@theliem/xmarket-sdk 3.3.0 → 3.4.0

package/dist/index.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var anchor4 = require('@coral-xyz/anchor');
+var anchor5 = require('@coral-xyz/anchor');
 var web3_js = require('@solana/web3.js');
 var crypto = require('crypto');
 var splToken = require('@solana/spl-token');
-var BN4 = require('bn.js');
+var BN5 = require('bn.js');
 var nacl = require('tweetnacl');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -27,8 +27,8 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var anchor4__namespace = /*#__PURE__*/_interopNamespace(anchor4);
-var BN4__default = /*#__PURE__*/_interopDefault(BN4);
+var anchor5__namespace = /*#__PURE__*/_interopNamespace(anchor5);
+var BN5__default = /*#__PURE__*/_interopDefault(BN5);
 var nacl__namespace = /*#__PURE__*/_interopNamespace(nacl);
 
 // src/sdk.ts
@@ -59,7 +59,10 @@ var SEEDS = {
   userBuy: Buffer.from("user_buy"),
   // Market Oracle
   marketOracle: Buffer.from("market_oracle"),
-  userClaim: Buffer.from("user_claim")
+  userClaim: Buffer.from("user_claim"),
+  // Admin Contract
+  adminConfig: Buffer.from("admin_config"),
+  claimRecord: Buffer.from("claim_record")
 };
 var PDA = class {
   // ─── Question Market ────────────────────────────────────────────────────────
@@ -171,6 +174,14 @@ var PDA = class {
       programIds.clobExchange
     );
   }
+  static orderRecord(maker, nonce, programIds) {
+    const nonceBuf = Buffer.alloc(8);
+    nonceBuf.writeBigUInt64LE(BigInt(nonce.toString()));
+    return web3_js.PublicKey.findProgramAddressSync(
+      [Buffer.from("order_record"), maker.toBuffer(), nonceBuf],
+      programIds.clobExchange
+    );
+  }
   // ─── Fee Management ─────────────────────────────────────────────────────────
   static feeConfig(owner, programIds) {
     if (!programIds.feeManagement) throw new Error("feeManagement program ID not configured");
@@ -239,6 +250,21 @@ var PDA = class {
       programIds.marketOracle
     );
   }
