tempo.ts 0.12.1 → 0.13.0

package/src/wagmi/Actions/faucet.ts

@@ -1,89 +0,0 @@
-import type { Config } from '@wagmi/core'
-import type { ChainIdParameter, UnionCompute } from '@wagmi/core/internal'
-import { Actions } from 'viem/tempo'
-
-/**
- * Funds an account with an initial amount of set token(s)
- * on Tempo's testnet.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'viem/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempoTestnet],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const hashes = await Actions.faucet.fund(config, {
- *   account: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction hashes.
- */
-export async function fund<config extends Config>(
-  config: config,
-  parameters: fund.Parameters<config>,
-): Promise<fund.ReturnValue> {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return Actions.faucet.fund(client, rest)
-}
-
-export declare namespace fund {
-  export type Parameters<config extends Config> = UnionCompute<
-    ChainIdParameter<config> & Actions.faucet.fund.Parameters
-  >
-
-  export type ReturnValue = Actions.faucet.fund.ReturnValue
-}
-
-/**
- * Funds an account with an initial amount of set token(s)
- * on Tempo's testnet. Returns with the transaction receipts.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'viem/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempoTestnet],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const receipts = await Actions.faucet.fundSync(config, {
- *   account: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction hashes.
- */
-export async function fundSync<config extends Config>(
-  config: config,
-  parameters: fundSync.Parameters<config>,
-): Promise<fundSync.ReturnValue> {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return Actions.faucet.fundSync(client, rest)
-}
-
-export declare namespace fundSync {
-  export type Parameters<config extends Config> = UnionCompute<
-    ChainIdParameter<config> & Actions.faucet.fundSync.Parameters
-  >
-
-  export type ReturnValue = Actions.faucet.fundSync.ReturnValue
-}

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

@@ -1,63 +0,0 @@
-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

@@ -1,211 +0,0 @@
-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 { Actions } from 'viem/tempo'
-import type { PartialBy, RequiredBy, UnionOmit } from '../../internal/types.js'
-
-/**
- * Gets the user's default fee token.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'viem/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempoTestnet],
- *   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 Actions.fee.getUserToken(client, rest)
-}
-
-export namespace getUserToken {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    Actions.fee.getUserToken.Parameters
-
-  export type ReturnValue = Actions.fee.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 'viem/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempoTestnet],
- *   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<Actions.fee.setUserToken.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return Actions.fee.setUserToken(client, parameters as never)
-}
-
-export declare namespace setUserToken {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    ConnectorParameter &
-    UnionOmit<
-      Actions.fee.setUserToken.Parameters<config['chains'][number], Account>,
-      'chain'
-    >
-
-  export type ReturnValue = Actions.fee.setUserToken.ReturnValue
-
-  export type ErrorType = Actions.fee.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 'viem/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempoTestnet],
- *   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<Actions.fee.setUserTokenSync.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return Actions.fee.setUserTokenSync(client, parameters as never)
-}
-
-export declare namespace setUserTokenSync {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    ConnectorParameter &
-    UnionOmit<
-      Actions.fee.setUserTokenSync.Parameters<
-        config['chains'][number],
-        Account
-      >,
-      'chain'
-    >
-
-  export type ReturnValue = Actions.fee.setUserTokenSync.ReturnValue
-
-  export type ErrorType = Actions.fee.setUserTokenSync.ErrorType
-}

package/src/wagmi/Actions/index.ts

@@ -1,8 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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 { 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(0n)
-  })
-
-  describe('queryOptions', () => {
-    test('default', async () => {
-      const options = getNonce.queryOptions(config, {
-        account: account.address,
-        nonceKey: 1n,
-      })
-      const result = await queryClient.fetchQuery(options)
-      expect(result).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()
-  })
-})

package/src/wagmi/Actions/nonce.ts

@@ -1,139 +0,0 @@
-import type * as Query from '@tanstack/query-core'
-import type { Config } from '@wagmi/core'
-import type { ChainIdParameter } from '@wagmi/core/internal'
-import { Actions } from 'viem/tempo'
-import type { PartialBy, RequiredBy } from '../../internal/types.js'
-
-/**
- * Gets the nonce for an account and nonce key.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'viem/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempoTestnet],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const nonce = await Actions.nonce.getNonce(config, {
- *   account: '0x...',
- *   nonceKey: 1n,
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The nonce value.
- */
-export function getNonce<config extends Config>(
-  config: config,
-  parameters: getNonce.Parameters<config>,
-): Promise<getNonce.ReturnValue> {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return Actions.nonce.getNonce(client, rest)
-}
-
-export namespace getNonce {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    Actions.nonce.getNonce.Parameters
-
-  export type ReturnValue = Actions.nonce.getNonce.ReturnValue
-
-  export function queryKey<config extends Config>(
-    parameters: PartialBy<Parameters<config>, 'account' | 'nonceKey'>,
-  ) {
-    return ['getNonce', 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, nonceKey, ...parameters }] = queryKey
-        if (!account) throw new Error('account is required.')
-        if (nonceKey === undefined) throw new Error('nonceKey is required.')
-        return await getNonce(config, { account, nonceKey, ...parameters })
-      },
-    }
-  }
-
-  export declare namespace queryOptions {
-    export type Parameters<
-      config extends Config,
-      selectData = getNonce.ReturnValue,
-    > = PartialBy<getNonce.Parameters<config>, 'account' | 'nonceKey'> & {
-      query?:
-        | Omit<ReturnValue<config, selectData>, 'queryKey' | 'queryFn'>
-        | undefined
-    }
-
-    export type ReturnValue<
-      config extends Config,
-      selectData = getNonce.ReturnValue,
-    > = RequiredBy<
-      Query.QueryOptions<
-        getNonce.ReturnValue,
-        Query.DefaultError,
-        selectData,
-        getNonce.QueryKey<config>
-      >,
-      'queryKey' | 'queryFn'
-    >
-  }
-}
-
-/**
- * Watches for nonce incremented events.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'viem/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempoTestnet],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const unwatch = Actions.nonce.watchNonceIncremented(config, {
- *   onNonceIncremented: (args, log) => {
- *     console.log('Nonce incremented:', args)
- *   },
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns A function to unsubscribe from the event.
- */
-export function watchNonceIncremented<config extends Config>(
-  config: config,
-  parameters: watchNonceIncremented.Parameters<config>,
-): () => void {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return Actions.nonce.watchNonceIncremented(client, rest)
-}
-
-export declare namespace watchNonceIncremented {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    Actions.nonce.watchNonceIncremented.Parameters
-}