@theliem/xmarket-sdk 3.0.1 → 3.1.0

package/dist/index.js

@@ -4,11 +4,14 @@ var anchor4 = require('@coral-xyz/anchor');
 var web3_js = require('@solana/web3.js');
 var crypto = require('crypto');
 var splToken = require('@solana/spl-token');
-var oracleIdl = require('./oracle-FZJJIJGI.json');
+var oracleIdl = require('./oracle-A5VOIMGM.json');
 var hookIdl = require('./hook-THBRGUM6.json');
-var questionMarketIdl = require('./question_market-CB6ZUZ5E.json');
+var questionMarketIdl = require('./question_market-77YI4LRP.json');
 var conditionalTokensIdl = require('./conditional_tokens-3O5V46N5.json');
 var clobExchangeIdl = require('./clob_exchange-MQF4NI27.json');
+var feeManagementIdl = require('./fee_management-VGF77YXG.json');
+var presaleIdl = require('./presale-ZZJXXQS3.json');
+var marketOracleIdl = require('./market_oracle-E6UUARGR.json');
 var BN4 = require('bn.js');
 var nacl = require('tweetnacl');
 
@@ -38,6 +41,9 @@ var hookIdl__default = /*#__PURE__*/_interopDefault(hookIdl);
 var questionMarketIdl__default = /*#__PURE__*/_interopDefault(questionMarketIdl);
 var conditionalTokensIdl__default = /*#__PURE__*/_interopDefault(conditionalTokensIdl);
 var clobExchangeIdl__default = /*#__PURE__*/_interopDefault(clobExchangeIdl);
+var feeManagementIdl__default = /*#__PURE__*/_interopDefault(feeManagementIdl);
+var presaleIdl__default = /*#__PURE__*/_interopDefault(presaleIdl);
+var marketOracleIdl__default = /*#__PURE__*/_interopDefault(marketOracleIdl);
 var BN4__default = /*#__PURE__*/_interopDefault(BN4);
 var nacl__namespace = /*#__PURE__*/_interopNamespace(nacl);
 
@@ -58,7 +64,18 @@ var SEEDS = {
   hookConfig: Buffer.from("hook_config"),
   extraAccountMetas: Buffer.from("extra-account-metas"),
   clobConfig: Buffer.from("clob_config"),
-  order: Buffer.from("order")
+  order: Buffer.from("order"),
+  feeConfig: Buffer.from("fee_config"),
+  questionFee: Buffer.from("question_fee"),
+  marketFee: Buffer.from("market_fee"),
+  // Presale
+  presale: Buffer.from("presale"),
+  qtMint: Buffer.from("qt_mint"),
+  qtAuthority: Buffer.from("qt_authority"),
+  userBuy: Buffer.from("user_buy"),
+  // Market Oracle
+  marketOracle: Buffer.from("market_oracle"),
+  userClaim: Buffer.from("user_claim")
 };
 var PDA = class {
   // ─── Question Market ────────────────────────────────────────────────────────
@@ -170,6 +187,74 @@ var PDA = class {
       programIds.clobExchange
     );
   }
