@matterlabs/zksync-js 0.0.13 → 0.0.15

package/dist/{chunk-HI64OOAR.js → chunk-HVHMLAYH.js}

@@ -1,4 +1,4 @@
-import { isETH, normalizeAddrEq } from './chunk-RI73VJSH.js';
+import { isETH, normalizeAddrEq } from './chunk-JXR5V5YK.js';
 
 // src/core/resources/deposits/route.ts
 async function pickDepositRoute(client, chainIdL2, token) {

package/dist/{chunk-2RIARDXZ.js → chunk-JHRYNLZG.js}

@@ -1,8 +1,8 @@
-import { createErrorHandlers } from './chunk-5R7L5NM5.js';
-import { createZksRpc, makeTransportFromViem } from './chunk-4S4XDA4N.js';
-import { OP_CLIENT, IBridgehub_default, IL1AssetRouter_default, IL1Nullifier_default, IBaseToken_default, L2NativeTokenVault_default, IL2AssetRouter_default, L1NativeTokenVault_default } from './chunk-RI73VJSH.js';
-import { L2_ASSET_ROUTER_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, L2_BASE_TOKEN_ADDRESS } from './chunk-QQ2OR434.js';
-import { getContract, createWalletClient } from 'viem';
+import { createErrorHandlers } from './chunk-YIWXIP2M.js';
+import { makeTransportFromViem } from './chunk-BWKWWLY4.js';
+import { OP_CLIENT, IBridgehub_default, IL1AssetRouter_default, IL1Nullifier_default, IBaseToken_default, L2NativeTokenVault_default, IL2AssetRouter_default, L1NativeTokenVault_default, createError, createZksRpc } from './chunk-JXR5V5YK.js';
+import { L2_ASSET_ROUTER_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_INTEROP_CENTER_ADDRESS, L2_INTEROP_HANDLER_ADDRESS, L2_MESSAGE_VERIFICATION_ADDRESS, FORMAL_ETH_ADDRESS } from './chunk-MT4X5FEO.js';
+import { getContract, createWalletClient, custom } from 'viem';
 
 // src/adapters/viem/rpc.ts
 function zksRpcFromViem(l2Client) {
@@ -14,6 +14,15 @@ function zksRpcFromViem(l2Client) {
 
 // src/adapters/viem/client.ts
 var { wrap } = createErrorHandlers("client");
+var ChainTypeManagerABI = [
+  {
+    type: "function",
+    name: "getSemverProtocolVersion",
+    inputs: [],
+    outputs: [{ type: "uint32" }, { type: "uint32" }, { type: "uint32" }],
+    stateMutability: "view"
+  }
+];
 function createViemClient(args) {
   const { l1, l2, l1Wallet, l2Wallet } = args;
   if (!l1Wallet.account) {
@@ -47,6 +56,9 @@ function createViemClient(args) {
         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,
@@ -54,7 +66,10 @@ function createViemClient(args) {
           l1NativeTokenVault,
           l2AssetRouter,
           l2NativeTokenVault,
-          l2BaseTokenSystem
+          l2BaseTokenSystem,
+          interopCenter,
+          interopHandler,
+          l2MessageVerification
         };
         return addrCache;
       },
@@ -104,13 +119,55 @@ function createViemClient(args) {
     });
     return token;
   }
+  async function getProtocolVersion(chainId) {
+    const targetChainId = chainId ?? BigInt(await l2.getChainId());
+    const { bridgehub } = await ensureAddresses();
+    const chainTypeManager = await wrap(
+      OP_CLIENT.getSemverProtocolVersion,
+      () => l1.readContract({
+        address: bridgehub,
+        abi: IBridgehub_default,
+        functionName: "chainTypeManager",
+        args: [targetChainId]
+      }),
+      {
+        ctx: { where: "bridgehub.chainTypeManager", bridgehub, chainId: targetChainId },
+        message: "Failed to read chain type manager."
+      }
+    );
+    if (chainTypeManager.toLowerCase() === FORMAL_ETH_ADDRESS.toLowerCase()) {
+      throw createError("STATE", {
+        resource: "client",
+        operation: OP_CLIENT.getSemverProtocolVersion,
+        message: "No registered chain type manager for the chain.",
+        context: { chainId }
+      });
+    }
+    const semver = await wrap(
+      OP_CLIENT.getSemverProtocolVersion,
+      () => l1.readContract({
+        address: chainTypeManager,
+        abi: ChainTypeManagerABI,
+        functionName: "getSemverProtocolVersion"
+      }),
+      {
+        ctx: {
+          where: "chainTypeManager.getSemverProtocolVersion",
+          chainId: targetChainId,
+          chainTypeManager
+        },
+        message: "Failed to read semver protocol version."
+      }
+    );
+    return semver;
+  }
   let lazyL2;
   function getL2Wallet() {
     if (l2Wallet) return l2Wallet;
     if (!lazyL2) {
       lazyL2 = createWalletClient({
         account: l1Wallet.account,
-        transport: l2.transport
+        transport: custom(l2.transport)
       });
     }
     return lazyL2;
@@ -127,6 +184,7 @@ function createViemClient(args) {
     contracts,
     refresh,
     baseToken,
+    getProtocolVersion,
     getL2Wallet
   };
 }

package/dist/{chunk-RI73VJSH.js → chunk-JXR5V5YK.js}

@@ -1,4 +1,4 @@
-import { __export, ETH_ADDRESS, FORMAL_ETH_ADDRESS, L2_BASE_TOKEN_ADDRESS } from './chunk-QQ2OR434.js';
+import { __export, ETH_ADDRESS, FORMAL_ETH_ADDRESS, L2_BASE_TOKEN_ADDRESS } from './chunk-MT4X5FEO.js';
 
 // src/core/internal/abis/IBridgehub.ts
 var IBridgehubABI = [
@@ -4449,6 +4449,11 @@ var IInteropCenterABI = [
             type: "uint256",
             internalType: "uint256"
           },
+          {
+            name: "destinationBaseTokenAssetId",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
           {
             name: "interopBundleSalt",
             type: "bytes32",
@@ -5447,56 +5452,69 @@ var IERC20_default = IERC20ABI;
 // src/core/internal/abis/IERC7786Attributes.ts
 var IERC7786AttributesABI = [
   {
+    type: "function",
+    name: "executionAddress",
     inputs: [
       {
-        internalType: "bytes",
         name: "_executionAddress",
-        type: "bytes"
+        type: "bytes",
+        internalType: "bytes"
       }
     ],
-    name: "executionAddress",
     outputs: [],
-    stateMutability: "pure",
-    type: "function"
+    stateMutability: "pure"
   },
   {
+    type: "function",
+    name: "indirectCall",
     inputs: [
       {
-        internalType: "uint256",
         name: "_indirectCallMessageValue",
-        type: "uint256"
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
-    name: "indirectCall",
     outputs: [],
-    stateMutability: "pure",
-    type: "function"
+    stateMutability: "pure"
   },
   {
+    type: "function",
+    name: "interopCallValue",
     inputs: [
       {
-        internalType: "uint256",
         name: "_interopCallValue",
-        type: "uint256"
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
-    name: "interopCallValue",
     outputs: [],
-    stateMutability: "pure",
-    type: "function"
+    stateMutability: "pure"
   },
   {
+    type: "function",
+    name: "unbundlerAddress",
     inputs: [
       {
-        internalType: "bytes",
         name: "_unbundlerAddress",
-        type: "bytes"
+        type: "bytes",
+        internalType: "bytes"
       }
     ],
-    name: "unbundlerAddress",
     outputs: [],
-    stateMutability: "pure",
-    type: "function"
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "useFixedFee",
+    inputs: [
+      {
+        name: "_useFixed",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [],
+    stateMutability: "pure"
   }
 ];
 var IERC7786Attributes_default = IERC7786AttributesABI;
@@ -7041,6 +7059,11 @@ var OP_INTEROP = {
     wait: {
       poll: "interop.svc.wait:poll",
       timeout: "interop.svc.wait:timeout"
+    },
+    fees: {
+      zkInteropFee: "interop.svc.fees:zkInteropFee",
+      zkToken: "interop.svc.fees:zkToken",
+      protocolFee: "interop.svc.fees:protocolFee"
     }
   }
 };
@@ -7055,20 +7078,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;
@@ -7080,4 +7103,417 @@ function shapeCause(err) {
   };
 }
 
-export { IBaseToken_default, IBridgehub_default, IERC20_default, IERC7786Attributes_default, IInteropCenter_default, IInteropErrors_default, IInteropHandler_default, IInteropRootStorage_default, IL1AssetRouter_default, IL1ContractErrors_default, IL1Nullifier_default, IL2AssetRouter_default, L1NativeTokenVault_default, L2MessageVerification_default, L2NativeTokenVault_default, Mailbox_default, OP_CLIENT, OP_DEPOSITS, OP_INTEROP, OP_WITHDRAWALS, abi_exports, assertNever, createError, factory_exports, formatEnvelopePretty, hexEq, isAddress, isAddressEq, isBigint, isETH, isHash, isHash66, isHash66Array, isHashArray, isNumber, isReceiptNotFound, isZKsyncError, normalizeAddrEq, normalizeL1Token, shapeCause, sleep };
+// src/core/rpc/zks.ts
+var zks_exports = {};
+__export(zks_exports, {
+  ProofTarget: () => ProofTarget,
+  createZksRpc: () => createZksRpc,
+  normalizeBlockMetadata: () => normalizeBlockMetadata,
+  normalizeGenesis: () => normalizeGenesis,
+  normalizeProof: () => normalizeProof
+});
+
+// src/core/errors/rpc.ts
+async function withRpcOp(operation, message, ctx, fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    if (isZKsyncError(e)) throw e;
+    throw createError("RPC", {
+      resource: "zksrpc",
+      operation,
+      message,
+      context: ctx,
+      cause: shapeCause(e)
+    });
+  }
+}
+
+// src/core/rpc/zks.ts
+var ProofTarget = /* @__PURE__ */ ((ProofTarget2) => {
+  ProofTarget2["L1BatchRoot"] = "l1BatchRoot";
+  ProofTarget2["MessageRoot"] = "messageRoot";
+  return ProofTarget2;
+})(ProofTarget || {});
+var METHODS = {
+  getBridgehub: "zks_getBridgehubContract",
+  getL2ToL1LogProof: "zks_getL2ToL1LogProof",
+  getReceipt: "eth_getTransactionReceipt",
+  getBytecodeSupplier: "zks_getBytecodeSupplierContract",
+  getBlockMetadataByNumber: "zks_getBlockMetadataByNumber",
+  getGenesis: "zks_getGenesis"
+};
+function toHexArray(arr) {
+  const list = Array.isArray(arr) ? arr : [];
+  return list.map((x) => x);
+}
+function normalizeProof(p) {
+  try {
+    const raw = p ?? {};
+    const idRaw = raw?.id ?? raw?.index;
+    const bnRaw = raw?.batch_number ?? raw?.batchNumber;
+    const gwBlockNumberRaw = raw?.gatewayBlockNumber;
+    if (idRaw == null || bnRaw == null) {
+      throw createError("RPC", {
+        resource: "zksrpc",
+        operation: "zksrpc.normalizeProof",
+        message: "Malformed proof: missing id or batch number.",
+        context: { keys: Object.keys(raw ?? {}) }
+      });
+    }
+    const toBig = (x) => isBigint(x) ? x : isNumber(x) ? BigInt(x) : typeof x === "string" ? BigInt(x) : (() => {
+      throw createError("RPC", {
+        resource: "zksrpc",
+        operation: "zksrpc.normalizeProof",
+        message: "Malformed proof: invalid numeric field.",
+        context: { valueType: typeof x }
+      });
+    })();
+    return {
+      id: toBig(idRaw),
+      batchNumber: toBig(bnRaw),
+      proof: toHexArray(raw?.proof),
+      root: raw.root,
+      gatewayBlockNumber: gwBlockNumberRaw != null ? toBig(gwBlockNumberRaw) : void 0
+    };
+  } catch (e) {
+    if (isZKsyncError(e)) throw e;
+    throw createError("RPC", {
+      resource: "zksrpc",
+      operation: "zksrpc.normalizeProof",
+      message: "Failed to normalize proof.",
+      context: { receivedType: typeof p },
+      cause: shapeCause(e)
+    });
+  }
+}
+function ensureHex(value, field, context) {
+  if (typeof value === "string" && value.startsWith("0x")) return value;
+  throw createError("RPC", {
+    resource: "zksrpc",
+    operation: "zksrpc.normalizeGenesis",
+    message: "Malformed genesis response: expected 0x-prefixed hex value.",
+    context: { field, valueType: typeof value, ...context }
+  });
+}
+function ensureNumber(value, field, opts) {
+  const operation = opts?.operation;
+  const messagePrefix = opts?.messagePrefix;
+  if (isNumber(value)) return value;
+  if (isBigint(value)) return Number(value);
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  throw createError("RPC", {
+    resource: "zksrpc",
+    operation,
+    message: `${messagePrefix}: expected numeric value.`,
+    context: { field, valueType: typeof value }
+  });
+}
+function ensureBigInt(value, field, opts) {
+  const operation = opts?.operation ?? "zksrpc.normalizeBlockMetadata";
+  const messagePrefix = opts?.messagePrefix ?? "Malformed block metadata response";
+  if (isBigint(value)) return value;
+  if (isNumber(value)) {
+    if (!Number.isInteger(value)) {
+      throw createError("RPC", {
+        resource: "zksrpc",
+        operation,
+        message: `${messagePrefix}: expected integer value.`,
+        context: { field, valueType: typeof value }
+      });
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    try {
+      return BigInt(value);
+    } catch {
+    }
+  }
+  throw createError("RPC", {
+    resource: "zksrpc",
+    operation,
+    message: `${messagePrefix}: expected bigint-compatible value.`,
+    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", {
+      resource: "zksrpc",
+      operation: "zksrpc.normalizeGenesis",
+      message: "Malformed genesis response: invalid contract tuple.",
+      context: { index, valueType: typeof tuple }
+    });
+  }
+  const [addrRaw, bytecodeRaw] = tuple;
+  return {
+    address: ensureHex(addrRaw, "initial_contracts.address", { index }),
+    bytecode: ensureHex(bytecodeRaw, "initial_contracts.bytecode", { index })
+  };
+}
+function normalizeRawStorageTuple(tuple, index) {
+  if (!Array.isArray(tuple) || tuple.length < 2) {
+    throw createError("RPC", {
+      resource: "zksrpc",
+      operation: "zksrpc.normalizeGenesis",
+      message: "Malformed genesis response: invalid storage tuple.",
+      context: { index, valueType: typeof tuple }
+    });
+  }
+  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") {
+      throw createError("RPC", {
+        resource: "zksrpc",
+        operation: "zksrpc.normalizeGenesis",
+        message: "Malformed genesis response: expected object.",
+        context: { receivedType: typeof raw }
+      });
+    }
+    const record = raw;
+    const contractsRaw = record["initial_contracts"];
+    if (!Array.isArray(contractsRaw)) {
+      throw createError("RPC", {
+        resource: "zksrpc",
+        operation: "zksrpc.normalizeGenesis",
+        message: "Malformed genesis response: initial_contracts must be an array.",
+        context: { valueType: typeof contractsRaw }
+      });
+    }
+    const genesisRoot = ensureHex(record["genesis_root"], "genesis_root", {});
+    const initialContracts = contractsRaw.map(
+      (entry, index) => normalizeContractTuple(entry, index)
+    );
+    const additionalStorage = normalizeAdditionalStorage(record["additional_storage"], record);
+    return {
+      initialContracts,
+      additionalStorage,
+      genesisRoot
+    };
+  } catch (e) {
+    if (isZKsyncError(e)) throw e;
+    throw createError("RPC", {
+      resource: "zksrpc",
+      operation: "zksrpc.normalizeGenesis",
+      message: "Failed to normalize genesis response.",
+      context: { receivedType: typeof raw },
+      cause: shapeCause(e)
+    });
+  }
+}
+function normalizeBlockMetadata(raw) {
+  try {
+    if (!raw || typeof raw !== "object") {
+      throw createError("RPC", {
+        resource: "zksrpc",
+        operation: "zksrpc.normalizeBlockMetadata",
+        message: "Malformed block metadata response: expected object.",
+        context: { receivedType: typeof raw }
+      });
+    }
+    const record = raw;
+    const pubdataPricePerByte = ensureBigInt(
+      record["pubdata_price_per_byte"] ?? record["pubdataPricePerByte"],
+      "pubdata_price_per_byte",
+      {
+        operation: "zksrpc.normalizeBlockMetadata",
+        messagePrefix: "Malformed block metadata response"
+      }
+    );
+    const nativePrice = ensureBigInt(
+      record["native_price"] ?? record["nativePrice"],
+      "native_price",
+      {
+        operation: "zksrpc.normalizeBlockMetadata",
+        messagePrefix: "Malformed block metadata response"
+      }
+    );
+    const executionVersion = ensureNumber(
+      record["execution_version"] ?? record["executionVersion"],
+      "execution_version",
+      {
+        operation: "zksrpc.normalizeBlockMetadata",
+        messagePrefix: "Malformed block metadata response"
+      }
+    );
+    return {
+      pubdataPricePerByte,
+      nativePrice,
+      executionVersion
+    };
+  } catch (e) {
+    if (isZKsyncError(e)) throw e;
+    throw createError("RPC", {
+      resource: "zksrpc",
+      operation: "zksrpc.normalizeBlockMetadata",
+      message: "Failed to normalize block metadata response.",
+      context: { receivedType: typeof raw },
+      cause: shapeCause(e)
+    });
+  }
+}
+function createZksRpc(transport) {
+  return {
+    // Fetches the Bridgehub contract address.
+    async getBridgehubAddress() {
+      return withRpcOp(
+        "zksrpc.getBridgehubAddress",
+        "Failed to fetch Bridgehub address.",
+        {},
+        async () => {
+          const addrRaw = await transport(METHODS.getBridgehub, []);
+          if (typeof addrRaw !== "string" || !addrRaw.startsWith("0x")) {
+            throw createError("RPC", {
+              resource: "zksrpc",
+              operation: "zksrpc.getBridgehubAddress",
+              message: "Unexpected Bridgehub address response.",
+              context: { valueType: typeof addrRaw }
+            });
+          }
+          return addrRaw;
+        }
+      );
+    },
+    // Fetches the Bytecode Supplier contract address.
+    async getBytecodeSupplierAddress() {
+      return withRpcOp(
+        "zksrpc.getBytecodeSupplierAddress",
+        "Failed to fetch Bytecode Supplier address.",
+        {},
+        async () => {
+          const addrRaw = await transport(METHODS.getBytecodeSupplier, []);
+          if (typeof addrRaw !== "string" || !addrRaw.startsWith("0x")) {
+            throw createError("RPC", {
+              resource: "zksrpc",
+              operation: "zksrpc.getBytecodeSupplierAddress",
+              message: "Unexpected Bytecode Supplier address response.",
+              context: { valueType: typeof addrRaw }
+            });
+          }
+          return addrRaw;
+        }
+      );
+    },
+    // Fetches a proof for an L2→L1 log emitted in the given transaction.
+    async getL2ToL1LogProof(txHash, index, proofTarget) {
+      return withRpcOp(
+        "zksrpc.getL2ToL1LogProof",
+        "Failed to fetch L2\u2192L1 log proof.",
+        { txHash, index, proofTarget },
+        async () => {
+          const params = [txHash, index];
+          if (proofTarget != void 0) params.push(proofTarget);
+          const proof = await transport(METHODS.getL2ToL1LogProof, params);
+          if (!proof) {
+            throw createError("STATE", {
+              resource: "zksrpc",
+              operation: "zksrpc.getL2ToL1LogProof",
+              message: "Proof not yet available. Please try again later.",
+              context: { txHash, index }
+            });
+          }
+          return normalizeProof(proof);
+        }
+      );
+    },
+    // Fetches the transaction receipt, including the `l2ToL1Logs` field.
+    async getReceiptWithL2ToL1(txHash) {
+      return withRpcOp(
+        "zksrpc.getReceiptWithL2ToL1",
+        "Failed to fetch transaction receipt.",
+        { txHash },
+        async () => {
+          const rcptRaw = await transport(METHODS.getReceipt, [txHash]);
+          if (!rcptRaw) return null;
+          const rcptObj = rcptRaw;
+          const logs = Array.isArray(rcptObj["l2ToL1Logs"]) ? rcptObj["l2ToL1Logs"] : [];
+          rcptObj["l2ToL1Logs"] = logs;
+          return rcptObj;
+        }
+      );
+    },
+    // Fetches block metadata for the given block number.
+    async getBlockMetadataByNumber(blockNumber) {
+      return withRpcOp(
+        "zksrpc.getBlockMetadataByNumber",
+        "Failed to fetch block metadata.",
+        { blockNumber },
+        async () => {
+          const raw = await transport(METHODS.getBlockMetadataByNumber, [blockNumber]);
+          if (raw == null) return null;
+          return normalizeBlockMetadata(raw);
+        }
+      );
+    },
+    // Fetches the genesis configuration returned by `zks_getGenesis`.
+    async getGenesis() {
+      return withRpcOp(
+        "zksrpc.getGenesis",
+        "Failed to fetch genesis configuration.",
+        {},
+        async () => {
+          const genesisRaw = await transport(METHODS.getGenesis, []);
+          return normalizeGenesis(genesisRaw);
+        }
+      );
+    }
+  };
+}
+
+export { IBaseToken_default, IBridgehub_default, IERC20_default, IERC7786Attributes_default, IInteropCenter_default, IInteropErrors_default, IInteropHandler_default, IInteropRootStorage_default, IL1AssetRouter_default, IL1ContractErrors_default, IL1Nullifier_default, IL2AssetRouter_default, L1NativeTokenVault_default, L2MessageVerification_default, L2NativeTokenVault_default, Mailbox_default, OP_CLIENT, OP_DEPOSITS, OP_INTEROP, OP_WITHDRAWALS, abi_exports, assertNever, createError, createZksRpc, factory_exports, formatEnvelopePretty, hexEq, isAddress, isAddressEq, isBigint, isETH, isHash, isHash66, isHash66Array, isHashArray, isNumber, isReceiptNotFound, isZKsyncError, normalizeAddrEq, normalizeL1Token, shapeCause, sleep, zks_exports };