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

package/src/tempo/internal/relay.ts

@@ -0,0 +1,149 @@
+import * as RpcResponse from 'ox/RpcResponse'
+import { BaseError } from '../../core/Errors.js'
+import type * as Relay from '../Relay.js'
+import { toRpcError } from './relay/utils.js'
+
+/** Adapts an RPC handler to the Fetch API without changing its method results. */
+export async function fetch(
+  request: Request,
+  handler: Relay.handleRequest.Handler,
+  options: Relay.handleRequest.RequestOptions = {},
+): Promise<Response> {
+  if (request.method !== 'POST')
+    return new Response(null, { status: 405, headers: { Allow: 'POST' } })
+  const contentType = request.headers
+    .get('content-type')
+    ?.split(';')[0]
+    ?.trim()
+    .toLowerCase()
+  if (contentType !== 'application/json')
+    return new Response(null, { status: 415 })
+
+  const body = await (async () => {
+    try {
+      return { value: (await request.json()) as unknown }
+    } catch {
+      return {
+        error: {
+          jsonrpc: '2.0',
+          id: null,
+          error: { code: -32700, message: 'Parse error' },
+        },
+      }
+    }
+  })()
+  if (body.error) return Response.json(body.error)
+
+  const requestOptions = {
+    ...options,
+    signal: options.signal ?? request.signal,
+  }
+  const handle = async (value: unknown) => {
+    if (
+      !value ||
+      typeof value !== 'object' ||
+      Array.isArray(value) ||
+      !('jsonrpc' in value) ||
+      value.jsonrpc !== '2.0' ||
+      !('method' in value) ||
+      typeof value.method !== 'string' ||
+      ('id' in value &&
+        value.id !== null &&
+        typeof value.id !== 'string' &&
+        (typeof value.id !== 'number' || !Number.isFinite(value.id))) ||
+      ('params' in value &&
+        (value.params === null || typeof value.params !== 'object'))
+    )
+      return {
+        jsonrpc: '2.0',
+        id: null,
+        error: { code: -32600, message: 'Invalid Request' },
+      }
+
+    const id = 'id' in value ? value.id : undefined
+    try {
+      if ('params' in value && !Array.isArray(value.params))
+        throw new RpcResponse.InvalidParamsError({
+          message: 'Expected positional RPC parameters.',
+        })
+      const metadata = {}
+      const result = await handler(
+        {
+          method: value.method,
+          ...('params' in value
+            ? { params: value.params as readonly unknown[] }
+            : {}),
+        },
+        {
+          ...requestOptions,
+          response: metadata,
+        } as Relay.handleRequest.RequestOptions,
+      )
+      if (id === undefined) return undefined
+      // Serialization errors belong to this batch item, not the entire response.
+      return JSON.parse(
+        JSON.stringify({
+          jsonrpc: '2.0',
+          id,
+          result: result ?? null,
+          ...metadata,
+        }),
+      ) as unknown
+    } catch (error) {
+      requestOptions.signal.throwIfAborted()
+      if (id === undefined) return undefined
+      const cause =
+        error instanceof BaseError
+          ? error.walk((error) => error instanceof RpcResponse.BaseError)
+          : error
+      const rpc =
+        cause instanceof RpcResponse.BaseError ? toRpcError(cause) : undefined
+      const rpcError = rpc
+        ? { code: rpc.code, message: rpc.message, data: rpc.data }
+        : { code: -32603, message: 'Internal error' }
+      try {
+        return JSON.parse(
+          JSON.stringify({ jsonrpc: '2.0', id, error: rpcError }),
+        ) as unknown
+      } catch {
+        return {
+          jsonrpc: '2.0',
+          id,
+          error: { code: -32603, message: 'Internal error' },
+        }
+      }
+    }
+  }
+
+  if (Array.isArray(body.value) && body.value.length > 0) {
+    if (body.value.length > 100)
+      return Response.json({
+        jsonrpc: '2.0',
+        id: null,
+        error: {
+          code: -32600,
+          message: 'Batch exceeds the limit of 100 requests.',
+        },
+      })
+
+    const batch = body.value
+    const results = new Array<unknown>(batch.length)
+    let index = 0
+    await Promise.all(
+      Array.from({ length: Math.min(10, batch.length) }, async () => {
+        while (index < batch.length) {
+          const current = index++
+          results[current] = await handle(batch[current])
+        }
+      }),
+    )
+    const responses = results.filter((value) => value !== undefined)
+    return responses.length
+      ? Response.json(responses)
+      : new Response(null, { status: 204 })
+  }
+  const response = await handle(body.value)
+  return response === undefined
+    ? new Response(null, { status: 204 })
+    : Response.json(response)
+}

