@permissionless-technologies/upp-sdk 0.1.0

package/dist/chunk-NDM5EJEV.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+var chunkG7VZBCD6_cjs = require('./chunk-G7VZBCD6.cjs');
+var upcSdk = require('@permissionless-technologies/upc-sdk');
+
+var ASP_TREE_DEPTH = upcSdk.DEFAULT_TREE_DEPTH;
+var bn254 = new upcSdk.PoseidonBN254();
+async function computeSingleOriginASPRoot(origin) {
+  return origin;
+}
+async function generateSingleOriginASPProof(aspId, origin) {
+  const proof = upcSdk.generateSingleMemberProof(origin, ASP_TREE_DEPTH);
+  return {
+    aspId,
+    aspRoot: proof.root,
+    aspPathElements: proof.pathElements,
+    aspPathIndices: proof.pathIndices
+  };
+}
+async function verifyASPProof(origin, proof) {
+  return upcSdk.verifyMembershipProof(
+    origin,
+    { root: proof.aspRoot, pathElements: proof.aspPathElements, pathIndices: proof.aspPathIndices },
+    bn254
+  );
+}
+var DEMO_ASP_ID = 1n;
+var DEMO_ASP_NAME = "Demo ASP (Single-Origin)";
+async function createDemoASPRoot(origin) {
+  return computeSingleOriginASPRoot(origin);
+}
+function buildASPTree(origins) {
+  const { buildMerkleTree } = chunkG7VZBCD6_cjs.__require("@permissionless-technologies/upc-sdk");
+  return buildMerkleTree(origins, ASP_TREE_DEPTH, bn254);
+}
+async function computeMultiOriginASPRoot(origins) {
+  return upcSdk.computeMerkleRoot(origins, ASP_TREE_DEPTH, bn254);
+}
+async function generateMultiOriginASPProof(aspId, origin, allOrigins) {
+  if (allOrigins.length <= 1) {
+    return generateSingleOriginASPProof(aspId, origin);
+  }
+  const proof = await upcSdk.generateMembershipProof(origin, allOrigins, ASP_TREE_DEPTH, bn254);
+  return {
+    aspId,
+    aspRoot: proof.root,
+    aspPathElements: proof.pathElements,
+    aspPathIndices: proof.pathIndices
+  };
+}
+async function generateASPProof(aspId, origin, approvedOrigins) {
+  if (approvedOrigins && approvedOrigins.length > 0) {
+    return generateMultiOriginASPProof(aspId, origin, approvedOrigins);
+  }
+  return generateSingleOriginASPProof(aspId, origin);
+}
+
+exports.ASP_TREE_DEPTH = ASP_TREE_DEPTH;
+exports.DEMO_ASP_ID = DEMO_ASP_ID;
+exports.DEMO_ASP_NAME = DEMO_ASP_NAME;
+exports.buildASPTree = buildASPTree;
+exports.computeMultiOriginASPRoot = computeMultiOriginASPRoot;
+exports.computeSingleOriginASPRoot = computeSingleOriginASPRoot;
+exports.createDemoASPRoot = createDemoASPRoot;
+exports.generateASPProof = generateASPProof;
+exports.generateMultiOriginASPProof = generateMultiOriginASPProof;
+exports.generateSingleOriginASPProof = generateSingleOriginASPProof;
+exports.verifyASPProof = verifyASPProof;
+//# sourceMappingURL=chunk-NDM5EJEV.cjs.map
+//# sourceMappingURL=chunk-NDM5EJEV.cjs.map

