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

package/actions/public/verifyHash.ts

@@ -15,6 +15,7 @@ import {
 } from '../../utils/data/isBytesEqual.js'
 import type { IsHexErrorType } from '../../utils/data/isHex.js'
 import type { ToHexErrorType } from '../../utils/encoding/toHex.js'
+import { getAction } from '../../utils/getAction.js'
 import { encodeDeployData, isHex, toHex } from '../../utils/index.js'
 import { type CallErrorType, type CallParameters, call } from './call.js'
 
@@ -54,7 +55,10 @@ export async function verifyHash<TChain extends Chain | undefined,>(
   const signatureHex = isHex(signature) ? signature : toHex(signature)
 
   try {
-    const { data } = await call(client, {
+    const { data } = await getAction(
+      client,
+      call,
+    )({
       data: encodeDeployData({
         abi: universalSignatureValidatorAbi,
         args: [address, hash, signatureHex],

package/actions/public/waitForTransactionReceipt.ts

@@ -9,6 +9,7 @@ import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 import type { Transaction } from '../../types/transaction.js'
+import { getAction } from '../../utils/getAction.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { withRetry } from '../../utils/promise/withRetry.js'
 import { stringify } from '../../utils/stringify.js'
@@ -140,7 +141,10 @@ export async function waitForTransactionReceipt<
       observerId,
       { onReplaced, resolve, reject },
       (emit) => {
-        const _unwatch = watchBlockNumber(client, {
+        const _unwatch = getAction(
+          client,
+          watchBlockNumber,
+        )({
           emitMissed: true,
           emitOnBegin: true,
           poll: true,
@@ -178,7 +182,10 @@ export async function waitForTransactionReceipt<
                 retrying = true
                 await withRetry(
                   async () => {
-                    transaction = await getTransaction(client, { hash })
+                    transaction = (await getAction(
+                      client,
+                      getTransaction,
+                    )({ hash })) as GetTransactionReturnType<TChain>
                     if (transaction.blockNumber)
                       blockNumber = transaction.blockNumber
                   },
@@ -192,7 +199,7 @@ export async function waitForTransactionReceipt<
               }
 
               // Get the receipt to check if it's been processed.
-              receipt = await getTransactionReceipt(client, { hash })
+              receipt = await getAction(client, getTransactionReceipt)({ hash })
 
               // Check if we have enough confirmations. If not, continue polling.
               if (
@@ -215,13 +222,16 @@ export async function waitForTransactionReceipt<
                   replacedTransaction = transaction
 
                   // Let's retrieve the transactions from the current block.
-                  const block = await getBlock(client, {
+                  const block = await getAction(
+                    client,
+                    getBlock,
+                  )({
                     blockNumber,
                     includeTransactions: true,
                   })
 
                   const replacementTransaction = (
-                    block.transactions as Transaction[]
+                    block.transactions as {} as Transaction[]
                   ).find(
                     ({ from, nonce }) =>
                       from === replacedTransaction!.from &&
@@ -232,7 +242,10 @@ export async function waitForTransactionReceipt<
                   if (!replacementTransaction) return
 
                   // If we found a replacement transaction, return it's receipt.
-                  receipt = await getTransactionReceipt(client, {
+                  receipt = await getAction(
+                    client,
+                    getTransactionReceipt,
+                  )({
                     hash: replacementTransaction.hash,
                   })
 

package/actions/public/watchBlockNumber.ts

@@ -4,6 +4,7 @@ import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { GetTransportConfig } from '../../types/transport.js'
 import { hexToBigInt } from '../../utils/encoding/fromHex.js'
+import { getAction } from '../../utils/getAction.js'
 import { observe } from '../../utils/observe.js'
 import { type PollErrorType, poll } from '../../utils/poll.js'
 import { stringify } from '../../utils/stringify.js'
@@ -108,7 +109,10 @@ export function watchBlockNumber<
       poll(
         async () => {
           try {
-            const blockNumber = await getBlockNumber(client, { cacheTime: 0 })
+            const blockNumber = await getAction(
+              client,
+              getBlockNumber,
+            )({ cacheTime: 0 })
 
             if (prevBlockNumber) {
               // If the current block number is the same as the previous,

package/actions/public/watchBlocks.ts

@@ -5,6 +5,7 @@ import type { BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type { GetTransportConfig } from '../../types/transport.js'
 import { formatBlock } from '../../utils/formatters/block.js'
+import { getAction } from '../../utils/getAction.js'
 import { observe } from '../../utils/observe.js'
 import { type PollErrorType, poll } from '../../utils/poll.js'
 import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
@@ -137,7 +138,10 @@ export function watchBlocks<
       poll(
         async () => {
           try {
-            const block = await getBlock(client, {
+            const block = await getAction(
+              client,
+              getBlock,
+            )({
               blockTag,
               includeTransactions,
             })
@@ -150,10 +154,13 @@ export function watchBlocks<
               // `emitMissed` flag is truthy, let's emit those blocks.
               if (block.number - prevBlock.number > 1 && emitMissed) {
                 for (let i = prevBlock?.number + 1n; i < block.number; i++) {
-                  const block = await getBlock(client, {
+                  const block = (await getAction(
+                    client,
+                    getBlock,
+                  )({
                     blockNumber: i,
                     includeTransactions,
-                  })
+                  })) as GetBlockReturnType<TChain>
                   emit.onBlock(block as any, prevBlock as any)
                   prevBlock = block
                 }

package/actions/public/watchContractEvent.ts

@@ -24,6 +24,7 @@ import {
   encodeEventTopics,
 } from '../../utils/abi/encodeEventTopics.js'
 import { formatLog } from '../../utils/formatters/log.js'
+import { getAction } from '../../utils/getAction.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
 import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
@@ -173,7 +174,10 @@ export function watchContractEvent<
         async () => {
           if (!initialized) {
             try {
-              filter = (await createContractEventFilter(client, {
+              filter = (await getAction(
+                client,
+                createContractEventFilter,
+              )({
                 abi,
                 address,
                 args: args as any,
@@ -188,19 +192,22 @@ export function watchContractEvent<
           try {
             let logs: Log[]
             if (filter) {
-              logs = await getFilterChanges(client, { filter })
+              logs = await getAction(client, getFilterChanges)({ filter })
             } else {
               // If the filter doesn't exist, we will fall back to use `getLogs`.
               // The fall back exists because some RPC Providers do not support filters.
 
               // Fetch the block number to use for `getLogs`.
-              const blockNumber = await getBlockNumber(client)
+              const blockNumber = await getAction(client, getBlockNumber)({})
 
               // If the block number has changed, we will need to fetch the logs.
               // If the block number doesn't exist, we are yet to reach the first poll interval,
               // so do not emit any logs.
               if (previousBlockNumber && previousBlockNumber !== blockNumber) {
-                logs = await getContractEvents(client, {
+                logs = await getAction(
+                  client,
+                  getContractEvents,
+                )({
                   abi,
                   address,
                   args: args as any,
@@ -232,7 +239,7 @@ export function watchContractEvent<
       )
 
       return async () => {
-        if (filter) await uninstallFilter(client, { filter })
+        if (filter) await getAction(client, uninstallFilter)({ filter })
         unwatch()
       }
     })

package/actions/public/watchEvent.ts

@@ -22,6 +22,7 @@ import {
 } from '../../errors/abi.js'
 import { InvalidInputRpcError } from '../../errors/rpc.js'
 import type { ErrorType } from '../../errors/utils.js'
+import { getAction } from '../../utils/getAction.js'
 import {
   decodeEventLog,
   encodeEventTopics,
@@ -191,7 +192,10 @@ export function watchEvent<
         async () => {
           if (!initialized) {
             try {
-              filter = (await createEventFilter(client, {
+              filter = (await getAction(
+                client,
+                createEventFilter as any,
+              )({
                 address,
                 args,
                 event: event!,
@@ -210,19 +214,22 @@ export function watchEvent<
           try {
             let logs: Log[]
             if (filter) {
-              logs = await getFilterChanges(client, { filter })
+              logs = await getAction(client, getFilterChanges)({ filter })
             } else {
               // If the filter doesn't exist, we will fall back to use `getLogs`.
               // The fall back exists because some RPC Providers do not support filters.
 
               // Fetch the block number to use for `getLogs`.
-              const blockNumber = await getBlockNumber(client)
+              const blockNumber = await getAction(client, getBlockNumber)({})
 
               // If the block number has changed, we will need to fetch the logs.
               // If the block number doesn't exist, we are yet to reach the first poll interval,
               // so do not emit any logs.
               if (previousBlockNumber && previousBlockNumber !== blockNumber) {
-                logs = await getLogs(client, {
+                logs = await getAction(
+                  client,
+                  getLogs,
+                )({
                   address,
                   args,
                   event: event!,
@@ -254,7 +261,7 @@ export function watchEvent<
       )
 
       return async () => {
-        if (filter) await uninstallFilter(client, { filter })
+        if (filter) await getAction(client, uninstallFilter)({ filter })
         unwatch()
       }
     })

package/actions/public/watchPendingTransactions.ts

@@ -5,6 +5,7 @@ import type { Chain } from '../../types/chain.js'
 import type { Filter } from '../../types/filter.js'
 import type { Hash } from '../../types/misc.js'
 import type { GetPollOptions } from '../../types/transport.js'
+import { getAction } from '../../utils/getAction.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
 import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
@@ -92,7 +93,10 @@ export function watchPendingTransactions<
           try {
             if (!filter) {
               try {
-                filter = await createPendingTransactionFilter(client)
+                filter = await getAction(
+                  client,
+                  createPendingTransactionFilter,
+                )({})
                 return
               } catch (err) {
                 unwatch()
@@ -100,7 +104,7 @@ export function watchPendingTransactions<
               }
             }
 
-            const hashes = await getFilterChanges(client, { filter })
+            const hashes = await getAction(client, getFilterChanges)({ filter })
             if (hashes.length === 0) return
             if (batch) emit.onTransactions(hashes)
             else hashes.forEach((hash) => emit.onTransactions([hash]))
@@ -115,7 +119,7 @@ export function watchPendingTransactions<
       )
 
       return async () => {
-        if (filter) await uninstallFilter(client, { filter })
+        if (filter) await getAction(client, uninstallFilter)({ filter })
         unwatch()
       }
     })

package/actions/test/sendUnsignedTransaction.ts

@@ -69,12 +69,12 @@ export async function sendUnsignedTransaction<
     ...rest
   } = args
 
-  const format =
-    client.chain?.formatters?.transactionRequest?.format ||
-    formatTransactionRequest
+  const chainFormat = client.chain?.formatters?.transactionRequest?.format
+  const format = chainFormat || formatTransactionRequest
+
   const request = format({
     // Pick out extra data that might exist on the chain's transaction request type.
-    ...extract(rest, { format }),
+    ...extract(rest, { format: chainFormat }),
     accessList,
     data,
     from,

package/actions/wallet/getAddresses.ts

@@ -44,6 +44,7 @@ export async function getAddresses<
 >(
   client: Client<Transport, TChain, TAccount>,
 ): Promise<GetAddressesReturnType> {
+  if (client.account?.type === 'local') return [client.account.address]
   const addresses = await client.request({ method: 'eth_accounts' })
   return addresses.map((address) => checksumAddress(address))
 }

package/actions/wallet/prepareTransactionRequest.ts

@@ -36,6 +36,7 @@ import type { GetChain } from '../../types/chain.js'
 import type { TransactionSerializable } from '../../types/transaction.js'
 import type { UnionOmit } from '../../types/utils.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import type {
   AssertRequestErrorType,
   AssertRequestParameters,
@@ -118,7 +119,7 @@ export type PrepareTransactionRequestErrorType =
 export async function prepareTransactionRequest<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
-  TChainOverride extends Chain | undefined,
+  TChainOverride extends Chain | undefined = undefined,
 >(
   client: Client<Transport, TChain, TAccount>,
   args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
@@ -129,12 +130,15 @@ export async function prepareTransactionRequest<
   if (!account_) throw new AccountNotFoundError()
   const account = parseAccount(account_)
 
-  const block = await getBlock(client, { blockTag: 'latest' })
+  const block = await getAction(client, getBlock)({ blockTag: 'latest' })
 
   const request = { ...args, from: account.address }
 
   if (typeof nonce === 'undefined')
-    request.nonce = await getTransactionCount(client, {
+    request.nonce = await getAction(
+      client,
+      getTransactionCount,
+    )({
       address: account.address,
       blockTag: 'pending',
     })
@@ -189,7 +193,10 @@ export async function prepareTransactionRequest<
   }
 
   if (typeof gas === 'undefined')
-    request.gas = await estimateGas(client, {
+    request.gas = await getAction(
+      client,
+      estimateGas,
+    )({
       ...request,
       account: { address: account.address, type: 'json-rpc' },
     } as EstimateGasParameters)

package/actions/wallet/sendTransaction.ts

@@ -22,7 +22,7 @@ import type { RequestErrorType } from '../../utils/buildRequest.js'
 import {
   type AssertCurrentChainErrorType,
   assertCurrentChain,
-} from '../../utils/chain.js'
+} from '../../utils/chain/assertCurrentChain.js'
 import {
   type GetTransactionErrorReturnType,
   getTransactionError,
@@ -32,6 +32,7 @@ import {
   type FormattedTransactionRequest,
   formatTransactionRequest,
 } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import {
   type AssertRequestErrorType,
   type AssertRequestParameters,
@@ -123,7 +124,7 @@ export type SendTransactionErrorType =
 export async function sendTransaction<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
-  TChainOverride extends Chain | undefined,
+  TChainOverride extends Chain | undefined = undefined,
 >(
   client: Client<Transport, TChain, TAccount>,
   args: SendTransactionParameters<TChain, TAccount, TChainOverride>,
@@ -154,7 +155,7 @@ export async function sendTransaction<
 
     let chainId
     if (chain !== null) {
-      chainId = await getChainId(client)
+      chainId = await getAction(client, getChainId)({})
       assertCurrentChain({
         currentChainId: chainId,
         chain,
@@ -163,7 +164,10 @@ export async function sendTransaction<
 
     if (account.type === 'local') {
       // Prepare the request for signing (assign appropriate fees, etc.)
-      const request = await prepareTransactionRequest(client, {
+      const request = await getAction(
+        client,
+        prepareTransactionRequest,
+      )({
         account,
         accessList,
         chain,
@@ -178,7 +182,7 @@ export async function sendTransaction<
         ...rest,
       } as any)
 
-      if (!chainId) chainId = await getChainId(client)
+      if (!chainId) chainId = await getAction(client, getChainId)({})
 
       const serializer = chain?.serializers?.transaction
       const serializedTransaction = (await account.signTransaction(
@@ -188,16 +192,20 @@ export async function sendTransaction<
         } as TransactionSerializable,
         { serializer },
       )) as Hash
-      return await sendRawTransaction(client, {
+      return await getAction(
+        client,
+        sendRawTransaction,
+      )({
         serializedTransaction,
       })
     }
 
-    const format =
-      chain?.formatters?.transactionRequest?.format || formatTransactionRequest
+    const chainFormat = client.chain?.formatters?.transactionRequest?.format
+    const format = chainFormat || formatTransactionRequest
+
     const request = format({
       // Pick out extra data that might exist on the chain's transaction request type.
-      ...extract(rest, { format }),
+      ...extract(rest, { format: chainFormat }),
       accessList,
       data,
       from: account.address,

package/actions/wallet/signTransaction.ts

@@ -21,12 +21,13 @@ import type { RequestErrorType } from '../../utils/buildRequest.js'
 import {
   type AssertCurrentChainErrorType,
   assertCurrentChain,
-} from '../../utils/chain.js'
+} from '../../utils/chain/assertCurrentChain.js'
 import type { NumberToHexErrorType } from '../../utils/encoding/toHex.js'
 import {
   type FormattedTransactionRequest,
   formatTransactionRequest,
 } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import { numberToHex } from '../../utils/index.js'
 import {
   type AssertRequestErrorType,
@@ -105,7 +106,7 @@ export type SignTransactionErrorType =
 export async function signTransaction<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
-  TChainOverride extends Chain | undefined,
+  TChainOverride extends Chain | undefined = undefined,
 >(
   client: Client<Transport, TChain, TAccount>,
   args: SignTransactionParameters<TChain, TAccount, TChainOverride>,
@@ -127,7 +128,7 @@ export async function signTransaction<
     ...args,
   })
 
-  const chainId = await getChainId(client)
+  const chainId = await getAction(client, getChainId)({})
   if (chain !== null)
     assertCurrentChain({
       currentChainId: chainId,
@@ -141,8 +142,8 @@ export async function signTransaction<
   if (account.type === 'local')
     return account.signTransaction(
       {
-        chainId,
         ...transaction,
+        chainId,
       } as unknown as TransactionSerializable,
       { serializer: client.chain?.serializers?.transaction },
     ) as Promise<SignTransactionReturnType>

package/actions/wallet/writeContract.ts

@@ -16,9 +16,11 @@ import type { Hex } from '../../types/misc.js'
 import type { Prettify, UnionEvaluate, UnionOmit } from '../../types/utils.js'
 import {
   type EncodeFunctionDataErrorType,
+  type EncodeFunctionDataParameters,
   encodeFunctionData,
 } from '../../utils/abi/encodeFunctionData.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
 import {
   type SendTransactionErrorType,
   type SendTransactionParameters,
@@ -153,11 +155,18 @@ export async function writeContract<
 ): Promise<WriteContractReturnType> {
   const { abi, address, args, dataSuffix, functionName, ...request } =
     parameters as WriteContractParameters
-  const data = encodeFunctionData({ abi, args, functionName })
-  const hash = await sendTransaction(client, {
+  const data = encodeFunctionData({
+    abi,
+    args,
+    functionName,
+  } as EncodeFunctionDataParameters)
+  const hash = await getAction(
+    client,
+    sendTransaction,
+  )({
     data: `${data}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
     to: address,
     ...request,
-  })
+  } as SendTransactionParameters)
   return hash
 }

package/chains/celo/formatters.ts

@@ -20,6 +20,22 @@ import type {
   CeloTransactionRequest,
 } from './types.js'
 
+function isTransactionRequestCIP64(args: CeloTransactionRequest): boolean {
+  if (args.type === 'cip64') return true
+  if (args.type) return false
+  return (
+    'feeCurrency' in args &&
+    args.gatewayFee === undefined &&
+    args.gatewayFeeRecipient === undefined
+  )
+}
+
+function isTransactionRequestCIP42(args: CeloTransactionRequest): boolean {
+  if (args.type === 'cip42') return true
+  if (args.type) return false
+  return args.gatewayFee !== undefined || args.gatewayFeeRecipient !== undefined
+}
+
 export const formattersCelo = {
   block: /*#__PURE__*/ defineBlock({
     exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
@@ -35,10 +51,15 @@ export const formattersCelo = {
         return {
           ...formatTransaction(transaction as RpcTransaction),
           feeCurrency: transaction.feeCurrency,
-          gatewayFee: transaction.gatewayFee
-            ? hexToBigInt(transaction.gatewayFee)
-            : null,
-          gatewayFeeRecipient: transaction.gatewayFeeRecipient,
+
+          ...(transaction.type !== '0x7b'
+            ? {
+                gatewayFee: transaction.gatewayFee
+                  ? hexToBigInt(transaction.gatewayFee)
+                  : null,
+                gatewayFeeRecipient: transaction.gatewayFeeRecipient || null,
+              }
+            : {}),
         }
       }) as Hash[] | CeloTransaction[]
       return {
@@ -49,6 +70,10 @@ export const formattersCelo = {
   }),
   transaction: /*#__PURE__*/ defineTransaction({
     format(args: CeloRpcTransaction): CeloTransaction {
+      if (args.type === '0x7b')
+        return {
+          feeCurrency: args.feeCurrency,
+        } as CeloTransaction
       return {
         feeCurrency: args.feeCurrency,
         gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
@@ -67,8 +92,15 @@ export const formattersCelo = {
       }
     },
   }),
+
   transactionRequest: /*#__PURE__*/ defineTransactionRequest({
     format(args: CeloTransactionRequest): CeloRpcTransactionRequest {
+      if (isTransactionRequestCIP64(args))
+        return {
+          type: '0x7b',
+          feeCurrency: args.feeCurrency,
+        } as CeloRpcTransactionRequest
+
       const request = {
         feeCurrency: args.feeCurrency,
         gatewayFee:
@@ -77,7 +109,9 @@ export const formattersCelo = {
             : undefined,
         gatewayFeeRecipient: args.gatewayFeeRecipient,
       } as CeloRpcTransactionRequest
-      if (args.type === 'cip42') request.type = '0x7c'
+
+      if (isTransactionRequestCIP42(args)) request.type = '0x7c'
+
       return request
     },
   }),