@veilo/sdk-core 0.4.0 → 0.6.0

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

@@ -0,0 +1,29 @@
+import { PublicKey } from "@solana/web3.js";
+import type { JperpSide } from "./types.js";
+export declare const JPERP_SIDE_LONG = 1;
+export declare const JPERP_SIDE_SHORT = 2;
+export declare const JPERP_CHANGE_INCREASE = 1;
+export declare const JPERP_CHANGE_DECREASE = 2;
+export declare function deriveJupiterPerpetualsPda(): PublicKey;
+export declare function deriveJperpExecutorPda(params: {
+    programId: PublicKey;
+    mint: PublicKey;
+    claimant: PublicKey;
+    withdrawalId: Uint8Array;
+}): PublicKey;
+export declare function deriveJperpSlotPda(params: {
+    programId: PublicKey;
+    mint: PublicKey;
+    withdrawalId: Uint8Array;
+}): PublicKey;
+export declare function deriveJupiterPerpPositionPda(params: {
+    executor: PublicKey;
+    custody: PublicKey;
+    collateralCustody: PublicKey;
+    side: JperpSide;
+}): PublicKey;
+export declare function deriveJupiterPerpRequestPda(params: {
+    position: PublicKey;
+    counter: bigint;
+    change: "increase" | "decrease";
+}): PublicKey;

package/dist/esm/perps/pdas.js

@@ -0,0 +1,47 @@
+import { PublicKey } from "@solana/web3.js";
+import { assertBytes, uint64Le, utf8, } from "../identity/encoding.js";
+import { JUPITER_PERPS_POOL, JUPITER_PERPS_PROGRAM_ID, } from "./constants.js";
+export const JPERP_SIDE_LONG = 1;
+export const JPERP_SIDE_SHORT = 2;
+export const JPERP_CHANGE_INCREASE = 1;
+export const JPERP_CHANGE_DECREASE = 2;
+export function deriveJupiterPerpetualsPda() {
+    return PublicKey.findProgramAddressSync([utf8("perpetuals")], new PublicKey(JUPITER_PERPS_PROGRAM_ID))[0];
+}
+export function deriveJperpExecutorPda(params) {
+    assertBytes(params.withdrawalId, 32, "jPerp withdrawal ID");
+    return PublicKey.findProgramAddressSync([
+        utf8("jperp_executor"),
+        params.mint.toBytes(),
+        params.claimant.toBytes(),
+        params.withdrawalId,
+    ], params.programId)[0];
+}
+export function deriveJperpSlotPda(params) {
+    assertBytes(params.withdrawalId, 32, "jPerp withdrawal ID");
+    return PublicKey.findProgramAddressSync([utf8("jperp_slot_v1"), params.mint.toBytes(), params.withdrawalId], params.programId)[0];
+}
+export function deriveJupiterPerpPositionPda(params) {
+    return PublicKey.findProgramAddressSync([
+        utf8("position"),
+        params.executor.toBytes(),
+        new PublicKey(JUPITER_PERPS_POOL).toBytes(),
+        params.custody.toBytes(),
+        params.collateralCustody.toBytes(),
+        Uint8Array.from([
+            params.side === "long" ? JPERP_SIDE_LONG : JPERP_SIDE_SHORT,
+        ]),
+    ], new PublicKey(JUPITER_PERPS_PROGRAM_ID))[0];
+}
+export function deriveJupiterPerpRequestPda(params) {
+    return PublicKey.findProgramAddressSync([
+        utf8("position_request"),
+        params.position.toBytes(),
+        uint64Le(params.counter, "jPerp request counter"),
+        Uint8Array.from([
+            params.change === "increase"
+                ? JPERP_CHANGE_INCREASE
+                : JPERP_CHANGE_DECREASE,
+        ]),
+    ], new PublicKey(JUPITER_PERPS_PROGRAM_ID))[0];
+}

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

@@ -0,0 +1,9 @@
+import type { JperpCancelTriggerRequest, JperpCancelTriggerResponse, JperpCloseRequest, JperpDecreaseResponse, JperpOpenRequest, JperpOpenResponse, JperpRecoverNativeRequest, JperpRecoverNativeResponse, JperpRecoverSeedRequest, JperpRecoverSeedResponse, JperpReissueRequest, JperpReissueResponse, JperpSetTpslRequest, JperpUpdateTpslRequest } from "./types.js";
+export declare function submitJperpOpen(data: JperpOpenRequest): Promise<JperpOpenResponse>;
+export declare function submitJperpClose(data: JperpCloseRequest): Promise<JperpDecreaseResponse>;
+export declare function submitJperpSetTpsl(data: JperpSetTpslRequest): Promise<JperpDecreaseResponse>;
+export declare function submitJperpUpdateTpsl(data: JperpUpdateTpslRequest): Promise<JperpDecreaseResponse>;
+export declare function submitJperpCancelTrigger(data: JperpCancelTriggerRequest): Promise<JperpCancelTriggerResponse>;
+export declare function submitJperpReissue(data: JperpReissueRequest): Promise<JperpReissueResponse>;
+export declare function submitJperpRecoverSeed(data: JperpRecoverSeedRequest): Promise<JperpRecoverSeedResponse>;
+export declare function submitJperpRecoverNative(data: JperpRecoverNativeRequest): Promise<JperpRecoverNativeResponse>;

package/dist/esm/perps/relayer.js

@@ -0,0 +1,25 @@
+import { getInternalRelayerClient } from "../relayer/internal.js";
+export function submitJperpOpen(data) {
+    return getInternalRelayerClient().submitJperpOpen(data);
+}
+export function submitJperpClose(data) {
+    return getInternalRelayerClient().submitJperpClose(data);
+}
+export function submitJperpSetTpsl(data) {
+    return getInternalRelayerClient().submitJperpSetTpsl(data);
+}
+export function submitJperpUpdateTpsl(data) {
+    return getInternalRelayerClient().submitJperpUpdateTpsl(data);
+}
+export function submitJperpCancelTrigger(data) {
+    return getInternalRelayerClient().submitJperpCancelTrigger(data);
+}
+export function submitJperpReissue(data) {
+    return getInternalRelayerClient().submitJperpReissue(data);
+}
+export function submitJperpRecoverSeed(data) {
+    return getInternalRelayerClient().submitJperpRecoverSeed(data);
+}
+export function submitJperpRecoverNative(data) {
+    return getInternalRelayerClient().submitJperpRecoverNative(data);
+}

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;