@matterlabs/zksync-js 0.0.1

package/dist/chunk-3LALBFFE.js

@@ -0,0 +1,138 @@
+import { createZksRpc, makeTransportFromEthers } from './chunk-4HLJJKIY.js';
+import { IBridgehub_default, IL1AssetRouter_default, IL1Nullifier_default, IBaseToken_default, L2NativeTokenVault_default, IL2AssetRouter_default, L1NativeTokenVault_default } from './chunk-Y75OMFK6.js';
+import { createError } from './chunk-B77GWPO5.js';
+import { L2_ASSET_ROUTER_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, L2_BASE_TOKEN_ADDRESS } from './chunk-6GCT6TLS.js';
+import { BrowserProvider, Interface, Contract } from 'ethers';
+
+// src/adapters/ethers/rpc.ts
+function zksRpcFromEthers(l2Provider) {
+  const maybe = l2Provider;
+  if (typeof maybe.send !== "function") {
+    throw new Error(
+      "zksRpcFromEthers requires a JSON-RPC capable provider with .send(method, params). Pass an ethers JsonRpcProvider (or wrap your EIP-1193 provider: new BrowserProvider(window.ethereum))."
+    );
+  }
+  return createZksRpc(makeTransportFromEthers(maybe));
+}
+
+// src/adapters/ethers/client.ts
+function createEthersClient(args) {
+  const { l1, l2, signer } = args;
+  let boundSigner = signer;
+  const signerProvider = signer.provider;
+  const isBrowserProvider = signerProvider instanceof 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;
+    const bridgehub = args.overrides?.bridgehub ?? await zks.getBridgehubAddress();
+    const IBridgehub = new Interface(IBridgehub_default);
+    const bh = new Contract(bridgehub, IBridgehub, l1);
+    const l1AssetRouter = args.overrides?.l1AssetRouter ?? await bh.assetRouter();
+    const IL1AssetRouter = new Interface(IL1AssetRouter_default);
+    const ar = new Contract(l1AssetRouter, IL1AssetRouter, l1);
+    const l1Nullifier = args.overrides?.l1Nullifier ?? await ar.L1_NULLIFIER();
+    const IL1Nullifier = new Interface(IL1Nullifier_default);
+    const nf = new 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 Contract(a.bridgehub, IBridgehub_default, l1),
+      l1AssetRouter: new Contract(a.l1AssetRouter, IL1AssetRouter_default, l1),
+      l1Nullifier: new Contract(a.l1Nullifier, IL1Nullifier_default, l1),
+      l1NativeTokenVault: new Contract(a.l1NativeTokenVault, L1NativeTokenVault_default, l1),
+      l2AssetRouter: new Contract(a.l2AssetRouter, IL2AssetRouter_default, l2),
+      l2NativeTokenVault: new Contract(a.l2NativeTokenVault, L2NativeTokenVault_default, l2),
+      l2BaseTokenSystem: new 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 Contract(bridgehub, IBridgehub_default, l1);
+    return await bh.baseToken(chainId);
+  }
+  const client = {
+    kind: "ethers",
+    l1,
+    l2,
+    signer: boundSigner,
+    getL1Signer() {
+      return resolveSignerFor(l1);
+    },
+    getL2Signer() {
+      return resolveSignerFor(l2);
+    },
+    zks,
+    ensureAddresses,
+    contracts,
+    refresh,
+    baseToken
+  };
+  return client;
+}
+
+export { createEthersClient };

package/dist/chunk-4HLJJKIY.js

@@ -0,0 +1,262 @@
+import { createError, isZKsyncError, shapeCause } from './chunk-B77GWPO5.js';
+import { __export } from './chunk-6GCT6TLS.js';
+
+// src/core/rpc/zks.ts
+var zks_exports = {};
+__export(zks_exports, {
+  createZksRpc: () => createZksRpc,
+  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 METHODS = {
+  getBridgehub: "zks_getBridgehubContract",
+  getL2ToL1LogProof: "zks_getL2ToL1LogProof",
+  getReceipt: "eth_getTransactionReceipt",
+  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;
+    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) => typeof x === "bigint" ? x : typeof x === "number" ? 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)
+    };
+  } 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) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "bigint") 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.",
+    context: { field, valueType: typeof value }
+  });
+}
+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 normalizeStorageTuple(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 {
+    key: ensureHex(keyRaw, "additional_storage.key", { index }),
+    value: ensureHex(valueRaw, "additional_storage.value", { index })
+  };
+}
+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 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));
+    return {
+      initialContracts,
+      additionalStorage,
+      executionVersion,
+      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 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 a proof for an L2→L1 log emitted in the given transaction.
+    async getL2ToL1LogProof(txHash, index) {
+      return withRpcOp(
+        "zksrpc.getL2ToL1LogProof",
+        "Failed to fetch L2\u2192L1 log proof.",
+        { txHash, index },
+        async () => {
+          const proof = await transport(METHODS.getL2ToL1LogProof, [txHash, index]);
+          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 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);
+        }
+      );
+    }
+  };
+}
+
+// src/core/rpc/transport.ts
+function makeTransportFromEthers(provider) {
+  return (m, p = []) => provider.send(m, p);
+}
+function makeTransportFromViem(client) {
+  return (m, p = []) => client.request({ method: m, params: p });
+}
+
+export { createZksRpc, makeTransportFromEthers, makeTransportFromViem, zks_exports };

