@veilo/sdk-core 0.4.0 → 0.6.0

package/dist/esm/predictions/client.js

@@ -0,0 +1,141 @@
+import { VersionedTransaction } from "@solana/web3.js";
+export const JUPITER_PREDICTION_API_URL = "https://api.jup.ag/prediction/v1";
+export const POLYMARKET_CLOB_API_URL = "https://clob.polymarket.com";
+export class JupiterPredictionApiError extends Error {
+    constructor(status, responseBody) {
+        const body = typeof responseBody === "object" && responseBody !== null
+            ? responseBody
+            : undefined;
+        const message = typeof responseBody === "string" && responseBody
+            ? responseBody
+            : typeof body?.message === "string"
+                ? body.message
+                : typeof body?.error === "string"
+                    ? body.error
+                    : `Jupiter Prediction API request failed: ${status}`;
+        super(message);
+        this.name = "JupiterPredictionApiError";
+        this.status = status;
+        this.code = typeof body?.error === "string" ? body.error : undefined;
+        this.responseBody = responseBody;
+    }
+}
+/** Typed client for the unsigned Jupiter Prediction transaction API. */
+export class JupiterPredictionClient {
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = normalizeBaseUrl(config.baseUrl ?? JUPITER_PREDICTION_API_URL, "baseUrl");
+        this.polymarketBaseUrl = normalizeBaseUrl(config.polymarketBaseUrl ?? POLYMARKET_CLOB_API_URL, "polymarketBaseUrl");
+        this.fetcher = config.fetch ?? fetch;
+    }
+    async listEvents(params = {}) {
+        const query = new URLSearchParams({ status: params.status ?? "live" });
+        if (params.category)
+            query.set("category", params.category);
+        return (await this.request(`/events?${query}`)).data;
+    }
+    async getEvent(eventId) {
+        return this.request(`/events/${encodeURIComponent(eventId)}`);
+    }
+    async listPositions(ownerPubkey) {
+        return (await this.request(`/positions?ownerPubkey=${encodeURIComponent(ownerPubkey)}`)).data;
+    }
+    async listHistory(ownerPubkey) {
+        return (await this.request(`/history?ownerPubkey=${encodeURIComponent(ownerPubkey)}`)).data;
+    }
+    async getPosition(positionPubkey) {
+        return this.request(`/positions/${encodeURIComponent(positionPubkey)}`);
+    }
+    async placeOrder(request) {
+        return this.request("/orders", { method: "POST", body: request });
+    }
+    async getOrderStatus(orderPubkey) {
+        return this.request(`/orders/status/${encodeURIComponent(orderPubkey)}`);
+    }
+    async closePosition(positionPubkey, ownerPubkey) {
+        return this.request(`/positions/${encodeURIComponent(positionPubkey)}`, {
+            method: "DELETE",
+            body: { ownerPubkey },
+        });
+    }
+    async closeAllPositions(ownerPubkey, minSellPriceSlippageBps = 300) {
+        return this.request("/positions", {
+            method: "DELETE",
+            body: { ownerPubkey, minSellPriceSlippageBps },
+        });
+    }
+    async claimPosition(positionPubkey, ownerPubkey) {
+        return this.request(`/positions/${encodeURIComponent(positionPubkey)}/claim`, { method: "POST", body: { ownerPubkey } });
+    }
+    async getPriceHistory(clobTokenId, interval) {
+        const fidelity = {
+            "1d": 5,
+            "1w": 30,
+            "1m": 180,
+            max: 180,
+        };
+        const query = new URLSearchParams({
+            market: clobTokenId,
+            interval,
+            fidelity: String(fidelity[interval]),
+        });
+        const response = await this.fetcher(`${this.polymarketBaseUrl}/prices-history?${query}`);
+        const body = await readResponseBody(response);
+        if (!response.ok) {
+            throw new JupiterPredictionApiError(response.status, body);
+        }
+        return body.history ?? [];
+    }
+    async request(path, options = {}) {
+        const response = await this.fetcher(`${this.baseUrl}${path}`, {
+            method: options.method ?? "GET",
+            headers: {
+                "x-api-key": this.apiKey,
+                ...(options.body === undefined
+                    ? {}
+                    : { "Content-Type": "application/json" }),
+            },
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+        });
+        const body = await readResponseBody(response);
+        if (!response.ok) {
+            throw new JupiterPredictionApiError(response.status, body);
+        }
+        return body;
+    }
+}
+/** Decode an unsigned transaction returned by Jupiter for wallet signing. */
+export function deserializePredictionTransaction(response) {
+    if (!response.transaction) {
+        throw new TypeError("Prediction transaction must not be empty");
+    }
+    return VersionedTransaction.deserialize(decodeBase64(response.transaction));
+}
+function normalizeBaseUrl(value, label) {
+    const normalized = value.trim().replace(/\/+$/, "");
+    if (!normalized)
+        throw new TypeError(`${label} must not be empty`);
+    return normalized;
+}
+async function readResponseBody(response) {
+    const body = await response.text();
+    if (!body)
+        return {};
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return body;
+    }
+}
+function decodeBase64(encoded) {
+    if (typeof Buffer !== "undefined") {
+        return new Uint8Array(Buffer.from(encoded, "base64"));
+    }
+    const binary = atob(encoded);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index++) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}

