@matterlabs/zksync-js 0.0.7 → 0.0.9

package/dist/adapters/viem/index.cjs

@@ -3,9 +3,58 @@
 var viem = require('viem');
 var sha3 = require('@noble/hashes/sha3');
 var utils = require('@noble/hashes/utils');
+var ethers = require('ethers');
 
 // src/adapters/viem/client.ts
 
+// src/core/utils/hash.ts
+var RegExpHex = /^0x[0-9a-fA-F]*$/;
+var isHash = (x, length) => {
+  if (!x || typeof x !== "string") return false;
+  return (x.length === length) && RegExpHex.test(x);
+};
+var isHash66 = (x) => isHash(x, 66);
+
+// src/core/utils/number.ts
+var isNumber = (x) => typeof x === "number" && Number.isFinite(x);
+var isBigint = (x) => typeof x === "bigint";
+var k256hex = (s) => `0x${utils.bytesToHex(sha3.keccak_256(utils.utf8ToBytes(s)))}`.toLowerCase();
+var FORMAL_ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ETH_ADDRESS = "0x0000000000000000000000000000000000000001";
+var L2_ASSET_ROUTER_ADDRESS = "0x0000000000000000000000000000000000010003";
+var L2_NATIVE_TOKEN_VAULT_ADDRESS = "0x0000000000000000000000000000000000010004";
+var L1_MESSENGER_ADDRESS = "0x0000000000000000000000000000000000008008";
+var L2_BASE_TOKEN_ADDRESS = "0x000000000000000000000000000000000000800A";
+var TOPIC_L1_MESSAGE_SENT_NEW = k256hex("L1MessageSent(uint256,bytes32,bytes)");
+var TOPIC_L1_MESSAGE_SENT_LEG = k256hex("L1MessageSent(address,bytes32,bytes)");
+var TOPIC_CANONICAL_ASSIGNED = "0x779f441679936c5441b671969f37400b8c3ed0071cb47444431bf985754560df";
+var TOPIC_CANONICAL_SUCCESS = "0xe4def01b981193a97a9e81230d7b9f31812ceaf23f864a828a82c687911cb2df";
+var BUFFER = 20n;
+var TX_OVERHEAD_GAS = 10000n;
+var TX_MEMORY_OVERHEAD_GAS = 10n;
+var DEFAULT_PUBDATA_BYTES = 155n;
+var DEFAULT_ABI_BYTES = 400n;
+var SAFE_L1_BRIDGE_GAS = 700000n;
+
+// src/core/utils/addr.ts
+function isAddressEq(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function isETH(token) {
+  return isAddressEq(token, FORMAL_ETH_ADDRESS) || isAddressEq(token, L2_BASE_TOKEN_ADDRESS) || isAddressEq(token, ETH_ADDRESS);
+}
+function normalizeAddrEq(a, b) {
+  if (!a || !b) return false;
+  const normalize = (s) => {
+    const hasPrefix = s.slice(0, 2).toLowerCase() === "0x";
+    const body = hasPrefix ? s.slice(2) : s;
+    return `0x${body.toLowerCase()}`;
+  };
+  return normalize(a) === normalize(b);
+}
+var hexEq = (a, b) => a.toLowerCase() === b.toLowerCase();
+var normalizeL1Token = (token) => isAddressEq(token, FORMAL_ETH_ADDRESS) ? ETH_ADDRESS : token;
+
 // src/core/errors/formatter.ts
 function elideMiddle(s, max = 96) {
   if (s.length <= max) return s;
@@ -16,7 +65,7 @@ function shortJSON(v, max = 240) {
   try {
     const s = JSON.stringify(
       v,
-      (_k, val) => typeof val === "bigint" ? `${val.toString()}n` : val
+      (_k, val) => isBigint(val) ? `${val.toString()}n` : val
     );
     return s.length > max ? elideMiddle(s, max) : s;
   } catch {
@@ -36,7 +85,7 @@ function formatContextLine(ctx) {
   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);
+    const nonceStr = typeof nonce === "string" || isNumber(nonce) || isBigint(nonce) ? String(nonce) : shortJSON(nonce, 48);
     parts.push(`nonce=${nonceStr}`);
   }
   return parts.length ? `  ${kv("Context", parts.join("  \u2022  "))}` : void 0;
@@ -66,17 +115,17 @@ function formatCause(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);
+      const nameStr = typeof nameVal === "string" || isNumber(nameVal) || isBigint(nameVal) || 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);
+      const codeStr = typeof codeVal === "string" || isNumber(codeVal) || isBigint(codeVal) || 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);
+      const messageStr = typeof obj.message === "string" || isNumber(obj.message) || isBigint(obj.message) || typeof obj.message === "boolean" ? String(obj.message) : shortJSON(obj.message, 600);
       out.push(`              message=${elideMiddle(messageStr, 600)}`);
     }
     if (obj.data) {
@@ -151,12 +200,13 @@ if (kInspect) {
     enumerable: false
   });
 }
-function isZKsyncError(e) {
+function isZKsyncError(e, opts) {
   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";
+  if (typeof envelope?.type !== "string" || typeof envelope?.message !== "string") return false;
+  return true;
 }
 function isReceiptNotFound(e) {
   const chain = [];
@@ -203,6 +253,8 @@ function isReceiptNotFound(e) {
   })();
   return MSG_RE.test(raw);
 }
