@veilo/sdk-core 0.5.0 → 0.7.0

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

@@ -0,0 +1,126 @@
+import type { TransactNote } from "../relayer/types.js";
+export type JperpMarket = "SOL" | "ETH" | "BTC";
+export type JperpSide = "long" | "short";
+/** Jupiter market accounts forwarded to the relayer's Perps CPI builder. */
+export interface JperpMarketPayload {
+    custody: string;
+    collateralCustody: string;
+    /** Veilo pool mint used for notes and the ZK proof. */
+    inputMint: string;
+    /** Jupiter SPL collateral mint; WSOL when inputMint is native SOL. */
+    jupiterInputMint?: string;
+    /** Optional; the relayer resolves the known market oracle when omitted. */
+    dovesOracle?: string;
+}
+export interface JperpOpenRequest extends JperpMarketPayload {
+    notes: TransactNote[];
+    depositAmount: string;
+    /** 32-byte withdrawal ID, hex. */
+    withdrawalId: string;
+    claimantPublicKey: string;
+    userPublicKey: string;
+    /** Position size in Jupiter's 1e6 USD units. */
+    sizeUsdDelta: string;
+    collateralTokenDelta: string;
+    side: JperpSide;
+    priceSlippage?: string;
+    counter: string;
+}
+export interface JperpOpenResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        executor: string;
+        position: string;
+        positionRequest: string;
+        changeAmount: string;
+    };
+}
+export interface JperpDecreaseBase extends JperpMarketPayload {
+    withdrawalId: string;
+    claimantSecretKey: string;
+    userPublicKey: string;
+    side: JperpSide;
+    counter: string;
+}
+export interface JperpCloseRequest extends JperpDecreaseBase {
+    collateralUsdDelta?: string;
+    sizeUsdDelta?: string;
+    entirePosition?: boolean;
+    priceSlippage?: string;
+}
+export interface JperpSetTpslRequest extends JperpDecreaseBase {
+    collateralUsdDelta?: string;
+    sizeUsdDelta?: string;
+    triggerPrice: string;
+    triggerAboveThreshold: boolean;
+    entirePosition?: boolean;
+}
+export interface JperpUpdateTpslRequest extends JperpDecreaseBase {
+    sizeUsdDelta?: string;
+    triggerPrice: string;
+}
+export interface JperpDecreaseResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        positionRequest: string;
+    };
+}
+export interface JperpReissueRequest {
+    withdrawalId: string;
+    claimantSecretKey: string;
+    reissueAmount: string;
+    veiloPublicKey: string;
+    userPublicKey: string;
+    poolMint?: string;
+}
+export interface JperpReissueResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        reissueAmount: string;
+    };
+}
+export interface JperpRecoverSeedRequest {
+    withdrawalId: string;
+    claimantPublicKey: string;
+    poolMint: string;
+    userPublicKey: string;
+}
+export interface JperpRecoverSeedResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature?: string;
+        executorWsolAta: string;
+        recoverable: string;
+    };
+}
+export type JperpCancelTriggerRequest = JperpDecreaseBase;
+export interface JperpCancelTriggerResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        triggerRequest: string;
+    };
+}
+export interface JperpRecoverNativeRequest {
+    withdrawalId: string;
+    claimantSecretKey: string;
+    veiloPublicKey: string;
+    userPublicKey: string;
+    poolMint?: string;
+}
+export interface JperpRecoverNativeResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        recoverAmount: string;
+    };
+}

package/dist/esm/perps/types.js

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

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

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

package/dist/esm/positions/index.js

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

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

@@ -0,0 +1,29 @@
+import { Keypair, PublicKey } from "@solana/web3.js";
+import type { NewPositionKeys, PositionNotePayload } from "./types.js";
+export interface PositionKeyMaterial {
+    positionSecretN: bigint;
+    positionBlinding: bigint;
+    positionPubkey: bigint;
+    positionPdaKeyBytes: Uint8Array;
+}
+export interface PositionKeyBundle {
+    material: PositionKeyMaterial;
+    claimant: Keypair;
+    position: NewPositionKeys;
+}
+/** Derive the exact Poseidon key material used by private position notes. */
+export declare function derivePositionKeys(spendingKey: Uint8Array, index: number): PositionKeyMaterial;
+/** Deterministic claimant required to close or merge a position. */
+export declare function derivePositionClaimantKeypair(spendingKey: Uint8Array, positionPdaKeyBytes: Uint8Array): Keypair;
+/** Derive both local secret material and the public request payload. */
+export declare function derivePositionKeyBundle(spendingKey: Uint8Array, index: number): PositionKeyBundle;
+/** Serialize a returned open/merge position into the relayer's close shape. */
+export declare function createPositionNotePayload(params: {
+    amount: bigint | string;
+    commitment: Uint8Array | string;
+    leafIndex: number;
+    mint: PublicKey | string;
+    isToken2022: boolean;
+    treeId?: number;
+    keys: PositionKeyMaterial;
+}): PositionNotePayload;

