viem 2.54.0 → 2.54.2

package/chains/index.ts

@@ -392,6 +392,7 @@ export { mantraDuKongEVMTestnet } from './definitions/mantraDuKongEVMTestnet.js'
 export { mantraEVM } from './definitions/mantraEVM.js'
 export { mapProtocol } from './definitions/mapProtocol.js'
 export { marooTestnet } from './definitions/marooTestnet.js'
+export { marsCredit } from './definitions/marsCredit.js'
 export { matchain } from './definitions/matchain.js'
 export { matchainTestnet } from './definitions/matchainTestnet.js'
 export { mchVerse } from './definitions/mchVerse.js'

package/clients/createClient.ts

@@ -349,9 +349,10 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 /**
  * Binds an action function to a `client`, returning a parameter-only version
  * along with any helpers the action exposes. Helpers that need a client
- * (`.call`, `.calls`, `.callWithPeriod`, `.estimateGas`, `.simulate`) are bound
- * to `client`; pure helpers (`.extractEvent`, `.extractEvents`) are copied
- * as-is. Used by decorators that attach namespaced actions to a Client.
+ * (`.call`, `.calls`, `.callWithPeriod`, `.estimateGas`, `.prepare`,
+ * `.simulate`) are bound to `client`; pure helpers (`.extractEvent`,
+ * `.extractEvents`) are copied as-is. Used by decorators that attach
+ * namespaced actions to a Client.
  * @internal
  */
 export function bindActionDecorators(
@@ -364,6 +365,7 @@ export function bindActionDecorators(
     'calls',
     'callWithPeriod',
     'estimateGas',
+    'prepare',
     'simulate',
   ] as const)
     if (Object.hasOwn(action, key)) {

package/errors/encoding.ts

@@ -77,6 +77,32 @@ export class RlpDepthLimitExceededError extends BaseError {
   }
 }
 
+export type RlpListBoundaryExceededErrorType = RlpListBoundaryExceededError & {
+  name: 'RlpListBoundaryExceededError'
+}
+export class RlpListBoundaryExceededError extends BaseError {
+  constructor({ consumed, declared }: { consumed: number; declared: number }) {
+    super(
+      `RLP list items consumed \`${consumed}\` bytes but the list declared a length of \`${declared}\`.`,
+      { name: 'RlpListBoundaryExceededError' },
+    )
+  }
+}
+
+export type RlpTrailingBytesErrorType = RlpTrailingBytesError & {
+  name: 'RlpTrailingBytesError'
+}
+export class RlpTrailingBytesError extends BaseError {
+  constructor({ count }: { count: number }) {
+    super(
+      `RLP payload encodes a single item, but \`${count}\` trailing ${
+        count === 1 ? 'byte remains' : 'bytes remain'
+      }.`,
+      { name: 'RlpTrailingBytesError' },
+    )
+  }
+}
+
 export type SizeOverflowErrorType = SizeOverflowError & {
   name: 'SizeOverflowError'
 }

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.54.0'
+export const version = '2.54.2'

package/index.ts

@@ -880,6 +880,10 @@ export {
   type InvalidHexValueErrorType,
   RlpDepthLimitExceededError,
   type RlpDepthLimitExceededErrorType,
+  RlpListBoundaryExceededError,
+  type RlpListBoundaryExceededErrorType,
+  RlpTrailingBytesError,
+  type RlpTrailingBytesErrorType,
   SizeOverflowError,
   type SizeOverflowErrorType,
 } from './errors/encoding.js'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.54.0",
+  "version": "2.54.2",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -235,7 +235,7 @@
     "abitype": "1.2.3",
     "isows": "1.0.7",
     "ox": "0.14.29",
-    "ws": "8.20.1"
+    "ws": "8.21.0"
   },
   "license": "MIT",
   "homepage": "https://viem.sh",

package/tempo/Abis.ts

@@ -2570,6 +2570,54 @@ export const validatorConfig = [
   },
 ] as const
 