package/dist/esm/predictions/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./keys.js";
+export * from "./pdas.js";
+export * from "./client.js";
+export * from "./relayer.js";

package/dist/esm/predictions/index.js

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./keys.js";
+export * from "./pdas.js";
+export * from "./client.js";
+export * from "./relayer.js";

package/dist/esm/predictions/keys.d.ts

@@ -0,0 +1,14 @@
+import { Keypair } from "@solana/web3.js";
+export interface PredictionKeyBundle {
+    withdrawalId: Uint8Array;
+    withdrawalIdHex: string;
+    ephemeral: Keypair;
+    claimantPublicKey: string;
+    claimantSecretKey: string;
+}
+export declare function derivePredictionEphemeralKeypair(spendingKey: Uint8Array, nonce: number): Keypair;
+export declare function derivePredictionWithdrawalId(spendingKey: Uint8Array, nonce: number): Uint8Array;
+export declare function predictionWithdrawalIdToHex(withdrawalId: Uint8Array): string;
+export declare function predictionWithdrawalIdFromHex(value: string): Uint8Array;
+/** Derive every client-held key field needed across a prediction lifecycle. */
+export declare function derivePredictionKeyBundle(spendingKey: Uint8Array, nonce: number): PredictionKeyBundle;

package/dist/esm/predictions/keys.js

@@ -0,0 +1,33 @@
+import { sha256 } from "@noble/hashes/sha256";
+import { Keypair } from "@solana/web3.js";
+import { assertBytes, bytesToHex, concatBytes, encodeBase58, hexToBytes, uint32Le, uint64Le, utf8, } from "../identity/encoding.js";
+export function derivePredictionEphemeralKeypair(spendingKey, nonce) {
+    assertBytes(spendingKey, 32, "spending key");
+    if (!Number.isSafeInteger(nonce) || nonce < 0) {
+        throw new RangeError("prediction nonce must be a non-negative safe integer");
+    }
+    return Keypair.fromSeed(sha256(concatBytes(utf8("prediction_ephemeral"), spendingKey, uint64Le(BigInt(nonce), "prediction nonce"))));
+}
+export function derivePredictionWithdrawalId(spendingKey, nonce) {
+    assertBytes(spendingKey, 32, "spending key");
+    return sha256(concatBytes(utf8("prediction_withdrawal_v1"), spendingKey, uint32Le(nonce, "prediction nonce")));
+}
+export function predictionWithdrawalIdToHex(withdrawalId) {
+    assertBytes(withdrawalId, 32, "prediction withdrawal ID");
+    return bytesToHex(withdrawalId);
+}
+export function predictionWithdrawalIdFromHex(value) {
+    return hexToBytes(value, 32, "prediction withdrawal ID");
+}
+/** Derive every client-held key field needed across a prediction lifecycle. */
+export function derivePredictionKeyBundle(spendingKey, nonce) {
+    const withdrawalId = derivePredictionWithdrawalId(spendingKey, nonce);
+    const ephemeral = derivePredictionEphemeralKeypair(spendingKey, nonce);
+    return {
+        withdrawalId,
+        withdrawalIdHex: predictionWithdrawalIdToHex(withdrawalId),
+        ephemeral,
+        claimantPublicKey: ephemeral.publicKey.toBase58(),
+        claimantSecretKey: encodeBase58(ephemeral.secretKey),
+    };
+}

