@matterlabs/zksync-js 0.0.14 → 0.0.16

package/dist/{chunk-XKRNLFET.js → chunk-5HG2DUYW.js}

@@ -1,9 +1,9 @@
-import { createErrorHandlers, toZKsyncError, classifyReadinessFromRevert } from './chunk-5RRJDPAJ.js';
-import { createNTVCodec, toGasOverrides, buildFeeBreakdown, derivePriorityTxGasBreakdown, quoteL2Gas, quoteL2BaseCost, quoteL1Gas, derivePriorityBodyGasEstimateCap, quoteL2Gas2 } from './chunk-EOBXYHTZ.js';
-import { findL1MessageSentLog, messengerLogIndex, isL1MessageSentLog, pickWithdrawRoute } from './chunk-3HHUZXSV.js';
-import { isHash66, IL1Nullifier_default, OP_WITHDRAWALS, createError, normalizeL1Token, isAddressEq, hexEq, OP_DEPOSITS, IERC20_default, isZKsyncError, isReceiptNotFound, OP_INTEROP, IInteropHandler_default, IERC7786Attributes_default, isBigint, isHash, IInteropCenter_default, sleep, isETH, normalizeAddrEq, isNumber, isAddress, isHash66Array, IInteropRootStorage_default, IL2AssetRouter_default, L2NativeTokenVault_default, assertNever } from './chunk-JY62QO3W.js';
-import { ETH_ADDRESS, TOPIC_CANONICAL_ASSIGNED, TOPIC_CANONICAL_SUCCESS, L1_MESSENGER_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, L2_INTEROP_CENTER_ADDRESS, BUNDLE_IDENTIFIER, L2_INTEROP_ROOT_STORAGE_ADDRESS, SAFE_L1_BRIDGE_GAS, L2_ASSET_ROUTER_ADDRESS, FORMAL_ETH_ADDRESS } from './chunk-MT4X5FEO.js';
-import { Interface, keccak256, AbiCoder, ethers, getBytes, Contract, NonceManager, JsonRpcProvider, isError, getAddress, concat, hexlify, toBeArray, toBeHex } from 'ethers';
+import { createErrorHandlers, toZKsyncError, classifyReadinessFromRevert } from './chunk-NJK325XV.js';
+import { createNTVCodec, resolveCreateDepositL1GasLimit, isInteropFinalizationInfo, DEFAULT_POLL_MS, DEFAULT_TIMEOUT_MS, resolveIdsFromWaitable, parseBundleReceiptInfo, buildFinalizationInfo, parseBundleSentFromReceipt, createAttributesResource, pickInteropRoute, ZERO_HASH, toGasOverrides, applyPriorityL2GasLimitBuffer, buildFeeBreakdown, buildIndirectBundle, preflightIndirect, buildDirectBundle, preflightDirect, derivePriorityTxGasBreakdown, quoteL2Gas, quoteL2BaseCost, quoteL1Gas, derivePriorityBodyGasEstimateCap, quoteL2Gas2, assertProtocolVersion } from './chunk-NLUCYVMX.js';
+import { findL1MessageSentLog, messengerLogIndex, pickWithdrawRoute } from './chunk-3HHUZXSV.js';
+import { isHash66, IL1Nullifier_default, OP_WITHDRAWALS, createError, normalizeL1Token, isAddressEq, hexEq, OP_DEPOSITS, IERC20_default, isZKsyncError, isReceiptNotFound, OP_INTEROP, IInteropHandler_default, IERC7786Attributes_default, IInteropRootStorage_default, IInteropCenter_default, sleep, isETH, normalizeAddrEq, IL2AssetRouter_default, L2NativeTokenVault_default, assertNever } from './chunk-UEKFQAOS.js';
+import { ETH_ADDRESS, TOPIC_CANONICAL_ASSIGNED, TOPIC_CANONICAL_SUCCESS, L1_MESSENGER_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, L2_INTEROP_ROOT_STORAGE_ADDRESS, BUFFER, SAFE_L1_BRIDGE_GAS, L2_ASSET_ROUTER_ADDRESS, FORMAL_ETH_ADDRESS } from './chunk-MT4X5FEO.js';
+import { Interface, keccak256, AbiCoder, ethers, getBytes, Contract, NonceManager, JsonRpcProvider, getAddress, concat, hexlify, toBeArray, toBeHex, isError } from 'ethers';
 
 var I_BRIDGEHUB = new Interface([
   "event NewPriorityRequest(uint256 indexed chainId, address indexed sender, bytes32 txHash, uint256 txId, bytes data)"
@@ -388,7 +388,10 @@ function routeEthDirect() {
         l2Calldata,
         gasPerPubdata: ctx.gasPerPubdata
       });
-      const quotedL2GasLimit = ctx.l2GasLimit ?? priorityFloorBreakdown.derivedL2GasLimit;
+      const quotedL2GasLimit = ctx.l2GasLimit ?? applyPriorityL2GasLimitBuffer({
+        chainIdL2: ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      });
       const l2GasParams = await quoteL2Gas3({
         ctx,
         route: "eth-base",
@@ -450,11 +453,6 @@ function routeEthDirect() {
     }
   };
 }
-
-// src/core/types/primitives.ts
-var ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
-
-// src/adapters/ethers/resources/deposits/routes/erc20-nonbase.ts
 var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
 var ZERO_L2_TOKEN_ADDRESS2 = "0x0000000000000000000000000000000000000000";
 var ZERO_ASSET_ID = "0x0000000000000000000000000000000000000000000000000000000000000000";
@@ -491,7 +489,10 @@ async function getPriorityGasModel(input) {
       gasPerPubdata: input.ctx.gasPerPubdata
     });
     const model = {
-      priorityFloorGasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      priorityFloorGasLimit: applyPriorityL2GasLimitBuffer({
+        chainIdL2: input.ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      })
     };
     if (isFirstBridge || input.ctx.resolvedToken.l2.toLowerCase() === ZERO_L2_TOKEN_ADDRESS2) {
       model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
@@ -697,7 +698,10 @@ async function getPriorityGasModel2(input) {
       gasPerPubdata: input.ctx.gasPerPubdata
     });
     const model = {
-      priorityFloorGasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      priorityFloorGasLimit: applyPriorityL2GasLimitBuffer({
+        chainIdL2: input.ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      })
     };
     if (input.ctx.resolvedToken.l2.toLowerCase() === ZERO_L2_TOKEN_ADDRESS3) {
       model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
@@ -819,7 +823,7 @@ function routeEthNonBase() {
       const requestStruct = {
         chainId: ctx.chainIdL2,
         mintValue,
-        l2Value: p.amount,
+        l2Value: 0n,
         l2GasLimit: l2GasParams.gasLimit,
         l2GasPerPubdataByteLimit: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
@@ -827,6 +831,7 @@ function routeEthNonBase() {
         secondBridgeValue: p.amount,
         secondBridgeCalldata
       };
+      const bridgehubValue = p.amount;
       const bridgehub = await ctx.contracts.bridgehub();
       const data = bridgehub.interface.encodeFunctionData("requestL2TransactionTwoBridges", [
         requestStruct
@@ -834,8 +839,7 @@ function routeEthNonBase() {
       const l1TxCandidate = {
         to: ctx.bridgehub,
         data,
-        value: p.amount,
-        // base ≠ ETH ⇒ msg.value == secondBridgeValue
+        value: bridgehubValue,
         from: ctx.sender,
         ...ctx.gasOverrides
       };
@@ -914,7 +918,10 @@ function routeErc20Base() {
         l2Calldata,
         gasPerPubdata: ctx.gasPerPubdata
       });
-      const quotedL2GasLimit = ctx.l2GasLimit ?? priorityFloorBreakdown.derivedL2GasLimit;
+      const quotedL2GasLimit = ctx.l2GasLimit ?? applyPriorityL2GasLimitBuffer({
+        chainIdL2: ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      });
       const l2GasParams = await quoteL2Gas3({
         ctx,
         route: "erc20-base",
@@ -1340,6 +1347,8 @@ function createDepositsResource(client, tokens, contracts) {
     async () => {
       const plan = await prepare(p);
       const stepHashes = {};
+      const { chainId } = await client.l2.getNetwork();
+      const chainIdL2 = BigInt(chainId);
       const managed = new NonceManager(client.signer);
       const from = await managed.getAddress();
       let next;
@@ -1385,8 +1394,14 @@ function createDepositsResource(client, tokens, contracts) {
         }
         if (!p.l1TxOverrides?.gasLimit) {
           try {
+            const preparedGasLimit = step.tx.gasLimit != null ? BigInt(step.tx.gasLimit.toString()) : void 0;
             const est = await client.l1.estimateGas(step.tx);
-            step.tx.gasLimit = BigInt(est) * 115n / 100n;
+            step.tx.gasLimit = resolveCreateDepositL1GasLimit({
+              chainIdL2,
+              stepKey: step.key,
+              preparedGasLimit,
+              estimatedGasLimit: BigInt(est)
+            });
           } catch {
           }
         }
@@ -2374,38 +2389,6 @@ function createWithdrawalsResource(client, tokens, contracts) {
     tryWait
   };
 }
-
-// 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/adapters/ethers/resources/interop/attributes/resource.ts
 function getInteropAttributes(params, ctx) {
   const bundleAttributes = [];
   if (params.execution?.only) {
@@ -2442,183 +2425,6 @@ function createEthersAttributesResource(opts = {}) {
   const encode2 = (fn, args) => iface.encodeFunctionData(fn, args);
   return createAttributesResource({ encode: encode2 });
 }
-
-// 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/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
-    }
-  };
-}
 var PREFIX_EVM_CHAIN = getBytes("0x00010000");
 var PREFIX_EVM_ADDRESS = getBytes("0x000100000014");
 function formatInteropEvmChain(chainId) {
@@ -2783,7 +2589,9 @@ function routeIndirect() {
         dstChainId: ctx.dstChainId,
         baseTokens: ctx.baseTokens,
         l2AssetRouter: ctx.l2AssetRouter,
-        l2NativeTokenVault: ctx.l2NativeTokenVault});
+        l2NativeTokenVault: ctx.l2NativeTokenVault,
+        codec: interopCodec
+      });
     },
     async build(params, ctx) {
       const steps = [];
@@ -2844,7 +2652,9 @@ function routeDirect() {
         dstChainId: ctx.dstChainId,
         baseTokens: ctx.baseTokens,
         l2AssetRouter: ctx.l2AssetRouter,
-        l2NativeTokenVault: ctx.l2NativeTokenVault});
+        l2NativeTokenVault: ctx.l2NativeTokenVault,
+        codec: interopCodec
+      });
     },
     async build(params, ctx) {
       const steps = [];
@@ -2889,26 +2699,11 @@ function routeDirect() {
     }
   };
 }
