@theliem/xmarket-sdk 1.0.12

package/dist/index.d.mts

@@ -0,0 +1,818 @@
+import * as anchor from '@coral-xyz/anchor';
+import * as _solana_web3_js from '@solana/web3.js';
+import { PublicKey, Keypair, TransactionInstruction, Transaction, AddressLookupTableAccount } from '@solana/web3.js';
+import BN from 'bn.js';
+
+interface ProgramIds {
+    oracle: PublicKey;
+    conditionalTokens: PublicKey;
+    questionMarket: PublicKey;
+    hook: PublicKey;
+    clobExchange: PublicKey;
+}
+interface CollateralConfig {
+    mint: PublicKey;
+    /** Token decimals (USDC = 6) */
+    decimals: number;
+}
+interface NetworkConfig {
+    name: string;
+    rpcUrl: string;
+    programIds: ProgramIds;
+    defaultCollateral: CollateralConfig;
+}
+type NetworkName = "devnet" | "localnet" | "mainnet";
+declare const DEVNET_CONFIG: NetworkConfig;
+declare const LOCALNET_CONFIG: NetworkConfig;
+declare const MAINNET_CONFIG: NetworkConfig;
+declare const NETWORK_CONFIGS: Record<NetworkName, NetworkConfig>;
+
+interface TxResult {
+    signature: string;
+}
+interface OracleConfig {
+    owner: PublicKey;
+    admin: PublicKey;
+    questionCount: number;
+    whitelist: PublicKey[];
+    whitelistLen: number;
+    isPaused: boolean;
+    bump: number;
+}
+interface QuestionResult {
+    oracleConfig: PublicKey;
+    questionId: Uint8Array;
+    outcomeIndex: number;
+    outcomeCount: number;
+    payoutNumerators: BN[];
+    isResolved: boolean;
+    resolvedAt: number;
+    reporter: PublicKey;
+    condition: PublicKey | null;
+    bump: number;
+}
+interface Condition {
+    oracle: PublicKey;
+    questionId: Uint8Array;
+    outcomeSlotCount: number;
+    payoutNumerators: BN[];
+    payoutDenominator: BN;
+    totalCollateral: BN;
+    collateralMint: PublicKey;
+    collateralVault: PublicKey;
+    yesMint: PublicKey;
+    noMint: PublicKey;
+    hookProgram: PublicKey;
+    authorizedClob: PublicKey;
+    isResolved: boolean;
+    resolvedAt: number;
+    bump: number;
+}
+interface CollateralVault {
+    collateralMint: PublicKey;
+    vaultTokenAccount: PublicKey;
+    totalLocked: BN;
+    conditionCount: BN;
+    bump: number;
+    vaultBump: number;
+}
+interface Position {
+    owner: PublicKey;
+    condition: PublicKey;
+    outcomeIndex: number;
+    balance: BN;
+    bump: number;
+}
+declare enum QuestionStatus {
+    Pending = "pending",
+    Approved = "approved",
+    Rejected = "rejected",
+    Resolved = "resolved"
+}
+interface QuestionMarketConfig {
+    owner: PublicKey;
+    admin: PublicKey;
+    oracle: PublicKey;
+    conditionalTokensProgram: PublicKey;
+    questionCount: number;
+    approvedCount: number;
+    rejectedCount: number;
+    whitelist: PublicKey[];
+    whitelistLen: number;
+    isPaused: boolean;
+    bump: number;
+}
+interface Question {
+    config: PublicKey;
+    questionId: Uint8Array;
+    contentHash: Uint8Array;
+    expirationTime: number;
+    currencyMint: PublicKey;
+    creator: PublicKey;
+    condition: PublicKey | null;
+    status: QuestionStatus;
+    createdAt: number;
+    approvedAt: number;
+    resolvedAt: number;
+    bump: number;
+}
+interface CreateQuestionParams {
+    /** Human-readable question text — used to derive questionId + contentHash */
+    content: string;
+    /** Expiration as Unix timestamp */
+    expirationTime: number;
+    /** Collateral mint (e.g. USDC) */
+    collateralMint: PublicKey;
+    /** Hook program ID for Token-2022 transfer enforcement */
+    hookProgram: PublicKey;
+    /** Authorized CLOB program ID */
+    authorizedClob: PublicKey;
+    /** Override auto-generated questionId */
+    questionId?: Uint8Array;
+    /** Override auto-generated contentHash */
+    contentHash?: Uint8Array;
+}
+interface CtfConfig {
+    owner: PublicKey;
+    bump: number;
+}
+interface HookConfig {
+    owner: PublicKey;
+    whitelist: PublicKey[];
+    whitelistLen: number;
+    isFrozen: boolean;
+    bump: number;
+}
+interface ClobConfig {
+    owner: PublicKey;
+    operators: PublicKey[];
+    operatorsLen: number;
+    feeRecipient: PublicKey;
+    feeRateBps: number;
+    conditionalTokensProgram: PublicKey;
+    isPaused: boolean;
+    bump: number;
+}
+interface ClobWhitelistEntry {
+    address: PublicKey;
+    bump: number;
+}
+interface OrderStatus {
+    maker: PublicKey;
+    nonce: BN;
+    filledAmount: BN;
+    isCancelled: boolean;
+    bump: number;
+}
+/**
+ * Off-chain order struct passed as instruction data.
+ * Operator validates + submits matched order pairs on-chain.
+ *
+ * Semantics (mirrors EVM makerAmount/takerAmount):
+ *   BUY  (side=1): makerAmount = USDC paid,      takerAmount = CTF tokens received
+ *   SELL (side=0): makerAmount = CTF tokens given, takerAmount = USDC received
+ */
+interface Order {
+    /** Maker's wallet public key */
+    maker: PublicKey;
+    /** Condition PDA this order belongs to */
+    condition: PublicKey;
+    /** Outcome token: 0 = NO, 1 = YES */
+    tokenId: number;
+    /** Side: 0 = SELL (give tokens, want USDC), 1 = BUY (give USDC, want tokens) */
+    side: number;
+    /** Amount the maker puts in: BUY → USDC, SELL → CTF tokens */
+    makerAmount: BN;
+    /** Amount the maker wants to receive: BUY → CTF tokens, SELL → USDC */
+    takerAmount: BN;
+    /** Unique nonce per maker — used for OrderStatus PDA + replay protection */
+    nonce: BN;
+    /** Unix timestamp expiry (0 = no expiry) */
+    expiry: BN;
+    /** Creation timestamp (Unix seconds) */
+    createdAt: BN;
+    /** Fee from taker order transferred to treasury. 0 = use global fee_rate_bps */
+    fee: BN;
+    /** Directed order: only this pubkey can be counterparty. PublicKey.default() = public */
+    taker: PublicKey;
+    /** Ed25519 signer key. Must equal maker for now (proxy not supported) */
+    signer: PublicKey;
+}
+/**
+ * Signed order — Order + 64-byte Ed25519 signature over serializeOrderToBytes().
+ * This is the on-chain instruction data type for all match_* instructions.
+ */
+interface SignedOrder {
+    order: Order;
+    /** Ed25519 signature (64 bytes) from order.maker over serializeOrderToBytes() */
+    signature: Uint8Array;
+}
+declare class XMarketError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+declare class UnauthorizedError extends XMarketError {
+    constructor(msg?: string);
+}
+declare class AccountNotFoundError extends XMarketError {
+    constructor(account: string, address?: string);
+}
+declare class InvalidParamError extends XMarketError {
+    constructor(msg?: string);
+}
+
+declare class OracleClient {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds);
+    get walletPubkey(): PublicKey;
+    configPda(owner?: PublicKey): PublicKey;
+    /** One-time setup. Caller becomes owner. */
+    initialize(admin: PublicKey): Promise<TxResult>;
+    /** Admin or owner adds an address to the oracle whitelist. */
+    addToWhitelist(address: PublicKey, ownerPubkey?: PublicKey): Promise<TxResult>;
+    /** Admin or owner removes an address from the oracle whitelist. */
+    removeFromWhitelist(address: PublicKey, ownerPubkey?: PublicKey): Promise<TxResult>;
+    /**
+     * Whitelisted reporter resolves a question.
+     * CPIs directly into CTF.set_payout — condition is resolved in one tx.
+     * @param conditionPda  - CTF condition account (oracle_config = oraclePda, question_id must match)
+     * @param ownerPubkey   - oracle config owner (defaults to wallet)
+     * @param payer         - fee payer (defaults to wallet)
+     */
+    resolveQuestion(questionId: Uint8Array, outcomeCount: number, payoutNumerators: number[], conditionPda: PublicKey, ownerPubkey?: PublicKey, payer?: PublicKey, signers?: Keypair[]): Promise<TxResult>;
+    /** Owner updates the admin. */
+    updateAdmin(newAdmin: PublicKey, ownerPubkey?: PublicKey): Promise<TxResult>;
+    /** Owner transfers ownership to a new keypair. */
+    transferOwnership(newOwner: PublicKey, ownerPubkey?: PublicKey): Promise<TxResult>;
+    /** Admin or owner pause/unpause the oracle. */
+    pause(paused: boolean, ownerPubkey?: PublicKey): Promise<TxResult>;
+    fetchConfig(owner?: PublicKey): Promise<OracleConfig | null>;
+    fetchQuestionResult(questionId: Uint8Array, ownerPubkey?: PublicKey): Promise<QuestionResult | null>;
+}
+
+declare class HookClient {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds);
+    get walletPubkey(): PublicKey;
+    configPda(): PublicKey;
+    /** One-time setup. Caller becomes owner. */
+    initialize(initialWhitelist: PublicKey[]): Promise<TxResult>;
+    /**
+     * Register extra account metas for a Token-2022 YES/NO mint.
+     * Must be called once per mint after CTF creates it.
+     */
+    initializeExtraAccountMetaList(mint: PublicKey): Promise<TxResult>;
+    /** Owner adds a program to the transfer whitelist. */
+    addToWhitelist(program: PublicKey): Promise<TxResult>;
+    /** Owner removes a program from the transfer whitelist. */
+    removeFromWhitelist(program: PublicKey): Promise<TxResult>;
+    /** Permanently freeze the whitelist — no further changes allowed. */
+    freezeWhitelist(): Promise<TxResult>;
+    /**
+     * SPL Transfer-Hook `execute` — invoked automatically by Token-2022 on every
+     * YES/NO token transfer. Validates the destination against the whitelist.
+     *
+     * Calling this directly is useful for:
+     * - Off-chain simulation ("would this transfer be allowed?")
+     * - Integration tests that verify whitelist enforcement
+     *
+     * Token-2022 calls this automatically; you normally don't call it manually.
+     *
+     * @param sourceToken      - Source token account (tokens leaving)
+     * @param mint             - The YES/NO Token-2022 mint
+     * @param destinationToken - Destination token account (tokens arriving)
+     * @param owner            - Authority that authorized the transfer
+     * @param amount           - Token amount being transferred
+     */
+    execute(sourceToken: PublicKey, mint: PublicKey, destinationToken: PublicKey, owner: PublicKey, amount: anchor.BN): Promise<TxResult>;
+    fetchConfig(): Promise<HookConfig | null>;
+    isWhitelisted(program: PublicKey): Promise<boolean>;
+}
+
+declare class CtfClient {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds);
+    get walletPubkey(): PublicKey;
+    /**
+     * Create a Condition directly (bypasses QuestionMarket).
+     * oracle is UncheckedAccount — set it to any pubkey (e.g. user wallet)
+     * so that wallet can later sign reportPayouts.
+     * payer covers rent for condition + mints.
+     */
+    prepareCondition(questionId: Uint8Array, oracle: PublicKey, collateralMint: PublicKey, hookProgram: PublicKey, authorizedClob: PublicKey, payer?: PublicKey, signers?: Keypair[]): Promise<{
+        signature: string;
+        conditionPda: PublicKey;
+        yesMint: PublicKey;
+        noMint: PublicKey;
+    }>;
+    /** One-time setup. Caller becomes the CTF owner. Can only be called once. */
+    initializeCtfConfig(): Promise<TxResult>;
+    /**
+     * Create the shared collateral vault for a given collateral mint (e.g. USDC).
+     * Only callable by the CTF owner (as stored in ctf_config).
+     * authority defaults to the wallet — pass a different signer if needed.
+     */
+    initializeVault(collateralMint: PublicKey): Promise<TxResult>;
+    /**
+     * Initialize an empty Position account (balance = 0) for a user.
+     * Needed before redeemPositions when the user only holds the opposite outcome
+     * (e.g. buyer received YES via CLOB match but never had a NO position).
+     *
+     * Idempotent — call `fetchPosition` first to skip if already initialized.
+     */
+    initPosition(condition: PublicKey, outcomeIndex: number, user?: PublicKey): Promise<TxResult>;
+    /**
+     * Split `amount` collateral into equal YES + NO tokens.
+     * ATAs created automatically via `init_if_needed`.
+     */
+    splitPosition(condition: PublicKey, collateralMint: PublicKey, amount: anchor.BN, user?: PublicKey, payer?: PublicKey, signers?: Keypair[]): Promise<TxResult>;
+    /**
+     * Merge `amount` YES + NO tokens back into collateral.
+     * Both token balances must be ≥ amount.
+     */
+    mergePosition(condition: PublicKey, collateralMint: PublicKey, amount: anchor.BN, user?: PublicKey, payer?: PublicKey, signers?: Keypair[]): Promise<TxResult>;
+    /**
+     * After condition resolves: burn outcome tokens proportional to payout
+     * and receive USDC. Works for winning, losing, or both positions.
+     */
+    redeemPositions(condition: PublicKey, collateralMint: PublicKey, user?: PublicKey, payer?: PublicKey, signers?: Keypair[]): Promise<TxResult>;
+    /**
+     * Oracle directly resolves a condition with payout numerators.
+     * Bypasses QuestionMarket — only for oracle-owned conditions.
+     */
+    reportPayouts(condition: PublicKey, payoutNumerators: number[]): Promise<TxResult>;
+    /**
+     * Build the `transfer_position` instruction for use in a CLOB CPI.
+     *
+     * This instruction requires `clob_authority` (the CLOB's PDA) to sign.
+     * A PDA can only sign from within its own program via CPI — this method
+     * CANNOT be called directly from a wallet transaction.
+     *
+     * Use-cases:
+     * - Custom CLOB implementations that call CTF.transfer_position via CPI
+     * - Anchor CPI builders in other Rust programs
+     *
+     * @param condition       - Condition PDA
+     * @param outcomeMint     - YES or NO mint
+     * @param fromUser        - Source wallet
+     * @param fromTokenAccount - Source ATA
+     * @param fromPosition    - Source Position PDA
+     * @param toUser          - Destination wallet
+     * @param toTokenAccount  - Destination ATA (created if needed — payer covers rent)
+     * @param toPosition      - Destination Position PDA
+     * @param payer           - Pays rent for toPosition + toTokenAccount creation
+     * @param clobAuthority   - CLOB config PDA (must sign via CPI)
+     * @param outcomeIndex    - 0 = NO, 1 = YES
+     * @param amount          - Token amount to transfer
+     */
+    transferPositionIx(condition: PublicKey, outcomeMint: PublicKey, fromUser: PublicKey, fromTokenAccount: PublicKey, fromPosition: PublicKey, toUser: PublicKey, toTokenAccount: PublicKey, toPosition: PublicKey, payer: PublicKey, clobAuthority: PublicKey, outcomeIndex: number, amount: anchor.BN): Promise<TransactionInstruction>;
+    /**
+     * Update the authorized CLOB on a condition.
+     * Only callable by the condition's oracle (the wallet that signed createQuestion).
+     */
+    updateAuthorizedClob(condition: PublicKey, newAuthorizedClob: PublicKey): Promise<TxResult>;
+    fetchCtfConfig(): Promise<CtfConfig | null>;
+    fetchCondition(conditionPda: PublicKey): Promise<Condition | null>;
+    fetchVault(collateralMint: PublicKey): Promise<CollateralVault | null>;
+    fetchPosition(condition: PublicKey, outcomeIndex: number, owner?: PublicKey): Promise<Position | null>;
+    /** YES = outcome index 1, NO = outcome index 0. */
+    fetchBothPositions(condition: PublicKey, owner?: PublicKey): Promise<{
+        yes: Position | null;
+        no: Position | null;
+    }>;
+    /** Thin wrapper: fetch position for a single outcome token (0=NO, 1=YES). */
+    fetchTokenBalance(condition: PublicKey, tokenId: number, owner?: PublicKey): Promise<Position | null>;
+    yesMintPda(condition: PublicKey): PublicKey;
+    noMintPda(condition: PublicKey): PublicKey;
+    mintAuthorityPda(condition: PublicKey): PublicKey;
+    collateralVaultPda(collateralMint: PublicKey): PublicKey;
+}
+
+declare class MarketClient {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    readonly configPda: PublicKey;
+    /** Injected by XMarketSDK after construction — enables fetchQuestionBalances. */
+    ctfClient?: CtfClient;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds, ownerPubkey: PublicKey);
+    get walletPubkey(): PublicKey;
+    initialize(admin: PublicKey, oracle: PublicKey, owner?: PublicKey): Promise<Transaction>;
+    /**
+     * Build createQuestion transaction.
+     * @param payer   - Pays rent for all new accounts (can differ from creator)
+     * @param creator - Identity of the question creator (signs but does not pay)
+     */
+    createQuestion(params: CreateQuestionParams, oracle: PublicKey, creator?: PublicKey, payer?: PublicKey): Promise<{
+        tx: Transaction;
+        questionPda: PublicKey;
+        conditionPda: PublicKey;
+        questionId: Uint8Array;
+    }>;
+    /**
+     * Build createQuestionAdmin transaction (whitelist/admin path — status = Approved immediately).
+     * @param creator - Whitelisted creator (must be in whitelist or be admin/owner)
+     * @param payer   - Fee payer (pays rent; can differ from creator)
+     */
+    createQuestionAdmin(params: CreateQuestionParams, oracle: PublicKey, creator?: PublicKey, payer?: PublicKey): Promise<{
+        tx: Transaction;
+        questionPda: PublicKey;
+        conditionPda: PublicKey;
+        questionId: Uint8Array;
+    }>;
+    approveQuestion(questionPda: PublicKey, admin?: PublicKey, payer?: PublicKey): Promise<Transaction>;
+    updateConfig(params: {
+        newAdmin?: PublicKey;
+        newOracle?: PublicKey;
+        isPaused?: boolean;
+        newConditionalTokensProgram?: PublicKey;
+    }, authority?: PublicKey, payer?: PublicKey): Promise<Transaction>;
+    /** Set the admin (owner only). Replaces any existing admin. */
+    addAdmin(newAdmin: PublicKey, owner?: PublicKey): Promise<Transaction>;
+    /** Clear the admin (owner only). Sets admin to default pubkey. */
+    removeAdmin(owner?: PublicKey): Promise<Transaction>;
+    addToWhitelist(address: PublicKey, authority?: PublicKey, payer?: PublicKey): Promise<Transaction>;
+    removeFromWhitelist(address: PublicKey, authority?: PublicKey, payer?: PublicKey): Promise<Transaction>;
+    fetchConfig(): Promise<QuestionMarketConfig | null>;
+    fetchQuestion(questionPda: PublicKey): Promise<Question | null>;
+    questionPda(questionId: Uint8Array): PublicKey;
+    private _parseStatus;
+    /**
+     * Convenience: fetch YES and NO token balances for a question.
+     * Returns null for each if question not approved or position not initialized.
+     * Requires ctfClient to be injected (done automatically by XMarketSDK).
+     */
+    fetchQuestionBalances(questionPda: PublicKey, owner: PublicKey): Promise<{
+        yes: Position | null;
+        no: Position | null;
+    }>;
+}
+
+declare class ClobClient {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds);
+    get walletPubkey(): PublicKey;
+    /**
+     * Send a match transaction as versioned (v0).
+     * Pass a pre-built AddressLookupTableAccount to compress account keys and
+     * stay under the 1232-byte limit — required for match_complementary which
+     * has ~25 accounts + 2 Ed25519 precompile instructions (~1697 bytes raw).
+     *
+     * If `whitelistedWallet` is provided and differs from `this.provider.wallet`,
+     * both wallets sign the transaction (whitelisted operator + payer).
+     */
+    private _sendMatchTx;
+    /** PDA for a CLOB whitelist entry. */
+    whitelistEntryPda(address: PublicKey): PublicKey;
+    configPda(): PublicKey;
+    /** One-time setup. Caller becomes admin. */
+    initialize(operators: PublicKey[], feeRecipient: PublicKey, feeRateBps: number): Promise<TxResult>;
+    /** Admin adds an operator to the whitelist. */
+    addOperator(operator: PublicKey): Promise<TxResult>;
+    /** Admin removes an operator from the whitelist. */
+    removeOperator(operator: PublicKey): Promise<TxResult>;
+    /** Admin pause/unpause the CLOB. */
+    setPaused(paused: boolean): Promise<TxResult>;
+    /**
+     * Maker cancels their own order.
+     * OrderStatus PDA is marked cancelled — any future fill rejected.
+     */
+    cancelOrder(nonce: anchor.BN): Promise<TxResult>;
+    /**
+     * Emergency reset of CLOB config (upgrade authority only).
+     */
+    forceResetClob(programData: PublicKey, newAdmin: PublicKey, newOperators: PublicKey[], newFeeRecipient: PublicKey, newFeeRateBps: number): Promise<TxResult>;
+    /**
+     * COMPLEMENTARY match: 1 buyer (taker) + N sellers (makers), same tokenId.
+     *
+     * Transaction structure:
+     *   ix[0]   Ed25519(taker/buyer)
+     *   ix[1+i] Ed25519(maker_i/seller_i)
+     *   ix[N+1] match_complementary(buyNonce, makerNonces[])
+     *
+     * remaining_accounts: [hook×3] [seller×5 × N]
+     */
+    private matchComplementary;
+    /**
+     * MINT match: 1 YES buyer (taker) + N NO buyers (makers).
+     *
+     * Transaction structure:
+     *   ix[0]   Ed25519(taker/YES buyer)
+     *   ix[1+i] Ed25519(maker_i/NO buyer)
+     *   ix[N+1] match_mint_orders(yesNonce, makerNonces[])
+     *
+     * remaining_accounts: [maker×5 × N]  (no hook accounts — mint_to doesn't fire hook)
+     */
+    private matchMintOrders;
+    /**
+     * MERGE match: 1 YES seller (taker) + N NO sellers (makers).
+     *
+     * Transaction structure:
+     *   ix[0]   Ed25519(taker/YES seller)
+     *   ix[1+i] Ed25519(maker_i/NO seller)
+     *   ix[N+1] match_merge_orders(yesNonce, makerNonces[])
+     *
+     * remaining_accounts: [maker×5 × N]  (no hook accounts — burn doesn't fire hook)
+     */
+    private matchMergeOrders;
+    /**
+     * Auto-detect match type and execute 1-taker + N-makers in a single transaction.
+     *
+     * Detection (pure, no RPC) based on taker.order vs makers[0].order:
+     *   taker.tokenId === makers[0].tokenId: taker BUY + all makers SELL → COMPLEMENTARY
+     *   taker.tokenId !== makers[0].tokenId + taker BUY + all makers BUY → MINT
+     *   taker.tokenId !== makers[0].tokenId + taker SELL + all makers SELL → MERGE
+     *   Otherwise → throws InvalidParamError
+     *
+     * All makers must have the same tokenId and side as makers[0].
+     */
+    matchOrders(taker: SignedOrder, makers: SignedOrder[], collateralMint: PublicKey, feeRecipient: PublicKey, whitelistedWallet: anchor.Wallet, lookupTable?: AddressLookupTableAccount): Promise<TxResult>;
+    /** Add an address to the CLOB whitelist (owner only). */
+    addToWhitelist(address: PublicKey): Promise<TxResult>;
+    /** Batch-add addresses to the CLOB whitelist (owner only). All PDAs created in one tx. */
+    addToWhitelistBatch(addresses: PublicKey[]): Promise<TxResult>;
+    /** Remove an address from the CLOB whitelist (owner only). */
+    removeFromWhitelist(address: PublicKey, rentReceiver?: PublicKey): Promise<TxResult>;
+    /** Fetch a whitelist entry PDA (returns null if address is not whitelisted). */
+    fetchWhitelistEntry(address: PublicKey): Promise<ClobWhitelistEntry | null>;
+    /** Check if an address is on the CLOB whitelist. */
+    isWhitelisted(address: PublicKey): Promise<boolean>;
+    /** Fetch all whitelisted addresses (scans all ClobWhitelistEntry accounts). */
+    fetchWhitelist(): Promise<PublicKey[]>;
+    fetchConfig(): Promise<ClobConfig | null>;
+    fetchOrderStatus(maker: PublicKey, nonce: anchor.BN): Promise<OrderStatus | null>;
+    isOrderCancelled(maker: PublicKey, nonce: anchor.BN): Promise<boolean>;
+}
+
+interface XMarketSDKConfig {
+    /**
+     * Network to connect to.
+     * - `"devnet"` — public devnet, programs deployed
+     * - `"localnet"` — local test validator (same program IDs as devnet)
+     * - `"mainnet"` — mainnet-beta (hook + clob IDs TBD)
+     * - `NetworkConfig` — fully custom config
+     */
+    network: NetworkName | NetworkConfig;
+    wallet: anchor.Wallet;
+    /**
+     * Owner public key used to derive QuestionMarket + Oracle config PDAs.
+     * Defaults to wallet pubkey.
+     */
+    marketOwner?: PublicKey;
+}
+/**
+ * Top-level SDK entry point.
+ *
+ * ```ts
+ * // Quickstart: devnet
+ * const sdk = XMarketSDK.devnet(wallet);
+ *
+ * // Create a question market
+ * await sdk.market.createQuestion({ content: "...", ... }, oraclePubkey);
+ *
+ * // Split collateral into YES + NO tokens
+ * await sdk.ctf.splitPosition(conditionPda, usdcMint, new BN(100_000));
+ *
+ * // Match orders on the CLOB
+ * await sdk.clob.matchMintOrders(yesOrder, noOrder, fillAmount, usdcMint);
+ *
+ * // Inspect active network config
+ * console.log(sdk.networkConfig.name, sdk.networkConfig.programIds);
+ * ```
+ */
+declare class XMarketSDK {
+    readonly provider: anchor.AnchorProvider;
+    /** Active network configuration (program IDs, RPC, collateral) */
+    readonly networkConfig: NetworkConfig;
+    private readonly _programIds;
+    private readonly _marketOwner;
+    private _oracle?;
+    private _hook?;
+    private _market?;
+    private _ctf?;
+    private _clob?;
+    constructor(config: XMarketSDKConfig);
+    private _withAddress;
+    /** Oracle program client */
+    get oracle(): OracleClient;
+    /** Transfer-hook program client */
+    get hook(): HookClient;
+    /** QuestionMarket program client */
+    get market(): MarketClient;
+    /** Conditional tokens (CTF) program client */
+    get ctf(): CtfClient;
+    /** CLOB exchange program client */
+    get clob(): ClobClient;
+    /**
+     * Connect to devnet.
+     * ```ts
+     * const sdk = XMarketSDK.devnet(wallet);
+     * ```
+     */
+    static devnet(wallet: anchor.Wallet, marketOwner?: PublicKey): XMarketSDK;
+    /**
+     * Connect to localhost test validator.
+     * ```ts
+     * const sdk = XMarketSDK.localnet(wallet);
+     * ```
+     */
+    static localnet(wallet: anchor.Wallet, marketOwner?: PublicKey): XMarketSDK;
+    /**
+     * Connect to mainnet-beta.
+     * ```ts
+     * const sdk = XMarketSDK.mainnet(wallet);
+     * ```
+     */
+    static mainnet(wallet: anchor.Wallet, marketOwner?: PublicKey): XMarketSDK;
+    /**
+     * Custom network (e.g. custom RPC, custom program IDs for a fork).
+     * ```ts
+     * const sdk = XMarketSDK.custom({
+     *   name: "staging",
+     *   rpcUrl: "https://my-rpc.com",
+     *   programIds: { ... },
+     *   defaultCollateral: { mint: ..., decimals: 6 },
+     * }, wallet);
+     * ```
+     */
+    static custom(config: NetworkConfig, wallet: anchor.Wallet, marketOwner?: PublicKey): XMarketSDK;
+}
+
+declare const SEEDS: {
+    readonly config: Buffer<ArrayBuffer>;
+    readonly question: Buffer<ArrayBuffer>;
+    readonly condition: Buffer<ArrayBuffer>;
+    readonly collateralVault: Buffer<ArrayBuffer>;
+    readonly vaultToken: Buffer<ArrayBuffer>;
+    readonly position: Buffer<ArrayBuffer>;
+    readonly yesMint: Buffer<ArrayBuffer>;
+    readonly noMint: Buffer<ArrayBuffer>;
+    readonly mintAuthority: Buffer<ArrayBuffer>;
+    readonly reporter: Buffer<ArrayBuffer>;
+    readonly result: Buffer<ArrayBuffer>;
+    readonly ctfConfig: Buffer<ArrayBuffer>;
+    readonly hookConfig: Buffer<ArrayBuffer>;
+    readonly extraAccountMetas: Buffer<ArrayBuffer>;
+    readonly clobConfig: Buffer<ArrayBuffer>;
+    readonly order: Buffer<ArrayBuffer>;
+};
+declare class PDA {
+    static questionMarketConfig(owner: PublicKey, programIds: Pick<ProgramIds, "questionMarket">): [PublicKey, number];
+    static question(config: PublicKey, questionId: Uint8Array, programIds: Pick<ProgramIds, "questionMarket">): [PublicKey, number];
+    static ctfConfig(programIds: Pick<ProgramIds, "conditionalTokens">): [PublicKey, number];
+    static condition(oracle: PublicKey, questionId: Uint8Array, programIds: Pick<ProgramIds, "conditionalTokens">): [PublicKey, number];
+    static collateralVault(collateralMint: PublicKey, programIds: Pick<ProgramIds, "conditionalTokens">): [PublicKey, number];
+    static vaultToken(collateralMint: PublicKey, programIds: Pick<ProgramIds, "conditionalTokens">): [PublicKey, number];
+    static yesMint(condition: PublicKey, programIds: Pick<ProgramIds, "conditionalTokens">): [PublicKey, number];
+    static noMint(condition: PublicKey, programIds: Pick<ProgramIds, "conditionalTokens">): [PublicKey, number];
+    static mintAuthority(condition: PublicKey, programIds: Pick<ProgramIds, "conditionalTokens">): [PublicKey, number];
+    static position(condition: PublicKey, outcomeIndex: number, owner: PublicKey, programIds: Pick<ProgramIds, "conditionalTokens">): [PublicKey, number];
+    static oracleConfig(owner: PublicKey, programIds: Pick<ProgramIds, "oracle">): [PublicKey, number];
+    static reporter(oracleConfig: PublicKey, reporterAddress: PublicKey, programIds: Pick<ProgramIds, "oracle">): [PublicKey, number];
+    static questionResult(oracleConfig: PublicKey, questionId: Uint8Array, programIds: Pick<ProgramIds, "oracle">): [PublicKey, number];
+    static hookConfig(programIds: Pick<ProgramIds, "hook">): [PublicKey, number];
+    static extraAccountMetaList(mint: PublicKey, programIds: Pick<ProgramIds, "hook">): [PublicKey, number];
+    static clobConfig(programIds: Pick<ProgramIds, "clobExchange">): [PublicKey, number];
+    static orderStatus(maker: PublicKey, nonce: BN, programIds: Pick<ProgramIds, "clobExchange">): [PublicKey, number];
+}
+/** Unique 32-byte question ID: SHA-256(content + timestamp). Different each call. */
+declare function generateQuestionId(content: string, salt?: number): Uint8Array;
+/** Deterministic 32-byte content hash: SHA-256(content). Same content = same hash. */
+declare function generateContentHash(content: string): Uint8Array;
+
+declare function serializeOrderToBytes(order: Order): Uint8Array;
+/**
+ * Sign an order with a keypair's sign function.
+ * The `signFn` receives the 98-byte canonical message and returns a 64-byte signature.
+ *
+ * Usage with a Keypair:
+ *   const signed = signOrder(order, (msg) => keypair.secretKey.slice(0,64) && nacl.sign.detached(msg, keypair.secretKey))
+ *
+ * Or use the convenience wrapper `signOrderWithKeypair` from this module.
+ */
+declare function signOrder(order: Order, signFn: (message: Uint8Array) => Uint8Array | Promise<Uint8Array>): Promise<SignedOrder>;
+/**
+ * Build a single batched Ed25519 precompile instruction for N signed orders.
+ *
+ * All signatures are packed into one instruction (ix[0]).
+ * The on-chain program reads sig[i] via `extract_order_from_ed25519_ix(sysvar, i)`.
+ *
+ * Batched layout saves ~12 bytes vs N separate Ed25519 instructions — critical for
+ * fitting 1-taker + 2-maker transactions within Solana's 1232-byte raw tx limit.
+ *
+ * Data format:
+ *   [0]       num_sigs (N)
+ *   [1]       padding
+ *   [2+i*14]  per-sig offset entries (14 bytes each)
+ *   Then: sigs (64B each), pubkeys (32B each), messages (178B each)
+ */
+declare function buildBatchedEd25519Instruction(orders: SignedOrder[]): TransactionInstruction;
+/**
+ * The Solana instructions sysvar public key.
+ * Pass this as `ixSysvar` to all match_* instruction accounts.
+ */
+declare const IX_SYSVAR: _solana_web3_js.PublicKey;
+
+/**
+ * High-level order utilities — build, sign, serialize, verify, detect match type.
+ *
+ * These helpers layer on top of the low-level `signing.ts` primitives and
+ * provide a convenient interface for both the browser (wallet adapters) and
+ * Node.js (Keypair-based) environments.
+ */
+
+/**
+ * Build a fully-populated Order.
+ * Sets `signer = maker` (proxy not yet supported).
+ * `taker` defaults to new PublicKey(new Uint8Array(32)) (public order).
+ * `createdAt` defaults to current Unix timestamp.
+ * `fee` defaults to 0 (use global fee_rate_bps).
+ */
+declare function buildOrder(params: {
+    maker: PublicKey;
+    condition: PublicKey;
+    tokenId: number;
+    side: number;
+    makerAmount: BN;
+    takerAmount: BN;
+    nonce?: BN;
+    expiry?: BN;
+    createdAt?: BN;
+    fee?: BN;
+    taker?: PublicKey;
+}): Order;
+/**
+ * Sign an order with a Keypair.
+ * Uses Ed25519 (nacl.sign.detached) over the 178-byte canonical message.
+ */
+declare function signOrderWithKeypair(order: Order, keypair: Keypair): SignedOrder;
+/** Return the 178-byte canonical message that gets signed for an order. */
+declare function getOrderSignBytes(order: Order): Uint8Array;
+/** Serialize a SignedOrder to bytes: 178 (order) + 64 (sig) = 242 bytes. */
+declare function serializeSignedOrder(signed: SignedOrder): Uint8Array;
+/**
+ * Deserialize 242 bytes back to a SignedOrder.
+ * Field layout mirrors `serializeOrderToBytes()` + 64-byte signature.
+ */
+declare function deserializeSignedOrder(bytes: Uint8Array): SignedOrder;
+/**
+ * Verify the Ed25519 signature on a signed order.
+ * Returns true only if the signature is valid for `order.maker` (or `order.signer`).
+ */
+declare function verifySignedOrder(signed: SignedOrder): boolean;
+type MatchType = "COMPLEMENTARY" | "MINT" | "MERGE";
+/**
+ * Detect the match type from two orders (pure, no RPC).
+ *
+ * | tokenId A === B | sides        | type          |
+ * |-----------------|--------------|---------------|
+ * | yes             | one BUY+SELL | COMPLEMENTARY |
+ * | no              | both BUY     | MINT          |
+ * | no              | both SELL    | MERGE         |
+ */
+declare function detectMatchType(a: Order | SignedOrder, b: Order | SignedOrder): MatchType;
+
+/**
+ * SPL Token / Token-2022 approve utilities for the CLOB matching flow.
+ *
+ * Before a match instruction can transfer tokens on behalf of a user, the user
+ * must approve the CLOB config PDA as a delegate. These helpers build the
+ * approve transactions that need two signers:
+ *   - signer  = the token owner (user wallet — must sign the approve instruction)
+ *   - payer   = the BE wallet (pays transaction fees)
+ *
+ * Both must sign the resulting Transaction before sending.
+ */
+
+/** Maximum u64 — approve "unlimited" amount. */
+declare const MAX_APPROVE_AMOUNT: BN;
+/**
+ * Build a Transaction that approves the CLOB config PDA to transfer collateral
+ * (USDC) from the signer's ATA.
+ *
+ * Required signers: signer (token owner), payer (fee payer).
+ *
+ * @param collateralMint - e.g. USDC mint
+ * @param signer         - token owner (must sign)
+ * @param payer          - fee payer wallet pubkey
+ * @param delegate       - clob config PDA (the spender)
+ * @param amount         - amount to approve (defaults to MAX_APPROVE_AMOUNT)
+ */
+declare function buildApproveCollateralTx(collateralMint: PublicKey, signer: PublicKey, payer: PublicKey, delegate: PublicKey, amount?: BN): Transaction;
+/**
+ * Build a Transaction that approves the CLOB config PDA to transfer BOTH
+ * YES and NO outcome tokens from the signer's ATAs (two approve instructions).
+ *
+ * Required signers: signer (token owner), payer (fee payer).
+ */
+declare function buildApproveAllOutcomeTokensTx(condition: PublicKey, signer: PublicKey, payer: PublicKey, delegate: PublicKey, programIds: ProgramIds, amount?: BN): Transaction;
+
+export { AccountNotFoundError, ClobClient, type ClobConfig, type ClobWhitelistEntry, type CollateralConfig, type CollateralVault, type Condition, type CreateQuestionParams, CtfClient, type CtfConfig, DEVNET_CONFIG, HookClient, type HookConfig, IX_SYSVAR, InvalidParamError, LOCALNET_CONFIG, MAINNET_CONFIG, MAX_APPROVE_AMOUNT, MarketClient, type MatchType, NETWORK_CONFIGS, type NetworkConfig, type NetworkName, OracleClient, type OracleConfig, type Order, type OrderStatus, PDA, type Position, type ProgramIds, type Question, type QuestionMarketConfig, type QuestionResult, QuestionStatus, SEEDS, type SignedOrder, type TxResult, UnauthorizedError, XMarketError, XMarketSDK, type XMarketSDKConfig, buildApproveAllOutcomeTokensTx, buildApproveCollateralTx, buildBatchedEd25519Instruction, buildOrder, deserializeSignedOrder, detectMatchType, generateContentHash, generateQuestionId, getOrderSignBytes, serializeOrderToBytes, serializeSignedOrder, signOrder, signOrderWithKeypair, verifySignedOrder };