package/dist/esm/predictions/pdas.d.ts

@@ -0,0 +1,6 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function derivePredictionSlotPda(params: {
+    programId: PublicKey;
+    mint: PublicKey;
+    withdrawalId: Uint8Array;
+}): PublicKey;

package/dist/esm/predictions/pdas.js

@@ -0,0 +1,10 @@
+import { PublicKey } from "@solana/web3.js";
+import { assertBytes, utf8 } from "../identity/encoding.js";
+export function derivePredictionSlotPda(params) {
+    assertBytes(params.withdrawalId, 32, "prediction withdrawal ID");
+    return PublicKey.findProgramAddressSync([
+        utf8("prediction_slot_v1"),
+        params.mint.toBytes(),
+        params.withdrawalId,
+    ], params.programId)[0];
+}

package/dist/esm/predictions/relayer.d.ts

@@ -0,0 +1,3 @@
+import type { PredictionOpenRequest, PredictionOpenResponse, PredictionReissueRequest, PredictionReissueResponse } from "./types.js";
+export declare function submitPredictionOpen(data: PredictionOpenRequest): Promise<PredictionOpenResponse>;
+export declare function submitPredictionReissue(data: PredictionReissueRequest): Promise<PredictionReissueResponse>;

package/dist/esm/predictions/relayer.js

@@ -0,0 +1,7 @@
+import { getInternalRelayerClient } from "../relayer/internal.js";
+export function submitPredictionOpen(data) {
+    return getInternalRelayerClient().submitPredictionOpen(data);
+}
+export function submitPredictionReissue(data) {
+    return getInternalRelayerClient().submitPredictionReissue(data);
+}

package/dist/esm/predictions/types.d.ts

@@ -0,0 +1,178 @@
+import type { TransactNote } from "../relayer/types.js";
+export interface PredictionOpenRequest {
+    notes: TransactNote[];
+    /** USDC stake, raw 6-decimal units. */
+    depositAmount: string;
+    /** 32-byte prediction-slot withdrawal ID, hex. */
+    withdrawalId: string;
+    /** Deterministic ephemeral wallet and open-proof claimant, base58. */
+    claimantPublicKey: string;
+    userPublicKey: string;
+}
+export interface PredictionOpenResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        ephemeralWallet: string;
+        ephemeralTokenAccount: string;
+        changeAmount: string;
+        fee: string;
+        feeBps: number;
+        totalDebited: string;
+    };
+}
+export interface PredictionReissueRequest {
+    withdrawalId: string;
+    claimantSecretKey: string;
+    /** Kept for API compatibility; the relayer reads the real chain balance. */
+    reissueAmount: string;
+    veiloPublicKey: string;
+    userPublicKey: string;
+}
+export interface PredictionReissueResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string | null;
+        reissueAmount: string;
+        fee?: string;
+        tradeHappened?: boolean;
+    };
+}
+export interface PredictionMarketPricing {
+    buyYesPriceUsd: number;
+    sellYesPriceUsd: number;
+    buyNoPriceUsd: number;
+    sellNoPriceUsd: number;
+    volume: number;
+}
+export interface PredictionMarket {
+    provider: string;
+    marketId: string;
+    status: "open" | "closed" | "cancelled";
+    result: string | null;
+    title: string;
+    openTime: number;
+    closeTime: number;
+    rulesPrimary?: string;
+    imageUrl?: string;
+    clobTokenIds?: string[];
+    pricing: PredictionMarketPricing;
+}
+export interface PredictionEvent {
+    eventId: string;
+    isActive: boolean;
+    isLive: boolean;
+    category: string;
+    subcategory: string;
+    tags: string[];
+    metadata: {
+        title: string;
+        closeTime: string;
+        imageUrl?: string;
+        series?: string;
+        slug?: string;
+    };
+    volumeUsd: string;
+    volume24hr: string;
+    closeCondition?: string;
+    markets: PredictionMarket[];
+}
+export interface PredictionPosition {
+    pubkey: string;
+    owner: string;
+    marketId: string;
+    isYes: boolean;
+    contracts: string;
+    contractsDecimal: string;
+    totalCostUsd: string;
+    sizeUsd: string;
+    valueUsd: string;
+    avgPriceUsd: string;
+    markPriceUsd: string;
+    pnlUsd: string;
+    pnlUsdPercent: number;
+    feesPaidUsd: string;
+    claimed: boolean;
+    claimable: boolean;
+    payoutUsd: string;
+    sellPriceUsd: string;
+    settlementDate: number;
+    eventMetadata: {
+        title: string;
+        category: string;
+        imageUrl?: string;
+    };
+    marketMetadata: {
+        title: string;
+        result: string | null;
+        status: string;
+    };
+}
+export interface PlacePredictionOrderRequest {
+    ownerPubkey: string;
+    marketId: string;
+    isYes: boolean;
+    isBuy: true;
+    depositAmount: string;
+    depositMint: string;
+}
+export interface PredictionTransactionResponse {
+    transaction: string;
+    txMeta: {
+        blockhash: string;
+        lastValidBlockHeight: number;
+    };
+}
+export interface PlacePredictionOrderResponse extends PredictionTransactionResponse {
+    order: {
+        orderPubkey: string;
+        positionPubkey: string;
+        contracts: number;
+    };
+}
+export type PredictionOrderStatus = "pending" | "filled" | "partiallyfilled" | "failed";
+export interface PredictionOrderStatusResponse {
+    orderPubkey: string;
+    status: PredictionOrderStatus;
+    latestEventType: string;
+    latestSignature: string;
+    history: Array<{
+        eventType: string;
+        status: string;
+        rawStatus: string;
+        timestamp: number;
+        signature: string;
+    }>;
+}
+export interface PredictionHistoryEvent {
+    id: number;
+    eventType: string;
+    signature: string;
+    timestamp: number;
+    marketId: string;
+    isYes: boolean;
+    isBuy: boolean;
+    contractsDecimal: string;
+    avgFillPriceUsd?: string;
+    totalCostUsd?: string;
+    netProceedsUsd?: string;
+    realizedPnl?: string;
+    payoutAmountUsd?: string;
+    eventMetadata: {
+        title: string;
+        category?: string;
+        imageUrl?: string;
+    };
+    marketMetadata: {
+        title: string;
+        result: string | null;
+        status: string;
+    };
+}
+export type PredictionPriceInterval = "1d" | "1w" | "1m" | "max";
+export interface PredictionPricePoint {
+    t: number;
+    p: number;
+}

