drama-pm-client 0.4.8 → 0.4.10

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,52 @@ export interface RefundParams {
     tokenAmount?: number | BN;
     closeAccount?: boolean;
 }
+/**
+ * Parameters for refundV2 - refunding both Yes and No positions in one transaction.
+ * Use this when a user has bet on both outcomes and wants to refund everything at once.
+ */
+export interface RefundV2Params {
+    user: PublicKey;
+    market: PublicKey;
+    bettingToken: PublicKey;
+    yesTokenAmount?: number | BN;
+    noTokenAmount?: number | BN;
+    closeYesAccount?: boolean;
+    closeNoAccount?: boolean;
+}
+/**
+ * Parameters for claim_burn_market instruction
+ * Combines claiming rewards (if won) and burning tokens (if lost) in one call.
+ * Always closes token accounts to reclaim rent.
+ */
+export interface ClaimBurnMarketParams {
+    user: PublicKey;
+    market: PublicKey;
+    bettingToken: PublicKey;
+}
+/**
+ * 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 +183,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
      */
@@ -168,6 +272,62 @@ export declare class DramaPmClient {
      * Build a complete transaction to refund
      */
     buildRefundTx(params: RefundParams): Promise<Transaction>;
+    /**
+     * Refund both Yes and No positions in a single transaction.
+     *
+     * Use this method when a user has bet on both Yes and No outcomes and needs to
+     * refund all positions after the market has been resolved as "Refunded" (None).
+     *
+     * This method automatically:
+     * - Checks if the user has Yes tokens and/or No tokens
+     * - Only includes refund instructions for outcomes the user actually holds
+     * - Closes the token accounts after refunding (by default)
+     *
+     * @param params - RefundV2Params
+     * @param params.user - User's public key (signer)
+     * @param params.market - Market PDA address
+     * @param params.bettingToken - Betting token mint (e.g., USDC)
+     * @param params.yesTokenAmount - Optional. Amount of Yes tokens to refund. 0 or undefined = refund all.
+     * @param params.noTokenAmount - Optional. Amount of No tokens to refund. 0 or undefined = refund all.
+     * @param params.closeYesAccount - Optional. Whether to close the Yes token account after refund. Default: true
+     * @param params.closeNoAccount - Optional. Whether to close the No token account after refund. Default: true
+     *
+     * @returns Transaction containing refund instructions for both outcomes (if applicable)
+     *
+     * @example
+     * ```typescript
+     * // Basic usage: Refund all Yes and No tokens
+     * const tx = await client.buildRefundV2Tx({
+     *   user: userPublicKey,
+     *   market: marketPda,
+     *   bettingToken: usdcMint,
+     * });
+     *
+     * // Sign and send
+     * tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+     * tx.feePayer = userPublicKey;
+     * await wallet.signTransaction(tx);
+     * await connection.sendRawTransaction(tx.serialize());
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Keep token accounts open (don't close them)
+     * const tx = await client.buildRefundV2Tx({
+     *   user: userPublicKey,
+     *   market: marketPda,
+     *   bettingToken: usdcMint,
+     *   closeYesAccount: false, // Keep Yes token account open
+     *   closeNoAccount: false,  // Keep No token account open
+     * });
+     * ```
+     *
+     * @remarks
+     * - The market must be in "Refunded" status for this method to work
+     * - If the user only has tokens on one side, only that side will be refunded
+     * - The returned transaction will be empty if the user has no tokens on either side
+     */
+    buildRefundV2Tx(params: RefundV2Params): Promise<Transaction>;
     /**
      * Resolve a market (Admin only)
      */
@@ -224,6 +384,20 @@ export declare class DramaPmClient {
      * @param closeAccount - Whether to close the losing token account after burning all tokens (default: false)
      */
     buildBurnMarketTokensTx(user: PublicKey, market: PublicKey, losingOutcome: Outcome, tokenAmount?: number | BN, closeAccount?: boolean): Promise<Transaction>;
+    /**
+     * Claim rewards if won, or burn tokens if lost, with optional account closure.
+     * This instruction combines claim_rewards and burn_market_tokens logic into a single call.
+     *
+     * @param params - ClaimBurnMarketParams
+     * @param userYesToken - User's YES token account (optional, pass null if user has no YES tokens)
+     * @param userNoToken - User's NO token account (optional, pass null if user has no NO tokens)
+     */
+    claimBurnMarket(params: ClaimBurnMarketParams, userYesToken: PublicKey | null, userNoToken: PublicKey | null): Promise<TransactionInstruction>;
+    /**
+     * Build a complete transaction to claim rewards (if won) or burn tokens (if lost)
+     * Automatically creates user outcome token accounts based on user's holdings
+     */
+    buildClaimBurnMarketTx(params: ClaimBurnMarketParams): Promise<Transaction>;
     /**
      * Fetch global config account data
      */