tempo.ts 0.0.0 → 0.0.2

package/src/viem/actions/fee.test.ts

@@ -0,0 +1,281 @@
+import { setTimeout } from 'node:timers/promises'
+import * as actions from 'tempo.ts/viem/actions'
+import { parseEther, publicActions } from 'viem'
+import { mnemonicToAccount } from 'viem/accounts'
+import { writeContractSync } from 'viem/actions'
+import { describe, expect, test } from 'vitest'
+import { tempoTest } from '../../../test/viem/config.js'
+import { tip20Abi } from '../abis.js'
+import { usdAddress } from '../addresses.js'
+import { createTempoClient } from '../client.js'
+
+const account = mnemonicToAccount(
+  'test test test test test test test test test test test junk',
+)
+const account2 = mnemonicToAccount(
+  'test test test test test test test test test test test junk',
+  { accountIndex: 1 },
+)
+const account3 = mnemonicToAccount(
+  'test test test test test test test test test test test junk',
+  { accountIndex: 2 },
+)
+
+const client = createTempoClient({
+  account,
+  chain: tempoTest,
+  pollingInterval: 100,
+}).extend(publicActions)
+
+describe('getUserToken', () => {
+  test('default', async () => {
+    // Fund accounts
+    await writeContractSync(client, {
+      abi: tip20Abi,
+      address: usdAddress,
+      functionName: 'transfer',
+      args: [account2.address, parseEther('100')],
+    })
+    await writeContractSync(client, {
+      abi: tip20Abi,
+      address: usdAddress,
+      functionName: 'transfer',
+      args: [account3.address, parseEther('100')],
+    })
+
+    // Set token (address)
+    await actions.fee.setUserTokenSync(client, {
+      account: account2,
+      token: '0x20c0000000000000000000000000000000000001',
+    })
+
+    // Set another token (id)
+    await actions.fee.setUserTokenSync(client, {
+      account: account3,
+      token: 2n,
+    })
+
+    // Assert that account (with default) & account2 (with custom) tokens are set correctly.
+    expect(
+      await actions.fee.getUserToken(client, { account }),
+    ).toMatchInlineSnapshot(`
+      {
+        "address": "0x20C0000000000000000000000000000000000000",
+        "id": 0n,
+      }
+    `)
+    expect(
+      await actions.fee.getUserToken(client, { account: account2 }),
+    ).toMatchInlineSnapshot(`
+      {
+        "address": "0x20C0000000000000000000000000000000000001",
+        "id": 1n,
+      }
+    `)
+    expect(
+      await actions.fee.getUserToken(client, { account: account3 }),
+    ).toMatchInlineSnapshot(`
+      {
+        "address": "0x20C0000000000000000000000000000000000002",
+        "id": 2n,
+      }
+    `)
+  })
+})
+
+describe('setUserToken', () => {
+  test('default', async () => {
+    expect(await actions.fee.getUserToken(client)).toMatchInlineSnapshot(
+      `
+        {
+          "address": "0x20C0000000000000000000000000000000000000",
+          "id": 0n,
+        }
+      `,
+    )
+
+    const { receipt: setReceipt, ...setResult } =
+      await actions.fee.setUserTokenSync(client, {
+        token: '0x20c0000000000000000000000000000000000001',
+      })
+    expect(setReceipt).toBeDefined()
+    expect(setResult).toMatchInlineSnapshot(`
+      {
+        "token": "0x20C0000000000000000000000000000000000001",
+        "user": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      }
+    `)
+
+    expect(await actions.fee.getUserToken(client, {})).toMatchInlineSnapshot(
+      `
+        {
+          "address": "0x20C0000000000000000000000000000000000001",
+          "id": 1n,
+        }
+      `,
+    )
+
+    const { receipt: resetReceipt, ...resetResult } =
+      await actions.fee.setUserTokenSync(client, {
+        feeToken: 0n,
+        token: 0n,
+      })
+    expect(resetReceipt).toBeDefined()
+    expect(resetResult).toMatchInlineSnapshot(`
+      {
+        "token": "0x20C0000000000000000000000000000000000000",
+        "user": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      }
+    `)
+
+    expect(await actions.fee.getUserToken(client, {})).toMatchInlineSnapshot(
+      `
+        {
+          "address": "0x20C0000000000000000000000000000000000000",
+          "id": 0n,
+        }
+      `,
+    )
+  })
+})
+
+describe('watchSetUserToken', () => {
+  test('default', async () => {
+    const receivedSets: Array<{
+      args: actions.fee.watchSetUserToken.Args
+      log: actions.fee.watchSetUserToken.Log
+    }> = []
+
+    // Start watching for user token set events
+    const unwatch = actions.fee.watchSetUserToken(client, {
+      onUserTokenSet: (args, log) => {
+        receivedSets.push({ args, log })
+      },
+    })
+
+    try {
+      // Set token for account2
+      await writeContractSync(client, {
+        abi: tip20Abi,
+        address: usdAddress,
+        functionName: 'transfer',
+        args: [account2.address, parseEther('1')],
+      })
+
+      await actions.fee.setUserTokenSync(client, {
+        account: account2,
+        token: '0x20c0000000000000000000000000000000000001',
+      })
+
+      // Set token for account3
+      await writeContractSync(client, {
+        abi: tip20Abi,
+        address: usdAddress,
+        functionName: 'transfer',
+        args: [account3.address, parseEther('1')],
+      })
+
+      await actions.fee.setUserTokenSync(client, {
+        account: account3,
+        token: '0x20c0000000000000000000000000000000000002',
+      })
+
+      await setTimeout(100)
+
+      expect(receivedSets).toHaveLength(2)
+
+      expect(receivedSets.at(0)!.args).toMatchInlineSnapshot(`
+        {
+          "token": "0x20C0000000000000000000000000000000000001",
+          "user": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
+        }
+      `)
+      expect(receivedSets.at(1)!.args).toMatchInlineSnapshot(`
+        {
+          "token": "0x20C0000000000000000000000000000000000002",
+          "user": "0x98e503f35D0a019cB0a251aD243a4cCFCF371F46",
+        }
+      `)
+    } finally {
+      if (unwatch) unwatch()
+    }
+  })
+
+  test('behavior: filter by user address', async () => {
+    const receivedSets: Array<{
+      args: actions.fee.watchSetUserToken.Args
+      log: actions.fee.watchSetUserToken.Log
+    }> = []
+
+    // Start watching for user token set events only for account2
+    const unwatch = actions.fee.watchSetUserToken(client, {
+      args: {
+        user: account2.address,
+      },
+      onUserTokenSet: (args, log) => {
+        receivedSets.push({ args, log })
+      },
+    })
+
+    try {
+      // Transfer gas to accounts
+      await writeContractSync(client, {
+        abi: tip20Abi,
+        address: usdAddress,
+        functionName: 'transfer',
+        args: [account2.address, parseEther('1')],
+      })
+
+      await writeContractSync(client, {
+        abi: tip20Abi,
+        address: usdAddress,
+        functionName: 'transfer',
+        args: [account3.address, parseEther('1')],
+      })
+
+      // Set token for account2 (should be captured)
+      await actions.fee.setUserTokenSync(client, {
+        account: account2,
+        token: '0x20c0000000000000000000000000000000000001',
+      })
+
+      // Set token for account3 (should NOT be captured)
+      await actions.fee.setUserTokenSync(client, {
+        account: account3,
+        token: '0x20c0000000000000000000000000000000000002',
+      })
+
+      // Set token for account2 again (should be captured)
+      await actions.fee.setUserTokenSync(client, {
+        account: account2,
+        feeToken: 0n,
+        token: 2n,
+      })
+
+      await setTimeout(100)
+
+      // Should only receive 2 events (for account2)
+      expect(receivedSets).toHaveLength(2)
+
+      expect(receivedSets.at(0)!.args).toMatchInlineSnapshot(`
+        {
+          "token": "0x20C0000000000000000000000000000000000001",
+          "user": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
+        }
+      `)
+      expect(receivedSets.at(1)!.args).toMatchInlineSnapshot(`
+        {
+          "token": "0x20C0000000000000000000000000000000000002",
+          "user": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
+        }
+      `)
+
+      // Verify all received events are for account2
+      for (const set of receivedSets) {
+        expect(set.args.user).toBe(account2.address)
+      }
+    } finally {
+      if (unwatch) unwatch()
+    }
+  })
+})