-var MIN_INTEROP_PROTOCOL = 31;
 async function assertInteropProtocolVersion(client, srcChainId, dstChainId) {
   const [srcProtocolVersion, dstProtocolVersion] = await Promise.all([
     client.getProtocolVersion(srcChainId),
     client.getProtocolVersion(dstChainId)
   ]);
-  const 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
-        }
-      });
-    }
-  };
   assertProtocolVersion(srcChainId, srcProtocolVersion);
   assertProtocolVersion(dstChainId, dstProtocolVersion);
 }
@@ -2979,7 +2774,14 @@ function parseMaxBlockRangeLimit(error) {
 async function getTxReceipt(provider, txHash) {
   const receipt = await wrap3(
     OP_INTEROP.svc.status.sourceReceipt,
-    () => provider.getTransactionReceipt(txHash),
+    async () => {
+      try {
+        return await provider.getTransactionReceipt(txHash);
+      } catch (error) {
+        if (isReceiptNotFound(error)) return null;
+        throw error;
+      }
+    },
     {
       ctx: { where: "l2.getTransactionReceipt", l2SrcTxHash: txHash },
       message: "Failed to fetch source L2 receipt for interop tx."
@@ -3144,137 +2946,59 @@ async function executeBundle(client, dstProvider, info, opts) {
     );
   }
 }
-
-// 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: decodeInteropBundleSent2 } = 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 = decodeInteropBundleSent2({
-    data: bundleSentLog.data,
-    topics: bundleSentLog.topics
+async function verifyBundle(client, dstProvider, info) {
+  const signer = await wrap4(OP_INTEROP.verify, () => client.signerFor(dstProvider), {
+    message: "Failed to resolve destination signer for verifyBundle."
   });
-  return { bundleHash: decoded.bundleHash, dstChainId: decoded.destinationChainId };
-}
-function parseBundleReceiptInfo(params) {
-  const {
-    rawReceipt,
-    interopCenter,
-    interopBundleSentTopic,
-    decodeInteropBundleSent: decodeInteropBundleSent2,
-    decodeL1MessageData: decodeL1MessageData2,
-    l2SrcTxHash
-  } = params;
-  let l2ToL1LogIndex = -1;
-  let l1MessageData = null;
-  let found;
-  for (const log of rawReceipt.logs) {
-    if (isL1MessageSentLog(log)) {
-      l2ToL1LogIndex += 1;
-      try {
-        l1MessageData = decodeL1MessageData2(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
-        });
+  const { interopHandler } = await client.ensureAddresses();
+  const handler = new Contract(interopHandler, IInteropHandler_default, signer);
+  try {
+    const txResponse = await handler.verifyBundle(
+      info.encodedData,
+      info.proof
+    );
+    const hash = txResponse.hash;
+    return {
+      hash,
+      wait: async () => {
+        try {
+          const receipt = await txResponse.wait();
+          if (!receipt || receipt.status !== 1) {
+            throw createError("EXECUTION", {
+              resource: "interop",
+              operation: OP_INTEROP.verify,
+              message: "Interop bundle verification reverted on destination.",
+              context: { txHash: hash }
+            });
+          }
+          return receipt;
+        } catch (e) {
+          if (isZKsyncError(e)) throw e;
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "interop",
+              operation: OP_INTEROP.verify,
+              message: "Failed while waiting for verifyBundle transaction on destination.",
+              context: { txHash: hash }
+            },
+            e
+          );
+        }
       }
-      continue;
-    }
-    if (log.address.toLowerCase() !== interopCenter.toLowerCase() || log.topics[0].toLowerCase() !== interopBundleSentTopic.toLowerCase())
-      continue;
-    const decoded = decodeInteropBundleSent2({
-      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 }
-    });
+  } catch (e) {
+    if (isZKsyncError(e)) throw e;
+    throw toZKsyncError(
+      "EXECUTION",
+      {
+        resource: "interop",
+        operation: OP_INTEROP.verify,
+        message: "Failed to send verifyBundle transaction on destination chain."
+      },
+      e
+    );
   }
-  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)
-  };
 }
 function decodeInteropBundleSent(centerIface, log) {
   const decoded = centerIface.decodeEventLog(
@@ -3509,6 +3233,31 @@ function resolveChainRef(ref) {
   return typeof ref === "string" ? new JsonRpcProvider(ref) : ref;
 }
 
+// src/adapters/ethers/resources/interop/services/gas.ts
+async function quoteStepsL2Fee(steps, ctx) {
+  if (steps.length === 0) return 0n;
+  const estimator = ethersToGasEstimator(ctx.client.l2);
+  let maxFeePerGas;
+  try {
+    const fees = await estimator.estimateFeesPerGas();
+    maxFeePerGas = fees.maxFeePerGas ?? fees.gasPrice ?? await estimator.getGasPrice();
+  } catch {
+    return void 0;
+  }
+  let total = 0n;
+  for (const step of steps) {
+    try {
+      const coreTx = toCoreTx({ ...step.tx, from: ctx.sender });
+      const est = await estimator.estimateGas(coreTx);
+      const buffered = BigInt(est) * (100n + BUFFER) / 100n;
+      total += buffered * maxFeePerGas;
+    } catch {
+      return void 0;
+    }
+  }
+  return total;
+}
+
 // src/adapters/ethers/resources/interop/index.ts
 var { wrap: wrap6, toResult: toResult2 } = createErrorHandlers("interop");
 var ROUTES3 = {
@@ -3565,12 +3314,14 @@ function createInteropResource(client, config, tokens, contracts, attributes) {
         ctx: { where: `routes.${route}.build` }
       }
     );
+    const l2Fee = await quoteStepsL2Fee(steps, ctx).catch(() => void 0);
     const summary = {
       route,
       approvalsNeeded: approvals,
       totalActionValue: quoteExtras.totalActionValue,
       bridgedTokenTotal: quoteExtras.bridgedTokenTotal,
-      interopFee
+      interopFee,
+      l2Fee
     };
     return { plan: { route, summary, steps }, ctx };
   }
@@ -3695,6 +3446,28 @@ function createInteropResource(client, config, tokens, contracts, attributes) {
     }
   );
   const tryFinalize = (dstChain, h, opts) => toResult2(OP_INTEROP.tryFinalize, () => finalize(dstChain, h, opts));