+var OP_CLIENT = {
+  ensureAddresses: "client.ensureAddresses"};
 var OP_DEPOSITS = {
   // high-level flow ops
   quote: "deposits.quote",
@@ -279,11 +331,9 @@ var OP_WITHDRAWALS = {
       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"
+      network: "withdrawals.finalize.fetchParams:network"
     },
     readiness: {
-      ensureAddresses: "withdrawals.finalize.readiness:ensureAddresses",
       isFinalized: "withdrawals.finalize.readiness:isWithdrawalFinalized",
       simulate: "withdrawals.finalize.readiness:simulate"
     },
@@ -299,20 +349,20 @@ function createError(type, input) {
   return new ZKsyncError({ ...input, type });
 }
 function shapeCause(err) {
-  const isRecord = (x) => x !== null && typeof x === "object";
+  const isRecord2 = (x) => x !== null && typeof x === "object";
   let data = void 0;
-  if (isRecord(err)) {
+  if (isRecord2(err)) {
     const r2 = err;
     const d = r2.data;
-    if (isRecord(d) && "data" in d) {
+    if (isRecord2(d) && "data" in d) {
       data = d.data;
-    } else if ("error" in r2 && isRecord(r2.error) && "data" in r2.error) {
+    } else if ("error" in r2 && isRecord2(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 r = isRecord2(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;
@@ -366,7 +416,7 @@ function normalizeProof(p) {
         context: { keys: Object.keys(raw ?? {}) }
       });
     }
-    const toBig = (x) => typeof x === "bigint" ? x : typeof x === "number" ? BigInt(x) : typeof x === "string" ? BigInt(x) : (() => {
+    const toBig = (x) => isBigint(x) ? x : isNumber(x) ? BigInt(x) : typeof x === "string" ? BigInt(x) : (() => {
       throw createError("RPC", {
         resource: "zksrpc",
         operation: "zksrpc.normalizeProof",
@@ -377,7 +427,8 @@ function normalizeProof(p) {
     return {
       id: toBig(idRaw),
       batchNumber: toBig(bnRaw),
-      proof: toHexArray(raw?.proof)
+      proof: toHexArray(raw?.proof),
+      root: raw.root
     };
   } catch (e) {
     if (isZKsyncError(e)) throw e;
@@ -402,8 +453,8 @@ function ensureHex(value, field, context) {
 function ensureNumber(value, field, opts) {
   const operation = opts?.operation ?? "zksrpc.normalizeGenesis";
   const messagePrefix = opts?.messagePrefix ?? "Malformed genesis response";
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "bigint") return Number(value);
+  if (isNumber(value)) return value;
+  if (isBigint(value)) return Number(value);
   if (typeof value === "string" && value.trim() !== "") {
     const parsed = Number(value);
     if (Number.isFinite(parsed)) return parsed;
@@ -418,8 +469,8 @@ function ensureNumber(value, field, opts) {
 function ensureBigInt(value, field, opts) {
   const operation = opts?.operation ?? "zksrpc.normalizeBlockMetadata";
   const messagePrefix = opts?.messagePrefix ?? "Malformed block metadata response";
-  if (typeof value === "bigint") return value;
-  if (typeof value === "number" && Number.isFinite(value)) {
+  if (isBigint(value)) return value;
+  if (isNumber(value)) {
     if (!Number.isInteger(value)) {
       throw createError("RPC", {
         resource: "zksrpc",
@@ -443,6 +494,9 @@ function ensureBigInt(value, field, opts) {
     context: { field, valueType: typeof value }
   });
 }
+function isRecord(x) {
+  return !!x && typeof x === "object" && !Array.isArray(x);
+}
 function normalizeContractTuple(tuple, index) {
   if (!Array.isArray(tuple) || tuple.length < 2) {
     throw createError("RPC", {
@@ -458,7 +512,7 @@ function normalizeContractTuple(tuple, index) {
     bytecode: ensureHex(bytecodeRaw, "initial_contracts.bytecode", { index })
   };
 }
-function normalizeStorageTuple(tuple, index) {
+function normalizeRawStorageTuple(tuple, index) {
   if (!Array.isArray(tuple) || tuple.length < 2) {
     throw createError("RPC", {
       resource: "zksrpc",
@@ -469,10 +523,53 @@ function normalizeStorageTuple(tuple, index) {
   }
   const [keyRaw, valueRaw] = tuple;
   return {
+    format: "raw",
     key: ensureHex(keyRaw, "additional_storage.key", { index }),
     value: ensureHex(valueRaw, "additional_storage.value", { index })
   };
 }
+function normalizeAdditionalStorage(value, record) {
+  const effective = value ?? record["additional_storage_raw"];
+  if (Array.isArray(effective)) {
+    return effective.map((entry, index) => {
+      const kv2 = normalizeRawStorageTuple(entry, index);
+      return { format: "raw", key: kv2.key, value: kv2.value };
+    });
+  }
+  if (isRecord(effective)) {
+    const out = [];
+    for (const [addrRaw, slotsRaw] of Object.entries(effective)) {
+      const address = ensureHex(addrRaw, "additional_storage.address", {});
+      if (!isRecord(slotsRaw)) {
+        throw createError("RPC", {
+          resource: "zksrpc",
+          operation: "zksrpc.normalizeGenesis",
+          message: "Malformed genesis response: additional_storage[address] must be an object map.",
+          context: { address, valueType: typeof slotsRaw }
+        });
+      }
+      for (const [slotRaw, valRaw] of Object.entries(slotsRaw)) {
+        out.push({
+          format: "pretty",
+          address,
+          key: ensureHex(slotRaw, "additional_storage.key", { address }),
+          value: ensureHex(valRaw, "additional_storage.value", { address, key: slotRaw })
+        });
+      }
+    }
+    return out;
+  }
+  throw createError("RPC", {
+    resource: "zksrpc",
+    operation: "zksrpc.normalizeGenesis",
+    message: "Malformed genesis response: additional_storage must be an array (raw) or an object map (pretty).",
+    context: {
+      valueType: typeof effective,
+      hasAdditionalStorage: "additional_storage" in record,
+      hasAdditionalStorageRaw: "additional_storage_raw" in record
+    }
+  });
+}
 function normalizeGenesis(raw) {
   try {
     if (!raw || typeof raw !== "object") {
@@ -493,21 +590,12 @@ function normalizeGenesis(raw) {
         context: { valueType: typeof contractsRaw }
       });
     }
-    const storageRaw = record["additional_storage"];
-    if (!Array.isArray(storageRaw)) {
-      throw createError("RPC", {
-        resource: "zksrpc",
-        operation: "zksrpc.normalizeGenesis",
-        message: "Malformed genesis response: additional_storage must be an array.",
-        context: { valueType: typeof storageRaw }
-      });
-    }
     const executionVersion = ensureNumber(record["execution_version"], "execution_version");
     const genesisRoot = ensureHex(record["genesis_root"], "genesis_root", {});
     const initialContracts = contractsRaw.map(
       (entry, index) => normalizeContractTuple(entry, index)
     );
-    const additionalStorage = storageRaw.map((entry, index) => normalizeStorageTuple(entry, index));
+    const additionalStorage = normalizeAdditionalStorage(record["additional_storage"], record);
     return {
       initialContracts,
       additionalStorage,
@@ -694,23 +782,6 @@ function zksRpcFromViem(l2Client) {
   };
   return createZksRpc(makeTransportFromViem(compatible));
 }
-var k256hex = (s) => `0x${utils.bytesToHex(sha3.keccak_256(utils.utf8ToBytes(s)))}`.toLowerCase();
-var FORMAL_ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
-var ETH_ADDRESS = "0x0000000000000000000000000000000000000001";
-var L2_ASSET_ROUTER_ADDRESS = "0x0000000000000000000000000000000000010003";
-var L2_NATIVE_TOKEN_VAULT_ADDRESS = "0x0000000000000000000000000000000000010004";
-var L1_MESSENGER_ADDRESS = "0x0000000000000000000000000000000000008008";
-var L2_BASE_TOKEN_ADDRESS = "0x000000000000000000000000000000000000800A";
-var TOPIC_L1_MESSAGE_SENT_NEW = k256hex("L1MessageSent(uint256,bytes32,bytes)");
-var TOPIC_L1_MESSAGE_SENT_LEG = k256hex("L1MessageSent(address,bytes32,bytes)");
-var TOPIC_CANONICAL_ASSIGNED = "0x779f441679936c5441b671969f37400b8c3ed0071cb47444431bf985754560df";
-var TOPIC_CANONICAL_SUCCESS = "0xe4def01b981193a97a9e81230d7b9f31812ceaf23f864a828a82c687911cb2df";
-var BUFFER = 20n;
-var TX_OVERHEAD_GAS = 10000n;
-var TX_MEMORY_OVERHEAD_GAS = 10n;
-var DEFAULT_PUBDATA_BYTES = 155n;
-var DEFAULT_ABI_BYTES = 400n;
-var SAFE_L1_BRIDGE_GAS = 700000n;
 
 // src/core/internal/abis/IBridgehub.ts
 var IBridgehubABI = [
@@ -5200,7 +5271,166 @@ var MailboxABI = [
 ];
 var Mailbox_default = MailboxABI;
 
+// src/core/errors/error-ops.ts
+function resolveMessage(op, msg) {
+  if (!msg) return `Error during ${op}.`;
+  return typeof msg === "function" ? msg() : msg;
+}
+function createErrorOps(decodeRevert3) {
+  function toZKsyncError3(type, base, err) {
+    if (isZKsyncError(err)) return err;
+    const revert = decodeRevert3 ? decodeRevert3(err) : void 0;
+    return createError(type, { ...base, ...revert ? { revert } : {}, cause: shapeCause(err) });
+  }
+  function createErrorHandlers3(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 toZKsyncError3(kind, { resource, operation, context: opts?.ctx ?? {}, message }, e);
+      }
+    }
+    function wrap3(operation, fn, opts) {
+      return run("INTERNAL", operation, fn, opts);
+    }
+    function wrapAs10(kind, operation, fn, opts) {
+      return run(kind, operation, fn, opts);
+    }
+    async function toResult2(operation, fn, opts) {
+      try {
+        const value = await wrap3(operation, fn, opts);
+        return { ok: true, value };
+      } catch (e) {
+        const shaped = isZKsyncError(e) ? e : toZKsyncError3(
+          "INTERNAL",
+          {
+            resource,
+            operation,
+            context: opts?.ctx ?? {},
+            message: resolveMessage(operation, opts?.message)
+          },
+          e
+        );
+        return { ok: false, error: shaped };
+      }
+    }
+    return { wrap: wrap3, wrapAs: wrapAs10, toResult: toResult2 };
+  }
+  return { toZKsyncError: toZKsyncError3, createErrorHandlers: createErrorHandlers3 };
+}
+
+// src/core/errors/withdrawal-revert-map.ts
+var REVERT_TO_READINESS = {
+  // Already done
+  WithdrawalAlreadyFinalized: { kind: "FINALIZED" },
+  // Temporary — try later
+  BatchNotExecuted: { kind: "NOT_READY", reason: "batch-not-executed" },
+  LocalRootIsZero: { kind: "NOT_READY", reason: "root-missing" },
+  // Permanent — won’t become ready for this tx
+  WrongL2Sender: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  InvalidSelector: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  L2WithdrawalMessageWrongLength: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  WrongMsgLength: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  TokenNotLegacy: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  TokenIsLegacy: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  InvalidProof: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  InvalidChainId: { kind: "UNFINALIZABLE", reason: "invalid-chain" },
+  NotSettlementLayer: { kind: "UNFINALIZABLE", reason: "settlement-layer" },
+  // Likely environment mismatch — treat as permanent for this tx
+  OnlyEraSupported: { kind: "UNFINALIZABLE", reason: "unsupported" },
+  LocalRootMustBeZero: { kind: "UNFINALIZABLE", reason: "unsupported" }
+};
+
+// src/adapters/ethers/errors/revert.ts
+var ERROR_IFACES = [];
+var IFACE_ERROR_STRING = new ethers.Interface(["error Error(string)"]);
+var IFACE_PANIC = new ethers.Interface(["error Panic(uint256)"]);
+(function bootstrapDefaultIfaces() {
+  try {
+    ERROR_IFACES.push({
+      name: "IL1Nullifier",
+      iface: new ethers.Interface(IL1Nullifier_default)
+    });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({ name: "IERC20", iface: new ethers.Interface(IERC20_default) });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({
+      name: "IL1NativeTokenVault",
+      iface: new ethers.Interface(L1NativeTokenVault_default)
+    });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({
+      name: "IL2NativeTokenVault",
+      iface: new ethers.Interface(L2NativeTokenVault_default)
+    });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({ name: "Mailbox", iface: new ethers.Interface(Mailbox_default) });
+  } catch {
+  }
+})();
+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 };
+}
+
+// src/adapters/ethers/errors/error-ops.ts
+var { createErrorHandlers } = createErrorOps(decodeRevert);
+
 // src/adapters/viem/client.ts
+var { wrap } = createErrorHandlers("client");
 function createViemClient(args) {
   const { l1, l2, l1Wallet, l2Wallet } = args;
   if (!l1Wallet.account) {
@@ -5212,35 +5442,44 @@ function createViemClient(args) {
   let cCache;
   async function ensureAddresses() {
     if (addrCache) return addrCache;
-    const bridgehub = args.overrides?.bridgehub ?? await zks.getBridgehubAddress();
-    const l1AssetRouter = args.overrides?.l1AssetRouter ?? await l1.readContract({
-      address: bridgehub,
-      abi: IBridgehub_default,
-      functionName: "assetRouter"
-    });
-    const l1Nullifier = args.overrides?.l1Nullifier ?? await l1.readContract({
-      address: l1AssetRouter,
-      abi: IL1AssetRouter_default,
-      functionName: "L1_NULLIFIER"
-    });
-    const l1NativeTokenVault = args.overrides?.l1NativeTokenVault ?? await l1.readContract({
-      address: l1Nullifier,
-      abi: IL1Nullifier_default,
-      functionName: "l1NativeTokenVault"
-    });
-    const l2AssetRouter = args.overrides?.l2AssetRouter ?? L2_ASSET_ROUTER_ADDRESS;
-    const l2NativeTokenVault = args.overrides?.l2NativeTokenVault ?? L2_NATIVE_TOKEN_VAULT_ADDRESS;
-    const l2BaseTokenSystem = args.overrides?.l2BaseTokenSystem ?? L2_BASE_TOKEN_ADDRESS;
-    addrCache = {
-      bridgehub,
-      l1AssetRouter,
-      l1Nullifier,
-      l1NativeTokenVault,
-      l2AssetRouter,
-      l2NativeTokenVault,
-      l2BaseTokenSystem
-    };
-    return addrCache;
+    return await wrap(
+      OP_CLIENT.ensureAddresses,
+      async () => {
+        const bridgehub = args.overrides?.bridgehub ?? await zks.getBridgehubAddress();
+        const l1AssetRouter = args.overrides?.l1AssetRouter ?? await l1.readContract({
+          address: bridgehub,
+          abi: IBridgehub_default,
+          functionName: "assetRouter"
+        });
+        const l1Nullifier = args.overrides?.l1Nullifier ?? await l1.readContract({
+          address: l1AssetRouter,
+          abi: IL1AssetRouter_default,
+          functionName: "L1_NULLIFIER"
+        });
+        const l1NativeTokenVault = args.overrides?.l1NativeTokenVault ?? await l1.readContract({
+          address: l1Nullifier,
+          abi: IL1Nullifier_default,
+          functionName: "l1NativeTokenVault"
+        });
+        const l2AssetRouter = args.overrides?.l2AssetRouter ?? L2_ASSET_ROUTER_ADDRESS;
+        const l2NativeTokenVault = args.overrides?.l2NativeTokenVault ?? L2_NATIVE_TOKEN_VAULT_ADDRESS;
+        const l2BaseTokenSystem = args.overrides?.l2BaseTokenSystem ?? L2_BASE_TOKEN_ADDRESS;
+        addrCache = {
+          bridgehub,
+          l1AssetRouter,
+          l1Nullifier,
+          l1NativeTokenVault,
+          l2AssetRouter,
+          l2NativeTokenVault,
+          l2BaseTokenSystem
+        };
+        return addrCache;
+      },
+      {
+        ctx: { where: "ensureAddresses" },
+        message: "Failed to ensure contract addresses."
+      }
+    );
   }
   async function contracts() {
     if (cCache) return cCache;
@@ -5309,6 +5548,12 @@ function createViemClient(args) {
   };
 }
 
+// src/core/types/fees.ts
+function toGasOverrides(overrides) {
+  const { nonce: _, ...gas } = overrides;
+  return gas;
+}
+
 // src/adapters/viem/resources/deposits/context.ts
 async function commonCtx(p, client, tokens, contracts) {
   const { bridgehub, l1AssetRouter } = await contracts.addresses();
@@ -5343,7 +5588,7 @@ async function commonCtx(p, client, tokens, contracts) {
     bridgehub,
     chainIdL2: BigInt(chainId),
     sender,
-    gasOverrides: p.l1TxOverrides,
+    gasOverrides: p.l1TxOverrides ? toGasOverrides(p.l1TxOverrides) : void 0,
     l2GasLimit: p.l2GasLimit,
     gasPerPubdata,
     operatorTip,
@@ -5399,80 +5644,6 @@ function buildDirectRequestStruct(args) {
     refundRecipient: args.refundRecipient
   };
 }
-
-// src/core/errors/error-ops.ts
-function resolveMessage(op, msg) {
-  if (!msg) return `Error during ${op}.`;
-  return typeof msg === "function" ? msg() : msg;
-}
-function createErrorOps(decodeRevert2) {
-  function toZKsyncError2(type, base, err) {
-    if (isZKsyncError(err)) return err;
-    const revert = decodeRevert2 ? decodeRevert2(err) : void 0;
-    return createError(type, { ...base, ...revert ? { revert } : {}, cause: shapeCause(err) });
-  }
-  function createErrorHandlers2(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 toZKsyncError2(kind, { resource, operation, context: opts?.ctx ?? {}, message }, e);
-      }
-    }
-    function wrap2(operation, fn, opts) {
-      return run("INTERNAL", operation, fn, opts);
-    }
-    function wrapAs10(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 : toZKsyncError2(
-          "INTERNAL",
-          {
-            resource,
-            operation,
-            context: opts?.ctx ?? {},
-            message: resolveMessage(operation, opts?.message)
-          },
-          e
-        );
-        return { ok: false, error: shaped };
-      }
-    }
-    return { wrap: wrap2, wrapAs: wrapAs10, toResult: toResult2 };
-  }
-  return { toZKsyncError: toZKsyncError2, createErrorHandlers: createErrorHandlers2 };
-}
-
-// src/core/errors/withdrawal-revert-map.ts
-var REVERT_TO_READINESS = {
-  // Already done
-  WithdrawalAlreadyFinalized: { kind: "FINALIZED" },
-  // Temporary — try later
-  BatchNotExecuted: { kind: "NOT_READY", reason: "batch-not-executed" },
-  LocalRootIsZero: { kind: "NOT_READY", reason: "root-missing" },
-  // Permanent — won’t become ready for this tx
-  WrongL2Sender: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  InvalidSelector: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  L2WithdrawalMessageWrongLength: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  WrongMsgLength: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  TokenNotLegacy: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  TokenIsLegacy: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  InvalidProof: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  InvalidChainId: { kind: "UNFINALIZABLE", reason: "invalid-chain" },
-  NotSettlementLayer: { kind: "UNFINALIZABLE", reason: "settlement-layer" },
-  // Likely environment mismatch — treat as permanent for this tx
-  OnlyEraSupported: { kind: "UNFINALIZABLE", reason: "unsupported" },
-  LocalRootMustBeZero: { kind: "UNFINALIZABLE", reason: "unsupported" }
-};
-
-// src/adapters/viem/errors/revert.ts
 var ERROR_ABIS = [];
 var ABI_ERROR_STRING = [
   { type: "error", name: "Error", inputs: [{ name: "message", type: "string" }] }
@@ -5508,7 +5679,7 @@ function registerErrorAbi(name, abi) {
   if (i >= 0) ERROR_ABIS[i] = entry;
   else ERROR_ABIS.push(entry);
 }
-function extractRevertData(e) {
+function extractRevertData2(e) {
   const candidates = [
     e?.data?.data,
     e?.error?.data,
@@ -5526,8 +5697,8 @@ function extractRevertData(e) {
   }
   return void 0;
 }
-function decodeRevert(e) {
-  const data = extractRevertData(e);
+function decodeRevert2(e) {
+  const data = extractRevertData2(e);
   if (!data) return;
   const selector = `0x${data.slice(2, 10)}`;
   try {
@@ -5561,7 +5732,7 @@ function decodeRevert(e) {
   return { selector };
 }
 function classifyReadinessFromRevert(e) {
-  const r = decodeRevert(e);
+  const r = decodeRevert2(e);
   const name = r?.name;
   if (name && REVERT_TO_READINESS[name]) return REVERT_TO_READINESS[name];
   const msg = (() => {
@@ -5579,7 +5750,7 @@ function classifyReadinessFromRevert(e) {
 }
 
 // src/adapters/viem/errors/error-ops.ts
-var { toZKsyncError, createErrorHandlers } = createErrorOps(decodeRevert);
+var { toZKsyncError: toZKsyncError2, createErrorHandlers: createErrorHandlers2 } = createErrorOps(decodeRevert2);
 
 // src/core/resources/deposits/gas.ts
 function makeGasQuote(p) {
@@ -5842,7 +6013,7 @@ async function determineErc20L2Gas(input) {
 }
 
 // src/adapters/viem/resources/deposits/services/fee.ts
-var { wrapAs } = createErrorHandlers("deposits");
+var { wrapAs } = createErrorHandlers2("deposits");
 async function quoteL2BaseCost(input) {
   const { ctx, l2GasLimit } = input;
   const estimator = viemToGasEstimator(ctx.client.l1);
@@ -5892,7 +6063,7 @@ function buildFeeBreakdown(p) {
 }
 
 // src/adapters/viem/resources/deposits/routes/eth.ts
-var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
+var { wrapAs: wrapAs2 } = createErrorHandlers2("deposits");
 function routeEthDirect() {
   return {
     async build(p, ctx) {
@@ -5986,29 +6157,7 @@ function routeEthDirect() {
     }
   };
 }
-
-// src/core/utils/addr.ts
-var isHash66 = (x) => !!x && x.startsWith("0x") && x.length === 66;
-function isAddressEq(a, b) {
-  return a.toLowerCase() === b.toLowerCase();
-}
-function isETH(token) {
-  return isAddressEq(token, FORMAL_ETH_ADDRESS) || isAddressEq(token, L2_BASE_TOKEN_ADDRESS) || isAddressEq(token, ETH_ADDRESS);
-}
-function normalizeAddrEq(a, b) {
-  if (!a || !b) return false;
-  const normalize = (s) => {
-    const hasPrefix = s.slice(0, 2).toLowerCase() === "0x";
-    const body = hasPrefix ? s.slice(2) : s;
-    return `0x${body.toLowerCase()}`;
-  };
-  return normalize(a) === normalize(b);
-}
-var hexEq = (a, b) => a.toLowerCase() === b.toLowerCase();
-var normalizeL1Token = (token) => isAddressEq(token, FORMAL_ETH_ADDRESS) ? ETH_ADDRESS : token;
-
-// src/adapters/viem/resources/deposits/routes/erc20-nonbase.ts
-var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
+var { wrapAs: wrapAs3 } = createErrorHandlers2("deposits");
 function routeErc20NonBase() {
   return {
     // TODO: do we even need these validations?
@@ -6235,7 +6384,7 @@ function routeErc20NonBase() {
     }
   };
 }
-var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
+var { wrapAs: wrapAs4 } = createErrorHandlers2("deposits");
 function routeEthNonBase() {
   return {
     // TODO: do we even need these validations?
@@ -6446,7 +6595,7 @@ function routeEthNonBase() {
     }
   };
 }
-var { wrapAs: wrapAs5 } = createErrorHandlers("deposits");
+var { wrapAs: wrapAs5 } = createErrorHandlers2("deposits");
 function routeErc20Base() {
   return {
     async preflight(p, ctx) {
@@ -6634,7 +6783,7 @@ var I_BRIDGEHUB_NEW_PRIORITY_REQUEST = {
     { name: "data", type: "bytes", indexed: false }
   ]
 };
-function extractL2TxHashFromL1Logs(logs) {
+function getL2TransactionHashFromLogs(logs) {
   for (const lg of logs) {
     try {
       const parsed = viem.decodeEventLog({
@@ -6666,7 +6815,7 @@ function extractL2TxHashFromL1Logs(logs) {
 async function waitForL2ExecutionFromL1Tx(l1, l2, l1TxHash) {
   const l1Receipt = await l1.waitForTransactionReceipt({ hash: l1TxHash });
   if (!l1Receipt) throw new Error("No L1 receipt found");
-  const l2TxHash = extractL2TxHashFromL1Logs(l1Receipt.logs);
+  const l2TxHash = getL2TransactionHashFromLogs(l1Receipt.logs);
   if (!l2TxHash) {
     throw createError("VERIFICATION", {
       message: "Failed to extract L2 transaction hash from L1 logs",
@@ -6714,7 +6863,7 @@ function createNTVCodec(deps) {
 }
 
 // src/adapters/viem/resources/tokens/tokens.ts
-var { wrapAs: wrapAs6 } = createErrorHandlers("tokens");
+var { wrapAs: wrapAs6 } = createErrorHandlers2("tokens");
 var ntvCodec = createNTVCodec({
   encode: (types, values) => viem.encodeAbiParameters(
     types.map((t, i) => ({ type: t, name: `arg${i}` })),
@@ -6970,7 +7119,7 @@ function createContractsResource(client) {
 }
 
 // src/adapters/viem/resources/deposits/index.ts
-var { wrap, toResult } = createErrorHandlers("deposits");
+var { wrap: wrap2, toResult } = createErrorHandlers2("deposits");
 var ROUTES = {
   "eth-base": routeEthDirect(),
   "eth-nonbase": routeEthNonBase(),
@@ -7001,7 +7150,7 @@ function createDepositsResource(client, tokens, contracts) {
       steps
     };
   }
-  const quote = async (p) => wrap(
+  const quote = async (p) => wrap2(
     OP_DEPOSITS.quote,
     async () => {
       const plan = await buildPlan(p);
@@ -7016,20 +7165,26 @@ function createDepositsResource(client, tokens, contracts) {
     message: "Internal error while preparing a deposit quote.",
     ctx: { token: p.token, where: "deposits.tryQuote" }
   });
-  const prepare = (p) => wrap(OP_DEPOSITS.prepare, () => buildPlan(p), {
+  const prepare = (p) => wrap2(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(
+  const create = (p) => wrap2(
     OP_DEPOSITS.create,
     async () => {
       const plan = await prepare(p);
       const stepHashes = {};
       const from = client.account.address;
-      let next = await client.l1.getTransactionCount({ address: from, blockTag: "latest" });
+      let next;
+      if (typeof p.l1TxOverrides?.nonce === "number") {
+        next = p.l1TxOverrides.nonce;
+      } else {
+        const blockTag = p.l1TxOverrides?.nonce ?? "latest";
+        next = await client.l1.getTransactionCount({ address: from, blockTag });
+      }
       for (const step of plan.steps) {
         if (step.kind === "approve") {
           try {
@@ -7047,7 +7202,7 @@ function createDepositsResource(client, tokens, contracts) {
               continue;
             }
           } catch (e) {
-            throw toZKsyncError(
+            throw toZKsyncError2(
               "CONTRACT",
               {
                 resource: "deposits",
@@ -7128,7 +7283,7 @@ function createDepositsResource(client, tokens, contracts) {
           }
         } catch (e) {
           if (isZKsyncError(e)) throw e;
-          throw toZKsyncError(
+          throw toZKsyncError2(
             "EXECUTION",
             {
               resource: "deposits",
@@ -7153,7 +7308,7 @@ function createDepositsResource(client, tokens, contracts) {
     message: "Internal error while creating a deposit.",
     ctx: { token: p.token, amount: p.amount, to: p.to, where: "deposits.tryCreate" }
   });
-  const status = (h) => wrap(
+  const status = (h) => wrap2(
     OP_DEPOSITS.status,
     async () => {
       const l1TxHash = typeof h === "string" ? h : h.l1TxHash;
@@ -7162,7 +7317,7 @@ function createDepositsResource(client, tokens, contracts) {
       try {
         l1Rcpt = await client.l1.getTransactionReceipt({ hash: l1TxHash });
       } catch (e) {
-        throw toZKsyncError(
+        throw toZKsyncError2(
           "RPC",
           {
             resource: "deposits",
@@ -7176,14 +7331,14 @@ function createDepositsResource(client, tokens, contracts) {
       if (!l1Rcpt) return { phase: "L1_PENDING", l1TxHash };
       let l2TxHash;
       try {
-        l2TxHash = extractL2TxHashFromL1Logs(l1Rcpt.logs) ?? void 0;
+        l2TxHash = getL2TransactionHashFromLogs(l1Rcpt.logs) ?? void 0;
       } catch (e) {
-        throw toZKsyncError(
+        throw toZKsyncError2(
           "INTERNAL",
           {
             resource: "deposits",
-            operation: "deposits.status.extractL2TxHashFromL1Logs",
-            context: { where: "extractL2TxHashFromL1Logs", l1TxHash },
+            operation: "deposits.status.getL2TransactionHashFromLogs",
+            context: { where: "getL2TransactionHashFromLogs", l1TxHash },
             message: "Failed to derive L2 transaction hash from L1 logs."
           },
           e
@@ -7197,7 +7352,7 @@ function createDepositsResource(client, tokens, contracts) {
         if (isReceiptNotFound(e)) {
           return { phase: "L2_PENDING", l1TxHash, l2TxHash };
         }
-        throw toZKsyncError(
+        throw toZKsyncError2(
           "RPC",
           {
             resource: "deposits",
@@ -7217,7 +7372,7 @@ function createDepositsResource(client, tokens, contracts) {
       ctx: { input: h, where: "deposits.status" }
     }
   );
-  const wait = (h, opts) => wrap(
+  const wait = (h, opts) => wrap2(
     OP_DEPOSITS.wait,
     async () => {
       const l1Hash = typeof h === "string" ? h : "l1TxHash" in h ? h.l1TxHash : void 0;
@@ -7226,7 +7381,7 @@ function createDepositsResource(client, tokens, contracts) {
       try {
         l1Receipt = await client.l1.waitForTransactionReceipt({ hash: l1Hash });
       } catch (e) {
-        throw toZKsyncError(
+        throw toZKsyncError2(
           "RPC",
           {
             resource: "deposits",
@@ -7244,7 +7399,7 @@ function createDepositsResource(client, tokens, contracts) {
         return l2Receipt ?? null;
       } catch (e) {
         if (isZKsyncError(e)) throw e;
-        throw toZKsyncError(
+        throw toZKsyncError2(
           "INTERNAL",
           {
             resource: "deposits",
@@ -7332,7 +7487,7 @@ async function commonCtx2(p, client, tokens, contracts) {
     l2NativeTokenVault,
     l2BaseTokenSystem,
     baseIsEth,
-    gasOverrides: p.l2TxOverrides
+    gasOverrides: p.l2TxOverrides ? toGasOverrides(p.l2TxOverrides) : void 0
   };
 }
 
@@ -7425,7 +7580,7 @@ function buildFeeBreakdown2(p) {
 }
 
 // src/adapters/viem/resources/withdrawals/routes/eth.ts
-var { wrapAs: wrapAs7 } = createErrorHandlers("withdrawals");
+var { wrapAs: wrapAs7 } = createErrorHandlers2("withdrawals");
 function routeEthBase() {
   return {
     async build(p, ctx) {
@@ -7480,7 +7635,7 @@ function routeEthBase() {
     }
   };
 }
-var { wrapAs: wrapAs8 } = createErrorHandlers("withdrawals");
+var { wrapAs: wrapAs8 } = createErrorHandlers2("withdrawals");
 function routeErc20NonBase2() {
   return {
     // TODO: add preflight validations here
@@ -7553,8 +7708,7 @@ function routeErc20NonBase2() {
           tx: approveTx
         });
       }
-      const resolved = ctx.resolvedToken ?? (ctx.tokens ? await ctx.tokens.resolve(p.token, { chain: "l2" }) : void 0);
-      const assetId = resolved?.assetId ?? (await wrapAs8(
+      const assetId = (await wrapAs8(
         "CONTRACT",
         OP_WITHDRAWALS.erc20.ensureRegistered,
         () => ctx.client.l2.simulateContract({
@@ -7588,7 +7742,7 @@ function routeErc20NonBase2() {
         value: 0n,
         from: ctx.sender
       };
-      const withdrawGas = await quoteL2Gas4({ ctx, tx: withdrawTxCandidate });
+      const withdrawGas = current >= p.amount ? await quoteL2Gas4({ ctx, tx: withdrawTxCandidate }) : void 0;
       if (withdrawGas) {
         withdrawTxCandidate.gas = withdrawGas.gasLimit;
         withdrawTxCandidate.maxFeePerGas = withdrawGas.maxFeePerGas;
@@ -7642,11 +7796,14 @@ function routeErc20NonBase2() {
   };
 }
 
-// src/core/resources/withdrawals/events.ts
+// src/core/utils/events.ts
+function extractPreferAddress(opts) {
+  const preferAddr = typeof opts?.prefer === "object" ? opts.prefer.address : opts?.prefer === "assetRouter" ? L2_ASSET_ROUTER_ADDRESS : L1_MESSENGER_ADDRESS;
+  return (preferAddr || L1_MESSENGER_ADDRESS).toLowerCase();
+}
 function findL1MessageSentLog(receipt, opts) {
   const index = opts?.index;
-  const preferAddr = typeof opts?.prefer === "object" ? opts?.prefer.address : opts?.prefer === "assetRouter" ? L2_ASSET_ROUTER_ADDRESS : L1_MESSENGER_ADDRESS;
-  const prefer = (preferAddr ?? L1_MESSENGER_ADDRESS).toLowerCase();
+  const preferAddr = extractPreferAddress(opts);
   const matches = receipt.logs.filter((lg) => {
     const t0 = (lg.topics?.[0] ?? "").toLowerCase();
     return t0 === TOPIC_L1_MESSAGE_SENT_NEW || t0 === TOPIC_L1_MESSAGE_SENT_LEG;
@@ -7654,7 +7811,7 @@ function findL1MessageSentLog(receipt, opts) {
   if (!matches.length) {
     throw new Error("No L1MessageSent event found in L2 receipt logs.");
   }
-  const preferred = matches.find((lg) => (lg.address ?? "").toLowerCase() === prefer);
+  const preferred = matches.find((lg) => (lg.address ?? "").toLowerCase() === preferAddr);
   const chosen = preferred ?? matches[index] ?? matches[0];
   if (!chosen) {
     throw new Error("No suitable L1MessageSent event found.");
@@ -7673,7 +7830,7 @@ function messengerLogIndex(raw, opts) {
   }
   return (hits[index] ?? hits[0]).i;
 }
-var { wrapAs: wrapAs9 } = createErrorHandlers("withdrawals");
+var { wrapAs: wrapAs9 } = createErrorHandlers2("withdrawals");
 var IL1NullifierMini = [
   {
     type: "function",
@@ -7780,27 +7937,11 @@ function createFinalizationServices(client) {
         message,
         merkleProof: proof.proof
       };
-      const { l1Nullifier } = await wrapAs9(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
-        () => client.ensureAddresses(),
-        {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
-        }
-      );
+      const { l1Nullifier } = await client.ensureAddresses();
       return { params, nullifier: l1Nullifier };
     },
     async simulateFinalizeReadiness(params) {
-      const { l1Nullifier } = await wrapAs9(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.readiness.ensureAddresses,
-        () => client.ensureAddresses(),
-        {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
-        }
-      );
+      const { l1Nullifier } = await client.ensureAddresses();
       const done = await (async () => {
         try {
           const result = await wrapAs9(
@@ -7837,15 +7978,7 @@ function createFinalizationServices(client) {
       }
     },
     async isWithdrawalFinalized(key) {
-      const { l1Nullifier } = await wrapAs9(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
-        () => client.ensureAddresses(),
-        {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
-        }
-      );
+      const { l1Nullifier } = await client.ensureAddresses();
       return await wrapAs9(
         "RPC",
         OP_WITHDRAWALS.finalize.isFinalized,
@@ -7862,15 +7995,7 @@ function createFinalizationServices(client) {
       );
     },
     async estimateFinalization(params) {
-      const { l1Nullifier } = await wrapAs9(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.estimate,
-        () => client.ensureAddresses(),
-        {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
-        }
-      );
+      const { l1Nullifier } = await client.ensureAddresses();
       const gasLimit = await wrapAs9(
         "RPC",
         OP_WITHDRAWALS.finalize.estimate,
@@ -7933,15 +8058,7 @@ function createFinalizationServices(client) {
       };
     },
     async finalizeDeposit(params) {
-      const { l1Nullifier } = await wrapAs9(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
-        () => client.ensureAddresses(),
-        {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
-        }
-      );
+      const { l1Nullifier } = await client.ensureAddresses();
       try {
         const hash = await client.l1Wallet.writeContract({
           address: l1Nullifier,
@@ -7956,7 +8073,7 @@ function createFinalizationServices(client) {
             try {
               return await client.l1.waitForTransactionReceipt({ hash });
             } catch (e) {
-              throw toZKsyncError(
+              throw toZKsyncError2(
                 "EXECUTION",
                 {
                   resource: "withdrawals",
@@ -7970,7 +8087,7 @@ function createFinalizationServices(client) {
           }
         };
       } catch (e) {
-        throw toZKsyncError(
+        throw toZKsyncError2(
           "EXECUTION",
           {
             resource: "withdrawals",
@@ -7999,7 +8116,7 @@ var ROUTES2 = {
 };
 function createWithdrawalsResource(client, tokens, contracts) {
   const svc = createFinalizationServices(client);
-  const { wrap: wrap2, toResult: toResult2 } = createErrorHandlers("withdrawals");
+  const { wrap: wrap3, toResult: toResult2 } = createErrorHandlers2("withdrawals");
   const tokensResource = tokens ?? createTokensResource(client);
   const contractsResource = contracts ?? createContractsResource(client);
   async function buildPlan(p) {
@@ -8020,7 +8137,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
     };
   }
   const finalizeCache = /* @__PURE__ */ new Map();
-  const quote = (p) => wrap2(OP_WITHDRAWALS.quote, async () => (await buildPlan(p)).summary, {
+  const quote = (p) => wrap3(OP_WITHDRAWALS.quote, async () => (await buildPlan(p)).summary, {
     message: "Internal error while preparing a withdrawal quote.",
     ctx: { token: p.token, where: "withdrawals.quote" }
   });
@@ -8028,7 +8145,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
     message: "Internal error while preparing a withdrawal quote.",
     ctx: { token: p.token, where: "withdrawals.tryQuote" }
   });
-  const prepare = (p) => wrap2(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
+  const prepare = (p) => wrap3(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
     message: "Internal error while preparing a withdrawal plan.",
     ctx: { token: p.token, where: "withdrawals.prepare" }
   });
@@ -8036,12 +8153,20 @@ function createWithdrawalsResource(client, tokens, contracts) {
     message: "Internal error while preparing a withdrawal plan.",
     ctx: { token: p.token, where: "withdrawals.tryPrepare" }
   });
-  const create = (p) => wrap2(
+  const create = (p) => wrap3(
     OP_WITHDRAWALS.create,
     async () => {
       const plan = await prepare(p);
       const stepHashes = {};
       const l2Wallet = client.getL2Wallet();
+      const from = client.account.address;
+      let next;
+      if (typeof p.l2TxOverrides?.nonce === "number") {
+        next = p.l2TxOverrides.nonce;
+      } else {
+        const blockTag = p.l2TxOverrides?.nonce ?? "pending";
+        next = await client.l2.getTransactionCount({ address: from, blockTag });
+      }
       for (const step of plan.steps) {
         if (p.l2TxOverrides) {
           const overrides = p.l2TxOverrides;
@@ -8075,6 +8200,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
           maxFeePerGas: step.tx.maxFeePerGas,
           maxPriorityFeePerGas: step.tx.maxPriorityFeePerGas
         } : {};
+        const nonce = next++;
         const baseReq = {
           address: step.tx.address,
           abi: step.tx.abi,
@@ -8082,6 +8208,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
           args: step.tx.args ?? [],
           account: step.tx.account ?? l2Wallet.account ?? client.account,
           gas: step.tx.gas,
+          nonce,
           ...fee1559,
           ...step.tx.dataSuffix ? { dataSuffix: step.tx.dataSuffix } : {},
           ...step.tx.chain ? { chain: step.tx.chain } : {}
@@ -8109,7 +8236,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
             });
           }
         } catch (e) {
-          throw toZKsyncError(
+          throw toZKsyncError2(
             "EXECUTION",
             {
               resource: "withdrawals",
@@ -8134,7 +8261,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
     message: "Internal error while creating withdrawal transactions.",
     ctx: { token: p.token, amount: p.amount, to: p.to, where: "withdrawals.tryCreate" }
   });
-  const status = (h) => wrap2(
+  const status = (h) => wrap3(
     OP_WITHDRAWALS.status,
     async () => {
       const l2TxHash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
@@ -8148,7 +8275,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
         if (isReceiptNotFound(e)) {
           return { phase: "L2_PENDING", l2TxHash };
         }
-        throw toZKsyncError(
+        throw toZKsyncError2(
           "RPC",
           {
             resource: "withdrawals",
@@ -8189,7 +8316,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
   const wait = (h, opts = {
     for: "l2",
     pollMs: 5500
-  }) => wrap2(
+  }) => wrap3(
     OP_WITHDRAWALS.wait,
     async () => {
       const l2Hash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
@@ -8199,7 +8326,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
         try {
           rcpt = await client.l2.waitForTransactionReceipt({ hash: l2Hash });
         } catch (e) {
-          throw toZKsyncError(
+          throw toZKsyncError2(
             "RPC",
             {
               resource: "withdrawals",
@@ -8258,7 +8385,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
       }
     }
   );
-  const finalize = (l2TxHash) => wrap2(
+  const finalize = (l2TxHash) => wrap3(
     OP_WITHDRAWALS.finalize.send,
     async () => {
       const pack = await (async () => {
@@ -8387,19 +8514,20 @@ exports.classifyReadinessFromRevert = classifyReadinessFromRevert;
 exports.createClient = createViemClient;
 exports.createContractsResource = createContractsResource;
 exports.createDepositsResource = createDepositsResource;
-exports.createErrorHandlers = createErrorHandlers;
+exports.createErrorHandlers = createErrorHandlers2;
 exports.createFinalizationServices = createFinalizationServices;
 exports.createTokensResource = createTokensResource;
 exports.createViemClient = createViemClient;
 exports.createViemSdk = createViemSdk;
 exports.createWithdrawalsResource = createWithdrawalsResource;
-exports.decodeRevert = decodeRevert;
+exports.decodeRevert = decodeRevert2;
 exports.encodeNativeTokenVaultTransferData = encodeNativeTokenVaultTransferData;
 exports.encodeSecondBridgeArgs = encodeSecondBridgeArgs;
 exports.encodeSecondBridgeDataV1 = encodeSecondBridgeDataV1;
 exports.encodeSecondBridgeErc20Args = encodeSecondBridgeErc20Args;
 exports.encodeSecondBridgeEthArgs = encodeSecondBridgeEthArgs;
+exports.getL2TransactionHashFromLogs = getL2TransactionHashFromLogs;
 exports.registerErrorAbi = registerErrorAbi;
-exports.toZKsyncError = toZKsyncError;
+exports.toZKsyncError = toZKsyncError2;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map