viem 2.0.0-alpha.16 → 2.0.0-alpha.18

package/clients/decorators/wallet.ts

@@ -232,7 +232,9 @@ export type WalletActions<
    *   value: 1n,
    * })
    */
-  prepareTransactionRequest: <TChainOverride extends Chain | undefined,>(
+  prepareTransactionRequest: <
+    TChainOverride extends Chain | undefined = undefined,
+  >(
     args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
   ) => Promise<PrepareTransactionRequestReturnType>
   /**
@@ -351,7 +353,7 @@ export type WalletActions<
    *   value: 1000000000000000000n,
    * })
    */
-  sendTransaction: <TChainOverride extends Chain | undefined>(
+  sendTransaction: <TChainOverride extends Chain | undefined = undefined>(
     args: SendTransactionParameters<TChain, TAccount, TChainOverride>,
   ) => Promise<SendTransactionReturnType>
   /**
@@ -443,7 +445,7 @@ export type WalletActions<
    * })
    * const signature = await client.signTransaction(request)
    */
-  signTransaction: <TChainOverride extends Chain | undefined,>(
+  signTransaction: <TChainOverride extends Chain | undefined = undefined>(
     args: SignTransactionParameters<TChain, TAccount, TChainOverride>,
   ) => Promise<SignTransactionReturnType>
   /**

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.0.0-alpha.16'
+export const version = '2.0.0-alpha.18'

package/index.ts

@@ -956,6 +956,8 @@ export type {
   RpcTransactionReceipt,
   RpcTransactionRequest,
   RpcUncle,
+  Status,
+  RpcProof,
 } from './types/rpc.js'
 export type { Withdrawal } from './types/withdrawal.js'
 export { labelhash, type LabelhashErrorType } from './utils/ens/labelhash.js'
@@ -1245,11 +1247,19 @@ export {
 export {
   type AssertCurrentChainErrorType,
   type AssertCurrentChainParameters,
-  type GetChainContractAddressErrorType,
   assertCurrentChain,
-  defineChain,
+} from './utils/chain/assertCurrentChain.js'
+export { defineChain } from './utils/chain/defineChain.js'
+export {
+  type ExtractChainErrorType,
+  type ExtractChainParameters,
+  type ExtractChainReturnType,
+  extractChain,
+} from './utils/chain/extractChain.js'
+export {
+  type GetChainContractAddressErrorType,
   getChainContractAddress,
-} from './utils/chain.js'
+} from './utils/chain/getChainContractAddress.js'
 export {
   type EncodePackedErrorType,
   encodePacked,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.0.0-alpha.16",
+  "version": "2.0.0-alpha.18",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/types/chain.ts

@@ -206,6 +206,11 @@ export type ChainEstimateFeesPerGasFnParameters<
 /////////////////////////////////////////////////////////////////////
 // Utils
 
+export type ExtractChain<
+  chains extends readonly Chain[],
+  chainId extends Chain['id'],
+> = Extract<chains[number], { id: chainId }>
+
 export type ExtractChainFormatterExclude<
   chain extends { formatters?: Chain['formatters'] } | undefined,
   type extends keyof ChainFormatters,

package/utils/abi/decodeEventLog.ts

@@ -128,17 +128,15 @@ export function decodeEventLog<
 
   // Decode topics (indexed args).
   const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
-  if (argTopics.length > 0) {
-    for (let i = 0; i < indexedInputs.length; i++) {
-      const param = indexedInputs[i]
-      const topic = argTopics[i]
-      if (!topic)
-        throw new DecodeLogTopicsMismatch({
-          abiItem,
-          param: param as AbiParameter & { indexed: boolean },
-        })
-      args[param.name || i] = decodeTopic({ param, value: topic })
-    }
+  for (let i = 0; i < indexedInputs.length; i++) {
+    const param = indexedInputs[i]
+    const topic = argTopics[i]
+    if (!topic)
+      throw new DecodeLogTopicsMismatch({
+        abiItem,
+        param: param as AbiParameter & { indexed: boolean },
+      })
+    args[param.name || i] = decodeTopic({ param, value: topic })
   }
 
   // Decode data (non-indexed args).

package/utils/chain/assertCurrentChain.ts

@@ -0,0 +1,27 @@
+import {
+  ChainMismatchError,
+  type ChainMismatchErrorType,
+  ChainNotFoundError,
+  type ChainNotFoundErrorType,
+} from '../../errors/chain.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Chain } from '../../types/chain.js'
+
+export type AssertCurrentChainParameters = {
+  chain?: Chain
+  currentChainId: number
+}
+
+export type AssertCurrentChainErrorType =
+  | ChainNotFoundErrorType
+  | ChainMismatchErrorType
+  | ErrorType
+
+export function assertCurrentChain({
+  chain,
+  currentChainId,
+}: AssertCurrentChainParameters): void {
+  if (!chain) throw new ChainNotFoundError()
+  if (currentChainId !== chain.id)
+    throw new ChainMismatchError({ chain, currentChainId })
+}

package/utils/chain/defineChain.ts

@@ -0,0 +1,22 @@
+import type { Chain, ChainConfig, ChainFormatters } from '../../types/chain.js'
+import type { Assign } from '../../types/utils.js'
+
+export function defineChain<
+  const chain extends Chain,
+  formatters extends ChainFormatters | undefined = undefined,
+>(
+  chain: chain,
+  config: ChainConfig<formatters> = {},
+): Assign<chain, ChainConfig<formatters>> {
+  const {
+    fees = chain.fees,
+    formatters = chain.formatters,
+    serializers = chain.serializers,
+  } = config
+  return {
+    ...chain,
+    fees,
+    formatters,
+    serializers,
+  } as unknown as Assign<chain, ChainConfig<formatters>>
+}

package/utils/chain/extractChain.ts

@@ -0,0 +1,33 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { Chain, ExtractChain } from '../../types/chain.js'
+
+export type ExtractChainParameters<
+  chains extends readonly Chain[],
+  chainId extends chains[number]['id'],
+> = {
+  chains: chains
+  id: chainId | chains[number]['id']
+}
+
+export type ExtractChainReturnType<
+  chains extends readonly Chain[],
+  chainId extends chains[number]['id'],
+> = ExtractChain<chains, chainId>
+
+export type ExtractChainErrorType = ErrorType
+
+export function extractChain<
+  const chains extends readonly Chain[],
+  chainId extends chains[number]['id'],
+>({
+  chains,
+  id,
+}: ExtractChainParameters<chains, chainId>): ExtractChainReturnType<
+  chains,
+  chainId
+> {
+  return chains.find((chain) => chain.id === id) as ExtractChainReturnType<
+    chains,
+    chainId
+  >
+}

package/utils/chain/getChainContractAddress.ts

@@ -0,0 +1,41 @@
+import {
+  ChainDoesNotSupportContract,
+  type ChainDoesNotSupportContractErrorType,
+} from '../../errors/chain.js'
+import type { Chain, ChainContract } from '../../types/chain.js'
+
+export type GetChainContractAddressErrorType =
+  ChainDoesNotSupportContractErrorType
+
+export function getChainContractAddress({
+  blockNumber,
+  chain,
+  contract: name,
+}: {
+  blockNumber?: bigint
+  chain: Chain
+  contract: string
+}) {
+  const contract = (chain?.contracts as Record<string, ChainContract>)?.[name]
+  if (!contract)
+    throw new ChainDoesNotSupportContract({
+      chain,
+      contract: { name },
+    })
+
+  if (
+    blockNumber &&
+    contract.blockCreated &&
+    contract.blockCreated > blockNumber
+  )
+    throw new ChainDoesNotSupportContract({
+      blockNumber,
+      chain,
+      contract: {
+        name,
+        blockCreated: contract.blockCreated,
+      },
+    })
+
+  return contract.address
+}

package/utils/formatters/extract.ts

@@ -4,19 +4,30 @@ import type { ChainFormatter } from '../../types/chain.js'
 export type ExtractErrorType = ErrorType
 
 /**
- * @description Picks out the keys from `value` that exist in the formatter.
+ * @description Picks out the keys from `value` that exist in the formatter..
  */
 export function extract(
-  value: Record<string, unknown>,
+  value_: Record<string, unknown>,
   { format }: { format?: ChainFormatter['format'] },
 ) {
   if (!format) return {}
-  const keys = Object.keys(format({}))
-  return keys.reduce((data: Record<string, unknown>, key) => {
-    // biome-ignore lint/suspicious/noPrototypeBuiltins:
-    if (value?.hasOwnProperty(key)) {
-      data[key] = value[key]
+
+  const value: Record<string, unknown> = {}
+  function extract_(formatted: Record<string, any>) {
+    const keys = Object.keys(formatted)
+    for (const key of keys) {
+      if (key in value_) value[key] = value_[key]
+      if (
+        formatted[key] &&
+        typeof formatted[key] === 'object' &&
+        !Array.isArray(formatted[key])
+      )
+        extract_(formatted[key])
     }
-    return data
-  }, {})
+  }
+
+  const formatted = format(value_ || {})
+  extract_(formatted)
+
+  return value
 }

package/utils/formatters/formatter.ts

@@ -10,7 +10,7 @@ export function defineFormatter<TType extends string, TParameters, TReturnType>(
   return <
     TOverrideParameters,
     TOverrideReturnType,
-    TExclude extends (keyof TParameters)[] = [],
+    TExclude extends (keyof TParameters | keyof TOverrideParameters)[] = [],
   >({
     exclude,
     format: overrides,

package/utils/getAction.ts

@@ -0,0 +1,13 @@
+import type { Client } from '../clients/createClient.js'
+
+export function getAction<params extends {}, returnType extends {}>(
+  client: Client,
+  action: (_: any, params: params) => returnType,
+) {
+  return (params: params): returnType =>
+    (
+      client as Client & {
+        [key: string]: (params: params) => returnType
+      }
+    )[action.name]?.(params) ?? action(client, params)
+}

package/utils/index.ts

@@ -15,13 +15,22 @@ export {
 } from './ccip.js'
 
 export {
-  type AssertCurrentChainParameters,
   type AssertCurrentChainErrorType,
-  type GetChainContractAddressErrorType,
+  type AssertCurrentChainParameters,
   assertCurrentChain,
-  defineChain,
+} from './chain/assertCurrentChain.js'
+export { defineChain } from './chain/defineChain.js'
+export {
+  type ExtractChainErrorType,
+  type ExtractChainParameters,
+  type ExtractChainReturnType,
+  extractChain,
+} from './chain/extractChain.js'
+export {
+  type GetChainContractAddressErrorType,
   getChainContractAddress,
-} from './chain.js'
+} from './chain/getChainContractAddress.js'
+
 export { arrayRegex, bytesRegex, integerRegex } from './regex.js'
 
 export {