package/dist/esm/positions/keys.js

@@ -0,0 +1,65 @@
+import { sha256 } from "@noble/hashes/sha256";
+import { Keypair, PublicKey } from "@solana/web3.js";
+import { BN254_FR_MODULUS, bigIntToBytesBE, bytesToBigIntBE, poseidon1, poseidon2, } from "../poseidon.js";
+import { assertBytes, bytesToHex, concatBytes, hexToBytes, utf8, } from "../identity/encoding.js";
+/** Derive the exact Poseidon key material used by private position notes. */
+export function derivePositionKeys(spendingKey, index) {
+    assertBytes(spendingKey, 32, "spending key");
+    if (!Number.isSafeInteger(index) || index < 0) {
+        throw new RangeError("position index must be a non-negative safe integer");
+    }
+    const rootSecret = bytesToBigIntBE(sha256(concatBytes(spendingKey, utf8("veilo_v1")))) % BN254_FR_MODULUS;
+    const positionSecretN = poseidon2(rootSecret, BigInt(index));
+    const positionBlinding = poseidon2(positionSecretN, 1n);
+    const positionPubkey = poseidon1(positionSecretN);
+    return {
+        positionSecretN,
+        positionBlinding,
+        positionPubkey,
+        positionPdaKeyBytes: bigIntToBytesBE(positionPubkey),
+    };
+}
+/** Deterministic claimant required to close or merge a position. */
+export function derivePositionClaimantKeypair(spendingKey, positionPdaKeyBytes) {
+    assertBytes(spendingKey, 32, "spending key");
+    assertBytes(positionPdaKeyBytes, 32, "position PDA key");
+    return Keypair.fromSeed(sha256(concatBytes(utf8("position_claimant"), spendingKey, positionPdaKeyBytes)));
+}
+/** Derive both local secret material and the public request payload. */
+export function derivePositionKeyBundle(spendingKey, index) {
+    const material = derivePositionKeys(spendingKey, index);
+    const claimant = derivePositionClaimantKeypair(spendingKey, material.positionPdaKeyBytes);
+    return {
+        material,
+        claimant,
+        position: {
+            pubkey: material.positionPubkey.toString(),
+            blinding: bytesToHex(bigIntToBytesBE(material.positionBlinding)),
+            pdaKey: bytesToHex(material.positionPdaKeyBytes),
+            claimantPublicKey: claimant.publicKey.toBase58(),
+        },
+    };
+}
+/** Serialize a returned open/merge position into the relayer's close shape. */
+export function createPositionNotePayload(params) {
+    if (!Number.isSafeInteger(params.leafIndex) || params.leafIndex < 0) {
+        throw new RangeError("leafIndex must be a non-negative safe integer");
+    }
+    const commitment = typeof params.commitment === "string"
+        ? hexToBytes(params.commitment, 32, "position commitment")
+        : params.commitment;
+    assertBytes(commitment, 32, "position commitment");
+    const mint = params.mint instanceof PublicKey ? params.mint : new PublicKey(params.mint);
+    return {
+        amount: params.amount.toString(),
+        commitment: bytesToHex(commitment),
+        privateKey: bytesToHex(bigIntToBytesBE(params.keys.positionSecretN)),
+        publicKey: params.keys.positionPubkey.toString(),
+        blinding: bytesToHex(bigIntToBytesBE(params.keys.positionBlinding)),
+        leafIndex: params.leafIndex,
+        positionPdaKey: bytesToHex(params.keys.positionPdaKeyBytes),
+        mint: mint.toBase58(),
+        isToken2022: params.isToken2022,
+        treeId: params.treeId ?? 0,
+    };
+}

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