package/dist/chunk-NDM5EJEV.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/asp.ts"],"names":["DEFAULT_TREE_DEPTH","PoseidonBN254","generateSingleMemberProof","verifyMembershipProof","__require","computeMerkleRoot","generateMembershipProof"],"mappings":";;;;;AAoBO,IAAM,cAAA,GAAiBA;AAI9B,IAAM,KAAA,GAAQ,IAAIC,oBAAA,EAAc;AAmBhC,eAAsB,2BAA2B,MAAA,EAAiC;AAChF,EAAA,OAAO,MAAA;AACT;AAKA,eAAsB,4BAAA,CACpB,OACA,MAAA,EACmB;AACnB,EAAA,MAAM,KAAA,GAAQC,gCAAA,CAA0B,MAAA,EAAQ,cAAc,CAAA;AAC9D,EAAA,OAAO;AAAA,IACL,KAAA;AAAA,IACA,SAAS,KAAA,CAAM,IAAA;AAAA,IACf,iBAAiB,KAAA,CAAM,YAAA;AAAA,IACvB,gBAAgB,KAAA,CAAM;AAAA,GACxB;AACF;AAKA,eAAsB,cAAA,CAAe,QAAgB,KAAA,EAAmC;AACtF,EAAA,OAAOC,4BAAA;AAAA,IACL,MAAA;AAAA,IACA,EAAE,MAAM,KAAA,CAAM,OAAA,EAAS,cAAc,KAAA,CAAM,eAAA,EAAiB,WAAA,EAAa,KAAA,CAAM,cAAA,EAAe;AAAA,IAC9F;AAAA,GACF;AACF;AAKO,IAAM,WAAA,GAAc;AACpB,IAAM,aAAA,GAAgB;AAK7B,eAAsB,kBAAkB,MAAA,EAAiC;AACvE,EAAA,OAAO,2BAA2B,MAAM,CAAA;AAC1C;AAKO,SAAS,aAAa,OAAA,EAAmB;AAC9C,EAAA,MAAM,EAAE,eAAA,EAAgB,GAAIC,2BAAA,CAAQ,sCAAsC,CAAA;AAC1E,EAAA,OAAO,eAAA,CAAgB,OAAA,EAAS,cAAA,EAAgB,KAAK,CAAA;AACvD;AAKA,eAAsB,0BAA0B,OAAA,EAAoC;AAClF,EAAA,OAAOC,wBAAA,CAAkB,OAAA,EAAS,cAAA,EAAgB,KAAK,CAAA;AACzD;AAKA,eAAsB,2BAAA,CACpB,KAAA,EACA,MAAA,EACA,UAAA,EACmB;AACnB,EAAA,IAAI,UAAA,CAAW,UAAU,CAAA,EAAG;AAC1B,IAAA,OAAO,4BAAA,CAA6B,OAAO,MAAM,CAAA;AAAA,EACnD;AAEA,EAAA,MAAM,QAAQ,MAAMC,8BAAA,CAAwB,MAAA,EAAQ,UAAA,EAAY,gBAAgB,KAAK,CAAA;AAErF,EAAA,OAAO;AAAA,IACL,KAAA;AAAA,IACA,SAAS,KAAA,CAAM,IAAA;AAAA,IACf,iBAAiB,KAAA,CAAM,YAAA;AAAA,IACvB,gBAAgB,KAAA,CAAM;AAAA,GACxB;AACF;AAKA,eAAsB,gBAAA,CACpB,KAAA,EACA,MAAA,EACA,eAAA,EACmB;AACnB,EAAA,IAAI,eAAA,IAAmB,eAAA,CAAgB,MAAA,GAAS,CAAA,EAAG;AACjD,IAAA,OAAO,2BAAA,CAA4B,KAAA,EAAO,MAAA,EAAQ,eAAe,CAAA;AAAA,EACnE;AACA,EAAA,OAAO,4BAAA,CAA6B,OAAO,MAAM,CAAA;AACnD","file":"chunk-NDM5EJEV.cjs","sourcesContent":["/**\n * ASP (Association Set Provider) Utilities\n *\n * Thin wrapper around @permissionless-technologies/upc-sdk.\n * Provides pool-specific types (ASPProof with aspId) while delegating\n * Merkle tree operations to the compliance SDK.\n *\n * In UPP, every transfer must prove the origin is in an approved ASP's allowlist.\n */\n\nimport {\n  generateMembershipProof,\n  generateSingleMemberProof,\n  computeMerkleRoot,\n  verifyMembershipProof,\n  DEFAULT_TREE_DEPTH,\n  PoseidonBN254,\n} from '@permissionless-technologies/upc-sdk'\n\n// Re-export tree depth from UPC\nexport const ASP_TREE_DEPTH = DEFAULT_TREE_DEPTH\n\n// Use BN254 for backward compat with existing deployed circuits\n// (circuits were compiled for BN254; new deployments should use BLS12-381)\nconst bn254 = new PoseidonBN254()\n\n/**\n * ASP Merkle proof structure (pool-specific: includes aspId)\n */\nexport interface ASPProof {\n  /** ASP ID */\n  aspId: bigint\n  /** ASP's published root */\n  aspRoot: bigint\n  /** Path elements (siblings) - 20 levels */\n  aspPathElements: bigint[]\n  /** Path indices - 20 levels */\n  aspPathIndices: number[]\n}\n\n/**\n * Compute the ASP root for a single-leaf tree\n */\nexport async function computeSingleOriginASPRoot(origin: bigint): Promise<bigint> {\n  return origin // LeanIMT single-leaf optimization: root = leaf\n}\n\n/**\n * Generate ASP proof for a single-origin tree\n */\nexport async function generateSingleOriginASPProof(\n  aspId: bigint,\n  origin: bigint\n): Promise<ASPProof> {\n  const proof = generateSingleMemberProof(origin, ASP_TREE_DEPTH)\n  return {\n    aspId,\n    aspRoot: proof.root,\n    aspPathElements: proof.pathElements,\n    aspPathIndices: proof.pathIndices,\n  }\n}\n\n/**\n * Verify an ASP proof locally (for debugging)\n */\nexport async function verifyASPProof(origin: bigint, proof: ASPProof): Promise<boolean> {\n  return verifyMembershipProof(\n    origin,\n    { root: proof.aspRoot, pathElements: proof.aspPathElements, pathIndices: proof.aspPathIndices },\n    bn254\n  )\n}\n\n/**\n * Demo ASP configuration\n */\nexport const DEMO_ASP_ID = 1n\nexport const DEMO_ASP_NAME = 'Demo ASP (Single-Origin)'\n\n/**\n * Create a \"universal approval\" ASP root\n */\nexport async function createDemoASPRoot(origin: bigint): Promise<bigint> {\n  return computeSingleOriginASPRoot(origin)\n}\n\n/**\n * Build an ASP Merkle tree from multiple origin addresses\n */\nexport function buildASPTree(origins: bigint[]) {\n  const { buildMerkleTree } = require('@permissionless-technologies/upc-sdk') as typeof import('@permissionless-technologies/upc-sdk')\n  return buildMerkleTree(origins, ASP_TREE_DEPTH, bn254)\n}\n\n/**\n * Compute the Merkle root for a set of approved origins\n */\nexport async function computeMultiOriginASPRoot(origins: bigint[]): Promise<bigint> {\n  return computeMerkleRoot(origins, ASP_TREE_DEPTH, bn254)\n}\n\n/**\n * Generate an ASP membership proof for one origin within a multi-origin tree\n */\nexport async function generateMultiOriginASPProof(\n  aspId: bigint,\n  origin: bigint,\n  allOrigins: bigint[]\n): Promise<ASPProof> {\n  if (allOrigins.length <= 1) {\n    return generateSingleOriginASPProof(aspId, origin)\n  }\n\n  const proof = await generateMembershipProof(origin, allOrigins, ASP_TREE_DEPTH, bn254)\n\n  return {\n    aspId,\n    aspRoot: proof.root,\n    aspPathElements: proof.pathElements,\n    aspPathIndices: proof.pathIndices,\n  }\n}\n\n/**\n * Generate an ASP proof, automatically choosing single-origin or multi-origin\n */\nexport async function generateASPProof(\n  aspId: bigint,\n  origin: bigint,\n  approvedOrigins?: bigint[]\n): Promise<ASPProof> {\n  if (approvedOrigins && approvedOrigins.length > 0) {\n    return generateMultiOriginASPProof(aspId, origin, approvedOrigins)\n  }\n  return generateSingleOriginASPProof(aspId, origin)\n}\n"]}

