@theliem/xmarket-sdk 3.23.0 → 3.25.0

package/dist/index.mjs

@@ -161,6 +161,14 @@ var PDA = class {
       programIds.clobExchange
     );
   }
+  static collectFeeOrderRecord(user, nonce, programIds) {
+    const nonceBuf = Buffer.alloc(8);
+    nonceBuf.writeBigUInt64LE(BigInt(nonce.toString()));
+    return PublicKey.findProgramAddressSync(
+      [Buffer.from("collect_order"), user.toBuffer(), nonceBuf],
+      programIds.clobExchange
+    );
+  }
   // ─── Fee Management ─────────────────────────────────────────────────────────
   static feeConfig(owner, programIds) {
     if (!programIds.feeManagement) throw new Error("feeManagement program ID not configured");
@@ -1618,6 +1626,39 @@ var ClobClient = class {
     this._marketOracleVaultCache.set(key, vault);
     return vault;
   }
+  /**
+   * Returns a createATA ix for the oracle vault when:
+   *   - takerFee > 0
+   *   - marketFeeOverride exists for the condition
+   *   - oracle vault ATA is not yet initialized
+   * Idempotent — safe to call every tx; returns null if vault already exists.
+   */
+  async buildInitOracleVaultIfNeeded(condition, collateralMint, takerFee, payer) {
+    if (takerFee.isZero()) return null;
+    if (!this.feeConfigOwner || !this.programIds.feeManagement) return null;
+    if (!this.ctfClient || !this.qmConfigPda || !this.programIds.marketOracle) return null;
+    const companyAddr = await this.companyAddress();
+    const refVault = await this.referralVault();
+    if (!companyAddr || !refVault) return null;
+    const feeOverridePda = PDA.marketFeeOverride(condition, this.programIds)[0];
+    const cond = await this.ctfClient.fetchCondition(condition);
+    if (!cond) return null;
+    const [questionPda] = PDA.question(this.qmConfigPda, cond.questionId, this.programIds);
+    const [marketOraclePda] = PDA.marketOraclePda(questionPda, this.programIds);
+    const vault = getAssociatedTokenAddressSync(collateralMint, marketOraclePda, true);
+    const [feeOverrideInfo, vaultInfo] = await Promise.all([
+      this.provider.connection.getAccountInfo(feeOverridePda),
+      this.provider.connection.getAccountInfo(vault)
+    ]);
+    if (!feeOverrideInfo) return null;
+    if (vaultInfo) return null;
+    return createAssociatedTokenAccountIdempotentInstruction(
+      payer,
+      vault,
+      marketOraclePda,
+      collateralMint
+    );
+  }
   get walletPubkey() {
     return this.provider.wallet.publicKey;
   }
@@ -1756,8 +1797,8 @@ var ClobClient = class {
   async _sendLegacyTxSig(instructions) {
     const { connection } = this.provider;
     const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
-    const { Transaction: Transaction11 } = await import('@solana/web3.js');
-    const tx = new Transaction11();
+    const { Transaction: Transaction12 } = await import('@solana/web3.js');
+    const tx = new Transaction12();
     tx.recentBlockhash = blockhash;
     tx.feePayer = this.walletPubkey;
     tx.add(...instructions);
@@ -1783,10 +1824,10 @@ ${logs.join("\n")}`);
       connection.getAccountInfo(clobYesAta),
       connection.getAccountInfo(clobNoAta)
     ]);
-    const { createAssociatedTokenAccountIdempotentInstruction: createAssociatedTokenAccountIdempotentInstruction4 } = await import('@solana/spl-token');
+    const { createAssociatedTokenAccountIdempotentInstruction: createAssociatedTokenAccountIdempotentInstruction5 } = await import('@solana/spl-token');
     const ixs = [];
     if (!yesInfo) {
-      ixs.push(createAssociatedTokenAccountIdempotentInstruction4(
+      ixs.push(createAssociatedTokenAccountIdempotentInstruction5(
         this.walletPubkey,
         clobYesAta,
         clobConfig,
@@ -1795,7 +1836,7 @@ ${logs.join("\n")}`);
       ));
     }
     if (!noInfo) {
-      ixs.push(createAssociatedTokenAccountIdempotentInstruction4(
+      ixs.push(createAssociatedTokenAccountIdempotentInstruction5(
         this.walletPubkey,
         clobNoAta,
         clobConfig,
@@ -1878,6 +1919,49 @@ ${logs.join("\n")}`);
       await this.registerOrder(signed);
     }
   }
+  // ─── Register CollectFeeOrder ────────────────────────────────────────────────
+  /**
+   * Build a legacy Transaction to register a CollectFeeOrder on-chain.
+   * Must be signed and sent before calling buildBatchCollectRedeemEarlyTx.
+   *
+   * Flow: [Ed25519 ix (1 user sig) + register_collect_fee_order ix]
+   * Caller signs with payer keypair and sends.
+   */
+  async buildRegisterCollectFeeOrderTx(signedOrder, payer) {
+    const { order } = signedOrder;
+    const [collectFeeOrderRecord] = PDA.collectFeeOrderRecord(order.user, order.nonce, this.programIds);
+    const ed25519Ix = buildBatchedCollectFeeEd25519Instruction([signedOrder]);
+    const registerIx = await this.program.methods.registerCollectFeeOrder(order.nonce).accounts({
+      payer,
+      clobConfig: this.configPda(),
+      ixSysvar: IX_SYSVAR,
+      orderSigner: order.user,
+      collectFeeOrderRecord,
+      systemProgram: SystemProgram.programId
+    }).instruction();
+    const { blockhash } = await this.provider.connection.getLatestBlockhash();
+    const tx = new Transaction();
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = payer;
+    tx.add(ed25519Ix, registerIx);
+    return tx;
+  }
+  /**
+   * Register a CollectFeeOrder on-chain and send immediately (operator-signed flow).
+   * Idempotent — skips if PDA already exists.
+   */
+  async registerCollectFeeOrderIfNeeded(signedOrder) {
+    const [pda] = PDA.collectFeeOrderRecord(
+      signedOrder.order.user,
+      signedOrder.order.nonce,
+      this.programIds
+    );
+    const existing = await this.program.account.collectFeeOrderRecord?.fetchNullable(pda);
+    if (!existing) {
+      const tx = await this.buildRegisterCollectFeeOrderTx(signedOrder, this.walletPubkey);
+      await this._sendLegacyTx(tx.instructions);
+    }
+  }
   /** Cancel an order — closes its OrderRecord PDA and returns rent to maker. */
   async cancelOrder(nonce) {
     const [orderRecord] = PDA.orderRecord(this.walletPubkey, nonce, this.programIds);
@@ -2460,6 +2544,13 @@ ${logs.join("\n")}`);
       if (yIx) hookInitIxs.push(yIx);
       if (nIx) hookInitIxs.push(nIx);
     }
+    const oracleVaultInitIx = await this.buildInitOracleVaultIfNeeded(
+      t.condition,
+      collateralMint,
+      t.fee,
+      payer
+    );
+    const preIxs = oracleVaultInitIx ? [...hookInitIxs, oracleVaultInitIx] : hookInitIxs;
     if (t.tokenId === m0.tokenId) {
       let buySignedOrder, sellCandidates;
       if (t.side === SIDE_BUY && makers.every((m) => m.order.side === SIDE_SELL)) {
@@ -2479,7 +2570,7 @@ ${logs.join("\n")}`);
           opts,
           false
         );
-        return this._buildUnsignedVtx([...hookInitIxs, ...ixs3], alt, payer);
+        return this._buildUnsignedVtx([...preIxs, ...ixs3], alt, payer);
       } else {
         throw new InvalidParamError("COMPLEMENTARY requires one BUY and one or more SELLs on same tokenId");
       }
@@ -2495,7 +2586,7 @@ ${logs.join("\n")}`);
         operator,
         opts
       );
-      return this._buildUnsignedVtx([...hookInitIxs, ...ixs2], alt, payer);
+      return this._buildUnsignedVtx([...preIxs, ...ixs2], 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);
@@ -2516,7 +2607,7 @@ ${logs.join("\n")}`);
       ]);
       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 this._buildUnsignedVtx([...hookInitIxs, ix], alt, payer);
+      return this._buildUnsignedVtx([...preIxs, ix], alt, payer);
     }
     await Promise.all([
       this.registerOrderIfNeeded(taker),
@@ -2528,17 +2619,19 @@ ${logs.join("\n")}`);
       const ix = allBuy ? await this._buildMintIx(yesMaker, [taker], collateralMint, operator, payer) : await this._buildMergeIx(yesMaker, [taker], collateralMint, operator, payer, opts);
       ixs.push(ix);
     }
-    return this._buildUnsignedVtx([...hookInitIxs, ...ixs], alt, payer);
+    return this._buildUnsignedVtx([...preIxs, ...ixs], alt, payer);
   }
   // ─── batchCollectRedeemEarly ─────────────────────────────────────────────────
   /**
    * Build VersionedTransaction for batchCollectRedeemEarly.
    *
-   * Flow: Ed25519 ix (user sigs) + batchCollectRedeemEarly ix.
-   * Each SignedCollectFeeOrder authorizes CLOB to collect `amount` winning tokens
-   * from that user, redeem via CTF, then distribute as fees.
+   * Prerequisite: each user's CollectFeeOrder must be registered on-chain via
+   * buildRegisterCollectFeeOrderTx (one tx per user).
    *
-   * @param signedOrders  - Array of { order, signature } from winning users
+   * Flow: batchCollectRedeemEarly ix reads CollectFeeOrderRecord PDAs — no Ed25519 inline.
+   * No tx-size limit from signatures, supports 10+ orders in one tx.
+   *
+   * @param signedOrders  - Array of { order, signature } (used to derive record PDAs)
    * @param condition     - Market condition PDA
    * @param outcomeIndex  - 0 = NO wins, 1 = YES wins
    * @param operator      - Whitelisted operator pubkey (must sign)
@@ -2564,9 +2657,11 @@ ${logs.join("\n")}`);
     const [clobNoPosition] = PDA.position(condition, 0, clobConfig, this.programIds);
     const userAccounts = [];
     for (const { order } of signedOrders) {
+      const [collectFeeOrderRecord] = PDA.collectFeeOrderRecord(order.user, order.nonce, this.programIds);
       const userTokenAta = getAssociatedTokenAddressSync(outcomeMint, order.user, false, TOKEN_2022_PROGRAM_ID);
       const [userPosition] = PDA.position(condition, outcomeIndex, order.user, this.programIds);
       userAccounts.push(
+        { pubkey: collectFeeOrderRecord, isSigner: false, isWritable: true },
         { pubkey: order.user, isSigner: false, isWritable: false },
         { pubkey: userTokenAta, isSigner: false, isWritable: true },
         { pubkey: userPosition, isSigner: false, isWritable: true }
@@ -2603,11 +2698,7 @@ ${logs.join("\n")}`);
       const ix = await this.hookClient.buildInitHookIxIfNeeded(outcomeMint, payer);
       if (ix) hookInitIxs.push(ix);
     }
-    const ed25519Ix = buildBatchedCollectFeeEd25519Instruction(signedOrders);
-    const ed25519IxIndex = 2 + hookInitIxs.length;
     const collectIx = await this.program.methods.batchCollectRedeemEarly(
-      ed25519IxIndex,
-      // ix_index: adjusted for any prepended hook init ixs
       signedOrders.length,
       outcomeIndex
     ).accounts({
@@ -2624,14 +2715,96 @@ ${logs.join("\n")}`);
       clobNoAta,
       clobYesPosition,
       clobNoPosition,
-      ixSysvar: IX_SYSVAR,
       conditionalTokensProgram: this.programIds.conditionalTokens,
       tokenProgram: TOKEN_PROGRAM_ID,
       token2022Program: TOKEN_2022_PROGRAM_ID,
       systemProgram: SystemProgram.programId
     }).remainingAccounts([...userAccounts, ...hookAccounts, ...feeAccounts]).instruction();
-    const alt = opts?.lookupTable ?? this._altCache.get(condition.toBase58()) ?? await this.buildAltForCondition(condition, payer, collateralMint);
-    return this._buildUnsignedVtx([...hookInitIxs, ed25519Ix, collectIx], alt, payer);
+    const alt = opts?.lookupTable ?? await this.buildAltForCollectBatch(condition, payer, collateralMint, signedOrders, outcomeIndex);
+    return this._buildUnsignedVtx([...hookInitIxs, collectIx], alt, payer);
+  }
+  /**
+   * Build ALT for batchCollectRedeemEarly — includes per-user accounts so all
+   * remaining_accounts fit as 1-byte ALT indices instead of 32-byte inline addresses.
+   */
+  async buildAltForCollectBatch(condition, payer, collateralMint, signedOrders, outcomeIndex) {
+    const userKeys = signedOrders.map((o) => o.order.user.toBase58()).sort((a, b) => a.localeCompare(b)).join(",");
+    const cacheKey = `${condition.toBase58()}:collect:${userKeys}`;
+    if (this._altCache.has(cacheKey)) return this._altCache.get(cacheKey);
+    const { connection } = this.provider;
+    const clobConfigPda = this.configPda();
+    const [yesMint] = PDA.yesMint(condition, this.programIds);
+    const [noMint] = PDA.noMint(condition, this.programIds);
+    const outcomeMint = outcomeIndex === 1 ? yesMint : noMint;
+    const [extraAccountMeta] = PDA.extraAccountMetaList(outcomeMint, this.programIds);
+    const [hookConfig] = PDA.hookConfig(this.programIds);
+    const [collateralVault] = PDA.collateralVault(collateralMint, this.programIds);
+    const [vaultTokenAccount] = PDA.vaultToken(collateralMint, this.programIds);
+    const clobYesAta = getAssociatedTokenAddressSync(yesMint, clobConfigPda, true, TOKEN_2022_PROGRAM_ID);
+    const clobNoAta = getAssociatedTokenAddressSync(noMint, clobConfigPda, true, TOKEN_2022_PROGRAM_ID);
+    const [clobYesPos] = PDA.position(condition, 1, clobConfigPda, this.programIds);
+    const [clobNoPos] = PDA.position(condition, 0, clobConfigPda, this.programIds);
+    const feeRecipientAddr = (await this.fetchConfig())?.feeRecipient;
+    const addresses = [
+      this.programIds.clobExchange,
+      this.programIds.conditionalTokens,
+      this.programIds.hook,
+      TOKEN_PROGRAM_ID,
+      TOKEN_2022_PROGRAM_ID,
+      SystemProgram.programId,
+      clobConfigPda,
+      hookConfig,
+      condition,
+      yesMint,
+      noMint,
+      extraAccountMeta,
+      collateralVault,
+      vaultTokenAccount,
+      clobYesAta,
+      clobNoAta,
+      clobYesPos,
+      clobNoPos
+    ];
+    if (feeRecipientAddr) addresses.push(feeRecipientAddr);
+    if (this.feeConfigOwner && this.programIds.feeManagement) {
+      const companyAddr = await this.companyAddress();
+      const refVault = await this.referralVault();
+      addresses.push(this.programIds.feeManagement);
+      addresses.push(PDA.feeConfig(this.feeConfigOwner, this.programIds)[0]);
+      addresses.push(PDA.marketFeeOverride(condition, this.programIds)[0]);
+      if (companyAddr) addresses.push(getAssociatedTokenAddressSync(collateralMint, companyAddr));
+      if (refVault) addresses.push(refVault);
+      const oracleVault = await this.getMarketOracleVault(condition, collateralMint) ?? payer;
+      addresses.push(oracleVault);
+    }
+    for (const { order } of signedOrders) {
+      const [collectFeeOrderRecord] = PDA.collectFeeOrderRecord(order.user, order.nonce, this.programIds);
+      const userTokenAta = getAssociatedTokenAddressSync(outcomeMint, order.user, false, TOKEN_2022_PROGRAM_ID);
+      const [userPosition] = PDA.position(condition, outcomeIndex, order.user, this.programIds);
+      addresses.push(collectFeeOrderRecord, order.user, userTokenAta, userPosition);
+    }
+    const slot = await connection.getSlot("finalized");
+    const [createIx, altAddress] = AddressLookupTableProgram.createLookupTable(
+      { authority: payer, payer, recentSlot: slot }
+    );
+    const BATCH = 30;
+    const extendIxs = [];
+    for (let i = 0; i < addresses.length; i += BATCH) {
+      extendIxs.push(AddressLookupTableProgram.extendLookupTable(
+        { payer, authority: payer, lookupTable: altAddress, addresses: addresses.slice(i, i + BATCH) }
+      ));
+    }
+    await this._sendLegacyTx([createIx, extendIxs[0]]);
+    for (let i = 1; i < extendIxs.length; i++) await this._sendLegacyTx([extendIxs[i]]);
+    for (let attempt = 0; attempt < 30; attempt++) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const res = await connection.getAddressLookupTable(altAddress);
+      if (res.value && res.value.state.addresses.length === addresses.length) {
+        this._altCache.set(cacheKey, res.value);
+        return res.value;
+      }
+    }
+    throw new Error(`ALT ${altAddress.toBase58()} not active after 30s`);
   }
   /**
    * Build ALT with static accounts for a condition — no order-specific PDAs needed.
@@ -9394,7 +9567,8 @@ var clob_exchange_default = {
       name: "batch_collect_redeem_early",
       docs: [
         "Batch collect fee tokens from winning users after question resolution,",
-        "redeem them via CTF, and distribute USDS via fee_management."
+        "redeem them via CTF, and distribute USDS via fee_management.",
+        "Requires each user's CollectFeeOrderRecord to be registered via register_collect_fee_order."
       ],
       discriminator: [
         87,
@@ -9504,7 +9678,7 @@ var clob_exchange_default = {
         {
           name: "clob_yes_ata",
           docs: [
-            "CLOB's YES ATA (Token-2022) \u2014 must be pre-initialized (created during prior matchOrders)."
+            "CLOB's YES ATA (Token-2022) \u2014 must be pre-initialized."
           ],
           writable: true
         },
@@ -9523,9 +9697,6 @@ var clob_exchange_default = {
           name: "clob_no_position",
           writable: true
         },
-        {
-          name: "ix_sysvar"
-        },
         {
           name: "conditional_tokens_program",
           address: "A6N1F8MRsdgcojAx8p6FaECvw8mo8w6qJcWsbKQBANK4"
@@ -9544,10 +9715,6 @@ var clob_exchange_default = {
         }
       ],
       args: [
-        {
-          name: "ix_index",
-          type: "u8"
-        },
         {
           name: "order_count",
           type: "u8"
@@ -10493,6 +10660,105 @@ var clob_exchange_default = {
         }
       ]
     },
+    {
+      name: "register_collect_fee_order",
+      docs: [
+        "Register a signed CollectFeeOrder on-chain (Ed25519 verify at registration time).",
+        "ix[0] must be Ed25519 precompile with 1 entry for order.user.",
+        "Call once per user before batch_collect_redeem_early."
+      ],
+      discriminator: [
+        63,
+        26,
+        202,
+        98,
+        195,
+        2,
+        211,
+        36
+      ],
+      accounts: [
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "clob_config",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  108,
+                  111,
+                  98,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "ix_sysvar",
+          address: "Sysvar1nstructions1111111111111111111111111"
+        },
+        {
+          name: "order_signer"
+        },
+        {
+          name: "collect_fee_order_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  111,
+                  108,
+                  108,
+                  101,
+                  99,
+                  116,
+                  95,
+                  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: "register_order",
       docs: [
@@ -10783,6 +11049,19 @@ var clob_exchange_default = {
         160
       ]
     },
+    {
+      name: "CollectFeeOrderRecord",
+      discriminator: [
+        145,
+        140,
+        193,
+        74,
+        12,
+        98,
+        74,
+        130
+      ]
+    },
     {
       name: "OrderStatus",
       discriminator: [
@@ -10992,6 +11271,53 @@ var clob_exchange_default = {
         ]
       }
     },
+    {
+      name: "CollectFeeOrderRecord",
+      docs: [
+        "On-chain record of a signed CollectFeeOrder.",
+        "Created by `register_collect_fee_order` after Ed25519 verification.",
+        "Read and marked collected by `batch_collect_redeem_early`.",
+        "",
+        'PDA seeds: [b"collect_order", user, nonce_le_bytes]'
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "condition",
+            type: "pubkey"
+          },
+          {
+            name: "token_mint",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "nonce",
+            type: "u64"
+          },
+          {
+            name: "expiry",
+            type: "i64"
+          },
+          {
+            name: "is_collected",
+            type: "bool"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
     {
       name: "ComplementaryMatchEvent",
       type: {