@permissionless-technologies/upp-sdk 0.1.0

package/dist/chunk-G7VZBCD6.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+exports.__esm = __esm;
+exports.__export = __export;
+exports.__require = __require;
+exports.__toCommonJS = __toCommonJS;
+//# sourceMappingURL=chunk-G7VZBCD6.cjs.map
+//# sourceMappingURL=chunk-G7VZBCD6.cjs.map

package/dist/chunk-G7VZBCD6.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-G7VZBCD6.cjs"}

package/dist/chunk-GQV47S3N.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunk3HQ7A6ZM_cjs = require('./chunk-3HQ7A6ZM.cjs');
+var chunkJWNXBALH_cjs = require('./chunk-JWNXBALH.cjs');
+
+// src/utils/index.ts
+chunkJWNXBALH_cjs.init_poseidon();
+chunk3HQ7A6ZM_cjs.init_crypto();
+//# sourceMappingURL=chunk-GQV47S3N.cjs.map
+//# sourceMappingURL=chunk-GQV47S3N.cjs.map

package/dist/chunk-GQV47S3N.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/index.ts"],"names":["init_poseidon","init_crypto"],"mappings":";;;;;;AAKAA,+BAAA,EAAA;AAwCAC,6BAAA,EAAA","file":"chunk-GQV47S3N.cjs","sourcesContent":["/**\n * Utility functions for UPP SDK\n */\n\n// Poseidon hash\nexport {\n  poseidon,\n  poseidonHash,\n  poseidonScalar,\n  FIELD_PRIME,\n  BABYJUBJUB_SUBORDER,\n  addressToField,\n  fieldToAddress,\n  isValidFieldElement,\n  toFieldElement,\n} from './poseidon.js'\n\n// BabyJubJub curve operations\nexport {\n  type Point,\n  getSubOrder,\n  getBasePoint,\n  isOnCurve,\n  mulPointScalar,\n  addPoints,\n  privateToPublic,\n  computeSharedSecret,\n  packPoint,\n  pointToTuple,\n  tupleToPoint,\n  deriveEncryptionViewingKey,\n  deriveDecryptionViewingKey,\n} from './babyjubjub.js'\n\n// Merkle tree\nexport {\n  MerkleTree,\n  buildMerkleTree,\n  getMerkleProof,\n  verifyMerkleProof,\n  type MerkleProof,\n  MAX_TREE_DEPTH,\n} from './merkle.js'\n\n// Crypto utilities\nexport {\n  randomBytes,\n  randomFieldElement,\n  bytesToHex,\n  hexToBytes,\n  bigintToBytes,\n  bytesToBigint,\n} from './crypto.js'\n\n// Keccak-M31 hashing (STARK)\nexport {\n  keccakM31,\n  keccakHashTwo,\n  computeStarkOwnerHash,\n  computeStarkCommitment,\n  computeStarkNullifier,\n  splitToM31Limbs,\n  M31_P,\n  DIGEST_SIZE,\n  SECRET_LIMBS,\n  type M31Digest,\n  type M31Secret,\n} from './keccak-m31.js'\n"]}

package/dist/chunk-GXZ3MTCQ.cjs

