tempo.ts 0.10.2 → 0.10.4

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/viem/Chain.ts

@@ -47,12 +47,6 @@ function config<const chain extends Chain>(chain: chain) {
 
   return {
     blockTime: 1_000,
-    contracts: {
-      multicall3: {
-        address: '0xca11bde05977b3631167028862be2a173976ca11',
-        blockCreated: 0,
-      },
-    },
     formatters: {
       transaction: defineTransaction({
         exclude: ['aaAuthorizationList' as never],

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'

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

@@ -0,0 +1,141 @@
+import { connect } from '@wagmi/core'
+import { afterEach, describe, expect, test } from 'vitest'
+import { rpcUrl } from '../../../test/config.js'
+import { accounts } from '../../../test/viem/config.js'
+import { config, queryClient } from '../../../test/wagmi/config.js'
+import * as nonce from './nonce.js'
+import * as token from './token.js'
+
+const { getNonceKeyCount, getNonce } = nonce
+
+const account = accounts[0]
+const account2 = accounts[1]
+
+afterEach(async () => {
+  await fetch(`${rpcUrl}/restart`)
+})
+
+describe('getNonce', () => {
+  test('default', async () => {
+    const result = await getNonce(config, {
+      account: account.address,
+      nonceKey: 1n,
+    })
+    expect(result).toBe(1n)
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      const options = getNonce.queryOptions(config, {
+        account: account.address,
+        nonceKey: 1n,
+      })
+      const result = await queryClient.fetchQuery(options)
+      expect(result).toBe(1n)
+    })
+  })
+})
+
+describe('getNonceKeyCount', () => {
+  test('default', async () => {
+    const result = await getNonceKeyCount(config, {
+      account: account.address,
+    })
+    expect(result).toBe(0n)
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      const options = getNonceKeyCount.queryOptions(config, {
+        account: account.address,
+      })
+      expect(await queryClient.fetchQuery(options)).toBe(0n)
+    })
+  })
+})
+
+describe('watchNonceIncremented', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const events: any[] = []
+    const unwatch = nonce.watchNonceIncremented(config, {
+      onNonceIncremented: (args) => {
+        events.push(args)
+      },
+      args: {
+        account: account.address,
+        nonceKey: 5n,
+      },
+    })
+
+    // Have to manually set nonce because eth_FillTransaction does not support nonce keys
+    await token.transferSync(config, {
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 5n,
+      nonce: 0,
+    })
+
+    await token.transferSync(config, {
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 5n,
+      nonce: 1,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+
+    expect(events).toHaveLength(2)
+    expect(events[0]?.account).toBe(account.address)
+    expect(events[0]?.nonceKey).toBe(5n)
+    expect(events[0]?.newNonce).toBe(1n)
+    expect(events[1]?.newNonce).toBe(2n)
+    unwatch()
+  })
+})
+
+describe('watchActiveKeyCountChanged', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const events: any[] = []
+    const unwatch = nonce.watchActiveKeyCountChanged(config, {
+      onActiveKeyCountChanged: (args) => {
+        events.push(args)
+      },
+    })
+
+    // First use of nonceKey 10 should increment active key count
+    await token.transferSync(config, {
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 10n,
+      nonce: 0,
+    })
+
+    // First use of nonceKey 11 should increment again
+    await token.transferSync(config, {
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 11n,
+      nonce: 0,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+
+    expect(events).toHaveLength(2)
+    expect(events[0]?.account).toBe(account.address)
+    expect(events[0]?.newCount).toBe(1n)
+    expect(events[1]?.newCount).toBe(2n)
+    unwatch()
+  })
+})