@matterlabs/zksync-js 0.0.12 → 0.0.14

package/dist/adapters/ethers/index.cjs

@@ -48,7 +48,15 @@ var TX_OVERHEAD_GAS = 10000n;
 var TX_MEMORY_OVERHEAD_GAS = 10n;
 var DEFAULT_PUBDATA_BYTES = 155n;
 var DEFAULT_ABI_BYTES = 400n;
-var SAFE_L1_BRIDGE_GAS = 800000n;
+var SAFE_L1_BRIDGE_GAS = 3000000n;
+var L1_TX_INTRINSIC_L2_GAS = 167157n;
+var L1_TX_INTRINSIC_PUBDATA = 88n;
+var L1_TX_MIN_L2_GAS_BASE = 173484n;
+var L1_TX_DELTA_544_ENCODING_BYTES = 1656n;
+var L1_TX_DELTA_FACTORY_DEPS_L2_GAS = 2473n;
+var L1_TX_DELTA_FACTORY_DEPS_PUBDATA = 64n;
+var TX_SLOT_OVERHEAD_L2_GAS = 10000n;
+var PRIORITY_TX_MAX_GAS_LIMIT = 72000000n;
 
 // src/core/utils/addr.ts
 function isAddress(x) {
@@ -413,6 +421,11 @@ var OP_INTEROP = {
     wait: {
       poll: "interop.svc.wait:poll",
       timeout: "interop.svc.wait:timeout"
+    },
+    fees: {
+      zkInteropFee: "interop.svc.fees:zkInteropFee",
+      zkToken: "interop.svc.fees:zkToken",
+      protocolFee: "interop.svc.fees:protocolFee"
     }
   }
 };
