@matterlabs/zksync-js 0.0.8 → 0.0.9

package/dist/adapters/ethers/sdk.cjs

@@ -10,9 +10,14 @@ var utils = require('@noble/hashes/utils');
 var RegExpHex = /^0x[0-9a-fA-F]*$/;
 var isHash = (x, length) => {
   if (!x || typeof x !== "string") return false;
-  return (x.length === length) && RegExpHex.test(x);
+  return (length === void 0 || x.length === length) && RegExpHex.test(x);
+};
+var isHashArray = (x, length) => {
+  if (!Array.isArray(x)) return false;
+  return x.every((item) => isHash(item, length));
 };
 var isHash66 = (x) => isHash(x, 66);
+var isHash66Array = (x) => isHashArray(x, 66);
 var k256hex = (s) => `0x${utils.bytesToHex(sha3.keccak_256(utils.utf8ToBytes(s)))}`.toLowerCase();
 var FORMAL_ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
 var ETH_ADDRESS = "0x0000000000000000000000000000000000000001";
@@ -20,6 +25,9 @@ var L2_ASSET_ROUTER_ADDRESS = "0x0000000000000000000000000000000000010003";
 var L2_NATIVE_TOKEN_VAULT_ADDRESS = "0x0000000000000000000000000000000000010004";
 var L1_MESSENGER_ADDRESS = "0x0000000000000000000000000000000000008008";
 var L2_BASE_TOKEN_ADDRESS = "0x000000000000000000000000000000000000800A";
+var L2_INTEROP_CENTER_ADDRESS = "0x000000000000000000000000000000000001000d";
+var L2_INTEROP_ROOT_STORAGE_ADDRESS = "0x0000000000000000000000000000000000010008";
+var BUNDLE_IDENTIFIER = "0x01";
 var TOPIC_L1_MESSAGE_SENT_NEW = k256hex("L1MessageSent(uint256,bytes32,bytes)");
 var TOPIC_L1_MESSAGE_SENT_LEG = k256hex("L1MessageSent(address,bytes32,bytes)");
 var TOPIC_CANONICAL_ASSIGNED = "0x779f441679936c5441b671969f37400b8c3ed0071cb47444431bf985754560df";
@@ -36,6 +44,9 @@ var isNumber = (x) => typeof x === "number" && Number.isFinite(x);
 var isBigint = (x) => typeof x === "bigint";
 
 // src/core/utils/addr.ts
+function isAddress(x) {
+  return isHash(x, 42);
+}
 function isAddressEq(a, b) {
   return a.toLowerCase() === b.toLowerCase();
 }
@@ -54,6 +65,14 @@ function normalizeAddrEq(a, b) {
 var hexEq = (a, b) => a.toLowerCase() === b.toLowerCase();
 var normalizeL1Token = (token) => isAddressEq(token, FORMAL_ETH_ADDRESS) ? ETH_ADDRESS : token;
 
+// src/core/utils/index.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function assertNever(x) {
+  throw new Error("Unexpected action type: " + String(x));
+}
+
 // src/core/errors/formatter.ts
 function elideMiddle(s, max = 96) {
   if (s.length <= max) return s;
@@ -199,12 +218,18 @@ if (kInspect) {
     enumerable: false
   });
 }
