@theliem/xmarket-sdk 1.0.12

package/dist/index.js

@@ -0,0 +1,1860 @@
+'use strict';
+
+var anchor4 = require('@coral-xyz/anchor');
+var web3_js = require('@solana/web3.js');
+var crypto = require('crypto');
+var splToken = require('@solana/spl-token');
+var oracleIdl = require('./oracle-FZJJIJGI.json');
+var hookIdl = require('./hook-THBRGUM6.json');
+var questionMarketIdl = require('./question_market-CB6ZUZ5E.json');
+var conditionalTokensIdl = require('./conditional_tokens-3O5V46N5.json');
+var clobExchangeIdl = require('./clob_exchange-ATSH42KC.json');
+var BN4 = require('bn.js');
+var nacl = require('tweetnacl');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var anchor4__namespace = /*#__PURE__*/_interopNamespace(anchor4);
+var oracleIdl__default = /*#__PURE__*/_interopDefault(oracleIdl);
+var hookIdl__default = /*#__PURE__*/_interopDefault(hookIdl);
+var questionMarketIdl__default = /*#__PURE__*/_interopDefault(questionMarketIdl);
+var conditionalTokensIdl__default = /*#__PURE__*/_interopDefault(conditionalTokensIdl);
+var clobExchangeIdl__default = /*#__PURE__*/_interopDefault(clobExchangeIdl);
+var BN4__default = /*#__PURE__*/_interopDefault(BN4);
+var nacl__namespace = /*#__PURE__*/_interopNamespace(nacl);
+
+// src/sdk.ts
+var DEVNET_CONFIG = {
+  name: "devnet",
+  rpcUrl: "https://api.devnet.solana.com",
+  programIds: {
+    oracle: new web3_js.PublicKey("FzLnnbKtQCTKviEbrDYMLZYXNDHQdjSSa4Ybj4jAbrUL"),
+    conditionalTokens: new web3_js.PublicKey("A6N1F8MRsdgcojAx8p6FaECvw8mo8w6qJcWsbKQBANK4"),
+    questionMarket: new web3_js.PublicKey("FCvCbWoLpzNYKzQnXYXCo1yz9DTpgUs11QqHVqnqtWhA"),
+    hook: new web3_js.PublicKey("F7y5MfW8d5kqR25QHDhUQ9LrKCiZUZVF6Pdnw15q5zZW"),
+    clobExchange: new web3_js.PublicKey("Cs4GY1yZVxjxhhyUum3AupMuS3bo4yKRXifgLTTAh1sf")
+  },
+  defaultCollateral: {
+    mint: new web3_js.PublicKey("53osACZSom79AHf6nK4eq8DL6viMZmyVERYPDB6S6Eck"),
+    decimals: 9
+  }
+};
+var LOCALNET_CONFIG = {
+  name: "localnet",
+  rpcUrl: "http://localhost:8899",
+  programIds: { ...DEVNET_CONFIG.programIds },
+  defaultCollateral: {
+    mint: new web3_js.PublicKey("6Gk4qsruSjunenwzP4L5DQukawfVNvdr9rPX2qG77jmH"),
+    decimals: 6
+  }
+};
+var MAINNET_CONFIG = {
+  name: "mainnet",
+  rpcUrl: "https://api.mainnet-beta.solana.com",
+  programIds: {
+    oracle: new web3_js.PublicKey("E667trvbHmZEnptjnjXp9x8e1Fpji3viHo1J1DGPKijh"),
+    conditionalTokens: new web3_js.PublicKey("3WFSX7zPLrJSU811h7awgqXTZuKhUR1Fi1VBDayHhk4s"),
+    questionMarket: new web3_js.PublicKey("GiQh2xBmEiM4gYq4U9PMSaUJNq1T9TfEJL5cXvNYhtGm"),
+    hook: new web3_js.PublicKey("11111111111111111111111111111111"),
+    // not yet deployed
+    clobExchange: new web3_js.PublicKey("11111111111111111111111111111111")
+    // not yet deployed
+  },
+  defaultCollateral: {
+    mint: new web3_js.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+    // USDC mainnet
+    decimals: 6
+  }
+};
+var NETWORK_CONFIGS = {
+  devnet: DEVNET_CONFIG,
+  localnet: LOCALNET_CONFIG,
+  mainnet: MAINNET_CONFIG
+};
+var SEEDS = {
+  config: Buffer.from("config"),
+  question: Buffer.from("question"),
+  condition: Buffer.from("condition"),
+  collateralVault: Buffer.from("collateral_vault"),
+  vaultToken: Buffer.from("vault_token"),
+  position: Buffer.from("position"),
+  yesMint: Buffer.from("yes_mint"),
+  noMint: Buffer.from("no_mint"),
+  mintAuthority: Buffer.from("mint_authority"),
+  reporter: Buffer.from("reporter"),
+  result: Buffer.from("result"),
+  ctfConfig: Buffer.from("ctf_config"),
+  hookConfig: Buffer.from("hook_config"),
+  extraAccountMetas: Buffer.from("extra-account-metas"),
+  clobConfig: Buffer.from("clob_config"),
+  order: Buffer.from("order")
+};
+var PDA = class {
+  // ─── Question Market ────────────────────────────────────────────────────────
+  static questionMarketConfig(owner, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.config, owner.toBuffer()],
+      programIds.questionMarket
+    );
+  }
+  static question(config, questionId, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.question, config.toBuffer(), Buffer.from(questionId)],
+      programIds.questionMarket
+    );
+  }
+  // ─── Conditional Tokens ─────────────────────────────────────────────────────
+  static ctfConfig(programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.ctfConfig],
+      programIds.conditionalTokens
+    );
+  }
+  static condition(oracle, questionId, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.condition, oracle.toBuffer(), Buffer.from(questionId)],
+      programIds.conditionalTokens
+    );
+  }
+  static collateralVault(collateralMint, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.collateralVault, collateralMint.toBuffer()],
+      programIds.conditionalTokens
+    );
+  }
+  static vaultToken(collateralMint, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.vaultToken, collateralMint.toBuffer()],
+      programIds.conditionalTokens
+    );
+  }
+  static yesMint(condition, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.yesMint, condition.toBuffer()],
+      programIds.conditionalTokens
+    );
+  }
+  static noMint(condition, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.noMint, condition.toBuffer()],
+      programIds.conditionalTokens
+    );
+  }
+  static mintAuthority(condition, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.mintAuthority, condition.toBuffer()],
+      programIds.conditionalTokens
+    );
+  }
+  static position(condition, outcomeIndex, owner, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.position, condition.toBuffer(), Buffer.from([outcomeIndex]), owner.toBuffer()],
+      programIds.conditionalTokens
+    );
+  }
+  // ─── Oracle ─────────────────────────────────────────────────────────────────
+  static oracleConfig(owner, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.config, owner.toBuffer()],
+      programIds.oracle
+    );
+  }
+  static reporter(oracleConfig, reporterAddress, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.reporter, oracleConfig.toBuffer(), reporterAddress.toBuffer()],
+      programIds.oracle
+    );
+  }
+  static questionResult(oracleConfig, questionId, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.result, oracleConfig.toBuffer(), Buffer.from(questionId)],
+      programIds.oracle
+    );
+  }
+  // ─── Hook ───────────────────────────────────────────────────────────────────
+  static hookConfig(programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.hookConfig],
+      programIds.hook
+    );
+  }
+  static extraAccountMetaList(mint, programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.extraAccountMetas, mint.toBuffer()],
+      programIds.hook
+    );
+  }
+  // ─── CLOB ───────────────────────────────────────────────────────────────────
+  static clobConfig(programIds) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.clobConfig],
+      programIds.clobExchange
+    );
+  }
+  static orderStatus(maker, nonce, programIds) {
+    const nonceBuf = Buffer.alloc(8);
+    nonceBuf.writeBigUInt64LE(BigInt(nonce.toString()));
+    return web3_js.PublicKey.findProgramAddressSync(
+      [SEEDS.order, maker.toBuffer(), nonceBuf],
+      programIds.clobExchange
+    );
+  }
+};
+function generateQuestionId(content, salt) {
+  const input = content + (salt ?? Date.now());
+  return new Uint8Array(crypto.createHash("sha256").update(input).digest());
+}
+function generateContentHash(content) {
+  return new Uint8Array(crypto.createHash("sha256").update(content).digest());
+}
+
+// src/programs/oracle.ts
+var OracleClient = class {
+  constructor(program, provider, programIds) {
+    this.program = program;
+    this.provider = provider;
+    this.programIds = programIds;
+  }
+  get walletPubkey() {
+    return this.provider.wallet.publicKey;
+  }
+  configPda(owner = this.walletPubkey) {
+    return PDA.oracleConfig(owner, this.programIds)[0];
+  }
+  // ─── Instructions ────────────────────────────────────────────────────────────
+  /** One-time setup. Caller becomes owner. */
+  async initialize(admin) {
+    const sig = await this.program.methods.initialize(admin).accounts({
+      owner: this.walletPubkey,
+      oracleConfig: this.configPda(),
+      systemProgram: web3_js.SystemProgram.programId
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Admin or owner adds an address to the oracle whitelist. */
+  async addToWhitelist(address, ownerPubkey) {
+    const sig = await this.program.methods.addToWhitelist(address).accounts({
+      authority: this.walletPubkey,
+      payer: this.walletPubkey,
+      oracleConfig: this.configPda(ownerPubkey)
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Admin or owner removes an address from the oracle whitelist. */
+  async removeFromWhitelist(address, ownerPubkey) {
+    const sig = await this.program.methods.removeFromWhitelist(address).accounts({
+      authority: this.walletPubkey,
+      payer: this.walletPubkey,
+      oracleConfig: this.configPda(ownerPubkey)
+    }).rpc();
+    return { signature: sig };
+  }
+  /**
+   * Whitelisted reporter resolves a question.
+   * CPIs directly into CTF.set_payout — condition is resolved in one tx.
+   * @param conditionPda  - CTF condition account (oracle_config = oraclePda, question_id must match)
+   * @param ownerPubkey   - oracle config owner (defaults to wallet)
+   * @param payer         - fee payer (defaults to wallet)
+   */
+  async resolveQuestion(questionId, outcomeCount, payoutNumerators, conditionPda, ownerPubkey, payer, signers = []) {
+    const oracleConfig = this.configPda(ownerPubkey);
+    const [questionResultPda] = PDA.questionResult(oracleConfig, questionId, this.programIds);
+    const sig = await this.program.methods.resolveQuestion(
+      Array.from(questionId),
+      outcomeCount,
+      payoutNumerators.map((n) => new anchor4__namespace.BN(n))
+    ).accounts({
+      reporter: this.walletPubkey,
+      oracleConfig,
+      questionResult: questionResultPda,
+      condition: conditionPda,
+      conditionalTokensProgram: this.programIds.conditionalTokens,
+      payer: payer ?? this.walletPubkey,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers(signers).rpc();
+    return { signature: sig };
+  }
+  /** Owner updates the admin. */
+  async updateAdmin(newAdmin, ownerPubkey) {
+    const sig = await this.program.methods.updateAdmin(newAdmin).accounts({
+      owner: this.walletPubkey,
+      oracleConfig: this.configPda(ownerPubkey)
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Owner transfers ownership to a new keypair. */
+  async transferOwnership(newOwner, ownerPubkey) {
+    const sig = await this.program.methods.transferOwnership(newOwner).accounts({
+      owner: this.walletPubkey,
+      oracleConfig: this.configPda(ownerPubkey)
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Admin or owner pause/unpause the oracle. */
+  async pause(paused, ownerPubkey) {
+    const sig = await this.program.methods.pause(paused).accounts({
+      authority: this.walletPubkey,
+      oracleConfig: this.configPda(ownerPubkey)
+    }).rpc();
+    return { signature: sig };
+  }
+  // ─── Queries ─────────────────────────────────────────────────────────────────
+  async fetchConfig(owner) {
+    try {
+      const acc = await this.program.account.oracleConfig.fetch(
+        this.configPda(owner ?? this.walletPubkey)
+      );
+      return {
+        owner: acc.owner,
+        admin: acc.admin,
+        questionCount: acc.questionCount.toNumber(),
+        whitelist: acc.whitelist,
+        whitelistLen: acc.whitelistLen,
+        isPaused: acc.isPaused,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchQuestionResult(questionId, ownerPubkey) {
+    try {
+      const oracleConfig = this.configPda(ownerPubkey);
+      const [pda] = PDA.questionResult(oracleConfig, questionId, this.programIds);
+      const acc = await this.program.account.questionResult.fetch(pda);
+      return {
+        oracleConfig: acc.oracleConfig,
+        questionId: new Uint8Array(acc.questionId),
+        outcomeIndex: acc.outcomeIndex,
+        outcomeCount: acc.outcomeCount,
+        payoutNumerators: acc.payoutNumerators,
+        isResolved: acc.isResolved,
+        resolvedAt: acc.resolvedAt.toNumber(),
+        reporter: acc.reporter,
+        condition: acc.condition ?? null,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+var HookClient = class {
+  constructor(program, provider, programIds) {
+    this.program = program;
+    this.provider = provider;
+    this.programIds = programIds;
+  }
+  get walletPubkey() {
+    return this.provider.wallet.publicKey;
+  }
+  configPda() {
+    return PDA.hookConfig(this.programIds)[0];
+  }
+  // ─── Instructions ────────────────────────────────────────────────────────────
+  /** One-time setup. Caller becomes owner. */
+  async initialize(initialWhitelist) {
+    const sig = await this.program.methods.initializeHookConfig(initialWhitelist).accounts({
+      owner: this.walletPubkey,
+      hookConfig: this.configPda(),
+      systemProgram: web3_js.SystemProgram.programId
+    }).rpc();
+    return { signature: sig };
+  }
+  /**
+   * Register extra account metas for a Token-2022 YES/NO mint.
+   * Must be called once per mint after CTF creates it.
+   */
+  async initializeExtraAccountMetaList(mint) {
+    const [extraAccountMetaList] = PDA.extraAccountMetaList(mint, this.programIds);
+    const sig = await this.program.methods.initializeExtraAccountMetaList().accounts({
+      payer: this.walletPubkey,
+      extraAccountMetaList,
+      mint,
+      hookConfig: this.configPda(),
+      tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Owner adds a program to the transfer whitelist. */
+  async addToWhitelist(program) {
+    const sig = await this.program.methods.addToWhitelist(program).accounts({
+      owner: this.walletPubkey,
+      hookConfig: this.configPda()
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Owner removes a program from the transfer whitelist. */
+  async removeFromWhitelist(program) {
+    const sig = await this.program.methods.removeFromWhitelist(program).accounts({
+      owner: this.walletPubkey,
+      hookConfig: this.configPda()
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Permanently freeze the whitelist — no further changes allowed. */
+  async freezeWhitelist() {
+    const sig = await this.program.methods.freezeWhitelist().accounts({
+      owner: this.walletPubkey,
+      hookConfig: this.configPda()
+    }).rpc();
+    return { signature: sig };
+  }
+  /**
+   * SPL Transfer-Hook `execute` — invoked automatically by Token-2022 on every
+   * YES/NO token transfer. Validates the destination against the whitelist.
+   *
+   * Calling this directly is useful for:
+   * - Off-chain simulation ("would this transfer be allowed?")
+   * - Integration tests that verify whitelist enforcement
+   *
+   * Token-2022 calls this automatically; you normally don't call it manually.
+   *
+   * @param sourceToken      - Source token account (tokens leaving)
+   * @param mint             - The YES/NO Token-2022 mint
+   * @param destinationToken - Destination token account (tokens arriving)
+   * @param owner            - Authority that authorized the transfer
+   * @param amount           - Token amount being transferred
+   */
+  async execute(sourceToken, mint, destinationToken, owner, amount) {
+    const [extraAccountMetaList] = PDA.extraAccountMetaList(mint, this.programIds);
+    const sig = await this.program.methods.execute(amount).accounts({
+      sourceToken,
+      mint,
+      destinationToken,
+      owner,
+      extraAccountMetaList,
+      hookConfig: this.configPda()
+    }).rpc();
+    return { signature: sig };
+  }
+  // ─── Queries ─────────────────────────────────────────────────────────────────
+  async fetchConfig() {
+    try {
+      const acc = await this.program.account.hookConfig.fetch(this.configPda());
+      return {
+        owner: acc.owner,
+        whitelist: acc.whitelist,
+        whitelistLen: acc.whitelistLen,
+        isFrozen: acc.isFrozen,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async isWhitelisted(program) {
+    const config = await this.fetchConfig();
+    if (!config) return false;
+    return config.whitelist.some((p) => p.equals(program));
+  }
+};
+
+// src/types.ts
+var QuestionStatus = /* @__PURE__ */ ((QuestionStatus2) => {
+  QuestionStatus2["Pending"] = "pending";
+  QuestionStatus2["Approved"] = "approved";
+  QuestionStatus2["Rejected"] = "rejected";
+  QuestionStatus2["Resolved"] = "resolved";
+  return QuestionStatus2;
+})(QuestionStatus || {});
+var XMarketError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "XMarketError";
+  }
+};
+var UnauthorizedError = class extends XMarketError {
+  constructor(msg = "Unauthorized") {
+    super(msg, "UNAUTHORIZED");
+    this.name = "UnauthorizedError";
+  }
+};
+var AccountNotFoundError = class extends XMarketError {
+  constructor(account, address) {
+    super(`${account} not found${address ? `: ${address}` : ""}`, "NOT_FOUND");
+    this.name = "AccountNotFoundError";
+  }
+};
+var InvalidParamError = class extends XMarketError {
+  constructor(msg = "Invalid parameter") {
+    super(msg, "INVALID_PARAM");
+    this.name = "InvalidParamError";
+  }
+};
+
+// src/programs/market.ts
+var MarketClient = class {
+  constructor(program, provider, programIds, ownerPubkey) {
+    this.program = program;
+    this.provider = provider;
+    this.programIds = programIds;
+    this.configPda = PDA.questionMarketConfig(ownerPubkey, programIds)[0];
+  }
+  get walletPubkey() {
+    return this.provider.wallet.publicKey;
+  }
+  // ─── Instructions (return Transaction — caller signs + sends) ───────────────
+  async initialize(admin, oracle, owner = this.walletPubkey) {
+    return this.program.methods.initialize({
+      admin,
+      conditionalTokensProgram: this.programIds.conditionalTokens,
+      oracle
+    }).accounts({
+      owner,
+      config: this.configPda,
+      systemProgram: web3_js.SystemProgram.programId
+    }).transaction();
+  }
+  /**
+   * Build createQuestion transaction.
+   * @param payer   - Pays rent for all new accounts (can differ from creator)
+   * @param creator - Identity of the question creator (signs but does not pay)
+   */
+  async createQuestion(params, oracle, creator = this.walletPubkey, payer = creator) {
+    const questionId = params.questionId ?? generateQuestionId(params.content);
+    const contentHash = params.contentHash ?? generateContentHash(params.content);
+    const [questionPda] = PDA.question(this.configPda, questionId, this.programIds);
+    const [conditionPda] = PDA.condition(oracle, questionId, this.programIds);
+    const [yesMint] = PDA.yesMint(conditionPda, this.programIds);
+    const [noMint] = PDA.noMint(conditionPda, this.programIds);
+    const [mintAuthority] = PDA.mintAuthority(conditionPda, this.programIds);
+    const [collateralVault] = PDA.collateralVault(params.collateralMint, this.programIds);
+    const tx = await this.program.methods.createQuestionWithCondition({
+      questionId: Array.from(questionId),
+      contentHash: Array.from(contentHash),
+      hookProgram: params.hookProgram,
+      authorizedClob: params.authorizedClob,
+      expirationTime: new anchor4__namespace.BN(params.expirationTime)
+    }).accounts({
+      payer,
+      creator,
+      config: this.configPda,
+      question: questionPda,
+      currencyMint: params.collateralMint,
+      oracle,
+      condition: conditionPda,
+      yesMint,
+      noMint,
+      mintAuthority,
+      collateralVault,
+      conditionalTokensProgram: this.programIds.conditionalTokens,
+      tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId,
+      rent: web3_js.SYSVAR_RENT_PUBKEY
+    }).transaction();
+    return { tx, questionPda, conditionPda, questionId };
+  }
+  /**
+   * Build createQuestionAdmin transaction (whitelist/admin path — status = Approved immediately).
+   * @param creator - Whitelisted creator (must be in whitelist or be admin/owner)
+   * @param payer   - Fee payer (pays rent; can differ from creator)
+   */
+  async createQuestionAdmin(params, oracle, creator = this.walletPubkey, payer = creator) {
+    const questionId = params.questionId ?? generateQuestionId(params.content);
+    const contentHash = params.contentHash ?? generateContentHash(params.content);
+    const [questionPda] = PDA.question(this.configPda, questionId, this.programIds);
+    const [conditionPda] = PDA.condition(oracle, questionId, this.programIds);
+    const [yesMint] = PDA.yesMint(conditionPda, this.programIds);
+    const [noMint] = PDA.noMint(conditionPda, this.programIds);
+    const [mintAuthority] = PDA.mintAuthority(conditionPda, this.programIds);
+    const [collateralVault] = PDA.collateralVault(params.collateralMint, this.programIds);
+    const tx = await this.program.methods.createQuestionAdmin({
+      questionId: Array.from(questionId),
+      contentHash: Array.from(contentHash),
+      hookProgram: params.hookProgram,
+      authorizedClob: params.authorizedClob,
+      expirationTime: new anchor4__namespace.BN(params.expirationTime)
+    }).accounts({
+      creator,
+      payer,
+      config: this.configPda,
+      question: questionPda,
+      currencyMint: params.collateralMint,
+      oracle,
+      condition: conditionPda,
+      yesMint,
+      noMint,
+      mintAuthority,
+      collateralVault,
+      conditionalTokensProgram: this.programIds.conditionalTokens,
+      tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId,
+      rent: web3_js.SYSVAR_RENT_PUBKEY
+    }).transaction();
+    return { tx, questionPda, conditionPda, questionId };
+  }
+  async approveQuestion(questionPda, admin = this.walletPubkey, payer = admin) {
+    return this.program.methods.approveQuestion().accounts({
+      admin,
+      payer,
+      config: this.configPda,
+      question: questionPda
+    }).transaction();
+  }
+  async updateConfig(params, authority = this.walletPubkey, payer = authority) {
+    return this.program.methods.updateConfig({
+      newAdmin: params.newAdmin ?? null,
+      newOracle: params.newOracle ?? null,
+      isPaused: params.isPaused ?? null,
+      newConditionalTokensProgram: params.newConditionalTokensProgram ?? null
+    }).accounts({
+      authority,
+      payer,
+      config: this.configPda
+    }).transaction();
+  }
+  /** Set the admin (owner only). Replaces any existing admin. */
+  async addAdmin(newAdmin, owner = this.walletPubkey) {
+    return this.program.methods.addAdmin(newAdmin).accounts({
+      owner,
+      config: this.configPda
+    }).transaction();
+  }
+  /** Clear the admin (owner only). Sets admin to default pubkey. */
+  async removeAdmin(owner = this.walletPubkey) {
+    return this.program.methods.removeAdmin().accounts({
+      owner,
+      config: this.configPda
+    }).transaction();
+  }
+  async addToWhitelist(address, authority = this.walletPubkey, payer = authority) {
+    return this.program.methods.addToWhitelist(address).accounts({
+      authority,
+      payer,
+      config: this.configPda
+    }).transaction();
+  }
+  async removeFromWhitelist(address, authority = this.walletPubkey, payer = authority) {
+    return this.program.methods.removeFromWhitelist(address).accounts({
+      authority,
+      payer,
+      config: this.configPda
+    }).transaction();
+  }
+  // ─── Queries ─────────────────────────────────────────────────────────────────
+  async fetchConfig() {
+    try {
+      const acc = await this.program.account.questionMarketConfig.fetch(this.configPda);
+      return {
+        owner: acc.owner,
+        admin: acc.admin,
+        oracle: acc.oracle,
+        conditionalTokensProgram: acc.conditionalTokensProgram,
+        questionCount: acc.questionCount.toNumber(),
+        approvedCount: acc.approvedCount.toNumber(),
+        rejectedCount: acc.rejectedCount.toNumber(),
+        whitelist: acc.whitelist,
+        whitelistLen: acc.whitelistLen,
+        isPaused: acc.isPaused,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchQuestion(questionPda) {
+    try {
+      const acc = await this.program.account.question.fetch(questionPda);
+      return {
+        config: acc.config,
+        questionId: new Uint8Array(acc.questionId),
+        contentHash: new Uint8Array(acc.contentHash),
+        expirationTime: acc.expirationTime.toNumber(),
+        currencyMint: acc.currencyMint,
+        creator: acc.creator,
+        condition: acc.condition ?? null,
+        status: this._parseStatus(acc.status),
+        createdAt: acc.createdAt.toNumber(),
+        approvedAt: acc.approvedAt.toNumber(),
+        resolvedAt: acc.resolvedAt.toNumber(),
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  questionPda(questionId) {
+    return PDA.question(this.configPda, questionId, this.programIds)[0];
+  }
+  _parseStatus(raw) {
+    if (raw.pending !== void 0) return "pending" /* Pending */;
+    if (raw.approved !== void 0) return "approved" /* Approved */;
+    if (raw.rejected !== void 0) return "rejected" /* Rejected */;
+    if (raw.resolved !== void 0) return "resolved" /* Resolved */;
+    return "pending" /* Pending */;
+  }
+  /**
+   * Convenience: fetch YES and NO token balances for a question.
+   * Returns null for each if question not approved or position not initialized.
+   * Requires ctfClient to be injected (done automatically by XMarketSDK).
+   */
+  async fetchQuestionBalances(questionPda, owner) {
+    if (!this.ctfClient) return { yes: null, no: null };
+    const q = await this.fetchQuestion(questionPda);
+    if (!q || !q.condition) return { yes: null, no: null };
+    return this.ctfClient.fetchBothPositions(q.condition, owner);
+  }
+};
+var CtfClient = class {
+  constructor(program, provider, programIds) {
+    this.program = program;
+    this.provider = provider;
+    this.programIds = programIds;
+  }
+  get walletPubkey() {
+    return this.provider.wallet.publicKey;
+  }
+  // ─── Instructions ────────────────────────────────────────────────────────────
+  /**
+   * Create a Condition directly (bypasses QuestionMarket).
+   * oracle is UncheckedAccount — set it to any pubkey (e.g. user wallet)
+   * so that wallet can later sign reportPayouts.
+   * payer covers rent for condition + mints.
+   */
+  async prepareCondition(questionId, oracle, collateralMint, hookProgram, authorizedClob, payer = this.walletPubkey, signers = []) {
+    const [conditionPda] = PDA.condition(oracle, questionId, this.programIds);
+    const [yesMint] = PDA.yesMint(conditionPda, this.programIds);
+    const [noMint] = PDA.noMint(conditionPda, this.programIds);
+    const [mintAuthority] = PDA.mintAuthority(conditionPda, this.programIds);
+    const [collateralVault] = PDA.collateralVault(collateralMint, this.programIds);
+    const sig = await this.program.methods.prepareCondition(
+      Array.from(questionId),
+      hookProgram,
+      authorizedClob
+    ).accounts({
+      oracle,
+      condition: conditionPda,
+      yesMint,
+      noMint,
+      mintAuthority,
+      collateralMint,
+      collateralVault,
+      payer,
+      tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId,
+      rent: web3_js.SYSVAR_RENT_PUBKEY
+    }).signers(signers).rpc({ skipPreflight: true });
+    return { signature: sig, conditionPda, yesMint, noMint };
+  }
+  /** One-time setup. Caller becomes the CTF owner. Can only be called once. */
+  async initializeCtfConfig() {
+    const [ctfConfig] = PDA.ctfConfig(this.programIds);
+    const sig = await this.program.methods.initializeCtfConfig().accounts({
+      payer: this.walletPubkey,
+      ctfConfig,
+      systemProgram: web3_js.SystemProgram.programId
+    }).rpc();
+    return { signature: sig };
+  }
+  /**
+   * Create the shared collateral vault for a given collateral mint (e.g. USDC).
+   * Only callable by the CTF owner (as stored in ctf_config).
+   * authority defaults to the wallet — pass a different signer if needed.
+   */
+  async initializeVault(collateralMint) {
+    const [ctfConfig] = PDA.ctfConfig(this.programIds);
+    const [collateralVault] = PDA.collateralVault(collateralMint, this.programIds);
+    const [vaultTokenAccount] = PDA.vaultToken(collateralMint, this.programIds);
+    const sig = await this.program.methods.initializeVault().accounts({
+      authority: this.walletPubkey,
+      payer: this.walletPubkey,
+      ctfConfig,
+      collateralMint,
+      collateralVault,
+      vaultTokenAccount,
+      systemProgram: web3_js.SystemProgram.programId,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      rent: web3_js.SYSVAR_RENT_PUBKEY
+    }).rpc();
+    return { signature: sig };
+  }
+  /**
+   * Initialize an empty Position account (balance = 0) for a user.
+   * Needed before redeemPositions when the user only holds the opposite outcome
+   * (e.g. buyer received YES via CLOB match but never had a NO position).
+   *
+   * Idempotent — call `fetchPosition` first to skip if already initialized.
+   */
+  async initPosition(condition, outcomeIndex, user = this.walletPubkey) {
+    const [position] = PDA.position(condition, outcomeIndex, user, this.programIds);
+    const sig = await this.program.methods.initPosition(outcomeIndex).accounts({
+      user,
+      condition,
+      position,
+      systemProgram: web3_js.SystemProgram.programId
+    }).rpc();
+    return { signature: sig };
+  }
+  /**
+   * Split `amount` collateral into equal YES + NO tokens.
+   * ATAs created automatically via `init_if_needed`.
+   */
+  async splitPosition(condition, collateralMint, amount, user = this.walletPubkey, payer = this.walletPubkey, signers = []) {
+    const [collateralVault] = PDA.collateralVault(collateralMint, this.programIds);
+    const [vaultTokenAccount] = PDA.vaultToken(collateralMint, this.programIds);
+    const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [noMint] = PDA.noMint(condition, this.programIds);
+    const [mintAuthority] = PDA.mintAuthority(condition, this.programIds);
+    const [yesPosition] = PDA.position(condition, 1, user, this.programIds);
+    const [noPosition] = PDA.position(condition, 0, user, this.programIds);
+    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);
+    const sig = await this.program.methods.splitPosition(amount).accounts({
+      user,
+      payer,
+      condition,
+      collateralVault,
+      vaultTokenAccount,
+      userCollateral,
+      yesMint,
+      userYesAta,
+      noMint,
+      userNoAta,
+      yesPosition,
+      noPosition,
+      mintAuthority,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
+      associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers(signers).rpc({ skipPreflight: true });
+    return { signature: sig };
+  }
+  /**
+   * Merge `amount` YES + NO tokens back into collateral.
+   * Both token balances must be ≥ amount.
+   */
+  async mergePosition(condition, collateralMint, amount, user = this.walletPubkey, payer = this.walletPubkey, signers = []) {
+    const [collateralVault] = PDA.collateralVault(collateralMint, this.programIds);
+    const [vaultTokenAccount] = PDA.vaultToken(collateralMint, this.programIds);
+    const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [noMint] = PDA.noMint(condition, this.programIds);
+    const [yesPosition] = PDA.position(condition, 1, user, this.programIds);
+    const [noPosition] = PDA.position(condition, 0, user, this.programIds);
+    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);
+    const sig = await this.program.methods.mergePosition(amount).accounts({
+      user,
+      payer,
+      condition,
+      collateralVault,
+      vaultTokenAccount,
+      userCollateral,
+      yesMint,
+      userYesAta,
+      noMint,
+      userNoAta,
+      yesPosition,
+      noPosition,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers(signers).rpc({ skipPreflight: true });
+    return { signature: sig };
+  }
+  /**
+   * After condition resolves: burn outcome tokens proportional to payout
+   * and receive USDC. Works for winning, losing, or both positions.
+   */
+  async redeemPositions(condition, collateralMint, user = this.walletPubkey, payer = this.walletPubkey, signers = []) {
+    const [collateralVault] = PDA.collateralVault(collateralMint, this.programIds);
+    const [vaultTokenAccount] = PDA.vaultToken(collateralMint, this.programIds);
+    const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [noMint] = PDA.noMint(condition, this.programIds);
+    const [yesPosition] = PDA.position(condition, 1, user, this.programIds);
+    const [noPosition] = PDA.position(condition, 0, user, this.programIds);
+    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);
+    const sig = await this.program.methods.redeemPositions().accounts({
+      user,
+      payer,
+      condition,
+      collateralVault,
+      vaultTokenAccount,
+      userCollateral,
+      yesMint,
+      userYesAta,
+      noMint,
+      userNoAta,
+      yesPosition,
+      noPosition,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).signers(signers).rpc({ skipPreflight: true });
+    return { signature: sig };
+  }
+  /**
+   * 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({
+      oracle: this.walletPubkey,
+      condition
+    }).rpc();
+    return { signature: sig };
+  }
+  /**
+   * Build the `transfer_position` instruction for use in a CLOB CPI.
+   *
+   * This instruction requires `clob_authority` (the CLOB's PDA) to sign.
+   * A PDA can only sign from within its own program via CPI — this method
+   * CANNOT be called directly from a wallet transaction.
+   *
+   * Use-cases:
+   * - Custom CLOB implementations that call CTF.transfer_position via CPI
+   * - Anchor CPI builders in other Rust programs
+   *
+   * @param condition       - Condition PDA
+   * @param outcomeMint     - YES or NO mint
+   * @param fromUser        - Source wallet
+   * @param fromTokenAccount - Source ATA
+   * @param fromPosition    - Source Position PDA
+   * @param toUser          - Destination wallet
+   * @param toTokenAccount  - Destination ATA (created if needed — payer covers rent)
+   * @param toPosition      - Destination Position PDA
+   * @param payer           - Pays rent for toPosition + toTokenAccount creation
+   * @param clobAuthority   - CLOB config PDA (must sign via CPI)
+   * @param outcomeIndex    - 0 = NO, 1 = YES
+   * @param amount          - Token amount to transfer
+   */
+  async transferPositionIx(condition, outcomeMint, fromUser, fromTokenAccount, fromPosition, toUser, toTokenAccount, toPosition, payer, clobAuthority, outcomeIndex, amount) {
+    return this.program.methods.transferPosition(outcomeIndex, amount).accounts({
+      payer,
+      clobAuthority,
+      condition,
+      outcomeMint,
+      fromUser,
+      fromTokenAccount,
+      fromPosition,
+      toUser,
+      toTokenAccount,
+      toPosition,
+      token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).instruction();
+  }
+  /**
+   * Update the authorized CLOB on a condition.
+   * Only callable by the condition's oracle (the wallet that signed createQuestion).
+   */
+  async updateAuthorizedClob(condition, newAuthorizedClob) {
+    const sig = await this.program.methods.updateAuthorizedClob(newAuthorizedClob).accounts({
+      oracle: this.walletPubkey,
+      condition
+    }).rpc();
+    return { signature: sig };
+  }
+  // ─── Queries ─────────────────────────────────────────────────────────────────
+  async fetchCtfConfig() {
+    try {
+      const [ctfConfig] = PDA.ctfConfig(this.programIds);
+      const acc = await this.program.account.ctfConfig.fetch(ctfConfig);
+      return {
+        owner: acc.owner,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchCondition(conditionPda) {
+    try {
+      const acc = await this.program.account.condition.fetch(conditionPda);
+      return {
+        oracle: acc.oracle,
+        questionId: new Uint8Array(acc.questionId),
+        outcomeSlotCount: acc.outcomeSlotCount,
+        payoutNumerators: acc.payoutNumerators,
+        payoutDenominator: acc.payoutDenominator,
+        totalCollateral: acc.totalCollateral,
+        collateralMint: acc.collateralMint,
+        collateralVault: acc.collateralVault,
+        yesMint: acc.yesMint,
+        noMint: acc.noMint,
+        hookProgram: acc.hookProgram,
+        authorizedClob: acc.authorizedClob,
+        isResolved: acc.isResolved,
+        resolvedAt: acc.resolvedAt?.toNumber() ?? 0,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchVault(collateralMint) {
+    try {
+      const [vaultPda] = PDA.collateralVault(collateralMint, this.programIds);
+      const acc = await this.program.account.collateralVault.fetch(vaultPda);
+      return {
+        collateralMint: acc.collateralMint,
+        vaultTokenAccount: acc.vaultTokenAccount,
+        totalLocked: acc.totalLocked,
+        conditionCount: acc.conditionCount,
+        bump: acc.bump,
+        vaultBump: acc.vaultBump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchPosition(condition, outcomeIndex, owner = this.walletPubkey) {
+    try {
+      const [pda] = PDA.position(condition, outcomeIndex, owner, this.programIds);
+      const acc = await this.program.account.position.fetch(pda);
+      return {
+        owner: acc.owner,
+        condition: acc.condition,
+        outcomeIndex: acc.outcomeIndex,
+        balance: acc.balance,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  /** YES = outcome index 1, NO = outcome index 0. */
+  async fetchBothPositions(condition, owner = this.walletPubkey) {
+    const [yes, no] = await Promise.all([
+      this.fetchPosition(condition, 1, owner),
+      this.fetchPosition(condition, 0, owner)
+    ]);
+    return { yes, no };
+  }
+  /** Thin wrapper: fetch position for a single outcome token (0=NO, 1=YES). */
+  async fetchTokenBalance(condition, tokenId, owner = this.walletPubkey) {
+    return this.fetchPosition(condition, tokenId, owner);
+  }
+  // ─── PDA helpers (public for consumers) ──────────────────────────────────────
+  yesMintPda(condition) {
+    return PDA.yesMint(condition, this.programIds)[0];
+  }
+  noMintPda(condition) {
+    return PDA.noMint(condition, this.programIds)[0];
+  }
+  mintAuthorityPda(condition) {
+    return PDA.mintAuthority(condition, this.programIds)[0];
+  }
+  collateralVaultPda(collateralMint) {
+    return PDA.collateralVault(collateralMint, this.programIds)[0];
+  }
+};
+function serializeOrderToBytes(order) {
+  const buf = new Uint8Array(178);
+  buf.set(order.maker.toBytes(), 0);
+  buf.set(order.condition.toBytes(), 32);
+  buf[64] = order.tokenId;
+  buf[65] = order.side;
+  buf.set(order.makerAmount.toArrayLike(Buffer, "le", 8), 66);
+  buf.set(order.takerAmount.toArrayLike(Buffer, "le", 8), 74);
+  buf.set(order.nonce.toArrayLike(Buffer, "le", 8), 82);
+  buf.set(order.expiry.toArrayLike(Buffer, "le", 8), 90);
+  buf.set(order.createdAt.toArrayLike(Buffer, "le", 8), 98);
+  buf.set(order.fee.toArrayLike(Buffer, "le", 8), 106);
+  buf.set(order.taker.toBytes(), 114);
+  buf.set(order.signer.toBytes(), 146);
+  return buf;
+}
+async function signOrder(order, signFn) {
+  const message = serializeOrderToBytes(order);
+  const signature = await signFn(message);
+  if (signature.length !== 64) throw new Error("signature must be 64 bytes");
+  return { order, signature };
+}
+function buildBatchedEd25519Instruction(orders) {
+  const N = orders.length;
+  if (N === 0) throw new Error("At least 1 order required");
+  const MSG_SIZE = 178;
+  const SIG_SIZE = 64;
+  const PK_SIZE = 32;
+  const HEADER = 2 + N * 14;
+  const sigBase = HEADER;
+  const pkBase = sigBase + N * SIG_SIZE;
+  const msgBase = pkBase + N * PK_SIZE;
+  const totalSize = msgBase + N * MSG_SIZE;
+  const data = Buffer.alloc(totalSize);
+  data[0] = N;
+  data[1] = 0;
+  for (let i = 0; i < N; i++) {
+    const e = 2 + i * 14;
+    data.writeUInt16LE(sigBase + i * SIG_SIZE, e);
+    data.writeUInt16LE(65535, e + 2);
+    data.writeUInt16LE(pkBase + i * PK_SIZE, e + 4);
+    data.writeUInt16LE(65535, e + 6);
+    data.writeUInt16LE(msgBase + i * MSG_SIZE, e + 8);
+    data.writeUInt16LE(MSG_SIZE, e + 10);
+    data.writeUInt16LE(65535, e + 12);
+    data.set(orders[i].signature, sigBase + i * SIG_SIZE);
+    data.set(orders[i].order.maker.toBytes(), pkBase + i * PK_SIZE);
+    data.set(serializeOrderToBytes(orders[i].order), msgBase + i * MSG_SIZE);
+  }
+  return new web3_js.TransactionInstruction({
+    keys: [],
+    programId: web3_js.Ed25519Program.programId,
+    data
+  });
+}
+var IX_SYSVAR = web3_js.SYSVAR_INSTRUCTIONS_PUBKEY;
+
+// src/programs/clob.ts
+var CLOB_WHITELIST_SEED = Buffer.from("clob_whitelist");
+var ClobClient = class {
+  constructor(program, provider, programIds) {
+    this.program = program;
+    this.provider = provider;
+    this.programIds = programIds;
+  }
+  get walletPubkey() {
+    return this.provider.wallet.publicKey;
+  }
+  /**
+   * 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).
+   */
+  async _sendMatchTx(instructions, lookupTable, whitelistedWallet) {
+    const { connection } = this.provider;
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    const message = new web3_js.TransactionMessage({
+      payerKey: this.walletPubkey,
+      recentBlockhash: blockhash,
+      instructions
+    }).compileToV0Message(lookupTable ? [lookupTable] : []);
+    const vtx = new web3_js.VersionedTransaction(message);
+    const signers = [this.provider.wallet.payer];
+    if (whitelistedWallet && !whitelistedWallet.publicKey.equals(this.walletPubkey)) {
+      signers.push(whitelistedWallet.payer);
+    }
+    vtx.sign(signers);
+    const sig = await connection.sendRawTransaction(vtx.serialize(), {
+      skipPreflight: false
+    });
+    await connection.confirmTransaction(
+      { signature: sig, blockhash, lastValidBlockHeight },
+      "confirmed"
+    );
+    return sig;
+  }
+  /** PDA for a CLOB whitelist entry. */
+  whitelistEntryPda(address) {
+    return web3_js.PublicKey.findProgramAddressSync(
+      [CLOB_WHITELIST_SEED, address.toBytes()],
+      this.programIds.clobExchange
+    )[0];
+  }
+  configPda() {
+    return PDA.clobConfig(this.programIds)[0];
+  }
+  // ─── Instructions ────────────────────────────────────────────────────────────
+  /** One-time setup. Caller becomes admin. */
+  async initialize(operators, feeRecipient, feeRateBps) {
+    const sig = await this.program.methods.initializeClob(
+      operators,
+      feeRecipient,
+      feeRateBps,
+      this.programIds.conditionalTokens
+    ).accounts({
+      owner: this.walletPubkey,
+      clobConfig: this.configPda(),
+      systemProgram: web3_js.SystemProgram.programId
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Admin adds an operator to the whitelist. */
+  async addOperator(operator) {
+    const sig = await this.program.methods.addOperator(operator).accounts({
+      owner: this.walletPubkey,
+      clobConfig: this.configPda()
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Admin removes an operator from the whitelist. */
+  async removeOperator(operator) {
+    const sig = await this.program.methods.removeOperator(operator).accounts({
+      owner: this.walletPubkey,
+      clobConfig: this.configPda()
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Admin pause/unpause the CLOB. */
+  async setPaused(paused) {
+    const sig = await this.program.methods.setPaused(paused).accounts({
+      owner: this.walletPubkey,
+      clobConfig: this.configPda()
+    }).rpc();
+    return { signature: sig };
+  }
+  /**
+   * Maker cancels their own order.
+   * OrderStatus PDA is marked cancelled — any future fill rejected.
+   */
+  async cancelOrder(nonce) {
+    const maker = this.walletPubkey;
+    const [orderStatus] = PDA.orderStatus(maker, nonce, this.programIds);
+    const sig = await this.program.methods.cancelOrder(nonce).accounts({
+      signer: maker,
+      clobConfig: this.configPda(),
+      maker,
+      orderStatus,
+      systemProgram: web3_js.SystemProgram.programId
+    }).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,
+      programData,
+      clobConfig: this.configPda()
+    }).rpc();
+    return { signature: sig };
+  }
+  /**
+   * 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]
+   */
+  async matchComplementary(buySigned, makersSigned, collateralMint, feeRecipient, whitelistedWallet, lookupTable) {
+    const condition = buySigned.order.condition;
+    const tokenId = buySigned.order.tokenId;
+    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 [extraAccountMetaList] = PDA.extraAccountMetaList(outcomeMint, this.programIds);
+    const [hookConfig] = PDA.hookConfig(this.programIds);
+    const hookAccounts = [
+      { pubkey: extraAccountMetaList, isSigner: false, isWritable: false },
+      { 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 }
+      ];
+    });
+    const whitelisted = whitelistedWallet.publicKey;
+    const whitelistEntry = this.whitelistEntryPda(whitelisted);
+    const makerNonces = makersSigned.map((m) => m.order.nonce);
+    const ed25519Ixs = [
+      buildBatchedEd25519Instruction([buySigned, ...makersSigned])
+    ];
+    const matchIx = await this.program.methods.matchComplementary(buySigned.order.nonce, makerNonces).accounts({
+      whitelisted,
+      payer: this.walletPubkey,
+      whitelistEntry,
+      clobConfig: this.configPda(),
+      ixSysvar: IX_SYSVAR,
+      condition,
+      buyer,
+      buyerCollateral,
+      buyerTokenAccount,
+      buyerPosition,
+      buyOrderStatus,
+      outcomeMint,
+      feeRecipient,
+      conditionalTokensProgram: this.programIds.conditionalTokens,
+      tokenProgram: splToken.TOKEN_PROGRAM_ID,
+      token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).remainingAccounts([...hookAccounts, ...makerAccounts]).instruction();
+    const sig = await this._sendMatchTx(
+      [...ed25519Ixs, matchIx],
+      lookupTable,
+      whitelistedWallet
+    );
+    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[])
+   *
+   * remaining_accounts: [maker×5 × N]  (no hook accounts — mint_to doesn't fire hook)
+   */
+  async matchMintOrders(yesSigned, makersSigned, collateralMint, whitelistedWallet, lookupTable) {
+    const condition = yesSigned.order.condition;
+    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 [clobAuthority] = PDA.clobConfig(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 whitelisted = whitelistedWallet.publicKey;
+    const whitelistEntry = this.whitelistEntryPda(whitelisted);
+    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({
+      whitelisted,
+      payer: this.walletPubkey,
+      whitelistEntry,
+      clobConfig: this.configPda(),
+      ixSysvar: IX_SYSVAR,
+      condition,
+      buyerYes,
+      buyerYesCollateral,
+      buyerYesTokenAccount,
+      buyerYesPosition,
+      yesOrderStatus,
+      collateralVault,
+      vaultTokenAccount,
+      yesMint,
+      noMint,
+      mintAuthority,
+      clobAuthority,
+      conditionalTokensProgram: this.programIds.conditionalTokens,
+      collateralTokenProgram: splToken.TOKEN_PROGRAM_ID,
+      token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).remainingAccounts(makerAccounts).instruction();
+    const sig = await this._sendMatchTx(
+      [...ed25519Ixs, matchIx],
+      lookupTable,
+      whitelistedWallet
+    );
+    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[])
+   *
+   * remaining_accounts: [maker×5 × N]  (no hook accounts — burn doesn't fire hook)
+   */
+  async matchMergeOrders(yesSigned, makersSigned, collateralMint, whitelistedWallet, lookupTable) {
+    const condition = yesSigned.order.condition;
+    const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [noMint] = PDA.noMint(condition, this.programIds);
+    const [collateralVault] = PDA.collateralVault(collateralMint, this.programIds);
+    const [vaultTokenAccount] = PDA.vaultToken(collateralMint, this.programIds);
+    const [clobAuthority] = PDA.clobConfig(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 whitelisted = whitelistedWallet.publicKey;
+    const whitelistEntry = this.whitelistEntryPda(whitelisted);
+    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({
+      whitelisted,
+      payer: this.walletPubkey,
+      whitelistEntry,
+      clobConfig: this.configPda(),
+      ixSysvar: IX_SYSVAR,
+      condition,
+      sellerYes,
+      sellerYesTokenAccount,
+      sellerYesPosition,
+      sellerYesCollateral,
+      yesOrderStatus,
+      collateralVault,
+      vaultTokenAccount,
+      yesMint,
+      noMint,
+      clobAuthority,
+      conditionalTokensProgram: this.programIds.conditionalTokens,
+      collateralTokenProgram: splToken.TOKEN_PROGRAM_ID,
+      token2022Program: splToken.TOKEN_2022_PROGRAM_ID,
+      systemProgram: web3_js.SystemProgram.programId
+    }).remainingAccounts(makerAccounts).instruction();
+    const sig = await this._sendMatchTx(
+      [...ed25519Ixs, matchIx],
+      lookupTable,
+      whitelistedWallet
+    );
+    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
+   *
+   * All makers must have the same tokenId and side as makers[0].
+   */
+  async matchOrders(taker, makers, collateralMint, feeRecipient, whitelistedWallet, lookupTable) {
+    if (makers.length === 0) throw new InvalidParamError("At least 1 maker required");
+    const t = taker.order;
+    const m0 = makers[0].order;
+    const SIDE_BUY = 1;
+    const SIDE_SELL = 0;
+    if (t.tokenId === m0.tokenId) {
+      if (t.side === SIDE_BUY && makers.every((m) => m.order.side === SIDE_SELL)) {
+        return this.matchComplementary(taker, makers, collateralMint, feeRecipient, whitelistedWallet, lookupTable);
+      }
+      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);
+    const allSell = t.side === SIDE_SELL && makers.every((m) => m.order.side === SIDE_SELL);
+    if (!allBuy && !allSell) {
+      throw new InvalidParamError("MINT/MERGE: all orders must be the same side (all BUY or all SELL)");
+    }
+    if (t.tokenId !== 1) {
+      throw new InvalidParamError("MINT/MERGE: taker must be the YES side (tokenId=1)");
+    }
+    if (!makers.every((m) => m.order.tokenId === 0)) {
+      throw new InvalidParamError("MINT/MERGE: all makers must be the NO side (tokenId=0)");
+    }
+    if (allBuy) {
+      return this.matchMintOrders(taker, makers, collateralMint, whitelistedWallet, lookupTable);
+    }
+    return this.matchMergeOrders(taker, makers, collateralMint, whitelistedWallet, lookupTable);
+  }
+  // ─── Whitelist admin ─────────────────────────────────────────────────────────
+  /** Add an address to the CLOB whitelist (owner only). */
+  async addToWhitelist(address) {
+    const whitelistEntry = this.whitelistEntryPda(address);
+    const sig = await this.program.methods.addToClobWhitelist(address).accounts({
+      owner: this.walletPubkey,
+      payer: this.walletPubkey,
+      clobConfig: this.configPda(),
+      whitelistEntry,
+      systemProgram: web3_js.SystemProgram.programId
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Batch-add addresses to the CLOB whitelist (owner only). All PDAs created in one tx. */
+  async addToWhitelistBatch(addresses) {
+    if (addresses.length === 0) throw new InvalidParamError("At least 1 address required");
+    const remainingAccounts = addresses.map((addr) => ({
+      pubkey: this.whitelistEntryPda(addr),
+      isSigner: false,
+      isWritable: true
+    }));
+    const sig = await this.program.methods.addToClobWhitelistBatch(addresses).accounts({
+      owner: this.walletPubkey,
+      payer: this.walletPubkey,
+      clobConfig: this.configPda(),
+      systemProgram: web3_js.SystemProgram.programId
+    }).remainingAccounts(remainingAccounts).rpc();
+    return { signature: sig };
+  }
+  /** Remove an address from the CLOB whitelist (owner only). */
+  async removeFromWhitelist(address, rentReceiver) {
+    const whitelistEntry = this.whitelistEntryPda(address);
+    const sig = await this.program.methods.removeFromClobWhitelist(address).accounts({
+      owner: this.walletPubkey,
+      rentReceiver: rentReceiver ?? this.walletPubkey,
+      clobConfig: this.configPda(),
+      whitelistEntry
+    }).rpc();
+    return { signature: sig };
+  }
+  /** Fetch a whitelist entry PDA (returns null if address is not whitelisted). */
+  async fetchWhitelistEntry(address) {
+    try {
+      const pda = this.whitelistEntryPda(address);
+      const acc = await this.program.account.clobWhitelistEntry.fetch(pda);
+      return { address: acc.address, bump: acc.bump };
+    } catch {
+      return null;
+    }
+  }
+  /** Check if an address is on the CLOB whitelist. */
+  async isWhitelisted(address) {
+    return await this.fetchWhitelistEntry(address) !== null;
+  }
+  /** Fetch all whitelisted addresses (scans all ClobWhitelistEntry accounts). */
+  async fetchWhitelist() {
+    const entries = await this.program.account.clobWhitelistEntry.all();
+    return entries.map((e) => e.account.address);
+  }
+  // ─── Queries ─────────────────────────────────────────────────────────────────
+  async fetchConfig() {
+    try {
+      const acc = await this.program.account.clobConfig.fetch(this.configPda());
+      return {
+        owner: acc.owner,
+        operators: acc.operators,
+        operatorsLen: acc.operatorsLen,
+        feeRecipient: acc.feeRecipient,
+        feeRateBps: acc.feeRateBps,
+        conditionalTokensProgram: acc.conditionalTokensProgram,
+        isPaused: acc.isPaused,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchOrderStatus(maker, nonce) {
+    try {
+      const [pda] = PDA.orderStatus(maker, nonce, this.programIds);
+      const acc = await this.program.account.orderStatus.fetch(pda);
+      return {
+        maker: acc.maker,
+        nonce: acc.nonce,
+        isCancelled: acc.isCancelled,
+        filledAmount: acc.filledAmount,
+        bump: acc.bump
+      };
+    } catch {
+      return null;
+    }
+  }
+  async isOrderCancelled(maker, nonce) {
+    const status = await this.fetchOrderStatus(maker, nonce);
+    return status?.isCancelled === true;
+  }
+};
+var XMarketSDK = class _XMarketSDK {
+  constructor(config) {
+    this.networkConfig = typeof config.network === "string" ? NETWORK_CONFIGS[config.network] : config.network;
+    this.provider = new anchor4__namespace.AnchorProvider(
+      new web3_js.Connection(this.networkConfig.rpcUrl, "confirmed"),
+      config.wallet,
+      { commitment: "confirmed", preflightCommitment: "confirmed" }
+    );
+    anchor4__namespace.setProvider(this.provider);
+    this._programIds = this.networkConfig.programIds;
+    this._marketOwner = config.marketOwner ?? config.wallet.publicKey;
+  }
+  // ─── Lazy-initialised clients ─────────────────────────────────────────────
+  _withAddress(idl, address) {
+    return { ...idl, address: address.toBase58() };
+  }
+  /** Oracle program client */
+  get oracle() {
+    if (!this._oracle) {
+      const program = new anchor4__namespace.Program(this._withAddress(oracleIdl__default.default, this._programIds.oracle), this.provider);
+      this._oracle = new OracleClient(program, this.provider, this._programIds);
+    }
+    return this._oracle;
+  }
+  /** Transfer-hook program client */
+  get hook() {
+    if (!this._hook) {
+      const program = new anchor4__namespace.Program(this._withAddress(hookIdl__default.default, this._programIds.hook), this.provider);
+      this._hook = new HookClient(program, this.provider, this._programIds);
+    }
+    return this._hook;
+  }
+  /** QuestionMarket program client */
+  get market() {
+    if (!this._market) {
+      const program = new anchor4__namespace.Program(this._withAddress(questionMarketIdl__default.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;
+  }
+  /** Conditional tokens (CTF) program client */
+  get ctf() {
+    if (!this._ctf) {
+      const program = new anchor4__namespace.Program(this._withAddress(conditionalTokensIdl__default.default, this._programIds.conditionalTokens), this.provider);
+      this._ctf = new CtfClient(program, this.provider, this._programIds);
+    }
+    return this._ctf;
+  }
+  /** CLOB exchange program client */
+  get clob() {
+    if (!this._clob) {
+      const program = new anchor4__namespace.Program(this._withAddress(clobExchangeIdl__default.default, this._programIds.clobExchange), this.provider);
+      this._clob = new ClobClient(program, this.provider, this._programIds);
+    }
+    return this._clob;
+  }
+  // ─── Factory helpers ──────────────────────────────────────────────────────
+  /**
+   * Connect to devnet.
+   * ```ts
+   * const sdk = XMarketSDK.devnet(wallet);
+   * ```
+   */
+  static devnet(wallet, marketOwner) {
+    return new _XMarketSDK({ network: "devnet", wallet, marketOwner });
+  }
+  /**
+   * Connect to localhost test validator.
+   * ```ts
+   * const sdk = XMarketSDK.localnet(wallet);
+   * ```
+   */
+  static localnet(wallet, marketOwner) {
+    return new _XMarketSDK({ network: "localnet", wallet, marketOwner });
+  }
+  /**
+   * Connect to mainnet-beta.
+   * ```ts
+   * const sdk = XMarketSDK.mainnet(wallet);
+   * ```
+   */
+  static mainnet(wallet, marketOwner) {
+    return new _XMarketSDK({ network: "mainnet", wallet, marketOwner });
+  }
+  /**
+   * Custom network (e.g. custom RPC, custom program IDs for a fork).
+   * ```ts
+   * const sdk = XMarketSDK.custom({
+   *   name: "staging",
+   *   rpcUrl: "https://my-rpc.com",
+   *   programIds: { ... },
+   *   defaultCollateral: { mint: ..., decimals: 6 },
+   * }, wallet);
+   * ```
+   */
+  static custom(config, wallet, marketOwner) {
+    return new _XMarketSDK({ network: config, wallet, marketOwner });
+  }
+};
+function buildOrder(params) {
+  return {
+    maker: params.maker,
+    condition: params.condition,
+    tokenId: params.tokenId,
+    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),
+    taker: params.taker ?? new web3_js.PublicKey(new Uint8Array(32)),
+    signer: params.maker
+  };
+}
+function signOrderWithKeypair(order, keypair) {
+  const message = serializeOrderToBytes(order);
+  const signature = nacl__namespace.sign.detached(message, keypair.secretKey);
+  return { order, signature };
+}
+function getOrderSignBytes(order) {
+  return serializeOrderToBytes(order);
+}
+function serializeSignedOrder(signed) {
+  const orderBytes = serializeOrderToBytes(signed.order);
+  const buf = new Uint8Array(242);
+  buf.set(orderBytes, 0);
+  buf.set(signed.signature, 178);
+  return buf;
+}
+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 order = {
+    maker: readPubkey(0),
+    condition: readPubkey(32),
+    tokenId: bytes[64],
+    side: bytes[65],
+    makerAmount: readU64(66),
+    takerAmount: readU64(74),
+    nonce: readU64(82),
+    expiry: readI64(90),
+    createdAt: readI64(98),
+    fee: readU64(106),
+    taker: readPubkey(114),
+    signer: readPubkey(146)
+  };
+  const signature = bytes.slice(178, 242);
+  return { order, signature };
+}
+function verifySignedOrder(signed) {
+  const message = serializeOrderToBytes(signed.order);
+  return nacl__namespace.sign.detached.verify(
+    message,
+    signed.signature,
+    signed.order.signer.toBytes()
+  );
+}
+function detectMatchType(a, b) {
+  const _a = "order" in a ? a.order : a;
+  const _b = "order" in b ? b.order : b;
+  return _detectMatchType(_a, _b);
+}
+function _detectMatchType(a, b) {
+  const SIDE_BUY = 1;
+  if (a.tokenId === b.tokenId) {
+    const aBuy2 = a.side === SIDE_BUY;
+    const bBuy2 = b.side === SIDE_BUY;
+    if (aBuy2 !== bBuy2) return "COMPLEMENTARY";
+    throw new InvalidParamError(
+      "Orders with same tokenId must be one BUY and one SELL (COMPLEMENTARY)"
+    );
+  }
+  const aBuy = a.side === SIDE_BUY;
+  const bBuy = b.side === SIDE_BUY;
+  if (aBuy && bBuy) return "MINT";
+  if (!aBuy && !bBuy) return "MERGE";
+  throw new InvalidParamError(
+    "Orders with different tokenIds must both be BUY (MINT) or both SELL (MERGE)"
+  );
+}
+var MAX_APPROVE_AMOUNT = new BN4__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(
+    ownerAta,
+    delegate,
+    signer,
+    BigInt(amount.toString()),
+    [],
+    splToken.TOKEN_PROGRAM_ID
+  );
+  const tx = new web3_js.Transaction();
+  tx.feePayer = payer;
+  tx.add(approveIx);
+  return tx;
+}
+function buildApproveAllOutcomeTokensTx(condition, signer, payer, delegate, programIds, amount = MAX_APPROVE_AMOUNT) {
+  const [yesMint] = PDA.yesMint(condition, programIds);
+  const [noMint] = PDA.noMint(condition, programIds);
+  const yesAta = splToken.getAssociatedTokenAddressSync(yesMint, signer, false, splToken.TOKEN_2022_PROGRAM_ID);
+  const noAta = splToken.getAssociatedTokenAddressSync(noMint, signer, false, splToken.TOKEN_2022_PROGRAM_ID);
+  const amountBig = BigInt(amount.toString());
+  const approveYesIx = splToken.createApproveInstruction(
+    yesAta,
+    delegate,
+    signer,
+    amountBig,
+    [],
+    splToken.TOKEN_2022_PROGRAM_ID
+  );
+  const approveNoIx = splToken.createApproveInstruction(
+    noAta,
+    delegate,
+    signer,
+    amountBig,
+    [],
+    splToken.TOKEN_2022_PROGRAM_ID
+  );
+  const tx = new web3_js.Transaction();
+  tx.feePayer = payer;
+  tx.add(approveYesIx, approveNoIx);
+  return tx;
+}
+
+exports.AccountNotFoundError = AccountNotFoundError;
+exports.ClobClient = ClobClient;
+exports.CtfClient = CtfClient;
+exports.DEVNET_CONFIG = DEVNET_CONFIG;
+exports.HookClient = HookClient;
+exports.IX_SYSVAR = IX_SYSVAR;
+exports.InvalidParamError = InvalidParamError;
+exports.LOCALNET_CONFIG = LOCALNET_CONFIG;
+exports.MAINNET_CONFIG = MAINNET_CONFIG;
+exports.MAX_APPROVE_AMOUNT = MAX_APPROVE_AMOUNT;
+exports.MarketClient = MarketClient;
+exports.NETWORK_CONFIGS = NETWORK_CONFIGS;
+exports.OracleClient = OracleClient;
+exports.PDA = PDA;
+exports.QuestionStatus = QuestionStatus;
+exports.SEEDS = SEEDS;
+exports.UnauthorizedError = UnauthorizedError;
+exports.XMarketError = XMarketError;
+exports.XMarketSDK = XMarketSDK;
+exports.buildApproveAllOutcomeTokensTx = buildApproveAllOutcomeTokensTx;
+exports.buildApproveCollateralTx = buildApproveCollateralTx;
+exports.buildBatchedEd25519Instruction = buildBatchedEd25519Instruction;
+exports.buildOrder = buildOrder;
+exports.deserializeSignedOrder = deserializeSignedOrder;
+exports.detectMatchType = detectMatchType;
+exports.generateContentHash = generateContentHash;
+exports.generateQuestionId = generateQuestionId;
+exports.getOrderSignBytes = getOrderSignBytes;
+exports.serializeOrderToBytes = serializeOrderToBytes;
+exports.serializeSignedOrder = serializeSignedOrder;
+exports.signOrder = signOrder;
+exports.signOrderWithKeypair = signOrderWithKeypair;
+exports.verifySignedOrder = verifySignedOrder;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map