tempo.ts 0.10.2 → 0.10.3

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

@@ -0,0 +1,193 @@
+import { setTimeout } from 'node:timers/promises'
+import { afterEach, describe, expect, test } from 'vitest'
+import { rpcUrl } from '../../../test/config.js'
+import { accounts, clientWithAccount } from '../../../test/viem/config.js'
+import * as actions from './index.js'
+
+const account = accounts[0]
+const account2 = accounts[1]
+
+afterEach(async () => {
+  await fetch(`${rpcUrl}/restart`)
+})
+
+describe('getNonce', () => {
+  test('default', async () => {
+    // Get nonce for an account with previously unused noncekey
+    const nonce = await actions.nonce.getNonce(clientWithAccount, {
+      account: account.address,
+      nonceKey: 1n,
+    })
+
+    expect(nonce).toBe(1n)
+  })
+
+  test('behavior: different nonce keys are independent', async () => {
+    let nonce1 = await actions.nonce.getNonce(clientWithAccount, {
+      account: account.address,
+      nonceKey: 1n,
+    })
+    let nonce2 = await actions.nonce.getNonce(clientWithAccount, {
+      account: account.address,
+      nonceKey: 2n,
+    })
+
+    expect(nonce1).toBe(1n)
+    expect(nonce2).toBe(1n)
+
+    await actions.token.transferSync(clientWithAccount, {
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 2n,
+    })
+
+    nonce1 = await actions.nonce.getNonce(clientWithAccount, {
+      account: account.address,
+      nonceKey: 1n,
+    })
+    nonce2 = await actions.nonce.getNonce(clientWithAccount, {
+      account: account.address,
+      nonceKey: 2n,
+    })
+
+    // nonceKey 2 should be incremented to 2
+    expect(nonce1).toBe(1n)
+    expect(nonce2).toBe(2n)
+  })
+
+  test('behavior: different accounts are independent', async () => {
+    const nonce1 = await actions.nonce.getNonce(clientWithAccount, {
+      account: account.address,
+      nonceKey: 1n,
+    })
+    const nonce2 = await actions.nonce.getNonce(clientWithAccount, {
+      account: account2.address,
+      nonceKey: 1n,
+    })
+
+    // Both should return bigint values
+    expect(nonce1).toBe(1n)
+    expect(nonce2).toBe(1n)
+  })
+})
+
+describe('getNonceKeyCount', () => {
+  test('default', async () => {
+    // Get active nonce key count for a fresh account
+    const count = await actions.nonce.getNonceKeyCount(clientWithAccount, {
+      account: account.address,
+    })
+
+    // Fresh account should have 0 active nonce keys
+    expect(count).toBe(0n)
+  })
+
+  test('behavior: different accounts are independent', async () => {
+    const count1 = await actions.nonce.getNonceKeyCount(clientWithAccount, {
+      account: account.address,
+    })
+    const count2 = await actions.nonce.getNonceKeyCount(clientWithAccount, {
+      account: account2.address,
+    })
+
+    // Both should be 0 for fresh accounts
+    expect(count1).toBe(0n)
+    expect(count2).toBe(0n)
+  })
+})
+
+describe('watchNonceIncremented', () => {
+  test('default', async () => {
+    const events: Array<{
+      args: actions.nonce.watchNonceIncremented.Args
+      log: actions.nonce.watchNonceIncremented.Log
+    }> = []
+
+    const unwatch = actions.nonce.watchNonceIncremented(clientWithAccount, {
+      onNonceIncremented: (args, log) => {
+        events.push({ args, log })
+      },
+      args: {
+        account: account.address,
+        nonceKey: 5n,
+      },
+    })
+
+    try {
+      // Have to manually set nonce because eth_FillTransaction does not support nonce keys
+      await actions.token.transferSync(clientWithAccount, {
+        to: account2.address,
+        amount: 1n,
+        token: 1n,
+        nonceKey: 5n,
+        nonce: 0,
+      })
+
+      await actions.token.transferSync(clientWithAccount, {
+        to: account2.address,
+        amount: 1n,
+        token: 1n,
+        nonceKey: 5n,
+        nonce: 1,
+      })
+
+      await setTimeout(1000)
+
+      expect(events).toHaveLength(2)
+      expect(events[0]!.args.account).toBe(account.address)
+      expect(events[0]!.args.nonceKey).toBe(5n)
+      expect(events[0]!.args.newNonce).toBe(1n)
+      expect(events[1]!.args.newNonce).toBe(2n)
+    } finally {
+      unwatch()
+    }
+  })
+})
+
+describe('watchActiveKeyCountChanged', () => {
+  test('default', async () => {
+    const events: Array<{
+      args: actions.nonce.watchActiveKeyCountChanged.Args
+      log: actions.nonce.watchActiveKeyCountChanged.Log
+    }> = []
+
+    const unwatch = actions.nonce.watchActiveKeyCountChanged(
+      clientWithAccount,
+      {
+        onActiveKeyCountChanged: (args, log) => {
+          events.push({ args, log })
+        },
+      },
+    )
+
+    try {
+      // First use of nonceKey 10 should increment active key count
+      await actions.token.transferSync(clientWithAccount, {
+        to: account2.address,
+        amount: 1n,
+        token: 1n,
+        nonceKey: 10n,
+        nonce: 0,
+      })
+
+      // First use of nonceKey 11 should increment again
+      await actions.token.transferSync(clientWithAccount, {
+        to: account2.address,
+        amount: 1n,
+        token: 1n,
+        nonceKey: 11n,
+        nonce: 0,
+      })
+
+      await setTimeout(1000)
+
+      expect(events).toHaveLength(2)
+      expect(events[0]!.args.account).toBe(account.address)
+      expect(events[0]!.args.newCount).toBe(1n)
+      expect(events[1]!.args.newCount).toBe(2n)
+    } finally {
+      unwatch()
+    }
+  })
+})