+  const interopGetRoot = (dstChain, rootChainId, batchNumber) => wrap6(
+    OP_INTEROP.svc.status.getRoot,
+    () => getInteropRoot(resolveChainRef(dstChain), rootChainId, batchNumber),
+    {
+      message: "Failed to get interop root from the destination chain.",
+      ctx: { where: "interop.getInteropRoot" }
+    }
+  );
+  const verifyBundle2 = (dstChain, h) => wrap6(
+    OP_INTEROP.verify,
+    async () => {
+      const dstProvider = resolveChainRef(dstChain);
+      const info = isInteropFinalizationInfo(h) ? h : await svc.wait(dstProvider, getGwProvider(), h);
+      const result = await verifyBundle(client, dstProvider, info);
+      await result.wait();
+      return { bundleHash: info.bundleHash, dstExecTxHash: result.hash };
+    },
+    {
+      message: "Failed to verify interop bundle on destination.",
+      ctx: { where: "interop.verifyBundle" }
+    }
+  );
   return {
     quote,
     tryQuote,
@@ -3706,7 +3479,9 @@ function createInteropResource(client, config, tokens, contracts, attributes) {
     wait,
     tryWait,
     finalize,
-    tryFinalize
+    tryFinalize,
+    getInteropRoot: interopGetRoot,
+    verifyBundle: verifyBundle2
   };
 }