Implement caveat building logic for erc20tokenstream permission type

Author: jeffsmale90

packages/7715-permission-types/src/index.ts

@@ -22,6 +22,9 @@ export type {
 export type { PayeeRule, RedeemerRule, ExpiryRule } from './permissions';
 export {
   makePermissionDecoderConfigs,
+  createErc20TokenStreamCaveats,
+  type Erc20TokenStreamEnforcers,
+  type Erc20TokenStreamDecoderEnforcers,
   type DeployedContractsByName,
   type PermissionDecoderConfig,
 } from './permissions';

packages/7715-permission-types/src/permissions/caveats/erc20TokenStream.ts

@@ -1,4 +1,9 @@
-import { decodeERC20StreamingTerms } from '@metamask/delegation-core';
+import type { Caveat } from '@metamask/delegation-core';
+import {
+  createERC20StreamingTerms,
+  createValueLteTerms,
+  decodeERC20StreamingTerms,
+} from '@metamask/delegation-core';
 import { bigIntToHex } from '@metamask/utils';
 
 import type { Erc20TokenStreamPermission } from '../../types';
@@ -7,9 +12,10 @@ import { erc20PayeeRuleDecoder } from '../rules/payee';
 import { redeemerRuleDecoder } from '../rules/redeemer';
 import type {
   ChecksumCaveat,
-  ChecksumEnforcersByChainId,
   DecodedPermissionData,
-  MakePermissionDecoderConfig,
+  DeepRequired,
+  ChecksumEnforcersByChainId,
+  PermissionDecoderConfig,
 } from '../types';
 import { getTermsByEnforcer, ZERO_32_BYTES } from '../utils';
 
@@ -21,7 +27,7 @@ import { getTermsByEnforcer, ZERO_32_BYTES } from '../utils';
  */
 export function makeErc20TokenStreamDecoderConfig(
   contractAddresses: ChecksumEnforcersByChainId,
-): MakePermissionDecoderConfig {
+): PermissionDecoderConfig {
   const {
     timestampEnforcer,
     erc20StreamingEnforcer,
@@ -104,3 +110,54 @@ function validateAndDecodeData(
     startTime,
   };
 }
+
+/**
+ * Enforcers required to build ERC-20 token stream caveats.
+ */
+export type Erc20TokenStreamEnforcers = Pick<
+  ChecksumEnforcersByChainId,
+  'erc20StreamingEnforcer' | 'valueLteEnforcer'
+>;
+
+/**
+ * Builds the ERC-20 stream caveats required for this permission type.
+ *
+ * @param options0 - Caveat builder arguments.
+ * @param options0.permission - Fully populated ERC-20 stream permission data.
+ * @param options0.contracts - Enforcer addresses used to construct caveats.
+ * @returns The ERC20 streaming and zero-value caveats.
+ */
+export async function createErc20TokenStreamCaveats({
+  permission,
+  contracts,
+}: {
+  permission: DeepRequired<Erc20TokenStreamPermission>;
+  contracts: Erc20TokenStreamEnforcers;
+}): Promise<Caveat[]> {
+  const { initialAmount, maxAmount, amountPerSecond, startTime } =
+    permission.data;
+
+  // ERC20StreamingEnforcer: enforce token address, initial/max amount, amount per second, and start time.
+  const erc20StreamingCaveat: Caveat = {
+    enforcer: contracts.erc20StreamingEnforcer,
+    terms: createERC20StreamingTerms({
+      tokenAddress: permission.data.tokenAddress,
+      initialAmount: BigInt(initialAmount),
+      maxAmount: BigInt(maxAmount),
+      amountPerSecond: BigInt(amountPerSecond),
+      startTime,
+    }),
+    args: '0x',
+  };
+
+  // ValueLteEnforcer: allow no native value (e.g. msg.value must be 0).
+  const valueLteCaveat: Caveat = {
+    enforcer: contracts.valueLteEnforcer,
+    terms: createValueLteTerms({
+      maxValue: 0n,
+    }),
+    args: '0x',
+  };
+
+  return [erc20StreamingCaveat, valueLteCaveat];
+}

packages/7715-permission-types/src/permissions/index.ts

@@ -8,6 +8,12 @@ import { makeTokenApprovalRevocationDecoderConfig } from './caveats/tokenApprova
 import type { DeployedContractsByName, PermissionDecoderConfig } from './types';
 import { getChecksumEnforcersByChainId } from './utils';
 
+export {
+  createErc20TokenStreamCaveats,
+  type Erc20TokenStreamEnforcers,
+  type Erc20TokenStreamDecoderEnforcers,
+} from './caveats/erc20TokenStream';
+
 export type { ExpiryRule } from './rules/expiry';
 export type { PayeeRule } from './rules/payee';
 export type { RedeemerRule } from './rules/redeemer';

packages/7715-permission-types/src/permissions/types.ts

@@ -95,3 +95,18 @@ export type PermissionDecoder = {
  * A map of deployed contract names to addresses for one chain.
  */
 export type DeployedContractsByName = Record<string, Hex>;
+
+/**
+ * Makes all properties in an object type required recursively.
+ * This includes nested objects and arrays.
+ * Also removes undefined from union types.
+ */
+export type DeepRequired<TParent> = TParent extends (infer U)[]
+  ? DeepRequired<U>[]
+  : TParent extends object
+    ? {
+        [P in keyof TParent]-?: DeepRequired<
+          Exclude<TParent[P], undefined | null>
+        >;
+      }
+    : Exclude<TParent, undefined | null>;

packages/7715-permission-types/test/permissions/caveats/erc20TokenStream.test.ts

@@ -5,16 +5,24 @@ import {
 import { bigIntToHex, type Hex } from '@metamask/utils';
 import { describe, it, expect } from 'vitest';
 
-import { makePermissionDecoderConfigs } from '../../../src/permissions';
-import { makeErc20TokenStreamDecoderConfig } from '../../../src/permissions/caveats/erc20TokenStream';
+import { makePermissionDecoderConfigs} from '../../../src/permissions';
+import {
+  createErc20TokenStreamCaveats,
+  type Erc20TokenStreamEnforcers,
+  makeErc20TokenStreamDecoderConfig,
+} from '../../../src/permissions/caveats/erc20TokenStream';
 import { expiryRuleDecoder } from '../../../src/permissions/rules/expiry';
 import { erc20PayeeRuleDecoder } from '../../../src/permissions/rules/payee';
 import { redeemerRuleDecoder } from '../../../src/permissions/rules/redeemer';
-import type { ChecksumCaveat } from '../../../src/permissions/types';
+import type {
+  ChecksumCaveat,
+  DeepRequired,
+} from '../../../src/permissions/types';
 import {
   getChecksumEnforcersByChainId,
   ZERO_32_BYTES,
 } from '../../../src/permissions/utils';
+import type { Erc20TokenStreamPermission } from '../../../src/types';
 import { toWord } from '../../test-utils';
 
 describe('erc20-token-stream decoder config', () => {
@@ -173,3 +181,55 @@ describe('erc20-token-stream decoder config', () => {
     });
   });
 });
+
+describe('createErc20TokenStreamCaveats()', () => {
+  const initialAmount = '0x0de0b6b3a7640000' as const;
+  const maxAmount = '0x8ac7230489e80000' as const;
+  const amountPerSecond = '0x06f05b59d3b20000' as const;
+  const startTime = 1729900800; // 10/26/2024 00:00:00 UTC
+  const tokenAddress = '0x1234567890123456789012345678901234567890' as const;
+
+  const contracts: Erc20TokenStreamEnforcers = {
+    erc20StreamingEnforcer: '0x7356Ed4321Ff9e7DAE246461829cDC170ff660Ab',
+    valueLteEnforcer: '0x5e12Ca712176E7557e4fAa1c8cc27382B60B5e39',
+  };
+
+  const mockPermission: DeepRequired<Erc20TokenStreamPermission> = {
+    type: 'erc20-token-stream',
+    data: {
+      initialAmount,
+      maxAmount,
+      amountPerSecond,
+      startTime,
+      tokenAddress,
+      justification: 'test',
+    },
+    isAdjustmentAllowed: true,
+  };
+
+  it('creates erc20Streaming and valueLte caveats', async () => {
+    const caveats = await createErc20TokenStreamCaveats({
+      permission: mockPermission,
+      contracts,
+    });
+    const initialAmountHex = initialAmount.slice(2).padStart(64, '0');
+    const maxAmountHex = maxAmount.slice(2).padStart(64, '0');
+    const amountPerSecondHex = amountPerSecond.slice(2).padStart(64, '0');
+    const startTimeHex = startTime.toString(16).padStart(64, '0');
+    const erc20StreamingExpectedTerms = `0x${tokenAddress.slice(2)}${initialAmountHex}${maxAmountHex}${amountPerSecondHex}${startTimeHex}`;
+
+    expect(caveats).toStrictEqual([
+      {
+        enforcer: contracts.erc20StreamingEnforcer,
+        terms: erc20StreamingExpectedTerms,
+        args: '0x',
+      },
+      {
+        enforcer: contracts.valueLteEnforcer,
+        terms:
+          '0x0000000000000000000000000000000000000000000000000000000000000000',
+        args: '0x',
+      },
+    ]);
+  });
+});