package/dist/chunk-NUIQHTSA.js

@@ -0,0 +1,489 @@
+import { bigintToBytes, bytesToBigint, randomFieldElement, init_crypto } from './chunk-W77GRBO4.js';
+import { __export, __esm } from './chunk-Z6ZWNWWR.js';
+import { bech32m } from 'bech32';
+import { keccak256, encodeAbiParameters, parseAbiParameters, toHex, getAddress } from 'viem';
+
+// src/core/stealth.ts
+var stealth_exports = {};
+__export(stealth_exports, {
+  ADDRESS_VERSION: () => ADDRESS_VERSION,
+  STARK_ADDRESS_VERSION: () => STARK_ADDRESS_VERSION,
+  STARK_STEALTH_ADDRESS_PREFIX: () => STARK_STEALTH_ADDRESS_PREFIX,
+  STEALTH_ADDRESS_PREFIX: () => 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++] = ADDRESS_VERSION;
+  data[offset++] = chainId >> 24 & 255;
+  data[offset++] = chainId >> 16 & 255;
+  data[offset++] = chainId >> 8 & 255;
+  data[offset++] = chainId & 255;
+  const ownerBytes = bigintToBytes(ownerHash, 32);
+  data.set(ownerBytes, offset);
+  offset += 32;
+  const viewingBytes = bigintToBytes(viewingHash, 32);
+  data.set(viewingBytes, offset);
+  const words = bech32m.toWords(data);
+  return bech32m.encode(STEALTH_ADDRESS_PREFIX, words, BECH32M_LIMIT);
+}
+function decodeStealthAddress(address) {
+  const decoded = bech32m.decode(address, BECH32M_LIMIT);
+  if (decoded.prefix !== STEALTH_ADDRESS_PREFIX) {
+    throw new Error(`Invalid stealth address prefix: expected '${STEALTH_ADDRESS_PREFIX}', got '${decoded.prefix}'`);
+  }
+  const data = new Uint8Array(bech32m.fromWords(decoded.words));
+  let offset = 0;
+  const version = data[offset++];
+  if (version !== ADDRESS_VERSION) {
+    throw new Error(`Unsupported address version: ${version}. Expected v${ADDRESS_VERSION} (hash-based).`);
+  }
+  const chainId = data[offset++] << 24 | data[offset++] << 16 | data[offset++] << 8 | data[offset++];
+  const ownerHash = bytesToBigint(data.slice(offset, offset + 32));
+  offset += 32;
+  const viewingHash = 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-UHTJLWQM.js');
+  if (selfSecret !== void 0) {
+    const ownerHash2 = await poseidon([selfSecret]);
+    return {
+      oneTimeSecret: selfSecret,
+      ownerHash: ownerHash2
+    };
+  }
+  const oneTimeSecret = randomFieldElement();
+  const ownerHash = await poseidon([oneTimeSecret]);
+  return {
+    oneTimeSecret,
+    ownerHash
+  };
+}
+async function verifyOwnership(secret, expectedOwnerHash) {
+  const { poseidon } = await import('./poseidon-UHTJLWQM.js');
+  const computedHash = await poseidon([secret]);
+  return computedHash === expectedOwnerHash;
+}
+async function computeNoteEncryptionKey(viewingSecret, nonce) {
+  const { poseidon } = await import('./poseidon-UHTJLWQM.js');
+  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++] = 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 = bech32m.toWords(data);
+  return bech32m.encode(STARK_STEALTH_ADDRESS_PREFIX, words, BECH32M_LIMIT);
+}
+function decodeStarkStealthAddress(address) {
+  const decoded = bech32m.decode(address, BECH32M_LIMIT);
+  if (decoded.prefix !== STARK_STEALTH_ADDRESS_PREFIX) {
+    throw new Error(
+      `Invalid STARK stealth address prefix: expected '${STARK_STEALTH_ADDRESS_PREFIX}', got '${decoded.prefix}'`
+    );
+  }
+  const data = new Uint8Array(bech32m.fromWords(decoded.words));
+  let offset = 0;
+  const version = data[offset++];
+  if (version !== STARK_ADDRESS_VERSION) {
+    throw new Error(
+      `Unsupported STARK address version: ${version}. Expected v${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(STEALTH_ADDRESS_PREFIX + "1")) return "snark";
+  if (address.startsWith(STARK_STEALTH_ADDRESS_PREFIX + "1")) return "stark";
+  return "unknown";
+}
+var STEALTH_ADDRESS_PREFIX, ADDRESS_VERSION, BECH32M_LIMIT, STARK_STEALTH_ADDRESS_PREFIX, STARK_ADDRESS_VERSION;
+var init_stealth = __esm({
+  "src/core/stealth.ts"() {
+    init_crypto();
+    STEALTH_ADDRESS_PREFIX = "0zk";
+    ADDRESS_VERSION = 2;
+    BECH32M_LIMIT = 1023;
+    STARK_STEALTH_ADDRESS_PREFIX = "0zs";
+    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 keccak256(encodeAbiParameters(
+    parseAbiParameters("bytes32"),
+    [cancelSecret]
+  ));
+}
+function generateCancelSecret() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return 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 getAddress(addr);
+  } catch {
+    return addr;
+  }
+}
+
+export { ADDRESS_VERSION, NoteStore, RATE_PRECISION, STARK_ADDRESS_VERSION, STARK_STEALTH_ADDRESS_PREFIX, STEALTH_ADDRESS_PREFIX, SWAP_EVENTS_ABI, SWAP_ORDER_CANCELLED_EVENT, SWAP_ORDER_CLAIMED_EVENT, SWAP_ORDER_FILLED_EVENT, SWAP_ORDER_PLACED_EVENT, computeCancelKeyHash, computeFillPercentage, computeGiveAmount, computeNoteEncryptionKey, computeRate, computeTakeAmount, computeTotalBuyAmount, createOneTimeKeys, decodeStarkStealthAddress, decodeStealthAddress, detectAddressType, encodeStarkStealthAddress, encodeStealthAddress, filterOrdersByASP, filterOrdersByTokenPair, formatRate, generateCancelSecret, generateStarkStealthAddress, generateStealthAddress, getCancelSecret, getOwnOrderIds, init_stealth, isFillerASPAccepted, isOrderActive, isValidStarkStealthAddress, isValidStealthAddress, removeCancelSecret, stealth_exports, storeCancelSecret, verifyOwnership };
+//# sourceMappingURL=chunk-NUIQHTSA.js.map
+//# sourceMappingURL=chunk-NUIQHTSA.js.map