refactor: improve declarative delegation interface

Author: hanzel98

packages/delegation-toolkit/src/caveatBuilder/resolveCaveats.ts

@@ -10,7 +10,7 @@ export type Caveats = CaveatBuilder | (Caveat | CoreCaveatConfiguration)[];
  * @param config - The configuration for the caveat builder.
  * @param config.environment - The environment to be used for the caveat builder.
  * @param config.scope - The scope to be used for the caveat builder.
- * @param config.caveats - The caveats to be resolved, which can be either a CaveatBuilder or an array of Caveat or CaveatConfiguration.
+ * @param config.caveats - The caveats to be resolved, which can be either a CaveatBuilder or an array of Caveat or CaveatConfiguration. Optional - if not provided, only scope caveats will be used.
  * @returns The resolved array of caveats.
  */
 export const resolveCaveats = ({
@@ -20,27 +20,29 @@ export const resolveCaveats = ({
 }: {
   environment: DeleGatorEnvironment;
   scope: ScopeConfig;
-  caveats: Caveats;
+  caveats?: Caveats;
 }) => {
   const scopeCaveatBuilder = createCaveatBuilderFromScope(environment, scope);
 
-  if ('build' in caveats && typeof caveats.build === 'function') {
-    (caveats as CaveatBuilder).build().forEach((caveat) => {
-      scopeCaveatBuilder.addCaveat(caveat);
-    });
-  } else if (Array.isArray(caveats)) {
-    caveats.forEach((caveat) => {
-      try {
-        if ('type' in caveat) {
-          const { type, ...config } = caveat;
-          scopeCaveatBuilder.addCaveat(type, config);
-        } else {
-          scopeCaveatBuilder.addCaveat(caveat);
+  if (caveats) {
+    if ('build' in caveats && typeof caveats.build === 'function') {
+      (caveats as CaveatBuilder).build().forEach((caveat) => {
+        scopeCaveatBuilder.addCaveat(caveat);
+      });
+    } else if (Array.isArray(caveats)) {
+      caveats.forEach((caveat) => {
+        try {
+          if ('type' in caveat) {
+            const { type, ...config } = caveat;
+            scopeCaveatBuilder.addCaveat(type, config);
+          } else {
+            scopeCaveatBuilder.addCaveat(caveat);
+          }
+        } catch (error) {
+          throw new Error(`Invalid caveat: ${(error as Error).message}`);
         }
-      } catch (error) {
-        throw new Error(`Invalid caveat: ${(error as Error).message}`);
-      }
-    });
+      });
+    }
   }
 
   return scopeCaveatBuilder.build();

packages/delegation-toolkit/src/caveatBuilder/scope/nativeTokenPeriodicScope.ts

@@ -1,13 +1,17 @@
 import type { DeleGatorEnvironment } from '../../types';
+import type { AllowedCalldataBuilderConfig } from '../allowedCalldataBuilder';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
+import type { ExactCalldataBuilderConfig } from '../exactCalldataBuilder';
 import type {
   nativeTokenPeriodTransfer,
   NativeTokenPeriodTransferBuilderConfig,
 } from '../nativeTokenPeriodTransferBuilder';
 
 export type NativeTokenPeriodicScopeConfig = {
   type: typeof nativeTokenPeriodTransfer;
+  allowedCalldata?: AllowedCalldataBuilderConfig[];
+  exactCalldata?: ExactCalldataBuilderConfig;
 } & NativeTokenPeriodTransferBuilderConfig;
 
 /**
@@ -23,13 +27,36 @@ export function createNativeTokenPeriodicCaveatBuilder(
   environment: DeleGatorEnvironment,
   config: NativeTokenPeriodicScopeConfig,
 ): CoreCaveatBuilder {
-  return createCaveatBuilder(environment)
-    .addCaveat('exactCalldata', {
+  const {
+    periodAmount,
+    periodDuration,
+    startDate,
+    allowedCalldata,
+    exactCalldata,
+  } = config;
+
+  const caveatBuilder = createCaveatBuilder(environment);
+
+  // Add calldata restrictions
+  if (allowedCalldata) {
+    allowedCalldata.forEach((calldataConfig) => {
+      caveatBuilder.addCaveat('allowedCalldata', calldataConfig);
+    });
+  } else if (exactCalldata) {
+    caveatBuilder.addCaveat('exactCalldata', exactCalldata);
+  } else {
+    // Default behavior: only allow empty calldata
+    caveatBuilder.addCaveat('exactCalldata', {
       calldata: '0x',
-    })
-    .addCaveat('nativeTokenPeriodTransfer', {
-      periodAmount: config.periodAmount,
-      periodDuration: config.periodDuration,
-      startDate: config.startDate,
     });
+  }
+
+  // Add native token period transfer restriction
+  caveatBuilder.addCaveat('nativeTokenPeriodTransfer', {
+    periodAmount,
+    periodDuration,
+    startDate,
+  });
+
+  return caveatBuilder;
 }

packages/delegation-toolkit/src/caveatBuilder/scope/nativeTokenStreamingScope.ts

@@ -1,13 +1,17 @@
 import type { DeleGatorEnvironment } from '../../types';
+import type { AllowedCalldataBuilderConfig } from '../allowedCalldataBuilder';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
+import type { ExactCalldataBuilderConfig } from '../exactCalldataBuilder';
 import type {
   nativeTokenStreaming,
   NativeTokenStreamingBuilderConfig,
 } from '../nativeTokenStreamingBuilder';
 
 export type NativeTokenStreamingScopeConfig = {
   type: typeof nativeTokenStreaming;
+  allowedCalldata?: AllowedCalldataBuilderConfig[];
+  exactCalldata?: ExactCalldataBuilderConfig;
 } & NativeTokenStreamingBuilderConfig;
 
 /**
@@ -23,14 +27,38 @@ export function createNativeTokenStreamingCaveatBuilder(
   environment: DeleGatorEnvironment,
   config: NativeTokenStreamingScopeConfig,
 ): CoreCaveatBuilder {
-  return createCaveatBuilder(environment)
-    .addCaveat('exactCalldata', {
+  const {
+    initialAmount,
+    maxAmount,
+    amountPerSecond,
+    startTime,
+    allowedCalldata,
+    exactCalldata,
+  } = config;
+
+  const caveatBuilder = createCaveatBuilder(environment);
+
+  // Add calldata restrictions
+  if (allowedCalldata) {
+    allowedCalldata.forEach((calldataConfig) => {
+      caveatBuilder.addCaveat('allowedCalldata', calldataConfig);
+    });
+  } else if (exactCalldata) {
+    caveatBuilder.addCaveat('exactCalldata', exactCalldata);
+  } else {
+    // Default behavior: only allow empty calldata
+    caveatBuilder.addCaveat('exactCalldata', {
       calldata: '0x',
-    })
-    .addCaveat('nativeTokenStreaming', {
-      initialAmount: config.initialAmount,
-      maxAmount: config.maxAmount,
-      amountPerSecond: config.amountPerSecond,
-      startTime: config.startTime,
     });
+  }
+
+  // Add native token streaming restriction
+  caveatBuilder.addCaveat('nativeTokenStreaming', {
+    initialAmount,
+    maxAmount,
+    amountPerSecond,
+    startTime,
+  });
+
+  return caveatBuilder;
 }

packages/delegation-toolkit/src/caveatBuilder/scope/nativeTokenTransferScope.ts

@@ -1,13 +1,17 @@
 import type { DeleGatorEnvironment } from '../../types';
+import type { AllowedCalldataBuilderConfig } from '../allowedCalldataBuilder';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
+import type { ExactCalldataBuilderConfig } from '../exactCalldataBuilder';
 import type {
   nativeTokenTransferAmount,
   NativeTokenTransferAmountBuilderConfig,
 } from '../nativeTokenTransferAmountBuilder';
 
 export type NativeTokenTransferScopeConfig = {
   type: typeof nativeTokenTransferAmount;
+  allowedCalldata?: AllowedCalldataBuilderConfig[];
+  exactCalldata?: ExactCalldataBuilderConfig;
 } & NativeTokenTransferAmountBuilderConfig;
 
 /**
@@ -23,11 +27,28 @@ export function createNativeTokenTransferCaveatBuilder(
   environment: DeleGatorEnvironment,
   config: NativeTokenTransferScopeConfig,
 ): CoreCaveatBuilder {
-  return createCaveatBuilder(environment)
-    .addCaveat('exactCalldata', {
+  const { maxAmount, allowedCalldata, exactCalldata } = config;
+
+  const caveatBuilder = createCaveatBuilder(environment);
+
+  // Add calldata restrictions
+  if (allowedCalldata) {
+    allowedCalldata.forEach((calldataConfig) => {
+      caveatBuilder.addCaveat('allowedCalldata', calldataConfig);
+    });
+  } else if (exactCalldata) {
+    caveatBuilder.addCaveat('exactCalldata', exactCalldata);
+  } else {
+    // Default behavior: only allow empty calldata
+    caveatBuilder.addCaveat('exactCalldata', {
       calldata: '0x',
-    })
-    .addCaveat('nativeTokenTransferAmount', {
-      maxAmount: config.maxAmount,
     });
+  }
+
+  // Add native token transfer amount restriction
+  caveatBuilder.addCaveat('nativeTokenTransferAmount', {
+    maxAmount,
+  });
+
+  return caveatBuilder;
 }

packages/delegation-toolkit/src/delegation.ts

@@ -193,10 +193,9 @@ type BaseCreateDelegationOptions = {
   environment: DeleGatorEnvironment;
   scope: ScopeConfig;
   from: Hex;
-  caveats: Caveats;
+  caveats?: Caveats;
   parentDelegation?: Delegation | Hex;
   salt?: Hex;
-  allowInsecureUnrestrictedDelegation?: boolean;
 };
 
 /**

packages/delegation-toolkit/test/DelegationFramework/DelegationManager/delegationManagement.test.ts

@@ -91,7 +91,6 @@ describe('DelegationManager - Delegation Management', () => {
           targets: [alice.address],
           selectors: ['0x00000000'],
         },
-        caveats: [],
       });
 
       const encodedData = DelegationManager.encode.disableDelegation({
@@ -117,7 +116,6 @@ describe('DelegationManager - Delegation Management', () => {
           targets: [alice.address],
           selectors: ['0x00000000'],
         },
-        caveats: [],
       });
 
       const encodedData = DelegationManager.encode.enableDelegation({
@@ -143,7 +141,6 @@ describe('DelegationManager - Delegation Management', () => {
           targets: [alice.address],
           selectors: ['0x00000000'],
         },
-        caveats: [],
       });
 
       const execution = createExecution({

packages/delegation-toolkit/test/caveatBuilder/scope/nativeTokenTransferScope.test.ts

@@ -10,11 +10,12 @@ describe('createNativeTokenTransferCaveatBuilder', () => {
   const environment = {
     caveatEnforcers: {
       ExactCalldataEnforcer: randomAddress(),
+      AllowedCalldataEnforcer: randomAddress(),
       NativeTokenTransferAmountEnforcer: randomAddress(),
     },
   } as unknown as DeleGatorEnvironment;
 
-  it('creates a native token transfer CaveatBuilder', () => {
+  it('creates a native token transfer CaveatBuilder with default empty calldata', () => {
     const config: NativeTokenTransferScopeConfig = {
       type: 'nativeTokenTransferAmount',
       maxAmount: 1000n,
@@ -40,4 +41,69 @@ describe('createNativeTokenTransferCaveatBuilder', () => {
       },
     ]);
   });
+
+  it('creates a native token transfer CaveatBuilder with exact calldata', () => {
+    const config: NativeTokenTransferScopeConfig = {
+      type: 'nativeTokenTransferAmount',
+      maxAmount: 1000n,
+      exactCalldata: {
+        calldata: '0x1234abcd',
+      },
+    };
+
+    const caveatBuilder = createNativeTokenTransferCaveatBuilder(
+      environment,
+      config,
+    );
+
+    const caveats = caveatBuilder.build();
+
+    expect(caveats).to.deep.equal([
+      {
+        enforcer: environment.caveatEnforcers.ExactCalldataEnforcer,
+        args: '0x',
+        terms: '0x1234abcd',
+      },
+      {
+        enforcer: environment.caveatEnforcers.NativeTokenTransferAmountEnforcer,
+        args: '0x',
+        terms: toHex(config.maxAmount, { size: 32 }),
+      },
+    ]);
+  });
+
+  it('creates a native token transfer CaveatBuilder with allowed calldata', () => {
+    const config: NativeTokenTransferScopeConfig = {
+      type: 'nativeTokenTransferAmount',
+      maxAmount: 1000n,
+      allowedCalldata: [
+        {
+          startIndex: 4,
+          value: '0x1234',
+        },
+        {
+          startIndex: 8,
+          value: '0xabcd',
+        },
+      ],
+    };
+
+    const caveatBuilder = createNativeTokenTransferCaveatBuilder(
+      environment,
+      config,
+    );
+
+    const caveats = caveatBuilder.build();
+
+    expect(caveats).to.have.lengthOf(3);
+    expect(caveats[0]?.enforcer).to.equal(
+      environment.caveatEnforcers.AllowedCalldataEnforcer,
+    );
+    expect(caveats[1]?.enforcer).to.equal(
+      environment.caveatEnforcers.AllowedCalldataEnforcer,
+    );
+    expect(caveats[2]?.enforcer).to.equal(
+      environment.caveatEnforcers.NativeTokenTransferAmountEnforcer,
+    );
+  });
 });