+  // ─── Admin Contract ──────────────────────────────────────────────────────
+  static adminConfig(owner, programIds) {
+    if (!programIds.adminContract) throw new Error("adminContract program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.adminConfig, owner.toBuffer()],
+      programIds.adminContract
+    );
+  }
+  static claimRecord(conditionId, programIds) {
+    if (!programIds.adminContract) throw new Error("adminContract program ID not configured");
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.claimRecord, conditionId],
+      programIds.adminContract
+    );
+  }
 };
 function generateQuestionId(content, salt) {
   const input = content + (salt ?? Date.now());
@@ -299,7 +325,7 @@ var OracleClient = class {
     return this.program.methods.resolveQuestion(
       Array.from(questionId),
       outcomeCount,
-      payoutNumerators.map((n) => new anchor4__namespace.BN(n))
+      payoutNumerators.map((n) => new anchor5__namespace.BN(n))
     ).accounts({
       reporter,
       oracleConfig,
@@ -566,7 +592,7 @@ var MarketClient = class {
       contentHash: Array.from(contentHash),
       hookProgram: params.hookProgram,
       authorizedClob: params.authorizedClob,
-      expirationTime: new anchor4__namespace.BN(params.expirationTime)
+      expirationTime: new anchor5__namespace.BN(params.expirationTime)
     }).accounts({
       creator,
       payer,
@@ -634,6 +660,22 @@ var MarketClient = class {
       config: this.configPda
     }).transaction();
   }
+  async growConfig(owner = this.walletPubkey, payer = owner) {
+    return this.program.methods.growConfig().accounts({
+      payer,
+      owner,
+      config: this.configPda,
+      systemProgram: web3_js.SystemProgram.programId
+    }).transaction();
+  }
+  async restoreConfig(snapshot, owner = this.walletPubkey, payer = owner) {
+    return this.program.methods.restoreConfig(Array.from(snapshot)).accounts({
+      payer,
+      owner,
+      config: this.configPda,
+      systemProgram: web3_js.SystemProgram.programId
+    }).transaction();
+  }
   // ─── Queries ─────────────────────────────────────────────────────────────────
   async fetchConfig() {
     try {
@@ -825,13 +867,26 @@ var MarketClient = class {
    * Whitelist-only: distribute presale vault → 10% agents + 10% company + 80% botmm.
    * Closes presale_vault ATA and presale PDA after distribution; lamports returned to payer.
    */
-  async collectPresaleRevenue(presalePda, currencyMint, referralAddress, companyAddress, botmmAddress, caller = this.walletPubkey, payer = this.walletPubkey) {
+  async collectPresaleRevenue(params) {
+    const {
+      presalePda,
+      currencyMint,
+      conditionId,
+      referralAddress,
+      companyAddress,
+      adminOwner
+    } = params;
+    const caller = params.caller ?? this.walletPubkey;
+    const payer = params.payer ?? this.walletPubkey;
     if (!this.programIds.presale) throw new Error("presale program ID not configured");
+    if (!this.programIds.adminContract) throw new Error("adminContract program ID not configured");
     const presaleVault = splToken.getAssociatedTokenAddressSync(currencyMint, presalePda, true);
     const referralTokenAccount = splToken.getAssociatedTokenAddressSync(currencyMint, referralAddress);
     const companyTokenAccount = splToken.getAssociatedTokenAddressSync(currencyMint, companyAddress);
-    const botmmTokenAccount = splToken.getAssociatedTokenAddressSync(currencyMint, botmmAddress);
-    return this.program.methods.collectPresaleRevenue().accounts({
+    const [adminConfig] = PDA.adminConfig(adminOwner, this.programIds);
+    const [claimRecord] = PDA.claimRecord(conditionId, this.programIds);
+    const adminVault = splToken.getAssociatedTokenAddressSync(currencyMint, adminConfig, true);
+    return this.program.methods.collectPresaleRevenue(Array.from(conditionId)).accounts({
       caller,
       config: this.configPda,
       presale: presalePda,
@@ -839,9 +894,12 @@ var MarketClient = class {
       currencyMint,
       referralTokenAccount,
       companyTokenAccount,
-      botmmTokenAccount,
+      adminVault,
+      adminConfig,
+      claimRecord,
       payer,
       presaleProgram: this.programIds.presale,
+      adminProgram: this.programIds.adminContract,
       tokenProgram: splToken.TOKEN_PROGRAM_ID,
       associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
       systemProgram: web3_js.SystemProgram.programId
@@ -1033,7 +1091,21 @@ var CtfClient = class {
     const userYesAta = splToken.getAssociatedTokenAddressSync(yesMint, user, false, splToken.TOKEN_2022_PROGRAM_ID);
     const userNoAta = splToken.getAssociatedTokenAddressSync(noMint, user, false, splToken.TOKEN_2022_PROGRAM_ID);
     const userCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, user);
-    return this.program.methods.redeemPositions().accounts({
+    const createYesAtaIx = splToken.createAssociatedTokenAccountIdempotentInstruction(
+      payer,
+      userYesAta,
+      user,
+      yesMint,
+      splToken.TOKEN_2022_PROGRAM_ID
+    );
+    const createNoAtaIx = splToken.createAssociatedTokenAccountIdempotentInstruction(
+      payer,
+      userNoAta,
+      user,
+      noMint,
+      splToken.TOKEN_2022_PROGRAM_ID
+    );
+    const redeemIx = await this.program.methods.redeemPositions().accounts({
       user,
       payer,
       condition,
@@ -1049,14 +1121,17 @@ var CtfClient = class {
       tokenProgram: splToken.TOKEN_PROGRAM_ID,
       token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
       systemProgram: web3_js.SystemProgram.programId
-    }).transaction();
+    }).instruction();
+    const tx = new web3_js.Transaction();
+    tx.add(createYesAtaIx, createNoAtaIx, redeemIx);
+    return tx;
   }
   /**
    * Oracle directly resolves a condition with payout numerators.
    * Bypasses QuestionMarket — only for oracle-owned conditions.
    */
   async reportPayouts(condition, payoutNumerators) {
-    const sig = await this.program.methods.reportPayouts(payoutNumerators.map((n) => new anchor4__namespace.BN(n))).accounts({
+    const sig = await this.program.methods.reportPayouts(payoutNumerators.map((n) => new anchor5__namespace.BN(n))).accounts({
       oracle: this.walletPubkey,
       condition
     }).rpc();
@@ -1287,57 +1362,60 @@ var ClobClient = class {
   }
   /**
    * 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.
+   * Includes order_record PDAs for taker + all makers so match tx stays under 1232 bytes.
    */
-  async ensureAlt(condition, collateralMint, buyerPubkey, buyerNonce, makers) {
+  async ensureAlt(condition, collateralMint, takerSigned, makers) {
     const cacheKey = condition.toBase58();
     if (this._altCache.has(cacheKey)) {
       return this._altCache.get(cacheKey);
     }
     const { connection } = this.provider;
     const payer = this.walletPubkey;
+    const taker = takerSigned.order.maker;
+    const takerNonce = takerSigned.order.nonce;
+    const tokenId = takerSigned.order.tokenId;
     const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [noMint] = PDA.noMint(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 [takerOrderStatus] = PDA.orderStatus(taker, takerNonce, this.programIds);
+    const [takerOrderRecord] = PDA.orderRecord(taker, takerNonce, this.programIds);
+    const [takerPosition] = PDA.position(condition, tokenId, taker, this.programIds);
     const clobConfigPda = this.configPda();
+    const outcomeMint = tokenId === 1 ? yesMint : noMint;
     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,
-      // condition PDAs
       condition,
       yesMint,
+      noMint,
       extraAccountMeta,
-      // buyer pubkey + ATAs + PDAs
-      buyerPubkey,
-      splToken.getAssociatedTokenAddressSync(collateralMint, buyerPubkey),
-      splToken.getAssociatedTokenAddressSync(yesMint, buyerPubkey, false, splToken.TOKEN_2022_PROGRAM_ID),
-      buyerPosition,
-      buyOrderStatus
+      taker,
+      splToken.getAssociatedTokenAddressSync(collateralMint, taker),
+      splToken.getAssociatedTokenAddressSync(outcomeMint, taker, false, splToken.TOKEN_2022_PROGRAM_ID),
+      takerPosition,
+      takerOrderStatus,
+      takerOrderRecord
     ];
     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 [sellerPos] = PDA.position(condition, tokenId, seller, this.programIds);
       const [sellerStatus] = PDA.orderStatus(seller, m.order.nonce, this.programIds);
+      const [sellerRecord] = PDA.orderRecord(seller, m.order.nonce, this.programIds);
       addresses.push(
         seller,
-        splToken.getAssociatedTokenAddressSync(yesMint, seller, false, splToken.TOKEN_2022_PROGRAM_ID),
+        sellerRecord,
+        splToken.getAssociatedTokenAddressSync(outcomeMint, seller, false, splToken.TOKEN_2022_PROGRAM_ID),
         splToken.getAssociatedTokenAddressSync(collateralMint, seller),
         sellerPos,
         sellerStatus
@@ -1385,34 +1463,42 @@ var ClobClient = class {
     }
     throw new Error(`ALT ${altAddress.toBase58()} not active after 30s`);
   }
-  async _sendLegacyTx(instructions) {
+  async _sendLegacyTxSig(instructions) {
     const { connection } = this.provider;
     const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
-    const { Transaction: Transaction7 } = await import('@solana/web3.js');
-    const tx = new Transaction7();
+    const { Transaction: Transaction8 } = await import('@solana/web3.js');
+    const tx = new Transaction8();
     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");
+    const sig = await connection.sendRawTransaction(signed.serialize(), { skipPreflight: true });
+    const result = await connection.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, "confirmed");
+    if (result.value.err) {
+      const txInfo = await connection.getTransaction(sig, { maxSupportedTransactionVersion: 0 });
+      const logs = txInfo?.meta?.logMessages ?? [];
+      const err = new Error(`Register tx failed: ${JSON.stringify(result.value.err)}
+${logs.join("\n")}`);
+      err.logs = logs;
+      throw err;
+    }
+    return sig;
+  }
+  async _sendLegacyTx(instructions) {
+    await this._sendLegacyTxSig(instructions);
   }
   /**
-   * Send a match transaction as versioned (v0).
-   * Pass a pre-built AddressLookupTableAccount to compress account keys and
-   * stay under the 1232-byte limit — required for match_complementary which
-   * has ~25 accounts + 2 Ed25519 precompile instructions (~1697 bytes raw).
-   *
-   * If `whitelistedWallet` is provided and differs from `this.provider.wallet`,
-   * both wallets sign the transaction (whitelisted operator + payer).
+   * Send a match transaction as versioned (v0) with optional ALT.
+   * Both operator wallet and payer (this.provider.wallet) sign.
    */
   async sendMatchTx(instructions, lookupTable, whitelistedWallet) {
     const { connection } = this.provider;
     const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    const cuLimit = web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 8e5 });
     const message = new web3_js.TransactionMessage({
       payerKey: this.walletPubkey,
       recentBlockhash: blockhash,
-      instructions
+      instructions: [cuLimit, ...instructions]
     }).compileToV0Message(lookupTable ? [lookupTable] : []);
     const vtx = new web3_js.VersionedTransaction(message);
     const signers = [this.provider.wallet.payer];
@@ -1421,19 +1507,67 @@ var ClobClient = class {
     }
     vtx.sign(signers);
     const sig = await connection.sendRawTransaction(vtx.serialize(), {
-      skipPreflight: false
+      skipPreflight: true
     });
-    await connection.confirmTransaction(
+    const result = await connection.confirmTransaction(
       { signature: sig, blockhash, lastValidBlockHeight },
       "confirmed"
     );
+    if (result.value.err) {
+      const txInfo = await connection.getTransaction(sig, { maxSupportedTransactionVersion: 0 });
+      const logs = txInfo?.meta?.logMessages ?? [];
+      const err = new Error(`Match tx failed: ${JSON.stringify(result.value.err)}
+${logs.join("\n")}`);
+      err.logs = logs;
+      throw err;
+    }
     return sig;
   }
   configPda() {
     return PDA.clobConfig(this.programIds)[0];
   }
-  // ─── Instructions ────────────────────────────────────────────────────────────
-  /** One-time setup. Caller becomes admin. */
+  // ─── Register / Cancel ───────────────────────────────────────────────────────
+  /**
+   * 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.
+   */
+  async registerOrder(signed) {
+    const nonce = signed.order.nonce;
+    const orderSigner = signed.order.maker;
+    const [orderRecord] = PDA.orderRecord(orderSigner, nonce, this.programIds);
+    const ed25519Ix = buildBatchedEd25519Instruction([signed]);
+    const [orderStatus] = PDA.orderStatus(orderSigner, nonce, this.programIds);
+    const registerIx = await this.program.methods.registerOrder(nonce).accounts({
+      payer: this.walletPubkey,
+      clobConfig: this.configPda(),
+      ixSysvar: IX_SYSVAR,
+      orderSigner,
+      orderRecord,
+      orderStatus,
+      systemProgram: web3_js.SystemProgram.programId
+    }).instruction();
+    return this._sendLegacyTxSig([ed25519Ix, registerIx]);
+  }
+  /** Register only if the PDA doesn't exist yet (idempotent). */
+  async registerOrderIfNeeded(signed) {
+    const [pda] = PDA.orderRecord(signed.order.maker, signed.order.nonce, this.programIds);
+    const existing = await this.program.account.signedOrderRecord.fetchNullable(pda);
+    if (!existing) {
+      await this.registerOrder(signed);
+    }
+  }
+  /** Cancel an order — closes its OrderRecord PDA and returns rent to maker. */
+  async cancelOrder(nonce) {
+    const [orderRecord] = PDA.orderRecord(this.walletPubkey, nonce, this.programIds);
+    const sig = await this.program.methods.cancelOrder(nonce).accounts({
+      maker: this.walletPubkey,
+      orderRecord,
+      systemProgram: web3_js.SystemProgram.programId
+    }).rpc();
+    return { signature: sig };
+  }
+  // ─── Admin ───────────────────────────────────────────────────────────────────
   async initialize(operators, feeRecipient, feeRateBps) {
     const sig = await this.program.methods.initializeClob(
       operators,
@@ -1447,7 +1581,6 @@ var ClobClient = class {
     }).rpc();
     return { signature: sig };
   }
-  /** Admin adds an operator to the whitelist. */
   async addOperator(operator) {
     const sig = await this.program.methods.addOperator(operator).accounts({
       admin: this.walletPubkey,
@@ -1455,7 +1588,6 @@ var ClobClient = class {
     }).rpc();
     return { signature: sig };
   }
-  /** Admin removes an operator from the whitelist. */
   async removeOperator(operator) {
     const sig = await this.program.methods.removeOperator(operator).accounts({
       admin: this.walletPubkey,
@@ -1463,7 +1595,6 @@ var ClobClient = class {
     }).rpc();
     return { signature: sig };
   }
-  /** Admin pause/unpause the CLOB. */
   async setPaused(paused) {
     const sig = await this.program.methods.setPaused(paused).accounts({
       admin: this.walletPubkey,
@@ -1471,9 +1602,6 @@ var ClobClient = class {
     }).rpc();
     return { signature: sig };
   }
-  /**
-   * Emergency reset of CLOB config (upgrade authority only).
-   */
   async forceResetClob(programData, newAdmin, newOperators, newFeeRecipient, newFeeRateBps) {
     const sig = await this.program.methods.forceResetClob(newAdmin, newOperators, newFeeRecipient, newFeeRateBps).accounts({
       upgradeAuthority: this.walletPubkey,
@@ -1482,31 +1610,44 @@ var ClobClient = class {
     }).rpc();
     return { signature: sig };
   }
+  // ─── Match instructions ───────────────────────────────────────────────────────
   /**
-   * COMPLEMENTARY match: 1 buyer (taker) + N sellers (makers), same tokenId.
-   *
-   * Transaction structure:
-   *   ix[0]   Ed25519(taker/buyer)
-   *   ix[1+i] Ed25519(maker_i/seller_i)
-   *   ix[N+1] match_complementary(buyNonce, makerNonces[])
-   *
-   * remaining_accounts: [hook×3] [seller×5 × N]
-   */
-  /** Build Ed25519 + matchComplementary instructions without sending.
+   * Build match_complementary instruction (no Ed25519 — OrderRecord PDAs used).
    *
-   * 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.
+   * 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)
    */
-  async buildMatchComplementaryIxs(buySigned, makersSigned, collateralMint, feeRecipient, operator, opts) {
-    const condition = buySigned.order.condition;
-    const tokenId = buySigned.order.tokenId;
+  async buildMatchComplementaryIxs(takerSigned, makersSigned, collateralMint, feeRecipient, operator, opts) {
+    const condition = takerSigned.order.condition;
+    const tokenId = takerSigned.order.tokenId;
+    const taker = takerSigned.order.maker;
+    const takerNonce = takerSigned.order.nonce;
+    const fillAmount = opts?.fillAmount ?? new anchor5__namespace.BN("18446744073709551615");
     const [outcomeMint] = tokenId === 1 ? PDA.yesMint(condition, this.programIds) : PDA.noMint(condition, this.programIds);
-    const buyer = buySigned.order.maker;
-    const buyerCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, buyer);
-    const buyerTokenAccount = splToken.getAssociatedTokenAddressSync(outcomeMint, buyer, false, splToken.TOKEN_2022_PROGRAM_ID);
-    const [buyerPosition] = PDA.position(condition, tokenId, buyer, this.programIds);
-    const [buyOrderStatus] = PDA.orderStatus(buyer, buySigned.order.nonce, this.programIds);
+    const [takerOrderRecord] = PDA.orderRecord(taker, takerNonce, this.programIds);
+    const takerCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, taker);
+    const takerTokenAccount = splToken.getAssociatedTokenAddressSync(outcomeMint, taker, false, splToken.TOKEN_2022_PROGRAM_ID);
+    const [takerPosition] = PDA.position(condition, tokenId, taker, this.programIds);
+    const [takerOrderStatus] = PDA.orderStatus(taker, takerNonce, this.programIds);
+    const makerAccounts = [];
+    for (const ms of makersSigned) {
+      const seller = ms.order.maker;
+      const [sellerRecord] = PDA.orderRecord(seller, ms.order.nonce, this.programIds);
+      const sellerToken = splToken.getAssociatedTokenAddressSync(outcomeMint, seller, false, splToken.TOKEN_2022_PROGRAM_ID);
+      const sellerCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, seller);
+      const [sellerPosition] = PDA.position(condition, tokenId, seller, this.programIds);
+      const [sellerStatus] = PDA.orderStatus(seller, ms.order.nonce, this.programIds);
+      makerAccounts.push(
+        { pubkey: seller, isSigner: false, isWritable: false },
+        { pubkey: sellerRecord, isSigner: false, isWritable: false },
+        { pubkey: sellerToken, isSigner: false, isWritable: true },
+        { pubkey: sellerCollateral, isSigner: false, isWritable: true },
+        { pubkey: sellerPosition, isSigner: false, isWritable: true },
+        { pubkey: sellerStatus, isSigner: false, isWritable: true }
+      );
+    }
     const [extraAccountMetaList] = PDA.extraAccountMetaList(outcomeMint, this.programIds);
     const [hookConfig] = PDA.hookConfig(this.programIds);
     const hookAccounts = [
@@ -1514,22 +1655,8 @@ var ClobClient = class {
       { pubkey: hookConfig, isSigner: false, isWritable: false },
       { pubkey: this.programIds.hook, isSigner: false, isWritable: false }
     ];
-    const makerAccounts = makersSigned.flatMap((m) => {
-      const seller = m.order.maker;
-      const sellerTokenAccount = splToken.getAssociatedTokenAddressSync(outcomeMint, seller, false, splToken.TOKEN_2022_PROGRAM_ID);
-      const [sellerPosition] = PDA.position(condition, tokenId, seller, this.programIds);
-      const sellerCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, seller);
-      const [sellOrderStatus] = PDA.orderStatus(seller, m.order.nonce, this.programIds);
-      return [
-        { pubkey: seller, isSigner: false, isWritable: false },
-        { pubkey: sellerTokenAccount, isSigner: false, isWritable: true },
-        { pubkey: sellerPosition, isSigner: false, isWritable: true },
-        { pubkey: sellerCollateral, isSigner: false, isWritable: true },
-        { pubkey: sellOrderStatus, isSigner: false, isWritable: true }
-      ];
-    });
     let feeAccounts = [];
-    if (buySigned.order.fee.gtn(0) && this.programIds.feeManagement && this.feeConfigOwner) {
+    if (takerSigned.order.fee.gtn(0) && this.programIds.feeManagement && this.feeConfigOwner) {
       const companyAddr = await this.companyAddress();
       if (companyAddr) {
         const oracleVault = opts?.marketOracleVault ?? this.walletPubkey;
@@ -1542,31 +1669,38 @@ var ClobClient = class {
         ];
       }
     }
-    const makerNonces = makersSigned.map((m) => m.order.nonce);
-    const ed25519Ix = buildBatchedEd25519Instruction([buySigned, ...makersSigned]);
-    const matchIx = await this.program.methods.matchComplementary(buySigned.order.nonce, makerNonces).accounts({
+    const matchIx = await this.program.methods.matchComplementary(takerNonce, fillAmount).accounts({
       operator,
       payer: this.walletPubkey,
       clobConfig: this.configPda(),
-      ixSysvar: IX_SYSVAR,
       condition,
-      buyer,
-      buyerCollateral,
-      buyerTokenAccount,
-      buyerPosition,
-      buyOrderStatus,
-      outcomeMint,
+      taker,
+      takerOrderRecord,
+      takerCollateral,
+      takerTokenAccount,
+      takerPosition,
+      takerOrderStatus,
       feeRecipient,
+      outcomeMint,
       conditionalTokensProgram: this.programIds.conditionalTokens,
       tokenProgram: splToken.TOKEN_PROGRAM_ID,
       token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
       systemProgram: web3_js.SystemProgram.programId
-    }).remainingAccounts([...hookAccounts, ...makerAccounts, ...feeAccounts]).instruction();
-    return [ed25519Ix, matchIx];
+    }).remainingAccounts([...makerAccounts, ...hookAccounts, ...feeAccounts]).instruction();
+    return [matchIx];
   }
-  async matchComplementary(buySigned, makersSigned, collateralMint, feeRecipient, operatorWallet, lookupTable, opts) {
+  /**
+   * COMPLEMENTARY: 1 taker (BUY) + N makers (SELL), same tokenId.
+   * Phase 1: register taker + all makers in parallel.
+   * Phase 2: 1 atomic match tx.
+   */
+  async matchComplementary(takerSigned, makersSigned, collateralMint, feeRecipient, operatorWallet, lookupTable, opts) {
+    await Promise.all([
+      this.registerOrderIfNeeded(takerSigned),
+      ...makersSigned.map((m) => this.registerOrderIfNeeded(m))
+    ]);
     const ixs = await this.buildMatchComplementaryIxs(
-      buySigned,
+      takerSigned,
       makersSigned,
       collateralMint,
       feeRecipient,
@@ -1577,160 +1711,167 @@ var ClobClient = class {
     return { signature: sig };
   }
   /**
-   * MINT match: 1 YES buyer (taker) + N NO buyers (makers).
-   *
-   * Transaction structure:
-   *   ix[0]   Ed25519(taker/YES buyer)
-   *   ix[1+i] Ed25519(maker_i/NO buyer)
-   *   ix[N+1] match_mint_orders(yesNonce, makerNonces[])
+   * 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: [maker×5 × N]  (no hook accounts — mint_to doesn't fire hook)
+   * remaining_accounts per NO maker (5):
+   *   [order_record, buyer_no_token, buyer_no_collateral, buyer_no_position, no_order_status]
    */
-  async matchMintOrders(yesSigned, makersSigned, collateralMint, feeRecipient, operatorWallet, lookupTable) {
+  async matchMintOrders(yesSigned, noMakers, collateralMint, _feeRecipient, operatorWallet, lookupTable) {
+    await Promise.all([
+      this.registerOrderIfNeeded(yesSigned),
+      ...noMakers.map((m) => this.registerOrderIfNeeded(m))
+    ]);
     const condition = yesSigned.order.condition;
+    const taker = yesSigned.order.maker;
+    const takerNonce = yesSigned.order.nonce;
+    const fillAmount = new anchor5__namespace.BN("18446744073709551615");
     const [yesMint] = PDA.yesMint(condition, this.programIds);
     const [noMint] = PDA.noMint(condition, this.programIds);
     const [mintAuthority] = PDA.mintAuthority(condition, this.programIds);
     const [collateralVault] = PDA.collateralVault(collateralMint, this.programIds);
     const [vaultTokenAccount] = PDA.vaultToken(collateralMint, this.programIds);
-    const buyerYes = yesSigned.order.maker;
-    const buyerYesCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, buyerYes);
-    const buyerYesTokenAccount = splToken.getAssociatedTokenAddressSync(yesMint, buyerYes, false, splToken.TOKEN_2022_PROGRAM_ID);
-    const [buyerYesPosition] = PDA.position(condition, 1, buyerYes, this.programIds);
-    const [yesOrderStatus] = PDA.orderStatus(buyerYes, yesSigned.order.nonce, this.programIds);
-    const makerAccounts = makersSigned.flatMap((m) => {
-      const maker = m.order.maker;
-      const makerUsdcAta = splToken.getAssociatedTokenAddressSync(collateralMint, maker);
-      const makerNoAta = splToken.getAssociatedTokenAddressSync(noMint, maker, false, splToken.TOKEN_2022_PROGRAM_ID);
-      const [makerNoPosition] = PDA.position(condition, 0, maker, this.programIds);
-      const [makerOrderStatus] = PDA.orderStatus(maker, m.order.nonce, this.programIds);
-      return [
-        { pubkey: maker, isSigner: false, isWritable: false },
-        { pubkey: makerUsdcAta, isSigner: false, isWritable: true },
-        { pubkey: makerNoAta, isSigner: false, isWritable: true },
-        { pubkey: makerNoPosition, isSigner: false, isWritable: true },
-        { pubkey: makerOrderStatus, isSigner: false, isWritable: true }
-      ];
-    });
-    const operator = operatorWallet.publicKey;
-    const makerNonces = makersSigned.map((m) => m.order.nonce);
-    const ed25519Ixs = [
-      buildBatchedEd25519Instruction([yesSigned, ...makersSigned])
-    ];
-    const matchIx = await this.program.methods.matchMintOrders(yesSigned.order.nonce, makerNonces).accounts({
-      operator,
+    const [takerOrderRecord] = PDA.orderRecord(taker, takerNonce, this.programIds);
+    const takerCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, taker);
+    const takerYesToken = splToken.getAssociatedTokenAddressSync(yesMint, taker, false, splToken.TOKEN_2022_PROGRAM_ID);
+    const [takerYesPosition] = PDA.position(condition, 1, taker, this.programIds);
+    const [takerOrderStatus] = PDA.orderStatus(taker, takerNonce, this.programIds);
+    const remainingAccounts = [];
+    for (const nm of noMakers) {
+      const noMaker = nm.order.maker;
+      const [noRecord] = PDA.orderRecord(noMaker, nm.order.nonce, this.programIds);
+      const noToken = splToken.getAssociatedTokenAddressSync(noMint, noMaker, false, splToken.TOKEN_2022_PROGRAM_ID);
+      const noCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, noMaker);
+      const [noPosition] = PDA.position(condition, 0, noMaker, this.programIds);
+      const [noStatus] = PDA.orderStatus(noMaker, nm.order.nonce, this.programIds);
+      remainingAccounts.push(
+        { pubkey: noRecord, isSigner: false, isWritable: false },
+        { pubkey: noToken, isSigner: false, isWritable: true },
+        { pubkey: noCollateral, isSigner: false, isWritable: true },
+        { pubkey: noPosition, isSigner: false, isWritable: true },
+        { pubkey: noStatus, isSigner: false, isWritable: true }
+      );
+    }
+    const matchIx = await this.program.methods.matchMintOrders(takerNonce, fillAmount).accounts({
+      operator: operatorWallet.publicKey,
       payer: this.walletPubkey,
       clobConfig: this.configPda(),
-      ixSysvar: IX_SYSVAR,
       condition,
-      buyerYes,
-      buyerYesCollateral,
-      buyerYesTokenAccount,
-      buyerYesPosition,
-      yesOrderStatus,
+      taker,
+      takerOrderRecord,
+      takerCollateral,
+      takerYesToken,
+      takerYesPosition,
+      takerOrderStatus,
       collateralVault,
       vaultTokenAccount,
       yesMint,
       noMint,
       mintAuthority,
+      clobAuthority: this.configPda(),
       conditionalTokensProgram: this.programIds.conditionalTokens,
       collateralTokenProgram: splToken.TOKEN_PROGRAM_ID,
       systemProgram: web3_js.SystemProgram.programId
-    }).remainingAccounts(makerAccounts).instruction();
-    const sig = await this.sendMatchTx(
-      [...ed25519Ixs, matchIx],
-      lookupTable,
-      operatorWallet
-    );
+    }).remainingAccounts(remainingAccounts).instruction();
+    const sig = await this.sendMatchTx([matchIx], lookupTable, operatorWallet);
     return { signature: sig };
   }
   /**
-   * MERGE match: 1 YES seller (taker) + N NO sellers (makers).
+   * MERGE: 1 YES seller (taker) + N NO sellers (makers).
+   * Phase 1: register taker + all NO makers in parallel.
+   * Phase 2: 1 atomic match tx.
    *
-   * Transaction structure:
-   *   ix[0]   Ed25519(taker/YES seller)
-   *   ix[1+i] Ed25519(maker_i/NO seller)
-   *   ix[N+1] match_merge_orders(yesNonce, makerNonces[])
-   *
-   * remaining_accounts: [maker×5 × N]  (no hook accounts — burn doesn't fire hook)
+   * 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.
    */
-  async matchMergeOrders(yesSigned, makersSigned, collateralMint, feeRecipient, operatorWallet, lookupTable) {
+  async matchMergeOrders(yesSigned, noMakers, collateralMint, feeRecipient, operatorWallet, lookupTable, opts) {
+    await Promise.all([
+      this.registerOrderIfNeeded(yesSigned),
+      ...noMakers.map((m) => this.registerOrderIfNeeded(m))
+    ]);
     const condition = yesSigned.order.condition;
+    const sellerYes = yesSigned.order.maker;
+    const takerNonce = yesSigned.order.nonce;
+    const fillAmount = new anchor5__namespace.BN("18446744073709551615");
     const [yesMint] = PDA.yesMint(condition, this.programIds);
     const [noMint] = PDA.noMint(condition, this.programIds);
+    const [mintAuthority] = PDA.mintAuthority(condition, this.programIds);
     const [collateralVault] = PDA.collateralVault(collateralMint, this.programIds);
     const [vaultTokenAccount] = PDA.vaultToken(collateralMint, this.programIds);
-    const sellerYes = yesSigned.order.maker;
-    const sellerYesTokenAccount = splToken.getAssociatedTokenAddressSync(yesMint, sellerYes, false, splToken.TOKEN_2022_PROGRAM_ID);
-    const [sellerYesPosition] = PDA.position(condition, 1, sellerYes, this.programIds);
-    const sellerYesCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, sellerYes);
-    const [yesOrderStatus] = PDA.orderStatus(sellerYes, yesSigned.order.nonce, this.programIds);
-    const makerAccounts = makersSigned.flatMap((m) => {
-      const maker = m.order.maker;
-      const makerNoAta = splToken.getAssociatedTokenAddressSync(noMint, maker, false, splToken.TOKEN_2022_PROGRAM_ID);
-      const [makerNoPosition] = PDA.position(condition, 0, maker, this.programIds);
-      const makerUsdcAta = splToken.getAssociatedTokenAddressSync(collateralMint, maker);
-      const [makerOrderStatus] = PDA.orderStatus(maker, m.order.nonce, this.programIds);
-      return [
-        { pubkey: maker, isSigner: false, isWritable: false },
-        { pubkey: makerNoAta, isSigner: false, isWritable: true },
-        { pubkey: makerNoPosition, isSigner: false, isWritable: true },
-        { pubkey: makerUsdcAta, isSigner: false, isWritable: true },
-        { pubkey: makerOrderStatus, isSigner: false, isWritable: true }
-      ];
-    });
-    const operator = operatorWallet.publicKey;
-    const makerNonces = makersSigned.map((m) => m.order.nonce);
-    const ed25519Ixs = [
-      buildBatchedEd25519Instruction([yesSigned, ...makersSigned])
-    ];
-    const matchIx = await this.program.methods.matchMergeOrders(yesSigned.order.nonce, makerNonces).accounts({
-      operator,
+    const [takerOrderRecord] = PDA.orderRecord(sellerYes, takerNonce, this.programIds);
+    const takerYesToken = splToken.getAssociatedTokenAddressSync(yesMint, sellerYes, false, splToken.TOKEN_2022_PROGRAM_ID);
+    const [takerYesPosition] = PDA.position(condition, 1, sellerYes, this.programIds);
+    const takerCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, sellerYes);
+    const [takerOrderStatus] = PDA.orderStatus(sellerYes, takerNonce, this.programIds);
+    const remainingAccounts = [];
+    for (const nm of noMakers) {
+      const noMaker = nm.order.maker;
+      const [noRecord] = PDA.orderRecord(noMaker, nm.order.nonce, this.programIds);
+      const noToken = splToken.getAssociatedTokenAddressSync(noMint, noMaker, false, splToken.TOKEN_2022_PROGRAM_ID);
+      const noCollateral = splToken.getAssociatedTokenAddressSync(collateralMint, noMaker);
+      const [noPosition] = PDA.position(condition, 0, noMaker, this.programIds);
+      const [noStatus] = PDA.orderStatus(noMaker, nm.order.nonce, this.programIds);
+      remainingAccounts.push(
+        { pubkey: noRecord, isSigner: false, isWritable: false },
+        { pubkey: noToken, isSigner: false, isWritable: true },
+        { pubkey: noCollateral, isSigner: false, isWritable: true },
+        { pubkey: noPosition, isSigner: false, isWritable: true },
+        { pubkey: noStatus, isSigner: false, isWritable: true }
+      );
+    }
+    if (yesSigned.order.fee.gtn(0) && this.programIds.feeManagement && this.feeConfigOwner) {
+      const companyAddr = await this.companyAddress();
+      if (companyAddr) {
+        const oracleVault = opts?.marketOracleVault ?? this.walletPubkey;
+        remainingAccounts.push(
+          { 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 matchIx = await this.program.methods.matchMergeOrders(takerNonce, fillAmount).accounts({
+      operator: operatorWallet.publicKey,
       payer: this.walletPubkey,
       clobConfig: this.configPda(),
-      ixSysvar: IX_SYSVAR,
       condition,
-      sellerYes,
-      sellerYesTokenAccount,
-      sellerYesPosition,
-      sellerYesCollateral,
-      yesOrderStatus,
+      taker: sellerYes,
+      takerOrderRecord,
+      takerYesToken,
+      takerYesPosition,
+      takerCollateral,
+      takerOrderStatus,
       collateralVault,
       vaultTokenAccount,
       yesMint,
       noMint,
+      mintAuthority,
       feeRecipient,
+      clobAuthority: this.configPda(),
       conditionalTokensProgram: this.programIds.conditionalTokens,
       collateralTokenProgram: splToken.TOKEN_PROGRAM_ID,
       systemProgram: web3_js.SystemProgram.programId
-    }).remainingAccounts(makerAccounts).instruction();
-    const sig = await this.sendMatchTx(
-      [...ed25519Ixs, matchIx],
-      lookupTable,
-      operatorWallet
-    );
+    }).remainingAccounts(remainingAccounts).instruction();
+    const sig = await this.sendMatchTx([matchIx], lookupTable, operatorWallet);
     return { signature: sig };
   }
   /**
-   * Auto-detect match type and execute 1-taker + N-makers in a single transaction.
-   *
-   * Detection (pure, no RPC) based on taker.order vs makers[0].order:
-   *   taker.tokenId === makers[0].tokenId: taker BUY + all makers SELL → COMPLEMENTARY
-   *   taker.tokenId !== makers[0].tokenId + taker BUY + all makers BUY → MINT
-   *   taker.tokenId !== makers[0].tokenId + taker SELL + all makers SELL → MERGE
-   *   Otherwise → throws InvalidParamError
+   * 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.
    *
-   * All makers must have the same tokenId and side as makers[0].
-   */
-  /**
-   * 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.
+   * 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  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).
+   * @param opts.marketOracleVault  Oracle vault ATA for presale markets.
+   *   Omit for admin markets (payer used as placeholder).
    */
   async matchOrders(taker, makers, opts) {
     if (makers.length === 0) throw new InvalidParamError("At least 1 maker required");
@@ -1742,8 +1883,7 @@ var ClobClient = class {
     const alt = await this.ensureAlt(
       taker.order.condition,
       collateralMint,
-      taker.order.maker,
-      taker.order.nonce,
+      taker,
       makers
     );
     const t = taker.order;
@@ -1755,9 +1895,9 @@ var ClobClient = class {
         return this.matchComplementary(taker, makers, collateralMint, feeRecipient, operatorWallet, 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");
+        return this.matchComplementary(makers[0], [taker, ...makers.slice(1)], collateralMint, feeRecipient, operatorWallet, alt, opts);
       }
-      throw new InvalidParamError("COMPLEMENTARY requires taker=BUY, makers=SELL on same tokenId");
+      throw new InvalidParamError("COMPLEMENTARY requires one BUY and one SELL on same tokenId");
     }
     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);
@@ -1765,7 +1905,7 @@ var ClobClient = class {
     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, operatorWallet, alt);
-    return this.matchMergeOrders(taker, makers, collateralMint, feeRecipient, operatorWallet, alt);
+    return this.matchMergeOrders(taker, makers, collateralMint, feeRecipient, operatorWallet, alt, opts);
   }
   // ─── Queries ─────────────────────────────────────────────────────────────────
   async fetchConfig() {
@@ -1799,6 +1939,15 @@ var ClobClient = class {
       return null;
     }
   }
+  async fetchOrderRecord(maker, nonce) {
+    try {
+      const [pda] = PDA.orderRecord(maker, nonce, this.programIds);
+      const acc = await this.program.account.signedOrderRecord.fetch(pda);
+      return acc;
+    } catch {
+      return null;
+    }
+  }
 };
 var FeeManagementClient = class {
   constructor(program, provider, programIds) {
@@ -2142,6 +2291,139 @@ var MarketOracleClient = class {
     }
   }
 };
+var AdminClient = class {
+  constructor(program, provider, programIds) {
+    this.program = program;
+    this.provider = provider;
+    this.programIds = programIds;
+  }
+  get walletPubkey() {
+    return this.provider.wallet.publicKey;
+  }
+  get configPda() {
+    const [pda] = PDA.adminConfig(this.walletPubkey, this.programIds);
+    return pda;
+  }
+  configPdaFor(owner) {
+    const [pda] = PDA.adminConfig(owner, this.programIds);
+    return pda;
+  }
+  adminVault(owner, collateralMint) {
+    const configPda = this.configPdaFor(owner);
+    return splToken.getAssociatedTokenAddressSync(collateralMint, configPda, true);
+  }
+  // ─── Fetch ────────────────────────────────────────────────────────────────
+  async fetchConfig(owner = this.walletPubkey) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    try {
+      const acc = await this.program.account.adminConfig.fetch(configPda);
+      return {
+        version: acc.version,
+        owner: acc.owner,
+        collateralMint: acc.collateralMint,
+        authorizedCaller: acc.authorizedCaller,
+        adminWhitelist: acc.adminWhitelist.slice(0, acc.adminWhitelistLen),
+        whitelist: acc.whitelist.slice(0, acc.whitelistLen),
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchClaimRecord(conditionId) {
+    const [pda] = PDA.claimRecord(conditionId, this.programIds);
+    try {
+      const acc = await this.program.account.claimRecord.fetch(pda);
+      return {
+        conditionId: acc.conditionId,
+        amount: acc.amount,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  // ─── Instructions ─────────────────────────────────────────────────────────
+  async initialize(authorizedCaller, collateralMint, owner = this.walletPubkey) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    const vault = splToken.getAssociatedTokenAddressSync(collateralMint, configPda, true);
+    return this.program.methods.initialize(authorizedCaller).accounts({
+      owner,
+      config: configPda,
+      collateralMint,
+      adminVault: vault,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).transaction();
+  }
+  async addAdmin(address, owner = this.walletPubkey) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    return this.program.methods.addAdmin(address).accounts({ owner, config: configPda }).transaction();
+  }
+  async removeAdmin(address, owner = this.walletPubkey) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    return this.program.methods.removeAdmin(address).accounts({ owner, config: configPda }).transaction();
+  }
+  async addToWhitelist(address, owner, admin = this.walletPubkey, payer = admin) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    return this.program.methods.addToWhitelist(address).accounts({ admin, payer, config: configPda }).transaction();
+  }
+  async removeFromWhitelist(address, owner, admin = this.walletPubkey, payer = admin) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    return this.program.methods.removeFromWhitelist(address).accounts({ admin, payer, config: configPda }).transaction();
+  }
+  /**
+   * Normally called via CPI from question_market (authorized_caller signs).
+   * For testing: initialize with authorizedCaller = wallet, call directly.
+   */
+  async setPresaleAmount(conditionId, amount, owner = this.walletPubkey, caller = this.walletPubkey, payer = caller) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    const [claimRecord] = PDA.claimRecord(conditionId, this.programIds);
+    return this.program.methods.setPresaleAmount(Array.from(conditionId), amount).accounts({
+      caller,
+      payer,
+      config: configPda,
+      claimRecord,
+      systemProgram: web3_js.SystemProgram.programId
+    }).transaction();
+  }
+  async claim(conditionId, collateralMint, owner, claimer = this.walletPubkey, payer = claimer) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    const [claimRecord] = PDA.claimRecord(conditionId, this.programIds);
+    const vault = splToken.getAssociatedTokenAddressSync(collateralMint, configPda, true);
+    const claimerAta = splToken.getAssociatedTokenAddressSync(collateralMint, claimer);
+    return this.program.methods.claim(Array.from(conditionId)).accounts({
+      claimer,
+      payer,
+      config: configPda,
+      adminVault: vault,
+      claimRecord,
+      claimerTokenAccount: claimerAta,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID
+    }).transaction();
+  }
+  async updateConfig(authorizedCaller, owner = this.walletPubkey) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    return this.program.methods.updateConfig(authorizedCaller).accounts({ owner, config: configPda }).transaction();
+  }
+  /**
+   * BOTMM sends USDC from their wallet to the market_oracle vault for a condition.
+   * Whitelist-only. No amount validation — caller responsible.
+   */
+  async distributeMarket(conditionId, amount, collateralMint, marketOracleVault, owner, claimer = this.walletPubkey, payer = claimer) {
+    const [configPda] = PDA.adminConfig(owner, this.programIds);
+    const claimerTokenAcct = splToken.getAssociatedTokenAddressSync(collateralMint, claimer);
+    return this.program.methods.distributeMarket(Array.from(conditionId), amount).accounts({
+      claimer,
+      payer,
+      config: configPda,
+      claimerTokenAccount: claimerTokenAcct,
+      marketOracleVault,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID
+    }).transaction();
+  }
+};
 
 // src/idls/oracle.json
 var oracle_default = {
@@ -2838,6 +3120,11 @@ var hook_default = {
           name: "owner",
           signer: true
         },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
         {
           name: "hook_config",
           writable: true,
@@ -2969,6 +3256,11 @@ var hook_default = {
           name: "owner",
           signer: true
         },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
         {
           name: "hook_config",
           writable: true,
@@ -3177,6 +3469,11 @@ var hook_default = {
           name: "owner",
           signer: true
         },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
         {
           name: "hook_config",
           writable: true,
@@ -3228,10 +3525,6 @@ var hook_default = {
   types: [
     {
       name: "HookConfig",
-      docs: [
-        "Global config for the Hook program.",
-        "Stores the whitelist of programs allowed to transfer YES/NO Token-2022 tokens."
-      ],
       type: {
         kind: "struct",
         fields: [
@@ -3241,16 +3534,10 @@ var hook_default = {
           },
           {
             name: "owner",
-            docs: [
-              "Owner who can update the whitelist"
-            ],
             type: "pubkey"
           },
           {
             name: "whitelist",
-            docs: [
-              "Programs allowed to initiate or receive YES/NO token transfers."
-            ],
             type: {
               array: [
                 "pubkey",
@@ -3264,16 +3551,10 @@ var hook_default = {
           },
           {
             name: "is_frozen",
-            docs: [
-              "If true, whitelist can no longer be modified (locked forever)"
-            ],
             type: "bool"
           },
           {
             name: "bump",
-            docs: [
-              "Bump for this PDA"
-            ],
             type: "u8"
           },
           {
@@ -3709,7 +3990,7 @@ var question_market_default = {
         {
           name: "presale_vault",
           docs: [
-            "Presale USDC vault \u2014 closed inside presale program"
+            "Presale USDC vault \u2014 read balance before CPI, closed inside presale program"
           ],
           writable: true
         },
@@ -3719,24 +4000,66 @@ var question_market_default = {
         {
           name: "referral_token_account",
           docs: [
-            "Referral address USDC token account"
+            "Referral address USDC token account (10%)"
           ],
           writable: true
         },
         {
           name: "company_token_account",
           docs: [
-            "Company address USDC token account"
+            "Company address USDC token account (10%)"
           ],
           writable: true
         },
         {
-          name: "botmm_token_account",
+          name: "admin_vault",
           docs: [
-            "BOTMM token account (receives ~80%)"
+            "admin_contract vault ATA \u2014 receives 80% instead of BOTMM wallet directly"
           ],
           writable: true
         },
+        {
+          name: "admin_config",
+          docs: [
+            "admin_contract config PDA"
+          ]
+        },
+        {
+          name: "claim_record",
+          docs: [
+            "ClaimRecord PDA for this conditionId (created by admin_contract CPI)"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  108,
+                  97,
+                  105,
+                  109,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
+                ]
+              },
+              {
+                kind: "arg",
+                path: "condition_id"
+              }
+            ],
+            program: {
+              kind: "account",
+              path: "admin_program"
+            }
+          }
+        },
         {
           name: "payer",
           docs: [
@@ -3748,6 +4071,10 @@ var question_market_default = {
           name: "presale_program",
           address: "2Rnw1VoEtsUMQ7wkvYZjDehqSqRob6uNkeymDfvKrquB"
         },
+        {
+          name: "admin_program",
+          address: "4NdD5962SfGqofmeyjfifJpdGnwTAiKaUKB5Z42UDc9T"
+        },
         {
           name: "token_program",
           address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
@@ -3761,9 +4088,19 @@ var question_market_default = {
           address: "11111111111111111111111111111111"
         }
       ],
-      args: []
-    },
-    {
+      args: [
+        {
+          name: "condition_id",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
+    {
       name: "collect_trading_fee",
       discriminator: [
         97,
@@ -4183,6 +4520,58 @@ var question_market_default = {
         }
       ]
     },
+    {
+      name: "grow_config",
+      discriminator: [
+        190,
+        5,
+        0,
+        130,
+        65,
+        253,
+        94,
+        228
+      ],
+      accounts: [
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "owner",
+          signer: true
+        },
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "owner"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
     {
       name: "initialize",
       discriminator: [
@@ -4551,6 +4940,63 @@ var question_market_default = {
         }
       ]
     },
+    {
+      name: "restore_config",
+      discriminator: [
+        95,
+        203,
+        226,
+        92,
+        60,
+        222,
+        192,
+        221
+      ],
+      accounts: [
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "owner",
+          signer: true
+        },
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "owner"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "snapshot",
+          type: "bytes"
+        }
+      ]
+    },
     {
       name: "update_config",
       discriminator: [
@@ -5583,7 +6029,7 @@ var question_market_default = {
             type: {
               array: [
                 "pubkey",
-                10
+                30
               ]
             }
           },
@@ -7685,9 +8131,6 @@ var clob_exchange_default = {
   instructions: [
     {
       name: "add_operator",
-      docs: [
-        "Add an authorized operator (off-chain matching engine)."
-      ],
       discriminator: [
         149,
         142,
@@ -7736,11 +8179,75 @@ var clob_exchange_default = {
       ]
     },
     {
-      name: "force_reset_clob",
+      name: "cancel_order",
       docs: [
-        "Force-reset the CLOB config (upgrade authority only).",
-        "Use when the original admin keypair is lost."
+        "Cancel an order \u2014 close OrderRecord PDA, return rent to maker."
+      ],
+      discriminator: [
+        95,
+        129,
+        237,
+        240,
+        8,
+        49,
+        223,
+        132
+      ],
+      accounts: [
+        {
+          name: "maker",
+          docs: [
+            "Must be the order maker/signer"
+          ],
+          signer: true
+        },
+        {
+          name: "order_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  111,
+                  114,
+                  100,
+                  101,
+                  114,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
+                ]
+              },
+              {
+                kind: "account",
+                path: "maker"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
       ],
+      args: [
+        {
+          name: "nonce",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "force_reset_clob",
       discriminator: [
         96,
         95,
@@ -7815,9 +8322,6 @@ var clob_exchange_default = {
     },
     {
       name: "initialize_clob",
-      docs: [
-        "Initialize the CLOB global config."
-      ],
       discriminator: [
         35,
         69,
@@ -7887,10 +8391,7 @@ var clob_exchange_default = {
     {
       name: "match_complementary",
       docs: [
-        "COMPLEMENTARY match: one buyer of YES/NO tokens meets one seller.",
-        "Operator verifies signatures off-chain, executes atomically on-chain.",
-        "",
-        "Execution price = seller's ask (maker-fills-taker model)."
+        "COMPLEMENTARY match: 1 taker (BUY) + N makers (SELL) via remaining_accounts."
       ],
       discriminator: [
         100,
@@ -7905,24 +8406,15 @@ var clob_exchange_default = {
       accounts: [
         {
           name: "operator",
-          docs: [
-            "Authorized operator (whitelisted signer)"
-          ],
           signer: true
         },
         {
           name: "payer",
-          docs: [
-            "Fee payer \u2014 pays tx fee and PDA rent"
-          ],
           writable: true,
           signer: true
         },
         {
           name: "clob_config",
-          docs: [
-            "CLOB config PDA \u2014 also used as the signing authority for CTF CPIs."
-          ],
           writable: true,
           pda: {
             seeds: [
@@ -7945,27 +8437,14 @@ var clob_exchange_default = {
             ]
           }
         },
-        {
-          name: "ix_sysvar",
-          address: "Sysvar1nstructions1111111111111111111111111"
-        },
         {
           name: "condition"
         },
         {
-          name: "buyer"
-        },
-        {
-          name: "buyer_collateral",
-          writable: true
-        },
-        {
-          name: "buyer_token_account",
-          writable: true
+          name: "taker"
         },
         {
-          name: "buy_order_status",
-          writable: true,
+          name: "taker_order_record",
           pda: {
             seeds: [
               {
@@ -7975,33 +8454,41 @@ var clob_exchange_default = {
                   114,
                   100,
                   101,
-                  114
+                  114,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
                 ]
               },
               {
                 kind: "account",
-                path: "buyer"
+                path: "taker"
               },
               {
                 kind: "arg",
-                path: "buy_signed.order.nonce"
+                path: "taker_nonce"
               }
             ]
           }
         },
         {
-          name: "seller"
+          name: "taker_collateral",
+          writable: true
         },
         {
-          name: "seller_token_account",
+          name: "taker_token_account",
           writable: true
         },
         {
-          name: "seller_collateral",
+          name: "taker_position",
           writable: true
         },
         {
-          name: "sell_order_status",
+          name: "taker_order_status",
           writable: true,
           pda: {
             seeds: [
@@ -8017,11 +8504,11 @@ var clob_exchange_default = {
               },
               {
                 kind: "account",
-                path: "seller"
+                path: "taker"
               },
               {
                 kind: "arg",
-                path: "sell_signed.order.nonce"
+                path: "taker_nonce"
               }
             ]
           }
@@ -8034,17 +8521,9 @@ var clob_exchange_default = {
           name: "outcome_mint",
           writable: true
         },
-        {
-          name: "seller_position",
-          writable: true
-        },
-        {
-          name: "buyer_position",
-          writable: true
-        },
         {
           name: "conditional_tokens_program",
-          address: "7boT4uqXGRMbDPzA7Q9znqbfYNB6auoXUcDnUfxyZAU"
+          address: "A6N1F8MRsdgcojAx8p6FaECvw8mo8w6qJcWsbKQBANK4"
         },
         {
           name: "token_program",
@@ -8061,20 +8540,8 @@ var clob_exchange_default = {
       ],
       args: [
         {
-          name: "buy_signed",
-          type: {
-            defined: {
-              name: "SignedOrder"
-            }
-          }
-        },
-        {
-          name: "sell_signed",
-          type: {
-            defined: {
-              name: "SignedOrder"
-            }
-          }
+          name: "taker_nonce",
+          type: "u64"
         },
         {
           name: "fill_amount",
@@ -8085,9 +8552,7 @@ var clob_exchange_default = {
     {
       name: "match_merge_orders",
       docs: [
-        "MERGE match: two sellers on complementary sides (one sells YES, one sells NO).",
-        "Their combined 1 YES + 1 NO is merged back into 1 USDC.",
-        "Requires: yes_price_bps + no_price_bps <= 10_000."
+        "MERGE match: 1 taker (YES SELL) + N makers (NO SELL) via remaining_accounts."
       ],
       discriminator: [
         105,
@@ -8102,16 +8567,10 @@ var clob_exchange_default = {
       accounts: [
         {
           name: "operator",
-          docs: [
-            "Authorized operator (whitelisted signer)"
-          ],
           signer: true
         },
         {
           name: "payer",
-          docs: [
-            "Fee payer \u2014 pays tx fee and PDA rent"
-          ],
           writable: true,
           signer: true
         },
@@ -8138,40 +8597,14 @@ var clob_exchange_default = {
             ]
           }
         },
-        {
-          name: "ix_sysvar",
-          address: "Sysvar1nstructions1111111111111111111111111"
-        },
         {
           name: "condition"
         },
         {
-          name: "seller_yes"
-        },
-        {
-          name: "seller_yes_token_account",
-          docs: [
-            "Seller YES's YES token account (tokens leave here)"
-          ],
-          writable: true
-        },
-        {
-          name: "seller_yes_position",
-          docs: [
-            "Seller YES's YES Position PDA"
-          ],
-          writable: true
-        },
-        {
-          name: "seller_yes_collateral",
-          docs: [
-            "Seller YES receives USDC here"
-          ],
-          writable: true
+          name: "taker"
         },
         {
-          name: "yes_order_status",
-          writable: true,
+          name: "taker_order_record",
           pda: {
             seeds: [
               {
@@ -8181,37 +8614,41 @@ var clob_exchange_default = {
                   114,
                   100,
                   101,
-                  114
-                ]
-              },
-              {
-                kind: "account",
-                path: "seller_yes"
-              },
-              {
+                  114,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
+                ]
+              },
+              {
+                kind: "account",
+                path: "taker"
+              },
+              {
                 kind: "arg",
-                path: "yes_signed.order.nonce"
+                path: "taker_nonce"
               }
             ]
           }
         },
         {
-          name: "seller_no"
-        },
-        {
-          name: "seller_no_token_account",
+          name: "taker_yes_token",
           writable: true
         },
         {
-          name: "seller_no_position",
+          name: "taker_yes_position",
           writable: true
         },
         {
-          name: "seller_no_collateral",
+          name: "taker_collateral",
           writable: true
         },
         {
-          name: "no_order_status",
+          name: "taker_order_status",
           writable: true,
           pda: {
             seeds: [
@@ -8227,11 +8664,11 @@ var clob_exchange_default = {
               },
               {
                 kind: "account",
-                path: "seller_no"
+                path: "taker"
               },
               {
                 kind: "arg",
-                path: "no_signed.order.nonce"
+                path: "taker_nonce"
               }
             ]
           }
@@ -8258,16 +8695,10 @@ var clob_exchange_default = {
         },
         {
           name: "fee_recipient",
-          docs: [
-            "Fee recipient (receives spread)"
-          ],
           writable: true
         },
         {
           name: "clob_authority",
-          docs: [
-            "CLOB authority PDA"
-          ],
           pda: {
             seeds: [
               {
@@ -8291,7 +8722,7 @@ var clob_exchange_default = {
         },
         {
           name: "conditional_tokens_program",
-          address: "7boT4uqXGRMbDPzA7Q9znqbfYNB6auoXUcDnUfxyZAU"
+          address: "A6N1F8MRsdgcojAx8p6FaECvw8mo8w6qJcWsbKQBANK4"
         },
         {
           name: "collateral_token_program",
@@ -8304,20 +8735,8 @@ var clob_exchange_default = {
       ],
       args: [
         {
-          name: "yes_signed",
-          type: {
-            defined: {
-              name: "SignedOrder"
-            }
-          }
-        },
-        {
-          name: "no_signed",
-          type: {
-            defined: {
-              name: "SignedOrder"
-            }
-          }
+          name: "taker_nonce",
+          type: "u64"
         },
         {
           name: "fill_amount",
@@ -8328,9 +8747,7 @@ var clob_exchange_default = {
     {
       name: "match_mint_orders",
       docs: [
-        "MINT match: two buyers on complementary sides (one buys YES, one buys NO).",
-        "Their combined USDC is used to split 1 USDC \u2192 1 YES + 1 NO.",
-        "Requires: yes_price_bps + no_price_bps >= 10_000."
+        "MINT match: 1 taker (YES BUY) + N makers (NO BUY) via remaining_accounts."
       ],
       discriminator: [
         146,
@@ -8345,16 +8762,10 @@ var clob_exchange_default = {
       accounts: [
         {
           name: "operator",
-          docs: [
-            "Authorized operator (whitelisted signer)"
-          ],
           signer: true
         },
         {
           name: "payer",
-          docs: [
-            "Fee payer \u2014 pays tx fee and PDA rent"
-          ],
           writable: true,
           signer: true
         },
@@ -8381,31 +8792,14 @@ var clob_exchange_default = {
             ]
           }
         },
-        {
-          name: "ix_sysvar",
-          address: "Sysvar1nstructions1111111111111111111111111"
-        },
         {
           name: "condition"
         },
         {
-          name: "buyer_yes"
-        },
-        {
-          name: "buyer_yes_collateral",
-          writable: true
-        },
-        {
-          name: "buyer_yes_token_account",
-          writable: true
+          name: "taker"
         },
         {
-          name: "buyer_yes_position",
-          writable: true
-        },
-        {
-          name: "yes_order_status",
-          writable: true,
+          name: "taker_order_record",
           pda: {
             seeds: [
               {
@@ -8415,37 +8809,41 @@ var clob_exchange_default = {
                   114,
                   100,
                   101,
-                  114
+                  114,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
                 ]
               },
               {
                 kind: "account",
-                path: "buyer_yes"
+                path: "taker"
               },
               {
                 kind: "arg",
-                path: "yes_signed.order.nonce"
+                path: "taker_nonce"
               }
             ]
           }
         },
         {
-          name: "buyer_no"
-        },
-        {
-          name: "buyer_no_collateral",
+          name: "taker_collateral",
           writable: true
         },
         {
-          name: "buyer_no_token_account",
+          name: "taker_yes_token",
           writable: true
         },
         {
-          name: "buyer_no_position",
+          name: "taker_yes_position",
           writable: true
         },
         {
-          name: "no_order_status",
+          name: "taker_order_status",
           writable: true,
           pda: {
             seeds: [
@@ -8461,11 +8859,11 @@ var clob_exchange_default = {
               },
               {
                 kind: "account",
-                path: "buyer_no"
+                path: "taker"
               },
               {
                 kind: "arg",
-                path: "no_signed.order.nonce"
+                path: "taker_nonce"
               }
             ]
           }
@@ -8492,9 +8890,6 @@ var clob_exchange_default = {
         },
         {
           name: "clob_authority",
-          docs: [
-            "CLOB authority PDA (signs CTF CPI)"
-          ],
           pda: {
             seeds: [
               {
@@ -8518,7 +8913,7 @@ var clob_exchange_default = {
         },
         {
           name: "conditional_tokens_program",
-          address: "7boT4uqXGRMbDPzA7Q9znqbfYNB6auoXUcDnUfxyZAU"
+          address: "A6N1F8MRsdgcojAx8p6FaECvw8mo8w6qJcWsbKQBANK4"
         },
         {
           name: "collateral_token_program",
@@ -8531,32 +8926,194 @@ var clob_exchange_default = {
       ],
       args: [
         {
-          name: "yes_signed",
-          type: {
-            defined: {
-              name: "SignedOrder"
-            }
+          name: "taker_nonce",
+          type: "u64"
+        },
+        {
+          name: "fill_amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "register_order",
+      docs: [
+        "Register a signed order on-chain (Ed25519 verify at registration time).",
+        "ix[0] must be Ed25519 precompile with 1 entry for order.signer."
+      ],
+      discriminator: [
+        92,
+        37,
+        29,
+        46,
+        77,
+        250,
+        219,
+        6
+      ],
+      accounts: [
+        {
+          name: "payer",
+          docs: [
+            "Operator pays rent for the OrderRecord PDA."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "clob_config",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  108,
+                  111,
+                  98,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
           }
         },
         {
-          name: "no_signed",
-          type: {
-            defined: {
-              name: "SignedOrder"
-            }
+          name: "ix_sysvar",
+          address: "Sysvar1nstructions1111111111111111111111111"
+        },
+        {
+          name: "order_signer"
+        },
+        {
+          name: "order_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  111,
+                  114,
+                  100,
+                  101,
+                  114,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
+                ]
+              },
+              {
+                kind: "account",
+                path: "order_signer"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
           }
         },
         {
-          name: "fill_amount",
+          name: "order_status",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  111,
+                  114,
+                  100,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "order_signer"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "nonce",
           type: "u64"
         }
       ]
     },
     {
-      name: "remove_operator",
-      docs: [
-        "Remove an operator."
+      name: "reinit_clob",
+      discriminator: [
+        41,
+        95,
+        240,
+        222,
+        95,
+        170,
+        14,
+        224
+      ],
+      accounts: [
+        {
+          name: "upgrade_authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "program_data"
+        },
+        {
+          name: "clob_config",
+          writable: true
+        }
       ],
+      args: [
+        {
+          name: "new_admin",
+          type: "pubkey"
+        },
+        {
+          name: "new_operators",
+          type: {
+            vec: "pubkey"
+          }
+        },
+        {
+          name: "new_fee_recipient",
+          type: "pubkey"
+        },
+        {
+          name: "new_fee_rate_bps",
+          type: "u16"
+        },
+        {
+          name: "conditional_tokens_program",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "remove_operator",
       discriminator: [
         84,
         183,
@@ -8606,9 +9163,6 @@ var clob_exchange_default = {
     },
     {
       name: "set_paused",
-      docs: [
-        "Pause or unpause the CLOB (admin only)."
-      ],
       discriminator: [
         91,
         60,
@@ -8683,6 +9237,19 @@ var clob_exchange_default = {
         65,
         3
       ]
+    },
+    {
+      name: "SignedOrderRecord",
+      discriminator: [
+        16,
+        167,
+        189,
+        166,
+        85,
+        0,
+        231,
+        55
+      ]
     }
   ],
   events: [
@@ -8877,29 +9444,13 @@ var clob_exchange_default = {
             type: "pubkey"
           },
           {
-            name: "buyer",
-            type: "pubkey"
-          },
-          {
-            name: "seller",
+            name: "taker",
             type: "pubkey"
           },
-          {
-            name: "token_id",
-            type: "u8"
-          },
           {
             name: "fill_amount",
             type: "u64"
           },
-          {
-            name: "price_bps",
-            type: "u64"
-          },
-          {
-            name: "usdc_transferred",
-            type: "u64"
-          },
           {
             name: "fee",
             type: "u64"
@@ -9050,33 +9601,13 @@ var clob_exchange_default = {
             type: "pubkey"
           },
           {
-            name: "seller_yes",
-            type: "pubkey"
-          },
-          {
-            name: "seller_no",
+            name: "taker",
             type: "pubkey"
           },
           {
             name: "fill_amount",
             type: "u64"
           },
-          {
-            name: "yes_price_bps",
-            type: "u64"
-          },
-          {
-            name: "no_price_bps",
-            type: "u64"
-          },
-          {
-            name: "yes_payout",
-            type: "u64"
-          },
-          {
-            name: "no_payout",
-            type: "u64"
-          },
           {
             name: "fee",
             type: "u64"
@@ -9097,173 +9628,108 @@ var clob_exchange_default = {
             name: "buyer_yes",
             type: "pubkey"
           },
-          {
-            name: "buyer_no",
-            type: "pubkey"
-          },
           {
             name: "fill_amount",
             type: "u64"
-          },
+          }
+        ]
+      }
+    },
+    {
+      name: "OrderStatus",
+      docs: [
+        "Tracks the fill state of an order for replay protection.",
+        'PDA seeds: [b"order", maker_pubkey, nonce_le_bytes]',
+        "",
+        "Created on first fill (init_if_needed). A missing PDA means the order",
+        "has never been touched (remaining = order.amount)."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
           {
-            name: "yes_price_bps",
-            type: "u64"
+            name: "maker",
+            type: "pubkey"
           },
           {
-            name: "no_price_bps",
+            name: "nonce",
             type: "u64"
           },
           {
-            name: "yes_cost",
+            name: "filled_amount",
             type: "u64"
           },
           {
-            name: "no_cost",
-            type: "u64"
+            name: "bump",
+            type: "u8"
           }
         ]
       }
     },
     {
-      name: "Order",
+      name: "SignedOrderRecord",
       docs: [
-        "Signed order message \u2014 passed as instruction data (not stored on-chain).",
-        "The operator verifies the maker's off-chain signature before calling match_*."
+        "On-chain verified order record.",
+        "Created by `register_order` after Ed25519 signature verification.",
+        "Read by match instructions via remaining_accounts.",
+        "Closed (rent returned) when order is fully filled or cancelled.",
+        "",
+        'PDA seeds: [b"order_record", maker, nonce_le_bytes]'
       ],
       type: {
         kind: "struct",
         fields: [
           {
             name: "maker",
-            docs: [
-              "Maker's wallet pubkey"
-            ],
             type: "pubkey"
           },
           {
             name: "condition",
-            docs: [
-              "Condition PDA this order belongs to"
-            ],
             type: "pubkey"
           },
           {
             name: "token_id",
-            docs: [
-              "Outcome token: 0=NO, 1=YES"
-            ],
             type: "u8"
           },
           {
             name: "side",
-            docs: [
-              "Side: 0=SELL (maker gives tokens, wants USDC), 1=BUY (maker gives USDC, wants tokens)"
-            ],
             type: "u8"
           },
           {
-            name: "price_bps",
-            docs: [
-              "Price in basis points (0-10000). e.g. 6000 = 60 cents per $1 of exposure.",
-              "For a BUY: maker pays price_bps / 10000 USDC per token.",
-              "For a SELL: maker wants price_bps / 10000 USDC per token."
-            ],
+            name: "maker_amount",
             type: "u64"
           },
           {
-            name: "amount",
-            docs: [
-              "Maximum order size in token units (YES or NO tokens, 0 decimals)."
-            ],
+            name: "taker_amount",
             type: "u64"
           },
           {
             name: "nonce",
-            docs: [
-              "Unique nonce per maker \u2014 used for OrderStatus PDA derivation & replay protection."
-            ],
             type: "u64"
           },
           {
             name: "expiry",
-            docs: [
-              "Unix timestamp after which the order is invalid (0 = no expiry)."
-            ],
             type: "i64"
-          }
-        ]
-      }
-    },
-    {
-      name: "OrderStatus",
-      docs: [
-        "Tracks the fill state of an order for replay protection.",
-        'PDA seeds: [b"order", maker_pubkey, nonce_le_bytes]',
-        "",
-        "Created on first fill (init_if_needed). A missing PDA means the order",
-        "has never been touched (remaining = order.amount)."
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "maker",
-            docs: [
-              "The maker who created the order"
-            ],
-            type: "pubkey"
           },
           {
-            name: "nonce",
-            docs: [
-              "Order nonce (unique per maker)"
-            ],
-            type: "u64"
+            name: "created_at",
+            type: "i64"
           },
           {
-            name: "filled_amount",
-            docs: [
-              "Amount of collateral (USDC) already filled"
-            ],
+            name: "fee",
             type: "u64"
           },
           {
-            name: "bump",
-            docs: [
-              "Bump for this PDA"
-            ],
-            type: "u8"
-          }
-        ]
-      }
-    },
-    {
-      name: "SignedOrder",
-      docs: [
-        "Order + 64-byte Ed25519 signature over `order.to_signable_bytes()`.",
-        "Passed as instruction data to all match_* instructions.",
-        "On-chain: the program verifies the signature exists in the tx",
-        "via Ed25519 precompile instructions at known indices."
-      ],
-      type: {
-        kind: "struct",
-        fields: [
+            name: "taker",
+            type: "pubkey"
+          },
           {
-            name: "order",
-            type: {
-              defined: {
-                name: "Order"
-              }
-            }
+            name: "signer",
+            type: "pubkey"
           },
           {
-            name: "signature",
-            type: {
-              array: [
-                "u8",
-                64
-              ]
-            }
+            name: "bump",
+            type: "u8"
           }
         ]
       }
@@ -9420,8 +9886,10 @@ var fee_management_default = {
         {
           name: "market_oracle_vault",
           docs: [
-            "For admin questions \u2014 not used; pass any account non-writable (no transfer occurs)."
-          ]
+            "Writable: tokens are transferred here when is_admin=false.",
+            "For admin questions pass any writable account (no transfer occurs)."
+          ],
+          writable: true
         },
         {
           name: "token_program",
@@ -12978,85 +13446,1067 @@ var market_oracle_default = {
   ]
 };
 
-// src/sdk.ts
-var XMarketSDK = class {
-  constructor(config, wallet, marketOwner) {
-    this.networkConfig = config;
-    this.provider = new anchor4__namespace.AnchorProvider(
-      new web3_js.Connection(config.rpcUrl, "confirmed"),
-      wallet,
-      { commitment: "confirmed", preflightCommitment: "confirmed" }
-    );
-    anchor4__namespace.setProvider(this.provider);
-    this._programIds = config.programIds;
-    this._marketOwner = marketOwner ?? wallet.publicKey;
-  }
-  _withAddress(idl, address) {
-    return { ...idl, address: address.toBase58() };
-  }
-  get oracle() {
-    if (!this._oracle) {
-      const program = new anchor4__namespace.Program(this._withAddress(oracle_default, this._programIds.oracle), this.provider);
-      this._oracle = new OracleClient(program, this.provider, this._programIds);
-    }
-    return this._oracle;
-  }
-  get hook() {
-    if (!this._hook) {
-      const program = new anchor4__namespace.Program(this._withAddress(hook_default, this._programIds.hook), this.provider);
-      this._hook = new HookClient(program, this.provider, this._programIds);
-    }
-    return this._hook;
-  }
-  get market() {
-    if (!this._market) {
-      const program = new anchor4__namespace.Program(this._withAddress(question_market_default, this._programIds.questionMarket), this.provider);
-      this._market = new MarketClient(program, this.provider, this._programIds, this._marketOwner);
-      this._market.ctfClient = this.ctf;
-    }
-    return this._market;
-  }
-  get ctf() {
-    if (!this._ctf) {
-      const program = new anchor4__namespace.Program(this._withAddress(conditional_tokens_default, this._programIds.conditionalTokens), this.provider);
-      this._ctf = new CtfClient(program, this.provider, this._programIds);
-    }
-    return this._ctf;
-  }
-  get clob() {
-    if (!this._clob) {
-      const program = new anchor4__namespace.Program(this._withAddress(clob_exchange_default, this._programIds.clobExchange), this.provider);
-      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(fee_management_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(presale_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(market_oracle_default, this._programIds.marketOracle), this.provider);
-      this._marketOracle = new MarketOracleClient(program, this.provider, this._programIds);
-    }
-    return this._marketOracle;
+// src/idls/admin_contract.json
+var admin_contract_default = {
+  address: "4NdD5962SfGqofmeyjfifJpdGnwTAiKaUKB5Z42UDc9T",
+  metadata: {
+    name: "admin_contract",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Admin contract for XMarket \u2014 whitelist, presale revenue custody, claim"
+  },
+  instructions: [
+    {
+      name: "add_admin",
+      discriminator: [
+        177,
+        236,
+        33,
+        205,
+        124,
+        152,
+        55,
+        186
+      ],
+      accounts: [
+        {
+          name: "owner",
+          signer: true
+        },
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  100,
+                  109,
+                  105,
+                  110,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "config.owner",
+                account: "AdminConfig"
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "address",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "add_to_whitelist",
+      discriminator: [
+        157,
+        211,
+        52,
+        54,
+        144,
+        81,
+        5,
+        55
+      ],
+      accounts: [
+        {
+          name: "admin",
+          signer: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  100,
+                  109,
+                  105,
+                  110,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "config.owner",
+                account: "AdminConfig"
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "address",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "claim",
+      discriminator: [
+        62,
+        198,
+        214,
+        193,
+        213,
+        159,
+        108,
+        210
+      ],
+      accounts: [
+        {
+          name: "claimer",
+          signer: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "config",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  100,
+                  109,
+                  105,
+                  110,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "config.owner",
+                account: "AdminConfig"
+              }
+            ]
+          }
+        },
+        {
+          name: "admin_vault",
+          docs: [
+            "ATA owned by config PDA"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "config"
+              },
+              {
+                kind: "const",
+                value: [
+                  6,
+                  221,
+                  246,
+                  225,
+                  215,
+                  101,
+                  161,
+                  147,
+                  217,
+                  203,
+                  225,
+                  70,
+                  206,
+                  235,
+                  121,
+                  172,
+                  28,
+                  180,
+                  133,
+                  237,
+                  95,
+                  91,
+                  55,
+                  145,
+                  58,
+                  140,
+                  245,
+                  133,
+                  126,
+                  255,
+                  0,
+                  169
+                ]
+              },
+              {
+                kind: "account",
+                path: "config.collateral_mint",
+                account: "AdminConfig"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "claim_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  108,
+                  97,
+                  105,
+                  109,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
+                ]
+              },
+              {
+                kind: "arg",
+                path: "condition_id"
+              }
+            ]
+          }
+        },
+        {
+          name: "claimer_token_account",
+          docs: [
+            "Claimer's USDC token account (receives payout)"
+          ],
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "condition_id",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "distribute_market",
+      discriminator: [
+        130,
+        221,
+        123,
+        201,
+        185,
+        168,
+        63,
+        19
+      ],
+      accounts: [
+        {
+          name: "claimer",
+          docs: [
+            "BOTMM \u2014 must be in whitelist"
+          ],
+          signer: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "config",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  100,
+                  109,
+                  105,
+                  110,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "config.owner",
+                account: "AdminConfig"
+              }
+            ]
+          }
+        },
+        {
+          name: "claimer_token_account",
+          docs: [
+            "BOTMM's USDC token account (source \u2014 claimer signs)"
+          ],
+          writable: true
+        },
+        {
+          name: "market_oracle_vault",
+          docs: [
+            "market_oracle vault \u2014 MST holder reward pool for this condition"
+          ],
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "condition_id",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        },
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "initialize",
+      discriminator: [
+        175,
+        175,
+        109,
+        31,
+        13,
+        152,
+        155,
+        237
+      ],
+      accounts: [
+        {
+          name: "owner",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  100,
+                  109,
+                  105,
+                  110,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "owner"
+              }
+            ]
+          }
+        },
+        {
+          name: "collateral_mint"
+        },
+        {
+          name: "admin_vault",
+          docs: [
+            "ATA owned by config PDA \u2014 holds USDC for unclaimed presale revenue"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "config"
+              },
+              {
+                kind: "const",
+                value: [
+                  6,
+                  221,
+                  246,
+                  225,
+                  215,
+                  101,
+                  161,
+                  147,
+                  217,
+                  203,
+                  225,
+                  70,
+                  206,
+                  235,
+                  121,
+                  172,
+                  28,
+                  180,
+                  133,
+                  237,
+                  95,
+                  91,
+                  55,
+                  145,
+                  58,
+                  140,
+                  245,
+                  133,
+                  126,
+                  255,
+                  0,
+                  169
+                ]
+              },
+              {
+                kind: "account",
+                path: "collateral_mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "authorized_caller",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "remove_admin",
+      discriminator: [
+        74,
+        202,
+        71,
+        106,
+        252,
+        31,
+        72,
+        183
+      ],
+      accounts: [
+        {
+          name: "owner",
+          signer: true
+        },
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  100,
+                  109,
+                  105,
+                  110,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "config.owner",
+                account: "AdminConfig"
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "address",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "remove_from_whitelist",
+      discriminator: [
+        7,
+        144,
+        216,
+        239,
+        243,
+        236,
+        193,
+        235
+      ],
+      accounts: [
+        {
+          name: "admin",
+          signer: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  100,
+                  109,
+                  105,
+                  110,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "config.owner",
+                account: "AdminConfig"
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "address",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "set_presale_amount",
+      discriminator: [
+        73,
+        71,
+        238,
+        3,
+        202,
+        163,
+        8,
+        254
+      ],
+      accounts: [
+        {
+          name: "caller",
+          docs: [
+            "question_market config PDA \u2014 signs this CPI call via seeds"
+          ],
+          signer: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "config",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  100,
+                  109,
+                  105,
+                  110,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "config.owner",
+                account: "AdminConfig"
+              }
+            ]
+          }
+        },
+        {
+          name: "claim_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  108,
+                  97,
+                  105,
+                  109,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
+                ]
+              },
+              {
+                kind: "arg",
+                path: "condition_id"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "condition_id",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        },
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "update_config",
+      discriminator: [
+        29,
+        158,
+        252,
+        191,
+        10,
+        83,
+        219,
+        99
+      ],
+      accounts: [
+        {
+          name: "owner",
+          signer: true
+        },
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  97,
+                  100,
+                  109,
+                  105,
+                  110,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "account",
+                path: "config.owner",
+                account: "AdminConfig"
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "authorized_caller",
+          type: "pubkey"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "AdminConfig",
+      discriminator: [
+        156,
+        10,
+        79,
+        161,
+        71,
+        9,
+        62,
+        77
+      ]
+    },
+    {
+      name: "ClaimRecord",
+      discriminator: [
+        57,
+        229,
+        0,
+        9,
+        65,
+        62,
+        96,
+        7
+      ]
+    }
+  ],
+  types: [
+    {
+      name: "AdminConfig",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "version",
+            type: "u8"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "collateral_mint",
+            type: "pubkey"
+          },
+          {
+            name: "authorized_caller",
+            docs: [
+              "question_market config PDA \u2014 only this can call set_presale_amount"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "admin_whitelist",
+            type: {
+              array: [
+                "pubkey",
+                10
+              ]
+            }
+          },
+          {
+            name: "admin_whitelist_len",
+            type: "u8"
+          },
+          {
+            name: "whitelist",
+            type: {
+              array: [
+                "pubkey",
+                30
+              ]
+            }
+          },
+          {
+            name: "whitelist_len",
+            type: "u8"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "_reserved",
+            type: {
+              array: [
+                "u8",
+                64
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "ClaimRecord",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "condition_id",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/sdk.ts
+var XMarketSDK = class {
+  // lazy-init in get admin()
+  constructor(config, wallet, marketOwner) {
+    this.networkConfig = config;
+    this.provider = new anchor5__namespace.AnchorProvider(
+      new web3_js.Connection(config.rpcUrl, "confirmed"),
+      wallet,
+      { commitment: "confirmed", preflightCommitment: "confirmed" }
+    );
+    anchor5__namespace.setProvider(this.provider);
+    this._programIds = config.programIds;
+    this._marketOwner = marketOwner ?? wallet.publicKey;
+  }
+  _withAddress(idl, address) {
+    return { ...idl, address: address.toBase58() };
+  }
+  get oracle() {
+    if (!this._oracle) {
+      const program = new anchor5__namespace.Program(this._withAddress(oracle_default, this._programIds.oracle), this.provider);
+      this._oracle = new OracleClient(program, this.provider, this._programIds);
+    }
+    return this._oracle;
+  }
+  get hook() {
+    if (!this._hook) {
+      const program = new anchor5__namespace.Program(this._withAddress(hook_default, this._programIds.hook), this.provider);
+      this._hook = new HookClient(program, this.provider, this._programIds);
+    }
+    return this._hook;
+  }
+  get market() {
+    if (!this._market) {
+      const program = new anchor5__namespace.Program(this._withAddress(question_market_default, this._programIds.questionMarket), this.provider);
+      this._market = new MarketClient(program, this.provider, this._programIds, this._marketOwner);
+      this._market.ctfClient = this.ctf;
+    }
+    return this._market;
+  }
+  get ctf() {
+    if (!this._ctf) {
+      const program = new anchor5__namespace.Program(this._withAddress(conditional_tokens_default, this._programIds.conditionalTokens), this.provider);
+      this._ctf = new CtfClient(program, this.provider, this._programIds);
+    }
+    return this._ctf;
+  }
+  get clob() {
+    if (!this._clob) {
+      const program = new anchor5__namespace.Program(this._withAddress(clob_exchange_default, this._programIds.clobExchange), this.provider);
+      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 anchor5__namespace.Program(this._withAddress(fee_management_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 anchor5__namespace.Program(this._withAddress(presale_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 anchor5__namespace.Program(this._withAddress(market_oracle_default, this._programIds.marketOracle), this.provider);
+      this._marketOracle = new MarketOracleClient(program, this.provider, this._programIds);
+    }
+    return this._marketOracle;
+  }
+  get admin() {
+    if (!this._admin) {
+      if (!this._programIds.adminContract) throw new Error("adminContract program ID not configured in NetworkConfig");
+      const program = new anchor5__namespace.Program(this._withAddress(admin_contract_default, this._programIds.adminContract), this.provider);
+      this._admin = new AdminClient(program, this.provider, this._programIds);
+    }
+    return this._admin;
   }
 };
 function buildOrder(params) {
@@ -13067,10 +14517,10 @@ function buildOrder(params) {
     side: params.side,
     makerAmount: params.makerAmount,
     takerAmount: params.takerAmount,
-    nonce: params.nonce ?? new BN4__default.default(Date.now()),
-    expiry: params.expiry ?? new BN4__default.default(0),
-    createdAt: params.createdAt ?? new BN4__default.default(Math.floor(Date.now() / 1e3)),
-    fee: params.fee ?? new BN4__default.default(0),
+    nonce: params.nonce ?? new BN5__default.default(Date.now()),
+    expiry: params.expiry ?? new BN5__default.default(0),
+    createdAt: params.createdAt ?? new BN5__default.default(Math.floor(Date.now() / 1e3)),
+    fee: params.fee ?? new BN5__default.default(0),
     taker: params.taker ?? new web3_js.PublicKey(new Uint8Array(32)),
     signer: params.maker
   };
@@ -13093,8 +14543,8 @@ function serializeSignedOrder(signed) {
 function deserializeSignedOrder(bytes) {
   if (bytes.length !== 242) throw new InvalidParamError("SignedOrder must be 242 bytes");
   const readPubkey = (offset) => new web3_js.PublicKey(bytes.slice(offset, offset + 32));
-  const readU64 = (offset) => new BN4__default.default(bytes.slice(offset, offset + 8), "le");
-  const readI64 = (offset) => new BN4__default.default(bytes.slice(offset, offset + 8), "le");
+  const readU64 = (offset) => new BN5__default.default(bytes.slice(offset, offset + 8), "le");
+  const readI64 = (offset) => new BN5__default.default(bytes.slice(offset, offset + 8), "le");
   const order = {
     maker: readPubkey(0),
     condition: readPubkey(32),
@@ -13143,7 +14593,7 @@ function _detectMatchType(a, b) {
     "Orders with different tokenIds must both be BUY (MINT) or both SELL (MERGE)"
   );
 }
-var MAX_APPROVE_AMOUNT = new BN4__default.default("18446744073709551615");
+var MAX_APPROVE_AMOUNT = new BN5__default.default("18446744073709551615");
 function buildApproveCollateralTx(collateralMint, signer, payer, delegate, amount = MAX_APPROVE_AMOUNT) {
   const ownerAta = splToken.getAssociatedTokenAddressSync(collateralMint, signer, false, splToken.TOKEN_PROGRAM_ID);
   const approveIx = splToken.createApproveInstruction(
@@ -13188,6 +14638,7 @@ function buildApproveAllOutcomeTokensTx(condition, signer, payer, delegate, prog
 }
 
 exports.AccountNotFoundError = AccountNotFoundError;
+exports.AdminClient = AdminClient;
 exports.ClobClient = ClobClient;
 exports.CtfClient = CtfClient;
 exports.FEE_DENOMINATOR = FEE_DENOMINATOR;