@matterlabs/zksync-js 0.0.13 → 0.0.15

package/dist/{chunk-EDWBCPO3.js → chunk-4PZCNTQ3.js}

@@ -1,9 +1,9 @@
-import { createNTVCodec, toGasOverrides, buildFeeBreakdown, quoteL2Gas, quoteL1Gas, quoteL2Gas2 } from './chunk-5L6EYUJB.js';
-import { findL1MessageSentLog, messengerLogIndex, pickWithdrawRoute } from './chunk-E3KP7XCG.js';
-import { createErrorHandlers, toZKsyncError, classifyReadinessFromRevert } from './chunk-5R7L5NM5.js';
-import { isHash66, IL1Nullifier_default, OP_WITHDRAWALS, createError, normalizeL1Token, isAddressEq, hexEq, OP_DEPOSITS, IERC20_default, isZKsyncError, isReceiptNotFound, IBridgehub_default, isETH, normalizeAddrEq, L2NativeTokenVault_default, IL2AssetRouter_default, IBaseToken_default } 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, SAFE_L1_BRIDGE_GAS, FORMAL_ETH_ADDRESS } from './chunk-QQ2OR434.js';
-import { keccak256, encodeAbiParameters, concat, decodeEventLog, decodeAbiParameters, encodeFunctionData, zeroAddress } from 'viem';
+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, quoteL1Gas, derivePriorityBodyGasEstimateCap, quoteL2Gas2, assertProtocolVersion } from './chunk-K2UVKMLN.js';
+import { findL1MessageSentLog, messengerLogIndex, pickWithdrawRoute } from './chunk-3HHUZXSV.js';
+import { createErrorHandlers, toZKsyncError, classifyReadinessFromRevert } from './chunk-YIWXIP2M.js';
+import { isHash66, IL1Nullifier_default, OP_WITHDRAWALS, createError, normalizeL1Token, isAddressEq, hexEq, OP_DEPOSITS, IERC20_default, isZKsyncError, isReceiptNotFound, OP_INTEROP, IInteropHandler_default, IInteropCenter_default, sleep, IERC7786Attributes_default, IBridgehub_default, isETH, normalizeAddrEq, L2NativeTokenVault_default, IL2AssetRouter_default, IBaseToken_default, IInteropRootStorage_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 { keccak256, encodeAbiParameters, toBytes, concat, decodeEventLog, decodeAbiParameters, createWalletClient, custom, encodeFunctionData, createPublicClient, http, encodeEventTopics, numberToHex, zeroAddress, getAddress, toHex } from 'viem';
 
 // src/adapters/viem/resources/deposits/context.ts
 async function commonCtx(p, client, tokens, contracts) {
@@ -221,8 +221,22 @@ async function determineNonBaseL2Gas(input) {
   try {
     const l2TokenAddress = input.knownL2Token ?? (ctx.tokens ? await ctx.tokens.toL2Address(l1Token) : await (await ctx.contracts.l2NativeTokenVault()).read.l2TokenAddress([l1Token]));
     if (l2TokenAddress === zeroAddress) {
+      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,
@@ -238,8 +252,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();
   }
 }
@@ -256,7 +269,9 @@ 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
   });
 }
 
@@ -281,35 +296,95 @@ async function quoteL2BaseCost(input) {
     { ctx: { chainIdL2: ctx.chainIdL2 } }
   );
 }
+var EMPTY_BYTES = "0x";
+var ZERO_RESERVED_WORDS = [0n, 0n, 0n, 0n];
+var L2_CANONICAL_TRANSACTION_PARAMETER = {
+  type: "tuple",
+  components: [
+    { name: "txType", type: "uint256" },
+    { name: "from", type: "uint256" },
+    { name: "to", type: "uint256" },
+    { name: "gasLimit", type: "uint256" },
+    { name: "gasPerPubdataByteLimit", type: "uint256" },
+    { name: "maxFeePerGas", type: "uint256" },
+    { name: "maxPriorityFeePerGas", type: "uint256" },
+    { name: "paymaster", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "value", type: "uint256" },
+    { name: "reserved", type: "uint256[4]" },
+    { name: "data", type: "bytes" },
+    { name: "signature", type: "bytes" },
+    { name: "factoryDeps", type: "uint256[]" },
+    { name: "paymasterInput", type: "bytes" },
+    { name: "reservedDynamic", type: "bytes" }
+  ]
+};
+function hexByteLength(hex) {
+  return BigInt(Math.max(hex.length - 2, 0) / 2);
+}
+function getPriorityTxEncodedLength(input) {
+  const encoded = encodeAbiParameters(
+    [L2_CANONICAL_TRANSACTION_PARAMETER],
+    [
+      {
+        txType: 0n,
+        from: BigInt(input.sender),
+        to: BigInt(input.l2Contract),
+        gasLimit: 0n,
+        gasPerPubdataByteLimit: input.gasPerPubdata,
+        maxFeePerGas: 0n,
+        maxPriorityFeePerGas: 0n,
+        paymaster: 0n,
+        nonce: 0n,
+        value: input.l2Value,
+        reserved: ZERO_RESERVED_WORDS,
+        data: input.l2Calldata,
+        signature: EMPTY_BYTES,
+        factoryDeps: input.factoryDepsHashes ?? [],
+        paymasterInput: EMPTY_BYTES,
+        reservedDynamic: EMPTY_BYTES
+      }
+    ]
+  );
+  return hexByteLength(encoded);
+}
+function getPriorityTxGasBreakdown(input) {
+  return derivePriorityTxGasBreakdown({
+    encodedLength: getPriorityTxEncodedLength(input),
+    gasPerPubdata: input.gasPerPubdata,
+    factoryDepsCount: BigInt(input.factoryDepsHashes?.length ?? 0)
+  });
+}
 
 // src/adapters/viem/resources/deposits/routes/eth.ts
 var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
