@theliem/xmarket-sdk 3.3.0 → 3.3.1

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
@@ -171,6 +171,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");
@@ -299,7 +307,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 +574,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 +642,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 {
@@ -1033,7 +1057,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 +1087,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 +1328,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,7 +1429,7 @@ 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');
@@ -1394,25 +1438,33 @@ var ClobClient = class {
     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 +1473,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 +1547,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 +1554,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 +1561,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 +1568,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 +1576,44 @@ var ClobClient = class {
     }).rpc();
     return { signature: sig };
   }
+  // ─── Match instructions ───────────────────────────────────────────────────────
   /**
-   * COMPLEMENTARY match: 1 buyer (taker) + N sellers (makers), same tokenId.
+   * Build match_complementary instruction (no Ed25519 — OrderRecord PDAs used).
    *
-   * 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.
-   *
-   * 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 +1621,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 +1635,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 +1677,167 @@ var ClobClient = class {
     return { signature: sig };
   }
   /**
-   * MINT match: 1 YES buyer (taker) + N NO buyers (makers).
+   * MINT: 1 YES buyer (taker) + N NO buyers (makers).
+   * Phase 1: register taker + all NO makers in parallel.
+   * Phase 2: 1 atomic match tx.
    *
-   * Transaction structure:
-   *   ix[0]   Ed25519(taker/YES buyer)
-   *   ix[1+i] Ed25519(maker_i/NO buyer)
-   *   ix[N+1] match_mint_orders(yesNonce, makerNonces[])
-   *
-   * 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).
-   *
-   * Transaction structure:
-   *   ix[0]   Ed25519(taker/YES seller)
-   *   ix[1+i] Ed25519(maker_i/NO seller)
-   *   ix[N+1] match_merge_orders(yesNonce, makerNonces[])
+   * MERGE: 1 YES seller (taker) + N NO sellers (makers).
+   * Phase 1: register taker + all NO makers in parallel.
+   * Phase 2: 1 atomic match tx.
    *
-   * remaining_accounts: [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.
+   * Auto-detect match type and execute 2-phase:
+   *   Phase 1 — register all orders (taker + makers) on-chain in parallel.
+   *   Phase 2 — 1 atomic match transaction.
    *
-   * Detection (pure, no RPC) 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
+   * 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
    *
-   * 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.
-   *
-   * @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 +1849,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;
@@ -1754,9 +1860,6 @@ var ClobClient = class {
       if (t.side === SIDE_BUY && makers.every((m) => m.order.side === SIDE_SELL)) {
         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");
-      }
       throw new InvalidParamError("COMPLEMENTARY requires taker=BUY, makers=SELL on same tokenId");
     }
     const allBuy = t.side === SIDE_BUY && makers.every((m) => m.order.side === SIDE_BUY);
@@ -1765,7 +1868,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 +1902,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) {
@@ -2838,6 +2950,11 @@ var hook_default = {
           name: "owner",
           signer: true
         },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
         {
           name: "hook_config",
           writable: true,
@@ -2969,6 +3086,11 @@ var hook_default = {
           name: "owner",
           signer: true
         },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
         {
           name: "hook_config",
           writable: true,
@@ -3177,6 +3299,11 @@ var hook_default = {
           name: "owner",
           signer: true
         },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
         {
           name: "hook_config",
           writable: true,
@@ -3228,10 +3355,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 +3364,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 +3381,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"
           },
           {
@@ -4183,6 +4294,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 +4714,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 +5803,7 @@ var question_market_default = {
             type: {
               array: [
                 "pubkey",
-                10
+                30
               ]
             }
           },
@@ -7685,9 +7905,6 @@ var clob_exchange_default = {
   instructions: [
     {
       name: "add_operator",
-      docs: [
-        "Add an authorized operator (off-chain matching engine)."
-      ],
       discriminator: [
         149,
         142,
@@ -7736,13 +7953,77 @@ 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: [
-        96,
+        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,
         187,
         95,
@@ -7815,9 +8096,6 @@ var clob_exchange_default = {
     },
     {
       name: "initialize_clob",
-      docs: [
-        "Initialize the CLOB global config."
-      ],
       discriminator: [
         35,
         69,
@@ -7887,10 +8165,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 +8180,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 +8211,14 @@ var clob_exchange_default = {
             ]
           }
         },
-        {
-          name: "ix_sysvar",
-          address: "Sysvar1nstructions1111111111111111111111111"
-        },
         {
           name: "condition"
         },
         {
-          name: "buyer"
+          name: "taker"
         },
         {
-          name: "buyer_collateral",
-          writable: true
-        },
-        {
-          name: "buyer_token_account",
-          writable: true
-        },
-        {
-          name: "buy_order_status",
-          writable: true,
+          name: "taker_order_record",
           pda: {
             seeds: [
               {
@@ -7975,33 +8228,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 +8278,11 @@ var clob_exchange_default = {
               },
               {
                 kind: "account",
-                path: "seller"
+                path: "taker"
               },
               {
                 kind: "arg",
-                path: "sell_signed.order.nonce"
+                path: "taker_nonce"
               }
             ]
           }
@@ -8034,17 +8295,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 +8314,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 +8326,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 +8341,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 +8371,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 +8388,41 @@ var clob_exchange_default = {
                   114,
                   100,
                   101,
-                  114
+                  114,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
                 ]
               },
               {
                 kind: "account",
-                path: "seller_yes"
+                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 +8438,11 @@ var clob_exchange_default = {
               },
               {
                 kind: "account",
-                path: "seller_no"
+                path: "taker"
               },
               {
                 kind: "arg",
-                path: "no_signed.order.nonce"
+                path: "taker_nonce"
               }
             ]
           }
@@ -8258,16 +8469,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 +8496,7 @@ var clob_exchange_default = {
         },
         {
           name: "conditional_tokens_program",
-          address: "7boT4uqXGRMbDPzA7Q9znqbfYNB6auoXUcDnUfxyZAU"
+          address: "A6N1F8MRsdgcojAx8p6FaECvw8mo8w6qJcWsbKQBANK4"
         },
         {
           name: "collateral_token_program",
@@ -8304,20 +8509,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 +8521,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 +8536,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 +8566,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: "buyer_yes_position",
-          writable: true
+          name: "taker"
         },
         {
-          name: "yes_order_status",
-          writable: true,
+          name: "taker_order_record",
           pda: {
             seeds: [
               {
@@ -8415,37 +8583,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 +8633,11 @@ var clob_exchange_default = {
               },
               {
                 kind: "account",
-                path: "buyer_no"
+                path: "taker"
               },
               {
                 kind: "arg",
-                path: "no_signed.order.nonce"
+                path: "taker_nonce"
               }
             ]
           }
@@ -8492,9 +8664,6 @@ var clob_exchange_default = {
         },
         {
           name: "clob_authority",
-          docs: [
-            "CLOB authority PDA (signs CTF CPI)"
-          ],
           pda: {
             seeds: [
               {
@@ -8518,7 +8687,7 @@ var clob_exchange_default = {
         },
         {
           name: "conditional_tokens_program",
-          address: "7boT4uqXGRMbDPzA7Q9znqbfYNB6auoXUcDnUfxyZAU"
+          address: "A6N1F8MRsdgcojAx8p6FaECvw8mo8w6qJcWsbKQBANK4"
         },
         {
           name: "collateral_token_program",
@@ -8531,32 +8700,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 +8937,6 @@ var clob_exchange_default = {
     },
     {
       name: "set_paused",
-      docs: [
-        "Pause or unpause the CLOB (admin only)."
-      ],
       discriminator: [
         91,
         60,
@@ -8683,6 +9011,19 @@ var clob_exchange_default = {
         65,
         3
       ]
+    },
+    {
+      name: "SignedOrderRecord",
+      discriminator: [
+        16,
+        167,
+        189,
+        166,
+        85,
+        0,
+        231,
+        55
+      ]
     }
   ],
   events: [
@@ -8877,29 +9218,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 +9375,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 +9402,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 +9660,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",
@@ -12982,12 +13224,12 @@ var market_oracle_default = {
 var XMarketSDK = class {
   constructor(config, wallet, marketOwner) {
     this.networkConfig = config;
-    this.provider = new anchor4__namespace.AnchorProvider(
+    this.provider = new anchor5__namespace.AnchorProvider(
       new web3_js.Connection(config.rpcUrl, "confirmed"),
       wallet,
       { commitment: "confirmed", preflightCommitment: "confirmed" }
     );
-    anchor4__namespace.setProvider(this.provider);
+    anchor5__namespace.setProvider(this.provider);
     this._programIds = config.programIds;
     this._marketOwner = marketOwner ?? wallet.publicKey;
   }
@@ -12996,21 +13238,21 @@ var XMarketSDK = class {
   }
   get oracle() {
     if (!this._oracle) {
-      const program = new anchor4__namespace.Program(this._withAddress(oracle_default, this._programIds.oracle), this.provider);
+      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 anchor4__namespace.Program(this._withAddress(hook_default, this._programIds.hook), this.provider);
+      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 anchor4__namespace.Program(this._withAddress(question_market_default, this._programIds.questionMarket), this.provider);
+      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;
     }
@@ -13018,14 +13260,14 @@ var XMarketSDK = class {
   }
   get ctf() {
     if (!this._ctf) {
-      const program = new anchor4__namespace.Program(this._withAddress(conditional_tokens_default, this._programIds.conditionalTokens), this.provider);
+      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 anchor4__namespace.Program(this._withAddress(clob_exchange_default, this._programIds.clobExchange), this.provider);
+      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;
@@ -13037,7 +13279,7 @@ var XMarketSDK = class {
   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);
+      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;
@@ -13045,7 +13287,7 @@ var XMarketSDK = class {
   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);
+      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;
@@ -13053,7 +13295,7 @@ var XMarketSDK = class {
   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);
+      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;
@@ -13067,10 +13309,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 +13335,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 +13385,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(