@matterlabs/zksync-js 0.0.8 → 0.0.9

package/dist/adapters/ethers/client.cjs

@@ -15,9 +15,13 @@ function makeTransportFromEthers(provider) {
 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)");
 
@@ -154,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"}};
@@ -5090,243 +5099,1636 @@ 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"
-      });
-    }
-    return boundSigner;
-  }
-  async function baseToken(chainId) {
-    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 },
-      message: "Failed to read base token."
-    });
+    ],
+    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;
+  }
+  async function baseToken(chainId) {
+    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", 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",
@@ -5343,7 +6745,9 @@ function createEthersClient(args) {
     ensureAddresses,
     contracts,
     refresh,
-    baseToken
+    baseToken,
+    getProtocolVersion,
+    signerFor
   };
   return client;
 }