@matterlabs/zksync-js 0.0.1 → 0.0.3

package/dist/chunk-LL3WKCFJ.js

@@ -0,0 +1,231 @@
+import { IBridgehub_default } from './chunk-M5J2MM2U.js';
+import { BUFFER, DEFAULT_ABI_BYTES, DEFAULT_PUBDATA_BYTES, TX_MEMORY_OVERHEAD_GAS, TX_OVERHEAD_GAS } from './chunk-F2ENUV3A.js';
+
+// src/core/codec/ntv.ts
+function createNTVCodec(deps) {
+  function encodeAssetId(originChainId, ntvAddress, tokenAddress) {
+    const encoded = deps.encode(
+      ["uint256", "address", "address"],
+      [originChainId, ntvAddress, tokenAddress]
+    );
+    return deps.keccak256(encoded);
+  }
+  return {
+    encodeAssetId
+  };
+}
+
+// src/core/resources/deposits/fee.ts
+function buildFeeBreakdown(p) {
+  const l1MaxTotal = p.l1Gas?.maxCost ?? 0n;
+  const l2Total = p.l2BaseCost + p.operatorTip;
+  const l1 = {
+    gasLimit: p.l1Gas?.gasLimit ?? 0n,
+    maxFeePerGas: p.l1Gas?.maxFeePerGas ?? 0n,
+    maxPriorityFeePerGas: p.l1Gas?.maxPriorityFeePerGas,
+    maxTotal: l1MaxTotal
+  };
+  const l2 = {
+    total: l2Total,
+    baseCost: p.l2BaseCost,
+    operatorTip: p.operatorTip,
+    gasLimit: p.l2Gas?.gasLimit ?? 0n,
+    maxFeePerGas: p.l2Gas?.maxFeePerGas ?? 0n,
+    maxPriorityFeePerGas: p.l2Gas?.maxPriorityFeePerGas,
+    gasPerPubdata: p.l2Gas?.gasPerPubdata ?? 0n
+  };
+  return {
+    token: p.feeToken,
+    maxTotal: l1MaxTotal + l2Total,
+    mintValue: p.mintValue,
+    l1,
+    l2
+  };
+}
+
+// src/core/resources/deposits/gas.ts
+function makeGasQuote(p) {
+  const maxPriorityFeePerGas = p.maxPriorityFeePerGas ?? 0n;
+  return {
+    gasLimit: p.gasLimit,
+    maxFeePerGas: p.maxFeePerGas,
+    maxPriorityFeePerGas,
+    gasPerPubdata: p.gasPerPubdata,
+    maxCost: p.gasLimit * p.maxFeePerGas
+  };
+}
+async function fetchFees(estimator) {
+  try {
+    const fees = await estimator.estimateFeesPerGas();
+    if (fees.maxFeePerGas != null) {
+      return {
+        maxFeePerGas: fees.maxFeePerGas,
+        maxPriorityFeePerGas: fees.maxPriorityFeePerGas ?? 0n
+      };
+    }
+    if (fees.gasPrice != null) {
+      return {
+        maxFeePerGas: fees.gasPrice,
+        maxPriorityFeePerGas: 0n
+      };
+    }
+  } catch {
+  }
+  try {
+    const gp = await estimator.getGasPrice();
+    return { maxFeePerGas: gp, maxPriorityFeePerGas: 0n };
+  } catch {
+    return { maxFeePerGas: 0n, maxPriorityFeePerGas: 0n };
+  }
+}
+async function quoteL1Gas(input) {
+  const { estimator, tx, overrides, fallbackGasLimit } = input;
+  let market;
+  const getMarket = async () => {
+    if (market) return market;
+    market = await fetchFees(estimator);
+    return market;
+  };
+  const maxFeePerGas = overrides?.maxFeePerGas ?? (tx.maxFeePerGas != null ? BigInt(tx.maxFeePerGas) : (await getMarket()).maxFeePerGas);
+  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? (tx.maxPriorityFeePerGas != null ? BigInt(tx.maxPriorityFeePerGas) : (await getMarket()).maxPriorityFeePerGas);
+  const explicitGasLimit = overrides?.gasLimit ?? (tx.gasLimit != null ? BigInt(tx.gasLimit) : void 0);
+  if (explicitGasLimit != null) {
+    return makeGasQuote({ gasLimit: explicitGasLimit, maxFeePerGas, maxPriorityFeePerGas });
+  }
+  try {
+    const est = await estimator.estimateGas(tx);
+    const buffered = BigInt(est) * (100n + BUFFER) / 100n;
+    return makeGasQuote({ gasLimit: buffered, maxFeePerGas, maxPriorityFeePerGas });
+  } catch (err) {
+    if (fallbackGasLimit != null) {
+      return makeGasQuote({ gasLimit: fallbackGasLimit, maxFeePerGas, maxPriorityFeePerGas });
+    }
+    console.warn("L1 gas estimation failed", err);
+    return void 0;
+  }
+}
+async function quoteL2Gas(input) {
+  const { estimator, route, tx, gasPerPubdata, l2GasLimit, overrideGasLimit, stateOverrides } = input;
+  const market = await fetchFees(estimator);
+  const maxFeePerGas = market.maxFeePerGas || market.maxPriorityFeePerGas || 0n;
+  const txGasLimit = tx?.gasLimit != null ? BigInt(tx.gasLimit) : void 0;
+  const explicit = overrideGasLimit ?? txGasLimit;
+  if (explicit != null) {
+    return makeGasQuote({
+      gasLimit: explicit,
+      maxFeePerGas,
+      gasPerPubdata
+    });
+  }
+  if (!tx) {
+    return makeGasQuote({
+      gasLimit: l2GasLimit ?? 0n,
+      maxFeePerGas,
+      gasPerPubdata
+    });
+  }
+  try {
+    const execEstimate = await estimator.estimateGas(tx, stateOverrides);
+    const memoryBytes = route === "erc20-nonbase" ? 500n : DEFAULT_ABI_BYTES;
+    const pubdataBytes = route === "erc20-nonbase" ? 200n : DEFAULT_PUBDATA_BYTES;
+    const pp = gasPerPubdata ?? 800n;
+    const memoryOverhead = memoryBytes * TX_MEMORY_OVERHEAD_GAS;
+    const pubdataOverhead = pubdataBytes * pp;
+    let total = BigInt(execEstimate) + TX_OVERHEAD_GAS + memoryOverhead + pubdataOverhead;
+    total = total * (100n + BUFFER) / 100n;
+    return makeGasQuote({
+      gasLimit: total,
+      maxFeePerGas,
+      gasPerPubdata: pp
+    });
+  } catch (err) {
+    console.warn("L2 gas estimation failed", err);
+    return makeGasQuote({
+      gasLimit: l2GasLimit ?? 0n,
+      maxFeePerGas,
+      gasPerPubdata
+    });
+  }
+}
+async function quoteL2BaseCost(input) {
+  const { estimator, encode, bridgehub, chainIdL2, l2GasLimit, gasPerPubdata } = input;
+  const market = await fetchFees(estimator);
+  const l1GasPrice = market.maxFeePerGas || market.maxPriorityFeePerGas || 0n;
+  if (l1GasPrice === 0n) {
+    throw new Error("Could not fetch L1 gas price for Bridgehub base cost calculation.");
+  }
+  const data = encode(IBridgehub_default, "l2TransactionBaseCost", [
+    chainIdL2,
+    l1GasPrice,
+    l2GasLimit,
+    gasPerPubdata
+  ]);
+  const raw = await estimator.call({
+    to: bridgehub,
+    data
+  });
+  return BigInt(raw);
+}
+
+// src/core/resources/withdrawals/gas.ts
+function makeGasQuote2(p) {
+  return {
+    gasLimit: p.gasLimit,
+    maxFeePerGas: p.maxFeePerGas,
+    maxPriorityFeePerGas: p.maxPriorityFeePerGas,
+    maxCost: p.gasLimit * p.maxFeePerGas
+  };
+}
+async function fetchFees2(estimator) {
+  try {
+    const fees = await estimator.estimateFeesPerGas();
+    if (fees.maxFeePerGas != null) {
+      return {
+        maxFeePerGas: fees.maxFeePerGas,
+        maxPriorityFeePerGas: fees.maxPriorityFeePerGas ?? 0n
+      };
+    }
+    if (fees.gasPrice != null) {
+      return {
+        maxFeePerGas: fees.gasPrice,
+        maxPriorityFeePerGas: 0n
+      };
+    }
+  } catch {
+  }
+  try {
+    const gp = await estimator.getGasPrice();
+    return { maxFeePerGas: gp, maxPriorityFeePerGas: 0n };
+  } catch {
+    return { maxFeePerGas: 0n, maxPriorityFeePerGas: 0n };
+  }
+}
+async function quoteL2Gas2(input) {
+  const { estimator, tx, overrides } = input;
+  const market = await fetchFees2(estimator);
+  const o = overrides;
+  const maxFeePerGas = o?.maxFeePerGas ?? (tx.maxFeePerGas != null ? BigInt(tx.maxFeePerGas) : market.maxFeePerGas);
+  const maxPriorityFeePerGas = o?.maxPriorityFeePerGas ?? (tx.maxPriorityFeePerGas != null ? BigInt(tx.maxPriorityFeePerGas) : market.maxPriorityFeePerGas);
+  const explicitGasLimit = o?.gasLimit ?? (tx.gasLimit != null ? BigInt(tx.gasLimit) : void 0);
+  if (explicitGasLimit != null) {
+    return makeGasQuote2({
+      gasLimit: explicitGasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas
+    });
+  }
+  try {
+    const est = await estimator.estimateGas(tx);
+    const buffered = BigInt(est) * (100n + BUFFER) / 100n;
+    return makeGasQuote2({
+      gasLimit: buffered,
+      maxFeePerGas,
+      maxPriorityFeePerGas
+    });
+  } catch (err) {
+    console.warn("Failed to estimate L2 gas for withdrawal.", err);
+    return void 0;
+  }
+}
+
+export { buildFeeBreakdown, createNTVCodec, quoteL1Gas, quoteL2BaseCost, quoteL2Gas, quoteL2Gas2 };

