viem 2.23.10 → 2.23.12

package/experimental/eip5792/actions/waitForCallsStatus.ts

@@ -0,0 +1,137 @@
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { BaseError } from '../../../errors/base.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Chain } from '../../../types/chain.js'
+import type { WalletGetCallsStatusReturnType } from '../../../types/eip1193.js'
+import type { Prettify } from '../../../types/utils.js'
+import { type ObserveErrorType, observe } from '../../../utils/observe.js'
+import { type PollErrorType, poll } from '../../../utils/poll.js'
+import { withResolvers } from '../../../utils/promise/withResolvers.js'
+import { stringify } from '../../../utils/stringify.js'
+import {
+  type GetCallsStatusErrorType,
+  getCallsStatus,
+} from './getCallsStatus.js'
+
+export type WaitForCallsStatusParameters = {
+  /**
+   * The id of the call batch to wait for.
+   */
+  id: string
+  /**
+   * Polling frequency (in ms). Defaults to the client's pollingInterval config.
+   *
+   * @default client.pollingInterval
+   */
+  pollingInterval?: number | undefined
+  /**
+   * The status to wait for.
+   *
+   * @default 'CONFIRMED'
+   */
+  status?: 'CONFIRMED' | undefined
+  /**
+   * Optional timeout (in milliseconds) to wait before stopping polling.
+   *
+   * @default 60_000
+   */
+  timeout?: number | undefined
+}
+
+export type WaitForCallsStatusReturnType = Prettify<
+  WalletGetCallsStatusReturnType<bigint, 'success' | 'reverted'>
+>
+
+export type WaitForCallsStatusErrorType =
+  | ObserveErrorType
+  | PollErrorType
+  | GetCallsStatusErrorType
+  | WaitForCallsStatusTimeoutError
+  | ErrorType
+
+/**
+ * Waits for the status & receipts of a call bundle that was sent via `sendCalls`.
+ *
+ * - Docs: https://viem.sh/experimental/eip5792/waitForCallsStatus
+ * - JSON-RPC Methods: [`wallet_getCallsStatus`](https://eips.ethereum.org/EIPS/eip-5792)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link WaitForCallsStatusParameters}
+ * @returns Status & receipts of the call bundle. {@link WaitForCallsStatusReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { waitForCallsStatus } from 'viem/experimental'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const { receipts, status } = await waitForCallsStatus(client, { id: '0xdeadbeef' })
+ */
+export async function waitForCallsStatus<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: WaitForCallsStatusParameters,
+): Promise<WaitForCallsStatusReturnType> {
+  const {
+    id,
+    pollingInterval = client.pollingInterval,
+    status = 'CONFIRMED',
+    timeout = 60_000,
+  } = parameters
+  const observerId = stringify(['waitForCallsStatus', client.uid, id])
+
+  const { promise, resolve, reject } =
+    withResolvers<WaitForCallsStatusReturnType>()
+
+  let timer: Timer | undefined = undefined
+
+  const unobserve = observe(observerId, { resolve, reject }, (emit) => {
+    const unpoll = poll(
+      async () => {
+        try {
+          const result = await getCallsStatus(client, { id })
+          if (result.status !== status) return
+          emit.resolve(result)
+        } catch (error) {
+          if (timer) clearTimeout(timer)
+          unpoll()
+          emit.reject(error)
+          unobserve()
+        }
+      },
+      {
+        interval: pollingInterval,
+        emitOnBegin: true,
+      },
+    )
+
+    return unpoll
+  })
+
+  timer = timeout
+    ? setTimeout(() => {
+        unobserve()
+        clearTimeout(timer)
+        reject(new WaitForCallsStatusTimeoutError({ id }))
+      }, timeout)
+    : undefined
+
+  return await promise
+}
+
+export type WaitForCallsStatusTimeoutErrorType =
+  WaitForCallsStatusTimeoutError & {
+    name: 'WaitForCallsStatusTimeoutError'
+  }
+export class WaitForCallsStatusTimeoutError extends BaseError {
+  constructor({ id }: { id: string }) {
+    super(
+      `Timed out while waiting for call bundle with id "${id}" to be confirmed.`,
+      { name: 'WaitForCallsStatusTimeoutError' },
+    )
+  }
+}

package/experimental/eip5792/decorators/eip5792.ts

@@ -22,6 +22,11 @@ import {
   type ShowCallsStatusReturnType,
   showCallsStatus,
 } from '../actions/showCallsStatus.js'
