tapimo 0.15.0 → 0.18.0

package/src/handlers/internal/multisig.ts

@@ -1,4 +1,4 @@
-import type { Store } from 'viem/tempo'
+import { Store } from 'viem/tempo'
 
 import type * as core_Store from '../../internal/Store.js'
 
@@ -7,14 +7,17 @@ export function fromStore(store: core_Store.State): Store.Atomic {
   const swap = store.swap?.bind(store)
   if (!swap) throw new Error('Multisig coordination requires an atomic state store.')
 
-  return {
-    compareAndSet(key, expected, value, options) {
-      const ttl =
-        options?.expiresAt === undefined ? undefined : Math.max(0, options.expiresAt - Date.now())
-      return swap(key, expected, value, ttl === undefined ? undefined : { ttl })
+  return Store.from(
+    {
+      compareAndSet(key, expected, value, options) {
+        const ttl =
+          options?.expiresAt === undefined ? undefined : Math.max(0, options.expiresAt - Date.now())
+        return swap(key, expected, value, ttl === undefined ? undefined : { ttl })
+      },
+      getItem: (key) => store.get(key),
+      removeItem: (key) => store.delete(key),
+      setItem: (key, value) => store.put(key, value),
     },
-    getItem: (key) => store.get(key),
-    removeItem: (key) => store.delete(key),
-    setItem: (key, value) => store.put(key, value),
-  }
+    { key: 'multisig:v2' },
+  )
 }

package/src/handlers/relay.test.ts

@@ -1,6 +1,6 @@
 /** @module-tag localnet */
 
-import type { RpcRequest } from 'ox'
+import { Hex, type RpcRequest } from 'ox'
 import { SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
 import { type Address, type BaseError, createClient, parseUnits, toHex } from 'viem'
 import { generatePrivateKey } from 'viem/accounts'
@@ -324,7 +324,7 @@ describe.skipIf(Runtime.get().mode !== 'localnet')('behavior: with feePayer', ()
   })
 })
 
-describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG === 'sha-2bd9fa3')(
+describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG === 'sha-83f3ccd')(
   'multisig',
   () => {
     let client: ReturnType<typeof Relay.getClient>
@@ -443,87 +443,9 @@ describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG
     `)
     })
 
-    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('rejects multisig accounts as owners', () => {
+      const child = Account.fromMultisig({ owners: [Relay.accounts[3]!] })
+      expect(() => Account.fromMultisig({ owners: [child as never] })).toThrow()
     })
 
     test('example: weighted quorum', async () => {
@@ -1146,6 +1068,141 @@ describe.skipIf(Runtime.get().mode !== 'localnet')('behavior: with feePayer.feeT
     expect(transaction.feePayerSignature).toBeDefined()
   })
 
+  test('behavior: resolves sponsor.feeToken from the request chain', async () => {
+    let resolvedChainId: number | undefined
+    const customServer = await Relay.createServer(
+      (
+        await Relay.relay({
+          feePayer: {
+            account: feePayerAccount,
+            resolveFeeToken: (chainId) => {
+              resolvedChainId = chainId
+              return sponsorFeeToken
+            },
+          },
+          tokens: localnetTokens,
+        })
+      ).listener,
+    )
+
+    try {
+      const { transaction } = await fillTransaction(Relay.getClient({ url: customServer.url }), {
+        account: userAccount.address,
+        calls: [transferCall()],
+      })
+
+      expect(resolvedChainId).toBe(Runtime.get().chainId)
+      expect(transaction.feeToken?.toLowerCase()).toBe(sponsorFeeToken)
+    } finally {
+      customServer.close()
+    }
+  })
+
+  test('behavior: validated fills retain the resolved fee token in the signed envelope', async () => {
+    const resolvedFeeToken = Relay.addresses.alphaUsd as Address
+    let signed: Hex.Hex | undefined
+    const customServer = await Relay.createServer(
+      (
+        await Relay.relay({
+          feePayer: {
+            account: feePayerAccount,
+            onSponsored: (event) => {
+              signed = event.transaction
+            },
+            resolveFeeToken: () => resolvedFeeToken,
+            validate: () => true,
+          },
+          tokens: localnetTokens,
+        })
+      ).listener,
+    )
+
+    try {
+      const { transaction } = await fillTransaction(Relay.getClient({ url: customServer.url }), {
+        account: userAccount.address,
+        calls: [transferCall()],
+      })
+
+      expect(transaction.feeToken?.toLowerCase()).toBe(resolvedFeeToken.toLowerCase())
+      expect(
+        (Transaction.deserialize(signed!) as Transaction.Transaction).feeToken?.toLowerCase(),
+      ).toBe(resolvedFeeToken.toLowerCase())
+    } finally {
+      customServer.close()
+    }
+  })
+
+  test('behavior: sponsored fills do not swap sender funds into the sponsor fee token', async () => {
+    const sender = Relay.accounts[4]!
+    const rpc = Relay.getClient({ account: Relay.accounts[0]! })
+    const { token } = await Actions.token.createSync(rpc, {
+      currency: 'USD',
+      name: 'Sponsored Fee Token',
+      quoteToken: Relay.addresses.alphaUsd,
+      symbol: 'SPFEE',
+    })
+    await sendTransactionSync(rpc, {
+      calls: [
+        Actions.token.grantRoles.call(caller, {
+          role: 'issuer',
+          to: rpc.account!.address,
+          token,
+        }),
+        Actions.token.mint.call(caller, {
+          amount: parseUnits('10000', 6),
+          to: rpc.account!.address,
+          token,
+        }),
+        Actions.token.approve.call(caller, {
+          amount: parseUnits('10000', 6),
+          spender: Addresses.stablecoinDex,
+          token,
+        }),
+        Actions.token.approve.call(caller, {
+          amount: parseUnits('10000', 6),
+          spender: Addresses.stablecoinDex,
+          token: Relay.addresses.alphaUsd,
+        }),
+      ],
+    })
+    await Actions.dex.createPairSync(rpc, { base: token })
+    await Actions.dex.placeSync(rpc, {
+      amount: parseUnits('500', 6),
+      tick: Tick.fromPrice('1.001'),
+      token,
+      type: 'sell',
+    })
+    await Actions.fee.setUserToken(Relay.getClient({ account: sender }), {
+      token: Relay.addresses.alphaUsd,
+    })
+
+    const customServer = await Relay.createServer(
+      (
+        await Relay.relay({
+          features: 'all',
+          feePayer: { account: feePayerAccount, feeToken: token },
+        })
+      ).listener,
+    )
+    try {
+      const result = await fillTransaction(Relay.getClient({ url: customServer.url }), {
+        account: sender.address,
+        ...Actions.token.transfer.call(caller, {
+          amount: 1n,
+          to: Relay.accounts[7]!.address,
+          token: Relay.addresses.alphaUsd,
+        }),
+      })
+
+      expect(result.transaction.calls).toHaveLength(1)
+      expect(result.transaction.feeToken?.toLowerCase()).toBe(token.toLowerCase())
+      expect(result.transaction.feePayerSignature).toBeDefined()
+      expect(result.capabilities?.['autoSwap']).toBeUndefined()
+    } finally {
+      customServer.close()
+    }
+  })
+
   test('behavior: request feeToken wins when sponsorship is opted out via feePayer:false', async () => {
     const { transaction } = await fillTransaction(client, {
       account: userAccount.address,
@@ -1206,6 +1263,48 @@ describe.skipIf(Runtime.get().mode !== 'localnet')('behavior: with feePayer.feeT
     expect(feeToken?.toLowerCase()).toBe(sponsorFeeToken)
   })
 
+  test('behavior: raw sponsor signing prefers the chain fee-token resolver', async () => {
+    const resolvedFeeToken = Relay.addresses.alphaUsd as Address
+    const customServer = await Relay.createServer(
+      (
+        await Relay.relay({
+          feePayer: {
+            account: feePayerAccount,
+            feeToken: sponsorFeeToken,
+            resolveFeeToken: () => resolvedFeeToken,
+          },
+          tokens: localnetTokens,
+        })
+      ).listener,
+    )
+    const rpc = Relay.getClient({ account: userAccount })
+    const { transaction } = await fillTransaction(rpc, {
+      account: userAccount.address,
+      calls: [transferCall()],
+      feePayer: true as never,
+    })
+    const partial = await userAccount.signTransaction({ ...transaction, feePayer: true } as never)
+
+    try {
+      const response = await fetch(customServer.url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: 1,
+          method: 'eth_signRawTransaction',
+          params: [partial],
+        }),
+      })
+      const body = (await response.json()) as { result: `0x76${string}` }
+      const feeToken = Transaction.deserialize(body.result).feeToken as Address | undefined
+
+      expect(feeToken?.toLowerCase()).toBe(resolvedFeeToken.toLowerCase())
+    } finally {
+      customServer.close()
+    }
+  })
+
   test('behavior: raw sponsor signing restores token-list default before validation', async () => {
     let feeToken_validated: Address | undefined
     const customServer = await Relay.createServer(
@@ -1486,6 +1585,8 @@ describe.skipIf(Runtime.get().mode !== 'localnet')(
   'behavior: app-provided feePayer URL bypasses wallet validate',
   () => {
     let appServer: Server
+    let externalRequest: unknown
+    let resolverCalls = 0
     let walletServer: Server
     let client: ReturnType<typeof Relay.getClient>
 
@@ -1500,6 +1601,10 @@ describe.skipIf(Runtime.get().mode !== 'localnet')(
               name: 'App Sponsor',
               url: 'https://app.example.com',
             },
+            async onRequest(request) {
+              if (request.method !== 'eth_fillTransaction') return
+              externalRequest = request
+            },
           })
         ).listener,
       )
@@ -1515,6 +1620,10 @@ describe.skipIf(Runtime.get().mode !== 'localnet')(
             feePayer: {
               account: feePayerAccount,
               name: 'Wallet Sponsor',
+              resolveFeeToken: () => {
+                resolverCalls++
+                return Relay.addresses.alphaUsd
+              },
               validate: () => false,
             },
           })
@@ -1529,6 +1638,22 @@ describe.skipIf(Runtime.get().mode !== 'localnet')(
       walletServer.close()
     })
 
+    test('behavior: external feePayer chooses its own fee token', async () => {
+      externalRequest = undefined
+      resolverCalls = 0
+      await fillTransaction(client, {
+        account: userAccount.address,
+        calls: [transferCall()],
+        feePayer: appServer.url as never,
+      })
+
+      expect(externalRequest).toMatchObject({ method: 'eth_fillTransaction' })
+      expect(externalRequest).not.toMatchObject({
+        params: [{ feeToken: Relay.addresses.alphaUsd }],
+      })
+      expect(resolverCalls).toBe(0)
+    })
+
     test('behavior: external feePayer URL is sponsored even when wallet validate rejects', async () => {
       const result = await fillTransaction(client, {
         account: userAccount.address,
@@ -2387,6 +2512,57 @@ describe.skipIf(Runtime.get().mode !== 'localnet')(
       expect(result.capabilities?.['sponsor']).toBeUndefined()
     })
 
+    test('behavior: rejected prepared fill restores the caller fee token', async () => {
+      const customServer = await Relay.createServer(
+        (
+          await Relay.relay({
+            feePayer: {
+              account: feePayerAccount,
+              feeToken: Relay.addresses.pathUsd,
+              validate: () => false,
+            },
+            tokens: localnetTokens,
+          })
+        ).listener,
+      )
+      try {
+        const response = await fetch(customServer.url, {
+          body: JSON.stringify(
+            {
+              id: 1,
+              jsonrpc: '2.0',
+              method: 'eth_fillTransaction',
+              params: [
+                {
+                  calls: [transferCall()],
+                  chainId: Hex.fromNumber(Runtime.get().chainId),
+                  feeToken: Relay.addresses.alphaUsd,
+                  from: rejectedSender.address,
+                  gas: '0x186a0',
+                  maxFeePerGas: '0xf4240',
+                  nonce: '0x0',
+                },
+              ],
+            },
+            (_key, value) => (typeof value === 'bigint' ? Hex.fromNumber(value) : value),
+          ),
+          headers: { 'content-type': 'application/json' },
+          method: 'POST',
+        })
+        const body = (await response.json()) as {
+          result: {
+            capabilities: { sponsored: boolean }
+            tx: { feePayerSignature?: string | undefined; feeToken?: string | undefined }
+          }
+        }
+        expect(body.result.tx.feeToken?.toLowerCase()).toBe(Relay.addresses.alphaUsd.toLowerCase())
+        expect(body.result.tx.feePayerSignature).toBeUndefined()
+        expect(body.result.capabilities.sponsored).toBe(false)
+      } finally {
+        customServer.close()
+      }
+    })
+
     test('behavior: rejected tx can be signed and broadcast by sender', async () => {
       const result = await fillTransaction(client, {
         account: rejectedSender.address,

package/src/handlers/relay.ts

@@ -129,8 +129,10 @@ export function relay(options: relay.Options = {}): Handler {
 
     return await Sponsorship.handleRawTransaction({
       account: feePayerOptions.account,
-      feeToken: feePayerOptions.feeToken,
-      getFeeToken: async (chainId) => (await getTokens(chainId))[0],
+      getFeeToken: async (chainId) =>
+        feePayerOptions.resolveFeeToken?.(chainId) ??
+        feePayerOptions.feeToken ??
+        (await getTokens(chainId))[0],
       getClient,
       method,
       onSponsored: feePayerOptions.onSponsored,
@@ -262,9 +264,16 @@ export function relay(options: relay.Options = {}): Handler {
           // overrides whatever the consumer asked for — the sponsor is
           // paying, so the sponsor picks. Falls back to the request's
           // feeToken otherwise.
-          const sponsoredFeeToken = requestsSponsorship
-            ? (feePayerOptions?.feeToken ?? requestFeeToken)
-            : requestFeeToken
+          const sponsoredFeeToken = (() => {
+            if (!requestsSponsorship) return requestFeeToken
+            if (externalFeePayerUrl) return requestFeeToken
+            if (chainId === undefined) return feePayerOptions?.feeToken ?? requestFeeToken
+            return (
+              feePayerOptions?.resolveFeeToken?.(chainId) ??
+              feePayerOptions?.feeToken ??
+              requestFeeToken
+            )
+          })()
 
           const baseTx = {
             ...normalized,
@@ -335,21 +344,12 @@ export function relay(options: relay.Options = {}): Handler {
               }
             } else {
               filled = await fill(fillClient, {
-                autoSwap,
+                autoSwap: externalFeePayerUrl ? autoSwap : undefined,
                 feeToken,
                 store,
-                resolveFeeToken: resolveFeeTokenForSwap,
+                resolveFeeToken: externalFeePayerUrl ? resolveFeeTokenForSwap : undefined,
                 transaction,
               })
-              // The chain echoes feeToken: null for sponsored fills served
-              // by viem clients that strip feeToken pre-sign; re-inject
-              // before the spread in mergeCallsFromRequest drops it.
-              if (
-                feeToken &&
-                filled?.transaction &&
-                (filled.transaction as { feeToken?: Address | null }).feeToken == null
-              )
-                (filled.transaction as { feeToken?: Address }).feeToken = feeToken
             }
             sponsored = true
           } else if (requestsSponsorship && feePayerOptions?.validate) {
@@ -372,6 +372,16 @@ export function relay(options: relay.Options = {}): Handler {
                 validate: feePayerOptions!.validate,
               })
               filled = prepared
+              if (!sponsored) {
+                filled = {
+                  ...prepared,
+                  transaction: Utils.normalizeTempoTransaction({
+                    ...normalized,
+                    ...(chainId !== undefined ? { chainId } : {}),
+                  }),
+                }
+                feeToken = requestFeeToken
+              }
             } else {
               const options = {
                 autoSwap,
@@ -380,7 +390,9 @@ export function relay(options: relay.Options = {}): Handler {
               }
               const fill_sponsored = await fill(fillClient, {
                 ...options,
+                autoSwap: undefined,
                 feeToken,
+                resolveFeeToken: undefined,
                 transaction: sponsoredTx,
               })
               sponsored = await Sponsorship.shouldSponsor({
@@ -401,7 +413,8 @@ export function relay(options: relay.Options = {}): Handler {
                     })
                   : requestFeeToken
                 const tx_unsponsored = {
-                  ...baseTx,
+                  ...normalized,
+                  ...(chainId !== undefined ? { chainId } : {}),
                   ...(feeToken_unsponsored ? { feeToken: feeToken_unsponsored } : {}),
                 }
                 filled = await fill(client, {
@@ -787,6 +800,8 @@ export namespace relay {
            * Called once the fee payer has signed a raw transaction.
            */
           onSponsored?: Sponsorship.handleRawTransaction.Options['onSponsored']
+          /** Resolves the sponsor's preferred fee token for a request chain. */
+          resolveFeeToken?: ((chainId: number) => Address | undefined) | undefined
           /**
            * Validates whether to sponsor the transaction. When omitted, all
            * transactions are sponsored. Return `false` to reject sponsorship.
@@ -1560,6 +1575,10 @@ function mergeCallsFromRequest(
   request: Record<string, unknown>,
 ): Record<string, unknown> {
   const merged: Record<string, unknown> = { ...request, ...resultTx }
+  // Nodes may return feeToken: null even when the request selected one. Keep
+  // the selected token because the fee payer signs the returned envelope.
+  if (resultTx['feeToken'] == null && request['feeToken'] != null)
+    merged['feeToken'] = request['feeToken']
   const resultCalls = resultTx['calls']
   if (Array.isArray(resultCalls) && resultCalls.length > 0) return merged