-function isZKsyncError(e) {
+function isZKsyncError(e, opts) {
   if (!e || typeof e !== "object") return false;
   const maybe = e;
   if (!("envelope" in maybe)) return false;
   const envelope = maybe.envelope;
-  return typeof envelope?.type === "string" && typeof envelope?.message === "string";
+  if (typeof envelope?.type !== "string" || typeof envelope?.message !== "string") return false;
+  if (opts?.type && envelope.type !== opts.type) return false;
+  if (opts?.resource && envelope.resource !== opts.resource) return false;
+  if (opts?.operation && envelope.operation !== opts.operation) return false;
+  if (opts?.messageIncludes && !envelope.message.toLowerCase().includes(opts.messageIncludes.toLowerCase()))
+    return false;
+  return true;
 }
 function isReceiptNotFound(e) {
   const chain = [];
@@ -319,11 +344,9 @@ var OP_WITHDRAWALS = {
       rawReceipt: "withdrawals.finalize.fetchParams:rawReceipt",
       messengerIndex: "withdrawals.finalize.fetchParams:messengerIndex",
       proof: "withdrawals.finalize.fetchParams:proof",
-      network: "withdrawals.finalize.fetchParams:network",
-      ensureAddresses: "withdrawals.finalize.fetchParams:ensureAddresses"
+      network: "withdrawals.finalize.fetchParams:network"
     },
     readiness: {
-      ensureAddresses: "withdrawals.finalize.readiness:ensureAddresses",
       isFinalized: "withdrawals.finalize.readiness:isWithdrawalFinalized",
       simulate: "withdrawals.finalize.readiness:simulate"
     },
@@ -333,6 +356,54 @@ var OP_WITHDRAWALS = {
     estimate: "withdrawals.finalize.estimateFinalizationFees"
   }
 };
+var OP_INTEROP = {
+  // high-level flow ops (match resource methods)
+  quote: "interop.quote",
+  tryQuote: "interop.tryQuote",
+  prepare: "interop.prepare",
+  tryPrepare: "interop.tryPrepare",
+  create: "interop.create",
+  tryCreate: "interop.tryCreate",
+  status: "interop.status",
+  wait: "interop.wait",
+  tryWait: "interop.tryWait",
+  finalize: "interop.finalize",
+  tryFinalize: "interop.tryFinalize",
+  context: {
+    chainTypeManager: "interop.chainTypeManager",
+    protocolVersion: "interop.protocolVersion"
+  },
+  // route-specific ops (keep names aligned with files)
+  routes: {
+    direct: {
+      preflight: "interop.routes.direct:preflight",
+      build: "interop.routes.direct:build"
+    },
+    indirect: {
+      preflight: "interop.routes.indirect:preflight",
+      build: "interop.routes.indirect:build"
+    }
+  },
+  // execution path (nonce, gas, send, wait) – mirrors deposits’ style
+  exec: {
+    sendStep: "interop.exec:sendStep",
+    waitStep: "interop.exec:waitStep"
+  },
+  // status service (logs & derivation)
+  svc: {
+    status: {
+      sourceReceipt: "interop.svc.status:sourceReceipt",
+      parseSentLog: "interop.svc.status:parseSentLog",
+      dstLogs: "interop.svc.status:dstLogs",
+      derive: "interop.svc.status:derive",
+      getRoot: "interop.svc.status:getRoot"
+    },
+    wait: {
+      poll: "interop.svc.wait:poll",
+      timeout: "interop.svc.wait:timeout"
+    }
+  }
+};
 
 // src/core/errors/factory.ts
 function createError(type, input) {
@@ -369,7 +440,7 @@ var I_BRIDGEHUB = new ethers.Interface([
   "event NewPriorityRequest(uint256 indexed chainId, address indexed sender, bytes32 txHash, uint256 txId, bytes data)"
 ]);
 var TOPIC_BRIDGEHUB_NPR = I_BRIDGEHUB.getEvent("NewPriorityRequest").topicHash;
-function extractL2TxHashFromL1Logs(logs) {
+function getL2TransactionHashFromLogs(logs) {
   for (const lg of logs) {
     if ((lg.topics?.[0] ?? "").toLowerCase() === TOPIC_BRIDGEHUB_NPR.toLowerCase()) {
       try {
@@ -396,7 +467,7 @@ function extractL2TxHashFromL1Logs(logs) {
 async function waitForL2ExecutionFromL1Tx(l1, l2, l1TxHash) {
   const l1Receipt = await l1.waitForTransaction(l1TxHash);
   if (!l1Receipt) throw new Error("No L1 receipt found");
-  const l2TxHash = extractL2TxHashFromL1Logs(l1Receipt.logs);
+  const l2TxHash = getL2TransactionHashFromLogs(l1Receipt.logs);
   if (!l2TxHash) {
     throw createError("VERIFICATION", {
       message: "Failed to extract L2 transaction hash from L1 logs",
@@ -3193,6 +3264,63 @@ var IERC20ABI = [
 ];
 var IERC20_default = IERC20ABI;
 
+// src/core/internal/abis/IERC7786Attributes.ts
+var IERC7786AttributesABI = [
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_executionAddress",
+        type: "bytes"
+      }
+    ],
+    name: "executionAddress",
+    outputs: [],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_indirectCallMessageValue",
+        type: "uint256"
+      }
+    ],
+    name: "indirectCall",
+    outputs: [],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_interopCallValue",
+        type: "uint256"
+      }
+    ],
+    name: "interopCallValue",
+    outputs: [],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_unbundlerAddress",
+        type: "bytes"
+      }
+    ],
+    name: "unbundlerAddress",
+    outputs: [],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
+var IERC7786Attributes_default = IERC7786AttributesABI;
+
 // src/core/internal/abis/Mailbox.ts
 var MailboxABI = [
   {
@@ -3569,209 +3697,1216 @@ var MailboxABI = [
 ];
 var Mailbox_default = MailboxABI;
 
-// src/adapters/ethers/resources/deposits/context.ts
-async function commonCtx(p, client, tokens, contracts) {
-  const { bridgehub, l1AssetRouter } = await contracts.addresses();
-  const { chainId } = await client.l2.getNetwork();
-  const sender = await client.signer.getAddress();
-  const gasPerPubdata = p.gasPerPubdata ?? 800n;
-  const operatorTip = p.operatorTip ?? 0n;
-  const refundRecipient = p.refundRecipient ?? sender;
-  const resolvedToken = await tokens.resolve(p.token, { chain: "l1" });
-  const baseTokenAssetId = resolvedToken.baseTokenAssetId;
-  const baseTokenL1 = await tokens.l1TokenFromAssetId(baseTokenAssetId);
-  const baseIsEth = resolvedToken.isChainEthBased;
-  const route = (() => {
-    if (resolvedToken.kind === "eth") {
-      return baseIsEth ? "eth-base" : "eth-nonbase";
-    }
-    if (resolvedToken.kind === "base") {
-      return baseIsEth ? "eth-base" : "erc20-base";
-    }
-    return "erc20-nonbase";
-  })();
-  return {
-    client,
-    tokens,
-    contracts,
-    resolvedToken,
-    baseTokenAssetId,
-    baseTokenL1,
-    baseIsEth,
-    l1AssetRouter,
-    route,
-    bridgehub,
-    chainIdL2: BigInt(chainId),
-    sender,
-    gasOverrides: p.l1TxOverrides,
-    l2GasLimit: p.l2GasLimit,
-    gasPerPubdata,
-    operatorTip,
-    refundRecipient
-  };
-}
-function encodeNativeTokenVaultTransferData(amount, receiver, token) {
-  return new ethers.AbiCoder().encode(["uint256", "address", "address"], [amount, receiver, token]);
-}
-function encodeSecondBridgeArgs(token, amount, l2Receiver) {
-  return ethers.AbiCoder.defaultAbiCoder().encode(
-    ["address", "uint256", "address"],
-    [token, amount, l2Receiver]
-  );
-}
-function encodeSecondBridgeErc20Args(token, amount, l2Receiver) {
-  return encodeSecondBridgeArgs(token, amount, l2Receiver);
-}
-function encodeSecondBridgeEthArgs(amount, l2Receiver, ethToken = ETH_ADDRESS) {
-  return encodeSecondBridgeArgs(ethToken, amount, l2Receiver);
-}
-function buildDirectRequestStruct(args) {
-  return {
-    chainId: args.chainId,
-    l2Contract: args.l2Contract,
-    mintValue: args.mintValue,
-    l2Value: args.l2Value,
-    l2Calldata: "0x",
-    l2GasLimit: args.l2GasLimit,
-    l2GasPerPubdataByteLimit: args.gasPerPubdata,
-    factoryDeps: [],
-    refundRecipient: args.refundRecipient
-  };
-}
-
-// src/core/resources/deposits/gas.ts
-function makeGasQuote(p) {
-  const maxPriorityFeePerGas = p.maxPriorityFeePerGas ?? 0n;
-  return {
-    gasLimit: p.gasLimit,
-    maxFeePerGas: p.maxFeePerGas,
-    maxPriorityFeePerGas,
-    gasPerPubdata: p.gasPerPubdata,
-    maxCost: p.gasLimit * p.maxFeePerGas
-  };
-}
-async function fetchFees(estimator) {
-  try {
-    const fees = await estimator.estimateFeesPerGas();
-    if (fees.maxFeePerGas != null) {
-      return {
-        maxFeePerGas: fees.maxFeePerGas,
-        maxPriorityFeePerGas: fees.maxPriorityFeePerGas ?? 0n
-      };
-    }
-    if (fees.gasPrice != null) {
-      return {
-        maxFeePerGas: fees.gasPrice,
-        maxPriorityFeePerGas: 0n
-      };
-    }
-  } catch {
-  }
-  try {
-    const gp = await estimator.getGasPrice();
-    return { maxFeePerGas: gp, maxPriorityFeePerGas: 0n };
-  } catch {
-    return { maxFeePerGas: 0n, maxPriorityFeePerGas: 0n };
-  }
-}
-async function quoteL1Gas(input) {
-  const { estimator, tx, overrides, fallbackGasLimit } = input;
-  let market;
-  const getMarket = async () => {
-    if (market) return market;
-    market = await fetchFees(estimator);
-    return market;
-  };
-  const maxFeePerGas = overrides?.maxFeePerGas ?? (tx.maxFeePerGas != null ? BigInt(tx.maxFeePerGas) : (await getMarket()).maxFeePerGas);
-  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? (tx.maxPriorityFeePerGas != null ? BigInt(tx.maxPriorityFeePerGas) : (await getMarket()).maxPriorityFeePerGas);
-  const explicitGasLimit = overrides?.gasLimit ?? (tx.gasLimit != null ? BigInt(tx.gasLimit) : void 0);
-  if (explicitGasLimit != null) {
-    return makeGasQuote({ gasLimit: explicitGasLimit, maxFeePerGas, maxPriorityFeePerGas });
-  }
-  try {
-    const est = await estimator.estimateGas(tx);
-    const buffered = BigInt(est) * (100n + BUFFER) / 100n;
-    return makeGasQuote({ gasLimit: buffered, maxFeePerGas, maxPriorityFeePerGas });
-  } catch (err) {
-    if (fallbackGasLimit != null) {
-      return makeGasQuote({ gasLimit: fallbackGasLimit, maxFeePerGas, maxPriorityFeePerGas });
-    }
-    console.warn("L1 gas estimation failed", err);
-    return void 0;
-  }
-}
-async function quoteL2Gas(input) {
-  const { estimator, route, tx, gasPerPubdata, l2GasLimit, overrideGasLimit, stateOverrides } = input;
-  const market = await fetchFees(estimator);
-  const maxFeePerGas = market.maxFeePerGas || market.maxPriorityFeePerGas || 0n;
-  const txGasLimit = tx?.gasLimit != null ? BigInt(tx.gasLimit) : void 0;
-  const explicit = overrideGasLimit ?? txGasLimit;
-  if (explicit != null) {
-    return makeGasQuote({
-      gasLimit: explicit,
-      maxFeePerGas,
-      gasPerPubdata
-    });
-  }
-  if (!tx) {
-    return makeGasQuote({
-      gasLimit: l2GasLimit ?? 0n,
-      maxFeePerGas,
-      gasPerPubdata
-    });
-  }
-  try {
-    const execEstimate = await estimator.estimateGas(tx, stateOverrides);
-    const memoryBytes = route === "erc20-nonbase" ? 500n : DEFAULT_ABI_BYTES;
-    const pubdataBytes = route === "erc20-nonbase" ? 200n : DEFAULT_PUBDATA_BYTES;
-    const pp = gasPerPubdata ?? 800n;
-    const memoryOverhead = memoryBytes * TX_MEMORY_OVERHEAD_GAS;
-    const pubdataOverhead = pubdataBytes * pp;
-    let total = BigInt(execEstimate) + TX_OVERHEAD_GAS + memoryOverhead + pubdataOverhead;
-    total = total * (100n + BUFFER) / 100n;
-    return makeGasQuote({
-      gasLimit: total,
-      maxFeePerGas,
-      gasPerPubdata: pp
-    });
-  } catch (err) {
-    console.warn("L2 gas estimation failed", err);
-    return makeGasQuote({
-      gasLimit: l2GasLimit ?? 0n,
-      maxFeePerGas,
-      gasPerPubdata
-    });
-  }
-}
-async function quoteL2BaseCost(input) {
-  const { estimator, encode: encode2, bridgehub, chainIdL2, l2GasLimit, gasPerPubdata } = input;
-  const market = await fetchFees(estimator);
-  const l1GasPrice = market.maxFeePerGas || market.maxPriorityFeePerGas || 0n;
-  if (l1GasPrice === 0n) {
-    throw new Error("Could not fetch L1 gas price for Bridgehub base cost calculation.");
-  }
-  const data = encode2(IBridgehub_default, "l2TransactionBaseCost", [
-    chainIdL2,
-    l1GasPrice,
-    l2GasLimit,
-    gasPerPubdata
-  ]);
-  const raw = await estimator.call({
-    to: bridgehub,
-    data
-  });
-  return BigInt(raw);
-}
-
-// src/adapters/ethers/estimator.ts
-function toCoreTx(tx) {
-  return {
-    to: tx.to,
-    from: tx.from,
-    data: tx.data,
-    value: tx.value ? BigInt(tx.value) : void 0,
-    gasLimit: tx.gasLimit ? BigInt(tx.gasLimit) : void 0,
-    maxFeePerGas: tx.maxFeePerGas ? BigInt(tx.maxFeePerGas) : void 0,
+// src/core/internal/abis/InteropCenter.ts
+var InteropCenterABI = [
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      }
+    ],
+    name: "AttributeAlreadySet",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      },
+      {
+        internalType: "uint256",
+        name: "restriction",
+        type: "uint256"
+      }
+    ],
+    name: "AttributeViolatesRestriction",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "expected",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "actual",
+        type: "uint256"
+      }
+    ],
+    name: "IndirectCallValueMismatch",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "interoperableAddress",
+        type: "bytes"
+      }
+    ],
+    name: "InteroperableAddressChainReferenceNotEmpty",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "interoperableAddress",
+        type: "bytes"
+      }
+    ],
+    name: "InteroperableAddressNotEmpty",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    name: "InteroperableAddressParsingError",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "expectedMsgValue",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "providedMsgValue",
+        type: "uint256"
+      }
+    ],
+    name: "MsgValueMismatch",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "NotInGatewayMode",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "sourceChainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "destinationChainId",
+        type: "uint256"
+      }
+    ],
+    name: "NotL2ToL2",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "SlotOccupied",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "caller",
+        type: "address"
+      }
+    ],
+    name: "Unauthorized",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      }
+    ],
+    name: "UnsupportedAttribute",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint8",
+        name: "version",
+        type: "uint8"
+      }
+    ],
+    name: "Initialized",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "l2l1MsgHash",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "interopBundleHash",
+        type: "bytes32"
+      },
+      {
+        components: [
+          {
+            internalType: "bytes1",
+            name: "version",
+            type: "bytes1"
+          },
+          {
+            internalType: "uint256",
+            name: "sourceChainId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "destinationChainId",
+            type: "uint256"
+          },
+          {
+            internalType: "bytes32",
+            name: "interopBundleSalt",
+            type: "bytes32"
+          },
+          {
+            components: [
+              {
+                internalType: "bytes1",
+                name: "version",
+                type: "bytes1"
+              },
+              {
+                internalType: "bool",
+                name: "shadowAccount",
+                type: "bool"
+              },
+              {
+                internalType: "address",
+                name: "to",
+                type: "address"
+              },
+              {
+                internalType: "address",
+                name: "from",
+                type: "address"
+              },
+              {
+                internalType: "uint256",
+                name: "value",
+                type: "uint256"
+              },
+              {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct InteropCall[]",
+            name: "calls",
+            type: "tuple[]"
+          },
+          {
+            components: [
+              {
+                internalType: "bytes",
+                name: "executionAddress",
+                type: "bytes"
+              },
+              {
+                internalType: "bytes",
+                name: "unbundlerAddress",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct BundleAttributes",
+            name: "bundleAttributes",
+            type: "tuple"
+          }
+        ],
+        indexed: false,
+        internalType: "struct InteropBundle",
+        name: "interopBundle",
+        type: "tuple"
+      }
+    ],
+    name: "InteropBundleSent",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "sendId",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "sender",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "recipient",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "payload",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "bytes[]",
+        name: "attributes",
+        type: "bytes[]"
+      }
+    ],
+    name: "MessageSent",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "oldAssetRouter",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newAssetRouter",
+        type: "address"
+      }
+    ],
+    name: "NewAssetRouter",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "oldAssetTracker",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newAssetTracker",
+        type: "address"
+      }
+    ],
+    name: "NewAssetTracker",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferStarted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "Paused",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "Unpaused",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "L1_CHAIN_ID",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "acceptOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "_canonicalTxHash",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint64",
+        name: "_expirationTimestamp",
+        type: "uint64"
+      },
+      {
+        components: [
+          {
+            internalType: "bytes1",
+            name: "version",
+            type: "bytes1"
+          },
+          {
+            internalType: "address",
+            name: "originToken",
+            type: "address"
+          },
+          {
+            internalType: "bytes32",
+            name: "baseTokenAssetId",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint256",
+            name: "baseTokenAmount",
+            type: "uint256"
+          },
+          {
+            internalType: "bytes32",
+            name: "assetId",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "tokenOriginChainId",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct BalanceChange",
+        name: "_balanceChange",
+        type: "tuple"
+      }
+    ],
+    name: "forwardTransactionOnGatewayWithBalanceChange",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_l1ChainId",
+        type: "uint256"
+      },
+      {
+        internalType: "address",
+        name: "_owner",
+        type: "address"
+      }
+    ],
+    name: "initL2",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      }
+    ],
+    name: "interopBundleNonce",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "numberOfBundlesSent",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes[]",
+        name: "_attributes",
+        type: "bytes[]"
+      },
+      {
+        internalType: "enum IInteropCenter.AttributeParsingRestrictions",
+        name: "_restriction",
+        type: "uint8"
+      }
+    ],
+    name: "parseAttributes",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "interopCallValue",
+            type: "uint256"
+          },
+          {
+            internalType: "bool",
+            name: "indirectCall",
+            type: "bool"
+          },
+          {
+            internalType: "uint256",
+            name: "indirectCallMessageValue",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct CallAttributes",
+        name: "callAttributes",
+        type: "tuple"
+      },
+      {
+        components: [
+          {
+            internalType: "bytes",
+            name: "executionAddress",
+            type: "bytes"
+          },
+          {
+            internalType: "bytes",
+            name: "unbundlerAddress",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct BundleAttributes",
+        name: "bundleAttributes",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pause",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "paused",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pendingOwner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_destinationChainId",
+        type: "bytes"
+      },
+      {
+        components: [
+          {
+            internalType: "bytes",
+            name: "to",
+            type: "bytes"
+          },
+          {
+            internalType: "bytes",
+            name: "data",
+            type: "bytes"
+          },
+          {
+            internalType: "bytes[]",
+            name: "callAttributes",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct InteropCallStarter[]",
+        name: "_callStarters",
+        type: "tuple[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "_bundleAttributes",
+        type: "bytes[]"
+      }
+    ],
+    name: "sendBundle",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "recipient",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "payload",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes[]",
+        name: "attributes",
+        type: "bytes[]"
+      }
+    ],
+    name: "sendMessage",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "sendId",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "_attributeSelector",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsAttribute",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "unpause",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var InteropCenter_default = InteropCenterABI;
+
+// src/core/internal/abis/IInteropHandler.ts
+var IInteropHandlerABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      }
+    ],
+    name: "BundleExecuted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      }
+    ],
+    name: "BundleUnbundled",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      }
+    ],
+    name: "BundleVerified",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "callIndex",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "enum CallStatus",
+        name: "status",
+        type: "uint8"
+      }
+    ],
+    name: "CallProcessed",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_bundle",
+        type: "bytes"
+      },
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "chainId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l1BatchNumber",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l2MessageIndex",
+            type: "uint256"
+          },
+          {
+            components: [
+              {
+                internalType: "uint16",
+                name: "txNumberInBatch",
+                type: "uint16"
+              },
+              {
+                internalType: "address",
+                name: "sender",
+                type: "address"
+              },
+              {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct L2Message",
+            name: "message",
+            type: "tuple"
+          },
+          {
+            internalType: "bytes32[]",
+            name: "proof",
+            type: "bytes32[]"
+          }
+        ],
+        internalType: "struct MessageInclusionProof",
+        name: "_proof",
+        type: "tuple"
+      }
+    ],
+    name: "executeBundle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_sourceChainId",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "_bundle",
+        type: "bytes"
+      },
+      {
+        internalType: "enum CallStatus[]",
+        name: "_callStatus",
+        type: "uint8[]"
+      }
+    ],
+    name: "unbundleBundle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_bundle",
+        type: "bytes"
+      },
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "chainId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l1BatchNumber",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l2MessageIndex",
+            type: "uint256"
+          },
+          {
+            components: [
+              {
+                internalType: "uint16",
+                name: "txNumberInBatch",
+                type: "uint16"
+              },
+              {
+                internalType: "address",
+                name: "sender",
+                type: "address"
+              },
+              {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct L2Message",
+            name: "message",
+            type: "tuple"
+          },
+          {
+            internalType: "bytes32[]",
+            name: "proof",
+            type: "bytes32[]"
+          }
+        ],
+        internalType: "struct MessageInclusionProof",
+        name: "_proof",
+        type: "tuple"
+      }
+    ],
+    name: "verifyBundle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var IInteropHandler_default = IInteropHandlerABI;
+
+// src/core/internal/abis/InteropRootStorage.ts
+var InteropRootStorageABI = [
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "batchNumber",
+        type: "uint256"
+      }
+    ],
+    name: "interopRoots",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var InteropRootStorage_default = InteropRootStorageABI;
+
+// src/core/types/fees.ts
+function toGasOverrides(overrides) {
+  const { nonce: _, ...gas } = overrides;
+  return gas;
+}
+
+// src/adapters/ethers/resources/deposits/context.ts
+async function commonCtx(p, client, tokens, contracts) {
+  const { bridgehub, l1AssetRouter } = await contracts.addresses();
+  const { chainId } = await client.l2.getNetwork();
+  const sender = await client.signer.getAddress();
+  const gasPerPubdata = p.gasPerPubdata ?? 800n;
+  const operatorTip = p.operatorTip ?? 0n;
+  const refundRecipient = p.refundRecipient ?? sender;
+  const resolvedToken = await tokens.resolve(p.token, { chain: "l1" });
+  const baseTokenAssetId = resolvedToken.baseTokenAssetId;
+  const baseTokenL1 = await tokens.l1TokenFromAssetId(baseTokenAssetId);
+  const baseIsEth = resolvedToken.isChainEthBased;
+  const route = (() => {
+    if (resolvedToken.kind === "eth") {
+      return baseIsEth ? "eth-base" : "eth-nonbase";
+    }
+    if (resolvedToken.kind === "base") {
+      return baseIsEth ? "eth-base" : "erc20-base";
+    }
+    return "erc20-nonbase";
+  })();
+  return {
+    client,
+    tokens,
+    contracts,
+    resolvedToken,
+    baseTokenAssetId,
+    baseTokenL1,
+    baseIsEth,
+    l1AssetRouter,
+    route,
+    bridgehub,
+    chainIdL2: BigInt(chainId),
+    sender,
+    gasOverrides: p.l1TxOverrides ? toGasOverrides(p.l1TxOverrides) : void 0,
+    l2GasLimit: p.l2GasLimit,
+    gasPerPubdata,
+    operatorTip,
+    refundRecipient
+  };
+}
+function encodeNativeTokenVaultTransferData(amount, receiver, token) {
+  return new ethers.AbiCoder().encode(["uint256", "address", "address"], [amount, receiver, token]);
+}
+function encodeSecondBridgeDataV1(assetId, transferData) {
+  const abi2 = new ethers.AbiCoder();
+  const data = abi2.encode(["bytes32", "bytes"], [assetId, transferData]);
+  return ethers.ethers.concat(["0x01", data]);
+}
+function encodeSecondBridgeArgs(token, amount, l2Receiver) {
+  return ethers.AbiCoder.defaultAbiCoder().encode(
+    ["address", "uint256", "address"],
+    [token, amount, l2Receiver]
+  );
+}
+function encodeSecondBridgeErc20Args(token, amount, l2Receiver) {
+  return encodeSecondBridgeArgs(token, amount, l2Receiver);
+}
+function encodeSecondBridgeEthArgs(amount, l2Receiver, ethToken = ETH_ADDRESS) {
+  return encodeSecondBridgeArgs(ethToken, amount, l2Receiver);
+}
+function buildDirectRequestStruct(args) {
+  return {
+    chainId: args.chainId,
+    l2Contract: args.l2Contract,
+    mintValue: args.mintValue,
+    l2Value: args.l2Value,
+    l2Calldata: "0x",
+    l2GasLimit: args.l2GasLimit,
+    l2GasPerPubdataByteLimit: args.gasPerPubdata,
+    factoryDeps: [],
+    refundRecipient: args.refundRecipient
+  };
+}
+
+// src/core/resources/deposits/gas.ts
+function makeGasQuote(p) {
+  const maxPriorityFeePerGas = p.maxPriorityFeePerGas ?? 0n;
+  return {
+    gasLimit: p.gasLimit,
+    maxFeePerGas: p.maxFeePerGas,
+    maxPriorityFeePerGas,
+    gasPerPubdata: p.gasPerPubdata,
+    maxCost: p.gasLimit * p.maxFeePerGas
+  };
+}
+async function fetchFees(estimator) {
+  try {
+    const fees = await estimator.estimateFeesPerGas();
+    if (fees.maxFeePerGas != null) {
+      return {
+        maxFeePerGas: fees.maxFeePerGas,
+        maxPriorityFeePerGas: fees.maxPriorityFeePerGas ?? 0n
+      };
+    }
+    if (fees.gasPrice != null) {
+      return {
+        maxFeePerGas: fees.gasPrice,
+        maxPriorityFeePerGas: 0n
+      };
+    }
+  } catch {
+  }
+  try {
+    const gp = await estimator.getGasPrice();
+    return { maxFeePerGas: gp, maxPriorityFeePerGas: 0n };
+  } catch {
+    return { maxFeePerGas: 0n, maxPriorityFeePerGas: 0n };
+  }
+}
+async function quoteL1Gas(input) {
+  const { estimator, tx, overrides, fallbackGasLimit } = input;
+  let market;
+  const getMarket = async () => {
+    if (market) return market;
+    market = await fetchFees(estimator);
+    return market;
+  };
+  const maxFeePerGas = overrides?.maxFeePerGas ?? (tx.maxFeePerGas != null ? BigInt(tx.maxFeePerGas) : (await getMarket()).maxFeePerGas);
+  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? (tx.maxPriorityFeePerGas != null ? BigInt(tx.maxPriorityFeePerGas) : (await getMarket()).maxPriorityFeePerGas);
+  const explicitGasLimit = overrides?.gasLimit ?? (tx.gasLimit != null ? BigInt(tx.gasLimit) : void 0);
+  if (explicitGasLimit != null) {
+    return makeGasQuote({ gasLimit: explicitGasLimit, maxFeePerGas, maxPriorityFeePerGas });
+  }
+  try {
+    const est = await estimator.estimateGas(tx);
+    const buffered = BigInt(est) * (100n + BUFFER) / 100n;
+    return makeGasQuote({ gasLimit: buffered, maxFeePerGas, maxPriorityFeePerGas });
+  } catch (err) {
+    if (fallbackGasLimit != null) {
+      return makeGasQuote({ gasLimit: fallbackGasLimit, maxFeePerGas, maxPriorityFeePerGas });
+    }
+    console.warn("L1 gas estimation failed", err);
+    return void 0;
+  }
+}
+async function quoteL2Gas(input) {
+  const { estimator, route, tx, gasPerPubdata, l2GasLimit, overrideGasLimit, stateOverrides } = input;
+  const market = await fetchFees(estimator);
+  const maxFeePerGas = market.maxFeePerGas || market.maxPriorityFeePerGas || 0n;
+  const txGasLimit = tx?.gasLimit != null ? BigInt(tx.gasLimit) : void 0;
+  const explicit = overrideGasLimit ?? txGasLimit;
+  if (explicit != null) {
+    return makeGasQuote({
+      gasLimit: explicit,
+      maxFeePerGas,
+      gasPerPubdata
+    });
+  }
+  if (!tx) {
+    return makeGasQuote({
+      gasLimit: l2GasLimit ?? 0n,
+      maxFeePerGas,
+      gasPerPubdata
+    });
+  }
+  try {
+    const execEstimate = await estimator.estimateGas(tx, stateOverrides);
+    const memoryBytes = route === "erc20-nonbase" ? 500n : DEFAULT_ABI_BYTES;
+    const pubdataBytes = route === "erc20-nonbase" ? 200n : DEFAULT_PUBDATA_BYTES;
+    const pp = gasPerPubdata ?? 800n;
+    const memoryOverhead = memoryBytes * TX_MEMORY_OVERHEAD_GAS;
+    const pubdataOverhead = pubdataBytes * pp;
+    let total = BigInt(execEstimate) + TX_OVERHEAD_GAS + memoryOverhead + pubdataOverhead;
+    total = total * (100n + BUFFER) / 100n;
+    return makeGasQuote({
+      gasLimit: total,
+      maxFeePerGas,
+      gasPerPubdata: pp
+    });
+  } catch (err) {
+    console.warn("L2 gas estimation failed", err);
+    return makeGasQuote({
+      gasLimit: l2GasLimit ?? 0n,
+      maxFeePerGas,
+      gasPerPubdata
+    });
+  }
+}
+async function quoteL2BaseCost(input) {
+  const { estimator, encode: encode2, bridgehub, chainIdL2, l2GasLimit, gasPerPubdata } = input;
+  const market = await fetchFees(estimator);
+  const l1GasPrice = market.maxFeePerGas || market.maxPriorityFeePerGas || 0n;
+  if (l1GasPrice === 0n) {
+    throw new Error("Could not fetch L1 gas price for Bridgehub base cost calculation.");
+  }
+  const data = encode2(IBridgehub_default, "l2TransactionBaseCost", [
+    chainIdL2,
+    l1GasPrice,
+    l2GasLimit,
+    gasPerPubdata
+  ]);
+  const raw = await estimator.call({
+    to: bridgehub,
+    data
+  });
+  return BigInt(raw);
+}
+
+// src/adapters/ethers/estimator.ts
+function toCoreTx(tx) {
+  return {
+    to: tx.to,
+    from: tx.from,
+    data: tx.data,
+    value: tx.value ? BigInt(tx.value) : void 0,
+    gasLimit: tx.gasLimit ? BigInt(tx.gasLimit) : void 0,
+    maxFeePerGas: tx.maxFeePerGas ? BigInt(tx.maxFeePerGas) : void 0,
     maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? BigInt(tx.maxPriorityFeePerGas) : void 0
   };
 }