package/src/viem/actions/fee.ts

@@ -0,0 +1,362 @@
+import {
+  type Account,
+  type Address,
+  type Chain,
+  type Client,
+  type ExtractAbiItem,
+  type GetEventArgs,
+  type Log,
+  parseEventLogs,
+  type TransactionReceipt,
+  type Transport,
+  type Log as viem_Log,
+  type WatchContractEventParameters,
+  type WriteContractReturnType,
+} 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 TokenId from '../../ox/TokenId.js'
+import { feeManagerAbi } from '../abis.js'
+import { feeManagerAddress } from '../addresses.js'
+import type {
+  GetAccountParameter,
+  ReadParameters,
+  WriteParameters,
+} from '../types.js'
+import { defineCall } from '../utils.js'
+
+/**
+ * Gets the user's default fee token.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import * as actions from 'tempo.ts/viem/actions'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo,
+ *   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 }),
+  })
+  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
+  }>
+
+  /**
+   * Defines a call to the `userTokens` function.
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { account } = args
+    return defineCall({
+      address: feeManagerAddress,
+      abi: feeManagerAbi,
+      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 * as actions from 'tempo.ts/viem/actions'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo,
+ *   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
+
+  /** @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 call = setUserToken.call(parameters)
+    return (await action(client, {
+      ...parameters,
+      ...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 * as actions from 'tempo.ts/viem/actions'
+   *
+   * const client = createClient({
+   *   chain: tempo,
+   *   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: feeManagerAddress,
+      abi: feeManagerAbi,
+      functionName: 'setUserToken',
+      args: [TokenId.toAddress(token)],
+    })
+  }
+
+  export function extractEvent(logs: Log[]) {
+    const [log] = parseEventLogs({
+      abi: feeManagerAbi,
+      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 * as actions from 'tempo.ts/viem/actions'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo,
+ *   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 receipt = await setUserToken.inner(
+    writeContractSync,
+    client,
+    parameters,
+  )
+  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 feeManagerAbi,
+      'UserTokenSet',
+      { IndexedOnly: false; Required: true }
+    > & {
+      receipt: TransactionReceipt
+    }
+  >
+}
+
+/**
+ * Watches for user token set events.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   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: feeManagerAddress,
+    abi: feeManagerAbi,
+    eventName: 'UserTokenSet',
+    onLogs: (logs) => {
+      for (const log of logs) onUserTokenSet(log.args, log)
+    },
+    strict: true,
+  })
+}
+
+export declare namespace watchSetUserToken {
+  export type Args = GetEventArgs<
+    typeof feeManagerAbi,
+    'UserTokenSet',
+    { IndexedOnly: false; Required: true }
+  >
+
+  export type Log = viem_Log<
+    bigint,
+    number,
+    false,
+    ExtractAbiItem<typeof feeManagerAbi, 'UserTokenSet'>,
+    true
+  >
+
+  export type Parameters = UnionOmit<
+    WatchContractEventParameters<typeof feeManagerAbi, '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

@@ -0,0 +1,4 @@
+export * as amm from './amm.js'
+export * as fee from './fee.js'
+export * as policy from './policy.js'
+export * as token from './token.js'