+export const storageCredits = [
+  {
+    type: 'error',
+    name: 'DelegateCallNotAllowed',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'InvalidMode',
+    inputs: [],
+  },
+  {
+    type: 'function',
+    name: 'balanceOf',
+    stateMutability: 'view',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [{ type: 'uint64' }],
+  },
+  {
+    type: 'function',
+    name: 'modeOf',
+    stateMutability: 'view',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [{ type: 'uint8' }],
+  },
+  {
+    type: 'function',
+    name: 'budgetOf',
+    stateMutability: 'view',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [{ type: 'uint64' }],
+  },
+  {
+    type: 'function',
+    name: 'setMode',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'newMode', type: 'uint8' }],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'setBudget',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'creditBudget', type: 'uint64' }],
+    outputs: [],
+  },
+] as const
+
 export const validatorConfigV2 = [
   {
     name: 'getActiveValidators',
@@ -2931,6 +2979,7 @@ export const abis = [
   ...receivePolicyGuard,
   ...signatureVerifier,
   ...stablecoinDex,
+  ...storageCredits,
   ...tip20,
   ...tip20ChannelReserve,
   ...tip20Factory,

package/tempo/Addresses.ts

@@ -9,6 +9,8 @@ export const pathUsd = '0x20c0000000000000000000000000000000000000'
 export const receivePolicyGuard = '0xB10C000000000000000000000000000000000000'
 export const signatureVerifier = '0x5165300000000000000000000000000000000000'
 export const stablecoinDex = '0xdec0000000000000000000000000000000000000'
+export const storageCredits = '0x1060000000000000000000000000000000000000'
+export const tip20ChannelReserve = '0x4d50500000000000000000000000000000000000'
 export const tip20Factory = '0x20fc000000000000000000000000000000000000'
 export const tip403Registry = '0x403c000000000000000000000000000000000000'
 export const validator = '0xcccccccc00000000000000000000000000000000'

package/tempo/Client.ts

@@ -18,6 +18,7 @@ import {
 import type { Transport } from '../clients/transports/createTransport.js'
 import { http } from '../clients/transports/http.js'
 import type { ErrorType } from '../errors/utils.js'
+import { tokens as tokenSets } from '../tokens/sets.js'
 import type { Account } from '../types/account.js'
 import type { Chain } from '../types/chain.js'
 import type { RpcSchema } from '../types/eip1193.js'
@@ -155,7 +156,7 @@ export function createClient<
     : accountOrAddress,
   rpcSchema
 > {
-  const { chain, feeToken, testnet, transport, ...rest } = parameters
+  const { chain, feeToken, testnet, tokens, transport, ...rest } = parameters
   const baseChain = chain ?? (testnet ? tempoTestnet : tempo)
   const resolvedChain =
     feeToken && typeof (baseChain as { extend?: unknown }).extend === 'function'
@@ -166,6 +167,7 @@ export function createClient<
   return createClient_({
     ...rest,
     chain: resolvedChain,
+    tokens: tokens ?? tokenSets.tempo,
     transport: transport ?? http(),
   } as ClientConfig_)
     .extend(publicActions)

package/tempo/Decorator.ts

@@ -5129,6 +5129,9 @@ type BoundActionHelpers<action> = (action extends { call: infer helper }
   (action extends { estimateGas: infer helper }
     ? { estimateGas: BoundHelper<helper> }
     : {}) &
+  (action extends { prepare: infer helper }
+    ? { prepare: BoundHelper<helper> }
+    : {}) &
   (action extends { simulate: infer helper }
     ? { simulate: BoundHelper<helper> }
     : {}) &

package/tempo/Selectors.ts

@@ -94,6 +94,14 @@ export const stablecoinDex = {
   withdraw: '0x08fab167',
 } as const satisfies FunctionSelectors<typeof Abis.stablecoinDex>
 
+export const storageCredits = {
+  balanceOf: '0x70a08231',
+  budgetOf: '0x7865e71f',
+  modeOf: '0x13668995',
+  setBudget: '0xffe295c3',
+  setMode: '0x21175b4a',
+} as const satisfies FunctionSelectors<typeof Abis.storageCredits>
+
 export const tip20 = {
   BURN_BLOCKED_ROLE: '0x32ad9be8',
   DOMAIN_SEPARATOR: '0x3644e515',

package/tempo/actions/receivePolicy.ts

@@ -1,5 +1,5 @@
 import type { Address } from 'abitype'
-import type { ReceivePolicyReceipt } from 'ox/tempo'
+import { type ReceivePolicyReceipt, VirtualAddress } from 'ox/tempo'
 import type { Account } from '../../accounts/types.js'
 import { parseAccount } from '../../accounts/utils/parseAccount.js'
 import type { ReadContractReturnType } from '../../actions/public/readContract.js'
@@ -57,6 +57,25 @@ export type BlockedReason = ReceivePolicyReceipt.BlockedReason
 /** @internal */
 const blockedReasons = ['none', 'tokenFilter', 'receivePolicy'] as const
 
+/** @internal 12-byte prefix shared by TIP-20 token addresses. */
+const tip20Prefix = '0x20c000000000000000000000'
+
+/** @internal */
+const systemPrecompiles = [
+  Addresses.accountKeychain,
+  Addresses.accountRegistrar,
+  Addresses.addressRegistry,
+  Addresses.feeManager,
+  Addresses.nonceManager,
+  Addresses.receivePolicyGuard,
+  Addresses.signatureVerifier,
+  Addresses.stablecoinDex,
+  Addresses.tip20ChannelReserve,
+  Addresses.tip20Factory,
+  Addresses.tip403Registry,
+  Addresses.validator,
+] as const
+
 /**
  * Claimer authorized to reclaim blocked funds.
  *
@@ -1253,9 +1272,25 @@ function toPolicyRef(id: bigint): PolicyRef {
 
 /** @internal */
 function resolveClaimer(claimer: Claimer, self: Address): Address {
-  if (claimer === 'sender') return zeroAddress
-  if (claimer === 'self') return self
-  return claimer
+  const recoveryAuthority =
+    claimer === 'sender' ? zeroAddress : claimer === 'self' ? self : claimer
+  assertValidRecoveryAuthority(recoveryAuthority)
+  return recoveryAuthority
+}
+
+/** @internal */
+function assertValidRecoveryAuthority(recoveryAuthority: Address) {
+  if (isAddressEqual(recoveryAuthority, zeroAddress)) return
+  if (VirtualAddress.isVirtual(recoveryAuthority))
+    throw new Error('Recovery authority cannot be a TIP-1022 virtual address.')
+  if (recoveryAuthority.toLowerCase().startsWith(tip20Prefix))
+    throw new Error('Recovery authority cannot be a TIP-20 token address.')
+  if (
+    systemPrecompiles.some((address) =>
+      isAddressEqual(address, recoveryAuthority),
+    )
+  )
+    throw new Error('Recovery authority cannot be a Tempo system precompile.')
 }
 
 /** @internal */

package/tempo/actions/virtualAddress.ts

@@ -1,5 +1,6 @@
 import type { Address } from 'abitype'
 import * as Hex from 'ox/Hex'
+import { VirtualAddress } from 'ox/tempo'
 import type { Account } from '../../accounts/types.js'
 import { readContract } from '../../actions/public/readContract.js'
 import type { WriteContractReturnType } from '../../actions/wallet/writeContract.js'
@@ -121,7 +122,7 @@ export async function resolve<
   client: Client<Transport, chain, account>,
   parameters: resolve.Parameters,
 ): Promise<resolve.ReturnValue> {
-  if (!isVirtual(parameters.address)) return parameters.address
+  if (!VirtualAddress.isVirtual(parameters.address)) return parameters.address
 
   const masterId = Hex.slice(parameters.address, 0, 4)
   return getMasterAddress(client, { ...parameters, masterId })
@@ -328,10 +329,3 @@ export namespace registerMasterSync {
   // TODO: exhaustive error type
   export type ErrorType = BaseErrorType
 }
-
-const virtualMagic = '0xfdfdfdfdfdfdfdfdfdfd'
-
-/** @internal */
-function isVirtual(address: string): boolean {
-  return Hex.slice(address as Hex.Hex, 4, 14).toLowerCase() === virtualMagic
-}

package/tempo/actions/zone.ts

@@ -26,7 +26,7 @@ import type {
   ReadParameters,
   WriteParameters,
 } from '../internal/types.js'
-import { defineCall } from '../internal/utils.js'
+import { defineCall, pickWriteParameters } from '../internal/utils.js'
 import * as Storage from '../Storage.js'
 import type { TransactionReceipt } from '../Transaction.js'
 import * as ZoneAbis from '../zones/Abis.js'
@@ -40,6 +40,23 @@ export type EncryptedPayload = {
   tag: Hex.Hex
 }
 
+export type PreparedEncryptedDeposit = {
+  /** Amount of tokens to deposit. */
+  amount: bigint
+  /** Parent chain ID (e.g. `42431` for moderato). */
+  chainId: number
+  /** Encrypted deposit payload. */
+  encrypted: EncryptedPayload
+  /** Encryption key index from the portal contract. */
+  keyIndex: bigint
+  /** Zone portal address on the parent chain. */
+  portalAddress: Address
+  /** Token address or ID to deposit. */
+  token: TokenId.TokenIdOrAddress
+  /** Zone ID (e.g. `7`). */
+  zoneId: number
+}
+
 /**
  * Deposits tokens into a zone on the parent Tempo chain.
  * Batches approve and deposit into a single transaction.
@@ -269,46 +286,31 @@ export async function encryptedDeposit<
   const account_ = account ? parseAccount(account) : undefined
   if (!account) throw new Error('`account` is required.')
 
-  const recipient = parameters.recipient ?? account_?.address
-  if (!recipient) throw new Error('`recipient` is required.')
-
-  const portalAddress = getPortalAddress(chainId, parameters.zoneId)
-
-  const [publicKey, keyIndex] = await Promise.all([
-    readContract(client, {
-      address: portalAddress,
-      abi: ZoneAbis.zonePortal,
-      functionName: 'sequencerEncryptionKey',
-    }),
-    readContract(client, {
-      address: portalAddress,
-      abi: ZoneAbis.zonePortal,
-      functionName: 'encryptionKeyCount',
-    }),
-  ])
-
-  if (keyIndex === 0n) {
-    throw new Error('No sequencer encryption key configured.')
+  if ('encrypted' in parameters) {
+    if (parameters.chainId !== chainId) {
+      throw new Error(
+        'Prepared encrypted deposit chain ID does not match client chain.',
+      )
+    }
+    return sendTransaction(client, {
+      ...pickWriteParameters(parameters as never),
+      calls: encryptedDeposit.calls(parameters),
+    } as never) as never
   }
 
-  const encrypted = await encryptDepositPayload(
-    { x: publicKey[0], yParity: publicKey[1] },
-    recipient,
-    portalAddress,
-    keyIndex - 1n,
-    parameters.memo,
-  )
+  const recipient = parameters.recipient ?? account_?.address
+  if (!recipient) throw new Error('`recipient` is required.')
 
-  const args = {
-    ...parameters,
-    chainId,
-    encrypted,
-    keyIndex: keyIndex - 1n,
+  const prepared = await encryptedDeposit.prepare(client, {
+    amount: parameters.amount,
+    memo: parameters.memo,
     recipient,
-  }
+    token: parameters.token,
+    zoneId: parameters.zoneId,
+  })
   return sendTransaction(client, {
     ...rest,
-    calls: encryptedDeposit.calls(args),
+    calls: encryptedDeposit.calls(prepared),
   } as never) as never
 }
 
@@ -317,10 +319,13 @@ export namespace encryptedDeposit {
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
   > = WriteParameters<chain, account> &
-    Omit<Args, 'chainId' | 'encrypted' | 'keyIndex' | 'recipient'> & {
-      /** Recipient address in the zone. @default `account.address` */
-      recipient?: Address | undefined
-    }
+    (
+      | (Omit<Args, 'chainId' | 'encrypted' | 'keyIndex' | 'recipient'> & {
+          /** Recipient address in the zone. @default `account.address` */
+          recipient?: Address | undefined
+        })
+      | PreparedEncryptedDeposit
+    )
 
   export type Args = {
     /** Amount of tokens to deposit. */
@@ -346,13 +351,111 @@ export namespace encryptedDeposit {
   // TODO: exhaustive error type
   export type ErrorType = BaseErrorType
 
+  /**
+   * Prepares an encrypted deposit instruction without broadcasting it.
+   *
+   * @example
+   * ```ts
+   * import { createClient, http } from 'viem'
+   * import { tempoModerato } from 'viem/chains'
+   * import { Actions } from 'viem/tempo'
+   *
+   * const client = createClient({
+   *   chain: tempoModerato,
+   *   transport: http(),
+   * })
+   *
+   * const prepared = await Actions.zone.encryptedDeposit.prepare(client, {
+   *   token: '0x20c0...0001',
+   *   amount: 1_000_000n,
+   *   recipient: '0x...',
+   *   zoneId: 7,
+   * })
+   * ```
+   *
+   * @param client - Public client connected to the parent Tempo chain.
+   * @param parameters - Encrypted deposit preparation parameters.
+   * @returns A prepared encrypted deposit instruction.
+   */
+  export async function prepare<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    client: Client<Transport, chain, account>,
+    parameters: prepare.Parameters,
+  ): Promise<prepare.ReturnValue> {
+    const chainId = client.chain?.id
+    if (!chainId) throw new Error('`chain` is required.')
+
+    const { amount, memo, recipient, token, zoneId, ...rest } = parameters
+    const portalAddress = getPortalAddress(chainId, zoneId)
+
+    const [publicKey, keyIndex] = await Promise.all([
+      readContract(client, {
+        ...rest,
+        address: portalAddress,
+        abi: ZoneAbis.zonePortal,
+        functionName: 'sequencerEncryptionKey',
+      }),
+      readContract(client, {
+        ...rest,
+        address: portalAddress,
+        abi: ZoneAbis.zonePortal,
+        functionName: 'encryptionKeyCount',
+      }),
+    ])
+
+    if (keyIndex === 0n) {
+      throw new Error('No sequencer encryption key configured.')
+    }
+
+    const encrypted = await encryptDepositPayload(
+      { x: publicKey[0], yParity: publicKey[1] },
+      recipient,
+      portalAddress,
+      keyIndex - 1n,
+      memo,
+    )
+
+    return {
+      amount,
+      chainId,
+      encrypted,
+      keyIndex: keyIndex - 1n,
+      portalAddress,
+      token,
+      zoneId,
+    }
+  }
+
+  export namespace prepare {
+    export type Parameters = ReadParameters & Args
+
+    export type Args = {
+      /** Amount of tokens to deposit. */
+      amount: bigint
+      /** Optional deposit memo. @default `0x00...00` */
+      memo?: Hex.Hex | undefined
+      /** Recipient address in the zone. */
+      recipient: Address
+      /** Token address or ID to deposit. */
+      token: TokenId.TokenIdOrAddress
+      /** Zone ID (e.g. `7`). */
+      zoneId: number
+    }
+
+    export type ReturnValue = PreparedEncryptedDeposit
+
+    export type ErrorType = RequestErrorType | BaseErrorType
+  }
+
   /**
    * Defines the calls to approve and deposit tokens into a zone (encrypted).
    *
    * @param args - Arguments.
    * @returns The calls.
    */
-  export function calls(args: Args) {
+  export function calls(args: Args | PreparedEncryptedDeposit) {
     const { amount, chainId, encrypted, keyIndex, token, zoneId } = args
     const portalAddress = getPortalAddress(chainId, zoneId)
     return [
@@ -430,47 +533,34 @@ export async function encryptedDepositSync<
   const account_ = account ? parseAccount(account) : undefined
   if (!account) throw new Error('`account` is required.')
 
-  const recipient = parameters.recipient ?? account_?.address
-  if (!recipient) throw new Error('`recipient` is required.')
-
-  const portalAddress = getPortalAddress(chainId, parameters.zoneId)
-
-  const [publicKey, keyIndex] = await Promise.all([
-    readContract(client, {
-      address: portalAddress,
-      abi: ZoneAbis.zonePortal,
-      functionName: 'sequencerEncryptionKey',
-    }),
-    readContract(client, {
-      address: portalAddress,
-      abi: ZoneAbis.zonePortal,
-      functionName: 'encryptionKeyCount',
-    }),
-  ])
-
-  if (keyIndex === 0n) {
-    throw new Error('No sequencer encryption key configured.')
+  if ('encrypted' in parameters) {
+    if (parameters.chainId !== chainId) {
+      throw new Error(
+        'Prepared encrypted deposit chain ID does not match client chain.',
+      )
+    }
+    const receipt = await sendTransactionSync(client, {
+      ...pickWriteParameters(parameters as never),
+      throwOnReceiptRevert,
+      calls: encryptedDeposit.calls(parameters),
+    } as never)
+    return { receipt }
   }
 
-  const encrypted = await encryptDepositPayload(
-    { x: publicKey[0], yParity: publicKey[1] },
-    recipient,
-    portalAddress,
-    keyIndex - 1n,
-    parameters.memo,
-  )
+  const recipient = parameters.recipient ?? account_?.address
+  if (!recipient) throw new Error('`recipient` is required.')
 
-  const args = {
-    ...parameters,
-    chainId,
-    encrypted,
-    keyIndex: keyIndex - 1n,
+  const prepared = await encryptedDeposit.prepare(client, {
+    amount: parameters.amount,
+    memo: parameters.memo,
     recipient,
-  }
+    token: parameters.token,
+    zoneId: parameters.zoneId,
+  })
   const receipt = await sendTransactionSync(client, {
     ...rest,
     throwOnReceiptRevert,
-    calls: encryptedDeposit.calls(args),
+    calls: encryptedDeposit.calls(prepared),
   } as never)
   return { receipt }
 }

package/tokens/definitions/cirbtc.ts

@@ -0,0 +1,21 @@
+import { defineToken } from '../defineToken.js'
+
+/**
+ * [cirBTC](https://www.circle.com/cirbtc) token, with canonical contract
+ * addresses across supported EVM chains.
+ *
+ * Pass to a Client's `tokens` array, call with a chain id to produce a
+ * [token config](/docs/chains/tokens), or read the metadata and `addresses`
+ * map directly.
+ */
+export const cirbtc = /*#__PURE__*/ defineToken({
+  addresses: {
+    1: '0x72DFB2E44f59C5AD2bAFE84314E5b99a7cd5075E', // mainnet
+    5042002: '0xf0C4a4CE82A5746AbAAd9425360Ab04fbBA432BF', // arcTestnet
+    11155111: '0x3a3fe695F684Bf9b9e43CF43C2b895Ea5e392bB3', // sepolia
+  },
+  currency: 'BTC',
+  decimals: 8,
+  name: 'Circle Wrapped Bitcoin',
+  symbol: 'cirBTC',
+})

package/tokens/definitions/eurc.ts

@@ -0,0 +1,29 @@
+import { defineToken } from '../defineToken.js'
+
+/**
+ * [EURC](https://www.circle.com/eurc) token, with canonical contract addresses
+ * across supported EVM chains.
+ *
+ * Pass to a Client's `tokens` array, call with a chain id to produce a
+ * [token config](/docs/chains/tokens), or read the metadata and `addresses`
+ * map directly.
+ */
+export const eurc = /*#__PURE__*/ defineToken({
+  addresses: {
+    1: '0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c', // mainnet
+    25: '0xA6dE01a2d62C6B5f3525d768f34d276652C554c8', // cronos
+    338: '0x31f7538adb53cF16350e6B0c89d03D91b7D12c46', // cronosTestnet
+    480: '0x1C60ba0A0eD1019e8Eb035E6daF4155A5cE2380B', // worldchain
+    4801: '0xe479EcA5740Ac65d6E1823bea2f1C08Bc14e954F', // worldchainSepolia
+    8453: '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42', // base
+    43113: '0x5E44db7996c682E92a960b65AC713a54AD815c6B', // avalancheFuji
+    43114: '0xC891EB4cbdEFf6e073e859e987815Ed1505c2ACD', // avalanche
+    84532: '0x808456652fdb597867f38412077A9182bf77359F', // baseSepolia
+    5042002: '0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a', // arcTestnet
+    11155111: '0x08210F9170F89Ab7658F0B5E3fF39b0E03C594D4', // sepolia
+  },
+  currency: 'EUR',
+  decimals: 6,
+  name: 'EURC',
+  symbol: 'EURC',
+})