tempo.ts 0.7.6 → 0.8.1

package/src/viem/Actions/reward.ts

@@ -276,6 +276,79 @@ export namespace getTotalPerSecond {
   }
 }
 
+/**
+ * Gets the reward information for a specific account.
+ *
+ * Returns the reward recipient address, reward per token value, and accumulated reward balance for the specified account.
+ * This information includes:
+ * - `rewardRecipient`: The address designated to receive rewards (zero address if opted out)
+ * - `rewardPerToken`: The reward per token value for this account
+ * - `rewardBalance`: The accumulated reward balance waiting to be claimed
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const info = await Actions.reward.getUserRewardInfo(client, {
+ *   token: '0x20c0000000000000000000000000000000000001',
+ *   account: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The user's reward information (recipient, rewardPerToken, rewardBalance).
+ */
+export async function getUserRewardInfo<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: getUserRewardInfo.Parameters,
+): Promise<getUserRewardInfo.ReturnValue> {
+  return readContract(client, {
+    ...parameters,
+    ...getUserRewardInfo.call(parameters),
+  })
+}
+
+export namespace getUserRewardInfo {
+  export type Parameters = ReadParameters & Args
+
+  export type Args = {
+    /** The account address to query reward info for */
+    account: Address
+    /** The TIP20 token address */
+    token: Address
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.tip20,
+    'userRewardInfo',
+    never
+  >
+
+  /**
+   * Defines a call to the `userRewardInfo` function.
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { account, token } = args
+    return defineCall({
+      address: token,
+      abi: Abis.tip20,
+      args: [account],
+      functionName: 'userRewardInfo',
+    })
+  }
+}
+
 /**
  * Sets or changes the reward recipient for a token holder.
  *

package/src/viem/Actions/token.test.ts

@@ -349,7 +349,7 @@ describe('getMetadata', () => {
         "name": "Test USD",
         "paused": false,
         "quoteToken": "0x20C0000000000000000000000000000000000000",
-        "supplyCap": 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+        "supplyCap": 340282366920938463463374607431768211455n,
         "symbol": "TUSD",
         "totalSupply": 0n,
         "transferPolicyId": 1n,
@@ -360,15 +360,15 @@ describe('getMetadata', () => {
   test('behavior: quote token', async () => {
     {
       const metadata = await actions.token.getMetadata(clientWithAccount, {
-        token: TokenIds.linkingUsd,
+        token: TokenIds.pathUsd,
       })
 
       expect(metadata).toMatchInlineSnapshot(`
         {
           "currency": "USD",
           "decimals": 6,
-          "name": "linkingUSD",
-          "symbol": "linkingUSD",
+          "name": "pathUSD",
+          "symbol": "pathUSD",
           "totalSupply": 18446744073709551615n,
         }
       `)
@@ -376,15 +376,15 @@ describe('getMetadata', () => {
 
     {
       const metadata = await actions.token.getMetadata(clientWithAccount, {
-        token: Addresses.linkingUsd,
+        token: Addresses.pathUsd,
       })
 
       expect(metadata).toMatchInlineSnapshot(`
         {
           "currency": "USD",
           "decimals": 6,
-          "name": "linkingUSD",
-          "symbol": "linkingUSD",
+          "name": "pathUSD",
+          "symbol": "pathUSD",
           "totalSupply": 18446744073709551615n,
         }
       `)
@@ -409,7 +409,7 @@ describe('getMetadata', () => {
         "name": "Test USD",
         "paused": false,
         "quoteToken": "0x20C0000000000000000000000000000000000000",
-        "supplyCap": 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+        "supplyCap": 340282366920938463463374607431768211455n,
         "symbol": "TUSD",
         "totalSupply": 0n,
         "transferPolicyId": 1n,

package/src/viem/Actions/token.ts

@@ -998,7 +998,7 @@ export namespace create {
       name,
       symbol,
       currency,
-      quoteToken = Addresses.linkingUsd,
+      quoteToken = Addresses.pathUsd,
       admin,
     } = args
     return defineCall({
@@ -1285,7 +1285,7 @@ export async function getMetadata<chain extends Chain | undefined>(
   const address = TokenId.toAddress(token)
   const abi = Abis.tip20
 
-  if (TokenId.from(token) === TokenId.fromAddress(Addresses.linkingUsd))
+  if (TokenId.from(token) === TokenId.fromAddress(Addresses.pathUsd))
     return multicall(client, {
       ...rest,
       contracts: [

package/src/viem/Addresses.ts

@@ -2,7 +2,7 @@ export const accountImplementation =
   '0x7702c00000000000000000000000000000000000'
 export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
 export const feeManager = '0xfeec000000000000000000000000000000000000'
-export const linkingUsd = '0x20c0000000000000000000000000000000000000'
+export const pathUsd = '0x20c0000000000000000000000000000000000000'
 export const stablecoinExchange = '0xdec0000000000000000000000000000000000000'
 export const tip20Factory = '0x20fc000000000000000000000000000000000000'
 export const tip403Registry = '0x403c000000000000000000000000000000000000'

package/src/viem/Chain.test.ts

@@ -0,0 +1,168 @@
+import {
+  getTransaction,
+  prepareTransactionRequest,
+  sendTransactionSync,
+} from 'viem/actions'
+import { describe, expect, test, vi } from 'vitest'
+import { chain, client, clientWithAccount } from '../../test/viem/config.js'
+
+describe('chain.prepareTransactionRequest', () => {
+  test('behavior: sequential nonce keys for feePayer transactions', async () => {
+    const requests = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    expect((requests[0] as any)?.nonceKey).toBe(0n)
+    expect((requests[1] as any)?.nonceKey).toBeGreaterThan(0n)
+    expect((requests[2] as any)?.nonceKey).toBeGreaterThan(0n)
+  })
+
+  test('behavior: nonce key counter resets after event loop tick', async () => {
+    const requests1 = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    expect((requests1[0] as any)?.nonceKey).toBe(0n)
+    expect((requests1[1] as any)?.nonceKey).toBeGreaterThan(0n)
+
+    // Wait for microtask queue to flush
+    await new Promise((resolve) => queueMicrotask(() => resolve(undefined)))
+
+    const requests2 = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    // Counter should have reset
+    expect((requests2[0] as any)?.nonceKey).toBe(0n)
+    expect((requests2[1] as any)?.nonceKey).toBeGreaterThan(0n)
+  })
+
+  test('behavior: explicit nonceKey overrides counter', async () => {
+    const requests = await Promise.all([
+      chain.prepareTransactionRequest({
+        feePayer: true,
+        nonceKey: 42n,
+      } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({
+        feePayer: true,
+        nonceKey: 100n,
+      } as never),
+    ])
+
+    expect((requests[0] as any)?.nonceKey).toBe(42n)
+    expect((requests[1] as any)?.nonceKey).toBe(0n)
+    expect((requests[2] as any)?.nonceKey).toBe(100n)
+  })
+
+  test('behavior: default nonceKey when feePayer is not true', async () => {
+    const request = await chain.prepareTransactionRequest({} as never)
+    expect((request as any)?.nonceKey).toBe(0n)
+  })
+
+  test('behavior: nonce with sequential nonceKey', async () => {
+    const requests = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never), // nonceKey: 0n
+      chain.prepareTransactionRequest({ feePayer: true } as never), // nonceKey: 1n
+      chain.prepareTransactionRequest({ feePayer: true } as never), // nonceKey: 2n
+    ])
+
+    // Note: 0n is falsy, so first request has nonce undefined
+    expect((requests[0] as any)?.nonce).toBe(undefined)
+    expect((requests[0] as any)?.nonceKey).toBe(0n)
+
+    // nonceKey >= 1n is truthy, so nonce is 0
+    expect((requests[1] as any)?.nonce).toBe(0)
+    expect((requests[1] as any)?.nonceKey).toBeGreaterThan(0n)
+
+    expect((requests[2] as any)?.nonce).toBe(0)
+    expect((requests[2] as any)?.nonceKey).toBeGreaterThan(0n)
+  })
+
+  test('behavior: explicit nonce is preserved', async () => {
+    const request = await chain.prepareTransactionRequest({
+      feePayer: true,
+      nonce: 123,
+    } as never)
+    expect((request as any)?.nonce).toBe(123)
+    expect((request as any)?.nonceKey).toBe(0n)
+  })
+
+  test('behavior: default nonceKey is 0n (falsy)', async () => {
+    const request = await chain.prepareTransactionRequest({} as never)
+    expect((request as any)?.nonceKey).toBe(0n)
+    expect((request as any)?.nonce).toBe(undefined)
+  })
+
+  test('behavior: resetScheduled optimization - only one microtask scheduled', async () => {
+    const queueMicrotaskSpy = vi.spyOn(globalThis, 'queueMicrotask')
+    const callCountBefore = queueMicrotaskSpy.mock.calls.length
+
+    // Prepare multiple transactions in parallel
+    await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    const callCountAfter = queueMicrotaskSpy.mock.calls.length
+
+    // Only one microtask should have been scheduled for the reset
+    expect(callCountAfter - callCountBefore).toBe(1)
+
+    queueMicrotaskSpy.mockRestore()
+  })
+
+  describe('e2e', async () => {
+    test('behavior: prepareTransactionRequest', async () => {
+      const [request, request2, request3] = await Promise.all([
+        prepareTransactionRequest(client, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        prepareTransactionRequest(client, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        prepareTransactionRequest(client, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+      ])
+      expect(request.nonceKey).toBe(0n)
+      expect(request2.nonceKey).toBeGreaterThan(0n)
+      expect(request3.nonceKey).toBeGreaterThan(0n)
+    })
+
+    test('behavior: sendTransaction', async () => {
+      const receipts = await Promise.all([
+        sendTransactionSync(clientWithAccount, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        sendTransactionSync(clientWithAccount, {
+          to: '0x0000000000000000000000000000000000000001',
+        }),
+        sendTransactionSync(clientWithAccount, {
+          to: '0x0000000000000000000000000000000000000002',
+        }),
+      ])
+      const transactions = await Promise.all([
+        getTransaction(clientWithAccount, {
+          hash: receipts[0].transactionHash,
+        }),
+        getTransaction(clientWithAccount, {
+          hash: receipts[1].transactionHash,
+        }),
+        getTransaction(clientWithAccount, {
+          hash: receipts[2].transactionHash,
+        }),
+      ])
+      expect(transactions[0].nonceKey).toBe(0n)
+      expect(transactions[1].nonceKey).toBeGreaterThan(0n)
+      expect(transactions[2].nonceKey).toBeGreaterThan(0n)
+    })
+  })
+})

package/src/viem/Chain.ts

@@ -1,3 +1,4 @@
+import * as Hex from 'ox/Hex'
 import {
   defineTransaction,
   defineTransactionReceipt,
@@ -25,6 +26,25 @@ export type Chain<
       })
 
 function config<const chain extends Chain>(chain: chain) {
+  const nonceKeyManager = {
+    counter: 0,
+    resetScheduled: false,
+    reset() {
+      this.counter = 0
+      this.resetScheduled = false
+    },
+    get() {
+      if (!this.resetScheduled) {
+        this.resetScheduled = true
+        queueMicrotask(() => this.reset())
+      }
+      const count = this.counter
+      this.counter++
+      if (count === 0) return 0n
+      return Hex.toBigInt(Hex.random(6))
+    },
+  }
+
   return {
     blockTime: 1_000,
     contracts: {
@@ -66,6 +86,22 @@ function config<const chain extends Chain>(chain: chain) {
           ),
       }),
     },
+    async prepareTransactionRequest(r) {
+      const request = r as Transaction.TransactionRequest
+      const nonceKey = (() => {
+        if (typeof request.nonceKey !== 'undefined') return request.nonceKey
+        return nonceKeyManager.get()
+      })()
+
+      const nonce = (() => {
+        if (typeof request.nonce === 'number') return request.nonce
+        // TODO: remove this line once `eth_fillTransaction` supports nonce keys.
+        if (nonceKey) return 0
+        return undefined
+      })()
+
+      return { ...request, nonce, nonceKey } as unknown as typeof r
+    },
     serializers: {
       // TODO: casting to satisfy viem – viem v3 to have more flexible serializer type.
       transaction: ((transaction, signature) =>
@@ -88,7 +124,7 @@ function config<const chain extends Chain>(chain: chain) {
         )) as SerializeTransactionFn,
     },
     ...chain,
-  } as const
+  } as const satisfies viem_Chain
 }
 
 export function define<const chain extends viem_Chain>(

package/src/viem/Decorator.ts

@@ -1591,6 +1591,60 @@ export type Decorator<
     ) => () => void
   }
   reward: {
+    /**
+     * Claims accumulated rewards for a recipient.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { tempoActions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const hash = await client.reward.claim({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    claim: (
+      parameters: rewardActions.claim.Parameters<chain, account>,
+    ) => Promise<rewardActions.claim.ReturnValue>
+    /**
+     * Claims accumulated rewards for a recipient and waits for confirmation.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { tempoActions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const result = await client.reward.claimSync({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The amount claimed and transaction receipt.
+     */
+    claimSync: (
+      parameters: rewardActions.claimSync.Parameters<chain, account>,
+    ) => Promise<rewardActions.claimSync.ReturnValue>
     /**
      * Gets the total reward per second rate for all active streams.
      *
@@ -1616,6 +1670,32 @@ export type Decorator<
     getTotalPerSecond: (
       parameters: rewardActions.getTotalPerSecond.Parameters,
     ) => Promise<rewardActions.getTotalPerSecond.ReturnValue>
+    /**
+     * Gets the reward information for a specific account.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { tempoActions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const info = await client.reward.getUserRewardInfo({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     *   account: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The user's reward information (recipient, rewardPerToken, rewardBalance).
+     */
+    getUserRewardInfo: (
+      parameters: rewardActions.getUserRewardInfo.Parameters,
+    ) => Promise<rewardActions.getUserRewardInfo.ReturnValue>
     /**
      * Sets or changes the reward recipient for a token holder.
      *
@@ -2986,8 +3066,12 @@ export function decorator() {
           policyActions.watchBlacklistUpdated(client, parameters),
       },
       reward: {
+        claim: (parameters) => rewardActions.claim(client, parameters),
+        claimSync: (parameters) => rewardActions.claimSync(client, parameters),
         getTotalPerSecond: (parameters) =>
           rewardActions.getTotalPerSecond(client, parameters),
+        getUserRewardInfo: (parameters) =>
+          rewardActions.getUserRewardInfo(client, parameters),
         setRecipient: (parameters) =>
           rewardActions.setRecipient(client, parameters),
         setRecipientSync: (parameters) =>

package/src/viem/Formatters.ts

@@ -12,6 +12,7 @@ import { parseAccount } from 'viem/accounts'
 import type { UnionOmit } from '../internal/types.js'
 import * as ox_Transaction from '../ox/Transaction.js'
 import * as ox_TransactionRequest from '../ox/TransactionRequest.js'
+import type { Account } from './Account.js'
 import type { GetFeeTokenParameter } from './internal/types.js'
 import {
   isTempo,
@@ -77,6 +78,7 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   action?: string | undefined,
 ): TransactionRequestRpc {
   const request = r as Request<chain>
+  const account = request.account as Account | undefined
 
   // Convert EIP-1559 transactions to AA transactions.
   if (request.type === 'eip1559') (request as any).type = 'aa'
@@ -91,7 +93,7 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   if (action)
     request.calls = request.calls ?? [
       {
-        to: r.to || undefined,
+        to: r.to || '0x0000000000000000000000000000000000000000',
         value: r.value,
         data: r.data,
       },
@@ -106,11 +108,10 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
       s: BigInt(auth.s!),
       yParity: Number(auth.yParity),
     })),
-    nonce: request.nonce ? BigInt(request.nonce) : undefined,
     type: 'aa',
   } as never)
 
-  if (action === 'estimateGas' || action === 'fillTransaction') {
+  if (action === 'estimateGas') {
     rpc.maxFeePerGas = undefined
     rpc.maxPriorityFeePerGas = undefined
   }
@@ -140,12 +141,12 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   }
 
   const [keyType, keyData] = (() => {
-    if (!r.account?.source) return [undefined, undefined]
-    if (r.account.source === 'webAuthn')
+    const type = account?.keyType || account?.source
+    if (!type) return [undefined, undefined]
+    if (type === 'webAuthn')
       // TODO: derive correct bytes size of key data based on webauthn create metadata.
       return ['webAuthn', `0x${'ff'.repeat(1400)}`]
-    if (['p256', 'secp256k1'].includes(r.account.source))
-      return [r.account.source, undefined]
+    if (['p256', 'secp256k1'].includes(type)) return [type, undefined]
     return [undefined, undefined]
   })()
 

package/src/viem/Storage.ts

@@ -1,6 +1,8 @@
+import { createStore, del, get, set } from 'idb-keyval'
 import * as Json from 'ox/Json'
 
 import type { MaybePromise } from '../internal/types.js'
+import { normalizeValue } from './internal/utils.js'
 
 export type Storage<
   schema extends Record<string, unknown> = Record<string, unknown>,
@@ -33,6 +35,26 @@ export namespace from {
   }
 }
 
+export function idb<schema extends Record<string, unknown>>() {
+  const store =
+    typeof indexedDB !== 'undefined'
+      ? createStore('tempo.ts', 'store')
+      : undefined
+  return from<schema>({
+    async getItem(name) {
+      const value = await get(name, store)
+      if (value === null) return null
+      return value
+    },
+    async removeItem(name) {
+      await del(name, store)
+    },
+    async setItem(name, value) {
+      await set(name, normalizeValue(value), store)
+    },
+  })
+}
+
 export function localStorage<schema extends Record<string, unknown>>(
   options: localStorage.Options = {},
 ) {

package/src/viem/TokenIds.ts

@@ -1 +1 @@
-export const linkingUsd = 0n
+export const pathUsd = 0n

package/src/viem/Transaction.ts

@@ -29,6 +29,7 @@ import {
   type TransactionType as viem_TransactionType,
 } from 'viem'
 import type { ExactPartial, OneOf, PartialBy } from '../internal/types.js'
+import type * as KeyAuthorization from '../ox/KeyAuthorization.js'
 import * as SignatureEnvelope from '../ox/SignatureEnvelope.js'
 import * as TxAA from '../ox/TransactionEnvelopeAA.js'
 import type * as ox_TransactionReceipt from '../ox/TransactionReceipt.js'
@@ -43,7 +44,11 @@ export type Transaction<
 >
 export type TransactionRpc<pending extends boolean = false> = OneOf<
   | viem_RpcTransaction<pending>
-  | (Omit<TransactionAA<Hex.Hex, Hex.Hex, pending, '0x76'>, 'signature'> & {
+  | (Omit<
+      TransactionAA<Hex.Hex, Hex.Hex, pending, '0x76'>,
+      'keyAuthorization' | 'signature'
+    > & {
+      keyAuthorization?: KeyAuthorization.Rpc | null | undefined
       signature: SignatureEnvelope.SignatureEnvelopeRpc
     })
 >
@@ -66,6 +71,7 @@ export type TransactionAA<
   chainId: index
   feeToken?: Address | undefined
   feePayerSignature?: viem_Signature | undefined
+  keyAuthorization?: KeyAuthorization.Signed<quantity, index> | null | undefined
   nonceKey?: quantity | undefined
   signature: SignatureEnvelope.SignatureEnvelope
   type: type
@@ -109,9 +115,13 @@ export type TransactionRequestAA<
   ExactPartial<FeeValuesEIP1559<quantity>> & {
     accessList?: AccessList | undefined
     authorizationList?: AuthorizationList<index, boolean> | undefined
+    keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
     calls?: readonly TxAA.Call<quantity>[] | undefined
     feePayer?: Account | true | undefined
     feeToken?: Address | bigint | undefined
+    nonceKey?: 'random' | quantity | undefined
+    validBefore?: index | undefined
+    validAfter?: index | undefined
   }
 
 export type TransactionSerializable = OneOf<
@@ -129,6 +139,7 @@ export type TransactionSerializableAA<
     chainId: number
     feeToken?: Address | bigint | undefined
     feePayerSignature?: viem_Signature | null | undefined
+    keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
     nonceKey?: quantity | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<quantity, index> | undefined
     validBefore?: index | undefined
@@ -151,6 +162,7 @@ export function getType(
     typeof transaction.calls !== 'undefined' ||
     typeof transaction.feePayer !== 'undefined' ||
     typeof transaction.feeToken !== 'undefined' ||
+    typeof transaction.nonceKey !== 'undefined' ||
     typeof transaction.signature !== 'undefined' ||
     typeof transaction.validBefore !== 'undefined' ||
     typeof transaction.validAfter !== 'undefined'
@@ -303,7 +315,7 @@ async function serializeAA(
       ? rest.calls
       : [
           {
-            to: rest.to || undefined,
+            to: rest.to || '0x0000000000000000000000000000000000000000',
             value: rest.value,
             data: rest.data,
           },