+import {
+  type WaitForCallsStatusParameters,
+  type WaitForCallsStatusReturnType,
+  waitForCallsStatus,
+} from '../actions/waitForCallsStatus.js'
 import {
   type WriteContractsParameters,
   type WriteContractsReturnType,
@@ -143,6 +148,31 @@ export type Eip5792Actions<
   showCallsStatus: (
     parameters: ShowCallsStatusParameters,
   ) => Promise<ShowCallsStatusReturnType>
+  /**
+   * Waits for the status & receipts of a call bundle that was sent via `sendCalls`.
+   *
+   * - Docs: https://viem.sh/experimental/eip5792/waitForCallsStatus
+   * - JSON-RPC Methods: [`wallet_getCallsStatus`](https://eips.ethereum.org/EIPS/eip-5792)
+   *
+   * @param client - Client to use
+   * @param parameters - {@link WaitForCallsStatusParameters}
+   * @returns Status & receipts of the call bundle. {@link WaitForCallsStatusReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { waitForCallsStatus } from 'viem/experimental'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   *
+   * const { receipts, status } = await waitForCallsStatus(client, { id: '0xdeadbeef' })
+   */
+  waitForCallsStatus: (
+    parameters: WaitForCallsStatusParameters,
+  ) => Promise<WaitForCallsStatusReturnType>
   /**
    * Requests for the wallet to sign and broadcast a batch of write contract calls (transactions) to the network.
    *
@@ -231,6 +261,8 @@ export function eip5792Actions() {
         getCapabilities(client as any, parameters)) as any,
       sendCalls: (parameters) => sendCalls(client, parameters),
       showCallsStatus: (parameters) => showCallsStatus(client, parameters),
+      waitForCallsStatus: (parameters) =>
+        waitForCallsStatus(client, parameters),
       writeContracts: (parameters) => writeContracts(client, parameters),
     }
   }

package/experimental/index.ts

@@ -23,6 +23,14 @@ export {
   type ShowCallsStatusReturnType,
   showCallsStatus,
 } from './eip5792/actions/showCallsStatus.js'
+export {
+  type WaitForCallsStatusErrorType,
+  type WaitForCallsStatusParameters,
+  type WaitForCallsStatusReturnType,
+  type WaitForCallsStatusTimeoutErrorType,
+  WaitForCallsStatusTimeoutError,
+  waitForCallsStatus,
+} from './eip5792/actions/waitForCallsStatus.js'
 export {
   type WriteContractsErrorType,
   type WriteContractsParameters,

package/package.json

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

package/utils/ccip.ts

@@ -141,7 +141,7 @@ export async function ccipRequest({
 
     try {
       const response = await fetch(
-        url.replace('{sender}', sender).replace('{data}', data),
+        url.replace('{sender}', sender.toLowerCase()).replace('{data}', data),
         {
           body: JSON.stringify(body),
           headers,

package/utils/formatters/transactionRequest.ts

@@ -91,8 +91,12 @@ function formatAuthorizationList(
     (authorization) =>
       ({
         address: authorization.contractAddress,
-        r: authorization.r,
-        s: authorization.s,
+        r: authorization.r
+          ? numberToHex(BigInt(authorization.r))
+          : authorization.r,
+        s: authorization.s
+          ? numberToHex(BigInt(authorization.s))
+          : authorization.s,
         chainId: numberToHex(authorization.chainId),
         nonce: numberToHex(authorization.nonce),
         ...(typeof authorization.yParity !== 'undefined'

package/zksync/actions/isWithdrawalFinalized.ts

@@ -0,0 +1,122 @@
+import type { Address } from 'abitype'
+import type { Account } from '../../accounts/types.js'
+import { readContract } from '../../actions/public/readContract.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import {
+  ChainNotFoundError,
+  type ChainNotFoundErrorType,
+} from '../../errors/chain.js'
+import type { Chain } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
+import { isAddressEqual, slice } from '../../utils/index.js'
+import { l1SharedBridgeAbi, l2SharedBridgeAbi } from '../constants/abis.js'
+import { l2BaseTokenAddress } from '../constants/address.js'
+import {
+  WithdrawalLogNotFoundError,
+  type WithdrawalLogNotFoundErrorType,
+} from '../errors/bridge.js'
+import type { ChainEIP712 } from '../types/chain.js'
+import { getWithdrawalL2ToL1Log } from '../utils/bridge/getWithdrawalL2ToL1Log.js'
+import { getWithdrawalLog } from '../utils/bridge/getWithdrawalLog.js'
+import { getBaseTokenL1Address } from './getBaseTokenL1Address.js'
+import { getDefaultBridgeAddresses } from './getDefaultBridgeAddresses.js'
+import { getLogProof } from './getLogProof.js'
+
+export type IsWithdrawalFinalizedParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = {
+  /** L2 client */
+  client: Client<Transport, chain, account>
+  /** Hash of the L2 transaction where the withdrawal was initiated. */
+  hash: Hash
+  /** In case there were multiple withdrawals in one transaction, you may pass an index of the
+  withdrawal you want to finalize. */
+  index?: number | undefined
+}
+
+export type IsWithdrawalFinalizedReturnType = boolean
+
+export type IsWithdrawalFinalizedErrorType =
+  | WithdrawalLogNotFoundErrorType
+  | ChainNotFoundErrorType
+
+/**
+ * Returns whether the withdrawal transaction is finalized on the L1 network.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link IsWithdrawalFinalizedParameters}
+ * @returns bool - Whether the withdrawal transaction is finalized on the L1 network. {@link IsWithdrawalFinalizedReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet, zksync } from 'viem/chains'
+ * import { isWithdrawalFinalized } from 'viem/zksync'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const clientL2 = createPublicClient({
+ *   chain: zksync,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await isWithdrawalFinalized(client, {
+ *     client: clientL2,
+ *     hash: '0x...',
+ * })
+ */
+export async function isWithdrawalFinalized<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainL2 extends ChainEIP712 | undefined,
+  accountL2 extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: IsWithdrawalFinalizedParameters<chainL2, accountL2>,
+): Promise<IsWithdrawalFinalizedReturnType> {
+  const { client: l2Client, hash, index = 0 } = parameters
+
+  if (!l2Client.chain) throw new ChainNotFoundError()
+
+  const { log } = await getWithdrawalLog(l2Client, { hash, index })
+  const { l2ToL1LogIndex } = await getWithdrawalL2ToL1Log(l2Client, {
+    hash,
+    index,
+  })
+  const sender = slice(log.topics[1]!, 12) as Address
+  // `getLogProof` is called not to get proof but
+  // to get the index of the corresponding L2->L1 log,
+  // which is returned as `proof.id`.
+  const proof = await getLogProof(l2Client, {
+    txHash: hash,
+    index: l2ToL1LogIndex!,
+  })
+  if (!proof) {
+    throw new WithdrawalLogNotFoundError({ hash })
+  }
+
+  let l1Bridge: Address
+  if (
+    isAddressEqual(sender, await getBaseTokenL1Address(l2Client)) ||
+    isAddressEqual(sender, l2BaseTokenAddress)
+  )
+    l1Bridge = (await getDefaultBridgeAddresses(l2Client)).sharedL1
+  else
+    l1Bridge = await readContract(l2Client, {
+      address: sender,
+      abi: l2SharedBridgeAbi,
+      functionName: 'l1SharedBridge',
+      args: [],
+    })
+
+  return await readContract(client, {
+    address: l1Bridge,
+    abi: l1SharedBridgeAbi,
+    functionName: 'isWithdrawalFinalized',
+    args: [BigInt(l2Client.chain.id), log.l1BatchNumber!, BigInt(proof.id)],
+  })
+}

