tempo.ts 0.11.1 → 0.12.1

package/src/viem/Actions/fee.ts

@@ -1,372 +0,0 @@
-import { TokenId } from 'ox/tempo'
-import {
-  type Account,
-  type Address,
-  type BaseErrorType,
-  type Chain,
-  type Client,
-  type ExtractAbiItem,
-  type GetEventArgs,
-  type Log,
-  parseEventLogs,
-  type TransactionReceipt,
-  type Transport,
-  type Log as viem_Log,
-  type WatchContractEventParameters,
-  type WriteContractReturnType,
-  zeroAddress,
-} from 'viem'
-import { parseAccount } from 'viem/accounts'
-import {
-  readContract,
-  watchContractEvent,
-  writeContract,
-  writeContractSync,
-} from 'viem/actions'
-import type { Compute, UnionOmit } from '../../internal/types.js'
-import * as Abis from '../Abis.js'
-import * as Addresses from '../Addresses.js'
-import type {
-  GetAccountParameter,
-  ReadParameters,
-  WriteParameters,
-} from '../internal/types.js'
-import { defineCall } from '../internal/utils.js'
-
-/**
- * Gets the user's default fee token.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/viem'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const client = createClient({
- *   account: privateKeyToAccount('0x...'),
- *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
- *   transport: http(),
- * })
- *
- * const { address, id } = await Actions.fee.getUserToken(client)
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The transaction hash.
- */
-export async function getUserToken<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  ...parameters: account extends Account
-    ? [getUserToken.Parameters<account>] | []
-    : [getUserToken.Parameters<account>]
-): Promise<getUserToken.ReturnValue> {
-  const { account: account_ = client.account, ...rest } = parameters[0] ?? {}
-  if (!account_) throw new Error('account is required.')
-  const account = parseAccount(account_)
-  const address = await readContract(client, {
-    ...rest,
-    ...getUserToken.call({ account: account.address }),
-  })
-  if (address === zeroAddress) return null
-  return {
-    address,
-    id: TokenId.fromAddress(address),
-  }
-}
-
-export namespace getUserToken {
-  export type Parameters<
-    account extends Account | undefined = Account | undefined,
-  > = ReadParameters & GetAccountParameter<account>
-
-  export type Args = {
-    /** Account address. */
-    account: Address
-  }
-
-  export type ReturnValue = Compute<{
-    address: Address
-    id: bigint
-  } | null>
-
-  /**
-   * Defines a call to the `userTokens` function.
-   *
-   * @param args - Arguments.
-   * @returns The call.
-   */
-  export function call(args: Args) {
-    const { account } = args
-    return defineCall({
-      address: Addresses.feeManager,
-      abi: Abis.feeManager,
-      args: [account],
-      functionName: 'userTokens',
-    })
-  }
-}
-
-/**
- * Sets the user's default fee token.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/viem'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const client = createClient({
- *   account: privateKeyToAccount('0x...'),
- *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
- *   transport: http(),
- * })
- *
- * const hash = await Actions.fee.setUserToken(client, {
- *   token: '0x...',
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The transaction hash.
- */
-export async function setUserToken<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: setUserToken.Parameters<chain, account>,
-): Promise<setUserToken.ReturnValue> {
-  return setUserToken.inner(writeContract, client, parameters)
-}
-
-export namespace setUserToken {
-  export type Parameters<
-    chain extends Chain | undefined = Chain | undefined,
-    account extends Account | undefined = Account | undefined,
-  > = WriteParameters<chain, account> & Args
-
-  export type Args = {
-    /** Address or ID of the TIP20 token. */
-    token: TokenId.TokenIdOrAddress
-  }
-
-  export type ReturnValue = WriteContractReturnType
-
-  // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
-
-  /** @internal */
-  export async function inner<
-    action extends typeof writeContract | typeof writeContractSync,
-    chain extends Chain | undefined,
-    account extends Account | undefined,
-  >(
-    action: action,
-    client: Client<Transport, chain, account>,
-    parameters: setUserToken.Parameters<chain, account>,
-  ): Promise<ReturnType<action>> {
-    const { token, ...rest } = parameters
-    const call = setUserToken.call({ token })
-    return (await action(client, {
-      ...rest,
-      ...call,
-    } as never)) as never
-  }
-
-  /**
-   * Defines a call to the `setUserToken` 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
-   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
-   *
-   * @example
-   * ```ts
-   * import { createClient, http, walletActions } from 'viem'
-   * import { tempo } from 'tempo.ts/chains'
-   * import { Actions } from 'tempo.ts/viem'
-   *
-   * const client = createClient({
-   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-   *   transport: http(),
-   * }).extend(walletActions)
-   *
-   * const { result } = await client.sendCalls({
-   *   calls: [
-   *     actions.fee.setUserToken.call({
-   *       token: '0x20c0...beef',
-   *     }),
-   *     actions.fee.setUserToken.call({
-   *       token: '0x20c0...babe',
-   *     }),
-   *   ]
-   * })
-   * ```
-   *
-   * @param args - Arguments.
-   * @returns The call.
-   */
-  export function call(args: Args) {
-    const { token } = args
-    return defineCall({
-      address: Addresses.feeManager,
-      abi: Abis.feeManager,
-      functionName: 'setUserToken',
-      args: [TokenId.toAddress(token)],
-    })
-  }
-
-  export function extractEvent(logs: Log[]) {
-    const [log] = parseEventLogs({
-      abi: Abis.feeManager,
-      logs,
-      eventName: 'UserTokenSet',
-      strict: true,
-    })
-    if (!log) throw new Error('`UserTokenSet` event not found.')
-    return log
-  }
-}
-
-/**
- * Sets the user's default fee token.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/viem'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const client = createClient({
- *   account: privateKeyToAccount('0x...'),
- *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
- *   transport: http(),
- * })
- *
- * const result = await Actions.fee.setUserTokenSync(client, {
- *   token: '0x...',
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The transaction receipt and event data.
- */
-export async function setUserTokenSync<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: setUserTokenSync.Parameters<chain, account>,
-): Promise<setUserTokenSync.ReturnValue> {
-  const { throwOnReceiptRevert = true, ...rest } = parameters
-  const receipt = await setUserToken.inner(writeContractSync, client, {
-    ...rest,
-    throwOnReceiptRevert,
-  } as never)
-  const { args } = setUserToken.extractEvent(receipt.logs)
-  return {
-    ...args,
-    receipt,
-  } as never
-}
-
-export namespace setUserTokenSync {
-  export type Parameters<
-    chain extends Chain | undefined = Chain | undefined,
-    account extends Account | undefined = Account | undefined,
-  > = setUserToken.Parameters<chain, account>
-
-  export type Args = setUserToken.Args
-
-  export type ReturnValue = Compute<
-    GetEventArgs<
-      typeof Abis.feeManager,
-      'UserTokenSet',
-      { IndexedOnly: false; Required: true }
-    > & {
-      receipt: TransactionReceipt
-    }
-  >
-
-  // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
-}
-
-/**
- * Watches for user token set 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.fee.watchSetUserToken(client, {
- *   onUserTokenSet: (args, log) => {
- *     console.log('User token set:', args)
- *   },
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns A function to unsubscribe from the event.
- */
-export function watchSetUserToken<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: watchSetUserToken.Parameters,
-) {
-  const { onUserTokenSet, ...rest } = parameters
-  return watchContractEvent(client, {
-    ...rest,
-    address: Addresses.feeManager,
-    abi: Abis.feeManager,
-    eventName: 'UserTokenSet',
-    onLogs: (logs) => {
-      for (const log of logs) onUserTokenSet(log.args, log)
-    },
-    strict: true,
-  })
-}
-
-export declare namespace watchSetUserToken {
-  export type Args = GetEventArgs<
-    typeof Abis.feeManager,
-    'UserTokenSet',
-    { IndexedOnly: false; Required: true }
-  >
-
-  export type Log = viem_Log<
-    bigint,
-    number,
-    false,
-    ExtractAbiItem<typeof Abis.feeManager, 'UserTokenSet'>,
-    true
-  >
-
-  export type Parameters = UnionOmit<
-    WatchContractEventParameters<typeof Abis.feeManager, 'UserTokenSet', true>,
-    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
-  > & {
-    /** Callback to invoke when a user token is set. */
-    onUserTokenSet: (args: Args, log: Log) => void
-  }
-}

