@matterlabs/zksync-js 0.0.1

package/dist/chunk-CGO27P7F.js

@@ -0,0 +1,2187 @@
+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 { Interface, AbiCoder, ethers, Contract, NonceManager } from 'ethers';
+
+var I_BRIDGEHUB = new Interface([
+  "event NewPriorityRequest(uint256 indexed chainId, address indexed sender, bytes32 txHash, uint256 txId, bytes data)"
+]);
+var TOPIC_BRIDGEHUB_NPR = I_BRIDGEHUB.getEvent("NewPriorityRequest").topicHash;
+function extractL2TxHashFromL1Logs(logs) {
+  for (const lg of logs) {
+    if ((lg.topics?.[0] ?? "").toLowerCase() === TOPIC_BRIDGEHUB_NPR.toLowerCase()) {
+      try {
+        const ev = I_BRIDGEHUB.decodeEventLog("NewPriorityRequest", lg.data, lg.topics);
+        const h = ev.txHash;
+        if (isHash66(h)) return h;
+      } catch {
+      }
+    }
+  }
+  for (const lg of logs) {
+    const t0 = (lg.topics?.[0] ?? "").toLowerCase();
+    if (t0 === TOPIC_CANONICAL_ASSIGNED.toLowerCase()) {
+      const h = lg.topics?.[2];
+      if (isHash66(h)) return h;
+    }
+    if (t0 === TOPIC_CANONICAL_SUCCESS.toLowerCase()) {
+      const h = lg.topics?.[3];
+      if (isHash66(h)) return h;
+    }
+  }
+  return null;
+}
+async function waitForL2ExecutionFromL1Tx(l1, l2, l1TxHash) {
+  const l1Receipt = await l1.waitForTransaction(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 }
+    });
+  }
+  const l2Receipt = await l2.waitForTransaction(l2TxHash);
+  if (!l2Receipt) {
+    const maybe = await l2.getTransactionReceipt(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.waitForTransaction" }
+      });
+    }
+    if (maybe.status !== 1) {
+      throw createError("VERIFICATION", {
+        message: "L2 transaction execution failed",
+        resource: "deposits",
+        operation: "deposits.wait",
+        context: { l1TxHash, l2TxHash, status: maybe.status }
+      });
+    }
+    return { l2Receipt: maybe, l2TxHash };
+  }
+  return { l2Receipt, l2TxHash };
+}
+function supportsGetGasPrice(provider) {
+  return typeof provider === "object" && provider !== null && typeof provider.getGasPrice === "function";
+}
+function encodeNativeTokenVaultAssetId(chainId, address) {
+  const abi = new AbiCoder();
+  const hex = abi.encode(
+    ["uint256", "address", "address"],
+    [chainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, address]
+  );
+  return ethers.keccak256(hex);
+}
+function encodeNativeTokenVaultTransferData(amount, receiver, token) {
+  return new AbiCoder().encode(["uint256", "address", "address"], [amount, receiver, token]);
+}
+function encodeSecondBridgeDataV1(assetId, transferData) {
+  const abi = new AbiCoder();
+  const data = abi.encode(["bytes32", "bytes"], [assetId, transferData]);
+  return ethers.concat(["0x01", data]);
+}
+function encodeNTVAssetId(chainId, address) {
+  const abi = new AbiCoder();
+  const hex = abi.encode(
+    ["uint256", "address", "address"],
+    [chainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, address]
+  );
+  return ethers.keccak256(hex);
+}
+function encodeNTVTransferData(amount, receiver, token) {
+  return new AbiCoder().encode(["uint256", "address", "address"], [amount, receiver, token]);
+}
+function scaleGasLimit(gasLimit) {
+  return gasLimit * BigInt(L1_FEE_ESTIMATION_COEF_NUMERATOR) / BigInt(L1_FEE_ESTIMATION_COEF_DENOMINATOR);
+}
+async function checkBaseCost(baseCost, value) {
+  const resolvedValue = await value;
+  if (baseCost > resolvedValue) {
+    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(resolvedValue)}!`
+    );
+  }
+}
+async function getFeeOverrides(client, overrides) {
+  assertNoLegacyGas(overrides);
+  const fd = await client.l1.getFeeData();
+  const maxFeeFromProvider = fd.maxFeePerGas ?? void 0;
+  const maxPriorityFromProvider = fd.maxPriorityFeePerGas ?? void 0;
+  const gasPriceFallback = fd.gasPrice ?? void 0;
+  const maxFeePerGas = overrides?.maxFeePerGas ?? maxFeeFromProvider ?? gasPriceFallback;
+  if (maxFeePerGas == null) throw new Error("provider returned no gas price data");
+  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? maxPriorityFromProvider ?? maxFeePerGas;
+  assertPriorityFeeBounds({ maxFeePerGas, maxPriorityFeePerGas });
+  const gasPriceForBaseCost = overrides?.maxFeePerGas ?? maxFeeFromProvider ?? gasPriceFallback ?? maxFeePerGas;
+  return {
+    gasLimit: overrides?.gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    gasPriceForBaseCost
+  };
+}
+async function getL2FeeOverrides(client, overrides) {
+  assertNoLegacyGas(overrides);
+  let maxFeeFromProvider;
+  let maxPriorityFromProvider;
+  let gasPriceFallback;
+  try {
+    const fd = await client.l2.getFeeData();
+    if (fd?.maxFeePerGas != null) maxFeeFromProvider = fd.maxFeePerGas;
+    if (fd?.maxPriorityFeePerGas != null) {
+      maxPriorityFromProvider = fd.maxPriorityFeePerGas;
+    }
+    if (fd?.gasPrice != null) gasPriceFallback = fd.gasPrice;
+  } catch {
+  }
+  if (gasPriceFallback == null) {
+    try {
+      if (supportsGetGasPrice(client.l2)) {
+        const gp = await client.l2.getGasPrice();
+        gasPriceFallback = typeof gp === "bigint" ? gp : BigInt(gp.toString());
+      }
+    } catch {
+    }
+  }
+  const maxFeePerGas = overrides?.maxFeePerGas ?? maxFeeFromProvider ?? gasPriceFallback;
+  if (maxFeePerGas == null) {
+    throw new Error("L2 provider returned no gas price data");
+  }
+  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? maxPriorityFromProvider ?? maxFeePerGas;
+  assertPriorityFeeBounds({ maxFeePerGas, maxPriorityFeePerGas });
+  return {
+    gasLimit: overrides?.gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas
+  };
+}
+async function getGasPriceWei(client) {
+  const fd = await client.l1.getFeeData();
+  if (fd.gasPrice != null) return fd.gasPrice;
+  if (fd.maxFeePerGas != null) return fd.maxFeePerGas;
+  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 AbiCoder.defaultAbiCoder().encode(
+    ["address", "uint256", "address"],
+    [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/ethers/resources/deposits/context.ts
+async function commonCtx(p, client) {
+  const { bridgehub, l1AssetRouter } = await client.ensureAddresses();
+  const { chainId } = await client.l2.getNetwork();
+  const sender = await client.signer.getAddress();
+  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_IFACES = [];
+var IFACE_ERROR_STRING = new Interface(["error Error(string)"]);
+var IFACE_PANIC = new Interface(["error Panic(uint256)"]);
+(function bootstrapDefaultIfaces() {
+  try {
+    ERROR_IFACES.push({
+      name: "IL1Nullifier",
+      iface: new Interface(IL1Nullifier_default)
+    });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({ name: "IERC20", iface: new Interface(IERC20_default) });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({
+      name: "IL1NativeTokenVault",
+      iface: new Interface(L1NativeTokenVault_default)
+    });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({
+      name: "IL2NativeTokenVault",
+      iface: new Interface(L2NativeTokenVault_default)
+    });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({ name: "Mailbox", iface: new Interface(Mailbox_default) });
+  } catch {
+  }
+})();
+function registerErrorAbi(name, abi) {
+  const existing = ERROR_IFACES.findIndex((x) => x.name === name);
+  const entry = { name, iface: new Interface(abi) };
+  if (existing >= 0) ERROR_IFACES[existing] = entry;
+  else ERROR_IFACES.push(entry);
+}
+function extractRevertData(e) {
+  const maybe = (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    e?.data?.data ?? e?.error?.data ?? e?.data ?? e?.error?.error?.data ?? e?.info?.error?.data
+  );
+  if (typeof maybe === "string" && maybe.startsWith("0x") && maybe.length >= 10) {
+    return maybe;
+  }
+  return void 0;
+}
+function decodeRevert(e) {
+  const data = extractRevertData(e);
+  if (!data) return;
+  const selector = `0x${data.slice(2, 10)}`;
+  try {
+    const parsed = IFACE_ERROR_STRING.parseError(data);
+    if (parsed?.name === "Error") {
+      const args = parsed.args ? Array.from(parsed.args) : void 0;
+      return { selector, name: "Error", args };
+    }
+  } catch {
+  }
+  try {
+    const parsed = IFACE_PANIC.parseError(data);
+    if (parsed?.name === "Panic") {
+      const args = parsed.args ? Array.from(parsed.args) : void 0;
+      return { selector, name: "Panic", args };
+    }
+  } catch {
+  }
+  for (const { name, iface } of ERROR_IFACES) {
+    try {
+      const parsed = iface.parseError(data);
+      if (parsed) {
+        const args = parsed.args ? Array.from(parsed.args) : void 0;
+        return {
+          selector,
+          name: parsed.name,
+          args,
+          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 maybeMsg = obj["shortMessage"] ?? obj["message"];
+    return typeof maybeMsg === "string" ? maybeMsg : "";
+  })();
+  const lower = String(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/ethers/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/ethers/resources/deposits/routes/eth.ts
+var { wrapAs } = createErrorHandlers("deposits");
+function routeEthDirect() {
+  return {
+    async build(p, ctx) {
+      const bh = new Contract(ctx.bridgehub, IBridgehub_default, ctx.client.l1);
+      const { gasPriceForBaseCost, gasLimit: overrideGasLimit, ...txFeeOverrides } = ctx.fee;
+      const rawBaseCost = await wrapAs(
+        "CONTRACT",
+        OP_DEPOSITS.eth.baseCost,
+        () => bh.l2TransactionBaseCost(
+          ctx.chainIdL2,
+          gasPriceForBaseCost,
+          ctx.l2GasLimit,
+          ctx.gasPerPubdata
+        ),
+        {
+          ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 },
+          message: "Could not fetch L2 base cost from Bridgehub."
+        }
+      );
+      const baseCost = BigInt(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 data = bh.interface.encodeFunctionData("requestL2TransactionDirect", [req]);
+      let resolvedL1GasLimit = overrideGasLimit ?? ctx.l2GasLimit;
+      const tx = {
+        to: ctx.bridgehub,
+        data,
+        value: mintValue,
+        from: ctx.sender,
+        ...txFeeOverrides
+      };
+      if (overrideGasLimit != null) {
+        tx.gasLimit = overrideGasLimit;
+        resolvedL1GasLimit = overrideGasLimit;
+      } else {
+        try {
+          const est = await wrapAs(
+            "RPC",
+            OP_DEPOSITS.eth.estGas,
+            () => ctx.client.l1.estimateGas(tx),
+            {
+              ctx: { where: "l1.estimateGas", to: ctx.bridgehub },
+              message: "Failed to estimate gas for Bridgehub request."
+            }
+          );
+          const buffered = BigInt(est) * 115n / 100n;
+          tx.gasLimit = buffered;
+          resolvedL1GasLimit = buffered;
+        } catch {
+        }
+      }
+      const steps = [
+        {
+          key: "bridgehub:direct",
+          kind: "bridgehub:direct",
+          description: "Bridge ETH via Bridgehub.requestL2TransactionDirect",
+          tx
+        }
+      ];
+      return {
+        steps,
+        approvals: [],
+        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+      };
+    }
+  };
+}
+var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
+var MIN_L2_GAS_FOR_ERC20 = 2500000n;
+function routeErc20NonBase() {
+  return {
+    async preflight() {
+    },
+    async build(p, ctx) {
+      const bh = new Contract(ctx.bridgehub, IBridgehub_default, ctx.client.l1);
+      const assetRouter = ctx.l1AssetRouter;
+      const { gasPriceForBaseCost, gasLimit: overrideGasLimit, ...txFeeOverrides } = ctx.fee;
+      const txOverrides = overrideGasLimit != null ? { ...txFeeOverrides, gasLimit: overrideGasLimit } : txFeeOverrides;
+      let resolvedL1GasLimit = overrideGasLimit ?? ctx.l2GasLimit;
+      const baseToken = await wrapAs2(
+        "CONTRACT",
+        OP_DEPOSITS.nonbase.baseToken ?? "deposits.erc20-nonbase:baseToken",
+        () => bh.baseToken(ctx.chainIdL2),
+        {
+          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
+          message: "Failed to read base token."
+        }
+      );
+      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 } }
+      );
+      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(
+        "RPC",
+        OP_DEPOSITS.nonbase.baseCost,
+        () => bh.l2TransactionBaseCost(
+          ctx.chainIdL2,
+          gasPriceForBaseCost,
+          l2GasLimitUsed,
+          ctx.gasPerPubdata
+        ),
+        {
+          ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 },
+          message: "Could not fetch L2 base cost from Bridgehub."
+        }
+      );
+      const baseCost = BigInt(rawBaseCost);
+      const mintValue = baseCost + ctx.operatorTip;
+      const approvals = [];
+      const steps = [];
+      const l1Signer = ctx.client.getL1Signer();
+      {
+        const erc20Deposit = new Contract(p.token, IERC20_default, l1Signer);
+        const allowanceToken = await wrapAs2(
+          "RPC",
+          OP_DEPOSITS.nonbase.allowanceToken,
+          () => erc20Deposit.allowance(ctx.sender, assetRouter),
+          {
+            ctx: { where: "erc20.allowance", token: p.token, spender: assetRouter },
+            message: "Failed to read deposit-token allowance."
+          }
+        );
+        if (allowanceToken < p.amount) {
+          approvals.push({ token: p.token, spender: assetRouter, amount: p.amount });
+          const data = erc20Deposit.interface.encodeFunctionData("approve", [
+            assetRouter,
+            p.amount
+          ]);
+          steps.push({
+            key: `approve:${p.token}:${assetRouter}`,
+            kind: "approve",
+            description: `Approve ${p.amount} for router (deposit token)`,
+            tx: { to: p.token, data, from: ctx.sender, ...txOverrides }
+          });
+        }
+      }
+      const baseIsEth = isETH(baseToken);
+      if (!baseIsEth) {
+        const erc20Base = new Contract(baseToken, IERC20_default, l1Signer);
+        const allowanceBase = await wrapAs2(
+          "RPC",
+          OP_DEPOSITS.nonbase.allowanceBase,
+          () => erc20Base.allowance(ctx.sender, assetRouter),
+          {
+            ctx: { where: "erc20.allowance", token: baseToken, spender: assetRouter },
+            message: "Failed to read base-token allowance."
+          }
+        );
+        if (allowanceBase < mintValue) {
+          approvals.push({ token: baseToken, spender: assetRouter, amount: mintValue });
+          const data = erc20Base.interface.encodeFunctionData("approve", [assetRouter, mintValue]);
+          steps.push({
+            key: `approve:${baseToken}:${assetRouter}`,
+            kind: "approve",
+            description: `Approve base token for mintValue`,
+            tx: { to: baseToken, data, from: ctx.sender, ...txOverrides }
+          });
+        }
+      }
+      const secondBridgeCalldata = await wrapAs2(
+        "INTERNAL",
+        OP_DEPOSITS.nonbase.encodeCalldata,
+        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, p.to ?? ctx.sender)),
+        {
+          ctx: { where: "encodeSecondBridgeErc20Args" },
+          message: "Failed to encode bridging calldata."
+        }
+      );
+      const outer = {
+        chainId: ctx.chainIdL2,
+        mintValue,
+        // fees (in ETH if base=ETH, else pulled as base ERC-20)
+        l2Value: 0n,
+        l2GasLimit: l2GasLimitUsed,
+        l2GasPerPubdataByteLimit: ctx.gasPerPubdata,
+        refundRecipient: ctx.refundRecipient,
+        secondBridgeAddress: assetRouter,
+        secondBridgeValue: 0n,
+        secondBridgeCalldata
+      };
+      const dataTwo = bh.interface.encodeFunctionData("requestL2TransactionTwoBridges", [outer]);
+      const bridgeTx = {
+        to: ctx.bridgehub,
+        data: dataTwo,
+        value: baseIsEth ? mintValue : 0n,
+        from: ctx.sender,
+        ...txOverrides
+      };
+      if (overrideGasLimit != null) {
+        bridgeTx.gasLimit = overrideGasLimit;
+        resolvedL1GasLimit = overrideGasLimit;
+      } else {
+        try {
+          const est = await wrapAs2(
+            "RPC",
+            OP_DEPOSITS.nonbase.estGas,
+            () => ctx.client.l1.estimateGas(bridgeTx),
+            {
+              ctx: { where: "l1.estimateGas", to: ctx.bridgehub, baseIsEth },
+              message: "Failed to estimate gas for Bridgehub request."
+            }
+          );
+          const buffered = BigInt(est) * 125n / 100n;
+          bridgeTx.gasLimit = buffered;
+          resolvedL1GasLimit = buffered;
+        } catch {
+        }
+      }
+      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, baseToken, baseIsEth, l1GasLimit: resolvedL1GasLimit }
+      };
+    }
+  };
+}
+var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
+var BASE_COST_BUFFER_BPS = 100n;
+var BPS = 10000n;
+var withBuffer = (x) => x * (BPS + BASE_COST_BUFFER_BPS) / BPS;
+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 bh = new Contract(ctx.bridgehub, IBridgehub_default, ctx.client.l1);
+      const baseToken = await wrapAs3(
+        "CONTRACT",
+        OP_DEPOSITS.ethNonBase.baseToken,
+        () => bh.baseToken(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(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 bh = new Contract(ctx.bridgehub, IBridgehub_default, ctx.client.l1);
+      const { gasPriceForBaseCost, gasLimit: overrideGasLimit, ...txFeeOverrides } = ctx.fee;
+      const txOverrides = overrideGasLimit != null ? { ...txFeeOverrides, gasLimit: overrideGasLimit } : txFeeOverrides;
+      const baseToken = await wrapAs3(
+        "CONTRACT",
+        OP_DEPOSITS.ethNonBase.baseToken,
+        () => bh.baseToken(ctx.chainIdL2),
+        {
+          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
+          message: "Failed to read base token."
+        }
+      );
+      const rawBaseCost = await wrapAs3(
+        "RPC",
+        OP_DEPOSITS.ethNonBase.baseCost,
+        () => bh.l2TransactionBaseCost(
+          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 = withBuffer(mintValueRaw);
+      const approvals = [];
+      const steps = [];
+      {
+        const erc20 = new Contract(baseToken, IERC20_default, ctx.client.getL1Signer());
+        const allowance = await wrapAs3(
+          "RPC",
+          OP_DEPOSITS.ethNonBase.allowanceBase,
+          () => erc20.allowance(ctx.sender, ctx.l1AssetRouter),
+          {
+            ctx: { where: "erc20.allowance", token: baseToken, spender: ctx.l1AssetRouter },
+            message: "Failed to read base-token allowance."
+          }
+        );
+        if (allowance < mintValue) {
+          approvals.push({ token: baseToken, spender: ctx.l1AssetRouter, amount: mintValue });
+          const data = erc20.interface.encodeFunctionData("approve", [
+            ctx.l1AssetRouter,
+            mintValue
+          ]);
+          steps.push({
+            key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
+            kind: "approve",
+            description: `Approve base token for mintValue`,
+            tx: { to: baseToken, data, from: ctx.sender, ...txOverrides }
+          });
+        }
+      }
+      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
+          }
+        }
+      );
+      const outer = {
+        chainId: ctx.chainIdL2,
+        mintValue,
+        l2Value: 0n,
+        l2GasLimit: ctx.l2GasLimit,
+        l2GasPerPubdataByteLimit: ctx.gasPerPubdata,
+        refundRecipient: ctx.refundRecipient,
+        secondBridgeAddress: ctx.l1AssetRouter,
+        secondBridgeValue: p.amount,
+        secondBridgeCalldata
+      };
+      const dataTwo = new Contract(
+        ctx.bridgehub,
+        IBridgehub_default,
+        ctx.client.l1
+      ).interface.encodeFunctionData("requestL2TransactionTwoBridges", [outer]);
+      let resolvedL1GasLimit = overrideGasLimit ?? ctx.l2GasLimit;
+      const bridgeTx = {
+        to: ctx.bridgehub,
+        data: dataTwo,
+        value: p.amount,
+        // base ≠ ETH ⇒ msg.value == secondBridgeValue
+        from: ctx.sender,
+        ...txOverrides
+      };
+      if (overrideGasLimit != null) {
+        bridgeTx.gasLimit = overrideGasLimit;
+        resolvedL1GasLimit = overrideGasLimit;
+      } else {
+        try {
+          const est = await wrapAs3(
+            "RPC",
+            OP_DEPOSITS.ethNonBase.estGas,
+            () => ctx.client.l1.estimateGas(bridgeTx),
+            {
+              ctx: { where: "l1.estimateGas", to: ctx.bridgehub },
+              message: "Failed to estimate gas for Bridgehub request."
+            }
+          );
+          const buffered = BigInt(est) * 115n / 100n;
+          bridgeTx.gasLimit = buffered;
+          resolvedL1GasLimit = buffered;
+        } catch {
+        }
+      }
+      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 }
+      };
+    }
+  };
+}
+var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
+var BASE_COST_BUFFER_BPS2 = 100n;
+var BPS2 = 10000n;
+var withBuffer2 = (x) => x * (BPS2 + BASE_COST_BUFFER_BPS2) / BPS2;
+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 bh = new Contract(ctx.bridgehub, IBridgehub_default, ctx.client.l1);
+      const baseToken = await wrapAs4(
+        "CONTRACT",
+        OP_DEPOSITS.base.baseToken,
+        () => bh.baseToken(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 bh = new Contract(ctx.bridgehub, IBridgehub_default, ctx.client.l1);
+      const { gasPriceForBaseCost, gasLimit: overrideGasLimit, ...txFeeOverrides } = ctx.fee;
+      const txOverrides = overrideGasLimit != null ? { ...txFeeOverrides, gasLimit: overrideGasLimit } : txFeeOverrides;
+      let resolvedL1GasLimit = overrideGasLimit ?? ctx.l2GasLimit;
+      const baseToken = await wrapAs4(
+        "CONTRACT",
+        OP_DEPOSITS.base.baseToken,
+        () => bh.baseToken(ctx.chainIdL2),
+        {
+          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
+          message: "Failed to read base token."
+        }
+      );
+      const rawBaseCost = await wrapAs4(
+        "RPC",
+        OP_DEPOSITS.base.baseCost,
+        () => bh.l2TransactionBaseCost(
+          ctx.chainIdL2,
+          gasPriceForBaseCost,
+          ctx.l2GasLimit,
+          ctx.gasPerPubdata
+        ),
+        {
+          ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 },
+          message: "Could not fetch L2 base cost from Bridgehub."
+        }
+      );
+      const baseCost = BigInt(rawBaseCost);
+      const l2Value = p.amount;
+      const rawMintValue = baseCost + ctx.operatorTip + l2Value;
+      const mintValue = withBuffer2(rawMintValue);
+      const approvals = [];
+      const steps = [];
+      {
+        const erc20 = new Contract(baseToken, IERC20_default, ctx.client.getL1Signer());
+        const allowance = await wrapAs4(
+          "RPC",
+          OP_DEPOSITS.base.allowance,
+          () => erc20.allowance(ctx.sender, ctx.l1AssetRouter),
+          {
+            ctx: { where: "erc20.allowance", token: baseToken, spender: ctx.l1AssetRouter },
+            message: "Failed to read base-token allowance."
+          }
+        );
+        if (allowance < mintValue) {
+          approvals.push({ token: baseToken, spender: ctx.l1AssetRouter, amount: mintValue });
+          const data2 = erc20.interface.encodeFunctionData("approve", [
+            ctx.l1AssetRouter,
+            mintValue
+          ]);
+          steps.push({
+            key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
+            kind: "approve",
+            description: "Approve base token for mintValue",
+            tx: { to: baseToken, data: data2, from: ctx.sender, ...txOverrides }
+          });
+        }
+      }
+      const req = buildDirectRequestStruct({
+        chainId: ctx.chainIdL2,
+        mintValue,
+        l2GasLimit: ctx.l2GasLimit,
+        gasPerPubdata: ctx.gasPerPubdata,
+        refundRecipient: ctx.refundRecipient,
+        l2Contract: p.to ?? ctx.sender,
+        l2Value
+      });
+      const data = new Contract(
+        ctx.bridgehub,
+        IBridgehub_default,
+        ctx.client.l1
+      ).interface.encodeFunctionData("requestL2TransactionDirect", [req]);
+      const tx = {
+        to: ctx.bridgehub,
+        data,
+        value: 0n,
+        // base token is ERC-20 ⇒ msg.value MUST be 0
+        from: ctx.sender,
+        ...txOverrides
+      };
+      if (overrideGasLimit != null) {
+        tx.gasLimit = overrideGasLimit;
+        resolvedL1GasLimit = overrideGasLimit;
+      } else {
+        try {
+          const est = await wrapAs4(
+            "RPC",
+            OP_DEPOSITS.base.estGas,
+            () => ctx.client.l1.estimateGas(tx),
+            {
+              ctx: { where: "l1.estimateGas", to: ctx.bridgehub },
+              message: "Failed to estimate gas for Bridgehub request."
+            }
+          );
+          const buffered = BigInt(est) * 115n / 100n;
+          tx.gasLimit = buffered;
+          resolvedL1GasLimit = buffered;
+        } catch {
+        }
+      }
+      steps.push({
+        key: "bridgehub:direct:erc20-base",
+        kind: "bridgehub:direct",
+        description: "Bridge base ERC-20 via Bridgehub.requestL2TransactionDirect",
+        tx
+      });
+      return {
+        steps,
+        approvals,
+        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+      };
+    }
+  };
+}
+
+// src/adapters/ethers/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.gasLimit;
+        if (candidate == null) continue;
+        if (typeof candidate === "bigint") return candidate;
+        try {
+          return BigInt(candidate.toString());
+        } catch {
+        }
+      }
+      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 managed = new NonceManager(client.signer);
+      const from = await managed.getAddress();
+      let next = await client.l1.getTransactionCount(from, "latest");
+      for (const step of plan.steps) {
+        if (step.kind === "approve") {
+          try {
+            const [, token, router] = step.key.split(":");
+            const erc20 = new Contract(token, IERC20_default, client.signer);
+            const target = plan.summary.approvalsNeeded.find(
+              (need) => need.token.toLowerCase() === (token ?? "").toLowerCase() && need.spender.toLowerCase() === (router ?? "").toLowerCase()
+            )?.amount ?? 0n;
+            const current = await erc20.allowance(from, router);
+            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
+            );
+          }
+        }
+        step.tx.nonce = next++;
+        if (p.l1TxOverrides) {
+          const overrides = p.l1TxOverrides;
+          if (overrides.gasLimit != null) step.tx.gasLimit = overrides.gasLimit;
+          if (overrides.maxFeePerGas != null) step.tx.maxFeePerGas = overrides.maxFeePerGas;
+          if (overrides.maxPriorityFeePerGas != null) {
+            step.tx.maxPriorityFeePerGas = overrides.maxPriorityFeePerGas;
+          }
+        }
+        if (!step.tx.gasLimit) {
+          try {
+            const est = await client.l1.estimateGas(step.tx);
+            step.tx.gasLimit = BigInt(est) * 115n / 100n;
+          } catch {
+          }
+        }
+        let hash;
+        try {
+          const sent = await managed.sendTransaction(step.tx);
+          hash = sent.hash;
+          stepHashes[step.key] = hash;
+          const rcpt = await sent.wait();
+          if (rcpt?.status === 0) {
+            throw createError("EXECUTION", {
+              resource: "deposits",
+              operation: "deposits.create.sendTransaction",
+              message: "Deposit transaction reverted on L1 during a step.",
+              context: { step: step.key, txHash: hash }
+            });
+          }
+        } catch (e) {
+          if (isZKsyncError(e)) throw e;
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "deposits",
+              operation: "deposits.create.sendTransaction",
+              context: { step: step.key, txHash: hash, nonce: Number(step.tx.nonce ?? -1) },
+              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(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(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 === 1;
+      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.waitForTransaction(l1Hash);
+      } catch (e) {
+        throw toZKsyncError(
+          "RPC",
+          {
+            resource: "deposits",
+            operation: "deposits.waitForTransaction",
+            context: { where: "l1.waitForTransaction", 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 };
+}
+async function ntvBaseAssetId(l2, ntv) {
+  const c = new Contract(ntv, L2NativeTokenVault_default, l2);
+  return await c.BASE_TOKEN_ASSET_ID();
+}
+async function ntvL1ChainId(l2, ntv) {
+  const c = new Contract(ntv, L2NativeTokenVault_default, l2);
+  return await c.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/ethers/resources/withdrawals/context.ts
+async function commonCtx2(p, client) {
+  const sender = await client.signer.getAddress();
+  const {
+    bridgehub,
+    l1AssetRouter,
+    l1Nullifier,
+    l2AssetRouter,
+    l2NativeTokenVault,
+    l2BaseTokenSystem
+  } = await client.ensureAddresses();
+  const { chainId } = await client.l2.getNetwork();
+  const chainIdL2 = BigInt(chainId);
+  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
+  };
+}
+var { wrapAs: wrapAs5 } = createErrorHandlers("withdrawals");
+function routeEthBase() {
+  return {
+    async build(p, ctx) {
+      const steps = [];
+      const { gasLimit: overrideGasLimit, maxFeePerGas, maxPriorityFeePerGas } = ctx.fee;
+      const base = new Contract(
+        L2_BASE_TOKEN_ADDRESS,
+        new Interface(IBaseToken_default),
+        ctx.client.l2
+      );
+      const toL1 = p.to ?? ctx.sender;
+      const data = await wrapAs5(
+        "INTERNAL",
+        OP_WITHDRAWALS.eth.encodeWithdraw,
+        () => Promise.resolve(base.interface.encodeFunctionData("withdraw", [toL1])),
+        {
+          ctx: { where: "L2BaseToken.withdraw", to: toL1 },
+          message: "Failed to encode ETH withdraw calldata."
+        }
+      );
+      const tx = {
+        to: L2_BASE_TOKEN_ADDRESS,
+        data,
+        from: ctx.sender,
+        value: p.amount,
+        maxFeePerGas,
+        maxPriorityFeePerGas
+      };
+      if (overrideGasLimit != null) {
+        tx.gasLimit = overrideGasLimit;
+      } else {
+        try {
+          const est = await wrapAs5(
+            "RPC",
+            OP_WITHDRAWALS.eth.estGas,
+            () => ctx.client.l2.estimateGas(tx),
+            {
+              ctx: { where: "l2.estimateGas", to: L2_BASE_TOKEN_ADDRESS },
+              message: "Failed to estimate gas for L2 ETH withdraw."
+            }
+          );
+          tx.gasLimit = BigInt(est) * 115n / 100n;
+        } catch {
+        }
+      }
+      steps.push({
+        key: "l2-base-token:withdraw",
+        kind: "l2-base-token:withdraw",
+        description: "Withdraw ETH via L2 Base Token System",
+        tx
+      });
+      return { steps, approvals: [], quoteExtras: {} };
+    }
+  };
+}
+var { wrapAs: wrapAs6 } = createErrorHandlers("withdrawals");
+var SIG = {
+  withdraw: "withdraw(bytes32,bytes)"
+};
+function routeErc20NonBase2() {
+  return {
+    async build(p, ctx) {
+      const steps = [];
+      const approvals = [];
+      const { gasLimit: overrideGasLimit, maxFeePerGas, maxPriorityFeePerGas } = ctx.fee;
+      const txOverrides = overrideGasLimit != null ? { maxFeePerGas, maxPriorityFeePerGas, gasLimit: overrideGasLimit } : { maxFeePerGas, maxPriorityFeePerGas };
+      const erc20 = new Contract(p.token, IERC20_default, ctx.client.getL2Signer());
+      const current = await wrapAs6(
+        "CONTRACT",
+        OP_WITHDRAWALS.erc20.allowance,
+        () => erc20.allowance(ctx.sender, ctx.l2NativeTokenVault),
+        {
+          ctx: {
+            where: "erc20.allowance",
+            chain: "L2",
+            token: p.token,
+            spender: ctx.l2NativeTokenVault
+          },
+          message: "Failed to read L2 ERC-20 allowance."
+        }
+      );
+      if (current < p.amount) {
+        approvals.push({ token: p.token, spender: ctx.l2NativeTokenVault, amount: p.amount });
+        const data = erc20.interface.encodeFunctionData("approve", [
+          ctx.l2NativeTokenVault,
+          p.amount
+        ]);
+        steps.push({
+          key: `approve:l2:${p.token}:${ctx.l2NativeTokenVault}`,
+          kind: "approve:l2",
+          description: `Approve ${p.amount} to NativeTokenVault`,
+          tx: { to: p.token, data, from: ctx.sender, ...txOverrides }
+        });
+      }
+      const ntv = new Contract(ctx.l2NativeTokenVault, L2NativeTokenVault_default, ctx.client.l2);
+      const assetId = await wrapAs6(
+        "CONTRACT",
+        OP_WITHDRAWALS.erc20.ensureRegistered,
+        () => ntv.getFunction("ensureTokenIsRegistered").staticCall(p.token),
+        {
+          ctx: { where: "L2NativeTokenVault.ensureTokenIsRegistered", token: p.token },
+          message: "Failed to ensure token is registered in L2NativeTokenVault."
+        }
+      );
+      const assetData = await wrapAs6(
+        "INTERNAL",
+        OP_WITHDRAWALS.erc20.encodeAssetData,
+        () => Promise.resolve(
+          AbiCoder.defaultAbiCoder().encode(
+            ["uint256", "address", "address"],
+            [p.amount, p.to ?? ctx.sender, p.token]
+          )
+        ),
+        {
+          ctx: { where: "AbiCoder.encode", token: p.token, to: p.to ?? ctx.sender },
+          message: "Failed to encode burn/withdraw asset data."
+        }
+      );
+      const l2ar = new Contract(ctx.l2AssetRouter, IL2AssetRouter_default, ctx.client.l2);
+      const dataWithdraw = await wrapAs6(
+        "INTERNAL",
+        OP_WITHDRAWALS.erc20.encodeWithdraw,
+        () => Promise.resolve(l2ar.interface.encodeFunctionData(SIG.withdraw, [assetId, assetData])),
+        {
+          ctx: { where: "L2AssetRouter.withdraw", assetId },
+          message: "Failed to encode withdraw calldata."
+        }
+      );
+      const withdrawTx = {
+        to: ctx.l2AssetRouter,
+        data: dataWithdraw,
+        from: ctx.sender,
+        ...txOverrides
+      };
+      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: {} };
+    }
+  };
+}
+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 steps = [];
+      const { gasLimit: overrideGasLimit, maxFeePerGas, maxPriorityFeePerGas } = ctx.fee;
+      const toL1 = p.to ?? ctx.sender;
+      const iface = new Interface(IBaseToken_default);
+      const data = await wrapAs7(
+        "INTERNAL",
+        OP_WITHDRAWALS.eth.encodeWithdraw,
+        // reuse label for base-token system call
+        () => Promise.resolve(iface.encodeFunctionData("withdraw", [toL1])),
+        { ctx: { where: "L2BaseToken.withdraw", to: toL1 } }
+      );
+      const tx = {
+        to: L2_BASE_TOKEN_ADDRESS,
+        data,
+        from: ctx.sender,
+        value: p.amount,
+        maxFeePerGas,
+        maxPriorityFeePerGas
+      };
+      if (overrideGasLimit != null) {
+        tx.gasLimit = overrideGasLimit;
+      } else {
+        try {
+          const est = await wrapAs7(
+            "RPC",
+            OP_WITHDRAWALS.eth.estGas,
+            () => ctx.client.l2.estimateGas(tx),
+            {
+              ctx: { where: "l2.estimateGas", to: L2_BASE_TOKEN_ADDRESS },
+              message: "Failed to estimate gas for L2 base-token withdraw."
+            }
+          );
+          tx.gasLimit = BigInt(est) * 115n / 100n;
+        } catch {
+        }
+      }
+      steps.push({
+        key: "l2-base-token:withdraw",
+        kind: "l2-base-token:withdraw",
+        description: "Withdraw base token via L2 Base Token System (base \u2260 ETH)",
+        tx
+      });
+      return { steps, approvals: [], quoteExtras: {} };
+    }
+  };
+}
+var { wrapAs: wrapAs8 } = createErrorHandlers("withdrawals");
+var IL1NullifierMini = [
+  "function isWithdrawalFinalized(uint256,uint256,uint256) view returns (bool)"
+];
+function createFinalizationServices(client) {
+  const { l1, l2, signer } = 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,
+        () => Promise.resolve(AbiCoder.defaultAbiCoder().decode(["bytes"], ev.data)[0]),
+        {
+          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,
+        () => l2.getNetwork(),
+        {
+          ctx: { where: "l2.getNetwork" },
+          message: "Failed to read L2 network."
+        }
+      );
+      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 cMini = new Contract(l1Nullifier, IL1NullifierMini, l1);
+          const isFinalized = await wrapAs8(
+            "RPC",
+            OP_WITHDRAWALS.finalize.readiness.isFinalized,
+            () => cMini.isWithdrawalFinalized(
+              params.chainId,
+              params.l2BatchNumber,
+              params.l2MessageIndex
+            ),
+            {
+              ctx: { where: "isWithdrawalFinalized", params },
+              message: "Failed to read finalization status."
+            }
+          );
+          return Boolean(isFinalized);
+        } catch {
+          return false;
+        }
+      })();
+      if (done) return { kind: "FINALIZED" };
+      const c = new Contract(l1Nullifier, IL1Nullifier_default, l1);
+      try {
+        await c.finalizeDeposit.staticCall(params);
+        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."
+        }
+      );
+      const c = new Contract(l1Nullifier, IL1NullifierMini, l1);
+      return await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.isFinalized,
+        () => c.isWithdrawalFinalized(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 signer2 = client.getL1Signer();
+      const c = new Contract(l1Nullifier, IL1Nullifier_default, signer2);
+      const gasLimit = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.estimate,
+        () => c.finalizeDeposit.estimateGas(params),
+        {
+          ctx: {
+            where: "estimateGas(finalizeDeposit)",
+            chainIdL2: params.chainId,
+            l2BatchNumber: params.l2BatchNumber,
+            l2MessageIndex: params.l2MessageIndex,
+            l1Nullifier
+          },
+          message: "Failed to estimate gas for finalizeDeposit."
+        }
+      );
+      const feeData = await wrapAs8("RPC", OP_WITHDRAWALS.finalize.estimate, () => l1.getFeeData(), {
+        ctx: { where: "l1.getFeeData" },
+        message: "Failed to estimate fee data for finalizeDeposit."
+      });
+      const maxFeePerGas = feeData.maxFeePerGas ?? feeData.gasPrice ?? // legacy-style gas price if present
+      (() => {
+        throw createError("RPC", {
+          resource: "withdrawals",
+          operation: OP_WITHDRAWALS.finalize.estimate,
+          message: "Provider did not return gas price or EIP-1559 fields.",
+          context: { feeData }
+        });
+      })();
+      const maxPriorityFeePerGas = feeData.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."
+        }
+      );
+      const c = new Contract(l1Nullifier, IL1Nullifier_default, signer);
+      try {
+        const receipt = await c.finalizeDeposit(params);
+        const hash = receipt.hash;
+        return {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          hash,
+          wait: async () => {
+            try {
+              return await receipt.wait();
+            } 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/ethers/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.gasLimit;
+        if (candidate == null) continue;
+        if (typeof candidate === "bigint") return candidate;
+        try {
+          return BigInt(candidate.toString());
+        } catch {
+        }
+      }
+      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 () => {
+      const plan = await buildPlan(p);
+      return plan.summary;
+    },
+    {
+      message: "Internal error while preparing a withdrawal quote.",
+      ctx: { token: p.token, where: "withdrawals.quote" }
+    }
+  );
+  const tryQuote = (p) => toResult2(
+    OP_WITHDRAWALS.tryQuote,
+    async () => {
+      const plan = await buildPlan(p);
+      return plan.summary;
+    },
+    {
+      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, () => buildPlan(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 managed = new NonceManager(client.getL2Signer());
+      const from = await managed.getAddress();
+      let next = await client.l2.getTransactionCount(from, "pending");
+      for (const step of plan.steps) {
+        step.tx.nonce = next++;
+        if (p.l2TxOverrides) {
+          const overrides = p.l2TxOverrides;
+          if (overrides.gasLimit != null) step.tx.gasLimit = overrides.gasLimit;
+          if (overrides.maxFeePerGas != null) step.tx.maxFeePerGas = overrides.maxFeePerGas;
+          if (overrides.maxPriorityFeePerGas != null) {
+            step.tx.maxPriorityFeePerGas = overrides.maxPriorityFeePerGas;
+          }
+        }
+        if (!step.tx.gasLimit) {
+          try {
+            const est = await client.l2.estimateGas(step.tx);
+            step.tx.gasLimit = BigInt(est) * 115n / 100n;
+          } catch {
+          }
+        }
+        let hash;
+        try {
+          const sent = await managed.sendTransaction(step.tx);
+          hash = sent.hash;
+          stepHashes[step.key] = hash;
+          const rcpt = await sent.wait();
+          if (rcpt?.status === 0) {
+            throw createError("EXECUTION", {
+              resource: "withdrawals",
+              operation: "withdrawals.create.sendTransaction",
+              message: "Withdrawal transaction reverted on L2 during a step.",
+              context: { step: step.key, txHash: hash, nonce: Number(step.tx.nonce ?? -1) }
+            });
+          }
+        } catch (e) {
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "withdrawals",
+              operation: "withdrawals.create.sendTransaction",
+              message: "Failed to send or confirm a withdrawal transaction step.",
+              context: { step: step.key, txHash: hash, nonce: Number(step.tx.nonce ?? -1) }
+            },
+            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(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.waitForTransaction(l2Hash);
+        } catch (e) {
+          throw toZKsyncError(
+            "RPC",
+            {
+              resource: "withdrawals",
+              operation: "withdrawals.wait.l2.waitForTransaction",
+              message: "Failed while waiting for L2 transaction.",
+              context: { l2TxHash: l2Hash }
+            },
+            e
+          );
+        }
+        if (!rcpt) return null;
+        try {
+          const raw = await client.zks.getReceiptWithL2ToL1(l2Hash);
+          rcpt.l2ToL1Logs = raw?.l2ToL1Logs ?? [];
+        } catch {
+          rcpt.l2ToL1Logs = rcpt.l2ToL1Logs ?? [];
+        }
+        return rcpt;
+      }
+      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(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/ethers/sdk.ts
+function createEthersSdk(client) {
+  return {
+    deposits: createDepositsResource(client),
+    withdrawals: createWithdrawalsResource(client),
+    // TODO: might update to create dedicated resources for these
+    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.getNetwork()).chainId);
+        return client.baseToken(id);
+      },
+      async l2TokenAddress(l1Token) {
+        if (isAddressEq(l1Token, FORMAL_ETH_ADDRESS)) {
+          return ETH_ADDRESS;
+        }
+        const { chainId } = await client.l2.getNetwork();
+        const base = await client.baseToken(BigInt(chainId));
+        if (isAddressEq(l1Token, base)) {
+          return L2_BASE_TOKEN_ADDRESS;
+        }
+        const { l2NativeTokenVault } = await client.contracts();
+        const addr = await l2NativeTokenVault.l2TokenAddress(l1Token);
+        return addr;
+      },
+      async l1TokenAddress(l2Token) {
+        if (isAddressEq(l2Token, ETH_ADDRESS)) {
+          return ETH_ADDRESS;
+        }
+        const { l2AssetRouter } = await client.contracts();
+        const addr = await l2AssetRouter.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.assetId(norm);
+        return id;
+      }
+    }
+  };
+}
+
+export { buildDirectRequestStruct, checkBaseCost, classifyReadinessFromRevert, createDepositsResource, createErrorHandlers, createEthersSdk, createFinalizationServices, createWithdrawalsResource, decodeRevert, encodeNTVAssetId, encodeNTVTransferData, encodeNativeTokenVaultAssetId, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getFeeOverrides, getGasPriceWei, getL2FeeOverrides, registerErrorAbi, scaleGasLimit, toZKsyncError };