drama-pm-client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,153 @@
+import type { BN, Program } from "@coral-xyz/anchor";
+import anchor from "@coral-xyz/anchor";
+import { Connection, PublicKey, Transaction, TransactionInstruction } from "@solana/web3.js";
+import { IDL } from "./idl.js";
+import { DramaPm } from "./types.js";
+export * from "./utils.js";
+export { DramaPm, IDL };
+export type Outcome = "Yes" | "No";
+export interface CreateMarketParams {
+    admin: PublicKey;
+    marketId: number | BN;
+    yesPrice: number | BN;
+    noPrice: number | BN;
+    endTime: number | BN;
+    bettingToken: PublicKey;
+}
+export interface PlaceBetParams {
+    user: PublicKey;
+    admin: PublicKey;
+    marketId: number | BN;
+    amount: number | BN;
+    outcome: Outcome;
+    bettingToken: PublicKey;
+    createAta?: boolean;
+}
+export interface ClaimRewardsParams {
+    user: PublicKey;
+    admin: PublicKey;
+    marketId: number | BN;
+    bettingToken: PublicKey;
+    winningOutcome: Outcome;
+}
+export interface RefundParams {
+    user: PublicKey;
+    admin: PublicKey;
+    marketId: number | BN;
+    bettingToken: PublicKey;
+    outcome: Outcome;
+}
+export declare class DramaPmClient {
+    program: Program<DramaPm>;
+    provider: anchor.AnchorProvider;
+    connection: Connection;
+    constructor(connection: Connection, wallet?: anchor.Wallet);
+    /**
+     * Check if an associated token account exists
+     */
+    ataExists(ata: PublicKey): Promise<boolean>;
+    /**
+     * Create an instruction to initialize an associated token account
+     */
+    createAtaInstruction(payer: PublicKey, owner: PublicKey, mint: PublicKey): TransactionInstruction;
+    /**
+     * Create a new prediction market instruction
+     */
+    createMarket(params: CreateMarketParams): Promise<TransactionInstruction>;
+    /**
+     * Build a complete transaction to create a market
+     */
+    buildCreateMarketTx(params: CreateMarketParams): Promise<Transaction>;
+    /**
+     * Place a bet instruction (without ATA creation)
+     */
+    placeBet(params: PlaceBetParams): Promise<TransactionInstruction>;
+    /**
+     * Build a complete transaction to place a bet (with optional ATA creation)
+     */
+    buildPlaceBetTx(params: PlaceBetParams): Promise<Transaction>;
+    /**
+     * Claim rewards after market resolution
+     */
+    claimRewards(params: ClaimRewardsParams): Promise<TransactionInstruction>;
+    /**
+     * Build a complete transaction to claim rewards
+     */
+    buildClaimRewardsTx(params: ClaimRewardsParams): Promise<Transaction>;
+    /**
+     * Refund bets if market is refunded
+     */
+    refund(params: RefundParams): Promise<TransactionInstruction>;
+    /**
+     * Build a complete transaction to refund
+     */
+    buildRefundTx(params: RefundParams): Promise<Transaction>;
+    /**
+     * Resolve a market (Admin only)
+     */
+    resolveMarket(admin: PublicKey, marketId: number | BN, winningOutcome: "Yes" | "No" | null): Promise<TransactionInstruction>;
+    /**
+     * Build a complete transaction to resolve a market
+     */
+    buildResolveMarketTx(admin: PublicKey, marketId: number | BN, winningOutcome: "Yes" | "No" | null): Promise<Transaction>;
+    /**
+     * Close a market (Admin only)
+     */
+    closeMarket(admin: PublicKey, marketId: number | BN): Promise<TransactionInstruction>;
+    /**
+     * Build a complete transaction to close a market
+     */
+    buildCloseMarketTx(admin: PublicKey, marketId: number | BN): Promise<Transaction>;
+    /**
+     * Fetch market account data
+     */
+    getMarketAccount(admin: PublicKey, marketId: number | BN): Promise<{
+        admin: anchor.web3.PublicKey;
+        marketId: BN;
+        yesMint: anchor.web3.PublicKey;
+        noMint: anchor.web3.PublicKey;
+        bettingToken: anchor.web3.PublicKey;
+        vault: anchor.web3.PublicKey;
+        yesPrice: BN;
+        noPrice: BN;
+        createTime: BN;
+        endTime: BN;
+        status: ({
+            closed?: undefined;
+            resolved?: undefined;
+            refunded?: undefined;
+        } & {
+            active: Record<string, never>;
+        }) | ({
+            active?: undefined;
+            resolved?: undefined;
+            refunded?: undefined;
+        } & {
+            closed: Record<string, never>;
+        }) | ({
+            active?: undefined;
+            closed?: undefined;
+            refunded?: undefined;
+        } & {
+            resolved: Record<string, never>;
+        }) | ({
+            active?: undefined;
+            closed?: undefined;
+            resolved?: undefined;
+        } & {
+            refunded: Record<string, never>;
+        });
+        winningOutcome: (({
+            yes?: undefined;
+        } & {
+            no: Record<string, never>;
+        }) | ({
+            no?: undefined;
+        } & {
+            yes: Record<string, never>;
+        })) | null;
+        totalYesSupply: BN;
+        totalNoSupply: BN;
+        bump: number;
+    }>;
+}