package/src/viem/Actions/nonce.ts

@@ -0,0 +1,345 @@
+import type {
+  Account,
+  Address,
+  Chain,
+  Client,
+  ExtractAbiItem,
+  GetEventArgs,
+  ReadContractReturnType,
+  Transport,
+  Log as viem_Log,
+  WatchContractEventParameters,
+} from 'viem'
+import { readContract, watchContractEvent } from 'viem/actions'
+import type { UnionOmit } from '../../internal/types.js'
+import * as Abis from '../Abis.js'
+import * as Addresses from '../Addresses.js'
+import type { ReadParameters } from '../internal/types.js'
+import { defineCall } from '../internal/utils.js'
+
+/**
+ * Gets the nonce for an account and nonce key.
+ *
+ * @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 nonce = await Actions.nonce.getNonce(client, {
+ *   account: '0x...',
+ *   nonceKey: 1n,
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The nonce value.
+ */
+export async function getNonce<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: getNonce.Parameters,
+): Promise<getNonce.ReturnValue> {
+  return readContract(client, {
+    ...parameters,
+    ...getNonce.call(parameters),
+  })
+}
+
+export namespace getNonce {
+  export type Parameters = ReadParameters & Args
+
+  export type Args = {
+    /** Account address. */
+    account: Address
+    /** Nonce key (must be > 0, key 0 is reserved for protocol nonces). */
+    nonceKey: bigint
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.nonce,
+    'getNonce',
+    never
+  >
+
+  /**
+   * Defines a call to the `getNonce` function.
+   *
+   * Can be passed as a parameter to:
+   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
+   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
+   * - [`multicall`](https://viem.sh/docs/contract/multicall): execute multiple calls in parallel
+   *
+   * @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 result = await client.multicall({
+   *   contracts: [
+   *     Actions.nonce.getNonce.call({ account: '0x...', nonceKey: 1n }),
+   *     Actions.nonce.getNonce.call({ account: '0x...', nonceKey: 2n }),
+   *   ],
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { account, nonceKey } = args
+    return defineCall({
+      address: Addresses.nonceManager,
+      abi: Abis.nonce,
+      args: [account, nonceKey],
+      functionName: 'getNonce',
+    })
+  }
+}
+
+/**
+ * Gets the number of active nonce keys for an account.
+ *
+ * @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 count = await Actions.nonce.getNonceKeyCount(client, {
+ *   account: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The number of active nonce keys.
+ */
+export async function getNonceKeyCount<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: getNonceKeyCount.Parameters,
+): Promise<getNonceKeyCount.ReturnValue> {
+  return readContract(client, {
+    ...parameters,
+    ...getNonceKeyCount.call(parameters),
+  })
+}
+
+export namespace getNonceKeyCount {
+  export type Parameters = ReadParameters & Args
+
+  export type Args = {
+    /** Account address. */
+    account: Address
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.nonce,
+    'getActiveNonceKeyCount',
+    never
+  >
+
+  /**
+   * Defines a call to the `getNonceKeyCount` function.
+   *
+   * Can be passed as a parameter to:
+   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
+   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
+   * - [`multicall`](https://viem.sh/docs/contract/multicall): execute multiple calls in parallel
+   *
+   * @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 result = await client.multicall({
+   *   contracts: [
+   *     Actions.nonce.getNonceKeyCount.call({ account: '0x...' }),
+   *     Actions.nonce.getNonceKeyCount.call({ account: '0x...' }),
+   *   ],
+   * })
+   * ```
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { account } = args
+    return defineCall({
+      address: Addresses.nonceManager,
+      abi: Abis.nonce,
+      args: [account],
+      functionName: 'getActiveNonceKeyCount',
+    })
+  }
+}
+
+/**
+ * Watches for nonce incremented events.
+ *
+ * @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 unwatch = Actions.nonce.watchNonceIncremented(client, {
+ *   onNonceIncremented: (args, log) => {
+ *     console.log('Nonce incremented:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchNonceIncremented<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: watchNonceIncremented.Parameters,
+) {
+  const { onNonceIncremented, ...rest } = parameters
+  return watchContractEvent(client, {
+    ...rest,
+    address: Addresses.nonceManager,
+    abi: Abis.nonce,
+    eventName: 'NonceIncremented',
+    onLogs: (logs) => {
+      for (const log of logs) onNonceIncremented(log.args, log)
+    },
+    strict: true,
+  })
+}
+
+export declare namespace watchNonceIncremented {
+  export type Args = GetEventArgs<
+    typeof Abis.nonce,
+    'NonceIncremented',
+    { IndexedOnly: false; Required: true }
+  >
+
+  export type Log = viem_Log<
+    bigint,
+    number,
+    false,
+    ExtractAbiItem<typeof Abis.nonce, 'NonceIncremented'>,
+    true
+  >
+
+  export type Parameters = UnionOmit<
+    WatchContractEventParameters<typeof Abis.nonce, 'NonceIncremented', true>,
+    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
+  > & {
+    /** Callback to invoke when a nonce is incremented. */
+    onNonceIncremented: (args: Args, log: Log) => void
+  }
+}
+
+/**
+ * Watches for active key count changed events.
+ *
+ * @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 unwatch = Actions.nonce.watchActiveKeyCountChanged(client, {
+ *   onActiveKeyCountChanged: (args, log) => {
+ *     console.log('Active key count changed:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchActiveKeyCountChanged<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: watchActiveKeyCountChanged.Parameters,
+) {
+  const { onActiveKeyCountChanged, ...rest } = parameters
+  return watchContractEvent(client, {
+    ...rest,
+    address: Addresses.nonceManager,
+    abi: Abis.nonce,
+    eventName: 'ActiveKeyCountChanged',
+    onLogs: (logs) => {
+      for (const log of logs) onActiveKeyCountChanged(log.args, log)
+    },
+    strict: true,
+  })
+}
+
+export declare namespace watchActiveKeyCountChanged {
+  export type Args = GetEventArgs<
+    typeof Abis.nonce,
+    'ActiveKeyCountChanged',
+    { IndexedOnly: false; Required: true }
+  >
+
+  export type Log = viem_Log<
+    bigint,
+    number,
+    false,
+    ExtractAbiItem<typeof Abis.nonce, 'ActiveKeyCountChanged'>,
+    true
+  >
+
+  export type Parameters = UnionOmit<
+    WatchContractEventParameters<
+      typeof Abis.nonce,
+      'ActiveKeyCountChanged',
+      true
+    >,
+    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
+  > & {
+    /** Callback to invoke when the active key count changes. */
+    onActiveKeyCountChanged: (args: Args, log: Log) => void
+  }
+}