@@ -3853,15 +4988,15 @@ function createErrorOps(decodeRevert2) {
         throw toZKsyncError2(kind, { resource, operation, context: opts?.ctx ?? {}, message }, e);
       }
     }
-    function wrap2(operation, fn, opts) {
+    function wrap6(operation, fn, opts) {
       return run("INTERNAL", operation, fn, opts);
     }
     function wrapAs9(kind, operation, fn, opts) {
       return run(kind, operation, fn, opts);
     }
-    async function toResult2(operation, fn, opts) {
+    async function toResult3(operation, fn, opts) {
       try {
-        const value = await wrap2(operation, fn, opts);
+        const value = await wrap6(operation, fn, opts);
         return { ok: true, value };
       } catch (e) {
         const shaped = isZKsyncError(e) ? e : toZKsyncError2(
@@ -3877,7 +5012,7 @@ function createErrorOps(decodeRevert2) {
         return { ok: false, error: shaped };
       }
     }
-    return { wrap: wrap2, wrapAs: wrapAs9, toResult: toResult2 };
+    return { wrap: wrap6, wrapAs: wrapAs9, toResult: toResult3 };
   }
   return { toZKsyncError: toZKsyncError2, createErrorHandlers: createErrorHandlers2 };
 }
@@ -4208,6 +5343,11 @@ 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");
 function routeErc20NonBase() {
   return {
@@ -4910,6 +6050,18 @@ function createContractsResource(client) {
     const { l2BaseTokenSystem: l2BaseTokenSystem2 } = await instances();
     return l2BaseTokenSystem2;
   }
+  async function interopCenter() {
+    const { interopCenter: interopCenter2 } = await instances();
+    return interopCenter2;
+  }
+  async function interopHandler() {
+    const { interopHandler: interopHandler2 } = await instances();
+    return interopHandler2;
+  }
+  async function l2MessageVerification() {
+    const { l2MessageVerification: l2MessageVerification2 } = await instances();
+    return l2MessageVerification2;
+  }
   return {
     addresses,
     instances,
@@ -4919,7 +6071,10 @@ function createContractsResource(client) {
     l1Nullifier,
     l2AssetRouter,
     l2NativeTokenVault,
-    l2BaseTokenSystem
+    l2BaseTokenSystem,
+    interopCenter,
+    interopHandler,
+    l2MessageVerification
   };
 }
 
@@ -4984,7 +6139,13 @@ function createDepositsResource(client, tokens, contracts) {
       const stepHashes = {};
       const managed = new ethers.NonceManager(client.signer);
       const from = await managed.getAddress();
-      let next = await client.l1.getTransactionCount(from, "latest");
+      let next;
+      if (typeof p.l1TxOverrides?.nonce === "number") {
+        next = p.l1TxOverrides.nonce;
+      } else {
+        const blockTag = p.l1TxOverrides?.nonce ?? "latest";
+        next = await client.l1.getTransactionCount(from, blockTag);
+      }
       for (const step of plan.steps) {
         if (step.kind === "approve") {
           try {
@@ -5092,14 +6253,14 @@ function createDepositsResource(client, tokens, contracts) {
       if (!l1Rcpt) return { phase: "L1_PENDING", l1TxHash };
       let l2TxHash;
       try {
-        l2TxHash = extractL2TxHashFromL1Logs(l1Rcpt.logs) ?? void 0;
+        l2TxHash = getL2TransactionHashFromLogs(l1Rcpt.logs) ?? void 0;
       } catch (e) {
         throw toZKsyncError(
           "INTERNAL",
           {
             resource: "deposits",
-            operation: "deposits.status.extractL2TxHashFromL1Logs",
-            context: { where: "extractL2TxHashFromL1Logs", l1TxHash },
+            operation: "deposits.status.getL2TransactionHashFromLogs",
+            context: { where: "getL2TransactionHashFromLogs", l1TxHash },
             message: "Failed to derive L2 transaction hash from L1 logs."
           },
           e
@@ -5249,7 +6410,7 @@ async function commonCtx2(p, client, tokens, contracts) {
     l2NativeTokenVault,
     l2BaseTokenSystem,
     baseIsEth,
-    gasOverrides: p.l2TxOverrides
+    gasOverrides: p.l2TxOverrides ? toGasOverrides(p.l2TxOverrides) : void 0
   };
 }
 
@@ -5341,806 +6502,2083 @@ function buildFeeBreakdown2(p) {
   };
 }
 
-// src/adapters/ethers/resources/withdrawals/routes/eth.ts
-var { wrapAs: wrapAs6 } = createErrorHandlers("withdrawals");
-function routeEthBase() {
+// src/adapters/ethers/resources/withdrawals/routes/eth.ts
+var { wrapAs: wrapAs6 } = createErrorHandlers("withdrawals");
+function routeEthBase() {
+  return {
+    async build(p, ctx) {
+      const steps = [];
+      const base = await ctx.contracts.l2BaseTokenSystem();
+      const data = await wrapAs6(
+        "INTERNAL",
+        OP_WITHDRAWALS.eth.encodeWithdraw,
+        () => Promise.resolve(base.interface.encodeFunctionData("withdraw", [p.to ?? ctx.sender])),
+        {
+          ctx: { where: "L2BaseToken.withdraw", to: p.to ?? ctx.sender },
+          message: "Failed to encode ETH withdraw calldata."
+        }
+      );
+      const tx = {
+        to: L2_BASE_TOKEN_ADDRESS,
+        data,
+        from: ctx.sender,
+        value: p.amount
+      };
+      const gas = await quoteL2Gas4({ ctx, tx });
+      if (gas) {
+        tx.gasLimit = gas.gasLimit;
+        tx.maxFeePerGas = gas.maxFeePerGas;
+        tx.maxPriorityFeePerGas = gas.maxPriorityFeePerGas;
+      }
+      const fees = buildFeeBreakdown2({
+        feeToken: L2_BASE_TOKEN_ADDRESS,
+        l2Gas: gas
+      });
+      steps.push({
+        key: "l2-base-token:withdraw",
+        kind: "l2-base-token:withdraw",
+        description: "Withdraw ETH via L2 Base Token System",
+        tx
+      });
+      return { steps, approvals: [], fees };
+    }
+  };
+}
+var { wrapAs: wrapAs7 } = createErrorHandlers("withdrawals");
+var SIG = {
+  withdraw: "withdraw(bytes32,bytes)"
+};
+function routeErc20NonBase2() {
+  return {
+    async build(p, ctx) {
+      const steps = [];
+      const approvals = [];
+      const erc20 = new ethers.Contract(p.token, IERC20_default, ctx.client.getL2Signer());
+      const current = await wrapAs7(
+        "CONTRACT",
+        OP_WITHDRAWALS.erc20.allowance,
+        () => erc20.allowance(ctx.sender, ctx.l2NativeTokenVault),
+        {
+          ctx: {
+            where: "erc20.allowance",
+            chain: "L2",
+            token: p.token,
+            spender: ctx.l2NativeTokenVault
+          },
+          message: "Failed to read L2 ERC-20 allowance."
+        }
+      );
+      if (current < p.amount) {
+        approvals.push({ token: p.token, spender: ctx.l2NativeTokenVault, amount: p.amount });
+        const data = erc20.interface.encodeFunctionData("approve", [
+          ctx.l2NativeTokenVault,
+          p.amount
+        ]);
+        const approveTx = {
+          to: p.token,
+          data,
+          from: ctx.sender
+        };
+        const approveGas = await quoteL2Gas4({ ctx, tx: approveTx });
+        if (approveGas) {
+          approveTx.gasLimit = approveGas.gasLimit;
+          approveTx.maxFeePerGas = approveGas.maxFeePerGas;
+          approveTx.maxPriorityFeePerGas = approveGas.maxPriorityFeePerGas;
+        }
+        steps.push({
+          key: `approve:l2:${p.token}:${ctx.l2NativeTokenVault}`,
+          kind: "approve:l2",
+          description: `Approve ${p.amount} to NativeTokenVault`,
+          tx: approveTx
+        });
+      }
+      const assetId = await wrapAs7(
+        "CONTRACT",
+        OP_WITHDRAWALS.erc20.ensureRegistered,
+        async () => {
+          const ntv = await ctx.contracts.l2NativeTokenVault();
+          const ensured = await ntv.getFunction("ensureTokenIsRegistered").staticCall(p.token);
+          return ensured;
+        },
+        {
+          ctx: { where: "L2NativeTokenVault.ensureTokenIsRegistered", token: p.token },
+          message: "Failed to ensure token is registered in L2NativeTokenVault."
+        }
+      );
+      const assetData = await wrapAs7(
+        "INTERNAL",
+        OP_WITHDRAWALS.erc20.encodeAssetData,
+        () => Promise.resolve(
+          encodeNativeTokenVaultTransferData(p.amount, p.to ?? ctx.sender, p.token)
+        ),
+        {
+          ctx: { where: "AbiCoder.encode", token: p.token, to: p.to ?? ctx.sender },
+          message: "Failed to encode burn/withdraw asset data."
+        }
+      );
+      const l2ar = await ctx.contracts.l2AssetRouter();
+      const dataWithdraw = await wrapAs7(
+        "INTERNAL",
+        OP_WITHDRAWALS.erc20.encodeWithdraw,
+        () => Promise.resolve(l2ar.interface.encodeFunctionData(SIG.withdraw, [assetId, assetData])),
+        {
+          ctx: { where: "L2AssetRouter.withdraw", assetId },
+          message: "Failed to encode withdraw calldata."
+        }
+      );
+      const withdrawTx = {
+        to: ctx.l2AssetRouter,
+        data: dataWithdraw,
+        from: ctx.sender
+      };
+      const withdrawGas = current >= p.amount ? await quoteL2Gas4({ ctx, tx: withdrawTx }) : void 0;
+      if (withdrawGas) {
+        withdrawTx.gasLimit = withdrawGas.gasLimit;
+        withdrawTx.maxFeePerGas = withdrawGas.maxFeePerGas;
+        withdrawTx.maxPriorityFeePerGas = withdrawGas.maxPriorityFeePerGas;
+      }
+      steps.push({
+        key: "l2-asset-router:withdraw",
+        kind: "l2-asset-router:withdraw",
+        description: "Burn on L2 & send L2\u2192L1 message",
+        tx: withdrawTx
+      });
+      const fees = buildFeeBreakdown2({
+        feeToken: ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2),
+        l2Gas: withdrawGas
+      });
+      return { steps, approvals, fees };
+    }
+  };
+}
+
+// src/core/utils/events.ts
+function extractPreferAddress(opts) {
+  const preferAddr = typeof opts?.prefer === "object" ? opts.prefer.address : opts?.prefer === "assetRouter" ? L2_ASSET_ROUTER_ADDRESS : L1_MESSENGER_ADDRESS;
+  return (preferAddr || L1_MESSENGER_ADDRESS).toLowerCase();
+}
+function findL1MessageSentLog(receipt, opts) {
+  const index = opts?.index ?? 0;
+  const preferAddr = extractPreferAddress(opts);
+  const matches = receipt.logs.filter((lg) => {
+    const t0 = (lg.topics?.[0] ?? "").toLowerCase();
+    return t0 === TOPIC_L1_MESSAGE_SENT_NEW || t0 === TOPIC_L1_MESSAGE_SENT_LEG;
+  });
+  if (!matches.length) {
+    throw new Error("No L1MessageSent event found in L2 receipt logs.");
+  }
+  const preferred = matches.find((lg) => (lg.address ?? "").toLowerCase() === preferAddr);
+  const chosen = preferred ?? matches[index] ?? matches[0];
+  if (!chosen) {
+    throw new Error("No suitable L1MessageSent event found.");
+  }
+  return chosen;
+}
+function isL1MessageSentLog(log, opts) {
+  const topic = log.topics[0].toLowerCase();
+  const preferAddr = extractPreferAddress(opts);
+  return log.address.toLowerCase() === preferAddr && (topic === TOPIC_L1_MESSAGE_SENT_LEG.toLowerCase() || topic === TOPIC_L1_MESSAGE_SENT_NEW.toLowerCase());
+}
+
+// src/core/resources/withdrawals/logs.ts
+function messengerLogIndex(raw, opts) {
+  const index = opts?.index;
+  const messenger = (opts?.messenger).toLowerCase();
+  const arr = Array.isArray(raw?.l2ToL1Logs) ? raw.l2ToL1Logs : [];
+  const hits = arr.map((lg, i) => ({ i, lg })).filter(({ lg }) => (lg?.sender ?? "").toLowerCase() === messenger);
+  if (!hits.length) {
+    throw new Error("No L2->L1 messenger logs found in receipt.");
+  }
+  return (hits[index] ?? hits[0]).i;
+}
+
+// src/adapters/ethers/resources/withdrawals/services/finalization.ts
+var { wrapAs: wrapAs8 } = createErrorHandlers("withdrawals");
+var IL1NullifierMini = [
+  "function isWithdrawalFinalized(uint256,uint256,uint256) view returns (bool)"
+];
+function createFinalizationServices(client) {
+  const { l1, l2, signer } = client;
   return {
-    async build(p, ctx) {
-      const steps = [];
-      const base = await ctx.contracts.l2BaseTokenSystem();
-      const data = await wrapAs6(
+    async fetchFinalizeDepositParams(l2TxHash) {
+      const parsed = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.fetchParams.receipt,
+        () => client.zks.getReceiptWithL2ToL1(l2TxHash),
+        {
+          ctx: { where: "getReceiptWithL2ToL1", l2TxHash },
+          message: "Failed to fetch L2 receipt (with L2\u2192L1 logs)."
+        }
+      );
+      if (!parsed) {
+        throw createError("STATE", {
+          resource: "withdrawals",
+          operation: OP_WITHDRAWALS.finalize.fetchParams.receipt,
+          message: "L2 receipt not found.",
+          context: { l2TxHash }
+        });
+      }
+      const ev = await wrapAs8(
         "INTERNAL",
-        OP_WITHDRAWALS.eth.encodeWithdraw,
-        () => Promise.resolve(base.interface.encodeFunctionData("withdraw", [p.to ?? ctx.sender])),
+        OP_WITHDRAWALS.finalize.fetchParams.findMessage,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+        () => Promise.resolve(findL1MessageSentLog(parsed, { index: 0 })),
         {
-          ctx: { where: "L2BaseToken.withdraw", to: p.to ?? ctx.sender },
-          message: "Failed to encode ETH withdraw calldata."
+          ctx: { l2TxHash, index: 0 },
+          message: "Failed to locate L1MessageSent event in L2 receipt."
         }
       );
-      const tx = {
-        to: L2_BASE_TOKEN_ADDRESS,
-        data,
-        from: ctx.sender,
-        value: p.amount
+      const message = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.fetchParams.decodeMessage,
+        () => Promise.resolve(ethers.AbiCoder.defaultAbiCoder().decode(["bytes"], ev.data)[0]),
+        {
+          ctx: { where: "decode L1MessageSent", data: ev.data },
+          message: "Failed to decode withdrawal message."
+        }
+      );
+      const raw = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.fetchParams.rawReceipt,
+        () => client.zks.getReceiptWithL2ToL1(l2TxHash),
+        {
+          ctx: { where: "getReceiptWithL2ToL1 (raw)", l2TxHash },
+          message: "Failed to fetch raw L2 receipt."
+        }
+      );
+      if (!raw) {
+        throw createError("STATE", {
+          resource: "withdrawals",
+          operation: OP_WITHDRAWALS.finalize.fetchParams.rawReceipt,
+          message: "Raw L2 receipt not found.",
+          context: { l2TxHash }
+        });
+      }
+      const idx = await wrapAs8(
+        "INTERNAL",
+        OP_WITHDRAWALS.finalize.fetchParams.messengerIndex,
+        () => Promise.resolve(messengerLogIndex(raw, { index: 0, messenger: L1_MESSENGER_ADDRESS })),
+        {
+          ctx: { where: "derive messenger log index", l2TxHash, receipt: raw },
+          message: "Failed to derive messenger log index."
+        }
+      );
+      const proof = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.fetchParams.proof,
+        () => client.zks.getL2ToL1LogProof(l2TxHash, idx),
+        {
+          ctx: { where: "get L2\u2192L1 log proof", l2TxHash, messengerLogIndex: idx },
+          message: "Failed to fetch L2\u2192L1 log proof."
+        }
+      );
+      const { chainId } = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.fetchParams.network,
+        () => l2.getNetwork(),
+        {
+          ctx: { where: "l2.getNetwork" },
+          message: "Failed to read L2 network."
+        }
+      );
+      const txIndex = Number(parsed.transactionIndex ?? 0);
+      const params = {
+        chainId: BigInt(chainId),
+        l2BatchNumber: proof.batchNumber,
+        l2MessageIndex: proof.id,
+        l2Sender: L2_ASSET_ROUTER_ADDRESS,
+        l2TxNumberInBatch: txIndex,
+        message,
+        merkleProof: proof.proof
       };
-      const gas = await quoteL2Gas4({ ctx, tx });
-      if (gas) {
-        tx.gasLimit = gas.gasLimit;
-        tx.maxFeePerGas = gas.maxFeePerGas;
-        tx.maxPriorityFeePerGas = gas.maxPriorityFeePerGas;
+      const { l1Nullifier } = await client.ensureAddresses();
+      return { params, nullifier: l1Nullifier };
+    },
+    async simulateFinalizeReadiness(params) {
+      const { l1Nullifier } = await client.ensureAddresses();
+      const done = await (async () => {
+        try {
+          const cMini = new ethers.Contract(l1Nullifier, IL1NullifierMini, l1);
+          const isFinalized = await wrapAs8(
+            "RPC",
+            OP_WITHDRAWALS.finalize.readiness.isFinalized,
+            () => cMini.isWithdrawalFinalized(
+              params.chainId,
+              params.l2BatchNumber,
+              params.l2MessageIndex
+            ),
+            {
+              ctx: { where: "isWithdrawalFinalized", params },
+              message: "Failed to read finalization status."
+            }
+          );
+          return Boolean(isFinalized);
+        } catch {
+          return false;
+        }
+      })();
+      if (done) return { kind: "FINALIZED" };
+      const c = new ethers.Contract(l1Nullifier, IL1Nullifier_default, l1);
+      try {
+        await c.finalizeDeposit.staticCall(params);
+        return { kind: "READY" };
+      } catch (e) {
+        return classifyReadinessFromRevert(e);
+      }
+    },
+    async isWithdrawalFinalized(key) {
+      const { l1Nullifier } = await client.ensureAddresses();
+      const c = new ethers.Contract(l1Nullifier, IL1NullifierMini, l1);
+      return await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.isFinalized,
+        () => c.isWithdrawalFinalized(key.chainIdL2, key.l2BatchNumber, key.l2MessageIndex),
+        {
+          ctx: { where: "isWithdrawalFinalized", key },
+          message: "Failed to read finalization status."
+        }
+      );
+    },
+    async estimateFinalization(params) {
+      const { l1Nullifier } = await client.ensureAddresses();
+      const signer2 = client.getL1Signer();
+      const c = new ethers.Contract(l1Nullifier, IL1Nullifier_default, signer2);
+      const gasLimit = await wrapAs8(
+        "RPC",
+        OP_WITHDRAWALS.finalize.estimate,
+        () => c.finalizeDeposit.estimateGas(params),
+        {
+          ctx: {
+            where: "estimateGas(finalizeDeposit)",
+            chainIdL2: params.chainId,
+            l2BatchNumber: params.l2BatchNumber,
+            l2MessageIndex: params.l2MessageIndex,
+            l1Nullifier
+          },
+          message: "Failed to estimate gas for finalizeDeposit."
+        }
+      );
+      const feeData = await wrapAs8("RPC", OP_WITHDRAWALS.finalize.estimate, () => l1.getFeeData(), {
+        ctx: { where: "l1.getFeeData" },
+        message: "Failed to estimate fee data for finalizeDeposit."
+      });
+      const maxFeePerGas = feeData.maxFeePerGas ?? feeData.gasPrice ?? // legacy-style gas price if present
+      (() => {
+        throw createError("RPC", {
+          resource: "withdrawals",
+          operation: OP_WITHDRAWALS.finalize.estimate,
+          message: "Provider did not return gas price or EIP-1559 fields.",
+          context: { feeData }
+        });
+      })();
+      const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? 0n;
+      return {
+        gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas
+      };
+    },
+    async finalizeDeposit(params) {
+      const { l1Nullifier } = await client.ensureAddresses();
+      const c = new ethers.Contract(l1Nullifier, IL1Nullifier_default, signer);
+      try {
+        const receipt = await c.finalizeDeposit(params);
+        const hash = receipt.hash;
+        return {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          hash,
+          wait: async () => {
+            try {
+              return await receipt.wait();
+            } catch (e) {
+              throw toZKsyncError(
+                "EXECUTION",
+                {
+                  resource: "withdrawals",
+                  operation: OP_WITHDRAWALS.finalize.wait,
+                  message: "Failed while waiting for finalizeDeposit transaction.",
+                  context: { txHash: hash }
+                },
+                e
+              );
+            }
+          }
+        };
+      } catch (e) {
+        throw toZKsyncError(
+          "EXECUTION",
+          {
+            resource: "withdrawals",
+            operation: OP_WITHDRAWALS.finalize.send,
+            message: "Failed to send finalizeDeposit transaction.",
+            context: {
+              chainIdL2: params.chainId,
+              l2BatchNumber: params.l2BatchNumber,
+              l2MessageIndex: params.l2MessageIndex,
+              l1Nullifier
+            }
+          },
+          e
+        );
       }
-      const fees = buildFeeBreakdown2({
-        feeToken: L2_BASE_TOKEN_ADDRESS,
-        l2Gas: gas
-      });
-      steps.push({
-        key: "l2-base-token:withdraw",
-        kind: "l2-base-token:withdraw",
-        description: "Withdraw ETH via L2 Base Token System",
-        tx
-      });
-      return { steps, approvals: [], fees };
     }
   };
 }
-var { wrapAs: wrapAs7 } = createErrorHandlers("withdrawals");
-var SIG = {
-  withdraw: "withdraw(bytes32,bytes)"
+
+// src/adapters/ethers/resources/withdrawals/index.ts
+var ROUTES2 = {
+  base: routeEthBase(),
+  // BaseTokenSystem.withdraw, chain base = ETH
+  "erc20-nonbase": routeErc20NonBase2()
+  // AssetRouter.withdraw for non-base ERC-20s
 };
-function routeErc20NonBase2() {
-  return {
-    async build(p, ctx) {
-      const steps = [];
-      const approvals = [];
-      const erc20 = new ethers.Contract(p.token, IERC20_default, ctx.client.getL2Signer());
-      const current = await wrapAs7(
-        "CONTRACT",
-        OP_WITHDRAWALS.erc20.allowance,
-        () => erc20.allowance(ctx.sender, ctx.l2NativeTokenVault),
-        {
-          ctx: {
-            where: "erc20.allowance",
-            chain: "L2",
-            token: p.token,
-            spender: ctx.l2NativeTokenVault
+function createWithdrawalsResource(client, tokens, contracts) {
+  const svc = createFinalizationServices(client);
+  const { wrap: wrap6, toResult: toResult3 } = createErrorHandlers("withdrawals");
+  const tokensResource = tokens ?? createTokensResource(client);
+  const contractsResource = contracts ?? createContractsResource(client);
+  async function buildPlan(p) {
+    const ctx = await commonCtx2(p, client, tokensResource, contractsResource);
+    await ROUTES2[ctx.route].preflight?.(p, ctx);
+    const { steps, approvals, fees } = await ROUTES2[ctx.route].build(p, ctx);
+    return {
+      route: ctx.route,
+      summary: {
+        route: ctx.route,
+        approvalsNeeded: approvals,
+        amounts: {
+          transfer: { token: p.token, amount: p.amount }
+        },
+        fees
+      },
+      steps
+    };
+  }
+  const finalizeCache = /* @__PURE__ */ new Map();
+  const quote = (p) => wrap6(
+    OP_WITHDRAWALS.quote,
+    async () => {
+      const plan = await buildPlan(p);
+      return plan.summary;
+    },
+    {
+      message: "Internal error while preparing a withdrawal quote.",
+      ctx: { token: p.token, where: "withdrawals.quote" }
+    }
+  );
+  const tryQuote = (p) => toResult3(
+    OP_WITHDRAWALS.tryQuote,
+    async () => {
+      const plan = await buildPlan(p);
+      return plan.summary;
+    },
+    {
+      message: "Internal error while preparing a withdrawal quote.",
+      ctx: { token: p.token, where: "withdrawals.tryQuote" }
+    }
+  );
+  const prepare = (p) => wrap6(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
+    message: "Internal error while preparing a withdrawal plan.",
+    ctx: { token: p.token, where: "withdrawals.prepare" }
+  });
+  const tryPrepare = (p) => toResult3(OP_WITHDRAWALS.tryPrepare, () => buildPlan(p), {
+    message: "Internal error while preparing a withdrawal plan.",
+    ctx: { token: p.token, where: "withdrawals.tryPrepare" }
+  });
+  const create = (p) => wrap6(
+    OP_WITHDRAWALS.create,
+    async () => {
+      const plan = await prepare(p);
+      const stepHashes = {};
+      const managed = new ethers.NonceManager(client.getL2Signer());
+      const from = await managed.getAddress();
+      let next;
+      if (typeof p.l2TxOverrides?.nonce === "number") {
+        next = p.l2TxOverrides.nonce;
+      } else {
+        const blockTag = p.l2TxOverrides?.nonce ?? "pending";
+        next = await client.l2.getTransactionCount(from, blockTag);
+      }
+      for (const step of plan.steps) {
+        step.tx.nonce = next++;
+        if (p.l2TxOverrides) {
+          const overrides = p.l2TxOverrides;
+          if (overrides.gasLimit != null) step.tx.gasLimit = overrides.gasLimit;
+          if (overrides.maxFeePerGas != null) step.tx.maxFeePerGas = overrides.maxFeePerGas;
+          if (overrides.maxPriorityFeePerGas != null) {
+            step.tx.maxPriorityFeePerGas = overrides.maxPriorityFeePerGas;
+          }
+        }
+        if (!step.tx.gasLimit) {
+          try {
+            const est = await client.l2.estimateGas(step.tx);
+            step.tx.gasLimit = BigInt(est) * 115n / 100n;
+          } catch {
+          }
+        }
+        let hash;
+        try {
+          const sent = await managed.sendTransaction(step.tx);
+          hash = sent.hash;
+          stepHashes[step.key] = hash;
+          const rcpt = await sent.wait();
+          if (rcpt?.status === 0) {
+            throw createError("EXECUTION", {
+              resource: "withdrawals",
+              operation: "withdrawals.create.sendTransaction",
+              message: "Withdrawal transaction reverted on L2 during a step.",
+              context: { step: step.key, txHash: hash, nonce: Number(step.tx.nonce ?? -1) }
+            });
+          }
+        } catch (e) {
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "withdrawals",
+              operation: "withdrawals.create.sendTransaction",
+              message: "Failed to send or confirm a withdrawal transaction step.",
+              context: { step: step.key, txHash: hash, nonce: Number(step.tx.nonce ?? -1) }
+            },
+            e
+          );
+        }
+      }
+      const keys = Object.keys(stepHashes);
+      const l2TxHash = stepHashes[keys[keys.length - 1]];
+      return { kind: "withdrawal", l2TxHash, stepHashes, plan };
+    },
+    {
+      message: "Internal error while creating withdrawal transactions.",
+      ctx: { token: p.token, amount: p.amount, to: p.to, where: "withdrawals.create" }
+    }
+  );
+  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) => wrap6(
+    OP_WITHDRAWALS.status,
+    async () => {
+      const l2TxHash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
+      if (!l2TxHash || l2TxHash === "0x") {
+        return { phase: "UNKNOWN", l2TxHash: "0x" };
+      }
+      let l2Rcpt;
+      try {
+        l2Rcpt = await client.l2.getTransactionReceipt(l2TxHash);
+      } catch (e) {
+        if (isReceiptNotFound(e)) {
+          return { phase: "L2_PENDING", l2TxHash };
+        }
+        throw toZKsyncError(
+          "RPC",
+          {
+            resource: "withdrawals",
+            operation: "withdrawals.status.getTransactionReceipt",
+            message: "Failed to fetch L2 transaction receipt.",
+            context: { l2TxHash, where: "l2.getTransactionReceipt" }
           },
-          message: "Failed to read L2 ERC-20 allowance."
+          e
+        );
+      }
+      if (!l2Rcpt) return { phase: "L2_PENDING", l2TxHash };
+      let pack;
+      try {
+        pack = await svc.fetchFinalizeDepositParams(l2TxHash);
+      } catch {
+        return { phase: "PENDING", l2TxHash };
+      }
+      const key = {
+        chainIdL2: pack.params.chainId,
+        l2BatchNumber: pack.params.l2BatchNumber,
+        l2MessageIndex: pack.params.l2MessageIndex
+      };
+      try {
+        const done = await svc.isWithdrawalFinalized(key);
+        if (done) return { phase: "FINALIZED", l2TxHash, key };
+      } catch {
+      }
+      const readiness = await svc.simulateFinalizeReadiness(pack.params);
+      if (readiness.kind === "FINALIZED") return { phase: "FINALIZED", l2TxHash, key };
+      if (readiness.kind === "READY") return { phase: "READY_TO_FINALIZE", l2TxHash, key };
+      return { phase: "PENDING", l2TxHash, key };
+    },
+    {
+      message: "Internal error while checking withdrawal status.",
+      ctx: { where: "withdrawals.status", l2TxHash: typeof h === "string" ? h : h.l2TxHash }
+    }
+  );
+  const wait = (h, opts = {
+    for: "l2",
+    pollMs: 5500
+  }) => wrap6(
+    OP_WITHDRAWALS.wait,
+    async () => {
+      const l2Hash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
+      if (!l2Hash || l2Hash === "0x") return null;
+      if (opts.for === "l2") {
+        let rcpt;
+        try {
+          rcpt = await client.l2.waitForTransaction(l2Hash);
+        } catch (e) {
+          throw toZKsyncError(
+            "RPC",
+            {
+              resource: "withdrawals",
+              operation: "withdrawals.wait.l2.waitForTransaction",
+              message: "Failed while waiting for L2 transaction.",
+              context: { l2TxHash: l2Hash }
+            },
+            e
+          );
         }
-      );
-      if (current < p.amount) {
-        approvals.push({ token: p.token, spender: ctx.l2NativeTokenVault, amount: p.amount });
-        const data = erc20.interface.encodeFunctionData("approve", [
-          ctx.l2NativeTokenVault,
-          p.amount
-        ]);
-        const approveTx = {
-          to: p.token,
-          data,
-          from: ctx.sender
-        };
-        const approveGas = await quoteL2Gas4({ ctx, tx: approveTx });
-        if (approveGas) {
-          approveTx.gasLimit = approveGas.gasLimit;
-          approveTx.maxFeePerGas = approveGas.maxFeePerGas;
-          approveTx.maxPriorityFeePerGas = approveGas.maxPriorityFeePerGas;
+        if (!rcpt) return null;
+        try {
+          const raw = await client.zks.getReceiptWithL2ToL1(l2Hash);
+          rcpt.l2ToL1Logs = raw?.l2ToL1Logs ?? [];
+        } catch {
+          rcpt.l2ToL1Logs = rcpt.l2ToL1Logs ?? [];
+        }
+        return rcpt;
+      }
+      const poll = Math.max(1e3, opts.pollMs ?? 2500);
+      const deadline = opts.timeoutMs ? Date.now() + opts.timeoutMs : void 0;
+      while (true) {
+        const s = await status(l2Hash);
+        if (opts.for === "ready") {
+          if (s.phase === "READY_TO_FINALIZE" || s.phase === "FINALIZED") return null;
+        } else {
+          if (s.phase === "FINALIZED") {
+            const l1Hash = finalizeCache.get(l2Hash);
+            if (l1Hash) {
+              try {
+                const l1Rcpt = await client.l1.getTransactionReceipt(l1Hash);
+                if (l1Rcpt) {
+                  finalizeCache.delete(l2Hash);
+                  return l1Rcpt;
+                }
+              } catch {
+              }
+            }
+            return null;
+          }
         }
-        steps.push({
-          key: `approve:l2:${p.token}:${ctx.l2NativeTokenVault}`,
-          kind: "approve:l2",
-          description: `Approve ${p.amount} to NativeTokenVault`,
-          tx: approveTx
-        });
+        if (deadline && Date.now() > deadline) return null;
+        await new Promise((r) => setTimeout(r, poll));
       }
-      const assetId = await wrapAs7(
-        "CONTRACT",
-        OP_WITHDRAWALS.erc20.ensureRegistered,
-        async () => {
-          const ntv = await ctx.contracts.l2NativeTokenVault();
-          const ensured = await ntv.getFunction("ensureTokenIsRegistered").staticCall(p.token);
-          return ensured;
-        },
-        {
-          ctx: { where: "L2NativeTokenVault.ensureTokenIsRegistered", token: p.token },
-          message: "Failed to ensure token is registered in L2NativeTokenVault."
+    },
+    {
+      message: "Internal error while waiting for withdrawal.",
+      ctx: {
+        where: "withdrawals.wait",
+        l2TxHash: typeof h === "string" ? h : h.l2TxHash,
+        for: opts.for
+      }
+    }
+  );
+  const finalize = (l2TxHash) => wrap6(
+    OP_WITHDRAWALS.finalize.send,
+    async () => {
+      const pack = await (async () => {
+        try {
+          return await svc.fetchFinalizeDepositParams(l2TxHash);
+        } catch (e) {
+          throw createError("STATE", {
+            resource: "withdrawals",
+            operation: OP_WITHDRAWALS.finalize.fetchParams.receipt,
+            message: "Withdrawal not ready: finalize params unavailable.",
+            context: { l2TxHash },
+            cause: e
+          });
         }
-      );
-      const assetData = await wrapAs7(
-        "INTERNAL",
-        OP_WITHDRAWALS.erc20.encodeAssetData,
-        () => Promise.resolve(
-          encodeNativeTokenVaultTransferData(p.amount, p.to ?? ctx.sender, p.token)
-        ),
-        {
-          ctx: { where: "AbiCoder.encode", token: p.token, to: p.to ?? ctx.sender },
-          message: "Failed to encode burn/withdraw asset data."
+      })();
+      const { params } = pack;
+      const key = {
+        chainIdL2: params.chainId,
+        l2BatchNumber: params.l2BatchNumber,
+        l2MessageIndex: params.l2MessageIndex
+      };
+      try {
+        const done = await svc.isWithdrawalFinalized(key);
+        if (done) {
+          const statusNow = await status(l2TxHash);
+          return { status: statusNow };
         }
-      );
-      const l2ar = await ctx.contracts.l2AssetRouter();
-      const dataWithdraw = await wrapAs7(
-        "INTERNAL",
-        OP_WITHDRAWALS.erc20.encodeWithdraw,
-        () => Promise.resolve(l2ar.interface.encodeFunctionData(SIG.withdraw, [assetId, assetData])),
-        {
-          ctx: { where: "L2AssetRouter.withdraw", assetId },
-          message: "Failed to encode withdraw calldata."
+      } catch {
+      }
+      const readiness = await svc.simulateFinalizeReadiness(params);
+      if (readiness.kind === "FINALIZED") {
+        const statusNow = await status(l2TxHash);
+        return { status: statusNow };
+      }
+      if (readiness.kind === "NOT_READY") {
+        throw createError("STATE", {
+          resource: "withdrawals",
+          operation: OP_WITHDRAWALS.finalize.readiness.simulate,
+          message: "Withdrawal not ready to finalize.",
+          context: readiness
+        });
+      }
+      try {
+        const tx = await svc.finalizeDeposit(params);
+        finalizeCache.set(l2TxHash, tx.hash);
+        const rcpt = await tx.wait();
+        const statusNow = await status(l2TxHash);
+        return { status: statusNow, receipt: rcpt };
+      } catch (e) {
+        const statusNow = await status(l2TxHash);
+        if (statusNow.phase === "FINALIZED") return { status: statusNow };
+        try {
+          const again = await svc.simulateFinalizeReadiness(params);
+          if (again.kind === "NOT_READY") {
+            throw createError("STATE", {
+              resource: "withdrawals",
+              operation: OP_WITHDRAWALS.finalize.readiness.simulate,
+              message: "Withdrawal not ready to finalize.",
+              context: again
+            });
+          }
+        } catch {
         }
-      );
-      const withdrawTx = {
-        to: ctx.l2AssetRouter,
-        data: dataWithdraw,
-        from: ctx.sender
-      };
-      const withdrawGas = current >= p.amount ? await quoteL2Gas4({ ctx, tx: withdrawTx }) : void 0;
-      if (withdrawGas) {
-        withdrawTx.gasLimit = withdrawGas.gasLimit;
-        withdrawTx.maxFeePerGas = withdrawGas.maxFeePerGas;
-        withdrawTx.maxPriorityFeePerGas = withdrawGas.maxPriorityFeePerGas;
+        throw e;
       }
-      steps.push({
-        key: "l2-asset-router:withdraw",
-        kind: "l2-asset-router:withdraw",
-        description: "Burn on L2 & send L2\u2192L1 message",
-        tx: withdrawTx
-      });
-      const fees = buildFeeBreakdown2({
-        feeToken: ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2),
-        l2Gas: withdrawGas
+    },
+    {
+      message: "Internal error while attempting to finalize withdrawal.",
+      ctx: { l2TxHash, where: "withdrawals.finalize" }
+    }
+  );
+  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) => toResult3(
+    OP_WITHDRAWALS.tryWait,
+    async () => {
+      const v = await wait(h, opts);
+      if (v) return v;
+      throw createError("STATE", {
+        resource: "withdrawals",
+        operation: "withdrawals.tryWait",
+        message: opts.for === "l2" ? "No L2 receipt yet; the withdrawal has not executed on L2." : "No L1 receipt yet; the withdrawal has not been included on L1.",
+        context: {
+          for: opts.for,
+          l2TxHash: typeof h === "string" ? h : "l2TxHash" in h ? h.l2TxHash : void 0,
+          where: "withdrawals.tryWait"
+        }
       });
-      return { steps, approvals, fees };
+    },
+    {
+      message: "Internal error while waiting for withdrawal.",
+      ctx: { input: h, for: opts?.for, where: "withdrawals.tryWait" }
     }
+  );
+  return {
+    quote,
+    tryQuote,
+    prepare,
+    tryPrepare,
+    create,
+    tryCreate,
+    status,
+    wait,
+    finalize,
+    tryFinalize,
+    tryWait
   };
 }
 
-// src/core/utils/events.ts
-function extractPreferAddress(opts) {
-  const preferAddr = typeof opts?.prefer === "object" ? opts.prefer.address : opts?.prefer === "assetRouter" ? L2_ASSET_ROUTER_ADDRESS : L1_MESSENGER_ADDRESS;
-  return (preferAddr || L1_MESSENGER_ADDRESS).toLowerCase();
-}
-function findL1MessageSentLog(receipt, opts) {
-  const index = opts?.index;
-  const preferAddr = extractPreferAddress(opts);
-  const matches = receipt.logs.filter((lg) => {
-    const t0 = (lg.topics?.[0] ?? "").toLowerCase();
-    return t0 === TOPIC_L1_MESSAGE_SENT_NEW || t0 === TOPIC_L1_MESSAGE_SENT_LEG;
-  });
-  if (!matches.length) {
-    throw new Error("No L1MessageSent event found in L2 receipt logs.");
-  }
-  const preferred = matches.find((lg) => (lg.address ?? "").toLowerCase() === preferAddr);
-  const chosen = preferred ?? matches[index] ?? matches[0];
-  if (!chosen) {
-    throw new Error("No suitable L1MessageSent event found.");
-  }
-  return chosen;
+// 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/withdrawals/logs.ts
-function messengerLogIndex(raw, opts) {
-  const index = opts?.index;
-  const messenger = (opts?.messenger).toLowerCase();
-  const arr = Array.isArray(raw?.l2ToL1Logs) ? raw.l2ToL1Logs : [];
-  const hits = arr.map((lg, i) => ({ i, lg })).filter(({ lg }) => (lg?.sender ?? "").toLowerCase() === messenger);
-  if (!hits.length) {
-    throw new Error("No L2->L1 messenger logs found in receipt.");
-  }
-  return (hits[index] ?? hits[0]).i;
+// 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/adapters/ethers/resources/withdrawals/services/finalization.ts
-var { wrapAs: wrapAs8 } = createErrorHandlers("withdrawals");
-var IL1NullifierMini = [
-  "function isWithdrawalFinalized(uint256,uint256,uint256) view returns (bool)"
-];
-function createFinalizationServices(client) {
-  const { l1, l2, signer } = client;
+// src/core/resources/interop/attributes/resource.ts
+function createAttributesResource(codec) {
   return {
-    async fetchFinalizeDepositParams(l2TxHash) {
-      const parsed = await wrapAs8(
-        "RPC",
-        OP_WITHDRAWALS.finalize.fetchParams.receipt,
-        () => client.zks.getReceiptWithL2ToL1(l2TxHash),
-        {
-          ctx: { where: "getReceiptWithL2ToL1", l2TxHash },
-          message: "Failed to fetch L2 receipt (with L2\u2192L1 logs)."
+    call: createCallAttributes(codec),
+    bundle: createBundleAttributes(codec)
+  };
+}
+
+// src/adapters/ethers/resources/interop/attributes/resource.ts
+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));
+  }
+  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)];
         }
-      );
-      if (!parsed) {
-        throw createError("STATE", {
-          resource: "withdrawals",
-          operation: OP_WITHDRAWALS.finalize.fetchParams.receipt,
-          message: "L2 receipt not found.",
-          context: { l2TxHash }
-        });
+        return [ctx.attributes.call.indirectCall(action.amount)];
       }
-      const ev = await wrapAs8(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.fetchParams.findMessage,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
-        () => Promise.resolve(findL1MessageSentLog(parsed, { index: 0 })),
-        {
-          ctx: { l2TxHash, index: 0 },
-          message: "Failed to locate L1MessageSent event in L2 receipt."
+      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 createEthersAttributesResource(opts = {}) {
+  const iface = opts.iface ?? new ethers.Interface(IERC7786Attributes_default);
+  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.");
         }
-      );
-      const message = await wrapAs8(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.fetchParams.decodeMessage,
-        () => Promise.resolve(ethers.AbiCoder.defaultAbiCoder().decode(["bytes"], ev.data)[0]),
-        {
-          ctx: { where: "decode L1MessageSent", data: ev.data },
-          message: "Failed to decode withdrawal message."
+        break;
+      case "call":
+        if (action.value != null && action.value < 0n) {
+          throw new Error("call.value must be >= 0 when provided.");
         }
-      );
-      const raw = await wrapAs8(
-        "RPC",
-        OP_WITHDRAWALS.finalize.fetchParams.rawReceipt,
-        () => client.zks.getReceiptWithL2ToL1(l2TxHash),
-        {
-          ctx: { where: "getReceiptWithL2ToL1 (raw)", l2TxHash },
-          message: "Failed to fetch raw L2 receipt."
+        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.");
         }
-      );
-      if (!raw) {
-        throw createError("STATE", {
-          resource: "withdrawals",
-          operation: OP_WITHDRAWALS.finalize.fetchParams.rawReceipt,
-          message: "Raw L2 receipt not found.",
-          context: { l2TxHash }
-        });
-      }
-      const idx = await wrapAs8(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.fetchParams.messengerIndex,
-        () => Promise.resolve(messengerLogIndex(raw, { index: 0, messenger: L1_MESSENGER_ADDRESS })),
-        {
-          ctx: { where: "derive messenger log index", l2TxHash, receipt: raw },
-          message: "Failed to derive messenger log index."
+        break;
+      case "sendErc20":
+        if (action.amount < 0n) {
+          throw new Error("sendErc20.amount must be >= 0.");
         }
-      );
-      const proof = await wrapAs8(
-        "RPC",
-        OP_WITHDRAWALS.finalize.fetchParams.proof,
-        () => client.zks.getL2ToL1LogProof(l2TxHash, idx),
-        {
-          ctx: { where: "get L2\u2192L1 log proof", l2TxHash, messengerLogIndex: idx },
-          message: "Failed to fetch L2\u2192L1 log proof."
+        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.");
+          }
         }
-      );
-      const { chainId } = await wrapAs8(
-        "RPC",
-        OP_WITHDRAWALS.finalize.fetchParams.network,
-        () => l2.getNetwork(),
-        {
-          ctx: { where: "l2.getNetwork" },
-          message: "Failed to read L2 network."
+        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 = ethers.getBytes("0x00010000");
+var PREFIX_EVM_ADDRESS = ethers.getBytes("0x000100000014");
+function formatInteropEvmChain(chainId) {
+  const chainRef = ethers.toBeArray(chainId);
+  const chainRefLength = ethers.getBytes(ethers.toBeHex(chainRef.length, 1));
+  const payload = ethers.concat([PREFIX_EVM_CHAIN, chainRefLength, chainRef, new Uint8Array([0])]);
+  return ethers.hexlify(payload);
+}
+function formatInteropEvmAddress(address) {
+  const normalized = ethers.getAddress(address);
+  const addrBytes = ethers.getBytes(normalized);
+  const payload = ethers.concat([PREFIX_EVM_ADDRESS, addrBytes]);
+  return ethers.hexlify(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 [];
+  const ntv = new ethers.Contract(ctx.l2NativeTokenVault, L2NativeTokenVault_default, ctx.client.l2);
+  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: ntv.interface.encodeFunctionData("ensureTokenIsRegistered", [token]),
+      ...ctx.gasOverrides
+    }
+  }));
+}
+async function resolveErc20AssetIds(erc20Tokens, ctx) {
+  const assetIds = /* @__PURE__ */ new Map();
+  if (erc20Tokens.length === 0) return assetIds;
+  const ntv = new ethers.Contract(ctx.l2NativeTokenVault, L2NativeTokenVault_default, ctx.client.getL2Signer());
+  for (const token of erc20Tokens) {
+    const assetId = await ntv.getFunction("ensureTokenIsRegistered").staticCall(token);
+    assetIds.set(token.toLowerCase(), assetId);
+  }
+  return assetIds;
+}
+
+// src/adapters/ethers/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 txIndex = Number(parsed.transactionIndex ?? 0);
-      const params = {
-        chainId: BigInt(chainId),
-        l2BatchNumber: proof.batchNumber,
-        l2MessageIndex: proof.id,
-        l2Sender: L2_ASSET_ROUTER_ADDRESS,
-        l2TxNumberInBatch: txIndex,
-        message,
-        merkleProof: proof.proof
-      };
-      const { l1Nullifier } = await wrapAs8(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
-        () => client.ensureAddresses(),
-        {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
+        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({});
         }
-      );
-      return { params, nullifier: l1Nullifier };
+        break;
+      case "call":
+        starterData.push({});
+        break;
+      default:
+        assertNever(action);
+    }
+  }
+  return starterData;
+}
+
+// src/adapters/ethers/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});
     },
-    async simulateFinalizeReadiness(params) {
-      const { l1Nullifier } = await wrapAs8(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.readiness.ensureAddresses,
-        () => client.ensureAddresses(),
+    async build(params, ctx) {
+      const steps = [];
+      const erc20Tokens = getErc20Tokens(params);
+      const erc20AssetIds = await resolveErc20AssetIds(erc20Tokens, ctx);
+      const attributes = getInteropAttributes(params, ctx);
+      const starterData = await getStarterData(params, ctx, erc20AssetIds);
+      const bundle = buildIndirectBundle(
+        params,
         {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
-        }
+          dstChainId: ctx.dstChainId,
+          baseTokens: ctx.baseTokens,
+          l2AssetRouter: ctx.l2AssetRouter,
+          l2NativeTokenVault: ctx.l2NativeTokenVault,
+          codec: interopCodec
+        },
+        attributes,
+        starterData
       );
-      const done = await (async () => {
-        try {
-          const cMini = new ethers.Contract(l1Nullifier, IL1NullifierMini, l1);
-          const isFinalized = await wrapAs8(
-            "RPC",
-            OP_WITHDRAWALS.finalize.readiness.isFinalized,
-            () => cMini.isWithdrawalFinalized(
-              params.chainId,
-              params.l2BatchNumber,
-              params.l2MessageIndex
-            ),
-            {
-              ctx: { where: "isWithdrawalFinalized", params },
-              message: "Failed to read finalization status."
+      steps.push(...buildEnsureTokenSteps(erc20Tokens, ctx));
+      for (const approval of bundle.approvals) {
+        const erc20 = new ethers.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
             }
-          );
-          return Boolean(isFinalized);
-        } catch {
-          return false;
+          });
         }
-      })();
-      if (done) return { kind: "FINALIZED" };
-      const c = new ethers.Contract(l1Nullifier, IL1Nullifier_default, l1);
-      try {
-        await c.finalizeDeposit.staticCall(params);
-        return { kind: "READY" };
-      } catch (e) {
-        return classifyReadinessFromRevert(e);
       }
+      const data = ctx.ifaces.interopCenter.encodeFunctionData("sendBundle", [
+        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,
+          ...ctx.gasOverrides
+        }
+      });
+      return {
+        steps,
+        approvals: bundle.approvals,
+        quoteExtras: bundle.quoteExtras
+      };
+    }
+  };
+}
+
+// src/adapters/ethers/resources/interop/routes/direct.ts
+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});
     },
-    async isWithdrawalFinalized(key) {
-      const { l1Nullifier } = await wrapAs8(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
-        () => client.ensureAddresses(),
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async build(params, ctx) {
+      const steps = [];
+      const attrs = getInteropAttributes(params, ctx);
+      const built = buildDirectBundle(
+        params,
         {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
-        }
+          dstChainId: ctx.dstChainId,
+          baseTokens: ctx.baseTokens,
+          l2AssetRouter: ctx.l2AssetRouter,
+          l2NativeTokenVault: ctx.l2NativeTokenVault,
+          codec: interopCodec
+        },
+        attrs
       );
-      const c = new ethers.Contract(l1Nullifier, IL1NullifierMini, l1);
-      return await wrapAs8(
-        "RPC",
-        OP_WITHDRAWALS.finalize.isFinalized,
-        () => c.isWithdrawalFinalized(key.chainIdL2, key.l2BatchNumber, key.l2MessageIndex),
-        {
-          ctx: { where: "isWithdrawalFinalized", key },
-          message: "Failed to read finalization status."
+      const data = ctx.ifaces.interopCenter.encodeFunctionData("sendBundle", [
+        built.dstChain,
+        built.starters,
+        built.bundleAttributes
+      ]);
+      steps.push({
+        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).
+        tx: {
+          to: ctx.interopCenter,
+          data,
+          value: built.quoteExtras.totalActionValue,
+          ...ctx.gasOverrides
         }
-      );
-    },
-    async estimateFinalization(params) {
-      const { l1Nullifier } = await wrapAs8(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.estimate,
-        () => client.ensureAddresses(),
-        {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
+      });
+      return {
+        steps,
+        approvals: built.approvals,
+        quoteExtras: built.quoteExtras
+      };
+    }
+  };
+}
+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
         }
-      );
-      const signer2 = client.getL1Signer();
-      const c = new ethers.Contract(l1Nullifier, IL1Nullifier_default, signer2);
-      const gasLimit = await wrapAs8(
-        "RPC",
-        OP_WITHDRAWALS.finalize.estimate,
-        () => c.finalizeDeposit.estimateGas(params),
-        {
-          ctx: {
-            where: "estimateGas(finalizeDeposit)",
-            chainIdL2: params.chainId,
-            l2BatchNumber: params.l2BatchNumber,
-            l2MessageIndex: params.l2MessageIndex,
-            l1Nullifier
-          },
-          message: "Failed to estimate gas for finalizeDeposit."
+      });
+    }
+  };
+  assertProtocolVersion(srcChainId, srcProtocolVersion);
+  assertProtocolVersion(dstChainId, dstProtocolVersion);
+}
+async function commonCtx3(dstProvider, params, client, tokens, contracts, attributes) {
+  const sender = await client.signer.getAddress();
+  const chainId = (await client.l2.getNetwork()).chainId;
+  const dstChainId = (await dstProvider.getNetwork()).chainId;
+  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 interopCenterIface = new ethers.Interface(InteropCenter_default);
+  const interopHandlerIface = new ethers.Interface(IInteropHandler_default);
+  const baseMatches = srcBaseToken.toLowerCase() === dstBaseToken.toLowerCase();
+  return {
+    client,
+    tokens,
+    contracts,
+    sender,
+    chainIdL2: chainId,
+    chainId,
+    bridgehub,
+    dstChainId,
+    dstProvider,
+    interopCenter,
+    interopHandler,
+    l2MessageVerification,
+    l2AssetRouter,
+    l2NativeTokenVault,
+    baseTokens: { src: srcBaseToken, dst: dstBaseToken, matches: baseMatches },
+    ifaces: { interopCenter: interopCenterIface, interopHandler: interopHandlerIface },
+    attributes,
+    gasOverrides: params.txOverrides ? toGasOverrides(params.txOverrides) : void 0
+  };
+}
+function getTopics() {
+  const centerIface = new ethers.Interface(InteropCenter_default);
+  const handlerIface = new ethers.Interface(IInteropHandler_default);
+  const topics = {
+    interopBundleSent: centerIface.getEvent("InteropBundleSent").topicHash,
+    bundleVerified: handlerIface.getEvent("BundleVerified").topicHash,
+    bundleExecuted: handlerIface.getEvent("BundleExecuted").topicHash,
+    bundleUnbundled: handlerIface.getEvent("BundleUnbundled").topicHash
+  };
+  return { topics, centerIface };
+}
+var { wrap: wrap2 } = createErrorHandlers("interop");
+var DEFAULT_BLOCKS_RANGE_SIZE = 1e4;
+var DEFAULT_MAX_BLOCKS_BACK = 2e4;
+var SAFE_BLOCKS_RANGE_SIZE = 1e3;
+function parseMaxBlockRangeLimit(error) {
+  if (!ethers.isError(error, "UNKNOWN_ERROR")) return null;
+  if (!error.error || typeof error.error !== "object") return null;
+  const match = /query exceeds max block range\s+(\d+)/i.exec(error.error?.message);
+  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 wrap2(
+    OP_INTEROP.svc.status.sourceReceipt,
+    () => provider.getTransactionReceipt(txHash),
+    {
+      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 wrap2(
+    OP_INTEROP.svc.status.dstLogs,
+    async () => {
+      const currentBlock = await provider.getBlockNumber();
+      const minBlock = Math.max(0, currentBlock - maxBlocksBack);
+      let toBlock = currentBlock;
+      let chunkSize = initialChunkSize;
+      while (toBlock >= minBlock) {
+        const fromBlock = Math.max(minBlock, toBlock - chunkSize + 1);
+        try {
+          const rawLogs = await provider.getLogs({
+            address,
+            topics,
+            fromBlock,
+            toBlock
+          });
+          if (rawLogs.length > 0) {
+            return rawLogs.map((log) => ({
+              address: log.address,
+              topics: log.topics,
+              data: log.data,
+              transactionHash: log.transactionHash
+            }));
+          }
+          toBlock = fromBlock - 1;
+        } 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 wrap2(
+    OP_INTEROP.svc.status.getRoot,
+    async () => {
+      const rootStorage = new ethers.Contract(
+        L2_INTEROP_ROOT_STORAGE_ADDRESS,
+        InteropRootStorage_default,
+        provider
       );
-      const feeData = await wrapAs8("RPC", OP_WITHDRAWALS.finalize.estimate, () => l1.getFeeData(), {
-        ctx: { where: "l1.getFeeData" },
-        message: "Failed to estimate fee data for finalizeDeposit."
-      });
-      const maxFeePerGas = feeData.maxFeePerGas ?? feeData.gasPrice ?? // legacy-style gas price if present
-      (() => {
-        throw createError("RPC", {
-          resource: "withdrawals",
-          operation: OP_WITHDRAWALS.finalize.estimate,
-          message: "Provider did not return gas price or EIP-1559 fields.",
-          context: { feeData }
-        });
-      })();
-      const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? 0n;
-      return {
-        gasLimit,
-        maxFeePerGas,
-        maxPriorityFeePerGas
-      };
+      return await rootStorage.interopRoots(rootChainId, batchNumber);
     },
-    async finalizeDeposit(params) {
-      const { l1Nullifier } = await wrapAs8(
-        "INTERNAL",
-        OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
-        () => client.ensureAddresses(),
-        {
-          ctx: { where: "ensureAddresses" },
-          message: "Failed to ensure L1 Nullifier address."
+    {
+      ctx: { rootChainId, batchNumber },
+      message: "Failed to get interop root from the destination chain."
+    }
+  );
+}
+
+// src/adapters/ethers/resources/interop/services/finalization/bundle.ts
+var { wrap: wrap3 } = 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 signer = await wrap3(OP_INTEROP.exec.sendStep, () => client.signerFor(dstProvider), {
+    message: "Failed to resolve destination signer."
+  });
+  const { interopHandler } = await client.ensureAddresses();
+  const handler = new ethers.Contract(interopHandler, IInteropHandler_default, signer);
+  try {
+    const txResponse = await handler.executeBundle(encodedData, proof);
+    const hash = txResponse.hash;
+    return {
+      hash,
+      wait: async () => {
+        try {
+          const receipt = await txResponse.wait();
+          if (!receipt || receipt.status !== 1) {
+            throw createError("EXECUTION", {
+              resource: "interop",
+              operation: OP_INTEROP.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
+          );
         }
-      );
-      const c = new ethers.Contract(l1Nullifier, IL1Nullifier_default, signer);
+      }
+    };
+  } catch (e) {
+    throw toZKsyncError(
+      "EXECUTION",
+      {
+        resource: "interop",
+        operation: OP_INTEROP.exec.sendStep,
+        message: "Failed to send executeBundle transaction on destination chain."
+      },
+      e
+    );
+  }
+}
+
+// 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 {
-        const receipt = await c.finalizeDeposit(params);
-        const hash = receipt.hash;
-        return {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          hash,
-          wait: async () => {
-            try {
-              return await receipt.wait();
-            } catch (e) {
-              throw toZKsyncError(
-                "EXECUTION",
-                {
-                  resource: "withdrawals",
-                  operation: OP_WITHDRAWALS.finalize.wait,
-                  message: "Failed while waiting for finalizeDeposit transaction.",
-                  context: { txHash: hash }
-                },
-                e
-              );
-            }
-          }
-        };
+        l1MessageData = decodeL1MessageData2(log);
       } catch (e) {
-        throw toZKsyncError(
-          "EXECUTION",
-          {
-            resource: "withdrawals",
-            operation: OP_WITHDRAWALS.finalize.send,
-            message: "Failed to send finalizeDeposit transaction.",
-            context: {
-              chainIdL2: params.chainId,
-              l2BatchNumber: params.l2BatchNumber,
-              l2MessageIndex: params.l2MessageIndex,
-              l1Nullifier
-            }
-          },
-          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",
+    log.data,
+    log.topics
+  );
+  return {
+    bundleHash: decoded.interopBundleHash,
+    sourceChainId: decoded.interopBundle.sourceChainId,
+    destinationChainId: decoded.interopBundle.destinationChainId
   };
 }
+function decodeL1MessageData(log) {
+  const decoded = ethers.AbiCoder.defaultAbiCoder().decode(["bytes"], log.data);
+  return decoded[0];
+}
 
-// src/adapters/ethers/resources/withdrawals/index.ts
-var ROUTES2 = {
-  base: routeEthBase(),
-  // BaseTokenSystem.withdraw, chain base = ETH
-  "erc20-nonbase": routeErc20NonBase2()
-  // AssetRouter.withdraw for non-base ERC-20s
-};
-function createWithdrawalsResource(client, tokens, contracts) {
-  const svc = createFinalizationServices(client);
-  const { wrap: wrap2, toResult: toResult2 } = createErrorHandlers("withdrawals");
-  const tokensResource = tokens ?? createTokensResource(client);
-  const contractsResource = contracts ?? createContractsResource(client);
-  async function buildPlan(p) {
-    const ctx = await commonCtx2(p, client, tokensResource, contractsResource);
-    await ROUTES2[ctx.route].preflight?.(p, ctx);
-    const { steps, approvals, fees } = await ROUTES2[ctx.route].build(p, ctx);
+// src/adapters/ethers/resources/interop/services/finalization/polling.ts
+var { wrap: wrap4 } = 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("finalized");
+    if (finalizedBlock && BigInt(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);
+    } catch (error) {
+      if (!isProofNotReadyError(error)) throw error;
+    }
+    await sleep(pollMs);
+  }
+}
+async function waitForRoot(provider, expectedRoot, 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 }
+      });
+    }
+    let interopRoot = null;
+    try {
+      const root = await getInteropRoot(
+        provider,
+        expectedRoot.rootChainId,
+        expectedRoot.batchNumber
+      );
+      if (root !== ZERO_HASH) {
+        interopRoot = root;
+      }
+    } catch (error) {
+      if (!shouldRetryRootFetch(error)) throw error;
+      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
+        }
+      });
+    }
+    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 wrap4(
+      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, input, opts) {
+  const { topics, centerIface } = 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(centerIface, 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
+  );
+  await waitForRoot(dstProvider, finalizationInfo.expectedRoot, pollMs, deadline);
+  return finalizationInfo;
+}
+
+// src/adapters/ethers/resources/interop/services/finalization/status.ts
+async function getStatus(client, dstProvider, input, opts) {
+  const { topics, centerIface } = 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(centerIface, log)
+    });
+    return { ...baseIds, bundleHash };
+  })();
+  if (!enrichedIds.bundleHash) {
+    const phase = enrichedIds.l2SrcTxHash ? "SENT" : "UNKNOWN";
     return {
-      route: ctx.route,
-      summary: {
-        route: ctx.route,
-        approvalsNeeded: approvals,
-        amounts: {
-          transfer: { token: p.token, amount: p.amount }
-        },
-        fees
-      },
-      steps
+      phase,
+      l2SrcTxHash: enrichedIds.l2SrcTxHash,
+      bundleHash: enrichedIds.bundleHash,
+      dstExecTxHash: enrichedIds.dstExecTxHash
     };
   }
