@matterlabs/zksync-js 0.0.1

package/dist/chunk-7M4V3FMT.js

@@ -0,0 +1,2444 @@
+import { assertNoLegacyGas, assertPriorityFeeBounds, REVERT_TO_READINESS } from './chunk-263G6636.js';
+import { findL1MessageSentLog, messengerLogIndex, isAddressEq, isHash66, pickDepositRoute, isETH, normalizeAddrEq, pickWithdrawRoute } from './chunk-DI2CJDPZ.js';
+import { IL1Nullifier_default, IERC20_default, L1NativeTokenVault_default, L2NativeTokenVault_default, Mailbox_default, IBridgehub_default, IL2AssetRouter_default, IBaseToken_default } from './chunk-Y75OMFK6.js';
+import { isZKsyncError, createError, shapeCause, OP_WITHDRAWALS, OP_DEPOSITS, isReceiptNotFound } from './chunk-B77GWPO5.js';
+import { ETH_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, L1_FEE_ESTIMATION_COEF_NUMERATOR, L1_FEE_ESTIMATION_COEF_DENOMINATOR, L1_MESSENGER_ADDRESS, L2_ASSET_ROUTER_ADDRESS, FORMAL_ETH_ADDRESS, L2_BASE_TOKEN_ADDRESS, TOPIC_CANONICAL_ASSIGNED, TOPIC_CANONICAL_SUCCESS } from './chunk-6GCT6TLS.js';
+import { encodeAbiParameters, keccak256, concat, decodeErrorResult, decodeAbiParameters, decodeEventLog } from 'viem';
+
+function encodeNativeTokenVaultAssetId(chainId, address) {
+  const encoded = encodeAbiParameters(
+    [
+      { type: "uint256", name: "originChainId" },
+      { type: "address", name: "ntv" },
+      { type: "address", name: "token" }
+    ],
+    [chainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, address]
+  );
+  return keccak256(encoded);
+}
+function encodeNativeTokenVaultTransferData(amount, receiver, token) {
+  return encodeAbiParameters(
+    [
+      { type: "uint256", name: "amount" },
+      { type: "address", name: "receiver" },
+      { type: "address", name: "token" }
+    ],
+    [amount, receiver, token]
+  );
+}
+function encodeSecondBridgeDataV1(assetId, transferData) {
+  const data = encodeAbiParameters(
+    [
+      { type: "bytes32", name: "assetId" },
+      { type: "bytes", name: "transferData" }
+    ],
+    [assetId, transferData]
+  );
+  return concat(["0x01", data]);
+}
+var encodeNTVAssetId = encodeNativeTokenVaultAssetId;
+var encodeNTVTransferData = encodeNativeTokenVaultTransferData;
+function scaleGasLimit(gasLimit) {
+  return gasLimit * BigInt(L1_FEE_ESTIMATION_COEF_NUMERATOR) / BigInt(L1_FEE_ESTIMATION_COEF_DENOMINATOR);
+}
+async function checkBaseCost(baseCost, value) {
+  const resolved = await value;
+  if (baseCost > resolved) {
+    throw new Error(
+      `The base cost of performing the priority operation is higher than the provided value parameter for the transaction: baseCost: ${String(baseCost)}, provided value: ${String(resolved)}!`
+    );
+  }
+}
+async function getFeeOverrides(client, overrides) {
+  assertNoLegacyGas(overrides);
+  let maxFeePerGasFromProvider;
+  let maxPriorityFromProvider;
+  let gasPriceFromProvider;
+  try {
+    const fees = await client.l1.estimateFeesPerGas();
+    const { maxFeePerGas: maxFeePerGas2, maxPriorityFeePerGas: maxPriorityFeePerGas2 } = fees;
+    if (maxFeePerGas2 != null && maxPriorityFeePerGas2 != null) {
+      maxFeePerGasFromProvider = maxFeePerGas2;
+      maxPriorityFromProvider = maxPriorityFeePerGas2;
+      gasPriceFromProvider = fees.gasPrice ?? maxFeePerGas2;
+    } else if (fees.gasPrice != null) {
+      gasPriceFromProvider = fees.gasPrice;
+    }
+  } catch {
+  }
+  if (gasPriceFromProvider == null) {
+    try {
+      gasPriceFromProvider = await client.l1.getGasPrice();
+    } catch {
+    }
+  }
+  const maxFeePerGas = overrides?.maxFeePerGas ?? maxFeePerGasFromProvider ?? gasPriceFromProvider;
+  if (maxFeePerGas == null) {
+    throw new Error("L1 provider returned no gas price data");
+  }
+  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? maxPriorityFromProvider ?? maxFeePerGas;
+  assertPriorityFeeBounds({ maxFeePerGas, maxPriorityFeePerGas });
+  const gasPriceForBaseCost = overrides?.maxFeePerGas ?? maxFeePerGasFromProvider ?? gasPriceFromProvider ?? maxFeePerGas;
+  return {
+    gasLimit: overrides?.gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    gasPriceForBaseCost
+  };
+}
+async function getL2FeeOverrides(client, overrides) {
+  assertNoLegacyGas(overrides);
+  let maxFeePerGasFromProvider;
+  let maxPriorityFromProvider;
+  let gasPriceFromProvider;
+  try {
+    const fees = await client.l2.estimateFeesPerGas();
+    if (fees?.maxFeePerGas != null && fees.maxPriorityFeePerGas != null) {
+      maxFeePerGasFromProvider = fees.maxFeePerGas;
+      maxPriorityFromProvider = fees.maxPriorityFeePerGas;
+      gasPriceFromProvider = fees.gasPrice ?? fees.maxFeePerGas;
+    } else if (fees?.gasPrice != null) {
+      gasPriceFromProvider = fees.gasPrice;
+    }
+  } catch {
+  }
+  if (gasPriceFromProvider == null) {
+    try {
+      gasPriceFromProvider = await client.l2.getGasPrice();
+    } catch {
+    }
+  }
+  const maxFeePerGas = overrides?.maxFeePerGas ?? maxFeePerGasFromProvider ?? gasPriceFromProvider;
+  if (maxFeePerGas == null) {
+    throw new Error("provider returned no gas price data");
+  }
+  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? maxPriorityFromProvider ?? maxFeePerGas;
+  assertPriorityFeeBounds({ maxFeePerGas, maxPriorityFeePerGas });
+  return {
+    gasLimit: overrides?.gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas
+  };
+}
+function buildViemFeeOverrides(fees) {
+  return {
+    maxFeePerGas: fees.maxFeePerGas,
+    maxPriorityFeePerGas: fees.maxPriorityFeePerGas,
+    gas: fees.gasLimit
+  };
+}
+async function getGasPriceWei(client) {
+  try {
+    const gp = await client.l1.getGasPrice();
+    if (gp != null) return gp;
+  } catch {
+  }
+  try {
+    const fees = await client.l1.estimateFeesPerGas();
+    if (fees?.maxFeePerGas != null) return fees.maxFeePerGas;
+  } catch {
+  }
+  throw new Error("provider returned no gas price data");
+}
+function buildDirectRequestStruct(args) {
+  return {
+    chainId: args.chainId,
+    l2Contract: args.l2Contract,
+    mintValue: args.mintValue,
+    l2Value: args.l2Value,
+    l2Calldata: "0x",
+    l2GasLimit: args.l2GasLimit,
+    l2GasPerPubdataByteLimit: args.gasPerPubdata,
+    factoryDeps: [],
+    refundRecipient: args.refundRecipient
+  };
+}
+function encodeSecondBridgeArgs(token, amount, l2Receiver) {
+  return encodeAbiParameters(
+    [
+      { type: "address", name: "token" },
+      { type: "uint256", name: "amount" },
+      { type: "address", name: "l2Receiver" }
+    ],
+    [token, amount, l2Receiver]
+  );
+}
+function encodeSecondBridgeErc20Args(token, amount, l2Receiver) {
+  return encodeSecondBridgeArgs(token, amount, l2Receiver);
+}
+function encodeSecondBridgeEthArgs(amount, l2Receiver, ethToken = ETH_ADDRESS) {
+  return encodeSecondBridgeArgs(ethToken, amount, l2Receiver);
+}
+
+// src/adapters/viem/resources/deposits/context.ts
+async function commonCtx(p, client) {
+  const { bridgehub, l1AssetRouter } = await client.ensureAddresses();
+  const chainId = await client.l2.getChainId();
+  const sender = client.account.address;
+  const fee = await getFeeOverrides(client, p.l1TxOverrides);
+  const l2GasLimit = p.l2GasLimit ?? 300000n;
+  const gasPerPubdata = p.gasPerPubdata ?? 800n;
+  const operatorTip = p.operatorTip ?? 0n;
+  const refundRecipient = p.refundRecipient ?? sender;
+  const route = await pickDepositRoute(client, BigInt(chainId), p.token);
+  return {
+    client,
+    l1AssetRouter,
+    route,
+    bridgehub,
+    chainIdL2: BigInt(chainId),
+    sender,
+    fee,
+    l2GasLimit,
+    gasPerPubdata,
+    operatorTip,
+    refundRecipient
+  };
+}
+var ERROR_ABIS = [];
+var ABI_ERROR_STRING = [
+  { type: "error", name: "Error", inputs: [{ name: "message", type: "string" }] }
+];
+var ABI_PANIC = [
+  { type: "error", name: "Panic", inputs: [{ name: "code", type: "uint256" }] }
+];
+(function bootstrapDefaultAbis() {
+  try {
+    ERROR_ABIS.push({ name: "IL1Nullifier", abi: IL1Nullifier_default });
+  } catch {
+  }
+  try {
+    ERROR_ABIS.push({ name: "IERC20", abi: IERC20_default });
+  } catch {
+  }
+  try {
+    ERROR_ABIS.push({ name: "IL1NativeTokenVault", abi: L1NativeTokenVault_default });
+  } catch {
+  }
+  try {
+    ERROR_ABIS.push({ name: "IL2NativeTokenVault", abi: L2NativeTokenVault_default });
+  } catch {
+  }
+  try {
+    ERROR_ABIS.push({ name: "Mailbox", abi: Mailbox_default });
+  } catch {
+  }
+})();
+function registerErrorAbi(name, abi) {
+  const i = ERROR_ABIS.findIndex((x) => x.name === name);
+  const entry = { name, abi };
+  if (i >= 0) ERROR_ABIS[i] = entry;
+  else ERROR_ABIS.push(entry);
+}
+function extractRevertData(e) {
+  const candidates = [
+    e?.data?.data,
+    e?.error?.data,
+    e?.data,
+    e?.error?.error?.data,
+    e?.info?.error?.data,
+    e?.cause?.data,
+    e?.cause?.cause?.data,
+    e?.details
+  ];
+  for (const c of candidates) {
+    if (typeof c === "string" && c.startsWith("0x") && c.length >= 10) {
+      return c;
+    }
+  }
+  return void 0;
+}
+function decodeRevert(e) {
+  const data = extractRevertData(e);
+  if (!data) return;
+  const selector = `0x${data.slice(2, 10)}`;
+  try {
+    const parsed = decodeErrorResult({ abi: ABI_ERROR_STRING, data });
+    if (parsed?.errorName === "Error") {
+      return { selector, name: parsed.errorName, args: parsed.args ? [...parsed.args] : void 0 };
+    }
+  } catch {
+  }
+  try {
+    const parsed = decodeErrorResult({ abi: ABI_PANIC, data });
+    if (parsed?.errorName === "Panic") {
+      return { selector, name: parsed.errorName, args: parsed.args ? [...parsed.args] : void 0 };
+    }
+  } catch {
+  }
+  for (const { name, abi } of ERROR_ABIS) {
+    try {
+      const parsed = decodeErrorResult({ abi, data });
+      if (parsed && parsed.errorName) {
+        return {
+          selector,
+          name: parsed.errorName,
+          args: parsed.args ? [...parsed.args] : void 0,
+          contract: name
+        };
+      }
+    } catch {
+    }
+  }
+  return { selector };
+}
+function classifyReadinessFromRevert(e) {
+  const r = decodeRevert(e);
+  const name = r?.name;
+  if (name && REVERT_TO_READINESS[name]) return REVERT_TO_READINESS[name];
+  const msg = (() => {
+    if (typeof e !== "object" || e === null) return "";
+    const obj = e;
+    const maybe = obj["shortMessage"] ?? obj["message"];
+    return typeof maybe === "string" ? maybe : "";
+  })();
+  const lower = msg.toLowerCase();
+  if (lower.includes("paused")) return { kind: "NOT_READY", reason: "paused" };
+  if (name || r?.selector) {
+    return { kind: "UNFINALIZABLE", reason: "unsupported", detail: name ?? r?.selector };
+  }
+  return { kind: "NOT_READY", reason: "unknown", detail: lower || void 0 };
+}
+
+// src/adapters/viem/errors/error-ops.ts
+function toZKsyncError(type, base, err) {
+  if (isZKsyncError(err)) return err;
+  const revert = decodeRevert(err);
+  return createError(type, { ...base, ...revert ? { revert } : {}, cause: shapeCause(err) });
+}
+function resolveMessage(op, msg) {
+  if (!msg) return `Error during ${op}.`;
+  return typeof msg === "function" ? msg() : msg;
+}
+function createErrorHandlers(resource) {
+  async function run(kind, operation, fn, opts) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (isZKsyncError(e)) throw e;
+      const message = resolveMessage(operation, opts?.message);
+      throw toZKsyncError(kind, { resource, operation, context: opts?.ctx ?? {}, message }, e);
+    }
+  }
+  function wrap2(operation, fn, opts) {
+    return run("INTERNAL", operation, fn, opts);
+  }
+  function wrapAs9(kind, operation, fn, opts) {
+    return run(kind, operation, fn, opts);
+  }
+  async function toResult2(operation, fn, opts) {
+    try {
+      const value = await wrap2(operation, fn, opts);
+      return { ok: true, value };
+    } catch (e) {
+      const shaped = isZKsyncError(e) ? e : toZKsyncError(
+        "INTERNAL",
+        {
+          resource,
+          operation,
+          context: opts?.ctx ?? {},
+          message: resolveMessage(operation, opts?.message)
+        },
+        e
+      );
+      return { ok: false, error: shaped };
+    }
+  }
+  return { wrap: wrap2, wrapAs: wrapAs9, toResult: toResult2 };
+}
+
+// src/adapters/viem/resources/deposits/routes/eth.ts
+var { wrapAs } = createErrorHandlers("deposits");
+function routeEthDirect() {
+  return {
+    async build(p, ctx) {
+      const { gasPriceForBaseCost } = ctx.fee;
+      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
+      const rawBaseCost = await wrapAs(
+        "CONTRACT",
+        OP_DEPOSITS.eth.baseCost,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "l2TransactionBaseCost",
+          args: [ctx.chainIdL2, gasPriceForBaseCost, ctx.l2GasLimit, ctx.gasPerPubdata]
+        }),
+        {
+          ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 },
+          message: "Could not fetch L2 base cost from Bridgehub."
+        }
+      );
+      const baseCost = rawBaseCost;
+      const l2Contract = p.to ?? ctx.sender;
+      const l2Value = p.amount;
+      const mintValue = baseCost + ctx.operatorTip + l2Value;
+      const req = buildDirectRequestStruct({
+        chainId: ctx.chainIdL2,
+        mintValue,
+        l2GasLimit: ctx.l2GasLimit,
+        gasPerPubdata: ctx.gasPerPubdata,
+        refundRecipient: ctx.refundRecipient,
+        l2Contract,
+        l2Value
+      });
+      const sim = await wrapAs(
+        "RPC",
+        OP_DEPOSITS.eth.estGas,
+        () => ctx.client.l1.simulateContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "requestL2TransactionDirect",
+          args: [req],
+          value: mintValue,
+          account: ctx.client.account
+        }),
+        {
+          ctx: { where: "l1.simulateContract", to: ctx.bridgehub },
+          message: "Failed to simulate Bridgehub.requestL2TransactionDirect."
+        }
+      );
+      const resolvedL1GasLimit = sim.request.gas ?? ctx.l2GasLimit;
+      const steps = [
+        {
+          key: "bridgehub:direct",
+          kind: "bridgehub:direct",
+          description: "Bridge ETH via Bridgehub.requestL2TransactionDirect",
+          tx: { ...sim.request, ...txFeeOverrides }
+        }
+      ];
+      return {
+        steps,
+        approvals: [],
+        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+      };
+    }
+  };
+}
+
+// src/adapters/viem/resources/deposits/routes/erc20-nonbase.ts
+var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
+var BASE_COST_BUFFER_BPS = 100n;
+var BPS = 10000n;
+var withBuffer = (x) => x * (BPS + BASE_COST_BUFFER_BPS) / BPS;
+function routeErc20NonBase() {
+  return {
+    async preflight(p, ctx) {
+      await wrapAs2(
+        "VALIDATION",
+        OP_DEPOSITS.nonbase.assertNotEthAsset,
+        () => {
+          if (isETH(p.token)) {
+            throw new Error("erc20-nonbase route requires an ERC-20 token (not ETH).");
+          }
+        },
+        { ctx: { token: p.token } }
+      );
+      const baseToken = await wrapAs2(
+        "CONTRACT",
+        OP_DEPOSITS.nonbase.baseToken,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "baseToken",
+          args: [ctx.chainIdL2]
+        }),
+        { ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 } }
+      );
+      await wrapAs2(
+        "VALIDATION",
+        OP_DEPOSITS.nonbase.assertNonBaseToken,
+        () => {
+          if (normalizeAddrEq(baseToken, p.token)) {
+            throw new Error("erc20-nonbase route requires a non-base ERC-20 deposit token.");
+          }
+        },
+        { ctx: { depositToken: p.token, baseToken } }
+      );
+      return;
+    },
+    async build(p, ctx) {
+      const { gasPriceForBaseCost } = ctx.fee;
+      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
+      const baseToken = await wrapAs2(
+        "CONTRACT",
+        OP_DEPOSITS.nonbase.baseToken,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "baseToken",
+          args: [ctx.chainIdL2]
+        }),
+        { ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 } }
+      );
+      const MIN_L2_GAS_FOR_ERC20 = 2500000n;
+      const l2GasLimitUsed = ctx.l2GasLimit && ctx.l2GasLimit > 0n ? ctx.l2GasLimit < MIN_L2_GAS_FOR_ERC20 ? MIN_L2_GAS_FOR_ERC20 : ctx.l2GasLimit : MIN_L2_GAS_FOR_ERC20;
+      const rawBaseCost = await wrapAs2(
+        "CONTRACT",
+        OP_DEPOSITS.nonbase.baseCost,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "l2TransactionBaseCost",
+          args: [ctx.chainIdL2, gasPriceForBaseCost, l2GasLimitUsed, ctx.gasPerPubdata]
+        }),
+        { ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 } }
+      );
+      const baseCost = rawBaseCost;
+      const mintValue = withBuffer(baseCost + ctx.operatorTip);
+      const approvals = [];
+      const steps = [];
+      const depositAllowance = await wrapAs2(
+        "CONTRACT",
+        OP_DEPOSITS.nonbase.allowance,
+        () => ctx.client.l1.readContract({
+          address: p.token,
+          abi: IERC20_default,
+          functionName: "allowance",
+          args: [ctx.sender, ctx.l1AssetRouter]
+        }),
+        {
+          ctx: { where: "erc20.allowance", token: p.token, spender: ctx.l1AssetRouter },
+          message: "Failed to read ERC-20 allowance for deposit token."
+        }
+      );
+      const needsDepositApprove = depositAllowance < p.amount;
+      if (needsDepositApprove) {
+        const approveDepReq = await wrapAs2(
+          "CONTRACT",
+          OP_DEPOSITS.nonbase.estGas,
+          () => ctx.client.l1.simulateContract({
+            address: p.token,
+            abi: IERC20_default,
+            functionName: "approve",
+            args: [ctx.l1AssetRouter, p.amount],
+            account: ctx.client.account
+          }),
+          {
+            ctx: { where: "l1.simulateContract", to: p.token },
+            message: "Failed to simulate deposit token approve."
+          }
+        );
+        approvals.push({ token: p.token, spender: ctx.l1AssetRouter, amount: p.amount });
+        steps.push({
+          key: `approve:${p.token}:${ctx.l1AssetRouter}`,
+          kind: "approve",
+          description: `Approve deposit token for amount`,
+          tx: { ...approveDepReq.request, ...txFeeOverrides }
+        });
+      }
+      const baseIsEth = isETH(baseToken);
+      let msgValue = 0n;
+      if (!baseIsEth) {
+        const baseAllowance = await wrapAs2(
+          "CONTRACT",
+          OP_DEPOSITS.nonbase.allowanceFees,
+          () => ctx.client.l1.readContract({
+            address: baseToken,
+            abi: IERC20_default,
+            functionName: "allowance",
+            args: [ctx.sender, ctx.l1AssetRouter]
+          }),
+          {
+            ctx: { where: "erc20.allowance", token: baseToken, spender: ctx.l1AssetRouter },
+            message: "Failed to read base-token allowance."
+          }
+        );
+        if (baseAllowance < mintValue) {
+          const approveBaseReq = await wrapAs2(
+            "CONTRACT",
+            OP_DEPOSITS.nonbase.estGas,
+            () => ctx.client.l1.simulateContract({
+              address: baseToken,
+              abi: IERC20_default,
+              functionName: "approve",
+              args: [ctx.l1AssetRouter, mintValue],
+              account: ctx.client.account
+            }),
+            {
+              ctx: { where: "l1.simulateContract", to: baseToken },
+              message: "Failed to simulate base-token approve."
+            }
+          );
+          approvals.push({ token: baseToken, spender: ctx.l1AssetRouter, amount: mintValue });
+          steps.push({
+            key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
+            kind: "approve",
+            description: `Approve base token for mintValue`,
+            tx: { ...approveBaseReq.request, ...txFeeOverrides }
+          });
+        }
+        msgValue = 0n;
+      } else {
+        msgValue = mintValue;
+      }
+      const secondBridgeCalldata = await wrapAs2(
+        "INTERNAL",
+        OP_DEPOSITS.nonbase.encodeCalldata,
+        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, p.to ?? ctx.sender)),
+        {
+          ctx: {
+            where: "encodeSecondBridgeErc20Args",
+            token: p.token,
+            amount: p.amount.toString()
+          }
+        }
+      );
+      const outer = {
+        chainId: ctx.chainIdL2,
+        mintValue,
+        l2Value: 0n,
+        l2GasLimit: l2GasLimitUsed,
+        l2GasPerPubdataByteLimit: ctx.gasPerPubdata,
+        refundRecipient: ctx.refundRecipient,
+        secondBridgeAddress: ctx.l1AssetRouter,
+        secondBridgeValue: 0n,
+        secondBridgeCalldata
+      };
+      const approvalsNeeded = approvals.length > 0;
+      let bridgeTx;
+      let resolvedL1GasLimit;
+      const gasOverride = txFeeOverrides.gas;
+      if (approvalsNeeded) {
+        bridgeTx = {
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "requestL2TransactionTwoBridges",
+          args: [outer],
+          value: msgValue,
+          account: ctx.client.account,
+          ...txFeeOverrides
+        };
+        resolvedL1GasLimit = gasOverride ?? ctx.l2GasLimit;
+      } else {
+        const sim = await wrapAs2(
+          "CONTRACT",
+          OP_DEPOSITS.nonbase.estGas,
+          () => ctx.client.l1.simulateContract({
+            address: ctx.bridgehub,
+            abi: IBridgehub_default,
+            functionName: "requestL2TransactionTwoBridges",
+            args: [outer],
+            value: msgValue,
+            account: ctx.client.account
+          }),
+          {
+            ctx: { where: "l1.simulateContract", to: ctx.bridgehub },
+            message: "Failed to simulate two-bridges request."
+          }
+        );
+        bridgeTx = { ...sim.request, ...txFeeOverrides };
+        resolvedL1GasLimit = sim.request.gas ?? ctx.l2GasLimit;
+      }
+      steps.push({
+        key: "bridgehub:two-bridges:nonbase",
+        kind: "bridgehub:two-bridges",
+        description: baseIsEth ? "Bridge ERC-20 (fees in ETH) via Bridgehub.requestL2TransactionTwoBridges" : "Bridge ERC-20 (fees in base ERC-20) via Bridgehub.requestL2TransactionTwoBridges",
+        tx: bridgeTx
+      });
+      return {
+        steps,
+        approvals,
+        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+      };
+    }
+  };
+}
+
+// src/adapters/viem/resources/deposits/routes/eth-nonbase.ts
+var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
+var BASE_COST_BUFFER_BPS2 = 100n;
+var BPS2 = 10000n;
+var withBuffer2 = (x) => x * (BPS2 + BASE_COST_BUFFER_BPS2) / BPS2;
+function routeEthNonBase() {
+  return {
+    async preflight(p, ctx) {
+      await wrapAs3(
+        "VALIDATION",
+        OP_DEPOSITS.ethNonBase.assertEthAsset,
+        () => {
+          if (!isETH(p.token)) {
+            throw new Error("eth-nonbase route requires ETH as the deposit asset.");
+          }
+        },
+        { ctx: { token: p.token } }
+      );
+      const baseToken = await wrapAs3(
+        "CONTRACT",
+        OP_DEPOSITS.ethNonBase.baseToken,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "baseToken",
+          args: [ctx.chainIdL2]
+        }),
+        {
+          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
+          message: "Failed to read base token."
+        }
+      );
+      await wrapAs3(
+        "VALIDATION",
+        OP_DEPOSITS.ethNonBase.assertNonEthBase,
+        () => {
+          if (isETH(baseToken)) {
+            throw new Error("eth-nonbase route requires target chain base token \u2260 ETH.");
+          }
+        },
+        { ctx: { baseToken, chainIdL2: ctx.chainIdL2 } }
+      );
+      const ethBal = await wrapAs3(
+        "RPC",
+        OP_DEPOSITS.ethNonBase.ethBalance,
+        () => ctx.client.l1.getBalance({ address: ctx.sender }),
+        {
+          ctx: { where: "l1.getBalance", sender: ctx.sender },
+          message: "Failed to read L1 ETH balance."
+        }
+      );
+      await wrapAs3(
+        "VALIDATION",
+        OP_DEPOSITS.ethNonBase.assertEthBalance,
+        () => {
+          if (ethBal < p.amount) {
+            throw new Error("Insufficient L1 ETH balance to cover deposit amount.");
+          }
+        },
+        { ctx: { required: p.amount.toString(), balance: ethBal.toString() } }
+      );
+      return;
+    },
+    async build(p, ctx) {
+      const { gasPriceForBaseCost } = ctx.fee;
+      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
+      const baseToken = await wrapAs3(
+        "CONTRACT",
+        OP_DEPOSITS.ethNonBase.baseToken,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "baseToken",
+          args: [ctx.chainIdL2]
+        }),
+        {
+          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
+          message: "Failed to read base token."
+        }
+      );
+      const rawBaseCost = await wrapAs3(
+        "CONTRACT",
+        OP_DEPOSITS.ethNonBase.baseCost,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "l2TransactionBaseCost",
+          args: [ctx.chainIdL2, gasPriceForBaseCost, ctx.l2GasLimit, ctx.gasPerPubdata]
+        }),
+        {
+          ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 },
+          message: "Could not fetch L2 base cost."
+        }
+      );
+      const baseCost = BigInt(rawBaseCost);
+      const mintValueRaw = baseCost + ctx.operatorTip;
+      const mintValue = withBuffer2(mintValueRaw);
+      const approvals = [];
+      const steps = [];
+      const allowance = await wrapAs3(
+        "CONTRACT",
+        OP_DEPOSITS.ethNonBase.allowanceBase,
+        () => ctx.client.l1.readContract({
+          address: baseToken,
+          abi: IERC20_default,
+          functionName: "allowance",
+          args: [ctx.sender, ctx.l1AssetRouter]
+        }),
+        {
+          ctx: { where: "erc20.allowance", token: baseToken, spender: ctx.l1AssetRouter },
+          message: "Failed to read base-token allowance."
+        }
+      );
+      const needsApprove = allowance < mintValue;
+      if (needsApprove) {
+        const approveSim = await wrapAs3(
+          "CONTRACT",
+          OP_DEPOSITS.ethNonBase.estGas,
+          () => ctx.client.l1.simulateContract({
+            address: baseToken,
+            abi: IERC20_default,
+            functionName: "approve",
+            args: [ctx.l1AssetRouter, mintValue],
+            account: ctx.client.account
+          }),
+          {
+            ctx: { where: "l1.simulateContract", to: baseToken },
+            message: "Failed to simulate base-token approve."
+          }
+        );
+        approvals.push({ token: baseToken, spender: ctx.l1AssetRouter, amount: mintValue });
+        steps.push({
+          key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
+          kind: "approve",
+          description: `Approve base token for mintValue`,
+          tx: { ...approveSim.request }
+        });
+      }
+      const secondBridgeCalldata = await wrapAs3(
+        "INTERNAL",
+        OP_DEPOSITS.ethNonBase.encodeCalldata,
+        () => Promise.resolve(encodeSecondBridgeEthArgs(p.amount, p.to ?? ctx.sender)),
+        {
+          ctx: {
+            where: "encodeSecondBridgeEthArgs",
+            amount: p.amount.toString(),
+            to: p.to ?? ctx.sender
+          },
+          message: "Failed to encode ETH bridging calldata."
+        }
+      );
+      const outer = {
+        chainId: ctx.chainIdL2,
+        mintValue,
+        l2Value: 0n,
+        l2GasLimit: ctx.l2GasLimit,
+        l2GasPerPubdataByteLimit: ctx.gasPerPubdata,
+        refundRecipient: ctx.refundRecipient,
+        secondBridgeAddress: ctx.l1AssetRouter,
+        secondBridgeValue: p.amount,
+        secondBridgeCalldata
+      };
+      let bridgeTx;
+      let resolvedL1GasLimit;
+      if (needsApprove) {
+        bridgeTx = {
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "requestL2TransactionTwoBridges",
+          args: [outer],
+          value: p.amount,
+          // base ≠ ETH ⇒ msg.value == secondBridgeValue
+          account: ctx.client.account
+        };
+        resolvedL1GasLimit = ctx.l2GasLimit;
+      } else {
+        const twoBridgesSim = await wrapAs3(
+          "CONTRACT",
+          OP_DEPOSITS.ethNonBase.estGas,
+          () => ctx.client.l1.simulateContract({
+            address: ctx.bridgehub,
+            abi: IBridgehub_default,
+            functionName: "requestL2TransactionTwoBridges",
+            args: [outer],
+            value: p.amount,
+            // base ≠ ETH ⇒ msg.value == secondBridgeValue
+            account: ctx.client.account
+          }),
+          {
+            ctx: { where: "l1.simulateContract", to: ctx.bridgehub },
+            message: "Failed to simulate Bridgehub two-bridges request."
+          }
+        );
+        bridgeTx = { ...twoBridgesSim.request, ...txFeeOverrides };
+        resolvedL1GasLimit = twoBridgesSim.request.gas ?? ctx.l2GasLimit;
+      }
+      steps.push({
+        key: "bridgehub:two-bridges:eth-nonbase",
+        kind: "bridgehub:two-bridges",
+        description: "Bridge ETH (fees in base ERC-20) via Bridgehub.requestL2TransactionTwoBridges",
+        tx: bridgeTx
+      });
+      return {
+        steps,
+        approvals,
+        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+      };
+    }
+  };
+}
+
+// src/adapters/viem/resources/deposits/routes/erc20-base.ts
+var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
+var BASE_COST_BUFFER_BPS3 = 100n;
+var BPS3 = 10000n;
+var withBuffer3 = (x) => x * (BPS3 + BASE_COST_BUFFER_BPS3) / BPS3;
+function routeErc20Base() {
+  return {
+    async preflight(p, ctx) {
+      await wrapAs4(
+        "VALIDATION",
+        OP_DEPOSITS.base.assertErc20Asset,
+        () => {
+          if (isETH(p.token)) {
+            throw new Error("erc20-base route requires an ERC-20 token (not ETH).");
+          }
+        },
+        { ctx: { token: p.token } }
+      );
+      const baseToken = await wrapAs4(
+        "CONTRACT",
+        OP_DEPOSITS.base.baseToken,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "baseToken",
+          args: [ctx.chainIdL2]
+        }),
+        {
+          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
+          message: "Failed to read base token."
+        }
+      );
+      await wrapAs4(
+        "VALIDATION",
+        OP_DEPOSITS.base.assertMatchesBase,
+        () => {
+          if (!normalizeAddrEq(baseToken, p.token)) {
+            throw new Error("Provided token is not the base token for the target chain.");
+          }
+        },
+        { ctx: { baseToken, provided: p.token, chainIdL2: ctx.chainIdL2 } }
+      );
+      return;
+    },
+    async build(p, ctx) {
+      const { gasPriceForBaseCost } = ctx.fee;
+      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
+      const gasOverride = txFeeOverrides.gas;
+      const baseToken = await wrapAs4(
+        "CONTRACT",
+        OP_DEPOSITS.base.baseToken,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "baseToken",
+          args: [ctx.chainIdL2]
+        }),
+        {
+          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
+          message: "Failed to read base token."
+        }
+      );
+      const rawBaseCost = await wrapAs4(
+        "CONTRACT",
+        OP_DEPOSITS.base.baseCost,
+        () => ctx.client.l1.readContract({
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "l2TransactionBaseCost",
+          args: [ctx.chainIdL2, gasPriceForBaseCost, ctx.l2GasLimit, ctx.gasPerPubdata]
+        }),
+        {
+          ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 },
+          message: "Could not fetch L2 base cost from Bridgehub."
+        }
+      );
+      const baseCost = rawBaseCost;
+      const l2Value = p.amount;
+      const rawMintValue = baseCost + ctx.operatorTip + l2Value;
+      const mintValue = withBuffer3(rawMintValue);
+      const allowance = await wrapAs4(
+        "CONTRACT",
+        OP_DEPOSITS.base.allowance,
+        () => ctx.client.l1.readContract({
+          address: baseToken,
+          abi: IERC20_default,
+          functionName: "allowance",
+          args: [ctx.sender, ctx.l1AssetRouter]
+        }),
+        {
+          ctx: { where: "erc20.allowance", token: baseToken, spender: ctx.l1AssetRouter },
+          message: "Failed to read base-token allowance."
+        }
+      );
+      const approvals = [];
+      const steps = [];
+      const needsApprove = allowance < mintValue;
+      if (needsApprove) {
+        const approveSim = await wrapAs4(
+          "CONTRACT",
+          OP_DEPOSITS.base.estGas,
+          () => ctx.client.l1.simulateContract({
+            address: baseToken,
+            abi: IERC20_default,
+            functionName: "approve",
+            args: [ctx.l1AssetRouter, mintValue],
+            account: ctx.client.account
+          }),
+          {
+            ctx: { where: "l1.simulateContract", to: baseToken },
+            message: "Failed to simulate ERC-20 approve."
+          }
+        );
+        approvals.push({ token: baseToken, spender: ctx.l1AssetRouter, amount: mintValue });
+        steps.push({
+          key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
+          kind: "approve",
+          description: "Approve base token for mintValue",
+          tx: { ...approveSim.request, ...txFeeOverrides }
+        });
+      }
+      const req = buildDirectRequestStruct({
+        chainId: ctx.chainIdL2,
+        mintValue,
+        l2GasLimit: ctx.l2GasLimit,
+        gasPerPubdata: ctx.gasPerPubdata,
+        refundRecipient: ctx.refundRecipient,
+        l2Contract: p.to ?? ctx.sender,
+        l2Value
+      });
+      let bridgeTx;
+      let resolvedL1GasLimit;
+      if (needsApprove) {
+        bridgeTx = {
+          address: ctx.bridgehub,
+          abi: IBridgehub_default,
+          functionName: "requestL2TransactionDirect",
+          args: [req],
+          value: 0n,
+          // base is ERC-20 ⇒ msg.value MUST be 0
+          account: ctx.client.account,
+          ...txFeeOverrides
+        };
+        resolvedL1GasLimit = gasOverride ?? ctx.l2GasLimit;
+      } else {
+        const sim = await wrapAs4(
+          "RPC",
+          OP_DEPOSITS.base.estGas,
+          () => ctx.client.l1.simulateContract({
+            address: ctx.bridgehub,
+            abi: IBridgehub_default,
+            functionName: "requestL2TransactionDirect",
+            args: [req],
+            value: 0n,
+            account: ctx.client.account
+          }),
+          {
+            ctx: { where: "l1.simulateContract", to: ctx.bridgehub },
+            message: "Failed to simulate Bridgehub.requestL2TransactionDirect."
+          }
+        );
+        bridgeTx = { ...sim.request, ...txFeeOverrides };
+        resolvedL1GasLimit = sim.request.gas ?? ctx.l2GasLimit;
+      }
+      steps.push({
+        key: "bridgehub:direct:erc20-base",
+        kind: "bridgehub:direct",
+        description: "Bridge base ERC-20 via Bridgehub.requestL2TransactionDirect",
+        tx: bridgeTx
+      });
+      return {
+        steps,
+        approvals,
+        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+      };
+    }
+  };
+}
+var I_BRIDGEHUB_NEW_PRIORITY_REQUEST = {
+  type: "event",
+  name: "NewPriorityRequest",
+  inputs: [
+    { name: "chainId", type: "uint256", indexed: true },
+    { name: "sender", type: "address", indexed: true },
+    { name: "txHash", type: "bytes32", indexed: false },
+    { name: "txId", type: "uint256", indexed: false },
+    { name: "data", type: "bytes", indexed: false }
+  ]
+};
+function extractL2TxHashFromL1Logs(logs) {
+  for (const lg of logs) {
+    try {
+      const parsed = decodeEventLog({
+        abi: [I_BRIDGEHUB_NEW_PRIORITY_REQUEST],
+        data: lg.data,
+        topics: lg.topics,
+        strict: false
+      });
+      if (parsed?.eventName === "NewPriorityRequest") {
+        const h = parsed.args?.txHash;
+        if (h && isHash66(h)) return h;
+      }
+    } catch {
+    }
+  }
+  for (const lg of logs) {
+    const t0 = (lg.topics?.[0] ?? "0x").toLowerCase();
+    if (t0 === TOPIC_CANONICAL_ASSIGNED.toLowerCase()) {
+      const h = lg.topics?.[2];
+      if (h && isHash66(h)) return h;
+    }
+    if (t0 === TOPIC_CANONICAL_SUCCESS.toLowerCase()) {
+      const h = lg.topics?.[3];
+      if (h && isHash66(h)) return h;
+    }
+  }
+  return null;
+}
+async function waitForL2ExecutionFromL1Tx(l1, l2, l1TxHash) {
+  const l1Receipt = await l1.waitForTransactionReceipt({ hash: l1TxHash });
+  if (!l1Receipt) throw new Error("No L1 receipt found");
+  const l2TxHash = extractL2TxHashFromL1Logs(l1Receipt.logs);
+  if (!l2TxHash) {
+    throw createError("VERIFICATION", {
+      message: "Failed to extract L2 transaction hash from L1 logs",
+      resource: "deposits",
+      operation: "deposits.wait",
+      context: { l1TxHash, logCount: l1Receipt.logs?.length ?? 0 }
+    });
+  }
+  let l2Receipt = await l2.waitForTransactionReceipt({ hash: l2TxHash }).catch(() => null);
+  if (!l2Receipt) {
+    const maybe = await l2.getTransactionReceipt({ hash: l2TxHash }).catch(() => null);
+    if (!maybe) {
+      throw createError("VERIFICATION", {
+        message: "L2 transaction was not found after waiting for its execution",
+        resource: "deposits",
+        operation: "deposits.wait",
+        context: { l1TxHash, l2TxHash, where: "l2.waitForTransactionReceipt" }
+      });
+    }
+    l2Receipt = maybe;
+  }
+  if (l2Receipt.status !== "success") {
+    throw createError("VERIFICATION", {
+      message: "L2 transaction execution failed",
+      resource: "deposits",
+      operation: "deposits.wait",
+      context: { l1TxHash, l2TxHash, status: l2Receipt.status }
+    });
+  }
+  return { l2Receipt, l2TxHash };
+}
+
+// src/adapters/viem/resources/deposits/index.ts
+var { wrap, toResult } = createErrorHandlers("deposits");
+var ROUTES = {
+  "eth-base": routeEthDirect(),
+  "eth-nonbase": routeEthNonBase(),
+  "erc20-nonbase": routeErc20NonBase(),
+  "erc20-base": routeErc20Base()
+};
+function createDepositsResource(client) {
+  async function buildPlan(p) {
+    const ctx = await commonCtx(p, client);
+    const route = ctx.route;
+    await ROUTES[route].preflight?.(p, ctx);
+    const { steps, approvals, quoteExtras } = await ROUTES[route].build(p, ctx);
+    const { baseCost, mintValue } = quoteExtras;
+    const fallbackGasLimit = quoteExtras.l1GasLimit;
+    const resolveGasLimit = () => {
+      if (ctx.fee.gasLimit != null) return ctx.fee.gasLimit;
+      for (let i = steps.length - 1; i >= 0; i--) {
+        const candidate = steps[i].tx.gas;
+        if (candidate != null) return candidate;
+      }
+      if (fallbackGasLimit != null) return fallbackGasLimit;
+      return ctx.l2GasLimit;
+    };
+    const gasLimit = resolveGasLimit();
+    return {
+      route: ctx.route,
+      summary: {
+        route: ctx.route,
+        approvalsNeeded: approvals,
+        baseCost,
+        mintValue,
+        gasPerPubdata: ctx.gasPerPubdata,
+        fees: {
+          gasLimit,
+          maxFeePerGas: ctx.fee.maxFeePerGas,
+          maxPriorityFeePerGas: ctx.fee.maxPriorityFeePerGas
+        }
+      },
+      steps
+    };
+  }
+  const quote = async (p) => wrap(
+    OP_DEPOSITS.quote,
+    async () => {
+      const plan = await buildPlan(p);
+      return plan.summary;
+    },
+    {
+      message: "Internal error while preparing a deposit quote.",
+      ctx: { token: p.token, where: "deposits.quote" }
+    }
+  );
+  const tryQuote = (p) => toResult(OP_DEPOSITS.tryQuote, () => quote(p), {
+    message: "Internal error while preparing a deposit quote.",
+    ctx: { token: p.token, where: "deposits.tryQuote" }
+  });
+  const prepare = (p) => wrap(OP_DEPOSITS.prepare, () => buildPlan(p), {
+    message: "Internal error while preparing a deposit plan.",
+    ctx: { token: p.token, where: "deposits.prepare" }
+  });
+  const tryPrepare = (p) => toResult(OP_DEPOSITS.tryPrepare, () => prepare(p), {
+    ctx: { token: p.token, where: "deposits.tryPrepare" }
+  });
+  const create = (p) => wrap(
+    OP_DEPOSITS.create,
+    async () => {
+      const plan = await prepare(p);
+      const stepHashes = {};
+      const from = client.account.address;
+      let next = await client.l1.getTransactionCount({ address: from, blockTag: "latest" });
+      for (const step of plan.steps) {
+        if (step.kind === "approve") {
+          try {
+            const [, token, router] = step.key.split(":");
+            const current = await client.l1.readContract({
+              address: token,
+              abi: IERC20_default,
+              functionName: "allowance",
+              args: [from, router]
+            });
+            const target = plan.summary.approvalsNeeded.find(
+              (need) => need.token.toLowerCase() === (token ?? "").toLowerCase() && need.spender.toLowerCase() === (router ?? "").toLowerCase()
+            )?.amount ?? 0n;
+            if (current >= target) {
+              continue;
+            }
+          } catch (e) {
+            throw toZKsyncError(
+              "CONTRACT",
+              {
+                resource: "deposits",
+                operation: "deposits.create.erc20-allowance-recheck",
+                context: { where: "erc20.allowance(recheck)", step: step.key, from },
+                message: "Failed to read ERC-20 allowance during deposit step."
+              },
+              e
+            );
+          }
+        }
+        if (p.l1TxOverrides) {
+          const overrides = p.l1TxOverrides;
+          if (overrides.maxFeePerGas != null) {
+            step.tx.maxFeePerGas = overrides.maxFeePerGas;
+          }
+          if (overrides.maxPriorityFeePerGas != null) {
+            step.tx.maxPriorityFeePerGas = overrides.maxPriorityFeePerGas;
+          }
+          if (overrides.gasLimit != null) {
+            step.tx.gas = overrides.gasLimit;
+          }
+        }
+        if (step.tx.gas == null) {
+          try {
+            const feePart = step.tx.maxFeePerGas != null && step.tx.maxPriorityFeePerGas != null ? {
+              maxFeePerGas: step.tx.maxFeePerGas,
+              maxPriorityFeePerGas: step.tx.maxPriorityFeePerGas
+            } : {};
+            const params = {
+              address: step.tx.address,
+              abi: step.tx.abi,
+              functionName: step.tx.functionName,
+              args: step.tx.args,
+              account: step.tx.account ?? client.account,
+              ...step.tx.value != null ? { value: step.tx.value } : {},
+              maxFeePerGas: step.tx.maxFeePerGas,
+              maxPriorityFeePerGas: step.tx.maxPriorityFeePerGas,
+              ...feePart
+            };
+            const gas = await client.l1.estimateContractGas({
+              ...params
+            });
+            step.tx.gas = gas * 115n / 100n;
+          } catch {
+          }
+        }
+        const nonce = next++;
+        const fee1559 = step.tx.maxFeePerGas != null && step.tx.maxPriorityFeePerGas != null ? {
+          maxFeePerGas: step.tx.maxFeePerGas,
+          maxPriorityFeePerGas: step.tx.maxPriorityFeePerGas
+        } : {};
+        const baseReq = {
+          address: step.tx.address,
+          abi: step.tx.abi,
+          functionName: step.tx.functionName,
+          args: step.tx.args,
+          account: step.tx.account ?? client.account,
+          gas: step.tx.gas,
+          nonce,
+          ...fee1559,
+          ...step.tx.dataSuffix ? { dataSuffix: step.tx.dataSuffix } : {},
+          ...step.tx.chain ? { chain: step.tx.chain } : {}
+        };
+        const req = step.tx.value != null ? { ...baseReq, value: step.tx.value } : baseReq;
+        let hash;
+        try {
+          hash = await client.l1Wallet.writeContract(req);
+          stepHashes[step.key] = hash;
+          const rcpt = await client.l1.waitForTransactionReceipt({ hash });
+          if (!rcpt || rcpt.status !== "success") {
+            throw createError("EXECUTION", {
+              resource: "deposits",
+              operation: "deposits.create.writeContract",
+              message: "Deposit transaction reverted on L1 during a step.",
+              context: { step: step.key, txHash: hash, status: rcpt?.status }
+            });
+          }
+        } catch (e) {
+          if (isZKsyncError(e)) throw e;
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "deposits",
+              operation: "deposits.create.writeContract",
+              context: { step: step.key, txHash: hash, nonce },
+              message: "Failed to send or confirm a deposit transaction step."
+            },
+            e
+          );
+        }
+      }
+      const ordered = Object.entries(stepHashes);
+      const last = ordered[ordered.length - 1][1];
+      return { kind: "deposit", l1TxHash: last, stepHashes, plan };
+    },
+    {
+      message: "Internal error while creating a deposit.",
+      ctx: { token: p.token, amount: p.amount, to: p.to, where: "deposits.create" }
+    }
+  );
+  const tryCreate = (p) => toResult(OP_DEPOSITS.tryCreate, () => create(p), {
+    message: "Internal error while creating a deposit.",
+    ctx: { token: p.token, amount: p.amount, to: p.to, where: "deposits.tryCreate" }
+  });
+  const status = (h) => wrap(
+    OP_DEPOSITS.status,
+    async () => {
+      const l1TxHash = typeof h === "string" ? h : h.l1TxHash;
+      if (!l1TxHash) return { phase: "UNKNOWN", l1TxHash: "0x" };
+      let l1Rcpt;
+      try {
+        l1Rcpt = await client.l1.getTransactionReceipt({ hash: l1TxHash });
+      } catch (e) {
+        throw toZKsyncError(
+          "RPC",
+          {
+            resource: "deposits",
+            operation: "deposits.status.getTransactionReceipt",
+            context: { where: "l1.getTransactionReceipt", l1TxHash },
+            message: "Failed to fetch L1 transaction receipt."
+          },
+          e
+        );
+      }
+      if (!l1Rcpt) return { phase: "L1_PENDING", l1TxHash };
+      let l2TxHash;
+      try {
+        l2TxHash = extractL2TxHashFromL1Logs(l1Rcpt.logs) ?? void 0;
+      } catch (e) {
+        throw toZKsyncError(
+          "INTERNAL",
+          {
+            resource: "deposits",
+            operation: "deposits.status.extractL2TxHashFromL1Logs",
+            context: { where: "extractL2TxHashFromL1Logs", l1TxHash },
+            message: "Failed to derive L2 transaction hash from L1 logs."
+          },
+          e
+        );
+      }
+      if (!l2TxHash) return { phase: "L1_INCLUDED", l1TxHash };
+      let l2Rcpt;
+      try {
+        l2Rcpt = await client.l2.getTransactionReceipt({ hash: l2TxHash });
+      } catch (e) {
+        if (isReceiptNotFound(e)) {
+          return { phase: "L2_PENDING", l1TxHash, l2TxHash };
+        }
+        throw toZKsyncError(
+          "RPC",
+          {
+            resource: "deposits",
+            operation: "deposits.status.getTransactionReceipt",
+            message: "Failed to fetch L2 transaction receipt.",
+            context: { l2TxHash, where: "l2.getTransactionReceipt" }
+          },
+          e
+        );
+      }
+      if (!l2Rcpt) return { phase: "L2_PENDING", l1TxHash, l2TxHash };
+      const ok = l2Rcpt.status === "success";
+      return ok ? { phase: "L2_EXECUTED", l1TxHash, l2TxHash } : { phase: "L2_FAILED", l1TxHash, l2TxHash };
+    },
+    {
+      message: "Internal error while checking deposit status.",
+      ctx: { input: h, where: "deposits.status" }
+    }
+  );
+  const wait = (h, opts) => wrap(
+    OP_DEPOSITS.wait,
+    async () => {
+      const l1Hash = typeof h === "string" ? h : "l1TxHash" in h ? h.l1TxHash : void 0;
+      if (!l1Hash) return null;
+      let l1Receipt;
+      try {
+        l1Receipt = await client.l1.waitForTransactionReceipt({ hash: l1Hash });
+      } catch (e) {
+        throw toZKsyncError(
+          "RPC",
+          {
+            resource: "deposits",
+            operation: "deposits.waitForTransaction",
+            context: { where: "l1.waitForTransactionReceipt", l1TxHash: l1Hash, for: opts.for },
+            message: "Failed while waiting for L1 transaction."
+          },
+          e
+        );
+      }
+      if (!l1Receipt) return null;
+      if (opts.for === "l1") return l1Receipt;
+      try {
+        const { l2Receipt } = await waitForL2ExecutionFromL1Tx(client.l1, client.l2, l1Hash);
+        return l2Receipt ?? null;
+      } catch (e) {
+        if (isZKsyncError(e)) throw e;
+        throw toZKsyncError(
+          "INTERNAL",
+          {
+            resource: "deposits",
+            operation: "deposits.waitForL2ExecutionFromL1Tx",
+            context: { where: "waitForL2ExecutionFromL1Tx", l1TxHash: l1Hash },
+            message: "Internal error while waiting for L2 execution."
+          },
+          e
+        );
+      }
+    },
+    {
+      message: "Internal error while waiting for deposit.",
+      ctx: { input: h, for: opts?.for, where: "deposits.wait" }
+    }
+  );
+  const tryWait = (h, opts) => toResult(
+    OP_DEPOSITS.tryWait,
+    async () => {
+      const v = await wait(h, opts);
+      if (v) return v;
+      throw createError("STATE", {
+        resource: "deposits",
+        operation: "deposits.tryWait",
+        message: opts.for === "l2" ? "No L2 receipt yet; the deposit has not executed on L2." : "No L1 receipt yet; the deposit has not been included on L1.",
+        context: {
+          for: opts.for,
+          l1TxHash: typeof h === "string" ? h : "l1TxHash" in h ? h.l1TxHash : void 0,
+          where: "deposits.tryWait"
+        }
+      });
+    },
+    {
+      message: "Internal error while waiting for deposit.",
+      ctx: { input: h, for: opts?.for, where: "deposits.tryWait" }
+    }
+  );
+  return { quote, tryQuote, prepare, tryPrepare, create, tryCreate, status, wait, tryWait };
+}
+
+// src/adapters/viem/resources/token-info.ts
+async function ntvBaseAssetId(l2, ntv) {
+  return l2.readContract({
+    address: ntv,
+    abi: L2NativeTokenVault_default,
+    functionName: "BASE_TOKEN_ASSET_ID"
+  });
+}
+async function ntvL1ChainId(l2, ntv) {
+  return l2.readContract({
+    address: ntv,
+    abi: L2NativeTokenVault_default,
+    functionName: "L1_CHAIN_ID"
+  });
+}
+async function isEthBasedChain(l2, ntv) {
+  const [baseAssetId, l1ChainId] = await Promise.all([
+    ntvBaseAssetId(l2, ntv),
+    ntvL1ChainId(l2, ntv)
+  ]);
+  const ethAssetId = encodeNativeTokenVaultAssetId(l1ChainId, ETH_ADDRESS);
+  return baseAssetId.toLowerCase() === ethAssetId.toLowerCase();
+}
+
+// src/adapters/viem/resources/withdrawals/context.ts
+async function commonCtx2(p, client) {
+  const sender = client.account.address;
+  const {
+    bridgehub,
+    l1AssetRouter,
+    l1Nullifier,
+    l2AssetRouter,
+    l2NativeTokenVault,
+    l2BaseTokenSystem
+  } = await client.ensureAddresses();
+  const chainIdL2 = BigInt(await client.l2.getChainId());
+  const baseIsEth = await isEthBasedChain(client.l2, l2NativeTokenVault);
+  const fee = await getL2FeeOverrides(client, p.l2TxOverrides);
+  const route = pickWithdrawRoute({
+    token: p.token,
+    baseIsEth
+  });
+  const l2GasLimit = p.l2GasLimit ?? 300000n;
+  const gasBufferPct = 15;
+  return {
+    client,
+    bridgehub,
+    chainIdL2,
+    sender,
+    route,
+    l1AssetRouter,
+    l1Nullifier,
+    l2AssetRouter,
+    l2NativeTokenVault,
+    l2BaseTokenSystem,
+    baseIsEth,
+    l2GasLimit,
+    gasBufferPct,
+    fee
+  };
+}
+
+// src/adapters/viem/resources/withdrawals/routes/eth.ts
+var { wrapAs: wrapAs5 } = createErrorHandlers("withdrawals");
+function routeEthBase() {
+  return {
+    async build(p, ctx) {
+      const toL1 = p.to ?? ctx.sender;
+      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
+      const sim = await wrapAs5(
+        "CONTRACT",
+        OP_WITHDRAWALS.eth.estGas,
+        () => ctx.client.l2.simulateContract({
+          address: L2_BASE_TOKEN_ADDRESS,
+          abi: IBaseToken_default,
+          functionName: "withdraw",
+          args: [toL1],
+          value: p.amount,
+          account: ctx.client.account,
+          ...txFeeOverrides
+        }),
+        {
+          ctx: { where: "l2.simulateContract", to: L2_BASE_TOKEN_ADDRESS },
+          message: "Failed to simulate L2 ETH withdraw."
+        }
+      );
+      const steps = [
+        {
+          key: "l2-base-token:withdraw",
+          kind: "l2-base-token:withdraw",
+          description: "Withdraw ETH via L2 Base Token System",
+          tx: { ...sim.request, ...txFeeOverrides }
+        }
+      ];
+      return { steps, approvals: [], quoteExtras: {} };
+    }
+  };
+}
+var { wrapAs: wrapAs6 } = createErrorHandlers("withdrawals");
+function routeErc20NonBase2() {
+  return {
+    // TODO: add preflight validations here
+    async build(p, ctx) {
+      const toL1 = p.to ?? ctx.sender;
+      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
+      const current = await wrapAs6(
+        "CONTRACT",
+        OP_WITHDRAWALS.erc20.allowance,
+        () => ctx.client.l2.readContract({
+          address: p.token,
+          abi: IERC20_default,
+          functionName: "allowance",
+          args: [ctx.sender, ctx.l2NativeTokenVault],
+          account: ctx.client.account
+        }),
+        {
+          ctx: {
+            where: "erc20.allowance",
+            chain: "L2",
+            token: p.token,
+            spender: ctx.l2NativeTokenVault
+          },
+          message: "Failed to read L2 ERC-20 allowance."
+        }
+      );
+      const needsApprove = current < p.amount;
+      const steps = [];
+      const approvals = [];
+      if (needsApprove) {
+        approvals.push({ token: p.token, spender: ctx.l2NativeTokenVault, amount: p.amount });
+        const approveSim = await wrapAs6(
+          "CONTRACT",
+          OP_WITHDRAWALS.erc20.estGas,
+          () => ctx.client.l2.simulateContract({
+            address: p.token,
+            abi: IERC20_default,
+            functionName: "approve",
+            args: [ctx.l2NativeTokenVault, p.amount],
+            account: ctx.client.account,
+            ...txFeeOverrides
+          }),
+          {
+            ctx: { where: "l2.simulateContract", to: p.token },
+            message: "Failed to simulate L2 ERC-20 approve."
+          }
+        );
+        steps.push({
+          key: `approve:l2:${p.token}:${ctx.l2NativeTokenVault}`,
+          kind: "approve:l2",
+          description: `Approve ${p.amount} to NativeTokenVault`,
+          tx: { ...approveSim.request, ...txFeeOverrides }
+        });
+      }
+      const ensure = await wrapAs6(
+        "CONTRACT",
+        OP_WITHDRAWALS.erc20.ensureRegistered,
+        () => ctx.client.l2.simulateContract({
+          address: ctx.l2NativeTokenVault,
+          abi: L2NativeTokenVault_default,
+          functionName: "ensureTokenIsRegistered",
+          args: [p.token],
+          account: ctx.client.account
+        }),
+        {
+          ctx: { where: "L2NativeTokenVault.ensureTokenIsRegistered", token: p.token },
+          message: "Failed to ensure token is registered in L2NativeTokenVault."
+        }
+      );
+      const assetId = ensure.result;
+      const assetData = encodeAbiParameters(
+        [
+          { type: "uint256", name: "amount" },
+          { type: "address", name: "l1Receiver" },
+          { type: "address", name: "l2Token" }
+        ],
+        [p.amount, toL1, p.token]
+      );
+      let withdrawTx;
+      if (needsApprove) {
+        withdrawTx = {
+          address: ctx.l2AssetRouter,
+          abi: IL2AssetRouter_default,
+          functionName: "withdraw",
+          args: [assetId, assetData],
+          account: ctx.client.account,
+          ...txFeeOverrides
+        };
+      } else {
+        const sim = await wrapAs6(
+          "CONTRACT",
+          OP_WITHDRAWALS.erc20.estGas,
+          () => ctx.client.l2.simulateContract({
+            address: ctx.l2AssetRouter,
+            abi: IL2AssetRouter_default,
+            functionName: "withdraw",
+            args: [assetId, assetData],
+            account: ctx.client.account,
+            ...txFeeOverrides
+          }),
+          {
+            ctx: { where: "l2.simulateContract", to: ctx.l2AssetRouter },
+            message: "Failed to simulate L2 ERC-20 withdraw."
+          }
+        );
+        withdrawTx = { ...sim.request, ...txFeeOverrides };
+      }
+      steps.push({
+        key: "l2-asset-router:withdraw",
+        kind: "l2-asset-router:withdraw",
+        description: "Burn on L2 & send L2\u2192L1 message",
+        tx: withdrawTx
+      });
+      return { steps, approvals, quoteExtras: {} };
+    }
+  };
+}
+
+// src/adapters/viem/resources/withdrawals/routes/eth-nonbase.ts
+var { wrapAs: wrapAs7 } = createErrorHandlers("withdrawals");
+function routeEthNonBase2() {
+  return {
+    async preflight(p, ctx) {
+      await wrapAs7(
+        "VALIDATION",
+        OP_WITHDRAWALS.ethNonBase.assertNonEthBase,
+        () => {
+          if (p.token.toLowerCase() !== L2_BASE_TOKEN_ADDRESS.toLowerCase()) {
+            throw new Error("eth-nonbase route requires the L2 base-token alias (0x\u2026800A).");
+          }
+          if (ctx.baseIsEth) {
+            throw new Error("eth-nonbase route requires chain base \u2260 ETH.");
+          }
+        },
+        { ctx: { token: p.token, baseIsEth: ctx.baseIsEth } }
+      );
+    },
+    async build(p, ctx) {
+      const toL1 = p.to ?? ctx.sender;
+      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
+      const sim = await wrapAs7(
+        "CONTRACT",
+        OP_WITHDRAWALS.ethNonBase.estGas,
+        () => ctx.client.l2.simulateContract({
+          address: L2_BASE_TOKEN_ADDRESS,
+          abi: IBaseToken_default,
+          functionName: "withdraw",
+          args: [toL1],
+          value: p.amount,
+          account: ctx.client.account,
+          ...txFeeOverrides
+        }),
+        {
+          ctx: { where: "l2.simulateContract", to: L2_BASE_TOKEN_ADDRESS },
+          message: "Failed to simulate L2 base-token withdraw."
+        }
+      );
+      const steps = [
+        {
+          key: "l2-base-token:withdraw",
+          kind: "l2-base-token:withdraw",
+          description: "Withdraw base token via L2 Base Token System (base \u2260 ETH)",
+          tx: { ...sim.request, ...txFeeOverrides }
+        }
+      ];
+      return { steps, approvals: [], quoteExtras: {} };
+    }
+  };
+}
+var { wrapAs: wrapAs8 } = createErrorHandlers("withdrawals");
+var IL1NullifierMini = [
+  {
+    type: "function",
+    name: "isWithdrawalFinalized",
+    stateMutability: "view",
+    inputs: [
+      { name: "chainId", type: "uint256" },
+      { name: "l2BatchNumber", type: "uint256" },
+      { name: "l2MessageIndex", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  }
+];
+function createFinalizationServices(client) {
+  return {
+    async fetchFinalizeDepositParams(l2TxHash) {
+      const parsed = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.fetchParams.receipt,
+        () => client.zks.getReceiptWithL2ToL1(l2TxHash),
+        {
+          ctx: { where: "getReceiptWithL2ToL1", l2TxHash },
+          message: "Failed to fetch L2 receipt (with L2\u2192L1 logs)."
+        }
+      );
+      if (!parsed) {
+        throw createError("STATE", {
+          resource: "withdrawals",
+          operation: OP_WITHDRAWALS.finalize.fetchParams.receipt,
+          message: "L2 receipt not found.",
+          context: { l2TxHash }
+        });
+      }
+      const ev = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.fetchParams.findMessage,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+        () => Promise.resolve(findL1MessageSentLog(parsed, { index: 0 })),
+        {
+          ctx: { l2TxHash, index: 0 },
+          message: "Failed to locate L1MessageSent event in L2 receipt."
+        }
+      );
+      const message = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.fetchParams.decodeMessage,
+        () => {
+          const [decoded] = decodeAbiParameters([{ type: "bytes" }], ev.data);
+          return decoded;
+        },
+        {
+          ctx: { where: "decode L1MessageSent", data: ev.data },
+          message: "Failed to decode withdrawal message."
+        }
+      );
+      const raw = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.fetchParams.rawReceipt,
+        () => client.zks.getReceiptWithL2ToL1(l2TxHash),
+        {
+          ctx: { where: "getReceiptWithL2ToL1 (raw)", l2TxHash },
+          message: "Failed to fetch raw L2 receipt."
+        }
+      );
+      if (!raw) {
+        throw createError("STATE", {
+          resource: "withdrawals",
+          operation: OP_WITHDRAWALS.finalize.fetchParams.rawReceipt,
+          message: "Raw L2 receipt not found.",
+          context: { l2TxHash }
+        });
+      }
+      const idx = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.fetchParams.messengerIndex,
+        () => Promise.resolve(messengerLogIndex(raw, { index: 0, messenger: L1_MESSENGER_ADDRESS })),
+        {
+          ctx: { where: "derive messenger log index", l2TxHash, receipt: raw },
+          message: "Failed to derive messenger log index."
+        }
+      );
+      const proof = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.fetchParams.proof,
+        () => client.zks.getL2ToL1LogProof(l2TxHash, idx),
+        {
+          ctx: { where: "get L2\u2192L1 log proof", l2TxHash, messengerLogIndex: idx },
+          message: "Failed to fetch L2\u2192L1 log proof."
+        }
+      );
+      const chainId = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.fetchParams.network,
+        () => client.l2.getChainId(),
+        { ctx: { where: "l2.getChainId" }, message: "Failed to read L2 chain id." }
+      );
+      const txIndex = Number(parsed.transactionIndex ?? 0);
+      const params = {
+        chainId: BigInt(chainId),
+        l2BatchNumber: proof.batchNumber,
+        l2MessageIndex: proof.id,
+        l2Sender: L2_ASSET_ROUTER_ADDRESS,
+        l2TxNumberInBatch: txIndex,
+        message,
+        merkleProof: proof.proof
+      };
+      const { l1Nullifier } = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
+        () => client.ensureAddresses(),
+        {
+          ctx: { where: "ensureAddresses" },
+          message: "Failed to ensure L1 Nullifier address."
+        }
+      );
+      return { params, nullifier: l1Nullifier };
+    },
+    async simulateFinalizeReadiness(params) {
+      const { l1Nullifier } = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.readiness.ensureAddresses,
+        () => client.ensureAddresses(),
+        {
+          ctx: { where: "ensureAddresses" },
+          message: "Failed to ensure L1 Nullifier address."
+        }
+      );
+      const done = await (async () => {
+        try {
+          const result = await wrapAs8(
+            "RPC",
+            OP_WITHDRAWALS.finalize.readiness.isFinalized,
+            () => client.l1.readContract({
+              address: l1Nullifier,
+              abi: IL1NullifierMini,
+              functionName: "isWithdrawalFinalized",
+              args: [params.chainId, params.l2BatchNumber, params.l2MessageIndex]
+            }),
+            {
+              ctx: { where: "isWithdrawalFinalized", params },
+              message: "Failed to read finalization status."
+            }
+          );
+          return result;
+        } catch {
+          return false;
+        }
+      })();
+      if (done) return { kind: "FINALIZED" };
+      try {
+        await client.l1.simulateContract({
+          address: l1Nullifier,
+          abi: IL1Nullifier_default,
+          functionName: "finalizeDeposit",
+          args: [params],
+          account: client.account
+        });
+        return { kind: "READY" };
+      } catch (e) {
+        return classifyReadinessFromRevert(e);
+      }
+    },
+    async isWithdrawalFinalized(key) {
+      const { l1Nullifier } = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
+        () => client.ensureAddresses(),
+        {
+          ctx: { where: "ensureAddresses" },
+          message: "Failed to ensure L1 Nullifier address."
+        }
+      );
+      return await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.isFinalized,
+        () => client.l1.readContract({
+          address: l1Nullifier,
+          abi: IL1NullifierMini,
+          functionName: "isWithdrawalFinalized",
+          args: [key.chainIdL2, key.l2BatchNumber, key.l2MessageIndex]
+        }),
+        {
+          ctx: { where: "isWithdrawalFinalized", key },
+          message: "Failed to read finalization status."
+        }
+      );
+    },
+    async estimateFinalization(params) {
+      const { l1Nullifier } = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.estimate,
+        () => client.ensureAddresses(),
+        {
+          ctx: { where: "ensureAddresses" },
+          message: "Failed to ensure L1 Nullifier address."
+        }
+      );
+      const gasLimit = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.estimate,
+        () => client.l1.estimateContractGas({
+          address: l1Nullifier,
+          abi: IL1Nullifier_default,
+          functionName: "finalizeDeposit",
+          args: [params],
+          account: client.account
+        }),
+        {
+          ctx: {
+            where: "estimateContractGas(finalizeDeposit)",
+            chainIdL2: params.chainId,
+            l2BatchNumber: params.l2BatchNumber,
+            l2MessageIndex: params.l2MessageIndex,
+            l1Nullifier
+          },
+          message: "Failed to estimate gas for finalizeDeposit."
+        }
+      );
+      let maxFeePerGas;
+      let maxPriorityFeePerGas;
+      try {
+        const fee = await wrapAs8(
+          "RPC",
+          OP_WITHDRAWALS.finalize.estimate,
+          () => client.l1.estimateFeesPerGas(),
+          {
+            ctx: { where: "estimateFeesPerGas" },
+            message: "Failed to estimate EIP-1559 fees."
+          }
+        );
+        maxFeePerGas = fee.maxFeePerGas ?? (() => {
+          throw createError("RPC", {
+            resource: "withdrawals",
+            operation: OP_WITHDRAWALS.finalize.estimate,
+            message: "Provider did not return maxFeePerGas.",
+            context: { fee }
+          });
+        })();
+        maxPriorityFeePerGas = fee.maxPriorityFeePerGas ?? 0n;
+      } catch {
+        const gasPrice = await wrapAs8(
+          "RPC",
+          OP_WITHDRAWALS.finalize.estimate,
+          () => client.l1.getGasPrice(),
+          {
+            ctx: { where: "getGasPrice" },
+            message: "Failed to read gas price for finalizeDeposit."
+          }
+        );
+        maxFeePerGas = gasPrice;
+        maxPriorityFeePerGas = 0n;
+      }
+      return {
+        gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas
+      };
+    },
+    async finalizeDeposit(params) {
+      const { l1Nullifier } = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
+        () => client.ensureAddresses(),
+        {
+          ctx: { where: "ensureAddresses" },
+          message: "Failed to ensure L1 Nullifier address."
+        }
+      );
+      try {
+        const hash = await client.l1Wallet.writeContract({
+          address: l1Nullifier,
+          abi: IL1Nullifier_default,
+          functionName: "finalizeDeposit",
+          args: [params],
+          account: client.account
+        });
+        return {
+          hash,
+          wait: async () => {
+            try {
+              return await client.l1.waitForTransactionReceipt({ hash });
+            } catch (e) {
+              throw toZKsyncError(
+                "EXECUTION",
+                {
+                  resource: "withdrawals",
+                  operation: OP_WITHDRAWALS.finalize.wait,
+                  message: "Failed while waiting for finalizeDeposit transaction.",
+                  context: { txHash: hash }
+                },
+                e
+              );
+            }
+          }
+        };
+      } catch (e) {
+        throw toZKsyncError(
+          "EXECUTION",
+          {
+            resource: "withdrawals",
+            operation: OP_WITHDRAWALS.finalize.send,
+            message: "Failed to send finalizeDeposit transaction.",
+            context: {
+              chainIdL2: params.chainId,
+              l2BatchNumber: params.l2BatchNumber,
+              l2MessageIndex: params.l2MessageIndex,
+              l1Nullifier
+            }
+          },
+          e
+        );
+      }
+    }
+  };
+}
+
+// src/adapters/viem/resources/withdrawals/index.ts
+var ROUTES2 = {
+  "eth-base": routeEthBase(),
+  // BaseTokenSystem.withdraw, chain base = ETH
+  "eth-nonbase": routeEthNonBase2(),
+  // BaseTokenSystem.withdraw, chain base ≠ ETH
+  "erc20-nonbase": routeErc20NonBase2()
+  // AssetRouter.withdraw for non-base ERC-20s
+};
+function createWithdrawalsResource(client) {
+  const svc = createFinalizationServices(client);
+  const { wrap: wrap2, toResult: toResult2 } = createErrorHandlers("withdrawals");
+  async function buildPlan(p) {
+    const ctx = await commonCtx2(p, client);
+    await ROUTES2[ctx.route].preflight?.(p, ctx);
+    const { steps, approvals } = await ROUTES2[ctx.route].build(p, ctx);
+    const resolveGasLimit = () => {
+      if (ctx.fee.gasLimit != null) return ctx.fee.gasLimit;
+      for (let i = steps.length - 1; i >= 0; i--) {
+        const candidate = steps[i].tx.gas;
+        if (candidate != null) return candidate;
+      }
+      return void 0;
+    };
+    const gasLimit = resolveGasLimit();
+    const summary = {
+      route: ctx.route,
+      approvalsNeeded: approvals,
+      suggestedL2GasLimit: ctx.l2GasLimit,
+      fees: {
+        gasLimit,
+        maxFeePerGas: ctx.fee.maxFeePerGas,
+        maxPriorityFeePerGas: ctx.fee.maxPriorityFeePerGas
+      }
+    };
+    return { route: ctx.route, summary, steps };
+  }
+  const finalizeCache = /* @__PURE__ */ new Map();
+  const quote = (p) => wrap2(OP_WITHDRAWALS.quote, async () => (await buildPlan(p)).summary, {
+    message: "Internal error while preparing a withdrawal quote.",
+    ctx: { token: p.token, where: "withdrawals.quote" }
+  });
+  const tryQuote = (p) => toResult2(OP_WITHDRAWALS.tryQuote, () => quote(p), {
+    message: "Internal error while preparing a withdrawal quote.",
+    ctx: { token: p.token, where: "withdrawals.tryQuote" }
+  });
+  const prepare = (p) => wrap2(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
+    message: "Internal error while preparing a withdrawal plan.",
+    ctx: { token: p.token, where: "withdrawals.prepare" }
+  });
+  const tryPrepare = (p) => toResult2(OP_WITHDRAWALS.tryPrepare, () => prepare(p), {
+    message: "Internal error while preparing a withdrawal plan.",
+    ctx: { token: p.token, where: "withdrawals.tryPrepare" }
+  });
+  const create = (p) => wrap2(
+    OP_WITHDRAWALS.create,
+    async () => {
+      const plan = await prepare(p);
+      const stepHashes = {};
+      const l2Wallet = client.getL2Wallet();
+      for (const step of plan.steps) {
+        if (p.l2TxOverrides) {
+          const overrides = p.l2TxOverrides;
+          if (overrides.maxFeePerGas != null) step.tx.maxFeePerGas = overrides.maxFeePerGas;
+          if (overrides.maxPriorityFeePerGas != null) {
+            step.tx.maxPriorityFeePerGas = overrides.maxPriorityFeePerGas;
+          }
+          if (overrides.gasLimit != null) step.tx.gas = overrides.gasLimit;
+        }
+        if (step.tx.gas == null) {
+          try {
+            const feePart = step.tx.maxFeePerGas != null && step.tx.maxPriorityFeePerGas != null ? {
+              maxFeePerGas: step.tx.maxFeePerGas,
+              maxPriorityFeePerGas: step.tx.maxPriorityFeePerGas
+            } : {};
+            const params = {
+              address: step.tx.address,
+              abi: step.tx.abi,
+              functionName: step.tx.functionName,
+              args: step.tx.args ?? [],
+              account: step.tx.account ?? l2Wallet.account ?? client.account,
+              ...step.tx.value != null ? { value: step.tx.value } : {},
+              ...feePart
+            };
+            const gas = await client.l2.estimateContractGas(params);
+            step.tx.gas = gas * 115n / 100n;
+          } catch {
+          }
+        }
+        const fee1559 = step.tx.maxFeePerGas != null && step.tx.maxPriorityFeePerGas != null ? {
+          maxFeePerGas: step.tx.maxFeePerGas,
+          maxPriorityFeePerGas: step.tx.maxPriorityFeePerGas
+        } : {};
+        const baseReq = {
+          address: step.tx.address,
+          abi: step.tx.abi,
+          functionName: step.tx.functionName,
+          args: step.tx.args ?? [],
+          account: step.tx.account ?? l2Wallet.account ?? client.account,
+          gas: step.tx.gas,
+          ...fee1559,
+          ...step.tx.dataSuffix ? { dataSuffix: step.tx.dataSuffix } : {},
+          ...step.tx.chain ? { chain: step.tx.chain } : {}
+        };
+        const execReq = step.tx.value != null ? { ...baseReq, value: step.tx.value } : baseReq;
+        let hash;
+        try {
+          if (!client.l2Wallet) {
+            throw createError("EXECUTION", {
+              resource: "withdrawals",
+              operation: "withdrawals.create.getL2Wallet",
+              message: "No L2 wallet available to send withdrawal transaction step.",
+              context: { step: step.key, l2Wallet }
+            });
+          }
+          hash = await l2Wallet.writeContract(execReq);
+          stepHashes[step.key] = hash;
+          const rcpt = await client.l2.waitForTransactionReceipt({ hash });
+          if (!rcpt || rcpt.status !== "success") {
+            throw createError("EXECUTION", {
+              resource: "withdrawals",
+              operation: "withdrawals.create.writeContract",
+              message: "Withdrawal transaction reverted on L2 during a step.",
+              context: { step: step.key, txHash: hash, status: rcpt?.status }
+            });
+          }
+        } catch (e) {
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "withdrawals",
+              operation: "withdrawals.create.writeContract",
+              message: "Failed to send or confirm a withdrawal transaction step.",
+              context: { step: step.key, txHash: hash, l2Wallet }
+            },
+            e
+          );
+        }
+      }
+      const keys = Object.keys(stepHashes);
+      const l2TxHash = stepHashes[keys[keys.length - 1]];
+      return { kind: "withdrawal", l2TxHash, stepHashes, plan };
+    },
+    {
+      message: "Internal error while creating withdrawal transactions.",
+      ctx: { token: p.token, amount: p.amount, to: p.to, where: "withdrawals.create" }
+    }
+  );
+  const tryCreate = (p) => toResult2(OP_WITHDRAWALS.tryCreate, () => create(p), {
+    message: "Internal error while creating withdrawal transactions.",
+    ctx: { token: p.token, amount: p.amount, to: p.to, where: "withdrawals.tryCreate" }
+  });
+  const status = (h) => wrap2(
+    OP_WITHDRAWALS.status,
+    async () => {
+      const l2TxHash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
+      if (!l2TxHash || l2TxHash === "0x") {
+        return { phase: "UNKNOWN", l2TxHash: "0x" };
+      }
+      let l2Rcpt;
+      try {
+        l2Rcpt = await client.l2.getTransactionReceipt({ hash: l2TxHash });
+      } catch (e) {
+        if (isReceiptNotFound(e)) {
+          return { phase: "L2_PENDING", l2TxHash };
+        }
+        throw toZKsyncError(
+          "RPC",
+          {
+            resource: "withdrawals",
+            operation: "withdrawals.status.getTransactionReceipt",
+            message: "Failed to fetch L2 transaction receipt.",
+            context: { l2TxHash, where: "l2.getTransactionReceipt" }
+          },
+          e
+        );
+      }
+      if (!l2Rcpt) return { phase: "L2_PENDING", l2TxHash };
+      let pack;
+      try {
+        pack = await svc.fetchFinalizeDepositParams(l2TxHash);
+      } catch {
+        return { phase: "PENDING", l2TxHash };
+      }
+      const key = {
+        chainIdL2: pack.params.chainId,
+        l2BatchNumber: pack.params.l2BatchNumber,
+        l2MessageIndex: pack.params.l2MessageIndex
+      };
+      try {
+        const done = await svc.isWithdrawalFinalized(key);
+        if (done) return { phase: "FINALIZED", l2TxHash, key };
+      } catch {
+      }
+      const readiness = await svc.simulateFinalizeReadiness(pack.params);
+      if (readiness.kind === "FINALIZED") return { phase: "FINALIZED", l2TxHash, key };
+      if (readiness.kind === "READY") return { phase: "READY_TO_FINALIZE", l2TxHash, key };
+      return { phase: "PENDING", l2TxHash, key };
+    },
+    {
+      message: "Internal error while checking withdrawal status.",
+      ctx: { where: "withdrawals.status", l2TxHash: typeof h === "string" ? h : h.l2TxHash }
+    }
+  );
+  const wait = (h, opts = {
+    for: "l2",
+    pollMs: 5500
+  }) => wrap2(
+    OP_WITHDRAWALS.wait,
+    async () => {
+      const l2Hash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
+      if (!l2Hash || l2Hash === "0x") return null;
+      if (opts.for === "l2") {
+        let rcpt;
+        try {
+          rcpt = await client.l2.waitForTransactionReceipt({ hash: l2Hash });
+        } catch (e) {
+          throw toZKsyncError(
+            "RPC",
+            {
+              resource: "withdrawals",
+              operation: "withdrawals.wait.l2.waitForTransactionReceipt",
+              message: "Failed while waiting for L2 transaction.",
+              context: { l2TxHash: l2Hash }
+            },
+            e
+          );
+        }
+        if (!rcpt) return null;
+        try {
+          const raw = await client.zks.getReceiptWithL2ToL1(l2Hash);
+          const zkRcpt = {
+            ...rcpt,
+            l2ToL1Logs: raw?.l2ToL1Logs ?? []
+          };
+          return zkRcpt;
+        } catch {
+          const zkRcpt = { ...rcpt, l2ToL1Logs: [] };
+          return zkRcpt;
+        }
+      }
+      const poll = Math.max(1e3, opts.pollMs ?? 2500);
+      const deadline = opts.timeoutMs ? Date.now() + opts.timeoutMs : void 0;
+      while (true) {
+        const s = await status(l2Hash);
+        if (opts.for === "ready") {
+          if (s.phase === "READY_TO_FINALIZE" || s.phase === "FINALIZED") return null;
+        } else {
+          if (s.phase === "FINALIZED") {
+            const l1Hash = finalizeCache.get(l2Hash);
+            if (l1Hash) {
+              try {
+                const l1Rcpt = await client.l1.getTransactionReceipt({ hash: l1Hash });
+                if (l1Rcpt) {
+                  finalizeCache.delete(l2Hash);
+                  return l1Rcpt;
+                }
+              } catch {
+              }
+            }
+            return null;
+          }
+        }
+        if (deadline && Date.now() > deadline) return null;
+        await new Promise((r) => setTimeout(r, poll));
+      }
+    },
+    {
+      message: "Internal error while waiting for withdrawal.",
+      ctx: {
+        where: "withdrawals.wait",
+        l2TxHash: typeof h === "string" ? h : h.l2TxHash,
+        for: opts.for
+      }
+    }
+  );
+  const finalize = (l2TxHash) => wrap2(
+    OP_WITHDRAWALS.finalize.send,
+    async () => {
+      const pack = await (async () => {
+        try {
+          return await svc.fetchFinalizeDepositParams(l2TxHash);
+        } catch (e) {
+          throw createError("STATE", {
+            resource: "withdrawals",
+            operation: OP_WITHDRAWALS.finalize.fetchParams.receipt,
+            message: "Withdrawal not ready: finalize params unavailable.",
+            context: { l2TxHash },
+            cause: e
+          });
+        }
+      })();
+      const { params } = pack;
+      const key = {
+        chainIdL2: params.chainId,
+        l2BatchNumber: params.l2BatchNumber,
+        l2MessageIndex: params.l2MessageIndex
+      };
+      try {
+        const done = await svc.isWithdrawalFinalized(key);
+        if (done) {
+          const statusNow = await status(l2TxHash);
+          return { status: statusNow };
+        }
+      } catch {
+      }
+      const readiness = await svc.simulateFinalizeReadiness(params);
+      if (readiness.kind === "FINALIZED") {
+        const statusNow = await status(l2TxHash);
+        return { status: statusNow };
+      }
+      if (readiness.kind === "NOT_READY") {
+        throw createError("STATE", {
+          resource: "withdrawals",
+          operation: OP_WITHDRAWALS.finalize.readiness.simulate,
+          message: "Withdrawal not ready to finalize.",
+          context: readiness
+        });
+      }
+      try {
+        const tx = await svc.finalizeDeposit(params);
+        finalizeCache.set(l2TxHash, tx.hash);
+        const rcpt = await tx.wait();
+        const statusNow = await status(l2TxHash);
+        return { status: statusNow, receipt: rcpt };
+      } catch (e) {
+        const statusNow = await status(l2TxHash);
+        if (statusNow.phase === "FINALIZED") return { status: statusNow };
+        try {
+          const again = await svc.simulateFinalizeReadiness(params);
+          if (again.kind === "NOT_READY") {
+            throw createError("STATE", {
+              resource: "withdrawals",
+              operation: OP_WITHDRAWALS.finalize.readiness.simulate,
+              message: "Withdrawal not ready to finalize.",
+              context: again
+            });
+          }
+        } catch {
+        }
+        throw e;
+      }
+    },
+    {
+      message: "Internal error while attempting to finalize withdrawal.",
+      ctx: { l2TxHash, where: "withdrawals.finalize" }
+    }
+  );
+  const tryFinalize = (l2TxHash) => toResult2("withdrawals.tryFinalize", () => finalize(l2TxHash), {
+    message: "Internal error while attempting to tryFinalize withdrawal.",
+    ctx: { l2TxHash, where: "withdrawals.tryFinalize" }
+  });
+  return {
+    quote,
+    tryQuote,
+    prepare,
+    tryPrepare,
+    create,
+    tryCreate,
+    status,
+    wait,
+    finalize,
+    tryFinalize
+  };
+}
+
+// src/adapters/viem/sdk.ts
+function createViemSdk(client) {
+  return {
+    deposits: createDepositsResource(client),
+    withdrawals: createWithdrawalsResource(client),
+    helpers: {
+      addresses: () => client.ensureAddresses(),
+      contracts: () => client.contracts(),
+      async l1AssetRouter() {
+        const { l1AssetRouter } = await client.contracts();
+        return l1AssetRouter;
+      },
+      async l1NativeTokenVault() {
+        const { l1NativeTokenVault } = await client.contracts();
+        return l1NativeTokenVault;
+      },
+      async l1Nullifier() {
+        const { l1Nullifier } = await client.contracts();
+        return l1Nullifier;
+      },
+      async baseToken(chainId) {
+        const id = chainId ?? BigInt(await client.l2.getChainId());
+        return client.baseToken(id);
+      },
+      async l2TokenAddress(l1Token) {
+        if (isAddressEq(l1Token, FORMAL_ETH_ADDRESS)) {
+          return ETH_ADDRESS;
+        }
+        const base = await client.baseToken(BigInt(await client.l2.getChainId()));
+        if (isAddressEq(l1Token, base)) {
+          return L2_BASE_TOKEN_ADDRESS;
+        }
+        const { l2NativeTokenVault } = await client.contracts();
+        const addr = await l2NativeTokenVault.read.l2TokenAddress([l1Token]);
+        return addr;
+      },
+      async l1TokenAddress(l2Token) {
+        if (isAddressEq(l2Token, FORMAL_ETH_ADDRESS)) {
+          return FORMAL_ETH_ADDRESS;
+        }
+        const { l2AssetRouter } = await client.contracts();
+        const addr = await l2AssetRouter.read.l1TokenAddress([l2Token]);
+        return addr;
+      },
+      async assetId(l1Token) {
+        const norm = isAddressEq(l1Token, FORMAL_ETH_ADDRESS) ? ETH_ADDRESS : l1Token;
+        const { l1NativeTokenVault } = await client.contracts();
+        const id = await l1NativeTokenVault.read.assetId([norm]);
+        return id;
+      }
+    }
+  };
+}
+
+export { buildDirectRequestStruct, buildViemFeeOverrides, checkBaseCost, classifyReadinessFromRevert, createDepositsResource, createErrorHandlers, createFinalizationServices, createViemSdk, createWithdrawalsResource, decodeRevert, encodeNTVAssetId, encodeNTVTransferData, encodeNativeTokenVaultAssetId, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getFeeOverrides, getGasPriceWei, getL2FeeOverrides, registerErrorAbi, scaleGasLimit, toZKsyncError };