@matterlabs/zksync-js 0.0.7 → 0.0.9

package/dist/adapters/ethers/client.cjs

@@ -11,6 +11,20 @@ function makeTransportFromEthers(provider) {
   return (m, p = []) => provider.send(m, p);
 }
 
+// src/core/utils/number.ts
+var isNumber = (x) => typeof x === "number" && Number.isFinite(x);
+var isBigint = (x) => typeof x === "bigint";
+var k256hex = (s) => `0x${utils.bytesToHex(sha3.keccak_256(utils.utf8ToBytes(s)))}`.toLowerCase();
+var FORMAL_ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+var L2_ASSET_ROUTER_ADDRESS = "0x0000000000000000000000000000000000010003";
+var L2_NATIVE_TOKEN_VAULT_ADDRESS = "0x0000000000000000000000000000000000010004";
+var L2_BASE_TOKEN_ADDRESS = "0x000000000000000000000000000000000000800A";
+var L2_INTEROP_CENTER_ADDRESS = "0x000000000000000000000000000000000001000d";
+var L2_INTEROP_HANDLER_ADDRESS = "0x000000000000000000000000000000000001000e";
+var L2_MESSAGE_VERIFICATION_ADDRESS = "0x0000000000000000000000000000000000010009";
+k256hex("L1MessageSent(uint256,bytes32,bytes)");
+k256hex("L1MessageSent(address,bytes32,bytes)");
+
 // src/core/errors/formatter.ts
 function elideMiddle(s, max = 96) {
   if (s.length <= max) return s;
@@ -21,7 +35,7 @@ function shortJSON(v, max = 240) {
   try {
     const s = JSON.stringify(
       v,
-      (_k, val) => typeof val === "bigint" ? `${val.toString()}n` : val
+      (_k, val) => isBigint(val) ? `${val.toString()}n` : val
     );
     return s.length > max ? elideMiddle(s, max) : s;
   } catch {
@@ -41,7 +55,7 @@ function formatContextLine(ctx) {
   if (txHash !== void 0)
     parts.push(`txHash=${typeof txHash === "string" ? txHash : shortJSON(txHash, 96)}`);
   if (nonce !== void 0) {
-    const nonceStr = typeof nonce === "string" || typeof nonce === "number" || typeof nonce === "bigint" ? String(nonce) : shortJSON(nonce, 48);
+    const nonceStr = typeof nonce === "string" || isNumber(nonce) || isBigint(nonce) ? String(nonce) : shortJSON(nonce, 48);
     parts.push(`nonce=${nonceStr}`);
   }
   return parts.length ? `  ${kv("Context", parts.join("  \u2022  "))}` : void 0;
@@ -71,17 +85,17 @@ function formatCause(c) {
     const head = [];
     if (obj.name !== void 0) {
       const nameVal = obj.name;
-      const nameStr = typeof nameVal === "string" || typeof nameVal === "number" || typeof nameVal === "bigint" || typeof nameVal === "boolean" ? String(nameVal) : shortJSON(nameVal, 120);
+      const nameStr = typeof nameVal === "string" || isNumber(nameVal) || isBigint(nameVal) || typeof nameVal === "boolean" ? String(nameVal) : shortJSON(nameVal, 120);
       head.push(`name=${nameStr}`);
     }
     if (obj.code !== void 0) {
       const codeVal = obj.code;
-      const codeStr = typeof codeVal === "string" || typeof codeVal === "number" || typeof codeVal === "bigint" || typeof codeVal === "boolean" ? String(codeVal) : shortJSON(codeVal, 120);
+      const codeStr = typeof codeVal === "string" || isNumber(codeVal) || isBigint(codeVal) || typeof codeVal === "boolean" ? String(codeVal) : shortJSON(codeVal, 120);
       head.push(`code=${codeStr}`);
     }
     if (head.length) out.push(`  ${kv("Cause", head.join("  "))}`);
     if (obj.message) {
-      const messageStr = typeof obj.message === "string" || typeof obj.message === "number" || typeof obj.message === "bigint" || typeof obj.message === "boolean" ? String(obj.message) : shortJSON(obj.message, 600);
+      const messageStr = typeof obj.message === "string" || isNumber(obj.message) || isBigint(obj.message) || typeof obj.message === "boolean" ? String(obj.message) : shortJSON(obj.message, 600);
       out.push(`              message=${elideMiddle(messageStr, 600)}`);
     }
     if (obj.data) {
@@ -144,13 +158,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;
+  return true;
 }
+var OP_CLIENT = {
+  ensureAddresses: "client.ensureAddresses",
+  getSemverProtocolVersion: "client.getSemverProtocolVersion"
+};
 var OP_DEPOSITS = {
   base: {
     baseToken: "deposits.erc20-base:baseToken"}};
@@ -160,20 +179,20 @@ function createError(type, input) {
   return new ZKsyncError({ ...input, type });
 }
 function shapeCause(err) {
-  const isRecord = (x) => x !== null && typeof x === "object";
+  const isRecord2 = (x) => x !== null && typeof x === "object";
   let data = void 0;
-  if (isRecord(err)) {
+  if (isRecord2(err)) {
     const r2 = err;
     const d = r2.data;
-    if (isRecord(d) && "data" in d) {
+    if (isRecord2(d) && "data" in d) {
       data = d.data;
-    } else if ("error" in r2 && isRecord(r2.error) && "data" in r2.error) {
+    } else if ("error" in r2 && isRecord2(r2.error) && "data" in r2.error) {
       data = r2.error.data;
     } else if ("data" in r2) {
       data = r2.data;
     }
   }
-  const r = isRecord(err) ? err : void 0;
+  const r = isRecord2(err) ? err : void 0;
   const name = r && typeof r.name === "string" ? r.name : void 0;
   const message = r && typeof r.message === "string" ? r.message : r && typeof r.shortMessage === "string" ? r.shortMessage : void 0;
   const code = r && "code" in r ? r.code : void 0;
@@ -227,7 +246,7 @@ function normalizeProof(p) {
         context: { keys: Object.keys(raw ?? {}) }
       });
     }
-    const toBig = (x) => typeof x === "bigint" ? x : typeof x === "number" ? BigInt(x) : typeof x === "string" ? BigInt(x) : (() => {
+    const toBig = (x) => isBigint(x) ? x : isNumber(x) ? BigInt(x) : typeof x === "string" ? BigInt(x) : (() => {
       throw createError("RPC", {
         resource: "zksrpc",
         operation: "zksrpc.normalizeProof",
@@ -238,7 +257,8 @@ function normalizeProof(p) {
     return {
       id: toBig(idRaw),
       batchNumber: toBig(bnRaw),
-      proof: toHexArray(raw?.proof)
+      proof: toHexArray(raw?.proof),
+      root: raw.root
     };
   } catch (e) {
     if (isZKsyncError(e)) throw e;
@@ -263,8 +283,8 @@ function ensureHex(value, field, context) {
 function ensureNumber(value, field, opts) {
   const operation = opts?.operation ?? "zksrpc.normalizeGenesis";
   const messagePrefix = opts?.messagePrefix ?? "Malformed genesis response";
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "bigint") return Number(value);
+  if (isNumber(value)) return value;
+  if (isBigint(value)) return Number(value);
   if (typeof value === "string" && value.trim() !== "") {
     const parsed = Number(value);
     if (Number.isFinite(parsed)) return parsed;
@@ -279,8 +299,8 @@ function ensureNumber(value, field, opts) {
 function ensureBigInt(value, field, opts) {
   const operation = opts?.operation ?? "zksrpc.normalizeBlockMetadata";
   const messagePrefix = opts?.messagePrefix ?? "Malformed block metadata response";
-  if (typeof value === "bigint") return value;
-  if (typeof value === "number" && Number.isFinite(value)) {
+  if (isBigint(value)) return value;
+  if (isNumber(value)) {
     if (!Number.isInteger(value)) {
       throw createError("RPC", {
         resource: "zksrpc",
@@ -304,6 +324,9 @@ function ensureBigInt(value, field, opts) {
     context: { field, valueType: typeof value }
   });
 }
+function isRecord(x) {
+  return !!x && typeof x === "object" && !Array.isArray(x);
+}
 function normalizeContractTuple(tuple, index) {
   if (!Array.isArray(tuple) || tuple.length < 2) {
     throw createError("RPC", {
@@ -319,7 +342,7 @@ function normalizeContractTuple(tuple, index) {
     bytecode: ensureHex(bytecodeRaw, "initial_contracts.bytecode", { index })
   };
 }
-function normalizeStorageTuple(tuple, index) {
+function normalizeRawStorageTuple(tuple, index) {
   if (!Array.isArray(tuple) || tuple.length < 2) {
     throw createError("RPC", {
       resource: "zksrpc",
@@ -330,10 +353,53 @@ function normalizeStorageTuple(tuple, index) {
   }
   const [keyRaw, valueRaw] = tuple;
   return {
+    format: "raw",
     key: ensureHex(keyRaw, "additional_storage.key", { index }),
     value: ensureHex(valueRaw, "additional_storage.value", { index })
   };
 }
+function normalizeAdditionalStorage(value, record) {
+  const effective = value ?? record["additional_storage_raw"];
+  if (Array.isArray(effective)) {
+    return effective.map((entry, index) => {
+      const kv2 = normalizeRawStorageTuple(entry, index);
+      return { format: "raw", key: kv2.key, value: kv2.value };
+    });
+  }
+  if (isRecord(effective)) {
+    const out = [];
+    for (const [addrRaw, slotsRaw] of Object.entries(effective)) {
+      const address = ensureHex(addrRaw, "additional_storage.address", {});
+      if (!isRecord(slotsRaw)) {
+        throw createError("RPC", {
+          resource: "zksrpc",
+          operation: "zksrpc.normalizeGenesis",
+          message: "Malformed genesis response: additional_storage[address] must be an object map.",
+          context: { address, valueType: typeof slotsRaw }
+        });
+      }
+      for (const [slotRaw, valRaw] of Object.entries(slotsRaw)) {
+        out.push({
+          format: "pretty",
+          address,
+          key: ensureHex(slotRaw, "additional_storage.key", { address }),
+          value: ensureHex(valRaw, "additional_storage.value", { address, key: slotRaw })
+        });
+      }
+    }
+    return out;
+  }
+  throw createError("RPC", {
+    resource: "zksrpc",
+    operation: "zksrpc.normalizeGenesis",
+    message: "Malformed genesis response: additional_storage must be an array (raw) or an object map (pretty).",
+    context: {
+      valueType: typeof effective,
+      hasAdditionalStorage: "additional_storage" in record,
+      hasAdditionalStorageRaw: "additional_storage_raw" in record
+    }
+  });
+}
 function normalizeGenesis(raw) {
   try {
     if (!raw || typeof raw !== "object") {
@@ -354,21 +420,12 @@ function normalizeGenesis(raw) {
         context: { valueType: typeof contractsRaw }
       });
     }
-    const storageRaw = record["additional_storage"];
-    if (!Array.isArray(storageRaw)) {
-      throw createError("RPC", {
-        resource: "zksrpc",
-        operation: "zksrpc.normalizeGenesis",
-        message: "Malformed genesis response: additional_storage must be an array.",
-        context: { valueType: typeof storageRaw }
-      });
-    }
     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)
     );
-    const additionalStorage = storageRaw.map((entry, index) => normalizeStorageTuple(entry, index));
+    const additionalStorage = normalizeAdditionalStorage(record["additional_storage"], record);
     return {
       initialContracts,
       additionalStorage,
@@ -553,12 +610,6 @@ function zksRpcFromEthers(l2Provider) {
   }
   return createZksRpc(makeTransportFromEthers(maybe));
 }
-var k256hex = (s) => `0x${utils.bytesToHex(sha3.keccak_256(utils.utf8ToBytes(s)))}`.toLowerCase();
-var L2_ASSET_ROUTER_ADDRESS = "0x0000000000000000000000000000000000010003";
-var L2_NATIVE_TOKEN_VAULT_ADDRESS = "0x0000000000000000000000000000000000010004";
-var L2_BASE_TOKEN_ADDRESS = "0x000000000000000000000000000000000000800A";
-k256hex("L1MessageSent(uint256,bytes32,bytes)");
-k256hex("L1MessageSent(address,bytes32,bytes)");
 
 // src/core/internal/abis/IBridgehub.ts
 var IBridgehubABI = [
@@ -5048,232 +5099,1581 @@ var MailboxABI = [
 ];
 var Mailbox_default = MailboxABI;
 
-// 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/InteropCenter.ts
+var InteropCenterABI = [
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
       }
-    }
-    function wrap(operation, fn, opts) {
-      return run("INTERNAL", operation, fn, opts);
-    }
-    function wrapAs2(kind, operation, fn, opts) {
-      return run(kind, operation, fn, opts);
-    }
-    async function toResult(operation, fn, opts) {
-      try {
-        const value = await wrap(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 };
+    ],
+    name: "AttributeAlreadySet",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      },
+      {
+        internalType: "uint256",
+        name: "restriction",
+        type: "uint256"
       }
-    }
-    return { wrap, wrapAs: wrapAs2, toResult };
-  }
-  return { toZKsyncError: toZKsyncError2, createErrorHandlers: createErrorHandlers2 };
-}
-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 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
-        };
+    ],
+    name: "AttributeViolatesRestriction",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "expected",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "actual",
+        type: "uint256"
       }
-    } catch {
-    }
-  }
-  return { selector };
-}
-
-// src/adapters/ethers/errors/error-ops.ts
-var { createErrorHandlers } = createErrorOps(decodeRevert);
-
-// src/adapters/ethers/client.ts
-var { wrapAs } = createErrorHandlers("client");
-function createEthersClient(args) {
-  const { l1, l2, signer } = args;
-  let boundSigner = signer;
-  const signerProvider = signer.provider;
-  const isBrowserProvider = signerProvider instanceof ethers.BrowserProvider;
-  if (!isBrowserProvider && (!boundSigner.provider || boundSigner.provider !== l1)) {
-    boundSigner = signer.connect(l1);
-  } else if (isBrowserProvider && signerProvider) {
-    void (async () => {
-      try {
-        const [signerNet, l1Net] = await Promise.all([
-          signerProvider.getNetwork(),
-          l1.getNetwork()
-        ]);
-        if (signerNet.chainId !== l1Net.chainId) {
-          const warning = createError("STATE", {
-            message: `BrowserProvider signer chainId (${signerNet.chainId}) != L1 provider chainId (${l1Net.chainId}). Ensure the wallet is connected to the correct network.`,
-            resource: "helpers",
-            operation: "client.browserProvider.networkMismatch",
-            context: {
-              signerChainId: signerNet.chainId,
-              l1ChainId: l1Net.chainId
-            }
-          });
-          console.debug("[zksync-sdk] non-fatal warning:", warning);
-        }
-      } catch (e) {
+    ],
+    name: "IndirectCallValueMismatch",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "interoperableAddress",
+        type: "bytes"
       }
-    })();
-  }
-  const zks = zksRpcFromEthers(l2);
-  let addrCache;
-  let cCache;
-  async function ensureAddresses() {
-    if (addrCache) return addrCache;
-    const bridgehub = args.overrides?.bridgehub ?? await zks.getBridgehubAddress();
-    const IBridgehub = new ethers.Interface(IBridgehub_default);
-    const bh = new ethers.Contract(bridgehub, IBridgehub, l1);
-    const l1AssetRouter = args.overrides?.l1AssetRouter ?? await bh.assetRouter();
-    const IL1AssetRouter = new ethers.Interface(IL1AssetRouter_default);
-    const ar = new ethers.Contract(l1AssetRouter, IL1AssetRouter, l1);
-    const l1Nullifier = args.overrides?.l1Nullifier ?? await ar.L1_NULLIFIER();
-    const IL1Nullifier = new ethers.Interface(IL1Nullifier_default);
-    const nf = new ethers.Contract(l1Nullifier, IL1Nullifier, l1);
-    const l1NativeTokenVault = args.overrides?.l1NativeTokenVault ?? await nf.l1NativeTokenVault();
-    const l2AssetRouter = args.overrides?.l2AssetRouter ?? L2_ASSET_ROUTER_ADDRESS;
-    const l2NativeTokenVault = args.overrides?.l2NativeTokenVault ?? L2_NATIVE_TOKEN_VAULT_ADDRESS;
-    const l2BaseTokenSystem = args.overrides?.l2BaseTokenSystem ?? L2_BASE_TOKEN_ADDRESS;
-    addrCache = {
-      bridgehub,
-      l1AssetRouter,
-      l1Nullifier,
-      l1NativeTokenVault,
-      l2AssetRouter,
-      l2NativeTokenVault,
-      l2BaseTokenSystem
-    };
-    return addrCache;
-  }
-  async function contracts() {
-    if (cCache) return cCache;
-    const a = await ensureAddresses();
-    cCache = {
-      bridgehub: new ethers.Contract(a.bridgehub, IBridgehub_default, l1),
-      l1AssetRouter: new ethers.Contract(a.l1AssetRouter, IL1AssetRouter_default, l1),
-      l1Nullifier: new ethers.Contract(a.l1Nullifier, IL1Nullifier_default, l1),
-      l1NativeTokenVault: new ethers.Contract(a.l1NativeTokenVault, L1NativeTokenVault_default, l1),
-      l2AssetRouter: new ethers.Contract(a.l2AssetRouter, IL2AssetRouter_default, l2),
-      l2NativeTokenVault: new ethers.Contract(a.l2NativeTokenVault, L2NativeTokenVault_default, l2),
-      l2BaseTokenSystem: new ethers.Contract(a.l2BaseTokenSystem, IBaseToken_default, l2)
-    };
-    return cCache;
-  }
-  function refresh() {
-    addrCache = void 0;
-    cCache = void 0;
-  }
-  function resolveSignerFor(provider) {
-    const signerProvider2 = boundSigner.provider;
-    if (signerProvider2 === provider) {
-      return boundSigner;
-    }
-    if (!isBrowserProvider && typeof boundSigner.connect === "function") {
-      return boundSigner.connect(provider);
-    }
-    if (!signerProvider2) {
-      throw createError("STATE", {
-        resource: "helpers",
-        message: "Signer has no associated provider; cannot resolve requested signer.",
-        operation: "client.resolveSignerFor"
+    ],
+    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/L2MessageVerification.ts
+var L2MessageVerificationABI = [
+  {
+    inputs: [],
+    name: "DepthMoreThanOneForRecursiveMerkleProof",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "HashedLogIsDefault",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidProofLengthForFinalNode",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "MerkleIndexOutOfBounds",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "MerklePathEmpty",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "MerklePathOutOfBounds",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "metadataVersion",
+        type: "uint256"
+      }
+    ],
+    name: "UnsupportedProofMetadataVersion",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "chainId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l2BatchNumber",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l2MessageIndex",
+            type: "uint256"
+          },
+          {
+            internalType: "address",
+            name: "l2Sender",
+            type: "address"
+          },
+          {
+            internalType: "uint16",
+            name: "l2TxNumberInBatch",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes",
+            name: "message",
+            type: "bytes"
+          },
+          {
+            internalType: "bytes32[]",
+            name: "merkleProof",
+            type: "bytes32[]"
+          }
+        ],
+        internalType: "struct FinalizeL1DepositParams",
+        name: "_finalizeWithdrawalParams",
+        type: "tuple"
+      }
+    ],
+    name: "proveL1DepositParamsInclusion",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "success",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "_l2TxHash",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint256",
+        name: "_l2BatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_l2MessageIndex",
+        type: "uint256"
+      },
+      {
+        internalType: "uint16",
+        name: "_l2TxNumberInBatch",
+        type: "uint16"
+      },
+      {
+        internalType: "bytes32[]",
+        name: "_merkleProof",
+        type: "bytes32[]"
+      },
+      {
+        internalType: "enum TxStatus",
+        name: "_status",
+        type: "uint8"
+      }
+    ],
+    name: "proveL1ToL2TransactionStatusShared",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_blockOrBatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_leafProofMask",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "_leaf",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32[]",
+        name: "_proof",
+        type: "bytes32[]"
+      }
+    ],
+    name: "proveL2LeafInclusionShared",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_blockOrBatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_leafProofMask",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "_leaf",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32[]",
+        name: "_proof",
+        type: "bytes32[]"
+      },
+      {
+        internalType: "uint256",
+        name: "_depth",
+        type: "uint256"
+      }
+    ],
+    name: "proveL2LeafInclusionSharedRecursive",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_blockOrBatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_index",
+        type: "uint256"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "l2ShardId",
+            type: "uint8"
+          },
+          {
+            internalType: "bool",
+            name: "isService",
+            type: "bool"
+          },
+          {
+            internalType: "uint16",
+            name: "txNumberInBatch",
+            type: "uint16"
+          },
+          {
+            internalType: "address",
+            name: "sender",
+            type: "address"
+          },
+          {
+            internalType: "bytes32",
+            name: "key",
+            type: "bytes32"
+          },
+          {
+            internalType: "bytes32",
+            name: "value",
+            type: "bytes32"
+          }
+        ],
+        internalType: "struct L2Log",
+        name: "_log",
+        type: "tuple"
+      },
+      {
+        internalType: "bytes32[]",
+        name: "_proof",
+        type: "bytes32[]"
+      }
+    ],
+    name: "proveL2LogInclusionShared",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_blockOrBatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_index",
+        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[]"
+      }
+    ],
+    name: "proveL2MessageInclusionShared",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var L2MessageVerification_default = L2MessageVerificationABI;
+
+// 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 wrap2(operation, fn, opts) {
+      return run("INTERNAL", operation, fn, opts);
+    }
+    function wrapAs2(kind, operation, fn, opts) {
+      return run(kind, operation, fn, opts);
+    }
+    async function toResult(operation, fn, opts) {
+      try {
+        const value = await wrap2(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: wrap2, wrapAs: wrapAs2, toResult };
+  }
+  return { toZKsyncError: toZKsyncError2, createErrorHandlers: createErrorHandlers2 };
+}
+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 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 };
+}
+
+// src/adapters/ethers/errors/error-ops.ts
+var { 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;
+  if (!isBrowserProvider && (!boundSigner.provider || boundSigner.provider !== l1)) {
+    boundSigner = signer.connect(l1);
+  } else if (isBrowserProvider && signerProvider) {
+    void (async () => {
+      try {
+        const [signerNet, l1Net] = await Promise.all([
+          signerProvider.getNetwork(),
+          l1.getNetwork()
+        ]);
+        if (signerNet.chainId !== l1Net.chainId) {
+          const warning = createError("STATE", {
+            message: `BrowserProvider signer chainId (${signerNet.chainId}) != L1 provider chainId (${l1Net.chainId}). Ensure the wallet is connected to the correct network.`,
+            resource: "helpers",
+            operation: "client.browserProvider.networkMismatch",
+            context: {
+              signerChainId: signerNet.chainId,
+              l1ChainId: l1Net.chainId
+            }
+          });
+          console.debug("[zksync-sdk] non-fatal warning:", warning);
+        }
+      } catch (e) {
+      }
+    })();
+  }
+  const zks = zksRpcFromEthers(l2);
+  let addrCache;
+  let cCache;
+  async function ensureAddresses() {
+    if (addrCache) return addrCache;
+    return await wrap(
+      OP_CLIENT.ensureAddresses,
+      async () => {
+        const bridgehub = args.overrides?.bridgehub ?? await zks.getBridgehubAddress();
+        const IBridgehub = new ethers.Interface(IBridgehub_default);
+        const bh = new ethers.Contract(bridgehub, IBridgehub, l1);
+        const l1AssetRouter = args.overrides?.l1AssetRouter ?? await bh.assetRouter();
+        const IL1AssetRouter = new ethers.Interface(IL1AssetRouter_default);
+        const ar = new ethers.Contract(l1AssetRouter, IL1AssetRouter, l1);
+        const l1Nullifier = args.overrides?.l1Nullifier ?? await ar.L1_NULLIFIER();
+        const IL1Nullifier = new ethers.Interface(IL1Nullifier_default);
+        const nf = new ethers.Contract(l1Nullifier, IL1Nullifier, l1);
+        const l1NativeTokenVault = args.overrides?.l1NativeTokenVault ?? await nf.l1NativeTokenVault();
+        const l2AssetRouter = args.overrides?.l2AssetRouter ?? L2_ASSET_ROUTER_ADDRESS;
+        const l2NativeTokenVault = args.overrides?.l2NativeTokenVault ?? L2_NATIVE_TOKEN_VAULT_ADDRESS;
+        const l2BaseTokenSystem = args.overrides?.l2BaseTokenSystem ?? L2_BASE_TOKEN_ADDRESS;
+        const interopCenter = args.overrides?.interopCenter ?? L2_INTEROP_CENTER_ADDRESS;
+        const interopHandler = args.overrides?.interopHandler ?? L2_INTEROP_HANDLER_ADDRESS;
+        const l2MessageVerification = args.overrides?.l2MessageVerification ?? L2_MESSAGE_VERIFICATION_ADDRESS;
+        addrCache = {
+          bridgehub,
+          l1AssetRouter,
+          l1Nullifier,
+          l1NativeTokenVault,
+          l2AssetRouter,
+          l2NativeTokenVault,
+          l2BaseTokenSystem,
+          interopCenter,
+          interopHandler,
+          l2MessageVerification
+        };
+        return addrCache;
+      },
+      {
+        ctx: { where: "ensureAddresses" },
+        message: "Failed to ensure contract addresses."
+      }
+    );
+  }
+  async function contracts() {
+    if (cCache) return cCache;
+    const a = await ensureAddresses();
+    cCache = {
+      bridgehub: new ethers.Contract(a.bridgehub, IBridgehub_default, l1),
+      l1AssetRouter: new ethers.Contract(a.l1AssetRouter, IL1AssetRouter_default, l1),
+      l1Nullifier: new ethers.Contract(a.l1Nullifier, IL1Nullifier_default, l1),
+      l1NativeTokenVault: new ethers.Contract(a.l1NativeTokenVault, L1NativeTokenVault_default, l1),
+      l2AssetRouter: new ethers.Contract(a.l2AssetRouter, IL2AssetRouter_default, l2),
+      l2NativeTokenVault: new ethers.Contract(a.l2NativeTokenVault, L2NativeTokenVault_default, l2),
+      l2BaseTokenSystem: new ethers.Contract(a.l2BaseTokenSystem, IBaseToken_default, l2),
+      interopCenter: new ethers.Contract(a.interopCenter, InteropCenter_default, l2),
+      interopHandler: new ethers.Contract(a.interopHandler, IInteropHandler_default, l2),
+      l2MessageVerification: new ethers.Contract(a.l2MessageVerification, L2MessageVerification_default, l2)
+    };
+    return cCache;
+  }
+  function refresh() {
+    addrCache = void 0;
+    cCache = void 0;
+  }
+  function resolveSignerFor(provider) {
+    const signerProvider2 = boundSigner.provider;
+    if (signerProvider2 === provider) {
+      return boundSigner;
+    }
+    if (!isBrowserProvider && typeof boundSigner.connect === "function") {
+      return boundSigner.connect(provider);
+    }
+    if (!signerProvider2) {
+      throw createError("STATE", {
+        resource: "helpers",
+        message: "Signer has no associated provider; cannot resolve requested signer.",
+        operation: "client.resolveSignerFor"
       });
     }
     return boundSigner;
@@ -5282,10 +6682,54 @@ function createEthersClient(args) {
     const { bridgehub } = await ensureAddresses();
     const bh = new ethers.Contract(bridgehub, IBridgehub_default, l1);
     return await wrapAs("CONTRACT", OP_DEPOSITS.base.baseToken, () => bh.baseToken(chainId), {
-      ctx: { where: "bridgehub.baseToken", chainIdL2: chainId },
+      ctx: { where: "bridgehub.baseToken", chainId },
       message: "Failed to read base token."
     });
   }
+  async function getProtocolVersion(chainId) {
+    const targetChainId = chainId ?? (await l2.getNetwork()).chainId;
+    const { bridgehub } = await ensureAddresses();
+    const bh = new ethers.Contract(bridgehub, IBridgehub_default, l1);
+    const chainTypeManager = await wrapAs(
+      "CONTRACT",
+      OP_CLIENT.getSemverProtocolVersion,
+      () => bh.chainTypeManager(targetChainId),
+      {
+        ctx: { where: "bridgehub.chainTypeManager", bridgehub, chainId: targetChainId },
+        message: "Failed to read chain type manager."
+      }
+    );
+    if (chainTypeManager.toLowerCase() === FORMAL_ETH_ADDRESS) {
+      throw createError("STATE", {
+        resource: "client",
+        operation: OP_CLIENT.getSemverProtocolVersion,
+        message: "No registered chain type manager for the chain.",
+        context: { chainId }
+      });
+    }
+    const ctm = new ethers.Contract(chainTypeManager, ChainTypeManagerABI, l1);
+    const semver = await wrapAs(
+      "CONTRACT",
+      OP_CLIENT.getSemverProtocolVersion,
+      () => ctm.getSemverProtocolVersion(),
+      {
+        ctx: {
+          where: "chainTypeManager.getSemverProtocolVersion",
+          chainId: targetChainId,
+          chainTypeManager
+        },
+        message: "Failed to read semver protocol version."
+      }
+    );
+    return semver;
+  }
+  function signerFor(target) {
+    if (target === "l1") {
+      return boundSigner.provider === l1 ? boundSigner : boundSigner.connect(l1);
+    }
+    const provider = target ?? l2;
+    return boundSigner.provider === provider ? boundSigner : boundSigner.connect(provider);
+  }
   const client = {
     kind: "ethers",
     l1,
@@ -5301,7 +6745,9 @@ function createEthersClient(args) {
     ensureAddresses,
     contracts,
     refresh,
-    baseToken
+    baseToken,
+    getProtocolVersion,
+    signerFor
   };
   return client;
 }