@obelyzk/sdk 0.5.0

package/dist/obelysk/index.mjs

@@ -0,0 +1,1449 @@
+import {
+  CURVE_ORDER,
+  FIELD_PRIME,
+  GENERATOR_G,
+  GENERATOR_H,
+  ObelyskPrivacy,
+  ecAdd,
+  ecMul,
+  invMod,
+  randomScalar
+} from "../chunk-O2PF7VJA.mjs";
+
+// src/obelysk/client.ts
+import { RpcProvider } from "starknet";
+
+// src/obelysk/privacyPool.ts
+import { CallData, hash as hash2 } from "starknet";
+
+// src/obelysk/contracts.ts
+var MAINNET_RPC = "https://starknet-mainnet.public.blastapi.io/rpc/v0_7";
+var SEPOLIA_RPC = "https://starknet-sepolia.public.blastapi.io/rpc/v0_7";
+function getRpcUrl(network) {
+  return network === "mainnet" ? MAINNET_RPC : SEPOLIA_RPC;
+}
+var MAINNET_CONTRACTS = {
+  sage_token: "0x0098d563900789f934e610b67482ae58793a2efc373ba3a45af94cdbf931c799",
+  confidential_transfer: "0x0673685bdb01fbf57c390ec2c0d893e7c77316cdea315b0fbfbc85b9a9a979d2",
+  privacy_router: "0x00f3fd871ba1b5b176270a7eb9e222c964c50fa8a31234394ea00ce70bfbdfbd",
+  prover_staking: "0x07d2ecff4a4d7ca6c75df367d8dbc7cc12ea583f88813f7020832a7cf7f293e3",
+  dark_pool: "0x0230b5822556f0d9afca7b02f01e37cb9cf2a7e8d590a9020e9bbca183ea7727",
+  shielded_swap: "0x05a7f8a6ab74ee6ab41169118ca2ea21070dc6594bae5a39f5bb9ac50629725b",
+  stealth_registry: "0x077ee4c38201b4e45b643f4af56ff6daf780260e9c8a281f3536fb711afcaea8",
+  otc_orderbook: "0x04165f8fe590e94d7f12e77af72577123b24cbd01101a62b53c3e119fb8bb119",
+  sumcheck_verifier: "0x05071a9428cba9a7e4cbcbf3cee2d16caaaf2b6b9d270a8fb6089a4a97d330e8",
+  vm31_pool: "0x0230eb355e54a98b4511d86585d45d6a5b9075d0ec254877485047b6d651400d",
+  vm31_bridge: "0x048f481c4ada306f5b62d7d223ddd0cf8055a423ffa2b278b3ff767ca9c0356c",
+  privacy_pool_wbtc: "0x030fcfd4ae4f022e720e52f54359258a02517e11701c153ae46ab2cf10d5e5e2",
+  privacy_pool_sage: "0x0224977344d123eb5c20fd088f15b62d0541f8282f4a23dd87bdf9839aac724f",
+  privacy_pool_eth: "0x06d0b41c96809796faa02a5eac2f74e090effd09ccab7274054b90aa671e82b5",
+  privacy_pool_strk: "0x02c348e89b355691ba5e4ece681fd6b497f8ab2ba670fa5842208b251a3c9cf1",
+  privacy_pool_usdc: "0x05d36d7fd19d094ee0fd454e461061d68eb9f4fd0b241e2d1c94320b46d4d59b",
+  tokens: {
+    eth: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
+    strk: "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
+    usdc: "0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8",
+    wbtc: "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
+    sage: "0x0098d563900789f934e610b67482ae58793a2efc373ba3a45af94cdbf931c799"
+  }
+};
+var SEPOLIA_CONTRACTS = {
+  sage_token: "0x072349097c8a802e7f66dc96b95aca84e4d78ddad22014904076c76293a99850",
+  prover_staking: "0x3287a0af5ab2d74fbf968204ce2291adde008d645d42bc363cb741ebfa941b",
+  privacy_router: "0x7d1a6c242a4f0573696e117790f431fd60518a000b85fe5ee507456049ffc53",
+  tokens: {
+    eth: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
+    strk: "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d"
+  }
+};
+function getContracts(network) {
+  return network === "mainnet" ? MAINNET_CONTRACTS : SEPOLIA_CONTRACTS;
+}
+var MAINNET_TOKENS = {
+  eth: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
+  strk: "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
+  usdc: "0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8",
+  wbtc: "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
+  sage: "0x0098d563900789f934e610b67482ae58793a2efc373ba3a45af94cdbf931c799"
+};
+var MAINNET_PRIVACY_POOLS = {
+  eth: "0x06d0b41c96809796faa02a5eac2f74e090effd09ccab7274054b90aa671e82b5",
+  strk: "0x02c348e89b355691ba5e4ece681fd6b497f8ab2ba670fa5842208b251a3c9cf1",
+  usdc: "0x05d36d7fd19d094ee0fd454e461061d68eb9f4fd0b241e2d1c94320b46d4d59b",
+  wbtc: "0x030fcfd4ae4f022e720e52f54359258a02517e11701c153ae46ab2cf10d5e5e2",
+  sage: "0x0224977344d123eb5c20fd088f15b62d0541f8282f4a23dd87bdf9839aac724f"
+};
+var TOKEN_DECIMALS = {
+  eth: 18,
+  strk: 18,
+  usdc: 6,
+  wbtc: 8,
+  sage: 18
+};
+var DARKPOOL_ASSET_IDS = {
+  eth: "0x2",
+  strk: "0x3",
+  usdc: "0x4",
+  wbtc: "0x0",
+  sage: "0x1"
+};
+var VM31_ASSET_IDS = {
+  wbtc: 0,
+  sage: 1,
+  eth: 2,
+  strk: 3,
+  usdc: 4
+};
+function parseAmount(amount, token) {
+  const decimals = TOKEN_DECIMALS[token.toLowerCase()] ?? 18;
+  const parts = String(amount).split(".");
+  const whole = BigInt(parts[0] || "0");
+  const frac = (parts[1] || "").padEnd(decimals, "0").slice(0, decimals);
+  return whole * 10n ** BigInt(decimals) + BigInt(frac);
+}
+function formatAmount(amount, token) {
+  const decimals = TOKEN_DECIMALS[token.toLowerCase()] ?? 18;
+  const divisor = 10n ** BigInt(decimals);
+  const whole = amount / divisor;
+  const frac = (amount % divisor).toString().padStart(decimals, "0");
+  const trimmed = frac.replace(/0+$/, "") || "0";
+  return trimmed === "0" ? whole.toString() : `${whole}.${trimmed}`;
+}
+
+// src/obelysk/crypto.ts
+import { hash } from "starknet";
+function mod(a, m) {
+  const r = a % m;
+  return r < 0n ? r + m : r;
+}
+var modInverse = invMod;
+var ecAdd2 = ecAdd;
+var ecMul2 = ecMul;
+var randomScalar2 = randomScalar;
+function pedersenCommit(value, blinding) {
+  return ecAdd2(
+    ecMul2(mod(value, CURVE_ORDER), GENERATOR_G),
+    ecMul2(mod(blinding, CURVE_ORDER), GENERATOR_H)
+  );
+}
+function elgamalEncrypt(amount, publicKey) {
+  const r = randomScalar2();
+  const c1 = ecMul2(r, GENERATOR_G);
+  const mH = ecMul2(amount, GENERATOR_H);
+  const rPK = ecMul2(r, publicKey);
+  const c2 = ecAdd2(mH, rPK);
+  return { c1, c2, randomness: r };
+}
+function createEncryptionProof(r, c1) {
+  const k = randomScalar2();
+  const commitment = ecMul2(k, GENERATOR_G);
+  const challenge = BigInt(hash.computePoseidonHashOnElements([
+    commitment.x.toString(),
+    commitment.y.toString(),
+    c1.x.toString(),
+    c1.y.toString()
+  ]));
+  const response = mod(k - challenge * r, CURVE_ORDER);
+  return { commitment, challenge, response };
+}
+function createAEHint(amount, sharedSecret) {
+  const encryptedAmount = mod(amount + sharedSecret, FIELD_PRIME);
+  const mac = BigInt(hash.computePoseidonHash(sharedSecret.toString(), encryptedAmount.toString()));
+  return { encryptedAmount, mac };
+}
+function commitmentToHash(point) {
+  return hash.computePoseidonHash(point.x.toString(), point.y.toString());
+}
+function deriveNullifier(nullifierSecret, commitmentHash) {
+  return hash.computePoseidonHash(nullifierSecret.toString(), commitmentHash);
+}
+
+// src/obelysk/privacyPool.ts
+function generateRangeProof32(value, blinding) {
+  if (value < 0n || value >= 1n << 32n) {
+    throw new Error("Value out of 32-bit range");
+  }
+  const value_bits = [];
+  const blinding_bits = [];
+  const bit_commitments = [];
+  let blindingSum = 0n;
+  for (let i = 0; i < 32; i++) {
+    const bit = value >> BigInt(i) & 1n;
+    value_bits.push(bit);
+    let r_i;
+    if (i === 31) {
+      r_i = mod(blinding - blindingSum, CURVE_ORDER);
+    } else {
+      r_i = randomScalar2();
+      blindingSum = mod(blindingSum + r_i * (1n << BigInt(i)), CURVE_ORDER);
+    }
+    blinding_bits.push(r_i);
+    bit_commitments.push(pedersenCommit(bit, r_i));
+  }
+  return { value_bits, blinding_bits, bit_commitments };
+}
+function serializeRangeProof32(proof) {
+  const calldata = [];
+  for (const c of proof.bit_commitments) {
+    calldata.push("0x" + c.x.toString(16));
+    calldata.push("0x" + c.y.toString(16));
+  }
+  for (const r of proof.blinding_bits) {
+    calldata.push("0x" + r.toString(16));
+  }
+  return calldata;
+}
+function deriveNullifier2(nullifierSecret, leafIndex) {
+  return hash2.computePoseidonHash(nullifierSecret.toString(), leafIndex.toString());
+}
+var PrivacyPoolClient = class {
+  constructor(obelysk) {
+    this.obelysk = obelysk;
+  }
+  /**
+   * Deposit tokens into a privacy pool.
+   *
+   * Creates a Pedersen commitment and range proof, then calls the
+   * privacy pool contract's deposit function.
+   *
+   * @returns DepositResult with the note (SAVE THIS for withdrawal)
+   */
+  async deposit(params) {
+    const account = this.obelysk.requireAccount();
+    const poolAddress = this.obelysk.getPrivacyPoolAddress(params.token);
+    const tokenAddress = this.obelysk.getTokenAddress(params.token);
+    const amountWei = parseAmount(params.amount, params.token);
+    const blinding = randomScalar2();
+    const nullifierSecret = randomScalar2();
+    const commitment = pedersenCommit(amountWei, blinding);
+    const commitHash = commitmentToHash(commitment);
+    const rangeProof = generateRangeProof32(amountWei, blinding);
+    const amountLow = amountWei & (1n << 128n) - 1n;
+    const amountHigh = amountWei >> 128n;
+    const calls = [
+      {
+        contractAddress: tokenAddress,
+        entrypoint: "approve",
+        calldata: CallData.compile({
+          spender: poolAddress,
+          amount: { low: amountLow.toString(), high: amountHigh.toString() }
+        })
+      },
+      {
+        contractAddress: poolAddress,
+        entrypoint: "deposit",
+        calldata: CallData.compile({
+          amount: { low: amountLow.toString(), high: amountHigh.toString() },
+          commitment_x: commitment.x.toString(),
+          commitment_y: commitment.y.toString(),
+          range_proof: serializeRangeProof32(rangeProof)
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    const note = {
+      token: params.token,
+      amount: amountWei.toString(),
+      blinding: blinding.toString(),
+      nullifierSecret: nullifierSecret.toString(),
+      commitmentX: commitment.x.toString(),
+      commitmentY: commitment.y.toString(),
+      commitmentHash: commitHash,
+      depositTxHash: result.transaction_hash,
+      createdAt: Date.now()
+    };
+    return { txHash: result.transaction_hash, note, commitmentHash: commitHash };
+  }
+  /**
+   * Withdraw tokens from a privacy pool.
+   *
+   * Requires the original note, a Merkle proof of inclusion,
+   * and the leaf index. The recipient can be any address.
+   */
+  async withdraw(params) {
+    const account = this.obelysk.requireAccount();
+    const poolAddress = this.obelysk.getPrivacyPoolAddress(params.note.token);
+    const leafIndex = params.leafIndex ?? params.note.leafIndex;
+    if (leafIndex === void 0) throw new Error("leafIndex required for withdrawal");
+    const nullifier = deriveNullifier2(BigInt(params.note.nullifierSecret), leafIndex);
+    const amountWei = BigInt(params.note.amount);
+    const amountLow = amountWei & (1n << 128n) - 1n;
+    const amountHigh = amountWei >> 128n;
+    const calls = [
+      {
+        contractAddress: poolAddress,
+        entrypoint: "withdraw",
+        calldata: CallData.compile({
+          amount: { low: amountLow.toString(), high: amountHigh.toString() },
+          nullifier,
+          recipient: params.recipient,
+          commitment_x: params.note.commitmentX,
+          commitment_y: params.note.commitmentY,
+          blinding: params.note.blinding,
+          merkle_proof: params.merkleProof,
+          leaf_index: leafIndex
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return {
+      txHash: result.transaction_hash,
+      amount: formatAmount(amountWei, params.note.token),
+      token: params.note.token
+    };
+  }
+  /**
+   * Read the current global deposit Merkle root of a privacy pool.
+   */
+  async getMerkleRoot(token) {
+    const poolAddress = this.obelysk.getPrivacyPoolAddress(token);
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: poolAddress,
+      entrypoint: "get_global_deposit_root",
+      calldata: []
+    });
+    return result[0];
+  }
+  /**
+   * Get pool stats: (total_deposits, total_withdrawals, total_deposited_amount, total_withdrawn_amount)
+   */
+  async getPoolStats(token) {
+    const poolAddress = this.obelysk.getPrivacyPoolAddress(token);
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: poolAddress,
+      entrypoint: "get_pp_stats",
+      calldata: []
+    });
+    return {
+      totalDeposits: Number(BigInt(result[0])),
+      totalWithdrawals: Number(BigInt(result[1])),
+      totalDeposited: BigInt(result[2]),
+      totalWithdrawn: BigInt(result[3])
+    };
+  }
+  /**
+   * Get the current leaf count (number of deposits) in a privacy pool.
+   */
+  async getLeafCount(token) {
+    const stats = await this.getPoolStats(token);
+    return stats.totalDeposits;
+  }
+  /**
+   * Check if a nullifier has been used (prevents double-withdrawal).
+   */
+  async isNullifierUsed(token, nullifier) {
+    const poolAddress = this.obelysk.getPrivacyPoolAddress(token);
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: poolAddress,
+        entrypoint: "is_pp_nullifier_used",
+        calldata: [nullifier]
+      });
+      return BigInt(result[0]) !== 0n;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if a deposit commitment is valid.
+   */
+  async isDepositValid(token, commitment) {
+    const poolAddress = this.obelysk.getPrivacyPoolAddress(token);
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: poolAddress,
+        entrypoint: "is_pp_deposit_valid",
+        calldata: [commitment]
+      });
+      return BigInt(result[0]) !== 0n;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get fee info for a privacy pool (bps, recipient, accumulated).
+   */
+  async getFeeInfo(token) {
+    const poolAddress = this.obelysk.getPrivacyPoolAddress(token);
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: poolAddress,
+      entrypoint: "get_fee_info",
+      calldata: []
+    });
+    return {
+      feeBps: Number(BigInt(result[0])),
+      feeRecipient: result[1],
+      accumulated: BigInt(result[2])
+    };
+  }
+  /**
+   * Fetch a Merkle proof for a given leaf index from on-chain data.
+   * Reconstructs the tree from deposit events.
+   */
+  async fetchMerkleProof(token, leafIndex) {
+    const poolAddress = this.obelysk.getPrivacyPoolAddress(token);
+    const events = await this.obelysk.provider.getEvents({
+      address: poolAddress,
+      keys: [],
+      from_block: { block_number: 0 },
+      to_block: "latest",
+      chunk_size: 1e3
+    });
+    const leaves = [];
+    for (const event of events.events) {
+      if (event.data.length >= 1) {
+        leaves.push(event.data[0]);
+      }
+    }
+    if (leafIndex >= leaves.length) {
+      throw new Error(`Leaf index ${leafIndex} out of range (${leaves.length} leaves)`);
+    }
+    const { proof, root } = buildMerkleProof(leaves, leafIndex);
+    return { proof, root };
+  }
+};
+function poseidonHash2(a, b) {
+  return hash2.computePoseidonHash(a, b);
+}
+function buildMerkleProof(leaves, leafIndex) {
+  if (leaves.length === 0) throw new Error("Empty tree");
+  let level = [...leaves];
+  const depth = Math.ceil(Math.log2(Math.max(level.length, 2)));
+  while (level.length < 1 << depth) {
+    level.push("0x0");
+  }
+  const proof = [];
+  let idx = leafIndex;
+  for (let d = 0; d < depth; d++) {
+    const siblingIdx = idx ^ 1;
+    proof.push(level[siblingIdx] ?? "0x0");
+    const nextLevel = [];
+    for (let i = 0; i < level.length; i += 2) {
+      nextLevel.push(poseidonHash2(level[i], level[i + 1]));
+    }
+    level = nextLevel;
+    idx >>= 1;
+  }
+  return { proof, root: level[0] };
+}
+
+// src/obelysk/darkPool.ts
+import { CallData as CallData2, hash as hash3 } from "starknet";
+function hashOrder(price, amount, side, giveAsset, wantAsset, salt) {
+  return hash3.computePoseidonHashOnElements([
+    "0x" + price.toString(16),
+    "0x" + amount.toString(16),
+    side.toString(),
+    giveAsset,
+    wantAsset,
+    "0x" + salt.toString(16)
+  ]);
+}
+var DarkPoolClient = class {
+  constructor(obelysk) {
+    this.obelysk = obelysk;
+  }
+  get darkPoolAddress() {
+    const addr = this.obelysk.contracts.dark_pool;
+    if (!addr) throw new Error("DarkPool contract not configured for this network");
+    return addr;
+  }
+  /**
+   * Deposit tokens into the DarkPool for trading.
+   *
+   * Encrypts the amount using ElGamal and generates an AE hint
+   * for O(1) balance decryption.
+   */
+  async deposit(params) {
+    const account = this.obelysk.requireAccount();
+    const tokenAddress = this.obelysk.getTokenAddress(params.token);
+    const assetId = DARKPOOL_ASSET_IDS[params.token.toLowerCase()];
+    if (!assetId) throw new Error(`Unknown DarkPool asset: ${params.token}`);
+    const amountWei = parseAmount(params.amount, params.token);
+    const amountLow = amountWei & (1n << 128n) - 1n;
+    const amountHigh = amountWei >> 128n;
+    const keyPair = this.obelysk.privacy.generateKeyPair();
+    const encrypted = this.obelysk.privacy.encrypt(amountWei, keyPair.publicKey);
+    const nonce = randomScalar2();
+    const sharedSecret = BigInt(hash3.computePoseidonHash(
+      keyPair.privateKey.toString(),
+      nonce.toString()
+    ));
+    const { encryptedAmount, mac } = createAEHint(amountWei, sharedSecret);
+    const calls = [
+      {
+        contractAddress: tokenAddress,
+        entrypoint: "approve",
+        calldata: CallData2.compile({
+          spender: this.darkPoolAddress,
+          amount: { low: amountLow.toString(), high: amountHigh.toString() }
+        })
+      },
+      {
+        contractAddress: this.darkPoolAddress,
+        entrypoint: "deposit",
+        calldata: CallData2.compile({
+          asset: assetId,
+          amount: { low: amountLow.toString(), high: amountHigh.toString() },
+          encrypted_amount: {
+            c1_x: encrypted.c1.x.toString(),
+            c1_y: encrypted.c1.y.toString(),
+            c2_x: encrypted.c2.x.toString(),
+            c2_y: encrypted.c2.y.toString()
+          },
+          ae_hint: {
+            encrypted_amount: encryptedAmount.toString(),
+            nonce: nonce.toString(),
+            mac: mac.toString()
+          }
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash };
+  }
+  /**
+   * Commit an order in the current commit phase.
+   *
+   * Returns order data that must be saved for the reveal phase.
+   */
+  async commitOrder(params) {
+    const account = this.obelysk.requireAccount();
+    const [giveSymbol, wantSymbol] = params.pair.split("/");
+    const giveAsset = DARKPOOL_ASSET_IDS[giveSymbol.toLowerCase()];
+    const wantAsset = DARKPOOL_ASSET_IDS[wantSymbol.toLowerCase()];
+    if (!giveAsset || !wantAsset) throw new Error(`Unknown pair: ${params.pair}`);
+    const price = parseAmount(params.price, "eth");
+    const amount = parseAmount(params.amount, giveSymbol.toLowerCase());
+    const salt = randomScalar2();
+    const side = params.side === "sell" ? 1 : 0;
+    const commitHash = hashOrder(price, amount, side, giveAsset, wantAsset, salt);
+    const amountBlinding = randomScalar2();
+    const amountCommitment = pedersenCommit(amount, amountBlinding);
+    const epochInfo = await this.getEpochInfo();
+    const calls = [
+      {
+        contractAddress: this.darkPoolAddress,
+        entrypoint: "commit_order",
+        calldata: CallData2.compile({
+          order_hash: commitHash,
+          amount_commitment_x: amountCommitment.x.toString(),
+          amount_commitment_y: amountCommitment.y.toString()
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    let orderId = "0";
+    return {
+      orderId,
+      pair: params.pair,
+      side: params.side,
+      price: price.toString(),
+      amount: amount.toString(),
+      salt: salt.toString(),
+      amountBlinding: amountBlinding.toString(),
+      commitHash,
+      epoch: epochInfo.epoch
+    };
+  }
+  /**
+   * Reveal a previously committed order in the reveal phase.
+   */
+  async revealOrder(params) {
+    const account = this.obelysk.requireAccount();
+    const { orderData } = params;
+    const [giveSymbol, wantSymbol] = orderData.pair.split("/");
+    const calls = [
+      {
+        contractAddress: this.darkPoolAddress,
+        entrypoint: "reveal_order",
+        calldata: CallData2.compile({
+          order_id: orderData.orderId,
+          price: orderData.price,
+          amount: orderData.amount,
+          side: orderData.side === "sell" ? 1 : 0,
+          give_asset: DARKPOOL_ASSET_IDS[giveSymbol.toLowerCase()],
+          want_asset: DARKPOOL_ASSET_IDS[wantSymbol.toLowerCase()],
+          salt: orderData.salt,
+          amount_blinding: orderData.amountBlinding
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash };
+  }
+  /**
+   * Get current epoch info from the contract.
+   */
+  async getEpochInfo() {
+    const [epochResult, phaseResult] = await Promise.all([
+      this.obelysk.provider.callContract({
+        contractAddress: this.darkPoolAddress,
+        entrypoint: "get_current_epoch",
+        calldata: []
+      }),
+      this.obelysk.provider.callContract({
+        contractAddress: this.darkPoolAddress,
+        entrypoint: "get_epoch_phase",
+        calldata: []
+      })
+    ]);
+    const epoch = Number(BigInt(epochResult[0]));
+    const phaseNum = Number(BigInt(phaseResult[0]));
+    const phases = ["Commit", "Reveal", "Settle", "Closed"];
+    return {
+      epoch,
+      phase: phases[phaseNum] ?? "Closed",
+      blocksRemaining: 0
+    };
+  }
+  /**
+   * Get the total number of orders ever placed.
+   */
+  async getOrderCount() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.darkPoolAddress,
+      entrypoint: "get_order_count",
+      calldata: []
+    });
+    return Number(BigInt(result[0]));
+  }
+  /**
+   * Get order IDs for a given epoch.
+   */
+  async getEpochOrders(epochId) {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.darkPoolAddress,
+      entrypoint: "get_epoch_orders",
+      calldata: [epochId.toString()]
+    });
+    const len = Number(BigInt(result[0]));
+    return result.slice(1, 1 + len);
+  }
+  /**
+   * Get supported trading pairs.
+   */
+  async getSupportedPairs() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.darkPoolAddress,
+      entrypoint: "get_supported_pairs",
+      calldata: []
+    });
+    const len = Number(BigInt(result[0]));
+    const pairs = [];
+    for (let i = 0; i < len; i++) {
+      pairs.push({
+        giveAsset: result[1 + i * 2],
+        wantAsset: result[2 + i * 2]
+      });
+    }
+    return pairs;
+  }
+  /**
+   * Get fee info (bps, recipient). Returns null if fee module not yet active.
+   */
+  async getFeeInfo() {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.darkPoolAddress,
+        entrypoint: "get_fee_info",
+        calldata: []
+      });
+      return {
+        feeBps: Number(BigInt(result[0])),
+        feeRecipient: result[1]
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Withdraw tokens from the DarkPool.
+   */
+  async withdraw(params) {
+    const account = this.obelysk.requireAccount();
+    const assetId = DARKPOOL_ASSET_IDS[params.token.toLowerCase()];
+    if (!assetId) throw new Error(`Unknown DarkPool asset: ${params.token}`);
+    const amountWei = parseAmount(params.amount, params.token);
+    const amountLow = amountWei & (1n << 128n) - 1n;
+    const amountHigh = amountWei >> 128n;
+    const calls = [
+      {
+        contractAddress: this.darkPoolAddress,
+        entrypoint: "withdraw",
+        calldata: CallData2.compile({
+          asset: assetId,
+          amount: { low: amountLow.toString(), high: amountHigh.toString() }
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash };
+  }
+};
+
+// src/obelysk/stealth.ts
+import { CallData as CallData3, hash as hash4 } from "starknet";
+var StealthClient = class {
+  constructor(obelysk) {
+    this.obelysk = obelysk;
+  }
+  get registryAddress() {
+    const addr = this.obelysk.contracts.stealth_registry;
+    if (!addr) throw new Error("StealthRegistry not configured for this network");
+    return addr;
+  }
+  /**
+   * Look up a recipient's stealth meta-address from the registry.
+   */
+  async lookupRecipient(address) {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.registryAddress,
+        entrypoint: "get_meta_address",
+        calldata: [address]
+      });
+      if (result.length < 4 || result[0] === "0x0") return null;
+      return {
+        spendPublicKey: { x: BigInt(result[0]), y: BigInt(result[1]) },
+        viewPublicKey: { x: BigInt(result[2]), y: BigInt(result[3]) }
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Send tokens to a stealth address.
+   *
+   * Generates ephemeral key, derives stealth address via ECDH,
+   * sends tokens + publishes ephemeral pubkey on-chain.
+   */
+  async send(params) {
+    const account = this.obelysk.requireAccount();
+    const tokenAddress = this.obelysk.getTokenAddress(params.token);
+    const meta = await this.lookupRecipient(params.to);
+    if (!meta) throw new Error(`Recipient ${params.to} not registered in StealthRegistry`);
+    const ephemeralSecret = randomScalar2();
+    const ephemeralPubKey = ecMul2(ephemeralSecret, GENERATOR_G);
+    const sharedPoint = ecMul2(ephemeralSecret, meta.viewPublicKey);
+    const sharedSecretHash = BigInt(hash4.computePoseidonHash(
+      sharedPoint.x.toString(),
+      sharedPoint.y.toString()
+    ));
+    const stealthOffset = ecMul2(sharedSecretHash, GENERATOR_G);
+    const stealthPubKey = ecAdd2(meta.spendPublicKey, stealthOffset);
+    const stealthAddress = "0x" + mod(
+      BigInt(hash4.computePoseidonHash(stealthPubKey.x.toString(), stealthPubKey.y.toString())),
+      FIELD_PRIME
+    ).toString(16);
+    const amountWei = parseAmount(params.amount, params.token);
+    const amountLow = amountWei & (1n << 128n) - 1n;
+    const amountHigh = amountWei >> 128n;
+    const calls = [
+      {
+        contractAddress: tokenAddress,
+        entrypoint: "transfer",
+        calldata: CallData3.compile({
+          recipient: stealthAddress,
+          amount: { low: amountLow.toString(), high: amountHigh.toString() }
+        })
+      },
+      {
+        contractAddress: this.registryAddress,
+        entrypoint: "announce",
+        calldata: CallData3.compile({
+          ephemeral_pub_key_x: ephemeralPubKey.x.toString(),
+          ephemeral_pub_key_y: ephemeralPubKey.y.toString(),
+          stealth_address: stealthAddress,
+          token: tokenAddress
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return {
+      txHash: result.transaction_hash,
+      stealthAddress,
+      ephemeralPubKey: {
+        x: "0x" + ephemeralPubKey.x.toString(16),
+        y: "0x" + ephemeralPubKey.y.toString(16)
+      }
+    };
+  }
+  /**
+   * Check if an address has a registered stealth meta-address.
+   */
+  async hasMetaAddress(address) {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.registryAddress,
+        entrypoint: "has_meta_address",
+        calldata: [address]
+      });
+      return BigInt(result[0]) !== 0n;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the total number of stealth payment announcements.
+   */
+  async getAnnouncementCount() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.registryAddress,
+      entrypoint: "get_announcement_count",
+      calldata: []
+    });
+    return Number(BigInt(result[0]));
+  }
+  /**
+   * Get the total number of registered workers/recipients.
+   */
+  async getRegisteredCount() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.registryAddress,
+      entrypoint: "get_registered_worker_count",
+      calldata: []
+    });
+    return Number(BigInt(result[0]));
+  }
+  /**
+   * Check if a stealth payment announcement has been claimed.
+   */
+  async isClaimed(announcementIndex) {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.registryAddress,
+      entrypoint: "is_claimed",
+      calldata: [announcementIndex.toString()]
+    });
+    return BigInt(result[0]) !== 0n;
+  }
+  /**
+   * Register your stealth meta-address in the registry.
+   */
+  async register(spendPubKey, viewPubKey) {
+    const account = this.obelysk.requireAccount();
+    const calls = [
+      {
+        contractAddress: this.registryAddress,
+        entrypoint: "register_meta_address",
+        calldata: CallData3.compile({
+          spend_pub_key_x: spendPubKey.x.toString(),
+          spend_pub_key_y: spendPubKey.y.toString(),
+          view_pub_key_x: viewPubKey.x.toString(),
+          view_pub_key_y: viewPubKey.y.toString()
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash };
+  }
+};
+
+// src/obelysk/confidentialTransfer.ts
+import { CallData as CallData4, hash as hash5 } from "starknet";
+var ConfidentialTransferClient = class {
+  constructor(obelysk) {
+    this.obelysk = obelysk;
+  }
+  get contractAddress() {
+    const addr = this.obelysk.contracts.confidential_transfer;
+    if (!addr) throw new Error("ConfidentialTransfer not configured for this network");
+    return addr;
+  }
+  /**
+   * Send a confidential transfer with ElGamal encrypted amount.
+   *
+   * Generates encryption proof (Schnorr) to prove the ciphertext is well-formed.
+   */
+  async transfer(params) {
+    const account = this.obelysk.requireAccount();
+    const tokenAddress = this.obelysk.getTokenAddress(params.token);
+    const amountWei = parseAmount(params.amount, params.token);
+    const { c1, c2, randomness } = elgamalEncrypt(amountWei, params.recipientPublicKey);
+    const proof = createEncryptionProof(randomness, c1);
+    const nonce = randomScalar2();
+    const sharedPoint = ecMul2(randomness, params.recipientPublicKey);
+    const sharedSecret = BigInt(hash5.computePoseidonHash(
+      sharedPoint.x.toString(),
+      sharedPoint.y.toString()
+    ));
+    const { encryptedAmount: encryptedHint, mac } = createAEHint(amountWei, sharedSecret);
+    const amountLow = amountWei & (1n << 128n) - 1n;
+    const amountHigh = amountWei >> 128n;
+    const calls = [
+      {
+        contractAddress: tokenAddress,
+        entrypoint: "approve",
+        calldata: CallData4.compile({
+          spender: this.contractAddress,
+          amount: { low: amountLow.toString(), high: amountHigh.toString() }
+        })
+      },
+      {
+        contractAddress: this.contractAddress,
+        entrypoint: "confidential_transfer",
+        calldata: CallData4.compile({
+          recipient: params.to,
+          amount: { low: amountLow.toString(), high: amountHigh.toString() },
+          encrypted_amount: {
+            c1_x: c1.x.toString(),
+            c1_y: c1.y.toString(),
+            c2_x: c2.x.toString(),
+            c2_y: c2.y.toString()
+          },
+          encryption_proof: {
+            commitment_x: proof.commitment.x.toString(),
+            commitment_y: proof.commitment.y.toString(),
+            challenge: proof.challenge.toString(),
+            response: proof.response.toString()
+          },
+          ae_hint: {
+            encrypted_amount: encryptedHint.toString(),
+            nonce: nonce.toString(),
+            mac: mac.toString()
+          }
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash };
+  }
+  /**
+   * Read your encrypted balance from the contract.
+   */
+  async getEncryptedBalance(address, token) {
+    try {
+      const tokenAddress = this.obelysk.getTokenAddress(token);
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.contractAddress,
+        entrypoint: "get_encrypted_balance",
+        calldata: [address, tokenAddress]
+      });
+      if (result.length < 4) return null;
+      return {
+        c1: { x: BigInt(result[0]), y: BigInt(result[1]) },
+        c2: { x: BigInt(result[2]), y: BigInt(result[3]) }
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/obelysk/proverStaking.ts
+import { CallData as CallData5 } from "starknet";
+var GPU_TIER_MAP = {
+  Consumer: 0,
+  Professional: 1,
+  DataCenter: 2,
+  H100: 3
+};
+var ProverStakingClient = class {
+  constructor(obelysk) {
+    this.obelysk = obelysk;
+  }
+  get contractAddress() {
+    const addr = this.obelysk.contracts.prover_staking;
+    if (!addr) throw new Error("ProverStaking not configured for this network");
+    return addr;
+  }
+  /**
+   * Get a worker's current stake info.
+   */
+  async getStake(workerAddress) {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_stake",
+      calldata: [workerAddress]
+    });
+    const tiers = ["Consumer", "Professional", "DataCenter", "H100"];
+    return {
+      amount: BigInt(result[0]),
+      gpuTier: tiers[Number(BigInt(result[1]))] ?? "Consumer",
+      stakedAt: Number(BigInt(result[2])),
+      isActive: BigInt(result[3]) !== 0n,
+      successCount: Number(BigInt(result[4])),
+      failCount: Number(BigInt(result[5]))
+    };
+  }
+  /**
+   * Check if a worker is eligible (staked enough, not in cooldown).
+   */
+  async isEligible(workerAddress) {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "is_eligible",
+      calldata: [workerAddress]
+    });
+    return BigInt(result[0]) !== 0n;
+  }
+  /**
+   * Get minimum stake required for a GPU tier.
+   */
+  async getMinStake(tier) {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_min_stake",
+      calldata: [GPU_TIER_MAP[tier].toString()]
+    });
+    return BigInt(result[0]);
+  }
+  /**
+   * Get total SAGE staked across all workers.
+   */
+  async getTotalStaked() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "total_staked",
+      calldata: []
+    });
+    return BigInt(result[0]);
+  }
+  /**
+   * Get total SAGE slashed.
+   */
+  async getTotalSlashed() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "total_slashed",
+      calldata: []
+    });
+    return BigInt(result[0]);
+  }
+  /**
+   * Get staking configuration.
+   */
+  async getConfig() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_config",
+      calldata: []
+    });
+    return {
+      minStakeConsumer: BigInt(result[0]),
+      minStakeProfessional: BigInt(result[1]),
+      minStakeDataCenter: BigInt(result[2]),
+      minStakeH100: BigInt(result[3]),
+      cooldownPeriod: Number(BigInt(result[4])),
+      slashPercent: Number(BigInt(result[5])),
+      rewardRateBps: Number(BigInt(result[6]))
+    };
+  }
+  /**
+   * Stake SAGE tokens to become a prover.
+   */
+  async stake(amount, tier) {
+    const account = this.obelysk.requireAccount();
+    const sageToken = this.obelysk.getTokenAddress("sage");
+    const amountWei = parseAmount(amount, "sage");
+    const amountLow = amountWei & (1n << 128n) - 1n;
+    const amountHigh = amountWei >> 128n;
+    const calls = [
+      {
+        contractAddress: sageToken,
+        entrypoint: "approve",
+        calldata: CallData5.compile({
+          spender: this.contractAddress,
+          amount: { low: amountLow.toString(), high: amountHigh.toString() }
+        })
+      },
+      {
+        contractAddress: this.contractAddress,
+        entrypoint: "stake",
+        calldata: CallData5.compile({
+          amount: { low: amountLow.toString(), high: amountHigh.toString() },
+          gpu_tier: GPU_TIER_MAP[tier].toString()
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash };
+  }
+  /**
+   * Request unstaking (starts cooldown period).
+   */
+  async requestUnstake(amount) {
+    const account = this.obelysk.requireAccount();
+    const amountWei = parseAmount(amount, "sage");
+    const amountLow = amountWei & (1n << 128n) - 1n;
+    const amountHigh = amountWei >> 128n;
+    const calls = [
+      {
+        contractAddress: this.contractAddress,
+        entrypoint: "request_unstake",
+        calldata: CallData5.compile({
+          amount: { low: amountLow.toString(), high: amountHigh.toString() }
+        })
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash };
+  }
+  /**
+   * Complete unstaking after cooldown period.
+   */
+  async completeUnstake() {
+    const account = this.obelysk.requireAccount();
+    const calls = [
+      {
+        contractAddress: this.contractAddress,
+        entrypoint: "complete_unstake",
+        calldata: []
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash };
+  }
+  /**
+   * Claim accumulated staking rewards.
+   */
+  async claimRewards() {
+    const account = this.obelysk.requireAccount();
+    const calls = [
+      {
+        contractAddress: this.contractAddress,
+        entrypoint: "claim_rewards",
+        calldata: []
+      }
+    ];
+    const result = await account.execute(calls);
+    await this.obelysk.provider.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash };
+  }
+};
+
+// src/obelysk/privacyRouter.ts
+var PrivacyRouterClient = class {
+  constructor(obelysk) {
+    this.obelysk = obelysk;
+  }
+  get contractAddress() {
+    const addr = this.obelysk.contracts.privacy_router;
+    if (!addr) throw new Error("PrivacyRouter not configured for this network");
+    return addr;
+  }
+  /**
+   * Get a registered private account's info.
+   */
+  async getAccount(address) {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.contractAddress,
+        entrypoint: "get_account",
+        calldata: [address]
+      });
+      if (result.length < 8) return null;
+      return {
+        publicKey: { x: BigInt(result[0]), y: BigInt(result[1]) },
+        encryptedBalance: {
+          c1: { x: BigInt(result[2]), y: BigInt(result[3]) },
+          c2: { x: BigInt(result[4]), y: BigInt(result[5]) }
+        },
+        registered: BigInt(result[6]) !== 0n
+      };
+    } catch {
+      return null;
+    }
+  }
+  /** Check if a nullifier has been spent. */
+  async isNullifierUsed(nullifier) {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.contractAddress,
+        entrypoint: "is_nullifier_used",
+        calldata: [nullifier]
+      });
+      return BigInt(result[0]) !== 0n;
+    } catch {
+      return false;
+    }
+  }
+  /** Get the current nullifier tree root. */
+  async getNullifierTreeRoot() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_nullifier_tree_root",
+      calldata: []
+    });
+    return result[0];
+  }
+  /** Get the current epoch of the privacy router. */
+  async getCurrentEpoch() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_current_epoch",
+      calldata: []
+    });
+    return Number(BigInt(result[0]));
+  }
+  /** Get total nullifier count. */
+  async getNullifierCount() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_nullifier_count",
+      calldata: []
+    });
+    return Number(BigInt(result[0]));
+  }
+  /** Check if an asset ID is supported. */
+  async isAssetSupported(assetId) {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.contractAddress,
+        entrypoint: "is_asset_supported",
+        calldata: [assetId.toString()]
+      });
+      return BigInt(result[0]) !== 0n;
+    } catch {
+      return false;
+    }
+  }
+  /** Get the token address for an asset ID. */
+  async getAssetToken(assetId) {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_asset_token",
+      calldata: [assetId.toString()]
+    });
+    return result[0];
+  }
+  /** Get the number of auditors. */
+  async getAuditorCount() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_auditor_count",
+      calldata: []
+    });
+    return Number(BigInt(result[0]));
+  }
+  /** Check if an address is a registered auditor. */
+  async isAuditor(address) {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.contractAddress,
+        entrypoint: "is_auditor",
+        calldata: [address]
+      });
+      return BigInt(result[0]) !== 0n;
+    } catch {
+      return false;
+    }
+  }
+  /** Get the audit approval threshold. */
+  async getAuditThreshold() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_audit_threshold",
+      calldata: []
+    });
+    return Number(BigInt(result[0]));
+  }
+  /** Get the large transfer threshold. */
+  async getLargeTransferThreshold() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_large_transfer_threshold",
+      calldata: []
+    });
+    return BigInt(result[0]);
+  }
+  /** Check if the Lean IMT is active. */
+  async isLeanIMTActive() {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.contractAddress,
+        entrypoint: "is_lean_imt_active",
+        calldata: []
+      });
+      return BigInt(result[0]) !== 0n;
+    } catch {
+      return false;
+    }
+  }
+  /** Get pending audit/disclosure request count. */
+  async getPendingRequestCount() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_pending_request_count",
+      calldata: []
+    });
+    return Number(BigInt(result[0]));
+  }
+};
+
+// src/obelysk/shieldedSwap.ts
+var ShieldedSwapClient = class {
+  constructor(obelysk) {
+    this.obelysk = obelysk;
+  }
+  get contractAddress() {
+    const addr = this.obelysk.contracts.shielded_swap;
+    if (!addr) throw new Error("ShieldedSwap not configured for this network");
+    return addr;
+  }
+  /** Get total number of shielded swaps executed. */
+  async getSwapCount() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_swap_count",
+      calldata: []
+    });
+    return Number(BigInt(result[0]));
+  }
+  /** Get the privacy pool address registered for a token. */
+  async getPool(tokenAddress) {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.contractAddress,
+        entrypoint: "get_pool",
+        calldata: [tokenAddress]
+      });
+      return result[0] === "0x0" ? null : result[0];
+    } catch {
+      return null;
+    }
+  }
+  /** Get the Ekubo core address (AMM integration). */
+  async getEkuboCore() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "get_ekubo_core",
+      calldata: []
+    });
+    return result[0];
+  }
+  /** Get swap fee info (bps, recipient). Returns null if not active. */
+  async getSwapFeeInfo() {
+    try {
+      const result = await this.obelysk.provider.callContract({
+        contractAddress: this.contractAddress,
+        entrypoint: "get_swap_fee_info",
+        calldata: []
+      });
+      return {
+        feeBps: Number(BigInt(result[0])),
+        feeRecipient: result[1]
+      };
+    } catch {
+      return null;
+    }
+  }
+  /** Get contract owner. */
+  async getOwner() {
+    const result = await this.obelysk.provider.callContract({
+      contractAddress: this.contractAddress,
+      entrypoint: "owner",
+      calldata: []
+    });
+    return result[0];
+  }
+};
+
+// src/obelysk/client.ts
+var ObelyskClient = class {
+  network;
+  provider;
+  account;
+  privacy;
+  contracts;
+  tokens;
+  privacyPools;
+  /** Privacy Pool operations (deposit/withdraw shielded tokens) */
+  privacyPool;
+  /** DarkPool batch auction trading */
+  darkPool;
+  /** Stealth address payments */
+  stealth;
+  /** Confidential peer-to-peer transfers */
+  confidentialTransfer;
+  /** SAGE prover staking (stake/unstake/rewards) */
+  staking;
+  /** Privacy Router (private balances, nullifiers, auditing) */
+  router;
+  /** Shielded swap router (privacy-preserving AMM swaps) */
+  swap;
+  constructor(config) {
+    this.network = config.network;
+    this.provider = new RpcProvider({ nodeUrl: config.rpcUrl ?? getRpcUrl(config.network) });
+    this.account = config.account;
+    this.contracts = getContracts(config.network);
+    this.tokens = this.contracts.tokens ?? MAINNET_TOKENS;
+    this.privacyPools = config.network === "mainnet" ? MAINNET_PRIVACY_POOLS : {};
+    this.privacy = new ObelyskPrivacy();
+    if (config.privacyPrivateKey) {
+      const pk = BigInt(config.privacyPrivateKey);
+      this.privacy.setKeyPair(pk);
+    }
+    this.privacyPool = new PrivacyPoolClient(this);
+    this.darkPool = new DarkPoolClient(this);
+    this.stealth = new StealthClient(this);
+    this.confidentialTransfer = new ConfidentialTransferClient(this);
+    this.staking = new ProverStakingClient(this);
+    this.router = new PrivacyRouterClient(this);
+    this.swap = new ShieldedSwapClient(this);
+  }
+  /** Get token address by symbol */
+  getTokenAddress(symbol) {
+    const addr = this.tokens[symbol.toLowerCase()];
+    if (!addr) throw new Error(`Unknown token: ${symbol}`);
+    return addr;
+  }
+  /** Get privacy pool address for a token */
+  getPrivacyPoolAddress(symbol) {
+    const addr = this.privacyPools[symbol.toLowerCase()];
+    if (!addr) throw new Error(`No privacy pool for: ${symbol}`);
+    return addr;
+  }
+  /** Require an account is set */
+  requireAccount() {
+    if (!this.account) throw new Error("ObelyskClient: account required for transactions");
+    return this.account;
+  }
+};
+export {
+  CURVE_ORDER,
+  ConfidentialTransferClient,
+  DARKPOOL_ASSET_IDS,
+  DarkPoolClient,
+  FIELD_PRIME,
+  GENERATOR_G,
+  GENERATOR_H,
+  MAINNET_PRIVACY_POOLS,
+  MAINNET_TOKENS,
+  ObelyskClient,
+  ObelyskPrivacy,
+  PrivacyPoolClient,
+  PrivacyRouterClient,
+  ProverStakingClient,
+  ShieldedSwapClient,
+  StealthClient,
+  TOKEN_DECIMALS,
+  VM31_ASSET_IDS,
+  commitmentToHash,
+  createAEHint,
+  createEncryptionProof,
+  deriveNullifier,
+  ecAdd2 as ecAdd,
+  ecMul2 as ecMul,
+  elgamalEncrypt,
+  formatAmount,
+  getContracts,
+  getRpcUrl,
+  mod,
+  modInverse,
+  parseAmount,
+  pedersenCommit,
+  randomScalar2 as randomScalar
+};