viem 2.23.2 → 2.23.4

package/op-stack/abis.ts

@@ -917,19 +917,6 @@ export const portal2Abi = [
     stateMutability: 'payable',
     type: 'receive',
   },
-  {
-    inputs: [],
-    name: 'balance',
-    outputs: [
-      {
-        internalType: 'uint256',
-        name: '',
-        type: 'uint256',
-      },
-    ],
-    stateMutability: 'view',
-    type: 'function',
-  },
   {
     inputs: [
       {
@@ -961,44 +948,6 @@ export const portal2Abi = [
     stateMutability: 'view',
     type: 'function',
   },
-  {
-    inputs: [
-      {
-        internalType: 'address',
-        name: '_to',
-        type: 'address',
-      },
-      {
-        internalType: 'uint256',
-        name: '_mint',
-        type: 'uint256',
-      },
-      {
-        internalType: 'uint256',
-        name: '_value',
-        type: 'uint256',
-      },
-      {
-        internalType: 'uint64',
-        name: '_gasLimit',
-        type: 'uint64',
-      },
-      {
-        internalType: 'bool',
-        name: '_isCreation',
-        type: 'bool',
-      },
-      {
-        internalType: 'bytes',
-        name: '_data',
-        type: 'bytes',
-      },
-    ],
-    name: 'depositERC20Transaction',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
   {
     inputs: [
       {
@@ -1056,7 +1005,7 @@ export const portal2Abi = [
     name: 'disputeGameFactory',
     outputs: [
       {
-        internalType: 'contract DisputeGameFactory',
+        internalType: 'contract IDisputeGameFactory',
         name: '',
         type: 'address',
       },
@@ -1214,17 +1163,17 @@ export const portal2Abi = [
   {
     inputs: [
       {
-        internalType: 'contract DisputeGameFactory',
+        internalType: 'contract IDisputeGameFactory',
         name: '_disputeGameFactory',
         type: 'address',
       },
       {
-        internalType: 'contract SystemConfig',
+        internalType: 'contract ISystemConfig',
         name: '_systemConfig',
         type: 'address',
       },
       {
-        internalType: 'contract SuperchainConfig',
+        internalType: 'contract ISuperchainConfig',
         name: '_superchainConfig',
         type: 'address',
       },
@@ -1500,34 +1449,6 @@ export const portal2Abi = [
     stateMutability: 'view',
     type: 'function',
   },
-  {
-    inputs: [
-      {
-        internalType: 'address',
-        name: '_token',
-        type: 'address',
-      },
-      {
-        internalType: 'uint8',
-        name: '_decimals',
-        type: 'uint8',
-      },
-      {
-        internalType: 'bytes32',
-        name: '_name',
-        type: 'bytes32',
-      },
-      {
-        internalType: 'bytes32',
-        name: '_symbol',
-        type: 'bytes32',
-      },
-    ],
-    name: 'setGasPayingToken',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
   {
     inputs: [
       {
@@ -1546,7 +1467,7 @@ export const portal2Abi = [
     name: 'superchainConfig',
     outputs: [
       {
-        internalType: 'contract SuperchainConfig',
+        internalType: 'contract ISuperchainConfig',
         name: '',
         type: 'address',
       },
@@ -1559,7 +1480,7 @@ export const portal2Abi = [
     name: 'systemConfig',
     outputs: [
       {
-        internalType: 'contract SystemConfig',
+        internalType: 'contract ISystemConfig',
         name: '',
         type: 'address',
       },
@@ -1791,7 +1712,7 @@ export const portal2Abi = [
   },
   {
     inputs: [],
-    name: 'NoValue',
+    name: 'LegacyGame',
     type: 'error',
   },
   {
@@ -1799,11 +1720,6 @@ export const portal2Abi = [
     name: 'NonReentrant',
     type: 'error',
   },
-  {
-    inputs: [],
-    name: 'OnlyCustomGasToken',
-    type: 'error',
-  },
   {
     inputs: [],
     name: 'OutOfGas',
@@ -1819,11 +1735,6 @@ export const portal2Abi = [
     name: 'SmallGasLimit',
     type: 'error',
   },
-  {
-    inputs: [],
-    name: 'TransferFailed',
-    type: 'error',
-  },
   {
     inputs: [],
     name: 'Unauthorized',

package/op-stack/actions/getWithdrawalStatus.ts

@@ -1,3 +1,4 @@
+import type { Address } from 'abitype'
 import {
   type ReadContractErrorType,
   readContract,
@@ -12,6 +13,7 @@ import type {
   DeriveChain,
   GetChainParameter,
 } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
 import type { TransactionReceipt } from '../../types/transaction.js'
 import type { OneOf } from '../../types/utils.js'
 import { portal2Abi, portalAbi } from '../abis.js'
@@ -62,13 +64,33 @@ export type GetWithdrawalStatusParameters<
      * @default 100
      */
     gameLimit?: number
-    /**
-     * The relative index of the withdrawal in the transaction receipt logs.
-     * @default 0
-     */
-    logIndex?: number
-    receipt: TransactionReceipt
-  }
+  } & OneOf<
+    | {
+        /**
+         * The relative index of the withdrawal in the transaction receipt logs.
+         * @default 0
+         */
+        logIndex?: number
+        /**
+         * The transaction receipt of the withdrawal.
+         */
+        receipt: TransactionReceipt
+      }
+    | {
+        /**
+         * The L2 block number of the withdrawal.
+         */
+        l2BlockNumber: bigint
+        /**
+         * The sender of the withdrawal.
+         */
+        sender: Address
+        /**
+         * The hash of the withdrawal.
+         */
+        withdrawalHash: Hash
+      }
+  >
 export type GetWithdrawalStatusReturnType =
   | 'waiting-to-prove'
   | 'ready-to-prove'
@@ -138,12 +160,22 @@ export async function getWithdrawalStatus<
     return Object.values(targetChain.contracts.portal)[0].address
   })()
 
-  const withdrawal = getWithdrawals(receipt)[logIndex]
+  const l2BlockNumber = receipt?.blockNumber ?? parameters.l2BlockNumber
 
-  if (!withdrawal)
-    throw new ReceiptContainsNoWithdrawalsError({
-      hash: receipt.transactionHash,
-    })
+  const withdrawal = (() => {
+    if (receipt) {
+      const withdrawal = getWithdrawals({ logs: receipt.logs })[logIndex]
+      if (!withdrawal)
+        throw new ReceiptContainsNoWithdrawalsError({
+          hash: receipt.transactionHash,
+        })
+      return withdrawal
+    }
+    return {
+      sender: parameters.sender,
+      withdrawalHash: parameters.withdrawalHash,
+    }
+  })()
 
   const portalVersion = await getPortalVersion(
     client,
@@ -156,7 +188,7 @@ export async function getWithdrawalStatus<
       await Promise.allSettled([
         getL2Output(client, {
           ...parameters,
-          l2BlockNumber: receipt.blockNumber,
+          l2BlockNumber,
         } as GetL2OutputParameters),
         readContract(client, {
           abi: portalAbi,
@@ -221,7 +253,7 @@ export async function getWithdrawalStatus<
     await Promise.allSettled([
       getGame(client, {
         ...parameters,
-        l2BlockNumber: receipt.blockNumber,
+        l2BlockNumber,
         limit: gameLimit,
       } as GetGameParameters),
       readContract(client, {
@@ -249,27 +281,38 @@ export async function getWithdrawalStatus<
   if (checkWithdrawalResult.status === 'rejected') {
     const error = checkWithdrawalResult.reason as ReadContractErrorType
     if (error.cause instanceof ContractFunctionRevertedError) {
-      const errorMessage = error.cause.data?.args?.[0]
-      if (
-        errorMessage === 'OptimismPortal: invalid game type' ||
-        errorMessage === 'OptimismPortal: withdrawal has not been proven yet' ||
-        errorMessage ===
-          'OptimismPortal: withdrawal has not been proven by proof submitter address yet' ||
-        errorMessage ===
-          'OptimismPortal: dispute game created before respected game type was updated'
-      )
+      // All potential error causes listed here, can either be the error string or the error name
+      // if custom error types are returned.
+      const errorCauses = {
+        'ready-to-prove': [
+          'OptimismPortal: invalid game type',
+          'OptimismPortal: withdrawal has not been proven yet',
+          'OptimismPortal: withdrawal has not been proven by proof submitter address yet',
+          'OptimismPortal: dispute game created before respected game type was updated',
+          'InvalidGameType',
+          'LegacyGame',
+        ],
+        'waiting-to-finalize': [
+          'OptimismPortal: proven withdrawal has not matured yet',
+          'OptimismPortal: output proposal has not been finalized yet',
+          'OptimismPortal: output proposal in air-gap',
+        ],
+      }
+
+      // Pick out the error message and/or error name
+      // Return the status based on the error
+      const errors = [
+        error.cause.data?.errorName,
+        error.cause.data?.args?.[0] as string,
+      ]
+      if (errorCauses['ready-to-prove'].some((cause) => errors.includes(cause)))
         return 'ready-to-prove'
       if (
-        errorMessage ===
-          'OptimismPortal: proven withdrawal has not matured yet' ||
-        errorMessage ===
-          'OptimismPortal: output proposal has not been finalized yet' ||
-        errorMessage === 'OptimismPortal: output proposal in air-gap'
+        errorCauses['waiting-to-finalize'].some((cause) =>
+          errors.includes(cause),
+        )
       )
         return 'waiting-to-finalize'
-
-      if (error.cause.data?.errorName === 'InvalidGameType')
-        return 'ready-to-prove'
     }
     throw checkWithdrawalResult.reason
   }

package/package.json

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

package/types/eip1193.ts

@@ -210,15 +210,13 @@ export type WalletSendCallsParameters<
 > = [
   {
     calls: readonly {
-      chainId?: chainId | undefined
       to?: Address | undefined
       data?: Hex | undefined
       value?: quantity | undefined
     }[]
     capabilities?: capabilities | undefined
-    /** @deprecated Use `chainId` on `calls` instead. */
     chainId?: chainId | undefined
-    from: Address
+    from?: Address | undefined
     version: string
   },
 ]

package/zksync/actions/finalizeWithdrawal.ts

@@ -0,0 +1,248 @@
+import type { Address } from 'abitype'
+import type { Account } from '../../accounts/types.js'
+import { readContract } from '../../actions/public/readContract.js'
+import {
+  type SendTransactionErrorType,
+  type SendTransactionParameters,
+  type SendTransactionRequest,
+  type SendTransactionReturnType,
+  sendTransaction,
+} from '../../actions/wallet/sendTransaction.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../errors/account.js'
+import {
+  ChainNotFoundError,
+  type ChainNotFoundErrorType,
+} from '../../errors/chain.js'
+import type { Chain } from '../../types/chain.js'
+import type { Hex } from '../../types/misc.js'
+import {
+  decodeAbiParameters,
+  encodeFunctionData,
+  isAddressEqual,
+  parseAccount,
+  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 { getDefaultBridgeAddresses } from './getDefaultBridgeAddresses.js'
+import { getLogProof } from './getLogProof.js'
+
+export type FinalizeWithdrawalParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  chainL2 extends ChainEIP712 | undefined = ChainEIP712 | undefined,
+  accountL2 extends Account | undefined = Account | undefined,
+  request extends SendTransactionRequest<
+    chain,
+    chainOverride
+  > = SendTransactionRequest<chain, chainOverride>,
+> = Omit<
+  SendTransactionParameters<chain, account, chainOverride, request>,
+  'value' | 'data' | 'to'
+> & {
+  /** L2 client */
+  client: Client<Transport, chainL2, accountL2>
+  /** Hash of the L2 transaction where the withdrawal was initiated. */
+  hash: Hex
+  /** 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 FinalizeWithdrawalReturnType = SendTransactionReturnType
+
+export type FinalizeWithdrawalErrorType =
+  | SendTransactionErrorType
+  | WithdrawalLogNotFoundErrorType
+  | ChainNotFoundErrorType
+
+/**
+ * Proves the inclusion of the `L2->L1` withdrawal message.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link FinalizeWithdrawalParameters}
+ * @returns hash - The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link FinalizeWithdrawalReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet, zksync } from 'viem/chains'
+ * import { finalizeWithdrawal, publicActionsL2 } from 'viem/zksync'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const clientL2 = createPublicClient({
+ *   chain: zksync,
+ *   transport: http(),
+ * }).extend(publicActionsL2())
+ *
+ * const hash = await finalizeWithdrawal(client, {
+ *     account: privateKeyToAccount('0x…'),
+ *     client: clientL2,
+ *     hash: '0x...',
+ * })
+ *
+ * @example Account Hoisting
+ * import { createPublicClient, createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet, zksync } from 'viem/chains'
+ * import { finalizeWithdrawal, publicActionsL2 } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const clientL2 = createPublicClient({
+ *   chain: zksync,
+ *   transport: http(),
+ * }).extend(publicActionsL2())
+ *
+ * const hash = await finalizeWithdrawal(client, {
+ *     client: clientL2,
+ *     hash: '0x…',
+ * })
+ */
+export async function finalizeWithdrawal<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  accountL2 extends Account | undefined,
+  const request extends SendTransactionRequest<chain, chainOverride>,
+  chainOverride extends Chain | undefined,
+  chainL2 extends ChainEIP712 | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: FinalizeWithdrawalParameters<
+    chain,
+    account,
+    chainOverride,
+    chainL2,
+    accountL2,
+    request
+  >,
+): Promise<FinalizeWithdrawalReturnType> {
+  const {
+    account: account_ = client.account,
+    client: l2Client,
+    hash,
+    index = 0,
+    ...rest
+  } = parameters
+  const account = account_ ? parseAccount(account_) : client.account
+  if (!account)
+    throw new AccountNotFoundError({
+      docsPath: '/docs/actions/wallet/sendTransaction',
+    })
+  if (!l2Client.chain) throw new ChainNotFoundError()
+
+  const {
+    l1BatchNumber,
+    l2MessageIndex,
+    l2TxNumberInBlock,
+    message,
+    sender,
+    proof,
+  } = await getFinalizeWithdrawalParams(l2Client, { hash, index })
+
+  let l1Bridge: Address
+
+  if (isAddressEqual(sender, l2BaseTokenAddress))
+    l1Bridge = (await getDefaultBridgeAddresses(l2Client)).sharedL1
+  else if (!(await isLegacyBridge(l2Client, { address: sender })))
+    l1Bridge = await readContract(l2Client, {
+      address: sender,
+      abi: l2SharedBridgeAbi,
+      functionName: 'l1SharedBridge',
+      args: [],
+    })
+  else
+    l1Bridge = await readContract(l2Client, {
+      address: sender,
+      abi: l2SharedBridgeAbi,
+      functionName: 'l1Bridge',
+      args: [],
+    })
+
+  const data = encodeFunctionData({
+    abi: l1SharedBridgeAbi,
+    functionName: 'finalizeWithdrawal',
+    args: [
+      BigInt(l2Client.chain.id),
+      l1BatchNumber!,
+      BigInt(l2MessageIndex),
+      Number(l2TxNumberInBlock),
+      message,
+      proof,
+    ],
+  })
+
+  return await sendTransaction(client, {
+    account,
+    to: l1Bridge,
+    data,
+    value: 0n,
+    ...rest,
+  } as SendTransactionParameters)
+}
+
+async function getFinalizeWithdrawalParams<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: { hash: Hex; index: number },
+) {
+  const { hash } = parameters
+  const { log, l1BatchTxId } = await getWithdrawalLog(client, parameters)
+  const { l2ToL1LogIndex } = await getWithdrawalL2ToL1Log(client, parameters)
+  const sender = slice(log.topics[1]!, 12) as Address
+  const proof = await getLogProof(client, {
+    txHash: hash,
+    index: l2ToL1LogIndex!,
+  })
+  if (!proof) {
+    throw new WithdrawalLogNotFoundError({ hash })
+  }
+
+  const [message] = decodeAbiParameters([{ type: 'bytes' }], log.data)
+
+  return {
+    l1BatchNumber: log.l1BatchNumber,
+    l2MessageIndex: proof.id,
+    l2TxNumberInBlock: l1BatchTxId,
+    message,
+    sender,
+    proof: proof.proof,
+  }
+}
+
+async function isLegacyBridge<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(client: Client<Transport, chain, account>, parameters: { address: Address }) {
+  try {
+    await readContract(client, {
+      address: parameters.address,
+      abi: l2SharedBridgeAbi,
+      functionName: 'l1SharedBridge',
+      args: [],
+    })
+    return false
+  } catch (_e) {
+    return true
+  }
+}