viem 2.30.1 → 2.30.3

package/zksync/actions/isWithdrawalFinalized.ts

@@ -1,4 +1,3 @@
-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'
@@ -9,9 +8,7 @@ import {
 } 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 { l1SharedBridgeAbi } from '../constants/abis.js'
 import {
   WithdrawalLogNotFoundError,
   type WithdrawalLogNotFoundErrorType,
@@ -19,7 +16,6 @@ import {
 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'
 
@@ -87,7 +83,7 @@ export async function isWithdrawalFinalized<
     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`.
@@ -95,23 +91,9 @@ export async function isWithdrawalFinalized<
     txHash: hash,
     index: l2ToL1LogIndex!,
   })
-  if (!proof) {
-    throw new WithdrawalLogNotFoundError({ hash })
-  }
+  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: [],
-    })
+  const l1Bridge = (await getDefaultBridgeAddresses(l2Client)).sharedL1
 
   return await readContract(client, {
     address: l1Bridge,

package/zksync/actions/withdraw.ts

@@ -1,26 +1,33 @@
-import type { Address } from 'abitype'
+import { type Address, parseAbi } 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 { AccountNotFoundError } from '../../errors/account.js'
+import { ClientChainNotConfiguredError } from '../../errors/chain.js'
 import type { GetAccountParameter } from '../../types/account.js'
 import type { GetChainParameter } from '../../types/chain.js'
 import type { UnionOmit } from '../../types/utils.js'
 import type { EncodeFunctionDataReturnType } from '../../utils/abi/encodeFunctionData.js'
 import {
+  encodeAbiParameters,
   encodeFunctionData,
   isAddressEqual,
+  keccak256,
   parseAccount,
 } from '../../utils/index.js'
 import { ethTokenAbi, l2SharedBridgeAbi } from '../constants/abis.js'
 import {
   ethAddressInContracts,
+  l2AssetRouterAddress,
   l2BaseTokenAddress,
+  l2NativeTokenVaultAddress,
   legacyEthAddress,
 } from '../constants/address.js'
 import type { ChainEIP712 } from '../types/chain.js'
 import type { ZksyncTransactionRequest } from '../types/transaction.js'
 import { getDefaultBridgeAddresses } from './getDefaultBridgeAddresses.js'
+import { getL1ChainId } from './getL1ChainId.js'
 import { getL2TokenAddress } from './getL2TokenAddress.js'
 import {
   type SendTransactionErrorType,
@@ -133,6 +140,7 @@ export async function withdraw<
 ): Promise<WithdrawReturnType> {
   let {
     account: account_ = client.account,
+    chain: chain_ = client.chain,
     token = l2BaseTokenAddress,
     to,
     amount,
@@ -165,17 +173,65 @@ export async function withdraw<
     value = amount
     contract = l2BaseTokenAddress
   } else {
-    data = encodeFunctionData({
-      abi: l2SharedBridgeAbi,
-      functionName: 'withdraw',
-      args: [to, token, amount],
+    const assetId = await readContract(client, {
+      address: l2NativeTokenVaultAddress,
+      abi: parseAbi(['function assetId(address token) view returns (bytes32)']),
+      functionName: 'assetId',
+      args: [token],
     })
-    contract = bridgeAddress
-      ? bridgeAddress
-      : (await getDefaultBridgeAddresses(client)).sharedL2
+    const originChainId = await readContract(client, {
+      address: l2NativeTokenVaultAddress,
+      abi: parseAbi([
+        'function originChainId(bytes32 assetId) view returns (uint256)',
+      ]),
+      functionName: 'originChainId',
+      args: [assetId],
+    })
+    const l1ChainId = await getL1ChainId(client)
+
+    const isTokenL1Native =
+      originChainId === BigInt(l1ChainId) || token === ethAddressInContracts
+    if (!bridgeAddress) {
+      // If the legacy L2SharedBridge is deployed we use it for l1 native tokens.
+      bridgeAddress = isTokenL1Native
+        ? (await getDefaultBridgeAddresses(client)).sharedL2
+        : l2AssetRouterAddress
+    }
+    // For non L1 native tokens we need to use the AssetRouter.
+    // For L1 native tokens we can use the legacy withdraw method.
+    if (!isTokenL1Native) {
+      contract = l2AssetRouterAddress
+      if (!chain_) throw new ClientChainNotConfiguredError()
+      const chainId = chain_.id
+      const assetId = keccak256(
+        encodeAbiParameters(
+          [{ type: 'uint256' }, { type: 'address' }, { type: 'address' }],
+          [BigInt(chainId), l2NativeTokenVaultAddress, token],
+        ),
+      )
+      const assetData = encodeAbiParameters(
+        [{ type: 'uint256' }, { type: 'address' }, { type: 'address' }],
+        [BigInt(amount), to, token],
+      )
+      data = encodeFunctionData({
+        abi: parseAbi([
+          'function withdraw(bytes32 _assetId, bytes _transferData)',
+        ]),
+        functionName: 'withdraw',
+        args: [assetId, assetData],
+      })
+    } else {
+      contract = bridgeAddress
+      data = encodeFunctionData({
+        abi: l2SharedBridgeAbi,
+        functionName: 'withdraw',
+        args: [to, token, amount],
+      })
+    }
   }
 
   return await sendTransaction(client, {
+    chain: chain_,
     account,
     to: contract,
     data,

package/zksync/constants/address.ts

@@ -21,4 +21,13 @@ export const l1MessengerAddress =
 export const l1ToL2AliasOffset =
   '0x1111000000000000000000000000000000001111' as const
 
+export const l2AssetRouterAddress =
+  '0x0000000000000000000000000000000000010003' as const
+
+export const l2NativeTokenVaultAddress =
+  '0x0000000000000000000000000000000000010004' as const
+
+export const bootloaderFormalAddress =
+  '0x0000000000000000000000000000000000008001' as const
+
 export const addressModulo = 2n ** 160n

package/zksync/decorators/walletL1.ts

@@ -2,6 +2,11 @@ import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
+import {
+  type ClaimFailedDepositParameters,
+  type ClaimFailedDepositReturnType,
+  claimFailedDeposit,
+} from '../actions/claimFailedDeposit.js'
 import {
   type DepositParameters,
   type DepositReturnType,
@@ -23,6 +28,49 @@ export type WalletActionsL1<
   chain extends Chain | undefined = Chain | undefined,
   account extends Account | undefined = Account | undefined,
 > = {
+  /**
+   * Withdraws funds from the initiated deposit, which failed when finalizing on L2.
+   * If the deposit L2 transaction has failed, it sends an L1 transaction calling `claimFailedDeposit` method of the
+   * L1 bridge, which results in returning L1 tokens back to the depositor.
+   *
+   * @param parameters - {@link ClaimFailedDepositParameters}
+   * @returns hash - The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link ClaimFailedDepositReturnType}
+   *
+   * @example
+   * import { createPublicClient, createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { zksync, mainnet } from 'viem/chains'
+   * import { walletActionsL1, publicActionsL2 } from 'viem/zksync'
+   *
+   * const walletClient = createWalletClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   *   account: privateKeyToAccount('0x…'),
+   * }).extend(walletActionsL1())
+   *
+   * const clientL2 = createPublicClient({
+   *   chain: zksync,
+   *   transport: http(),
+   * }).extend(publicActionsL2())
+   *
+   * const hash = await walletClient.claimFailedDeposit({
+   *     client: clientL2,
+   *     depositHash: <L2_HASH_OF_FAILED_DEPOSIT>,
+   * })
+   */
+  claimFailedDeposit: <
+    chainOverride extends Chain | undefined = undefined,
+    chainL2 extends ChainEIP712 | undefined = ChainEIP712 | undefined,
+    accountL2 extends Account | undefined = Account | undefined,
+  >(
+    parameters: ClaimFailedDepositParameters<
+      chain,
+      account,
+      chainOverride,
+      chainL2,
+      accountL2
+    >,
+  ) => Promise<ClaimFailedDepositReturnType>
   /**
    * Transfers the specified token from the associated account on the L1 network to the target account on the L2 network.
    * The token can be either ETH or any ERC20 token. For ERC20 tokens, enough approved tokens must be associated with
@@ -53,7 +101,6 @@ export type WalletActionsL1<
    *
    * const hash = await walletClient.deposit({
    *     client: clientL2,
-   *     account,
    *     token: legacyEthAddress,
    *     to: walletClient.account.address,
    *     amount: 1_000_000_000_000_000_000n,
@@ -168,6 +215,7 @@ export function walletActionsL1() {
   >(
     client: Client<transport, chain, account>,
   ): WalletActionsL1<chain, account> => ({
+    claimFailedDeposit: (args) => claimFailedDeposit(client, args),
     deposit: (args) => deposit(client, args),
     finalizeWithdrawal: (args) => finalizeWithdrawal(client, args),
     requestExecute: (args) => requestExecute(client, args),

package/zksync/errors/bridge.ts

@@ -44,3 +44,38 @@ export class WithdrawalLogNotFoundError extends BaseError {
     )
   }
 }
+
+export type CannotClaimSuccessfulDepositErrorType =
+  CannotClaimSuccessfulDepositError & {
+    name: 'CannotClaimSuccessfulDepositError'
+  }
+export class CannotClaimSuccessfulDepositError extends BaseError {
+  constructor({ hash }: { hash: Hash }) {
+    super([`Cannot claim successful deposit: ${hash}.`].join('\n'), {
+      name: 'CannotClaimSuccessfulDepositError',
+    })
+  }
+}
+
+export type LogProofNotFoundErrorType = LogProofNotFoundError & {
+  name: 'LogProofNotFoundError'
+}
+export class LogProofNotFoundError extends BaseError {
+  constructor({ hash, index }: { hash: Hash; index: number }) {
+    super(
+      [`Log proof not found for hash ${hash} and index ${index}.`].join('\n'),
+      { name: 'LogProofNotFoundError' },
+    )
+  }
+}
+
+export type L2BridgeNotFoundErrorType = L2BridgeNotFoundError & {
+  name: 'L2BridgeNotFoundError'
+}
+export class L2BridgeNotFoundError extends BaseError {
+  constructor() {
+    super(['L2 bridge address not found.'].join('\n'), {
+      name: 'L2BridgeNotFoundError',
+    })
+  }
+}

package/zksync/index.ts

@@ -28,6 +28,12 @@ export {
   type HashBytecodeErrorType,
   hashBytecode,
 } from './utils/hashBytecode.js'
+export {
+  type ClaimFailedDepositErrorType,
+  type ClaimFailedDepositParameters,
+  type ClaimFailedDepositReturnType,
+  claimFailedDeposit,
+} from './actions/claimFailedDeposit.js'
 export {
   type DepositErrorType,
   type DepositReturnType,

package/zksync/types/contract.ts

@@ -4,6 +4,8 @@ export type BridgeContractAddresses = {
   erc20L1: Address
   sharedL1: Address
   sharedL2: Address
+  l1Nullifier: Address | undefined
+  l1NativeTokenVault: Address | undefined
 }
 
 export type ContractDeploymentType =

package/zksync/types/eip1193.ts

@@ -91,6 +91,8 @@ export type PublicZksyncRpcSchema = [
       l2WethBridge: Address
       l1SharedDefaultBridge: Address
       l2SharedDefaultBridge: Address
+      l1Nullifier?: Address
+      l1NativeTokenVault?: Address
     }
   },
   {