drama-pm-client 0.4.8 → 0.4.9

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { AnchorProvider, Program, Wallet } from "@coral-xyz/anchor";
 import BN from "bn.js";
-import { Connection, PublicKey, Transaction, TransactionInstruction } from "@solana/web3.js";
+import { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } from "@solana/web3.js";
 import { IDL } from "./idl.js";
 import { DramaPm } from "./types.js";
 export * from "./utils.js";
@@ -57,6 +57,29 @@ export interface RefundParams {
     tokenAmount?: number | BN;
     closeAccount?: boolean;
 }
+/**
+ * Parameters for placeBetV2 - combines user bet and bonus account bet in one transaction
+ * Requires both user and bonusAccount to sign the transaction
+ */
+export interface PlaceBetV2Params {
+    user: PublicKey;
+    bonusAccount: PublicKey;
+    market: PublicKey;
+    userAmount: number | BN;
+    bonusAmount: number | BN;
+    outcome: Outcome;
+    bettingToken: PublicKey;
+    feeRecipient?: PublicKey;
+    createAta?: boolean;
+}
+/**
+ * Result from buildPlaceBetV2Tx containing both the transaction and its serialized form
+ * for split signing workflow (frontend user sign + backend bonus sign)
+ */
+export interface PlaceBetV2Result {
+    transaction: Transaction;
+    requiredSigners: PublicKey[];
+}
 export declare class DramaPmClient {
     program: Program<DramaPm>;
     provider: AnchorProvider;
@@ -137,6 +160,64 @@ export declare class DramaPmClient {
      * Build a complete transaction to place a bet (with optional ATA creation for both outcome token and fee recipient)
      */
     buildPlaceBetTx(params: PlaceBetParams): Promise<Transaction>;
+    /**
+     * Build a transaction to place bets from both user and bonus account in one transaction.
+     * This transaction requires two signers: user and bonusAccount.
+     *
+     * Use case: User pays part of the bet, bonus account (backend) pays the rest.
+     * Example: User bets 10U total, user pays 8U, bonus account pays 2U.
+     *
+     * Both bets are placed on the same outcome, but outcome tokens go to each account respectively.
+     */
+    buildPlaceBetV2Tx(params: PlaceBetV2Params): Promise<PlaceBetV2Result>;
+    withdrawBonus(): Promise<void>;
+    /**
+     * Deserialize a base64 encoded transaction
+     * Use this on frontend to decode the transaction received from backend
+     */
+    static deserializeTransaction(serializedTx: string): Transaction;
+    /**
+     * Sign a partially signed transaction with the bonus account (backend side)
+     *
+     * @param userSignedTxBase64 - Base64 encoded transaction that has been signed by user
+     * @param bonusAccountKeypair - The bonus account keypair for signing
+     * @returns The fully signed transaction ready for submission
+     */
+    static signWithKeyPair(userSignedTxBase64: string, keyPair: Keypair): Transaction;
+    /**
+     * Build a transaction to withdraw bonus (transfer USDT from bonus account to user)
+     * This transaction requires the bonus account to sign.
+     *
+     * @param bonusAccount - The bonus account public key (signer, source of funds)
+     * @param user - The user's public key (destination)
+     * @param tokenMint - The token mint address (e.g., USDT)
+     * @param amount - Amount to transfer (in token's smallest unit, e.g., 1_000_000 for 1 USDT with 6 decimals)
+     * @param createAta - Whether to create the user's ATA if it doesn't exist (default: true)
+     * @returns Transaction ready for signing
+     */
+    buildWithdrawBonusTx(params: {
+        bonusAccount: PublicKey;
+        user: PublicKey;
+        tokenMint: PublicKey;
+        amount: number | BN;
+        createAta?: boolean;
+    }): Promise<Transaction>;
+    /**
+     * Build and return a transaction for withdrawing bonus with serialization info
+     * Useful for split signing workflow where user/admin builds tx and bonus account signs
+     *
+     * @returns Object containing transaction and required signers
+     */
+    buildWithdrawBonusTxWithInfo(params: {
+        bonusAccount: PublicKey;
+        user: PublicKey;
+        tokenMint: PublicKey;
+        amount: number | BN;
+        createAta?: boolean;
+    }): Promise<{
+        transaction: Transaction;
+        requiredSigners: PublicKey[];
+    }>;
     /**
      * Claim rewards after market resolution
      */

package/dist/index.js

@@ -1,4 +1,4 @@
-import { ASSOCIATED_TOKEN_PROGRAM_ID, getAccount, getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, createTransferInstruction, getAccount, getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
 import { Program as AnchorProgram, AnchorProvider } from "@coral-xyz/anchor";
 import BN from "bn.js";
 import { Keypair, PublicKey, SystemProgram, Transaction, TransactionInstruction } from "@solana/web3.js";
@@ -287,6 +287,156 @@ export class DramaPmClient {
         tx.add(placeBetIx);
         return tx;
     }
+    /**
+     * Build a transaction to place bets from both user and bonus account in one transaction.
+     * This transaction requires two signers: user and bonusAccount.
+     *
+     * Use case: User pays part of the bet, bonus account (backend) pays the rest.
+     * Example: User bets 10U total, user pays 8U, bonus account pays 2U.
+     *
+     * Both bets are placed on the same outcome, but outcome tokens go to each account respectively.
+     */
+    async buildPlaceBetV2Tx(params) {
+        const { user, bonusAccount, market, userAmount, bonusAmount, outcome, bettingToken, createAta = true } = params;
+        const tx = new Transaction();
+        // Fetch config to check fee_bps
+        const configAccount = await this.getGlobalConfigAccount();
+        // Derive mint PDAs from market address
+        const yesMint = PublicKey.findProgramAddressSync([Buffer.from(YES_MINT_SEED), market.toBuffer()], this.program.programId)[0];
+        const noMint = PublicKey.findProgramAddressSync([Buffer.from(NO_MINT_SEED), market.toBuffer()], this.program.programId)[0];
+        // Outcome tokens (Yes/No) use Token-2022 program
+        const targetMint = outcome === "Yes" ? yesMint : noMint;
+        // User's outcome token account
+        const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);
+        // Bonus account's outcome token account
+        const bonusOutcomeToken = getAssociatedTokenAddressSync(targetMint, bonusAccount, false, TOKEN_2022_PROGRAM_ID);
+        // Create ATAs if needed
+        if (createAta) {
+            // Check if user outcome ATA exists and create if needed
+            const userAtaExists = await this.ataExists(userOutcomeToken);
+            if (!userAtaExists) {
+                const createUserAtaIx = this.createAtaInstruction(user, user, targetMint, TOKEN_2022_PROGRAM_ID);
+                tx.add(createUserAtaIx);
+            }
+            // Check if bonus account outcome ATA exists and create if needed
+            const bonusAtaExists = await this.ataExists(bonusOutcomeToken);
+            if (!bonusAtaExists) {
+                // User pays for creating the bonus account's ATA
+                const createBonusAtaIx = this.createAtaInstruction(user, bonusAccount, targetMint, TOKEN_2022_PROGRAM_ID);
+                tx.add(createBonusAtaIx);
+            }
+        }
+        // Handle fee recipient token account if fee_bps > 0
+        let feeRecipientToken = null;
+        if (configAccount.feeBps > 0) {
+            const feeRecipientAddress = params.feeRecipient || configAccount.feeRecipient;
+            feeRecipientToken = getAssociatedTokenAddressSync(bettingToken, feeRecipientAddress);
+            // Check if fee recipient ATA exists and create if needed
+            const feeAtaExists = await this.ataExists(feeRecipientToken);
+            if (!feeAtaExists) {
+                const createFeeAtaIx = this.createAtaInstruction(user, feeRecipientAddress, bettingToken);
+                tx.add(createFeeAtaIx);
+            }
+        }
+        // Create user's placeBet instruction
+        const userBetIx = await this.placeBet({
+            user,
+            market,
+            amount: userAmount,
+            outcome,
+            bettingToken,
+            feeRecipientToken,
+        });
+        tx.add(userBetIx);
+        // Create bonus account's placeBet instruction
+        const bonusBetIx = await this.placeBet({
+            user: bonusAccount,
+            market,
+            amount: bonusAmount,
+            outcome,
+            bettingToken,
+            feeRecipientToken,
+        });
+        tx.add(bonusBetIx);
+        return {
+            transaction: tx,
+            requiredSigners: [user, bonusAccount],
+        };
+    }
+    async withdrawBonus() {
+    }
+    /**
+     * Deserialize a base64 encoded transaction
+     * Use this on frontend to decode the transaction received from backend
+     */
+    static deserializeTransaction(serializedTx) {
+        const buffer = Buffer.from(serializedTx, 'base64');
+        return Transaction.from(buffer);
+    }
+    /**
+     * Sign a partially signed transaction with the bonus account (backend side)
+     *
+     * @param userSignedTxBase64 - Base64 encoded transaction that has been signed by user
+     * @param bonusAccountKeypair - The bonus account keypair for signing
+     * @returns The fully signed transaction ready for submission
+     */
+    static signWithKeyPair(userSignedTxBase64, keyPair) {
+        const buffer = Buffer.from(userSignedTxBase64, 'base64');
+        const tx = Transaction.from(buffer);
+        tx.partialSign(keyPair);
+        return tx;
+    }
+    // async transfer()
+    /**
+     * Build a transaction to withdraw bonus (transfer USDT from bonus account to user)
+     * This transaction requires the bonus account to sign.
+     *
+     * @param bonusAccount - The bonus account public key (signer, source of funds)
+     * @param user - The user's public key (destination)
+     * @param tokenMint - The token mint address (e.g., USDT)
+     * @param amount - Amount to transfer (in token's smallest unit, e.g., 1_000_000 for 1 USDT with 6 decimals)
+     * @param createAta - Whether to create the user's ATA if it doesn't exist (default: true)
+     * @returns Transaction ready for signing
+     */
+    async buildWithdrawBonusTx(params) {
+        const { bonusAccount, user, tokenMint, amount, createAta = true } = params;
+        const amountBn = new BN(amount);
+        const tx = new Transaction();
+        // Get ATA addresses for both accounts
+        const bonusTokenAccount = getAssociatedTokenAddressSync(tokenMint, bonusAccount);
+        const userTokenAccount = getAssociatedTokenAddressSync(tokenMint, user);
+        // Create user's ATA if needed
+        if (createAta) {
+            const userAtaExists = await this.ataExists(userTokenAccount);
+            if (!userAtaExists) {
+                const createUserAtaIx = this.createAtaInstruction(bonusAccount, user, tokenMint);
+                tx.add(createUserAtaIx);
+            }
+        }
+        // Create transfer instruction
+        const transferIx = createTransferInstruction(bonusTokenAccount, // source
+        userTokenAccount, // destination
+        bonusAccount, // owner (signer)
+        BigInt(amountBn.toString()), // amount
+        [], // multiSigners (empty for single signer)
+        TOKEN_PROGRAM_ID // program id
+        );
+        tx.add(transferIx);
+        return tx;
+    }
+    /**
+     * Build and return a transaction for withdrawing bonus with serialization info
+     * Useful for split signing workflow where user/admin builds tx and bonus account signs
+     *
+     * @returns Object containing transaction and required signers
+     */
+    async buildWithdrawBonusTxWithInfo(params) {
+        const tx = await this.buildWithdrawBonusTx(params);
+        return {
+            transaction: tx,
+            requiredSigners: [params.bonusAccount],
+        };
+    }
     /**
      * Claim rewards after market resolution
      */
@@ -683,4 +833,4 @@ export class DramaPmClient {
         return await getAccount(this.connection, vaultPda);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ASSOCIATED_TOKEN_PROGRAM_ID,\n  getAccount,\n  getAssociatedTokenAddressSync,\n  TOKEN_2022_PROGRAM_ID,\n  TOKEN_PROGRAM_ID\n} from \"@solana/spl-token\";\n\nimport { Program as AnchorProgram, AnchorProvider, Idl, Program, Wallet } from \"@coral-xyz/anchor\";\n\nimport BN from \"bn.js\";\n\nimport {\n  Connection,\n  Keypair,\n  PublicKey,\n  SystemProgram,\n  Transaction,\n  TransactionInstruction\n} from \"@solana/web3.js\";\nimport { IDL } from \"./idl.js\";\nimport { DramaPm } from \"./types.js\";\nimport {\n  getGlobalConfigPda,\n  getMarketPda,\n  getMarketPdas,\n  getVaultPda,\n  NO_MINT_SEED,\n  VAULT_SEED,\n  YES_MINT_SEED\n} from \"./utils.js\";\n\nexport * from \"./utils.js\";\nexport { DramaPm, IDL };\n\nexport type Outcome = \"Yes\" | \"No\";\n\nexport interface CreateMarketParams {\n  admin: PublicKey;\n  marketId: number | BN;\n  yesPrice: number | BN;\n  noPrice: number | BN;\n  endTime: number | BN;\n  bettingToken: PublicKey;\n}\n\nexport interface PlaceBetParams {\n  user: PublicKey;\n  market: PublicKey; // Market PDA address\n  amount: number | BN;\n  outcome: Outcome;\n  bettingToken: PublicKey;\n  feeRecipient?: PublicKey; // Fee recipient address (optional, will fetch from config if not provided)\n  feeRecipientToken?: PublicKey | null; // Fee recipient token account (optional, used internally by buildPlaceBetTx)\n  createAta?: boolean; // Whether to create ATA instruction automatically\n}\n\nexport interface UpdateFeeConfigParams {\n  authority: PublicKey; // Can be authority or authorized admin\n  newFeeBps: number; // Fee in basis points (1 bps = 0.01%, max 2000 = 20%)\n  newFeeRecipient: PublicKey;\n  newFeeClaimBps: number; // Fee for claiming rewards in basis points\n}\n\nexport interface ClaimRewardsParams {\n  user: PublicKey;\n  market: PublicKey; // Market PDA address\n  bettingToken: PublicKey;\n  winningOutcome: Outcome;\n  sharesToClaim: number | BN; // Amount of shares to claim (0 = claim all)\n  closeAccount?: boolean; // Whether to close the outcome token account after claiming all shares (default: false)\n  feeRecipient?: PublicKey; // Fee recipient address (optional, will fetch from config if not provided)\n}\n\nexport interface BatchClaimParams {\n  user: PublicKey;\n  claims: Array<{\n    market: PublicKey;\n    bettingToken: PublicKey;\n    winningOutcome: Outcome;\n    sharesToClaim?: number | BN; // Amount of shares to claim (0 or undefined = claim all)\n    closeAccount?: boolean; // Whether to close the outcome token account after claiming all shares\n  }>;\n}\n\nexport interface RefundParams {\n  user: PublicKey;\n  market: PublicKey; // Market PDA address\n  bettingToken: PublicKey;\n  outcome: Outcome;\n  tokenAmount?: number | BN; // Amount of shares to refund. 0 or undefined means refund all shares.\n  closeAccount?: boolean; // Whether to close the outcome token account after refunding all shares (default: false)\n}\n\nexport class DramaPmClient {\n  program: Program<DramaPm>;\n  provider: AnchorProvider;\n  connection: Connection;\n\n  constructor(connection: Connection, wallet?: Wallet, programId?: PublicKey) {\n    this.connection = connection;\n    \n    // Create a default wallet if none provided\n    const defaultKeypair = Keypair.generate();\n    const defaultWallet: Wallet = {\n      publicKey: defaultKeypair.publicKey,\n      signTransaction: async (tx) => tx,\n      signAllTransactions: async (txs) => txs,\n      payer: defaultKeypair,\n    };\n    \n    this.provider = new AnchorProvider(\n      connection,\n      wallet || defaultWallet,\n      { commitment: \"confirmed\" }\n    );\n    \n    // Use custom programId if provided, otherwise use the default from IDL\n    const finalProgramId = programId || new PublicKey(IDL.address);\n    \n    // Create a new IDL with the custom programId\n    const customIdl = { ...IDL, address: finalProgramId.toBase58() };\n    \n    this.program = new AnchorProgram(customIdl as Idl, this.provider) as unknown as Program<DramaPm>;\n  }\n\n  /**\n   * Get the current program ID\n   */\n  getProgramId(): PublicKey {\n    return this.program.programId;\n  }\n\n  /**\n   * Set a new program ID and reinitialize the program instance\n   * Useful when redeploying the program to a new address\n   */\n  setProgramId(programId: PublicKey): void {\n    const customIdl = { ...IDL, address: programId.toBase58() };\n    this.program = new AnchorProgram(customIdl as Idl, this.provider) as unknown as Program<DramaPm>;\n  }\n\n  /**\n   * Check if an associated token account exists\n   */\n  async ataExists(ata: PublicKey): Promise<boolean> {\n    try {\n      await getAccount(this.connection, ata);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Create an instruction to initialize an associated token account\n   * @param tokenProgram - Token program ID (TOKEN_PROGRAM_ID for betting token, TOKEN_2022_PROGRAM_ID for outcome tokens)\n   */\n  createAtaInstruction(\n    payer: PublicKey,\n    owner: PublicKey,\n    mint: PublicKey,\n    tokenProgram: PublicKey = TOKEN_PROGRAM_ID\n  ): TransactionInstruction {\n    const ata = getAssociatedTokenAddressSync(mint, owner, true, tokenProgram);\n    \n    // Use CreateIdempotent instruction (opcode 1) to support PDAs and idempotency\n    const keys = [\n      { pubkey: payer, isSigner: true, isWritable: true },\n      { pubkey: ata, isSigner: false, isWritable: true },\n      { pubkey: owner, isSigner: false, isWritable: false },\n      { pubkey: mint, isSigner: false, isWritable: false },\n      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },\n      { pubkey: tokenProgram, isSigner: false, isWritable: false },\n    ];\n\n    return new TransactionInstruction({\n      keys,\n      programId: ASSOCIATED_TOKEN_PROGRAM_ID,\n      data: Buffer.from([1]),\n    });\n  }\n\n  /**\n   * Initialize global configuration (Authority only)\n   */\n  async initializeConfig(authority: PublicKey): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n    return await this.program.methods\n      .initializeConfig()\n      .accountsPartial({\n        globalConfig,\n        authority: authority,\n        systemProgram: SystemProgram.programId,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to initialize config\n   */\n  async buildInitializeConfigTx(authority: PublicKey): Promise<Transaction> {\n    const ix = await this.initializeConfig(authority);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Migrate GlobalConfig to new version with fee_claim_bps field (Authority only)\n   * Should be called once after program upgrade\n   */\n  async migrateConfig(authority: PublicKey): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n    return await this.program.methods\n      .migrateConfig()\n      .accountsPartial({\n        globalConfig,\n        authority: authority,\n        systemProgram: SystemProgram.programId,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to migrate config\n   */\n  async buildMigrateConfigTx(authority: PublicKey): Promise<Transaction> {\n    const ix = await this.migrateConfig(authority);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Update authorized admin (Authority only)\n   */\n  async addAdmin(newAdmin: PublicKey): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    return await this.program.methods\n      .addAdmin(newAdmin)\n      .accountsPartial({\n        globalConfig,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to update admin\n   */\n  async buildAddAdminTx(newAdmin: PublicKey): Promise<Transaction> {\n    const ix = await this.addAdmin(newAdmin);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Remove authorized admin (Authority only)\n   */\n  async removeAdmin(adminToRemove: PublicKey): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    return await this.program.methods\n      .removeAdmin(adminToRemove)\n      .accountsPartial({\n        globalConfig,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to remove admin\n   */\n  async buildRemoveAdminTx(adminToRemove: PublicKey): Promise<Transaction> {\n    const ix = await this.removeAdmin(adminToRemove);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Update fee configuration (Authority or authorized admin)\n   */\n  async updateFeeConfig(params: UpdateFeeConfigParams): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    return await this.program.methods\n      .updateFeeConfig(params.newFeeBps, params.newFeeRecipient, params.newFeeClaimBps)\n      .accountsPartial({\n        globalConfig: globalConfig,\n        authority: params.authority,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to update fee config\n   */\n  async buildUpdateFeeConfigTx(params: UpdateFeeConfigParams): Promise<Transaction> {\n    const ix = await this.updateFeeConfig(params);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Create a new prediction market instruction\n   */\n  async createMarket(params: CreateMarketParams): Promise<TransactionInstruction> {\n    const { admin, marketId, yesPrice, noPrice, endTime, bettingToken } = params;\n    \n    const marketIdBn = new BN(marketId);\n    const yesPriceBn = new BN(yesPrice);\n    const noPriceBn = new BN(noPrice);\n    const endTimeBn = new BN(endTime);\n\n    const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    return await this.program.methods\n      .createMarket({\n          marketId: marketIdBn,\n          yesPrice: yesPriceBn,\n          noPrice: noPriceBn,\n          endTime: endTimeBn,\n        })\n        .accountsPartial({\n          globalConfig,\n          market: pdas.market,\n          yesMint: pdas.yesMint,\n          noMint: pdas.noMint,\n          bettingToken: bettingToken,\n          vault: pdas.vault,\n          admin: admin,\n          tokenProgram: TOKEN_PROGRAM_ID,\n          systemProgram: SystemProgram.programId,\n        })\n        .instruction();\n  }\n\n  /**\n   * Build a complete transaction to create a market\n   */\n  async buildCreateMarketTx(params: CreateMarketParams): Promise<Transaction> {\n    const ix = await this.createMarket(params);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Place a bet instruction (without ATA creation)\n   */\n  async placeBet(params: PlaceBetParams): Promise<TransactionInstruction> {\n    const { user, market, amount, outcome, bettingToken, feeRecipientToken } = params;\n    \n    const amountBn = new BN(amount);\n    const outcomeEnum = outcome === \"Yes\" ? { yes: {} } : { no: {} };\n\n    // Get global config for fee info\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    // Derive PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    \n    // Determine which outcome token the user will receive\n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = outcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n\n    return await this.program.methods\n      .placeBet({\n        buyOutcome: outcomeEnum,\n        amount: amountBn,\n      })\n      .accountsPartial({\n        globalConfig,\n        market,\n        yesMint,\n        noMint,\n        vault,\n        feeRecipientToken: feeRecipientToken || null,\n        userOutcomeToken,\n        userBettingToken,\n        user,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to place a bet (with optional ATA creation for both outcome token and fee recipient)\n   */\n  async buildPlaceBetTx(params: PlaceBetParams): Promise<Transaction> {\n    const { user, market, outcome, bettingToken, createAta = true } = params;\n    \n    const tx = new Transaction();\n    \n    // Fetch config to check fee_bps\n    const configAccount = await this.getGlobalConfigAccount();\n    \n    // Derive mint PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    \n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = outcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n\n    // Check if user outcome ATA exists and create if needed\n    if (createAta) {\n      const exists = await this.ataExists(userOutcomeToken);\n      if (!exists) {\n        const createAtaIx = this.createAtaInstruction(user, user, targetMint, TOKEN_2022_PROGRAM_ID);\n        tx.add(createAtaIx);\n      }\n    }\n\n    // Handle fee recipient token account if fee_bps > 0\n    let feeRecipientToken: PublicKey | null = null;\n    if (configAccount.feeBps > 0) {\n      const feeRecipientAddress = params.feeRecipient || configAccount.feeRecipient;\n      feeRecipientToken = getAssociatedTokenAddressSync(bettingToken, feeRecipientAddress);\n      \n      // Check if fee recipient ATA exists and create if needed\n      const feeAtaExists = await this.ataExists(feeRecipientToken);\n      if (!feeAtaExists) {\n        const createFeeAtaIx = this.createAtaInstruction(user, feeRecipientAddress, bettingToken);\n        tx.add(createFeeAtaIx);\n      }\n    }\n\n    const placeBetIx = await this.placeBet({\n      ...params,\n      feeRecipientToken,\n    });\n    tx.add(placeBetIx);\n\n    return tx;\n  }\n\n  /**\n   * Claim rewards after market resolution\n   */\n  async claimRewards(params: ClaimRewardsParams): Promise<TransactionInstruction> {\n    const { user, market, bettingToken, winningOutcome } = params;\n\n    // Derive mint PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = winningOutcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n    const sharesToClaimBn = new BN(params.sharesToClaim);\n    const closeAccount = params.closeAccount ?? true;\n    return await this.program.methods\n      .claimRewards({\n        tokenAmount: sharesToClaimBn,\n        closeAccount,\n      })\n      .accountsPartial({\n        market,\n        yesMint,\n        noMint,\n        vault,\n        userOutcomeToken,\n        userBettingToken,\n        user,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to claim rewards\n   */\n  async buildClaimRewardsTx(params: ClaimRewardsParams): Promise<Transaction> {\n    const { user, market, bettingToken, winningOutcome } = params;\n    const tx = new Transaction();\n\n    // Derive mint PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = winningOutcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n    const sharesToClaimBn = new BN(params.sharesToClaim);\n    const closeAccount = params.closeAccount ?? true;\n\n    const ix = await this.program.methods\n      .claimRewards({\n        tokenAmount: sharesToClaimBn,\n        closeAccount,\n      })\n      .accountsPartial({\n        market,\n        yesMint,\n        noMint,\n        vault,\n        userOutcomeToken,\n        userBettingToken,\n        user,\n      })\n      .instruction();\n    \n    tx.add(ix);\n    return tx;\n  }\n\n  /**\n   * Build instructions to claim rewards from multiple markets\n   * Returns an array of instructions that can be batched into transactions\n   */\n  async batchClaimRewards(params: BatchClaimParams): Promise<TransactionInstruction[]> {\n    const { user, claims } = params;\n    const instructions: TransactionInstruction[] = [];\n\n    for (const claim of claims) {\n      const ix = await this.claimRewards({\n        user,\n        market: claim.market,\n        bettingToken: claim.bettingToken,\n        winningOutcome: claim.winningOutcome,\n        sharesToClaim: claim.sharesToClaim ?? 0,\n        closeAccount: claim.closeAccount ?? true,\n      });\n      instructions.push(ix);\n    }\n\n    return instructions;\n  }\n\n  /**\n   * Build transactions to claim rewards from multiple markets\n   * Automatically splits into multiple transactions if needed (max 5 claims per tx to avoid size limits)\n   * @param params - Batch claim parameters\n   * @param maxClaimsPerTx - Maximum claims per transaction (default: 5)\n   * @returns Array of transactions\n   */\n  async buildBatchClaimRewardsTx(\n    params: BatchClaimParams,\n    maxClaimsPerTx: number = 5\n  ): Promise<Transaction[]> {\n    const instructions = await this.batchClaimRewards(params);\n    const transactions: Transaction[] = [];\n\n    // Split instructions into chunks\n    for (let i = 0; i < instructions.length; i += maxClaimsPerTx) {\n      const chunk = instructions.slice(i, i + maxClaimsPerTx);\n      const tx = new Transaction();\n      chunk.forEach(ix => tx.add(ix));\n      transactions.push(tx);\n    }\n\n    return transactions;\n  }\n\n  /**\n   * Refund bets if market is refunded\n   * @param params.tokenAmount - Amount of shares to refund. 0 or undefined means refund all shares.\n   *                             This allows users to partially refund their position across multiple transactions.\n   */\n  async refund(params: RefundParams): Promise<TransactionInstruction> {\n    const { user, market, bettingToken, outcome, tokenAmount, closeAccount = true } = params;\n    \n    const outcomeEnum = outcome === \"Yes\" ? { yes: {} } : { no: {} };\n    \n    // Convert tokenAmount to BN (0 means refund all)\n    const tokenAmountBn = new BN(tokenAmount ?? 0);\n    \n    // Derive mint PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = outcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n\n    return await this.program.methods\n      .refund({\n        outcome: outcomeEnum,\n        tokenAmount: tokenAmountBn,\n        closeAccount,\n      })\n      .accountsPartial({\n        market: market,\n        yesMint: yesMint,\n        noMint: noMint,\n        vault: vault,\n        userOutcomeToken: userOutcomeToken,\n        userBettingToken: userBettingToken,\n        tokenProgram: TOKEN_PROGRAM_ID,\n        token2022Program: TOKEN_2022_PROGRAM_ID,\n        user: user,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to refund\n   */\n  async buildRefundTx(params: RefundParams): Promise<Transaction> {\n    const ix = await this.refund(params);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Resolve a market (Admin only)\n   */\n  async resolveMarketByID(\n    admin: PublicKey,\n    marketId: number | BN,\n    winningOutcome: \"Yes\" | \"No\" | null,\n    feeRecipient?: PublicKey\n  ): Promise<TransactionInstruction> {\n    const marketIdBn = new BN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    let outcomeEnum: any = null;\n    if (winningOutcome === \"Yes\") {\n      outcomeEnum = { yes: {} };\n    } else if (winningOutcome === \"No\") {\n      outcomeEnum = { no: {} };\n    }\n\n    // Get market info to determine betting token\n    const marketInfo = await this.getMarketInfo(marketPda);\n    // fee recipient address\n    const feeRecipientAddress = feeRecipient || (await this.getGlobalConfigAccount()).feeRecipient;\n    // fee recipient token account (allowOwnerOffCurve for multisig/PDA)\n    const feeRecipientToken = getAssociatedTokenAddressSync(marketInfo.bettingToken, feeRecipientAddress, true);\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), marketPda.toBuffer()],\n      this.program.programId\n    )[0];\n\n    return await this.program.methods\n      .resolveMarket(outcomeEnum)\n      .accountsPartial({\n        globalConfig,\n        market: marketPda,\n        vault,\n        feeRecipient: feeRecipientToken,\n        admin,\n        tokenProgram: TOKEN_PROGRAM_ID,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to resolve a market\n   */\n  async buildResolveMarketTxByID(\n    admin: PublicKey,\n    marketId: number | BN,\n    winningOutcome: \"Yes\" | \"No\" | null,\n    feeRecipient?: PublicKey\n  ): Promise<Transaction> {\n    const marketIdBn = new BN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n    const marketInfo = await this.getMarketInfo(marketPda);\n    const globalConfigAccount = await this.getGlobalConfigAccount();\n    const feeRecipientAddress = feeRecipient || globalConfigAccount.feeRecipient;\n    // allowOwnerOffCurve for multisig/PDA fee recipients\n    const feeRecipientToken = getAssociatedTokenAddressSync(marketInfo.bettingToken, feeRecipientAddress, true);\n\n    const tx = new Transaction();\n\n    // Check if fee recipient token account exists and create if needed\n    const feeRecipientAtaExists = await this.ataExists(feeRecipientToken);\n    if (!feeRecipientAtaExists) {\n      const createFeeRecipientAtaIx = this.createAtaInstruction(admin, feeRecipientAddress, marketInfo.bettingToken);\n      tx.add(createFeeRecipientAtaIx);\n    }\n\n    // Add resolve market instruction\n    const resolveMarketIx = await this.resolveMarketByID(admin, marketId, winningOutcome, feeRecipient);\n    tx.add(resolveMarketIx);\n\n    return tx;\n  }\n\n  /**\n   * Resolve a market (Admin only)\n   */\n  async resolveMarket(\n    admin: PublicKey,\n    market: PublicKey,\n    winningOutcome: \"Yes\" | \"No\" | null,\n    feeRecipient?: PublicKey\n  ): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    let outcomeEnum: any = null;\n    if (winningOutcome === \"Yes\") {\n      outcomeEnum = { yes: {} };\n    } else if (winningOutcome === \"No\") {\n      outcomeEnum = { no: {} };\n    }\n\n    // Get market info to determine betting token\n    const marketInfo = await this.getMarketInfo(market);\n    const feeRecipientAddress = feeRecipient || (await this.getGlobalConfigAccount()).feeRecipient;\n    // allowOwnerOffCurve for multisig/PDA fee recipients\n    const feeRecipientToken = getAssociatedTokenAddressSync(marketInfo.bettingToken, feeRecipientAddress, true);\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    return await this.program.methods\n      .resolveMarket(outcomeEnum)\n      .accountsPartial({\n        globalConfig,\n        market: market,\n        vault,\n        feeRecipient: feeRecipientToken,\n        admin,\n        tokenProgram: TOKEN_PROGRAM_ID,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to resolve a market\n   */\n  async buildResolveMarketTx(\n    admin: PublicKey,\n    market: PublicKey,\n    winningOutcome: \"Yes\" | \"No\" | null,\n    feeRecipient?: PublicKey\n  ): Promise<Transaction> {\n    const marketInfo = await this.getMarketInfo(market);\n    const globalConfigAccount = await this.getGlobalConfigAccount();\n    const feeRecipientAddress = feeRecipient || globalConfigAccount.feeRecipient;\n    // allowOwnerOffCurve for multisig/PDA fee recipients\n    const feeRecipientToken = getAssociatedTokenAddressSync(marketInfo.bettingToken, feeRecipientAddress, true);\n\n    const tx = new Transaction();\n\n    // Check if fee recipient token account exists and create if needed\n    const feeRecipientAtaExists = await this.ataExists(feeRecipientToken);\n    if (!feeRecipientAtaExists) {\n      const createFeeRecipientAtaIx = this.createAtaInstruction(admin, feeRecipientAddress, marketInfo.bettingToken);\n      tx.add(createFeeRecipientAtaIx);\n    }\n\n    // Add resolve market instruction\n    const resolveMarketIx = await this.resolveMarket(admin, market, winningOutcome, feeRecipient);\n    tx.add(resolveMarketIx);\n\n    return tx;\n  }\n\n  /**\n   * Close a market (Admin only)\n   */\n  async closeMarket(\n    admin: PublicKey,\n    market: PublicKey\n  ): Promise<TransactionInstruction> {\n    return await this.program.methods\n      .closeMarket()\n      .accountsPartial({\n        market: market,\n        admin: admin,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to close a market\n   */\n  async buildCloseMarketTx(\n    admin: PublicKey,\n    market: PublicKey\n  ): Promise<Transaction> {\n    const ix = await this.closeMarket(admin, market);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Close a market (Admin only)\n   */\n  async closeMarketByID(\n    admin: PublicKey,\n    marketId: number | BN\n  ): Promise<TransactionInstruction> {\n    const marketIdBn = new BN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n\n    return await this.program.methods\n      .closeMarket()\n      .accountsPartial({\n        market: marketPda,\n        admin: admin,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to close a market\n   */\n  async buildCloseMarketTxByID(\n    admin: PublicKey,\n    marketId: number | BN\n  ): Promise<Transaction> {\n    const ix = await this.closeMarketByID(admin, marketId);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Close market account and reclaim rent (Admin only)\n   * Can only be called after market is resolved and all rewards claimed\n   */\n  async closeMarketAccount(\n    admin: PublicKey,\n    market: PublicKey\n  ): Promise<TransactionInstruction> {\n    // Derive PDAs\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    return await this.program.methods\n      .closeMarketAccount()\n      .accountsPartial({\n        market,\n        yesMint,\n        noMint,\n        vault,\n        admin,\n        tokenProgram: TOKEN_PROGRAM_ID,\n        token2022Program: TOKEN_2022_PROGRAM_ID,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to close market account\n   */\n  async buildCloseMarketAccountTx(\n    admin: PublicKey,\n    market: PublicKey\n  ): Promise<Transaction> {\n    const ix = await this.closeMarketAccount(admin, market);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Burn worthless tokens from the losing side of a resolved market.\n   * This allows users to clean up their losing tokens so the market account can be closed.\n   * @param user - The user who holds losing tokens\n   * @param market - The market PDA\n   * @param losingOutcome - The outcome that lost (the side to burn)\n   * @param tokenAmount - Amount to burn (0 = burn all)\n   * @param closeAccount - Whether to close the losing token account after burning all tokens (default: false)\n   */\n  async burnMarketTokens(\n    user: PublicKey,\n    market: PublicKey,\n    losingOutcome: Outcome,\n    tokenAmount: number | BN = 0,\n    closeAccount: boolean = false\n  ): Promise<TransactionInstruction> {\n    // Derive PDAs\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    // The losing mint is the side that lost\n    const losingMint = losingOutcome === \"Yes\" ? yesMint : noMint;\n    const userLosingToken = getAssociatedTokenAddressSync(losingMint, user, false, TOKEN_2022_PROGRAM_ID);\n\n    return await this.program.methods\n      .burnMarketTokens({\n        tokenAmount: new BN(tokenAmount),\n        closeAccount,\n      })\n      .accountsPartial({\n        market,\n        yesMint,\n        noMint,\n        losingMint,\n        userLosingToken,\n        user,\n        token2022Program: TOKEN_2022_PROGRAM_ID,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to burn market tokens\n   * @param closeAccount - Whether to close the losing token account after burning all tokens (default: false)\n   */\n  async buildBurnMarketTokensTx(\n    user: PublicKey,\n    market: PublicKey,\n    losingOutcome: Outcome,\n    tokenAmount: number | BN = 0,\n    closeAccount: boolean = true\n  ): Promise<Transaction> {\n    const ix = await this.burnMarketTokens(user, market, losingOutcome, tokenAmount, closeAccount);\n    return new Transaction().add(ix);\n  }\n  \n  /**\n   * Fetch global config account data\n   */\n  async getGlobalConfigAccount() {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n    return await this.program.account.globalConfig.fetch(globalConfig);\n  }\n\n  /**\n   * Fetch market account data\n   */\n  async getMarketAccount(admin: PublicKey, marketId: number | BN) {\n    const marketIdBn = new BN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n    return await this.program.account.market.fetch(marketPda);\n  }\n\n  async getMarketInfo(marketPda: PublicKey) {\n    const marketAccount = await this.program.account.market.fetch(marketPda);\n    return marketAccount;\n  }\n\n  /**\n   * Fetch vault account data\n   */\n  async getVaultAccount(marketPda: PublicKey) {\n    const vaultPda = getVaultPda(this.program.programId, marketPda);\n    return await getAccount(this.connection, vaultPda);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ASSOCIATED_TOKEN_PROGRAM_ID,\n  createTransferInstruction,\n  getAccount,\n  getAssociatedTokenAddressSync,\n  TOKEN_2022_PROGRAM_ID,\n  TOKEN_PROGRAM_ID\n} from \"@solana/spl-token\";\n\nimport { Program as AnchorProgram, AnchorProvider, Idl, Program, Wallet } from \"@coral-xyz/anchor\";\n\nimport BN from \"bn.js\";\n\nimport {\n  Connection,\n  Keypair,\n  PublicKey,\n  SystemProgram,\n  Transaction,\n  TransactionInstruction\n} from \"@solana/web3.js\";\nimport { IDL } from \"./idl.js\";\nimport { DramaPm } from \"./types.js\";\nimport {\n  getGlobalConfigPda,\n  getMarketPda,\n  getMarketPdas,\n  getVaultPda,\n  NO_MINT_SEED,\n  VAULT_SEED,\n  YES_MINT_SEED\n} from \"./utils.js\";\n\nexport * from \"./utils.js\";\nexport { DramaPm, IDL };\n\nexport type Outcome = \"Yes\" | \"No\";\n\nexport interface CreateMarketParams {\n  admin: PublicKey;\n  marketId: number | BN;\n  yesPrice: number | BN;\n  noPrice: number | BN;\n  endTime: number | BN;\n  bettingToken: PublicKey;\n}\n\nexport interface PlaceBetParams {\n  user: PublicKey;\n  market: PublicKey; // Market PDA address\n  amount: number | BN;\n  outcome: Outcome;\n  bettingToken: PublicKey;\n  feeRecipient?: PublicKey; // Fee recipient address (optional, will fetch from config if not provided)\n  feeRecipientToken?: PublicKey | null; // Fee recipient token account (optional, used internally by buildPlaceBetTx)\n  createAta?: boolean; // Whether to create ATA instruction automatically\n}\n\nexport interface UpdateFeeConfigParams {\n  authority: PublicKey; // Can be authority or authorized admin\n  newFeeBps: number; // Fee in basis points (1 bps = 0.01%, max 2000 = 20%)\n  newFeeRecipient: PublicKey;\n  newFeeClaimBps: number; // Fee for claiming rewards in basis points\n}\n\nexport interface ClaimRewardsParams {\n  user: PublicKey;\n  market: PublicKey; // Market PDA address\n  bettingToken: PublicKey;\n  winningOutcome: Outcome;\n  sharesToClaim: number | BN; // Amount of shares to claim (0 = claim all)\n  closeAccount?: boolean; // Whether to close the outcome token account after claiming all shares (default: false)\n  feeRecipient?: PublicKey; // Fee recipient address (optional, will fetch from config if not provided)\n}\n\nexport interface BatchClaimParams {\n  user: PublicKey;\n  claims: Array<{\n    market: PublicKey;\n    bettingToken: PublicKey;\n    winningOutcome: Outcome;\n    sharesToClaim?: number | BN; // Amount of shares to claim (0 or undefined = claim all)\n    closeAccount?: boolean; // Whether to close the outcome token account after claiming all shares\n  }>;\n}\n\nexport interface RefundParams {\n  user: PublicKey;\n  market: PublicKey; // Market PDA address\n  bettingToken: PublicKey;\n  outcome: Outcome;\n  tokenAmount?: number | BN; // Amount of shares to refund. 0 or undefined means refund all shares.\n  closeAccount?: boolean; // Whether to close the outcome token account after refunding all shares (default: false)\n}\n\n/**\n * Parameters for placeBetV2 - combines user bet and bonus account bet in one transaction\n * Requires both user and bonusAccount to sign the transaction\n */\nexport interface PlaceBetV2Params {\n  user: PublicKey;              // User's public key (signer)\n  bonusAccount: PublicKey;      // Bonus account public key (signer)\n  market: PublicKey;            // Market PDA address\n  userAmount: number | BN;      // Amount user pays\n  bonusAmount: number | BN;     // Amount bonus account pays\n  outcome: Outcome;             // Outcome to bet on (Yes/No)\n  bettingToken: PublicKey;      // Betting token mint\n  feeRecipient?: PublicKey;     // Fee recipient address (optional)\n  createAta?: boolean;          // Whether to create ATA instruction automatically\n}\n\n/**\n * Result from buildPlaceBetV2Tx containing both the transaction and its serialized form\n * for split signing workflow (frontend user sign + backend bonus sign)\n */\nexport interface PlaceBetV2Result {\n  transaction: Transaction;     // Transaction object for local signing (testing)\n  requiredSigners: PublicKey[]; // List of required signers [user, bonusAccount]\n}\n\nexport class DramaPmClient {\n  program: Program<DramaPm>;\n  provider: AnchorProvider;\n  connection: Connection;\n\n  constructor(connection: Connection, wallet?: Wallet, programId?: PublicKey) {\n    this.connection = connection;\n    \n    // Create a default wallet if none provided\n    const defaultKeypair = Keypair.generate();\n    const defaultWallet: Wallet = {\n      publicKey: defaultKeypair.publicKey,\n      signTransaction: async (tx) => tx,\n      signAllTransactions: async (txs) => txs,\n      payer: defaultKeypair,\n    };\n    \n    this.provider = new AnchorProvider(\n      connection,\n      wallet || defaultWallet,\n      { commitment: \"confirmed\" }\n    );\n    \n    // Use custom programId if provided, otherwise use the default from IDL\n    const finalProgramId = programId || new PublicKey(IDL.address);\n    \n    // Create a new IDL with the custom programId\n    const customIdl = { ...IDL, address: finalProgramId.toBase58() };\n    \n    this.program = new AnchorProgram(customIdl as Idl, this.provider) as unknown as Program<DramaPm>;\n  }\n\n  /**\n   * Get the current program ID\n   */\n  getProgramId(): PublicKey {\n    return this.program.programId;\n  }\n\n  /**\n   * Set a new program ID and reinitialize the program instance\n   * Useful when redeploying the program to a new address\n   */\n  setProgramId(programId: PublicKey): void {\n    const customIdl = { ...IDL, address: programId.toBase58() };\n    this.program = new AnchorProgram(customIdl as Idl, this.provider) as unknown as Program<DramaPm>;\n  }\n\n  /**\n   * Check if an associated token account exists\n   */\n  async ataExists(ata: PublicKey): Promise<boolean> {\n    try {\n      await getAccount(this.connection, ata);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Create an instruction to initialize an associated token account\n   * @param tokenProgram - Token program ID (TOKEN_PROGRAM_ID for betting token, TOKEN_2022_PROGRAM_ID for outcome tokens)\n   */\n  createAtaInstruction(\n    payer: PublicKey,\n    owner: PublicKey,\n    mint: PublicKey,\n    tokenProgram: PublicKey = TOKEN_PROGRAM_ID\n  ): TransactionInstruction {\n    const ata = getAssociatedTokenAddressSync(mint, owner, true, tokenProgram);\n    \n    // Use CreateIdempotent instruction (opcode 1) to support PDAs and idempotency\n    const keys = [\n      { pubkey: payer, isSigner: true, isWritable: true },\n      { pubkey: ata, isSigner: false, isWritable: true },\n      { pubkey: owner, isSigner: false, isWritable: false },\n      { pubkey: mint, isSigner: false, isWritable: false },\n      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },\n      { pubkey: tokenProgram, isSigner: false, isWritable: false },\n    ];\n\n    return new TransactionInstruction({\n      keys,\n      programId: ASSOCIATED_TOKEN_PROGRAM_ID,\n      data: Buffer.from([1]),\n    });\n  }\n\n  /**\n   * Initialize global configuration (Authority only)\n   */\n  async initializeConfig(authority: PublicKey): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n    return await this.program.methods\n      .initializeConfig()\n      .accountsPartial({\n        globalConfig,\n        authority: authority,\n        systemProgram: SystemProgram.programId,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to initialize config\n   */\n  async buildInitializeConfigTx(authority: PublicKey): Promise<Transaction> {\n    const ix = await this.initializeConfig(authority);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Migrate GlobalConfig to new version with fee_claim_bps field (Authority only)\n   * Should be called once after program upgrade\n   */\n  async migrateConfig(authority: PublicKey): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n    return await this.program.methods\n      .migrateConfig()\n      .accountsPartial({\n        globalConfig,\n        authority: authority,\n        systemProgram: SystemProgram.programId,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to migrate config\n   */\n  async buildMigrateConfigTx(authority: PublicKey): Promise<Transaction> {\n    const ix = await this.migrateConfig(authority);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Update authorized admin (Authority only)\n   */\n  async addAdmin(newAdmin: PublicKey): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    return await this.program.methods\n      .addAdmin(newAdmin)\n      .accountsPartial({\n        globalConfig,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to update admin\n   */\n  async buildAddAdminTx(newAdmin: PublicKey): Promise<Transaction> {\n    const ix = await this.addAdmin(newAdmin);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Remove authorized admin (Authority only)\n   */\n  async removeAdmin(adminToRemove: PublicKey): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    return await this.program.methods\n      .removeAdmin(adminToRemove)\n      .accountsPartial({\n        globalConfig,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to remove admin\n   */\n  async buildRemoveAdminTx(adminToRemove: PublicKey): Promise<Transaction> {\n    const ix = await this.removeAdmin(adminToRemove);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Update fee configuration (Authority or authorized admin)\n   */\n  async updateFeeConfig(params: UpdateFeeConfigParams): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    return await this.program.methods\n      .updateFeeConfig(params.newFeeBps, params.newFeeRecipient, params.newFeeClaimBps)\n      .accountsPartial({\n        globalConfig: globalConfig,\n        authority: params.authority,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to update fee config\n   */\n  async buildUpdateFeeConfigTx(params: UpdateFeeConfigParams): Promise<Transaction> {\n    const ix = await this.updateFeeConfig(params);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Create a new prediction market instruction\n   */\n  async createMarket(params: CreateMarketParams): Promise<TransactionInstruction> {\n    const { admin, marketId, yesPrice, noPrice, endTime, bettingToken } = params;\n    \n    const marketIdBn = new BN(marketId);\n    const yesPriceBn = new BN(yesPrice);\n    const noPriceBn = new BN(noPrice);\n    const endTimeBn = new BN(endTime);\n\n    const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    return await this.program.methods\n      .createMarket({\n          marketId: marketIdBn,\n          yesPrice: yesPriceBn,\n          noPrice: noPriceBn,\n          endTime: endTimeBn,\n        })\n        .accountsPartial({\n          globalConfig,\n          market: pdas.market,\n          yesMint: pdas.yesMint,\n          noMint: pdas.noMint,\n          bettingToken: bettingToken,\n          vault: pdas.vault,\n          admin: admin,\n          tokenProgram: TOKEN_PROGRAM_ID,\n          systemProgram: SystemProgram.programId,\n        })\n        .instruction();\n  }\n\n  /**\n   * Build a complete transaction to create a market\n   */\n  async buildCreateMarketTx(params: CreateMarketParams): Promise<Transaction> {\n    const ix = await this.createMarket(params);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Place a bet instruction (without ATA creation)\n   */\n  async placeBet(params: PlaceBetParams): Promise<TransactionInstruction> {\n    const { user, market, amount, outcome, bettingToken, feeRecipientToken } = params;\n    \n    const amountBn = new BN(amount);\n    const outcomeEnum = outcome === \"Yes\" ? { yes: {} } : { no: {} };\n\n    // Get global config for fee info\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    // Derive PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    \n    // Determine which outcome token the user will receive\n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = outcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n\n    return await this.program.methods\n      .placeBet({\n        buyOutcome: outcomeEnum,\n        amount: amountBn,\n      })\n      .accountsPartial({\n        globalConfig,\n        market,\n        yesMint,\n        noMint,\n        vault,\n        feeRecipientToken: feeRecipientToken || null,\n        userOutcomeToken,\n        userBettingToken,\n        user,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to place a bet (with optional ATA creation for both outcome token and fee recipient)\n   */\n  async buildPlaceBetTx(params: PlaceBetParams): Promise<Transaction> {\n    const { user, market, outcome, bettingToken, createAta = true } = params;\n    \n    const tx = new Transaction();\n    \n    // Fetch config to check fee_bps\n    const configAccount = await this.getGlobalConfigAccount();\n    \n    // Derive mint PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    \n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = outcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n\n    // Check if user outcome ATA exists and create if needed\n    if (createAta) {\n      const exists = await this.ataExists(userOutcomeToken);\n      if (!exists) {\n        const createAtaIx = this.createAtaInstruction(user, user, targetMint, TOKEN_2022_PROGRAM_ID);\n        tx.add(createAtaIx);\n      }\n    }\n\n    // Handle fee recipient token account if fee_bps > 0\n    let feeRecipientToken: PublicKey | null = null;\n    if (configAccount.feeBps > 0) {\n      const feeRecipientAddress = params.feeRecipient || configAccount.feeRecipient;\n      feeRecipientToken = getAssociatedTokenAddressSync(bettingToken, feeRecipientAddress);\n      \n      // Check if fee recipient ATA exists and create if needed\n      const feeAtaExists = await this.ataExists(feeRecipientToken);\n      if (!feeAtaExists) {\n        const createFeeAtaIx = this.createAtaInstruction(user, feeRecipientAddress, bettingToken);\n        tx.add(createFeeAtaIx);\n      }\n    }\n\n    const placeBetIx = await this.placeBet({\n      ...params,\n      feeRecipientToken,\n    });\n    tx.add(placeBetIx);\n\n    return tx;\n  }\n\n  /**\n   * Build a transaction to place bets from both user and bonus account in one transaction.\n   * This transaction requires two signers: user and bonusAccount.\n   * \n   * Use case: User pays part of the bet, bonus account (backend) pays the rest.\n   * Example: User bets 10U total, user pays 8U, bonus account pays 2U.\n   * \n   * Both bets are placed on the same outcome, but outcome tokens go to each account respectively.\n   */\n  async buildPlaceBetV2Tx(params: PlaceBetV2Params): Promise<PlaceBetV2Result> {\n    const { \n      user, \n      bonusAccount, \n      market, \n      userAmount, \n      bonusAmount, \n      outcome, \n      bettingToken, \n      createAta = true \n    } = params;\n    \n    const tx = new Transaction();\n    \n    // Fetch config to check fee_bps\n    const configAccount = await this.getGlobalConfigAccount();\n    \n    // Derive mint PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    \n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = outcome === \"Yes\" ? yesMint : noMint;\n    \n    // User's outcome token account\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n    \n    // Bonus account's outcome token account\n    const bonusOutcomeToken = getAssociatedTokenAddressSync(targetMint, bonusAccount, false, TOKEN_2022_PROGRAM_ID);\n\n    // Create ATAs if needed\n    if (createAta) {\n      // Check if user outcome ATA exists and create if needed\n      const userAtaExists = await this.ataExists(userOutcomeToken);\n      if (!userAtaExists) {\n        const createUserAtaIx = this.createAtaInstruction(user, user, targetMint, TOKEN_2022_PROGRAM_ID);\n        tx.add(createUserAtaIx);\n      }\n      \n      // Check if bonus account outcome ATA exists and create if needed\n      const bonusAtaExists = await this.ataExists(bonusOutcomeToken);\n      if (!bonusAtaExists) {\n        // User pays for creating the bonus account's ATA\n        const createBonusAtaIx = this.createAtaInstruction(user, bonusAccount, targetMint, TOKEN_2022_PROGRAM_ID);\n        tx.add(createBonusAtaIx);\n      }\n    }\n\n    // Handle fee recipient token account if fee_bps > 0\n    let feeRecipientToken: PublicKey | null = null;\n    if (configAccount.feeBps > 0) {\n      const feeRecipientAddress = params.feeRecipient || configAccount.feeRecipient;\n      feeRecipientToken = getAssociatedTokenAddressSync(bettingToken, feeRecipientAddress);\n      \n      // Check if fee recipient ATA exists and create if needed\n      const feeAtaExists = await this.ataExists(feeRecipientToken);\n      if (!feeAtaExists) {\n        const createFeeAtaIx = this.createAtaInstruction(user, feeRecipientAddress, bettingToken);\n        tx.add(createFeeAtaIx);\n      }\n    }\n\n    // Create user's placeBet instruction\n    const userBetIx = await this.placeBet({\n      user,\n      market,\n      amount: userAmount,\n      outcome,\n      bettingToken,\n      feeRecipientToken,\n    });\n    tx.add(userBetIx);\n\n    // Create bonus account's placeBet instruction\n    const bonusBetIx = await this.placeBet({\n      user: bonusAccount,\n      market,\n      amount: bonusAmount,\n      outcome,\n      bettingToken,\n      feeRecipientToken,\n    });\n    tx.add(bonusBetIx);\n    return {\n      transaction: tx,\n      requiredSigners: [user, bonusAccount],\n    };\n  }\n\n  async withdrawBonus() {\n    \n  }\n\n  /**\n   * Deserialize a base64 encoded transaction\n   * Use this on frontend to decode the transaction received from backend\n   */\n  static deserializeTransaction(serializedTx: string): Transaction {\n    const buffer = Buffer.from(serializedTx, 'base64');\n    return Transaction.from(buffer);\n  }\n\n  /**\n   * Sign a partially signed transaction with the bonus account (backend side)\n   * \n   * @param userSignedTxBase64 - Base64 encoded transaction that has been signed by user\n   * @param bonusAccountKeypair - The bonus account keypair for signing\n   * @returns The fully signed transaction ready for submission\n   */\n  static signWithKeyPair(userSignedTxBase64: string, keyPair: Keypair): Transaction {\n    const buffer = Buffer.from(userSignedTxBase64, 'base64');\n    const tx = Transaction.from(buffer);\n    tx.partialSign(keyPair);\n    return tx;\n  }\n\n  // async transfer()\n\n  /**\n   * Build a transaction to withdraw bonus (transfer USDT from bonus account to user)\n   * This transaction requires the bonus account to sign.\n   * \n   * @param bonusAccount - The bonus account public key (signer, source of funds)\n   * @param user - The user's public key (destination)\n   * @param tokenMint - The token mint address (e.g., USDT)\n   * @param amount - Amount to transfer (in token's smallest unit, e.g., 1_000_000 for 1 USDT with 6 decimals)\n   * @param createAta - Whether to create the user's ATA if it doesn't exist (default: true)\n   * @returns Transaction ready for signing\n   */\n  async buildWithdrawBonusTx(params: {\n    bonusAccount: PublicKey;\n    user: PublicKey;\n    tokenMint: PublicKey;\n    amount: number | BN;\n    createAta?: boolean;\n  }): Promise<Transaction> {\n    const { bonusAccount, user, tokenMint, amount, createAta = true } = params;\n    const amountBn = new BN(amount);\n    \n    const tx = new Transaction();\n    \n    // Get ATA addresses for both accounts\n    const bonusTokenAccount = getAssociatedTokenAddressSync(tokenMint, bonusAccount);\n    const userTokenAccount = getAssociatedTokenAddressSync(tokenMint, user);\n    \n    // Create user's ATA if needed\n    if (createAta) {\n      const userAtaExists = await this.ataExists(userTokenAccount);\n      if (!userAtaExists) {\n        const createUserAtaIx = this.createAtaInstruction(bonusAccount, user, tokenMint);\n        tx.add(createUserAtaIx);\n      }\n    }\n    \n    // Create transfer instruction\n    const transferIx = createTransferInstruction(\n      bonusTokenAccount,  // source\n      userTokenAccount,   // destination\n      bonusAccount,       // owner (signer)\n      BigInt(amountBn.toString()),  // amount\n      [],                 // multiSigners (empty for single signer)\n      TOKEN_PROGRAM_ID    // program id\n    );\n    tx.add(transferIx);\n    \n    return tx;\n  }\n\n  /**\n   * Build and return a transaction for withdrawing bonus with serialization info\n   * Useful for split signing workflow where user/admin builds tx and bonus account signs\n   * \n   * @returns Object containing transaction and required signers\n   */\n  async buildWithdrawBonusTxWithInfo(params: {\n    bonusAccount: PublicKey;\n    user: PublicKey;\n    tokenMint: PublicKey;\n    amount: number | BN;\n    createAta?: boolean;\n  }): Promise<{ transaction: Transaction; requiredSigners: PublicKey[] }> {\n    const tx = await this.buildWithdrawBonusTx(params);\n    return {\n      transaction: tx,\n      requiredSigners: [params.bonusAccount],\n    };\n  }\n\n  /**\n   * Claim rewards after market resolution\n   */\n  async claimRewards(params: ClaimRewardsParams): Promise<TransactionInstruction> {\n    const { user, market, bettingToken, winningOutcome } = params;\n\n    // Derive mint PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = winningOutcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n    const sharesToClaimBn = new BN(params.sharesToClaim);\n    const closeAccount = params.closeAccount ?? true;\n    return await this.program.methods\n      .claimRewards({\n        tokenAmount: sharesToClaimBn,\n        closeAccount,\n      })\n      .accountsPartial({\n        market,\n        yesMint,\n        noMint,\n        vault,\n        userOutcomeToken,\n        userBettingToken,\n        user,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to claim rewards\n   */\n  async buildClaimRewardsTx(params: ClaimRewardsParams): Promise<Transaction> {\n    const { user, market, bettingToken, winningOutcome } = params;\n    const tx = new Transaction();\n\n    // Derive mint PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = winningOutcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n    const sharesToClaimBn = new BN(params.sharesToClaim);\n    const closeAccount = params.closeAccount ?? true;\n\n    const ix = await this.program.methods\n      .claimRewards({\n        tokenAmount: sharesToClaimBn,\n        closeAccount,\n      })\n      .accountsPartial({\n        market,\n        yesMint,\n        noMint,\n        vault,\n        userOutcomeToken,\n        userBettingToken,\n        user,\n      })\n      .instruction();\n    \n    tx.add(ix);\n    return tx;\n  }\n\n  /**\n   * Build instructions to claim rewards from multiple markets\n   * Returns an array of instructions that can be batched into transactions\n   */\n  async batchClaimRewards(params: BatchClaimParams): Promise<TransactionInstruction[]> {\n    const { user, claims } = params;\n    const instructions: TransactionInstruction[] = [];\n\n    for (const claim of claims) {\n      const ix = await this.claimRewards({\n        user,\n        market: claim.market,\n        bettingToken: claim.bettingToken,\n        winningOutcome: claim.winningOutcome,\n        sharesToClaim: claim.sharesToClaim ?? 0,\n        closeAccount: claim.closeAccount ?? true,\n      });\n      instructions.push(ix);\n    }\n\n    return instructions;\n  }\n\n  /**\n   * Build transactions to claim rewards from multiple markets\n   * Automatically splits into multiple transactions if needed (max 5 claims per tx to avoid size limits)\n   * @param params - Batch claim parameters\n   * @param maxClaimsPerTx - Maximum claims per transaction (default: 5)\n   * @returns Array of transactions\n   */\n  async buildBatchClaimRewardsTx(\n    params: BatchClaimParams,\n    maxClaimsPerTx: number = 5\n  ): Promise<Transaction[]> {\n    const instructions = await this.batchClaimRewards(params);\n    const transactions: Transaction[] = [];\n\n    // Split instructions into chunks\n    for (let i = 0; i < instructions.length; i += maxClaimsPerTx) {\n      const chunk = instructions.slice(i, i + maxClaimsPerTx);\n      const tx = new Transaction();\n      chunk.forEach(ix => tx.add(ix));\n      transactions.push(tx);\n    }\n\n    return transactions;\n  }\n\n  /**\n   * Refund bets if market is refunded\n   * @param params.tokenAmount - Amount of shares to refund. 0 or undefined means refund all shares.\n   *                             This allows users to partially refund their position across multiple transactions.\n   */\n  async refund(params: RefundParams): Promise<TransactionInstruction> {\n    const { user, market, bettingToken, outcome, tokenAmount, closeAccount = true } = params;\n    \n    const outcomeEnum = outcome === \"Yes\" ? { yes: {} } : { no: {} };\n    \n    // Convert tokenAmount to BN (0 means refund all)\n    const tokenAmountBn = new BN(tokenAmount ?? 0);\n    \n    // Derive mint PDAs from market address\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    // Outcome tokens (Yes/No) use Token-2022 program\n    const targetMint = outcome === \"Yes\" ? yesMint : noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user, false, TOKEN_2022_PROGRAM_ID);\n\n    return await this.program.methods\n      .refund({\n        outcome: outcomeEnum,\n        tokenAmount: tokenAmountBn,\n        closeAccount,\n      })\n      .accountsPartial({\n        market: market,\n        yesMint: yesMint,\n        noMint: noMint,\n        vault: vault,\n        userOutcomeToken: userOutcomeToken,\n        userBettingToken: userBettingToken,\n        tokenProgram: TOKEN_PROGRAM_ID,\n        token2022Program: TOKEN_2022_PROGRAM_ID,\n        user: user,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to refund\n   */\n  async buildRefundTx(params: RefundParams): Promise<Transaction> {\n    const ix = await this.refund(params);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Resolve a market (Admin only)\n   */\n  async resolveMarketByID(\n    admin: PublicKey,\n    marketId: number | BN,\n    winningOutcome: \"Yes\" | \"No\" | null,\n    feeRecipient?: PublicKey\n  ): Promise<TransactionInstruction> {\n    const marketIdBn = new BN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    let outcomeEnum: any = null;\n    if (winningOutcome === \"Yes\") {\n      outcomeEnum = { yes: {} };\n    } else if (winningOutcome === \"No\") {\n      outcomeEnum = { no: {} };\n    }\n\n    // Get market info to determine betting token\n    const marketInfo = await this.getMarketInfo(marketPda);\n    // fee recipient address\n    const feeRecipientAddress = feeRecipient || (await this.getGlobalConfigAccount()).feeRecipient;\n    // fee recipient token account (allowOwnerOffCurve for multisig/PDA)\n    const feeRecipientToken = getAssociatedTokenAddressSync(marketInfo.bettingToken, feeRecipientAddress, true);\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), marketPda.toBuffer()],\n      this.program.programId\n    )[0];\n\n    return await this.program.methods\n      .resolveMarket(outcomeEnum)\n      .accountsPartial({\n        globalConfig,\n        market: marketPda,\n        vault,\n        feeRecipient: feeRecipientToken,\n        admin,\n        tokenProgram: TOKEN_PROGRAM_ID,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to resolve a market\n   */\n  async buildResolveMarketTxByID(\n    admin: PublicKey,\n    marketId: number | BN,\n    winningOutcome: \"Yes\" | \"No\" | null,\n    feeRecipient?: PublicKey\n  ): Promise<Transaction> {\n    const marketIdBn = new BN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n    const marketInfo = await this.getMarketInfo(marketPda);\n    const globalConfigAccount = await this.getGlobalConfigAccount();\n    const feeRecipientAddress = feeRecipient || globalConfigAccount.feeRecipient;\n    // allowOwnerOffCurve for multisig/PDA fee recipients\n    const feeRecipientToken = getAssociatedTokenAddressSync(marketInfo.bettingToken, feeRecipientAddress, true);\n\n    const tx = new Transaction();\n\n    // Check if fee recipient token account exists and create if needed\n    const feeRecipientAtaExists = await this.ataExists(feeRecipientToken);\n    if (!feeRecipientAtaExists) {\n      const createFeeRecipientAtaIx = this.createAtaInstruction(admin, feeRecipientAddress, marketInfo.bettingToken);\n      tx.add(createFeeRecipientAtaIx);\n    }\n\n    // Add resolve market instruction\n    const resolveMarketIx = await this.resolveMarketByID(admin, marketId, winningOutcome, feeRecipient);\n    tx.add(resolveMarketIx);\n\n    return tx;\n  }\n\n  /**\n   * Resolve a market (Admin only)\n   */\n  async resolveMarket(\n    admin: PublicKey,\n    market: PublicKey,\n    winningOutcome: \"Yes\" | \"No\" | null,\n    feeRecipient?: PublicKey\n  ): Promise<TransactionInstruction> {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n\n    let outcomeEnum: any = null;\n    if (winningOutcome === \"Yes\") {\n      outcomeEnum = { yes: {} };\n    } else if (winningOutcome === \"No\") {\n      outcomeEnum = { no: {} };\n    }\n\n    // Get market info to determine betting token\n    const marketInfo = await this.getMarketInfo(market);\n    const feeRecipientAddress = feeRecipient || (await this.getGlobalConfigAccount()).feeRecipient;\n    // allowOwnerOffCurve for multisig/PDA fee recipients\n    const feeRecipientToken = getAssociatedTokenAddressSync(marketInfo.bettingToken, feeRecipientAddress, true);\n\n    // Derive vault PDA\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    return await this.program.methods\n      .resolveMarket(outcomeEnum)\n      .accountsPartial({\n        globalConfig,\n        market: market,\n        vault,\n        feeRecipient: feeRecipientToken,\n        admin,\n        tokenProgram: TOKEN_PROGRAM_ID,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to resolve a market\n   */\n  async buildResolveMarketTx(\n    admin: PublicKey,\n    market: PublicKey,\n    winningOutcome: \"Yes\" | \"No\" | null,\n    feeRecipient?: PublicKey\n  ): Promise<Transaction> {\n    const marketInfo = await this.getMarketInfo(market);\n    const globalConfigAccount = await this.getGlobalConfigAccount();\n    const feeRecipientAddress = feeRecipient || globalConfigAccount.feeRecipient;\n    // allowOwnerOffCurve for multisig/PDA fee recipients\n    const feeRecipientToken = getAssociatedTokenAddressSync(marketInfo.bettingToken, feeRecipientAddress, true);\n\n    const tx = new Transaction();\n\n    // Check if fee recipient token account exists and create if needed\n    const feeRecipientAtaExists = await this.ataExists(feeRecipientToken);\n    if (!feeRecipientAtaExists) {\n      const createFeeRecipientAtaIx = this.createAtaInstruction(admin, feeRecipientAddress, marketInfo.bettingToken);\n      tx.add(createFeeRecipientAtaIx);\n    }\n\n    // Add resolve market instruction\n    const resolveMarketIx = await this.resolveMarket(admin, market, winningOutcome, feeRecipient);\n    tx.add(resolveMarketIx);\n\n    return tx;\n  }\n\n  /**\n   * Close a market (Admin only)\n   */\n  async closeMarket(\n    admin: PublicKey,\n    market: PublicKey\n  ): Promise<TransactionInstruction> {\n    return await this.program.methods\n      .closeMarket()\n      .accountsPartial({\n        market: market,\n        admin: admin,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to close a market\n   */\n  async buildCloseMarketTx(\n    admin: PublicKey,\n    market: PublicKey\n  ): Promise<Transaction> {\n    const ix = await this.closeMarket(admin, market);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Close a market (Admin only)\n   */\n  async closeMarketByID(\n    admin: PublicKey,\n    marketId: number | BN\n  ): Promise<TransactionInstruction> {\n    const marketIdBn = new BN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n\n    return await this.program.methods\n      .closeMarket()\n      .accountsPartial({\n        market: marketPda,\n        admin: admin,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to close a market\n   */\n  async buildCloseMarketTxByID(\n    admin: PublicKey,\n    marketId: number | BN\n  ): Promise<Transaction> {\n    const ix = await this.closeMarketByID(admin, marketId);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Close market account and reclaim rent (Admin only)\n   * Can only be called after market is resolved and all rewards claimed\n   */\n  async closeMarketAccount(\n    admin: PublicKey,\n    market: PublicKey\n  ): Promise<TransactionInstruction> {\n    // Derive PDAs\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const vault = PublicKey.findProgramAddressSync(\n      [Buffer.from(VAULT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    return await this.program.methods\n      .closeMarketAccount()\n      .accountsPartial({\n        market,\n        yesMint,\n        noMint,\n        vault,\n        admin,\n        tokenProgram: TOKEN_PROGRAM_ID,\n        token2022Program: TOKEN_2022_PROGRAM_ID,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to close market account\n   */\n  async buildCloseMarketAccountTx(\n    admin: PublicKey,\n    market: PublicKey\n  ): Promise<Transaction> {\n    const ix = await this.closeMarketAccount(admin, market);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Burn worthless tokens from the losing side of a resolved market.\n   * This allows users to clean up their losing tokens so the market account can be closed.\n   * @param user - The user who holds losing tokens\n   * @param market - The market PDA\n   * @param losingOutcome - The outcome that lost (the side to burn)\n   * @param tokenAmount - Amount to burn (0 = burn all)\n   * @param closeAccount - Whether to close the losing token account after burning all tokens (default: false)\n   */\n  async burnMarketTokens(\n    user: PublicKey,\n    market: PublicKey,\n    losingOutcome: Outcome,\n    tokenAmount: number | BN = 0,\n    closeAccount: boolean = false\n  ): Promise<TransactionInstruction> {\n    // Derive PDAs\n    const yesMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(YES_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n    const noMint = PublicKey.findProgramAddressSync(\n      [Buffer.from(NO_MINT_SEED), market.toBuffer()],\n      this.program.programId\n    )[0];\n\n    // The losing mint is the side that lost\n    const losingMint = losingOutcome === \"Yes\" ? yesMint : noMint;\n    const userLosingToken = getAssociatedTokenAddressSync(losingMint, user, false, TOKEN_2022_PROGRAM_ID);\n\n    return await this.program.methods\n      .burnMarketTokens({\n        tokenAmount: new BN(tokenAmount),\n        closeAccount,\n      })\n      .accountsPartial({\n        market,\n        yesMint,\n        noMint,\n        losingMint,\n        userLosingToken,\n        user,\n        token2022Program: TOKEN_2022_PROGRAM_ID,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to burn market tokens\n   * @param closeAccount - Whether to close the losing token account after burning all tokens (default: false)\n   */\n  async buildBurnMarketTokensTx(\n    user: PublicKey,\n    market: PublicKey,\n    losingOutcome: Outcome,\n    tokenAmount: number | BN = 0,\n    closeAccount: boolean = true\n  ): Promise<Transaction> {\n    const ix = await this.burnMarketTokens(user, market, losingOutcome, tokenAmount, closeAccount);\n    return new Transaction().add(ix);\n  }\n  \n  /**\n   * Fetch global config account data\n   */\n  async getGlobalConfigAccount() {\n    const globalConfig = getGlobalConfigPda(this.program.programId);\n    return await this.program.account.globalConfig.fetch(globalConfig);\n  }\n\n  /**\n   * Fetch market account data\n   */\n  async getMarketAccount(admin: PublicKey, marketId: number | BN) {\n    const marketIdBn = new BN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n    return await this.program.account.market.fetch(marketPda);\n  }\n\n  async getMarketInfo(marketPda: PublicKey) {\n    const marketAccount = await this.program.account.market.fetch(marketPda);\n    return marketAccount;\n  }\n\n  /**\n   * Fetch vault account data\n   */\n  async getVaultAccount(marketPda: PublicKey) {\n    const vaultPda = getVaultPda(this.program.programId, marketPda);\n    return await getAccount(this.connection, vaultPda);\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drama-pm-client",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "type": "module",
   "description": "TypeScript client for Drama Prediction Market",
   "main": "dist/index.js",