package/src/tempo/internal/types.ts

@@ -1,8 +1,8 @@
 import type { Address } from 'ox'
 
 import type { writeSync } from '../../core/actions/contract/writeSync.js'
-import type { TransactionRequest } from '../chainConfig.js'
 import type { UnionPick } from '../../core/internal/types.js'
+import type { TransactionRequest } from '../chainConfig.js'
 
 export type {
   ReadParameters,
@@ -41,6 +41,7 @@ export type WriteParameters = UnionPick<
     | 'feeToken'
     | 'keyAuthorization'
     | 'nonceKey'
+    | 'owner'
     | 'validAfter'
     | 'validBefore'
   >

package/src/tempo/internal/utils.ts

@@ -121,6 +121,7 @@ export function pickWriteParameters(parameters: Record<string, unknown>) {
     maxPriorityFeePerGas,
     nonce,
     nonceKey,
+    owner,
     validAfter,
     validBefore,
   } = parameters
@@ -135,6 +136,7 @@ export function pickWriteParameters(parameters: Record<string, unknown>) {
     maxPriorityFeePerGas,
     nonce,
     nonceKey,
+    owner,
     validAfter,
     validBefore,
   }

package/src/tempo/multisig/Config.ts

@@ -0,0 +1,139 @@
+import type { Hex } from 'ox'
+import { Address, Hash, Json } from 'ox'
+import { MultisigConfig } from 'ox/tempo'
+import { BaseError } from '../../core/Errors.js'
+import { nativeMultisigFactory } from '../Addresses.js'
+import type * as Store from '../Store.js'
+
+/** A valid 48-owner config is much smaller; 64 KiB bounds hostile store parsing work. */
+const maxStoredValueLength = 65_536
+
+/** Zero commitment used before an account is initialized. */
+const zeroCommitment = `0x${'00'.repeat(32)}` as const
+
+/** Reads a cached multisig config. */
+export async function read(
+  store: Store.Store,
+  options: read.Options,
+): Promise<MultisigConfig.Config | null> {
+  const { address, commitment } = options
+  const value = await store.getItem(key({ address, commitment }))
+  if (value === null || value === undefined) return null
+  const config = deserialize(value)
+  assertKey({ address, commitment, config })
+  return config
+}
+
+export declare namespace read {
+  /** Parameters for {@link read}. */
+  export type Options = {
+    /** Multisig account address. */
+    address: Address.Address
+    /** Config commitment observed onchain. */
+    commitment: Hex.Hex
+  }
+}
+
+/** Writes a validated multisig config. */
+export async function write(
+  store: Store.Store,
+  options: write.Options,
+): Promise<void> {
+  const { address, commitment } = options
+  const config = MultisigConfig.from(options.config)
+  assertKey({ address, commitment, config })
+  const value = serialize(config)
+  await store.setItem(key({ address, commitment }), value)
+  // Initialization commits the version-zero config without changing its version.
+  if (commitment.toLowerCase() === zeroCommitment)
+    await store.setItem(
+      key({ address, commitment: MultisigConfig.getCommitment(config) }),
+      value,
+    )
+}
+
+export declare namespace write {
+  /** Parameters for {@link write}. */
+  export type Options = {
+    /** Multisig account address. */
+    address: Address.Address
+    /** Config commitment used for lookup. */
+    commitment: Hex.Hex
+    /** Complete config. */
+    config: MultisigConfig.Config
+  }
+}
+
+/** Verifies that a config matches its account-and-commitment key. */
+function assertKey(options: {
+  address: Address.Address
+  commitment: Hex.Hex
+  config: MultisigConfig.Config
+}) {
+  const { address, commitment, config } = options
+  if (!Address.validate(address) || !Hash.validate(commitment))
+    throw new InvalidStoreValueError()
+  if (config.version === 0n) {
+    if (
+      !Address.isEqual(
+        MultisigConfig.getAddress(config, { factory: nativeMultisigFactory }),
+        address,
+      )
+    )
+      throw new InvalidStoreValueError()
+    if (commitment.toLowerCase() === zeroCommitment) return
+  }
+  if (
+    MultisigConfig.getCommitment(config).toLowerCase() !==
+    commitment.toLowerCase()
+  )
+    throw new InvalidStoreValueError()
+}
+
+/** Deserializes a multisig config from storage. */
+function deserialize(value: string): MultisigConfig.Config {
+  try {
+    if (value.length > maxStoredValueLength) throw new InvalidStoreValueError()
+    return MultisigConfig.fromRpc(Json.parse(value) as never)
+  } catch (cause) {
+    if (cause instanceof InvalidStoreValueError) throw cause
+    throw new InvalidStoreValueError({ cause })
+  }
+}
+
+/** Returns the store key for an account and config commitment. */
+function key(options: { address: Address.Address; commitment: Hex.Hex }) {
+  const { address, commitment } = options
+  return `multisig:config:${address.toLowerCase()}:${commitment.toLowerCase()}`
+}
+
+/** Serializes a multisig config for storage. */
+function serialize(config: MultisigConfig.Config): string {
+  try {
+    const value = Json.stringify(MultisigConfig.toRpc(config))
+    if (value.length > maxStoredValueLength) throw new InvalidStoreValueError()
+    return value
+  } catch (cause) {
+    if (cause instanceof InvalidStoreValueError) throw cause
+    throw new InvalidStoreValueError({ cause })
+  }
+}
+
+/** Thrown when a stored multisig config is malformed or mismatched. */
+export class InvalidStoreValueError extends BaseError<Error | undefined> {
+  override name = 'Multisig.Config.InvalidStoreValueError'
+  /** Creates an invalid store value error. */
+  constructor(options: InvalidStoreValueError.Options = {}) {
+    super('Stored multisig config is malformed or mismatched.', {
+      cause: options.cause as Error | undefined,
+    })
+  }
+}
+
+export declare namespace InvalidStoreValueError {
+  /** Error construction options. */
+  export type Options = {
+    /** Underlying error. */
+    cause?: unknown | undefined
+  }
+}

package/src/tempo/multisig/Operation.ts

@@ -0,0 +1,213 @@
+import type { Hex } from 'ox'
+import { Json } from 'ox'
+import { MultisigOperation, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
+import { BaseError } from '../../core/Errors.js'
+import type * as Store from '../Store.js'
+
+/** Bounds parsing and serialization work if a store returns unexpectedly large data. */
+const maxStoredValueLength = 1_048_576
+
+/** Prevents sustained compare-and-set contention from retrying indefinitely. */
+const maxUpdateAttempts = 32
+
+/** Bounds abandoned operation state while allowing long-lived approval ceremonies. */
+const pendingOperationTtl = 30 * 24 * 60 * 60 * 1_000
+
+/** Reads a persisted multisig operation. */
+export async function read(
+  store: Store.Store,
+  hash: Hex.Hex,
+): Promise<MultisigOperation.Operation | null> {
+  const value = await store.getItem(operationKey(hash))
+  if (value === null || value === undefined) return null
+  const operation = deserialize(value)
+  if (operation.hash.toLowerCase() !== hash.toLowerCase())
+    throw new InvalidStoreValueError()
+  return operation
+}
+
+/** Atomically updates a multisig operation. */
+export async function update(
+  store: Store.Atomic,
+  hash: Hex.Hex,
+  update: (
+    operation: MultisigOperation.Operation | null,
+  ) => MultisigOperation.Operation | Promise<MultisigOperation.Operation>,
+): Promise<MultisigOperation.Operation> {
+  const key = operationKey(hash)
+  for (let attempt = 0; attempt < maxUpdateAttempts; attempt++) {
+    const value = (await store.getItem(key)) ?? null
+    const current = value === null ? null : deserialize(value)
+    if (current && current.hash.toLowerCase() !== hash.toLowerCase())
+      throw new InvalidStoreValueError()
+    const value_ = await update(current)
+    let next: MultisigOperation.Operation
+    try {
+      next = MultisigOperation.from(value_)
+    } catch (cause) {
+      throw new InvalidStoreValueError({ cause })
+    }
+    if (next.hash.toLowerCase() !== hash.toLowerCase())
+      throw new InvalidStoreValueError()
+    const serialized = serialize(next)
+    const options =
+      next.status === 'success'
+        ? undefined
+        : { expiresAt: Date.now() + pendingOperationTtl }
+    if (await store.compareAndSet(key, value, serialized, options)) return next
+  }
+  throw new StoreConflictError()
+}
+
+/** Reads a submission hash without rebuilding its envelope from mutable configurations. */
+export async function readSubmission(
+  store: Store.Store,
+  operation: MultisigOperation.TransactionOperation,
+  submissionId: Hex.Hex,
+): Promise<Hex.Hex | null> {
+  const value = await store.getItem(submissionKey(operation.hash, submissionId))
+  if (value === null || value === undefined) return null
+  try {
+    if (value.length > maxStoredValueLength) throw new InvalidStoreValueError()
+    const transaction = TxEnvelopeTempo.deserialize(
+      value as TxEnvelopeTempo.Serialized,
+    )
+    if (transaction.signature?.type !== 'multisig')
+      throw new InvalidStoreValueError()
+    const serialized = MultisigOperation.serializeTransaction(operation, {
+      approvals: transaction.signature.signatures.map((signature) =>
+        SignatureEnvelope.serialize(signature),
+      ),
+    })
+    if (serialized.toLowerCase() !== value.toLowerCase())
+      throw new InvalidStoreValueError()
+    return TxEnvelopeTempo.hash(transaction as TxEnvelopeTempo.Signed)
+  } catch (cause) {
+    if (cause instanceof InvalidStoreValueError) throw cause
+    throw new InvalidStoreValueError({ cause })
+  }
+}
+
+/** Removes a persisted final envelope after its submission is settled. */
+export async function removeSubmission(
+  store: Store.Store,
+  hash: Hex.Hex,
+  submissionId: Hex.Hex,
+): Promise<void> {
+  await store.removeItem(submissionKey(hash, submissionId))
+}
+
+/** Persists the final envelope before broadcast so recovery uses the exact transaction. */
+export async function writeSubmission(
+  store: Store.Atomic,
+  hash: Hex.Hex,
+  submissionId: Hex.Hex,
+  transaction: TxEnvelopeTempo.Serialized,
+): Promise<void> {
+  try {
+    if (transaction.length > maxStoredValueLength)
+      throw new InvalidStoreValueError()
+    const envelope = TxEnvelopeTempo.deserialize(transaction)
+    if (!envelope.signature) throw new InvalidStoreValueError()
+    TxEnvelopeTempo.hash(envelope as TxEnvelopeTempo.Signed)
+    const written = await store.compareAndSet(
+      submissionKey(hash, submissionId),
+      null,
+      transaction,
+      { expiresAt: Date.now() + pendingOperationTtl },
+    )
+    if (!written) throw new InvalidStoreValueError()
+  } catch (cause) {
+    if (cause instanceof InvalidStoreValueError) throw cause
+    throw new InvalidStoreValueError({ cause })
+  }
+}
+
+/** Deserializes a multisig operation from storage. */
+function deserialize(value: string): MultisigOperation.Operation {
+  try {
+    if (value.length > maxStoredValueLength) throw new InvalidStoreValueError()
+    const operation = MultisigOperation.from(Json.parse(value) as never)
+    assertHash(operation)
+    return operation
+  } catch (cause) {
+    if (cause instanceof InvalidStoreValueError) throw cause
+    throw new InvalidStoreValueError({ cause })
+  }
+}
+
+/** Serializes a multisig operation for storage. */
+function serialize(operation: MultisigOperation.Operation): string {
+  try {
+    const operation_ = MultisigOperation.from(operation)
+    assertHash(operation_)
+    const value = Json.stringify(operation_)
+    if (value.length > maxStoredValueLength) throw new InvalidStoreValueError()
+    return value
+  } catch (cause) {
+    if (cause instanceof InvalidStoreValueError) throw cause
+    throw new InvalidStoreValueError({ cause })
+  }
+}
+
+/** Verifies that the operation hash commits to its stored payload. */
+function assertHash(operation: MultisigOperation.Operation) {
+  const hash = MultisigOperation.getHash(
+    operation.type === 'transaction'
+      ? {
+          account: operation.account,
+          config: operation.config,
+          transaction: operation.transaction as TxEnvelopeTempo.Serialized,
+          type: operation.type,
+        }
+      : {
+          account: operation.account,
+          config: operation.config,
+          keyAuthorization: operation.keyAuthorization,
+          type: operation.type,
+        },
+  )
+  if (hash.toLowerCase() !== operation.hash.toLowerCase())
+    throw new InvalidStoreValueError()
+}
+
+/** Returns the store key for an operation hash. */
+function operationKey(hash: Hex.Hex) {
+  return `multisig:operation:${hash.toLowerCase()}`
+}
+
+/** Returns the store key for a submission attempt. */
+function submissionKey(hash: Hex.Hex, submissionId: Hex.Hex) {
+  return `multisig:submission:${hash.toLowerCase()}:${submissionId.toLowerCase()}`
+}
+
+/** Thrown when a stored multisig operation is malformed or unsupported. */
+export class InvalidStoreValueError extends BaseError<Error | undefined> {
+  override name = 'Multisig.Operation.InvalidStoreValueError'
+  /** Creates an invalid store value error. */
+  constructor(options: InvalidStoreValueError.Options = {}) {
+    super('Stored multisig operation is malformed or unsupported.', {
+      cause: options.cause as Error | undefined,
+    })
+  }
+}
+
+export declare namespace InvalidStoreValueError {
+  /** Error construction options. */
+  export type Options = {
+    /** Underlying error. */
+    cause?: unknown | undefined
+  }
+}
+
+/** Thrown when a multisig operation cannot be updated due to contention. */
+export class StoreConflictError extends BaseError<Error | undefined> {
+  override name = 'Multisig.Operation.StoreConflictError'
+  /** Creates a store conflict error. */
+  constructor() {
+    super(
+      'Multisig operation could not be updated after repeated conflicts.',
+      {},
+    )
+  }
+}

package/src/tempo/multisig/Signature.ts

@@ -0,0 +1,11 @@
+import { SignatureEnvelope } from 'ox/tempo'
+
+/** Parses a primitive multisig owner approval. */
+export function parseApproval(
+  signature: SignatureEnvelope.Serialized,
+): SignatureEnvelope.Primitive {
+  const approval = SignatureEnvelope.from(signature)
+  if (approval.type === 'multisig' || approval.type === 'keychain')
+    throw new Error('Multisig owners must use primitive signatures.')
+  return approval
+}

package/src/tempo/zones/Abis.ts

@@ -119,7 +119,7 @@ export const zonePortal = [
       { name: 'to', type: 'address' },
       { name: 'amount', type: 'uint128' },
       { name: 'memo', type: 'bytes32' },
-      { name: 'bouncebackRecipient', type: 'address' },
+      { name: 'tempoRefundRecipient', type: 'address' },
     ],
     outputs: [{ name: '', type: 'bytes32' }],
   },
@@ -142,7 +142,7 @@ export const zonePortal = [
           { name: 'tag', type: 'bytes16' },
         ],
       },
