@matterlabs/zksync-js 0.0.1

package/dist/chunk-B77GWPO5.js

@@ -0,0 +1,339 @@
+import { __export } from './chunk-6GCT6TLS.js';
+
+// src/core/errors/formatter.ts
+function elideMiddle(s, max = 96) {
+  if (s.length <= max) return s;
+  const keep = Math.max(10, Math.floor((max - 1) / 2));
+  return `${s.slice(0, keep)}\u2026${s.slice(-keep)}`;
+}
+function shortJSON(v, max = 240) {
+  try {
+    const s = JSON.stringify(
+      v,
+      (_k, val) => typeof val === "bigint" ? `${val.toString()}n` : val
+    );
+    return s.length > max ? elideMiddle(s, max) : s;
+  } catch {
+    return String(v);
+  }
+}
+function kv(label, value) {
+  const width = 10;
+  const pad = label.length >= width ? " " : " ".repeat(width - label.length);
+  return `${label + pad}: ${value}`;
+}
+function formatContextLine(ctx) {
+  if (!ctx) return;
+  const txHash = ctx["txHash"] ?? ctx["l1TxHash"] ?? ctx["hash"];
+  const nonce = ctx["nonce"];
+  const parts = [];
+  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);
+    parts.push(`nonce=${nonceStr}`);
+  }
+  return parts.length ? `  ${kv("Context", parts.join("  \u2022  "))}` : void 0;
+}
+function formatStep(ctx) {
+  const step = ctx && typeof ctx["step"] === "string" ? ctx["step"] : void 0;
+  return step ? `  ${kv("Step", step)}` : void 0;
+}
+function formatRevert(r) {
+  if (!r) return;
+  const first = [`selector=${r.selector}`];
+  const lines = [];
+  lines.push(`  ${kv("Revert", first.join(" "))}`);
+  if (r.name) lines.push(`              name=${r.name}`);
+  if (r.contract) lines.push(`              contract=${r.contract}`);
+  if (r.fn) lines.push(`              fn=${r.fn}`);
+  if (r.args && r.args.length) {
+    lines.push(`              args=${shortJSON(r.args, 120)}`);
+  }
+  return lines.join("\n");
+}
+function formatCause(c) {
+  if (!c) return [];
+  const out = [];
+  if (typeof c === "object" && c !== null) {
+    const obj = 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);
+      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);
+      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);
+      out.push(`              message=${elideMiddle(messageStr, 600)}`);
+    }
+    if (obj.data) {
+      const dataStr = shortJSON(obj.data, 200);
+      out.push(`              data=${elideMiddle(dataStr, 200)}`);
+    }
+  } else {
+    out.push(`  ${kv("Cause", shortJSON(c, 200))}`);
+  }
+  return out;
+}
+function formatEnvelopePretty(e) {
+  const lines = [];
+  lines.push(`\u2716 ZKsyncError [${e.type}]`);
+  lines.push(`  ${kv("Message", e.message)}`);
+  lines.push("");
+  lines.push(`  ${kv("Operation", e.operation)}`);
+  const ctx = (() => {
+    const u = e;
+    if (!u || typeof u !== "object") return void 0;
+    const obj = u;
+    const candidate = obj["ctx"] ?? obj["context"];
+    if (candidate && typeof candidate === "object" && candidate !== null) {
+      return candidate;
+    }
+    return void 0;
+  })();
+  const ctxLine = formatContextLine(ctx);
+  if (ctxLine) lines.push(ctxLine);
+  const stepLine = formatStep(ctx);
+  if (stepLine) lines.push(stepLine);
+  const rv = formatRevert(e.revert);
+  if (rv) lines.push(rv);
+  const causeLines = formatCause(e.cause);
+  if (causeLines.length) {
+    if (!ctxLine && !rv) lines.push("");
+    lines.push(...causeLines);
+  }
+  return lines.join("\n");
+}
+
+// src/core/errors/factory.ts
+var factory_exports = {};
+__export(factory_exports, {
+  createError: () => createError,
+  shapeCause: () => shapeCause
+});
+
+// src/core/types/errors.ts
+var hasSymbolInspect = typeof Symbol === "function" && typeof Symbol.for === "function";
+var kInspect = hasSymbolInspect ? Symbol.for("nodejs.util.inspect.custom") : void 0;
+function safeInspect(val) {
+  try {
+    if (typeof val === "string") return val;
+    return JSON.stringify(val, null, 2);
+  } catch {
+    try {
+      return String(val);
+    } catch {
+      return Object.prototype.toString.call(val);
+    }
+  }
+}
+var ZKsyncError = class extends Error {
+  constructor(envelope) {
+    super(formatEnvelopePretty(envelope), envelope.cause ? { cause: envelope.cause } : void 0);
+    this.envelope = envelope;
+    this.name = "ZKsyncError";
+  }
+  toJSON() {
+    return { name: this.name, ...this.envelope };
+  }
+};
+if (kInspect) {
+  Object.defineProperty(ZKsyncError.prototype, kInspect, {
+    value() {
+      return `${this.name}: ${formatEnvelopePretty(this.envelope)}`;
+    },
+    enumerable: false
+  });
+}
+function isZKsyncError(e) {
+  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";
+}
+function isReceiptNotFound(e) {
+  const chain = [];
+  let cur = e;
+  for (let i = 0; i < 5 && cur; i++) {
+    chain.push(cur);
+    cur = cur.cause;
+  }
+  const NAME_HITS = /* @__PURE__ */ new Set([
+    "TransactionReceiptNotFoundError",
+    // viem
+    "TransactionNotFoundError",
+    // viem
+    "NotFoundError"
+    // some RPC wrappers
+  ]);
+  const CODE_HITS = /* @__PURE__ */ new Set([
+    "TRANSACTION_NOT_FOUND",
+    // some ethers-ish shapes / providers
+    "RECEIPT_NOT_FOUND",
+    "NOT_FOUND",
+    -32e3
+    // JSON-RPC server error
+  ]);
+  const MSG_RE = /(transaction|receipt)[^]*?(not\s+(?:be\s+)?found|missing)/i;
+  for (const node of chain) {
+    const name = node?.name;
+    const code = node?.code;
+    const short = node?.shortMessage;
+    const msg = String(short ?? node?.message ?? "");
+    if (name && NAME_HITS.has(name)) return true;
+    if (code && CODE_HITS.has(code)) return true;
+    if (MSG_RE.test(msg)) return true;
+  }
+  const raw = (() => {
+    const node = e;
+    const short = node?.shortMessage;
+    const msg = node?.message;
+    if (typeof short === "string" && short) return short;
+    if (typeof msg === "string" && msg) return msg;
+    if (e == null) return "";
+    if (typeof e === "string") return e;
+    return safeInspect(e);
+  })();
+  return MSG_RE.test(raw);
+}
+var OP_DEPOSITS = {
+  // high-level flow ops
+  quote: "deposits.quote",
+  tryQuote: "deposits.tryQuote",
+  prepare: "deposits.prepare",
+  tryPrepare: "deposits.tryPrepare",
+  create: "deposits.create",
+  tryCreate: "deposits.tryCreate",
+  status: "deposits.status",
+  wait: "deposits.wait",
+  tryWait: "deposits.tryWait",
+  base: {
+    assertErc20Asset: "deposits.erc20-base:assertErc20Asset",
+    assertMatchesBase: "deposits.erc20-base:assertMatchesBase",
+    baseToken: "deposits.erc20-base:baseToken",
+    allowance: "deposits.erc20-base:allowance",
+    baseCost: "deposits.erc20-base:l2TransactionBaseCost",
+    estGas: "deposits.erc20-base:estimateGas"
+  },
+  nonbase: {
+    baseToken: "deposits.erc20-nonbase:baseToken",
+    assertNotEthAsset: "deposits.erc20-nonbase:assertNotEthAsset",
+    allowance: "deposits.erc20-nonbase:allowance",
+    allowanceFees: "deposits.erc20-nonbase:allowanceFeesBaseToken",
+    baseCost: "deposits.erc20-nonbase:l2TransactionBaseCost",
+    encodeCalldata: "deposits.erc20-nonbase:encodeSecondBridgeErc20Args",
+    estGas: "deposits.erc20-nonbase:estimateGas",
+    assertBaseIsEth: "deposits.erc20-nonbase:assertBaseIsEth",
+    assertBaseIsErc20: "deposits.erc20-nonbase:assertBaseIsErc20",
+    assertNonBaseToken: "deposits.erc20-nonbase:assertNonBaseToken",
+    allowanceToken: "deposits.erc20-nonbase:allowanceToken",
+    allowanceBase: "deposits.erc20-nonbase:allowanceBase"
+  },
+  eth: {
+    baseCost: "deposits.eth:l2TransactionBaseCost",
+    estGas: "deposits.eth:estimateGas"
+  },
+  ethNonBase: {
+    baseToken: "deposits.eth-nonbase:baseToken",
+    baseCost: "deposits.eth-nonbase:l2TransactionBaseCost",
+    allowanceBase: "deposits.eth-nonbase:allowanceBaseToken",
+    ethBalance: "deposits.eth-nonbase:getEthBalance",
+    encodeCalldata: "deposits.eth-nonbase:encodeSecondBridgeEthArgs",
+    estGas: "deposits.eth-nonbase:estimateGas",
+    assertEthAsset: "deposits.eth-nonbase:assertEthAsset",
+    assertNonEthBase: "deposits.eth-nonbase:assertNonEthBase",
+    assertEthBalance: "deposits.eth-nonbase:assertEthBalance"
+  }
+};
+var OP_WITHDRAWALS = {
+  quote: "withdrawals.quote",
+  tryQuote: "withdrawals.tryQuote",
+  prepare: "withdrawals.prepare",
+  tryPrepare: "withdrawals.tryPrepare",
+  create: "withdrawals.create",
+  tryCreate: "withdrawals.tryCreate",
+  status: "withdrawals.status",
+  wait: "withdrawals.wait",
+  tryWait: "withdrawals.tryWait",
+  erc20: {
+    allowance: "withdrawals.erc20:allowance",
+    ensureRegistered: "withdrawals.erc20:ensureTokenIsRegistered",
+    encodeAssetData: "withdrawals.erc20:encodeAssetData",
+    encodeWithdraw: "withdrawals.erc20:encodeWithdraw",
+    estGas: "withdrawals.erc20:estimateGas"
+  },
+  eth: {
+    encodeWithdraw: "withdrawals.eth:encodeWithdraw",
+    estGas: "withdrawals.eth:estimateGas"
+  },
+  ethNonBase: {
+    allowance: "withdrawals.eth-nonbase:allowance",
+    ensureRegistered: "withdrawals.eth-nonbase:ensureTokenIsRegistered",
+    encodeAssetData: "withdrawals.eth-nonbase:encodeAssetData",
+    encodeWithdraw: "withdrawals.eth-nonbase:encodeWithdraw",
+    estGas: "withdrawals.eth-nonbase:estimateGas",
+    baseToken: "withdrawals.eth-nonbase:baseToken",
+    assertNonEthBase: "withdrawals.eth-nonbase:assertNonEthBase"
+  },
+  finalize: {
+    fetchParams: {
+      receipt: "withdrawals.finalize.fetchParams:receipt",
+      findMessage: "withdrawals.finalize.fetchParams:findMessage",
+      decodeMessage: "withdrawals.finalize.fetchParams:decodeMessage",
+      rawReceipt: "withdrawals.finalize.fetchParams:rawReceipt",
+      messengerIndex: "withdrawals.finalize.fetchParams:messengerIndex",
+      proof: "withdrawals.finalize.fetchParams:proof",
+      network: "withdrawals.finalize.fetchParams:network",
+      ensureAddresses: "withdrawals.finalize.fetchParams:ensureAddresses"
+    },
+    readiness: {
+      ensureAddresses: "withdrawals.finalize.readiness:ensureAddresses",
+      isFinalized: "withdrawals.finalize.readiness:isWithdrawalFinalized",
+      simulate: "withdrawals.finalize.readiness:simulate"
+    },
+    isFinalized: "withdrawals.finalize.isWithdrawalFinalized",
+    send: "withdrawals.finalize.finalizeDeposit:send",
+    wait: "withdrawals.finalize.finalizeDeposit:wait",
+    estimate: "withdrawals.finalize.estimateFinalizationFees"
+  }
+};
+
+// src/core/errors/factory.ts
+function createError(type, input) {
+  return new ZKsyncError({ ...input, type });
+}
+function shapeCause(err) {
+  const isRecord = (x) => x !== null && typeof x === "object";
+  let data = void 0;
+  if (isRecord(err)) {
+    const r2 = err;
+    const d = r2.data;
+    if (isRecord(d) && "data" in d) {
+      data = d.data;
+    } else if ("error" in r2 && isRecord(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 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;
+  return {
+    name,
+    message,
+    code,
+    data: typeof data === "string" && data.startsWith("0x") ? `${data.slice(0, 10)}\u2026` : void 0
+  };
+}
+
+export { OP_DEPOSITS, OP_WITHDRAWALS, createError, factory_exports, formatEnvelopePretty, isReceiptNotFound, isZKsyncError, shapeCause };

package/dist/chunk-BD2LUO5T.js

@@ -0,0 +1,123 @@
+import { createZksRpc, makeTransportFromViem } from './chunk-4HLJJKIY.js';
+import { IBridgehub_default, IL1AssetRouter_default, IL1Nullifier_default, IBaseToken_default, L2NativeTokenVault_default, IL2AssetRouter_default, L1NativeTokenVault_default } from './chunk-Y75OMFK6.js';
+import { L2_ASSET_ROUTER_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, L2_BASE_TOKEN_ADDRESS } from './chunk-6GCT6TLS.js';
+import { getContract, createWalletClient } from 'viem';
+
+// src/adapters/viem/rpc.ts
+function zksRpcFromViem(l2Client) {
+  const compatible = {
+    request: (args) => l2Client.request(args)
+  };
+  return createZksRpc(makeTransportFromViem(compatible));
+}
+
+// src/adapters/viem/client.ts
+function createViemClient(args) {
+  const { l1, l2, l1Wallet, l2Wallet } = args;
+  if (!l1Wallet.account) {
+    throw new Error("WalletClient must have an account configured.");
+  }
+  if (l2Wallet && !l2Wallet.account) throw new Error("l2Wallet provided without an account.");
+  const zks = zksRpcFromViem(l2);
+  let addrCache;
+  let cCache;
+  async function ensureAddresses() {
+    if (addrCache) return addrCache;
+    const bridgehub = args.overrides?.bridgehub ?? await zks.getBridgehubAddress();
+    const l1AssetRouter = args.overrides?.l1AssetRouter ?? await l1.readContract({
+      address: bridgehub,
+      abi: IBridgehub_default,
+      functionName: "assetRouter"
+    });
+    const l1Nullifier = args.overrides?.l1Nullifier ?? await l1.readContract({
+      address: l1AssetRouter,
+      abi: IL1AssetRouter_default,
+      functionName: "L1_NULLIFIER"
+    });
+    const l1NativeTokenVault = args.overrides?.l1NativeTokenVault ?? await l1.readContract({
+      address: l1Nullifier,
+      abi: IL1Nullifier_default,
+      functionName: "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: getContract({ address: a.bridgehub, abi: IBridgehub_default, client: l1 }),
+      l1AssetRouter: getContract({ address: a.l1AssetRouter, abi: IL1AssetRouter_default, client: l1 }),
+      l1Nullifier: getContract({ address: a.l1Nullifier, abi: IL1Nullifier_default, client: l1 }),
+      l1NativeTokenVault: getContract({
+        address: a.l1NativeTokenVault,
+        abi: L1NativeTokenVault_default,
+        client: l1
+      }),
+      l2AssetRouter: getContract({ address: a.l2AssetRouter, abi: IL2AssetRouter_default, client: l2 }),
+      l2NativeTokenVault: getContract({
+        address: a.l2NativeTokenVault,
+        abi: L2NativeTokenVault_default,
+        client: l2
+      }),
+      l2BaseTokenSystem: getContract({
+        address: a.l2BaseTokenSystem,
+        abi: IBaseToken_default,
+        client: l2
+      })
+    };
+    return cCache;
+  }
+  function refresh() {
+    addrCache = void 0;
+    cCache = void 0;
+  }
+  async function baseToken(chainId) {
+    const { bridgehub } = await ensureAddresses();
+    const token = await l1.readContract({
+      address: bridgehub,
+      abi: IBridgehub_default,
+      functionName: "baseToken",
+      args: [chainId]
+    });
+    return token;
+  }
+  let lazyL2;
+  function getL2Wallet() {
+    if (l2Wallet) return l2Wallet;
+    if (!lazyL2) {
+      lazyL2 = createWalletClient({
+        account: l1Wallet.account,
+        transport: l2.transport
+      });
+    }
+    return lazyL2;
+  }
+  return {
+    kind: "viem",
+    l1,
+    l2,
+    l1Wallet,
+    l2Wallet,
+    account: l1Wallet.account,
+    zks,
+    ensureAddresses,
+    contracts,
+    refresh,
+    baseToken,
+    getL2Wallet
+  };
+}
+
+export { createViemClient };