-  const finalizeCache = /* @__PURE__ */ new Map();
-  const quote = (p) => wrap2(
-    OP_WITHDRAWALS.quote,
-    async () => {
-      const plan = await buildPlan(p);
-      return plan.summary;
+  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/ethers/resources/interop/services/finalization/index.ts
+function createInteropFinalizationServices(client) {
+  return {
+    status(dstProvider, input, opts) {
+      return getStatus(client, dstProvider, input, opts);
     },
-    {
-      message: "Internal error while preparing a withdrawal quote.",
-      ctx: { token: p.token, where: "withdrawals.quote" }
-    }
-  );
-  const tryQuote = (p) => toResult2(
-    OP_WITHDRAWALS.tryQuote,
-    async () => {
-      const plan = await buildPlan(p);
-      return plan.summary;
+    wait(dstProvider, input, opts) {
+      return waitForFinalization(client, dstProvider, input, opts);
     },
-    {
-      message: "Internal error while preparing a withdrawal quote.",
-      ctx: { token: p.token, where: "withdrawals.tryQuote" }
+    async finalize(dstProvider, info, opts) {
+      const execResult = await executeBundle(client, dstProvider, info, opts);
+      await execResult.wait();
+      return {
+        bundleHash: info.bundleHash,
+        dstExecTxHash: execResult.hash
+      };
     }
-  );
-  const prepare = (p) => wrap2(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
-    message: "Internal error while preparing a withdrawal plan.",
-    ctx: { token: p.token, where: "withdrawals.prepare" }
+  };
+}
+function resolveDstProvider(dstChain) {
+  return typeof dstChain === "string" ? new ethers.JsonRpcProvider(dstChain) : dstChain;
+}
+function resolveWaitableInput(waitableInput) {
+  const input = waitableInput;
+  return {
+    dstProvider: resolveDstProvider(waitableInput.dstChain),
+    waitable: input.waitable ? input.waitable : waitableInput
+  };
+}
+
+// src/adapters/ethers/resources/interop/index.ts
+var { wrap: wrap5, toResult: toResult2 } = createErrorHandlers("interop");
+var ROUTES3 = {
+  direct: routeDirect(),
+  indirect: routeIndirect()
+};
+function createInteropResource(client, tokens, contracts, attributes) {
+  const svc = createInteropFinalizationServices(client);
+  const tokensResource = createTokensResource(client);
+  const contractsResource = createContractsResource(client);
+  const attributesResource = createEthersAttributesResource();
+  async function buildPlanWithCtx(dstProvider, params) {
+    const ctx = await commonCtx3(
+      dstProvider,
+      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 wrap5(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(
+      OP_INTEROP.routes[route].build,
+      () => ROUTES3[route].build(params, ctx),
+      {
+        message: "Failed to build interop route plan.",
+        ctx: { where: `routes.${route}.build` }
+      }
+    );
+    const summary = {
+      route,
+      approvalsNeeded: approvals,
+      totalActionValue: quoteExtras.totalActionValue,
+      bridgedTokenTotal: quoteExtras.bridgedTokenTotal
+    };
+    return { plan: { route, summary, steps }, ctx };
+  }
+  async function buildPlan(dstProvider, params) {
+    const { plan } = await buildPlanWithCtx(dstProvider, params);
+    return plan;
+  }
+  const quote = (params) => wrap5(OP_INTEROP.quote, async () => {
+    const plan = await buildPlan(resolveDstProvider(params.dstChain), params);
+    return plan.summary;
   });
-  const tryPrepare = (p) => toResult2(OP_WITHDRAWALS.tryPrepare, () => buildPlan(p), {
-    message: "Internal error while preparing a withdrawal plan.",
-    ctx: { token: p.token, where: "withdrawals.tryPrepare" }
+  const tryQuote = (params) => toResult2(OP_INTEROP.tryQuote, () => quote(params));
+  const prepare = (params) => wrap5(OP_INTEROP.prepare, () => buildPlan(resolveDstProvider(params.dstChain), params), {
+    message: "Internal error while preparing an interop plan.",
+    ctx: { where: "interop.prepare" }
   });
-  const create = (p) => wrap2(
-    OP_WITHDRAWALS.create,
+  const tryPrepare = (params) => toResult2(OP_INTEROP.tryPrepare, () => prepare(params));
+  const create = (params) => wrap5(
+    OP_INTEROP.create,
     async () => {
-      const plan = await prepare(p);
+      const { plan, ctx } = await buildPlanWithCtx(resolveDstProvider(params.dstChain), params);
+      const signer = ctx.client.signerFor(ctx.client.l2);
+      const srcProvider = ctx.client.l2;
+      const from = await signer.getAddress();
+      let next;
+      if (typeof params.txOverrides?.nonce === "number") {
+        next = params.txOverrides.nonce;
+      } else {
+        const blockTag = params.txOverrides?.nonce ?? "pending";
+        next = await srcProvider.getTransactionCount(from, blockTag);
+      }
       const stepHashes = {};
-      const managed = new ethers.NonceManager(client.getL2Signer());
-      const from = await managed.getAddress();
-      let next = await client.l2.getTransactionCount(from, "pending");
       for (const step of plan.steps) {
         step.tx.nonce = next++;
-        if (p.l2TxOverrides) {
-          const overrides = p.l2TxOverrides;
-          if (overrides.gasLimit != null) step.tx.gasLimit = overrides.gasLimit;
-          if (overrides.maxFeePerGas != null) step.tx.maxFeePerGas = overrides.maxFeePerGas;
-          if (overrides.maxPriorityFeePerGas != null) {
-            step.tx.maxPriorityFeePerGas = overrides.maxPriorityFeePerGas;
-          }
+        if (!step.tx.chainId) {
+          step.tx.chainId = Number(ctx.chainId);
         }
         if (!step.tx.gasLimit) {
           try {
-            const est = await client.l2.estimateGas(step.tx);
+            const est = await srcProvider.estimateGas({
+              ...step.tx,
+              from
+            });
             step.tx.gasLimit = BigInt(est) * 115n / 100n;
           } catch {
           }
         }
         let hash;
         try {
-          const sent = await managed.sendTransaction(step.tx);
+          const sent = await signer.sendTransaction(step.tx);
           hash = sent.hash;
           stepHashes[step.key] = hash;
           const rcpt = await sent.wait();
           if (rcpt?.status === 0) {
             throw createError("EXECUTION", {
-              resource: "withdrawals",
-              operation: "withdrawals.create.sendTransaction",
-              message: "Withdrawal transaction reverted on L2 during a step.",
-              context: { step: step.key, txHash: hash, nonce: Number(step.tx.nonce ?? -1) }
+              resource: "interop",
+              operation: "interop.create.sendTransaction",
+              message: "Interop transaction reverted on source L2.",
+              context: { step: step.key, txHash: hash }
             });
           }
         } catch (e) {
-          throw toZKsyncError(
-            "EXECUTION",
-            {
-              resource: "withdrawals",
-              operation: "withdrawals.create.sendTransaction",
-              message: "Failed to send or confirm a withdrawal transaction step.",
-              context: { step: step.key, txHash: hash, nonce: Number(step.tx.nonce ?? -1) }
+          if (isZKsyncError(e)) throw e;
+          throw createError("EXECUTION", {
+            resource: "interop",
+            operation: "interop.create.sendTransaction",
+            message: "Failed to send or confirm an interop transaction step.",
+            context: {
+              step: step.key,
+              txHash: hash,
+              nonce: Number(step.tx.nonce ?? -1)
             },
-            e
-          );
-        }
-      }
-      const keys = Object.keys(stepHashes);
-      const l2TxHash = stepHashes[keys[keys.length - 1]];
-      return { kind: "withdrawal", l2TxHash, stepHashes, plan };
-    },
-    {
-      message: "Internal error while creating withdrawal transactions.",
-      ctx: { token: p.token, amount: p.amount, to: p.to, where: "withdrawals.create" }
-    }
-  );
-  const tryCreate = (p) => toResult2(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(
-    OP_WITHDRAWALS.status,
-    async () => {
-      const l2TxHash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
-      if (!l2TxHash || l2TxHash === "0x") {
-        return { phase: "UNKNOWN", l2TxHash: "0x" };
-      }
-      let l2Rcpt;
-      try {
-        l2Rcpt = await client.l2.getTransactionReceipt(l2TxHash);
-      } catch (e) {
-        if (isReceiptNotFound(e)) {
-          return { phase: "L2_PENDING", l2TxHash };
+            cause: e
+          });
         }
-        throw toZKsyncError(
-          "RPC",
-          {
-            resource: "withdrawals",
-            operation: "withdrawals.status.getTransactionReceipt",
-            message: "Failed to fetch L2 transaction receipt.",
-            context: { l2TxHash, where: "l2.getTransactionReceipt" }
-          },
-          e
-        );
-      }
-      if (!l2Rcpt) return { phase: "L2_PENDING", l2TxHash };
-      let pack;
-      try {
-        pack = await svc.fetchFinalizeDepositParams(l2TxHash);
-      } catch {
-        return { phase: "PENDING", l2TxHash };
       }
-      const key = {
-        chainIdL2: pack.params.chainId,
-        l2BatchNumber: pack.params.l2BatchNumber,
-        l2MessageIndex: pack.params.l2MessageIndex
+      const last = Object.values(stepHashes).pop();
+      return {
+        kind: "interop",
+        dstChain: params.dstChain,
+        stepHashes,
+        plan,
+        l2SrcTxHash: last ?? "0x"
       };
-      try {
-        const done = await svc.isWithdrawalFinalized(key);
-        if (done) return { phase: "FINALIZED", l2TxHash, key };
-      } catch {
-      }
-      const readiness = await svc.simulateFinalizeReadiness(pack.params);
-      if (readiness.kind === "FINALIZED") return { phase: "FINALIZED", l2TxHash, key };
-      if (readiness.kind === "READY") return { phase: "READY_TO_FINALIZE", l2TxHash, key };
-      return { phase: "PENDING", l2TxHash, key };
     },
     {
-      message: "Internal error while checking withdrawal status.",
-      ctx: { where: "withdrawals.status", l2TxHash: typeof h === "string" ? h : h.l2TxHash }
+      message: "Internal error while creating interop bundle.",
+      ctx: { where: "interop.create" }
     }
   );
-  const wait = (h, opts = {
-    for: "l2",
-    pollMs: 5500
-  }) => wrap2(
-    OP_WITHDRAWALS.wait,
-    async () => {
-      const l2Hash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
-      if (!l2Hash || l2Hash === "0x") return null;
-      if (opts.for === "l2") {
-        let rcpt;
-        try {
-          rcpt = await client.l2.waitForTransaction(l2Hash);
-        } catch (e) {
-          throw toZKsyncError(
-            "RPC",
-            {
-              resource: "withdrawals",
-              operation: "withdrawals.wait.l2.waitForTransaction",
-              message: "Failed while waiting for L2 transaction.",
-              context: { l2TxHash: l2Hash }
-            },
-            e
-          );
-        }
-        if (!rcpt) return null;
-        try {
-          const raw = await client.zks.getReceiptWithL2ToL1(l2Hash);
-          rcpt.l2ToL1Logs = raw?.l2ToL1Logs ?? [];
-        } catch {
-          rcpt.l2ToL1Logs = rcpt.l2ToL1Logs ?? [];
-        }
-        return rcpt;
-      }
-      const poll = Math.max(1e3, opts.pollMs ?? 2500);
-      const deadline = opts.timeoutMs ? Date.now() + opts.timeoutMs : void 0;
-      while (true) {
-        const s = await status(l2Hash);
-        if (opts.for === "ready") {
-          if (s.phase === "READY_TO_FINALIZE" || s.phase === "FINALIZED") return null;
-        } else {
-          if (s.phase === "FINALIZED") {
-            const l1Hash = finalizeCache.get(l2Hash);
-            if (l1Hash) {
-              try {
-                const l1Rcpt = await client.l1.getTransactionReceipt(l1Hash);
-                if (l1Rcpt) {
-                  finalizeCache.delete(l2Hash);
-                  return l1Rcpt;
-                }
-              } catch {
-              }
-            }
-            return null;
-          }
-        }
-        if (deadline && Date.now() > deadline) return null;
-        await new Promise((r) => setTimeout(r, poll));
-      }
-    },
-    {
-      message: "Internal error while waiting for withdrawal.",
-      ctx: {
-        where: "withdrawals.wait",
-        l2TxHash: typeof h === "string" ? h : h.l2TxHash,
-        for: opts.for
+  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 finalize = (l2TxHash) => wrap2(
-    OP_WITHDRAWALS.finalize.send,
+    );
+  };
+  const tryWait = (h, opts) => toResult2(OP_INTEROP.tryWait, () => wait(h, opts));
+  const finalize = (h, opts) => wrap5(
+    OP_INTEROP.finalize,
     async () => {
-      const pack = await (async () => {
-        try {
-          return await svc.fetchFinalizeDepositParams(l2TxHash);
-        } catch (e) {
+      if (isInteropFinalizationInfo(h)) {
+        if (h.dstChain == null) {
           throw createError("STATE", {
-            resource: "withdrawals",
-            operation: OP_WITHDRAWALS.finalize.fetchParams.receipt,
-            message: "Withdrawal not ready: finalize params unavailable.",
-            context: { l2TxHash },
-            cause: e
+            resource: "interop",
+            operation: OP_INTEROP.finalize,
+            message: "Missing dstChain in interop finalization info.",
+            context: { input: h }
           });
         }
-      })();
-      const { params } = pack;
-      const key = {
-        chainIdL2: params.chainId,
-        l2BatchNumber: params.l2BatchNumber,
-        l2MessageIndex: params.l2MessageIndex
-      };
-      try {
-        const done = await svc.isWithdrawalFinalized(key);
-        if (done) {
-          const statusNow = await status(l2TxHash);
-          return { status: statusNow };
-        }
-      } catch {
-      }
-      const readiness = await svc.simulateFinalizeReadiness(params);
-      if (readiness.kind === "FINALIZED") {
-        const statusNow = await status(l2TxHash);
-        return { status: statusNow };
-      }
-      if (readiness.kind === "NOT_READY") {
-        throw createError("STATE", {
-          resource: "withdrawals",
-          operation: OP_WITHDRAWALS.finalize.readiness.simulate,
-          message: "Withdrawal not ready to finalize.",
-          context: readiness
-        });
-      }
-      try {
-        const tx = await svc.finalizeDeposit(params);
-        finalizeCache.set(l2TxHash, tx.hash);
-        const rcpt = await tx.wait();
-        const statusNow = await status(l2TxHash);
-        return { status: statusNow, receipt: rcpt };
-      } catch (e) {
-        const statusNow = await status(l2TxHash);
-        if (statusNow.phase === "FINALIZED") return { status: statusNow };
-        try {
-          const again = await svc.simulateFinalizeReadiness(params);
-          if (again.kind === "NOT_READY") {
-            throw createError("STATE", {
-              resource: "withdrawals",
-              operation: OP_WITHDRAWALS.finalize.readiness.simulate,
-              message: "Withdrawal not ready to finalize.",
-              context: again
-            });
-          }
-        } catch {
-        }
-        throw e;
+        const dstProvider2 = resolveDstProvider(h.dstChain);
+        return svc.finalize(dstProvider2, h, opts);
       }
+      const { dstProvider, waitable } = resolveWaitableInput(h);
+      const info = await svc.wait(dstProvider, waitable);
+      return svc.finalize(dstProvider, info, opts);
     },
     {
-      message: "Internal error while attempting to finalize withdrawal.",
-      ctx: { l2TxHash, where: "withdrawals.finalize" }
-    }
-  );
-  const tryFinalize = (l2TxHash) => toResult2("withdrawals.tryFinalize", () => finalize(l2TxHash), {
-    message: "Internal error while attempting to tryFinalize withdrawal.",
-    ctx: { l2TxHash, where: "withdrawals.tryFinalize" }
-  });
-  const tryWait = (h, opts) => toResult2(
-    OP_WITHDRAWALS.tryWait,
-    async () => {
-      const v = await wait(h, opts);
-      if (v) return v;
-      throw createError("STATE", {
-        resource: "withdrawals",
-        operation: "withdrawals.tryWait",
-        message: opts.for === "l2" ? "No L2 receipt yet; the withdrawal has not executed on L2." : "No L1 receipt yet; the withdrawal has not been included on L1.",
-        context: {
-          for: opts.for,
-          l2TxHash: typeof h === "string" ? h : "l2TxHash" in h ? h.l2TxHash : void 0,
-          where: "withdrawals.tryWait"
-        }
-      });
-    },
-    {
-      message: "Internal error while waiting for withdrawal.",
-      ctx: { input: h, for: opts?.for, where: "withdrawals.tryWait" }
+      message: "Failed to finalize/execute interop bundle on destination.",
+      ctx: { where: "interop.finalize" }
     }
   );
+  const tryFinalize = (h, opts) => toResult2(OP_INTEROP.tryFinalize, () => finalize(h, opts));
   return {
     quote,
     tryQuote,
@@ -6150,9 +8588,9 @@ function createWithdrawalsResource(client, tokens, contracts) {
     tryCreate,
     status,
     wait,
+    tryWait,
     finalize,
-    tryFinalize,
-    tryWait
+    tryFinalize
   };
 }
 
@@ -6160,11 +8598,13 @@ function createWithdrawalsResource(client, tokens, contracts) {
 function createEthersSdk(client) {
   const tokens = createTokensResource(client);
   const contracts = createContractsResource(client);
+  const interop = createInteropResource(client);
   return {
     deposits: createDepositsResource(client, tokens, contracts),
     withdrawals: createWithdrawalsResource(client, tokens, contracts),
     tokens,
-    contracts
+    contracts,
+    interop
   };
 }