@triadxyz/triad-protocol 3.1.6-beta → 3.1.8-beta

package/dist/market.d.ts

@@ -0,0 +1,129 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
+import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { TriadProtocol } from './types/triad_protocol';
+import { RpcOptions, CreateMarketArgs, CreatePoolArgs, UpdateMarketWinningDirectionArgs } from './types';
+export default class Market {
+    private program;
+    private rpcOptions;
+    constructor(program: Program<TriadProtocol>, rpcOptions: RpcOptions);
+    /**
+     * Get All Pools
+     */
+    getAllPools(): Promise<import("./types").Pool[]>;
+    /**
+     * Get All Markets
+     */
+    getAllMarkets(): Promise<import("./types").Market[]>;
+    /**
+     * Get Pool By ID
+     * @param poolId - The ID of the pool
+     */
+    getPoolById(poolId: number): Promise<import("./types").Pool>;
+    /**
+     * Get Market By ID
+     * @param marketId - The ID of the market
+     */
+    getMarketById(marketId: number): Promise<import("./types").Market>;
+    /**
+     * Get Market By Address
+     * @param marketAddress - The address of the market
+     */
+    getMarketByAddress(marketAddress: PublicKey): Promise<import("./types").Market>;
+    /**
+     * Get Current Market ID
+     */
+    nextMarketId(): Promise<number>;
+    /**
+     * Get Next Customer ID
+     */
+    nextCustomerId(): Promise<number>;
+    /**
+     * Get Next Pool ID
+     */
+    nextPoolId(): Promise<number>;
+    /**
+     * Create Market
+     * @param args.markets - Array of markets to create
+     * @param args.markets.marketId - Market ID
+     * @param args.markets.startTime - start time
+     * @param args.markets.endTime - end time
+     * @param args.markets.question - question (max 80 characters)
+     * @param args.markets.liquidityAtStart - liquidity at start
+     * @param args.markets.payoutFee - payout fee (to add affiliate system)
+     * @param args.customer - The customer of the market
+     * @param args.poolId - The ID of the pool
+     */
+    createMarket({ markets, customer, poolId }: CreateMarketArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Create Pool
+     * @param poolId - The ID of the pool
+     * @param question - The question of the pool
+     * @param markets - The markets of the pool
+     */
+    createPool({ poolId, question, markets, customer, startTime, endTime, feeBps, payoutFee, isFast }: CreatePoolArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Resolve Market
+     * @param args.marketId - The ID of the Market
+     * @param args.poolId - The ID of the Pool
+     * @param args.winningDirection - The Winning Direction of the Market
+     */
+    updateMarketWinningDirection({ marketId, poolId, winningDirection }: UpdateMarketWinningDirectionArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Update Market Payout
+     * @param marketId - The ID of the market
+     * @param poolId - The ID of the pool
+     * @param allowPayout - Whether to allow the market to payout
+     */
+    updateMarketPayout({ marketId, poolId, allowPayout }: {
+        marketId: number;
+        poolId?: number;
+        allowPayout: boolean;
+    }): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Update Market End
+     * @param marketId - The ID of the market
+     * @param marketEnd - The end time of the market
+     */
+    updateMarketEnd({ marketId, marketEnd }: {
+        marketId: number;
+        marketEnd: number;
+    }): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Update Market Question
+     * @param marketId - The ID of the market
+     * @param question - The question of the market
+     */
+    updateMarketQuestion({ marketId, question }: {
+        marketId: number;
+        question: string;
+    }): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Collect Market Fee
+     * @param args.markets - The markets to collect the fee from
+     * @param args.markets.marketAddress - The address of the market
+     * @param args.markets.customerId - The ID of the customer
+     * @param args.markets.customerFeeRecipient - The address of the customer fee recipient
+     */
+    collectMarketFee(markets: {
+        marketAddress: PublicKey;
+        customerId: number;
+        customerFeeRecipient: PublicKey;
+    }[]): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Collect Market Order Fee
+     * @param marketAddress - The address of the market
+     */
+    collectMarketOrderFee(marketAddress: PublicKey[]): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Close Order Book
+     * @param marketIds - Market IDs
+     */
+    closeOrderBook(marketIds: number[]): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Update Pool Question
+     * @param poolId - Pool ID
+     * @param question - Question
+     */
+    updatePoolQuestion(poolId: number, question: string): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+}

package/dist/market.js

@@ -0,0 +1,377 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const helpers_1 = require("./utils/helpers");
+const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
+const pda_1 = require("./utils/pda");
+class Market {
+    constructor(program, rpcOptions) {
+        this.program = program;
+        this.rpcOptions = rpcOptions;
+    }
+    /**
+     * Get All Pools
+     */
+    getAllPools() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pool = yield this.program.account.pool.all();
+            return pool.map(({ account, publicKey }) => (0, helpers_1.formatPool)(account, publicKey));
+        });
+    }
+    /**
+     * Get All Markets
+     */
+    getAllMarkets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketV2 = yield this.program.account.marketV2.all();
+            return marketV2.map(({ account, publicKey }) => (0, helpers_1.formatMarket)(account, publicKey));
+        });
+    }
+    /**
+     * Get Pool By ID
+     * @param poolId - The ID of the pool
+     */
+    getPoolById(poolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            const response = yield this.program.account.pool.fetch(poolPDA);
+            return (0, helpers_1.formatPool)(response, poolPDA);
+        });
+    }
+    /**
+     * Get Market By ID
+     * @param marketId - The ID of the market
+     */
+    getMarketById(marketId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
+            const response = yield this.program.account.marketV2.fetch(marketPDA);
+            return (0, helpers_1.formatMarket)(response, marketPDA);
+        });
+    }
+    /**
+     * Get Market By Address
+     * @param marketAddress - The address of the market
+     */
+    getMarketByAddress(marketAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const account = yield this.program.account.marketV2.fetch(marketAddress);
+            return (0, helpers_1.formatMarket)(account, marketAddress);
+        });
+    }
+    /**
+     * Get Current Market ID
+     */
+    nextMarketId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const markets = yield this.program.account.marketV2.all();
+            return markets.length + 10;
+        });
+    }
+    /**
+     * Get Next Customer ID
+     */
+    nextCustomerId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customers = yield this.program.account.customer.all();
+            return customers.length + 1;
+        });
+    }
+    /**
+     * Get Next Pool ID
+     */
+    nextPoolId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pools = yield this.program.account.pool.all();
+            return pools.length + 1;
+        });
+    }
+    /**
+     * Create Market
+     * @param args.markets - Array of markets to create
+     * @param args.markets.marketId - Market ID
+     * @param args.markets.startTime - start time
+     * @param args.markets.endTime - end time
+     * @param args.markets.question - question (max 80 characters)
+     * @param args.markets.liquidityAtStart - liquidity at start
+     * @param args.markets.payoutFee - payout fee (to add affiliate system)
+     * @param args.customer - The customer of the market
+     * @param args.poolId - The ID of the pool
+     */
+    createMarket({ markets, customer, poolId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            let poolPDA = null;
+            if (poolId) {
+                poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            }
+            for (const market of markets) {
+                if (market.question.length > 80) {
+                    throw new Error('Question must be less than 80 characters');
+                }
+                ixs.push(yield this.program.methods
+                    .createMarket({
+                    marketId: new anchor_1.BN(market.marketId),
+                    question: (0, helpers_1.encodeString)(market.question, 80),
+                    marketStart: new anchor_1.BN(market.startTime),
+                    marketEnd: new anchor_1.BN(market.endTime),
+                    feeBps: market.feeBps,
+                    payoutFee: market.payoutFee
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    pool: poolPDA,
+                    customer
+                })
+                    .instruction());
+                ixs.push(yield this.program.methods
+                    .createOrderBook(new anchor_1.BN(market.marketId))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, market.marketId)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Create Pool
+     * @param poolId - The ID of the pool
+     * @param question - The question of the pool
+     * @param markets - The markets of the pool
+     */
+    createPool({ poolId, question, markets, customer, startTime, endTime, feeBps, payoutFee, isFast }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (question.length > 80) {
+                throw new Error('Pool question must be less than 80 characters');
+            }
+            const ixs = [];
+            const poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            ixs.push(yield this.program.methods
+                .createPool({
+                poolId: new anchor_1.BN(poolId),
+                question: (0, helpers_1.encodeString)(question, 80),
+                isFast
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                customer
+            })
+                .instruction());
+            for (const market of markets) {
+                if (market.question.length > 80) {
+                    throw new Error('Market question must be less than 80 characters');
+                }
+                ixs.push(yield this.program.methods
+                    .createMarket({
+                    marketId: new anchor_1.BN(market.marketId),
+                    question: (0, helpers_1.encodeString)(market.question, 80),
+                    marketStart: new anchor_1.BN(startTime),
+                    marketEnd: new anchor_1.BN(endTime),
+                    feeBps,
+                    payoutFee
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    pool: poolPDA,
+                    customer
+                })
+                    .instruction());
+                ixs.push(yield this.program.methods
+                    .createOrderBook(new anchor_1.BN(market.marketId))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, market.marketId)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Resolve Market
+     * @param args.marketId - The ID of the Market
+     * @param args.poolId - The ID of the Pool
+     * @param args.winningDirection - The Winning Direction of the Market
+     */
+    updateMarketWinningDirection({ marketId, poolId, winningDirection }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let poolPDA = null;
+            if (poolId) {
+                poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            }
+            const ixs = [
+                yield this.program.methods
+                    .updateMarketWinningDirection(winningDirection)
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                    pool: poolPDA
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Market Payout
+     * @param marketId - The ID of the market
+     * @param poolId - The ID of the pool
+     * @param allowPayout - Whether to allow the market to payout
+     */
+    updateMarketPayout({ marketId, poolId, allowPayout }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let poolPDA = null;
+            if (poolId) {
+                poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            }
+            const ixs = [
+                yield this.program.methods
+                    .updateMarketPayout(allowPayout)
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId)
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Market End
+     * @param marketId - The ID of the market
+     * @param marketEnd - The end time of the market
+     */
+    updateMarketEnd({ marketId, marketEnd }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .updateMarketEnd(new anchor_1.BN(marketEnd))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId)
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Market Question
+     * @param marketId - The ID of the market
+     * @param question - The question of the market
+     */
+    updateMarketQuestion({ marketId, question }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .updateMarketQuestion((0, helpers_1.encodeString)(question, 80))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId)
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Collect Market Fee
+     * @param args.markets - The markets to collect the fee from
+     * @param args.markets.marketAddress - The address of the market
+     * @param args.markets.customerId - The ID of the customer
+     * @param args.markets.customerFeeRecipient - The address of the customer fee recipient
+     */
+    collectMarketFee(markets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const market of markets) {
+                ixs.push(yield this.program.methods
+                    .collectMarketFee()
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: market.marketAddress,
+                    customer: (0, pda_1.getCustomerPDA)(this.program.programId, market.customerId),
+                    customerFeeRecipient: market.customerFeeRecipient
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Collect Market Order Fee
+     * @param marketAddress - The address of the market
+     */
+    collectMarketOrderFee(marketAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const market of marketAddress) {
+                ixs.push(yield this.program.methods
+                    .collectMarketOrderFee()
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: market
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Close Order Book
+     * @param marketIds - Market IDs
+     */
+    closeOrderBook(marketIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const marketId of marketIds) {
+                ixs.push(yield this.program.methods
+                    .closeOrderBook()
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Pool Question
+     * @param poolId - Pool ID
+     * @param question - Question
+     */
+    updatePoolQuestion(poolId, question) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .updatePoolQuestion((0, helpers_1.encodeString)(question, 80))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    pool: (0, pda_1.getPoolPDA)(this.program.programId, poolId)
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+}
+exports.default = Market;

package/dist/poseidon.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
 import { Program } from '@coral-xyz/anchor';
 import { PublicKey } from '@solana/web3.js';
 import { TriadProtocol } from './types/triad_protocol';
@@ -16,28 +17,28 @@ export default class Poseidon {
         poseidonAsset: PublicKey;
         ticketAsset: PublicKey;
         ticketNumber: number;
-    }[]): Promise<string>;
+    }[]): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Withdraw Poseidon
      * @param poseidonAsset - Poseidon Asset - CORE PublicKey
      * @param nft - NFT Poseidon Number
      */
-    withdrawPoseidon(poseidonAsset: PublicKey, nft: number): Promise<string>;
+    withdrawPoseidon(poseidonAsset: PublicKey, nft: number): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Collect Royalty
      * @param collectionSymbol - Collection Symbol
      */
-    collectRoyalty(collectionSymbol: string): Promise<string>;
+    collectRoyalty(collectionSymbol: string): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Add Trader Poseidon
      * @param user - User Public Key
      * @param poseidonAsset - Poseidon Asset
      */
-    addTraderPoseidon(user: PublicKey, poseidonAsset: PublicKey): Promise<string>;
+    addTraderPoseidon(user: PublicKey, poseidonAsset: PublicKey): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Remove Trader Poseidon
      * @param user - User Public Key
      * @param poseidonAsset - Poseidon Asset
      */
-    removeTraderPoseidon(user: PublicKey, poseidonAsset: PublicKey): Promise<string>;
+    removeTraderPoseidon(user: PublicKey, poseidonAsset: PublicKey): Promise<string | import("@solana/web3.js").VersionedTransaction>;
 }

package/dist/stake.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
 import { Program } from '@coral-xyz/anchor';
 import { PublicKey } from '@solana/web3.js';
 import { TriadProtocol } from './types/triad_protocol';
@@ -38,29 +39,29 @@ export default class Stake {
      * Stake Token
      * @param amount - Amount to stake
      */
-    stakeToken(amount: number): Promise<string>;
+    stakeToken(amount: number): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Update Stake Vault
      * @param amount - Reward amount to deposit
      */
-    addStakeVaultRewards(amount: number): Promise<string>;
+    addStakeVaultRewards(amount: number): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Update Stake Vault Is Locked
      * @param isLocked - Whether the stake vault is locked
      */
-    updateStakeVaultIsLocked(isLocked: boolean): Promise<string>;
+    updateStakeVaultIsLocked(isLocked: boolean): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Request Unstake
      * @param amount - Amount to unstake
      */
-    requestUnstake(amount: number): Promise<string>;
+    requestUnstake(amount: number): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Unstake Token
      * @param unstakePDA - Unstake Public Key
      */
-    unstakeToken(unstakePDA: PublicKey): Promise<string>;
+    unstakeToken(unstakePDA: PublicKey): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Claim Stake Rewards
      */
-    claimStakeRewards(): Promise<string>;
+    claimStakeRewards(): Promise<string | import("@solana/web3.js").VersionedTransaction>;
 }