Function call scope no longer accepts native token value, unless explicitly configured.

Author: jeffsmale90

packages/smart-accounts-kit/src/caveatBuilder/scope/functionCallScope.ts

@@ -6,17 +6,18 @@ import type { AllowedTargetsBuilderConfig } from '../allowedTargetsBuilder';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
 import type { ExactCalldataBuilderConfig } from '../exactCalldataBuilder';
+import { ValueLteBuilderConfig } from '../valueLteBuilder';
 
 type FunctionCallScopeBaseConfig = {
   type: 'functionCall';
+  allowedCalldata?: AllowedCalldataBuilderConfig[];
+  exactCalldata?: ExactCalldataBuilderConfig;
+  valueLte?: ValueLteBuilderConfig;
 };
 
 export type FunctionCallScopeConfig = FunctionCallScopeBaseConfig &
   AllowedTargetsBuilderConfig &
-  AllowedMethodsBuilderConfig & {
-    allowedCalldata?: AllowedCalldataBuilderConfig[];
-    exactCalldata?: ExactCalldataBuilderConfig;
-  };
+  AllowedMethodsBuilderConfig;
 
 const isFunctionCallConfig = (
   config: FunctionCallScopeConfig,
@@ -49,9 +50,12 @@ export function createFunctionCallCaveatBuilder(
     );
   }
 
+  const valueLteConfig = config.valueLte || { maxValue: 0n };
+
   const caveatBuilder = createCaveatBuilder(environment)
     .addCaveat('allowedTargets', { targets })
-    .addCaveat('allowedMethods', { selectors });
+    .addCaveat('allowedMethods', { selectors })
+    .addCaveat('valueLte', valueLteConfig);
 
   if (allowedCalldata && allowedCalldata.length > 0) {
     allowedCalldata.forEach((calldataConfig) => {

packages/smart-accounts-kit/test/caveatBuilder/scope/functionCallScope.test.ts

@@ -14,6 +14,7 @@ describe('createFunctionCallCaveatBuilder', () => {
       AllowedMethodsEnforcer: randomAddress(),
       AllowedCalldataEnforcer: randomAddress(),
       ExactCalldataEnforcer: randomAddress(),
+      ValueLteEnforcer: randomAddress(),
     },
   } as unknown as SmartAccountsEnvironment;
 
@@ -39,6 +40,11 @@ describe('createFunctionCallCaveatBuilder', () => {
         args: '0x',
         terms: concat(config.selectors as Hex[]),
       },
+      {
+        enforcer: environment.caveatEnforcers.ValueLteEnforcer,
+        args: '0x',
+        terms: toHex(0n, { size: 32 }),
+      },
     ]);
   });
 
@@ -66,6 +72,11 @@ describe('createFunctionCallCaveatBuilder', () => {
         args: '0x',
         terms: concat(config.selectors as Hex[]),
       },
+      {
+        enforcer: environment.caveatEnforcers.ValueLteEnforcer,
+        args: '0x',
+        terms: toHex(0n, { size: 32 }),
+      },
       {
         enforcer: environment.caveatEnforcers.AllowedCalldataEnforcer,
         args: '0x',
@@ -101,6 +112,11 @@ describe('createFunctionCallCaveatBuilder', () => {
         args: '0x',
         terms: concat(config.selectors as Hex[]),
       },
+      {
+        enforcer: environment.caveatEnforcers.ValueLteEnforcer,
+        args: '0x',
+        terms: toHex(0n, { size: 32 }),
+      },
       {
         enforcer: environment.caveatEnforcers.ExactCalldataEnforcer,
         args: '0x',
@@ -109,6 +125,37 @@ describe('createFunctionCallCaveatBuilder', () => {
     ]);
   });
 
+  it('creates a Function Call CaveatBuilder with configured valueLte', () => {
+    const config: FunctionCallScopeConfig = {
+      type: 'functionCall',
+      targets: [randomAddress()],
+      selectors: ['0x12345678'],
+      valueLte: { maxValue: 123n },
+    };
+
+    const caveatBuilder = createFunctionCallCaveatBuilder(environment, config);
+
+    const caveats = caveatBuilder.build();
+
+    expect(caveats).to.deep.equal([
+      {
+        enforcer: environment.caveatEnforcers.AllowedTargetsEnforcer,
+        args: '0x',
+        terms: concat(config.targets),
+      },
+      {
+        enforcer: environment.caveatEnforcers.AllowedMethodsEnforcer,
+        args: '0x',
+        terms: concat(config.selectors as Hex[]),
+      },
+      {
+        enforcer: environment.caveatEnforcers.ValueLteEnforcer,
+        args: '0x',
+        terms: toHex(123n, { size: 32 }),
+      },
+    ]);
+  });
+
   it('throws an error for invalid configuration', () => {
     const config = {
       type: 'functionCall',

shared/config/base.tsconfig.json

@@ -2,16 +2,14 @@
   "$schema": "https://json.schemastore.org/tsconfig",
   "display": "Default",
   "compilerOptions": {
+    "files": ["src/**/*.ts"],
     "composite": false,
     "declaration": true,
     "declarationMap": true,
     "esModuleInterop": true,
     "incremental": false,
     "isolatedModules": true,
-    "lib": [
-      "dom",
-      "esnext"
-    ],
+    "lib": ["dom", "esnext"],
     "module": "ESNext",
     "moduleResolution": "Bundler",
     "moduleDetection": "force",
@@ -20,6 +18,6 @@
     "skipLibCheck": true,
     "strict": true,
     "target": "ES2022",
-    "removeComments": true,
+    "removeComments": true
   }
-}
+}