package/zksync/decorators/publicL1.ts

@@ -17,6 +17,11 @@ import {
   type GetL1TokenBalanceReturnType,
   getL1TokenBalance,
 } from '../actions/getL1TokenBalance.js'
+import {
+  type IsWithdrawalFinalizedParameters,
+  type IsWithdrawalFinalizedReturnType,
+  isWithdrawalFinalized,
+} from '../actions/isWithdrawalFinalized.js'
 
 export type PublicActionsL1<
   account extends Account | undefined = Account | undefined,
@@ -163,6 +168,36 @@ export type PublicActionsL1<
       ? [GetL1BalanceParameters<account>]
       : [GetL1BalanceParameters<account>] | []
   ) => Promise<GetL1BalanceReturnType>
+  /**
+   * Returns whether the withdrawal transaction is finalized on the L1 network.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link IsWithdrawalFinalizedParameters}
+   * @returns bool - Whether the withdrawal transaction is finalized on the L1 network. {@link IsWithdrawalFinalizedReturnType}
+   *
+   * @example
+   * import { createPublicClient, http } from 'viem'
+   * import { mainnet, zksync } from 'viem/chains'
+   * import { publicActionsL1, publicActionsL2 } from 'viem/zksync'
+   *
+   * const client = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(publicActionsL1())
+   *
+   * const clientL2 = createPublicClient({
+   *   chain: zksync,
+   *   transport: http(),
+   * }).extend(publicActionsL2())
+   *
+   * const hash = await client.isWithdrawalFinalized({
+   *     client: clientL2,
+   *     hash: '0x...',
+   * })
+   */
+  isWithdrawalFinalized: (
+    parameters: IsWithdrawalFinalizedParameters,
+  ) => Promise<IsWithdrawalFinalizedReturnType>
 }
 
 export function publicActionsL1() {
@@ -176,5 +211,6 @@ export function publicActionsL1() {
     getL1TokenBalance: (args) => getL1TokenBalance(client, args),
     // @ts-expect-error
     getL1Balance: (args) => getL1Balance(client, args),
+    isWithdrawalFinalized: (args) => isWithdrawalFinalized(client, args),
   })
 }

package/zksync/index.ts

@@ -95,6 +95,12 @@ export {
   type GetTransactionDetailsReturnType,
   getTransactionDetails,
 } from './actions/getTransactionDetails.js'
+export {
+  type IsWithdrawalFinalizedErrorType,
+  type IsWithdrawalFinalizedReturnType,
+  type IsWithdrawalFinalizedParameters,
+  isWithdrawalFinalized,
+} from './actions/isWithdrawalFinalized.js'
 export {
   type RequestExecuteErrorType,
   type RequestExecuteReturnType,

package/zksync/serializers.ts

@@ -63,7 +63,7 @@ function serializeTransactionEIP712(
     gas ? toHex(gas) : '0x',
     to ?? '0x',
     value ? toHex(value) : '0x',
-    data ?? '0x0',
+    data ?? '0x',
     toHex(chainId),
     toHex(''),
     toHex(''),