viem 3.0.0-next.10 → 3.0.0-next.13

package/src/tempo/Addresses.ts

@@ -1,51 +1,80 @@
+import { Hex } from 'ox'
+import { ZoneId } from 'ox/tempo'
+
+const legacyZoneChainIdBase = 4_217_000_000
+const legacyZoneChainIdLimit = 4_218_000_000
+const mainnetZoneChainIdBase = ZoneId.toChainId(0)
+const testnetZoneChainIdBase = ZoneId.toChainId(0, 42_431)
+const zoneChainIdLimit = 2 ** 31
+
 /** Address of the account implementation (default delegation target). */
 export const accountImplementation =
   '0x7702c00000000000000000000000000000000000'
-
 /** Address of the account keychain precompile. */
 export const accountKeychain = '0xaAAAaaAA00000000000000000000000000000000'
-
 /** Address of the account registrar precompile. */
 export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
-
 /** Address of the address registry precompile. */
 export const addressRegistry = '0xfdc0000000000000000000000000000000000000'
-
-/** Address of the fee manager precompile. */
+/** Current consensus committee precompile address, used with `Abis.currentCommittee` to read committee members. */
+export const currentCommittee = '0xC077e00000000000000000000000000000000000'
 export const feeManager = '0xfeec000000000000000000000000000000000000'
-
+export const nativeMultisig = '0xAACC000000000000000000000000000000000000'
+/** Temporary recovery factory until the production address is finalized. */
+export const nativeMultisigFactory =
+  '0x7171717171717171717171717171717171717171'
 /** Address of the nonce manager precompile. */
 export const nonceManager = '0x4e4F4E4345000000000000000000000000000000'
-
 /** Address of the PathUSD token. */
 export const pathUsd = '0x20c0000000000000000000000000000000000000'
-
 /** Address of the receive-policy guard precompile. */
 export const receivePolicyGuard = '0xB10C000000000000000000000000000000000000'
-
 /** Address of the signature verifier precompile. */
 export const signatureVerifier = '0x5165300000000000000000000000000000000000'
-
 /** Address of the stablecoin DEX precompile. */
 export const stablecoinDex = '0xdec0000000000000000000000000000000000000'
-
 /** Address of the storage credits precompile. */
 export const storageCredits = '0x1060000000000000000000000000000000000000'
-
 /** Address of the TIP-20 channel reserve precompile. */
 export const tip20ChannelReserve = '0x4d50500000000000000000000000000000000000'
-
 /** Address of the TIP-20 token factory precompile. */
 export const tip20Factory = '0x20fc000000000000000000000000000000000000'
-
 /** Address of the TIP-403 registry precompile. */
 export const tip403Registry = '0x403c000000000000000000000000000000000000'
-
 /** Address of the validator config precompile. */
 export const validator = '0xcccccccc00000000000000000000000000000000'
-
 /** Address of the validator config V2 precompile. */
 export const validatorV2 = '0xcccccccc00000000000000000000000000000001'
-
+export const zoneFactory = '0x5aF2000000000000000000000000000000000000'
+export const zoneMessenger = '0x5A4d000000000000000000000000000000000000'
 /** Address of the zone outbox precompile. */
 export const zoneOutbox = '0x1c00000000000000000000000000000000000002'
+export const zonePortalImplementation =
+  '0x5AD1000000000000000000000000000000000000'
+export const zoneVerifier = '0x5a56000000000000000000000000000000000000'
+
+/**
+ * Returns the Zone portal address for a Zone ID or chain ID.
+ *
+ * @param id - Zone ID or chain ID.
+ * @returns The Zone portal address.
+ */
+export function zonePortal(id: number): `0x${string}` {
+  const zoneId = normalizeZoneId(id)
+
+  // TODO: Remove legacy Zone portal address compatibility.
+  if (zoneId === 6) return '0x7069DeC4E64Fd07334A0933eDe836C17259c9B23'
+  if (zoneId === 7) return '0x3F5296303400B56271b476F5A0B9cBF74350D6Ac'
+  const suffix = Hex.fromNumber(zoneId, { size: 8 }).slice(2)
+  return `0x5ad000000000000000000000${suffix}`
+}
+
+function normalizeZoneId(id: number) {
+  if (id >= legacyZoneChainIdBase && id < legacyZoneChainIdLimit)
+    return id - legacyZoneChainIdBase
+  if (id >= testnetZoneChainIdBase && id < zoneChainIdLimit)
+    return ZoneId.fromChainId(id, 42_431)
+  if (id >= mainnetZoneChainIdBase && id < testnetZoneChainIdBase)
+    return ZoneId.fromChainId(id)
+  return id
+}