@@ -0,0 +1,527 @@
+'use strict';
+
+var chunk3HQ7A6ZM_cjs = require('./chunk-3HQ7A6ZM.cjs');
+var chunkG7VZBCD6_cjs = require('./chunk-G7VZBCD6.cjs');
+var bech32 = require('bech32');
+var viem = require('viem');
+
+// src/core/stealth.ts
+var stealth_exports = {};
+chunkG7VZBCD6_cjs.__export(stealth_exports, {
+  ADDRESS_VERSION: () => exports.ADDRESS_VERSION,
+  STARK_ADDRESS_VERSION: () => exports.STARK_ADDRESS_VERSION,
+  STARK_STEALTH_ADDRESS_PREFIX: () => exports.STARK_STEALTH_ADDRESS_PREFIX,
+  STEALTH_ADDRESS_PREFIX: () => exports.STEALTH_ADDRESS_PREFIX,
+  computeNoteEncryptionKey: () => computeNoteEncryptionKey,
+  createOneTimeKeys: () => createOneTimeKeys,
+  decodeStarkStealthAddress: () => decodeStarkStealthAddress,
+  decodeStealthAddress: () => decodeStealthAddress,
+  detectAddressType: () => detectAddressType,
+  encodeStarkStealthAddress: () => encodeStarkStealthAddress,
+  encodeStealthAddress: () => encodeStealthAddress,
+  generateStarkStealthAddress: () => generateStarkStealthAddress,
+  generateStealthAddress: () => generateStealthAddress,
+  isValidStarkStealthAddress: () => isValidStarkStealthAddress,
+  isValidStealthAddress: () => isValidStealthAddress,
+  verifyOwnership: () => verifyOwnership
+});
+function encodeStealthAddress(ownerHash, viewingHash, chainId = 0) {
+  const data = new Uint8Array(1 + 4 + 32 * 2);
+  let offset = 0;
+  data[offset++] = exports.ADDRESS_VERSION;
+  data[offset++] = chainId >> 24 & 255;
+  data[offset++] = chainId >> 16 & 255;
+  data[offset++] = chainId >> 8 & 255;
+  data[offset++] = chainId & 255;
+  const ownerBytes = chunk3HQ7A6ZM_cjs.bigintToBytes(ownerHash, 32);
+  data.set(ownerBytes, offset);
+  offset += 32;
+  const viewingBytes = chunk3HQ7A6ZM_cjs.bigintToBytes(viewingHash, 32);
+  data.set(viewingBytes, offset);
+  const words = bech32.bech32m.toWords(data);
+  return bech32.bech32m.encode(exports.STEALTH_ADDRESS_PREFIX, words, BECH32M_LIMIT);
+}
+function decodeStealthAddress(address) {
+  const decoded = bech32.bech32m.decode(address, BECH32M_LIMIT);
+  if (decoded.prefix !== exports.STEALTH_ADDRESS_PREFIX) {
+    throw new Error(`Invalid stealth address prefix: expected '${exports.STEALTH_ADDRESS_PREFIX}', got '${decoded.prefix}'`);
+  }
+  const data = new Uint8Array(bech32.bech32m.fromWords(decoded.words));
+  let offset = 0;
+  const version = data[offset++];
+  if (version !== exports.ADDRESS_VERSION) {
+    throw new Error(`Unsupported address version: ${version}. Expected v${exports.ADDRESS_VERSION} (hash-based).`);
+  }
+  const chainId = data[offset++] << 24 | data[offset++] << 16 | data[offset++] << 8 | data[offset++];
+  const ownerHash = chunk3HQ7A6ZM_cjs.bytesToBigint(data.slice(offset, offset + 32));
+  offset += 32;
+  const viewingHash = chunk3HQ7A6ZM_cjs.bytesToBigint(data.slice(offset, offset + 32));
+  return {
+    version,
+    chainId,
+    ownerHash,
+    viewingHash
+  };
+}
+function isValidStealthAddress(address) {
+  try {
+    decodeStealthAddress(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateStealthAddress(keys, chainId = 0) {
+  return encodeStealthAddress(keys.ownerHash, keys.viewingHash, chainId);
+}
+async function createOneTimeKeys(_recipientOwnerHash, selfSecret) {
+  const { poseidon } = await import('./poseidon-WHJSZSNP.cjs');
+  if (selfSecret !== void 0) {
+    const ownerHash2 = await poseidon([selfSecret]);
+    return {
+      oneTimeSecret: selfSecret,
+      ownerHash: ownerHash2
+    };
+  }
+  const oneTimeSecret = chunk3HQ7A6ZM_cjs.randomFieldElement();
+  const ownerHash = await poseidon([oneTimeSecret]);
+  return {
+    oneTimeSecret,
+    ownerHash
+  };
+}
+async function verifyOwnership(secret, expectedOwnerHash) {
+  const { poseidon } = await import('./poseidon-WHJSZSNP.cjs');
+  const computedHash = await poseidon([secret]);
+  return computedHash === expectedOwnerHash;
+}
+async function computeNoteEncryptionKey(viewingSecret, nonce) {
+  const { poseidon } = await import('./poseidon-WHJSZSNP.cjs');
+  if (nonce !== void 0) {
+    return poseidon([viewingSecret, nonce]);
+  }
+  return poseidon([viewingSecret]);
+}
+function encodeStarkStealthAddress(ownerHash, viewingHash, chainId = 0) {
+  const data = new Uint8Array(1 + 4 + 16 + 16);
+  let offset = 0;
+  data[offset++] = exports.STARK_ADDRESS_VERSION;
+  data[offset++] = chainId >> 24 & 255;
+  data[offset++] = chainId >> 16 & 255;
+  data[offset++] = chainId >> 8 & 255;
+  data[offset++] = chainId & 255;
+  for (let i = 0; i < 4; i++) {
+    const val = Number(ownerHash[i]);
+    data[offset++] = val & 255;
+    data[offset++] = val >> 8 & 255;
+    data[offset++] = val >> 16 & 255;
+    data[offset++] = val >> 24 & 255;
+  }
+  for (let i = 0; i < 4; i++) {
+    const val = Number(viewingHash[i]);
+    data[offset++] = val & 255;
+    data[offset++] = val >> 8 & 255;
+    data[offset++] = val >> 16 & 255;
+    data[offset++] = val >> 24 & 255;
+  }
+  const words = bech32.bech32m.toWords(data);
+  return bech32.bech32m.encode(exports.STARK_STEALTH_ADDRESS_PREFIX, words, BECH32M_LIMIT);
+}
+function decodeStarkStealthAddress(address) {
+  const decoded = bech32.bech32m.decode(address, BECH32M_LIMIT);
+  if (decoded.prefix !== exports.STARK_STEALTH_ADDRESS_PREFIX) {
+    throw new Error(
+      `Invalid STARK stealth address prefix: expected '${exports.STARK_STEALTH_ADDRESS_PREFIX}', got '${decoded.prefix}'`
+    );
+  }
+  const data = new Uint8Array(bech32.bech32m.fromWords(decoded.words));
+  let offset = 0;
+  const version = data[offset++];
+  if (version !== exports.STARK_ADDRESS_VERSION) {
+    throw new Error(
+      `Unsupported STARK address version: ${version}. Expected v${exports.STARK_ADDRESS_VERSION}.`
+    );
+  }
+  const chainId = data[offset++] << 24 | data[offset++] << 16 | data[offset++] << 8 | data[offset++];
+  const ownerHash = [];
+  for (let i = 0; i < 4; i++) {
+    const val = data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24;
+    ownerHash.push(BigInt(val >>> 0));
+    offset += 4;
+  }
+  const viewingHash = [];
+  for (let i = 0; i < 4; i++) {
+    const val = data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24;
+    viewingHash.push(BigInt(val >>> 0));
+    offset += 4;
+  }
+  return {
+    version,
+    chainId,
+    ownerHash,
+    viewingHash
+  };
+}
+function isValidStarkStealthAddress(address) {
+  try {
+    decodeStarkStealthAddress(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateStarkStealthAddress(keys, chainId = 0) {
+  return encodeStarkStealthAddress(keys.starkOwnerHash, keys.starkViewingHash, chainId);
+}
+function detectAddressType(address) {
+  if (address.startsWith(exports.STEALTH_ADDRESS_PREFIX + "1")) return "snark";
+  if (address.startsWith(exports.STARK_STEALTH_ADDRESS_PREFIX + "1")) return "stark";
+  return "unknown";
+}
+exports.STEALTH_ADDRESS_PREFIX = void 0; exports.ADDRESS_VERSION = void 0; var BECH32M_LIMIT; exports.STARK_STEALTH_ADDRESS_PREFIX = void 0; exports.STARK_ADDRESS_VERSION = void 0;
+var init_stealth = chunkG7VZBCD6_cjs.__esm({
+  "src/core/stealth.ts"() {
+    chunk3HQ7A6ZM_cjs.init_crypto();
+    exports.STEALTH_ADDRESS_PREFIX = "0zk";
+    exports.ADDRESS_VERSION = 2;
+    BECH32M_LIMIT = 1023;
+    exports.STARK_STEALTH_ADDRESS_PREFIX = "0zs";
+    exports.STARK_ADDRESS_VERSION = 1;
+  }
+});
+var RATE_PRECISION = 10n ** 18n;
+var SWAP_ORDER_PLACED_EVENT = {
+  type: "event",
+  name: "SwapOrderPlaced",
+  inputs: [
+    { name: "orderId", type: "bytes32", indexed: true },
+    { name: "sellToken", type: "address", indexed: true },
+    { name: "buyToken", type: "address", indexed: true },
+    { name: "sellAmount", type: "uint256", indexed: false },
+    { name: "rate", type: "uint256", indexed: false },
+    { name: "makerAspId", type: "uint256", indexed: false },
+    { name: "requiredFillerAspId", type: "uint256", indexed: false },
+    { name: "expiry", type: "uint256", indexed: false }
+  ]
+};
+var SWAP_ORDER_FILLED_EVENT = {
+  type: "event",
+  name: "SwapOrderFilled",
+  inputs: [
+    { name: "orderId", type: "bytes32", indexed: true },
+    { name: "fillerNullifier", type: "bytes32", indexed: true },
+    { name: "takeAmount", type: "uint256", indexed: false },
+    { name: "giveAmount", type: "uint256", indexed: false },
+    { name: "fillerAspId", type: "uint256", indexed: false }
+  ]
+};
+var SWAP_ORDER_CLAIMED_EVENT = {
+  type: "event",
+  name: "SwapOrderClaimed",
+  inputs: [
+    { name: "orderId", type: "bytes32", indexed: true },
+    { name: "accumulatedBuyAmount", type: "uint256", indexed: false },
+    { name: "refundedSellAmount", type: "uint256", indexed: false }
+  ]
+};
+var SWAP_ORDER_CANCELLED_EVENT = {
+  type: "event",
+  name: "SwapOrderCancelled",
+  inputs: [
+    { name: "orderId", type: "bytes32", indexed: true },
+    { name: "refundedSellAmount", type: "uint256", indexed: false }
+  ]
+};
+var SWAP_EVENTS_ABI = [
+  SWAP_ORDER_PLACED_EVENT,
+  SWAP_ORDER_FILLED_EVENT,
+  SWAP_ORDER_CLAIMED_EVENT,
+  SWAP_ORDER_CANCELLED_EVENT
+];
+function computeGiveAmount(takeAmount, rate) {
+  return takeAmount * rate / RATE_PRECISION;
+}
+function computeTakeAmount(giveAmount, rate) {
+  if (rate === 0n) throw new Error("Rate cannot be zero");
+  return giveAmount * RATE_PRECISION / rate;
+}
+function computeRate(sellAmount, buyAmount) {
+  if (sellAmount === 0n) throw new Error("Sell amount cannot be zero");
+  return buyAmount * RATE_PRECISION / sellAmount;
+}
+function formatRate(rate, decimals = 6) {
+  const whole = rate / RATE_PRECISION;
+  const frac = rate % RATE_PRECISION;
+  const fracStr = frac.toString().padStart(18, "0").slice(0, decimals);
+  return `${whole}.${fracStr}`;
+}
+function computeCancelKeyHash(cancelSecret) {
+  return viem.keccak256(viem.encodeAbiParameters(
+    viem.parseAbiParameters("bytes32"),
+    [cancelSecret]
+  ));
+}
+function generateCancelSecret() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return viem.toHex(bytes);
+}
+function filterOrdersByASP(orders, acceptableAspIds) {
+  const aspSet = new Set(acceptableAspIds.map((id) => id.toString()));
+  return orders.filter((o) => aspSet.has(o.makerAspId.toString()));
+}
+function filterOrdersByTokenPair(orders, sellToken, buyToken) {
+  const sell = sellToken.toLowerCase();
+  const buy = buyToken.toLowerCase();
+  return orders.filter(
+    (o) => o.sellToken.toLowerCase() === sell && o.buyToken.toLowerCase() === buy
+  );
+}
+function isFillerASPAccepted(order, fillerAspId) {
+  const required = "requiredFillerAspId" in order ? order.requiredFillerAspId : 0n;
+  return required === 0n || required === fillerAspId;
+}
+var CANCEL_SECRET_PREFIX = "upp_swap_cancel_";
+function cancelKey(account, orderId) {
+  return `${CANCEL_SECRET_PREFIX}${account.toLowerCase()}_${orderId}`;
+}
+function storeCancelSecret(orderId, cancelSecret, account) {
+  if (typeof localStorage === "undefined") return;
+  if (account) {
+    localStorage.setItem(cancelKey(account, orderId), cancelSecret);
+  }
+  localStorage.setItem(`${CANCEL_SECRET_PREFIX}${orderId}`, cancelSecret);
+}
+function getCancelSecret(orderId, account) {
+  if (typeof localStorage === "undefined") return null;
+  if (account) {
+    const scoped = localStorage.getItem(cancelKey(account, orderId));
+    if (scoped) return scoped;
+  }
+  return localStorage.getItem(`${CANCEL_SECRET_PREFIX}${orderId}`);
+}
+function removeCancelSecret(orderId, account) {
+  if (typeof localStorage === "undefined") return;
+  if (account) {
+    localStorage.removeItem(cancelKey(account, orderId));
+  }
+  localStorage.removeItem(`${CANCEL_SECRET_PREFIX}${orderId}`);
+}
+function getOwnOrderIds(account) {
+  if (typeof localStorage === "undefined") return [];
+  const prefix = account ? `${CANCEL_SECRET_PREFIX}${account.toLowerCase()}_` : CANCEL_SECRET_PREFIX;
+  const ids = [];
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (key?.startsWith(prefix)) {
+      ids.push(key.slice(prefix.length));
+    }
+  }
+  return ids;
+}
+function isOrderActive(order, currentBlock) {
+  return !order.claimed && !order.cancelled && currentBlock <= order.expiry && order.remainingSellAmount > 0n;
+}
+function computeTotalBuyAmount(sellAmount, rate) {
+  return computeGiveAmount(sellAmount, rate);
+}
+function computeFillPercentage(order) {
+  if (order.sellAmount === 0n) return 0;
+  const filled = order.sellAmount - order.remainingSellAmount;
+  return Number(filled * 10000n / order.sellAmount) / 100;
+}
+var NoteStore = class {
+  constructor(storage, storageKey = "notes") {
+    this.storage = storage;
+    this.storageKey = storageKey;
+  }
+  notes = [];
+  commitmentSet = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  dirty = false;
+  // ---------- Queries ----------
+  getNotes() {
+    return [...this.notes];
+  }
+  getUnspentNotes(proofSystem) {
+    let result = this.notes.filter((n) => n.status !== "spent");
+    if (proofSystem) {
+      result = result.filter((n) => (n.proofSystem ?? "snark") === proofSystem);
+    }
+    return result;
+  }
+  getBalance(token, proofSystem) {
+    let notes = this.getUnspentNotes(proofSystem);
+    if (token) {
+      const normalized = token.toLowerCase();
+      notes = notes.filter((n) => n.token.toLowerCase() === normalized);
+    }
+    return notes.reduce((sum, n) => sum + n.amount, 0n);
+  }
+  // ---------- Mutations ----------
+  /**
+   * Add a note. Returns false if duplicate (by commitment).
+   * Normalizes token and origin addresses.
+   */
+  addNote(note) {
+    const key = note.commitment.toLowerCase();
+    if (this.commitmentSet.has(key)) return false;
+    const normalized = {
+      ...note,
+      commitment: note.commitment.toLowerCase(),
+      origin: safeGetAddress(note.origin),
+      token: safeGetAddress(note.token)
+    };
+    this.notes.push(normalized);
+    this.commitmentSet.add(key);
+    this.dirty = true;
+    this.notify();
+    return true;
+  }
+  /**
+   * Add multiple notes. Returns count of actually added (non-duplicate).
+   */
+  addNotes(notes) {
+    let added = 0;
+    for (const note of notes) {
+      if (this.addNote(note)) added++;
+    }
+    return added;
+  }
+  /**
+   * Mark a note as spent (optimistic — syncNotes reconciles via nullifier check).
+   */
+  markSpent(commitment) {
+    const key = commitment.toLowerCase();
+    const note = this.notes.find((n) => n.commitment.toLowerCase() === key);
+    if (note && note.status !== "spent") {
+      note.status = "spent";
+      this.dirty = true;
+      this.notify();
+    }
+  }
+  /**
+   * Un-mark a note as spent (reconciliation: nullifier not found on-chain).
+   */
+  unmarkSpent(commitment) {
+    const key = commitment.toLowerCase();
+    const note = this.notes.find((n) => n.commitment.toLowerCase() === key);
+    if (note && note.status === "spent") {
+      note.status = "confirmed";
+      this.dirty = true;
+      this.notify();
+    }
+  }
+  /**
+   * Update the leafIndex for a note (e.g., after confirming on-chain).
+   */
+  updateLeafIndex(commitment, leafIndex) {
+    const key = commitment.toLowerCase();
+    const note = this.notes.find((n) => n.commitment.toLowerCase() === key);
+    if (note && note.leafIndex !== leafIndex) {
+      note.leafIndex = leafIndex;
+      this.dirty = true;
+      this.notify();
+    }
+  }
+  // ---------- Persistence ----------
+  async load() {
+    const serialized = await this.storage.get(this.storageKey);
+    if (!serialized || !Array.isArray(serialized)) {
+      this.notes = [];
+      this.commitmentSet.clear();
+      return;
+    }
+    this.notes = serialized.map(deserializeNote);
+    this.commitmentSet.clear();
+    for (const note of this.notes) {
+      this.commitmentSet.add(note.commitment.toLowerCase());
+    }
+    this.dirty = false;
+  }
+  async persist() {
+    if (!this.dirty) return;
+    const serialized = this.notes.map(serializeNote);
+    await this.storage.set(this.storageKey, serialized);
+    this.dirty = false;
+  }
+  async clear() {
+    this.notes = [];
+    this.commitmentSet.clear();
+    this.dirty = false;
+    await this.storage.delete(this.storageKey);
+    this.notify();
+  }
+  // ---------- Events ----------
+  onChange(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+};
+function serializeNote(note) {
+  return {
+    ...note,
+    amount: note.amount.toString(),
+    blinding: note.blinding.toString()
+  };
+}
+function deserializeNote(s) {
+  return {
+    ...s,
+    amount: BigInt(s.amount),
+    blinding: BigInt(s.blinding),
+    proofSystem: s.proofSystem ?? "snark"
+  };
+}
+function safeGetAddress(addr) {
+  try {
+    return viem.getAddress(addr);
+  } catch {
+    return addr;
+  }
+}
+
+exports.NoteStore = NoteStore;
+exports.RATE_PRECISION = RATE_PRECISION;
+exports.SWAP_EVENTS_ABI = SWAP_EVENTS_ABI;
+exports.SWAP_ORDER_CANCELLED_EVENT = SWAP_ORDER_CANCELLED_EVENT;
+exports.SWAP_ORDER_CLAIMED_EVENT = SWAP_ORDER_CLAIMED_EVENT;
+exports.SWAP_ORDER_FILLED_EVENT = SWAP_ORDER_FILLED_EVENT;
+exports.SWAP_ORDER_PLACED_EVENT = SWAP_ORDER_PLACED_EVENT;
+exports.computeCancelKeyHash = computeCancelKeyHash;
+exports.computeFillPercentage = computeFillPercentage;
+exports.computeGiveAmount = computeGiveAmount;
+exports.computeNoteEncryptionKey = computeNoteEncryptionKey;
+exports.computeRate = computeRate;
+exports.computeTakeAmount = computeTakeAmount;
+exports.computeTotalBuyAmount = computeTotalBuyAmount;
+exports.createOneTimeKeys = createOneTimeKeys;
+exports.decodeStarkStealthAddress = decodeStarkStealthAddress;
+exports.decodeStealthAddress = decodeStealthAddress;
+exports.detectAddressType = detectAddressType;
+exports.encodeStarkStealthAddress = encodeStarkStealthAddress;
+exports.encodeStealthAddress = encodeStealthAddress;
+exports.filterOrdersByASP = filterOrdersByASP;
+exports.filterOrdersByTokenPair = filterOrdersByTokenPair;
+exports.formatRate = formatRate;
+exports.generateCancelSecret = generateCancelSecret;
+exports.generateStarkStealthAddress = generateStarkStealthAddress;
+exports.generateStealthAddress = generateStealthAddress;
+exports.getCancelSecret = getCancelSecret;
+exports.getOwnOrderIds = getOwnOrderIds;
+exports.init_stealth = init_stealth;
+exports.isFillerASPAccepted = isFillerASPAccepted;
+exports.isOrderActive = isOrderActive;
+exports.isValidStarkStealthAddress = isValidStarkStealthAddress;
+exports.isValidStealthAddress = isValidStealthAddress;
+exports.removeCancelSecret = removeCancelSecret;
+exports.stealth_exports = stealth_exports;
+exports.storeCancelSecret = storeCancelSecret;
+exports.verifyOwnership = verifyOwnership;
+//# sourceMappingURL=chunk-GXZ3MTCQ.cjs.map
+//# sourceMappingURL=chunk-GXZ3MTCQ.cjs.map