@@ -481,6 +494,7 @@ function normalizeProof(p) {
     const raw = p ?? {};
     const idRaw = raw?.id ?? raw?.index;
     const bnRaw = raw?.batch_number ?? raw?.batchNumber;
+    const gwBlockNumberRaw = raw?.gatewayBlockNumber;
     if (idRaw == null || bnRaw == null) {
       throw createError("RPC", {
         resource: "zksrpc",
@@ -501,7 +515,8 @@ function normalizeProof(p) {
       id: toBig(idRaw),
       batchNumber: toBig(bnRaw),
       proof: toHexArray(raw?.proof),
-      root: raw.root
+      root: raw.root,
+      gatewayBlockNumber: gwBlockNumberRaw != null ? toBig(gwBlockNumberRaw) : void 0
     };
   } catch (e) {
     if (isZKsyncError(e)) throw e;
@@ -524,8 +539,8 @@ function ensureHex(value, field, context) {
   });
 }
 function ensureNumber(value, field, opts) {
-  const operation = opts?.operation ?? "zksrpc.normalizeGenesis";
-  const messagePrefix = opts?.messagePrefix ?? "Malformed genesis response";
+  const operation = opts?.operation;
+  const messagePrefix = opts?.messagePrefix;
   if (isNumber(value)) return value;
   if (isBigint(value)) return Number(value);
   if (typeof value === "string" && value.trim() !== "") {
@@ -663,7 +678,6 @@ function normalizeGenesis(raw) {
         context: { valueType: typeof contractsRaw }
       });
     }
-    const executionVersion = ensureNumber(record["execution_version"], "execution_version");
     const genesisRoot = ensureHex(record["genesis_root"], "genesis_root", {});
     const initialContracts = contractsRaw.map(
       (entry, index) => normalizeContractTuple(entry, index)
@@ -672,7 +686,6 @@ function normalizeGenesis(raw) {
     return {
       initialContracts,
       additionalStorage,
-      executionVersion,
       genesisRoot
     };
   } catch (e) {
@@ -780,13 +793,15 @@ function createZksRpc(transport) {
       );
     },
     // Fetches a proof for an L2→L1 log emitted in the given transaction.
-    async getL2ToL1LogProof(txHash, index) {
+    async getL2ToL1LogProof(txHash, index, proofTarget) {
       return withRpcOp(
         "zksrpc.getL2ToL1LogProof",
         "Failed to fetch L2\u2192L1 log proof.",
-        { txHash, index },
+        { txHash, index, proofTarget },
         async () => {
-          const proof = await transport(METHODS.getL2ToL1LogProof, [txHash, index]);
+          const params = [txHash, index];
+          if (proofTarget != void 0) params.push(proofTarget);
+          const proof = await transport(METHODS.getL2ToL1LogProof, params);
           if (!proof) {
             throw createError("STATE", {
               resource: "zksrpc",
@@ -4969,56 +4984,69 @@ var IERC20_default = IERC20ABI;
 // src/core/internal/abis/IERC7786Attributes.ts
 var IERC7786AttributesABI = [
   {
+    type: "function",
+    name: "executionAddress",
     inputs: [
       {
-        internalType: "bytes",
         name: "_executionAddress",
-        type: "bytes"
+        type: "bytes",
+        internalType: "bytes"
       }
     ],
-    name: "executionAddress",
     outputs: [],
-    stateMutability: "pure",
-    type: "function"
+    stateMutability: "pure"
   },
   {
+    type: "function",
+    name: "indirectCall",
     inputs: [
       {
-        internalType: "uint256",
         name: "_indirectCallMessageValue",
-        type: "uint256"
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
-    name: "indirectCall",
     outputs: [],
-    stateMutability: "pure",
-    type: "function"
+    stateMutability: "pure"
   },
   {
+    type: "function",
+    name: "interopCallValue",
     inputs: [
       {
-        internalType: "uint256",
         name: "_interopCallValue",
-        type: "uint256"
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
-    name: "interopCallValue",
     outputs: [],
-    stateMutability: "pure",
-    type: "function"
+    stateMutability: "pure"
   },
   {
+    type: "function",
+    name: "unbundlerAddress",
     inputs: [
       {
-        internalType: "bytes",
         name: "_unbundlerAddress",
-        type: "bytes"
+        type: "bytes",
+        internalType: "bytes"
       }
     ],
-    name: "unbundlerAddress",
     outputs: [],
-    stateMutability: "pure",
-    type: "function"
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "useFixedFee",
+    inputs: [
+      {
+        name: "_useFixed",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [],
+    stateMutability: "pure"
   }
 ];
 var IERC7786Attributes_default = IERC7786AttributesABI;
@@ -5866,6 +5894,11 @@ var IInteropCenterABI = [
             type: "uint256",
             internalType: "uint256"
           },
+          {
+            name: "destinationBaseTokenAssetId",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
           {
             name: "interopBundleSalt",
             type: "bytes32",
@@ -6764,197 +6797,917 @@ var L2MessageVerificationABI = [
 ];
 var L2MessageVerification_default = L2MessageVerificationABI;
 
-// src/core/types/primitives.ts
-var ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
-
-// src/core/errors/error-ops.ts
-function resolveMessage(op, msg) {
-  if (!msg) return `Error during ${op}.`;
-  return typeof msg === "function" ? msg() : msg;
-}
-function createErrorOps(decodeRevert2) {
-  function toZKsyncError2(type, base, err) {
-    if (isZKsyncError(err)) return err;
-    const revert = decodeRevert2 ? decodeRevert2(err) : void 0;
-    return createError(type, { ...base, ...revert ? { revert } : {}, cause: shapeCause(err) });
-  }
-  function createErrorHandlers2(resource) {
-    async function run(kind, operation, fn, opts) {
-      try {
-        return await fn();
-      } catch (e) {
-        if (isZKsyncError(e)) throw e;
-        const message = resolveMessage(operation, opts?.message);
-        throw toZKsyncError2(kind, { resource, operation, context: opts?.ctx ?? {}, message }, e);
+// src/core/internal/abis/IInteropErrors.ts
+var IInteropErrorsABI = [
+  {
+    type: "error",
+    name: "AttributeAlreadySet",
+    inputs: [
+      {
+        name: "selector",
+        type: "bytes4"
       }
-    }
-    function wrap7(operation, fn, opts) {
-      return run("INTERNAL", operation, fn, opts);
-    }
-    function wrapAs10(kind, operation, fn, opts) {
-      return run(kind, operation, fn, opts);
-    }
-    async function toResult3(operation, fn, opts) {
-      try {
-        const value = await wrap7(operation, fn, opts);
-        return { ok: true, value };
-      } catch (e) {
-        const shaped = isZKsyncError(e) ? e : toZKsyncError2(
-          "INTERNAL",
-          {
-            resource,
-            operation,
-            context: opts?.ctx ?? {},
-            message: resolveMessage(operation, opts?.message)
-          },
-          e
-        );
-        return { ok: false, error: shaped };
+    ]
+  },
+  {
+    type: "error",
+    name: "AttributeViolatesRestriction",
+    inputs: [
+      {
+        name: "selector",
+        type: "bytes4"
+      },
+      {
+        name: "restriction",
+        type: "uint256"
       }
-    }
-    return { wrap: wrap7, wrapAs: wrapAs10, toResult: toResult3 };
-  }
-  return { toZKsyncError: toZKsyncError2, createErrorHandlers: createErrorHandlers2 };
-}
-
-// src/core/errors/withdrawal-revert-map.ts
-var REVERT_TO_READINESS = {
-  // Already done
-  WithdrawalAlreadyFinalized: { kind: "FINALIZED" },
-  // Temporary — try later
-  BatchNotExecuted: { kind: "NOT_READY", reason: "batch-not-executed" },
-  LocalRootIsZero: { kind: "NOT_READY", reason: "root-missing" },
-  // Permanent — won’t become ready for this tx
-  WrongL2Sender: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  InvalidSelector: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  L2WithdrawalMessageWrongLength: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  WrongMsgLength: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  TokenNotLegacy: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  TokenIsLegacy: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  InvalidProof: { kind: "UNFINALIZABLE", reason: "message-invalid" },
-  InvalidChainId: { kind: "UNFINALIZABLE", reason: "invalid-chain" },
-  NotSettlementLayer: { kind: "UNFINALIZABLE", reason: "settlement-layer" },
-  // Likely environment mismatch — treat as permanent for this tx
-  OnlyEraSupported: { kind: "UNFINALIZABLE", reason: "unsupported" },
-  LocalRootMustBeZero: { kind: "UNFINALIZABLE", reason: "unsupported" }
-};
-
-// src/adapters/ethers/errors/revert.ts
-var ERROR_IFACES = [];
-var IFACE_ERROR_STRING = new ethers.Interface(["error Error(string)"]);
-var IFACE_PANIC = new ethers.Interface(["error Panic(uint256)"]);
-(function bootstrapDefaultIfaces() {
-  try {
-    ERROR_IFACES.push({
-      name: "IL1Nullifier",
-      iface: new ethers.Interface(IL1Nullifier_default)
-    });
-  } catch {
-  }
-  try {
-    ERROR_IFACES.push({ name: "IERC20", iface: new ethers.Interface(IERC20_default) });
-  } catch {
-  }
-  try {
-    ERROR_IFACES.push({
-      name: "IL1NativeTokenVault",
-      iface: new ethers.Interface(L1NativeTokenVault_default)
-    });
-  } catch {
-  }
-  try {
-    ERROR_IFACES.push({
-      name: "IL2NativeTokenVault",
-      iface: new ethers.Interface(L2NativeTokenVault_default)
-    });
-  } catch {
-  }
-  try {
-    ERROR_IFACES.push({ name: "Mailbox", iface: new ethers.Interface(Mailbox_default) });
-  } catch {
-  }
-})();
-function registerErrorAbi(name, abi2) {
-  const existing = ERROR_IFACES.findIndex((x) => x.name === name);
-  const entry = { name, iface: new ethers.Interface(abi2) };
-  if (existing >= 0) ERROR_IFACES[existing] = entry;
-  else ERROR_IFACES.push(entry);
-}
-function extractRevertData(e) {
-  const maybe = (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    e?.data?.data ?? e?.error?.data ?? e?.data ?? e?.error?.error?.data ?? e?.info?.error?.data
-  );
-  if (typeof maybe === "string" && maybe.startsWith("0x") && maybe.length >= 10) {
-    return maybe;
-  }
-  return void 0;
-}
-function decodeRevert(e) {
-  const data = extractRevertData(e);
-  if (!data) return;
-  const selector = `0x${data.slice(2, 10)}`;
-  try {
-    const parsed = IFACE_ERROR_STRING.parseError(data);
-    if (parsed?.name === "Error") {
-      const args = parsed.args ? Array.from(parsed.args) : void 0;
-      return { selector, name: "Error", args };
-    }
-  } catch {
-  }
-  try {
-    const parsed = IFACE_PANIC.parseError(data);
-    if (parsed?.name === "Panic") {
-      const args = parsed.args ? Array.from(parsed.args) : void 0;
-      return { selector, name: "Panic", args };
-    }
-  } catch {
-  }
-  for (const { name, iface } of ERROR_IFACES) {
-    try {
-      const parsed = iface.parseError(data);
-      if (parsed) {
-        const args = parsed.args ? Array.from(parsed.args) : void 0;
-        return {
-          selector,
-          name: parsed.name,
-          args,
-          contract: name
-        };
+    ]
+  },
+  {
+    type: "error",
+    name: "BundleAlreadyProcessed",
+    inputs: [
+      {
+        name: "bundleHash",
+        type: "bytes32"
       }
-    } catch {
-    }
-  }
-  return { selector };
-}
-function classifyReadinessFromRevert(e) {
-  const r = decodeRevert(e);
-  const name = r?.name;
-  if (name && REVERT_TO_READINESS[name]) return REVERT_TO_READINESS[name];
-  const msg = (() => {
-    if (typeof e !== "object" || e === null) return "";
-    const obj = e;
-    const maybeMsg = obj["shortMessage"] ?? obj["message"];
-    return typeof maybeMsg === "string" ? maybeMsg : "";
-  })();
-  const lower = String(msg).toLowerCase();
-  if (lower.includes("paused")) return { kind: "NOT_READY", reason: "paused" };
-  if (name || r?.selector) {
-    return { kind: "UNFINALIZABLE", reason: "unsupported", detail: name ?? r?.selector };
-  }
-  return { kind: "NOT_READY", reason: "unknown", detail: lower || void 0 };
-}
-
-// src/adapters/ethers/errors/error-ops.ts
-var { toZKsyncError, createErrorHandlers } = createErrorOps(decodeRevert);
-
-// src/adapters/ethers/client.ts
-var { wrapAs, wrap } = createErrorHandlers("client");
-var ChainTypeManagerABI = [
-  "function getSemverProtocolVersion() view returns (uint32,uint32,uint32)"
-];
-function createEthersClient(args) {
-  const { l1, l2, signer } = args;
+    ]
+  },
+  {
+    type: "error",
+    name: "CallAlreadyExecuted",
+    inputs: [
+      {
+        name: "bundleHash",
+        type: "bytes32"
+      },
+      {
+        name: "callIndex",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "CallNotExecutable",
+    inputs: [
+      {
+        name: "bundleHash",
+        type: "bytes32"
+      },
+      {
+        name: "callIndex",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "CanNotUnbundle",
+    inputs: [
+      {
+        name: "bundleHash",
+        type: "bytes32"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "DestinationChainNotRegistered",
+    inputs: [
+      {
+        name: "destinationChainId",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ExecutingNotAllowed",
+    inputs: [
+      {
+        name: "bundleHash",
+        type: "bytes32"
+      },
+      {
+        name: "callerAddress",
+        type: "bytes"
+      },
+      {
+        name: "executionAddress",
+        type: "bytes"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "FeeWithdrawalFailed",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "IndirectCallValueMismatch",
+    inputs: [
+      {
+        name: "expected",
+        type: "uint256"
+      },
+      {
+        name: "actual",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "InteroperableAddressChainReferenceNotEmpty",
+    inputs: [
+      {
+        name: "interoperableAddress",
+        type: "bytes"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "InteroperableAddressNotEmpty",
+    inputs: [
+      {
+        name: "interoperableAddress",
+        type: "bytes"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "InvalidInteropBundleVersion",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidInteropCallVersion",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InteropRootAlreadyExists",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "MessageNotIncluded",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "SidesLengthNotOne",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "UnauthorizedMessageSender",
+    inputs: [
+      {
+        name: "expected",
+        type: "address"
+      },
+      {
+        name: "actual",
+        type: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "UnbundlingNotAllowed",
+    inputs: [
+      {
+        name: "bundleHash",
+        type: "bytes32"
+      },
+      {
+        name: "callerAddress",
+        type: "bytes"
+      },
+      {
+        name: "unbundlerAddress",
+        type: "bytes"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "WrongCallStatusLength",
+    inputs: [
+      {
+        name: "bundleCallsLength",
+        type: "uint256"
+      },
+      {
+        name: "providedCallStatusLength",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "WrongDestinationChainId",
+    inputs: [
+      {
+        name: "bundleHash",
+        type: "bytes32"
+      },
+      {
+        name: "expected",
+        type: "uint256"
+      },
+      {
+        name: "actual",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "WrongDestinationBaseTokenAssetId",
+    inputs: [
+      {
+        name: "bundleHash",
+        type: "bytes32"
+      },
+      {
+        name: "expected",
+        type: "bytes32"
+      },
+      {
+        name: "actual",
+        type: "bytes32"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "WrongSourceChainId",
+    inputs: [
+      {
+        name: "bundleHash",
+        type: "bytes32"
+      },
+      {
+        name: "expected",
+        type: "uint256"
+      },
+      {
+        name: "actual",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ZKTokenNotAvailable",
+    inputs: []
+  }
+];
+var IInteropErrors_default = IInteropErrorsABI;
+
+// src/core/internal/abis/IL1ContractErrors.ts
+var IL1ContractErrorsABI = [
+  {
+    type: "error",
+    name: "AccessToFallbackDenied",
+    inputs: [
+      { name: "target", type: "address" },
+      { name: "invoker", type: "address" }
+    ]
+  },
+  {
+    type: "error",
+    name: "AccessToFunctionDenied",
+    inputs: [
+      { name: "target", type: "address" },
+      { name: "selector", type: "bytes4" },
+      { name: "invoker", type: "address" }
+    ]
+  },
+  { type: "error", name: "AddressAlreadySet", inputs: [{ name: "addr", type: "address" }] },
+  { type: "error", name: "AddressHasNoCode", inputs: [{ name: "", type: "address" }] },
+  {
+    type: "error",
+    name: "AddressMismatch",
+    inputs: [
+      { name: "expected", type: "address" },
+      { name: "supplied", type: "address" }
+    ]
+  },
+  { type: "error", name: "AlreadyPermanentRollup", inputs: [] },
+  { type: "error", name: "AlreadyWhitelisted", inputs: [{ name: "", type: "address" }] },
+  { type: "error", name: "AmountMustBeGreaterThanZero", inputs: [] },
+  {
+    type: "error",
+    name: "AssetHandlerDoesNotExist",
+    inputs: [{ name: "assetId", type: "bytes32" }]
+  },
+  {
+    type: "error",
+    name: "AssetHandlerNotRegistered",
+    inputs: [{ name: "assetId", type: "bytes32" }]
+  },
+  { type: "error", name: "AssetIdAlreadyRegistered", inputs: [] },
+  {
+    type: "error",
+    name: "AssetIdMismatch",
+    inputs: [
+      { name: "expected", type: "bytes32" },
+      { name: "supplied", type: "bytes32" }
+    ]
+  },
+  { type: "error", name: "AssetIdNotSupported", inputs: [{ name: "assetId", type: "bytes32" }] },
+  { type: "error", name: "AssetRouterAllowanceNotZero", inputs: [] },
+  { type: "error", name: "BaseTokenGasPriceDenominatorNotSet", inputs: [] },
+  {
+    type: "error",
+    name: "BatchHashMismatch",
+    inputs: [
+      { name: "expected", type: "bytes32" },
+      { name: "actual", type: "bytes32" }
+    ]
+  },
+  { type: "error", name: "BatchNotExecuted", inputs: [{ name: "batchNumber", type: "uint256" }] },
+  {
+    type: "error",
+    name: "BatchNumberMismatch",
+    inputs: [
+      { name: "expectedBatchNumber", type: "uint256" },
+      { name: "providedBatchNumber", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "BridgeHubAlreadyRegistered", inputs: [] },
+  { type: "error", name: "BridgeMintNotImplemented", inputs: [] },
+  { type: "error", name: "BurningNativeWETHNotSupported", inputs: [] },
+  {
+    type: "error",
+    name: "BytecodeAlreadyPublished",
+    inputs: [{ name: "bytecodeHash", type: "bytes32" }]
+  },
+  { type: "error", name: "CallerNotTimerAdmin", inputs: [] },
+  { type: "error", name: "CallNotAllowed", inputs: [{ name: "call", type: "bytes" }] },
+  { type: "error", name: "CanOnlyProcessOneBatch", inputs: [] },
+  { type: "error", name: "CantExecuteUnprovenBatches", inputs: [] },
+  { type: "error", name: "CantRevertExecutedBatch", inputs: [] },
+  { type: "error", name: "ChainAlreadyLive", inputs: [] },
+  { type: "error", name: "ChainIdAlreadyExists", inputs: [] },
+  { type: "error", name: "ChainIdCantBeCurrentChain", inputs: [] },
+  { type: "error", name: "ChainIdMismatch", inputs: [] },
+  { type: "error", name: "ChainIdNotRegistered", inputs: [{ name: "chainId", type: "uint256" }] },
+  { type: "error", name: "ChainIdTooBig", inputs: [] },
+  { type: "error", name: "CTMAlreadyRegistered", inputs: [] },
+  { type: "error", name: "CTMNotRegistered", inputs: [] },
+  { type: "error", name: "DeadlineNotYetPassed", inputs: [] },
+  { type: "error", name: "DefaultAdminTransferNotAllowed", inputs: [] },
+  { type: "error", name: "DelegateCallFailed", inputs: [{ name: "returnData", type: "bytes" }] },
+  { type: "error", name: "DenominatorIsZero", inputs: [] },
+  { type: "error", name: "DeployFailed", inputs: [] },
+  { type: "error", name: "DeployingBridgedTokenForNativeToken", inputs: [] },
+  { type: "error", name: "DepositDoesNotExist", inputs: [] },
+  { type: "error", name: "DepositExists", inputs: [] },
+  { type: "error", name: "DiamondAlreadyFrozen", inputs: [] },
+  { type: "error", name: "DiamondNotFrozen", inputs: [] },
+  { type: "error", name: "EmptyAddress", inputs: [] },
+  { type: "error", name: "EmptyAssetId", inputs: [] },
+  { type: "error", name: "EmptyBytes32", inputs: [] },
+  { type: "error", name: "EmptyData", inputs: [] },
+  { type: "error", name: "EmptyDeposit", inputs: [] },
+  { type: "error", name: "EmptyPrecommitData", inputs: [{ name: "batchNumber", type: "uint256" }] },
+  { type: "error", name: "EmptyProofLength", inputs: [] },
+  { type: "error", name: "ETHDepositNotSupported", inputs: [] },
+  {
+    type: "error",
+    name: "FacetExists",
+    inputs: [
+      { name: "selector", type: "bytes4" },
+      { name: "", type: "address" }
+    ]
+  },
+  { type: "error", name: "GasPerPubdataMismatch", inputs: [] },
+  { type: "error", name: "GenesisBatchCommitmentZero", inputs: [] },
+  { type: "error", name: "GenesisBatchHashZero", inputs: [] },
+  { type: "error", name: "GenesisIndexStorageZero", inputs: [] },
+  { type: "error", name: "GenesisUpgradeZero", inputs: [] },
+  { type: "error", name: "HashedLogIsDefault", inputs: [] },
+  {
+    type: "error",
+    name: "HashMismatch",
+    inputs: [
+      { name: "expected", type: "bytes32" },
+      { name: "actual", type: "bytes32" }
+    ]
+  },
+  {
+    type: "error",
+    name: "IncorrectBatchBounds",
+    inputs: [
+      { name: "processFromExpected", type: "uint256" },
+      { name: "processToExpected", type: "uint256" },
+      { name: "processFromProvided", type: "uint256" },
+      { name: "processToProvided", type: "uint256" }
+    ]
+  },
+  {
+    type: "error",
+    name: "IncorrectBridgeHubAddress",
+    inputs: [{ name: "bridgehub", type: "address" }]
+  },
+  {
+    type: "error",
+    name: "IncorrectTokenAddressFromNTV",
+    inputs: [
+      { name: "assetId", type: "bytes32" },
+      { name: "tokenAddress", type: "address" }
+    ]
+  },
+  { type: "error", name: "InsufficientChainBalance", inputs: [] },
+  {
+    type: "error",
+    name: "InvalidBatchNumber",
+    inputs: [
+      { name: "provided", type: "uint256" },
+      { name: "expected", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "InvalidCaller", inputs: [{ name: "", type: "address" }] },
+  { type: "error", name: "InvalidDAForPermanentRollup", inputs: [] },
+  { type: "error", name: "InvalidDelay", inputs: [] },
+  {
+    type: "error",
+    name: "InvalidLogSender",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "logKey", type: "uint256" }
+    ]
+  },
+  {
+    type: "error",
+    name: "InvalidMessageRoot",
+    inputs: [
+      { name: "expectedMessageRoot", type: "bytes32" },
+      { name: "providedMessageRoot", type: "bytes32" }
+    ]
+  },
+  { type: "error", name: "InvalidNTVBurnData", inputs: [] },
+  {
+    type: "error",
+    name: "InvalidNumberOfBlobs",
+    inputs: [
+      { name: "expected", type: "uint256" },
+      { name: "numCommitments", type: "uint256" },
+      { name: "numHashes", type: "uint256" }
+    ]
+  },
+  {
+    type: "error",
+    name: "InvalidPackedPrecommitmentLength",
+    inputs: [{ name: "length", type: "uint256" }]
+  },
+  { type: "error", name: "InvalidProof", inputs: [] },
+  { type: "error", name: "InvalidProofLengthForFinalNode", inputs: [] },
+  { type: "error", name: "InvalidProtocolVersion", inputs: [] },
+  { type: "error", name: "InvalidPubdataPricingMode", inputs: [] },
+  { type: "error", name: "InvalidSelector", inputs: [{ name: "func", type: "bytes4" }] },
+  { type: "error", name: "InvalidSystemLogsLength", inputs: [] },
+  { type: "error", name: "InvalidUpgradeTxn", inputs: [{ name: "", type: "uint8" }] },
+  { type: "error", name: "L2TimestampTooBig", inputs: [] },
+  {
+    type: "error",
+    name: "L2WithdrawalMessageWrongLength",
+    inputs: [{ name: "messageLen", type: "uint256" }]
+  },
+  { type: "error", name: "LegacyBridgeNotSet", inputs: [] },
+  { type: "error", name: "LegacyBridgeUsesNonNativeToken", inputs: [] },
+  { type: "error", name: "LegacyEncodingUsedForNonL1Token", inputs: [] },
+  { type: "error", name: "LegacyMethodForNonL1Token", inputs: [] },
+  {
+    type: "error",
+    name: "LengthIsNotDivisibleBy32",
+    inputs: [{ name: "length", type: "uint256" }]
+  },
+  { type: "error", name: "LogAlreadyProcessed", inputs: [{ name: "", type: "uint8" }] },
+  { type: "error", name: "MalformedBytecode", inputs: [{ name: "", type: "uint8" }] },
+  { type: "error", name: "MerkleIndexOrHeightMismatch", inputs: [] },
+  { type: "error", name: "MerkleIndexOutOfBounds", inputs: [] },
+  { type: "error", name: "MerkleNothingToProve", inputs: [] },
+  { type: "error", name: "MerklePathEmpty", inputs: [] },
+  {
+    type: "error",
+    name: "MerklePathLengthMismatch",
+    inputs: [
+      { name: "pathLength", type: "uint256" },
+      { name: "expectedLength", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "MerklePathOutOfBounds", inputs: [] },
+  {
+    type: "error",
+    name: "MerkleWrongIndex",
+    inputs: [
+      { name: "index", type: "uint256" },
+      { name: "maxNodeNumber", type: "uint256" }
+    ]
+  },
+  {
+    type: "error",
+    name: "MerkleWrongLength",
+    inputs: [
+      { name: "newLeavesLength", type: "uint256" },
+      { name: "leafNumber", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "MigrationPaused", inputs: [] },
+  { type: "error", name: "MigrationsNotPaused", inputs: [] },
+  {
+    type: "error",
+    name: "MissingSystemLogs",
+    inputs: [
+      { name: "expected", type: "uint256" },
+      { name: "actual", type: "uint256" }
+    ]
+  },
+  {
+    type: "error",
+    name: "MsgValueMismatch",
+    inputs: [
+      { name: "expectedMsgValue", type: "uint256" },
+      { name: "providedMsgValue", type: "uint256" }
+    ]
+  },
+  {
+    type: "error",
+    name: "MsgValueTooLow",
+    inputs: [
+      { name: "required", type: "uint256" },
+      { name: "provided", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "NewDeadlineExceedsMaxDeadline", inputs: [] },
+  { type: "error", name: "NewDeadlineNotGreaterThanCurrent", inputs: [] },
+  { type: "error", name: "NoCallsProvided", inputs: [] },
+  { type: "error", name: "NoCTMForAssetId", inputs: [{ name: "assetId", type: "bytes32" }] },
+  { type: "error", name: "NoFunctionsForDiamondCut", inputs: [] },
+  { type: "error", name: "NoFundsTransferred", inputs: [] },
+  { type: "error", name: "NoLegacySharedBridge", inputs: [] },
+  { type: "error", name: "NonEmptyCalldata", inputs: [] },
+  { type: "error", name: "NonEmptyMsgValue", inputs: [] },
+  { type: "error", name: "NonIncreasingTimestamp", inputs: [] },
+  { type: "error", name: "NonSequentialBatch", inputs: [] },
+  { type: "error", name: "NonSequentialVersion", inputs: [] },
+  { type: "error", name: "NotAllowed", inputs: [{ name: "addr", type: "address" }] },
+  { type: "error", name: "NotARestriction", inputs: [{ name: "addr", type: "address" }] },
+  { type: "error", name: "NotAZKChain", inputs: [{ name: "addr", type: "address" }] },
+  { type: "error", name: "NotInitializedReentrancyGuard", inputs: [] },
+  { type: "error", name: "NotWhitelisted", inputs: [{ name: "", type: "address" }] },
+  { type: "error", name: "OnlyEraSupported", inputs: [] },
+  { type: "error", name: "OnlySelfAllowed", inputs: [] },
+  { type: "error", name: "OperationExists", inputs: [] },
+  { type: "error", name: "OperationMustBePending", inputs: [] },
+  { type: "error", name: "OperationMustBeReady", inputs: [] },
+  { type: "error", name: "OriginChainIdNotFound", inputs: [] },
+  {
+    type: "error",
+    name: "PrecommitmentMismatch",
+    inputs: [
+      { name: "batchNumber", type: "uint256" },
+      { name: "expected", type: "bytes32" },
+      { name: "found", type: "bytes32" }
+    ]
+  },
+  { type: "error", name: "PreviousOperationNotExecuted", inputs: [] },
+  { type: "error", name: "PriorityOperationsRollingHashMismatch", inputs: [] },
+  { type: "error", name: "PriorityTxPubdataExceedsMaxPubDataPerBatch", inputs: [] },
+  {
+    type: "error",
+    name: "ProtocolIdMismatch",
+    inputs: [
+      { name: "expectedProtocolVersion", type: "uint256" },
+      { name: "providedProtocolId", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "ProtocolIdNotGreater", inputs: [] },
+  {
+    type: "error",
+    name: "PubdataGreaterThanLimit",
+    inputs: [
+      { name: "limit", type: "uint256" },
+      { name: "length", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "QueueIsEmpty", inputs: [] },
+  { type: "error", name: "Reentrancy", inputs: [] },
+  {
+    type: "error",
+    name: "RemoveFunctionFacetAddressNotZero",
+    inputs: [{ name: "facet", type: "address" }]
+  },
+  { type: "error", name: "RemoveFunctionFacetAddressZero", inputs: [] },
+  { type: "error", name: "RemovingPermanentRestriction", inputs: [] },
+  { type: "error", name: "ReplaceFunctionFacetAddressZero", inputs: [] },
+  {
+    type: "error",
+    name: "RestrictionWasAlreadyPresent",
+    inputs: [{ name: "restriction", type: "address" }]
+  },
+  {
+    type: "error",
+    name: "RestrictionWasNotPresent",
+    inputs: [{ name: "restriction", type: "address" }]
+  },
+  { type: "error", name: "RevertedBatchNotAfterNewLastBatch", inputs: [] },
+  {
+    type: "error",
+    name: "RoleAccessDenied",
+    inputs: [
+      { name: "chainAddress", type: "address" },
+      { name: "role", type: "bytes32" },
+      { name: "account", type: "address" }
+    ]
+  },
+  { type: "error", name: "SelectorsMustAllHaveSameFreezability", inputs: [] },
+  { type: "error", name: "SettlementLayersMustSettleOnL1", inputs: [] },
+  { type: "error", name: "SharedBridgeNotSet", inputs: [] },
+  { type: "error", name: "SharedBridgeValueNotSet", inputs: [{ name: "", type: "uint8" }] },
+  { type: "error", name: "SlotOccupied", inputs: [] },
+  { type: "error", name: "SystemLogsSizeTooBig", inputs: [] },
+  {
+    type: "error",
+    name: "TimeNotReached",
+    inputs: [
+      { name: "expectedTimestamp", type: "uint256" },
+      { name: "actualTimestamp", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "TimerAlreadyStarted", inputs: [] },
+  { type: "error", name: "TimestampError", inputs: [] },
+  { type: "error", name: "TokenIsLegacy", inputs: [] },
+  { type: "error", name: "TokenNotLegacy", inputs: [] },
+  { type: "error", name: "TokenNotSupported", inputs: [{ name: "token", type: "address" }] },
+  { type: "error", name: "TokensWithFeesNotSupported", inputs: [] },
+  { type: "error", name: "TooHighDeploymentNonce", inputs: [] },
+  { type: "error", name: "TooManyFactoryDeps", inputs: [] },
+  { type: "error", name: "TooMuchGas", inputs: [] },
+  { type: "error", name: "TransactionNotAllowed", inputs: [] },
+  { type: "error", name: "TxHashMismatch", inputs: [] },
+  { type: "error", name: "TxnBodyGasLimitNotEnoughGas", inputs: [] },
+  {
+    type: "error",
+    name: "UnallowedImplementation",
+    inputs: [{ name: "implementationHash", type: "bytes32" }]
+  },
+  { type: "error", name: "Unauthorized", inputs: [{ name: "caller", type: "address" }] },
+  { type: "error", name: "UndefinedDiamondCutAction", inputs: [] },
+  { type: "error", name: "UnexpectedSystemLog", inputs: [{ name: "logKey", type: "uint256" }] },
+  { type: "error", name: "UnknownVerifierType", inputs: [] },
+  {
+    type: "error",
+    name: "UnsupportedCommitBatchEncoding",
+    inputs: [{ name: "version", type: "uint8" }]
+  },
+  { type: "error", name: "UnsupportedEncodingVersion", inputs: [] },
+  {
+    type: "error",
+    name: "UnsupportedExecuteBatchEncoding",
+    inputs: [{ name: "version", type: "uint8" }]
+  },
+  {
+    type: "error",
+    name: "UnsupportedProofBatchEncoding",
+    inputs: [{ name: "version", type: "uint8" }]
+  },
+  { type: "error", name: "UpgradeBatchNumberIsNotZero", inputs: [] },
+  { type: "error", name: "ValidateTxnNotEnoughGas", inputs: [] },
+  {
+    type: "error",
+    name: "ValueMismatch",
+    inputs: [
+      { name: "expected", type: "uint256" },
+      { name: "actual", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "VerifiedBatchesExceedsCommittedBatches", inputs: [] },
+  { type: "error", name: "WithdrawalAlreadyFinalized", inputs: [] },
+  { type: "error", name: "WithdrawFailed", inputs: [] },
+  { type: "error", name: "WrappedBaseTokenAlreadyRegistered", inputs: [] },
+  {
+    type: "error",
+    name: "WrongMagicValue",
+    inputs: [
+      { name: "expectedMagicValue", type: "uint256" },
+      { name: "providedMagicValue", type: "uint256" }
+    ]
+  },
+  { type: "error", name: "ZeroAddress", inputs: [] },
+  { type: "error", name: "ZeroChainId", inputs: [] },
+  { type: "error", name: "ZKChainLimitReached", inputs: [] }
+];
+var IL1ContractErrors_default = IL1ContractErrorsABI;
+
+// src/core/types/primitives.ts
+var ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
+
+// src/core/errors/error-ops.ts
+function resolveMessage(op, msg) {
+  if (!msg) return `Error during ${op}.`;
+  return typeof msg === "function" ? msg() : msg;
+}
+function createErrorOps(decodeRevert2) {
+  function toZKsyncError2(type, base, err) {
+    if (isZKsyncError(err)) return err;
+    const revert = decodeRevert2 ? decodeRevert2(err) : void 0;
+    return createError(type, { ...base, ...revert ? { revert } : {}, cause: shapeCause(err) });
+  }
+  function createErrorHandlers2(resource) {
+    async function run(kind, operation, fn, opts) {
+      try {
+        return await fn();
+      } catch (e) {
+        if (isZKsyncError(e)) throw e;
+        const message = resolveMessage(operation, opts?.message);
+        throw toZKsyncError2(kind, { resource, operation, context: opts?.ctx ?? {}, message }, e);
+      }
+    }
+    function wrap8(operation, fn, opts) {
+      return run("INTERNAL", operation, fn, opts);
+    }
+    function wrapAs10(kind, operation, fn, opts) {
+      return run(kind, operation, fn, opts);
+    }
+    async function toResult3(operation, fn, opts) {
+      try {
+        const value = await wrap8(operation, fn, opts);
+        return { ok: true, value };
+      } catch (e) {
+        const shaped = isZKsyncError(e) ? e : toZKsyncError2(
+          "INTERNAL",
+          {
+            resource,
+            operation,
+            context: opts?.ctx ?? {},
+            message: resolveMessage(operation, opts?.message)
+          },
+          e
+        );
+        return { ok: false, error: shaped };
+      }
+    }
+    return { wrap: wrap8, wrapAs: wrapAs10, toResult: toResult3 };
+  }
+  return { toZKsyncError: toZKsyncError2, createErrorHandlers: createErrorHandlers2 };
+}
+
+// src/core/errors/withdrawal-revert-map.ts
+var REVERT_TO_READINESS = {
+  // Already done
+  WithdrawalAlreadyFinalized: { kind: "FINALIZED" },
+  // Temporary — try later
+  BatchNotExecuted: { kind: "NOT_READY", reason: "batch-not-executed" },
+  LocalRootIsZero: { kind: "NOT_READY", reason: "root-missing" },
+  // Permanent — won’t become ready for this tx
+  WrongL2Sender: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  InvalidSelector: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  L2WithdrawalMessageWrongLength: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  WrongMsgLength: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  TokenNotLegacy: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  TokenIsLegacy: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  InvalidProof: { kind: "UNFINALIZABLE", reason: "message-invalid" },
+  InvalidChainId: { kind: "UNFINALIZABLE", reason: "invalid-chain" },
+  NotSettlementLayer: { kind: "UNFINALIZABLE", reason: "settlement-layer" },
+  // Likely environment mismatch — treat as permanent for this tx
+  OnlyEraSupported: { kind: "UNFINALIZABLE", reason: "unsupported" },
+  LocalRootMustBeZero: { kind: "UNFINALIZABLE", reason: "unsupported" }
+};
+
+// src/adapters/ethers/errors/revert.ts
+var ERROR_IFACES = [];
+var IFACE_ERROR_STRING = new ethers.Interface(["error Error(string)"]);
+var IFACE_PANIC = new ethers.Interface(["error Panic(uint256)"]);
+(function bootstrapDefaultIfaces() {
+  try {
+    ERROR_IFACES.push({
+      name: "IL1Nullifier",
+      iface: new ethers.Interface(IL1Nullifier_default)
+    });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({ name: "IERC20", iface: new ethers.Interface(IERC20_default) });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({
+      name: "IL1NativeTokenVault",
+      iface: new ethers.Interface(L1NativeTokenVault_default)
+    });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({
+      name: "IL2NativeTokenVault",
+      iface: new ethers.Interface(L2NativeTokenVault_default)
+    });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({ name: "Mailbox", iface: new ethers.Interface(Mailbox_default) });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({ name: "IL1ContractErrors", iface: new ethers.Interface(IL1ContractErrors_default) });
+  } catch {
+  }
+  try {
+    ERROR_IFACES.push({ name: "IInteropErrors", iface: new ethers.Interface(IInteropErrors_default) });
+  } catch {
+  }
+})();
+function registerErrorAbi(name, abi2) {
+  const existing = ERROR_IFACES.findIndex((x) => x.name === name);
+  const entry = { name, iface: new ethers.Interface(abi2) };
+  if (existing >= 0) ERROR_IFACES[existing] = entry;
+  else ERROR_IFACES.push(entry);
+}
+function extractRevertData(e) {
+  const maybe = (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    e?.data?.data ?? e?.error?.data ?? e?.data ?? e?.error?.error?.data ?? e?.info?.error?.data
+  );
+  if (typeof maybe === "string" && maybe.startsWith("0x") && maybe.length >= 10) {
+    return maybe;
+  }
+  return void 0;
+}
+function decodeRevert(e) {
+  const data = extractRevertData(e);
+  if (!data) return;
+  const selector = `0x${data.slice(2, 10)}`;
+  try {
+    const parsed = IFACE_ERROR_STRING.parseError(data);
+    if (parsed?.name === "Error") {
+      const args = parsed.args ? Array.from(parsed.args) : void 0;
+      return { selector, name: "Error", args };
+    }
+  } catch {
+  }
+  try {
+    const parsed = IFACE_PANIC.parseError(data);
+    if (parsed?.name === "Panic") {
+      const args = parsed.args ? Array.from(parsed.args) : void 0;
+      return { selector, name: "Panic", args };
+    }
+  } catch {
+  }
+  for (const { name, iface } of ERROR_IFACES) {
+    try {
+      const parsed = iface.parseError(data);
+      if (parsed) {
+        const args = parsed.args ? Array.from(parsed.args) : void 0;
+        return {
+          selector,
+          name: parsed.name,
+          args,
+          contract: name
+        };
+      }
+    } catch {
+    }
+  }
+  return { selector };
+}
+function classifyReadinessFromRevert(e) {
+  const r = decodeRevert(e);
+  const name = r?.name;
+  if (name && REVERT_TO_READINESS[name]) return REVERT_TO_READINESS[name];
+  const msg = (() => {
+    if (typeof e !== "object" || e === null) return "";
+    const obj = e;
+    const maybeMsg = obj["shortMessage"] ?? obj["message"];
+    return typeof maybeMsg === "string" ? maybeMsg : "";
+  })();
+  const lower = String(msg).toLowerCase();
+  if (lower.includes("paused")) return { kind: "NOT_READY", reason: "paused" };
+  if (name || r?.selector) {
+    return { kind: "UNFINALIZABLE", reason: "unsupported", detail: name ?? r?.selector };
+  }
+  return { kind: "NOT_READY", reason: "unknown", detail: lower || void 0 };
+}
+
+// src/adapters/ethers/errors/error-ops.ts
+var { toZKsyncError, createErrorHandlers } = createErrorOps(decodeRevert);
+
+// src/adapters/ethers/client.ts
+var { wrapAs, wrap } = createErrorHandlers("client");
+var ChainTypeManagerABI = [
+  "function getSemverProtocolVersion() view returns (uint32,uint32,uint32)"
+];
+function createEthersClient(args) {
+  const { l1, l2, signer } = args;
   let boundSigner = signer;
   const signerProvider = signer.provider;
   const isBrowserProvider = signerProvider instanceof ethers.BrowserProvider;
@@ -7336,11 +8089,10 @@ async function quoteL1Gas(input) {
     const est = await estimator.estimateGas(tx);
     const buffered = BigInt(est) * (100n + BUFFER) / 100n;
     return makeGasQuote({ gasLimit: buffered, maxFeePerGas, maxPriorityFeePerGas });
-  } catch (err) {
+  } catch {
     if (fallbackGasLimit != null) {
       return makeGasQuote({ gasLimit: fallbackGasLimit, maxFeePerGas, maxPriorityFeePerGas });
     }
-    console.warn("L1 gas estimation failed", err);
     return void 0;
   }
 }
@@ -7378,8 +8130,7 @@ async function quoteL2Gas(input) {
       maxFeePerGas,
       gasPerPubdata: pp
     });
-  } catch (err) {
-    console.warn("L2 gas estimation failed", err);
+  } catch {
     return makeGasQuote({
       gasLimit: l2GasLimit ?? 0n,
       maxFeePerGas,
@@ -7542,8 +8293,22 @@ async function determineNonBaseL2Gas(input) {
   try {
     const l2TokenAddress = input.knownL2Token ?? (ctx.tokens ? await ctx.tokens.toL2Address(l1Token) : await (await ctx.contracts.l2NativeTokenVault()).l2TokenAddress(l1Token));
     if (l2TokenAddress === ZERO_L2_TOKEN_ADDRESS) {
+      if (input.undeployedGasLimit != null) {
+        return quoteL2Gas2({
+          ctx,
+          route,
+          overrideGasLimit: input.undeployedGasLimit
+        });
+      }
       return fallbackQuote();
     }
+    if (input.priorityFloorGasLimit != null) {
+      return quoteL2Gas2({
+        ctx,
+        route,
+        overrideGasLimit: input.priorityFloorGasLimit
+      });
+    }
     const modelTx = {
       to: input.modelTx?.to ?? ctx.sender,
       from: input.modelTx?.from ?? ctx.sender,
@@ -7559,8 +8324,7 @@ async function determineNonBaseL2Gas(input) {
       return fallbackQuote();
     }
     return gas;
-  } catch (err) {
-    console.warn("Failed to determine non-base deposit L2 gas; defaulting to safe gas limit.", err);
+  } catch {
     return fallbackQuote();
   }
 }
@@ -7577,7 +8341,9 @@ async function determineEthNonBaseL2Gas(input) {
     route: "eth-nonbase",
     l1Token: input.ctx.resolvedToken?.l1 ?? FORMAL_ETH_ADDRESS,
     knownL2Token: input.ctx.resolvedToken?.l2,
-    modelTx: input.modelTx
+    modelTx: input.modelTx,
+    priorityFloorGasLimit: input.priorityFloorGasLimit,
+    undeployedGasLimit: input.undeployedGasLimit
   });
 }
 
@@ -7609,41 +8375,112 @@ function buildFeeBreakdown(p) {
   };
 }
 
+// src/core/resources/deposits/priority.ts
+var PRIORITY_TX_ENCODING_STEP_BYTES = 544n;
+var DEFAULT_PRIORITY_BODY_GAS_ESTIMATE_MULTIPLIER = 6n;
+var maxBigInt = (a, b) => a > b ? a : b;
+var ceilDiv = (a, b) => (a + b - 1n) / b;
+function derivePriorityTxGasBreakdown(input) {
+  const factoryDepsCount = input.factoryDepsCount ?? 0n;
+  const minBodyGas = maxBigInt(
+    L1_TX_INTRINSIC_L2_GAS + ceilDiv(
+      input.encodedLength * L1_TX_DELTA_544_ENCODING_BYTES,
+      PRIORITY_TX_ENCODING_STEP_BYTES
+    ) + factoryDepsCount * L1_TX_DELTA_FACTORY_DEPS_L2_GAS,
+    L1_TX_MIN_L2_GAS_BASE
+  ) + L1_TX_INTRINSIC_PUBDATA * input.gasPerPubdata + factoryDepsCount * L1_TX_DELTA_FACTORY_DEPS_PUBDATA * input.gasPerPubdata;
+  const overhead = maxBigInt(TX_SLOT_OVERHEAD_L2_GAS, TX_MEMORY_OVERHEAD_GAS * input.encodedLength);
+  const derivedBodyGas = minBodyGas;
+  return {
+    encodedLength: input.encodedLength,
+    minBodyGas,
+    overhead,
+    derivedBodyGas,
+    derivedL2GasLimit: derivedBodyGas + overhead,
+    priorityTxMaxGasLimit: PRIORITY_TX_MAX_GAS_LIMIT,
+    priorityTxMaxGasLimitExceeded: derivedBodyGas > PRIORITY_TX_MAX_GAS_LIMIT
+  };
+}
+function derivePriorityBodyGasEstimateCap(input) {
+  return input.minBodyGas * (input.multiplier ?? DEFAULT_PRIORITY_BODY_GAS_ESTIMATE_MULTIPLIER);
+}
+
+// src/adapters/ethers/resources/deposits/routes/priority.ts
+var EMPTY_BYTES = "0x";
+var ZERO_RESERVED_WORDS = [0n, 0n, 0n, 0n];
+var L2_CANONICAL_TRANSACTION_TUPLE = "tuple(uint256 txType,uint256 from,uint256 to,uint256 gasLimit,uint256 gasPerPubdataByteLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,uint256 paymaster,uint256 nonce,uint256 value,uint256[4] reserved,bytes data,bytes signature,uint256[] factoryDeps,bytes paymasterInput,bytes reservedDynamic)";
+function hexByteLength(hex) {
+  return BigInt(Math.max(hex.length - 2, 0) / 2);
+}
+function getPriorityTxEncodedLength(input) {
+  const encoded = ethers.AbiCoder.defaultAbiCoder().encode(
+    [L2_CANONICAL_TRANSACTION_TUPLE],
+    [
+      [
+        0n,
+        BigInt(input.sender),
+        BigInt(input.l2Contract),
+        0n,
+        input.gasPerPubdata,
+        0n,
+        0n,
+        0n,
+        0n,
+        input.l2Value,
+        ZERO_RESERVED_WORDS,
+        input.l2Calldata,
+        EMPTY_BYTES,
+        input.factoryDepsHashes ?? [],
+        EMPTY_BYTES,
+        EMPTY_BYTES
+      ]
+    ]
+  );
+  return hexByteLength(encoded);
+}
+function getPriorityTxGasBreakdown(input) {
+  return derivePriorityTxGasBreakdown({
+    encodedLength: getPriorityTxEncodedLength(input),
+    gasPerPubdata: input.gasPerPubdata,
+    factoryDepsCount: BigInt(input.factoryDepsHashes?.length ?? 0)
+  });
+}
+
 // src/adapters/ethers/resources/deposits/routes/eth.ts
+var EMPTY_BYTES2 = "0x";
 function routeEthDirect() {
   return {
     async build(p, ctx) {
       const bh = await ctx.contracts.bridgehub();
-      const l2TxModel = {
-        to: p.to ?? ctx.sender,
-        from: ctx.sender,
-        data: "0x",
-        value: 0n
-      };
+      const l2Contract = p.to ?? ctx.sender;
+      const l2Value = p.amount;
+      const l2Calldata = EMPTY_BYTES2;
+      const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+        sender: ctx.sender,
+        l2Contract,
+        l2Value,
+        l2Calldata,
+        gasPerPubdata: ctx.gasPerPubdata
+      });
+      const quotedL2GasLimit = ctx.l2GasLimit ?? priorityFloorBreakdown.derivedL2GasLimit;
       const l2GasParams = await quoteL2Gas2({
         ctx,
         route: "eth-base",
-        l2TxForModeling: l2TxModel,
-        overrideGasLimit: ctx.l2GasLimit,
-        stateOverrides: {
-          [ctx.sender]: {
-            balance: "0xffffffffffffffffffff"
-          }
-        }
+        overrideGasLimit: quotedL2GasLimit
       });
       if (!l2GasParams) {
         throw new Error("Failed to estimate L2 gas for deposit.");
       }
       const baseCost = await quoteL2BaseCost2({ ctx, l2GasLimit: l2GasParams.gasLimit });
-      const mintValue = baseCost + ctx.operatorTip + p.amount;
+      const mintValue = baseCost + ctx.operatorTip + l2Value;
       const req = buildDirectRequestStruct({
         chainId: ctx.chainIdL2,
         mintValue,
         l2GasLimit: l2GasParams.gasLimit,
         gasPerPubdata: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
-        l2Contract: p.to ?? ctx.sender,
-        l2Value: p.amount
+        l2Contract,
+        l2Value
       });
       const data = bh.interface.encodeFunctionData("requestL2TransactionDirect", [req]);
       const l1TxCandidate = {
@@ -7688,6 +8525,53 @@ function routeEthDirect() {
   };
 }
 var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
+var ZERO_L2_TOKEN_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+var ZERO_ASSET_ID = "0x0000000000000000000000000000000000000000000000000000000000000000";
+async function getPriorityGasModel(input) {
+  try {
+    const l1NativeTokenVault = await input.ctx.contracts.l1NativeTokenVault();
+    const l1AssetRouter = await input.ctx.contracts.l1AssetRouter();
+    const { chainId: l1ChainId } = await input.ctx.client.l1.getNetwork();
+    const isFirstBridge = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID || input.ctx.resolvedToken.originChainId === 0n;
+    const erc20MetadataOriginChainId = isFirstBridge ? BigInt(l1ChainId) : input.ctx.resolvedToken.originChainId;
+    const erc20Metadata = await l1NativeTokenVault.getERC20Getters(
+      input.token,
+      erc20MetadataOriginChainId
+    );
+    const bridgeMintCalldata = ethers.AbiCoder.defaultAbiCoder().encode(
+      ["address", "address", "address", "uint256", "bytes"],
+      [input.ctx.sender, input.receiver, input.token, input.amount, erc20Metadata]
+    );
+    const l2Calldata = isFirstBridge ? new ethers.Interface(IL2AssetRouter_default).encodeFunctionData(
+      "finalizeDeposit(address,address,address,uint256,bytes)",
+      [input.ctx.sender, input.receiver, input.token, input.amount, erc20Metadata]
+    ) : await (() => {
+      return l1AssetRouter.getDepositCalldata(
+        input.ctx.sender,
+        input.ctx.resolvedToken.assetId,
+        bridgeMintCalldata
+      );
+    })();
+    const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+      sender: input.ctx.l1AssetRouter,
+      l2Contract: L2_ASSET_ROUTER_ADDRESS,
+      l2Value: 0n,
+      l2Calldata,
+      gasPerPubdata: input.ctx.gasPerPubdata
+    });
+    const model = {
+      priorityFloorGasLimit: priorityFloorBreakdown.derivedL2GasLimit
+    };
+    if (isFirstBridge || input.ctx.resolvedToken.l2.toLowerCase() === ZERO_L2_TOKEN_ADDRESS2) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeErc20NonBase() {
   return {
     async preflight(p, ctx) {
@@ -7708,11 +8592,29 @@ function routeErc20NonBase() {
       const l1Signer = ctx.client.getL1Signer();
       const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
       const baseIsEth = ctx.baseIsEth ?? isETH(baseToken);
+      const receiver = p.to ?? ctx.sender;
+      const secondBridgeCalldata = await wrapAs3(
+        "INTERNAL",
+        OP_DEPOSITS.nonbase.encodeCalldata,
+        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, receiver)),
+        {
+          ctx: { where: "encodeSecondBridgeErc20Args" },
+          message: "Failed to encode bridging calldata."
+        }
+      );
+      const priorityGasModel = await getPriorityGasModel({
+        ctx,
+        token: p.token,
+        amount: p.amount,
+        receiver
+      });
       const l2GasParams = await determineErc20L2Gas({
         ctx,
         l1Token: p.token,
+        priorityFloorGasLimit: priorityGasModel.priorityFloorGasLimit,
+        undeployedGasLimit: priorityGasModel.undeployedGasLimit,
         modelTx: {
-          to: p.to ?? ctx.sender,
+          to: receiver,
           from: ctx.sender,
           data: "0x",
           value: 0n
@@ -7774,15 +8676,6 @@ function routeErc20NonBase() {
           });
         }
       }
-      const secondBridgeCalldata = await wrapAs3(
-        "INTERNAL",
-        OP_DEPOSITS.nonbase.encodeCalldata,
-        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, p.to ?? ctx.sender)),
-        {
-          ctx: { where: "encodeSecondBridgeErc20Args" },
-          message: "Failed to encode bridging calldata."
-        }
-      );
       const requestStruct = {
         chainId: ctx.chainIdL2,
         mintValue,
@@ -7839,7 +8732,68 @@ function routeErc20NonBase() {
     }
   };
 }
+
+// src/core/codec/ntv.ts
+function createNTVCodec(deps) {
+  function encodeAssetId(originChainId, ntvAddress, tokenAddress) {
+    const encoded = deps.encode(
+      ["uint256", "address", "address"],
+      [originChainId, ntvAddress, tokenAddress]
+    );
+    return deps.keccak256(encoded);
+  }
+  return {
+    encodeAssetId
+  };
+}
+
+// src/adapters/ethers/resources/deposits/routes/eth-nonbase.ts
 var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
+var ZERO_L2_TOKEN_ADDRESS3 = "0x0000000000000000000000000000000000000000";
+var ZERO_ASSET_ID2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var ntvCodec = createNTVCodec({
+  encode: (types, values) => ethers.AbiCoder.defaultAbiCoder().encode(types, values),
+  keccak256: (data) => ethers.keccak256(data)
+});
+async function getPriorityGasModel2(input) {
+  try {
+    const l1AssetRouter = await input.ctx.contracts.l1AssetRouter();
+    const l1NativeTokenVault = await input.ctx.contracts.l1NativeTokenVault();
+    const originChainId = input.ctx.resolvedToken.originChainId !== 0n ? input.ctx.resolvedToken.originChainId : BigInt((await input.ctx.client.l1.getNetwork()).chainId);
+    const resolvedAssetId = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID2 ? ntvCodec.encodeAssetId(originChainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, ETH_ADDRESS) : input.ctx.resolvedToken.assetId;
+    const erc20Metadata = await l1NativeTokenVault.getERC20Getters(
+      ETH_ADDRESS,
+      originChainId
+    );
+    const bridgeMintCalldata = ethers.AbiCoder.defaultAbiCoder().encode(
+      ["address", "address", "address", "uint256", "bytes"],
+      [input.ctx.sender, input.receiver, ETH_ADDRESS, input.amount, erc20Metadata]
+    );
+    const l2Calldata = await l1AssetRouter.getDepositCalldata(
+      input.ctx.sender,
+      resolvedAssetId,
+      bridgeMintCalldata
+    );
+    const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+      sender: input.ctx.l1AssetRouter,
+      l2Contract: L2_ASSET_ROUTER_ADDRESS,
+      l2Value: 0n,
+      l2Calldata,
+      gasPerPubdata: input.ctx.gasPerPubdata
+    });
+    const model = {
+      priorityFloorGasLimit: priorityFloorBreakdown.derivedL2GasLimit
+    };
+    if (input.ctx.resolvedToken.l2.toLowerCase() === ZERO_L2_TOKEN_ADDRESS3) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeEthNonBase() {
   return {
     async preflight(p, ctx) {
@@ -7888,15 +8842,23 @@ function routeEthNonBase() {
     async build(p, ctx) {
       const l1Signer = ctx.client.getL1Signer();
       const baseToken = ctx.baseTokenL1;
+      const receiver = p.to ?? ctx.sender;
+      const priorityGasModel = await getPriorityGasModel2({
+        ctx,
+        amount: p.amount,
+        receiver
+      });
       const l2TxModel = {
-        to: p.to ?? ctx.sender,
+        to: receiver,
         from: ctx.sender,
         data: "0x",
         value: 0n
       };
       const l2GasParams = await determineEthNonBaseL2Gas({
         ctx,
-        modelTx: l2TxModel
+        modelTx: l2TxModel,
+        priorityFloorGasLimit: priorityGasModel.priorityFloorGasLimit,
+        undeployedGasLimit: priorityGasModel.undeployedGasLimit
       });
       if (!l2GasParams) throw new Error("Failed to estimate L2 gas parameters.");
       const baseCost = await quoteL2BaseCost2({ ctx, l2GasLimit: l2GasParams.gasLimit });
@@ -7930,12 +8892,12 @@ function routeEthNonBase() {
       const secondBridgeCalldata = await wrapAs4(
         "INTERNAL",
         OP_DEPOSITS.ethNonBase.encodeCalldata,
-        () => Promise.resolve(encodeSecondBridgeEthArgs(p.amount, p.to ?? ctx.sender)),
+        () => Promise.resolve(encodeSecondBridgeEthArgs(p.amount, receiver)),
         {
           ctx: {
             where: "encodeSecondBridgeEthArgs",
             amount: p.amount.toString(),
-            to: p.to ?? ctx.sender
+            to: receiver
           }
         }
       );
@@ -7996,6 +8958,7 @@ function routeEthNonBase() {
   };
 }
 var { wrapAs: wrapAs5 } = createErrorHandlers("deposits");
+var EMPTY_BYTES3 = "0x";
 function routeErc20Base() {
   return {
     async preflight(p, ctx) {
@@ -8026,17 +8989,21 @@ function routeErc20Base() {
     async build(p, ctx) {
       const l1Signer = ctx.client.getL1Signer();
       const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
-      const l2TxModel = {
-        to: p.to ?? ctx.sender,
-        from: ctx.sender,
-        data: "0x",
-        value: 0n
-      };
+      const l2Contract = p.to ?? ctx.sender;
+      const l2Value = p.amount;
+      const l2Calldata = EMPTY_BYTES3;
+      const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+        sender: ctx.sender,
+        l2Contract,
+        l2Value,
+        l2Calldata,
+        gasPerPubdata: ctx.gasPerPubdata
+      });
+      const quotedL2GasLimit = ctx.l2GasLimit ?? priorityFloorBreakdown.derivedL2GasLimit;
       const l2GasParams = await quoteL2Gas2({
         ctx,
         route: "erc20-base",
-        l2TxForModeling: l2TxModel,
-        overrideGasLimit: ctx.l2GasLimit
+        overrideGasLimit: quotedL2GasLimit
       });
       if (!l2GasParams) throw new Error("Failed to estimate L2 gas parameters.");
       const baseCost = await quoteL2BaseCost2({ ctx, l2GasLimit: l2GasParams.gasLimit });
@@ -8075,8 +9042,8 @@ function routeErc20Base() {
         l2GasLimit: l2GasParams.gasLimit,
         gasPerPubdata: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
-        l2Contract: p.to ?? ctx.sender,
-        l2Value: p.amount
+        l2Contract,
+        l2Value
       });
       const bridgehub = await ctx.contracts.bridgehub();
       const data = bridgehub.interface.encodeFunctionData("requestL2TransactionDirect", [
@@ -8123,25 +9090,9 @@ function routeErc20Base() {
     }
   };
 }
-
-// src/core/codec/ntv.ts
-function createNTVCodec(deps) {
-  function encodeAssetId(originChainId, ntvAddress, tokenAddress) {
-    const encoded = deps.encode(
-      ["uint256", "address", "address"],
-      [originChainId, ntvAddress, tokenAddress]
-    );
-    return deps.keccak256(encoded);
-  }
-  return {
-    encodeAssetId
-  };
-}
-
-// src/adapters/ethers/resources/tokens/tokens.ts
 var { wrapAs: wrapAs6 } = createErrorHandlers("tokens");
 var abi = ethers.AbiCoder.defaultAbiCoder();
-var ntvCodec = createNTVCodec({
+var ntvCodec2 = createNTVCodec({
   encode: (types, values) => abi.encode(types, values),
   keccak256: (data) => ethers.ethers.keccak256(data)
 });
@@ -8260,7 +9211,7 @@ function createTokensResource(client) {
     return wrapAs6("CONTRACT", "tokens.isChainEthBased", async () => {
       const baseAssetId = await getBaseTokenAssetId();
       const l1ChainId = await getL1ChainId();
-      const ethAssetId = ntvCodec.encodeAssetId(
+      const ethAssetId = ntvCodec2.encodeAssetId(
         l1ChainId,
         L2_NATIVE_TOKEN_VAULT_ADDRESS,
         ETH_ADDRESS
@@ -9271,7 +10222,7 @@ var ROUTES2 = {
 };
 function createWithdrawalsResource(client, tokens, contracts) {
   const svc = createFinalizationServices(client);
-  const { wrap: wrap7, toResult: toResult3 } = createErrorHandlers("withdrawals");
+  const { wrap: wrap8, toResult: toResult3 } = createErrorHandlers("withdrawals");
   const tokensResource = tokens ?? createTokensResource(client);
   const contractsResource = contracts ?? createContractsResource(client);
   async function buildPlan(p) {
@@ -9292,7 +10243,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
     };
   }
   const finalizeCache = /* @__PURE__ */ new Map();
-  const quote = (p) => wrap7(
+  const quote = (p) => wrap8(
     OP_WITHDRAWALS.quote,
     async () => {
       const plan = await buildPlan(p);
@@ -9314,7 +10265,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
       ctx: { token: p.token, where: "withdrawals.tryQuote" }
     }
   );
-  const prepare = (p) => wrap7(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
+  const prepare = (p) => wrap8(OP_WITHDRAWALS.prepare, () => buildPlan(p), {
     message: "Internal error while preparing a withdrawal plan.",
     ctx: { token: p.token, where: "withdrawals.prepare" }
   });
@@ -9322,7 +10273,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
     message: "Internal error while preparing a withdrawal plan.",
     ctx: { token: p.token, where: "withdrawals.tryPrepare" }
   });
-  const create = (p) => wrap7(
+  const create = (p) => wrap8(
     OP_WITHDRAWALS.create,
     async () => {
       const plan = await prepare(p);
@@ -9393,7 +10344,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
     message: "Internal error while creating withdrawal transactions.",
     ctx: { token: p.token, amount: p.amount, to: p.to, where: "withdrawals.tryCreate" }
   });
-  const status = (h) => wrap7(
+  const status = (h) => wrap8(
     OP_WITHDRAWALS.status,
     async () => {
       const l2TxHash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
@@ -9448,7 +10399,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
   const wait = (h, opts = {
     for: "l2",
     pollMs: 5500
-  }) => wrap7(
+  }) => wrap8(
     OP_WITHDRAWALS.wait,
     async () => {
       const l2Hash = typeof h === "string" ? h : "l2TxHash" in h && h.l2TxHash ? h.l2TxHash : "0x";
@@ -9513,7 +10464,7 @@ function createWithdrawalsResource(client, tokens, contracts) {
       }
     }
   );
-  const finalize = (l2TxHash) => wrap7(
+  const finalize = (l2TxHash) => wrap8(
     OP_WITHDRAWALS.finalize.send,
     async () => {
       const pack = await (async () => {
@@ -9639,9 +10590,11 @@ function createCallAttributes(codec) {
 function createBundleAttributes(codec) {
   const executionAddress = (executor) => codec.encode("executionAddress", [executor]);
   const unbundlerAddress = (addr) => codec.encode("unbundlerAddress", [addr]);
+  const useFixedFee = (enabled) => codec.encode("useFixedFee", [enabled]);
   return {
     executionAddress,
-    unbundlerAddress
+    unbundlerAddress,
+    useFixedFee
   };
 }
 
@@ -9662,6 +10615,7 @@ function getInteropAttributes(params, ctx) {
   if (params.unbundling?.by) {
     bundleAttributes.push(ctx.attributes.bundle.unbundlerAddress(params.unbundling.by));
   }
+  bundleAttributes.push(ctx.attributes.bundle.useFixedFee(params.fee?.useFixed ?? false));
   const callAttributes = params.actions.map((action) => {
     switch (action.type) {
       case "sendNative": {
@@ -9691,11 +10645,6 @@ function createEthersAttributesResource(opts = {}) {
 }
 
 // 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;
@@ -9704,7 +10653,7 @@ function isInteropMessageProof(obj) {
 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);
+  return isHash66(info.l2SrcTxHash) && isHash66(info.bundleHash) && isBigint(info.dstChainId) && isHash(info.encodedData) && isInteropMessageProof(info.proof);
 }
 
 // src/core/resources/interop/route.ts
@@ -9757,7 +10706,7 @@ function preflightDirect(params, ctx) {
     }
   }
 }
-function buildDirectBundle(params, ctx, attrs) {
+function buildDirectBundle(params, ctx, attrs, interopFeeInfo) {
   const totalActionValue = sumActionMsgValue(params.actions);
   const starters = params.actions.map((action, index) => {
     const to = ctx.codec.formatAddress(action.to);
@@ -9775,7 +10724,8 @@ function buildDirectBundle(params, ctx, attrs) {
     dstChain: ctx.codec.formatChain(ctx.dstChainId),
     starters,
     bundleAttributes: attrs.bundleAttributes,
-    approvals: [],
+    approvals: interopFeeInfo.approval ? [interopFeeInfo.approval] : [],
+    interopFee: interopFeeInfo.fee,
     quoteExtras: {
       totalActionValue,
       bridgedTokenTotal: 0n
@@ -9820,7 +10770,7 @@ function preflightIndirect(params, ctx) {
     }
   }
 }
-function buildIndirectBundle(params, ctx, attrs, starterData) {
+function buildIndirectBundle(params, ctx, attrs, starterData, interopFeeInfo) {
   const totalActionValue = sumActionMsgValue(params.actions);
   const bridgedTokenTotal = sumErc20Amounts(params.actions);
   const approvalMap = /* @__PURE__ */ new Map();
@@ -9839,6 +10789,7 @@ function buildIndirectBundle(params, ctx, attrs, starterData) {
     }
   }
   const approvals = Array.from(approvalMap.values());
+  if (interopFeeInfo.approval) approvals.push(interopFeeInfo.approval);
   const starters = params.actions.map((action, index) => {
     const callAttributes = attrs.callAttributes[index] ?? [];
     if (starterData[index]?.assetRouterPayload) {
@@ -9862,6 +10813,7 @@ function buildIndirectBundle(params, ctx, attrs, starterData) {
     starters,
     bundleAttributes: attrs.bundleAttributes,
     approvals,
+    interopFee: interopFeeInfo.fee,
     quoteExtras: {
       totalActionValue,
       bridgedTokenTotal
@@ -9908,6 +10860,29 @@ function buildEnsureTokenSteps(erc20Tokens, ctx) {
     }
   }));
 }
+async function buildApproveSteps(approvals, ctx) {
+  const steps = [];
+  for (const approval of approvals) {
+    const erc20 = new ethers.Contract(approval.token, IERC20_default, ctx.client.l2);
+    const currentAllowance = await erc20.allowance(ctx.sender, approval.spender);
+    if (currentAllowance < approval.amount) {
+      steps.push({
+        key: `approve:${approval.token}:${approval.spender}`,
+        kind: "approve",
+        description: `Approve ${approval.spender} to spend ${approval.amount} of ${approval.token}`,
+        tx: {
+          to: approval.token,
+          data: erc20.interface.encodeFunctionData("approve", [
+            approval.spender,
+            approval.amount
+          ]),
+          ...ctx.gasOverrides
+        }
+      });
+    }
+  }
+  return steps;
+}
 async function resolveErc20AssetIds(erc20Tokens, ctx) {
   const assetIds = /* @__PURE__ */ new Map();
   if (erc20Tokens.length === 0) return assetIds;
@@ -9961,6 +10936,44 @@ async function getStarterData(params, ctx, erc20AssetIds) {
   }
   return starterData;
 }
+var { wrap: wrap3 } = createErrorHandlers("interop");
+async function buildFeeInfo(params, ctx, numStarters) {
+  const useFixed = params.fee?.useFixed ?? false;
+  const interopCenter = new ethers.Contract(ctx.interopCenter, IInteropCenter_default, ctx.client.l2);
+  if (useFixed) {
+    const zkFeePerCall = await wrap3(
+      OP_INTEROP.svc.fees.zkInteropFee,
+      () => interopCenter.ZK_INTEROP_FEE(),
+      { message: "Failed to fetch ZK interop fee from InteropCenter." }
+    );
+    const zkFeeTotal = zkFeePerCall * BigInt(numStarters);
+    const zkTokenAddress = await wrap3(
+      OP_INTEROP.svc.fees.zkToken,
+      () => interopCenter.zkToken(),
+      { message: "Failed to fetch ZK token address from InteropCenter." }
+    );
+    const approval = {
+      token: zkTokenAddress,
+      spender: ctx.interopCenter,
+      amount: zkFeeTotal
+    };
+    return {
+      approval,
+      fee: { token: zkTokenAddress, amount: zkFeeTotal }
+    };
+  } else {
+    const protocolFeePerCall = await wrap3(
+      OP_INTEROP.svc.fees.protocolFee,
+      () => interopCenter.interopProtocolFee(),
+      { message: "Failed to fetch interop protocol fee from InteropCenter." }
+    );
+    const totalFee = protocolFeePerCall * BigInt(numStarters);
+    return {
+      approval: null,
+      fee: { token: ctx.baseTokens.src, amount: totalFee }
+    };
+  }
+}
 
 // src/adapters/ethers/resources/interop/routes/indirect.ts
 function routeIndirect() {
@@ -9976,7 +10989,10 @@ function routeIndirect() {
     async build(params, ctx) {
       const steps = [];
       const erc20Tokens = getErc20Tokens(params);
-      const erc20AssetIds = await resolveErc20AssetIds(erc20Tokens, ctx);
+      const [erc20AssetIds, feeInfo] = await Promise.all([
+        resolveErc20AssetIds(erc20Tokens, ctx),
+        buildFeeInfo(params, ctx, params.actions.length)
+      ]);
       const attributes = getInteropAttributes(params, ctx);
       const starterData = await getStarterData(params, ctx, erc20AssetIds);
       const bundle = buildIndirectBundle(
@@ -9989,32 +11005,11 @@ function routeIndirect() {
           codec: interopCodec
         },
         attributes,
-        starterData
+        starterData,
+        feeInfo
       );
       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
-            }
-          });
-        }
-      }
+      steps.push(...await buildApproveSteps(bundle.approvals, ctx));
       const data = ctx.ifaces.interopCenter.encodeFunctionData("sendBundle", [
         bundle.dstChain,
         bundle.starters,
@@ -10027,14 +11022,15 @@ function routeIndirect() {
         tx: {
           to: ctx.interopCenter,
           data,
-          value: bundle.quoteExtras.totalActionValue,
+          value: bundle.quoteExtras.totalActionValue + feeInfo.fee.amount,
           ...ctx.gasOverrides
         }
       });
       return {
         steps,
         approvals: bundle.approvals,
-        quoteExtras: bundle.quoteExtras
+        quoteExtras: bundle.quoteExtras,
+        interopFee: feeInfo.fee
       };
     }
   };
@@ -10051,10 +11047,10 @@ function routeDirect() {
         l2AssetRouter: ctx.l2AssetRouter,
         l2NativeTokenVault: ctx.l2NativeTokenVault});
     },
-    // eslint-disable-next-line @typescript-eslint/require-await
     async build(params, ctx) {
       const steps = [];
       const attrs = getInteropAttributes(params, ctx);
+      const feeInfo = await buildFeeInfo(params, ctx, params.actions.length);
       const built = buildDirectBundle(
         params,
         {
@@ -10064,8 +11060,10 @@ function routeDirect() {
           l2NativeTokenVault: ctx.l2NativeTokenVault,
           codec: interopCodec
         },
-        attrs
+        attrs,
+        feeInfo
       );
+      steps.push(...await buildApproveSteps(built.approvals, ctx));
       const data = ctx.ifaces.interopCenter.encodeFunctionData("sendBundle", [
         built.dstChain,
         built.starters,
@@ -10075,19 +11073,19 @@ function routeDirect() {
         key: "sendBundle",
         kind: "interop.center",
         description: `Send interop bundle (direct route; ${params.actions.length} actions)`,
-        // In direct route, msg.value equals the total forwarded value across
-        // all calls (sendNative.amount + call.value).
+        // msg.value = forwarded action value + protocol fee.
         tx: {
           to: ctx.interopCenter,
           data,
-          value: built.quoteExtras.totalActionValue,
+          value: built.quoteExtras.totalActionValue + feeInfo.fee.amount,
           ...ctx.gasOverrides
         }
       });
       return {
         steps,
         approvals: built.approvals,
-        quoteExtras: built.quoteExtras
+        quoteExtras: built.quoteExtras,
+        interopFee: feeInfo.fee
       };
     }
   };
@@ -10167,7 +11165,7 @@ function getTopics() {
   };
   return { topics, centerIface };
 }
-var { wrap: wrap3 } = createErrorHandlers("interop");
+var { wrap: wrap4 } = createErrorHandlers("interop");
 var DEFAULT_BLOCKS_RANGE_SIZE = 1e4;
 var DEFAULT_MAX_BLOCKS_BACK = 2e4;
 var SAFE_BLOCKS_RANGE_SIZE = 1e3;
@@ -10180,7 +11178,7 @@ function parseMaxBlockRangeLimit(error) {
   return Number.isInteger(limit) && limit > 0 ? limit : null;
 }
 async function getTxReceipt(provider, txHash) {
-  const receipt = await wrap3(
+  const receipt = await wrap4(
     OP_INTEROP.svc.status.sourceReceipt,
     () => provider.getTransactionReceipt(txHash),
     {
@@ -10201,7 +11199,7 @@ async function getTxReceipt(provider, txHash) {
 async function getLogs(provider, address, topics, opts) {
   const maxBlocksBack = opts?.maxBlocksBack ?? DEFAULT_MAX_BLOCKS_BACK;
   const initialChunkSize = opts?.logChunkSize ?? DEFAULT_BLOCKS_RANGE_SIZE;
-  return await wrap3(
+  return await wrap4(
     OP_INTEROP.svc.status.dstLogs,
     async () => {
       const currentBlock = await provider.getBlockNumber();
@@ -10248,7 +11246,7 @@ async function getLogs(provider, address, topics, opts) {
   );
 }
 async function getInteropRoot(provider, rootChainId, batchNumber) {
-  return await wrap3(
+  return await wrap4(
     OP_INTEROP.svc.status.getRoot,
     async () => {
       const rootStorage = new ethers.Contract(
@@ -10266,7 +11264,7 @@ async function getInteropRoot(provider, rootChainId, batchNumber) {
 }
 
 // src/adapters/ethers/resources/interop/services/finalization/bundle.ts
-var { wrap: wrap4 } = createErrorHandlers("interop");
+var { wrap: wrap5 } = createErrorHandlers("interop");
 async function getBundleStatus(client, dstProvider, topics, bundleHash, opts) {
   const { interopHandler } = await client.ensureAddresses();
   const bundleLogs = await getLogs(dstProvider, interopHandler, [null, bundleHash], opts);
@@ -10298,7 +11296,7 @@ async function executeBundle(client, dstProvider, info, opts) {
       context: { bundleHash }
     });
   }
-  const signer = await wrap4(OP_INTEROP.exec.sendStep, () => client.signerFor(dstProvider), {
+  const signer = await wrap5(OP_INTEROP.exec.sendStep, () => client.signerFor(dstProvider), {
     message: "Failed to resolve destination signer."
   });
   const { interopHandler } = await client.ensureAddresses();
@@ -10460,11 +11458,6 @@ function getBundleEncodedData(messageData) {
   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,
@@ -10480,7 +11473,6 @@ function buildFinalizationInfo(ids, bundleInfo, proof, messageData) {
     l2SrcTxHash: ids.l2SrcTxHash,
     bundleHash: bundleInfo.bundleHash,
     dstChainId: bundleInfo.dstChainId,
-    expectedRoot,
     proof: messageProof,
     encodedData: getBundleEncodedData(messageData)
   };
@@ -10503,7 +11495,7 @@ function decodeL1MessageData(log) {
 }
 
 // src/adapters/ethers/resources/interop/services/finalization/polling.ts
-var { wrap: wrap5 } = createErrorHandlers("interop");
+var { wrap: wrap6 } = createErrorHandlers("interop");
 function isProofNotReadyError(error) {
   return isZKsyncError(error, {
     operation: "zksrpc.getL2ToL1LogProof",
@@ -10540,30 +11532,26 @@ async function waitForProof(client, l2SrcTxHash, logIndex, blockNumber, pollMs,
       });
     }
     try {
-      return await client.zks.getL2ToL1LogProof(l2SrcTxHash, logIndex);
+      return await client.zks.getL2ToL1LogProof(l2SrcTxHash, logIndex, "messageRoot" /* MessageRoot */);
     } catch (error) {
       if (!isProofNotReadyError(error)) throw error;
     }
     await sleep(pollMs);
   }
 }
-async function waitForRoot(provider, expectedRoot, pollMs, deadline) {
+async function waitForRoot(provider, chainId, batchNumber, pollMs, deadline) {
   while (true) {
     if (Date.now() > deadline) {
       throw createError("TIMEOUT", {
         resource: "interop",
         operation: OP_INTEROP.svc.wait.timeout,
         message: "Timed out waiting for interop root to become available.",
-        context: { expectedRoot }
+        context: { chainId, batchNumber }
       });
     }
     let interopRoot = null;
     try {
-      const root = await getInteropRoot(
-        provider,
-        expectedRoot.rootChainId,
-        expectedRoot.batchNumber
-      );
+      const root = await getInteropRoot(provider, chainId, batchNumber);
       if (root !== ZERO_HASH) {
         interopRoot = root;
       }
@@ -10572,18 +11560,7 @@ async function waitForRoot(provider, expectedRoot, pollMs, deadline) {
       interopRoot = null;
     }
     if (interopRoot) {
-      if (interopRoot.toLowerCase() === expectedRoot.expectedRoot.toLowerCase()) {
-        return;
-      }
-      throw createError("STATE", {
-        resource: "interop",
-        operation: OP_INTEROP.wait,
-        message: "Interop root mismatch.",
-        context: {
-          expected: expectedRoot.expectedRoot,
-          got: interopRoot
-        }
-      });
+      return interopRoot;
     }
     await sleep(pollMs);
   }
@@ -10598,7 +11575,7 @@ async function waitForTxReceipt(client, txHash, pollMs, deadline) {
         context: { txHash }
       });
     }
-    const receipt = await wrap5(
+    const receipt = await wrap6(
       OP_INTEROP.svc.status.sourceReceipt,
       () => client.zks.getReceiptWithL2ToL1(txHash),
       {
@@ -10612,7 +11589,7 @@ async function waitForTxReceipt(client, txHash, pollMs, deadline) {
     await sleep(pollMs);
   }
 }
-async function waitForFinalization(client, dstProvider, input, opts) {
+async function waitForFinalization(client, dstProvider, gwProvider, input, opts) {
   const { topics, centerIface } = getTopics();
   const pollMs = opts?.pollMs ?? DEFAULT_POLL_MS;
   const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -10661,7 +11638,16 @@ async function waitForFinalization(client, dstProvider, input, opts) {
     proof,
     bundleInfo.l1MessageData
   );
-  await waitForRoot(dstProvider, finalizationInfo.expectedRoot, pollMs, deadline);
+  if (proof.gatewayBlockNumber == null) {
+    throw createError("STATE", {
+      resource: "interop",
+      operation: OP_INTEROP.svc.wait.timeout,
+      message: "Proof missing gatewayBlockNumber required for interop finalization.",
+      context: { l2SrcTxHash: ids.l2SrcTxHash }
+    });
+  }
+  const { chainId: gwChainId } = await gwProvider.getNetwork();
+  await waitForRoot(dstProvider, gwChainId, proof.gatewayBlockNumber, pollMs, deadline);
   return finalizationInfo;
 }
 
@@ -10707,8 +11693,8 @@ function createInteropFinalizationServices(client) {
     status(dstProvider, input, opts) {
       return getStatus(client, dstProvider, input, opts);
     },
-    wait(dstProvider, input, opts) {
-      return waitForFinalization(client, dstProvider, input, opts);
+    wait(dstProvider, gwProvider, input, opts) {
+      return waitForFinalization(client, dstProvider, gwProvider, input, opts);
     },
     async finalize(dstProvider, info, opts) {
       const execResult = await executeBundle(client, dstProvider, info, opts);
@@ -10720,24 +11706,31 @@ function createInteropFinalizationServices(client) {
     }
   };
 }
-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
-  };
+function resolveChainRef(ref) {
+  return typeof ref === "string" ? new ethers.JsonRpcProvider(ref) : ref;
 }
 
 // src/adapters/ethers/resources/interop/index.ts
-var { wrap: wrap6, toResult: toResult2 } = createErrorHandlers("interop");
+var { wrap: wrap7, toResult: toResult2 } = createErrorHandlers("interop");
 var ROUTES3 = {
   direct: routeDirect(),
   indirect: routeIndirect()
 };
-function createInteropResource(client, tokens, contracts, attributes) {
+function createInteropResource(client, config, tokens, contracts, attributes) {
+  let gwProviderCache;
+  function requireConfig() {
+    if (!config)
+      throw createError("STATE", {
+        resource: "interop",
+        operation: "interop.init",
+        message: "Interop is not configured. Pass gwChain in createEthersSdk options."
+      });
+    return config;
+  }
+  function getGwProvider() {
+    if (!gwProviderCache) gwProviderCache = resolveChainRef(requireConfig().gwChain);
+    return gwProviderCache;
+  }
   const svc = createInteropFinalizationServices(client);
   const tokensResource = tokens ?? createTokensResource(client);
   const contractsResource = contracts ?? createContractsResource(client);
@@ -10761,11 +11754,11 @@ function createInteropResource(client, tokens, contracts, attributes) {
         baseTokenDst: ctx.baseTokens.dst
       }
     });
-    await wrap6(OP_INTEROP.routes[route].preflight, () => ROUTES3[route].preflight?.(params, ctx), {
+    await wrap7(OP_INTEROP.routes[route].preflight, () => ROUTES3[route].preflight?.(params, ctx), {
       message: "Interop preflight failed.",
       ctx: { where: `routes.${route}.preflight` }
     });
-    const { steps, approvals, quoteExtras } = await wrap6(
+    const { steps, approvals, quoteExtras, interopFee } = await wrap7(
       OP_INTEROP.routes[route].build,
       () => ROUTES3[route].build(params, ctx),
       {
@@ -10777,7 +11770,8 @@ function createInteropResource(client, tokens, contracts, attributes) {
       route,
       approvalsNeeded: approvals,
       totalActionValue: quoteExtras.totalActionValue,
-      bridgedTokenTotal: quoteExtras.bridgedTokenTotal
+      bridgedTokenTotal: quoteExtras.bridgedTokenTotal,
+      interopFee
     };
     return { plan: { route, summary, steps }, ctx };
   }
@@ -10785,20 +11779,23 @@ function createInteropResource(client, tokens, contracts, attributes) {
     const { plan } = await buildPlanWithCtx(dstProvider, params);
     return plan;
   }
-  const quote = (params) => wrap6(OP_INTEROP.quote, async () => {
-    const plan = await buildPlan(resolveDstProvider(params.dstChain), params);
+  const quote = (dstChain, params) => wrap7(OP_INTEROP.quote, async () => {
+    const plan = await buildPlan(resolveChainRef(dstChain), params);
     return plan.summary;
   });
-  const tryQuote = (params) => toResult2(OP_INTEROP.tryQuote, () => quote(params));
-  const prepare = (params) => wrap6(OP_INTEROP.prepare, () => buildPlan(resolveDstProvider(params.dstChain), params), {
+  const tryQuote = (dstChain, params) => toResult2(OP_INTEROP.tryQuote, () => quote(dstChain, params));
+  const prepare = (dstChain, params) => wrap7(OP_INTEROP.prepare, () => buildPlan(resolveChainRef(dstChain), params), {
     message: "Internal error while preparing an interop plan.",
     ctx: { where: "interop.prepare" }
   });
-  const tryPrepare = (params) => toResult2(OP_INTEROP.tryPrepare, () => prepare(params));
-  const create = (params) => wrap6(
+  const tryPrepare = (dstChain, params) => toResult2(
+    OP_INTEROP.tryPrepare,
+    () => prepare(dstChain, params)
+  );
+  const create = (dstChain, params) => wrap7(
     OP_INTEROP.create,
     async () => {
-      const { plan, ctx } = await buildPlanWithCtx(resolveDstProvider(params.dstChain), params);
+      const { plan, ctx } = await buildPlanWithCtx(resolveChainRef(dstChain), params);
       const signer = ctx.client.signerFor(ctx.client.l2);
       const srcProvider = ctx.client.l2;
       const from = await signer.getAddress();
@@ -10841,23 +11838,25 @@ function createInteropResource(client, tokens, contracts, attributes) {
           }
         } catch (e) {
           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)
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "interop",
+              operation: "interop.create.sendTransaction",
+              message: "Failed to send or confirm an interop transaction step.",
+              context: {
+                step: step.key,
+                txHash: hash,
+                nonce: Number(step.tx.nonce ?? -1)
+              }
             },
-            cause: e
-          });
+            e
+          );
         }
       }
       const last = Object.values(stepHashes).pop();
       return {
         kind: "interop",
-        dstChain: params.dstChain,
         stepHashes,
         plan,
         l2SrcTxHash: last ?? "0x"
@@ -10868,46 +11867,27 @@ function createInteropResource(client, tokens, contracts, attributes) {
       ctx: { where: "interop.create" }
     }
   );
-  const tryCreate = (params) => toResult2(OP_INTEROP.tryCreate, () => create(params));
-  const status = (h, opts) => {
-    const { dstProvider, waitable } = resolveWaitableInput(h);
-    return wrap6(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 wrap6(
-      OP_INTEROP.wait,
-      async () => {
-        const info = await svc.wait(dstProvider, waitable, opts);
-        return { ...info, dstChain: h.dstChain };
-      },
-      {
-        message: "Internal error while waiting for interop finalization.",
-        ctx: { where: "interop.wait" }
-      }
-    );
-  };
-  const tryWait = (h, opts) => toResult2(OP_INTEROP.tryWait, () => wait(h, opts));
-  const finalize = (h, opts) => wrap6(
+  const tryCreate = (dstChain, params) => toResult2(
+    OP_INTEROP.tryCreate,
+    () => create(dstChain, params)
+  );
+  const status = (dstChain, h, opts) => wrap7(OP_INTEROP.status, () => svc.status(resolveChainRef(dstChain), h, opts), {
+    message: "Internal error while checking interop status.",
+    ctx: { where: "interop.status" }
+  });
+  const wait = (dstChain, h, opts) => wrap7(OP_INTEROP.wait, () => svc.wait(resolveChainRef(dstChain), getGwProvider(), h, opts), {
+    message: "Internal error while waiting for interop finalization.",
+    ctx: { where: "interop.wait" }
+  });
+  const tryWait = (dstChain, h, opts) => toResult2(OP_INTEROP.tryWait, () => wait(dstChain, h, opts));
+  const finalize = (dstChain, h, opts) => wrap7(
     OP_INTEROP.finalize,
     async () => {
+      const dstProvider = resolveChainRef(dstChain);
       if (isInteropFinalizationInfo(h)) {
-        if (h.dstChain == null) {
-          throw createError("STATE", {
-            resource: "interop",
-            operation: OP_INTEROP.finalize,
-            message: "Missing dstChain in interop finalization info.",
-            context: { input: h }
-          });
-        }
-        const dstProvider2 = resolveDstProvider(h.dstChain);
-        return svc.finalize(dstProvider2, h, opts);
+        return svc.finalize(dstProvider, h, opts);
       }
-      const { dstProvider, waitable } = resolveWaitableInput(h);
-      const info = await svc.wait(dstProvider, waitable);
+      const info = await svc.wait(dstProvider, getGwProvider(), h);
       return svc.finalize(dstProvider, info, opts);
     },
     {
@@ -10915,7 +11895,7 @@ function createInteropResource(client, tokens, contracts, attributes) {
       ctx: { where: "interop.finalize" }
     }
   );
-  const tryFinalize = (h, opts) => toResult2(OP_INTEROP.tryFinalize, () => finalize(h, opts));
+  const tryFinalize = (dstChain, h, opts) => toResult2(OP_INTEROP.tryFinalize, () => finalize(dstChain, h, opts));
   return {
     quote,
     tryQuote,
@@ -10932,10 +11912,10 @@ function createInteropResource(client, tokens, contracts, attributes) {
 }
 
 // src/adapters/ethers/sdk.ts
-function createEthersSdk(client) {
+function createEthersSdk(client, options) {
   const tokens = createTokensResource(client);
   const contracts = createContractsResource(client);
-  const interop = createInteropResource(client);
+  const interop = createInteropResource(client, options?.interop, tokens, contracts);
   return {
     deposits: createDepositsResource(client, tokens, contracts),
     withdrawals: createWithdrawalsResource(client, tokens, contracts),