package/dist/index.js

@@ -0,0 +1,232 @@
+import anchor from "@coral-xyz/anchor";
+import { createAssociatedTokenAccountInstruction, getAccount, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID, } from "@solana/spl-token";
+import { Keypair, Transaction } from "@solana/web3.js";
+import { IDL } from "./idl.js";
+import { getMarketPda, getMarketPdas } from "./utils.js";
+const { BN: AnchorBN, Program: AnchorProgram } = anchor;
+export * from "./utils.js";
+export { IDL };
+export class DramaPmClient {
+    constructor(connection, wallet) {
+        this.connection = connection;
+        this.provider = new anchor.AnchorProvider(connection, wallet || new anchor.Wallet(Keypair.generate()), { commitment: "confirmed" });
+        this.program = new AnchorProgram(IDL, this.provider);
+    }
+    /**
+     * Check if an associated token account exists
+     */
+    async ataExists(ata) {
+        try {
+            await getAccount(this.connection, ata);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Create an instruction to initialize an associated token account
+     */
+    createAtaInstruction(payer, owner, mint) {
+        const ata = getAssociatedTokenAddressSync(mint, owner);
+        return createAssociatedTokenAccountInstruction(payer, ata, owner, mint, TOKEN_PROGRAM_ID);
+    }
+    /**
+     * Create a new prediction market instruction
+     */
+    async createMarket(params) {
+        const { admin, marketId, yesPrice, noPrice, endTime, bettingToken } = params;
+        const marketIdBn = new AnchorBN(marketId);
+        const yesPriceBn = new AnchorBN(yesPrice);
+        const noPriceBn = new AnchorBN(noPrice);
+        const endTimeBn = new AnchorBN(endTime);
+        const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);
+        return await this.program.methods
+            .createMarket({
+            marketId: marketIdBn,
+            yesPrice: yesPriceBn,
+            noPrice: noPriceBn,
+            endTime: endTimeBn,
+        })
+            .accountsPartial({
+            market: pdas.market,
+            yesMint: pdas.yesMint,
+            noMint: pdas.noMint,
+            bettingToken: bettingToken,
+            vault: pdas.vault,
+            admin: admin,
+            systemProgram: anchor.web3.SystemProgram.programId,
+        })
+            .instruction();
+    }
+    /**
+     * Build a complete transaction to create a market
+     */
+    async buildCreateMarketTx(params) {
+        const ix = await this.createMarket(params);
+        return new Transaction().add(ix);
+    }
+    /**
+     * Place a bet instruction (without ATA creation)
+     */
+    async placeBet(params) {
+        const { user, admin, marketId, amount, outcome, bettingToken } = params;
+        const marketIdBn = new AnchorBN(marketId);
+        const amountBn = new AnchorBN(amount);
+        const outcomeEnum = outcome === "Yes" ? { yes: {} } : { no: {} };
+        const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);
+        const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);
+        // Determine which outcome token the user will receive
+        const targetMint = outcome === "Yes" ? pdas.yesMint : pdas.noMint;
+        const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user);
+        return await this.program.methods
+            .placeBet({
+            buyOutcome: outcomeEnum,
+            amount: amountBn,
+        })
+            .accountsPartial({
+            market: pdas.market,
+            yesMint: pdas.yesMint,
+            noMint: pdas.noMint,
+            vault: pdas.vault,
+            userOutcomeToken,
+            userBettingToken,
+            user,
+        })
+            .instruction();
+    }
+    /**
+     * Build a complete transaction to place a bet (with optional ATA creation)
+     */
+    async buildPlaceBetTx(params) {
+        const { user, admin, marketId, outcome, createAta = true } = params;
+        const tx = new Transaction();
+        const marketIdBn = new AnchorBN(marketId);
+        const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);
+        const targetMint = outcome === "Yes" ? pdas.yesMint : pdas.noMint;
+        const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user);
+        // Check if ATA exists and create if needed
+        if (createAta) {
+            const exists = await this.ataExists(userOutcomeToken);
+            if (!exists) {
+                const createAtaIx = this.createAtaInstruction(user, user, targetMint);
+                tx.add(createAtaIx);
+            }
+        }
+        const placeBetIx = await this.placeBet(params);
+        tx.add(placeBetIx);
+        return tx;
+    }
+    /**
+     * Claim rewards after market resolution
+     */
+    async claimRewards(params) {
+        const { user, admin, marketId, bettingToken, winningOutcome } = params;
+        const marketIdBn = new AnchorBN(marketId);
+        const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);
+        const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);
+        const targetMint = winningOutcome === "Yes" ? pdas.yesMint : pdas.noMint;
+        const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user);
+        return await this.program.methods
+            .claimRewards()
+            .accountsPartial({
+            market: pdas.market,
+            userOutcomeToken,
+            userBettingToken,
+            user,
+        })
+            .instruction();
+    }
+    /**
+     * Build a complete transaction to claim rewards
+     */
+    async buildClaimRewardsTx(params) {
+        const ix = await this.claimRewards(params);
+        return new Transaction().add(ix);
+    }
+    /**
+     * Refund bets if market is refunded
+     */
+    async refund(params) {
+        const { user, admin, marketId, bettingToken, outcome } = params;
+        const marketIdBn = new AnchorBN(marketId);
+        const outcomeEnum = outcome === "Yes" ? { yes: {} } : { no: {} };
+        const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);
+        const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);
+        const targetMint = outcome === "Yes" ? pdas.yesMint : pdas.noMint;
+        const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user);
+        return await this.program.methods
+            .refund(outcomeEnum)
+            .accountsPartial({
+            market: pdas.market,
+            userOutcomeToken,
+            userBettingToken,
+            user,
+        })
+            .instruction();
+    }
+    /**
+     * Build a complete transaction to refund
+     */
+    async buildRefundTx(params) {
+        const ix = await this.refund(params);
+        return new Transaction().add(ix);
+    }
+    /**
+     * Resolve a market (Admin only)
+     */
+    async resolveMarket(admin, marketId, winningOutcome) {
+        const marketIdBn = new AnchorBN(marketId);
+        const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);
+        let outcomeEnum = null;
+        if (winningOutcome === "Yes") {
+            outcomeEnum = { yes: {} };
+        }
+        else if (winningOutcome === "No") {
+            outcomeEnum = { no: {} };
+        }
+        return await this.program.methods
+            .resolveMarket(outcomeEnum)
+            .accountsPartial({
+            market: marketPda,
+            admin,
+        })
+            .instruction();
+    }
+    /**
+     * Build a complete transaction to resolve a market
+     */
+    async buildResolveMarketTx(admin, marketId, winningOutcome) {
+        const ix = await this.resolveMarket(admin, marketId, winningOutcome);
+        return new Transaction().add(ix);
+    }
+    /**
+     * Close a market (Admin only)
+     */
+    async closeMarket(admin, marketId) {
+        const marketIdBn = new AnchorBN(marketId);
+        const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);
+        return await this.program.methods
+            .closeMarket()
+            .accountsPartial({
+            market: marketPda,
+        })
+            .instruction();
+    }
+    /**
+     * Build a complete transaction to close a market
+     */
+    async buildCloseMarketTx(admin, marketId) {
+        const ix = await this.closeMarket(admin, marketId);
+        return new Transaction().add(ix);
+    }
+    /**
+     * Fetch market account data
+     */
+    async getMarketAccount(admin, marketId) {
+        const marketIdBn = new AnchorBN(marketId);
+        const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);
+        return await this.program.account.market.fetch(marketPda);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { BN, Idl, Program } from \"@coral-xyz/anchor\";\nimport anchor from \"@coral-xyz/anchor\";\nimport {\n    createAssociatedTokenAccountInstruction,\n    getAccount,\n    getAssociatedTokenAddressSync,\n    TOKEN_PROGRAM_ID,\n} from \"@solana/spl-token\";\nimport {\n    Connection,\n    Keypair,\n    PublicKey,\n    Transaction,\n    TransactionInstruction\n} from \"@solana/web3.js\";\nimport { IDL } from \"./idl.js\";\nimport { DramaPm } from \"./types.js\";\nimport {\n    getMarketPda,\n    getMarketPdas\n} from \"./utils.js\";\nconst { BN: AnchorBN, Program: AnchorProgram } = anchor;\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  admin: PublicKey;\n  marketId: number | BN;\n  amount: number | BN;\n  outcome: Outcome;\n  bettingToken: PublicKey;\n  createAta?: boolean; // Whether to create ATA instruction automatically\n}\n\nexport interface ClaimRewardsParams {\n  user: PublicKey;\n  admin: PublicKey;\n  marketId: number | BN;\n  bettingToken: PublicKey;\n  winningOutcome: Outcome;\n}\n\nexport interface RefundParams {\n  user: PublicKey;\n  admin: PublicKey;\n  marketId: number | BN;\n  bettingToken: PublicKey;\n  outcome: Outcome;\n}\n\nexport class DramaPmClient {\n  program: Program<DramaPm>;\n  provider: anchor.AnchorProvider;\n  connection: Connection;\n\n  constructor(connection: Connection, wallet?: anchor.Wallet) {\n    this.connection = connection;\n    this.provider = new anchor.AnchorProvider(\n      connection,\n      wallet || new anchor.Wallet(Keypair.generate()),\n      { commitment: \"confirmed\" }\n    );\n    this.program = new AnchorProgram(IDL 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   */\n  createAtaInstruction(\n    payer: PublicKey,\n    owner: PublicKey,\n    mint: PublicKey\n  ): TransactionInstruction {\n    const ata = getAssociatedTokenAddressSync(mint, owner);\n    return createAssociatedTokenAccountInstruction(\n      payer,\n      ata,\n      owner,\n      mint,\n      TOKEN_PROGRAM_ID\n    );\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 AnchorBN(marketId);\n    const yesPriceBn = new AnchorBN(yesPrice);\n    const noPriceBn = new AnchorBN(noPrice);\n    const endTimeBn = new AnchorBN(endTime);\n\n    const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);\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          market: pdas.market,\n          yesMint: pdas.yesMint,\n          noMint: pdas.noMint,\n          bettingToken: bettingToken,\n          vault: pdas.vault,\n          admin: admin,\n          systemProgram: anchor.web3.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, admin, marketId, amount, outcome, bettingToken } = params;\n    \n    const marketIdBn = new AnchorBN(marketId);\n    const amountBn = new AnchorBN(amount);\n    const outcomeEnum = outcome === \"Yes\" ? { yes: {} } : { no: {} };\n\n\n    const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    \n    // Determine which outcome token the user will receive\n    const targetMint = outcome === \"Yes\" ? pdas.yesMint : pdas.noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user);\n\n    return await this.program.methods\n      .placeBet({\n        buyOutcome: outcomeEnum,\n        amount: amountBn,\n      })\n      .accountsPartial({\n        market: pdas.market,\n        yesMint: pdas.yesMint,\n        noMint: pdas.noMint,\n        vault: pdas.vault,\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)\n   */\n  async buildPlaceBetTx(params: PlaceBetParams): Promise<Transaction> {\n    const { user, admin, marketId, outcome, createAta = true } = params;\n    \n    const tx = new Transaction();\n    const marketIdBn = new AnchorBN(marketId);\n    const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);\n    \n    const targetMint = outcome === \"Yes\" ? pdas.yesMint : pdas.noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user);\n\n    // Check if 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);\n        tx.add(createAtaIx);\n      }\n    }\n\n    const placeBetIx = await this.placeBet(params);\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, admin, marketId, bettingToken, winningOutcome } = params;\n    \n    const marketIdBn = new AnchorBN(marketId);\n    const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    \n    const targetMint = winningOutcome === \"Yes\" ? pdas.yesMint : pdas.noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user);\n\n    return await this.program.methods\n      .claimRewards()\n      .accountsPartial({\n        market: pdas.market,\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 ix = await this.claimRewards(params);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Refund bets if market is refunded\n   */\n  async refund(params: RefundParams): Promise<TransactionInstruction> {\n    const { user, admin, marketId, bettingToken, outcome } = params;\n    \n    const marketIdBn = new AnchorBN(marketId);\n    const outcomeEnum = outcome === \"Yes\" ? { yes: {} } : { no: {} };\n    const pdas = getMarketPdas(this.program.programId, admin, marketIdBn);\n    const userBettingToken = getAssociatedTokenAddressSync(bettingToken, user);\n    \n    const targetMint = outcome === \"Yes\" ? pdas.yesMint : pdas.noMint;\n    const userOutcomeToken = getAssociatedTokenAddressSync(targetMint, user);\n\n    return await this.program.methods\n      .refund(outcomeEnum)\n      .accountsPartial({\n        market: pdas.market,\n        userOutcomeToken,\n        userBettingToken,\n        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 resolveMarket(\n    admin: PublicKey,\n    marketId: number | BN,\n    winningOutcome: \"Yes\" | \"No\" | null\n  ): Promise<TransactionInstruction> {\n    const marketIdBn = new AnchorBN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n\n    let outcomeEnum: any = null;\n    if (winningOutcome === \"Yes\") {\n      outcomeEnum = { yes: {} };\n    } else if (winningOutcome === \"No\") {\n      outcomeEnum = { no: {} };\n    }\n\n    return await this.program.methods\n      .resolveMarket(outcomeEnum)\n      .accountsPartial({\n        market: marketPda,\n        admin,\n      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to resolve a market\n   */\n  async buildResolveMarketTx(\n    admin: PublicKey,\n    marketId: number | BN,\n    winningOutcome: \"Yes\" | \"No\" | null\n  ): Promise<Transaction> {\n    const ix = await this.resolveMarket(admin, marketId, winningOutcome);\n    return new Transaction().add(ix);\n  }\n\n  /**\n   * Close a market (Admin only)\n   */\n  async closeMarket(\n    admin: PublicKey,\n    marketId: number | BN\n  ): Promise<TransactionInstruction> {\n    const marketIdBn = new AnchorBN(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      })\n      .instruction();\n  }\n\n  /**\n   * Build a complete transaction to close a market\n   */\n  async buildCloseMarketTx(\n    admin: PublicKey,\n    marketId: number | BN\n  ): Promise<Transaction> {\n    const ix = await this.closeMarket(admin, marketId);\n    return new Transaction().add(ix);\n  }\n  \n  /**\n   * Fetch market account data\n   */\n  async getMarketAccount(admin: PublicKey, marketId: number | BN) {\n    const marketIdBn = new AnchorBN(marketId);\n    const marketPda = getMarketPda(this.program.programId, admin, marketIdBn);\n    return await this.program.account.market.fetch(marketPda);\n  }\n}\n"]}