package/dist/esm/predictions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/program.d.ts

@@ -1,6 +1,8 @@
 import { Program, Idl, Wallet } from "@coral-xyz/anchor";
 import { Connection, PublicKey } from "@solana/web3.js";
+import { PRIVACY_POOL_CURRENT_IDL, PRIVACY_POOL_IDLS, PRIVACY_POOL_LEGACY2_IDL, PRIVACY_POOL_LEGACY_IDL } from "./idl/index.js";
 export declare const PRIVACY_POOL_IDL: Idl;
+export { PRIVACY_POOL_CURRENT_IDL, PRIVACY_POOL_IDLS, PRIVACY_POOL_LEGACY_IDL, PRIVACY_POOL_LEGACY2_IDL, };
 /** Deployed program ID extracted from the bundled IDL. */
 export declare const PRIVACY_POOL_PROGRAM_ID: PublicKey;
 /**

package/dist/esm/program.js

@@ -1,10 +1,11 @@
 import { Program, AnchorProvider } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
-import IDL_JSON from "./idl/privacy_pool.js";
+import { PRIVACY_POOL_CURRENT_IDL, PRIVACY_POOL_IDLS, PRIVACY_POOL_LEGACY2_IDL, PRIVACY_POOL_LEGACY_IDL, } from "./idl/index.js";
 // Re-export so consumers can access the raw IDL if needed
-export const PRIVACY_POOL_IDL = IDL_JSON;
+export const PRIVACY_POOL_IDL = PRIVACY_POOL_CURRENT_IDL;
+export { PRIVACY_POOL_CURRENT_IDL, PRIVACY_POOL_IDLS, PRIVACY_POOL_LEGACY_IDL, PRIVACY_POOL_LEGACY2_IDL, };
 /** Deployed program ID extracted from the bundled IDL. */
