@matterlabs/zksync-js 0.0.13 → 0.0.15

package/dist/index.js

@@ -1,5 +1,5 @@
-export { pickDepositRoute } from './chunk-HI64OOAR.js';
-export { findL1MessageSentLog, isL1MessageSentLog, messengerLogIndex, pickWithdrawRoute } from './chunk-E3KP7XCG.js';
-export { makeTransportFromEthers, makeTransportFromViem, zks_exports as zksRpc } from './chunk-4S4XDA4N.js';
-export { abi_exports as abi, factory_exports as errors, formatEnvelopePretty, hexEq, isAddress, isAddressEq, isETH, isHash, isHash66, isHash66Array, isHashArray, normalizeAddrEq, normalizeL1Token } from './chunk-RI73VJSH.js';
-export { constants_exports as constants } from './chunk-QQ2OR434.js';
+export { pickDepositRoute } from './chunk-HVHMLAYH.js';
+export { findL1MessageSentLog, isL1MessageSentLog, messengerLogIndex, pickWithdrawRoute } from './chunk-3HHUZXSV.js';
+export { makeTransportFromEthers, makeTransportFromViem } from './chunk-BWKWWLY4.js';
+export { abi_exports as abi, factory_exports as errors, formatEnvelopePretty, hexEq, isAddress, isAddressEq, isETH, isHash, isHash66, isHash66Array, isHashArray, normalizeAddrEq, normalizeL1Token, zks_exports as zksRpc } from './chunk-JXR5V5YK.js';
+export { constants_exports as constants } from './chunk-MT4X5FEO.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterlabs/zksync-js",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "devDependencies": {

package/dist/chunk-4S4XDA4N.js