@@ -0,0 +1,15 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function derivePositionConfigPda(programId: PublicKey): PublicKey;
+export declare function derivePositionTreePda(programId: PublicKey, treeId?: number): PublicKey;
+export declare function derivePositionVaultRecordPda(programId: PublicKey, mint: PublicKey): PublicKey;
+export declare function derivePositionVaultPda(programId: PublicKey, mint: PublicKey): PublicKey;
+export declare function derivePositionPda(programId: PublicKey, positionPdaKey: Uint8Array): PublicKey;
+export declare function derivePositionNullifierMarkerPda(programId: PublicKey, mint: PublicKey, nullifier: Uint8Array): PublicKey;
+export declare function derivePositionExecutorPda(params: {
+    programId: PublicKey;
+    sourceMint: PublicKey;
+    destMint: PublicKey;
+    inputNullifier0: Uint8Array;
+    relayer: PublicKey;
+}): PublicKey;
+export declare function derivePositionSwapLegsBufferPda(programId: PublicKey, nullifier0: Uint8Array): PublicKey;

package/dist/esm/positions/pdas.js

@@ -0,0 +1,44 @@
+import { PublicKey } from "@solana/web3.js";
+import { assertBytes, utf8 } from "../identity/encoding.js";
+function treeIdLe(treeId) {
+    if (!Number.isInteger(treeId) || treeId < 0 || treeId > 0xffff) {
+        throw new RangeError("position tree ID must be an unsigned 16-bit integer");
+    }
+    const bytes = new Uint8Array(2);
+    new DataView(bytes.buffer).setUint16(0, treeId, true);
+    return bytes;
+}
+export function derivePositionConfigPda(programId) {
+    return PublicKey.findProgramAddressSync([utf8("position_config_v1")], programId)[0];
+}
+export function derivePositionTreePda(programId, treeId = 0) {
+    return PublicKey.findProgramAddressSync([utf8("position_tree_v1"), treeIdLe(treeId)], programId)[0];
+}
+export function derivePositionVaultRecordPda(programId, mint) {
+    return PublicKey.findProgramAddressSync([utf8("position_vault_v1"), mint.toBytes()], programId)[0];
+}
+export function derivePositionVaultPda(programId, mint) {
+    return PublicKey.findProgramAddressSync([utf8("position_vault_token_v1"), mint.toBytes()], programId)[0];
+}
+export function derivePositionPda(programId, positionPdaKey) {
+    assertBytes(positionPdaKey, 32, "position PDA key");
+    return PublicKey.findProgramAddressSync([utf8("position_pda_v1"), positionPdaKey], programId)[0];
+}
+export function derivePositionNullifierMarkerPda(programId, mint, nullifier) {
+    assertBytes(nullifier, 32, "position nullifier");
+    return PublicKey.findProgramAddressSync([utf8("position_nullifier_v1"), mint.toBytes(), nullifier], programId)[0];
+}
+export function derivePositionExecutorPda(params) {
+    assertBytes(params.inputNullifier0, 32, "input nullifier");
+    return PublicKey.findProgramAddressSync([
+        utf8("position_executor"),
+        params.sourceMint.toBytes(),
+        params.destMint.toBytes(),
+        params.inputNullifier0,
+        params.relayer.toBytes(),
+    ], params.programId)[0];
+}
+export function derivePositionSwapLegsBufferPda(programId, nullifier0) {
+    assertBytes(nullifier0, 32, "input nullifier");
+    return PublicKey.findProgramAddressSync([utf8("swap_legs_v1"), nullifier0], programId)[0];
+}

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

@@ -0,0 +1,4 @@
+import type { ClosePositionRequest, ClosePositionResponse, MergePositionsRequest, MergePositionsResponse, OpenPositionRequest, OpenPositionResponse } from "./types.js";
+export declare function submitOpenPosition(data: OpenPositionRequest): Promise<OpenPositionResponse>;
+export declare function submitClosePosition(data: ClosePositionRequest): Promise<ClosePositionResponse>;
+export declare function submitMergePositions(data: MergePositionsRequest): Promise<MergePositionsResponse>;

package/dist/esm/positions/relayer.js

@@ -0,0 +1,10 @@
+import { getInternalRelayerClient } from "../relayer/internal.js";
+export function submitOpenPosition(data) {
+    return getInternalRelayerClient().submitOpenPosition(data);
+}
+export function submitClosePosition(data) {
+    return getInternalRelayerClient().submitClosePosition(data);
+}
+export function submitMergePositions(data) {
+    return getInternalRelayerClient().submitMergePositions(data);
+}

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

