tempo.ts 0.1.5 → 0.2.0

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

@@ -0,0 +1,63 @@
+import { connect } from '@wagmi/core'
+import { describe, expect, test } from 'vitest'
+import { accounts } from '../../../test/viem/config.js'
+import { config, queryClient } from '../../../test/wagmi/config.js'
+import { getUserToken, setUserToken, setUserTokenSync } from './fee.js'
+
+const account = accounts[0]
+
+describe('getUserToken', () => {
+  test('default', async () => {
+    const result = await getUserToken(config, {
+      account,
+    })
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "address": "0x20C0000000000000000000000000000000000001",
+        "id": 1n,
+      }
+    `)
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      const options = getUserToken.queryOptions(config, {
+        account,
+      })
+      expect(await queryClient.fetchQuery(options)).toMatchInlineSnapshot(
+        `
+        {
+          "address": "0x20C0000000000000000000000000000000000001",
+          "id": 1n,
+        }
+      `,
+      )
+    })
+  })
+})
+
+describe.skip('setUserToken', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+    const hash = await setUserToken(config, {
+      account,
+      token: '0x20C0000000000000000000000000000000000001',
+    })
+    expect(hash).toBeDefined()
+  })
+})
+
+describe.skip('setUserTokenSync', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+    const result = await setUserTokenSync(config, {
+      account,
+      token: '0x20C0000000000000000000000000000000000001',
+    })
+    expect(result).toBeDefined()
+  })
+})

package/src/wagmi/Actions/fee.ts

@@ -0,0 +1,208 @@
+import type * as Query from '@tanstack/query-core'
+import { type Config, getConnectorClient } from '@wagmi/core'
+import type { ChainIdParameter, ConnectorParameter } from '@wagmi/core/internal'
+import type { Account } from 'viem'
+import type { PartialBy, RequiredBy } from '../../internal/types.js'
+import * as viem_Actions from '../../viem/Actions/fee.js'
+
+/**
+ * Gets the user's default fee token.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, http } from '@wagmi/core'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/wagmi'
+ *
+ * const config = createConfig({
+ *   chains: [tempo],
+ *   transports: {
+ *     [tempo.id]: http(),
+ *   },
+ * })
+ *
+ * const hash = await Actions.fee.getUserToken(config, {
+ *   account: '0x20c...0055',
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns Transaction hash.
+ */
+export function getUserToken<config extends Config>(
+  config: config,
+  parameters: getUserToken.Parameters<config>,
+): Promise<getUserToken.ReturnValue> {
+  const { chainId, ...rest } = parameters
+  const client = config.getClient({ chainId })
+  return viem_Actions.getUserToken(client, rest)
+}
+
+export namespace getUserToken {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    viem_Actions.getUserToken.Parameters
+
+  export type ReturnValue = viem_Actions.getUserToken.ReturnValue
+
+  export function queryKey<config extends Config>(
+    parameters: PartialBy<Parameters<config>, 'account'>,
+  ) {
+    return ['getUserToken', parameters] as const
+  }
+
+  export type QueryKey<config extends Config> = ReturnType<
+    typeof queryKey<config>
+  >
+
+  export function queryOptions<config extends Config, selectData = ReturnValue>(
+    config: Config,
+    parameters: queryOptions.Parameters<config, selectData>,
+  ): queryOptions.ReturnValue<config, selectData> {
+    const { query, ...rest } = parameters
+    return {
+      ...query,
+      queryKey: queryKey(rest),
+      async queryFn({ queryKey }) {
+        const [, { account, ...parameters }] = queryKey
+        if (!account) throw new Error('account is required.')
+        return await getUserToken(config, { account, ...parameters })
+      },
+    }
+  }
+
+  export declare namespace queryOptions {
+    export type Parameters<
+      config extends Config,
+      selectData = getUserToken.ReturnValue,
+    > = PartialBy<getUserToken.Parameters<config>, 'account'> & {
+      query?:
+        | Omit<ReturnValue<config, selectData>, 'queryKey' | 'queryFn'>
+        | undefined
+    }
+
+    export type ReturnValue<
+      config extends Config,
+      selectData = getUserToken.ReturnValue,
+    > = RequiredBy<
+      Query.QueryOptions<
+        getUserToken.ReturnValue,
+        Query.DefaultError,
+        selectData,
+        getUserToken.QueryKey<config>
+      >,
+      'queryKey' | 'queryFn'
+    >
+  }
+}
+
+/**
+ * Sets the user's default fee token.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, http } from '@wagmi/core'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/wagmi'
+ *
+ * const config = createConfig({
+ *   chains: [tempo],
+ *   transports: {
+ *     [tempo.id]: http(),
+ *   },
+ * })
+ *
+ * const result = await Actions.fee.setUserToken(config, {
+ *   token: '0x20c...0055',
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns The transaction receipt and event data.
+ */
+export async function setUserToken<config extends Config>(
+  config: config,
+  parameters: setUserToken.Parameters<config>,
+): Promise<viem_Actions.setUserToken.ReturnValue> {
+  const { account, chainId, connector } = parameters
+
+  const client = await getConnectorClient(config, {
+    account,
+    assertChainId: false,
+    chainId,
+    connector,
+  })
+
+  return viem_Actions.setUserToken(
+    client,
+    parameters as viem_Actions.setUserToken.Parameters,
+  )
+}
+
+export declare namespace setUserToken {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    ConnectorParameter &
+    Omit<viem_Actions.setUserToken.Parameters<undefined, Account>, 'chain'>
+
+  export type ReturnValue = viem_Actions.setUserToken.ReturnValue
+
+  export type ErrorType = viem_Actions.setUserToken.ErrorType
+}
+
+/**
+ * Sets the user's default fee token.
+ *
+ * Note: This is a synchronous action that waits for the transaction to
+ * be included on a block before returning a response.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, http } from '@wagmi/core'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/wagmi'
+ *
+ * const config = createConfig({
+ *   chains: [tempo],
+ *   transports: {
+ *     [tempo.id]: http(),
+ *   },
+ * })
+ *
+ * const result = await Actions.fee.setUserTokenSync(config, {
+ *   token: '0x20c...0055',
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns The transaction receipt and event data.
+ */
+export async function setUserTokenSync<config extends Config>(
+  config: config,
+  parameters: setUserTokenSync.Parameters<config>,
+): Promise<viem_Actions.setUserTokenSync.ReturnValue> {
+  const { account, chainId, connector } = parameters
+
+  const client = await getConnectorClient(config, {
+    account,
+    assertChainId: false,
+    chainId,
+    connector,
+  })
+
+  return viem_Actions.setUserTokenSync(
+    client,
+    parameters as viem_Actions.setUserTokenSync.Parameters,
+  )
+}
+
+export declare namespace setUserTokenSync {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    ConnectorParameter &
+    Omit<viem_Actions.setUserTokenSync.Parameters<undefined, Account>, 'chain'>
+
+  export type ReturnValue = viem_Actions.setUserTokenSync.ReturnValue
+
+  export type ErrorType = viem_Actions.setUserTokenSync.ErrorType
+}

package/src/wagmi/Actions/index.ts

@@ -0,0 +1,5 @@
+export * as amm from './amm.js'
+export * as dex from './dex.js'
+export * as fee from './fee.js'
+export * as reward from './reward.js'
+export * as token from './token.js'

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

@@ -0,0 +1,210 @@
+import { getAccount } from '@wagmi/core'
+import { parseUnits } from 'viem'
+import { describe, expect, test } from 'vitest'
+import { config, queryClient, setupToken } from '../../../test/wagmi/config.js'
+import * as actions from './reward.js'
+import * as tokenActions from './token.js'
+
+describe('cancelSync', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    // Start a reward stream
+    const rewardAmount = parseUnits('100', 6)
+    const { id: streamId } = await actions.startSync(config, {
+      amount: rewardAmount,
+      seconds: 3600,
+      token,
+    })
+
+    // Cancel the reward
+    const { receipt, refund, ...result } = await actions.cancelSync(config, {
+      id: streamId,
+      token,
+    })
+
+    expect(refund).toBeGreaterThan(0n)
+    expect(receipt).toBeDefined()
+    expect(result.funder).toBeDefined()
+    expect(result.id).toBe(streamId)
+  })
+})
+
+// TODO: unskip
+describe.skip('claimSync', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    const account = getAccount(config)
+
+    const balanceBefore = await tokenActions.getBalance(config, {
+      account: account.address!,
+      token,
+    })
+
+    // Opt in to rewards
+    await actions.setRecipientSync(config, {
+      recipient: account.address!,
+      token,
+    })
+
+    // Mint reward tokens
+    const rewardAmount = parseUnits('100', 6)
+    await tokenActions.mintSync(config, {
+      amount: rewardAmount,
+      to: account.address!,
+      token,
+    })
+
+    // Start immediate reward
+    await actions.startSync(config, {
+      amount: rewardAmount,
+      seconds: 0,
+      token,
+    })
+
+    // Trigger reward accrual by transferring
+    await tokenActions.transferSync(config, {
+      amount: 1n,
+      to: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+      token,
+    })
+
+    // Claim rewards
+    const { receipt } = await actions.claimSync(config, {
+      token,
+    })
+
+    expect(receipt).toBeDefined()
+
+    const balanceAfter = await tokenActions.getBalance(config, {
+      account: account.address!,
+      token,
+    })
+
+    // Balance should have increased due to claimed rewards
+    expect(balanceAfter).toBeGreaterThan(
+      balanceBefore + rewardAmount - parseUnits('1', 6),
+    )
+  })
+})
+
+describe('getStream', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    // Start a reward stream
+    const rewardAmount = parseUnits('100', 6)
+    const { id: streamId } = await actions.startSync(config, {
+      amount: rewardAmount,
+      seconds: 10,
+      token,
+    })
+
+    // Get the stream
+    const stream = await actions.getStream(config, {
+      id: streamId,
+      token,
+    })
+
+    expect(stream.funder).toBeDefined()
+    expect(stream.amountTotal).toBe(rewardAmount)
+    expect(stream.endTime).toBeGreaterThan(stream.startTime)
+    expect(stream.ratePerSecondScaled).toBeGreaterThan(0n)
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      const { token } = await setupToken()
+
+      // Start a reward stream
+      const rewardAmount = parseUnits('100', 6)
+      const { id: streamId } = await actions.startSync(config, {
+        amount: rewardAmount,
+        seconds: 10,
+        token,
+      })
+
+      const options = actions.getStream.queryOptions(config, {
+        id: streamId,
+        token,
+      })
+
+      const stream = await queryClient.fetchQuery(options)
+
+      expect(stream.funder).toBeDefined()
+      expect(stream.amountTotal).toBe(rewardAmount)
+    })
+  })
+})
+
+describe('getTotalPerSecond', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    const rate = await actions.getTotalPerSecond(config, {
+      token,
+    })
+
+    expect(rate).toBe(0n)
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      const { token } = await setupToken()
+
+      const options = actions.getTotalPerSecond.queryOptions(config, {
+        token,
+      })
+
+      const rate = await queryClient.fetchQuery(options)
+
+      expect(rate).toBe(0n)
+    })
+  })
+})
+
+describe('setRecipientSync', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    const account = getAccount(config)
+
+    // Set reward recipient
+    const { holder, receipt, recipient } = await actions.setRecipientSync(
+      config,
+      {
+        recipient: account.address!,
+        token,
+      },
+    )
+
+    expect(receipt).toBeDefined()
+    expect(holder).toBe(account.address)
+    expect(recipient).toBe(account.address)
+  })
+})
+
+describe('startSync', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    const account = getAccount(config)
+
+    // Start a reward stream
+    const rewardAmount = parseUnits('100', 6)
+    const duration = 10
+    const { amount, durationSeconds, funder, id, receipt } =
+      await actions.startSync(config, {
+        amount: rewardAmount,
+        seconds: duration,
+        token,
+      })
+
+    expect(receipt).toBeDefined()
+    expect(funder).toBe(account.address)
+    expect(id).toBeGreaterThan(0n)
+    expect(amount).toBe(rewardAmount)
+    expect(durationSeconds).toBe(duration)
+  })
+})