@matterlabs/zksync-js 0.0.6 → 0.0.8

package/dist/adapters/ethers/client.cjs

@@ -11,6 +11,16 @@ 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 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/errors/formatter.ts
 function elideMiddle(s, max = 96) {
   if (s.length <= max) return s;
@@ -21,7 +31,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 +51,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 +81,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) {
@@ -160,20 +170,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;
@@ -206,6 +216,8 @@ var METHODS = {
   getBridgehub: "zks_getBridgehubContract",
   getL2ToL1LogProof: "zks_getL2ToL1LogProof",
   getReceipt: "eth_getTransactionReceipt",
+  getBytecodeSupplier: "zks_getBytecodeSupplierContract",
+  getBlockMetadataByNumber: "zks_getBlockMetadataByNumber",
   getGenesis: "zks_getGenesis"
 };
 function toHexArray(arr) {
@@ -225,7 +237,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",
@@ -236,7 +248,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;
@@ -258,20 +271,53 @@ function ensureHex(value, field, context) {
     context: { field, valueType: typeof value, ...context }
   });
 }
-function ensureNumber(value, field) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "bigint") return Number(value);
+function ensureNumber(value, field, opts) {
+  const operation = opts?.operation ?? "zksrpc.normalizeGenesis";
+  const messagePrefix = opts?.messagePrefix ?? "Malformed genesis response";
+  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: "zksrpc.normalizeGenesis",
-    message: "Malformed genesis response: expected numeric value.",
+    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", {
@@ -287,7 +333,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",
@@ -298,10 +344,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") {
@@ -322,21 +411,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,
@@ -354,6 +434,57 @@ function normalizeGenesis(raw) {
     });
   }
 }
+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.
@@ -376,6 +507,26 @@ function createZksRpc(transport) {
         }
       );
     },
+    // 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) {
       return withRpcOp(
@@ -412,6 +563,19 @@ function createZksRpc(transport) {
         }
       );
     },
+    // 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(
@@ -437,12 +601,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 = [
@@ -4931,6 +5089,56 @@ var MailboxABI = [
   { type: "error", name: "ZeroGasPriceL1TxZKSyncOS", inputs: [] }
 ];
 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);
+      }
+    }
+    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 };
+      }
+    }
+    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)"]);
@@ -5014,51 +5222,7 @@ function decodeRevert(e) {
 }
 
 // src/adapters/ethers/errors/error-ops.ts
-function toZKsyncError(type, base, err) {
-  if (isZKsyncError(err)) return err;
-  const revert = decodeRevert(err);
-  return createError(type, { ...base, ...revert ? { revert } : {}, cause: shapeCause(err) });
-}
-function resolveMessage(op, msg) {
-  if (!msg) return `Error during ${op}.`;
-  return typeof msg === "function" ? msg() : msg;
-}
-function createErrorHandlers(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 toZKsyncError(kind, { resource, operation, context: opts?.ctx ?? {}, message }, e);
-    }
-  }
-  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 : toZKsyncError(
-        "INTERNAL",
-        {
-          resource,
-          operation,
-          context: opts?.ctx ?? {},
-          message: resolveMessage(operation, opts?.message)
-        },
-        e
-      );
-      return { ok: false, error: shaped };
-    }
-  }
-  return { wrap, wrapAs: wrapAs2, toResult };
-}
+var { createErrorHandlers } = createErrorOps(decodeRevert);
 
 // src/adapters/ethers/client.ts
 var { wrapAs } = createErrorHandlers("client");