+var EMPTY_BYTES2 = "0x";
 function routeEthDirect() {
   return {
     async build(p, ctx) {
-      const l2TxModel = {
-        to: p.to ?? ctx.sender,
-        from: ctx.sender,
-        data: "0x",
-        value: p.amount
-      };
+      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 quoteL2BaseCost({ ctx, l2GasLimit: l2GasParams.gasLimit });
-      const l2Contract = p.to ?? ctx.sender;
-      const l2Value = p.amount;
       const mintValue = baseCost + ctx.operatorTip + l2Value;
       const req = buildDirectRequestStruct({
         chainId: ctx.chainIdL2,
@@ -353,12 +428,21 @@ function routeEthDirect() {
         tx: l1TxCandidate,
         overrides: ctx.gasOverrides
       });
+      let bridgeTx = { ...sim.request };
+      if (l1Gas) {
+        bridgeTx = {
+          ...bridgeTx,
+          gas: l1Gas.gasLimit,
+          maxFeePerGas: l1Gas.maxFeePerGas,
+          maxPriorityFeePerGas: l1Gas.maxPriorityFeePerGas
+        };
+      }
       const steps = [
         {
           key: "bridgehub:direct",
           kind: "bridgehub:direct",
           description: "Bridge ETH via Bridgehub.requestL2TransactionDirect",
-          tx: { ...sim.request, ...l1Gas }
+          tx: bridgeTx
         }
       ];
       const fees = buildFeeBreakdown({
@@ -378,6 +462,62 @@ function routeEthDirect() {
   };
 }
 var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
+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 l1ChainId = BigInt(await input.ctx.client.l1.getChainId());
+    const isFirstBridge = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID || input.ctx.resolvedToken.originChainId === 0n;
+    const erc20MetadataOriginChainId = isFirstBridge ? l1ChainId : input.ctx.resolvedToken.originChainId;
+    const erc20Metadata = await l1NativeTokenVault.read.getERC20Getters([
+      input.token,
+      erc20MetadataOriginChainId
+    ]);
+    const bridgeMintCalldata = encodeAbiParameters(
+      [
+        { type: "address", name: "originalCaller" },
+        { type: "address", name: "receiver" },
+        { type: "address", name: "originToken" },
+        { type: "uint256", name: "amount" },
+        { type: "bytes", name: "erc20Metadata" }
+      ],
+      [input.ctx.sender, input.receiver, input.token, input.amount, erc20Metadata]
+    );
+    const l2Calldata = isFirstBridge ? encodeFunctionData({
+      abi: IL2AssetRouter_default,
+      functionName: "finalizeDeposit",
+      args: [input.ctx.sender, input.receiver, input.token, input.amount, erc20Metadata]
+    }) : await (async () => {
+      return await l1AssetRouter.read.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() === zeroAddress) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeErc20NonBase() {
   return {
     // TODO: do we even need these validations?
@@ -408,11 +548,33 @@ function routeErc20NonBase() {
       const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
       const baseIsEth = ctx.baseIsEth ?? isETH(baseToken);
       const assetRouter = ctx.l1AssetRouter;
+      const receiver = p.to ?? ctx.sender;
+      const secondBridgeCalldata = await wrapAs3(
+        "INTERNAL",
+        OP_DEPOSITS.nonbase.encodeCalldata,
+        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, receiver)),
+        {
+          ctx: {
+            where: "encodeSecondBridgeErc20Args",
+            token: p.token,
+            amount: p.amount.toString()
+          },
+          message: "Failed to encode bridging calldata."
+        }
+      );
+      const priorityGasModel = await getPriorityGasModel({
+        ctx,
+        token: p.token,
+        amount: p.amount,
+        receiver
+      });
       const l2Gas = 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
@@ -501,19 +663,6 @@ function routeErc20NonBase() {
           });
         }
       }
-      const secondBridgeCalldata = await wrapAs3(
-        "INTERNAL",
-        OP_DEPOSITS.nonbase.encodeCalldata,
-        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, p.to ?? ctx.sender)),
-        {
-          ctx: {
-            where: "encodeSecondBridgeErc20Args",
-            token: p.token,
-            amount: p.amount.toString()
-          },
-          message: "Failed to encode bridging calldata."
-        }
-      );
       const requestStruct = {
         chainId: ctx.chainIdL2,
         mintValue,
@@ -605,6 +754,62 @@ function routeErc20NonBase() {
   };
 }
 var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
+var ZERO_ASSET_ID2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var ntvCodec = createNTVCodec({
+  encode: (types, values) => encodeAbiParameters(
+    types.map((type, index) => ({ type, name: `arg${index}` })),
+    values
+  ),
+  keccak256
+});
+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.getChainId());
+    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.read.getERC20Getters([
+      ETH_ADDRESS,
+      originChainId
+    ]);
+    const bridgeMintCalldata = encodeAbiParameters(
+      [
+        { type: "address", name: "originalCaller" },
+        { type: "address", name: "receiver" },
+        { type: "address", name: "originToken" },
+        { type: "uint256", name: "amount" },
+        { type: "bytes", name: "erc20Metadata" }
+      ],
+      [input.ctx.sender, input.receiver, ETH_ADDRESS, input.amount, erc20Metadata]
+    );
+    const l2Calldata = await l1AssetRouter.read.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() === zeroAddress) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeEthNonBase() {
   return {
     // TODO: do we even need these validations?
@@ -651,15 +856,23 @@ function routeEthNonBase() {
     },
     async build(p, ctx) {
       const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
+      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 l2Gas = await determineEthNonBaseL2Gas({
         ctx,
-        modelTx: l2TxModel
+        modelTx: l2TxModel,
+        priorityFloorGasLimit: priorityGasModel.priorityFloorGasLimit,
+        undeployedGasLimit: priorityGasModel.undeployedGasLimit
       });
       if (!l2Gas) throw new Error("Failed to estimate L2 gas parameters.");
       const l2BaseCost = await quoteL2BaseCost({ ctx, l2GasLimit: l2Gas.gasLimit });
@@ -708,12 +921,12 @@ function routeEthNonBase() {
       const secondBridgeCalldata = await wrapAs4(
         "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
           },
           message: "Failed to encode ETH bridging calldata."
         }
@@ -814,6 +1027,7 @@ function routeEthNonBase() {
   };
 }
 var { wrapAs: wrapAs5 } = createErrorHandlers("deposits");
+var EMPTY_BYTES3 = "0x";
 function routeErc20Base() {
   return {
     async preflight(p, ctx) {
@@ -841,17 +1055,24 @@ function routeErc20Base() {
     },
     async build(p, ctx) {
       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 l2Gas = await quoteL2Gas3({
         ctx,
         route: "erc20-base",
-        l2TxForModeling: l2TxModel,
-        overrideGasLimit: ctx.l2GasLimit
+        overrideGasLimit: quotedL2GasLimit
       });
       if (!l2Gas) throw new Error("Failed to estimate L2 gas parameters.");
       const l2BaseCost = await quoteL2BaseCost({ ctx, l2GasLimit: l2Gas.gasLimit });
@@ -903,8 +1124,8 @@ function routeErc20Base() {
         l2GasLimit: l2Gas.gasLimit,
         gasPerPubdata: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
-        l2Contract: p.to ?? ctx.sender,
-        l2Value: p.amount
+        l2Contract,
+        l2Value
       });
       let bridgeTx;
       let calldata;
@@ -1066,7 +1287,7 @@ async function waitForL2ExecutionFromL1Tx(l1, l2, l1TxHash) {
   return { l2Receipt, l2TxHash };
 }
 var { wrapAs: wrapAs6 } = createErrorHandlers("tokens");
-var ntvCodec = createNTVCodec({
+var ntvCodec2 = createNTVCodec({
   encode: (types, values) => encodeAbiParameters(
     types.map((t, i) => ({ type: t, name: `arg${i}` })),
     values
@@ -1180,7 +1401,7 @@ function createTokensResource(client) {
     return wrapAs6("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
@@ -1379,6 +1600,7 @@ function createDepositsResource(client, tokens, contracts) {
     async () => {
       const plan = await prepare(p);
       const stepHashes = {};
+      const chainIdL2 = BigInt(await client.l2.getChainId());
       const from = client.account.address;
       let next;
       if (typeof p.l1TxOverrides?.nonce === "number") {
@@ -1430,6 +1652,7 @@ function createDepositsResource(client, tokens, contracts) {
         }
         if (!p.l1TxOverrides?.gasLimit) {
           try {
+            const preparedGasLimit = step.tx.gas;
             const feePart = step.tx.maxFeePerGas != null && step.tx.maxPriorityFeePerGas != null ? {
               maxFeePerGas: step.tx.maxFeePerGas,
               maxPriorityFeePerGas: step.tx.maxPriorityFeePerGas
@@ -1448,7 +1671,12 @@ function createDepositsResource(client, tokens, contracts) {
             const gas = await client.l1.estimateContractGas({
               ...params
             });
-            step.tx.gas = gas * 115n / 100n;
+            step.tx.gas = resolveCreateDepositL1GasLimit({
+              chainIdL2,
+              stepKey: step.key,
+              preparedGasLimit,
+              estimatedGasLimit: gas
+            });
           } catch {
           }
         }
@@ -2209,7 +2437,7 @@ var ROUTES2 = {
 };
 function createWithdrawalsResource(client, tokens, contracts) {
   const svc = createFinalizationServices(client);
-  const { wrap: wrap2, toResult: toResult2 } = createErrorHandlers("withdrawals");
+  const { wrap: wrap7, toResult: toResult3 } = createErrorHandlers("withdrawals");
   const tokensResource = tokens ?? createTokensResource(client);
   const contractsResource = contracts ?? createContractsResource(client);
   async function buildPlan(p) {
@@ -2230,23 +2458,23 @@ function createWithdrawalsResource(client, tokens, contracts) {
     };
   }
   const finalizeCache = /* @__PURE__ */ new Map();
-  const quote = (p) => wrap2(OP_WITHDRAWALS.quote, async () => (await buildPlan(p)).summary, {
+  const quote = (p) => wrap7(OP_WITHDRAWALS.quote, async () => (await buildPlan(p)).summary, {
     message: "Internal error while preparing a withdrawal quote.",
     ctx: { token: p.token, where: "withdrawals.quote" }
   });
-  const tryQuote = (p) => toResult2(OP_WITHDRAWALS.tryQuote, () => quote(p), {
+  const tryQuote = (p) => toResult3(OP_WITHDRAWALS.tryQuote, () => quote(p), {
     message: "Internal error while preparing a withdrawal quote.",
     ctx: { token: p.token, where: "withdrawals.tryQuote" }
   });
-  const prepare = (p) => wrap2(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
+  const prepare = (p) => wrap7(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
     message: "Internal error while preparing a withdrawal plan.",
     ctx: { token: p.token, where: "withdrawals.prepare" }
   });
-  const tryPrepare = (p) => toResult2(OP_WITHDRAWALS.tryPrepare, () => prepare(p), {
+  const tryPrepare = (p) => toResult3(OP_WITHDRAWALS.tryPrepare, () => prepare(p), {
     message: "Internal error while preparing a withdrawal plan.",
     ctx: { token: p.token, where: "withdrawals.tryPrepare" }
   });
-  const create = (p) => wrap2(
+  const create = (p) => wrap7(
     OP_WITHDRAWALS.create,
     async () => {
       const plan = await prepare(p);
@@ -2350,11 +2578,11 @@ function createWithdrawalsResource(client, tokens, contracts) {
       ctx: { token: p.token, amount: p.amount, to: p.to, where: "withdrawals.create" }
     }
   );
-  const tryCreate = (p) => toResult2(OP_WITHDRAWALS.tryCreate, () => create(p), {
+  const tryCreate = (p) => toResult3(OP_WITHDRAWALS.tryCreate, () => create(p), {
     message: "Internal error while creating withdrawal transactions.",
     ctx: { token: p.token, amount: p.amount, to: p.to, where: "withdrawals.tryCreate" }
   });
-  const status = (h) => wrap2(
+  const status = (h) => wrap7(
     OP_WITHDRAWALS.status,
     async () => {
       const l2TxHash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
@@ -2409,7 +2637,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
   const wait = (h, opts = {
     for: "l2",
     pollMs: 5500
-  }) => wrap2(
+  }) => wrap7(
     OP_WITHDRAWALS.wait,
     async () => {
       const l2Hash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
@@ -2478,7 +2706,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
       }
     }
   );
-  const finalize = (l2TxHash) => wrap2(
+  const finalize = (l2TxHash) => wrap7(
     OP_WITHDRAWALS.finalize.send,
     async () => {
       const pack = await (async () => {
@@ -2550,11 +2778,11 @@ function createWithdrawalsResource(client, tokens, contracts) {
       ctx: { l2TxHash, where: "withdrawals.finalize" }
     }
   );
-  const tryFinalize = (l2TxHash) => toResult2("withdrawals.tryFinalize", () => finalize(l2TxHash), {
+  const tryFinalize = (l2TxHash) => toResult3("withdrawals.tryFinalize", () => finalize(l2TxHash), {
     message: "Internal error while attempting to tryFinalize withdrawal.",
     ctx: { l2TxHash, where: "withdrawals.tryFinalize" }
   });
-  const tryWait = (h, opts) => toResult2(
+  const tryWait = (h, opts) => toResult3(
     OP_WITHDRAWALS.tryWait,
     async () => {
       const v = await wait(h, opts);
@@ -2589,17 +2817,1105 @@ function createWithdrawalsResource(client, tokens, contracts) {
     tryWait
   };
 }
+function getInteropAttributes(params, ctx) {
+  const bundleAttributes = [];
+  if (params.execution?.only) {
+    bundleAttributes.push(ctx.attributes.bundle.executionAddress(params.execution.only));
+  }
+  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": {
+        const baseMatches = ctx.baseTokens.src.toLowerCase() === ctx.baseTokens.dst.toLowerCase();
+        if (baseMatches) {
+          return [ctx.attributes.call.interopCallValue(action.amount)];
+        }
+        return [ctx.attributes.call.indirectCall(action.amount)];
+      }
+      case "call":
+        if (action.value && action.value > 0n) {
+          return [ctx.attributes.call.interopCallValue(action.value)];
+        }
+        return [];
+      case "sendErc20":
+        return [ctx.attributes.call.indirectCall(0n)];
+      default:
+        assertNever(action);
+    }
+  });
+  return { bundleAttributes, callAttributes };
+}
+function createViemAttributesResource() {
+  const encode = (fn, args) => encodeFunctionData({
+    abi: IERC7786Attributes_default,
+    functionName: fn,
+    args
+  });
+  return createAttributesResource({ encode });
+}
+var PREFIX_EVM_CHAIN = toBytes("0x00010000");
+var PREFIX_EVM_ADDRESS = toBytes("0x000100000014");
+function formatInteropEvmChain(chainId) {
+  const chainRef = toBytes(toHex(chainId));
+  const chainRefLength = toBytes(toHex(chainRef.length, { size: 1 }));
+  const payload = concat([PREFIX_EVM_CHAIN, chainRefLength, chainRef, new Uint8Array([0])]);
+  return toHex(payload);
+}
+function formatInteropEvmAddress(address) {
+  const normalized = getAddress(address);
+  const addrBytes = toBytes(normalized);
+  const payload = concat([PREFIX_EVM_ADDRESS, addrBytes]);
+  return toHex(payload);
+}
+var interopCodec = {
+  formatChain: formatInteropEvmChain,
+  formatAddress: formatInteropEvmAddress
+};
+function getErc20Tokens(params) {
+  const erc20Tokens = /* @__PURE__ */ new Map();
+  for (const action of params.actions) {
+    if (action.type !== "sendErc20") continue;
+    erc20Tokens.set(action.token.toLowerCase(), action.token);
+  }
+  return Array.from(erc20Tokens.values());
+}
+function buildEnsureTokenSteps(erc20Tokens, ctx) {
+  if (erc20Tokens.length === 0) return [];
+  return erc20Tokens.map((token) => ({
+    key: `ensure-token:${token.toLowerCase()}`,
+    kind: "interop.ntv.ensure-token",
+    description: `Ensure ${token} is registered in the native token vault`,
+    tx: {
+      to: ctx.l2NativeTokenVault,
+      data: encodeFunctionData({
+        abi: L2NativeTokenVault_default,
+        functionName: "ensureTokenIsRegistered",
+        args: [token]
+      }),
+      ...ctx.gasOverrides
+    }
+  }));
+}
+async function buildApproveSteps(approvals, ctx) {
+  const steps = [];
+  for (const approval of approvals) {
+    const currentAllowance = await ctx.client.l2.readContract({
+      address: approval.token,
+      abi: IERC20_default,
+      functionName: "allowance",
+      args: [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: encodeFunctionData({
+            abi: IERC20_default,
+            functionName: "approve",
+            args: [approval.spender, approval.amount]
+          }),
+          ...ctx.gasOverrides
+        }
+      });
+    }
+  }
+  return steps;
+}
+async function resolveErc20AssetIds(erc20Tokens, ctx) {
+  const assetIds = /* @__PURE__ */ new Map();
+  if (erc20Tokens.length === 0) return assetIds;
+  for (const token of erc20Tokens) {
+    const { result: assetId } = await ctx.client.l2.simulateContract({
+      address: ctx.l2NativeTokenVault,
+      abi: L2NativeTokenVault_default,
+      functionName: "ensureTokenIsRegistered",
+      args: [token],
+      account: ctx.sender
+    });
+    assetIds.set(token.toLowerCase(), assetId);
+  }
+  return assetIds;
+}
+
+// src/adapters/viem/resources/interop/services/starter-data.ts
+async function getStarterData(params, ctx, erc20AssetIds) {
+  const starterData = [];
+  for (const action of params.actions) {
+    switch (action.type) {
+      case "sendErc20": {
+        const assetId = erc20AssetIds.get(action.token.toLowerCase());
+        if (!assetId) {
+          throw new Error(`Missing precomputed assetId for token ${action.token}.`);
+        }
+        const transferData = encodeNativeTokenVaultTransferData(
+          action.amount,
+          action.to,
+          action.token
+        );
+        const assetRouterPayload = encodeSecondBridgeDataV1(assetId, transferData);
+        starterData.push({ assetRouterPayload });
+        break;
+      }
+      case "sendNative":
+        if (!ctx.baseTokens.matches) {
+          const assetId = await ctx.tokens.baseTokenAssetId();
+          const transferData = encodeNativeTokenVaultTransferData(
+            action.amount,
+            action.to,
+            ctx.baseTokens.src
+          );
+          const assetRouterPayload = encodeSecondBridgeDataV1(assetId, transferData);
+          starterData.push({ assetRouterPayload });
+        } else {
+          starterData.push({});
+        }
+        break;
+      case "call":
+        starterData.push({});
+        break;
+      default:
+        assertNever(action);
+    }
+  }
+  return starterData;
+}
+
+// src/adapters/viem/resources/interop/services/fee.ts
+var { wrap: wrap2 } = createErrorHandlers("interop");
+async function buildFeeInfo(params, ctx, numStarters) {
+  const useFixed = params.fee?.useFixed ?? false;
+  if (useFixed) {
+    const zkFeePerCall = await wrap2(
+      OP_INTEROP.svc.fees.zkInteropFee,
+      () => ctx.client.l2.readContract({
+        address: ctx.interopCenter,
+        abi: IInteropCenter_default,
+        functionName: "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,
+      () => ctx.client.l2.readContract({
+        address: ctx.interopCenter,
+        abi: IInteropCenter_default,
+        functionName: "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,
+      () => ctx.client.l2.readContract({
+        address: ctx.interopCenter,
+        abi: IInteropCenter_default,
+        functionName: "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/viem/resources/interop/routes/indirect.ts
+function routeIndirect() {
+  return {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async preflight(params, ctx) {
+      preflightIndirect(params, {
+        dstChainId: ctx.dstChainId,
+        baseTokens: ctx.baseTokens,
+        l2AssetRouter: ctx.l2AssetRouter,
+        l2NativeTokenVault: ctx.l2NativeTokenVault,
+        codec: interopCodec
+      });
+    },
+    async build(params, ctx) {
+      const steps = [];
+      const erc20Tokens = getErc20Tokens(params);
+      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(
+        params,
+        {
+          dstChainId: ctx.dstChainId,
+          baseTokens: ctx.baseTokens,
+          l2AssetRouter: ctx.l2AssetRouter,
+          l2NativeTokenVault: ctx.l2NativeTokenVault,
+          codec: interopCodec
+        },
+        attributes,
+        starterData,
+        feeInfo
+      );
+      steps.push(...buildEnsureTokenSteps(erc20Tokens, ctx));
+      steps.push(...await buildApproveSteps(bundle.approvals, ctx));
+      const data = encodeFunctionData({
+        abi: IInteropCenter_default,
+        functionName: "sendBundle",
+        args: [bundle.dstChain, bundle.starters, bundle.bundleAttributes]
+      });
+      steps.push({
+        key: "sendBundle",
+        kind: "interop.center",
+        description: "Send interop bundle (indirect route)",
+        tx: {
+          to: ctx.interopCenter,
+          data,
+          value: bundle.quoteExtras.totalActionValue + feeInfo.fee.amount,
+          ...ctx.gasOverrides
+        }
+      });
+      return {
+        steps,
+        approvals: bundle.approvals,
+        quoteExtras: bundle.quoteExtras,
+        interopFee: feeInfo.fee
+      };
+    }
+  };
+}
+function routeDirect() {
+  return {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async preflight(params, ctx) {
+      preflightDirect(params, {
+        dstChainId: ctx.dstChainId,
+        baseTokens: ctx.baseTokens,
+        l2AssetRouter: ctx.l2AssetRouter,
+        l2NativeTokenVault: ctx.l2NativeTokenVault,
+        codec: interopCodec
+      });
+    },
+    async build(params, ctx) {
+      const steps = [];
+      const attrs = getInteropAttributes(params, ctx);
+      const feeInfo = await buildFeeInfo(params, ctx, params.actions.length);
+      const built = buildDirectBundle(
+        params,
+        {
+          dstChainId: ctx.dstChainId,
+          baseTokens: ctx.baseTokens,
+          l2AssetRouter: ctx.l2AssetRouter,
+          l2NativeTokenVault: ctx.l2NativeTokenVault,
+          codec: interopCodec
+        },
+        attrs,
+        feeInfo
+      );
+      steps.push(...await buildApproveSteps(built.approvals, ctx));
+      const data = encodeFunctionData({
+        abi: IInteropCenter_default,
+        functionName: "sendBundle",
+        args: [built.dstChain, built.starters, built.bundleAttributes]
+      });
+      steps.push({
+        key: "sendBundle",
+        kind: "interop.center",
+        description: `Send interop bundle (direct route; ${params.actions.length} actions)`,
+        tx: {
+          to: ctx.interopCenter,
+          data,
+          value: built.quoteExtras.totalActionValue + feeInfo.fee.amount,
+          ...ctx.gasOverrides
+        }
+      });
+      return {
+        steps,
+        approvals: built.approvals,
+        quoteExtras: built.quoteExtras,
+        interopFee: feeInfo.fee
+      };
+    }
+  };
+}
+
+// src/adapters/viem/resources/interop/context.ts
+async function assertInteropProtocolVersion(client, srcChainId, dstChainId) {
+  const [srcProtocolVersion, dstProtocolVersion] = await Promise.all([
+    client.getProtocolVersion(srcChainId),
+    client.getProtocolVersion(dstChainId)
+  ]);
+  assertProtocolVersion(srcChainId, srcProtocolVersion);
+  assertProtocolVersion(dstChainId, dstProtocolVersion);
+}
+async function commonCtx3(dstPublicClient, params, client, tokens, contracts, attributes) {
+  const sender = client.account.address;
+  const chainId = BigInt(await client.l2.getChainId());
+  const dstChainId = BigInt(await dstPublicClient.getChainId());
+  const {
+    bridgehub,
+    l2AssetRouter,
+    l2NativeTokenVault,
+    interopCenter,
+    interopHandler,
+    l2MessageVerification
+  } = await contracts.addresses();
+  await assertInteropProtocolVersion(client, chainId, dstChainId);
+  const [srcBaseToken, dstBaseToken] = await Promise.all([
+    client.baseToken(chainId),
+    client.baseToken(dstChainId)
+  ]);
+  const baseMatches = srcBaseToken.toLowerCase() === dstBaseToken.toLowerCase();
+  return {
+    client,
+    tokens,
+    contracts,
+    sender,
+    chainIdL2: chainId,
+    chainId,
+    bridgehub,
+    dstChainId,
+    dstPublicClient,
+    interopCenter,
+    interopHandler,
+    l2MessageVerification,
+    l2AssetRouter,
+    l2NativeTokenVault,
+    baseTokens: { src: srcBaseToken, dst: dstBaseToken, matches: baseMatches },
+    attributes,
+    gasOverrides: params.txOverrides ? toGasOverrides(params.txOverrides) : void 0
+  };
+}
+function getTopics() {
+  const topics = {
+    interopBundleSent: encodeEventTopics({
+      abi: IInteropCenter_default,
+      eventName: "InteropBundleSent"
+    })[0],
+    bundleVerified: encodeEventTopics({
+      abi: IInteropHandler_default,
+      eventName: "BundleVerified"
+    })[0],
+    bundleExecuted: encodeEventTopics({
+      abi: IInteropHandler_default,
+      eventName: "BundleExecuted"
+    })[0],
+    bundleUnbundled: encodeEventTopics({
+      abi: IInteropHandler_default,
+      eventName: "BundleUnbundled"
+    })[0]
+  };
+  return { topics };
+}
+var { wrap: wrap3 } = createErrorHandlers("interop");
+var DEFAULT_BLOCKS_RANGE_SIZE = 1e4;
+var DEFAULT_MAX_BLOCKS_BACK = 2e4;
+var SAFE_BLOCKS_RANGE_SIZE = 1e3;
+function parseMaxBlockRangeLimit(error) {
+  const msg = typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
+  const match = /query exceeds max block range\s+(\d+)/i.exec(msg);
+  if (!match) return null;
+  const limit = Number.parseInt(match[1], 10);
+  return Number.isInteger(limit) && limit > 0 ? limit : null;
+}
+async function getTxReceipt(provider, txHash) {
+  const receipt = await wrap3(
+    OP_INTEROP.svc.status.sourceReceipt,
+    async () => {
+      try {
+        return await provider.getTransactionReceipt({ hash: 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."
+    }
+  );
+  if (!receipt) return null;
+  return {
+    logs: receipt.logs.map((log) => ({
+      address: log.address,
+      topics: log.topics,
+      data: log.data,
+      transactionHash: log.transactionHash
+    }))
+  };
+}
+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 wrap3(
+    OP_INTEROP.svc.status.dstLogs,
+    async () => {
+      const currentBlock = await provider.getBlockNumber();
+      const minBlock = BigInt(Math.max(0, Number(currentBlock) - maxBlocksBack));
+      let toBlock = currentBlock;
+      let chunkSize = initialChunkSize;
+      while (toBlock >= minBlock) {
+        const fromBlock = toBlock - BigInt(chunkSize) + 1n > minBlock ? toBlock - BigInt(chunkSize) + 1n : minBlock;
+        try {
+          const rawLogs = await provider.request({
+            method: "eth_getLogs",
+            params: [
+              {
+                address,
+                topics,
+                fromBlock: numberToHex(fromBlock),
+                toBlock: numberToHex(toBlock)
+              }
+            ]
+          });
+          if (rawLogs.length > 0) {
+            return rawLogs.map((log) => ({
+              address: log.address,
+              topics: log.topics,
+              data: log.data,
+              transactionHash: log.transactionHash
+            }));
+          }
+          toBlock = fromBlock - 1n;
+        } catch (error) {
+          const serverLimit = parseMaxBlockRangeLimit(error);
+          if (serverLimit == null) {
+            if (chunkSize > SAFE_BLOCKS_RANGE_SIZE) {
+              chunkSize = SAFE_BLOCKS_RANGE_SIZE;
+            } else {
+              throw error;
+            }
+          } else {
+            chunkSize = Math.min(chunkSize, serverLimit);
+          }
+        }
+      }
+      return [];
+    },
+    {
+      ctx: { address, maxBlocksBack, logChunkSize: initialChunkSize },
+      message: "Failed to query destination bundle lifecycle logs."
+    }
+  );
+}
+async function getInteropRoot(provider, rootChainId, batchNumber) {
+  return await wrap3(
+    OP_INTEROP.svc.status.getRoot,
+    async () => {
+      return await provider.readContract({
+        address: L2_INTEROP_ROOT_STORAGE_ADDRESS,
+        abi: IInteropRootStorage_default,
+        functionName: "interopRoots",
+        args: [rootChainId, batchNumber]
+      });
+    },
+    {
+      ctx: { rootChainId, batchNumber },
+      message: "Failed to get interop root from the destination chain."
+    }
+  );
+}
+
+// src/adapters/viem/resources/interop/services/finalization/bundle.ts
+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);
+  const findLastByTopic = (eventTopic) => bundleLogs.findLast((log) => log.topics[0].toLowerCase() === eventTopic.toLowerCase());
+  const lifecycleChecks = [
+    { phase: "UNBUNDLED", topic: topics.bundleUnbundled, includeTxHash: true },
+    { phase: "EXECUTED", topic: topics.bundleExecuted, includeTxHash: true },
+    { phase: "VERIFIED", topic: topics.bundleVerified }
+  ];
+  for (const check of lifecycleChecks) {
+    const match = findLastByTopic(check.topic);
+    if (!match) continue;
+    if (check.includeTxHash) {
+      return { phase: check.phase, dstExecTxHash: match.transactionHash };
+    }
+    return { phase: check.phase };
+  }
+  return { phase: "SENT" };
+}
+async function executeBundle(client, dstProvider, info, opts) {
+  const { topics } = getTopics();
+  const { bundleHash, encodedData, proof } = info;
+  const dstStatus = await getBundleStatus(client, dstProvider, topics, bundleHash, opts);
+  if (["EXECUTED", "UNBUNDLED"].includes(dstStatus.phase)) {
+    throw createError("STATE", {
+      resource: "interop",
+      operation: OP_INTEROP.finalize,
+      message: `Interop bundle has already been ${dstStatus.phase.toLowerCase()}.`,
+      context: { bundleHash }
+    });
+  }
+  const dstWallet = await wrap4(
+    OP_INTEROP.exec.sendStep,
+    () => createWalletClient({
+      account: client.account,
+      transport: custom(dstProvider.transport),
+      chain: dstProvider.chain
+    }),
+    { message: "Failed to create destination wallet client." }
+  );
+  const { interopHandler } = await client.ensureAddresses();
+  try {
+    const hash = await dstWallet.writeContract({
+      address: interopHandler,
+      abi: IInteropHandler_default,
+      functionName: "executeBundle",
+      args: [encodedData, proof],
+      account: client.account,
+      chain: dstProvider.chain ?? null
+    });
+    return {
+      hash,
+      wait: async () => {
+        try {
+          const receipt = await dstProvider.waitForTransactionReceipt({ hash });
+          if (receipt.status === "reverted") {
+            throw createError("EXECUTION", {
+              resource: "interop",
+              operation: OP_INTEROP.exec.waitStep,
+              message: "Interop bundle execution reverted on destination.",
+              context: { txHash: hash }
+            });
+          }
+          return receipt;
+        } catch (e) {
+          if (isZKsyncError(e)) throw e;
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "interop",
+              operation: OP_INTEROP.exec.waitStep,
+              message: "Failed while waiting for executeBundle transaction on destination.",
+              context: { txHash: hash }
+            },
+            e
+          );
+        }
+      }
+    };
+  } catch (e) {
+    throw toZKsyncError(
+      "EXECUTION",
+      {
+        resource: "interop",
+        operation: OP_INTEROP.exec.sendStep,
+        message: "Failed to send executeBundle transaction on destination chain."
+      },
+      e
+    );
+  }
+}
+function decodeInteropBundleSent(log) {
+  const { args } = decodeEventLog({
+    abi: IInteropCenter_default,
+    eventName: "InteropBundleSent",
+    data: log.data,
+    topics: log.topics
+  });
+  return {
+    bundleHash: args.interopBundleHash,
+    sourceChainId: args.interopBundle.sourceChainId,
+    destinationChainId: args.interopBundle.destinationChainId
+  };
+}
+function decodeL1MessageData(log) {
+  const [decoded] = decodeAbiParameters([{ type: "bytes" }], log.data);
+  return decoded;
+}
+
+// src/adapters/viem/resources/interop/services/finalization/polling.ts
+var { wrap: wrap5 } = createErrorHandlers("interop");
+function isProofNotReadyError(error) {
+  return isZKsyncError(error, {
+    operation: "zksrpc.getL2ToL1LogProof",
+    messageIncludes: "proof not yet available"
+  });
+}
+function shouldRetryRootFetch(error) {
+  if (!isZKsyncError(error)) return false;
+  return error.envelope.operation === OP_INTEROP.svc.status.getRoot;
+}
+async function waitForProof(client, l2SrcTxHash, logIndex, blockNumber, pollMs, deadline) {
+  while (true) {
+    if (Date.now() > deadline) {
+      throw createError("TIMEOUT", {
+        resource: "interop",
+        operation: OP_INTEROP.svc.wait.timeout,
+        message: "Timed out waiting for block to be finalized.",
+        context: { l2SrcTxHash, logIndex, blockNumber }
+      });
+    }
+    const finalizedBlock = await client.l2.getBlock({ blockTag: "finalized" });
+    if (finalizedBlock && finalizedBlock.number !== null && finalizedBlock.number >= blockNumber) {
+      break;
+    }
+    await sleep(pollMs);
+  }
+  while (true) {
+    if (Date.now() > deadline) {
+      throw createError("TIMEOUT", {
+        resource: "interop",
+        operation: OP_INTEROP.svc.wait.timeout,
+        message: "Timed out waiting for L2->L1 log proof to become available.",
+        context: { l2SrcTxHash, logIndex }
+      });
+    }
+    try {
+      return await client.zks.getL2ToL1LogProof(l2SrcTxHash, logIndex, "messageRoot" /* MessageRoot */);
+    } catch (error) {
+      if (!isProofNotReadyError(error)) throw error;
+    }
+    await sleep(pollMs);
+  }
+}
+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: { chainId, batchNumber }
+      });
+    }
+    let interopRoot = null;
+    try {
+      const root = await getInteropRoot(provider, chainId, batchNumber);
+      if (root !== ZERO_HASH) {
+        interopRoot = root;
+      }
+    } catch (error) {
+      if (!shouldRetryRootFetch(error)) throw error;
+      interopRoot = null;
+    }
+    if (interopRoot) {
+      return interopRoot;
+    }
+    await sleep(pollMs);
+  }
+}
+async function waitForTxReceipt(client, txHash, pollMs, deadline) {
+  while (true) {
+    if (Date.now() > deadline) {
+      throw createError("TIMEOUT", {
+        resource: "interop",
+        operation: OP_INTEROP.svc.wait.timeout,
+        message: "Timed out waiting for source receipt to be available.",
+        context: { txHash }
+      });
+    }
+    const receipt = await wrap5(
+      OP_INTEROP.svc.status.sourceReceipt,
+      () => client.zks.getReceiptWithL2ToL1(txHash),
+      {
+        ctx: { where: "zks.getReceiptWithL2ToL1", txHash },
+        message: "Failed to fetch source L2 receipt (with L2->L1 logs) for interop tx."
+      }
+    );
+    if (receipt) {
+      return receipt;
+    }
+    await sleep(pollMs);
+  }
+}
+async function waitForFinalization(client, dstProvider, gwProvider, input, opts) {
+  const { topics } = getTopics();
+  const pollMs = opts?.pollMs ?? DEFAULT_POLL_MS;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  const ids = resolveIdsFromWaitable(input);
+  if (!ids.l2SrcTxHash) {
+    throw createError("STATE", {
+      resource: "interop",
+      operation: OP_INTEROP.svc.status.sourceReceipt,
+      message: "Cannot wait for interop finalization: missing l2SrcTxHash.",
+      context: { input }
+    });
+  }
+  const { interopCenter } = await client.ensureAddresses();
+  let bundleInfo = null;
+  while (!bundleInfo) {
+    if (Date.now() > deadline) {
+      throw createError("TIMEOUT", {
+        resource: "interop",
+        operation: OP_INTEROP.svc.wait.timeout,
+        message: "Timed out waiting for source receipt to be available.",
+        context: { l2SrcTxHash: ids.l2SrcTxHash }
+      });
+    }
+    const txReceipt = await waitForTxReceipt(client, ids.l2SrcTxHash, pollMs, deadline);
+    bundleInfo = parseBundleReceiptInfo({
+      rawReceipt: txReceipt,
+      interopCenter,
+      interopBundleSentTopic: topics.interopBundleSent,
+      decodeInteropBundleSent: (log) => decodeInteropBundleSent(log),
+      decodeL1MessageData,
+      l2SrcTxHash: ids.l2SrcTxHash
+    });
+  }
+  const proof = await waitForProof(
+    client,
+    ids.l2SrcTxHash,
+    bundleInfo.l2ToL1LogIndex,
+    BigInt(bundleInfo.rawReceipt.blockNumber),
+    pollMs,
+    deadline
+  );
+  const finalizationInfo = buildFinalizationInfo(
+    { l2SrcTxHash: ids.l2SrcTxHash, bundleHash: ids.bundleHash },
+    bundleInfo,
+    proof,
+    bundleInfo.l1MessageData
+  );
+  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 gwChainId = BigInt(await gwProvider.getChainId());
+  await waitForRoot(dstProvider, gwChainId, proof.gatewayBlockNumber, pollMs, deadline);
+  return finalizationInfo;
+}
+
+// src/adapters/viem/resources/interop/services/finalization/status.ts
+async function getStatus(client, dstProvider, input, opts) {
+  const { topics } = getTopics();
+  const baseIds = resolveIdsFromWaitable(input);
+  const enrichedIds = await (async () => {
+    if (baseIds.bundleHash) return baseIds;
+    if (!baseIds.l2SrcTxHash) return baseIds;
+    const { interopCenter } = await client.ensureAddresses();
+    const receipt = await getTxReceipt(client.l2, baseIds.l2SrcTxHash);
+    if (!receipt) return baseIds;
+    const { bundleHash } = parseBundleSentFromReceipt({
+      receipt: { logs: receipt.logs },
+      interopCenter,
+      interopBundleSentTopic: topics.interopBundleSent,
+      decodeInteropBundleSent: (log) => decodeInteropBundleSent(log)
+    });
+    return { ...baseIds, bundleHash };
+  })();
+  if (!enrichedIds.bundleHash) {
+    const phase = enrichedIds.l2SrcTxHash ? "SENT" : "UNKNOWN";
+    return {
+      phase,
+      l2SrcTxHash: enrichedIds.l2SrcTxHash,
+      bundleHash: enrichedIds.bundleHash,
+      dstExecTxHash: enrichedIds.dstExecTxHash
+    };
+  }
+  const dstInfo = await getBundleStatus(client, dstProvider, topics, enrichedIds.bundleHash, opts);
+  return {
+    phase: dstInfo.phase,
+    l2SrcTxHash: enrichedIds.l2SrcTxHash,
+    bundleHash: enrichedIds.bundleHash,
+    dstExecTxHash: dstInfo.dstExecTxHash ?? enrichedIds.dstExecTxHash
+  };
+}
+
+// src/adapters/viem/resources/interop/services/finalization/index.ts
+function createInteropFinalizationServices(client) {
+  return {
+    status(dstProvider, input, opts) {
+      return getStatus(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);
+      await execResult.wait();
+      return {
+        bundleHash: info.bundleHash,
+        dstExecTxHash: execResult.hash
+      };
+    }
+  };
+}
+function resolveChainRef(ref) {
+  if (typeof ref === "string") {
+    return createPublicClient({ transport: http(ref) });
+  }
+  return ref;
+}
+
+// src/adapters/viem/resources/interop/services/gas.ts
+async function quoteStepsL2Fee(steps, ctx) {
+  if (steps.length === 0) return 0n;
+  const estimator = viemToGasEstimator(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 = {
+        to: step.tx.to,
+        from: ctx.sender,
+        data: step.tx.data,
+        value: step.tx.value,
+        gasLimit: step.tx.gas ?? step.tx.gasLimit,
+        maxFeePerGas: step.tx.maxFeePerGas,
+        maxPriorityFeePerGas: step.tx.maxPriorityFeePerGas
+      };
+      const est = await estimator.estimateGas(coreTx);
+      const buffered = BigInt(est) * (100n + BUFFER) / 100n;
+      total += buffered * maxFeePerGas;
+    } catch {
+      return void 0;
+    }
+  }
+  return total;
+}
+
+// src/adapters/viem/resources/interop/index.ts
+var { wrap: wrap6, toResult: toResult2 } = createErrorHandlers("interop");
+var ROUTES3 = {
+  direct: routeDirect(),
+  indirect: routeIndirect()
+};
+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 createViemSdk 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);
+  const attributesResource = attributes ?? createViemAttributesResource();
+  async function buildPlanWithCtx(dstPublicClient, params) {
+    const ctx = await commonCtx3(
+      dstPublicClient,
+      params,
+      client,
+      tokensResource,
+      contractsResource,
+      attributesResource
+    );
+    const route = pickInteropRoute({
+      actions: params.actions,
+      ctx: {
+        sender: ctx.sender,
+        srcChainId: ctx.chainId,
+        dstChainId: ctx.dstChainId,
+        baseTokenSrc: ctx.baseTokens.src,
+        baseTokenDst: ctx.baseTokens.dst
+      }
+    });
+    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, interopFee } = await wrap6(
+      OP_INTEROP.routes[route].build,
+      () => ROUTES3[route].build(params, ctx),
+      {
+        message: "Failed to build interop route plan.",
+        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,
+      l2Fee
+    };
+    return { plan: { route, summary, steps }, ctx };
+  }
+  async function buildPlan(dstPublicClient, params) {
+    const { plan } = await buildPlanWithCtx(dstPublicClient, params);
+    return plan;
+  }
+  const quote = (dstChain, params) => wrap6(OP_INTEROP.quote, async () => {
+    const plan = await buildPlan(resolveChainRef(dstChain), params);
+    return plan.summary;
+  });
+  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 = (dstChain, params) => toResult2(
+    OP_INTEROP.tryPrepare,
+    () => prepare(dstChain, params)
+  );
+  const create = (dstChain, params) => wrap6(
+    OP_INTEROP.create,
+    async () => {
+      const { plan } = await buildPlanWithCtx(resolveChainRef(dstChain), params);
+      const l2Wallet = client.getL2Wallet();
+      const from = client.account.address;
+      let next;
+      if (typeof params.txOverrides?.nonce === "number") {
+        next = params.txOverrides.nonce;
+      } else {
+        const blockTag = params.txOverrides?.nonce ?? "pending";
+        next = await client.l2.getTransactionCount({ address: from, blockTag });
+      }
+      const stepHashes = {};
+      for (const step of plan.steps) {
+        let gasLimit = step.tx.gas ?? step.tx.gasLimit;
+        if (!gasLimit) {
+          try {
+            const est = await client.l2.estimateGas({
+              account: from,
+              to: step.tx.to,
+              data: step.tx.data,
+              value: step.tx.value
+            });
+            gasLimit = est * 115n / 100n;
+          } catch {
+          }
+        }
+        let hash;
+        try {
+          hash = await l2Wallet.sendTransaction({
+            to: step.tx.to,
+            data: step.tx.data,
+            value: step.tx.value,
+            gas: gasLimit,
+            maxFeePerGas: step.tx.maxFeePerGas,
+            maxPriorityFeePerGas: step.tx.maxPriorityFeePerGas,
+            nonce: next++,
+            account: client.account,
+            chain: null
+          });
+          stepHashes[step.key] = hash;
+          const rcpt = await client.l2.waitForTransactionReceipt({ hash });
+          if (rcpt.status === "reverted") {
+            throw createError("EXECUTION", {
+              resource: "interop",
+              operation: "interop.create.sendTransaction",
+              message: "Interop transaction reverted on source L2.",
+              context: { step: step.key, txHash: hash }
+            });
+          }
+        } catch (e) {
+          if (isZKsyncError(e)) throw e;
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "interop",
+              operation: "interop.create.sendTransaction",
+              message: "Failed to send or confirm an interop transaction step.",
+              context: {
+                step: step.key,
+                txHash: hash,
+                nonce: next - 1
+              }
+            },
+            e
+          );
+        }
+      }
+      const last = Object.values(stepHashes).pop();
+      return {
+        kind: "interop",
+        stepHashes,
+        plan,
+        l2SrcTxHash: last ?? "0x"
+      };
+    },
+    {
+      message: "Internal error while creating interop bundle.",
+      ctx: { where: "interop.create" }
+    }
+  );
+  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)) {
+        return svc.finalize(dstProvider, h, opts);
+      }
+      const info = await svc.wait(dstProvider, getGwProvider(), h);
+      return svc.finalize(dstProvider, info, opts);
+    },
+    {
+      message: "Failed to finalize/execute interop bundle on destination.",
+      ctx: { where: "interop.finalize" }
+    }
+  );
+  const tryFinalize = (dstChain, h, opts) => toResult2(OP_INTEROP.tryFinalize, () => finalize(dstChain, h, opts));
+  return {
+    quote,
+    tryQuote,
+    prepare,
+    tryPrepare,
+    create,
+    tryCreate,
+    status,
+    wait,
+    tryWait,
+    finalize,
+    tryFinalize
+  };
+}
 
 // src/adapters/viem/sdk.ts
-function createViemSdk(client) {
+function createViemSdk(client, options) {
   const tokens = createTokensResource(client);
   const contracts = createContractsResource(client);
+  const interop = createInteropResource(client, options?.interop, tokens, contracts);
   return {
     deposits: createDepositsResource(client, tokens, contracts),
     withdrawals: createWithdrawalsResource(client, tokens, contracts),
     tokens,
-    contracts
+    contracts,
+    interop
   };
 }
 
-export { buildDirectRequestStruct, createContractsResource, createDepositsResource, createFinalizationServices, createTokensResource, createViemSdk, createWithdrawalsResource, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getL2TransactionHashFromLogs };
+export { buildDirectRequestStruct, createContractsResource, createDepositsResource, createFinalizationServices, createInteropFinalizationServices, createInteropResource, createTokensResource, createViemSdk, createWithdrawalsResource, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getL2TransactionHashFromLogs };