pnp-sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,583 @@
+import { Connection, PublicKey, Commitment as Commitment$1, Transaction, VersionedTransaction, Keypair } from '@solana/web3.js';
+import { z } from 'zod';
+import * as anchor from '@coral-xyz/anchor';
+import { Idl } from '@coral-xyz/anchor';
+import { BN } from 'bn.js';
+
+type Commitment = "processed" | "confirmed" | "finalized";
+interface Logger {
+    debug?: (...args: any[]) => void;
+    info?: (...args: any[]) => void;
+    warn?: (...args: any[]) => void;
+    error?: (...args: any[]) => void;
+}
+interface SdkConfig {
+    rpcUrl: string;
+    commitment?: Commitment;
+    httpHeaders?: Record<string, string>;
+    priorityFeeMicroLamports?: number;
+    computeUnitLimit?: number;
+    computeUnitPriceMicroLamports?: number;
+    addressLookupTables?: unknown[];
+    logger?: Logger;
+}
+declare class SdkError extends Error {
+    code: string;
+    details?: unknown;
+    constructor(code: string, message: string, details?: unknown);
+}
+declare class ValidationError extends SdkError {
+    constructor(message: string, details?: unknown);
+}
+declare class TransportError extends SdkError {
+    constructor(message: string, details?: unknown);
+}
+declare class ProgramError extends SdkError {
+    programErrorCode?: number;
+    logs?: string[];
+    constructor(message: string, details?: unknown, programErrorCode?: number, logs?: string[]);
+}
+type PubkeyLike = string;
+type U64Like = bigint | number | string;
+type WinningTokenLike = "none" | "yes" | "no" | number | Record<string, unknown> | null;
+interface MarketType {
+    id: U64Like;
+    resolved: boolean;
+    market_reserves: U64Like;
+    collateral_token: PubkeyLike;
+    winning_token_id: WinningTokenLike;
+    yes_token_mint: PubkeyLike;
+    no_token_mint: PubkeyLike;
+    yes_token_supply_minted: U64Like;
+    no_token_supply_minted: U64Like;
+    creator: PubkeyLike;
+    creator_fee_treasury: PubkeyLike;
+    question: string;
+    initial_liquidity: U64Like;
+    end_time: U64Like;
+    bump: number;
+    creation_time: U64Like;
+    resolvable: boolean;
+    force_resolve: boolean;
+    version: number;
+}
+interface MarketsResponse {
+    count: number;
+    data: Array<{
+        publicKey: string;
+        account: MarketType;
+    }>;
+}
+interface GlobalConfigType {
+    admin: PubkeyLike;
+    oracle_program: PubkeyLike;
+    fee: U64Like;
+    creator_fee: U64Like;
+    bump: number;
+    yes_global_metadata: string;
+    no_global_metadata: string;
+    collateral_token_mint: PubkeyLike;
+    global_id: U64Like;
+    min_liquidity: U64Like;
+    buffer_period: U64Like;
+    burn_fee: U64Like;
+    trading_paused: boolean;
+}
+interface SettlementCriteria {
+    category: string;
+    reasoning: string;
+    resolvable: boolean;
+    resolution_sources: string[];
+    settlement_criteria: string;
+    suggested_improvements: string;
+}
+interface SettlementData {
+    answer: string;
+    reasoning: string;
+    resolved?: boolean;
+    winning_token_id?: string;
+    resolution_time?: string;
+    settlement_description?: string;
+    resolution_source?: string;
+}
+
+declare class Client {
+    readonly connection: Connection;
+    readonly programId: PublicKey;
+    readonly commitment: Commitment$1;
+    readonly logger: Logger;
+    constructor(cfg: SdkConfig);
+    fail(code: string, message: string, details?: unknown): TransportError;
+}
+
+type AccountsMap = Record<string, PublicKey>;
+
+type CreateMarketArgs = {
+    question: string;
+    initial_liquidity: bigint;
+    end_time: bigint;
+    creator?: PublicKey;
+};
+type MintDecisionTokensArgs = {
+    amount: bigint;
+    buy_yes_token: boolean;
+    minimum_out: bigint;
+};
+type BurnDecisionTokensArgs = {
+    amount: bigint;
+    burn_yes_token: boolean;
+};
+
+interface SignerLike {
+    publicKey: PublicKey;
+    signTransaction(tx: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
+    signAllTransactions?(txs: (Transaction | VersionedTransaction)[]): Promise<(Transaction | VersionedTransaction)[]>;
+}
+
+declare const CreateMarketSchema: z.ZodObject<{
+    baseMint: z.ZodOptional<z.ZodType<PublicKey, z.ZodTypeDef, PublicKey>>;
+    quoteMint: z.ZodOptional<z.ZodType<PublicKey, z.ZodTypeDef, PublicKey>>;
+    question: z.ZodOptional<z.ZodString>;
+    initialLiquidity: z.ZodOptional<z.ZodBigInt>;
+    endTime: z.ZodOptional<z.ZodBigInt>;
+    tickSize: z.ZodOptional<z.ZodBigInt>;
+    lotSize: z.ZodOptional<z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    question?: string | undefined;
+    initialLiquidity?: bigint | undefined;
+    endTime?: bigint | undefined;
+    baseMint?: PublicKey | undefined;
+    quoteMint?: PublicKey | undefined;
+    tickSize?: bigint | undefined;
+    lotSize?: bigint | undefined;
+}, {
+    question?: string | undefined;
+    initialLiquidity?: bigint | undefined;
+    endTime?: bigint | undefined;
+    baseMint?: PublicKey | undefined;
+    quoteMint?: PublicKey | undefined;
+    tickSize?: bigint | undefined;
+    lotSize?: bigint | undefined;
+}>;
+declare class MarketModule {
+    private readonly client;
+    private readonly signer;
+    constructor(client: Client, signer: SignerLike);
+    createMarket(params: z.infer<typeof CreateMarketSchema>): Promise<{
+        signature: string | undefined;
+        market: PublicKey;
+    }>;
+    createMarketIdl(accounts: AccountsMap, args: CreateMarketArgs): Promise<{
+        signature: string | undefined;
+    }>;
+    createMarketDerived(params: {
+        question: string;
+        initialLiquidity: bigint;
+        endTime: bigint;
+        collateralMint?: PublicKey;
+    }): Promise<{
+        signature: string | undefined;
+        market: PublicKey;
+    }>;
+    fetchGlobalConfig(): Promise<{
+        publicKey: PublicKey;
+        account: any;
+    }>;
+    fetchMarket(market: PublicKey): Promise<{
+        publicKey: PublicKey;
+        account: any;
+    }>;
+}
+
+declare const TradeSchema: z.ZodObject<{
+    market: z.ZodType<PublicKey, z.ZodTypeDef, PublicKey>;
+    side: z.ZodUnion<[z.ZodLiteral<"buy">, z.ZodLiteral<"sell">]>;
+    price: z.ZodBigInt;
+    size: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    market: PublicKey;
+    side: "buy" | "sell";
+    price: bigint;
+    size: bigint;
+}, {
+    market: PublicKey;
+    side: "buy" | "sell";
+    price: bigint;
+    size: bigint;
+}>;
+declare class TradingModule {
+    private readonly client;
+    private readonly signer;
+    constructor(client: Client, signer: SignerLike);
+    trade(params: z.infer<typeof TradeSchema>): Promise<{
+        signature: string | undefined;
+    }>;
+    mintDecisionTokens(accounts: AccountsMap, args: MintDecisionTokensArgs): Promise<{
+        signature: string | undefined;
+    }>;
+    burnDecisionTokens(accounts: AccountsMap, args: BurnDecisionTokensArgs): Promise<{
+        signature: string | undefined;
+    }>;
+    mintDecisionTokensDerived(params: {
+        market: PublicKey;
+        amount: bigint;
+        buyYesToken: boolean;
+        minimumOut: bigint;
+    }): Promise<{
+        signature: string | undefined;
+    }>;
+    burnDecisionTokensDerived(params: {
+        market: PublicKey;
+        amount: bigint;
+        burnYesToken: boolean;
+    }): Promise<{
+        signature: string | undefined;
+    }>;
+    getMarketInfo(market: PublicKey): Promise<{
+        address: PublicKey;
+        question: any;
+        id: any;
+        creator: PublicKey;
+        initialLiquidity: any;
+        marketReserves: any;
+        endTime: any;
+        resolvable: any;
+        resolved: any;
+        winningTokenId: any;
+        yesTokenMint: PublicKey;
+        noTokenMint: PublicKey;
+        collateralToken: PublicKey;
+        yesTokenSupplyMinted: any;
+        noTokenSupplyMinted: any;
+    }>;
+    getBalances(market: PublicKey): Promise<{
+        collateral: {
+            account: PublicKey;
+            amount: any;
+            uiAmount: any;
+            uiAmountString: any;
+        };
+        yes: {
+            account: PublicKey;
+            amount: any;
+            uiAmount: any;
+            uiAmountString: any;
+        };
+        no: {
+            account: PublicKey;
+            amount: any;
+            uiAmount: any;
+            uiAmountString: any;
+        };
+    }>;
+    getPrices(market: PublicKey): Promise<{
+        yesMinted: number;
+        noMinted: number;
+        totalMinted: number;
+        yesShare: number;
+        noShare: number;
+    }>;
+    buyTokensUsdc(params: {
+        market: PublicKey;
+        buyYesToken: boolean;
+        amountUsdc: number;
+        minimumOut?: bigint;
+    }): Promise<{
+        signature: string;
+        usdcSpent: number;
+        tokensReceived: number;
+        before: {
+            collateral: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+            yes: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+            no: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+        };
+        after: {
+            collateral: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+            yes: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+            no: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+        };
+    }>;
+    sellTokensBase(params: {
+        market: PublicKey;
+        burnYesToken: boolean;
+        amountBaseUnits: bigint;
+    }): Promise<{
+        signature: string;
+        tokensSold: number;
+        usdcReceived: number;
+        before: {
+            collateral: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+            yes: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+            no: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+        };
+        after: {
+            collateral: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+            yes: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+            no: {
+                account: PublicKey;
+                amount: any;
+                uiAmount: any;
+                uiAmountString: any;
+            };
+        };
+    }>;
+    redeemPosition(market: PublicKey): Promise<void>;
+}
+
+declare const RedeemSchema: z.ZodObject<{
+    market: z.ZodType<PublicKey, z.ZodTypeDef, PublicKey>;
+    position: z.ZodType<PublicKey, z.ZodTypeDef, PublicKey>;
+    amount: z.ZodBigInt;
+    to: z.ZodOptional<z.ZodType<PublicKey, z.ZodTypeDef, PublicKey>>;
+}, "strip", z.ZodTypeAny, {
+    market: PublicKey;
+    amount: bigint;
+    position: PublicKey;
+    to?: PublicKey | undefined;
+}, {
+    market: PublicKey;
+    amount: bigint;
+    position: PublicKey;
+    to?: PublicKey | undefined;
+}>;
+declare class RedemptionModule {
+    private readonly client;
+    private readonly signer;
+    constructor(client: Client, signer: SignerLike);
+    redeemPosition(params: z.infer<typeof RedeemSchema>): Promise<{
+        signature: string | undefined;
+    }>;
+    claimCreatorFee(accounts: AccountsMap): Promise<{
+        signature: string | undefined;
+    }>;
+    creatorRefund(accounts: AccountsMap): Promise<{
+        signature: string | undefined;
+    }>;
+    creatorRefundV2(accounts: AccountsMap): Promise<{
+        signature: string | undefined;
+    }>;
+    /**
+     * Redeem a winning position from a resolved market
+     * @param accounts - Account mapping for the redemption instruction
+     * @returns Transaction signature
+     */
+    redeemPositionV2(accounts: AccountsMap): Promise<{
+        signature: string | undefined;
+    }>;
+}
+
+/**
+ * Provides a wrapper for Anchor program interactions
+ * Following the same pattern as the JavaScript example
+ */
+declare class AnchorClient {
+    readonly connection: Connection;
+    readonly signer: Keypair;
+    readonly idlOverride?: Idl | undefined;
+    readonly provider: anchor.AnchorProvider;
+    readonly wallet: anchor.Wallet;
+    readonly program: anchor.Program;
+    constructor(connection: Connection, signer: Keypair, idlOverride?: Idl | undefined);
+    /**
+     * Convert a JavaScript BigInt or number to Anchor BN
+     */
+    static toBN(value: bigint | number): typeof BN.prototype;
+    /**
+     * Returns the IDL for the PNP program
+     */
+    static getIdl(): Promise<Idl>;
+    static fromIdl(connection: Connection, signer: Keypair, idl: Idl): AnchorClient;
+    /**
+     * Get the wallet's public key
+     */
+    get walletPublicKey(): PublicKey;
+}
+
+/**
+ * Market module that uses direct Anchor program calls
+ */
+declare class AnchorMarketModule {
+    private anchorClient;
+    constructor(anchorClient: AnchorClient);
+    /**
+     * Create a new prediction market using direct Anchor program calls
+     * Following the same structure as the working JavaScript example
+     */
+    createMarket(params: {
+        question: string;
+        initialLiquidity: bigint;
+        endTime: bigint;
+        collateralTokenMint: PublicKey;
+        creator?: PublicKey;
+    }): Promise<{
+        signature: any;
+        market: PublicKey;
+        marketDetails: any;
+    } | {
+        signature: any;
+        market: PublicKey;
+        marketDetails?: undefined;
+    }>;
+}
+
+declare class PNPClient {
+    readonly client: Client;
+    readonly signer?: SignerLike;
+    readonly market?: MarketModule;
+    readonly trading?: TradingModule;
+    readonly redemption?: RedemptionModule;
+    readonly anchorMarket?: AnchorMarketModule;
+    readonly anchorClient?: AnchorClient;
+    constructor(rpcUrl: string, privateKey?: Uint8Array | string | {
+        secretKey: Uint8Array;
+    });
+    /**
+     * Redeems a winning position in a resolved market
+     * @param market - The public key of the market where the position was created
+     * @param options - Optional parameters for customizing the redemption
+     * @returns Transaction signature
+     */
+    redeemPosition(market: PublicKey, options?: {
+        admin?: PublicKey;
+        marketCreator?: PublicKey;
+        creatorFeeTreasury?: PublicKey;
+    }): Promise<{
+        signature: string | undefined;
+    }>;
+    fetchGlobalConfig(): Promise<{
+        publicKey: PublicKey;
+        account: GlobalConfigType;
+    }>;
+    fetchMarket(market: PublicKey): Promise<{
+        publicKey: PublicKey;
+        account: MarketType;
+    }>;
+    fetchMarkets(): Promise<MarketsResponse>;
+    /**
+     * Fetch settlement criteria for a market from the proxy server
+     * @param market - Market public key (as string or PublicKey)
+     * @param baseUrl - Optional base URL for the proxy server
+     * @returns Settlement criteria data
+     */
+    fetchSettlementCriteria(market: string | PublicKey, baseUrl?: string): Promise<SettlementCriteria>;
+    /**
+     * Get settlement criteria for a market from the proxy server (alias for fetchSettlementCriteria)
+     * @param market - Market public key (as string or PublicKey)
+     * @param baseUrl - Optional base URL for the proxy server
+     * @returns Settlement criteria data
+     */
+    getSettlementCriteria(market: string | PublicKey, baseUrl?: string, options?: {
+        retryDelayMs?: number;
+        maxRetryTimeMs?: number;
+    }): Promise<SettlementCriteria>;
+    /**
+     * Fetch settlement data for a market from the proxy server
+     * @param market - Market public key (as string or PublicKey)
+     * @param baseUrl - Optional base URL for the proxy server
+     * @returns Settlement data
+     */
+    fetchSettlementData(market: string | PublicKey, baseUrl?: string): Promise<SettlementData>;
+    /**
+     * Get settlement data for a market from the proxy server (alias for fetchSettlementData)
+     * @param market - Market public key (as string or PublicKey)
+     * @param baseUrl - Optional base URL for the proxy server
+     * @returns Settlement data
+     */
+    getSettlementData(market: string | PublicKey, baseUrl?: string): Promise<SettlementData>;
+    /**
+     * Fetch market addresses from the proxy server
+     * @param baseUrl - Optional base URL for the proxy server
+     * @returns Array of market addresses
+     */
+    fetchMarketAddresses(baseUrl?: string): Promise<string[]>;
+    /**
+     * Claim creator refund for a market.
+     * Behavior parity with scripts/claimCreatorRefund.ts:
+     * - Eligible if market is not resolvable (proxy or on-chain flag) AND signer is the creator
+     * - Mixed token programs => use creator_refund_v2 with accountsPartial (yes/no token mints null)
+     * - Uniform token programs => try creator_refund_v2 then fallback to v1
+     */
+    claimMarketRefund(market: PublicKey): Promise<{
+        signature: string;
+    }>;
+}
+
+declare function deriveMarketPda(baseMint: PublicKey, quoteMint: PublicKey, programId: PublicKey): [PublicKey, number];
+declare function derivePositionPda(market: PublicKey, owner: PublicKey, programId: PublicKey): [PublicKey, number];
+declare function deriveGlobalConfigPda(programId: PublicKey): [PublicKey, number];
+declare function deriveCreatorFeeTreasuryPda(creator: PublicKey, programId: PublicKey): [PublicKey, number];
+declare function deriveAta(owner: PublicKey, mint: PublicKey, allowOwnerOffCurve?: boolean, tokenProgramId?: PublicKey, ataProgramId?: PublicKey): PublicKey;
+declare function deriveMarketPdaFromMints(yesMint: PublicKey, noMint: PublicKey, programId: PublicKey): [PublicKey, number];
+declare function deriveYesTokenMint(globalId: bigint, programId: PublicKey): [PublicKey, number];
+declare function deriveNoTokenMint(globalId: bigint, programId: PublicKey): [PublicKey, number];
+declare function deriveTokenMetadataPda(mint: PublicKey, metadataProgramId: PublicKey): [PublicKey, number];
+
+declare const pdas_deriveAta: typeof deriveAta;
+declare const pdas_deriveCreatorFeeTreasuryPda: typeof deriveCreatorFeeTreasuryPda;
+declare const pdas_deriveGlobalConfigPda: typeof deriveGlobalConfigPda;
+declare const pdas_deriveMarketPda: typeof deriveMarketPda;
+declare const pdas_deriveMarketPdaFromMints: typeof deriveMarketPdaFromMints;
+declare const pdas_deriveNoTokenMint: typeof deriveNoTokenMint;
+declare const pdas_derivePositionPda: typeof derivePositionPda;
+declare const pdas_deriveTokenMetadataPda: typeof deriveTokenMetadataPda;
+declare const pdas_deriveYesTokenMint: typeof deriveYesTokenMint;
+declare namespace pdas {
+  export { pdas_deriveAta as deriveAta, pdas_deriveCreatorFeeTreasuryPda as deriveCreatorFeeTreasuryPda, pdas_deriveGlobalConfigPda as deriveGlobalConfigPda, pdas_deriveMarketPda as deriveMarketPda, pdas_deriveMarketPdaFromMints as deriveMarketPdaFromMints, pdas_deriveNoTokenMint as deriveNoTokenMint, pdas_derivePositionPda as derivePositionPda, pdas_deriveTokenMetadataPda as deriveTokenMetadataPda, pdas_deriveYesTokenMint as deriveYesTokenMint };
+}
+
+export { Client, type Commitment, type GlobalConfigType, type Logger, MarketModule, type MarketType, type MarketsResponse, PNPClient, ProgramError, type PubkeyLike, RedemptionModule, type SdkConfig, SdkError, type SettlementCriteria, type SettlementData, TradingModule, TransportError, type U64Like, ValidationError, type WinningTokenLike, pdas };