+  // ─── Fee Management ─────────────────────────────────────────────────────────
+  static feeConfig(owner, programIds) {
+    if (!programIds.feeManagement) throw new Error("feeManagement program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.feeConfig, owner.toBuffer()],
+      programIds.feeManagement
+    );
+  }
+  static questionFee(conditionPda, programIds) {
+    if (!programIds.feeManagement) throw new Error("feeManagement program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.questionFee, conditionPda.toBuffer()],
+      programIds.feeManagement
+    );
+  }
+  static marketFeeOverride(conditionPda, programIds) {
+    if (!programIds.feeManagement) throw new Error("feeManagement program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.marketFee, conditionPda.toBuffer()],
+      programIds.feeManagement
+    );
+  }
+  // ─── Presale ─────────────────────────────────────────────────────────────────
+  static presale(questionMarketConfig, presaleIndex, programIds) {
+    if (!programIds.presale) throw new Error("presale program ID not configured");
+    const idxBuf = Buffer.alloc(8);
+    idxBuf.writeBigUInt64LE(BigInt(presaleIndex.toString()));
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.presale, questionMarketConfig.toBuffer(), idxBuf],
+      programIds.presale
+    );
+  }
+  static qtMint(presalePda, programIds) {
+    if (!programIds.presale) throw new Error("presale program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.qtMint, presalePda.toBuffer()],
+      programIds.presale
+    );
+  }
+  static qtAuthority(presalePda, programIds) {
+    if (!programIds.presale) throw new Error("presale program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.qtAuthority, presalePda.toBuffer()],
+      programIds.presale
+    );
+  }
+  static userBuyRecord(presalePda, user, programIds) {
+    if (!programIds.presale) throw new Error("presale program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.userBuy, presalePda.toBuffer(), user.toBuffer()],
+      programIds.presale
+    );
+  }
+  // ─── Market Oracle ────────────────────────────────────────────────────────────
+  static marketOraclePda(questionPda, programIds) {
+    if (!programIds.marketOracle) throw new Error("marketOracle program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.marketOracle, questionPda.toBuffer()],
+      programIds.marketOracle
+    );
+  }
+  static userClaimRecord(marketOraclePda, user, programIds) {
+    if (!programIds.marketOracle) throw new Error("marketOracle program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.userClaim, marketOraclePda.toBuffer(), user.toBuffer()],
+      programIds.marketOracle
+    );
+  }
 };
 function generateQuestionId(content, salt) {
   const input = content + (salt ?? Date.now());
@@ -249,6 +334,7 @@ var OracleClient = class {
   async updateAdmin(newAdmin, ownerPubkey) {
     const sig = await this.program.methods.updateAdmin(newAdmin).accounts({
       owner: this.walletPubkey,
+      payer: this.walletPubkey,
       oracleConfig: this.configPda(ownerPubkey)
     }).rpc();
     return { signature: sig };
@@ -430,6 +516,7 @@ var QuestionStatus = /* @__PURE__ */ ((QuestionStatus2) => {
   QuestionStatus2["Resolved"] = "resolved";
   return QuestionStatus2;
 })(QuestionStatus || {});
+var FEE_DENOMINATOR = 1e6;
 var XMarketError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -484,7 +571,7 @@ var MarketClient = class {
    * @param payer   - Pays rent for all new accounts (can differ from creator)
    * @param creator - Identity of the question creator (signs but does not pay)
    */
-  async createQuestion(params, oracle, creator = this.walletPubkey, payer = creator) {
+  async createQuestion(params, oracle, creator = this.walletPubkey, payer = this.walletPubkey) {
     const questionId = params.questionId ?? generateQuestionId(params.content);
     const contentHash = params.contentHash ?? generateContentHash(params.content);
     const [questionPda] = PDA.question(this.configPda, questionId, this.programIds);
@@ -523,7 +610,7 @@ var MarketClient = class {
    * @param creator - Whitelisted creator (must be in whitelist or be admin/owner)
    * @param payer   - Fee payer (pays rent; can differ from creator)
    */
-  async createQuestionAdmin(params, oracle, creator = this.walletPubkey, payer = creator) {
+  async createQuestionAdmin(params, oracle, creator = this.walletPubkey, payer = this.walletPubkey) {
     const questionId = params.questionId ?? generateQuestionId(params.content);
     const contentHash = params.contentHash ?? generateContentHash(params.content);
     const [questionPda] = PDA.question(this.configPda, questionId, this.programIds);
@@ -617,6 +704,7 @@ var MarketClient = class {
         questionCount: acc.questionCount.toNumber(),
         approvedCount: acc.approvedCount.toNumber(),
         rejectedCount: acc.rejectedCount.toNumber(),
+        presaleCount: acc.presaleCount.toNumber(),
         whitelist: acc.whitelist,
         whitelistLen: acc.whitelistLen,
         isPaused: acc.isPaused,
@@ -668,6 +756,157 @@ var MarketClient = class {
     if (!q || !q.condition) return { yes: null, no: null };
     return this.ctfClient.fetchBothPositions(q.condition, owner);
   }
+  // ─── Presale instructions ────────────────────────────────────────────────────
+  /**
+   * 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
+   */
+  async createPresale(params, feeConfig, currencyMint, presaleIndex, creator = this.walletPubkey, payer = creator) {
+    if (!this.programIds.presale) throw new Error("presale program ID not configured");
+    const [presalePda] = PDA.presale(this.configPda, presaleIndex, this.programIds);
+    const [qtMint] = PDA.qtMint(presalePda, this.programIds);
+    const [qtAuthority] = PDA.qtAuthority(presalePda, this.programIds);
+    const [userBuyRecord] = PDA.userBuyRecord(presalePda, creator, this.programIds);
+    const presaleVault = splToken.getAssociatedTokenAddressSync(currencyMint, presalePda, true);
+    const creatorQtAta = splToken.getAssociatedTokenAddressSync(qtMint, creator);
+    const creatorCurrencyAta = splToken.getAssociatedTokenAddressSync(currencyMint, creator);
+    const tx = await this.program.methods.createPresale({
+      price: params.price,
+      startTime: params.startTime,
+      endTime: params.endTime,
+      initialBuyAmount: params.initialBuyAmount
+    }).accounts({
+      creator,
+      payer,
+      config: this.configPda,
+      feeConfig,
+      presale: presalePda,
+      qtMint,
+      qtAuthority,
+      currencyMint,
+      presaleVault,
+      creatorCurrencyAta,
+      creatorQtAta,
+      userBuyRecord,
+      presaleProgram: this.programIds.presale,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId,
+      rent: web3_js.SYSVAR_RENT_PUBKEY
+    }).transaction();
+    return { tx, presalePda, qtMint };
+  }
+  /**
+   * 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
+   */
+  async approvePresale(presalePda, contentHash, hookProgram, authorizedClob, expirationTime, creator, currencyMint, caller = this.walletPubkey, payer = caller) {
+    if (!this.programIds.presale) throw new Error("presale program ID not configured");
+    if (!this.programIds.marketOracle) throw new Error("marketOracle program ID not configured");
+    const questionId = presalePda.toBytes();
+    const [questionPda] = PDA.question(this.configPda, questionId, this.programIds);
+    const marketConfig = await this.fetchConfig();
+    if (!marketConfig) throw new Error("QuestionMarketConfig not found");
+    const oraclePubkey = marketConfig.oracle;
+    const [conditionPda] = PDA.condition(oraclePubkey, questionId, this.programIds);
+    const [yesMint] = PDA.yesMint(conditionPda, this.programIds);
+    const [noMint] = PDA.noMint(conditionPda, this.programIds);
+    const [mintAuthority] = PDA.mintAuthority(conditionPda, this.programIds);
+    const [collateralVault] = PDA.collateralVault(currencyMint, this.programIds);
+    const [marketOraclePda] = PDA.marketOraclePda(questionPda, this.programIds);
+    const marketOracleVault = splToken.getAssociatedTokenAddressSync(currencyMint, marketOraclePda, true);
+    const tx = await this.program.methods.approvePresale({
+      contentHash: Array.from(contentHash),
+      hookProgram,
+      authorizedClob,
+      expirationTime,
+      creator
+    }).accounts({
+      caller,
+      payer,
+      config: this.configPda,
+      presale: presalePda,
+      question: questionPda,
+      currencyMint,
+      oracle: oraclePubkey,
+      condition: conditionPda,
+      yesMint,
+      noMint,
+      mintAuthority,
+      collateralVault,
+      marketOracle: marketOraclePda,
+      marketOracleVault,
+      conditionalTokensProgram: this.programIds.conditionalTokens,
+      presaleProgram: this.programIds.presale,
+      marketOracleProgram: this.programIds.marketOracle,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
+      associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId,
+      rent: web3_js.SYSVAR_RENT_PUBKEY
+    }).transaction();
+    return { tx, questionPda, conditionPda, marketOraclePda, marketOracleVault };
+  }
+  /**
+   * Whitelist-only: reject presale so users can refund.
+   */
+  async rejectPresale(presalePda, caller = this.walletPubkey) {
+    if (!this.programIds.presale) throw new Error("presale program ID not configured");
+    return this.program.methods.rejectPresale().accounts({
+      caller,
+      config: this.configPda,
+      presale: presalePda,
+      presaleProgram: this.programIds.presale
+    }).transaction();
+  }
+  /**
+   * Whitelist-only: distribute presale vault funds → agents_rev% + company_rev% + rest to creator.
+   * Must be called after approvePresale.
+   */
+  async collectPresaleRevenue(presalePda, currencyMint, referralAddress, companyAddress, caller = this.walletPubkey) {
+    if (!this.programIds.presale) throw new Error("presale program ID not configured");
+    const presaleVault = splToken.getAssociatedTokenAddressSync(currencyMint, presalePda, true);
+    const referralTokenAccount = splToken.getAssociatedTokenAddressSync(currencyMint, referralAddress);
+    const companyTokenAccount = splToken.getAssociatedTokenAddressSync(currencyMint, companyAddress);
+    return this.program.methods.collectPresaleRevenue().accounts({
+      caller,
+      config: this.configPda,
+      presale: presalePda,
+      presaleVault,
+      currencyMint,
+      referralTokenAccount,
+      companyTokenAccount,
+      presaleProgram: this.programIds.presale,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).transaction();
+  }
+  /**
+   * Whitelist-only: snapshot MST supply so holders can claim trading fees.
+   * Call after oracle resolves the question.
+   */
+  async collectTradingFee(marketOraclePda, qtMint, caller = this.walletPubkey) {
+    if (!this.programIds.marketOracle) throw new Error("marketOracle program ID not configured");
+    return this.program.methods.collectTradingFee().accounts({
+      caller,
+      config: this.configPda,
+      marketOracle: marketOraclePda,
+      qtMint,
+      marketOracleProgram: this.programIds.marketOracle
+    }).transaction();
+  }
 };
 var CtfClient = class {
   constructor(program, provider, programIds) {
@@ -1077,14 +1316,138 @@ var IX_SYSVAR = web3_js.SYSVAR_INSTRUCTIONS_PUBKEY;
 // src/programs/clob.ts
 var CLOB_WHITELIST_SEED = Buffer.from("clob_whitelist");
 var ClobClient = class {
-  constructor(program, provider, programIds) {
+  constructor(program, provider, programIds, networkConfig) {
+    /** ALT cache: condition.toBase58() → loaded ALT account */
+    this._altCache = /* @__PURE__ */ new Map();
     this.program = program;
     this.provider = provider;
     this.programIds = programIds;
+    this.networkConfig = networkConfig;
+  }
+  async companyAddress() {
+    if (!this.feeClient || !this.feeConfigOwner) return void 0;
+    if (!this._companyAddress) {
+      const cfg = await this.feeClient.fetchFeeConfig(this.feeConfigOwner);
+      if (cfg) this._companyAddress = cfg.companyAddress;
+    }
+    return this._companyAddress;
   }
   get walletPubkey() {
     return this.provider.wallet.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.
+   */
+  async ensureAlt(condition, collateralMint, buyerPubkey, buyerNonce, makers) {
+    const cacheKey = condition.toBase58();
+    if (this._altCache.has(cacheKey)) {
+      return this._altCache.get(cacheKey);
+    }
+    const { connection } = this.provider;
+    const payer = this.walletPubkey;
+    const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [extraAccountMeta] = PDA.extraAccountMetaList(yesMint, this.programIds);
+    const [hookConfig] = PDA.hookConfig(this.programIds);
+    const [buyOrderStatus] = PDA.orderStatus(buyerPubkey, buyerNonce, this.programIds);
+    const [buyerPosition] = PDA.position(condition, 1, buyerPubkey, this.programIds);
+    const clobConfigPda = this.configPda();
+    const feeRecipientAddr = (await this.fetchConfig())?.feeRecipient;
+    const addresses = [
+      // instruction program IDs — must be in ALT to keep static keys minimal
+      web3_js.Ed25519Program.programId,
+      this.programIds.clobExchange,
+      // other programs
+      this.programIds.conditionalTokens,
+      this.programIds.hook,
+      splToken.TOKEN_PROGRAM_ID,
+      splToken.TOKEN_2022_PROGRAM_ID,
+      web3_js.SystemProgram.programId,
+      web3_js.SYSVAR_INSTRUCTIONS_PUBKEY,
+      // config PDAs
+      clobConfigPda,
+      hookConfig,
+      this.whitelistEntryPda(payer),
+      // condition PDAs
+      condition,
+      yesMint,
+      extraAccountMeta,
+      // buyer pubkey + ATAs + PDAs
+      buyerPubkey,
+      splToken.getAssociatedTokenAddressSync(collateralMint, buyerPubkey),
+      splToken.getAssociatedTokenAddressSync(yesMint, buyerPubkey, false, splToken.TOKEN_2022_PROGRAM_ID),
+      buyerPosition,
+      buyOrderStatus
+    ];
+    if (feeRecipientAddr) addresses.push(feeRecipientAddr);
+    for (const m of makers) {
+      const seller = m.order.maker;
+      const [sellerPos] = PDA.position(condition, 1, seller, this.programIds);
+      const [sellerStatus] = PDA.orderStatus(seller, m.order.nonce, this.programIds);
+      addresses.push(
+        seller,
+        splToken.getAssociatedTokenAddressSync(yesMint, seller, false, splToken.TOKEN_2022_PROGRAM_ID),
+        splToken.getAssociatedTokenAddressSync(collateralMint, seller),
+        sellerPos,
+        sellerStatus
+      );
+    }
+    if (this.programIds.feeManagement && this.feeConfigOwner) {
+      const companyAddr = await this.companyAddress();
+      addresses.push(
+        this.programIds.feeManagement,
+        PDA.feeConfig(this.feeConfigOwner, this.programIds)[0],
+        PDA.marketFeeOverride(condition, this.programIds)[0]
+      );
+      if (companyAddr) {
+        addresses.push(splToken.getAssociatedTokenAddressSync(collateralMint, companyAddr));
+      }
+      addresses.push(payer);
+    }
+    const slot = await connection.getSlot("finalized");
+    const [createIx, altAddress] = web3_js.AddressLookupTableProgram.createLookupTable({
+      authority: payer,
+      payer,
+      recentSlot: slot
+    });
+    const BATCH = 30;
+    const extendIxs = [];
+    for (let i = 0; i < addresses.length; i += BATCH) {
+      extendIxs.push(web3_js.AddressLookupTableProgram.extendLookupTable({
+        payer,
+        authority: payer,
+        lookupTable: altAddress,
+        addresses: addresses.slice(i, i + BATCH)
+      }));
+    }
+    await this._sendLegacyTx([createIx, extendIxs[0]]);
+    for (let i = 1; i < extendIxs.length; i++) {
+      await this._sendLegacyTx([extendIxs[i]]);
+    }
+    for (let attempt = 0; attempt < 30; attempt++) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const res = await connection.getAddressLookupTable(altAddress);
+      if (res.value && res.value.state.addresses.length === addresses.length) {
+        this._altCache.set(cacheKey, res.value);
+        return res.value;
+      }
+    }
+    throw new Error(`ALT ${altAddress.toBase58()} not active after 30s`);
+  }
+  async _sendLegacyTx(instructions) {
+    const { connection } = this.provider;
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    const { Transaction: Transaction3 } = await import('@solana/web3.js');
+    const tx = new Transaction3();
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = this.walletPubkey;
+    tx.add(...instructions);
+    const signed = await this.provider.wallet.signTransaction(tx);
+    const sig = await connection.sendRawTransaction(signed.serialize());
+    await connection.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, "confirmed");
+  }
   /**
    * Send a match transaction as versioned (v0).
    * Pass a pre-built AddressLookupTableAccount to compress account keys and
@@ -1094,7 +1457,7 @@ var ClobClient = class {
    * If `whitelistedWallet` is provided and differs from `this.provider.wallet`,
    * both wallets sign the transaction (whitelisted operator + payer).
    */
-  async _sendMatchTx(instructions, lookupTable, whitelistedWallet) {
+  async sendMatchTx(instructions, lookupTable, whitelistedWallet) {
     const { connection } = this.provider;
     const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
     const message = new web3_js.TransactionMessage({
@@ -1203,7 +1566,13 @@ var ClobClient = class {
    *
    * remaining_accounts: [hook×3] [seller×5 × N]
    */
-  async matchComplementary(buySigned, makersSigned, collateralMint, feeRecipient, whitelistedWallet, lookupTable) {
+  /** 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.
+   */
+  async buildMatchComplementaryIxs(buySigned, makersSigned, collateralMint, feeRecipient, whitelisted, opts) {
     const condition = buySigned.order.condition;
     const tokenId = buySigned.order.tokenId;
     const [outcomeMint] = tokenId === 1 ? PDA.yesMint(condition, this.programIds) : PDA.noMint(condition, this.programIds);
@@ -1233,12 +1602,23 @@ var ClobClient = class {
         { pubkey: sellOrderStatus, isSigner: false, isWritable: true }
       ];
     });
-    const whitelisted = whitelistedWallet.publicKey;
+    let feeAccounts = [];
+    if (buySigned.order.fee.gtn(0) && this.programIds.feeManagement && this.feeConfigOwner) {
+      const companyAddr = await this.companyAddress();
+      if (companyAddr) {
+        const oracleVault = opts?.marketOracleVault ?? this.walletPubkey;
+        feeAccounts = [
+          { pubkey: this.programIds.feeManagement, isSigner: false, isWritable: false },
+          { pubkey: PDA.feeConfig(this.feeConfigOwner, this.programIds)[0], isSigner: false, isWritable: false },
+          { pubkey: PDA.marketFeeOverride(condition, this.programIds)[0], isSigner: false, isWritable: false },
+          { pubkey: splToken.getAssociatedTokenAddressSync(collateralMint, companyAddr), isSigner: false, isWritable: true },
+          { pubkey: oracleVault, isSigner: false, isWritable: true }
+        ];
+      }
+    }
     const whitelistEntry = this.whitelistEntryPda(whitelisted);
     const makerNonces = makersSigned.map((m) => m.order.nonce);
-    const ed25519Ixs = [
-      buildBatchedEd25519Instruction([buySigned, ...makersSigned])
-    ];
+    const ed25519Ix = buildBatchedEd25519Instruction([buySigned, ...makersSigned]);
     const matchIx = await this.program.methods.matchComplementary(buySigned.order.nonce, makerNonces).accounts({
       whitelisted,
       payer: this.walletPubkey,
@@ -1257,12 +1637,19 @@ var ClobClient = class {
       tokenProgram: splToken.TOKEN_PROGRAM_ID,
       token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
       systemProgram: web3_js.SystemProgram.programId
-    }).remainingAccounts([...hookAccounts, ...makerAccounts]).instruction();
-    const sig = await this._sendMatchTx(
-      [...ed25519Ixs, matchIx],
-      lookupTable,
-      whitelistedWallet
+    }).remainingAccounts([...hookAccounts, ...makerAccounts, ...feeAccounts]).instruction();
+    return [ed25519Ix, matchIx];
+  }
+  async matchComplementary(buySigned, makersSigned, collateralMint, feeRecipient, whitelistedWallet, lookupTable, opts) {
+    const ixs = await this.buildMatchComplementaryIxs(
+      buySigned,
+      makersSigned,
+      collateralMint,
+      feeRecipient,
+      whitelistedWallet.publicKey,
+      opts
     );
+    const sig = await this.sendMatchTx(ixs, lookupTable, whitelistedWallet);
     return { signature: sig };
   }
   /**
@@ -1337,7 +1724,7 @@ var ClobClient = class {
         break;
       }
     }
-    const sig = await this._sendMatchTx(
+    const sig = await this.sendMatchTx(
       [...ed25519Ixs, matchIx],
       lookupTable,
       whitelistedWallet
@@ -1414,7 +1801,7 @@ var ClobClient = class {
         break;
       }
     }
-    const sig = await this._sendMatchTx(
+    const sig = await this.sendMatchTx(
       [...ed25519Ixs, matchIx],
       lookupTable,
       whitelistedWallet
@@ -1432,15 +1819,37 @@ var ClobClient = class {
    *
    * All makers must have the same tokenId and side as makers[0].
    */
-  async matchOrders(taker, makers, collateralMint, feeRecipient, whitelistedWallet, lookupTable) {
+  /**
+   * 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).
+   */
+  async matchOrders(taker, makers, opts) {
     if (makers.length === 0) throw new InvalidParamError("At least 1 maker required");
+    const collateralMint = this.networkConfig.defaultCollateral.mint;
+    const cfg = await this.fetchConfig();
+    if (!cfg) throw new InvalidParamError("CLOB config not found on-chain");
+    const feeRecipient = cfg.feeRecipient;
+    const whitelistedWallet = this.provider.wallet;
+    const alt = await this.ensureAlt(
+      taker.order.condition,
+      collateralMint,
+      taker.order.maker,
+      taker.order.nonce,
+      makers
+    );
     const t = taker.order;
     const m0 = makers[0].order;
     const SIDE_BUY = 0;
     const SIDE_SELL = 1;
     if (t.tokenId === m0.tokenId) {
       if (t.side === SIDE_BUY && makers.every((m) => m.order.side === SIDE_SELL)) {
-        return this.matchComplementary(taker, makers, collateralMint, feeRecipient, whitelistedWallet, lookupTable);
+        return this.matchComplementary(taker, makers, collateralMint, feeRecipient, whitelistedWallet, alt, opts);
       }
       if (t.side === SIDE_SELL && makers.every((m) => m.order.side === SIDE_BUY)) {
         throw new InvalidParamError("COMPLEMENTARY N-maker: taker must be the BUY side");
@@ -1449,19 +1858,11 @@ var ClobClient = class {
     }
     const allBuy = t.side === SIDE_BUY && makers.every((m) => m.order.side === SIDE_BUY);
     const allSell = t.side === SIDE_SELL && makers.every((m) => m.order.side === SIDE_SELL);
-    if (!allBuy && !allSell) {
-      throw new InvalidParamError("MINT/MERGE: all orders must be the same side (all BUY or all SELL)");
-    }
-    if (t.tokenId !== 1) {
-      throw new InvalidParamError("MINT/MERGE: taker must be the YES side (tokenId=1)");
-    }
-    if (!makers.every((m) => m.order.tokenId === 0)) {
-      throw new InvalidParamError("MINT/MERGE: all makers must be the NO side (tokenId=0)");
-    }
-    if (allBuy) {
-      return this.matchMintOrders(taker, makers, collateralMint, feeRecipient, whitelistedWallet, lookupTable);
-    }
-    return this.matchMergeOrders(taker, makers, collateralMint, feeRecipient, whitelistedWallet, lookupTable);
+    if (!allBuy && !allSell) throw new InvalidParamError("MINT/MERGE: all orders must be same side");
+    if (t.tokenId !== 1) throw new InvalidParamError("MINT/MERGE: taker must be YES (tokenId=1)");
+    if (!makers.every((m) => m.order.tokenId === 0)) throw new InvalidParamError("MINT/MERGE: makers must be NO (tokenId=0)");
+    if (allBuy) return this.matchMintOrders(taker, makers, collateralMint, feeRecipient, whitelistedWallet, alt);
+    return this.matchMergeOrders(taker, makers, collateralMint, feeRecipient, whitelistedWallet, alt);
   }
   // ─── Whitelist admin ─────────────────────────────────────────────────────────
   /** Add an address to the CLOB whitelist (owner only). */
@@ -1560,6 +1961,369 @@ var ClobClient = class {
     return status?.isCancelled === true;
   }
 };
+var FeeManagementClient = class {
+  constructor(program, provider, programIds) {
+    this.program = program;
+    this.provider = provider;
+    this.programIds = programIds;
+  }
+  async initFeeConfig(admin, companyAddress, referralAddress, presaleRevenueAddress, investorsMarketRev, companyMarketRev, agentsPresaleRev, companyPresaleRev, authority, payer) {
+    const [feeConfigPda] = PDA.feeConfig(authority, this.programIds);
+    const sig = await this.program.methods.initialize({
+      admin,
+      companyAddress,
+      referralAddress,
+      presaleRevenueAddress,
+      investorsMarketRev,
+      companyMarketRev,
+      agentsPresaleRev,
+      companyPresaleRev
+    }).accounts({
+      authority,
+      payer,
+      feeConfig: feeConfigPda,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers([]).rpc();
+    return { signature: sig };
+  }
+  async fetchFeeConfig(owner) {
+    try {
+      const [pda] = PDA.feeConfig(owner, this.programIds);
+      return await this.program.account.feeConfig.fetch(pda);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Fetch per-question fees for a condition.
+   * Returns null if no fees have been set yet.
+   */
+  async fetchQuestionFee(conditionPda) {
+    try {
+      const [pda] = PDA.questionFee(conditionPda, this.programIds);
+      const acc = await this.program.account.questionFee.fetch(pda);
+      return {
+        conditionId: new Uint8Array(acc.conditionId),
+        mergeFee: acc.mergeFee,
+        redeemFee: acc.redeemFee,
+        swapFee: acc.swapFee,
+        bump: acc.bump
+      };
+    } catch {
+      return 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
+   */
+  async updateFeeConfig(companyAddress, referralAddress, presaleRevenueAddress, investorsMarketRev, companyMarketRev, agentsPresaleRev, companyPresaleRev, authority, payer) {
+    const [feeConfigPda] = PDA.feeConfig(authority, this.programIds);
+    const sig = await this.program.methods.updateConfig({
+      companyAddress,
+      referralAddress,
+      presaleRevenueAddress,
+      investorsMarketRev,
+      companyMarketRev,
+      agentsPresaleRev,
+      companyPresaleRev
+    }).accounts({
+      authority,
+      payer,
+      feeConfig: feeConfigPda
+    }).signers([]).rpc();
+    return { signature: sig };
+  }
+  async setMarketFeeOverride(conditionPda, investors, company, isAdmin, feeConfigOwner, authority, payer) {
+    const [feeConfigPda] = PDA.feeConfig(feeConfigOwner, this.programIds);
+    const [marketFeeOverridePda] = PDA.marketFeeOverride(conditionPda, this.programIds);
+    const sig = await this.program.methods.setMarketFeeOverride(conditionPda, investors, company, isAdmin).accounts({
+      authority,
+      payer,
+      feeConfig: feeConfigPda,
+      marketFeeOverride: marketFeeOverridePda,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers([]).rpc();
+    return { signature: sig };
+  }
+  async buildDistributeFeeIx(conditionPda, amount, feeConfigOwner, sourceAta, companyAta, marketOracleVault, authority) {
+    const [feeConfigPda] = PDA.feeConfig(feeConfigOwner, this.programIds);
+    const [marketFeeOverridePda] = PDA.marketFeeOverride(conditionPda, this.programIds);
+    return this.program.methods.distributeFee(conditionPda, amount).accounts({
+      feeConfig: feeConfigPda,
+      marketFeeOverride: marketFeeOverridePda,
+      authority,
+      sourceAta,
+      companyAta,
+      marketOracleVault,
+      tokenProgram: new web3_js.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
+    }).instruction();
+  }
+  async distributeFee(conditionPda, amount, feeConfigOwner, sourceAta, companyAta, marketOracleVault, authority) {
+    const [feeConfigPda] = PDA.feeConfig(feeConfigOwner, this.programIds);
+    const [marketFeeOverridePda] = PDA.marketFeeOverride(conditionPda, this.programIds);
+    const sig = await this.program.methods.distributeFee(conditionPda, amount).accounts({
+      feeConfig: feeConfigPda,
+      marketFeeOverride: marketFeeOverridePda,
+      authority,
+      sourceAta,
+      companyAta,
+      marketOracleVault,
+      tokenProgram: new web3_js.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
+    }).signers([]).rpc();
+    return { signature: sig };
+  }
+  async setQuestionFee(conditionPda, mergeFee, redeemFee, swapFee, feeConfigOwner, authority, payer) {
+    const [feeConfigPda] = PDA.feeConfig(feeConfigOwner, this.programIds);
+    const [questionFeePda] = PDA.questionFee(conditionPda, this.programIds);
+    const sig = await this.program.methods.setQuestionFee(
+      Array.from(conditionPda.toBytes()),
+      mergeFee,
+      redeemFee,
+      swapFee
+    ).accounts({
+      authority,
+      payer,
+      feeConfig: feeConfigPda,
+      questionFee: questionFeePda,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers([]).rpc();
+    return { signature: sig };
+  }
+};
+var PresaleClient = class {
+  constructor(program, provider, programIds) {
+    this.program = program;
+    this.provider = provider;
+    this.programIds = programIds;
+  }
+  get walletPubkey() {
+    return this.provider.wallet.publicKey;
+  }
+  presalePda(questionMarketConfig, presaleIndex) {
+    return PDA.presale(questionMarketConfig, presaleIndex, this.programIds)[0];
+  }
+  qtMintPda(presalePda) {
+    return PDA.qtMint(presalePda, this.programIds)[0];
+  }
+  qtAuthorityPda(presalePda) {
+    return PDA.qtAuthority(presalePda, this.programIds)[0];
+  }
+  userBuyRecordPda(presalePda, user) {
+    return PDA.userBuyRecord(presalePda, user, this.programIds)[0];
+  }
+  /**
+   * Buy MST tokens during presale.
+   * qtAmount: amount of MST to receive (9 decimals).
+   * USDC cost = qtAmount * price / 1e9.
+   */
+  async buy(presalePda, qtAmount, buyer = this.walletPubkey, payer = this.walletPubkey, signers = []) {
+    const presale = await this.fetchPresale(presalePda);
+    if (!presale) throw new Error(`Presale not found: ${presalePda.toBase58()}`);
+    const qtMint = presale.qtMint;
+    const currencyMint = presale.currencyMint;
+    const qtAuthority = this.qtAuthorityPda(presalePda);
+    const userBuyRecord = this.userBuyRecordPda(presalePda, buyer);
+    const buyerQtAta = splToken.getAssociatedTokenAddressSync(qtMint, buyer);
+    const buyerCurrencyAta = splToken.getAssociatedTokenAddressSync(currencyMint, buyer);
+    const presaleVault = splToken.getAssociatedTokenAddressSync(currencyMint, presalePda, true);
+    const sig = await this.program.methods.buy(qtAmount).accounts({
+      buyer,
+      payer,
+      presale: presalePda,
+      qtMint,
+      qtAuthority,
+      buyerQtAta,
+      buyerCurrencyAta,
+      presaleVault,
+      currencyMint,
+      userBuyRecord,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers(signers).rpc();
+    return { signature: sig };
+  }
+  /**
+   * Refund: burn user's MST and return USDC.
+   * Only callable when presale status = Rejected.
+   */
+  async refund(presalePda, user = this.walletPubkey, signers = []) {
+    const presale = await this.fetchPresale(presalePda);
+    if (!presale) throw new Error(`Presale not found: ${presalePda.toBase58()}`);
+    const qtMint = presale.qtMint;
+    const currencyMint = presale.currencyMint;
+    const userBuyRecord = this.userBuyRecordPda(presalePda, user);
+    const userQtAta = splToken.getAssociatedTokenAddressSync(qtMint, user);
+    const userCurrencyAta = splToken.getAssociatedTokenAddressSync(currencyMint, user);
+    const presaleVault = splToken.getAssociatedTokenAddressSync(currencyMint, presalePda, true);
+    const sig = await this.program.methods.refund().accounts({
+      user,
+      presale: presalePda,
+      qtMint,
+      userQtAta,
+      userCurrencyAta,
+      presaleVault,
+      currencyMint,
+      userBuyRecord,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers(signers).rpc();
+    return { signature: sig };
+  }
+  /**
+   * Creator claims their share of presale revenue after distribute_presale_revenue.
+   */
+  async claimRevenue(presalePda, creator = this.walletPubkey, signers = []) {
+    const presale = await this.fetchPresale(presalePda);
+    if (!presale) throw new Error(`Presale not found: ${presalePda.toBase58()}`);
+    const currencyMint = presale.currencyMint;
+    const presaleVault = splToken.getAssociatedTokenAddressSync(currencyMint, presalePda, true);
+    const creatorCurrencyAta = splToken.getAssociatedTokenAddressSync(currencyMint, creator);
+    const sig = await this.program.methods.claimRevenue().accounts({
+      creator,
+      presale: presalePda,
+      presaleVault,
+      creatorCurrencyAta,
+      currencyMint,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers(signers).rpc();
+    return { signature: sig };
+  }
+  // ─── Queries ─────────────────────────────────────────────────────────────────
+  async fetchPresale(presalePda) {
+    try {
+      const acc = await this.program.account.presaleAccount.fetch(presalePda);
+      const rawStatus = acc.status;
+      const status = rawStatus.approved !== void 0 ? "approved" : rawStatus.rejected !== void 0 ? "rejected" : "pending";
+      return {
+        version: acc.version,
+        questionMarketConfig: acc.questionMarketConfig,
+        presaleIndex: acc.presaleIndex,
+        creator: acc.creator,
+        currencyMint: acc.currencyMint,
+        qtMint: acc.qtMint,
+        price: acc.price,
+        startTime: acc.startTime,
+        endTime: acc.endTime,
+        status,
+        soldTokenAmount: acc.soldTokenAmount,
+        initialTokenAmountCreator: acc.initialTokenAmountCreator,
+        agentsRev: acc.agentsRev,
+        companyRev: acc.companyRev,
+        referralAddress: acc.referralAddress,
+        companyAddress: acc.companyAddress,
+        isDistributeRevenue: acc.isDistributeRevenue,
+        creatorClaimableRevenue: acc.creatorClaimableRevenue,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchUserBuyRecord(presalePda, user) {
+    try {
+      const pda = this.userBuyRecordPda(presalePda, user);
+      const acc = await this.program.account.userBuyRecord.fetch(pda);
+      return {
+        user: acc.user,
+        presale: acc.presale,
+        currencyAmount: acc.currencyAmount,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+var MarketOracleClient = class {
+  constructor(program, provider, programIds) {
+    this.program = program;
+    this.provider = provider;
+    this.programIds = programIds;
+  }
+  get walletPubkey() {
+    return this.provider.wallet.publicKey;
+  }
+  marketOraclePda(questionPda) {
+    return PDA.marketOraclePda(questionPda, this.programIds)[0];
+  }
+  userClaimRecordPda(marketOraclePda, user) {
+    return PDA.userClaimRecord(marketOraclePda, user, this.programIds)[0];
+  }
+  /**
+   * User burns their MST and claims proportional share of oracle vault USDC.
+   * Call after market.collectTradingFee snapshotted qt supply.
+   */
+  async claimFeesShare(marketOraclePda, user = this.walletPubkey, payer = this.walletPubkey, signers = []) {
+    const oracle = await this.fetchMarketOracle(marketOraclePda);
+    if (!oracle) throw new Error(`MarketOracle not found: ${marketOraclePda.toBase58()}`);
+    const currencyMint = oracle.currencyMint;
+    const qtMint = oracle.qtMint;
+    const marketOracleVault = splToken.getAssociatedTokenAddressSync(currencyMint, marketOraclePda, true);
+    const userQtAta = splToken.getAssociatedTokenAddressSync(qtMint, user);
+    const userCurrencyAta = splToken.getAssociatedTokenAddressSync(currencyMint, user);
+    const userClaimRecord = this.userClaimRecordPda(marketOraclePda, user);
+    const sig = await this.program.methods.claimFeesShare().accounts({
+      user,
+      payer,
+      marketOracle: marketOraclePda,
+      marketOracleVault,
+      currencyMint,
+      qtMint,
+      userQtAta,
+      userCurrencyAta,
+      userClaimRecord,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers(signers).rpc();
+    return { signature: sig };
+  }
+  // ─── Queries ─────────────────────────────────────────────────────────────────
+  async fetchMarketOracle(marketOraclePda) {
+    try {
+      const acc = await this.program.account.marketOracleAccount.fetch(marketOraclePda);
+      return {
+        version: acc.version,
+        question: acc.question,
+        questionMarketConfig: acc.questionMarketConfig,
+        currencyMint: acc.currencyMint,
+        creator: acc.creator,
+        qtMint: acc.qtMint,
+        feesDistributed: acc.feesDistributed,
+        qtTotalSupply: acc.qtTotalSupply,
+        totalClaimed: acc.totalClaimed,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchUserClaimRecord(marketOraclePda, user) {
+    try {
+      const pda = this.userClaimRecordPda(marketOraclePda, user);
+      const acc = await this.program.account.userClaimRecord.fetch(pda);
+      return {
+        user: acc.user,
+        marketOracle: acc.marketOracle,
+        hasClaimed: acc.hasClaimed,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+};
 var XMarketSDK = class {
   constructor(config, wallet, marketOwner) {
     this.networkConfig = config;
@@ -1607,10 +2371,38 @@ var XMarketSDK = class {
   get clob() {
     if (!this._clob) {
       const program = new anchor4__namespace.Program(this._withAddress(clobExchangeIdl__default.default, this._programIds.clobExchange), this.provider);
-      this._clob = new ClobClient(program, this.provider, this._programIds);
+      this._clob = new ClobClient(program, this.provider, this._programIds, this.networkConfig);
+      if (this.networkConfig.feeConfigOwner && this._programIds.feeManagement) {
+        this._clob.feeConfigOwner = this.networkConfig.feeConfigOwner;
+        this._clob.feeClient = this.fee;
+      }
     }
     return this._clob;
   }
+  get fee() {
+    if (!this._fee) {
+      if (!this._programIds.feeManagement) throw new Error("feeManagement program ID not configured in NetworkConfig");
+      const program = new anchor4__namespace.Program(this._withAddress(feeManagementIdl__default.default, this._programIds.feeManagement), this.provider);
+      this._fee = new FeeManagementClient(program, this.provider, this._programIds);
+    }
+    return this._fee;
+  }
+  get presale() {
+    if (!this._presale) {
+      if (!this._programIds.presale) throw new Error("presale program ID not configured in NetworkConfig");
+      const program = new anchor4__namespace.Program(this._withAddress(presaleIdl__default.default, this._programIds.presale), this.provider);
+      this._presale = new PresaleClient(program, this.provider, this._programIds);
+    }
+    return this._presale;
+  }
+  get marketOracle() {
+    if (!this._marketOracle) {
+      if (!this._programIds.marketOracle) throw new Error("marketOracle program ID not configured in NetworkConfig");
+      const program = new anchor4__namespace.Program(this._withAddress(marketOracleIdl__default.default, this._programIds.marketOracle), this.provider);
+      this._marketOracle = new MarketOracleClient(program, this.provider, this._programIds);
+    }
+    return this._marketOracle;
+  }
 };
 function buildOrder(params) {
   return {
@@ -1743,13 +2535,17 @@ function buildApproveAllOutcomeTokensTx(condition, signer, payer, delegate, prog
 exports.AccountNotFoundError = AccountNotFoundError;
 exports.ClobClient = ClobClient;
 exports.CtfClient = CtfClient;
+exports.FEE_DENOMINATOR = FEE_DENOMINATOR;
+exports.FeeManagementClient = FeeManagementClient;
 exports.HookClient = HookClient;
 exports.IX_SYSVAR = IX_SYSVAR;
 exports.InvalidParamError = InvalidParamError;
 exports.MAX_APPROVE_AMOUNT = MAX_APPROVE_AMOUNT;
 exports.MarketClient = MarketClient;
+exports.MarketOracleClient = MarketOracleClient;
 exports.OracleClient = OracleClient;
 exports.PDA = PDA;
+exports.PresaleClient = PresaleClient;
 exports.QuestionStatus = QuestionStatus;
 exports.SEEDS = SEEDS;
 exports.UnauthorizedError = UnauthorizedError;