tempo.ts 0.11.1 → 0.12.1

package/src/wagmi/Actions/faucet.ts

@@ -1,6 +1,6 @@
 import type { Config } from '@wagmi/core'
 import type { ChainIdParameter, UnionCompute } from '@wagmi/core/internal'
-import * as viem_Actions from '../../viem/Actions/faucet.js'
+import { Actions } from 'viem/tempo'
 
 /**
  * Funds an account with an initial amount of set token(s)
@@ -9,11 +9,11 @@ import * as viem_Actions from '../../viem/Actions/faucet.js'
  * @example
  * ```ts
  * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
+ * import { tempo } from 'viem/chains'
  * import { Actions } from 'tempo.ts/wagmi'
  *
  * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   chains: [tempoTestnet],
  *   transports: {
  *     [tempo.id]: http(),
  *   },
@@ -34,15 +34,15 @@ export async function fund<config extends Config>(
 ): Promise<fund.ReturnValue> {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.fund(client, rest)
+  return Actions.faucet.fund(client, rest)
 }
 
 export declare namespace fund {
   export type Parameters<config extends Config> = UnionCompute<
-    ChainIdParameter<config> & viem_Actions.fund.Parameters
+    ChainIdParameter<config> & Actions.faucet.fund.Parameters
   >
 
-  export type ReturnValue = viem_Actions.fund.ReturnValue
+  export type ReturnValue = Actions.faucet.fund.ReturnValue
 }
 
 /**
@@ -52,11 +52,11 @@ export declare namespace fund {
  * @example
  * ```ts
  * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
+ * import { tempo } from 'viem/chains'
  * import { Actions } from 'tempo.ts/wagmi'
  *
  * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   chains: [tempoTestnet],
  *   transports: {
  *     [tempo.id]: http(),
  *   },
@@ -77,13 +77,13 @@ export async function fundSync<config extends Config>(
 ): Promise<fundSync.ReturnValue> {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.fundSync(client, rest)
+  return Actions.faucet.fundSync(client, rest)
 }
 
 export declare namespace fundSync {
   export type Parameters<config extends Config> = UnionCompute<
-    ChainIdParameter<config> & viem_Actions.fundSync.Parameters
+    ChainIdParameter<config> & Actions.faucet.fundSync.Parameters
   >
 
-  export type ReturnValue = viem_Actions.fundSync.ReturnValue
+  export type ReturnValue = Actions.faucet.fundSync.ReturnValue
 }

package/src/wagmi/Actions/fee.ts

@@ -2,8 +2,8 @@ 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'
-import * as viem_Actions from '../../viem/Actions/fee.js'
 
 /**
  * Gets the user's default fee token.
@@ -11,11 +11,11 @@ import * as viem_Actions from '../../viem/Actions/fee.js'
  * @example
  * ```ts
  * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
+ * import { tempo } from 'viem/chains'
  * import { Actions } from 'tempo.ts/wagmi'
  *
  * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   chains: [tempoTestnet],
  *   transports: {
  *     [tempo.id]: http(),
  *   },
@@ -36,14 +36,14 @@ export function getUserToken<config extends Config>(
 ): Promise<getUserToken.ReturnValue> {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.getUserToken(client, rest)
+  return Actions.fee.getUserToken(client, rest)
 }
 
 export namespace getUserToken {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.getUserToken.Parameters
+    Actions.fee.getUserToken.Parameters
 
-  export type ReturnValue = viem_Actions.getUserToken.ReturnValue
+  export type ReturnValue = Actions.fee.getUserToken.ReturnValue
 
   export function queryKey<config extends Config>(
     parameters: PartialBy<Parameters<config>, 'account'>,
@@ -102,11 +102,11 @@ export namespace getUserToken {
  * @example
  * ```ts
  * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
+ * import { tempo } from 'viem/chains'
  * import { Actions } from 'tempo.ts/wagmi'
  *
  * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   chains: [tempoTestnet],
  *   transports: {
  *     [tempo.id]: http(),
  *   },
@@ -124,7 +124,7 @@ export namespace getUserToken {
 export async function setUserToken<config extends Config>(
   config: config,
   parameters: setUserToken.Parameters<config>,
-): Promise<viem_Actions.setUserToken.ReturnValue> {
+): Promise<Actions.fee.setUserToken.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -134,20 +134,20 @@ export async function setUserToken<config extends Config>(
     connector,
   })
 
-  return viem_Actions.setUserToken(client, parameters as never)
+  return Actions.fee.setUserToken(client, parameters as never)
 }
 
 export declare namespace setUserToken {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.setUserToken.Parameters<config['chains'][number], Account>,
+      Actions.fee.setUserToken.Parameters<config['chains'][number], Account>,
       'chain'
     >
 
-  export type ReturnValue = viem_Actions.setUserToken.ReturnValue
+  export type ReturnValue = Actions.fee.setUserToken.ReturnValue
 
-  export type ErrorType = viem_Actions.setUserToken.ErrorType
+  export type ErrorType = Actions.fee.setUserToken.ErrorType
 }
 
 /**
@@ -159,11 +159,11 @@ export declare namespace setUserToken {
  * @example
  * ```ts
  * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
+ * import { tempo } from 'viem/chains'
  * import { Actions } from 'tempo.ts/wagmi'
  *
  * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   chains: [tempoTestnet],
  *   transports: {
  *     [tempo.id]: http(),
  *   },
@@ -181,7 +181,7 @@ export declare namespace setUserToken {
 export async function setUserTokenSync<config extends Config>(
   config: config,
   parameters: setUserTokenSync.Parameters<config>,
-): Promise<viem_Actions.setUserTokenSync.ReturnValue> {
+): Promise<Actions.fee.setUserTokenSync.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -191,21 +191,21 @@ export async function setUserTokenSync<config extends Config>(
     connector,
   })
 
-  return viem_Actions.setUserTokenSync(client, parameters as never)
+  return Actions.fee.setUserTokenSync(client, parameters as never)
 }
 
 export declare namespace setUserTokenSync {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.setUserTokenSync.Parameters<
+      Actions.fee.setUserTokenSync.Parameters<
         config['chains'][number],
         Account
       >,
       'chain'
     >
 
-  export type ReturnValue = viem_Actions.setUserTokenSync.ReturnValue
+  export type ReturnValue = Actions.fee.setUserTokenSync.ReturnValue
 
-  export type ErrorType = viem_Actions.setUserTokenSync.ErrorType
+  export type ErrorType = Actions.fee.setUserTokenSync.ErrorType
 }

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

@@ -6,7 +6,7 @@ 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 { getNonce } = nonce
 
 const account = accounts[0]
 const account2 = accounts[1]
@@ -36,24 +36,6 @@ describe('getNonce', () => {
   })
 })
 
-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, {
@@ -98,48 +80,3 @@ describe('watchNonceIncremented', () => {
     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)
-      },
-    })
-
-    const priorKeyCount = await getNonceKeyCount(config, {
-      account: account.address,
-    })
-
-    // 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 - priorKeyCount).toBe(1n)
-    expect(events[1]?.newCount - priorKeyCount).toBe(2n)
-    unwatch()
-  })
-})

package/src/wagmi/Actions/nonce.ts

@@ -1,8 +1,8 @@
 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'
-import * as viem_Actions from '../../viem/Actions/nonce.js'
 
 /**
  * Gets the nonce for an account and nonce key.
@@ -10,11 +10,11 @@ import * as viem_Actions from '../../viem/Actions/nonce.js'
  * @example
  * ```ts
  * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
+ * import { tempo } from 'viem/chains'
  * import { Actions } from 'tempo.ts/wagmi'
  *
  * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   chains: [tempoTestnet],
  *   transports: {
  *     [tempo.id]: http(),
  *   },
@@ -36,14 +36,14 @@ export function getNonce<config extends Config>(
 ): Promise<getNonce.ReturnValue> {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.getNonce(client, rest)
+  return Actions.nonce.getNonce(client, rest)
 }
 
 export namespace getNonce {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.getNonce.Parameters
+    Actions.nonce.getNonce.Parameters
 
-  export type ReturnValue = viem_Actions.getNonce.ReturnValue
+  export type ReturnValue = Actions.nonce.getNonce.ReturnValue
 
   export function queryKey<config extends Config>(
     parameters: PartialBy<Parameters<config>, 'account' | 'nonceKey'>,
@@ -97,108 +97,17 @@ export namespace getNonce {
   }
 }
 
-/**
- * Gets the number of active nonce keys for an account.
- *
- * @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({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const count = await Actions.nonce.getNonceKeyCount(config, {
- *   account: '0x...',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The number of active nonce keys.
- */
-export function getNonceKeyCount<config extends Config>(
-  config: config,
-  parameters: getNonceKeyCount.Parameters<config>,
-): Promise<getNonceKeyCount.ReturnValue> {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return viem_Actions.getNonceKeyCount(client, rest)
-}
-
-export namespace getNonceKeyCount {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.getNonceKeyCount.Parameters
-
-  export type ReturnValue = viem_Actions.getNonceKeyCount.ReturnValue
-
-  export function queryKey<config extends Config>(
-    parameters: PartialBy<Parameters<config>, 'account'>,
-  ) {
-    return ['getNonceKeyCount', 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 getNonceKeyCount(config, { account, ...parameters })
-      },
-    }
-  }
-
-  export declare namespace queryOptions {
-    export type Parameters<
-      config extends Config,
-      selectData = getNonceKeyCount.ReturnValue,
-    > = PartialBy<getNonceKeyCount.Parameters<config>, 'account'> & {
-      query?:
-        | Omit<ReturnValue<config, selectData>, 'queryKey' | 'queryFn'>
-        | undefined
-    }
-
-    export type ReturnValue<
-      config extends Config,
-      selectData = getNonceKeyCount.ReturnValue,
-    > = RequiredBy<
-      Query.QueryOptions<
-        getNonceKeyCount.ReturnValue,
-        Query.DefaultError,
-        selectData,
-        getNonceKeyCount.QueryKey<config>
-      >,
-      'queryKey' | 'queryFn'
-    >
-  }
-}
-
 /**
  * Watches for nonce incremented events.
  *
  * @example
  * ```ts
  * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
+ * import { tempo } from 'viem/chains'
  * import { Actions } from 'tempo.ts/wagmi'
  *
  * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   chains: [tempoTestnet],
  *   transports: {
  *     [tempo.id]: http(),
  *   },
@@ -221,51 +130,10 @@ export function watchNonceIncremented<config extends Config>(
 ): () => void {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.watchNonceIncremented(client, rest)
+  return Actions.nonce.watchNonceIncremented(client, rest)
 }
 
 export declare namespace watchNonceIncremented {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.watchNonceIncremented.Parameters
-}
-
-/**
- * Watches for active key count changed events.
- *
- * @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({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const unwatch = Actions.nonce.watchActiveKeyCountChanged(config, {
- *   onActiveKeyCountChanged: (args, log) => {
- *     console.log('Active key count changed:', args)
- *   },
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns A function to unsubscribe from the event.
- */
-export function watchActiveKeyCountChanged<config extends Config>(
-  config: config,
-  parameters: watchActiveKeyCountChanged.Parameters<config>,
-): () => void {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return viem_Actions.watchActiveKeyCountChanged(client, rest)
-}
-
-export declare namespace watchActiveKeyCountChanged {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.watchActiveKeyCountChanged.Parameters
+    Actions.nonce.watchNonceIncremented.Parameters
 }