-export const PRIVACY_POOL_PROGRAM_ID = new PublicKey(IDL_JSON.address);
+export const PRIVACY_POOL_PROGRAM_ID = new PublicKey(PRIVACY_POOL_CURRENT_IDL.address);
 /**
  * Create an Anchor `Program` instance for the Veilo Privacy Pool.
  *

package/dist/esm/proof.d.ts

@@ -1,183 +1 @@
-import { PublicKey } from "@solana/web3.js";
-import { SerializedUTXO, InputUTXO } from "./utxo.js";
-/**
- * External data that gets hashed into ext_data_hash.
- * These are public parameters that affect financial flows.
- */
-export type ExtData = {
-    /** Who receives withdrawal (for withdrawals) */
-    recipient: PublicKey;
-    /** Who submits tx and gets fee */
-    relayer: PublicKey;
-    /** Fee to relayer in lamports/token units */
-    fee: bigint;
-    /** Refund to user in lamports/token units (for gas compensation) */
-    refund: bigint;
-    /** Claimant key committed into the proof */
-    claimant: PublicKey;
-};
-/**
- * Transaction circuit inputs (8 public inputs, many private inputs).
- * This structure is used to prepare inputs for the snarkjs prover.
- */
-export type TransactionCircuitInputs = {
-    /** Merkle root of UTXO tree */
-    root: Uint8Array;
-    /** Net deposit/withdrawal amount (positive = deposit, negative = withdrawal) */
-    publicAmount: bigint;
-    /** Hash of external data (recipient, relayer, fee, refund) */
-    extDataHash: Uint8Array;
-    /** Token mint address */
-    mintAddress: PublicKey;
-    /** Nullifiers for the two input UTXOs */
-    inputNullifiers: [Uint8Array, Uint8Array];
-    /** Commitments for the two output UTXOs */
-    outputCommitments: [Uint8Array, Uint8Array];
-    inAmount: [bigint, bigint];
-    inPubkey: [bigint, bigint];
-    inBlinding: [bigint, bigint];
-    inPathIndex: [number, number];
-    inPathElements: [bigint[], bigint[]];
-    inPrivateKey: [bigint, bigint];
-    outAmount: [bigint, bigint];
-    outPubkey: [bigint, bigint];
-    outBlinding: [bigint, bigint];
-};
-/**
- * Proof structure matching the on-chain TransactionProof struct.
- * Total size: 256 bytes (64 + 128 + 64)
- */
-export type TransactionProofStruct = {
-    /** G1 point A (64 bytes) */
-    proofA: number[];
-    /** G2 point B (128 bytes) */
-    proofB: number[];
-    /** G1 point C (64 bytes) */
-    proofC: number[];
-};
-/**
- * Shape of a Groth16 proof produced by snarkjs.
- */
-export type RawProof = {
-    pi_a: [string, string, string];
-    pi_b: [[string, string], [string, string], [string, string]];
-    pi_c: [string, string, string];
-    protocol: string;
-    curve: string;
-};
-/**
- * Proof builder function type - takes circuit inputs and returns a raw snarkjs proof.
- */
-export type TransactionProofBuilder = (inputs: TransactionCircuitInputs) => Promise<RawProof>;
-/**
- * Compute the external data hash.
- * Matches on-chain computation:
- *   hash1 = Poseidon(recipient, relayer)
- *   hash2 = Poseidon(fee, refund)
- *   extDataHash = Poseidon(hash1, hash2, claimant)
- */
-export declare function computeExtDataHash(extData: ExtData): Uint8Array;
-/**
- * Convert i64 to field element (handles negative via modular arithmetic).
- * For negative values, we add the field modulus to get the equivalent positive representation.
- */
-export declare function i64ToField(value: bigint): bigint;
-/**
- * Prepare transaction circuit inputs from high-level parameters.
- * This converts the SDK types into the format expected by the circuit.
- */
-export declare function prepareTransactionInputs(params: {
-    inputUTXOs: [InputUTXO, InputUTXO];
-    outputUTXOs: [SerializedUTXO, SerializedUTXO];
-    root: Uint8Array;
-    publicAmount: bigint;
-    extData: ExtData;
-    mintAddress: PublicKey;
-}): TransactionCircuitInputs;
-/**
- * Turn a snarkjs Groth16 proof into 256 bytes:
- *   A(G1) | B(G2) | C(G1)
- * where:
- *   A = (ax, ay)               -> 64 bytes
- *   B = (bx1, bx0, by1, by0)  -> 128 bytes  (swapped pairs for alt_bn128)
- *   C = (cx, cy)               -> 64 bytes
- *
- * Each field element is encoded as 32-byte BE to match the on-chain verifier.
- * We ignore the extra projective/z components snarkjs keeps.
- */
-export declare function packProofToBytes(proof: RawProof): Uint8Array;
-/**
- * Encode a snarkjs proof into the TransactionProofStruct format expected by the on-chain program.
- */
-export declare function encodeSnarkjsProofToTransactionProof(proof: RawProof): TransactionProofStruct;
-/**
- * Convert TransactionCircuitInputs to the format expected by snarkjs.groth16.fullProve().
- * All values are converted to strings (snarkjs expects string inputs for field elements).
- */
-export declare function formatInputsForSnarkjs(inputs: TransactionCircuitInputs): Record<string, any>;
-/**
- * Swap circuit inputs. Matches the signal shape declared by swap.circom's
- * main component (see zk-circuits/swap.circom lines 208-238). Unlike the
- * transaction circuit, the swap circuit distinguishes a "change" output
- * (same mint as source) from a "dest" output (dest mint) and takes a
- * swap-specific params hash and swapAmount alongside the usual inputs.
- */
-export type SwapCircuitInputs = {
-    sourceRoot: Uint8Array;
-    swapParamsHash: Uint8Array;
-    extDataHash: Uint8Array;
-    sourceMint: PublicKey;
-    destMint: PublicKey;
-    inputNullifiers: [Uint8Array, Uint8Array];
-    changeCommitment: Uint8Array;
-    destCommitment: Uint8Array;
-    swapAmount: bigint;
-    inAmount: [bigint, bigint];
-    inPubkey: [bigint, bigint];
-    inBlinding: [bigint, bigint];
-    inPathIndex: [number, number];
-    inPathElements: [bigint[], bigint[]];
-    inPrivateKey: [bigint, bigint];
-    changeAmount: bigint;
-    changePubkey: bigint;
-    changeBlinding: bigint;
-    destAmount: bigint;
-    destPubkey: bigint;
-    destBlinding: bigint;
-    minAmountOut: bigint;
-    deadline: bigint;
-};
-/**
- * Convert SwapCircuitInputs into the shape expected by
- * snarkjs.groth16.fullProve() for swap.circom. Every value is emitted as a
- * decimal string (or string array) because snarkjs only accepts field
- * elements as strings.
- *
- * Mirrors `generateSwapProof` in
- * relayer-server/src/controllers/swap.helpers.ts so SDK-side swap proofs
- * verify against the same circuit the relayer uses.
- */
-export declare function formatSwapInputsForSnarkjs(inputs: SwapCircuitInputs): Record<string, any>;
-/**
- * Compute the swap params hash that the swap circuit and on-chain program verify.
- * Mirrors relayer-server/src/controllers/swap.helpers.ts `computeSwapParamsHash`.
- *
- * Circuit formula (swap.circom lines 293-307):
- *   mintPairHash   = Poseidon(sourceMint, destMint)
- *   swapTermsHash  = Poseidon(minAmountOut, deadline, destAmount)
- *   swapParamsHash = Poseidon(mintPairHash, swapTermsHash)
- *
- * @param sourceMint   Source pool mint
- * @param destMint     Destination pool mint
- * @param minAmountOut Minimum accepted output amount (slippage protected)
- * @param deadline     Unix timestamp deadline (i64, 0 = no deadline)
- * @param destAmount   Actual amount committed to destination UTXO (≥ minAmountOut -
- *                     relayerFee). If omitted, defaults to minAmountOut.
- */
-export declare function computeSwapParamsHash(sourceMint: PublicKey, destMint: PublicKey, minAmountOut: bigint, deadline: bigint, destAmount?: bigint): Uint8Array;
-/**
- * Compute the swap data hash committed on-chain for Jupiter instruction integrity.
- * SHA-256 of the raw Jupiter swap instruction data bytes.
- * Mirrors relayer-server/src/controllers/swap.helpers.ts `computeSwapDataHash`.
- */
-export declare function computeSwapDataHash(swapData: Uint8Array | Buffer): Uint8Array;
+export * from "./proofs/index.js";