viem 2.52.0 → 2.53.1

package/tempo/Account.ts

@@ -4,7 +4,12 @@ import * as P256 from 'ox/P256'
 import * as PublicKey from 'ox/PublicKey'
 import * as Secp256k1 from 'ox/Secp256k1'
 import * as Signature from 'ox/Signature'
-import { Channel, KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
+import {
+  Channel,
+  KeyAuthorization,
+  MultisigConfig,
+  SignatureEnvelope,
+} from 'ox/tempo'
 import * as WebAuthnP256 from 'ox/WebAuthnP256'
 import * as WebCryptoP256 from 'ox/WebCryptoP256'
 import type {
@@ -269,6 +274,78 @@ export declare namespace fromSecp256k1 {
     from.ReturnValue<options>
 }
 
+/**
+ * Instantiates a synthetic Account for a native multisig (TIP-1061) config.
+ *
+ * The returned account does not hold a key. It is used purely to drive the
+ * standard `sendTransaction` flow: it derives the multisig address from the
+ * config and passes the prepared request (carrying the collected owner
+ * `signatures`) through to the chain serializer, which combines the approvals
+ * into the multisig signature envelope.
+ *
+ * Owner approvals are produced separately by signing with `multisig` request
+ * metadata (see `signTransaction`), and provided here via `signatures`.
+ *
+ * Accepts a raw config and normalizes it internally (via `MultisigConfig.from`),
+ * so callers don't need to call `MultisigConfig.from` themselves.
+ *
+ * @example
+ * ```ts
+ * import { Account } from 'viem/tempo'
+ *
+ * const account = Account.fromMultisig({
+ *   threshold: 2,
+ *   owners: [
+ *     { owner: owner_1.address, weight: 1 },
+ *     { owner: owner_2.address, weight: 1 },
+ *   ],
+ * })
+ *
+ * // Pass the account to `prepareTransactionRequest` — the multisig config is
+ * // inferred from it, so no `multisig` field is needed.
+ * const request = await client.prepareTransactionRequest({ account, ...rest })
+ *
+ * // The prepared request carries the multisig account as sender, so it doesn't
+ * // need to be re-passed to `sendTransaction`.
+ * const transaction = await client.sendTransaction({
+ *   ...request,
+ *   signatures: [signature_1, signature_2],
+ * })
+ * ```
+ *
+ * @param config Multisig config (raw or from `MultisigConfig.from`).
+ * @returns Multisig account.
+ */
+export function fromMultisig(config: MultisigConfig.Config): MultisigAccount {
+  const normalized = MultisigConfig.from(config)
+  const address = Address.checksum(MultisigConfig.getAddress(normalized))
+  return {
+    address,
+    config: normalized,
+    publicKey: '0x',
+    source: 'multisig',
+    type: 'local',
+    async sign() {
+      throw new Error('`sign` is not supported for multisig accounts.')
+    },
+    async signMessage() {
+      throw new Error('`signMessage` is not supported for multisig accounts.')
+    },
+    async signTransaction(transaction, options) {
+      const { serializer = Transaction.serialize } = options ?? {}
+      return (await serializer(transaction as never)) as Hex.Hex
+    },
+    async signTypedData() {
+      throw new Error('`signTypedData` is not supported for multisig accounts.')
+    },
+  }
+}
+
+export type MultisigAccount = LocalAccount<'multisig'> & {
+  /** Multisig config (from `MultisigConfig.from`). */
+  config: MultisigConfig.Config
+}
+
 /**
  * Instantiates an Account from a WebAuthn credential.
  *
@@ -594,9 +671,25 @@ function fromBase(parameters: fromBase.Parameters): Account_base {
           return { ...transaction, feePayerSignature: null }
         return transaction
       })()
-      const signature = await sign({
-        hash: keccak256(await serializer(presign)),
-      })
+
+      const payload = keccak256(await serializer(presign))
+
+      // Native multisig (TIP-1061): return this owner's approval — a serialized
+      // primitive signature over the multisig owner approval digest — instead of
+      // a full serialized transaction. Approvals are combined later in
+      // `sendTransaction({ signatures })`.
+      const multisig = (
+        transaction as { multisig?: MultisigConfig.Config | undefined }
+      ).multisig
+      if (multisig) {
+        const digest = MultisigConfig.getSignPayload({
+          payload,
+          genesisConfig: multisig,
+        })
+        return await sign({ hash: digest, raw: true })
+      }
+
+      const signature = await sign({ hash: payload })
       const envelope = SignatureEnvelope.from(signature)
       return await serializer(transaction, envelope as never)
     },

package/tempo/Client.ts

@@ -0,0 +1,172 @@
+import type { Address } from 'abitype'
+import type { TokenId } from 'ox/tempo'
+
+import type { JsonRpcAccount } from '../accounts/types.js'
+import {
+  type Client as Client_,
+  type ClientConfig as ClientConfig_,
+  createClient as createClient_,
+} from '../clients/createClient.js'
+import {
+  type PublicActions,
+  publicActions,
+} from '../clients/decorators/public.js'
+import {
+  type WalletActions,
+  walletActions,
+} from '../clients/decorators/wallet.js'
+import type { Transport } from '../clients/transports/createTransport.js'
+import { http } from '../clients/transports/http.js'
+import type { ErrorType } from '../errors/utils.js'
+import type { Account } from '../types/account.js'
+import type { Chain } from '../types/chain.js'
+import type { RpcSchema } from '../types/eip1193.js'
+import type { Prettify } from '../types/utils.js'
+import { tempo, tempoTestnet } from './Chain.js'
+import { type Decorator, decorator as tempoActions } from './Decorator.js'
+
+/**
+ * Configuration for a Tempo {@link Client}.
+ *
+ * Extends Viem's {@link ClientConfig} with Tempo-specific defaults: `chain`
+ * and `transport` become optional, and a `testnet` flag is added to select
+ * the Tempo testnet chain.
+ */
+export type ClientConfig<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  accountOrAddress extends Account | Address | undefined =
+    | Account
+    | Address
+    | undefined,
+  rpcSchema extends RpcSchema | undefined = undefined,
+> = Prettify<
+  Omit<
+    ClientConfig_<transport, chain, accountOrAddress, rpcSchema>,
+    'chain' | 'transport'
+  > & {
+    /**
+     * Chain for the Client.
+     *
+     * @default tempo (or `tempoTestnet` when `testnet` is truthy)
+     */
+    chain?: chain | Chain | undefined
+    /**
+     * Default fee token for the Client. Extended onto the chain so it applies
+     * to every transaction sent with the Client.
+     */
+    feeToken?: TokenId.TokenIdOrAddress | undefined
+    /**
+     * Whether to use the Tempo testnet chain.
+     *
+     * Ignored when `chain` is provided.
+     *
+     * @default false
+     */
+    testnet?: boolean | undefined
+    /**
+     * The RPC transport.
+     *
+     * @default http()
+     */
+    transport?: transport | Transport | undefined
+  }
+>
+
+/**
+ * A Tempo {@link Client}: Viem's base Client decorated with
+ * `publicActions`, `walletActions`, and `tempoActions`.
+ */
+export type Client<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  rpcSchema extends RpcSchema | undefined = undefined,
+> = Prettify<
+  Client_<
+    transport,
+    chain,
+    account,
+    rpcSchema,
+    PublicActions<transport, chain, account> &
+      WalletActions<chain, account> &
+      Decorator<chain, account>
+  >
+>
+
+export type CreateClientErrorType = ErrorType
+
+/**
+ * Creates a Tempo {@link Client}: an extension of Viem's `createClient`
+ * decorated with `publicActions`, `walletActions`, and `tempoActions`.
+ *
+ * Defaults to the `tempo` mainnet chain and `http` transport, so a minimal
+ * client can be created with `createClient()`. Pass `testnet` to use the
+ * Tempo testnet, or `chain` to override the chain entirely. Pass `feeToken`
+ * to set a default fee token for every transaction.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem/tempo'
+ *
+ * // Minimal client (tempo mainnet, http transport).
+ * const client = createClient()
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { Account, createClient, http } from 'viem/tempo'
+ *
+ * // Testnet client with an account and custom transport.
+ * const client = createClient({
+ *   account: Account.fromSecp256k1('0x...'),
+ *   testnet: true,
+ *   transport: http('https://rpc.example.com'),
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem/tempo'
+ *
+ * // Client with a default fee token.
+ * const client = createClient({
+ *   feeToken: '0x20c0000000000000000000000000000000000001',
+ * })
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns The Tempo Client.
+ */
+export function createClient<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = typeof tempo,
+  accountOrAddress extends Account | Address | undefined = undefined,
+  rpcSchema extends RpcSchema | undefined = undefined,
+>(
+  parameters: ClientConfig<transport, chain, accountOrAddress, rpcSchema> = {},
+): Client<
+  transport,
+  chain,
+  accountOrAddress extends Address
+    ? Prettify<JsonRpcAccount<accountOrAddress>>
+    : accountOrAddress,
+  rpcSchema
+> {
+  const { chain, feeToken, testnet, transport, ...rest } = parameters
+  const baseChain = chain ?? (testnet ? tempoTestnet : tempo)
+  const resolvedChain =
+    feeToken && typeof (baseChain as { extend?: unknown }).extend === 'function'
+      ? (baseChain as { extend: (e: { feeToken: unknown }) => Chain }).extend({
+          feeToken,
+        })
+      : baseChain
+  return createClient_({
+    ...rest,
+    chain: resolvedChain,
+    transport: transport ?? http(),
+  } as ClientConfig_)
+    .extend(publicActions)
+    .extend(walletActions)
+    .extend(tempoActions()) as never
+}

package/tempo/Formatters.ts

@@ -79,6 +79,8 @@ export function formatTransactionRequest(
     keyData?: Hex.Hex | undefined
     keyId?: Address | undefined
     keyType?: 'p256' | 'secp256k1' | 'webAuthn' | undefined
+    multisig?: unknown
+    signatures?: unknown
   }
   const account = request.account
     ? parseAccount<Account | viem_Account | Address>(request.account)
@@ -116,8 +118,17 @@ export function formatTransactionRequest(
   if (request.feePayer === true && !request.feePayerSignature)
     delete request.feeToken
 
+  // `multisig` / `signatures` are client-side only (TIP-1061). They drive
+  // sender derivation, owner signing, and final envelope assembly, but are
+  // never sent as raw RPC fields — the wire payload is the serialized tx.
+  const {
+    multisig: _multisig,
+    signatures: _signatures,
+    ...rpcRequest
+  } = request
+
   const rpc = ox_TransactionRequest.toRpc({
-    ...request,
+    ...rpcRequest,
     type: 'tempo',
   } as never)
 

package/tempo/Scopes.ts

@@ -0,0 +1,124 @@
+import type { Address } from 'abitype'
+import type { KeyAuthorization } from 'ox/tempo'
+import * as Selectors from './Selectors.js'
+
+export type Selector = NonNullable<KeyAuthorization.Scope['selector']>
+
+export type Options = {
+  /** Recipient allowlist for selectors that support recipient restrictions. */
+  recipients?: readonly Address[] | undefined
+}
+
+export type Scope<
+  address extends Address = Address,
+  selector extends Selector | undefined = Selector | undefined,
+> = Omit<KeyAuthorization.Scope, 'address' | 'recipients' | 'selector'> & {
+  address: address
+  recipients?: readonly Address[] | undefined
+  selector?: selector | undefined
+}
+
+export type Target<address extends Address = Address> = {
+  /** Allows any selector on the target. */
+  any: () => Scope<address, undefined>
+  /** Allows calls matching the selector on the target. */
+  selector: <selector extends Selector>(
+    selector: selector,
+    options?: Options | undefined,
+  ) => Scope<address, selector>
+}
+
+export type SelectorMap = Record<string, Selector | Record<string, Selector>>
+
+export type Contract<
+  address extends Address = Address,
+  selectors extends SelectorMap = SelectorMap,
+> = Target<address> & {
+  readonly [name in keyof selectors]: selectors[name] extends Selector
+    ? (options?: Options | undefined) => Scope<address, selectors[name]>
+    : selectors[name] extends Record<string, Selector>
+      ? OverloadedSelector<address, selectors[name]>
+      : never
+}
+
+export type OverloadedSelector<
+  address extends Address = Address,
+  selectors extends Record<string, Selector> = Record<string, Selector>,
+> = {
+  readonly [signature in keyof selectors]: (
+    options?: Options | undefined,
+  ) => Scope<address, selectors[signature]>
+} & {
+  selector: <signature extends keyof selectors>(
+    signature: signature,
+    options?: Options | undefined,
+  ) => Scope<address, selectors[signature]>
+}
+
+export type Tip20<address extends Address = Address> = Contract<
+  address,
+  typeof Selectors.tip20
+>
+
+/**
+ * Creates a call scope builder for an arbitrary target.
+ *
+ * @experimental
+ */
+export function target<address extends Address>(
+  address: address,
+): Target<address> {
+  return {
+    any: () => ({ address }),
+    selector: (selector, options) => ({
+      address,
+      ...(options && 'recipients' in options
+        ? { recipients: options.recipients }
+        : {}),
+      selector,
+    }),
+  }
+}
+
+/**
+ * Creates a typed call scope builder from a selector map.
+ *
+ * @experimental
+ */
+export function contract<
+  address extends Address,
+  selectors extends SelectorMap,
+>(address: address, selectors: selectors): Contract<address, selectors> {
+  const target_ = target(address)
+  const result: Record<string, unknown> = { ...target_ }
+
+  for (const [name, selector] of Object.entries(selectors)) {
+    if (typeof selector === 'string') {
+      result[name] = (options?: Options | undefined) =>
+        target_.selector(selector, options)
+      continue
+    }
+
+    const overloads: Record<string, unknown> = {}
+    for (const [signature, overloadSelector] of Object.entries(selector)) {
+      overloads[signature] = (options?: Options | undefined) =>
+        target_.selector(overloadSelector, options)
+    }
+    overloads.selector = (signature: string, options?: Options | undefined) =>
+      target_.selector(selector[signature]!, options)
+    result[name] = overloads
+  }
+
+  return result as Contract<address, selectors>
+}
+
+/**
+ * Creates a call scope builder for a TIP-20 token.
+ *
+ * @experimental
+ */
+export function tip20<address extends Address>(
+  address: address,
+): Tip20<address> {
+  return contract(address, Selectors.tip20)
+}

package/tempo/Selectors.ts

@@ -0,0 +1,260 @@
+// Generated with `pnpm gen:abis`. Do not modify manually.
+
+import type { Abi, ExtractAbiFunctionNames } from 'abitype'
+import type { Hex } from '../types/misc.js'
+import type * as Abis from './Abis.js'
+
+type FunctionSelectors<abi extends Abi, excluded extends string = never> = {
+  readonly [name in Exclude<ExtractAbiFunctionNames<abi>, excluded>]: Hex
+}
+
+type OverloadedFunctionSelectors<names extends string> = {
+  readonly [name in names]: Record<string, Hex>
+}
+
+export const accountKeychain = {
+  authorizeAdminKey: '0x9a424307',
+  authorizeKey: {
+    'authorizeKey(address,uint8,(uint64,bool,(address,uint256,uint64)[],bool,(address,(bytes4,address[])[])[]))':
+      '0x980a6025',
+    'authorizeKey(address,uint8,(uint64,bool,(address,uint256,uint64)[],bool,(address,(bytes4,address[])[])[]),bytes32)':
+      '0xe3c154d2',
+    'authorizeKey(address,uint8,uint64,bool,(address,uint256)[])': '0x54063a55',
+  },
+  burnKeyAuthorizationWitness: '0xcff31c46',
+  getAllowedCalls: '0x0163e7ec',
+  getKey: '0xbc298553',
+  getRemainingLimit: '0x63b4290d',
+  getRemainingLimitWithPeriod: '0xa7f72cab',
+  getTransactionKey: '0xb07fbc1a',
+  isAdminKey: '0x9009a18d',
+  isKeyAuthorizationWitnessBurned: '0x8e6c7e11',
+  removeAllowedCalls: '0xf3941811',
+  revokeKey: '0x5ae7ab32',
+  setAllowedCalls: '0xf5456703',
+  updateSpendingLimit: '0xcbbb4480',
+} as const satisfies FunctionSelectors<
+  typeof Abis.accountKeychain,
+  'authorizeKey'
+> &
+  OverloadedFunctionSelectors<'authorizeKey'>
+
+export const addressRegistry = {
+  decodeVirtualAddress: '0xb35d6fb9',
+  getMaster: '0xd84ab166',
+  isImplicitlyApproved: '0xa8da6aa7',
+  isVirtualAddress: '0xd501235a',
+  registerVirtualMaster: '0x5c559d20',
+  resolveRecipient: '0xfbea9d67',
+  resolveVirtualAddress: '0xe2fc56ef',
+} as const satisfies FunctionSelectors<typeof Abis.addressRegistry>
+
+export const nonce = {
+  getNonce: '0x89535803',
+} as const satisfies FunctionSelectors<typeof Abis.nonce>
+
+export const receivePolicyGuard = {
+  balanceOf: '0x78415365',
+  burnBlockedReceipt: '0x96c1264c',
+  claim: '0xbb1757cf',
+} as const satisfies FunctionSelectors<typeof Abis.receivePolicyGuard>
+
+export const signatureVerifier = {
+  recover: '0x19045a25',
+  verify: '0x1a86b550',
+  verifyKeychain: '0x6c0c731e',
+  verifyKeychainAdmin: '0x5f6fc5b7',
+} as const satisfies FunctionSelectors<typeof Abis.signatureVerifier>
+
+export const stablecoinDex = {
+  MAX_PRICE: '0x01c11d96',
+  MAX_TICK: '0x6882a888',
+  MIN_ORDER_AMOUNT: '0x40bf2aa4',
+  MIN_PRICE: '0xad9f20a6',
+  MIN_TICK: '0xa1634b14',
+  PRICE_SCALE: '0xc33f59d3',
+  TICK_SPACING: '0x46ca626b',
+  balanceOf: '0xf7888aec',
+  books: '0x0c0dee70',
+  cancel: '0x81649d06',
+  cancelStaleOrder: '0x928b0e7f',
+  createPair: '0x9ccb0744',
+  getOrder: '0x117d4128',
+  getTickLevel: '0x949bc662',
+  nextOrderId: '0x2a58b330',
+  pairKey: '0xcd27ca82',
+  place: '0x63813125',
+  placeFlip: '0x922828f1',
+  priceToTick: '0x87b4e352',
+  quoteSwapExactAmountIn: '0xe7c98f1a',
+  quoteSwapExactAmountOut: '0x1576fa0e',
+  swapExactAmountIn: '0xf8856c0f',
+  swapExactAmountOut: '0xf0122b75',
+  tickToPrice: '0x269a311d',
+  withdraw: '0x08fab167',
+} as const satisfies FunctionSelectors<typeof Abis.stablecoinDex>
+
+export const tip20 = {
+  BURN_BLOCKED_ROLE: '0x32ad9be8',
+  DOMAIN_SEPARATOR: '0x3644e515',
+  ISSUER_ROLE: '0x82aefa24',
+  PAUSE_ROLE: '0x389ed267',
+  UNPAUSE_ROLE: '0x309756fb',
+  allowance: '0xdd62ed3e',
+  approve: '0x095ea7b3',
+  balanceOf: '0x70a08231',
+  burn: '0x42966c68',
+  burnBlocked: '0xec0cf3dc',
+  burnWithMemo: '0x38f23b0b',
+  changeTransferPolicyId: '0xfd5e9420',
+  claimRewards: '0x372500ab',
+  completeQuoteTokenUpdate: '0x638bc4a3',
+  currency: '0xe5a6b10f',
+  decimals: '0x313ce567',
+  distributeReward: '0x940a4e45',
+  getPendingRewards: '0xf6ed2017',
+  getRoleAdmin: '0x248a9ca3',
+  globalRewardPerToken: '0x726ce324',
+  grantRole: '0x2f2ff15d',
+  hasRole: '0xac4ab3fb',
+  logoURI: '0x6bb38b28',
+  mint: '0x40c10f19',
+  mintWithMemo: '0xe44f0b12',
+  name: '0x06fdde03',
+  nextQuoteToken: '0x7d0819b7',
+  nonces: '0x7ecebe00',
+  optedInSupply: '0x8ef39dce',
+  pause: '0x8456cb59',
+  paused: '0x5c975abb',
+  permit: '0xd505accf',
+  quoteToken: '0x217a4b70',
+  renounceRole: '0x8bb9c5bf',
+  revokeRole: '0xd547741f',
+  setLogoURI: '0xc30ff6df',
+  setNextQuoteToken: '0x4593223f',
+  setRewardRecipient: '0xe521136f',
+  setRoleAdmin: '0x1e4e0091',
+  setSupplyCap: '0xb6a3f59a',
+  supplyCap: '0x8f770ad0',
+  symbol: '0x95d89b41',
+  totalSupply: '0x18160ddd',
+  transfer: '0xa9059cbb',
+  transferFrom: '0x23b872dd',
+  transferFromWithMemo: '0x929c2539',
+  transferPolicyId: '0x9c4bad29',
+  transferWithMemo: '0x95777d59',
+  unpause: '0x3f4ba83a',
+  userRewardInfo: '0x360b8ed9',
+} as const satisfies FunctionSelectors<typeof Abis.tip20>
+
+export const tip20ChannelReserve = {
+  CLOSE_GRACE_PERIOD: '0x956c8327',
+  VOUCHER_TYPEHASH: '0x94739e87',
+  close: '0x73b57f74',
+  computeChannelId: '0x185eeeac',
+  domainSeparator: '0xf698da25',
+  getChannel: '0xeef95313',
+  getChannelState: '0xd18da8b1',
+  getChannelStatesBatch: '0xd1f4cda2',
+  getVoucherDigest: '0xf3b349e8',
+  open: '0xedc53b00',
+  requestClose: '0x675402e5',
+  settle: '0x97fb5104',
+  topUp: '0xdc48471e',
+  withdraw: '0x41e2c664',
+} as const satisfies FunctionSelectors<typeof Abis.tip20ChannelReserve>
+
+export const tip20Factory = {
+  createToken: {
+    'createToken(string,string,string,address,address,bytes32)': '0x68130445',
+    'createToken(string,string,string,address,address,bytes32,string)':
+      '0x5323d222',
+  },
+  getTokenAddress: '0x9ed7cd64',
+  isTIP20: '0x35ec42c9',
+} as const satisfies FunctionSelectors<
+  typeof Abis.tip20Factory,
+  'createToken'
+> &
+  OverloadedFunctionSelectors<'createToken'>
+
+export const tip403Registry = {
+  compoundPolicyData: '0xb6266019',
+  createCompoundPolicy: '0x5da414ee',
+  createPolicy: '0xca5d55f6',
+  createPolicyWithAccounts: '0xa2d3044f',
+  isAuthorized: '0x55a1179e',
+  isAuthorizedMintRecipient: '0xb389e305',
+  isAuthorizedRecipient: '0x6fbc13d6',
+  isAuthorizedSender: '0x14abd81d',
+  modifyPolicyBlacklist: '0xc62b27d4',
+  modifyPolicyWhitelist: '0x71ec67a3',
+  policyData: '0x50214329',
+  policyExists: '0x330f5637',
+  policyIdCounter: '0x3cc32f9c',
+  receivePolicy: '0xe111e611',
+  setPolicyAdmin: '0x25f7d376',
+  setReceivePolicy: '0xdda03d86',
+  validateReceivePolicy: '0xb72b0c59',
+} as const satisfies FunctionSelectors<typeof Abis.tip403Registry>
+
+export const feeManager = {
+  collectedFees: '0x4c97f766',
+  distributeFees: '0xa6c07924',
+  setUserToken: '0xe7897444',
+  setValidatorToken: '0xb60d2ddb',
+  userTokens: '0xed498fa8',
+  validatorTokens: '0x6dc54a7a',
+} as const satisfies FunctionSelectors<typeof Abis.feeManager>
+
+export const feeAmm = {
+  M: '0x693f917e',
+  MIN_LIQUIDITY: '0x21b77d63',
+  N: '0xc9e525df',
+  SCALE: '0xeced5526',
+  burn: '0xfa291e53',
+  getPool: '0x531aa03e',
+  getPoolId: '0x2ef61c21',
+  liquidityBalances: '0x4fb5bf7f',
+  mint: '0xf1aa8cb8',
+  pools: '0xb5217bb4',
+  rebalanceSwap: '0x1bd94ac7',
+  totalSupply: '0xb524abcf',
+} as const satisfies FunctionSelectors<typeof Abis.feeAmm>
+
+export const validatorConfig = {
+  addValidator: '0xffb4822e',
+  changeOwner: '0xa6f9dae1',
+  changeValidatorStatus: '0xa1b3f4a9',
+  changeValidatorStatusByIndex: '0x5aa3d0e1',
+  getNextFullDkgCeremony: '0x281a69ec',
+  getValidators: '0xb7ab4db5',
+  owner: '0x8da5cb5b',
+  setNextFullDkgCeremony: '0xc3576d46',
+  updateValidator: '0x09970c76',
+  validatorCount: '0x0f43a677',
+  validators: '0xfa52c7d8',
+  validatorsArray: '0x031fadbd',
+} as const satisfies FunctionSelectors<typeof Abis.validatorConfig>
+
+export const validatorConfigV2 = {
+  addValidator: '0x6dcf616a',
+  deactivateValidator: '0x8f289544',
+  getActiveValidators: '0x9de70258',
+  getInitializedAtHeight: '0xf926b083',
+  getNextNetworkIdentityRotationEpoch: '0x42739f79',
+  initializeIfMigrated: '0x2f88bb4f',
+  isInitialized: '0x392e53cd',
+  migrateValidator: '0xc8e73200',
+  owner: '0x8da5cb5b',
+  rotateValidator: '0x82f20dbe',
+  setFeeRecipient: '0x572e4068',
+  setIpAddresses: '0x55f25dc6',
+  setNetworkIdentityRotationEpoch: '0xcb8425d2',
+  transferOwnership: '0xf2fde38b',
+  transferValidatorOwnership: '0x9e38a5f1',
+  validatorByAddress: '0x1a6dda94',
+  validatorByIndex: '0xecb14a34',
+  validatorByPublicKey: '0x1b425d5e',
+  validatorCount: '0x0f43a677',
+} as const satisfies FunctionSelectors<typeof Abis.validatorConfigV2>