package/src/viem/Actions/index.ts

@@ -1,9 +0,0 @@
-export { verifyHash } from './account.js'
-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/viem/Actions/nonce.test.ts

@@ -1,206 +0,0 @@
-import { setTimeout } from 'node:timers/promises'
-import { beforeEach, 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]
-
-beforeEach(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(0n)
-  })
-
-  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(0n)
-    expect(nonce2).toBe(0n)
-
-    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(0n)
-    expect(nonce2).toBe(1n)
-  })
-
-  test('behavior: different accounts are independent', async () => {
-    await actions.token.transferSync(clientWithAccount, {
-      to: account2.address,
-      amount: 1n,
-      token: 1n,
-      nonceKey: 1n,
-    })
-    const nonce1 = await actions.nonce.getNonce(clientWithAccount, {
-      account: account.address,
-      nonceKey: 1n,
-    })
-    const nonce2 = await actions.nonce.getNonce(clientWithAccount, {
-      account: account2.address,
-      nonceKey: 1n,
-    })
-
-    expect(nonce1).toBe(1n)
-    expect(nonce2).toBe(0n)
-  })
-})
-
-describe('getNonceKeyCount', () => {
-  test('default', async () => {
-    // Get active nonce key count for a fresh account
-    const count = await actions.nonce.getNonceKeyCount(clientWithAccount, {
-      account: accounts.at(10)!.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: accounts.at(10)!.address,
-    })
-    const count2 = await actions.nonce.getNonceKeyCount(clientWithAccount, {
-      account: accounts.at(11)!.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 })
-        },
-      },
-    )
-
-    const priorKeyCount = await actions.nonce.getNonceKeyCount(
-      clientWithAccount,
-      {
-        account: account.address,
-      },
-    )
-
-    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)
-      // Assert the number of new active keys
-      expect(events[0]!.args.newCount - priorKeyCount).toBe(1n)
-      expect(events[1]!.args.newCount - priorKeyCount).toBe(2n)
-    } finally {
-      unwatch()
-    }
-  })
-})