package/dist/chunk-6GCT6TLS.js

@@ -0,0 +1,45 @@
+import { keccak_256 } from '@noble/hashes/sha3';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  ETH_ADDRESS: () => ETH_ADDRESS,
+  FORMAL_ETH_ADDRESS: () => FORMAL_ETH_ADDRESS,
+  L1_FEE_ESTIMATION_COEF_DENOMINATOR: () => L1_FEE_ESTIMATION_COEF_DENOMINATOR,
+  L1_FEE_ESTIMATION_COEF_NUMERATOR: () => L1_FEE_ESTIMATION_COEF_NUMERATOR,
+  L1_MESSENGER_ADDRESS: () => L1_MESSENGER_ADDRESS,
+  L1_SOPH_TOKEN_ADDRESS: () => L1_SOPH_TOKEN_ADDRESS,
+  L2_ASSET_ROUTER_ADDRESS: () => L2_ASSET_ROUTER_ADDRESS,
+  L2_BASE_TOKEN_ADDRESS: () => L2_BASE_TOKEN_ADDRESS,
+  L2_NATIVE_TOKEN_VAULT_ADDRESS: () => L2_NATIVE_TOKEN_VAULT_ADDRESS,
+  TOPIC_CANONICAL_ASSIGNED: () => TOPIC_CANONICAL_ASSIGNED,
+  TOPIC_CANONICAL_SUCCESS: () => TOPIC_CANONICAL_SUCCESS,
+  TOPIC_L1_MESSAGE_SENT: () => TOPIC_L1_MESSAGE_SENT,
+  TOPIC_L1_MESSAGE_SENT_LEG: () => TOPIC_L1_MESSAGE_SENT_LEG,
+  TOPIC_L1_MESSAGE_SENT_NEW: () => TOPIC_L1_MESSAGE_SENT_NEW,
+  k256hex: () => k256hex
+});
+var k256hex = (s) => `0x${bytesToHex(keccak_256(utf8ToBytes(s)))}`.toLowerCase();
+var FORMAL_ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ETH_ADDRESS = "0x0000000000000000000000000000000000000001";
+var L2_ASSET_ROUTER_ADDRESS = "0x0000000000000000000000000000000000010003";
+var L2_NATIVE_TOKEN_VAULT_ADDRESS = "0x0000000000000000000000000000000000010004";
+var L1_MESSENGER_ADDRESS = "0x0000000000000000000000000000000000008008";
+var L2_BASE_TOKEN_ADDRESS = "0x000000000000000000000000000000000000800A";
+var L1_SOPH_TOKEN_ADDRESS = "0xa9544a49d4aEa4c8E074431c89C79fA9592049d8";
+var TOPIC_L1_MESSAGE_SENT = "0x2632cc0d58b0cb1017b99cc0b6cc66ad86440cc0dd923bfdaa294f95ba1b0201";
+var TOPIC_L1_MESSAGE_SENT_NEW = k256hex("L1MessageSent(uint256,bytes32,bytes)");
+var TOPIC_L1_MESSAGE_SENT_LEG = k256hex("L1MessageSent(address,bytes32,bytes)");
+var TOPIC_CANONICAL_ASSIGNED = "0x779f441679936c5441b671969f37400b8c3ed0071cb47444431bf985754560df";
+var TOPIC_CANONICAL_SUCCESS = "0xe4def01b981193a97a9e81230d7b9f31812ceaf23f864a828a82c687911cb2df";
+var L1_FEE_ESTIMATION_COEF_NUMERATOR = 12;
+var L1_FEE_ESTIMATION_COEF_DENOMINATOR = 10;
+
+export { ETH_ADDRESS, FORMAL_ETH_ADDRESS, L1_FEE_ESTIMATION_COEF_DENOMINATOR, L1_FEE_ESTIMATION_COEF_NUMERATOR, L1_MESSENGER_ADDRESS, L1_SOPH_TOKEN_ADDRESS, L2_ASSET_ROUTER_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, TOPIC_CANONICAL_ASSIGNED, TOPIC_CANONICAL_SUCCESS, TOPIC_L1_MESSAGE_SENT, TOPIC_L1_MESSAGE_SENT_LEG, TOPIC_L1_MESSAGE_SENT_NEW, __export, constants_exports, k256hex };