viem 2.54.6 → 2.55.1

package/tempo/chainConfig.ts

@@ -219,8 +219,10 @@ export const chainConfig = {
         const keyInfo = await getMetadata(client, {
           account: address,
           accessKey: accessKeyAddress,
+          blockHash: parameters.blockHash,
           blockNumber: parameters.blockNumber,
           blockTag: parameters.blockTag,
+          requireCanonical: parameters.requireCanonical,
         } as never)
 
         if (keyInfo.isRevoked) return false
@@ -237,8 +239,10 @@ export const chainConfig = {
       if (envelope.type === 'p256' || envelope.type === 'webAuthn') {
         const code = await getCode(client, {
           address,
+          blockHash: parameters.blockHash,
           blockNumber: parameters.blockNumber,
           blockTag: parameters.blockTag,
+          requireCanonical: parameters.requireCanonical,
         } as never)
         // Check if EOA, if not, we want to go down the ERC-1271 flow.
         if (

package/tempo/errors.ts

@@ -1,5 +1,19 @@
 import { BaseError } from '../errors/base.js'
 
+export type WaitForDepositStatusTimeoutErrorType =
+  WaitForDepositStatusTimeoutError & {
+    name: 'WaitForDepositStatusTimeoutError'
+  }
+
+export class WaitForDepositStatusTimeoutError extends BaseError {
+  constructor({ tempoBlockNumber }: { tempoBlockNumber: bigint }) {
+    super(
+      `Timed out while waiting for deposits from Tempo block "${tempoBlockNumber}" to be processed.`,
+      { name: 'WaitForDepositStatusTimeoutError' },
+    )
+  }
+}
+
 export type InvalidFeeTokenErrorType = InvalidFeeTokenError & {
   name: 'InvalidFeeTokenError'
 }

package/tempo/zones/Abis.ts

@@ -1,3 +1,64 @@
+export const zoneFactory = [
+  {
+    type: 'event',
+    name: 'ZoneCreated',
+    inputs: [
+      { name: 'zoneId', type: 'uint32', indexed: true },
+      { name: 'portal', type: 'address', indexed: true },
+      { name: 'messenger', type: 'address', indexed: true },
+      { name: 'initialToken', type: 'address', indexed: false },
+      { name: 'admin', type: 'address', indexed: false },
+      { name: 'sequencer', type: 'address', indexed: false },
+      { name: 'verifier', type: 'address', indexed: false },
+      { name: 'genesisBlockHash', type: 'bytes32', indexed: false },
+      { name: 'genesisTempoBlockHash', type: 'bytes32', indexed: false },
+      {
+        name: 'genesisTempoBlockNumber',
+        type: 'uint64',
+        indexed: false,
+      },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'createZone',
+    stateMutability: 'nonpayable',
+    inputs: [
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          { name: 'initialToken', type: 'address' },
+          { name: 'admin', type: 'address' },
+          { name: 'sequencer', type: 'address' },
+          { name: 'verifier', type: 'address' },
+          {
+            name: 'zoneParams',
+            type: 'tuple',
+            components: [
+              { name: 'genesisBlockHash', type: 'bytes32' },
+              { name: 'genesisTempoBlockHash', type: 'bytes32' },
+              { name: 'genesisTempoBlockNumber', type: 'uint64' },
+            ],
+          },
+          { name: 'rpcUrl', type: 'string' },
+        ],
+      },
+    ],
+    outputs: [
+      { name: 'zoneId', type: 'uint32' },
+      { name: 'portal', type: 'address' },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'verifier',
+    stateMutability: 'view',
+    inputs: [],
+    outputs: [{ name: '', type: 'address' }],
+  },
+] as const
+
 export const zonePortal = [
   {
     name: 'deposit',
@@ -8,6 +69,7 @@ export const zonePortal = [
       { name: 'to', type: 'address' },
       { name: 'amount', type: 'uint128' },
       { name: 'memo', type: 'bytes32' },
+      { name: 'bouncebackRecipient', type: 'address' },
     ],
     outputs: [{ name: '', type: 'bytes32' }],
   },
@@ -30,6 +92,7 @@ export const zonePortal = [
           { name: 'tag', type: 'bytes16' },
         ],
       },
+      { name: 'bouncebackRecipient', type: 'address' },
     ],
     outputs: [{ name: '', type: 'bytes32' }],
   },

package/tempo/zones/zone.ts

@@ -77,6 +77,7 @@ export function from(options: from.Options) {
         },
       },
       sourceId: options.sourceId,
+      supportsTransactionReplacementDetection: false,
     })
   }
 }

package/tokens/definitions/cirbtc.ts

@@ -5,7 +5,7 @@ import { defineToken } from '../defineToken.js'
  * 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`
+ * [token config](/tokens/guides/defining-tokens), or read the metadata and `addresses`
  * map directly.
  */
 export const cirbtc = /*#__PURE__*/ defineToken({

package/tokens/definitions/eurc.ts

@@ -5,7 +5,7 @@ import { defineToken } from '../defineToken.js'
  * 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`
