tempo.ts 0.7.6 → 0.8.0

package/src/viem/e2e.test.ts

@@ -2,15 +2,17 @@ import * as Http from 'node:http'
 import { createRequestListener } from '@remix-run/node-fetch-server'
 import { RpcRequest, RpcResponse, WebCryptoP256 } from 'ox'
 import { Account, Transaction } from 'tempo.ts/viem'
-import { http, parseGwei, publicActions, walletActions } from 'viem'
+import { publicActions, walletActions } from 'viem'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
+import { defaultPrepareTransactionRequestParameters } from 'viem/actions'
 import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest'
-import { fetchOptions, rpcUrl } from '../../test/config.js'
+import { rpcUrl } from '../../test/config.js'
 import {
   accounts,
   client as client_,
   fundAddress,
   getClient,
+  http,
 } from '../../test/viem/config.js'
 import * as actions from './Actions/index.js'
 import { tempoActions } from './index.js'
@@ -41,11 +43,11 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -61,6 +63,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -79,7 +82,6 @@ describe('sendTransaction', () => {
           "feePayerSignature": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -117,11 +119,11 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -138,6 +140,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -149,7 +152,6 @@ describe('sendTransaction', () => {
           "feePayerSignature": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -182,11 +184,11 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -203,6 +205,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -220,7 +223,6 @@ describe('sendTransaction', () => {
           "data": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -232,6 +234,45 @@ describe('sendTransaction', () => {
         }
       `)
     })
+
+    test('with access key', async () => {
+      const account = accounts[0]
+      const accessKey = Account.fromP256(generatePrivateKey(), {
+        access: account,
+      })
+
+      const keyAuthorization = await account.signKeyAuthorization(accessKey)
+      await account.assignKeyAuthorization(keyAuthorization)
+
+      {
+        const receipt = await client.sendTransactionSync({
+          account: accessKey,
+        })
+        expect(receipt).toBeDefined()
+      }
+
+      // TODO: uncomment once unlimited spend supported
+      // {
+      //   const receipt = await client.token.transferSync({
+      //     account: accessKey,
+      //     amount: 100n,
+      //     token: '0x20c0000000000000000000000000000000000001',
+      //     to: '0x0000000000000000000000000000000000000001',
+      //   })
+      //   expect(receipt).toBeDefined()
+      // }
+
+      {
+        const receipt = await client.token.createSync({
+          account: accessKey,
+          admin: accessKey.address,
+          currency: 'USD',
+          name: 'Test Token 4',
+          symbol: 'TEST4',
+        })
+        expect(receipt).toBeDefined()
+      }
+    })
   })
 
   describe('p256', () => {
@@ -257,11 +298,11 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -279,6 +320,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -297,7 +339,6 @@ describe('sendTransaction', () => {
           "feePayerSignature": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -341,11 +382,11 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -364,6 +405,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -375,7 +417,6 @@ describe('sendTransaction', () => {
           "feePayerSignature": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -411,11 +452,11 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -432,6 +473,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -449,7 +491,6 @@ describe('sendTransaction', () => {
           "data": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -461,6 +502,63 @@ describe('sendTransaction', () => {
         }
       `)
     })
+
+    test('with access key', async () => {
+      const account = accounts[0]
+      const accessKey = Account.fromP256(generatePrivateKey(), {
+        access: account,
+      })
+
+      const keyAuthorization = await account.signKeyAuthorization(accessKey)
+      await account.assignKeyAuthorization(keyAuthorization)
+
+      {
+        const receipt = await client.sendTransactionSync({
+          account: accessKey,
+        })
+        expect(receipt).toBeDefined()
+      }
+
+      {
+        const receipt = await client.sendTransactionSync({
+          account: accessKey,
+          to: '0x0000000000000000000000000000000000000000',
+        })
+        expect(receipt).toBeDefined()
+      }
+    })
+
+    test('with access key + fee payer', async () => {
+      const account = Account.fromP256(
+        // unfunded account with different key
+        '0x1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b',
+      )
+      const accessKey = Account.fromP256(generatePrivateKey(), {
+        access: account,
+      })
+      const feePayer = accounts[0]
+
+      const keyAuthorization = await account.signKeyAuthorization(accessKey)
+      await account.assignKeyAuthorization(keyAuthorization)
+
+      {
+        const receipt = await client.sendTransactionSync({
+          account: accessKey,
+          feePayer,
+          to: '0x0000000000000000000000000000000000000000',
+        })
+        expect(receipt).toBeDefined()
+      }
+
+      {
+        const receipt = await client.sendTransactionSync({
+          account: accessKey,
+          feePayer,
+          to: '0x0000000000000000000000000000000000000000',
+        })
+        expect(receipt).toBeDefined()
+      }
+    })
   })
 
   describe('webcrypto', () => {
@@ -484,11 +582,11 @@ describe('sendTransaction', () => {
         from,
         gasPrice,
         hash,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -505,6 +603,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -524,7 +623,6 @@ describe('sendTransaction', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "gas": 29012n,
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -567,7 +665,6 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
@@ -612,7 +709,6 @@ describe('sendTransaction', () => {
         from,
         gasPrice,
         hash: hash_,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
@@ -633,6 +729,35 @@ describe('sendTransaction', () => {
       expect(signature).toBeDefined()
       expect(transaction).toBeDefined()
     })
+
+    test('with access key', async () => {
+      const keyPair = await WebCryptoP256.createKeyPair()
+      const account = Account.fromWebCryptoP256(keyPair)
+      const accessKey = Account.fromWebCryptoP256(keyPair, {
+        access: account,
+      })
+
+      // fund account
+      await fundAddress(client, { address: account.address })
+
+      const keyAuthorization = await account.signKeyAuthorization(accessKey)
+      await account.assignKeyAuthorization(keyAuthorization)
+
+      {
+        const receipt = await client.sendTransactionSync({
+          account: accessKey,
+        })
+        expect(receipt).toBeDefined()
+      }
+
+      {
+        const receipt = await client.sendTransactionSync({
+          account: accessKey,
+          to: '0x0000000000000000000000000000000000000000',
+        })
+        expect(receipt).toBeDefined()
+      }
+    })
   })
 
   describe('webAuthn', () => {
@@ -662,11 +787,11 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -684,6 +809,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -702,7 +828,6 @@ describe('sendTransaction', () => {
           "feePayerSignature": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -750,11 +875,11 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -773,6 +898,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -784,7 +910,6 @@ describe('sendTransaction', () => {
           "feePayerSignature": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -824,11 +949,11 @@ describe('sendTransaction', () => {
         gas,
         gasPrice,
         hash: hash_,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -845,6 +970,7 @@ describe('sendTransaction', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -862,7 +988,6 @@ describe('sendTransaction', () => {
           "data": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -874,6 +999,96 @@ describe('sendTransaction', () => {
         }
       `)
     })
+
+    test('with access key', async () => {
+      const account = Account.fromHeadlessWebAuthn(
+        '0x6a3086fb3f2f95a3f36ef5387d18151ff51dc98a1e0eb987b159ba196beb0c99',
+        {
+          rpId: 'localhost',
+          origin: 'http://localhost',
+        },
+      )
+      const accessKey = Account.fromP256(generatePrivateKey(), {
+        access: account,
+      })
+
+      // fund account
+      await fundAddress(client, { address: account.address })
+
+      const keyAuthorization = await account.signKeyAuthorization(accessKey)
+      await account.assignKeyAuthorization(keyAuthorization)
+
+      {
+        const receipt = await client.sendTransactionSync({
+          account: accessKey,
+        })
+        expect(receipt).toBeDefined()
+      }
+
+      {
+        const receipt = await client.sendTransactionSync({
+          account: accessKey,
+          to: '0x0000000000000000000000000000000000000000',
+        })
+        expect(receipt).toBeDefined()
+      }
+    })
+  })
+
+  test('behavior: 2d nonces', async () => {
+    const account = accounts[0]
+
+    // fund account
+    await fundAddress(client, { address: account.address })
+
+    const receipts = await Promise.all([
+      client.sendTransactionSync({
+        account,
+        nonceKey: 'random',
+        to: '0x0000000000000000000000000000000000000000',
+      }),
+      client.sendTransactionSync({
+        account,
+        nonceKey: 'random',
+        to: '0x0000000000000000000000000000000000000000',
+      }),
+    ])
+
+    expect(receipts[0].status).toBe('success')
+    expect(receipts[1].status).toBe('success')
+    expect(receipts[0].transactionHash).not.toBe(receipts[1].transactionHash)
+  })
+
+  test('behavior: 2d nonces (implicit)', async () => {
+    const account = accounts[0]
+
+    // fund account
+    await fundAddress(client, { address: account.address })
+
+    const receipts = await Promise.all([
+      client.sendTransactionSync({
+        account,
+        to: '0x0000000000000000000000000000000000000000',
+      }),
+      client.sendTransactionSync({
+        account,
+        to: '0x0000000000000000000000000000000000000000',
+      }),
+      client.sendTransactionSync({
+        account,
+        to: '0x0000000000000000000000000000000000000000',
+      }),
+    ])
+
+    const transactions = await Promise.all([
+      client.getTransaction({ hash: receipts[0].transactionHash }),
+      client.getTransaction({ hash: receipts[1].transactionHash }),
+      client.getTransaction({ hash: receipts[2].transactionHash }),
+    ])
+
+    expect(transactions[0].nonceKey).toBe(0n)
+    expect(transactions[1].nonceKey).toBeGreaterThan(0n)
+    expect(transactions[2].nonceKey).toBeGreaterThan(0n)
   })
 })
 
@@ -889,6 +1104,7 @@ describe('signTransaction', () => {
       account,
       data: '0xdeadbeef',
       feePayer: true,
+      parameters: defaultPrepareTransactionRequestParameters,
       to: '0xcafebabecafebabecafebabecafebabecafebabe',
     })
     let transaction = await client.signTransaction(request as never)
@@ -912,11 +1128,11 @@ describe('signTransaction', () => {
       from,
       gasPrice,
       hash: hash_,
-      // @ts-expect-error
       keyAuthorization: __,
       maxFeePerGas,
       maxPriorityFeePerGas,
       nonce,
+      nonceKey,
       signature,
       transactionIndex,
       ...transaction2
@@ -932,6 +1148,7 @@ describe('signTransaction', () => {
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(nonce).toBeDefined()
+    expect(nonceKey).toBeDefined()
     expect(signature).toBeDefined()
     expect(transactionIndex).toBeDefined()
     expect(transaction2).toMatchInlineSnapshot(`
@@ -950,7 +1167,6 @@ describe('signTransaction', () => {
         "feeToken": "0x20c0000000000000000000000000000000000001",
         "gas": 24002n,
         "maxFeePerBlobGas": undefined,
-        "nonceKey": 0n,
         "to": null,
         "type": "aa",
         "typeHex": "0x76",
@@ -966,11 +1182,7 @@ describe('signTransaction', () => {
 
 describe('relay', () => {
   const client = getClient({
-    transport: withFeePayer(
-      http(undefined, { fetchOptions }),
-      http('http://localhost:3050'),
-      { policy: 'sign-and-broadcast' },
-    ),
+    transport: withFeePayer(http(), http('http://localhost:3050')),
   })
     .extend(tempoActions())
     .extend(walletActions)
@@ -1067,7 +1279,6 @@ describe('relay', () => {
 
       const { receipt } = await client.fee.setUserTokenSync({
         account,
-        maxFeePerGas: parseGwei('20'),
         feePayer: true,
         token: 1n,
       })
@@ -1089,11 +1300,11 @@ describe('relay', () => {
         gas,
         gasPrice,
         hash,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -1110,6 +1321,7 @@ describe('relay', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -1127,7 +1339,6 @@ describe('relay', () => {
           "data": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -1139,6 +1350,56 @@ describe('relay', () => {
         }
       `)
     })
+
+    test('behavior: 2d nonces', async () => {
+      const account = privateKeyToAccount(
+        // unfunded PK
+        '0xecc3fe55647412647e5c6b657c496803b08ef956f927b7a821da298cfbdd9666',
+      )
+
+      const receipts = await Promise.all([
+        client.sendTransactionSync({
+          account,
+          feePayer: true,
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        client.sendTransactionSync({
+          account,
+          feePayer: true,
+          to: '0x0000000000000000000000000000000000000001',
+        }),
+        client.sendTransactionSync({
+          account,
+          feePayer: true,
+          to: '0x0000000000000000000000000000000000000002',
+        }),
+      ])
+
+      expect(receipts.every((receipt) => receipt.status === 'success')).toBe(
+        true,
+      )
+    })
+
+    test('behavior: policy: sign-and-broadcast', async () => {
+      const client = getClient({
+        transport: withFeePayer(http(), http('http://localhost:3050'), {
+          policy: 'sign-and-broadcast',
+        }),
+      }).extend(tempoActions())
+
+      // unfunded account that needs sponsorship
+      const account = privateKeyToAccount(
+        '0xecc3fe55647412647e5c6b657c496803b08ef956f927b7a821da298cfbdd9666',
+      )
+
+      const { receipt } = await client.fee.setUserTokenSync({
+        account,
+        feePayer: true,
+        token: 1n,
+      })
+
+      expect(receipt.status).toBe('success')
+    })
   })
 
   describe('p256', () => {
@@ -1170,11 +1431,11 @@ describe('relay', () => {
         gas,
         gasPrice,
         hash,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -1191,6 +1452,7 @@ describe('relay', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -1208,7 +1470,6 @@ describe('relay', () => {
           "data": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -1282,11 +1543,11 @@ describe('relay', () => {
         gas,
         gasPrice,
         hash,
-        // @ts-expect-error
         keyAuthorization: __,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
+        nonceKey,
         signature,
         transactionIndex,
         ...transaction
@@ -1303,6 +1564,7 @@ describe('relay', () => {
       expect(maxFeePerGas).toBeDefined()
       expect(maxPriorityFeePerGas).toBeDefined()
       expect(nonce).toBeDefined()
+      expect(nonceKey).toBeDefined()
       expect(signature).toBeDefined()
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
@@ -1320,7 +1582,6 @@ describe('relay', () => {
           "data": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
-          "nonceKey": 0n,
           "to": null,
           "type": "aa",
           "typeHex": "0x76",
@@ -1333,62 +1594,4 @@ describe('relay', () => {
       `)
     })
   })
-
-  describe('policy: sign-only', () => {
-    test('relay co-signs and transport auto-submits', async () => {
-      const signClient = getClient({
-        transport: withFeePayer(
-          http(undefined, { fetchOptions }),
-          http('http://localhost:3050'),
-          { policy: 'sign-only' },
-        ),
-      })
-        .extend(tempoActions())
-        .extend(walletActions)
-        .extend(publicActions)
-
-      // unfunded account that needs sponsorship
-      const account = privateKeyToAccount(
-        '0xecc3fe55647412647e5c6b657c496803b08ef956f927b7a821da298cfbdd9666',
-      )
-
-      // With 'sign-only' policy, the relay co-signs and the transport auto-submits
-      const { user, token, receipt } = await signClient.fee.setUserTokenSync({
-        account,
-        feePayer: true,
-        token: 1n,
-      })
-
-      // Verify the action returned the expected values
-      expect(user).toBe(account.address)
-      expect(token).toBe('0x20C0000000000000000000000000000000000001')
-      expect(receipt).toBeDefined()
-
-      // Verify the transaction was successfully executed
-      const userToken = await signClient.fee.getUserToken({
-        account: account.address,
-      })
-      expect(userToken?.id).toBe(1n)
-
-      const {
-        feePayerSignature,
-        from,
-        gas,
-        gasPrice,
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-        signature,
-      } = (await signClient.getTransaction({
-        hash: receipt.transactionHash,
-      })) as any
-
-      expect(feePayerSignature).toBeDefined()
-      expect(from).toBe(account.address.toLowerCase())
-      expect(gas).toBeDefined()
-      expect(gasPrice).toBeDefined()
-      expect(maxFeePerGas).toBeDefined()
-      expect(maxPriorityFeePerGas).toBeDefined()
-      expect(signature).toBeDefined()
-    })
-  })
 })