tapimo 0.14.0 → 0.15.1

package/src/handlers/relay.test.ts

@@ -2,13 +2,29 @@
 
 import type { RpcRequest } from 'ox'
 import { SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
-import { parseUnits, type Address, type BaseError } from 'viem'
-import { fillTransaction, sendTransactionSync } from 'viem/actions'
-import { Actions, Addresses, Capabilities, Tick, Transaction, VirtualAddress } from 'viem/tempo'
+import { type Address, type BaseError, createClient, parseUnits, toHex } from 'viem'
+import { generatePrivateKey } from 'viem/accounts'
+import {
+  fillTransaction,
+  getTransaction,
+  prepareTransactionRequest,
+  sendTransactionSync,
+} from 'viem/actions'
+import {
+  Account,
+  Actions,
+  Addresses,
+  Capabilities,
+  Tick,
+  Transaction,
+  VirtualAddress,
+  withRelay,
+} from 'viem/tempo'
 import { tempo, tempoModerato } from 'viem/tempo/chains'
 
 import * as Relay from '../../test/Relay.js'
 import * as Runtime from '../../test/runtime.js'
+import * as Store from '../internal/Store.js'
 
 type Server = Relay.Server
 
@@ -308,6 +324,784 @@ describe.skipIf(Runtime.get().mode !== 'localnet')('behavior: with feePayer', ()
   })
 })
 
+describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG === 'sha-2bd9fa3')(
+  'multisig',
+  () => {
+    let client: ReturnType<typeof Relay.getClient>
+    let server: Server
+    const store = Store.memory()
+
+    beforeAll(async () => {
+      server = await Relay.createServer(
+        (
+          await Relay.relay({
+            multisig: { store },
+            tokens: localnetTokens,
+          })
+        ).listener,
+      )
+      client = createClient({
+        chain: Relay.chain,
+        pollingInterval: 100,
+        transport: withRelay(Relay.http(), Relay.http(server.url)),
+      })
+    })
+
+    afterAll(() => {
+      server.close()
+    })
+
+    test('example: initial configuration', async () => {
+      const owner_1 = Relay.accounts[1]!
+      const owner_2 = Relay.accounts[2]!
+      const account = Account.fromMultisig({
+        address: 'infer',
+        owners: [owner_1.address, owner_2.address],
+        salt: toHex(0x109700, { size: 32 }),
+        threshold: 2,
+      })
+
+      await Actions.token.transferSync(caller, {
+        account: feePayerAccount,
+        amount: parseUnits('1', 6),
+        to: account.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const balance = await Actions.token.getBalance(client, {
+        account: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+
+      const { receipt: pending } = await Actions.token.transferSync(client, {
+        account,
+        amount: 1n,
+        owner: owner_1,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      expect({
+        signatureCount: pending.multisig?.signatureCount,
+        status: pending.status,
+        threshold: pending.multisig?.threshold,
+        weight: pending.multisig?.weight,
+      }).toMatchInlineSnapshot(`
+      {
+        "signatureCount": 1,
+        "status": "pending",
+        "threshold": 2,
+        "weight": 1,
+      }
+    `)
+
+      const { receipt } = await Actions.token.transferSync(client, {
+        account,
+        amount: 1n,
+        hash: pending.transactionHash,
+        owner: owner_2,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      } as never)
+      expect({
+        signatureCount: receipt.multisig?.signatureCount,
+        status: receipt.status,
+        threshold: receipt.multisig?.threshold,
+        weight: receipt.multisig?.weight,
+      }).toMatchInlineSnapshot(`
+      {
+        "signatureCount": 2,
+        "status": "success",
+        "threshold": 2,
+        "weight": 2,
+      }
+    `)
+      expect(
+        (
+          await Actions.token.getBalance(client, {
+            account: recipient.address,
+            token: Relay.addresses.alphaUsd,
+          })
+        ).amount - balance.amount,
+      ).toMatchInlineSnapshot(`1n`)
+
+      const transaction = await getTransaction(client, {
+        hash: receipt.transactionHash,
+      })
+      if (transaction.signature?.type !== 'multisig')
+        throw new Error('Expected a multisig signature.')
+      expect({
+        account: transaction.signature.account,
+        signatureCount: transaction.signature.signatures.length,
+        type: transaction.signature.type,
+        version: transaction.signature.config.version,
+      }).toMatchInlineSnapshot(`
+      {
+        "account": "${account.address.toLowerCase()}",
+        "signatureCount": 2,
+        "type": "multisig",
+        "version": 0n,
+      }
+    `)
+    })
+
+    test('example: nested ownership', async () => {
+      const childOwner = Relay.accounts[3]!
+      const child = Account.fromMultisig({
+        address: 'infer',
+        owners: [childOwner],
+        salt: toHex(0x109701, { size: 32 }),
+      })
+
+      await Actions.token.transferSync(caller, {
+        account: feePayerAccount,
+        amount: parseUnits('1', 6),
+        to: child.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const current = await Actions.multisig.updateConfigSync(client, {
+        account: child,
+        nextConfig: {
+          owners: [{ owner: childOwner.address, weight: 1 }],
+          threshold: 1,
+        },
+        owner: childOwner,
+      })
+      expect(current.receipt.status).toMatchInlineSnapshot(`"success"`)
+
+      const currentChild = Account.fromMultisig({
+        address: child.address,
+        owners: [{ owner: childOwner, weight: 1 }],
+        salt: current.config.salt,
+        threshold: current.config.threshold,
+        version: current.config.version,
+      })
+      const parent = Account.fromMultisig({
+        address: 'infer',
+        owners: [currentChild],
+        salt: toHex(0x109702, { size: 32 }),
+      })
+
+      await Actions.token.transferSync(caller, {
+        account: feePayerAccount,
+        amount: parseUnits('1', 6),
+        to: parent.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const currentParent = await Actions.multisig.updateConfigSync(client, {
+        account: parent,
+        nextConfig: {
+          owners: [{ owner: currentChild.address, weight: 1 }],
+          threshold: 1,
+        },
+        owner: currentChild,
+      })
+      expect(currentParent.receipt.status).toMatchInlineSnapshot(`"success"`)
+
+      const account = Account.fromMultisig({
+        address: parent.address,
+        owners: [{ owner: currentChild, weight: 1 }],
+        salt: currentParent.config.salt,
+        threshold: currentParent.config.threshold,
+        version: currentParent.config.version,
+      })
+      const { receipt } = await Actions.token.transferSync(client, {
+        account,
+        amount: 2n,
+        owner: currentChild,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      expect(receipt.status).toMatchInlineSnapshot(`"success"`)
+
+      const transaction = await getTransaction(client, {
+        hash: receipt.transactionHash,
+      })
+      expect(transaction.signature?.type).toMatchInlineSnapshot(`"multisig"`)
+      if (transaction.signature?.type !== 'multisig')
+        throw new Error('Expected a multisig signature.')
+      expect(transaction.signature.signatures.map((signature) => signature.type))
+        .toMatchInlineSnapshot(`
+      [
+        "multisig",
+      ]
+    `)
+    })
+
+    test('example: weighted quorum', async () => {
+      const owners = [Relay.accounts[4]!, Relay.accounts[6]!, Relay.accounts[8]!].sort((a, b) =>
+        a.address.localeCompare(b.address),
+      )
+      const heavy = owners[0]!
+      const light_1 = owners[1]!
+      const light_2 = owners[2]!
+      const account = Account.fromMultisig({
+        address: 'infer',
+        owners: [
+          { owner: heavy.address, weight: 2 },
+          { owner: light_1.address, weight: 1 },
+          { owner: light_2.address, weight: 1 },
+        ],
+        salt: toHex(0x109703, { size: 32 }),
+        threshold: 3,
+      })
+
+      await Actions.token.transferSync(caller, {
+        account: feePayerAccount,
+        amount: parseUnits('1', 6),
+        to: account.address,
+        token: Relay.addresses.alphaUsd,
+      })
+
+      const { receipt: alicePending } = await Actions.token.transferSync(client, {
+        account,
+        amount: 3n,
+        owner: heavy,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      expect({
+        status: alicePending.status,
+        weight: alicePending.multisig?.weight,
+      }).toMatchInlineSnapshot(`
+      {
+        "status": "pending",
+        "weight": 2,
+      }
+    `)
+      const { receipt: aliceBob } = await Actions.token.transferSync(client, {
+        account,
+        amount: 3n,
+        hash: alicePending.transactionHash,
+        owner: light_1,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      } as never)
+      expect(aliceBob.status).toMatchInlineSnapshot(`"success"`)
+
+      const { receipt: secondAlicePending } = await Actions.token.transferSync(client, {
+        account,
+        amount: 4n,
+        owner: heavy,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const { receipt: aliceCarol } = await Actions.token.transferSync(client, {
+        account,
+        amount: 4n,
+        hash: secondAlicePending.transactionHash,
+        owner: light_2,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      } as never)
+      expect(aliceCarol.status).toMatchInlineSnapshot(`"success"`)
+
+      const { receipt: bobPending } = await Actions.token.transferSync(client, {
+        account,
+        amount: 5n,
+        owner: light_1,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const { receipt: bobCarolPending } = await Actions.token.transferSync(client, {
+        account,
+        amount: 5n,
+        hash: bobPending.transactionHash,
+        owner: light_2,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      } as never)
+      expect({
+        status: bobCarolPending.status,
+        weight: bobCarolPending.multisig?.weight,
+      }).toMatchInlineSnapshot(`
+      {
+        "status": "pending",
+        "weight": 2,
+      }
+    `)
+
+      const { receipt } = await Actions.token.transferSync(client, {
+        account,
+        amount: 5n,
+        hash: bobCarolPending.transactionHash,
+        owner: heavy,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      } as never)
+      expect(receipt.status).toMatchInlineSnapshot(`"success"`)
+
+      const transaction = await getTransaction(client, {
+        hash: receipt.transactionHash,
+      })
+      if (transaction.signature?.type !== 'multisig')
+        throw new Error('Expected a multisig signature.')
+      expect({
+        signatureCount: transaction.signature.signatures.length,
+        status: receipt.status,
+        weight: receipt.multisig?.weight,
+      }).toMatchInlineSnapshot(`
+      {
+        "signatureCount": 2,
+        "status": "success",
+        "weight": 3,
+      }
+    `)
+    })
+
+    test('example: fee sponsorship', async () => {
+      const sponsorStore = Store.memory()
+      const sponsorServer = await Relay.createServer(
+        (
+          await Relay.relay({
+            feePayer: {
+              account: feePayerAccount,
+              onSponsored: () => ({ subsidized: true }),
+            },
+            multisig: { store: sponsorStore },
+            tokens: localnetTokens,
+          })
+        ).listener,
+      )
+      const sponsorClient = createClient({
+        chain: Relay.chain,
+        pollingInterval: 100,
+        transport: withRelay(Relay.http(), Relay.http(sponsorServer.url)),
+      })
+      const owner_1 = Relay.accounts[1]!
+      const owner_2 = Relay.accounts[2]!
+
+      try {
+        const transaction = await prepareTransactionRequest(caller, {
+          account: userAccount.address,
+          calls: [transferCall()],
+          feePayer: true,
+        })
+        const serialized = await userAccount.signTransaction(transaction as never)
+        const response = await fetch(sponsorServer.url, {
+          body: JSON.stringify({
+            id: 1,
+            jsonrpc: '2.0',
+            method: 'eth_sendRawTransactionSync',
+            params: [serialized],
+          }),
+          headers: { 'content-type': 'application/json' },
+          method: 'POST',
+        })
+        expect(await response.json()).toMatchObject({
+          sponsorship_details: { subsidized: true },
+        })
+
+        const ownerFirst = Account.fromMultisig({
+          address: 'infer',
+          owners: [owner_1.address, owner_2.address],
+          salt: toHex(0x109704, { size: 32 }),
+          threshold: 2,
+        })
+        await Actions.token.transferSync(caller, {
+          account: feePayerAccount,
+          amount: parseUnits('1', 6),
+          to: ownerFirst.address,
+          token: Relay.addresses.alphaUsd,
+        })
+
+        const { receipt: ownerFirstPending } = await Actions.token.transferSync(sponsorClient, {
+          account: ownerFirst,
+          amount: 6n,
+          feePayer: true,
+          owner: owner_1,
+          to: recipient.address,
+          token: Relay.addresses.alphaUsd,
+        })
+        if (!ownerFirstPending.multisig) throw new Error('Expected a multisig operation.')
+        const ownerFirstTransaction = Transaction.deserialize(
+          ownerFirstPending.multisig.transaction,
+        )
+        expect({
+          feePayerSigned:
+            'feePayerSignature' in ownerFirstTransaction &&
+            !!ownerFirstTransaction.feePayerSignature,
+          status: ownerFirstPending.status,
+        }).toMatchInlineSnapshot(`
+        {
+          "feePayerSigned": false,
+          "status": "pending",
+        }
+      `)
+
+        const { receipt: ownerFirstReceipt } = await Actions.token.transferSync(sponsorClient, {
+          account: ownerFirst,
+          amount: 6n,
+          hash: ownerFirstPending.transactionHash,
+          owner: owner_2,
+          to: recipient.address,
+          token: Relay.addresses.alphaUsd,
+        } as never)
+        expect({
+          feePayer: ownerFirstReceipt.feePayer,
+          status: ownerFirstReceipt.status,
+        }).toMatchInlineSnapshot(`
+        {
+          "feePayer": "${feePayerAccount.address.toLowerCase()}",
+          "status": "success",
+        }
+      `)
+
+        const feePayerFirst = Account.fromMultisig({
+          address: 'infer',
+          owners: [owner_1.address, owner_2.address],
+          salt: toHex(0x109705, { size: 32 }),
+          threshold: 2,
+        })
+        await Actions.token.transferSync(caller, {
+          account: feePayerAccount,
+          amount: parseUnits('1', 6),
+          to: feePayerFirst.address,
+          token: Relay.addresses.alphaUsd,
+        })
+
+        const { receipt: feePayerFirstPending } = await Actions.token.transferSync(sponsorClient, {
+          account: feePayerFirst,
+          amount: 7n,
+          feePayer: feePayerAccount,
+          owner: owner_1,
+          to: recipient.address,
+          token: Relay.addresses.alphaUsd,
+        })
+        if (!feePayerFirstPending.multisig) throw new Error('Expected a multisig operation.')
+        const feePayerFirstTransaction = Transaction.deserialize(
+          feePayerFirstPending.multisig.transaction,
+        )
+        expect({
+          feePayerSigned:
+            'feePayerSignature' in feePayerFirstTransaction &&
+            !!feePayerFirstTransaction.feePayerSignature,
+          status: feePayerFirstPending.status,
+        }).toMatchInlineSnapshot(`
+        {
+          "feePayerSigned": true,
+          "status": "pending",
+        }
+      `)
+
+        const { receipt: feePayerFirstReceipt } = await Actions.token.transferSync(sponsorClient, {
+          account: feePayerFirst,
+          amount: 7n,
+          hash: feePayerFirstPending.transactionHash,
+          owner: owner_2,
+          to: recipient.address,
+          token: Relay.addresses.alphaUsd,
+        } as never)
+        expect({
+          feePayer: feePayerFirstReceipt.feePayer,
+          status: feePayerFirstReceipt.status,
+        }).toMatchInlineSnapshot(`
+        {
+          "feePayer": "${feePayerAccount.address.toLowerCase()}",
+          "status": "success",
+        }
+      `)
+      } finally {
+        sponsorServer.close()
+      }
+    })
+
+    test('example: initial config and immediate access key use', async () => {
+      const owner_1 = Relay.accounts[3]!
+      const owner_2 = Relay.accounts[4]!
+      const account = Account.fromMultisig({
+        address: 'infer',
+        owners: [owner_1, owner_2],
+        salt: toHex(0x109706, { size: 32 }),
+        threshold: 2,
+      })
+      const accessKey = Account.fromSecp256k1(generatePrivateKey(), {
+        access: account,
+      })
+
+      await Actions.token.transferSync(caller, {
+        account: feePayerAccount,
+        amount: parseUnits('1', 6),
+        to: account.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const pending = await Actions.accessKey.signAuthorization(client, {
+        accessKey,
+        account,
+        owner: owner_1,
+      })
+      expect({
+        signatureCount: pending.multisig.signatureCount,
+        status: pending.status,
+        threshold: pending.multisig.threshold,
+        weight: pending.multisig.weight,
+      }).toMatchInlineSnapshot(`
+      {
+        "signatureCount": 1,
+        "status": "pending",
+        "threshold": 2,
+        "weight": 1,
+      }
+    `)
+      const keyAuthorization = await Actions.accessKey.signAuthorization(client, {
+        hash: pending.hash,
+        owner: owner_2,
+      })
+
+      const { receipt } = await Actions.token.transferSync(client, {
+        account: accessKey,
+        amount: 8n,
+        keyAuthorization,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const transaction = await getTransaction(client, {
+        hash: receipt.transactionHash,
+      })
+      expect({
+        from: receipt.from,
+        keyAuthorizationSignature: transaction.keyAuthorization?.signature.type,
+        status: receipt.status,
+        transactionSignature: transaction.signature?.type,
+        version:
+          transaction.keyAuthorization?.signature.type === 'multisig'
+            ? transaction.keyAuthorization.signature.config.version
+            : undefined,
+      }).toMatchInlineSnapshot(`
+      {
+        "from": "${account.address.toLowerCase()}",
+        "keyAuthorizationSignature": "multisig",
+        "status": "success",
+        "transactionSignature": "keychain",
+        "version": 0n,
+      }
+    `)
+    })
+
+    test('example: initial config and subsequent access key use', async () => {
+      const owner_1 = Relay.accounts[6]!
+      const owner_2 = Relay.accounts[8]!
+      const account = Account.fromMultisig({
+        address: 'infer',
+        owners: [owner_1, owner_2],
+        salt: toHex(0x109707, { size: 32 }),
+        threshold: 2,
+      })
+      const accessKey = Account.fromSecp256k1(generatePrivateKey(), {
+        access: account,
+      })
+
+      await Actions.token.transferSync(caller, {
+        account: feePayerAccount,
+        amount: parseUnits('1', 6),
+        to: account.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const pendingAuthorization = await Actions.accessKey.signAuthorization(client, {
+        accessKey,
+        account,
+        owner: owner_1,
+      })
+      const keyAuthorization = await Actions.accessKey.signAuthorization(client, {
+        hash: pendingAuthorization.hash,
+        owner: owner_2,
+      })
+
+      const { receipt: pending } = await Actions.token.transferSync(client, {
+        account,
+        amount: 9n,
+        keyAuthorization,
+        owner: owner_1,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const { receipt: initialReceipt } = await Actions.token.transferSync(client, {
+        account,
+        amount: 9n,
+        hash: pending.transactionHash,
+        keyAuthorization,
+        owner: owner_2,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      } as never)
+      const initialTransaction = await getTransaction(client, {
+        hash: initialReceipt.transactionHash,
+      })
+      expect({
+        keyAuthorizationSignature: initialTransaction.keyAuthorization?.signature.type,
+        status: initialReceipt.status,
+        transactionSignature: initialTransaction.signature?.type,
+      }).toMatchInlineSnapshot(`
+      {
+        "keyAuthorizationSignature": "multisig",
+        "status": "success",
+        "transactionSignature": "multisig",
+      }
+    `)
+
+      const { receipt } = await Actions.token.transferSync(client, {
+        account: accessKey,
+        amount: 10n,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      expect({
+        from: receipt.from,
+        status: receipt.status,
+      }).toMatchInlineSnapshot(`
+      {
+        "from": "${account.address.toLowerCase()}",
+        "status": "success",
+      }
+    `)
+    })
+
+    test('example: current configuration and configuration rotation', async () => {
+      const owner_1 = Relay.accounts[1]!
+      const owner_2 = Relay.accounts[2]!
+      const owner_3 = Relay.accounts[3]!
+      const account = Account.fromMultisig({
+        address: 'infer',
+        owners: [owner_1, owner_2],
+        salt: toHex(0x109708, { size: 32 }),
+        threshold: 2,
+      })
+      const nextConfig = {
+        owners: [{ owner: owner_3.address, weight: 1 }],
+        threshold: 1,
+      } as const
+
+      await Actions.token.transferSync(caller, {
+        account: feePayerAccount,
+        amount: parseUnits('1', 6),
+        to: account.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const { receipt: pending } = await Actions.multisig.updateConfigSync(client, {
+        account,
+        nextConfig,
+        owner: owner_1,
+      })
+      expect({
+        status: pending.status,
+        version: pending.multisig?.config.version,
+      }).toMatchInlineSnapshot(`
+      {
+        "status": "pending",
+        "version": 0n,
+      }
+    `)
+
+      const { receipt: updateReceipt, ...rotation } = await Actions.multisig.updateConfigSync(
+        client,
+        {
+          account,
+          hash: pending.transactionHash,
+          nextConfig,
+          owner: owner_2,
+        } as never,
+      )
+      expect({
+        account: rotation.account,
+        status: updateReceipt.status,
+        threshold: rotation.config.threshold,
+        version: rotation.config.version,
+      }).toMatchInlineSnapshot(`
+      {
+        "account": "${account.address}",
+        "status": "success",
+        "threshold": 1,
+        "version": 1n,
+      }
+    `)
+
+      const currentAccount = Account.fromMultisig(account.address)
+      const { receipt } = await Actions.token.transferSync(client, {
+        account: currentAccount,
+        amount: 11n,
+        owner: owner_3,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const transaction = await getTransaction(client, {
+        hash: receipt.transactionHash,
+      })
+      expect({
+        account: transaction.from,
+        status: receipt.status,
+        version:
+          transaction.signature?.type === 'multisig'
+            ? transaction.signature.config.version
+            : undefined,
+      }).toMatchInlineSnapshot(`
+      {
+        "account": "${account.address.toLowerCase()}",
+        "status": "success",
+        "version": 1n,
+      }
+    `)
+    })
+
+    test('behavior: routes pathless approvals to their operation chain', async () => {
+      const owner_1 = Relay.accounts[1]!
+      const owner_2 = Relay.accounts[2]!
+      const account = Account.fromMultisig({
+        address: 'infer',
+        owners: [owner_1, owner_2],
+        salt: toHex(0x109709, { size: 32 }),
+        threshold: 2,
+      })
+
+      await Actions.token.transferSync(caller, {
+        account: feePayerAccount,
+        amount: parseUnits('1', 6),
+        to: account.address,
+        token: Relay.addresses.alphaUsd,
+      })
+      const { receipt: pending } = await Actions.token.transferSync(client, {
+        account,
+        amount: 12n,
+        owner: owner_1,
+        to: recipient.address,
+        token: Relay.addresses.alphaUsd,
+      })
+
+      const getClient = Relay.readClient()
+      if (!getClient) throw new Error('Expected a relay client resolver.')
+      const routedServer = await Relay.createServer(
+        (
+          await Relay.relay({
+            getClient(chainId) {
+              if (chainId !== Relay.chain.id)
+                throw new Error('Expected the multisig operation chain.')
+              return getClient(chainId)
+            },
+            multisig: { store },
+            tokens: localnetTokens,
+          })
+        ).listener,
+      )
+      try {
+        const routedClient = createClient({
+          chain: Relay.chain,
+          pollingInterval: 100,
+          transport: withRelay(Relay.http(), Relay.http(routedServer.url)),
+        })
+        const { receipt } = await Actions.token.transferSync(routedClient, {
+          account,
+          amount: 12n,
+          hash: pending.transactionHash,
+          owner: owner_2,
+          to: recipient.address,
+          token: Relay.addresses.alphaUsd,
+        } as never)
+
+        expect(receipt.status).toMatchInlineSnapshot(`"success"`)
+      } finally {
+        await routedServer.closeAsync()
+      }
+    })
+  },
+)
+
 describe.skipIf(Runtime.get().mode !== 'localnet')('behavior: with feePayer.feeToken', () => {
   let server: Server
   let client: ReturnType<typeof Relay.getClient>
@@ -507,6 +1301,32 @@ describe.skipIf(Runtime.get().mode !== 'localnet')(
       expect(transaction.gas).toBeDefined()
     })
 
+    test('rejects redirects from external fee-payer relays', async () => {
+      let targetRequests = 0
+      const target = await Relay.createServer((_request, response) => {
+        targetRequests++
+        response.end()
+      })
+      const redirect = await Relay.createServer((_request, response) => {
+        response.writeHead(302, { location: target.url })
+        response.end()
+      })
+
+      try {
+        await expect(
+          fillTransaction(client, {
+            account: userAccount.address,
+            calls: [transferCall()],
+            feePayer: redirect.url as never,
+          }),
+        ).rejects.toThrow()
+        expect(targetRequests).toBe(0)
+      } finally {
+        redirect.close()
+        target.close()
+      }
+    })
+
     test('behavior: relays sponsor metadata from app relay', async () => {
       const result = await fillTransaction(client, {
         account: userAccount.address,