Ensure that only delegations with inheritance may be created without a scope

Author: jeffsmale90

packages/smart-accounts-kit/src/caveatBuilder/resolveCaveats.ts

@@ -15,17 +15,24 @@ export type Caveats = CaveatBuilder | (Caveat | CoreCaveatConfiguration)[];
  * @param config.environment - The environment to be used for the caveat builder.
  * @param config.scope - The scope to be used for the caveat builder. Optional - when not provided and redelegating, scope is inherited from the parent delegation.
  * @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.
+ * @param config.hasInheritance - Whether the delegation has inheritance.
  * @returns The resolved array of caveats.
  */
 export const resolveCaveats = ({
   environment,
   scope,
   caveats,
+  hasInheritance,
 }: {
   environment: SmartAccountsEnvironment;
   scope?: ScopeConfig;
   caveats?: Caveats;
+  hasInheritance: boolean;
 }) => {
+  if (!scope && !hasInheritance) {
+    throw new Error('Scope is required when the delegation has no inheritance');
+  }
+
   // Create base caveat builder from scope if provided, otherwise use core caveat builder
   const scopeCaveatBuilder = scope
     ? createCaveatBuilderFromScope(environment, scope)

packages/smart-accounts-kit/src/delegation.ts

@@ -349,6 +349,7 @@ export const createDelegation = (
     environment: options.environment,
     scope: options.scope,
     caveats: options.caveats,
+    hasInheritance: Boolean(parentDelegation),
   });
 
   trackSmartAccountsKitFunctionCall('createDelegation', {
@@ -387,6 +388,7 @@ export const createOpenDelegation = (
     environment: options.environment,
     scope: options.scope,
     caveats: options.caveats,
+    hasInheritance: Boolean(parentDelegation),
   });
 
   trackSmartAccountsKitFunctionCall('createOpenDelegation', {

packages/smart-accounts-kit/test/caveatBuilder/resolveCaveats.test.ts

@@ -48,6 +48,7 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc20Scope,
         caveats: caveatBuilder,
+        hasInheritance: false,
       });
 
       // 4 caveats: 2 from the scope, 2 from the builder
@@ -65,6 +66,7 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc20Scope,
         caveats: caveatBuilder,
+        hasInheritance: false,
       });
 
       expect(result).to.be.an('array');
@@ -83,6 +85,7 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc20Scope,
         caveats: caveatBuilder as any,
+        hasInheritance: false,
       });
 
       expect(result).to.be.an('array');
@@ -98,6 +101,7 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc20Scope,
         caveats,
+        hasInheritance: false,
       });
 
       expect(result).to.be.an('array');
@@ -125,6 +129,7 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc20Scope,
         caveats: caveatConfigs,
+        hasInheritance: false,
       });
 
       expect(result).to.be.an('array');
@@ -135,6 +140,7 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc20Scope,
         caveats: [],
+        hasInheritance: false,
       });
       expect(result.length).to.be.greaterThan(scopeOnlyResult.length);
     });
@@ -158,6 +164,7 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc20Scope,
         caveats: mixedCaveats,
+        hasInheritance: false,
       });
 
       expect(result).to.be.an('array');
@@ -173,6 +180,7 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc20Scope,
         caveats: [],
+        hasInheritance: false,
       });
 
       expect(result).to.be.an('array');
@@ -197,6 +205,7 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc721Scope,
         caveats: [caveatConfig],
+        hasInheritance: false,
       });
 
       expect(result).to.be.an('array');
@@ -208,12 +217,14 @@ describe('resolveCaveats', () => {
         environment,
         scope: erc20Scope,
         caveats: [mockCaveat1],
+        hasInheritance: false,
       });
 
       const resultWithoutCaveats = resolveCaveats({
         environment,
         scope: erc20Scope,
         caveats: [],
+        hasInheritance: false,
       });
 
       expect(resultWithCaveats.length).to.be.greaterThan(
@@ -236,8 +247,65 @@ describe('resolveCaveats', () => {
           environment,
           scope: erc20Scope,
           caveats: [invalidType as any],
+          hasInheritance: false,
         });
       }).to.throw('Invalid caveat');
     });
   });
+
+  describe('hasInheritance', () => {
+    it('should throw if scope is not provided and the delegation has no inheritance', () => {
+      expect(() =>
+        resolveCaveats({
+          environment,
+          caveats: [mockCaveat1],
+          hasInheritance: false,
+        }),
+      ).to.throw('Scope is required when the delegation has no inheritance');
+    });
+
+    it('should throw if neither scope nor caveats are provided and the delegation has no inheritance', () => {
+      expect(() =>
+        resolveCaveats({
+          environment,
+          hasInheritance: false,
+        }),
+      ).to.throw('Scope is required when the delegation has no inheritance');
+    });
+
+    it('should resolve caveats without a scope when the delegation has inheritance', () => {
+      const result = resolveCaveats({
+        environment,
+        caveats: [mockCaveat1, mockCaveat2],
+        hasInheritance: true,
+      });
+
+      // No scope caveats are added when the scope is inherited from the parent
+      expect(result).to.have.lengthOf(2);
+      expect(result).to.deep.include(mockCaveat1);
+      expect(result).to.deep.include(mockCaveat2);
+    });
+
+    it('should return an empty array when no scope, no caveats and the delegation has inheritance', () => {
+      const result = resolveCaveats({
+        environment,
+        hasInheritance: true,
+      });
+
+      expect(result).to.deep.equal([]);
+    });
+
+    it('should still apply scope caveats when both scope and inheritance are provided', () => {
+      const result = resolveCaveats({
+        environment,
+        scope: erc20Scope,
+        caveats: [mockCaveat1],
+        hasInheritance: true,
+      });
+
+      // Scope caveats are still produced when an explicit scope is provided
+      expect(result.length).to.be.greaterThan(1);
+      expect(result).to.deep.include(mockCaveat1);
+    });
+  });
 });

packages/smart-accounts-kit/test/delegation.test.ts

@@ -353,6 +353,16 @@ describe('createDelegation', () => {
     });
   });
 
+  it('throws if no scope no inheritance is provided', () => {
+    expect(() => {
+      createDelegation({
+        environment: smartAccountEnvironment,
+        to: mockDelegate,
+        from: mockDelegator,
+      } as any);
+    }).toThrow('Scope is required when the delegation has no inheritance');
+  });
+
   describe('parentPermissionContext support', () => {
     it('should create a delegation using parentPermissionContext with Delegation array', () => {
       const parentDelegation = createDelegation({
@@ -653,6 +663,15 @@ describe('createOpenDelegation', () => {
     });
   });
 
+  it('throws if no scope no inheritance is provided', () => {
+    expect(() => {
+      createOpenDelegation({
+        environment: smartAccountEnvironment,
+        from: mockDelegator,
+      } as any);
+    }).toThrow('Scope is required when the delegation has no inheritance');
+  });
+
   describe('parentPermissionContext support', () => {
     it('should create an open delegation using parentPermissionContext', () => {
       const parentDelegation = createDelegation({