Add managed exact-call execution tests

Author: christianbaroni

src/features/delegation/callsExecutionTracking.test.ts

@@ -0,0 +1,115 @@
+import { type Address } from 'viem';
+
+import { TransactionStatus } from '@/entities/transactions';
+import { RelayExecutionStatus, type ExecuteCallsResult, type ExecutionResult } from '@rainbow-me/delegation';
+
+import { trackCallsExecution } from './callsExecutionTracking';
+
+jest.mock('@/resources/assets/assets', () => ({
+  parseGoldskyAddressAsset: jest.fn(),
+  parseGoldskyAsset: jest.fn(),
+}));
+
+const mockAddPendingTransaction = jest.fn();
+const mockAddNewTransaction = jest.fn();
+
+jest.mock('@/state/pendingTransactions', () => ({
+  addNewTransaction: (...args: unknown[]) => mockAddNewTransaction(...args),
+  pendingTransactionsActions: {
+    addPendingTransaction: (...args: unknown[]) => mockAddPendingTransaction(...args),
+  },
+}));
+
+const ADDRESS: Address = '0x1111111111111111111111111111111111111111';
+const HASH = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+
+describe('callsExecutionTracking', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('registers managed exact-call execution under the relay execution id', () => {
+    trackCallsExecution({
+      address: ADDRESS,
+      batch: true,
+      chainId: 8453,
+      execution: {
+        executionId: 'execution-1',
+        kind: 'calls.managed',
+        status: RelayExecutionStatus.Pending,
+      } satisfies ExecuteCallsResult,
+      transaction: {
+        asset: null,
+        chainId: 8453,
+        data: Uint8Array.from([0xab, 0xcd]),
+        from: null,
+        network: 'Base',
+        nonce: 7,
+        status: TransactionStatus.pending,
+        to: null,
+        type: 'swap',
+        value: 5n,
+      },
+    });
+
+    const pendingTransaction = mockAddPendingTransaction.mock.calls[0]?.[0]?.pendingTransaction;
+
+    expect(mockAddPendingTransaction).toHaveBeenCalledWith({
+      address: ADDRESS,
+      pendingTransaction: expect.objectContaining({
+        batch: true,
+        data: '0xabcd',
+        delegation: false,
+        hash: 'execution-1',
+        relayExecutionId: 'execution-1',
+        title: 'swap.pending',
+        value: '5',
+      }),
+    });
+    expect(() => JSON.stringify(pendingTransaction)).not.toThrow();
+  });
+
+  it('registers wallet exact-call execution under the submitted transaction hash', () => {
+    trackCallsExecution({
+      address: ADDRESS,
+      batch: false,
+      chainId: 8453,
+      execution: {
+        hash: HASH,
+        transaction: {
+          data: '0x1234',
+          gas: 21000n,
+          maxFeePerGas: 2n,
+          maxPriorityFeePerGas: 1n,
+          nonce: 9,
+          to: ADDRESS,
+          value: 0n,
+        },
+        type: 'eip1559',
+      } satisfies ExecutionResult,
+      transaction: {
+        asset: null,
+        chainId: 8453,
+        from: ADDRESS,
+        network: 'Base',
+        nonce: -1,
+        status: TransactionStatus.pending,
+        to: null,
+        type: 'stake',
+        value: 0,
+      },
+    });
+
+    expect(mockAddNewTransaction).toHaveBeenCalledWith({
+      address: ADDRESS,
+      chainId: 8453,
+      transaction: expect.objectContaining({
+        data: '0x1234',
+        gasLimit: '21000',
+        hash: HASH,
+        nonce: 9,
+        to: ADDRESS,
+      }),
+    });
+  });
+});

src/features/delegation/preparedCallsStore.test.ts

@@ -0,0 +1,26 @@
+import { destroyStore } from '@storesjs/stores';
+
+import { createPreparedCallsStore } from './preparedCallsStore';
+
+type TestParams = {
+  id: string;
+};
+
+describe('createPreparedCallsStore', () => {
+  it('uses the active cached preparation once, then refreshes repeated submissions for the same params', async () => {
+    const fetcher = jest
+      .fn<Promise<string>, [TestParams]>()
+      .mockResolvedValueOnce('prepared:a:cached')
+      .mockResolvedValueOnce('prepared:a:fresh');
+    const store = createPreparedCallsStore<string, TestParams>(fetcher);
+
+    await store.getState().fetch({ id: 'a' });
+
+    await expect(store.getState().getPreparedCalls({ id: 'a' })).resolves.toBe('prepared:a:cached');
+    await expect(store.getState().getPreparedCalls({ id: 'a' })).resolves.toBe('prepared:a:fresh');
+
+    expect(fetcher).toHaveBeenCalledTimes(2);
+
+    destroyStore(store, { clearQueryCache: true });
+  });
+});

