tempo.ts 0.11.1 → 0.12.0

package/src/wagmi/Actions/policy.ts

@@ -2,10 +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 { RequiredBy, UnionOmit } from '../../internal/types.js'
-import * as viem_Actions from '../../viem/Actions/policy.js'
-
-export type { PolicyType } from '../../viem/Actions/policy.js'
 
 /**
  * Creates a new policy.
@@ -13,11 +11,11 @@ export type { PolicyType } from '../../viem/Actions/policy.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(),
  *   },
@@ -35,7 +33,7 @@ export type { PolicyType } from '../../viem/Actions/policy.js'
 export async function create<config extends Config>(
   config: config,
   parameters: create.Parameters<config>,
-): Promise<viem_Actions.create.ReturnValue> {
+): Promise<Actions.policy.create.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -45,20 +43,20 @@ export async function create<config extends Config>(
     connector,
   })
 
-  return viem_Actions.create(client, parameters as never)
+  return Actions.policy.create(client, parameters as never)
 }
 
 export declare namespace create {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.create.Parameters<config['chains'][number], Account>,
+      Actions.policy.create.Parameters<config['chains'][number], Account>,
       'chain' | 'admin'
     >
 
-  export type ReturnValue = viem_Actions.create.ReturnValue
+  export type ReturnValue = Actions.policy.create.ReturnValue
 
-  export type ErrorType = viem_Actions.create.ErrorType
+  export type ErrorType = Actions.policy.create.ErrorType
 }
 
 /**
@@ -70,11 +68,11 @@ export declare namespace create {
  * @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(),
  *   },
@@ -92,7 +90,7 @@ export declare namespace create {
 export async function createSync<config extends Config>(
   config: config,
   parameters: createSync.Parameters<config>,
-): Promise<viem_Actions.createSync.ReturnValue> {
+): Promise<Actions.policy.createSync.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -102,20 +100,20 @@ export async function createSync<config extends Config>(
     connector,
   })
 
-  return viem_Actions.createSync(client, parameters as never)
+  return Actions.policy.createSync(client, parameters as never)
 }
 
 export declare namespace createSync {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.createSync.Parameters<config['chains'][number], Account>,
+      Actions.policy.createSync.Parameters<config['chains'][number], Account>,
       'chain' | 'admin'
     >
 
-  export type ReturnValue = viem_Actions.createSync.ReturnValue
+  export type ReturnValue = Actions.policy.createSync.ReturnValue
 
-  export type ErrorType = viem_Actions.createSync.ErrorType
+  export type ErrorType = Actions.policy.createSync.ErrorType
 }
 
 /**
@@ -124,11 +122,11 @@ export declare namespace createSync {
  * @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(),
  *   },
@@ -147,7 +145,7 @@ export declare namespace createSync {
 export async function setAdmin<config extends Config>(
   config: config,
   parameters: setAdmin.Parameters<config>,
-): Promise<viem_Actions.setAdmin.ReturnValue> {
+): Promise<Actions.policy.setAdmin.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -157,20 +155,20 @@ export async function setAdmin<config extends Config>(
     connector,
   })
 
-  return viem_Actions.setAdmin(client, parameters as never)
+  return Actions.policy.setAdmin(client, parameters as never)
 }
 
 export declare namespace setAdmin {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.setAdmin.Parameters<config['chains'][number], Account>,
+      Actions.policy.setAdmin.Parameters<config['chains'][number], Account>,
       'chain'
     >
 
-  export type ReturnValue = viem_Actions.setAdmin.ReturnValue
+  export type ReturnValue = Actions.policy.setAdmin.ReturnValue
 
-  export type ErrorType = viem_Actions.setAdmin.ErrorType
+  export type ErrorType = Actions.policy.setAdmin.ErrorType
 }
 
 /**
@@ -182,11 +180,11 @@ export declare namespace setAdmin {
  * @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(),
  *   },
@@ -205,7 +203,7 @@ export declare namespace setAdmin {
 export async function setAdminSync<config extends Config>(
   config: config,
   parameters: setAdminSync.Parameters<config>,
-): Promise<viem_Actions.setAdminSync.ReturnValue> {
+): Promise<Actions.policy.setAdminSync.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -215,20 +213,20 @@ export async function setAdminSync<config extends Config>(
     connector,
   })
 
-  return viem_Actions.setAdminSync(client, parameters as never)
+  return Actions.policy.setAdminSync(client, parameters as never)
 }
 
 export declare namespace setAdminSync {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.setAdminSync.Parameters<config['chains'][number], Account>,
+      Actions.policy.setAdminSync.Parameters<config['chains'][number], Account>,
       'chain'
     >
 
-  export type ReturnValue = viem_Actions.setAdminSync.ReturnValue
+  export type ReturnValue = Actions.policy.setAdminSync.ReturnValue
 
-  export type ErrorType = viem_Actions.setAdminSync.ErrorType
+  export type ErrorType = Actions.policy.setAdminSync.ErrorType
 }
 
 /**
@@ -237,11 +235,11 @@ export declare namespace setAdminSync {
  * @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(),
  *   },
@@ -261,7 +259,7 @@ export declare namespace setAdminSync {
 export async function modifyWhitelist<config extends Config>(
   config: config,
   parameters: modifyWhitelist.Parameters<config>,
-): Promise<viem_Actions.modifyWhitelist.ReturnValue> {
+): Promise<Actions.policy.modifyWhitelist.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -271,23 +269,23 @@ export async function modifyWhitelist<config extends Config>(
     connector,
   })
 
-  return viem_Actions.modifyWhitelist(client, parameters as never)
+  return Actions.policy.modifyWhitelist(client, parameters as never)
 }
 
 export declare namespace modifyWhitelist {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.modifyWhitelist.Parameters<
+      Actions.policy.modifyWhitelist.Parameters<
         config['chains'][number],
         Account
       >,
       'chain'
     >
 
-  export type ReturnValue = viem_Actions.modifyWhitelist.ReturnValue
+  export type ReturnValue = Actions.policy.modifyWhitelist.ReturnValue
 
-  export type ErrorType = viem_Actions.modifyWhitelist.ErrorType
+  export type ErrorType = Actions.policy.modifyWhitelist.ErrorType
 }
 
 /**
@@ -299,11 +297,11 @@ export declare namespace modifyWhitelist {
  * @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(),
  *   },
@@ -323,7 +321,7 @@ export declare namespace modifyWhitelist {
 export async function modifyWhitelistSync<config extends Config>(
   config: config,
   parameters: modifyWhitelistSync.Parameters<config>,
-): Promise<viem_Actions.modifyWhitelistSync.ReturnValue> {
+): Promise<Actions.policy.modifyWhitelistSync.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -333,23 +331,23 @@ export async function modifyWhitelistSync<config extends Config>(
     connector,
   })
 
-  return viem_Actions.modifyWhitelistSync(client, parameters as never)
+  return Actions.policy.modifyWhitelistSync(client, parameters as never)
 }
 
 export declare namespace modifyWhitelistSync {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.modifyWhitelistSync.Parameters<
+      Actions.policy.modifyWhitelistSync.Parameters<
         config['chains'][number],
         Account
       >,
       'chain'
     >
 
-  export type ReturnValue = viem_Actions.modifyWhitelistSync.ReturnValue
+  export type ReturnValue = Actions.policy.modifyWhitelistSync.ReturnValue
 
-  export type ErrorType = viem_Actions.modifyWhitelistSync.ErrorType
+  export type ErrorType = Actions.policy.modifyWhitelistSync.ErrorType
 }
 
 /**
@@ -358,11 +356,11 @@ export declare namespace modifyWhitelistSync {
  * @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(),
  *   },
@@ -382,7 +380,7 @@ export declare namespace modifyWhitelistSync {
 export async function modifyBlacklist<config extends Config>(
   config: config,
   parameters: modifyBlacklist.Parameters<config>,
-): Promise<viem_Actions.modifyBlacklist.ReturnValue> {
+): Promise<Actions.policy.modifyBlacklist.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -392,23 +390,23 @@ export async function modifyBlacklist<config extends Config>(
     connector,
   })
 
-  return viem_Actions.modifyBlacklist(client, parameters as never)
+  return Actions.policy.modifyBlacklist(client, parameters as never)
 }
 
 export declare namespace modifyBlacklist {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.modifyBlacklist.Parameters<
+      Actions.policy.modifyBlacklist.Parameters<
         config['chains'][number],
         Account
       >,
       'chain'
     >
 
-  export type ReturnValue = viem_Actions.modifyBlacklist.ReturnValue
+  export type ReturnValue = Actions.policy.modifyBlacklist.ReturnValue
 
-  export type ErrorType = viem_Actions.modifyBlacklist.ErrorType
+  export type ErrorType = Actions.policy.modifyBlacklist.ErrorType
 }
 
 /**
@@ -420,11 +418,11 @@ export declare namespace modifyBlacklist {
  * @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(),
  *   },
@@ -444,7 +442,7 @@ export declare namespace modifyBlacklist {
 export async function modifyBlacklistSync<config extends Config>(
   config: config,
   parameters: modifyBlacklistSync.Parameters<config>,
-): Promise<viem_Actions.modifyBlacklistSync.ReturnValue> {
+): Promise<Actions.policy.modifyBlacklistSync.ReturnValue> {
   const { account, chainId, connector } = parameters
 
   const client = await getConnectorClient(config, {
@@ -454,23 +452,23 @@ export async function modifyBlacklistSync<config extends Config>(
     connector,
   })
 
-  return viem_Actions.modifyBlacklistSync(client, parameters as never)
+  return Actions.policy.modifyBlacklistSync(client, parameters as never)
 }
 
 export declare namespace modifyBlacklistSync {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     ConnectorParameter &
     UnionOmit<
-      viem_Actions.modifyBlacklistSync.Parameters<
+      Actions.policy.modifyBlacklistSync.Parameters<
         config['chains'][number],
         Account
       >,
       'chain'
     >
 
-  export type ReturnValue = viem_Actions.modifyBlacklistSync.ReturnValue
+  export type ReturnValue = Actions.policy.modifyBlacklistSync.ReturnValue
 
-  export type ErrorType = viem_Actions.modifyBlacklistSync.ErrorType
+  export type ErrorType = Actions.policy.modifyBlacklistSync.ErrorType
 }
 
 /**
@@ -479,11 +477,11 @@ export declare namespace modifyBlacklistSync {
  * @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(),
  *   },
@@ -504,14 +502,14 @@ export function getData<config extends Config>(
 ): Promise<getData.ReturnValue> {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.getData(client, rest)
+  return Actions.policy.getData(client, rest)
 }
 
 export namespace getData {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.getData.Parameters
+    Actions.policy.getData.Parameters
 
-  export type ReturnValue = viem_Actions.getData.ReturnValue
+  export type ReturnValue = Actions.policy.getData.ReturnValue
 
   export function queryKey<config extends Config>(
     parameters: Parameters<config>,
@@ -569,11 +567,11 @@ export namespace getData {
  * @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(),
  *   },
@@ -595,14 +593,14 @@ export function isAuthorized<config extends Config>(
 ): Promise<isAuthorized.ReturnValue> {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.isAuthorized(client, rest)
+  return Actions.policy.isAuthorized(client, rest)
 }
 
 export namespace isAuthorized {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.isAuthorized.Parameters
+    Actions.policy.isAuthorized.Parameters
 
-  export type ReturnValue = viem_Actions.isAuthorized.ReturnValue
+  export type ReturnValue = Actions.policy.isAuthorized.ReturnValue
 
   export function queryKey<config extends Config>(
     parameters: Parameters<config>,
@@ -660,11 +658,11 @@ export namespace isAuthorized {
  * @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(),
  *   },
@@ -687,12 +685,12 @@ export function watchCreate<config extends Config>(
 ) {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.watchCreate(client, rest)
+  return Actions.policy.watchCreate(client, rest)
 }
 
 export declare namespace watchCreate {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.watchCreate.Parameters
+    Actions.policy.watchCreate.Parameters
 }
 
 /**
@@ -701,11 +699,11 @@ export declare namespace watchCreate {
  * @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(),
  *   },
@@ -728,12 +726,12 @@ export function watchAdminUpdated<config extends Config>(
 ) {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.watchAdminUpdated(client, rest)
+  return Actions.policy.watchAdminUpdated(client, rest)
 }
 
 export declare namespace watchAdminUpdated {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.watchAdminUpdated.Parameters
+    Actions.policy.watchAdminUpdated.Parameters
 }
 
 /**
@@ -742,11 +740,11 @@ export declare namespace watchAdminUpdated {
  * @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(),
  *   },
@@ -769,12 +767,12 @@ export function watchWhitelistUpdated<config extends Config>(
 ) {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.watchWhitelistUpdated(client, rest)
+  return Actions.policy.watchWhitelistUpdated(client, rest)
 }
 
 export declare namespace watchWhitelistUpdated {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.watchWhitelistUpdated.Parameters
+    Actions.policy.watchWhitelistUpdated.Parameters
 }
 
 /**
@@ -783,11 +781,11 @@ export declare namespace watchWhitelistUpdated {
  * @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(),
  *   },
@@ -810,10 +808,10 @@ export function watchBlacklistUpdated<config extends Config>(
 ) {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_Actions.watchBlacklistUpdated(client, rest)
+  return Actions.policy.watchBlacklistUpdated(client, rest)
 }
 
 export declare namespace watchBlacklistUpdated {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.watchBlacklistUpdated.Parameters
+    Actions.policy.watchBlacklistUpdated.Parameters
 }