fix(evm-wallet-experiment): check relay path before resolving chain ID / SDK calldata

Move the peer relay check in `submitDelegationUserOp` and
`submitBatchDelegationUserOp` before `resolveChainId()` and
`buildSdkRedeemCallData()`. The relay path forwards raw delegations and
execution to the home wallet and does not need local chain ID or SDK
calldata — computing them first blocks the relay when the provider is
temporarily unreachable.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sirtimid

packages/evm-wallet-experiment/src/vats/coordinator-vat.test.ts

@@ -3204,7 +3204,74 @@ describe('coordinator-vat', () => {
           },
           delegationId: delegation.id,
         }),
-      ).rejects.toThrow('Failed to relay delegation redemption to home wallet');
+      ).rejects.toThrow(
+        'Failed to relay delegation redemption to home wallet: CapTP connection lost',
+      );
+    });
+
+    it('propagates batch peer relay errors to the caller', async () => {
+      const peerAddress =
+        '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' as Address;
+      const mockPeerWallet = {
+        getAccounts: vi.fn().mockResolvedValue([peerAddress]),
+        getCapabilities: vi.fn().mockResolvedValue({ signingMode: 'local' }),
+        handleSigningRequest: vi.fn(),
+        handleRedemptionRequest: vi
+          .fn()
+          .mockRejectedValue(new Error('peer disconnected')),
+        registerAwayWallet: vi.fn().mockResolvedValue(undefined),
+        registerDelegateAddress: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const freshBaggage = makeMockBaggage();
+      freshBaggage.init('keyringVat', keyringVat);
+      freshBaggage.init('providerVat', providerVat);
+      freshBaggage.init('delegationVat', delegationVat);
+      freshBaggage.init('peerWallet', mockPeerWallet);
+
+      const coord = buildRootObject(
+        {},
+        undefined,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        freshBaggage as any,
+      );
+
+      await coord.bootstrap(
+        {
+          keyring: keyringVat,
+          provider: providerVat,
+          delegation: delegationVat,
+        },
+        {},
+      );
+
+      await coord.initializeKeyring({
+        type: 'srp',
+        mnemonic: TEST_MNEMONIC,
+      });
+
+      const accounts = await coord.getAccounts();
+      const delegator = accounts[0] as Address;
+
+      await coord.createDelegation({
+        delegate: delegator,
+        caveats: [
+          makeCaveat({
+            type: 'allowedTargets',
+            terms: encodeAllowedTargets([TARGET]),
+          }),
+        ],
+        chainId: 1,
+      });
+
+      await expect(
+        coord.sendBatchTransaction([
+          { from: delegator, to: TARGET, value: '0x1' as Hex },
+          { from: delegator, to: TARGET, value: '0x2' as Hex },
+        ]),
+      ).rejects.toThrow(
+        'Failed to relay batch delegation redemption to home wallet: peer disconnected',
+      );
     });
 
     it('throws for non-delegation batch when peer is set but no bundler', async () => {

packages/evm-wallet-experiment/src/vats/coordinator-vat.ts

@@ -1050,6 +1050,34 @@ export function buildRootObject(
     maxFeePerGas?: Hex | undefined;
     maxPriorityFeePerGas?: Hex | undefined;
   }): Promise<Hex> {
+    // Check the relay path first — it forwards raw delegations/execution to
+    // the home wallet and does not need local chain ID or SDK calldata.
+    if (!bundlerConfig && !smartAccountConfig) {
+      if (peerWallet) {
+        try {
+          return await E(peerWallet).handleRedemptionRequest({
+            type: 'single',
+            delegations: options.delegations,
+            execution: options.execution,
+            maxFeePerGas: options.maxFeePerGas,
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+          });
+        } catch (relayError) {
+          const detail =
+            relayError instanceof Error
+              ? relayError.message
+              : String(relayError);
+          throw new Error(
+            `Failed to relay delegation redemption to home wallet: ${detail}`,
+            { cause: relayError },
+          );
+        }
+      }
+      throw new Error(
+        'Bundler not configured and no peer wallet available for relay',
+      );
+    }
+
     const sender =
       smartAccountConfig?.address ?? options.delegations[0].delegate;
 
@@ -1070,25 +1098,8 @@ export function buildRootObject(
     }
 
     if (!bundlerConfig) {
-      if (peerWallet) {
-        try {
-          return await E(peerWallet).handleRedemptionRequest({
-            type: 'single',
-            delegations: options.delegations,
-            execution: options.execution,
-            maxFeePerGas: options.maxFeePerGas,
-            maxPriorityFeePerGas: options.maxPriorityFeePerGas,
-          });
-        } catch (relayError) {
-          throw new Error(
-            'Failed to relay delegation redemption to home wallet — ' +
-              'ensure the home device is online and try again',
-            { cause: relayError },
-          );
-        }
-      }
       throw new Error(
-        'Bundler not configured and no peer wallet available for relay',
+        'Bundler not configured (required for hybrid smart account redemption)',
       );
     }
 
@@ -1122,6 +1133,32 @@ export function buildRootObject(
     delegations: Delegation[];
     executions: Execution[];
   }): Promise<Hex> {
+    // Check the relay path first — it forwards raw delegations/executions to
+    // the home wallet and does not need local chain ID or SDK calldata.
+    if (!bundlerConfig && !smartAccountConfig) {
+      if (peerWallet) {
+        try {
+          return await E(peerWallet).handleRedemptionRequest({
+            type: 'batch',
+            delegations: options.delegations,
+            executions: options.executions,
+          });
+        } catch (relayError) {
+          const detail =
+            relayError instanceof Error
+              ? relayError.message
+              : String(relayError);
+          throw new Error(
+            `Failed to relay batch delegation redemption to home wallet: ${detail}`,
+            { cause: relayError },
+          );
+        }
+      }
+      throw new Error(
+        'Bundler not configured and no peer wallet available for relay',
+      );
+    }
+
     const sender =
       smartAccountConfig?.address ?? options.delegations[0]?.delegate;
     if (!sender) {
@@ -1140,23 +1177,8 @@ export function buildRootObject(
     }
 
     if (!bundlerConfig) {
-      if (peerWallet) {
-        try {
-          return await E(peerWallet).handleRedemptionRequest({
-            type: 'batch',
-            delegations: options.delegations,
-            executions: options.executions,
-          });
-        } catch (relayError) {
-          throw new Error(
-            'Failed to relay batch delegation redemption to home wallet — ' +
-              'ensure the home device is online and try again',
-            { cause: relayError },
-          );
-        }
-      }
       throw new Error(
-        'Bundler not configured and no peer wallet available for relay',
+        'Bundler not configured (required for hybrid smart account batch redemption)',
       );
     }
 
@@ -2767,12 +2789,14 @@ export function buildRootObject(
         throw new Error('Missing or empty delegations in redemption request');
       }
 
-      // Guard against infinite relay loops: if this wallet also has no
-      // bundler and no direct 7702, it cannot fulfill the request and
-      // must not relay it back to its own peer.
-      const sender =
-        smartAccountConfig?.address ?? request.delegations[0].delegate;
-      if (!bundlerConfig && !(await useDirect7702Tx(sender))) {
+      // Guard against infinite relay loops: if this wallet cannot fulfill
+      // the request locally, it must not relay it back to its own peer.
+      // Uses the same config-based check as the relay entry condition in
+      // submitDelegationUserOp/submitBatchDelegationUserOp — keep in sync.
+      const canFulfillLocally =
+        bundlerConfig !== undefined ||
+        smartAccountConfig?.implementation === 'stateless7702';
+      if (!canFulfillLocally) {
         throw new Error(
           'Cannot fulfill relayed redemption: no bundler or direct 7702 configured',
         );
@@ -2838,7 +2862,7 @@ export function buildRootObject(
           cachedPeerSigningMode = signingMode;
           persistBaggage('cachedPeerSigningMode', cachedPeerSigningMode);
         } catch (error) {
-          logger.warn('peer getCapabilities timed out, using cache', error);
+          logger.warn('peer getCapabilities failed, using cache', error);
           signingMode = cachedPeerSigningMode ?? 'peer:unknown';
         }
       } else if (externalSigner) {
@@ -2867,8 +2891,12 @@ export function buildRootObject(
       let autonomy: string;
       const canRedeemLocally =
         bundlerConfig !== undefined ||
-        smartAccountConfig?.implementation === 'stateless7702';
-      const canRedeemViaRelay = !canRedeemLocally && peerWallet !== undefined;
+        (smartAccountConfig?.implementation === 'stateless7702' &&
+          providerVat !== undefined);
+      // Relay requires no smartAccountConfig — mirrors the entry condition
+      // in submitDelegationUserOp/submitBatchDelegationUserOp.
+      const canRedeemViaRelay =
+        !canRedeemLocally && !smartAccountConfig && peerWallet !== undefined;
       const canRedeemDelegationsOnChain =
         activeDelegations.length > 0 && (canRedeemLocally || canRedeemViaRelay);
       if (canRedeemDelegationsOnChain) {