@@ -1,415 +0,0 @@
-import { createError, isBigint, isNumber, isZKsyncError, shapeCause } from './chunk-RI73VJSH.js';
-import { __export } from './chunk-QQ2OR434.js';
-
-// src/core/rpc/zks.ts
-var zks_exports = {};
-__export(zks_exports, {
-  createZksRpc: () => createZksRpc,
-  normalizeBlockMetadata: () => normalizeBlockMetadata,
-  normalizeGenesis: () => normalizeGenesis,
-  normalizeProof: () => normalizeProof
-});
-
-// src/core/errors/rpc.ts
-async function withRpcOp(operation, message, ctx, fn) {
-  try {
-    return await fn();
-  } catch (e) {
-    if (isZKsyncError(e)) throw e;
-    throw createError("RPC", {
-      resource: "zksrpc",
-      operation,
-      message,
-      context: ctx,
-      cause: shapeCause(e)
-    });
-  }
-}
-
-// src/core/rpc/zks.ts
-var METHODS = {
-  getBridgehub: "zks_getBridgehubContract",
-  getL2ToL1LogProof: "zks_getL2ToL1LogProof",
-  getReceipt: "eth_getTransactionReceipt",
-  getBytecodeSupplier: "zks_getBytecodeSupplierContract",
-  getBlockMetadataByNumber: "zks_getBlockMetadataByNumber",
-  getGenesis: "zks_getGenesis"
-};
-function toHexArray(arr) {
-  const list = Array.isArray(arr) ? arr : [];
-  return list.map((x) => x);
-}
-function normalizeProof(p) {
-  try {
-    const raw = p ?? {};
-    const idRaw = raw?.id ?? raw?.index;
-    const bnRaw = raw?.batch_number ?? raw?.batchNumber;
-    if (idRaw == null || bnRaw == null) {
-      throw createError("RPC", {
-        resource: "zksrpc",
-        operation: "zksrpc.normalizeProof",
-        message: "Malformed proof: missing id or batch number.",
-        context: { keys: Object.keys(raw ?? {}) }
-      });
-    }
-    const toBig = (x) => isBigint(x) ? x : isNumber(x) ? BigInt(x) : typeof x === "string" ? BigInt(x) : (() => {
-      throw createError("RPC", {
-        resource: "zksrpc",
-        operation: "zksrpc.normalizeProof",
-        message: "Malformed proof: invalid numeric field.",
-        context: { valueType: typeof x }
-      });
-    })();
-    return {
-      id: toBig(idRaw),
-      batchNumber: toBig(bnRaw),
-      proof: toHexArray(raw?.proof),
-      root: raw.root
-    };
-  } catch (e) {
-    if (isZKsyncError(e)) throw e;
-    throw createError("RPC", {
-      resource: "zksrpc",
-      operation: "zksrpc.normalizeProof",
-      message: "Failed to normalize proof.",
-      context: { receivedType: typeof p },
-      cause: shapeCause(e)
-    });
-  }
-}
-function ensureHex(value, field, context) {
-  if (typeof value === "string" && value.startsWith("0x")) return value;
-  throw createError("RPC", {
-    resource: "zksrpc",
-    operation: "zksrpc.normalizeGenesis",
-    message: "Malformed genesis response: expected 0x-prefixed hex value.",
-    context: { field, valueType: typeof value, ...context }
-  });
-}
-function ensureNumber(value, field, opts) {
-  const operation = opts?.operation;
-  const messagePrefix = opts?.messagePrefix;
-  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;
-  }
-  throw createError("RPC", {
-    resource: "zksrpc",
-    operation,
-    message: `${messagePrefix}: expected numeric value.`,
-    context: { field, valueType: typeof value }
-  });
-}
-function ensureBigInt(value, field, opts) {
-  const operation = opts?.operation ?? "zksrpc.normalizeBlockMetadata";
-  const messagePrefix = opts?.messagePrefix ?? "Malformed block metadata response";
-  if (isBigint(value)) return value;
-  if (isNumber(value)) {
-    if (!Number.isInteger(value)) {
-      throw createError("RPC", {
-        resource: "zksrpc",
-        operation,
-        message: `${messagePrefix}: expected integer value.`,
-        context: { field, valueType: typeof value }
-      });
-    }
-    return BigInt(value);
-  }
-  if (typeof value === "string" && value.trim() !== "") {
-    try {
-      return BigInt(value);
-    } catch {
-    }
-  }
-  throw createError("RPC", {
-    resource: "zksrpc",
-    operation,
-    message: `${messagePrefix}: expected bigint-compatible value.`,
-    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", {
-      resource: "zksrpc",
-      operation: "zksrpc.normalizeGenesis",
-      message: "Malformed genesis response: invalid contract tuple.",
-      context: { index, valueType: typeof tuple }
-    });
-  }
-  const [addrRaw, bytecodeRaw] = tuple;
-  return {
-    address: ensureHex(addrRaw, "initial_contracts.address", { index }),
-    bytecode: ensureHex(bytecodeRaw, "initial_contracts.bytecode", { index })
-  };
-}
-function normalizeRawStorageTuple(tuple, index) {
-  if (!Array.isArray(tuple) || tuple.length < 2) {
-    throw createError("RPC", {
-      resource: "zksrpc",
-      operation: "zksrpc.normalizeGenesis",
-      message: "Malformed genesis response: invalid storage tuple.",
-      context: { index, valueType: typeof tuple }
-    });
-  }
-  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 kv = normalizeRawStorageTuple(entry, index);
-      return { format: "raw", key: kv.key, value: kv.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") {
-      throw createError("RPC", {
-        resource: "zksrpc",
-        operation: "zksrpc.normalizeGenesis",
-        message: "Malformed genesis response: expected object.",
-        context: { receivedType: typeof raw }
-      });
-    }
-    const record = raw;
-    const contractsRaw = record["initial_contracts"];
-    if (!Array.isArray(contractsRaw)) {
-      throw createError("RPC", {
-        resource: "zksrpc",
-        operation: "zksrpc.normalizeGenesis",
-        message: "Malformed genesis response: initial_contracts must be an array.",
-        context: { valueType: typeof contractsRaw }
-      });
-    }
-    const genesisRoot = ensureHex(record["genesis_root"], "genesis_root", {});
-    const initialContracts = contractsRaw.map(
-      (entry, index) => normalizeContractTuple(entry, index)
-    );
-    const additionalStorage = normalizeAdditionalStorage(record["additional_storage"], record);
-    return {
-      initialContracts,
-      additionalStorage,
-      genesisRoot
-    };
-  } catch (e) {
-    if (isZKsyncError(e)) throw e;
-    throw createError("RPC", {
-      resource: "zksrpc",
-      operation: "zksrpc.normalizeGenesis",
-      message: "Failed to normalize genesis response.",
-      context: { receivedType: typeof raw },
-      cause: shapeCause(e)
-    });
-  }
-}
-function normalizeBlockMetadata(raw) {
-  try {
-    if (!raw || typeof raw !== "object") {
-      throw createError("RPC", {
-        resource: "zksrpc",
-        operation: "zksrpc.normalizeBlockMetadata",
-        message: "Malformed block metadata response: expected object.",
-        context: { receivedType: typeof raw }
-      });
-    }
-    const record = raw;
-    const pubdataPricePerByte = ensureBigInt(
-      record["pubdata_price_per_byte"] ?? record["pubdataPricePerByte"],
-      "pubdata_price_per_byte",
-      {
-        operation: "zksrpc.normalizeBlockMetadata",
-        messagePrefix: "Malformed block metadata response"
-      }
-    );
-    const nativePrice = ensureBigInt(
-      record["native_price"] ?? record["nativePrice"],
-      "native_price",
-      {
-        operation: "zksrpc.normalizeBlockMetadata",
-        messagePrefix: "Malformed block metadata response"
-      }
-    );
-    const executionVersion = ensureNumber(
-      record["execution_version"] ?? record["executionVersion"],
-      "execution_version",
-      {
-        operation: "zksrpc.normalizeBlockMetadata",
-        messagePrefix: "Malformed block metadata response"
-      }
-    );
-    return {
-      pubdataPricePerByte,
-      nativePrice,
-      executionVersion
-    };
-  } catch (e) {
-    if (isZKsyncError(e)) throw e;
-    throw createError("RPC", {
-      resource: "zksrpc",
-      operation: "zksrpc.normalizeBlockMetadata",
-      message: "Failed to normalize block metadata response.",
-      context: { receivedType: typeof raw },
-      cause: shapeCause(e)
-    });
-  }
-}
-function createZksRpc(transport) {
-  return {
-    // Fetches the Bridgehub contract address.
-    async getBridgehubAddress() {
-      return withRpcOp(
-        "zksrpc.getBridgehubAddress",
-        "Failed to fetch Bridgehub address.",
-        {},
-        async () => {
-          const addrRaw = await transport(METHODS.getBridgehub, []);
-          if (typeof addrRaw !== "string" || !addrRaw.startsWith("0x")) {
-            throw createError("RPC", {
-              resource: "zksrpc",
-              operation: "zksrpc.getBridgehubAddress",
-              message: "Unexpected Bridgehub address response.",
-              context: { valueType: typeof addrRaw }
-            });
-          }
-          return addrRaw;
-        }
-      );
-    },
-    // Fetches the Bytecode Supplier contract address.
-    async getBytecodeSupplierAddress() {
-      return withRpcOp(
-        "zksrpc.getBytecodeSupplierAddress",
-        "Failed to fetch Bytecode Supplier address.",
-        {},
-        async () => {
-          const addrRaw = await transport(METHODS.getBytecodeSupplier, []);
-          if (typeof addrRaw !== "string" || !addrRaw.startsWith("0x")) {
-            throw createError("RPC", {
-              resource: "zksrpc",
-              operation: "zksrpc.getBytecodeSupplierAddress",
-              message: "Unexpected Bytecode Supplier address response.",
-              context: { valueType: typeof addrRaw }
-            });
-          }
-          return addrRaw;
-        }
-      );
-    },
-    // Fetches a proof for an L2→L1 log emitted in the given transaction.
-    async getL2ToL1LogProof(txHash, index) {
-      return withRpcOp(
-        "zksrpc.getL2ToL1LogProof",
-        "Failed to fetch L2\u2192L1 log proof.",
-        { txHash, index },
-        async () => {
-          const proof = await transport(METHODS.getL2ToL1LogProof, [txHash, index]);
-          if (!proof) {
-            throw createError("STATE", {
-              resource: "zksrpc",
-              operation: "zksrpc.getL2ToL1LogProof",
-              message: "Proof not yet available. Please try again later.",
-              context: { txHash, index }
-            });
-          }
-          return normalizeProof(proof);
-        }
-      );
-    },
-    // Fetches the transaction receipt, including the `l2ToL1Logs` field.
-    async getReceiptWithL2ToL1(txHash) {
-      return withRpcOp(
-        "zksrpc.getReceiptWithL2ToL1",
-        "Failed to fetch transaction receipt.",
-        { txHash },
-        async () => {
-          const rcptRaw = await transport(METHODS.getReceipt, [txHash]);
-          if (!rcptRaw) return null;
-          const rcptObj = rcptRaw;
-          const logs = Array.isArray(rcptObj["l2ToL1Logs"]) ? rcptObj["l2ToL1Logs"] : [];
-          rcptObj["l2ToL1Logs"] = logs;
-          return rcptObj;
-        }
-      );
-    },
-    // Fetches block metadata for the given block number.
-    async getBlockMetadataByNumber(blockNumber) {
-      return withRpcOp(
-        "zksrpc.getBlockMetadataByNumber",
-        "Failed to fetch block metadata.",
-        { blockNumber },
-        async () => {
-          const raw = await transport(METHODS.getBlockMetadataByNumber, [blockNumber]);
-          if (raw == null) return null;
-          return normalizeBlockMetadata(raw);
-        }
-      );
-    },
-    // Fetches the genesis configuration returned by `zks_getGenesis`.
-    async getGenesis() {
-      return withRpcOp(
-        "zksrpc.getGenesis",
-        "Failed to fetch genesis configuration.",
-        {},
-        async () => {
-          const genesisRaw = await transport(METHODS.getGenesis, []);
-          return normalizeGenesis(genesisRaw);
-        }
-      );
-    }
-  };
-}
-
-// src/core/rpc/transport.ts
-function makeTransportFromEthers(provider) {
-  return (m, p = []) => provider.send(m, p);
-}
-function makeTransportFromViem(client) {
-  return (m, p = []) => client.request({ method: m, params: p });
-}
-
-export { createZksRpc, makeTransportFromEthers, makeTransportFromViem, zks_exports };

package/dist/chunk-5L6EYUJB.js

@@ -1,237 +0,0 @@
-import { IBridgehub_default } from './chunk-RI73VJSH.js';
-import { BUFFER, DEFAULT_ABI_BYTES, DEFAULT_PUBDATA_BYTES, TX_MEMORY_OVERHEAD_GAS, TX_OVERHEAD_GAS } from './chunk-QQ2OR434.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/types/fees.ts
-function toGasOverrides(overrides) {
-  const { nonce: _, ...gas } = overrides;
-  return gas;
-}
-
-// 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, toGasOverrides };