@matterlabs/zksync-js 0.0.13 → 0.0.15

package/dist/{chunk-JHO2UQ5F.js → chunk-HGB3DOV2.js}

@@ -1,9 +1,9 @@
-import { createErrorHandlers, toZKsyncError, classifyReadinessFromRevert } from './chunk-UDBRUBEK.js';
-import { createNTVCodec, toGasOverrides, buildFeeBreakdown, quoteL2Gas, quoteL2BaseCost, quoteL1Gas, quoteL2Gas2 } from './chunk-5L6EYUJB.js';
-import { findL1MessageSentLog, messengerLogIndex, isL1MessageSentLog, pickWithdrawRoute } from './chunk-E3KP7XCG.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, L2NativeTokenVault_default, assertNever } from './chunk-RI73VJSH.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, FORMAL_ETH_ADDRESS } from './chunk-QQ2OR434.js';
-import { Interface, AbiCoder, ethers, getBytes, Contract, NonceManager, JsonRpcProvider, isError, getAddress, concat, hexlify, toBeArray, toBeHex } from 'ethers';
+import { createErrorHandlers, toZKsyncError, classifyReadinessFromRevert } from './chunk-65HAYKVL.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-K2UVKMLN.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, IInteropCenter_default, sleep, isETH, normalizeAddrEq, IInteropRootStorage_default, IL2AssetRouter_default, L2NativeTokenVault_default, assertNever } from './chunk-JXR5V5YK.js';
+import { ETH_ADDRESS, TOPIC_CANONICAL_ASSIGNED, TOPIC_CANONICAL_SUCCESS, L1_MESSENGER_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, BUFFER, 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, 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)"
@@ -279,8 +279,22 @@ async function determineNonBaseL2Gas(input) {
   try {
     const l2TokenAddress = input.knownL2Token ?? (ctx.tokens ? await ctx.tokens.toL2Address(l1Token) : await (await ctx.contracts.l2NativeTokenVault()).l2TokenAddress(l1Token));
     if (l2TokenAddress === ZERO_L2_TOKEN_ADDRESS) {
+      if (input.undeployedGasLimit != null) {
+        return quoteL2Gas3({
+          ctx,
+          route,
+          overrideGasLimit: input.undeployedGasLimit
+        });
+      }
       return fallbackQuote();
     }
+    if (input.priorityFloorGasLimit != null) {
+      return quoteL2Gas3({
+        ctx,
+        route,
+        overrideGasLimit: input.priorityFloorGasLimit
+      });
+    }
     const modelTx = {
       to: input.modelTx?.to ?? ctx.sender,
       from: input.modelTx?.from ?? ctx.sender,
@@ -296,8 +310,7 @@ async function determineNonBaseL2Gas(input) {
       return fallbackQuote();
     }
     return gas;
-  } catch (err) {
-    console.warn("Failed to determine non-base deposit L2 gas; defaulting to safe gas limit.", err);
+  } catch {
     return fallbackQuote();
   }
 }
@@ -314,45 +327,89 @@ async function determineEthNonBaseL2Gas(input) {
     route: "eth-nonbase",
     l1Token: input.ctx.resolvedToken?.l1 ?? FORMAL_ETH_ADDRESS,
     knownL2Token: input.ctx.resolvedToken?.l2,
-    modelTx: input.modelTx
+    modelTx: input.modelTx,
+    priorityFloorGasLimit: input.priorityFloorGasLimit,
+    undeployedGasLimit: input.undeployedGasLimit
+  });
+}
+var EMPTY_BYTES = "0x";
+var ZERO_RESERVED_WORDS = [0n, 0n, 0n, 0n];
+var L2_CANONICAL_TRANSACTION_TUPLE = "tuple(uint256 txType,uint256 from,uint256 to,uint256 gasLimit,uint256 gasPerPubdataByteLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,uint256 paymaster,uint256 nonce,uint256 value,uint256[4] reserved,bytes data,bytes signature,uint256[] factoryDeps,bytes paymasterInput,bytes reservedDynamic)";
+function hexByteLength(hex) {
+  return BigInt(Math.max(hex.length - 2, 0) / 2);
+}
+function getPriorityTxEncodedLength(input) {
+  const encoded = AbiCoder.defaultAbiCoder().encode(
+    [L2_CANONICAL_TRANSACTION_TUPLE],
+    [
+      [
+        0n,
+        BigInt(input.sender),
+        BigInt(input.l2Contract),
+        0n,
+        input.gasPerPubdata,
+        0n,
+        0n,
+        0n,
+        0n,
+        input.l2Value,
+        ZERO_RESERVED_WORDS,
+        input.l2Calldata,
+        EMPTY_BYTES,
+        input.factoryDepsHashes ?? [],
+        EMPTY_BYTES,
+        EMPTY_BYTES
+      ]
+    ]
+  );
+  return hexByteLength(encoded);
+}
+function getPriorityTxGasBreakdown(input) {
+  return derivePriorityTxGasBreakdown({
+    encodedLength: getPriorityTxEncodedLength(input),
+    gasPerPubdata: input.gasPerPubdata,
+    factoryDepsCount: BigInt(input.factoryDepsHashes?.length ?? 0)
   });
 }
 
 // src/adapters/ethers/resources/deposits/routes/eth.ts
