@theliem/xmarket-sdk 3.0.1 → 3.1.1

package/dist/index.d.mts

@@ -9,6 +9,9 @@ interface ProgramIds {
     questionMarket: PublicKey;
     hook: PublicKey;
     clobExchange: PublicKey;
+    feeManagement?: PublicKey;
+    presale?: PublicKey;
+    marketOracle?: PublicKey;
 }
 interface CollateralConfig {
     mint: PublicKey;
@@ -20,6 +23,8 @@ interface NetworkConfig {
     rpcUrl: string;
     programIds: ProgramIds;
     defaultCollateral: CollateralConfig;
+    /** Owner of the fee_config PDA — used to auto-derive fee distribution accounts */
+    feeConfigOwner?: PublicKey;
 }
 type NetworkName = string;
 
@@ -93,6 +98,7 @@ interface QuestionMarketConfig {
     questionCount: number;
     approvedCount: number;
     rejectedCount: number;
+    presaleCount: number;
     whitelist: PublicKey[];
     whitelistLen: number;
     isPaused: boolean;
@@ -160,6 +166,15 @@ interface OrderStatus {
     isCancelled: boolean;
     bump: number;
 }
+/** Per-question fee rates, all out of FEE_DENOMINATOR (1_000_000). E.g. 2_000 = 0.2% */
+interface QuestionFee {
+    conditionId: Uint8Array;
+    mergeFee: BN;
+    redeemFee: BN;
+    swapFee: BN;
+    bump: number;
+}
+declare const FEE_DENOMINATOR = 1000000;
 /**
  * Off-chain order struct passed as instruction data.
  * Operator validates + submits matched order pairs on-chain.
@@ -226,9 +241,9 @@ declare class OracleClient {
     configPda(owner?: PublicKey): PublicKey;
     /** One-time setup. Caller becomes owner. */
     initialize(admin: PublicKey): Promise<TxResult>;
-    /** Admin or owner adds an address to the oracle whitelist. */
+    /** Admin or owner adds an address to the oracle resolver whitelist. */
     addToWhitelist(address: PublicKey, ownerPubkey?: PublicKey): Promise<TxResult>;
-    /** Admin or owner removes an address from the oracle whitelist. */
+    /** Admin or owner removes an address from the oracle resolver whitelist. */
     removeFromWhitelist(address: PublicKey, ownerPubkey?: PublicKey): Promise<TxResult>;
     /**
      * Whitelisted reporter resolves a question.
@@ -400,17 +415,6 @@ declare class MarketClient {
     constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds, ownerPubkey: PublicKey);
     get walletPubkey(): PublicKey;
     initialize(admin: PublicKey, oracle: PublicKey, owner?: PublicKey): Promise<Transaction>;
-    /**
-     * Build createQuestion transaction.
-     * @param payer   - Pays rent for all new accounts (can differ from creator)
-     * @param creator - Identity of the question creator (signs but does not pay)
-     */
-    createQuestion(params: CreateQuestionParams, oracle: PublicKey, creator?: PublicKey, payer?: PublicKey): Promise<{
-        tx: Transaction;
-        questionPda: PublicKey;
-        conditionPda: PublicKey;
-        questionId: Uint8Array;
-    }>;
     /**
      * Build createQuestionAdmin transaction (whitelist/admin path — status = Approved immediately).
      * @param creator - Whitelisted creator (must be in whitelist or be admin/owner)
@@ -448,14 +452,114 @@ declare class MarketClient {
         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(presalePda: PublicKey, contentHash: Uint8Array, hookProgram: PublicKey, authorizedClob: PublicKey, expirationTime: anchor.BN, creator: PublicKey, currencyMint: PublicKey, caller?: PublicKey, payer?: PublicKey): Promise<{
+        tx: Transaction;
+        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 funds → agents_rev% + company_rev% + rest to creator.
+     * Must be called after approvePresale.
+     */
+    collectPresaleRevenue(presalePda: PublicKey, currencyMint: PublicKey, referralAddress: PublicKey, companyAddress: PublicKey, caller?: 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 {
+declare class FeeManagementClient {
     private readonly program;
     private readonly provider;
     private readonly programIds;
     constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds);
+    initFeeConfig(admin: PublicKey, companyAddress: PublicKey, referralAddress: PublicKey, presaleRevenueAddress: PublicKey, investorsMarketRev: number, companyMarketRev: number, agentsPresaleRev: number, companyPresaleRev: number, authority: PublicKey, payer: PublicKey): Promise<TxResult>;
+    fetchFeeConfig(owner: PublicKey): Promise<any | null>;
+    /**
+     * Fetch per-question fees for a condition.
+     * Returns null if no fees have been set yet.
+     */
+    fetchQuestionFee(conditionPda: PublicKey): Promise<QuestionFee | null>;
+    /**
+     * Set per-question fees for a condition.
+     * @param conditionPda   - condition PDA from the question
+     * @param mergeFee       - fee out of FEE_DENOMINATOR (1_000_000), e.g. 2_000 = 0.2%
+     * @param redeemFee      - fee out of FEE_DENOMINATOR
+     * @param swapFee        - trading fee out of FEE_DENOMINATOR
+     * @param feeConfigOwner - pubkey that owns the fee_config PDA (usually market deployer)
+     * @param authority      - signer authorized in fee_config whitelist / admin / owner
+     * @param payer          - rent + tx fee payer
+     */
+    updateFeeConfig(companyAddress: PublicKey, referralAddress: PublicKey, presaleRevenueAddress: PublicKey, investorsMarketRev: number, companyMarketRev: number, agentsPresaleRev: number, companyPresaleRev: number, authority: PublicKey, payer: PublicKey): Promise<TxResult>;
+    setMarketFeeOverride(conditionPda: PublicKey, investors: number, company: number, isAdmin: boolean, feeConfigOwner: PublicKey, authority: PublicKey, payer: PublicKey): Promise<TxResult>;
+    buildDistributeFeeIx(conditionPda: PublicKey, amount: BN, feeConfigOwner: PublicKey, sourceAta: PublicKey, companyAta: PublicKey, marketOracleVault: PublicKey, authority: PublicKey): Promise<TransactionInstruction>;
+    distributeFee(conditionPda: PublicKey, amount: BN, feeConfigOwner: PublicKey, sourceAta: PublicKey, companyAta: PublicKey, marketOracleVault: PublicKey, authority: PublicKey): Promise<TxResult>;
+    setQuestionFee(conditionPda: PublicKey, mergeFee: BN, redeemFee: BN, swapFee: BN, feeConfigOwner: PublicKey, authority: PublicKey, payer: PublicKey): Promise<TxResult>;
+}
+
+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;
+    /** Cached company_address from fee_config to avoid repeated RPC calls */
+    private _companyAddress?;
+    /** ALT cache: condition.toBase58() → loaded ALT account */
+    private _altCache;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds, networkConfig: {
+        defaultCollateral: {
+            mint: PublicKey;
+        };
+    });
+    private companyAddress;
     get walletPubkey(): PublicKey;
+    /**
+     * Get or create an ALT for a condition.
+     * First call: creates + extends ALT on-chain, waits for activation (~2s).
+     * Subsequent calls for same condition: returns cached ALT instantly.
+     * BE devs never interact with this — called automatically by matchOrders.
+     */
+    ensureAlt(condition: PublicKey, collateralMint: PublicKey, buyerPubkey: PublicKey, buyerNonce: anchor.BN, makers: SignedOrder[]): Promise<AddressLookupTableAccount>;
+    private _sendLegacyTx;
     /**
      * Send a match transaction as versioned (v0).
      * Pass a pre-built AddressLookupTableAccount to compress account keys and
@@ -465,7 +569,7 @@ declare class ClobClient {
      * If `whitelistedWallet` is provided and differs from `this.provider.wallet`,
      * both wallets sign the transaction (whitelisted operator + payer).
      */
-    private _sendMatchTx;
+    sendMatchTx(instructions: TransactionInstruction[], lookupTable?: AddressLookupTableAccount, whitelistedWallet?: anchor.Wallet): Promise<string>;
     /** PDA for a CLOB whitelist entry. */
     whitelistEntryPda(address: PublicKey): PublicKey;
     configPda(): PublicKey;
@@ -496,6 +600,15 @@ declare class ClobClient {
      *
      * remaining_accounts: [hook×3] [seller×5 × N]
      */
+    /** Build Ed25519 + matchComplementary instructions without sending.
+     *
+     * If `buySigned.order.fee > 0` and `feeClient` + `feeConfigOwner` are wired in,
+     * automatically appends 5 fee_management remaining_accounts so the program CPIs
+     * to distribute_fee internally. No manual `feeDistribute` param needed.
+     */
+    buildMatchComplementaryIxs(buySigned: SignedOrder, makersSigned: SignedOrder[], collateralMint: PublicKey, feeRecipient: PublicKey, whitelisted: PublicKey, opts?: {
+        marketOracleVault?: PublicKey;
+    }): Promise<TransactionInstruction[]>;
     private matchComplementary;
     /**
      * MINT match: 1 YES buyer (taker) + N NO buyers (makers).
@@ -530,7 +643,19 @@ declare class ClobClient {
      *
      * All makers must have the same tokenId and side as makers[0].
      */
-    matchOrders(taker: SignedOrder, makers: SignedOrder[], collateralMint: PublicKey, feeRecipient: PublicKey, whitelistedWallet: anchor.Wallet, lookupTable?: AddressLookupTableAccount): Promise<TxResult>;
+    /**
+     * Auto-detect match type and execute in a single transaction.
+     * ALT is managed automatically (created on first call per condition, cached thereafter).
+     * feeRecipient and collateralMint are derived from on-chain config.
+     * Fee distribution (distribute_fee CPI) fires automatically when order.fee > 0.
+     *
+     * @param opts.marketOracleVault  Required for presale markets (is_admin=false).
+     *   Pass the ATA of the market_oracle PDA so 50% of fee goes there.
+     *   For admin markets (is_admin=true) omit — payer is used as placeholder (no transfer).
+     */
+    matchOrders(taker: SignedOrder, makers: SignedOrder[], opts?: {
+        marketOracleVault?: PublicKey;
+    }): Promise<TxResult>;
     /** Add an address to the CLOB whitelist (owner only). */
     addToWhitelist(address: PublicKey): Promise<TxResult>;
     /** Batch-add addresses to the CLOB whitelist (owner only). All PDAs created in one tx. */
@@ -548,6 +673,102 @@ declare class ClobClient {
     isOrderCancelled(maker: PublicKey, nonce: anchor.BN): Promise<boolean>;
 }
 
+interface PresaleInfo {
+    version: number;
+    questionMarketConfig: PublicKey;
+    presaleIndex: anchor.BN;
+    creator: PublicKey;
+    currencyMint: PublicKey;
+    qtMint: PublicKey;
+    price: anchor.BN;
+    startTime: anchor.BN;
+    endTime: anchor.BN;
+    status: "pending" | "approved" | "rejected";
+    soldTokenAmount: anchor.BN;
+    initialTokenAmountCreator: anchor.BN;
+    agentsRev: number;
+    companyRev: number;
+    referralAddress: PublicKey;
+    companyAddress: PublicKey;
+    isDistributeRevenue: boolean;
+    creatorClaimableRevenue: anchor.BN;
+    bump: number;
+}
+interface UserBuyRecord {
+    user: PublicKey;
+    presale: PublicKey;
+    currencyAmount: anchor.BN;
+    bump: number;
+}
+declare class PresaleClient {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds);
+    get walletPubkey(): PublicKey;
+    presalePda(questionMarketConfig: PublicKey, presaleIndex: anchor.BN): PublicKey;
+    qtMintPda(presalePda: PublicKey): PublicKey;
+    qtAuthorityPda(presalePda: PublicKey): PublicKey;
+    userBuyRecordPda(presalePda: PublicKey, user: PublicKey): PublicKey;
+    /**
+     * Buy MST tokens during presale.
+     * qtAmount: amount of MST to receive (9 decimals).
+     * USDC cost = qtAmount * price / 1e9.
+     */
+    buy(presalePda: PublicKey, qtAmount: anchor.BN, buyer?: PublicKey, payer?: PublicKey, signers?: Keypair[]): Promise<TxResult>;
+    /**
+     * Refund: burn user's MST and return USDC.
+     * Only callable when presale status = Rejected.
+     */
+    refund(presalePda: PublicKey, user?: PublicKey, signers?: Keypair[]): Promise<TxResult>;
+    /**
+     * Creator claims their share of presale revenue after distribute_presale_revenue.
+     */
+    claimRevenue(presalePda: PublicKey, creator?: PublicKey, signers?: Keypair[]): Promise<TxResult>;
+    /**
+     * Transfer creator_claimable_revenue (80%) to BOTMM wallet.
+     * Call after collectPresaleRevenue (distribute_presale_revenue).
+     */
+    distributeBotmmRevenue(presalePda: PublicKey, botmmAddress: PublicKey, currencyMint?: PublicKey): Promise<Transaction>;
+    fetchPresale(presalePda: PublicKey): Promise<PresaleInfo | null>;
+    fetchUserBuyRecord(presalePda: PublicKey, user: PublicKey): Promise<UserBuyRecord | null>;
+}
+
+interface MarketOracleInfo {
+    version: number;
+    question: PublicKey;
+    questionMarketConfig: PublicKey;
+    currencyMint: PublicKey;
+    creator: PublicKey;
+    qtMint: PublicKey;
+    feesDistributed: boolean;
+    qtTotalSupply: anchor.BN;
+    totalClaimed: anchor.BN;
+    bump: number;
+}
+interface UserClaimRecord {
+    user: PublicKey;
+    marketOracle: PublicKey;
+    hasClaimed: boolean;
+    bump: number;
+}
+declare class MarketOracleClient {
+    private readonly program;
+    private readonly provider;
+    private readonly programIds;
+    constructor(program: anchor.Program, provider: anchor.AnchorProvider, programIds: ProgramIds);
+    get walletPubkey(): PublicKey;
+    marketOraclePda(questionPda: PublicKey): PublicKey;
+    userClaimRecordPda(marketOraclePda: PublicKey, user: PublicKey): PublicKey;
+    /**
+     * User burns their MST and claims proportional share of oracle vault USDC.
+     * Call after market.collectTradingFee snapshotted qt supply.
+     */
+    claimFeesShare(marketOraclePda: PublicKey, user?: PublicKey, payer?: PublicKey, signers?: Keypair[]): Promise<TxResult>;
+    fetchMarketOracle(marketOraclePda: PublicKey): Promise<MarketOracleInfo | null>;
+    fetchUserClaimRecord(marketOraclePda: PublicKey, user: PublicKey): Promise<UserClaimRecord | null>;
+}
+
 declare class XMarketSDK {
     readonly provider: anchor.AnchorProvider;
     readonly networkConfig: NetworkConfig;
@@ -558,6 +779,9 @@ declare class XMarketSDK {
     private _market?;
     private _ctf?;
     private _clob?;
+    private _fee?;
+    private _presale?;
+    private _marketOracle?;
     constructor(config: NetworkConfig, wallet: anchor.Wallet, marketOwner?: PublicKey);
     private _withAddress;
     get oracle(): OracleClient;
@@ -565,6 +789,9 @@ declare class XMarketSDK {
     get market(): MarketClient;
     get ctf(): CtfClient;
     get clob(): ClobClient;
+    get fee(): FeeManagementClient;
+    get presale(): PresaleClient;
+    get marketOracle(): MarketOracleClient;
 }
 
 declare const SEEDS: {
@@ -584,6 +811,15 @@ declare const SEEDS: {
     readonly extraAccountMetas: Buffer<ArrayBuffer>;
     readonly clobConfig: Buffer<ArrayBuffer>;
     readonly order: Buffer<ArrayBuffer>;
+    readonly feeConfig: 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>;
 };
 declare class PDA {
     static questionMarketConfig(owner: PublicKey, programIds: Pick<ProgramIds, "questionMarket">): [PublicKey, number];
@@ -603,6 +839,15 @@ declare class PDA {
     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 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];
 }
 /** Unique 32-byte question ID: SHA-256(content + timestamp). Different each call. */
 declare function generateQuestionId(content: string, salt?: number): Uint8Array;
@@ -736,4 +981,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, ClobClient, type ClobConfig, type ClobWhitelistEntry, type CollateralConfig, type CollateralVault, type Condition, type CreateQuestionParams, CtfClient, type CtfConfig, HookClient, type HookConfig, IX_SYSVAR, InvalidParamError, MAX_APPROVE_AMOUNT, MarketClient, type MatchType, type NetworkConfig, type NetworkName, OracleClient, type OracleConfig, type Order, type OrderStatus, PDA, type Position, type ProgramIds, type Question, type QuestionMarketConfig, type QuestionResult, QuestionStatus, SEEDS, type SignedOrder, type TxResult, UnauthorizedError, XMarketError, XMarketSDK, buildApproveAllOutcomeTokensTx, buildApproveCollateralTx, buildBatchedEd25519Instruction, buildOrder, deserializeSignedOrder, detectMatchType, generateContentHash, generateQuestionId, getOrderSignBytes, serializeOrderToBytes, serializeSignedOrder, signOrder, signOrderWithKeypair, verifySignedOrder };
+export { AccountNotFoundError, ClobClient, type ClobConfig, type ClobWhitelistEntry, type CollateralConfig, type CollateralVault, type Condition, type CreateQuestionParams, CtfClient, type CtfConfig, 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, SEEDS, type SignedOrder, type TxResult, UnauthorizedError, type UserBuyRecord, type UserClaimRecord, XMarketError, XMarketSDK, buildApproveAllOutcomeTokensTx, buildApproveCollateralTx, buildBatchedEd25519Instruction, buildOrder, deserializeSignedOrder, detectMatchType, generateContentHash, generateQuestionId, getOrderSignBytes, serializeOrderToBytes, serializeSignedOrder, signOrder, signOrderWithKeypair, verifySignedOrder };