@theliem/xmarket-sdk 3.27.0 → 3.29.0

package/dist/index.d.ts

@@ -1,13 +1,17 @@
 import * as anchor from '@coral-xyz/anchor';
 import * as _solana_web3_js from '@solana/web3.js';
-import { PublicKey, Transaction, TransactionInstruction, Keypair, AddressLookupTableAccount, VersionedTransaction } from '@solana/web3.js';
+import { PublicKey, Transaction, Keypair, TransactionInstruction, AddressLookupTableAccount, VersionedTransaction } from '@solana/web3.js';
 import BN from 'bn.js';
 
 interface ProgramIds {
     oracle: PublicKey;
     conditionalTokens: PublicKey;
     questionMarket: PublicKey;
-    hook: PublicKey;
+    /**
+     * Transfer-hook program (Token-2022).
+     * Optional in V2 — V2 programs use plain SPL token (TOKEN_PROGRAM_ID), no transfer hook.
+     */
+    hook?: PublicKey;
     clobExchange: PublicKey;
     feeManagement?: PublicKey;
     presale?: PublicKey;
@@ -297,53 +301,7 @@ declare class OracleClient {
     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>;
-    /**
-     * Returns initializeExtraAccountMetaList instruction if the account doesn't exist yet, else null.
-     * Used by ClobClient to auto-prepend when extraAccountMetaList is missing.
-     */
-    buildInitHookIxIfNeeded(mint: PublicKey, payer: PublicKey): Promise<TransactionInstruction | null>;
-    /**
-     * 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 {
+declare class CtfClientV2 {
     private readonly program;
     private readonly provider;
     private readonly programIds;
@@ -351,11 +309,12 @@ declare class CtfClient {
     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, hookProgram: PublicKey, authorizedClob: PublicKey, payer?: PublicKey, signers?: Keypair[]): Promise<{
+    prepareCondition(questionId: Uint8Array, oracle: PublicKey, collateralMint: PublicKey, authorizedClob: PublicKey, payer?: PublicKey, signers?: Keypair[]): Promise<{
         signature: string;
         conditionPda: PublicKey;
         yesMint: PublicKey;
@@ -379,17 +338,20 @@ declare class CtfClient {
     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>;
     /**
@@ -399,27 +361,11 @@ declare class CtfClient {
     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.
-     *
-     * 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>;
     /**
@@ -444,24 +390,25 @@ declare class CtfClient {
     collateralVaultPda(collateralMint: PublicKey): PublicKey;
 }
 
-declare class MarketClient {
+declare class MarketClientV2 {
     private readonly program;
     private readonly provider;
     private readonly programIds;
     readonly configPda: PublicKey;
-    /** Injected by XMarketSDK after construction — enables fetchQuestionBalances. */
-    ctfClient?: CtfClient;
-    /** Injected by XMarketSDK — fee config owner (= market owner) for MarketFeeOverride PDA derivation */
+    /** 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: CreateQuestionParams, oracle: PublicKey, creator?: PublicKey, payer?: PublicKey): Promise<{
+    createQuestionAdmin(params: Omit<CreateQuestionParams, "hookProgram">, oracle: PublicKey, creator?: PublicKey, payer?: PublicKey): Promise<{
         tx: Transaction;
         questionPda: PublicKey;
         conditionPda: PublicKey;
@@ -490,7 +437,7 @@ declare class MarketClient {
     /**
      * 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).
+     * Requires ctfClient to be injected (done automatically by XMarketSDKV2).
      */
     fetchQuestionBalances(questionPda: PublicKey, owner: PublicKey): Promise<{
         yes: Position | null;
@@ -516,10 +463,10 @@ declare class MarketClient {
     }>;
     /**
      * 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 hookProgram     token-2022 transfer hook program
      * @param authorizedClob  clob program allowed to do CTF transfers
      * @param expirationTime  Unix seconds
      * @param creator         presale creator pubkey (stored in question)
@@ -528,7 +475,6 @@ declare class MarketClient {
     approvePresale(params: {
         presalePda: PublicKey;
         contentHash: Uint8Array;
-        hookProgram: PublicKey;
         authorizedClob: PublicKey;
         expirationTime: anchor.BN;
         creator: PublicKey;
@@ -651,19 +597,25 @@ declare class FeeManagementClient {
     buildSetAdminTx(newAdmin: PublicKey, feeConfigOwner: PublicKey, authority: PublicKey): Promise<Transaction>;
 }
 
-declare class ClobClient {
+/**
+ * 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 XMarketSDK after construction — enables auto fee distribution */
+    /** Injected by XMarketSDKV2 after construction — enables auto fee distribution */
     feeClient?: FeeManagementClient;
     feeConfigOwner?: PublicKey;
-    /** Injected by XMarketSDK — enables auto-derive of marketOracleVault for presale markets */
-    ctfClient?: CtfClient;
+    /** Injected by XMarketSDKV2 — enables auto-derive of marketOracleVault for presale markets */
+    ctfClient?: CtfClientV2;
     qmConfigPda?: PublicKey;
-    /** Injected by XMarketSDK — enables auto-init extraAccountMetaList if missing */
-    hookClient?: HookClient;
     /** Cached company_address from fee_config to avoid repeated RPC calls */
     private _companyAddress?;
     /** Cached referral_vault from fee_config */
@@ -696,6 +648,7 @@ declare class ClobClient {
     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>;
@@ -738,11 +691,11 @@ declare class ClobClient {
     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
-     *   [extraAccountMetaList, hookConfig, hookProgram]
-     *   [feeManagement, fee_config, mkt_override, company_ata, oracle_vault]  (when fee > 0)
+     *   [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;
@@ -762,25 +715,21 @@ declare class ClobClient {
     private matchComplementarySellVsMultiBuy;
     /**
      * MINT: 1 YES buyer (taker) + N NO buyers (makers).
-     * Phase 1: register taker + all NO makers in parallel.
-     * Phase 2: 1 atomic match tx.
+     * V2: no hook accounts in remainingAccounts.
      *
-     * remaining_accounts per NO maker (5):
-     *   [order_record, buyer_no_token, buyer_no_collateral, buyer_no_position, no_order_status]
+     * remaining_accounts per NO maker (6):
+     *   [maker, order_record, buyer_no_token, buyer_no_collateral, buyer_no_position, no_order_status]
      */
-    /** Build the match_mint_orders instruction (no signing, no sending). */
     private _buildMintIx;
     private matchMintOrders;
     /**
      * MERGE: 1 YES seller (taker) + N NO sellers (makers).
-     * Phase 1: register taker + all NO makers in parallel.
-     * Phase 2: 1 atomic match tx.
+     * V2: no hook accounts in remainingAccounts.
      *
-     * remaining_accounts per NO maker (5):
-     *   [order_record, seller_no_token, seller_no_collateral, seller_no_position, no_order_status]
-     * After all makers, optional 5 fee accounts.
+     * 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.
      */
-    /** Build the match_merge_orders instruction (no signing, no sending). */
     private _buildMergeIx;
     private matchMergeOrders;
     /**
@@ -804,13 +753,6 @@ declare class ClobClient {
     /**
      * High-level match: caller passes price + quantity + keypair — SDK builds,
      * signs, and submits in one call. No manual amount calculation needed.
-     *
-     * Amounts are computed from each order's own limit `price` (percentage, e.g. 51 for 51%).
-     * NEVER pass averageMatchedPrice — that is an engine output, not an order input.
-     *
-     * @param taker   { keypair, condition, tokenId, side, price, quantity, nonce?, expiry? }
-     * @param makers  Array of same shape
-     * @param decimals Collateral decimals (default 9 for USDS)
      */
     matchOrdersFromPrice(taker: {
         keypair: {
@@ -846,21 +788,11 @@ declare class ClobClient {
     }): Promise<TxResult>;
     /**
      * Build an unsigned VersionedTransaction for a set of match instructions.
-     * Callers sign and send externally — mirrors createQuestionAdmin pattern.
      */
     private _buildUnsignedVtx;
     /**
      * Build unsigned VersionedTransaction(s) for matching orders.
-     *
-     * Mirrors createQuestionAdmin pattern — SDK registers orders internally but
-     * returns the match tx unsigned. BE signs with both keypairs and sends:
-     *
-     *   const [vtx] = await sdk.clob.buildMatchOrdersTx(taker, makers, operatorPk, payerPk);
-     *   vtx.sign([feePayerKeypair, operatorKeypair]);
-     *   await connection.sendRawTransaction(vtx.serialize());
-     *
-     * All match types pack into a single VersionedTransaction — same as createQuestionAdmin pattern.
-     * NO-taker MINT/MERGE decomposes into N instructions but all packed in 1 tx.
+     * 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)
@@ -870,12 +802,7 @@ declare class ClobClient {
     }): Promise<VersionedTransaction>;
     /**
      * Build VersionedTransaction for batchCollectRedeemEarly.
-     *
-     * Prerequisite: each user's CollectFeeOrder must be registered on-chain via
-     * buildRegisterCollectFeeOrderTx (one tx per user).
-     *
-     * Flow: batchCollectRedeemEarly ix reads CollectFeeOrderRecord PDAs — no Ed25519 inline.
-     * No tx-size limit from signatures, supports 10+ orders in one tx.
+     * 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
@@ -891,16 +818,13 @@ declare class ClobClient {
     /**
      * Build a Transaction to register a RedeemFeeOrder on-chain (Ed25519 verify + PDA).
      * Must be sent before calling buildBatchRedeemWithFeeTx / buildBatchMergeWithFeeTx.
-     *
-     * ix[0]: batched Ed25519 { pubkey=order.user, sig, msg=128 bytes }
-     * ix[1]: register_redeem_fee_order(nonce)
      */
     buildRegisterRedeemFeeOrderTx(signedOrder: SignedRedeemFeeOrder, payer: PublicKey): Promise<anchor.web3.Transaction>;
     /**
      * Build a VersionedTransaction for batchRedeemWithFee.
-     * Each pair has a YES order + NO order for the same user (same signer or different).
-     * After resolution: YES holder taker_amount > 0, NO holder taker_amount = 0 (or vice versa).
+     * 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?: {
@@ -909,8 +833,7 @@ declare class ClobClient {
     }): Promise<VersionedTransaction>;
     /**
      * Build a VersionedTransaction for batchMergeWithFee (pre-resolution merge with fee).
-     * Each pair: YES order + NO order with equal amounts for the same user.
-     * Only yes_signer receives net USDS (mirrors EVM _matchMergeOrder).
+     * V2: no hook accounts, uses TOKEN_PROGRAM_ID for outcome mints.
      *
      * Prerequisite: each order's RedeemFeeOrderRecord must be registered via buildRegisterRedeemFeeOrderTx.
      */
@@ -921,11 +844,12 @@ declare class ClobClient {
     /**
      * 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.
-     * Use before buildBatchCollectRedeemEarlyTx when no prior buildMatchOrdersTx ran in this session.
+     * V2: no hook program or hook PDAs included.
      */
     buildAltForCondition(condition: PublicKey, _payer: PublicKey, collateralMint?: PublicKey): Promise<AddressLookupTableAccount>;
     fetchConfig(): Promise<ClobConfig | null>;
@@ -1015,6 +939,22 @@ interface UserClaimRecord {
     hasClaimed: boolean;
     bump: number;
 }
+interface FeesShareEstimate {
+    /** Net USDS user will receive if they claim now */
+    share: anchor.BN;
+    /** Total accumulated fees (vault + already claimed) */
+    effectiveTotal: anchor.BN;
+    /** Current vault balance */
+    vaultBalance: anchor.BN;
+    /** User's current MST balance */
+    userQtBalance: anchor.BN;
+    /** Snapshotted total MST supply (0 if not yet distributed) */
+    qtTotalSupply: anchor.BN;
+    /** True if fees_distributed — claim is on-chain executable */
+    feesDistributed: boolean;
+    /** True if user already claimed */
+    hasClaimed: boolean;
+}
 declare class MarketOracleClient {
     private readonly program;
     private readonly provider;
@@ -1034,6 +974,19 @@ declare class MarketOracleClient {
      * presaleAddress is used as the questionId seed in the question PDA.
      */
     getOracleVaultBalance(presaleAddress: PublicKey, qmConfigPda: PublicKey, collateralMint: PublicKey): Promise<number>;
+    /**
+     * Estimate the USDS share a user would receive if they called claimFeesShare now.
+     * Works both before and after fees_distributed — no extra params needed.
+     *
+     * When fees not yet distributed, auto-resolves qtMint via:
+     *   oracle.question (questionPda) → raw account bytes[8..40] = presalePda
+     *   → PDA.qtMint(presalePda) → qtMint
+     *
+     * Formula mirrors on-chain claim_fees_share_handler:
+     *   effective_total = vault_balance + oracle.total_claimed
+     *   share = user_qt_balance * effective_total / oracle.qt_total_supply
+     */
+    estimateFeesShare(marketOraclePda: PublicKey, user: PublicKey): Promise<FeesShareEstimate | null>;
     fetchUserClaimRecord(marketOraclePda: PublicKey, user: PublicKey): Promise<UserClaimRecord | null>;
 }
 
@@ -1162,13 +1115,27 @@ declare class DisputeClient {
     buildResolveDisputeTx(conditionId: Uint8Array, amount: anchor.BN, isRefunded: boolean, owner: PublicKey, admin?: PublicKey): Promise<Transaction>;
 }
 
-declare class XMarketSDK {
+/**
+ * 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 _hook?;
     private _market?;
     private _ctf?;
     private _clob?;
@@ -1181,10 +1148,14 @@ declare class XMarketSDK {
     constructor(config: NetworkConfig, wallet: anchor.Wallet, marketOwner?: PublicKey);
     private _withAddress;
     get oracle(): OracleClient;
-    get hook(): HookClient;
-    get market(): MarketClient;
-    get ctf(): CtfClient;
-    get clob(): ClobClient;
+    /**
+     * 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;
@@ -1193,75 +1164,645 @@ declare class XMarketSDK {
     get dispute(): DisputeClient;
 }
 
-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>;
-    readonly feeConfig: Buffer<ArrayBuffer>;
-    readonly referralConfig: Buffer<ArrayBuffer>;
-    readonly questionFee: Buffer<ArrayBuffer>;
-    readonly marketFee: Buffer<ArrayBuffer>;
-    readonly presale: Buffer<ArrayBuffer>;
-    readonly qtMint: Buffer<ArrayBuffer>;
-    readonly qtAuthority: Buffer<ArrayBuffer>;
-    readonly userBuy: Buffer<ArrayBuffer>;
-    readonly marketOracle: Buffer<ArrayBuffer>;
-    readonly userClaim: Buffer<ArrayBuffer>;
-    readonly adminConfig: Buffer<ArrayBuffer>;
-    readonly claimRecord: Buffer<ArrayBuffer>;
-    readonly disputeConfig: Buffer<ArrayBuffer>;
-    readonly disputeMarket: Buffer<ArrayBuffer>;
-    readonly userDispute: 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];
-    static orderRecord(maker: PublicKey, nonce: BN, programIds: Pick<ProgramIds, "clobExchange">): [PublicKey, number];
-    static collectFeeOrderRecord(user: PublicKey, nonce: BN, programIds: Pick<ProgramIds, "clobExchange">): [PublicKey, number];
-    static redeemFeeOrderRecord(user: PublicKey, nonce: BN, programIds: Pick<ProgramIds, "clobExchange">): [PublicKey, number];
-    static feeConfig(owner: PublicKey, programIds: Pick<ProgramIds, "feeManagement">): [PublicKey, number];
-    static questionFee(conditionPda: PublicKey, programIds: Pick<ProgramIds, "feeManagement">): [PublicKey, number];
-    static marketFeeOverride(conditionPda: PublicKey, programIds: Pick<ProgramIds, "feeManagement">): [PublicKey, number];
-    static presale(questionMarketConfig: PublicKey, presaleIndex: BN, programIds: Pick<ProgramIds, "presale">): [PublicKey, number];
-    static qtMint(presalePda: PublicKey, programIds: Pick<ProgramIds, "presale">): [PublicKey, number];
-    static qtAuthority(presalePda: PublicKey, programIds: Pick<ProgramIds, "presale">): [PublicKey, number];
-    static userBuyRecord(presalePda: PublicKey, user: PublicKey, programIds: Pick<ProgramIds, "presale">): [PublicKey, number];
-    static marketOraclePda(questionPda: PublicKey, programIds: Pick<ProgramIds, "marketOracle">): [PublicKey, number];
-    static userClaimRecord(marketOraclePda: PublicKey, user: PublicKey, programIds: Pick<ProgramIds, "marketOracle">): [PublicKey, number];
-    static referralConfig(owner: PublicKey, programIds: Pick<ProgramIds, "referral">): [PublicKey, number];
-    static adminConfig(owner: PublicKey, programIds: Pick<ProgramIds, "adminContract">): [PublicKey, number];
-    static claimRecord(conditionId: Uint8Array, programIds: Pick<ProgramIds, "adminContract">): [PublicKey, number];
-    static disputeConfig(owner: PublicKey, programIds: Pick<ProgramIds, "dispute">): [PublicKey, number];
-    static disputeMarket(conditionId: Uint8Array, programIds: Pick<ProgramIds, "dispute">): [PublicKey, number];
-    static userDispute(user: PublicKey, conditionId: Uint8Array, programIds: Pick<ProgramIds, "dispute">): [PublicKey, number];
+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>;
+    /**
+     * Returns initializeExtraAccountMetaList instruction if the account doesn't exist yet, else null.
+     * Used by ClobClient to auto-prepend when extraAccountMetaList is missing.
+     */
+    buildInitHookIxIfNeeded(mint: PublicKey, payer: PublicKey): Promise<TransactionInstruction | null>;
+    /**
+     * 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): Promise<Transaction>;
+    /**
+     * 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): Promise<Transaction>;
+    /**
+     * 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): 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.
+     *
+     * 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;
+    /** Injected by XMarketSDK — 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).
+     * @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>;
+    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 XMarketSDK).
+     */
+    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.
+     *
+     * @param presalePda      the presale account
+     * @param contentHash     32-byte hash for question content
+     * @param hookProgram     token-2022 transfer hook program
+     * @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;
+        hookProgram: PublicKey;
+        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>;
+}
+
+declare class ClobClient {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    private readonly networkConfig;
+    /** Injected by XMarketSDK after construction — enables auto fee distribution */
+    feeClient?: FeeManagementClient;
+    feeConfigOwner?: PublicKey;
+    /** Injected by XMarketSDK — enables auto-derive of marketOracleVault for presale markets */
+    ctfClient?: CtfClient;
+    qmConfigPda?: PublicKey;
+    /** Injected by XMarketSDK — enables auto-init extraAccountMetaList if missing */
+    hookClient?: HookClient;
+    /** 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.
+     * 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).
+     *
+     * remaining_accounts layout:
+     *   [seller, order_record, seller_token, seller_collateral, seller_position, sell_status] × N
+     *   [extraAccountMetaList, hookConfig, hookProgram]
+     *   [feeManagement, fee_config, mkt_override, company_ata, oracle_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).
+     * Phase 1: register taker + all NO makers in parallel.
+     * Phase 2: 1 atomic match tx.
+     *
+     * remaining_accounts per NO maker (5):
+     *   [order_record, buyer_no_token, buyer_no_collateral, buyer_no_position, no_order_status]
+     */
+    /** Build the match_mint_orders instruction (no signing, no sending). */
+    private _buildMintIx;
+    private matchMintOrders;
+    /**
+     * MERGE: 1 YES seller (taker) + N NO sellers (makers).
+     * Phase 1: register taker + all NO makers in parallel.
+     * Phase 2: 1 atomic match tx.
+     *
+     * remaining_accounts per NO maker (5):
+     *   [order_record, seller_no_token, seller_no_collateral, seller_no_position, no_order_status]
+     * After all makers, optional 5 fee accounts.
+     */
+    /** Build the match_merge_orders instruction (no signing, no sending). */
+    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.
+     *
+     * Amounts are computed from each order's own limit `price` (percentage, e.g. 51 for 51%).
+     * NEVER pass averageMatchedPrice — that is an engine output, not an order input.
+     *
+     * @param taker   { keypair, condition, tokenId, side, price, quantity, nonce?, expiry? }
+     * @param makers  Array of same shape
+     * @param decimals Collateral decimals (default 9 for USDS)
+     */
+    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.
+     * Callers sign and send externally — mirrors createQuestionAdmin pattern.
+     */
+    private _buildUnsignedVtx;
+    /**
+     * Build unsigned VersionedTransaction(s) for matching orders.
+     *
+     * Mirrors createQuestionAdmin pattern — SDK registers orders internally but
+     * returns the match tx unsigned. BE signs with both keypairs and sends:
+     *
+     *   const [vtx] = await sdk.clob.buildMatchOrdersTx(taker, makers, operatorPk, payerPk);
+     *   vtx.sign([feePayerKeypair, operatorKeypair]);
+     *   await connection.sendRawTransaction(vtx.serialize());
+     *
+     * All match types pack into a single VersionedTransaction — same as createQuestionAdmin pattern.
+     * NO-taker MINT/MERGE decomposes into N instructions but all packed in 1 tx.
+     *
+     * @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.
+     *
+     * Prerequisite: each user's CollectFeeOrder must be registered on-chain via
+     * buildRegisterCollectFeeOrderTx (one tx per user).
+     *
+     * Flow: batchCollectRedeemEarly ix reads CollectFeeOrderRecord PDAs — no Ed25519 inline.
+     * No tx-size limit from signatures, supports 10+ orders in one tx.
+     *
+     * @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.
+     *
+     * ix[0]: batched Ed25519 { pubkey=order.user, sig, msg=128 bytes }
+     * ix[1]: register_redeem_fee_order(nonce)
+     */
+    buildRegisterRedeemFeeOrderTx(signedOrder: SignedRedeemFeeOrder, payer: PublicKey): Promise<anchor.web3.Transaction>;
+    /**
+     * Build a VersionedTransaction for batchRedeemWithFee.
+     * Each pair has a YES order + NO order for the same user (same signer or different).
+     * After resolution: YES holder taker_amount > 0, NO holder taker_amount = 0 (or vice versa).
+     *
+     * 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).
+     * Each pair: YES order + NO order with equal amounts for the same user.
+     * Only yes_signer receives net USDS (mirrors EVM _matchMergeOrder).
+     *
+     * 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.
+     */
+    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.
+     * Use before buildBatchCollectRedeemEarlyTx when no prior buildMatchOrdersTx ran in this session.
+     */
+    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>;
+}
+
+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>;
+    readonly feeConfig: Buffer<ArrayBuffer>;
+    readonly referralConfig: Buffer<ArrayBuffer>;
+    readonly questionFee: Buffer<ArrayBuffer>;
+    readonly marketFee: Buffer<ArrayBuffer>;
+    readonly presale: Buffer<ArrayBuffer>;
+    readonly qtMint: Buffer<ArrayBuffer>;
+    readonly qtAuthority: Buffer<ArrayBuffer>;
+    readonly userBuy: Buffer<ArrayBuffer>;
+    readonly marketOracle: Buffer<ArrayBuffer>;
+    readonly userClaim: Buffer<ArrayBuffer>;
+    readonly adminConfig: Buffer<ArrayBuffer>;
+    readonly claimRecord: Buffer<ArrayBuffer>;
+    readonly disputeConfig: Buffer<ArrayBuffer>;
+    readonly disputeMarket: Buffer<ArrayBuffer>;
+    readonly userDispute: 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];
+    static orderRecord(maker: PublicKey, nonce: BN, programIds: Pick<ProgramIds, "clobExchange">): [PublicKey, number];
+    static collectFeeOrderRecord(user: PublicKey, nonce: BN, programIds: Pick<ProgramIds, "clobExchange">): [PublicKey, number];
+    static redeemFeeOrderRecord(user: PublicKey, nonce: BN, programIds: Pick<ProgramIds, "clobExchange">): [PublicKey, number];
+    static feeConfig(owner: PublicKey, programIds: Pick<ProgramIds, "feeManagement">): [PublicKey, number];
+    static questionFee(conditionPda: PublicKey, programIds: Pick<ProgramIds, "feeManagement">): [PublicKey, number];
+    static marketFeeOverride(conditionPda: PublicKey, programIds: Pick<ProgramIds, "feeManagement">): [PublicKey, number];
+    static presale(questionMarketConfig: PublicKey, presaleIndex: BN, programIds: Pick<ProgramIds, "presale">): [PublicKey, number];
+    static qtMint(presalePda: PublicKey, programIds: Pick<ProgramIds, "presale">): [PublicKey, number];
+    static qtAuthority(presalePda: PublicKey, programIds: Pick<ProgramIds, "presale">): [PublicKey, number];
+    static userBuyRecord(presalePda: PublicKey, user: PublicKey, programIds: Pick<ProgramIds, "presale">): [PublicKey, number];
+    static marketOraclePda(questionPda: PublicKey, programIds: Pick<ProgramIds, "marketOracle">): [PublicKey, number];
+    static userClaimRecord(marketOraclePda: PublicKey, user: PublicKey, programIds: Pick<ProgramIds, "marketOracle">): [PublicKey, number];
+    static referralConfig(owner: PublicKey, programIds: Pick<ProgramIds, "referral">): [PublicKey, number];
+    static adminConfig(owner: PublicKey, programIds: Pick<ProgramIds, "adminContract">): [PublicKey, number];
+    static claimRecord(conditionId: Uint8Array, programIds: Pick<ProgramIds, "adminContract">): [PublicKey, number];
+    static disputeConfig(owner: PublicKey, programIds: Pick<ProgramIds, "dispute">): [PublicKey, number];
+    static disputeMarket(conditionId: Uint8Array, programIds: Pick<ProgramIds, "dispute">): [PublicKey, number];
+    static userDispute(user: PublicKey, conditionId: Uint8Array, programIds: Pick<ProgramIds, "dispute">): [PublicKey, number];
 }
 /** Unique 32-byte question ID: SHA-256(content + timestamp). Different each call. */
 declare function generateQuestionId(content: string, salt?: number): Uint8Array;
@@ -1441,50 +1982,22 @@ type MatchType = "COMPLEMENTARY" | "MINT" | "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.
+ * SPL Token approve utilities for the CLOB matching flow.
+ * V2: YES/NO mints are plain SPL tokens (TOKEN_PROGRAM_ID), no Token-2022.
  */
 
-/** Maximum u64 — approve "unlimited" amount. */
 declare const MAX_APPROVE_AMOUNT: BN;
 /**
- * Build a Transaction that creates YES and NO Token-2022 ATAs for a user
- * (idempotent — safe to call even if they already exist).
- *
- * Required signer: payer (fee payer). No user signature needed.
- *
- * @param condition  - condition PDA
- * @param user       - wallet that will own the ATAs
- * @param payer      - fee payer wallet pubkey
- * @param programIds - network program IDs
+ * Build a Transaction that creates YES and NO SPL ATAs for a user (idempotent).
  */
 declare function buildCreateUserAtasTx(condition: PublicKey, user: PublicKey, payer: PublicKey, programIds: ProgramIds): Transaction;
 /**
- * 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)
+ * Build a Transaction that approves the CLOB config PDA to transfer collateral (USDS).
  */
 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).
+ * Build a Transaction that approves the CLOB config PDA to transfer YES and NO tokens.
  */
 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, 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, XMarketSDKV2 as XMarketSDK, XMarketSDKV2, buildApproveAllOutcomeTokensTx, buildApproveCollateralTx, buildBatchedCollectFeeEd25519Instruction, buildBatchedEd25519Instruction, buildBatchedRedeemFeeEd25519Instruction, buildCreateUserAtasTx, buildOrder, buildOrderFromPrice, deserializeSignedOrder, detectMatchType, generateContentHash, generateQuestionId, getOrderSignBytes, orderAmountsFromPrice, serializeCollectFeeOrderToBytes, serializeOrderToBytes, serializeRedeemFeeOrderToBytes, serializeSignedOrder, signOrder, signOrderWithKeypair, verifySignedOrder };