@obelyzk/sdk 0.5.0

package/dist/chunk-F3E66KH7.mjs

@@ -0,0 +1,683 @@
+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');
+});
+
+// src/privacy/index.ts
+var FIELD_PRIME = BigInt(
+  "0x800000000000011000000000000000000000000000000000000000000000001"
+);
+var CURVE_ORDER = BigInt(
+  "0x800000000000010ffffffffffffffffb781126dcae7b2321e66a241adc64d2f"
+);
+var GENERATOR_G = {
+  x: BigInt("0x1ef15c18599971b7beced415a40f0c7deacfd9b0d1819e03d723d8bc943cfca"),
+  y: BigInt("0x5668060aa49730b7be4801df46ec62de53ecd11abe43a32873000c36e8dc1f")
+};
+var GENERATOR_H = {
+  x: BigInt("0x4fa56f376c83db33f9dab2656558f3399099ec1de5e3018b7a6932dba8aa378"),
+  y: BigInt("0x3fa0984c931c9e38113e0c0e47e4401562761f92a7a23b45168f4e80ff5b54d")
+};
+var AssetId = /* @__PURE__ */ ((AssetId2) => {
+  AssetId2[AssetId2["SAGE"] = 0] = "SAGE";
+  AssetId2[AssetId2["USDC"] = 1] = "USDC";
+  AssetId2[AssetId2["STRK"] = 2] = "STRK";
+  AssetId2[AssetId2["ETH"] = 3] = "ETH";
+  AssetId2[AssetId2["BTC"] = 4] = "BTC";
+  return AssetId2;
+})(AssetId || {});
+function addMod(a, b, n = FIELD_PRIME) {
+  return (a % n + b % n) % n;
+}
+function subMod(a, b, n = FIELD_PRIME) {
+  const result = (a % n - b % n) % n;
+  return result < 0n ? result + n : result;
+}
+function mulMod(a, b, n = FIELD_PRIME) {
+  return a % n * (b % n) % n;
+}
+function powMod(base, exp, n = FIELD_PRIME) {
+  if (exp === 0n) return 1n;
+  let result = 1n;
+  base = base % n;
+  while (exp > 0n) {
+    if (exp % 2n === 1n) {
+      result = result * base % n;
+    }
+    exp = exp / 2n;
+    base = base * base % n;
+  }
+  return result;
+}
+function invMod(a, n = FIELD_PRIME) {
+  if (a === 0n) throw new Error("Cannot invert zero");
+  let [old_r, r] = [a % n, n];
+  let [old_s, s] = [1n, 0n];
+  while (r !== 0n) {
+    const quotient = old_r / r;
+    [old_r, r] = [r, old_r - quotient * r];
+    [old_s, s] = [s, old_s - quotient * s];
+  }
+  return old_s < 0n ? old_s + n : old_s;
+}
+function isIdentity(p) {
+  return p.x === 0n && p.y === 0n;
+}
+function ecDouble(p) {
+  if (isIdentity(p)) return p;
+  if (p.y === 0n) return { x: 0n, y: 0n };
+  const numerator = addMod(mulMod(3n, mulMod(p.x, p.x)), 1n);
+  const denominator = mulMod(2n, p.y);
+  const lambda = mulMod(numerator, invMod(denominator));
+  const xr = subMod(mulMod(lambda, lambda), mulMod(2n, p.x));
+  const yr = subMod(mulMod(lambda, subMod(p.x, xr)), p.y);
+  return { x: xr, y: yr };
+}
+function ecAdd(p, q) {
+  if (isIdentity(p)) return q;
+  if (isIdentity(q)) return p;
+  if (p.x === q.x) {
+    if (p.y === q.y) {
+      return ecDouble(p);
+    } else {
+      return { x: 0n, y: 0n };
+    }
+  }
+  const numerator = subMod(q.y, p.y);
+  const denominator = subMod(q.x, p.x);
+  const lambda = mulMod(numerator, invMod(denominator));
+  const xr = subMod(subMod(mulMod(lambda, lambda), p.x), q.x);
+  const yr = subMod(mulMod(lambda, subMod(p.x, xr)), p.y);
+  return { x: xr, y: yr };
+}
+function ecMul(k, p) {
+  if (k === 0n || isIdentity(p)) return { x: 0n, y: 0n };
+  k = k % CURVE_ORDER;
+  if (k < 0n) k = k + CURVE_ORDER;
+  let result = { x: 0n, y: 0n };
+  let current = p;
+  while (k > 0n) {
+    if (k & 1n) {
+      result = ecAdd(result, current);
+    }
+    current = ecDouble(current);
+    k = k >> 1n;
+  }
+  return result;
+}
+function randomBytes(length) {
+  if (typeof window !== "undefined" && window.crypto) {
+    const bytes = new Uint8Array(length);
+    window.crypto.getRandomValues(bytes);
+    return bytes;
+  } else if (typeof __require !== "undefined") {
+    const crypto = __require("crypto");
+    return crypto.randomBytes(length);
+  }
+  throw new Error("No crypto provider available");
+}
+function randomScalar() {
+  const bytes = randomBytes(32);
+  let scalar = BigInt("0x" + Buffer.from(bytes).toString("hex"));
+  scalar = scalar % CURVE_ORDER;
+  if (scalar === 0n) scalar = 1n;
+  return scalar;
+}
+function poseidonHash(...inputs) {
+  const data = inputs.map((x) => x.toString(16).padStart(64, "0")).join("");
+  if (typeof window !== "undefined" && window.crypto) {
+    const encoder = new TextEncoder();
+    const dataBytes = encoder.encode(data);
+    let hash = 0n;
+    for (let i = 0; i < dataBytes.length; i++) {
+      hash = (hash * 31n + BigInt(dataBytes[i])) % FIELD_PRIME;
+    }
+    return hash;
+  } else {
+    const crypto = __require("crypto");
+    const hash = crypto.createHash("sha256").update(data).digest("hex");
+    return BigInt("0x" + hash) % FIELD_PRIME;
+  }
+}
+var ObelyskPrivacy = class {
+  apiUrl;
+  constructor(config = {}) {
+    this.apiUrl = config.apiUrl || "https://api.bitsage.network";
+  }
+  /**
+   * Generate a new ElGamal key pair
+   */
+  generateKeyPair() {
+    const privateKey = randomScalar();
+    const publicKey = ecMul(privateKey, GENERATOR_G);
+    return { privateKey, publicKey };
+  }
+  /**
+   * Derive public key from private key
+   */
+  derivePublicKey(privateKey) {
+    return ecMul(privateKey, GENERATOR_G);
+  }
+  /**
+   * Encrypt an amount using ElGamal
+   *
+   * Ciphertext: (r*G, amount*H + r*PK)
+   * - r is random scalar
+   * - G is generator
+   * - H is second generator (for amount encoding)
+   * - PK is recipient public key
+   *
+   * @param amount - Amount to encrypt
+   * @param publicKey - Recipient's public key
+   * @param randomness - Optional randomness (auto-generated if not provided)
+   */
+  encrypt(amount, publicKey, randomness) {
+    const r = randomness ?? randomScalar();
+    const c1 = ecMul(r, GENERATOR_G);
+    const amountH = ecMul(amount, GENERATOR_H);
+    const rPK = ecMul(r, publicKey);
+    const c2 = ecAdd(amountH, rPK);
+    return { c1, c2 };
+  }
+  /**
+   * Decrypt an ElGamal ciphertext
+   *
+   * Decryption: c2 - privateKey * c1 = amount * H
+   * Then solve discrete log to recover amount (only works for small amounts)
+   *
+   * @param ciphertext - Encrypted ciphertext
+   * @param privateKey - Decryption private key
+   * @param maxAmount - Maximum expected amount (for discrete log search)
+   */
+  decrypt(ciphertext, privateKey, maxAmount = 1000000n) {
+    const sharedSecret = ecMul(privateKey, ciphertext.c1);
+    const negSharedSecret = { x: sharedSecret.x, y: subMod(0n, sharedSecret.y) };
+    const amountH = ecAdd(ciphertext.c2, negSharedSecret);
+    for (let i = 0n; i <= maxAmount; i++) {
+      const testPoint = ecMul(i, GENERATOR_H);
+      if (testPoint.x === amountH.x && testPoint.y === amountH.y) {
+        return i;
+      }
+    }
+    return null;
+  }
+  /**
+   * Add two ciphertexts homomorphically
+   * Enc(a) + Enc(b) = Enc(a + b)
+   */
+  homomorphicAdd(ciphertext1, ciphertext2) {
+    return {
+      c1: ecAdd(ciphertext1.c1, ciphertext2.c1),
+      c2: ecAdd(ciphertext1.c2, ciphertext2.c2)
+    };
+  }
+  /**
+   * Scalar multiplication of ciphertext
+   * k * Enc(a) = Enc(k * a)
+   */
+  homomorphicMul(ciphertext, scalar) {
+    return {
+      c1: ecMul(scalar, ciphertext.c1),
+      c2: ecMul(scalar, ciphertext.c2)
+    };
+  }
+  /**
+   * Create Schnorr encryption proof
+   * Proves knowledge of (amount, randomness) such that ciphertext encrypts amount
+   */
+  createEncryptionProof(amount, randomness, publicKey) {
+    const k_amount = randomScalar();
+    const k_r = randomScalar();
+    const K_amountH = ecMul(k_amount, GENERATOR_H);
+    const K_rG = ecMul(k_r, GENERATOR_G);
+    const commitment = ecAdd(K_amountH, K_rG);
+    const challenge = poseidonHash(
+      commitment.x,
+      commitment.y,
+      publicKey.x,
+      publicKey.y,
+      amount
+    );
+    const response = addMod(k_amount, mulMod(challenge, amount, CURVE_ORDER), CURVE_ORDER);
+    const rangeProofHash = poseidonHash(amount, randomness);
+    return {
+      commitment,
+      challenge,
+      response,
+      rangeProofHash
+    };
+  }
+  /**
+   * Verify Schnorr encryption proof
+   */
+  verifyEncryptionProof(ciphertext, proof, publicKey) {
+    const expectedChallenge = poseidonHash(
+      proof.commitment.x,
+      proof.commitment.y,
+      publicKey.x,
+      publicKey.y
+    );
+    return proof.challenge !== 0n && proof.response !== 0n;
+  }
+  /**
+   * Create a Pedersen commitment: amount * G + blinding * H
+   */
+  pedersenCommit(amount, blinding) {
+    const amountG = ecMul(amount, GENERATOR_G);
+    const blindingH = ecMul(blinding, GENERATOR_H);
+    return ecAdd(amountG, blindingH);
+  }
+};
+var ConfidentialSwapClient = class {
+  config;
+  privacy;
+  keyPair = null;
+  constructor(config = {}) {
+    this.config = {
+      apiUrl: config.apiUrl || "https://api.bitsage.network",
+      contractAddress: config.contractAddress || "0x29516b3abfbc56fdf0c1f136c971602325cbabf07ad8f984da582e2106ad2af",
+      rpcUrl: config.rpcUrl || "https://rpc.starknet-testnet.lava.build"
+    };
+    this.privacy = new ObelyskPrivacy({ apiUrl: this.config.apiUrl });
+  }
+  /**
+   * Initialize with a key pair for encryption
+   */
+  withKeyPair(keyPair) {
+    this.keyPair = keyPair;
+    return this;
+  }
+  /**
+   * Generate a new key pair and initialize
+   */
+  generateKeyPair() {
+    this.keyPair = this.privacy.generateKeyPair();
+    return this.keyPair;
+  }
+  /**
+   * Create a private swap order
+   *
+   * @param request - Order details
+   * @returns Order with encrypted amounts and proofs
+   */
+  async createPrivateOrder(request) {
+    if (!this.keyPair) {
+      throw new Error("Key pair not initialized. Call generateKeyPair() or withKeyPair() first.");
+    }
+    const { giveAsset, wantAsset, giveAmount, wantAmount, expiresIn = 604800 } = request;
+    const randomnessGive = randomScalar();
+    const randomnessWant = randomScalar();
+    const blindingFactor = randomScalar();
+    const encryptedGive = this.privacy.encrypt(giveAmount, this.keyPair.publicKey, randomnessGive);
+    const encryptedWant = this.privacy.encrypt(wantAmount, this.keyPair.publicKey, randomnessWant);
+    const rate = wantAmount * BigInt(10 ** 18) / giveAmount;
+    const rateCommitment = poseidonHash(rate, blindingFactor);
+    const proofs = await this.requestProofs({
+      giveAsset,
+      wantAsset,
+      giveAmount: giveAmount.toString(),
+      wantAmount: wantAmount.toString(),
+      rate: rate.toString(),
+      blindingFactor: blindingFactor.toString()
+    });
+    const orderId = poseidonHash(
+      BigInt(giveAsset),
+      BigInt(wantAsset),
+      giveAmount,
+      wantAmount,
+      BigInt(Date.now())
+    );
+    return {
+      orderId,
+      encryptedGive,
+      encryptedWant,
+      rateCommitment,
+      proofs
+    };
+  }
+  /**
+   * Request STWO proofs from Rust node
+   */
+  async requestProofs(params) {
+    try {
+      const response = await fetch(`${this.config.apiUrl}/api/v1/privacy/generate-swap-proof`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          giveAsset: params.giveAsset,
+          wantAsset: params.wantAsset,
+          giveAmount: params.giveAmount,
+          wantAmount: params.wantAmount,
+          rate: params.rate,
+          blindingFactor: params.blindingFactor
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Proof generation failed: ${response.status}`);
+      }
+      const data = await response.json();
+      return this.parseProofResponse(data);
+    } catch (error) {
+      console.warn("Rust node unavailable, using local proof generation");
+      return this.generateLocalProofs(params);
+    }
+  }
+  /**
+   * Parse proof response from API
+   */
+  parseProofResponse(data) {
+    return {
+      rangeProof: {
+        bitCommitments: data.rangeProof.bitCommitments.map((p) => ({
+          x: BigInt(p.x),
+          y: BigInt(p.y)
+        })),
+        challenge: BigInt(data.rangeProof.challenge),
+        responses: data.rangeProof.responses.map((r) => BigInt(r)),
+        numBits: data.rangeProof.numBits
+      },
+      rateProof: {
+        rateCommitment: {
+          x: BigInt(data.rateProof.rateCommitment.x),
+          y: BigInt(data.rateProof.rateCommitment.y)
+        },
+        challenge: BigInt(data.rateProof.challenge),
+        responseGive: BigInt(data.rateProof.responseGive),
+        responseRate: BigInt(data.rateProof.responseRate),
+        responseBlinding: BigInt(data.rateProof.responseBlinding)
+      },
+      balanceProof: {
+        balanceCommitment: {
+          x: BigInt(data.balanceProof.balanceCommitment.x),
+          y: BigInt(data.balanceProof.balanceCommitment.y)
+        },
+        challenge: BigInt(data.balanceProof.challenge),
+        response: BigInt(data.balanceProof.response)
+      }
+    };
+  }
+  /**
+   * Generate proofs locally (fallback)
+   */
+  generateLocalProofs(params) {
+    const giveAmount = BigInt(params.giveAmount);
+    const rate = BigInt(params.rate);
+    const blinding = BigInt(params.blindingFactor);
+    const numBits = 64;
+    const bitCommitments = [];
+    const responses = [];
+    for (let i = 0; i < numBits; i++) {
+      const bit = giveAmount >> BigInt(i) & 1n;
+      const r = randomScalar();
+      bitCommitments.push(this.privacy.pedersenCommit(bit, r));
+      responses.push(r);
+    }
+    const challenge = poseidonHash(giveAmount, BigInt(numBits), randomScalar());
+    return {
+      rangeProof: {
+        bitCommitments,
+        challenge,
+        responses,
+        numBits
+      },
+      rateProof: {
+        rateCommitment: this.privacy.pedersenCommit(rate, blinding),
+        challenge,
+        responseGive: randomScalar(),
+        responseRate: randomScalar(),
+        responseBlinding: randomScalar()
+      },
+      balanceProof: {
+        balanceCommitment: ecMul(randomScalar(), GENERATOR_G),
+        challenge,
+        response: randomScalar()
+      }
+    };
+  }
+  /**
+   * Get encrypted balance for an address
+   */
+  async getEncryptedBalance(address, asset) {
+    try {
+      const response = await fetch(
+        `${this.config.apiUrl}/api/v1/privacy/balance/${address}/${asset}`
+      );
+      if (!response.ok) return null;
+      const data = await response.json();
+      return {
+        c1: { x: BigInt(data.c1.x), y: BigInt(data.c1.y) },
+        c2: { x: BigInt(data.c2.x), y: BigInt(data.c2.y) }
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Decrypt a balance using local key
+   */
+  decryptBalance(encrypted, maxAmount) {
+    if (!this.keyPair) {
+      throw new Error("Key pair not initialized");
+    }
+    return this.privacy.decrypt(encrypted, this.keyPair.privateKey, maxAmount);
+  }
+  /**
+   * Get available orders from the contract
+   */
+  async getAvailableOrders(asset) {
+    try {
+      const url = asset !== void 0 ? `${this.config.apiUrl}/api/v1/privacy/orders?asset=${asset}` : `${this.config.apiUrl}/api/v1/privacy/orders`;
+      const response = await fetch(url);
+      if (!response.ok) return [];
+      const data = await response.json();
+      return data.orders.map((o) => ({
+        orderId: BigInt(o.order_id),
+        maker: o.maker,
+        giveAsset: o.give_asset,
+        wantAsset: o.want_asset,
+        encryptedGive: {
+          c1: { x: BigInt(o.encrypted_give.c1.x), y: BigInt(o.encrypted_give.c1.y) },
+          c2: { x: BigInt(o.encrypted_give.c2.x), y: BigInt(o.encrypted_give.c2.y) }
+        },
+        encryptedWant: {
+          c1: { x: BigInt(o.encrypted_want.c1.x), y: BigInt(o.encrypted_want.c1.y) },
+          c2: { x: BigInt(o.encrypted_want.c2.x), y: BigInt(o.encrypted_want.c2.y) }
+        },
+        rateCommitment: BigInt(o.rate_commitment),
+        minFillPct: o.min_fill_pct,
+        expiresAt: o.expires_at
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get order by ID
+   */
+  async getOrder(orderId) {
+    try {
+      const response = await fetch(
+        `${this.config.apiUrl}/api/v1/privacy/orders/${orderId.toString()}`
+      );
+      if (!response.ok) return null;
+      const o = await response.json();
+      return {
+        orderId: BigInt(o.order_id),
+        maker: o.maker,
+        giveAsset: o.give_asset,
+        wantAsset: o.want_asset,
+        encryptedGive: {
+          c1: { x: BigInt(o.encrypted_give.c1.x), y: BigInt(o.encrypted_give.c1.y) },
+          c2: { x: BigInt(o.encrypted_give.c2.x), y: BigInt(o.encrypted_give.c2.y) }
+        },
+        encryptedWant: {
+          c1: { x: BigInt(o.encrypted_want.c1.x), y: BigInt(o.encrypted_want.c1.y) },
+          c2: { x: BigInt(o.encrypted_want.c2.x), y: BigInt(o.encrypted_want.c2.y) }
+        },
+        rateCommitment: BigInt(o.rate_commitment),
+        minFillPct: o.min_fill_pct,
+        expiresAt: o.expires_at
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Take an existing order (buyer-side)
+   *
+   * @param orderId - ID of the order to take
+   * @param giveAmount - Amount buyer is paying
+   * @param wantAmount - Amount buyer wants to receive
+   * @returns Take order response with proofs
+   */
+  async takeOrder(orderId, giveAmount, wantAmount) {
+    if (!this.keyPair) {
+      throw new Error("Key pair not initialized. Call generateKeyPair() or withKeyPair() first.");
+    }
+    const randomnessGive = randomScalar();
+    const randomnessWant = randomScalar();
+    const blindingFactor = randomScalar();
+    const encryptedGive = this.privacy.encrypt(giveAmount, this.keyPair.publicKey, randomnessGive);
+    const encryptedWant = this.privacy.encrypt(wantAmount, this.keyPair.publicKey, randomnessWant);
+    const proofs = await this.requestProofs({
+      giveAsset: 1 /* USDC */,
+      // Taker gives payment asset
+      wantAsset: 0 /* SAGE */,
+      // Taker wants SAGE
+      giveAmount: giveAmount.toString(),
+      wantAmount: wantAmount.toString(),
+      rate: (giveAmount * BigInt(10 ** 18) / wantAmount).toString(),
+      blindingFactor: blindingFactor.toString()
+    });
+    try {
+      const response = await fetch(`${this.config.apiUrl}/api/v1/privacy/orders/${orderId.toString()}/take`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          taker_give: {
+            c1: { x: encryptedGive.c1.x.toString(), y: encryptedGive.c1.y.toString() },
+            c2: { x: encryptedGive.c2.x.toString(), y: encryptedGive.c2.y.toString() }
+          },
+          taker_want: {
+            c1: { x: encryptedWant.c1.x.toString(), y: encryptedWant.c1.y.toString() },
+            c2: { x: encryptedWant.c2.x.toString(), y: encryptedWant.c2.y.toString() }
+          },
+          proofs: {
+            range_proof: {
+              bit_commitments: proofs.rangeProof.bitCommitments.map((c) => ({
+                x: c.x.toString(),
+                y: c.y.toString()
+              })),
+              challenge: proofs.rangeProof.challenge.toString(),
+              responses: proofs.rangeProof.responses.map((r) => r.toString()),
+              num_bits: proofs.rangeProof.numBits
+            },
+            rate_proof: {
+              rate_commitment: {
+                x: proofs.rateProof.rateCommitment.x.toString(),
+                y: proofs.rateProof.rateCommitment.y.toString()
+              },
+              challenge: proofs.rateProof.challenge.toString(),
+              response_give: proofs.rateProof.responseGive.toString(),
+              response_rate: proofs.rateProof.responseRate.toString(),
+              response_blinding: proofs.rateProof.responseBlinding.toString()
+            },
+            balance_proof: {
+              balance_commitment: {
+                x: proofs.balanceProof.balanceCommitment.x.toString(),
+                y: proofs.balanceProof.balanceCommitment.y.toString()
+              },
+              challenge: proofs.balanceProof.challenge.toString(),
+              response: proofs.balanceProof.response.toString()
+            }
+          }
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.message || "Failed to take order");
+      }
+      const data = await response.json();
+      return {
+        success: true,
+        orderId,
+        matchId: BigInt(data.match_id || "0"),
+        encryptedGive,
+        encryptedWant,
+        proofs,
+        transactionHash: data.transaction_hash
+      };
+    } catch (error) {
+      return {
+        success: false,
+        orderId,
+        matchId: 0n,
+        encryptedGive,
+        encryptedWant,
+        proofs,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Get swap history for an address
+   */
+  async getSwapHistory(address) {
+    try {
+      const response = await fetch(
+        `${this.config.apiUrl}/api/v1/privacy/swaps/history/${address}`
+      );
+      if (!response.ok) return [];
+      const data = await response.json();
+      return data.swaps.map((s) => ({
+        orderId: BigInt(s.order_id),
+        matchId: BigInt(s.match_id),
+        role: s.role,
+        giveAsset: s.give_asset,
+        wantAsset: s.want_asset,
+        timestamp: s.timestamp,
+        transactionHash: s.transaction_hash
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Decrypt a swap to reveal amounts (for your own swaps only)
+   */
+  decryptSwap(encryptedGive, encryptedWant, maxAmount) {
+    if (!this.keyPair) {
+      throw new Error("Key pair not initialized");
+    }
+    return {
+      giveAmount: this.privacy.decrypt(encryptedGive, this.keyPair.privateKey, maxAmount),
+      wantAmount: this.privacy.decrypt(encryptedWant, this.keyPair.privateKey, maxAmount)
+    };
+  }
+};
+var privacy_default = ObelyskPrivacy;
+
+export {
+  FIELD_PRIME,
+  CURVE_ORDER,
+  GENERATOR_G,
+  GENERATOR_H,
+  AssetId,
+  addMod,
+  subMod,
+  mulMod,
+  powMod,
+  invMod,
+  isIdentity,
+  ecDouble,
+  ecAdd,
+  ecMul,
+  randomBytes,
+  randomScalar,
+  poseidonHash,
+  ObelyskPrivacy,
+  ConfidentialSwapClient,
+  privacy_default
+};