package/src/viem/Addresses.ts

@@ -2,6 +2,7 @@ export const accountImplementation =
   '0x7702c00000000000000000000000000000000000'
 export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
 export const feeManager = '0xfeec000000000000000000000000000000000000'
+export const nonceManager = '0x4e4F4E4345000000000000000000000000000000'
 export const pathUsd = '0x20c0000000000000000000000000000000000000'
 export const stablecoinExchange = '0xdec0000000000000000000000000000000000000'
 export const tip20Factory = '0x20fc000000000000000000000000000000000000'

package/src/viem/Chain.test.ts

@@ -14,7 +14,7 @@ describe('chain.prepareTransactionRequest', () => {
       chain.prepareTransactionRequest({ feePayer: true } as never),
     ])
 
-    expect((requests[0] as any)?.nonceKey).toBe(0n)
+    expect((requests[0] as any)?.nonceKey).toBe(undefined)
     expect((requests[1] as any)?.nonceKey).toBeGreaterThan(0n)
     expect((requests[2] as any)?.nonceKey).toBeGreaterThan(0n)
   })
@@ -25,7 +25,7 @@ describe('chain.prepareTransactionRequest', () => {
       chain.prepareTransactionRequest({ feePayer: true } as never),
     ])
 
-    expect((requests1[0] as any)?.nonceKey).toBe(0n)
+    expect((requests1[0] as any)?.nonceKey).toBe(undefined)
     expect((requests1[1] as any)?.nonceKey).toBeGreaterThan(0n)
 
     // Wait for microtask queue to flush