src/features/delegation/sponsoredCalls.test.ts

@@ -26,6 +26,30 @@ describe('sponsoredCalls', () => {
     mockIsSponsorshipEligible.mockReturnValue(true);
   });
 
+  it('requires a delegation-capable wallet', () => {
+    mockCanUseDelegatedExecution.mockReturnValue(false);
+
+    expect(predictSponsoredCallsExecution({ address: ACCOUNT, chainId: ChainId.base })).toBe(false);
+
+    expect(mockIsSponsorshipEligible).not.toHaveBeenCalled();
+  });
+
+  it('requires sponsorship eligibility when the chain is known', () => {
+    mockIsSponsorshipEligible.mockReturnValue(false);
+
+    expect(predictSponsoredCallsExecution({ address: ACCOUNT, chainId: ChainId.mainnet })).toBe(false);
+  });
+
+  it('allows sponsorship prediction when the known chain is eligible', () => {
+    expect(predictSponsoredCallsExecution({ address: ACCOUNT, chainId: ChainId.base })).toBe(true);
+  });
+
+  it('allows explicit prediction before the chain is known', () => {
+    expect(predictSponsoredCallsExecution({ address: ACCOUNT, chainId: null })).toBe(true);
+
+    expect(mockIsSponsorshipEligible).not.toHaveBeenCalled();
+  });
+
   it('uses the provided sponsorship eligibility list when one is supplied', () => {
     expect(
       predictSponsoredCallsExecution({

src/features/delegation/waitForManagedExecution.test.ts

@@ -0,0 +1,58 @@
+import { RelayExecutionStatus, type RelayStatusSnapshot } from '@rainbow-me/delegation';
+
+import { waitForManagedExecutionConfirmation } from './waitForManagedExecution';
+
+const mockGetStatus = jest.fn<Promise<{ status: RelayStatusSnapshot }>, [string]>();
+
+jest.mock('@/features/delegation/relayService', () => ({
+  relayService: {
+    getStatus: (executionId: string) => mockGetStatus(executionId),
+  },
+}));
+
+jest.mock('@/utils/delay', () => ({
+  delay: () => Promise.resolve(),
+}));
+
+function buildRelayUpdate(status: RelayExecutionStatus, errorMessage?: string): { status: RelayStatusSnapshot } {
+  return {
+    status: {
+      status,
+      updatedAtMs: 1,
+      ...(errorMessage ? { errorMessage } : {}),
+    },
+  };
+}
+
+describe('waitForManagedExecutionConfirmation', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('polls relay status until confirmation', async () => {
+    mockGetStatus
+      .mockResolvedValueOnce(buildRelayUpdate(RelayExecutionStatus.Pending))
+      .mockResolvedValueOnce(buildRelayUpdate(RelayExecutionStatus.Confirmed));
+
+    await expect(waitForManagedExecutionConfirmation('execution-id')).resolves.toBeUndefined();
+
+    expect(mockGetStatus).toHaveBeenCalledTimes(2);
+    expect(mockGetStatus).toHaveBeenCalledWith('execution-id');
+  });
+
+  it('continues polling after transient relay status errors', async () => {
+    mockGetStatus.mockRejectedValueOnce(new Error('network down')).mockResolvedValueOnce(buildRelayUpdate(RelayExecutionStatus.Confirmed));
+
+    await expect(waitForManagedExecutionConfirmation('execution-id')).resolves.toBeUndefined();
+
+    expect(mockGetStatus).toHaveBeenCalledTimes(2);
+  });
+
+  it('surfaces terminal relay failure details', async () => {
+    mockGetStatus.mockResolvedValueOnce(buildRelayUpdate(RelayExecutionStatus.Reverted, 'execution reverted'));
+
+    await expect(waitForManagedExecutionConfirmation('execution-id')).rejects.toThrow(
+      'Managed relay execution reverted: execution reverted'
+    );
+  });
+});