package/src/tempo/Capabilities.ts

@@ -1,7 +1,8 @@
-import type { AbiItem, Address, Hex } from 'ox'
+import type * as ExecutionError from './ExecutionError.js'
+import type { Address, Hex } from 'ox'
 import type { TransactionRequest } from 'ox/tempo'
 
-import type { ExactPartial, OneOf } from '../core/internal/types.js'
+import type { ExactPartial } from '../core/internal/types.js'
 
 /** Tempo capability schema, keyed by RPC method. */
 export type Schema = {
@@ -18,6 +19,8 @@ export type Schema = {
 export type FillTransactionRequestCapabilities = {
   /** Whether to include `balanceDiffs` in the response. */
   balanceDiffs?: boolean | undefined
+  /** Whether execution reverts return error capabilities instead of throwing. */
+  errors?: boolean | undefined
 }
 
 /** Capabilities returned by `eth_fillTransaction`. */
@@ -37,18 +40,7 @@ export type FillTransactionCapabilities = {
   balanceDiffs?:
     | Readonly<Record<Address.Address, readonly BalanceDiff[]>>
     | undefined
-  error?:
-    | OneOf<
-        | {
-            abiItem: AbiItem.AbiItem
-            args: readonly unknown[] | undefined
-            data: Hex.Hex
-            errorName: string
-            message: string
-          }
-        | { errorName: 'unknown'; message: string }
-      >
-    | undefined
+  error?: ExecutionError.Rpc | undefined
   fee?:
     | {
         amount: Hex.Hex
@@ -57,7 +49,7 @@ export type FillTransactionCapabilities = {
         symbol: string
       }
     | undefined
-  requireFunds?:
+  insufficientFunds?:
     | {
         amount: Hex.Hex
         decimals: number

package/src/tempo/Client.ts

@@ -7,10 +7,10 @@ import type * as Token from '../core/Token.js'
 import type * as Transport from '../core/Transport.js'
 import { publicActions } from '../core/actions/decorators/public.js'
 import { walletActions } from '../core/actions/decorators/wallet.js'
-import { http } from '../core/transports/http.js'
 import { tokens as tokenSets } from '../tokens/sets.js'
 import { tempo, tempoModerato } from './Chain.js'
 import { type Decorator, tempoActions } from './Decorator.js'
+import { http } from './Transport.js'
 
 /** A Tempo {@link viem_Client.Client}: the base Client decorated with public, wallet, and Tempo actions. */
 export type Client<

package/src/tempo/Decorator.ts

@@ -9,8 +9,10 @@ import * as dex from './actions/dex/index.js'
 import * as earn from './actions/earn.js'
 import * as faucet from './actions/faucet/index.js'
 import * as fee from './actions/fee/index.js'
+import * as multisig from './actions/multisig/index.js'
 import * as nonce from './actions/nonce/index.js'
 import * as policy from './actions/policy/index.js'
+import * as propAmmActions from './actions/propAmm.js'
 import * as receivePolicy from './actions/receivePolicy/index.js'
 import * as token from './actions/token/index.js'
 import * as validator from './actions/validator/index.js'
@@ -53,8 +55,13 @@ export function tempoActions() {
       isWitnessBurned: (options) => accessKey.isWitnessBurned(client, options),
       revoke: (options) => accessKey.revoke(client, options),
       revokeSync: (options) => accessKey.revokeSync(client, options),
-      signAuthorization: (options) =>
-        accessKey.signAuthorization(client, options),
+      signAuthorization: ((options: accessKey.signAuthorization.Options) =>
+        accessKey.signAuthorization(
+          client,
+          options as accessKey.signAuthorization.CoordinatedOptions,
+        )) as Decorator<chain, account>['accessKey']['signAuthorization'],
+      prepareAuthorization: (options) =>
+        accessKey.prepareAuthorization(client, options),
       updateLimit: (options) => accessKey.updateLimit(client, options),
       updateLimitSync: (options) => accessKey.updateLimitSync(client, options),
       verifyHash: (options) => accessKey.verifyHash(client, options),
@@ -125,16 +132,15 @@ export function tempoActions() {
       withdrawSync: (options) => dex.withdrawSync(client, options),
     },
     earn: {
-      bindErc4626Engine: Object.assign(
-        (options: earn.bindErc4626Engine.Parameters) =>
-          earn.bindErc4626Engine(client, options),
+      bindEngine: Object.assign(
+        (options: earn.bindEngine.Parameters) =>
+          earn.bindEngine(client, options),
         {
-          call: earn.bindErc4626Engine.call,
-          extractEvent: earn.bindErc4626Engine.extractEvent,
+          call: earn.bindEngine.call,
+          extractEvent: earn.bindEngine.extractEvent,
         },
       ),
-      bindErc4626EngineSync: (options) =>
-        earn.bindErc4626EngineSync(client, options),
+      bindEngineSync: (options) => earn.bindEngineSync(client, options),
       configureExitSafePolicy: (options) =>
         earn.configureExitSafePolicy(client, options),
       createErc4626Engine: Object.assign(
@@ -283,6 +289,14 @@ export function tempoActions() {
       get: (options) => nonce.get(client, options),
       watchIncremented: (options) => nonce.watchIncremented(client, options),
     },
+    multisig: {
+      getConfig: (options) => multisig.getConfig(client, options),
+      getConfigCommitment: (options) =>
+        multisig.getConfigCommitment(client, options),
+      getOperation: (options) => multisig.getOperation(client, options),
+      updateConfig: (options) => multisig.updateConfig(client, options),
+      updateConfigSync: (options) => multisig.updateConfigSync(client, options),
+    },
     policy: {
       create: (options) => policy.create(client, options),
       createSync: (options) => policy.createSync(client, options),
@@ -303,6 +317,19 @@ export function tempoActions() {
       watchWhitelistUpdated: (options) =>
         policy.watchWhitelistUpdated(client, options),
     },
+    propAmm: {
+      baseToken: (options) => propAmmActions.baseToken(client, options),
+      quoteToken: (options) => propAmmActions.quoteToken(client, options),
+      paused: (options) => propAmmActions.paused(client, options),
+      takerAllowed: (options) => propAmmActions.takerAllowed(client, options),
+      recipientAllowed: (options) =>
+        propAmmActions.recipientAllowed(client, options),
+      resolveRecipient: (options) =>
+        propAmmActions.resolveRecipient(client, options),
+      getSwapQuote: (options) => propAmmActions.getSwapQuote(client, options),
+      swap: (options) => propAmmActions.swap(client, options),
+      swapSync: (options) => propAmmActions.swapSync(client, options),
+    },
     receivePolicy: {
       burn: (options) => receivePolicy.burn(client, options),
       burnSync: (options) => receivePolicy.burnSync(client, options),
@@ -417,6 +444,7 @@ export function tempoActions() {
         zone.encryptedDepositSync(client, options),
       getAuthorizationTokenInfo: (options) =>
         zone.getAuthorizationTokenInfo(client, options),
+      getPortalInfo: (options) => zone.getPortalInfo(client, options),
       getEncryptionKey: (options) => zone.getEncryptionKey(client, options),
       getWithdrawalFee: (options) => zone.getWithdrawalFee(client, options),
       getZoneInfo: (options) => zone.getZoneInfo(client, options),
@@ -728,9 +756,18 @@ export type Decorator<
      * @param options - Options.
      * @returns The signed key authorization.
      */
-    signAuthorization: (
-      options: accessKey.signAuthorization.Options,
-    ) => Promise<accessKey.signAuthorization.ReturnType>
+    signAuthorization: {
+      (
+        options: accessKey.signAuthorization.CoordinatedOptions,
+      ): Promise<accessKey.signAuthorization.CoordinatedReturnType>
+      (
+        options: accessKey.signAuthorization.LocalOptions<account>,
+      ): Promise<accessKey.signAuthorization.ReturnType>
+    }
+    /** Prepares a key authorization for local or multisig signing. */
+    prepareAuthorization: (
+      options: accessKey.prepareAuthorization.Options<account>,
+    ) => Promise<accessKey.prepareAuthorization.ReturnType>
     /**
      * Updates the spending limit for a specific token on an authorized access
      * key.
@@ -2061,16 +2098,16 @@ export type Decorator<
       options: earn.createStackSync.Parameters,
     ) => Promise<earn.createStackSync.ReturnValue>
     /** Binds an ERC-4626 engine to an Earn vault. */
-    bindErc4626Engine: ((
-      options: earn.bindErc4626Engine.Parameters,
-    ) => Promise<earn.bindErc4626Engine.ReturnValue>) & {
-      call: typeof earn.bindErc4626Engine.call
-      extractEvent: typeof earn.bindErc4626Engine.extractEvent
+    bindEngine: ((
+      options: earn.bindEngine.Parameters,
+    ) => Promise<earn.bindEngine.ReturnValue>) & {
+      call: typeof earn.bindEngine.call
+      extractEvent: typeof earn.bindEngine.extractEvent
     }
     /** Binds an ERC-4626 engine and waits for confirmation. */
-    bindErc4626EngineSync: (
-      options: earn.bindErc4626EngineSync.Parameters,
-    ) => Promise<earn.bindErc4626EngineSync.ReturnValue>
+    bindEngineSync: (
+      options: earn.bindEngineSync.Parameters,
+    ) => Promise<earn.bindEngineSync.ReturnValue>
     /** Deploys and binds a complete ERC-4626 Earn stack. */
     deployErc4626StackSync: (
       options: earn.deployErc4626StackSync.Parameters,
@@ -2350,7 +2387,7 @@ export type Decorator<
      *   assetAmount: 100_000_000n,
      *   gateway: '0x…',
      *   recipient: '0x…',
-     *   recoveryRecipient: '0x…',
+     *   tempoRefundRecipient: '0x…',
      *   shareAmountMin: 99_500_000n,
      *   vault: '0x…',
      *   vaultAssetAmountMin: 99_000_000n,
@@ -2394,7 +2431,7 @@ export type Decorator<
      * const prepared = await parentClient.earn.privateRedeem.prepare({
      *   gateway: '0x…',
      *   recipient: '0x…',
-     *   recoveryRecipient: '0x…',
+     *   tempoRefundRecipient: '0x…',
      *   shareAmount: 100_000_000n,
      *   slippageBps: 50,
      *   vault: '0x…',
@@ -2908,6 +2945,25 @@ export type Decorator<
       options?: nonce.watchIncremented.Options,
     ) => nonce.watchIncremented.ReturnType
   }
+  /** Native multisig configuration and coordinated operations. */
+  multisig: {
+    getConfig: (
+      options: multisig.getConfig.Options,
+    ) => Promise<multisig.getConfig.ReturnType>
+    getConfigCommitment: (
+      options: multisig.getConfigCommitment.Options,
+    ) => Promise<multisig.getConfigCommitment.ReturnType>
+    getOperation: (
+      options: multisig.getOperation.Options,
+    ) => Promise<multisig.getOperation.ReturnType>
+    updateConfig: (
+      options: multisig.updateConfig.Options,
+    ) => Promise<multisig.updateConfig.ReturnType>
+    updateConfigSync: (
+      options: multisig.updateConfigSync.Options,
+    ) => Promise<multisig.updateConfigSync.ReturnType>
+  }
+
   policy: {
     /**
      * Creates a TIP-403 transfer policy.
@@ -3223,6 +3279,228 @@ export type Decorator<
       options?: policy.watchWhitelistUpdated.Options,
     ) => policy.watchWhitelistUpdated.ReturnType
   }
+  propAmm: {
+    /**
+     * Reads the base token of a propAMM pool.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const base = await client.propAmm.baseToken({ pool: '0x...' })
+     * ```
+     *
+     * @param parameters - Pool and read options.
+     * @returns The base token address.
+     */
+    baseToken: (
+      parameters: propAmmActions.baseToken.Parameters,
+    ) => Promise<propAmmActions.baseToken.ReturnValue>
+    /**
+     * Quotes an exact input or output for a caller, recipient, and customer route.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const { amountOut, price, updatedAt } = await client.propAmm.getSwapQuote({
+     *   amountIn: 1_000_000n,
+     *   mode: 'exactInput',
+     *   pool: '0x...',
+     *   recipient: '0x...',
+     *   taker: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Route, swap mode, amount, and read options.
+     * @returns Quoted amount, oracle observation, rounding credit, and swap request.
+     */
+    getSwapQuote: <
+      const parameters extends propAmmActions.getSwapQuote.Parameters,
+    >(
+      parameters: parameters,
+    ) => Promise<propAmmActions.getSwapQuote.ReturnValue<parameters>>
+    /**
+     * Reads whether a propAMM pool is paused.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const paused = await client.propAmm.paused({ pool: '0x...' })
+     * ```
+     *
+     * @param parameters - Pool and read options.
+     * @returns Whether swaps are paused.
+     */
+    paused: (
+      parameters: propAmmActions.paused.Parameters,
+    ) => Promise<propAmmActions.paused.ReturnValue>
+    /**
+     * Reads whether a resolved address may receive swap output.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const allowed = await client.propAmm.recipientAllowed({
+     *   pool: '0x...',
+     *   recipient: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Pool, resolved recipient, and read options.
+     * @returns Whether the recipient is allowed.
+     */
+    recipientAllowed: (
+      parameters: propAmmActions.recipientAllowed.Parameters,
+    ) => Promise<propAmmActions.recipientAllowed.ReturnValue>
+    /**
+     * Resolves a Tempo recipient to the address checked by the pool's allowlist.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const resolved = await client.propAmm.resolveRecipient({
+     *   pool: '0x...',
+     *   recipient: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Pool, recipient, and read options.
+     * @returns The resolved recipient address.
+     */
+    resolveRecipient: (
+      parameters: propAmmActions.resolveRecipient.Parameters,
+    ) => Promise<propAmmActions.resolveRecipient.ReturnValue>
+    /**
+     * Reads the quote token of a propAMM pool.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const quote = await client.propAmm.quoteToken({ pool: '0x...' })
+     * ```
+     *
+     * @param parameters - Pool and read options.
+     * @returns The quote token address.
+     */
+    quoteToken: (
+      parameters: propAmmActions.quoteToken.Parameters,
+    ) => Promise<propAmmActions.quoteToken.ReturnValue>
+    /**
+     * Approves the input token and swaps an exact input or output in one transaction.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     * const hash = await client.propAmm.swap({
+     *   amountIn: 1_000_000n,
+     *   expectedOraclePrice: 1_000_000_000_000_000_000n,
+     *   minAmountOut: 1_000_000n,
+     *   minimumOracleUpdatedAt: 1_799_999_000n,
+     *   mode: 'exactInput',
+     *   pool: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Swap and transaction options.
+     * @returns The transaction hash.
+     */
+    swap: (
+      parameters: propAmmActions.swap.Parameters<chain, account>,
+    ) => Promise<propAmmActions.swap.ReturnValue>
+    /**
+     * Approves the input token, swaps, and returns the confirmed trade and receipt.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     * const trade = await client.propAmm.swapSync({
+     *   amountOut: 1_000_000n,
+     *   baseToQuote: false,
+     *   expectedOraclePrice: 1_000_000_000_000_000_000n,
+     *   maxAmountIn: 1_010_000n,
+     *   minimumOracleUpdatedAt: 1_799_999_000n,
+     *   mode: 'exactOutput',
+     *   pool: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Swap and transaction options.
+     * @returns Confirmed trade data and receipt.
+     */
+    swapSync: (
+      parameters: propAmmActions.swapSync.Parameters<chain, account>,
+    ) => Promise<propAmmActions.swapSync.ReturnValue>
+    /**
+     * Reads whether an address may call swaps on a propAMM pool.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const allowed = await client.propAmm.takerAllowed({
+     *   pool: '0x...',
+     *   taker: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Pool, taker, and read options.
+     * @returns Whether the taker is allowed.
+     */
+    takerAllowed: (
+      parameters: propAmmActions.takerAllowed.Parameters,
+    ) => Promise<propAmmActions.takerAllowed.ReturnValue>
+  }
   receivePolicy: {
     /**
      * Burns the funds backing a blocked receipt.
@@ -5236,6 +5514,10 @@ export type Decorator<
      * @param options - Options.
      * @returns The active encryption key and its zero-based index.
      */
+    /** Gets a Zone portal's configuration and metadata. */
+    getPortalInfo: (
+      options: zone.getPortalInfo.Options,
+    ) => Promise<zone.getPortalInfo.ReturnType>
     getEncryptionKey: (
       options: zone.getEncryptionKey.Options,
     ) => Promise<zone.getEncryptionKey.ReturnType>