@theliem/xmarket-sdk 3.10.0 → 3.11.0

package/dist/index.mjs

@@ -1889,11 +1889,8 @@ ${logs.join("\n")}`);
    * remaining_accounts per NO maker (5):
    *   [order_record, buyer_no_token, buyer_no_collateral, buyer_no_position, no_order_status]
    */
-  async matchMintOrders(yesSigned, noMakers, collateralMint, _feeRecipient, operatorWallet, lookupTable) {
-    await Promise.all([
-      this.registerOrderIfNeeded(yesSigned),
-      ...noMakers.map((m) => this.registerOrderIfNeeded(m))
-    ]);
+  /** Build the match_mint_orders instruction (no signing, no sending). */
+  async _buildMintIx(yesSigned, noMakers, collateralMint, operator, payer) {
     const condition = yesSigned.order.condition;
     const taker = yesSigned.order.maker;
     const takerNonce = yesSigned.order.nonce;
@@ -1941,9 +1938,9 @@ ${logs.join("\n")}`);
       { pubkey: hookConfig, isSigner: false, isWritable: false },
       { pubkey: hookProgram, isSigner: false, isWritable: false }
     );
-    const matchIx = await this.program.methods.matchMintOrders(takerNonce, fillAmount, true).accounts({
-      operator: operatorWallet.publicKey,
-      payer: this.walletPubkey,
+    return this.program.methods.matchMintOrders(takerNonce, fillAmount, true).accounts({
+      operator,
+      payer,
       clobConfig,
       condition,
       taker,
@@ -1970,6 +1967,19 @@ ${logs.join("\n")}`);
       associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
       systemProgram: SystemProgram.programId
     }).remainingAccounts(remainingAccounts).instruction();
+  }
+  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 clobConfig = this.configPda();
+    const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [noMint] = PDA.noMint(condition, this.programIds);
+    const clobYesAta = getAssociatedTokenAddressSync(yesMint, clobConfig, true, TOKEN_2022_PROGRAM_ID);
+    const clobNoAta = getAssociatedTokenAddressSync(noMint, clobConfig, true, TOKEN_2022_PROGRAM_ID);
+    const matchIx = await this._buildMintIx(yesSigned, noMakers, collateralMint, operatorWallet.publicKey, this.walletPubkey);
     await this._ensureClobOutcomeAtas(yesMint, noMint, clobConfig, clobYesAta, clobNoAta);
     const sig = await this.sendMatchTx([matchIx], lookupTable, operatorWallet);
     return { signature: sig };
@@ -1983,11 +1993,8 @@ ${logs.join("\n")}`);
    *   [order_record, seller_no_token, seller_no_collateral, seller_no_position, no_order_status]
    * After all makers, optional 5 fee accounts.
    */
-  async matchMergeOrders(yesSigned, noMakers, collateralMint, feeRecipient, operatorWallet, lookupTable, opts) {
-    await Promise.all([
-      this.registerOrderIfNeeded(yesSigned),
-      ...noMakers.map((m) => this.registerOrderIfNeeded(m))
-    ]);
+  /** Build the match_merge_orders instruction (no signing, no sending). */
+  async _buildMergeIx(yesSigned, noMakers, collateralMint, operator, payer, opts) {
     const condition = yesSigned.order.condition;
     const sellerYes = yesSigned.order.maker;
     const takerNonce = yesSigned.order.nonce;
@@ -2040,7 +2047,7 @@ ${logs.join("\n")}`);
         const feeOverridePda = PDA.marketFeeOverride(condition, this.programIds)[0];
         const feeOverrideExists = await this.provider.connection.getAccountInfo(feeOverridePda);
         if (feeOverrideExists) {
-          const oracleVault = opts?.marketOracleVault ?? this.walletPubkey;
+          const oracleVault = opts?.marketOracleVault ?? payer;
           remainingAccounts.push(
             { pubkey: this.programIds.feeManagement, isSigner: false, isWritable: false },
             { pubkey: PDA.feeConfig(this.feeConfigOwner, this.programIds)[0], isSigner: false, isWritable: false },
@@ -2051,9 +2058,9 @@ ${logs.join("\n")}`);
         }
       }
     }
-    const matchIx = await this.program.methods.matchMergeOrders(takerNonce, fillAmount, true).accounts({
-      operator: operatorWallet.publicKey,
-      payer: this.walletPubkey,
+    return this.program.methods.matchMergeOrders(takerNonce, fillAmount, true).accounts({
+      operator,
+      payer,
       clobConfig,
       condition,
       taker: sellerYes,
@@ -2079,6 +2086,19 @@ ${logs.join("\n")}`);
       associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
       systemProgram: SystemProgram.programId
     }).remainingAccounts(remainingAccounts).instruction();
+  }
+  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 clobConfig = this.configPda();
+    const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [noMint] = PDA.noMint(condition, this.programIds);
+    const clobYesAta = getAssociatedTokenAddressSync(yesMint, clobConfig, true, TOKEN_2022_PROGRAM_ID);
+    const clobNoAta = getAssociatedTokenAddressSync(noMint, clobConfig, true, TOKEN_2022_PROGRAM_ID);
+    const matchIx = await this._buildMergeIx(yesSigned, noMakers, collateralMint, operatorWallet.publicKey, this.walletPubkey, opts);
     await this._ensureClobOutcomeAtas(yesMint, noMint, clobConfig, clobYesAta, clobNoAta);
     const sig = await this.sendMatchTx([matchIx], lookupTable, operatorWallet);
     return { signature: sig };
@@ -2103,7 +2123,7 @@ ${logs.join("\n")}`);
     const cfg = await this.fetchConfig();
     if (!cfg) throw new InvalidParamError("CLOB config not found on-chain");
     const feeRecipient = cfg.feeRecipient;
-    const operatorWallet = this.provider.wallet;
+    const operatorWallet = opts?.operatorWallet ?? this.provider.wallet;
     const alt = await this.ensureAlt(
       taker.order.condition,
       collateralMint,
@@ -2191,6 +2211,124 @@ ${logs.join("\n")}`);
     const makersSigned = sortedMakers.map(buildSigned);
     return this.matchOrders(takerSigned, makersSigned, opts);
   }
+  /**
+   * Build an unsigned VersionedTransaction for a set of match instructions.
+   * Callers sign and send externally — mirrors createQuestionAdmin pattern.
+   */
+  async _buildUnsignedVtx(instructions, lookupTable, payer) {
+    const { connection } = this.provider;
+    const { blockhash } = await connection.getLatestBlockhash();
+    const cuLimit = ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 });
+    const heapFrame = ComputeBudgetProgram.requestHeapFrame({ bytes: 262144 });
+    const message = new TransactionMessage({
+      payerKey: payer,
+      recentBlockhash: blockhash,
+      instructions: [cuLimit, heapFrame, ...instructions]
+    }).compileToV0Message(lookupTable ? [lookupTable] : []);
+    return new VersionedTransaction(message);
+  }
+  /**
+   * Build unsigned VersionedTransaction(s) for matching orders.
+   *
+   * Mirrors createQuestionAdmin pattern — SDK registers orders internally but
+   * returns the match tx unsigned. BE signs with both keypairs and sends:
+   *
+   *   const [vtx] = await sdk.clob.buildMatchOrdersTx(taker, makers, operatorPk, payerPk);
+   *   vtx.sign([feePayerKeypair, operatorKeypair]);
+   *   await connection.sendRawTransaction(vtx.serialize());
+   *
+   * Returns an array because NO-taker MINT/MERGE decomposes into N txs (one per YES maker).
+   * Most direct/single-pair cases return a single-element array.
+   *
+   * @param operator - Whitelisted CLOB operator pubkey (must sign)
+   * @param payer    - Fee payer pubkey (must sign, pays tx fee + rent)
+   */
+  async buildMatchOrdersTx(taker, makers, operator, payer, opts) {
+    if (makers.length === 0) throw new InvalidParamError("At least 1 maker required");
+    const collateralMint = this.networkConfig.defaultCollateral.mint;
+    const cfg = await this.fetchConfig();
+    if (!cfg) throw new InvalidParamError("CLOB config not found on-chain");
+    const feeRecipient = cfg.feeRecipient;
+    const alt = await this.ensureAlt(taker.order.condition, collateralMint, taker, makers);
+    const t = taker.order;
+    const m0 = makers[0].order;
+    const SIDE_BUY = 0;
+    const SIDE_SELL = 1;
+    if (t.tokenId === m0.tokenId) {
+      let buySignedOrder, sellCandidates;
+      if (t.side === SIDE_BUY && makers.every((m) => m.order.side === SIDE_SELL)) {
+        buySignedOrder = taker;
+        sellCandidates = makers;
+      } else if (t.side === SIDE_SELL && makers.every((m) => m.order.side === SIDE_BUY)) {
+        await Promise.all([
+          this.registerOrderIfNeeded(taker),
+          ...makers.map((m) => this.registerOrderIfNeeded(m))
+        ]);
+        const ixs2 = [];
+        for (const buyMaker of makers) {
+          const built = await this.buildMatchComplementaryIxs(
+            buyMaker,
+            [taker],
+            collateralMint,
+            feeRecipient,
+            operator,
+            opts,
+            true,
+            true
+          );
+          ixs2.push(...built);
+        }
+        return [await this._buildUnsignedVtx(ixs2, alt, payer)];
+      } else {
+        throw new InvalidParamError("COMPLEMENTARY requires one BUY and one or more SELLs on same tokenId");
+      }
+      await Promise.all([
+        this.registerOrderIfNeeded(buySignedOrder),
+        ...sellCandidates.map((m) => this.registerOrderIfNeeded(m))
+      ]);
+      const ixs = await this.buildMatchComplementaryIxs(
+        buySignedOrder,
+        sellCandidates,
+        collateralMint,
+        feeRecipient,
+        operator,
+        opts
+      );
+      return [await this._buildUnsignedVtx(ixs, alt, payer)];
+    }
+    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 same side");
+    const takerIsYes = t.tokenId === 1 && makers.every((m) => m.order.tokenId === 0);
+    const takerIsNo = t.tokenId === 0 && makers.every((m) => m.order.tokenId === 1);
+    if (!takerIsYes && !takerIsNo) throw new InvalidParamError("MINT/MERGE: orders must be complementary YES+NO pair");
+    const condition = t.condition;
+    const clobConfig = this.configPda();
+    const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [noMint] = PDA.noMint(condition, this.programIds);
+    const clobYesAta = getAssociatedTokenAddressSync(yesMint, clobConfig, true, TOKEN_2022_PROGRAM_ID);
+    const clobNoAta = getAssociatedTokenAddressSync(noMint, clobConfig, true, TOKEN_2022_PROGRAM_ID);
+    if (takerIsYes) {
+      await Promise.all([
+        this.registerOrderIfNeeded(taker),
+        ...makers.map((m) => this.registerOrderIfNeeded(m))
+      ]);
+      await this._ensureClobOutcomeAtas(yesMint, noMint, clobConfig, clobYesAta, clobNoAta);
+      const ix = allBuy ? await this._buildMintIx(taker, makers, collateralMint, operator, payer) : await this._buildMergeIx(taker, makers, collateralMint, operator, payer, opts);
+      return [await this._buildUnsignedVtx([ix], alt, payer)];
+    }
+    const vtxs = [];
+    for (const yesMaker of makers) {
+      await Promise.all([
+        this.registerOrderIfNeeded(yesMaker),
+        this.registerOrderIfNeeded(taker)
+      ]);
+      await this._ensureClobOutcomeAtas(yesMint, noMint, clobConfig, clobYesAta, clobNoAta);
+      const ix = allBuy ? await this._buildMintIx(yesMaker, [taker], collateralMint, operator, payer) : await this._buildMergeIx(yesMaker, [taker], collateralMint, operator, payer, opts);
+      vtxs.push(await this._buildUnsignedVtx([ix], alt, payer));
+    }
+    return vtxs;
+  }
   // ─── Queries ─────────────────────────────────────────────────────────────────
   async fetchConfig() {
     try {