package/dist/{chunk-Y75OMFK6.js → chunk-M5J2MM2U.js}

@@ -1,3 +1,5 @@
+import { __export } from './chunk-F2ENUV3A.js';
+
 // src/core/internal/abis/IBridgehub.ts
 var IBridgehubABI = [
   {
@@ -3980,6 +3982,20 @@ var IBaseTokenABI = [
 ];
 var IBaseToken_default = IBaseTokenABI;
 
+// src/core/abi.ts
+var abi_exports = {};
+__export(abi_exports, {
+  IBaseTokenABI: () => IBaseToken_default,
+  IBridgehubABI: () => IBridgehub_default,
+  IERC20ABI: () => IERC20_default,
+  IL1AssetRouterABI: () => IL1AssetRouter_default,
+  IL1NullifierABI: () => IL1Nullifier_default,
+  IL2AssetRouterABI: () => IL2AssetRouter_default,
+  L1NativeTokenVaultABI: () => L1NativeTokenVault_default,
+  L2NativeTokenVaultABI: () => L2NativeTokenVault_default,
+  MailboxABI: () => Mailbox_default
+});
+
 // src/core/internal/abis/IERC20.ts
 var IERC20ABI = [
   {
@@ -4486,4 +4502,338 @@ var MailboxABI = [
 ];
 var Mailbox_default = MailboxABI;
 
-export { IBaseToken_default, IBridgehub_default, IERC20_default, IL1AssetRouter_default, IL1Nullifier_default, IL2AssetRouter_default, L1NativeTokenVault_default, L2NativeTokenVault_default, Mailbox_default };
+// src/core/errors/formatter.ts
+function elideMiddle(s, max = 96) {
+  if (s.length <= max) return s;
+  const keep = Math.max(10, Math.floor((max - 1) / 2));
+  return `${s.slice(0, keep)}\u2026${s.slice(-keep)}`;
+}
+function shortJSON(v, max = 240) {
+  try {
+    const s = JSON.stringify(
+      v,
+      (_k, val) => typeof val === "bigint" ? `${val.toString()}n` : val
+    );
+    return s.length > max ? elideMiddle(s, max) : s;
+  } catch {
+    return String(v);
+  }
+}
+function kv(label, value) {
+  const width = 10;
+  const pad = label.length >= width ? " " : " ".repeat(width - label.length);
+  return `${label + pad}: ${value}`;
+}
+function formatContextLine(ctx) {
+  if (!ctx) return;
+  const txHash = ctx["txHash"] ?? ctx["l1TxHash"] ?? ctx["hash"];
+  const nonce = ctx["nonce"];
+  const parts = [];
+  if (txHash !== void 0)
+    parts.push(`txHash=${typeof txHash === "string" ? txHash : shortJSON(txHash, 96)}`);
+  if (nonce !== void 0) {
+    const nonceStr = typeof nonce === "string" || typeof nonce === "number" || typeof nonce === "bigint" ? String(nonce) : shortJSON(nonce, 48);
+    parts.push(`nonce=${nonceStr}`);
+  }
+  return parts.length ? `  ${kv("Context", parts.join("  \u2022  "))}` : void 0;
+}
+function formatStep(ctx) {
+  const step = ctx && typeof ctx["step"] === "string" ? ctx["step"] : void 0;
+  return step ? `  ${kv("Step", step)}` : void 0;
+}
+function formatRevert(r) {
+  if (!r) return;
+  const first = [`selector=${r.selector}`];
+  const lines = [];
+  lines.push(`  ${kv("Revert", first.join(" "))}`);
+  if (r.name) lines.push(`              name=${r.name}`);
+  if (r.contract) lines.push(`              contract=${r.contract}`);
+  if (r.fn) lines.push(`              fn=${r.fn}`);
+  if (r.args && r.args.length) {
+    lines.push(`              args=${shortJSON(r.args, 120)}`);
+  }
+  return lines.join("\n");
+}
+function formatCause(c) {
+  if (!c) return [];
+  const out = [];
+  if (typeof c === "object" && c !== null) {
+    const obj = c;
+    const head = [];
+    if (obj.name !== void 0) {
+      const nameVal = obj.name;
+      const nameStr = typeof nameVal === "string" || typeof nameVal === "number" || typeof nameVal === "bigint" || typeof nameVal === "boolean" ? String(nameVal) : shortJSON(nameVal, 120);
+      head.push(`name=${nameStr}`);
+    }
+    if (obj.code !== void 0) {
+      const codeVal = obj.code;
+      const codeStr = typeof codeVal === "string" || typeof codeVal === "number" || typeof codeVal === "bigint" || typeof codeVal === "boolean" ? String(codeVal) : shortJSON(codeVal, 120);
+      head.push(`code=${codeStr}`);
+    }
+    if (head.length) out.push(`  ${kv("Cause", head.join("  "))}`);
+    if (obj.message) {
+      const messageStr = typeof obj.message === "string" || typeof obj.message === "number" || typeof obj.message === "bigint" || typeof obj.message === "boolean" ? String(obj.message) : shortJSON(obj.message, 600);
+      out.push(`              message=${elideMiddle(messageStr, 600)}`);
+    }
+    if (obj.data) {
+      const dataStr = shortJSON(obj.data, 200);
+      out.push(`              data=${elideMiddle(dataStr, 200)}`);
+    }
+  } else {
+    out.push(`  ${kv("Cause", shortJSON(c, 200))}`);
+  }
+  return out;
+}
+function formatEnvelopePretty(e) {
+  const lines = [];
+  lines.push(`\u2716 ZKsyncError [${e.type}]`);
+  lines.push(`  ${kv("Message", e.message)}`);
+  lines.push("");
+  lines.push(`  ${kv("Operation", e.operation)}`);
+  const ctx = (() => {
+    const u = e;
+    if (!u || typeof u !== "object") return void 0;
+    const obj = u;
+    const candidate = obj["ctx"] ?? obj["context"];
+    if (candidate && typeof candidate === "object" && candidate !== null) {
+      return candidate;
+    }
+    return void 0;
+  })();
+  const ctxLine = formatContextLine(ctx);
+  if (ctxLine) lines.push(ctxLine);
+  const stepLine = formatStep(ctx);
+  if (stepLine) lines.push(stepLine);
+  const rv = formatRevert(e.revert);
+  if (rv) lines.push(rv);
+  const causeLines = formatCause(e.cause);
+  if (causeLines.length) {
+    if (!ctxLine && !rv) lines.push("");
+    lines.push(...causeLines);
+  }
+  return lines.join("\n");
+}
+
+// src/core/types/errors.ts
+var hasSymbolInspect = typeof Symbol === "function" && typeof Symbol.for === "function";
+var kInspect = hasSymbolInspect ? Symbol.for("nodejs.util.inspect.custom") : void 0;
+function safeInspect(val) {
+  try {
+    if (typeof val === "string") return val;
+    return JSON.stringify(val, null, 2);
+  } catch {
+    try {
+      return String(val);
+    } catch {
+      return Object.prototype.toString.call(val);
+    }
+  }
+}
+var ZKsyncError = class extends Error {
+  constructor(envelope) {
+    super(formatEnvelopePretty(envelope), envelope.cause ? { cause: envelope.cause } : void 0);
+    this.envelope = envelope;
+    this.name = "ZKsyncError";
+  }
+  toJSON() {
+    return { name: this.name, ...this.envelope };
+  }
+};
+if (kInspect) {
+  Object.defineProperty(ZKsyncError.prototype, kInspect, {
+    value() {
+      return `${this.name}: ${formatEnvelopePretty(this.envelope)}`;
+    },
+    enumerable: false
+  });
+}
+function isZKsyncError(e) {
+  if (!e || typeof e !== "object") return false;
+  const maybe = e;
+  if (!("envelope" in maybe)) return false;
+  const envelope = maybe.envelope;
+  return typeof envelope?.type === "string" && typeof envelope?.message === "string";
+}
+function isReceiptNotFound(e) {
+  const chain = [];
+  let cur = e;
+  for (let i = 0; i < 5 && cur; i++) {
+    chain.push(cur);
+    cur = cur.cause;
+  }
+  const NAME_HITS = /* @__PURE__ */ new Set([
+    "TransactionReceiptNotFoundError",
+    // viem
+    "TransactionNotFoundError",
+    // viem
+    "NotFoundError"
+    // some RPC wrappers
+  ]);
+  const CODE_HITS = /* @__PURE__ */ new Set([
+    "TRANSACTION_NOT_FOUND",
+    // some ethers-ish shapes / providers
+    "RECEIPT_NOT_FOUND",
+    "NOT_FOUND",
+    -32e3
+    // JSON-RPC server error
+  ]);
+  const MSG_RE = /(transaction|receipt)[^]*?(not\s+(?:be\s+)?found|missing)/i;
+  for (const node of chain) {
+    const name = node?.name;
+    const code = node?.code;
+    const short = node?.shortMessage;
+    const msg = String(short ?? node?.message ?? "");
+    if (name && NAME_HITS.has(name)) return true;
+    if (code && CODE_HITS.has(code)) return true;
+    if (MSG_RE.test(msg)) return true;
+  }
+  const raw = (() => {
+    const node = e;
+    const short = node?.shortMessage;
+    const msg = node?.message;
+    if (typeof short === "string" && short) return short;
+    if (typeof msg === "string" && msg) return msg;
+    if (e == null) return "";
+    if (typeof e === "string") return e;
+    return safeInspect(e);
+  })();
+  return MSG_RE.test(raw);
+}
+var OP_DEPOSITS = {
+  // high-level flow ops
+  quote: "deposits.quote",
+  tryQuote: "deposits.tryQuote",
+  prepare: "deposits.prepare",
+  tryPrepare: "deposits.tryPrepare",
+  create: "deposits.create",
+  tryCreate: "deposits.tryCreate",
+  status: "deposits.status",
+  wait: "deposits.wait",
+  tryWait: "deposits.tryWait",
+  base: {
+    assertErc20Asset: "deposits.erc20-base:assertErc20Asset",
+    assertMatchesBase: "deposits.erc20-base:assertMatchesBase",
+    baseToken: "deposits.erc20-base:baseToken",
+    allowance: "deposits.erc20-base:allowance",
+    baseCost: "deposits.erc20-base:l2TransactionBaseCost",
+    estGas: "deposits.erc20-base:estimateGas"
+  },
+  nonbase: {
+    baseToken: "deposits.erc20-nonbase:baseToken",
+    assertNotEthAsset: "deposits.erc20-nonbase:assertNotEthAsset",
+    allowance: "deposits.erc20-nonbase:allowance",
+    allowanceFees: "deposits.erc20-nonbase:allowanceFeesBaseToken",
+    baseCost: "deposits.erc20-nonbase:l2TransactionBaseCost",
+    encodeCalldata: "deposits.erc20-nonbase:encodeSecondBridgeErc20Args",
+    estGas: "deposits.erc20-nonbase:estimateGas",
+    assertBaseIsEth: "deposits.erc20-nonbase:assertBaseIsEth",
+    assertBaseIsErc20: "deposits.erc20-nonbase:assertBaseIsErc20",
+    assertNonBaseToken: "deposits.erc20-nonbase:assertNonBaseToken",
+    allowanceToken: "deposits.erc20-nonbase:allowanceToken",
+    allowanceBase: "deposits.erc20-nonbase:allowanceBase"
+  },
+  eth: {
+    baseCost: "deposits.eth:l2TransactionBaseCost",
+    estGas: "deposits.eth:estimateGas"
+  },
+  ethNonBase: {
+    baseToken: "deposits.eth-nonbase:baseToken",
+    baseCost: "deposits.eth-nonbase:l2TransactionBaseCost",
+    allowanceBase: "deposits.eth-nonbase:allowanceBaseToken",
+    ethBalance: "deposits.eth-nonbase:getEthBalance",
+    encodeCalldata: "deposits.eth-nonbase:encodeSecondBridgeEthArgs",
+    estGas: "deposits.eth-nonbase:estimateGas",
+    assertEthAsset: "deposits.eth-nonbase:assertEthAsset",
+    assertNonEthBase: "deposits.eth-nonbase:assertNonEthBase",
+    assertEthBalance: "deposits.eth-nonbase:assertEthBalance"
+  }
+};
+var OP_WITHDRAWALS = {
+  quote: "withdrawals.quote",
+  tryQuote: "withdrawals.tryQuote",
+  prepare: "withdrawals.prepare",
+  tryPrepare: "withdrawals.tryPrepare",
+  create: "withdrawals.create",
+  tryCreate: "withdrawals.tryCreate",
+  status: "withdrawals.status",
+  wait: "withdrawals.wait",
+  tryWait: "withdrawals.tryWait",
+  erc20: {
+    allowance: "withdrawals.erc20:allowance",
+    ensureRegistered: "withdrawals.erc20:ensureTokenIsRegistered",
+    encodeAssetData: "withdrawals.erc20:encodeAssetData",
+    encodeWithdraw: "withdrawals.erc20:encodeWithdraw",
+    estGas: "withdrawals.erc20:estimateGas"
+  },
+  eth: {
+    encodeWithdraw: "withdrawals.eth:encodeWithdraw",
+    estGas: "withdrawals.eth:estimateGas"
+  },
+  ethNonBase: {
+    allowance: "withdrawals.eth-nonbase:allowance",
+    ensureRegistered: "withdrawals.eth-nonbase:ensureTokenIsRegistered",
+    encodeAssetData: "withdrawals.eth-nonbase:encodeAssetData",
+    encodeWithdraw: "withdrawals.eth-nonbase:encodeWithdraw",
+    estGas: "withdrawals.eth-nonbase:estimateGas",
+    baseToken: "withdrawals.eth-nonbase:baseToken",
+    assertNonEthBase: "withdrawals.eth-nonbase:assertNonEthBase"
+  },
+  finalize: {
+    fetchParams: {
+      receipt: "withdrawals.finalize.fetchParams:receipt",
+      findMessage: "withdrawals.finalize.fetchParams:findMessage",
+      decodeMessage: "withdrawals.finalize.fetchParams:decodeMessage",
+      rawReceipt: "withdrawals.finalize.fetchParams:rawReceipt",
+      messengerIndex: "withdrawals.finalize.fetchParams:messengerIndex",
+      proof: "withdrawals.finalize.fetchParams:proof",
+      network: "withdrawals.finalize.fetchParams:network",
+      ensureAddresses: "withdrawals.finalize.fetchParams:ensureAddresses"
+    },
+    readiness: {
+      ensureAddresses: "withdrawals.finalize.readiness:ensureAddresses",
+      isFinalized: "withdrawals.finalize.readiness:isWithdrawalFinalized",
+      simulate: "withdrawals.finalize.readiness:simulate"
+    },
+    isFinalized: "withdrawals.finalize.isWithdrawalFinalized",
+    send: "withdrawals.finalize.finalizeDeposit:send",
+    wait: "withdrawals.finalize.finalizeDeposit:wait",
+    estimate: "withdrawals.finalize.estimateFinalizationFees"
+  }
+};
+
+// src/core/errors/factory.ts
+var factory_exports = {};
+__export(factory_exports, {
+  createError: () => createError,
+  shapeCause: () => shapeCause
+});
+function createError(type, input) {
+  return new ZKsyncError({ ...input, type });
+}
+function shapeCause(err) {
+  const isRecord = (x) => x !== null && typeof x === "object";
+  let data = void 0;
+  if (isRecord(err)) {
+    const r2 = err;
+    const d = r2.data;
+    if (isRecord(d) && "data" in d) {
+      data = d.data;
+    } else if ("error" in r2 && isRecord(r2.error) && "data" in r2.error) {
+      data = r2.error.data;
+    } else if ("data" in r2) {
+      data = r2.data;
+    }
+  }
+  const r = isRecord(err) ? err : void 0;
+  const name = r && typeof r.name === "string" ? r.name : void 0;
+  const message = r && typeof r.message === "string" ? r.message : r && typeof r.shortMessage === "string" ? r.shortMessage : void 0;
+  const code = r && "code" in r ? r.code : void 0;
+  return {
+    name,
+    message,
+    code,
+    data: typeof data === "string" && data.startsWith("0x") ? `${data.slice(0, 10)}\u2026` : void 0
+  };
+}
+
+export { IBaseToken_default, IBridgehub_default, IERC20_default, IL1AssetRouter_default, IL1Nullifier_default, IL2AssetRouter_default, L1NativeTokenVault_default, L2NativeTokenVault_default, Mailbox_default, OP_DEPOSITS, OP_WITHDRAWALS, abi_exports, createError, factory_exports, formatEnvelopePretty, isReceiptNotFound, isZKsyncError, shapeCause };

package/dist/{chunk-263G6636.js → chunk-NCAIVYBR.js}

@@ -1,16 +1,3 @@
-// src/core/utils/gas.ts
-function assertNoLegacyGas(overrides) {
-  if (!overrides) return;
-  if ("gasPrice" in overrides && overrides.gasPrice !== void 0) {
-    throw new Error("Legacy gasPrice is not supported; use EIP-1559 fields instead.");
-  }
-}
-function assertPriorityFeeBounds(fees) {
-  if (fees.maxPriorityFeePerGas > fees.maxFeePerGas) {
-    throw new Error("maxPriorityFeePerGas cannot exceed maxFeePerGas.");
-  }
-}
-
 // src/core/errors/withdrawal-revert-map.ts
 var REVERT_TO_READINESS = {
   // Already done
@@ -33,4 +20,4 @@ var REVERT_TO_READINESS = {
   LocalRootMustBeZero: { kind: "UNFINALIZABLE", reason: "unsupported" }
 };
 
-export { REVERT_TO_READINESS, assertNoLegacyGas, assertPriorityFeeBounds };
+export { REVERT_TO_READINESS };

package/dist/{chunk-DI2CJDPZ.js → chunk-NEC2ZKHI.js}

@@ -1,4 +1,4 @@
-import { FORMAL_ETH_ADDRESS, L2_BASE_TOKEN_ADDRESS, ETH_ADDRESS, L2_ASSET_ROUTER_ADDRESS, L1_MESSENGER_ADDRESS, TOPIC_L1_MESSAGE_SENT_NEW, TOPIC_L1_MESSAGE_SENT_LEG } from './chunk-6GCT6TLS.js';
+import { ETH_ADDRESS, FORMAL_ETH_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_ASSET_ROUTER_ADDRESS, L1_MESSENGER_ADDRESS, TOPIC_L1_MESSAGE_SENT_NEW, TOPIC_L1_MESSAGE_SENT_LEG } from './chunk-F2ENUV3A.js';
 
 // src/core/utils/addr.ts
 var isHash66 = (x) => !!x && x.startsWith("0x") && x.length === 66;
@@ -17,16 +17,8 @@ function normalizeAddrEq(a, b) {
   };
   return normalize(a) === normalize(b);
 }
-
-// src/core/resources/deposits/route.ts
-async function pickDepositRoute(client, chainIdL2, token) {
-  if (isETH(token)) {
-    const base2 = await client.baseToken(chainIdL2);
-    return isETH(base2) ? "eth-base" : "eth-nonbase";
-  }
-  const base = await client.baseToken(chainIdL2);
-  return normalizeAddrEq(token, base) ? "erc20-base" : "erc20-nonbase";
-}
+var hexEq = (a, b) => a.toLowerCase() === b.toLowerCase();
+var normalizeL1Token = (token) => isAddressEq(token, FORMAL_ETH_ADDRESS) ? ETH_ADDRESS : token;
 
 // src/core/resources/withdrawals/route.ts
 function normalizeTokenForRouting(token) {
@@ -37,7 +29,7 @@ function normalizeTokenForRouting(token) {
 function pickWithdrawRoute(args) {
   const tokenNorm = normalizeTokenForRouting(args.token);
   const isL2BaseAlias = tokenNorm.toLowerCase() === L2_BASE_TOKEN_ADDRESS.toLowerCase();
-  if (isL2BaseAlias) return args.baseIsEth ? "eth-base" : "eth-nonbase";
+  if (isL2BaseAlias) return "base";
   return "erc20-nonbase";
 }
 
@@ -73,4 +65,4 @@ function messengerLogIndex(raw, opts) {
   return (hits[index] ?? hits[0]).i;
 }
 
-export { findL1MessageSentLog, isAddressEq, isETH, isHash66, messengerLogIndex, normalizeAddrEq, pickDepositRoute, pickWithdrawRoute };
+export { findL1MessageSentLog, hexEq, isAddressEq, isETH, isHash66, messengerLogIndex, normalizeAddrEq, normalizeL1Token, pickWithdrawRoute };

package/dist/chunk-NTEIA5KA.js

@@ -0,0 +1,13 @@
+import { isETH, normalizeAddrEq } from './chunk-NEC2ZKHI.js';
+
+// src/core/resources/deposits/route.ts
+async function pickDepositRoute(client, chainIdL2, token) {
+  if (isETH(token)) {
+    const base2 = await client.baseToken(chainIdL2);
+    return isETH(base2) ? "eth-base" : "eth-nonbase";
+  }
+  const base = await client.baseToken(chainIdL2);
+  return normalizeAddrEq(token, base) ? "erc20-base" : "erc20-nonbase";
+}
+
+export { pickDepositRoute };