x402 Payload now returns the root delegator, instead of the leaf delegator

Author: jeffsmale90

packages/smart-accounts-kit/src/experimental/x402DelegationProvider.ts

@@ -42,9 +42,10 @@ export function createx402DelegationProvider(
   ): Promise<x402DelegationProviderPaymentPayload> => {
     const {
       account,
+      createDelegationConfig,
       delegationManager,
       existingDelegations,
-      createDelegationConfig,
+      rootDelegator,
     } = await resolveDelegationCreationContext(config, requirements);
 
     const delegation = createOpenDelegation(createDelegationConfig);
@@ -76,7 +77,7 @@ export function createx402DelegationProvider(
     return {
       delegationManager,
       permissionContext,
-      delegator: delegation.delegator,
+      delegator: rootDelegator,
     };
   };
 }

packages/smart-accounts-kit/src/experimental/x402DelegationProviderUtils.ts

@@ -63,9 +63,10 @@ type EnsureExpirySufficientlyConstrainedParams = {
  */
 export type DelegationCreationContext = {
   account: Account;
+  createDelegationConfig: Parameters<typeof createOpenDelegation>[0];
   delegationManager: Address;
   existingDelegations: Delegation[];
-  createDelegationConfig: Parameters<typeof createOpenDelegation>[0];
+  rootDelegator: Address;
 };
 
 /**
@@ -552,10 +553,18 @@ export const resolveDelegationCreationContext = async (
     };
   }
 
+  const rootDelegator =
+    existingDelegations[existingDelegations.length - 1]?.delegator;
+
+  if (!rootDelegator) {
+    throw new Error('Root delegator not found');
+  }
+
   return {
     account,
+    createDelegationConfig,
     delegationManager,
     existingDelegations,
-    createDelegationConfig,
+    rootDelegator,
   };
 };

packages/smart-accounts-kit/test/experimental/x402DelegationProvider.test.ts

@@ -48,9 +48,11 @@ const mockPayeeEnforcer = '0x2000000000000000000000000000000000000004' as Hex;
 const mockTimestampEnforcer =
   '0x2000000000000000000000000000000000000005' as Hex;
 const mockDelegator = '0x3000000000000000000000000000000000000003' as Hex;
+const mockRootDelegator = '0x3100000000000000000000000000000000000003' as Hex;
 const mockSignature = '0xabc123' as Hex;
 const mockTypedData = { domain: {}, message: {} };
 const mockPermissionContext = '0xfeed' as Hex;
+const mockParentPermissionContext = '0xbeef' as Hex;
 const mockAllowedCalldataTerms = '0x3333' as Hex;
 const mockGeneratedSalt =
   '0x1111111111111111111111111111111111111111111111111111111111111111' as Hex;
@@ -141,7 +143,16 @@ describe('createx402DelegationProvider', () => {
       mockTypedData,
     );
     delegationMocks.encodeDelegations.mockReturnValue(mockPermissionContext);
-    delegationMocks.decodeDelegations.mockReturnValue([]);
+    delegationMocks.decodeDelegations.mockReturnValue([
+      {
+        delegate: '0xb00000000000000000000000000000000000000b',
+        delegator: mockRootDelegator,
+        authority: mockAuthority,
+        caveats: [],
+        salt: '0x44',
+        signature: '0x55',
+      },
+    ]);
   });
 
   it('creates and signs a delegation using default from/salt values', async () => {
@@ -151,6 +162,7 @@ describe('createx402DelegationProvider', () => {
       account,
       environment,
       caveats: [],
+      parentPermissionContext: mockParentPermissionContext,
     });
 
     const result = await provider(mockRequirements);
@@ -182,16 +194,19 @@ describe('createx402DelegationProvider', () => {
       },
     );
     expect(account.signTypedData).toHaveBeenCalledWith(mockTypedData);
+    const decodedDelegations =
+      delegationMocks.decodeDelegations.mock.results[0]?.value ?? [];
     expect(delegationMocks.encodeDelegations).toHaveBeenCalledWith([
       {
         ...delegationMocks.createOpenDelegation.mock.results[0]?.value,
         signature: mockSignature,
       },
+      ...decodedDelegations,
     ]);
     expect(result).toStrictEqual({
       delegationManager: mockDelegationManager,
       permissionContext: mockPermissionContext,
-      delegator: mockDelegator,
+      delegator: mockRootDelegator,
     });
   });
 
@@ -202,6 +217,7 @@ describe('createx402DelegationProvider', () => {
       account,
       environment,
       caveats: [],
+      parentPermissionContext: mockParentPermissionContext,
     });
 
     await provider({
@@ -223,6 +239,7 @@ describe('createx402DelegationProvider', () => {
       account,
       environment,
       caveats: [],
+      parentPermissionContext: mockParentPermissionContext,
     });
 
     await expect(
@@ -240,6 +257,7 @@ describe('createx402DelegationProvider', () => {
     const provider = createx402DelegationProvider({
       account,
       environment: createMockEnvironment(),
+      parentPermissionContext: mockParentPermissionContext,
     } as x402DelegationProviderConfig);
 
     await expect(provider(mockRequirements)).rejects.toThrow(

packages/smart-accounts-kit/test/experimental/x402DelegationProviderUtils.test.ts

@@ -481,13 +481,15 @@ describe('x402DelegationProviderUtils', () => {
       const getEnvironmentSpy = vi
         .spyOn(smartAccountsEnvironmentModule, 'getSmartAccountsEnvironment')
         .mockReturnValue(baseEnvironment);
+      const parentDelegation = makeDelegation([]);
 
       try {
         const result = await resolveDelegationCreationContext(
           {
             account: mockAccount,
             caveats: [],
             salt: `0x${'77'.repeat(32)}`,
+            parentPermissionContext: [parentDelegation],
           },
           {
             scheme: 'exact',
@@ -515,6 +517,7 @@ describe('x402DelegationProviderUtils', () => {
     });
 
     it('resolves deferred account, environment, from, and salt', async () => {
+      const parentDelegation = makeDelegation([]);
       const deferredAccount = vi.fn(async () => mockAccount);
       const deferredEnvironment = vi.fn(async () => baseEnvironment);
       const deferredFrom = vi.fn(
@@ -531,6 +534,7 @@ describe('x402DelegationProviderUtils', () => {
           from: deferredFrom,
           salt: deferredSalt,
           caveats: [],
+          parentPermissionContext: [parentDelegation],
         },
         {
           scheme: 'exact',
@@ -652,12 +656,14 @@ describe('x402DelegationProviderUtils', () => {
     });
 
     it('does not throw when facilitators are missing and redeemers are optional', async () => {
+      const parentDelegation = makeDelegation([]);
       await expect(
         resolveDelegationCreationContext(
           {
             account: mockAccount,
             environment: baseEnvironment,
             salt: `0x${'33'.repeat(32)}`,
+            parentPermissionContext: [parentDelegation],
           },
           {
             scheme: 'exact',
@@ -697,11 +703,13 @@ describe('x402DelegationProviderUtils', () => {
     });
 
     it('adds redeemer caveat from redeemers config addresses when facilitators are missing', async () => {
+      const parentDelegation = makeDelegation([]);
       const result = await resolveDelegationCreationContext(
         {
           account: mockAccount,
           environment: baseEnvironment,
           salt: `0x${'33'.repeat(32)}`,
+          parentPermissionContext: [parentDelegation],
           redeemers: {
             requireRedeemers: true,
             addresses: [facilitatorB],
@@ -732,6 +740,7 @@ describe('x402DelegationProviderUtils', () => {
     });
 
     it('resolves deferred redeemers configuration and addresses', async () => {
+      const parentDelegation = makeDelegation([]);
       const deferredRedeemerAddresses = vi.fn(async () => [facilitatorB]);
       const deferredRedeemersConfig = vi.fn(async () => ({
         requireRedeemers: true,
@@ -743,6 +752,7 @@ describe('x402DelegationProviderUtils', () => {
           account: mockAccount,
           environment: baseEnvironment,
           salt: `0x${'33'.repeat(32)}`,
+          parentPermissionContext: [parentDelegation],
           redeemers: deferredRedeemersConfig,
         },
         {
@@ -775,6 +785,7 @@ describe('x402DelegationProviderUtils', () => {
     it('resolves deferred expirySeconds and applies timestamp caveat', async () => {
       vi.useFakeTimers();
       vi.setSystemTime(new Date('2024-01-01T00:00:00Z'));
+      const parentDelegation = makeDelegation([]);
 
       const deferredExpirySeconds = vi.fn(async () => 120);
       const result = await resolveDelegationCreationContext(
@@ -784,6 +795,7 @@ describe('x402DelegationProviderUtils', () => {
           caveats: [],
           salt: `0x${'66'.repeat(32)}`,
           expirySeconds: deferredExpirySeconds,
+          parentPermissionContext: [parentDelegation],
         },
         {
           scheme: 'exact',
@@ -816,6 +828,7 @@ describe('x402DelegationProviderUtils', () => {
     it('resolves synchronous deferred expirySeconds and applies timestamp caveat', async () => {
       vi.useFakeTimers();
       vi.setSystemTime(new Date('2024-01-01T00:00:00Z'));
+      const parentDelegation = makeDelegation([]);
 
       const deferredExpirySeconds = vi.fn(() => 90);
       const result = await resolveDelegationCreationContext(
@@ -825,6 +838,7 @@ describe('x402DelegationProviderUtils', () => {
           caveats: [],
           salt: `0x${'66'.repeat(32)}`,
           expirySeconds: deferredExpirySeconds,
+          parentPermissionContext: [parentDelegation],
         },
         {
           scheme: 'exact',