-      { name: 'bouncebackRecipient', type: 'address' },
+      { name: 'tempoRefundRecipient', type: 'address' },
     ],
     outputs: [{ name: '', type: 'bytes32' }],
   },

package/src/tempo/zones/transport.ts

@@ -1,66 +1 @@
-import type * as Transport from '../../core/Transport.js'
-import { http as http_ } from '../../core/transports/http.js'
-import * as Storage from '../Storage.js'
-
-/**
- * Creates an HTTP JSON-RPC transport with support for Zone authorization
- * tokens.
- *
- * Reads the authorization token for the client's chain from {@link Storage}
- * and injects the `X-Authorization-Token` header on every request. Batching
- * is not supported because zone tokens are account-scoped.
- *
- * @example
- * ```ts
- * import { Client } from 'viem/tempo'
- * import { http, zone } from 'viem/tempo/zones'
- *
- * const client = Client.create({
- *   chain: zone(6),
- *   transport: http(),
- * })
- * ```
- *
- * @param url - RPC URL. Defaults to the chain's default RPC URL.
- * @param options - Options.
- * @returns An HTTP transport.
- */
-export function http(
-  url?: string | undefined,
-  options: http.Options = {},
-): Transport.Http {
-  const {
-    onFetchRequest,
-    storage = Storage.defaultStorage(),
-    ...rest
-  } = options
-  return {
-    key: rest.key ?? 'http',
-    name: rest.name ?? 'HTTP JSON-RPC',
-    type: 'http',
-    setup(setupOptions = {}) {
-      const chainId = setupOptions.chain?.id
-      return http_(url, {
-        ...rest,
-        async onFetchRequest(request, init) {
-          const next = (await onFetchRequest?.(request, init)) ?? init
-          const headers = new Headers(next.headers)
-
-          if (chainId) {
-            const token = await storage.getItem(`auth:token:${chainId}`)
-            if (token) headers.set('X-Authorization-Token', token)
-          }
-
-          return { ...next, headers }
-        },
-      }).setup(setupOptions)
-    },
-  }
-}
-
-export declare namespace http {
-  type Options = Omit<http_.Options, 'batch' | 'raw'> & {
-    /** Storage for reading zone authorization tokens. Defaults to sessionStorage (web) or memory (server). */
-    storage?: Storage.Storage | undefined
-  }
-}
+export { http } from '../Transport.js'

