@matterlabs/zksync-js 0.0.13 → 0.0.15

package/dist/chunk-K2UVKMLN.js

@@ -0,0 +1,658 @@
+import { isL1MessageSentLog } from './chunk-3HHUZXSV.js';
+import { IBridgehub_default, isHash66, isBigint, isHash, assertNever, createError, OP_INTEROP, isNumber, isAddress, isHash66Array } from './chunk-JXR5V5YK.js';
+import { BUFFER, DEFAULT_ABI_BYTES, DEFAULT_PUBDATA_BYTES, TX_MEMORY_OVERHEAD_GAS, TX_OVERHEAD_GAS, L1_TX_MIN_L2_GAS_BASE, L1_TX_INTRINSIC_L2_GAS, L1_TX_DELTA_544_ENCODING_BYTES, L1_TX_DELTA_FACTORY_DEPS_L2_GAS, L1_TX_INTRINSIC_PUBDATA, L1_TX_DELTA_FACTORY_DEPS_PUBDATA, TX_SLOT_OVERHEAD_L2_GAS, PRIORITY_TX_MAX_GAS_LIMIT, L2_INTEROP_CENTER_ADDRESS, BUNDLE_IDENTIFIER } from './chunk-MT4X5FEO.js';
+
+// src/core/resources/deposits/chains.ts
+var ERAVM_CHAIN_IDS = /* @__PURE__ */ new Set([324n, 2741n, 11124n, 300n]);
+function isEraVmChain(chainIdL2) {
+  return ERAVM_CHAIN_IDS.has(chainIdL2);
+}
+
+// src/core/resources/deposits/gas.ts
+var CREATE_REESTIMATE_BUFFER = 15n;
+var maxBigInt = (a, b) => a > b ? a : b;
+function applyGasBuffer(gasLimit, bufferPct = BUFFER) {
+  return gasLimit * (100n + bufferPct) / 100n;
+}
+function resolveCreateDepositL1GasLimit(input) {
+  const { chainIdL2, stepKey, preparedGasLimit, estimatedGasLimit } = input;
+  if (estimatedGasLimit == null) {
+    return preparedGasLimit;
+  }
+  const isEraVmBridgeStep = isEraVmChain(chainIdL2) && stepKey.startsWith("bridgehub:");
+  const reestimatedGasLimit = applyGasBuffer(
+    estimatedGasLimit,
+    isEraVmBridgeStep ? BUFFER : CREATE_REESTIMATE_BUFFER
+  );
+  if (isEraVmBridgeStep && preparedGasLimit != null) {
+    return maxBigInt(preparedGasLimit, reestimatedGasLimit);
+  }
+  return reestimatedGasLimit;
+}
+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 = applyGasBuffer(BigInt(est));
+    return makeGasQuote({ gasLimit: buffered, maxFeePerGas, maxPriorityFeePerGas });
+  } catch {
+    if (fallbackGasLimit != null) {
+      return makeGasQuote({ gasLimit: fallbackGasLimit, maxFeePerGas, maxPriorityFeePerGas });
+    }
+    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 = applyGasBuffer(total);
+    return makeGasQuote({
+      gasLimit: total,
+      maxFeePerGas,
+      gasPerPubdata: pp
+    });
+  } catch {
+    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/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/flows/interop.ts
+function isInteropMessageProof(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const proof = obj;
+  return isBigint(proof.chainId) && isBigint(proof.l1BatchNumber) && isBigint(proof.l2MessageIndex) && typeof proof.message === "object" && proof.message !== null && isNumber(proof.message.txNumberInBatch) && isAddress(proof.message.sender) && isHash(proof.message.data) && isHash66Array(proof.proof);
+}
+function isInteropFinalizationInfo(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const info = obj;
+  return isHash66(info.l2SrcTxHash) && isHash66(info.bundleHash) && isBigint(info.dstChainId) && isHash(info.encodedData) && isInteropMessageProof(info.proof);
+}
+
+// src/core/resources/interop/route.ts
+function sumActionMsgValue(actions) {
+  let sum = 0n;
+  for (const a of actions) {
+    if (a.type === "sendNative") sum += a.amount;
+    else if (a.type === "call" && a.value) sum += a.value;
+  }
+  return sum;
+}
+function sumErc20Amounts(actions) {
+  let sum = 0n;
+  for (const a of actions) if (a.type === "sendErc20") sum += a.amount;
+  return sum;
+}
+function pickInteropRoute(args) {
+  const hasErc20 = args.actions.some((a) => a.type === "sendErc20");
+  const baseMatches = args.ctx.baseTokenSrc.toLowerCase() === args.ctx.baseTokenDst.toLowerCase();
+  if (hasErc20) return "indirect";
+  if (!baseMatches) return "indirect";
+  return "direct";
+}
+
+// src/core/types/primitives.ts
+var ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
+
+// 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/priority.ts
+var PRIORITY_TX_ENCODING_STEP_BYTES = 544n;
+var DEFAULT_PRIORITY_BODY_GAS_ESTIMATE_MULTIPLIER = 6n;
+var ERAVM_PRIORITY_L2_GAS_BUFFER = 30n;
+var maxBigInt2 = (a, b) => a > b ? a : b;
+var ceilDiv = (a, b) => (a + b - 1n) / b;
+function derivePriorityTxGasBreakdown(input) {
+  const factoryDepsCount = input.factoryDepsCount ?? 0n;
+  const minBodyGas = maxBigInt2(
+    L1_TX_INTRINSIC_L2_GAS + ceilDiv(
+      input.encodedLength * L1_TX_DELTA_544_ENCODING_BYTES,
+      PRIORITY_TX_ENCODING_STEP_BYTES
+    ) + factoryDepsCount * L1_TX_DELTA_FACTORY_DEPS_L2_GAS,
+    L1_TX_MIN_L2_GAS_BASE
+  ) + L1_TX_INTRINSIC_PUBDATA * input.gasPerPubdata + factoryDepsCount * L1_TX_DELTA_FACTORY_DEPS_PUBDATA * input.gasPerPubdata;
+  const overhead = maxBigInt2(TX_SLOT_OVERHEAD_L2_GAS, TX_MEMORY_OVERHEAD_GAS * input.encodedLength);
+  const derivedBodyGas = minBodyGas;
+  return {
+    encodedLength: input.encodedLength,
+    minBodyGas,
+    overhead,
+    derivedBodyGas,
+    derivedL2GasLimit: derivedBodyGas + overhead,
+    priorityTxMaxGasLimit: PRIORITY_TX_MAX_GAS_LIMIT,
+    priorityTxMaxGasLimitExceeded: derivedBodyGas > PRIORITY_TX_MAX_GAS_LIMIT
+  };
+}
+function derivePriorityBodyGasEstimateCap(input) {
+  return input.minBodyGas * (input.multiplier ?? DEFAULT_PRIORITY_BODY_GAS_ESTIMATE_MULTIPLIER);
+}
+function applyPriorityL2GasLimitBuffer(input) {
+  if (!isEraVmChain(input.chainIdL2)) {
+    return input.gasLimit;
+  }
+  return input.gasLimit * (100n + ERAVM_PRIORITY_L2_GAS_BUFFER) / 100n;
+}
+
+// src/core/resources/interop/attributes/call.ts
+function createCallAttributes(codec) {
+  const indirectCall = (messageValue) => codec.encode("indirectCall", [messageValue]);
+  const interopCallValue = (bridgedAmount) => codec.encode("interopCallValue", [bridgedAmount]);
+  return {
+    indirectCall,
+    interopCallValue
+  };
+}
+
+// src/core/resources/interop/attributes/bundle.ts
+function createBundleAttributes(codec) {
+  const executionAddress = (executor) => codec.encode("executionAddress", [executor]);
+  const unbundlerAddress = (addr) => codec.encode("unbundlerAddress", [addr]);
+  const useFixedFee = (enabled) => codec.encode("useFixedFee", [enabled]);
+  return {
+    executionAddress,
+    unbundlerAddress,
+    useFixedFee
+  };
+}
+
+// src/core/resources/interop/attributes/resource.ts
+function createAttributesResource(codec) {
+  return {
+    call: createCallAttributes(codec),
+    bundle: createBundleAttributes(codec)
+  };
+}
+
+// src/core/resources/interop/plan.ts
+function preflightDirect(params, ctx) {
+  if (!params.actions?.length) {
+    throw new Error('route "direct" requires at least one action.');
+  }
+  const baseMatch = ctx.baseTokens.src.toLowerCase() === ctx.baseTokens.dst.toLowerCase();
+  if (!baseMatch) {
+    throw new Error('route "direct" requires matching base tokens between source and destination.');
+  }
+  for (const action of params.actions) {
+    switch (action.type) {
+      case "sendNative":
+        if (action.amount < 0n) {
+          throw new Error("sendNative.amount must be >= 0.");
+        }
+        break;
+      case "call":
+        if (action.value != null && action.value < 0n) {
+          throw new Error("call.value must be >= 0 when provided.");
+        }
+        break;
+      default:
+        throw new Error(
+          `route "direct" does not support ${action.type} actions; use the indirect route.`
+        );
+    }
+  }
+}
+function buildDirectBundle(params, ctx, attrs, interopFeeInfo) {
+  const totalActionValue = sumActionMsgValue(params.actions);
+  const starters = params.actions.map((action, index) => {
+    const to = ctx.codec.formatAddress(action.to);
+    const callAttributes = attrs.callAttributes[index] ?? [];
+    switch (action.type) {
+      case "sendNative":
+        return [to, "0x", callAttributes];
+      case "call":
+        return [to, action.data ?? "0x", callAttributes];
+      default:
+        throw new Error(`buildDirectBundle: unsupported action type "${action.type}".`);
+    }
+  });
+  return {
+    dstChain: ctx.codec.formatChain(ctx.dstChainId),
+    starters,
+    bundleAttributes: attrs.bundleAttributes,
+    approvals: interopFeeInfo.approval ? [interopFeeInfo.approval] : [],
+    interopFee: interopFeeInfo.fee,
+    quoteExtras: {
+      totalActionValue,
+      bridgedTokenTotal: 0n
+    }
+  };
+}
+function preflightIndirect(params, ctx) {
+  if (!params.actions?.length) {
+    throw new Error('route "indirect" requires at least one action.');
+  }
+  const hasErc20 = params.actions.some((a) => a.type === "sendErc20");
+  const baseMatches = ctx.baseTokens.src.toLowerCase() === ctx.baseTokens.dst.toLowerCase();
+  if (!hasErc20 && baseMatches) {
+    throw new Error(
+      'route "indirect" requires ERC-20 actions or mismatched base tokens; use the direct route instead.'
+    );
+  }
+  for (const action of params.actions) {
+    switch (action.type) {
+      case "sendNative":
+        if (action.amount < 0n) {
+          throw new Error("sendNative.amount must be >= 0.");
+        }
+        break;
+      case "sendErc20":
+        if (action.amount < 0n) {
+          throw new Error("sendErc20.amount must be >= 0.");
+        }
+        break;
+      case "call":
+        if (action.value != null) {
+          if (action.value < 0n) {
+            throw new Error("call.value must be >= 0 when provided.");
+          }
+          if (action.value > 0n && !baseMatches) {
+            throw new Error("indirect route does not support call.value when base tokens differ.");
+          }
+        }
+        break;
+      default:
+        assertNever(action);
+    }
+  }
+}
+function buildIndirectBundle(params, ctx, attrs, starterData, interopFeeInfo) {
+  const totalActionValue = sumActionMsgValue(params.actions);
+  const bridgedTokenTotal = sumErc20Amounts(params.actions);
+  const approvalMap = /* @__PURE__ */ new Map();
+  for (const action of params.actions) {
+    if (action.type !== "sendErc20") continue;
+    const key = action.token.toLowerCase();
+    const existing = approvalMap.get(key);
+    if (existing) {
+      existing.amount += action.amount;
+    } else {
+      approvalMap.set(key, {
+        token: action.token,
+        spender: ctx.l2NativeTokenVault,
+        amount: action.amount
+      });
+    }
+  }
+  const approvals = Array.from(approvalMap.values());
+  if (interopFeeInfo.approval) approvals.push(interopFeeInfo.approval);
+  const starters = params.actions.map((action, index) => {
+    const callAttributes = attrs.callAttributes[index] ?? [];
+    if (starterData[index]?.assetRouterPayload) {
+      const l2AssetRouter = ctx.codec.formatAddress(ctx.l2AssetRouter);
+      return [l2AssetRouter, starterData[index].assetRouterPayload, callAttributes];
+    }
+    const directTo = ctx.codec.formatAddress(action.to);
+    switch (action.type) {
+      case "sendNative":
+        return [directTo, "0x", callAttributes];
+      case "call":
+        return [directTo, action.data ?? "0x", callAttributes];
+      case "sendErc20":
+        throw new Error("buildIndirectBundle: missing assetRouterPayload for sendErc20 action.");
+      default:
+        return assertNever(action);
+    }
+  });
+  return {
+    dstChain: ctx.codec.formatChain(ctx.dstChainId),
+    starters,
+    bundleAttributes: attrs.bundleAttributes,
+    approvals,
+    interopFee: interopFeeInfo.fee,
+    quoteExtras: {
+      totalActionValue,
+      bridgedTokenTotal
+    }
+  };
+}
+
+// src/core/resources/interop/protocol.ts
+var MIN_INTEROP_PROTOCOL = 31;
+function assertProtocolVersion(chainId, protocolVersion) {
+  if (protocolVersion[1] < MIN_INTEROP_PROTOCOL) {
+    throw createError("VALIDATION", {
+      resource: "interop",
+      operation: OP_INTEROP.context.protocolVersion,
+      message: `Interop requires protocol version 31.0+. Found: ${protocolVersion[1]}.${protocolVersion[2]} for chain: ${chainId}.`,
+      context: {
+        chainId,
+        requiredMinor: MIN_INTEROP_PROTOCOL,
+        semver: protocolVersion
+      }
+    });
+  }
+}
+
+// src/core/resources/interop/finalization.ts
+var DEFAULT_POLL_MS = 1e3;
+var DEFAULT_TIMEOUT_MS = 3e5;
+function resolveIdsFromWaitable(input) {
+  if (typeof input === "string") {
+    return { l2SrcTxHash: input };
+  }
+  return {
+    l2SrcTxHash: input.l2SrcTxHash,
+    bundleHash: input.bundleHash,
+    dstExecTxHash: input.dstExecTxHash
+  };
+}
+function parseBundleSentFromReceipt(input) {
+  const { receipt, interopCenter, interopBundleSentTopic, decodeInteropBundleSent } = input;
+  const bundleSentLog = receipt.logs.find(
+    (log) => log.address.toLowerCase() === interopCenter.toLowerCase() && log.topics[0].toLowerCase() === interopBundleSentTopic.toLowerCase()
+  );
+  if (!bundleSentLog) {
+    throw createError("STATE", {
+      resource: "interop",
+      operation: OP_INTEROP.svc.status.parseSentLog,
+      message: "Failed to locate InteropBundleSent event in source receipt.",
+      context: { receipt, interopCenter }
+    });
+  }
+  const decoded = decodeInteropBundleSent({
+    data: bundleSentLog.data,
+    topics: bundleSentLog.topics
+  });
+  return { bundleHash: decoded.bundleHash, dstChainId: decoded.destinationChainId };
+}
+function parseBundleReceiptInfo(params) {
+  const {
+    rawReceipt,
+    interopCenter,
+    interopBundleSentTopic,
+    decodeInteropBundleSent,
+    decodeL1MessageData,
+    l2SrcTxHash
+  } = params;
+  let l2ToL1LogIndex = -1;
+  let l1MessageData = null;
+  let found;
+  for (const log of rawReceipt.logs) {
+    if (isL1MessageSentLog(log)) {
+      l2ToL1LogIndex += 1;
+      try {
+        l1MessageData = decodeL1MessageData(log);
+      } catch (e) {
+        throw createError("STATE", {
+          resource: "interop",
+          operation: OP_INTEROP.svc.status.parseSentLog,
+          message: "Failed to decode L1MessageSent log data for interop bundle.",
+          context: { l2SrcTxHash, l2ToL1LogIndex },
+          cause: e
+        });
+      }
+      continue;
+    }
+    if (log.address.toLowerCase() !== interopCenter.toLowerCase() || log.topics[0].toLowerCase() !== interopBundleSentTopic.toLowerCase())
+      continue;
+    const decoded = decodeInteropBundleSent({
+      data: log.data,
+      topics: log.topics
+    });
+    found = {
+      bundleHash: decoded.bundleHash,
+      dstChainId: decoded.destinationChainId,
+      sourceChainId: decoded.sourceChainId
+    };
+    break;
+  }
+  if (!found) {
+    throw createError("STATE", {
+      resource: "interop",
+      operation: OP_INTEROP.svc.status.parseSentLog,
+      message: "Failed to locate InteropBundleSent event in source receipt.",
+      context: { l2SrcTxHash, interopCenter }
+    });
+  }
+  if (!l1MessageData) {
+    throw createError("STATE", {
+      resource: "interop",
+      operation: OP_INTEROP.svc.status.parseSentLog,
+      message: "Failed to locate L1MessageSent log data for interop bundle.",
+      context: { l2SrcTxHash, interopCenter }
+    });
+  }
+  return {
+    bundleHash: found.bundleHash,
+    dstChainId: found.dstChainId,
+    sourceChainId: found.sourceChainId,
+    l1MessageData,
+    l2ToL1LogIndex,
+    txNumberInBatch: Number(rawReceipt.transactionIndex),
+    rawReceipt
+  };
+}
+function getBundleEncodedData(messageData) {
+  const prefix = `0x${messageData.slice(2, 4)}`;
+  if (prefix !== BUNDLE_IDENTIFIER) {
+    throw createError("STATE", {
+      resource: "interop",
+      operation: OP_INTEROP.wait,
+      message: "Unexpected bundle prefix in L1MessageSent data.",
+      context: { prefix, expected: BUNDLE_IDENTIFIER }
+    });
+  }
+  return `0x${messageData.slice(4)}`;
+}
+function buildFinalizationInfo(ids, bundleInfo, proof, messageData) {
+  const messageProof = {
+    chainId: bundleInfo.sourceChainId,
+    l1BatchNumber: proof.batchNumber,
+    l2MessageIndex: proof.id,
+    message: {
+      txNumberInBatch: bundleInfo.txNumberInBatch,
+      sender: L2_INTEROP_CENTER_ADDRESS,
+      data: messageData
+    },
+    proof: proof.proof
+  };
+  return {
+    l2SrcTxHash: ids.l2SrcTxHash,
+    bundleHash: bundleInfo.bundleHash,
+    dstChainId: bundleInfo.dstChainId,
+    proof: messageProof,
+    encodedData: getBundleEncodedData(messageData)
+  };
+}
+
+// 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 { DEFAULT_POLL_MS, DEFAULT_TIMEOUT_MS, ZERO_HASH, applyPriorityL2GasLimitBuffer, assertProtocolVersion, buildDirectBundle, buildFeeBreakdown, buildFinalizationInfo, buildIndirectBundle, createAttributesResource, createNTVCodec, derivePriorityBodyGasEstimateCap, derivePriorityTxGasBreakdown, isInteropFinalizationInfo, parseBundleReceiptInfo, parseBundleSentFromReceipt, pickInteropRoute, preflightDirect, preflightIndirect, quoteL1Gas, quoteL2BaseCost, quoteL2Gas, quoteL2Gas2, resolveCreateDepositL1GasLimit, resolveIdsFromWaitable, toGasOverrides };

package/dist/{chunk-53MC5BR2.js → chunk-MDPX5LNW.js}

@@ -1,4 +1,4 @@
-import { isZKsyncError, createError, shapeCause } from './chunk-RI73VJSH.js';
+import { isZKsyncError, createError, shapeCause } from './chunk-JXR5V5YK.js';
 
 // src/core/errors/error-ops.ts
 function resolveMessage(op, msg) {