+var EMPTY_BYTES2 = "0x";
 function routeEthDirect() {
   return {
     async build(p, ctx) {
       const bh = await ctx.contracts.bridgehub();
-      const l2TxModel = {
-        to: p.to ?? ctx.sender,
-        from: ctx.sender,
-        data: "0x",
-        value: 0n
-      };
+      const l2Contract = p.to ?? ctx.sender;
+      const l2Value = p.amount;
+      const l2Calldata = EMPTY_BYTES2;
+      const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+        sender: ctx.sender,
+        l2Contract,
+        l2Value,
+        l2Calldata,
+        gasPerPubdata: ctx.gasPerPubdata
+      });
+      const quotedL2GasLimit = ctx.l2GasLimit ?? applyPriorityL2GasLimitBuffer({
+        chainIdL2: ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      });
       const l2GasParams = await quoteL2Gas3({
         ctx,
         route: "eth-base",
-        l2TxForModeling: l2TxModel,
-        overrideGasLimit: ctx.l2GasLimit,
-        stateOverrides: {
-          [ctx.sender]: {
-            balance: "0xffffffffffffffffffff"
-          }
-        }
+        overrideGasLimit: quotedL2GasLimit
       });
       if (!l2GasParams) {
         throw new Error("Failed to estimate L2 gas for deposit.");
       }
       const baseCost = await quoteL2BaseCost2({ ctx, l2GasLimit: l2GasParams.gasLimit });
-      const mintValue = baseCost + ctx.operatorTip + p.amount;
+      const mintValue = baseCost + ctx.operatorTip + l2Value;
       const req = buildDirectRequestStruct({
         chainId: ctx.chainIdL2,
         mintValue,
         l2GasLimit: l2GasParams.gasLimit,
         gasPerPubdata: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
-        l2Contract: p.to ?? ctx.sender,
-        l2Value: p.amount
+        l2Contract,
+        l2Value
       });
       const data = bh.interface.encodeFunctionData("requestL2TransactionDirect", [req]);
       const l1TxCandidate = {
@@ -396,12 +453,57 @@ 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";
+async function getPriorityGasModel(input) {
+  try {
+    const l1NativeTokenVault = await input.ctx.contracts.l1NativeTokenVault();
+    const l1AssetRouter = await input.ctx.contracts.l1AssetRouter();
+    const { chainId: l1ChainId } = await input.ctx.client.l1.getNetwork();
+    const isFirstBridge = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID || input.ctx.resolvedToken.originChainId === 0n;
+    const erc20MetadataOriginChainId = isFirstBridge ? BigInt(l1ChainId) : input.ctx.resolvedToken.originChainId;
+    const erc20Metadata = await l1NativeTokenVault.getERC20Getters(
+      input.token,
+      erc20MetadataOriginChainId
+    );
+    const bridgeMintCalldata = AbiCoder.defaultAbiCoder().encode(
+      ["address", "address", "address", "uint256", "bytes"],
+      [input.ctx.sender, input.receiver, input.token, input.amount, erc20Metadata]
+    );
+    const l2Calldata = isFirstBridge ? new Interface(IL2AssetRouter_default).encodeFunctionData(
+      "finalizeDeposit(address,address,address,uint256,bytes)",
+      [input.ctx.sender, input.receiver, input.token, input.amount, erc20Metadata]
+    ) : await (() => {
+      return l1AssetRouter.getDepositCalldata(
+        input.ctx.sender,
+        input.ctx.resolvedToken.assetId,
+        bridgeMintCalldata
+      );
+    })();
+    const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+      sender: input.ctx.l1AssetRouter,
+      l2Contract: L2_ASSET_ROUTER_ADDRESS,
+      l2Value: 0n,
+      l2Calldata,
+      gasPerPubdata: input.ctx.gasPerPubdata
+    });
+    const model = {
+      priorityFloorGasLimit: applyPriorityL2GasLimitBuffer({
+        chainIdL2: input.ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      })
+    };
+    if (isFirstBridge || input.ctx.resolvedToken.l2.toLowerCase() === ZERO_L2_TOKEN_ADDRESS2) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeErc20NonBase() {
   return {
     async preflight(p, ctx) {
@@ -422,11 +524,29 @@ function routeErc20NonBase() {
       const l1Signer = ctx.client.getL1Signer();
       const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
       const baseIsEth = ctx.baseIsEth ?? isETH(baseToken);
+      const receiver = p.to ?? ctx.sender;
+      const secondBridgeCalldata = await wrapAs2(
+        "INTERNAL",
+        OP_DEPOSITS.nonbase.encodeCalldata,
+        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, receiver)),
+        {
+          ctx: { where: "encodeSecondBridgeErc20Args" },
+          message: "Failed to encode bridging calldata."
+        }
+      );
+      const priorityGasModel = await getPriorityGasModel({
+        ctx,
+        token: p.token,
+        amount: p.amount,
+        receiver
+      });
       const l2GasParams = await determineErc20L2Gas({
         ctx,
         l1Token: p.token,
+        priorityFloorGasLimit: priorityGasModel.priorityFloorGasLimit,
+        undeployedGasLimit: priorityGasModel.undeployedGasLimit,
         modelTx: {
-          to: p.to ?? ctx.sender,
+          to: receiver,
           from: ctx.sender,
           data: "0x",
           value: 0n
@@ -488,15 +608,6 @@ function routeErc20NonBase() {
           });
         }
       }
-      const secondBridgeCalldata = await wrapAs2(
-        "INTERNAL",
-        OP_DEPOSITS.nonbase.encodeCalldata,
-        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, p.to ?? ctx.sender)),
-        {
-          ctx: { where: "encodeSecondBridgeErc20Args" },
-          message: "Failed to encode bridging calldata."
-        }
-      );
       const requestStruct = {
         chainId: ctx.chainIdL2,
         mintValue,
@@ -554,6 +665,54 @@ function routeErc20NonBase() {
   };
 }
 var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
+var ZERO_L2_TOKEN_ADDRESS3 = "0x0000000000000000000000000000000000000000";
+var ZERO_ASSET_ID2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var ntvCodec = createNTVCodec({
+  encode: (types, values) => AbiCoder.defaultAbiCoder().encode(types, values),
+  keccak256: (data) => keccak256(data)
+});
+async function getPriorityGasModel2(input) {
+  try {
+    const l1AssetRouter = await input.ctx.contracts.l1AssetRouter();
+    const l1NativeTokenVault = await input.ctx.contracts.l1NativeTokenVault();
+    const originChainId = input.ctx.resolvedToken.originChainId !== 0n ? input.ctx.resolvedToken.originChainId : BigInt((await input.ctx.client.l1.getNetwork()).chainId);
+    const resolvedAssetId = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID2 ? ntvCodec.encodeAssetId(originChainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, ETH_ADDRESS) : input.ctx.resolvedToken.assetId;
+    const erc20Metadata = await l1NativeTokenVault.getERC20Getters(
+      ETH_ADDRESS,
+      originChainId
+    );
+    const bridgeMintCalldata = AbiCoder.defaultAbiCoder().encode(
+      ["address", "address", "address", "uint256", "bytes"],
+      [input.ctx.sender, input.receiver, ETH_ADDRESS, input.amount, erc20Metadata]
+    );
+    const l2Calldata = await l1AssetRouter.getDepositCalldata(
+      input.ctx.sender,
+      resolvedAssetId,
+      bridgeMintCalldata
+    );
+    const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+      sender: input.ctx.l1AssetRouter,
+      l2Contract: L2_ASSET_ROUTER_ADDRESS,
+      l2Value: 0n,
+      l2Calldata,
+      gasPerPubdata: input.ctx.gasPerPubdata
+    });
+    const model = {
+      priorityFloorGasLimit: applyPriorityL2GasLimitBuffer({
+        chainIdL2: input.ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      })
+    };
+    if (input.ctx.resolvedToken.l2.toLowerCase() === ZERO_L2_TOKEN_ADDRESS3) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeEthNonBase() {
   return {
     async preflight(p, ctx) {
@@ -602,15 +761,23 @@ function routeEthNonBase() {
     async build(p, ctx) {
       const l1Signer = ctx.client.getL1Signer();
       const baseToken = ctx.baseTokenL1;
+      const receiver = p.to ?? ctx.sender;
+      const priorityGasModel = await getPriorityGasModel2({
+        ctx,
+        amount: p.amount,
+        receiver
+      });
       const l2TxModel = {
-        to: p.to ?? ctx.sender,
+        to: receiver,
         from: ctx.sender,
         data: "0x",
         value: 0n
       };
       const l2GasParams = await determineEthNonBaseL2Gas({
         ctx,
-        modelTx: l2TxModel
+        modelTx: l2TxModel,
+        priorityFloorGasLimit: priorityGasModel.priorityFloorGasLimit,
+        undeployedGasLimit: priorityGasModel.undeployedGasLimit
       });
       if (!l2GasParams) throw new Error("Failed to estimate L2 gas parameters.");
       const baseCost = await quoteL2BaseCost2({ ctx, l2GasLimit: l2GasParams.gasLimit });
@@ -644,12 +811,12 @@ function routeEthNonBase() {
       const secondBridgeCalldata = await wrapAs3(
         "INTERNAL",
         OP_DEPOSITS.ethNonBase.encodeCalldata,
-        () => Promise.resolve(encodeSecondBridgeEthArgs(p.amount, p.to ?? ctx.sender)),
+        () => Promise.resolve(encodeSecondBridgeEthArgs(p.amount, receiver)),
         {
           ctx: {
             where: "encodeSecondBridgeEthArgs",
             amount: p.amount.toString(),
-            to: p.to ?? ctx.sender
+            to: receiver
           }
         }
       );
@@ -710,6 +877,7 @@ function routeEthNonBase() {
   };
 }
 var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
+var EMPTY_BYTES3 = "0x";
 function routeErc20Base() {
   return {
     async preflight(p, ctx) {
@@ -740,17 +908,24 @@ function routeErc20Base() {
     async build(p, ctx) {
       const l1Signer = ctx.client.getL1Signer();
       const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
-      const l2TxModel = {
-        to: p.to ?? ctx.sender,
-        from: ctx.sender,
-        data: "0x",
-        value: 0n
-      };
+      const l2Contract = p.to ?? ctx.sender;
+      const l2Value = p.amount;
+      const l2Calldata = EMPTY_BYTES3;
+      const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+        sender: ctx.sender,
+        l2Contract,
+        l2Value,
+        l2Calldata,
+        gasPerPubdata: ctx.gasPerPubdata
+      });
+      const quotedL2GasLimit = ctx.l2GasLimit ?? applyPriorityL2GasLimitBuffer({
+        chainIdL2: ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      });
       const l2GasParams = await quoteL2Gas3({
         ctx,
         route: "erc20-base",
-        l2TxForModeling: l2TxModel,
-        overrideGasLimit: ctx.l2GasLimit
+        overrideGasLimit: quotedL2GasLimit
       });
       if (!l2GasParams) throw new Error("Failed to estimate L2 gas parameters.");
       const baseCost = await quoteL2BaseCost2({ ctx, l2GasLimit: l2GasParams.gasLimit });
@@ -789,8 +964,8 @@ function routeErc20Base() {
         l2GasLimit: l2GasParams.gasLimit,
         gasPerPubdata: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
-        l2Contract: p.to ?? ctx.sender,
-        l2Value: p.amount
+        l2Contract,
+        l2Value
       });
       const bridgehub = await ctx.contracts.bridgehub();
       const data = bridgehub.interface.encodeFunctionData("requestL2TransactionDirect", [
@@ -839,7 +1014,7 @@ function routeErc20Base() {
 }
 var { wrapAs: wrapAs5 } = createErrorHandlers("tokens");
 var abi = AbiCoder.defaultAbiCoder();
-var ntvCodec = createNTVCodec({
+var ntvCodec2 = createNTVCodec({
   encode: (types, values) => abi.encode(types, values),
   keccak256: (data) => ethers.keccak256(data)
 });
@@ -958,7 +1133,7 @@ function createTokensResource(client) {
     return wrapAs5("CONTRACT", "tokens.isChainEthBased", async () => {
       const baseAssetId = await getBaseTokenAssetId();
       const l1ChainId = await getL1ChainId();
-      const ethAssetId = ntvCodec.encodeAssetId(
+      const ethAssetId = ntvCodec2.encodeAssetId(
         l1ChainId,
         L2_NATIVE_TOKEN_VAULT_ADDRESS,
         ETH_ADDRESS
@@ -1172,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;
@@ -1217,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 {
           }
         }
@@ -1853,7 +2036,7 @@ var ROUTES2 = {
 };
 function createWithdrawalsResource(client, tokens, contracts) {
   const svc = createFinalizationServices(client);
-  const { wrap: wrap6, toResult: toResult3 } = createErrorHandlers("withdrawals");
+  const { wrap: wrap7, toResult: toResult3 } = createErrorHandlers("withdrawals");
   const tokensResource = tokens ?? createTokensResource(client);
   const contractsResource = contracts ?? createContractsResource(client);
   async function buildPlan(p) {
@@ -1874,7 +2057,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
     };
   }
   const finalizeCache = /* @__PURE__ */ new Map();
-  const quote = (p) => wrap6(
+  const quote = (p) => wrap7(
     OP_WITHDRAWALS.quote,
     async () => {
       const plan = await buildPlan(p);
@@ -1896,7 +2079,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
       ctx: { token: p.token, where: "withdrawals.tryQuote" }
     }
   );
-  const prepare = (p) => wrap6(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
+  const prepare = (p) => wrap7(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
     message: "Internal error while preparing a withdrawal plan.",
     ctx: { token: p.token, where: "withdrawals.prepare" }
   });
@@ -1904,7 +2087,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
     message: "Internal error while preparing a withdrawal plan.",
     ctx: { token: p.token, where: "withdrawals.tryPrepare" }
   });
-  const create = (p) => wrap6(
+  const create = (p) => wrap7(
     OP_WITHDRAWALS.create,
     async () => {
       const plan = await prepare(p);
@@ -1975,7 +2158,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) => wrap6(
+  const status = (h) => wrap7(
     OP_WITHDRAWALS.status,
     async () => {
       const l2TxHash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
@@ -2030,7 +2213,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
   const wait = (h, opts = {
     for: "l2",
     pollMs: 5500
-  }) => wrap6(
+  }) => wrap7(
     OP_WITHDRAWALS.wait,
     async () => {
       const l2Hash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
@@ -2095,7 +2278,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
       }
     }
   );
-  const finalize = (l2TxHash) => wrap6(
+  const finalize = (l2TxHash) => wrap7(
     OP_WITHDRAWALS.finalize.send,
     async () => {
       const pack = await (async () => {
@@ -2206,36 +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]);
-  return {
-    executionAddress,
-    unbundlerAddress
-  };
-}
-
-// 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) {
@@ -2244,6 +2397,7 @@ function getInteropAttributes(params, ctx) {
   if (params.unbundling?.by) {
     bundleAttributes.push(ctx.attributes.bundle.unbundlerAddress(params.unbundling.by));
   }
+  bundleAttributes.push(ctx.attributes.bundle.useFixedFee(params.fee?.useFixed ?? false));
   const callAttributes = params.actions.map((action) => {
     switch (action.type) {
       case "sendNative": {
@@ -2271,185 +2425,6 @@ function createEthersAttributesResource(opts = {}) {
   const encode2 = (fn, args) => iface.encodeFunctionData(fn, args);
   return createAttributesResource({ encode: encode2 });
 }
-
-// src/core/types/flows/interop.ts
-function isInteropExpectedRoot(obj) {
-  if (typeof obj !== "object" || obj === null) return false;
-  const root = obj;
-  return isBigint(root.rootChainId) && isBigint(root.batchNumber) && isHash(root.expectedRoot);
-}
-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) && isInteropExpectedRoot(info.expectedRoot) && 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) {
-  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: [],
-    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) {
-  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());
-  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,
-    quoteExtras: {
-      totalActionValue,
-      bridgedTokenTotal
-    }
-  };
-}
 var PREFIX_EVM_CHAIN = getBytes("0x00010000");
 var PREFIX_EVM_ADDRESS = getBytes("0x000100000014");
 function formatInteropEvmChain(chainId) {
@@ -2490,6 +2465,29 @@ function buildEnsureTokenSteps(erc20Tokens, ctx) {
     }
   }));
 }
+async function buildApproveSteps(approvals, ctx) {
+  const steps = [];
+  for (const approval of approvals) {
+    const erc20 = new Contract(approval.token, IERC20_default, ctx.client.l2);
+    const currentAllowance = await erc20.allowance(ctx.sender, approval.spender);
+    if (currentAllowance < approval.amount) {
+      steps.push({
+        key: `approve:${approval.token}:${approval.spender}`,
+        kind: "approve",
+        description: `Approve ${approval.spender} to spend ${approval.amount} of ${approval.token}`,
+        tx: {
+          to: approval.token,
+          data: erc20.interface.encodeFunctionData("approve", [
+            approval.spender,
+            approval.amount
+          ]),
+          ...ctx.gasOverrides
+        }
+      });
+    }
+  }
+  return steps;
+}
 async function resolveErc20AssetIds(erc20Tokens, ctx) {
   const assetIds = /* @__PURE__ */ new Map();
   if (erc20Tokens.length === 0) return assetIds;
@@ -2543,6 +2541,44 @@ async function getStarterData(params, ctx, erc20AssetIds) {
   }
   return starterData;
 }
+var { wrap: wrap2 } = createErrorHandlers("interop");
+async function buildFeeInfo(params, ctx, numStarters) {
+  const useFixed = params.fee?.useFixed ?? false;
+  const interopCenter = new Contract(ctx.interopCenter, IInteropCenter_default, ctx.client.l2);
+  if (useFixed) {
+    const zkFeePerCall = await wrap2(
+      OP_INTEROP.svc.fees.zkInteropFee,
+      () => interopCenter.ZK_INTEROP_FEE(),
+      { message: "Failed to fetch ZK interop fee from InteropCenter." }
+    );
+    const zkFeeTotal = zkFeePerCall * BigInt(numStarters);
+    const zkTokenAddress = await wrap2(
+      OP_INTEROP.svc.fees.zkToken,
+      () => interopCenter.zkToken(),
+      { message: "Failed to fetch ZK token address from InteropCenter." }
+    );
+    const approval = {
+      token: zkTokenAddress,
+      spender: ctx.interopCenter,
+      amount: zkFeeTotal
+    };
+    return {
+      approval,
+      fee: { token: zkTokenAddress, amount: zkFeeTotal }
+    };
+  } else {
+    const protocolFeePerCall = await wrap2(
+      OP_INTEROP.svc.fees.protocolFee,
+      () => interopCenter.interopProtocolFee(),
+      { message: "Failed to fetch interop protocol fee from InteropCenter." }
+    );
+    const totalFee = protocolFeePerCall * BigInt(numStarters);
+    return {
+      approval: null,
+      fee: { token: ctx.baseTokens.src, amount: totalFee }
+    };
+  }
+}
 
 // src/adapters/ethers/resources/interop/routes/indirect.ts
 function routeIndirect() {
@@ -2553,12 +2589,17 @@ 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 = [];
       const erc20Tokens = getErc20Tokens(params);
-      const erc20AssetIds = await resolveErc20AssetIds(erc20Tokens, ctx);
+      const [erc20AssetIds, feeInfo] = await Promise.all([
+        resolveErc20AssetIds(erc20Tokens, ctx),
+        buildFeeInfo(params, ctx, params.actions.length)
+      ]);
       const attributes = getInteropAttributes(params, ctx);
       const starterData = await getStarterData(params, ctx, erc20AssetIds);
       const bundle = buildIndirectBundle(
@@ -2571,32 +2612,11 @@ function routeIndirect() {
           codec: interopCodec
         },
         attributes,
-        starterData
+        starterData,
+        feeInfo
       );
       steps.push(...buildEnsureTokenSteps(erc20Tokens, ctx));
-      for (const approval of bundle.approvals) {
-        const erc20 = new Contract(approval.token, IERC20_default, ctx.client.l2);
-        const currentAllowance = await erc20.allowance(
-          ctx.sender,
-          ctx.l2NativeTokenVault
-        );
-        if (currentAllowance < approval.amount) {
-          const approveData = erc20.interface.encodeFunctionData("approve", [
-            ctx.l2NativeTokenVault,
-            approval.amount
-          ]);
-          steps.push({
-            key: `approve:${approval.token}:${ctx.l2NativeTokenVault}`,
-            kind: "approve",
-            description: `Approve ${ctx.l2NativeTokenVault} to spend ${approval.amount} of ${approval.token}`,
-            tx: {
-              to: approval.token,
-              data: approveData,
-              ...ctx.gasOverrides
-            }
-          });
-        }
-      }
+      steps.push(...await buildApproveSteps(bundle.approvals, ctx));
       const data = ctx.ifaces.interopCenter.encodeFunctionData("sendBundle", [
         bundle.dstChain,
         bundle.starters,
@@ -2609,14 +2629,15 @@ function routeIndirect() {
         tx: {
           to: ctx.interopCenter,
           data,
-          value: bundle.quoteExtras.totalActionValue,
+          value: bundle.quoteExtras.totalActionValue + feeInfo.fee.amount,
           ...ctx.gasOverrides
         }
       });
       return {
         steps,
         approvals: bundle.approvals,
-        quoteExtras: bundle.quoteExtras
+        quoteExtras: bundle.quoteExtras,
+        interopFee: feeInfo.fee
       };
     }
   };
@@ -2631,12 +2652,14 @@ function routeDirect() {
         dstChainId: ctx.dstChainId,
         baseTokens: ctx.baseTokens,
         l2AssetRouter: ctx.l2AssetRouter,
-        l2NativeTokenVault: ctx.l2NativeTokenVault});
+        l2NativeTokenVault: ctx.l2NativeTokenVault,
+        codec: interopCodec
+      });
     },
-    // eslint-disable-next-line @typescript-eslint/require-await
     async build(params, ctx) {
       const steps = [];
       const attrs = getInteropAttributes(params, ctx);
+      const feeInfo = await buildFeeInfo(params, ctx, params.actions.length);
       const built = buildDirectBundle(
         params,
         {
@@ -2646,8 +2669,10 @@ function routeDirect() {
           l2NativeTokenVault: ctx.l2NativeTokenVault,
           codec: interopCodec
         },
-        attrs
+        attrs,
+        feeInfo
       );
+      steps.push(...await buildApproveSteps(built.approvals, ctx));
       const data = ctx.ifaces.interopCenter.encodeFunctionData("sendBundle", [
         built.dstChain,
         built.starters,
@@ -2657,43 +2682,28 @@ function routeDirect() {
         key: "sendBundle",
         kind: "interop.center",
         description: `Send interop bundle (direct route; ${params.actions.length} actions)`,
-        // In direct route, msg.value equals the total forwarded value across
-        // all calls (sendNative.amount + call.value).
+        // msg.value = forwarded action value + protocol fee.
         tx: {
           to: ctx.interopCenter,
           data,
-          value: built.quoteExtras.totalActionValue,
+          value: built.quoteExtras.totalActionValue + feeInfo.fee.amount,
           ...ctx.gasOverrides
         }
       });
       return {
         steps,
         approvals: built.approvals,
-        quoteExtras: built.quoteExtras
+        quoteExtras: built.quoteExtras,
+        interopFee: feeInfo.fee
       };
     }
   };
 }
-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);
 }
@@ -2749,7 +2759,7 @@ function getTopics() {
   };
   return { topics, centerIface };
 }
-var { wrap: wrap2 } = createErrorHandlers("interop");
+var { wrap: wrap3 } = createErrorHandlers("interop");
 var DEFAULT_BLOCKS_RANGE_SIZE = 1e4;
 var DEFAULT_MAX_BLOCKS_BACK = 2e4;
 var SAFE_BLOCKS_RANGE_SIZE = 1e3;
@@ -2762,9 +2772,16 @@ function parseMaxBlockRangeLimit(error) {
   return Number.isInteger(limit) && limit > 0 ? limit : null;
 }
 async function getTxReceipt(provider, txHash) {
-  const receipt = await wrap2(
+  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."
@@ -2783,7 +2800,7 @@ async function getTxReceipt(provider, txHash) {
 async function getLogs(provider, address, topics, opts) {
   const maxBlocksBack = opts?.maxBlocksBack ?? DEFAULT_MAX_BLOCKS_BACK;
   const initialChunkSize = opts?.logChunkSize ?? DEFAULT_BLOCKS_RANGE_SIZE;
-  return await wrap2(
+  return await wrap3(
     OP_INTEROP.svc.status.dstLogs,
     async () => {
       const currentBlock = await provider.getBlockNumber();
@@ -2830,7 +2847,7 @@ async function getLogs(provider, address, topics, opts) {
   );
 }
 async function getInteropRoot(provider, rootChainId, batchNumber) {
-  return await wrap2(
+  return await wrap3(
     OP_INTEROP.svc.status.getRoot,
     async () => {
       const rootStorage = new Contract(
@@ -2848,7 +2865,7 @@ async function getInteropRoot(provider, rootChainId, batchNumber) {
 }
 
 // src/adapters/ethers/resources/interop/services/finalization/bundle.ts
-var { wrap: wrap3 } = createErrorHandlers("interop");
+var { wrap: wrap4 } = createErrorHandlers("interop");
 async function getBundleStatus(client, dstProvider, topics, bundleHash, opts) {
   const { interopHandler } = await client.ensureAddresses();
   const bundleLogs = await getLogs(dstProvider, interopHandler, [null, bundleHash], opts);
@@ -2880,7 +2897,7 @@ async function executeBundle(client, dstProvider, info, opts) {
       context: { bundleHash }
     });
   }
-  const signer = await wrap3(OP_INTEROP.exec.sendStep, () => client.signerFor(dstProvider), {
+  const signer = await wrap4(OP_INTEROP.exec.sendStep, () => client.signerFor(dstProvider), {
     message: "Failed to resolve destination signer."
   });
   const { interopHandler } = await client.ensureAddresses();
@@ -2929,144 +2946,6 @@ 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
-  });
-  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
-        });
-      }
-      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 }
-    });
-  }
-  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 expectedRoot = {
-    rootChainId: bundleInfo.sourceChainId,
-    batchNumber: proof.batchNumber,
-    expectedRoot: proof.root
-  };
-  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,
-    expectedRoot,
-    proof: messageProof,
-    encodedData: getBundleEncodedData(messageData)
-  };
-}
 function decodeInteropBundleSent(centerIface, log) {
   const decoded = centerIface.decodeEventLog(
     "InteropBundleSent",
@@ -3085,7 +2964,7 @@ function decodeL1MessageData(log) {
 }
 
 // src/adapters/ethers/resources/interop/services/finalization/polling.ts
-var { wrap: wrap4 } = createErrorHandlers("interop");
+var { wrap: wrap5 } = createErrorHandlers("interop");
 function isProofNotReadyError(error) {
   return isZKsyncError(error, {
     operation: "zksrpc.getL2ToL1LogProof",
@@ -3122,30 +3001,26 @@ async function waitForProof(client, l2SrcTxHash, logIndex, blockNumber, pollMs,
       });
     }
     try {
-      return await client.zks.getL2ToL1LogProof(l2SrcTxHash, logIndex);
+      return await client.zks.getL2ToL1LogProof(l2SrcTxHash, logIndex, "messageRoot" /* MessageRoot */);
     } catch (error) {
       if (!isProofNotReadyError(error)) throw error;
     }
     await sleep(pollMs);
   }
 }
-async function waitForRoot(provider, expectedRoot, pollMs, deadline) {
+async function waitForRoot(provider, chainId, batchNumber, pollMs, deadline) {
   while (true) {
     if (Date.now() > deadline) {
       throw createError("TIMEOUT", {
         resource: "interop",
         operation: OP_INTEROP.svc.wait.timeout,
         message: "Timed out waiting for interop root to become available.",
-        context: { expectedRoot }
+        context: { chainId, batchNumber }
       });
     }
     let interopRoot = null;
     try {
-      const root = await getInteropRoot(
-        provider,
-        expectedRoot.rootChainId,
-        expectedRoot.batchNumber
-      );
+      const root = await getInteropRoot(provider, chainId, batchNumber);
       if (root !== ZERO_HASH) {
         interopRoot = root;
       }
@@ -3154,18 +3029,7 @@ async function waitForRoot(provider, expectedRoot, pollMs, deadline) {
       interopRoot = null;
     }
     if (interopRoot) {
-      if (interopRoot.toLowerCase() === expectedRoot.expectedRoot.toLowerCase()) {
-        return;
-      }
-      throw createError("STATE", {
-        resource: "interop",
-        operation: OP_INTEROP.wait,
-        message: "Interop root mismatch.",
-        context: {
-          expected: expectedRoot.expectedRoot,
-          got: interopRoot
-        }
-      });
+      return interopRoot;
     }
     await sleep(pollMs);
   }
@@ -3180,7 +3044,7 @@ async function waitForTxReceipt(client, txHash, pollMs, deadline) {
         context: { txHash }
       });
     }
-    const receipt = await wrap4(
+    const receipt = await wrap5(
       OP_INTEROP.svc.status.sourceReceipt,
       () => client.zks.getReceiptWithL2ToL1(txHash),
       {
@@ -3194,7 +3058,7 @@ async function waitForTxReceipt(client, txHash, pollMs, deadline) {
     await sleep(pollMs);
   }
 }
-async function waitForFinalization(client, dstProvider, input, opts) {
+async function waitForFinalization(client, dstProvider, gwProvider, input, opts) {
   const { topics, centerIface } = getTopics();
   const pollMs = opts?.pollMs ?? DEFAULT_POLL_MS;
   const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -3243,7 +3107,16 @@ async function waitForFinalization(client, dstProvider, input, opts) {
     proof,
     bundleInfo.l1MessageData
   );
-  await waitForRoot(dstProvider, finalizationInfo.expectedRoot, pollMs, deadline);
+  if (proof.gatewayBlockNumber == null) {
+    throw createError("STATE", {
+      resource: "interop",
+      operation: OP_INTEROP.svc.wait.timeout,
+      message: "Proof missing gatewayBlockNumber required for interop finalization.",
+      context: { l2SrcTxHash: ids.l2SrcTxHash }
+    });
+  }
+  const { chainId: gwChainId } = await gwProvider.getNetwork();
+  await waitForRoot(dstProvider, gwChainId, proof.gatewayBlockNumber, pollMs, deadline);
   return finalizationInfo;
 }
 
@@ -3289,8 +3162,8 @@ function createInteropFinalizationServices(client) {
     status(dstProvider, input, opts) {
       return getStatus(client, dstProvider, input, opts);
     },
-    wait(dstProvider, input, opts) {
-      return waitForFinalization(client, dstProvider, input, opts);
+    wait(dstProvider, gwProvider, input, opts) {
+      return waitForFinalization(client, dstProvider, gwProvider, input, opts);
     },
     async finalize(dstProvider, info, opts) {
       const execResult = await executeBundle(client, dstProvider, info, opts);
@@ -3302,24 +3175,56 @@ function createInteropFinalizationServices(client) {
     }
   };
 }
-function resolveDstProvider(dstChain) {
-  return typeof dstChain === "string" ? new JsonRpcProvider(dstChain) : dstChain;
+function resolveChainRef(ref) {
+  return typeof ref === "string" ? new JsonRpcProvider(ref) : ref;
 }
-function resolveWaitableInput(waitableInput) {
-  const input = waitableInput;
-  return {
-    dstProvider: resolveDstProvider(waitableInput.dstChain),
-    waitable: input.waitable ? input.waitable : waitableInput
-  };
+
+// 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: wrap5, toResult: toResult2 } = createErrorHandlers("interop");
+var { wrap: wrap6, toResult: toResult2 } = createErrorHandlers("interop");
 var ROUTES3 = {
   direct: routeDirect(),
   indirect: routeIndirect()
 };
-function createInteropResource(client, tokens, contracts, attributes) {
+function createInteropResource(client, config, tokens, contracts, attributes) {
+  let gwProviderCache;
+  function requireConfig() {
+    if (!config)
+      throw createError("STATE", {
+        resource: "interop",
+        operation: "interop.init",
+        message: "Interop is not configured. Pass gwChain in createEthersSdk options."
+      });
+    return config;
+  }
+  function getGwProvider() {
+    if (!gwProviderCache) gwProviderCache = resolveChainRef(requireConfig().gwChain);
+    return gwProviderCache;
+  }
   const svc = createInteropFinalizationServices(client);
   const tokensResource = tokens ?? createTokensResource(client);
   const contractsResource = contracts ?? createContractsResource(client);
@@ -3343,11 +3248,11 @@ function createInteropResource(client, tokens, contracts, attributes) {
         baseTokenDst: ctx.baseTokens.dst
       }
     });
-    await wrap5(OP_INTEROP.routes[route].preflight, () => ROUTES3[route].preflight?.(params, ctx), {
+    await wrap6(OP_INTEROP.routes[route].preflight, () => ROUTES3[route].preflight?.(params, ctx), {
       message: "Interop preflight failed.",
       ctx: { where: `routes.${route}.preflight` }
     });
-    const { steps, approvals, quoteExtras } = await wrap5(
+    const { steps, approvals, quoteExtras, interopFee } = await wrap6(
       OP_INTEROP.routes[route].build,
       () => ROUTES3[route].build(params, ctx),
       {
@@ -3355,11 +3260,14 @@ function createInteropResource(client, 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
+      bridgedTokenTotal: quoteExtras.bridgedTokenTotal,
+      interopFee,
+      l2Fee
     };
     return { plan: { route, summary, steps }, ctx };
   }
@@ -3367,20 +3275,23 @@ function createInteropResource(client, tokens, contracts, attributes) {
     const { plan } = await buildPlanWithCtx(dstProvider, params);
     return plan;
   }
-  const quote = (params) => wrap5(OP_INTEROP.quote, async () => {
-    const plan = await buildPlan(resolveDstProvider(params.dstChain), params);
+  const quote = (dstChain, params) => wrap6(OP_INTEROP.quote, async () => {
+    const plan = await buildPlan(resolveChainRef(dstChain), params);
     return plan.summary;
   });
-  const tryQuote = (params) => toResult2(OP_INTEROP.tryQuote, () => quote(params));
-  const prepare = (params) => wrap5(OP_INTEROP.prepare, () => buildPlan(resolveDstProvider(params.dstChain), params), {
+  const tryQuote = (dstChain, params) => toResult2(OP_INTEROP.tryQuote, () => quote(dstChain, params));
+  const prepare = (dstChain, params) => wrap6(OP_INTEROP.prepare, () => buildPlan(resolveChainRef(dstChain), params), {
     message: "Internal error while preparing an interop plan.",
     ctx: { where: "interop.prepare" }
   });
-  const tryPrepare = (params) => toResult2(OP_INTEROP.tryPrepare, () => prepare(params));
-  const create = (params) => wrap5(
+  const tryPrepare = (dstChain, params) => toResult2(
+    OP_INTEROP.tryPrepare,
+    () => prepare(dstChain, params)
+  );
+  const create = (dstChain, params) => wrap6(
     OP_INTEROP.create,
     async () => {
-      const { plan, ctx } = await buildPlanWithCtx(resolveDstProvider(params.dstChain), params);
+      const { plan, ctx } = await buildPlanWithCtx(resolveChainRef(dstChain), params);
       const signer = ctx.client.signerFor(ctx.client.l2);
       const srcProvider = ctx.client.l2;
       const from = await signer.getAddress();
@@ -3442,7 +3353,6 @@ function createInteropResource(client, tokens, contracts, attributes) {
       const last = Object.values(stepHashes).pop();
       return {
         kind: "interop",
-        dstChain: params.dstChain,
         stepHashes,
         plan,
         l2SrcTxHash: last ?? "0x"
@@ -3453,46 +3363,27 @@ function createInteropResource(client, tokens, contracts, attributes) {
       ctx: { where: "interop.create" }
     }
   );
-  const tryCreate = (params) => toResult2(OP_INTEROP.tryCreate, () => create(params));
-  const status = (h, opts) => {
-    const { dstProvider, waitable } = resolveWaitableInput(h);
-    return wrap5(OP_INTEROP.status, () => svc.status(dstProvider, waitable, opts), {
-      message: "Internal error while checking interop status.",
-      ctx: { where: "interop.status" }
-    });
-  };
-  const wait = (h, opts) => {
-    const { dstProvider, waitable } = resolveWaitableInput(h);
-    return wrap5(
-      OP_INTEROP.wait,
-      async () => {
-        const info = await svc.wait(dstProvider, waitable, opts);
-        return { ...info, dstChain: h.dstChain };
-      },
-      {
-        message: "Internal error while waiting for interop finalization.",
-        ctx: { where: "interop.wait" }
-      }
-    );
-  };
-  const tryWait = (h, opts) => toResult2(OP_INTEROP.tryWait, () => wait(h, opts));
-  const finalize = (h, opts) => wrap5(
+  const tryCreate = (dstChain, params) => toResult2(
+    OP_INTEROP.tryCreate,
+    () => create(dstChain, params)
+  );
+  const status = (dstChain, h, opts) => wrap6(OP_INTEROP.status, () => svc.status(resolveChainRef(dstChain), h, opts), {
+    message: "Internal error while checking interop status.",
+    ctx: { where: "interop.status" }
+  });
+  const wait = (dstChain, h, opts) => wrap6(OP_INTEROP.wait, () => svc.wait(resolveChainRef(dstChain), getGwProvider(), h, opts), {
+    message: "Internal error while waiting for interop finalization.",
+    ctx: { where: "interop.wait" }
+  });
+  const tryWait = (dstChain, h, opts) => toResult2(OP_INTEROP.tryWait, () => wait(dstChain, h, opts));
+  const finalize = (dstChain, h, opts) => wrap6(
     OP_INTEROP.finalize,
     async () => {
+      const dstProvider = resolveChainRef(dstChain);
       if (isInteropFinalizationInfo(h)) {
-        if (h.dstChain == null) {
-          throw createError("STATE", {
-            resource: "interop",
-            operation: OP_INTEROP.finalize,
-            message: "Missing dstChain in interop finalization info.",
-            context: { input: h }
-          });
-        }
-        const dstProvider2 = resolveDstProvider(h.dstChain);
-        return svc.finalize(dstProvider2, h, opts);
+        return svc.finalize(dstProvider, h, opts);
       }
-      const { dstProvider, waitable } = resolveWaitableInput(h);
-      const info = await svc.wait(dstProvider, waitable);
+      const info = await svc.wait(dstProvider, getGwProvider(), h);
       return svc.finalize(dstProvider, info, opts);
     },
     {
@@ -3500,7 +3391,7 @@ function createInteropResource(client, tokens, contracts, attributes) {
       ctx: { where: "interop.finalize" }
     }
   );
-  const tryFinalize = (h, opts) => toResult2(OP_INTEROP.tryFinalize, () => finalize(h, opts));
+  const tryFinalize = (dstChain, h, opts) => toResult2(OP_INTEROP.tryFinalize, () => finalize(dstChain, h, opts));
   return {
     quote,
     tryQuote,
@@ -3517,10 +3408,10 @@ function createInteropResource(client, tokens, contracts, attributes) {
 }
 
 // src/adapters/ethers/sdk.ts
-function createEthersSdk(client) {
+function createEthersSdk(client, options) {
   const tokens = createTokensResource(client);
   const contracts = createContractsResource(client);
-  const interop = createInteropResource(client);
+  const interop = createInteropResource(client, options?.interop, tokens, contracts);
   return {
     deposits: createDepositsResource(client, tokens, contracts),
     withdrawals: createWithdrawalsResource(client, tokens, contracts),