@theliem/xmarket-sdk 3.28.0 → 3.29.1

package/dist/index.d.ts

@@ -1222,6 +1222,545 @@ declare class XMarketSDK {
     get dispute(): DisputeClient;
 }
 
+declare class CtfClientV2 {
+    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).
+     * V2: uses plain SPL TOKEN_PROGRAM_ID for YES/NO mints — no hook program.
+     * 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, 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.
+     * V2: uses TOKEN_PROGRAM_ID for YES/NO mints (plain SPL, no Token-2022).
+     * ATAs created automatically via `init_if_needed`.
+     */
+    splitPosition(condition: PublicKey, collateralMint: PublicKey, amount: anchor.BN, user?: PublicKey, payer?: PublicKey): Promise<Transaction>;
+    /**
+     * Merge `amount` YES + NO tokens back into collateral.
+     * V2: uses TOKEN_PROGRAM_ID for YES/NO mints (plain SPL, no Token-2022).
+     * Both token balances must be ≥ amount.
+     */
+    mergePosition(condition: PublicKey, collateralMint: PublicKey, amount: anchor.BN, user?: PublicKey, payer?: PublicKey): Promise<Transaction>;
+    /**
+     * After condition resolves: burn outcome tokens proportional to payout
+     * and receive USDC. Works for winning, losing, or both positions.
+     * V2: uses TOKEN_PROGRAM_ID for YES/NO mints (plain SPL, no Token-2022).
+     */
+    redeemPositions(condition: PublicKey, collateralMint: PublicKey, user?: PublicKey, payer?: PublicKey): Promise<Transaction>;
+    /**
+     * 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.
+     * V2: uses TOKEN_PROGRAM_ID (plain SPL) for outcome mints.
+     *
+     * 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.
+     */
+    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 MarketClientV2 {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    readonly configPda: PublicKey;
+    /** Injected by XMarketSDKV2 after construction — enables fetchQuestionBalances. */
+    ctfClient?: CtfClientV2;
+    /** Injected by XMarketSDKV2 — fee config owner (= market owner) for MarketFeeOverride PDA derivation */
+    feeConfigOwner?: PublicKey;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds, ownerPubkey: PublicKey);
+    get walletPubkey(): PublicKey;
+    initialize(admin: PublicKey, oracle: PublicKey, owner?: PublicKey): Promise<Transaction>;
+    /**
+     * Build createQuestionAdmin transaction (whitelist/admin path — status = Approved immediately).
+     * V2: no hookProgram param, uses TOKEN_PROGRAM_ID for YES/NO mints.
+     * @param creator - Whitelisted creator (must be in whitelist or be admin/owner)
+     * @param payer   - Fee payer (pays rent; can differ from creator)
+     */
+    createQuestionAdmin(params: Omit<CreateQuestionParams, "hookProgram">, 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>;
+    growConfig(owner?: PublicKey, payer?: PublicKey): Promise<Transaction>;
+    restoreConfig(snapshot: Buffer, owner?: PublicKey, payer?: PublicKey): Promise<Transaction>;
+    bumpPresaleCount(count: number, authority: 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 XMarketSDKV2).
+     */
+    fetchQuestionBalances(questionPda: PublicKey, owner: PublicKey): Promise<{
+        yes: Position | null;
+        no: Position | null;
+    }>;
+    /**
+     * Any user creates a presale + initial buy (question-market::create_presale).
+     * Reads agents_rev / company_rev from fee_config.
+     *
+     * @param feeConfig   fee_management fee_config PDA (owner = feeConfigOwner)
+     * @param currencyMint collateral token (e.g. USDC)
+     * @param presaleIndex config.presale_count — fetch config first or pass 0 for first presale
+     */
+    createPresale(params: {
+        price: anchor.BN;
+        startTime: anchor.BN;
+        endTime: anchor.BN;
+        initialBuyAmount: anchor.BN;
+    }, feeConfig: PublicKey, currencyMint: PublicKey, presaleIndex: anchor.BN, creator?: PublicKey, payer?: PublicKey): Promise<{
+        tx: Transaction;
+        presalePda: PublicKey;
+        qtMint: PublicKey;
+    }>;
+    /**
+     * Whitelist-only: approve presale → creates question + CTF condition + market_oracle in one tx.
+     * V2: no hookProgram param — removes Token-2022 hook from CPI call.
+     *
+     * @param presalePda      the presale account
+     * @param contentHash     32-byte hash for question content
+     * @param authorizedClob  clob program allowed to do CTF transfers
+     * @param expirationTime  Unix seconds
+     * @param creator         presale creator pubkey (stored in question)
+     * @param currencyMint    collateral mint
+     */
+    approvePresale(params: {
+        presalePda: PublicKey;
+        contentHash: Uint8Array;
+        authorizedClob: PublicKey;
+        expirationTime: anchor.BN;
+        creator: PublicKey;
+        currencyMint: PublicKey;
+        /** Revenue distribution — required: approvePresale now distributes 80/10/10 automatically */
+        referralAddress: PublicKey;
+        companyAddress: PublicKey;
+        adminOwner: PublicKey;
+        caller?: PublicKey;
+        payer?: PublicKey;
+        /** Provide an ALT to use VersionedTransaction (required: 31 accounts exceeds legacy tx limit) */
+        lookupTable?: AddressLookupTableAccount;
+    }): Promise<{
+        tx: Transaction | VersionedTransaction;
+        questionPda: PublicKey;
+        conditionPda: PublicKey;
+        marketOraclePda: PublicKey;
+        marketOracleVault: PublicKey;
+    }>;
+    /**
+     * Whitelist-only: reject presale so users can refund.
+     */
+    rejectPresale(presalePda: PublicKey, caller?: PublicKey): Promise<Transaction>;
+    /**
+     * Whitelist-only: distribute presale vault → 10% agents + 10% company + 80% botmm.
+     * Closes presale_vault ATA and presale PDA after distribution; lamports returned to payer.
+     */
+    collectPresaleRevenue(params: {
+        presalePda: PublicKey;
+        currencyMint: PublicKey;
+        conditionId: Uint8Array;
+        referralAddress: PublicKey;
+        companyAddress: PublicKey;
+        adminOwner: PublicKey;
+        caller?: PublicKey;
+        payer?: PublicKey;
+    }): Promise<Transaction>;
+    /**
+     * Whitelist-only: snapshot MST supply so holders can claim trading fees.
+     * Call after oracle resolves the question.
+     */
+    collectTradingFee(marketOraclePda: PublicKey, qtMint: PublicKey, caller?: PublicKey): Promise<Transaction>;
+}
+
+/**
+ * ClobClientV2 — V2 variant of ClobClient.
+ * Key differences from ClobClient (v1):
+ *   - No hookClient dependency (Token-2022 hook removed)
+ *   - YES/NO token ATAs use TOKEN_PROGRAM_ID (plain SPL) instead of TOKEN_2022_PROGRAM_ID
+ *   - No hook accounts in remainingAccounts for any match instruction
+ *   - No extraAccountMetaList / hookConfig PDAs included in ALTs or remainingAccounts
+ */
+declare class ClobClientV2 {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    private readonly networkConfig;
+    /** Injected by XMarketSDKV2 after construction — enables auto fee distribution */
+    feeClient?: FeeManagementClient;
+    feeConfigOwner?: PublicKey;
+    /** Injected by XMarketSDKV2 — enables auto-derive of marketOracleVault for presale markets */
+    ctfClient?: CtfClientV2;
+    qmConfigPda?: PublicKey;
+    /** Cached company_address from fee_config to avoid repeated RPC calls */
+    private _companyAddress?;
+    /** Cached referral_vault from fee_config */
+    private _referralVault?;
+    /** Cache: conditionPda.toBase58() → marketOracleVault ATA */
+    private _marketOracleVaultCache;
+    /** ALT cache: condition.toBase58() → loaded ALT account */
+    private _altCache;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds, networkConfig: {
+        defaultCollateral: {
+            mint: PublicKey;
+        };
+    });
+    private companyAddress;
+    private referralVault;
+    /**
+     * Derive marketOracleVault ATA for a condition, cached per condition.
+     * Works for presale markets (market_oracle initialized by approvePresale).
+     * Returns undefined if ctfClient/qmConfigPda not injected or marketOracle not configured.
+     */
+    private getMarketOracleVault;
+    /**
+     * Returns a createATA ix for the oracle vault when:
+     *   - takerFee > 0
+     *   - marketFeeOverride exists for the condition
+     *   - oracle vault ATA is not yet initialized
+     * Idempotent — safe to call every tx; returns null if vault already exists.
+     */
+    private buildInitOracleVaultIfNeeded;
+    get walletPubkey(): PublicKey;
+    /**
+     * Get or create an ALT for a condition.
+     * V2: no hook accounts — TOKEN_2022_PROGRAM_ID and hook PDAs are excluded.
+     * Includes order_record PDAs for taker + all makers so match tx stays under 1232 bytes.
+     */
+    ensureAlt(condition: PublicKey, collateralMint: PublicKey, takerSigned: SignedOrder, makers: SignedOrder[]): Promise<AddressLookupTableAccount>;
+    private _sendLegacyTxSig;
+    private _sendLegacyTx;
+    private _ensureClobOutcomeAtas;
+    /**
+     * Send a match transaction as versioned (v0) with optional ALT.
+     * Both operator wallet and payer (this.provider.wallet) sign.
+     */
+    sendMatchTx(instructions: TransactionInstruction[], lookupTable?: AddressLookupTableAccount, whitelistedWallet?: anchor.Wallet): Promise<string>;
+    configPda(): PublicKey;
+    /**
+     * Register a signed order on-chain.
+     * Sends Ed25519 precompile ix + register_order ix in one legacy tx.
+     * Called at match time (engine-triggered), not at order placement.
+     */
+    registerOrder(signed: SignedOrder): Promise<string>;
+    /** Register only if the PDA doesn't exist yet (idempotent). */
+    private registerOrderIfNeeded;
+    /**
+     * Build a legacy Transaction to register a CollectFeeOrder on-chain.
+     * Must be signed and sent before calling buildBatchCollectRedeemEarlyTx.
+     *
+     * Flow: [Ed25519 ix (1 user sig) + register_collect_fee_order ix]
+     * Caller signs with payer keypair and sends.
+     */
+    buildRegisterCollectFeeOrderTx(signedOrder: SignedCollectFeeOrder, payer: PublicKey): Promise<Transaction>;
+    /**
+     * Register a CollectFeeOrder on-chain and send immediately (operator-signed flow).
+     * Idempotent — skips if PDA already exists.
+     */
+    registerCollectFeeOrderIfNeeded(signedOrder: SignedCollectFeeOrder): Promise<void>;
+    /** Cancel an order — closes its OrderRecord PDA and returns rent to maker. */
+    cancelOrder(nonce: anchor.BN): Promise<TxResult>;
+    initialize(operators: PublicKey[], feeRecipient: PublicKey, feeRateBps: number): Promise<TxResult>;
+    addOperator(operator: PublicKey): Promise<TxResult>;
+    removeOperator(operator: PublicKey): Promise<TxResult>;
+    setPaused(paused: boolean): Promise<TxResult>;
+    forceResetClob(programData: PublicKey, newAdmin: PublicKey, newOperators: PublicKey[], newFeeRecipient: PublicKey, newFeeRateBps: number): Promise<TxResult>;
+    /**
+     * Build match_complementary instruction (no Ed25519 — OrderRecord PDAs used).
+     * V2: no hook accounts in remainingAccounts.
+     *
+     * remaining_accounts layout:
+     *   [seller, order_record, seller_token, seller_collateral, seller_position, sell_status] × N
+     *   [feeManagement, fee_config, mkt_override, company_ata, oracle_vault, referral_vault] (when fee > 0)
+     */
+    buildMatchComplementaryIxs(takerSigned: SignedOrder, makersSigned: SignedOrder[], collateralMint: PublicKey, feeRecipient: PublicKey, operator: PublicKey, opts?: {
+        marketOracleVault?: PublicKey;
+        fillAmount?: anchor.BN;
+    }, useTakerPrice?: boolean, skipCrossingCheck?: boolean): Promise<TransactionInstruction[]>;
+    /**
+     * COMPLEMENTARY: 1 taker (BUY) + N makers (SELL), same tokenId.
+     * Phase 1: register taker + all makers in parallel.
+     * Phase 2: 1 atomic match tx.
+     */
+    private matchComplementary;
+    /**
+     * 1 SELL taker vs N BUY makers.
+     * Program now supports SELL-as-taker natively → 1 instruction with all BUY makers
+     * in remaining_accounts (same structure as BUY taker case).
+     */
+    private matchComplementarySellVsMultiBuy;
+    /**
+     * MINT: 1 YES buyer (taker) + N NO buyers (makers).
+     * V2: no hook accounts in remainingAccounts.
+     *
+     * remaining_accounts per NO maker (6):
+     *   [maker, order_record, buyer_no_token, buyer_no_collateral, buyer_no_position, no_order_status]
+     */
+    private _buildMintIx;
+    private matchMintOrders;
+    /**
+     * MERGE: 1 YES seller (taker) + N NO sellers (makers).
+     * V2: no hook accounts in remainingAccounts.
+     *
+     * remaining_accounts per NO maker (6):
+     *   [maker, order_record, seller_no_token, seller_no_collateral, seller_no_position, no_order_status]
+     * After all makers, optional 6 fee accounts.
+     */
+    private _buildMergeIx;
+    private matchMergeOrders;
+    /**
+     * Auto-detect match type and execute 2-phase:
+     *   Phase 1 — register all orders (taker + makers) on-chain in parallel.
+     *   Phase 2 — 1 atomic match transaction.
+     *
+     * Detection (pure, no RPC):
+     *   taker.tokenId === makers[0].tokenId:
+     *     taker BUY + all makers SELL → COMPLEMENTARY
+     *   taker.tokenId !== makers[0].tokenId + all BUY  → MINT
+     *   taker.tokenId !== makers[0].tokenId + all SELL → MERGE
+     *
+     * @param opts.marketOracleVault  Oracle vault ATA for presale markets.
+     *   Omit for admin markets (payer used as placeholder).
+     */
+    matchOrders(taker: SignedOrder, makers: SignedOrder[], opts?: {
+        marketOracleVault?: PublicKey;
+        operatorWallet?: anchor.Wallet;
+    }): Promise<TxResult>;
+    /**
+     * High-level match: caller passes price + quantity + keypair — SDK builds,
+     * signs, and submits in one call. No manual amount calculation needed.
+     */
+    matchOrdersFromPrice(taker: {
+        keypair: {
+            publicKey: PublicKey;
+            secretKey: Uint8Array;
+        };
+        condition: PublicKey;
+        tokenId: number;
+        side: 0 | 1;
+        price: number;
+        quantity: number;
+        nonce?: BN;
+        expiry?: BN;
+        fee?: BN;
+        taker?: PublicKey;
+    }, makers: Array<{
+        keypair: {
+            publicKey: PublicKey;
+            secretKey: Uint8Array;
+        };
+        condition: PublicKey;
+        tokenId: number;
+        side: 0 | 1;
+        price: number;
+        quantity: number;
+        nonce?: BN;
+        expiry?: BN;
+        fee?: BN;
+        taker?: PublicKey;
+    }>, decimals?: number, opts?: {
+        marketOracleVault?: PublicKey;
+        operatorWallet?: anchor.Wallet;
+    }): Promise<TxResult>;
+    /**
+     * Build an unsigned VersionedTransaction for a set of match instructions.
+     */
+    private _buildUnsignedVtx;
+    /**
+     * Build unsigned VersionedTransaction(s) for matching orders.
+     * V2: no hookClient, no hook init ixs prepended.
+     *
+     * @param operator - Whitelisted CLOB operator pubkey (must sign)
+     * @param payer    - Fee payer pubkey (must sign, pays tx fee + rent)
+     */
+    buildMatchOrdersTx(taker: SignedOrder, makers: SignedOrder[], operator: PublicKey, payer: PublicKey, opts?: {
+        marketOracleVault?: PublicKey;
+    }): Promise<VersionedTransaction>;
+    /**
+     * Build VersionedTransaction for batchCollectRedeemEarly.
+     * V2: no hook accounts in remainingAccounts, uses TOKEN_PROGRAM_ID for outcome mints.
+     *
+     * @param signedOrders  - Array of { order, signature } (used to derive record PDAs)
+     * @param condition     - Market condition PDA
+     * @param outcomeIndex  - 0 = NO wins, 1 = YES wins
+     * @param operator      - Whitelisted operator pubkey (must sign)
+     * @param payer         - Fee payer pubkey (must sign)
+     * @param opts.marketOracleVault - MarketOracle vault for fee distribution
+     */
+    buildBatchCollectRedeemEarlyTx(signedOrders: SignedCollectFeeOrder[], condition: PublicKey, outcomeIndex: 0 | 1, operator: PublicKey, payer: PublicKey, opts?: {
+        marketOracleVault?: PublicKey;
+        lookupTable?: AddressLookupTableAccount;
+    }): Promise<VersionedTransaction>;
+    /**
+     * Build a Transaction to register a RedeemFeeOrder on-chain (Ed25519 verify + PDA).
+     * Must be sent before calling buildBatchRedeemWithFeeTx / buildBatchMergeWithFeeTx.
+     */
+    buildRegisterRedeemFeeOrderTx(signedOrder: SignedRedeemFeeOrder, payer: PublicKey): Promise<anchor.web3.Transaction>;
+    /**
+     * Build a VersionedTransaction for batchRedeemWithFee.
+     * V2: no hook accounts, uses TOKEN_PROGRAM_ID for outcome mints.
+     *
+     * Each pair has a YES order + NO order for the same user (same signer or different).
+     * Prerequisite: each order's RedeemFeeOrderRecord must be registered via buildRegisterRedeemFeeOrderTx.
+     */
+    buildBatchRedeemWithFeeTx(orderPairs: RedeemFeeOrderPair[], condition: PublicKey, operator: PublicKey, payer: PublicKey, opts?: {
+        marketOracleVault?: PublicKey;
+        lookupTable?: AddressLookupTableAccount;
+    }): Promise<VersionedTransaction>;
+    /**
+     * Build a VersionedTransaction for batchMergeWithFee (pre-resolution merge with fee).
+     * V2: no hook accounts, uses TOKEN_PROGRAM_ID for outcome mints.
+     *
+     * Prerequisite: each order's RedeemFeeOrderRecord must be registered via buildRegisterRedeemFeeOrderTx.
+     */
+    buildBatchMergeWithFeeTx(orderPairs: RedeemFeeOrderPair[], condition: PublicKey, operator: PublicKey, payer: PublicKey, opts?: {
+        marketOracleVault?: PublicKey;
+        lookupTable?: AddressLookupTableAccount;
+    }): Promise<VersionedTransaction>;
+    /**
+     * Build ALT for batchCollectRedeemEarly — includes per-user accounts so all
+     * remaining_accounts fit as 1-byte ALT indices instead of 32-byte inline addresses.
+     * V2: no hook program or hook PDAs included.
+     */
+    buildAltForCollectBatch(condition: PublicKey, payer: PublicKey, collateralMint: PublicKey, signedOrders: SignedCollectFeeOrder[], outcomeIndex: 0 | 1): Promise<AddressLookupTableAccount>;
+    /**
+     * Build ALT with static accounts for a condition — no order-specific PDAs needed.
+     * V2: no hook program or hook PDAs included.
+     */
+    buildAltForCondition(condition: PublicKey, _payer: PublicKey, collateralMint?: PublicKey): Promise<AddressLookupTableAccount>;
+    fetchConfig(): Promise<ClobConfig | null>;
+    fetchOrderStatus(maker: PublicKey, nonce: anchor.BN): Promise<OrderStatus | null>;
+    fetchOrderRecord(maker: PublicKey, nonce: anchor.BN): Promise<{
+        maker: PublicKey;
+        condition: PublicKey;
+        tokenId: number;
+        side: number;
+        makerAmount: anchor.BN;
+        takerAmount: anchor.BN;
+        nonce: anchor.BN;
+        expiry: anchor.BN;
+        fee: anchor.BN;
+        taker: PublicKey;
+        signer: PublicKey;
+    } | null>;
+}
+
+/**
+ * XMarketSDKV2 — V2 variant of XMarketSDK.
+ *
+ * Key differences from XMarketSDK (v1):
+ *   - Uses V2 program IDs (conditionalTokens, clobExchange, questionMarket)
+ *   - CtfClientV2: plain SPL TOKEN_PROGRAM_ID for YES/NO mints, no hook
+ *   - ClobClientV2: no hookClient, no hook accounts in match instructions
+ *   - MarketClientV2: no hookProgram param in createQuestionAdmin / approvePresale
+ *   - No HookClient (sdk.hook throws a clear error)
+ *
+ * Usage:
+ *   const sdk = new XMarketSDKV2(DEVNET_V2_CONFIG, wallet, marketOwner);
+ *   await sdk.market.createQuestionAdmin(params, oracle);  // no hookProgram
+ *   await sdk.clob.matchOrders(taker, makers);             // no hook in remainingAccounts
+ */
+declare class XMarketSDKV2 {
+    readonly provider: anchor.AnchorProvider;
+    readonly networkConfig: NetworkConfig;
+    private readonly _programIds;
+    private readonly _marketOwner;
+    private _oracle?;
+    private _market?;
+    private _ctf?;
+    private _clob?;
+    private _fee?;
+    private _presale?;
+    private _marketOracle?;
+    private _admin?;
+    private _referral?;
+    private _dispute?;
+    constructor(config: NetworkConfig, wallet: anchor.Wallet, marketOwner?: PublicKey);
+    private _withAddress;
+    get oracle(): OracleClient;
+    /**
+     * V2 does not use a hook program — calling this getter throws an error.
+     * The hook is not needed for plain SPL YES/NO mints.
+     */
+    get hook(): never;
+    get market(): MarketClientV2;
+    get ctf(): CtfClientV2;
+    get clob(): ClobClientV2;
+    get fee(): FeeManagementClient;
+    get presale(): PresaleClient;
+    get marketOracle(): MarketOracleClient;
+    get admin(): AdminClient;
+    get referral(): ReferralClient;
+    get dispute(): DisputeClient;
+}
+
 declare const SEEDS: {
     readonly config: Buffer<ArrayBuffer>;
     readonly question: Buffer<ArrayBuffer>;
@@ -1516,4 +2055,4 @@ declare function buildApproveCollateralTx(collateralMint: PublicKey, signer: Pub
  */
 declare function buildApproveAllOutcomeTokensTx(condition: PublicKey, signer: PublicKey, payer: PublicKey, delegate: PublicKey, programIds: ProgramIds, amount?: BN): Transaction;
 
-export { AccountNotFoundError, AdminClient, type AdminConfigInfo, type ClaimRecordInfo, ClobClient, type ClobConfig, type CollateralConfig, type CollateralVault, type CollectFeeOrder, type Condition, type CreateQuestionParams, CtfClient, type CtfConfig, DisputeClient, type DisputeConfigInfo, type DisputeMarketInfo, FEE_DENOMINATOR, FeeManagementClient, type FeesShareEstimate, HookClient, type HookConfig, IX_SYSVAR, InvalidParamError, MAX_APPROVE_AMOUNT, MarketClient, MarketOracleClient, type MarketOracleInfo, type MatchType, type NetworkConfig, type NetworkName, OracleClient, type OracleConfig, type Order, type OrderStatus, PDA, type Position, PresaleClient, type PresaleInfo, type ProgramIds, type Question, type QuestionFee, type QuestionMarketConfig, type QuestionResult, QuestionStatus, type RedeemFeeOrder, type RedeemFeeOrderPair, ReferralClient, type ReferralConfigInfo, SEEDS, type SignedCollectFeeOrder, type SignedOrder, type SignedRedeemFeeOrder, type TxResult, UnauthorizedError, type UserBuyRecord, type UserClaimRecord, type UserDisputeInfo, XMarketError, XMarketSDK, buildApproveAllOutcomeTokensTx, buildApproveCollateralTx, buildBatchedCollectFeeEd25519Instruction, buildBatchedEd25519Instruction, buildBatchedRedeemFeeEd25519Instruction, buildCreateUserAtasTx, buildOrder, buildOrderFromPrice, deserializeSignedOrder, detectMatchType, generateContentHash, generateQuestionId, getOrderSignBytes, orderAmountsFromPrice, serializeCollectFeeOrderToBytes, serializeOrderToBytes, serializeRedeemFeeOrderToBytes, serializeSignedOrder, signOrder, signOrderWithKeypair, verifySignedOrder };
+export { AccountNotFoundError, AdminClient, type AdminConfigInfo, type ClaimRecordInfo, ClobClient, ClobClientV2, type ClobConfig, type CollateralConfig, type CollateralVault, type CollectFeeOrder, type Condition, type CreateQuestionParams, CtfClient, CtfClientV2, type CtfConfig, DisputeClient, type DisputeConfigInfo, type DisputeMarketInfo, FEE_DENOMINATOR, FeeManagementClient, type FeesShareEstimate, HookClient, type HookConfig, IX_SYSVAR, InvalidParamError, MAX_APPROVE_AMOUNT, MarketClient, MarketClientV2, MarketOracleClient, type MarketOracleInfo, type MatchType, type NetworkConfig, type NetworkName, OracleClient, type OracleConfig, type Order, type OrderStatus, PDA, type Position, PresaleClient, type PresaleInfo, type ProgramIds, type Question, type QuestionFee, type QuestionMarketConfig, type QuestionResult, QuestionStatus, type RedeemFeeOrder, type RedeemFeeOrderPair, ReferralClient, type ReferralConfigInfo, SEEDS, type SignedCollectFeeOrder, type SignedOrder, type SignedRedeemFeeOrder, type TxResult, UnauthorizedError, type UserBuyRecord, type UserClaimRecord, type UserDisputeInfo, XMarketError, XMarketSDK, XMarketSDKV2, buildApproveAllOutcomeTokensTx, buildApproveCollateralTx, buildBatchedCollectFeeEd25519Instruction, buildBatchedEd25519Instruction, buildBatchedRedeemFeeEd25519Instruction, buildCreateUserAtasTx, buildOrder, buildOrderFromPrice, deserializeSignedOrder, detectMatchType, generateContentHash, generateQuestionId, getOrderSignBytes, orderAmountsFromPrice, serializeCollectFeeOrderToBytes, serializeOrderToBytes, serializeRedeemFeeOrderToBytes, serializeSignedOrder, signOrder, signOrderWithKeypair, verifySignedOrder };