@@ -0,0 +1,97 @@
+import type { TransactNote } from "../relayer/types.js";
+/** Client-derived public material for a new private position note. */
+export interface NewPositionKeys {
+    /** Position owner field element, decimal. */
+    pubkey: string;
+    /** Position blinding, 32-byte hex. */
+    blinding: string;
+    /** Position PDA key, 32-byte hex. */
+    pdaKey: string;
+    /** Deterministic claimant public key, base58. */
+    claimantPublicKey: string;
+}
+/** Spendable private-position note passed back to the relayer. */
+export interface PositionNotePayload {
+    amount: string;
+    commitment: string;
+    privateKey: string;
+    publicKey: string;
+    blinding: string;
+    leafIndex: number;
+    positionPdaKey: string;
+    mint: string;
+    isToken2022: boolean;
+    treeId: number;
+}
+export interface OpenPositionRequest {
+    notes: TransactNote[];
+    sourceMintAddress: string;
+    destMintAddress: string;
+    swapAmountRaw: string;
+    slippageBps: number;
+    userPublicKey: string;
+    veiloPublicKey: string;
+    position: NewPositionKeys;
+    positionTreeId?: number;
+    isToken2022?: boolean;
+    dexes?: string;
+    pumpDirect?: boolean;
+}
+export interface OpenPositionResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        positionAmount: string;
+        changeAmount: string;
+        positionPda: string;
+        mint: string;
+        positionCommitment: string;
+        positionLeafIndex: number;
+        positionTreeId: number;
+        isToken2022: boolean;
+    };
+}
+export interface ClosePositionRequest {
+    positionNote: PositionNotePayload;
+    destMintAddress: string;
+    slippageBps: number;
+    userPublicKey: string;
+    veiloPublicKey: string;
+    /** Base58-encoded deterministic claimant secret key. */
+    claimantSecretKey: string;
+    dexes?: string;
+    staged?: boolean;
+}
+export interface ClosePositionResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        outputAmount: string;
+        feeRaw: string;
+        destMint: string;
+    };
+}
+export interface MergePositionsRequest {
+    positionNotes: [PositionNotePayload, PositionNotePayload];
+    mint: string;
+    userPublicKey: string;
+    veiloPublicKey: string;
+    newPosition: NewPositionKeys;
+    /** Base58 claimant secret shared by both input PositionPDAs. */
+    claimantSecretKey: string;
+}
+export interface MergePositionsResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        mergedAmount: string;
+        newPositionPda: string;
+        mergedCommitment: string;
+        mergedLeafIndex: number;
+        positionTreeId: number;
+        mint: string;
+    };
+}

package/dist/esm/positions/types.js

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

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

@@ -0,0 +1,41 @@
+import { VersionedTransaction } from "@solana/web3.js";
+import type { PlacePredictionOrderRequest, PlacePredictionOrderResponse, PredictionEvent, PredictionHistoryEvent, PredictionOrderStatusResponse, PredictionPosition, PredictionPriceInterval, PredictionPricePoint, PredictionTransactionResponse } from "./types.js";
+export declare const JUPITER_PREDICTION_API_URL = "https://api.jup.ag/prediction/v1";
+export declare const POLYMARKET_CLOB_API_URL = "https://clob.polymarket.com";
+export interface JupiterPredictionClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    polymarketBaseUrl?: string;
+    fetch?: typeof fetch;
+}
+export declare class JupiterPredictionApiError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    readonly responseBody: unknown;
+    constructor(status: number, responseBody: unknown);
+}
+/** Typed client for the unsigned Jupiter Prediction transaction API. */
+export declare class JupiterPredictionClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly polymarketBaseUrl;
+    private readonly fetcher;
+    constructor(config: JupiterPredictionClientConfig);
+    listEvents(params?: {
+        category?: string;
+        status?: string;
+    }): Promise<PredictionEvent[]>;
+    getEvent(eventId: string): Promise<PredictionEvent>;
+    listPositions(ownerPubkey: string): Promise<PredictionPosition[]>;
+    listHistory(ownerPubkey: string): Promise<PredictionHistoryEvent[]>;
+    getPosition(positionPubkey: string): Promise<PredictionPosition>;
+    placeOrder(request: PlacePredictionOrderRequest): Promise<PlacePredictionOrderResponse>;
+    getOrderStatus(orderPubkey: string): Promise<PredictionOrderStatusResponse>;
+    closePosition(positionPubkey: string, ownerPubkey: string): Promise<PredictionTransactionResponse>;
+    closeAllPositions(ownerPubkey: string, minSellPriceSlippageBps?: number): Promise<PredictionTransactionResponse>;
+    claimPosition(positionPubkey: string, ownerPubkey: string): Promise<PredictionTransactionResponse>;
+    getPriceHistory(clobTokenId: string, interval: PredictionPriceInterval): Promise<PredictionPricePoint[]>;
+    private request;
+}
+/** Decode an unsigned transaction returned by Jupiter for wallet signing. */
+export declare function deserializePredictionTransaction(response: PredictionTransactionResponse): VersionedTransaction;

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;