feat: flatten nested redeemDelegations into outer call

When a nested transaction in a delegated transaction is itself a
redeemDelegations call, merge its permission contexts, modes, and
calldatas into the outer redeemDelegations call as additional slots
rather than wrapping it inside another delegation. This avoids the
gas cost of an extra delegation layer when the nested call is already
self-authorised.

Author: matthewwalsh0

app/core/Delegation/delegation.ts

@@ -261,33 +261,37 @@ export const encodeDisableDelegation = ({
   return concat([encodedSignature, encodedData]);
 };
 
-/**
- * Encodes the calldata for a redeemDelegations(delegations,modes,executions) call.
- *
- * @param params
- * @param params.delegations - The delegations to redeem.
- * @param params.modes - The modes to redeem the delegations with.
- * @param params.executions - The executions to redeem the delegations with.
- * @returns The encoded calldata.
- */
 export const encodeRedeemDelegations = ({
   delegations,
   modes,
   executions,
+  extraContexts = [],
+  extraModes = [],
+  extraCalldatas = [],
 }: {
   delegations: Delegation[][];
   modes: ExecutionMode[];
   executions: ExecutionStruct[][];
+  extraContexts?: Hex[];
+  extraModes?: Hex[];
+  extraCalldatas?: Hex[];
 }) => {
   const encodedSignature = toFunctionSelector(
     'redeemDelegations(bytes[],bytes32[],bytes[])',
   );
 
-  const contexts = encodePermissionContexts(delegations);
-  const calldatas = encodeExecutionCalldatas(executions);
+  const contexts = [...encodePermissionContexts(delegations), ...extraContexts];
+  const calldatas = [
+    ...(executions.length > 0 ? encodeExecutionCalldatas(executions) : []),
+    ...extraCalldatas,
+  ];
+  const allModes = [...modes, ...extraModes];
 
   const encodedData = toHex(
-    encode(['bytes[]', 'bytes32[]', 'bytes[]'], [contexts, modes, calldatas]),
+    encode(
+      ['bytes[]', 'bytes32[]', 'bytes[]'],
+      [contexts, allModes, calldatas],
+    ),
   );
 
   return concat([encodedSignature, encodedData]);

app/util/transactions/delegation.test.ts

@@ -1,11 +1,21 @@
+import { decode } from '@metamask/abi-utils';
 import {
   IsAtomicBatchSupportedRequest,
   TransactionController,
   TransactionMeta,
 } from '@metamask/transaction-controller';
 import { SignMessenger, getDelegationTransaction } from './delegation';
 import { MOCK_ANY_NAMESPACE, Messenger } from '@metamask/messenger';
-import { Hex } from '@metamask/utils';
+import { Hex, bytesToHex, remove0x } from '@metamask/utils';
+import {
+  BATCH_DEFAULT_MODE,
+  SINGLE_DEFAULT_MODE,
+  getDeleGatorEnvironment,
+} from '../../core/Delegation';
+import {
+  REDEEM_DELEGATIONS_SELECTOR,
+  encodeRedeemDelegations,
+} from '../../core/Delegation/delegation';
 
 const mockGetNonceLock = jest.fn();
 
@@ -178,5 +188,181 @@ describe('Transaction Delegation Utils', () => {
         getDelegationTransaction(messengerMock, TRANSACTION_META_MOCK),
       ).rejects.toThrow('Upgrade contract address not found');
     });
+
+    describe('nested redeemDelegations flattening', () => {
+      const MAINNET_DELEGATION_MANAGER = getDeleGatorEnvironment(
+        1,
+      ).DelegationManager.toLowerCase() as Hex;
+
+      const INNER_CONTEXT = '0xaabb' as Hex;
+      const INNER_CALLDATA = '0xccdd' as Hex;
+
+      const buildInnerRedeemCalldata = (): Hex =>
+        encodeRedeemDelegations({
+          delegations: [],
+          modes: [],
+          executions: [],
+          extraContexts: [INNER_CONTEXT],
+          extraModes: [SINGLE_DEFAULT_MODE],
+          extraCalldatas: [INNER_CALLDATA],
+        });
+
+      const decodeOuter = (
+        outerData: Hex,
+      ): { contexts: Hex[]; modes: Hex[]; calldatas: Hex[] } => {
+        const payload = `0x${remove0x(outerData).slice(8)}` as Hex;
+        const [contexts, modes, calldatas] = decode(
+          ['bytes[]', 'bytes32[]', 'bytes[]'],
+          payload,
+        ) as [Uint8Array[], Uint8Array[], Uint8Array[]];
+        return {
+          contexts: contexts.map(bytesToHex),
+          modes: modes.map(bytesToHex),
+          calldatas: calldatas.map(bytesToHex),
+        };
+      };
+
+      it('flattens an inner redeemDelegations into additional outer slots', async () => {
+        const innerRedeem = buildInnerRedeemCalldata();
+        const regularTx = {
+          data: '0xdeadbeef' as Hex,
+          to: '0x1111111111111111111111111111111111111111' as Hex,
+        };
+
+        const result = await getDelegationTransaction(messengerMock, {
+          ...TRANSACTION_META_MOCK,
+          nestedTransactions: [
+            {
+              data: innerRedeem,
+              to: MAINNET_DELEGATION_MANAGER,
+            },
+            regularTx,
+          ],
+        } as TransactionMeta);
+
+        const outer = decodeOuter(result.data);
+
+        expect(outer.contexts).toHaveLength(2);
+        expect(outer.modes).toHaveLength(2);
+        expect(outer.calldatas).toHaveLength(2);
+        expect(outer.contexts[1]).toBe(INNER_CONTEXT);
+        expect(outer.modes[1]).toBe(SINGLE_DEFAULT_MODE);
+        expect(outer.calldatas[1]).toBe(INNER_CALLDATA);
+      });
+
+      it('signs the outer delegation only over the non-redeem nested transactions', async () => {
+        const innerRedeem = buildInnerRedeemCalldata();
+        const regularTx = {
+          data: '0xdeadbeef' as Hex,
+          to: '0x1111111111111111111111111111111111111111' as Hex,
+        };
+
+        await getDelegationTransaction(messengerMock, {
+          ...TRANSACTION_META_MOCK,
+          nestedTransactions: [
+            { data: innerRedeem, to: MAINNET_DELEGATION_MANAGER },
+            regularTx,
+          ],
+        } as TransactionMeta);
+
+        expect(signDelegationMock).toHaveBeenCalledTimes(1);
+        const [signCall] = signDelegationMock.mock.calls;
+        const signedDelegation = signCall[0].delegation;
+        expect(signedDelegation.caveats).toHaveLength(2);
+      });
+
+      it('uses SINGLE mode when only one regular nested transaction remains after flattening', async () => {
+        const innerRedeem = buildInnerRedeemCalldata();
+        const regularTx = {
+          data: '0xdeadbeef' as Hex,
+          to: '0x1111111111111111111111111111111111111111' as Hex,
+        };
+
+        const result = await getDelegationTransaction(messengerMock, {
+          ...TRANSACTION_META_MOCK,
+          nestedTransactions: [
+            { data: innerRedeem, to: MAINNET_DELEGATION_MANAGER },
+            regularTx,
+          ],
+        } as TransactionMeta);
+
+        const outer = decodeOuter(result.data);
+        expect(outer.modes[0]).toBe(SINGLE_DEFAULT_MODE);
+      });
+
+      it('does not flatten nested redeemDelegations when target is not the DelegationManager', async () => {
+        const innerRedeem = buildInnerRedeemCalldata();
+        const result = await getDelegationTransaction(messengerMock, {
+          ...TRANSACTION_META_MOCK,
+          nestedTransactions: [
+            {
+              data: innerRedeem,
+              to: '0x2222222222222222222222222222222222222222' as Hex,
+            },
+          ],
+        } as TransactionMeta);
+
+        const outer = decodeOuter(result.data);
+        expect(outer.contexts).toHaveLength(1);
+        expect(signDelegationMock).toHaveBeenCalledTimes(1);
+      });
+
+      it('does not flatten when nested tx data does not start with the redeemDelegations selector', async () => {
+        const result = await getDelegationTransaction(messengerMock, {
+          ...TRANSACTION_META_MOCK,
+          nestedTransactions: [
+            {
+              data: '0xdeadbeef' as Hex,
+              to: MAINNET_DELEGATION_MANAGER,
+            },
+          ],
+        } as TransactionMeta);
+
+        const outer = decodeOuter(result.data);
+        expect(outer.contexts).toHaveLength(1);
+      });
+
+      it('passes through inner contexts unchanged when only inner redeemDelegations are present', async () => {
+        const innerRedeem = buildInnerRedeemCalldata();
+        const result = await getDelegationTransaction(messengerMock, {
+          ...TRANSACTION_META_MOCK,
+          nestedTransactions: [
+            { data: innerRedeem, to: MAINNET_DELEGATION_MANAGER },
+          ],
+        } as TransactionMeta);
+
+        const outer = decodeOuter(result.data);
+        expect(outer.contexts).toEqual([INNER_CONTEXT]);
+        expect(outer.modes).toEqual([SINGLE_DEFAULT_MODE]);
+        expect(outer.calldatas).toEqual([INNER_CALLDATA]);
+        expect(signDelegationMock).not.toHaveBeenCalled();
+      });
+
+      it('selects the correct selector for a redeemDelegations nested tx', () => {
+        expect(REDEEM_DELEGATIONS_SELECTOR).toBe('0xcef6d209');
+      });
+
+      it('uses BATCH mode when multiple regular nested transactions remain after flattening', async () => {
+        const innerRedeem = buildInnerRedeemCalldata();
+        const result = await getDelegationTransaction(messengerMock, {
+          ...TRANSACTION_META_MOCK,
+          nestedTransactions: [
+            { data: innerRedeem, to: MAINNET_DELEGATION_MANAGER },
+            {
+              data: '0xdeadbeef' as Hex,
+              to: '0x1111111111111111111111111111111111111111' as Hex,
+            },
+            {
+              data: '0xfeedface' as Hex,
+              to: '0x3333333333333333333333333333333333333333' as Hex,
+            },
+          ],
+        } as TransactionMeta);
+
+        const outer = decodeOuter(result.data);
+        expect(outer.modes[0]).toBe(BATCH_DEFAULT_MODE);
+        expect(outer.contexts).toHaveLength(2);
+      });
+    });
   });
 });