@@ -37,7 +37,7 @@ describe('chain.prepareTransactionRequest', () => {
     ])
 
     // Counter should have reset
-    expect((requests2[0] as any)?.nonceKey).toBe(0n)
+    expect((requests2[0] as any)?.nonceKey).toBe(undefined)
     expect((requests2[1] as any)?.nonceKey).toBeGreaterThan(0n)
   })
 
@@ -55,13 +55,13 @@ describe('chain.prepareTransactionRequest', () => {
     ])
 
     expect((requests[0] as any)?.nonceKey).toBe(42n)
-    expect((requests[1] as any)?.nonceKey).toBe(0n)
+    expect((requests[1] as any)?.nonceKey).toBe(undefined)
     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)
+    expect((request as any)?.nonceKey).toBe(undefined)
   })
 
   test('behavior: nonce with sequential nonceKey', async () => {
@@ -73,7 +73,7 @@ describe('chain.prepareTransactionRequest', () => {
 
     // 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)
+    expect((requests[0] as any)?.nonceKey).toBe(undefined)
 
     // nonceKey >= 1n is truthy, so nonce is 0
     expect((requests[1] as any)?.nonce).toBe(0)
@@ -89,12 +89,12 @@ describe('chain.prepareTransactionRequest', () => {
       nonce: 123,
     } as never)
     expect((request as any)?.nonce).toBe(123)
-    expect((request as any)?.nonceKey).toBe(0n)
+    expect((request as any)?.nonceKey).toBe(undefined)
   })
 
   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)?.nonceKey).toBe(undefined)
     expect((request as any)?.nonce).toBe(undefined)
   })
 
@@ -132,7 +132,7 @@ describe('chain.prepareTransactionRequest', () => {
           to: '0x0000000000000000000000000000000000000000',
         }),
       ])
-      expect(request.nonceKey).toBe(0n)
+      expect(request.nonceKey).toBe(undefined)
       expect(request2.nonceKey).toBeGreaterThan(0n)
       expect(request3.nonceKey).toBeGreaterThan(0n)
     })

package/src/wagmi/Actions/index.ts

@@ -2,6 +2,7 @@ export * as amm from './amm.js'
 export * as dex from './dex.js'
 export * as faucet from './faucet.js'
 export * as fee from './fee.js'
+export * as nonce from './nonce.js'
 export * as policy from './policy.js'
 export * as reward from './reward.js'
 export * as token from './token.js'