@matterlabs/zksync-js 0.0.14 → 0.0.16

package/dist/{chunk-JY62QO3W.js → chunk-UEKFQAOS.js}

@@ -7027,6 +7027,7 @@ var OP_INTEROP = {
   tryWait: "interop.tryWait",
   finalize: "interop.finalize",
   tryFinalize: "interop.tryFinalize",
+  verify: "interop.verify",
   context: {
     chainTypeManager: "interop.chainTypeManager",
     protocolVersion: "interop.protocolVersion"
@@ -7078,20 +7079,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;
@@ -7103,4 +7104,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 };

package/dist/core/index.js

@@ -1,6 +1,5 @@
-export { pickDepositRoute } from '../chunk-J47RI3G7.js';
+export { pickDepositRoute } from '../chunk-TYYUG5GA.js';
 export { findL1MessageSentLog, isL1MessageSentLog, messengerLogIndex, pickWithdrawRoute } from '../chunk-3HHUZXSV.js';
 export { makeTransportFromEthers, makeTransportFromViem } from '../chunk-BWKWWLY4.js';
-export { zks_exports as zksRpc } from '../chunk-DYJKK5FW.js';
-export { abi_exports as abi, factory_exports as errors, formatEnvelopePretty, hexEq, isAddress, isAddressEq, isETH, isHash, isHash66, isHash66Array, isHashArray, normalizeAddrEq, normalizeL1Token } from '../chunk-JY62QO3W.js';
+export { abi_exports as abi, factory_exports as errors, formatEnvelopePretty, hexEq, isAddress, isAddressEq, isETH, isHash, isHash66, isHash66Array, isHashArray, normalizeAddrEq, normalizeL1Token, zks_exports as zksRpc } from '../chunk-UEKFQAOS.js';
 export { ETH_ADDRESS, FORMAL_ETH_ADDRESS, L1_MESSENGER_ADDRESS, L1_SOPH_TOKEN_ADDRESS, L2_ASSET_ROUTER_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS } from '../chunk-MT4X5FEO.js';

package/dist/core/resources/deposits/chains.d.ts

@@ -0,0 +1 @@
+export declare function isEraVmChain(chainIdL2: bigint): boolean;

package/dist/core/resources/deposits/gas.d.ts

@@ -10,6 +10,13 @@ export type GasQuote = {
     gasPerPubdata?: bigint;
     maxCost: bigint;
 };
+export declare function applyGasBuffer(gasLimit: bigint, bufferPct?: bigint): bigint;
+export declare function resolveCreateDepositL1GasLimit(input: {
+    chainIdL2: bigint;
+    stepKey: string;
+    preparedGasLimit?: bigint;
+    estimatedGasLimit?: bigint;
+}): bigint | undefined;
 export type QuoteL1GasInput = {
     estimator: GasEstimator;
     tx: CoreTransactionRequest;

package/dist/core/resources/deposits/priority.d.ts

@@ -35,3 +35,7 @@ export declare function derivePriorityBodyGasEstimateCap(input: {
     minBodyGas: bigint;
     multiplier?: bigint;
 }): bigint;
+export declare function applyPriorityL2GasLimitBuffer(input: {
+    chainIdL2: bigint;
+    gasLimit: bigint;
+}): bigint;

package/dist/core/resources/interop/protocol.d.ts

@@ -0,0 +1,3 @@
+import type { ProtocolVersion } from '../../types/primitives';
+export declare const MIN_INTEROP_PROTOCOL = 31;
+export declare function assertProtocolVersion(chainId: bigint, protocolVersion: ProtocolVersion): void;

package/dist/core/types/errors.d.ts

@@ -194,6 +194,7 @@ export declare const OP_INTEROP: {
     readonly tryWait: "interop.tryWait";
     readonly finalize: "interop.finalize";
     readonly tryFinalize: "interop.tryFinalize";
+    readonly verify: "interop.verify";
     readonly context: {
         readonly chainTypeManager: "interop.chainTypeManager";
         readonly protocolVersion: "interop.protocolVersion";

package/dist/core/types/flows/interop.d.ts

@@ -70,8 +70,6 @@ export interface InteropQuote {
     bridgedTokenTotal: bigint;
     /** Interop fee details */
     interopFee: InteropFee;
-    /** Optional: Estimated L1 fee */
-    l1Fee?: bigint;
     /** Optional: Estimated L2 fee */
     l2Fee?: bigint;
 }

package/dist/core/types/primitives.d.ts

@@ -1,4 +1,6 @@
 export type Address = `0x${string}`;
 export type Hex = `0x${string}`;
 export type Hash = Hex;
+/** Semver protocol version tuple: [patch, minor, major] as returned by getSemverProtocolVersion(). */
+export type ProtocolVersion = readonly [number, number, number];
 export declare const ZERO_HASH: Hash;

package/dist/index.js

@@ -1,6 +1,5 @@
-export { pickDepositRoute } from './chunk-J47RI3G7.js';
+export { pickDepositRoute } from './chunk-TYYUG5GA.js';
 export { findL1MessageSentLog, isL1MessageSentLog, messengerLogIndex, pickWithdrawRoute } from './chunk-3HHUZXSV.js';
 export { makeTransportFromEthers, makeTransportFromViem } from './chunk-BWKWWLY4.js';
-export { zks_exports as zksRpc } from './chunk-DYJKK5FW.js';
-export { abi_exports as abi, factory_exports as errors, formatEnvelopePretty, hexEq, isAddress, isAddressEq, isETH, isHash, isHash66, isHash66Array, isHashArray, normalizeAddrEq, normalizeL1Token } from './chunk-JY62QO3W.js';
+export { abi_exports as abi, factory_exports as errors, formatEnvelopePretty, hexEq, isAddress, isAddressEq, isETH, isHash, isHash66, isHash66Array, isHashArray, normalizeAddrEq, normalizeL1Token, zks_exports as zksRpc } from './chunk-UEKFQAOS.js';
 export { constants_exports as constants } from './chunk-MT4X5FEO.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterlabs/zksync-js",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "devDependencies": {