+ * [token config](/tokens/guides/defining-tokens), or read the metadata and `addresses`
  * map directly.
  */
 export const eurc = /*#__PURE__*/ defineToken({

package/tokens/definitions/usdc.ts

@@ -5,7 +5,7 @@ import { defineToken } from '../defineToken.js'
  * across supported 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`
+ * [token config](/tokens/guides/defining-tokens), or read the metadata and `addresses`
  * map directly.
  *
  * @example

package/tokens/definitions/usyc.ts

@@ -5,7 +5,7 @@ import { defineToken } from '../defineToken.js'
  * 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`
+ * [token config](/tokens/guides/defining-tokens), or read the metadata and `addresses`
  * map directly.
  */
 export const usyc = /*#__PURE__*/ defineToken({

package/types/chain.ts

@@ -67,6 +67,8 @@ export type Chain<
   }
   /** Source Chain ID (ie. the L1 chain) */
   sourceId?: number | undefined
+  /** Whether transaction replacement detection is supported. @default true */
+  supportsTransactionReplacementDetection?: boolean | undefined
   /** Flag for test networks */
   testnet?: boolean | undefined
 } & ChainConfig<formatters, extendSchema>

package/utils/chain/filterChains.ts

@@ -0,0 +1,87 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { Token } from '../../tokens/defineToken.js'
+import type { Chain } from '../../types/chain.js'
+
+export type FilterChainsParameters<
+  criteria extends filterChains.Criteria = filterChains.Criteria,
+> = {
+  chains: filterChains.Chains
+} & criteria
+
+export type FilterChainsReturnType<
+  criteria extends filterChains.Criteria | undefined,
+> = (Chain &
+  filterChains.TokenConstraint<criteria> &
+  filterChains.TestnetConstraint<criteria>)[]
+
+export type FilterChainsErrorType = ErrorType
+
+/**
+ * Filters a chain registry or array by structured criteria.
+ *
+ * @experimental
+ *
+ * @param parameters - Chain registry or array and criteria to filter by.
+ * @returns Matching chains.
+ */
+export function filterChains<const criteria extends filterChains.Criteria>(
+  parameters: FilterChainsParameters<criteria>,
+): FilterChainsReturnType<criteria> {
+  const { chains, sort, testnet, token } = parameters
+  const values = Array.isArray(chains) ? chains : Object.values(chains)
+  const filtered: Chain[] = []
+
+  for (const chain of values) {
+    if (!isChain(chain)) continue
+    if (token && !(chain.id in token.addresses)) continue
+    if (testnet === true && chain.testnet !== true) continue
+    if (testnet === false && chain.testnet === true) continue
+    filtered.push(chain)
+  }
+
+  if (sort === 'id') filtered.sort((a, b) => a.id - b.id)
+  if (sort === 'name') filtered.sort((a, b) => a.name.localeCompare(b.name))
+
+  return filtered as never
+}
+
+function isChain(chain: unknown): chain is Chain {
+  return (
+    typeof chain === 'object' &&
+    chain !== null &&
+    'id' in chain &&
+    typeof chain.id === 'number' &&
+    'name' in chain &&
+    typeof chain.name === 'string' &&
+    'nativeCurrency' in chain &&
+    'rpcUrls' in chain
+  )
+}
+
+export namespace filterChains {
+  export type Chains = Record<string, unknown> | readonly unknown[]
+
+  export type Criteria = {
+    /** Only include chains that have an address for the token. */
+    token?: Token | undefined
+    /** Only include testnets (`true`) or mainnets (`false`). */
+    testnet?: boolean | undefined
+    /** Sort the matching chains. */
+    sort?: 'id' | 'name' | undefined
+  }
+
+  export type ReturnType<criteria extends Criteria | undefined> =
+    FilterChainsReturnType<criteria>
+
+  export type TokenConstraint<criteria extends Criteria | undefined> =
+    criteria extends { token: infer token extends Token }
+      ? { id: Extract<keyof token['addresses'], number> }
+      : unknown
+
+  export type TestnetConstraint<criteria extends Criteria | undefined> =
+    criteria extends { testnet: infer testnet extends boolean }
+      ? testnet extends true
+        ? { testnet: true }
+        : { testnet?: false | undefined }
+      : unknown
+}

package/utils/encoding/fromHex.ts

@@ -208,7 +208,7 @@ export type HexToNumberErrorType =
  *
  * @example
  * import { hexToNumber } from 'viem'
- * const data = hexToBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+ * const data = hexToNumber('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
  * // 420
  */
 export function hexToNumber(hex: Hex, opts: HexToNumberOpts = {}): number {

package/utils/index.ts

@@ -171,6 +171,12 @@ export {
   type ExtractChainReturnType,
   extractChain,
 } from './chain/extractChain.js'
+export {
+  type FilterChainsErrorType,
+  type FilterChainsParameters,
+  type FilterChainsReturnType,
+  filterChains,
+} from './chain/filterChains.js'
 export {
   type GetChainContractAddressErrorType,
   getChainContractAddress,