package/src/tokens/definitions/cirbtc.ts

@@ -11,6 +11,7 @@ import * as Token from '../../core/Token.js'
 export const cirbtc = /*#__PURE__*/ Token.from({
   addresses: {
     1: '0x72DFB2E44f59C5AD2bAFE84314E5b99a7cd5075E', // mainnet
+    5042: '0x171A4217b86A807A64eB94757Db6849fb4bDbAA0', // arc
     5042002: '0xf0C4a4CE82A5746AbAAd9425360Ab04fbBA432BF', // arcTestnet
     11155111: '0x3a3fe695F684Bf9b9e43CF43C2b895Ea5e392bB3', // sepolia
   },

package/src/tokens/definitions/eurc.ts

@@ -15,7 +15,9 @@ export const eurc = /*#__PURE__*/ Token.from({
     338: '0x31f7538adb53cF16350e6B0c89d03D91b7D12c46', // cronosTestnet
     480: '0x1C60ba0A0eD1019e8Eb035E6daF4155A5cE2380B', // worldchain
     4801: '0xe479EcA5740Ac65d6E1823bea2f1C08Bc14e954F', // worldchainSepolia
+    5042: '0xbEf5f6d51CB62b58e6A8f77868681825C6fe21c1', // arc
     8453: '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42', // base
+    9745: '0x3EE196E78d4d4248b849B8E1C7F44C5457FAFD2C', // plasma
     43113: '0x5E44db7996c682E92a960b65AC713a54AD815c6B', // avalancheFuji
     43114: '0xC891EB4cbdEFf6e073e859e987815Ed1505c2ACD', // avalanche
     84532: '0x808456652fdb597867f38412077A9182bf77359F', // baseSepolia

package/src/tokens/definitions/ousd.ts

@@ -0,0 +1,26 @@
+import * as Token from '../../core/Token.js'
+
+/**
+ * [Open USD](https://joinopenstandard.com/) token, with canonical contract
+ * addresses on Ethereum, Tempo, and Base.
+ *
+ * @example
+ * ```ts
+ * import { ousd } from 'viem/tokens'
+ *
+ * ousd(4217)
+ * // { address: '0x20c0000000000000000000006a37DA5C996874BE', ... }
+ * ```
+ */
+export const ousd = /*#__PURE__*/ Token.from({
+  addresses: {
+    1: '0x9f6F3991D525015a6F8CaF062C83b62fD3AC4436', // mainnet
+    4217: '0x20c0000000000000000000006a37DA5C996874BE', // tempo
+    8453: '0xB2000000000000000000002fEb517dFeC7415344', // base
+  },
+  currency: 'USD',
+  decimals: 6,
+  name: 'OpenUSD',
+  popular: true,
+  symbol: 'OUSD',
+})

package/src/tokens/definitions/usdc.ts

@@ -58,7 +58,9 @@ export const usdc = /*#__PURE__*/ Token.from({
     2910: '0x7433b41C6c5e1d58D4Da99483609520255ab661B', // morphHoodi
     3343: '0x98d2919b9A214E6Fa5384AC81E6864bA686Ad74c', // edge
     4801: '0x66145f38cBAC35Ca6F1Dfb4914dF98F1614aeA88', // worldchainSepolia
+    5042: '0x3600000000000000000000000000000000000000', // arc
     8453: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // base
+    9745: '0x2d661C89D812261039AF9764eceaAee884f5F67F', // plasma
     10143: '0x534b2f3A21130d7a60830c2Df862319e593943A3', // monadTestnet
     33431: '0x2d9F7CAD728051AA35Ecdc472a14cf8cDF5CFD6B', // edgeTestnet
     42161: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // arbitrum