@triadxyz/triad-protocol 2.3.3-beta → 2.3.5-beta

package/dist/index.js

@@ -1,22 +1,884 @@
 "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 web3_js_1 = require("@solana/web3.js");
 const anchor_1 = require("@coral-xyz/anchor");
+const bn_js_1 = __importDefault(require("bn.js"));
 const idl_triad_protocol_json_1 = __importDefault(require("./types/idl_triad_protocol.json"));
-const trade_1 = __importDefault(require("./trade"));
+const types_1 = require("./types");
+const constants_1 = require("./utils/constants");
+const helpers_1 = require("./utils/helpers");
+const pda_1 = require("./utils/pda");
+const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
+const swap_1 = require("./utils/swap");
 const stake_1 = __importDefault(require("./stake"));
 const poseidon_1 = __importDefault(require("./poseidon"));
 class TriadProtocolClient {
     constructor(connection, wallet) {
+        this.decimals = constants_1.TRD_DECIMALS; // We're using only TRD or USDC so we can use the same decimals 6
         this.provider = new anchor_1.AnchorProvider(connection, wallet, {
             commitment: 'confirmed'
         });
         this.program = new anchor_1.Program(idl_triad_protocol_json_1.default, this.provider);
-        this.trade = new trade_1.default(this.program);
         this.stake = new stake_1.default(this.program);
         this.poseidon = new poseidon_1.default(this.program);
     }
+    /**
+     * 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 My User Trades from a user authority
+     * @param wallet - User wallet PublicKey
+     *
+     */
+    getMyUserTrades(wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.program.account.userTrade.all([
+                {
+                    memcmp: {
+                        offset: 8 + 1,
+                        bytes: wallet.toBase58()
+                    }
+                }
+            ]);
+            return response.map(({ account, publicKey }) => (0, helpers_1.formatUserTrade)(account, publicKey));
+        });
+    }
+    /**
+     * Get User Orders
+     * @param wallet - User wallet PublicKey
+     *
+     */
+    getUserOrders(wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const myUserTrades = yield this.getMyUserTrades(wallet);
+            return myUserTrades.flatMap((userTrade) => userTrade.orders);
+        });
+    }
+    /**
+     * 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 User Trade PDA
+     * @param wallet - User wallet PublicKey
+     * @param userNonce - The nonce of the user
+     *
+     */
+    getUserPDA(wallet, userNonce = 0) {
+        let userTradePDA = (0, pda_1.getUserTradePDA)(this.program.programId, wallet);
+        if (userNonce !== 0) {
+            const subUserTradePDA = (0, pda_1.getSubUserTradePDA)(this.program.programId, wallet, userNonce);
+            userTradePDA = (0, pda_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+        }
+        return userTradePDA;
+    }
+    /**
+     * Get User Trade
+     * @param wallet - User wallet PublicKey
+     * @param userNonce - The nonce of the user
+     *
+     */
+    getUserTrade(wallet, userNonce = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userTradePDA = this.getUserPDA(wallet, userNonce);
+            return this.program.account.userTrade.fetch(userTradePDA);
+        });
+    }
+    /**
+     * Create Market
+     * @param args.marketId - new markert id - length + 1
+     * @param args.startTime - start time
+     * @param args.endTime - end time
+     * @param args.question - question (max 80 characters)
+     * @param args.liquidityAtStart - liquidity at start
+     * @param args.payoutFee - payout fee (to add affiliate system)
+     * @param args.currentMarketId - if fast market, we need check the pool parameters
+     *
+     * @param options - RPC options
+     *
+     */
+    createMarket({ marketId, startTime, endTime, question, feeBps, customer, payoutFee, mint, poolId }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (question.length > 80) {
+                throw new Error('Question must be less than 80 characters');
+            }
+            const ixs = [];
+            let poolPDA = null;
+            if (poolId) {
+                poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            }
+            let userTrade = null;
+            try {
+                yield this.getUserTrade(this.program.provider.publicKey);
+                userTrade = (0, pda_1.getUserTradePDA)(this.program.programId, this.program.provider.publicKey);
+            }
+            catch (_a) { }
+            ixs.push(yield this.program.methods
+                .createMarket({
+                marketId: new bn_js_1.default(marketId),
+                question: (0, helpers_1.encodeString)(question, 80),
+                marketStart: new bn_js_1.default(startTime),
+                marketEnd: new bn_js_1.default(endTime),
+                feeBps,
+                payoutFee
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                mint,
+                tokenProgram: (0, helpers_1.getTokenProgram)(mint),
+                customer,
+                pool: poolPDA,
+                userTrade
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Create Pool
+     * @param poolId - The ID of the pool
+     * @param question - The question of the pool
+     * @param markets - The markets of the pool
+     *
+     * @param options - RPC options
+     */
+    createPool({ poolId, question, markets, mint, customer, startTime, endTime, feeBps, payoutFee, isFast }, options) {
+        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 bn_js_1.default(poolId),
+                question: (0, helpers_1.encodeString)(question, 80),
+                isFast
+            })
+                .accounts({
+                signer: this.program.provider.publicKey
+            })
+                .instruction());
+            let userTrade = null;
+            try {
+                yield this.getUserTrade(this.program.provider.publicKey);
+                userTrade = (0, pda_1.getUserTradePDA)(this.program.programId, this.program.provider.publicKey);
+            }
+            catch (_a) { }
+            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 bn_js_1.default(market.marketId),
+                    question: (0, helpers_1.encodeString)(market.question, 80),
+                    marketStart: new bn_js_1.default(startTime),
+                    marketEnd: new bn_js_1.default(endTime),
+                    feeBps,
+                    payoutFee
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    mint,
+                    tokenProgram: (0, helpers_1.getTokenProgram)(mint),
+                    pool: poolPDA,
+                    customer,
+                    userTrade
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Open Order
+     * @param args.marketId - The ID of the Market
+     * @param args.amount - The amount of the Order
+     * @param args.direction - The direction of the Order
+     * @param args.mint - The mint of the Order
+     * @param args.token - The token to use for the Order
+     *
+     * @param options - RPC options
+     *
+     */
+    openOrder({ marketId, amount, direction, mint, token }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            const addressLookupTableAccounts = [];
+            const { userTradePDA, ixs: userTradeIxs } = yield this.getUserTradeIxs();
+            if (userTradeIxs.length > 0) {
+                ixs.push(...userTradeIxs);
+            }
+            let amountInTRD = amount * Math.pow(10, constants_1.TRD_DECIMALS);
+            if (token !== constants_1.TRD_MINT.toBase58()) {
+                const { setupInstructions, swapIxs, addressLookupTableAccounts, trdAmount } = yield (0, swap_1.swap)({
+                    connection: this.program.provider.connection,
+                    wallet: this.program.provider.publicKey.toBase58(),
+                    inToken: token,
+                    amount
+                });
+                amountInTRD = trdAmount;
+                if (swapIxs.length === 0) {
+                    return;
+                }
+                ixs.push(...setupInstructions);
+                ixs.push(...swapIxs);
+                addressLookupTableAccounts.push(...addressLookupTableAccounts);
+            }
+            ixs.push(yield this.program.methods
+                .openOrder({
+                amount: new bn_js_1.default(amountInTRD),
+                direction: direction
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                userTrade: userTradePDA,
+                mint
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options, addressLookupTableAccounts);
+        });
+    }
+    /**
+     * Close Order
+     * @param args.marketId - The ID of the Market
+     * @param args.orderId - The ID of the Order
+     * @param args.userNonce - The nonce of the user
+     *
+     * @param options - RPC options
+     *
+     */
+    closeOrder({ marketId, orderId, userNonce }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            const userTrade = this.getUserPDA(this.program.provider.publicKey, userNonce);
+            ixs.push(yield this.program.methods
+                .closeOrder(new bn_js_1.default(orderId))
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                mint: constants_1.TRD_MINT,
+                userTrade
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Resolve Market
+     * @param args.marketId - The ID of the Market
+     * @param args.winningDirection - The Winning Direction of the Market
+     *
+     * @param options - RPC options
+     *
+     */
+    resolveMarket({ marketId, poolId, winningDirection }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            let poolPDA = null;
+            if (poolId) {
+                poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            }
+            ixs.push(yield this.program.methods
+                .updateMarket({
+                winningDirection,
+                allowPayout: null,
+                marketEnd: null
+            })
+                .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, options);
+        });
+    }
+    /**
+     * Collect Remaining Liquidity
+     * @param marketId - The ID of the market
+     *
+     * @param options - RPC options
+     *
+     */
+    collectRemainingLiquidity(marketId, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
+            const market = yield this.getMarketByAddress(marketPDA);
+            ixs.push(yield this.program.methods
+                .collectRemainingLiquidity()
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: marketPDA,
+                mint: market.mint
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Payout Order
+     * @param args.marketId - The ID of the Market
+     * @param args.orderId - The ID of the Order to Payout
+     * @param args.userNonce - The nonce of the user
+     *
+     * @param options - RPC options
+     *
+     */
+    payoutOrder(orders, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            if (orders.length > 10) {
+                throw new Error('Max 10 orders per transaction');
+            }
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .payoutOrder(new bn_js_1.default(order.orderId))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    userTrade: this.getUserPDA(this.program.provider.publicKey, order.userNonce),
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    mint: order.mint,
+                    tokenProgram: (0, helpers_1.getTokenProgram)(order.mint)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Allow Market to Payout
+     * @param marketId - The ID of the market
+     * @param poolId - The ID of the pool
+     *
+     * @param options - RPC options
+     *
+     */
+    allowMarketToPayout({ marketId, poolId }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            let poolPDA = null;
+            if (poolId) {
+                poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            }
+            ixs.push(yield this.program.methods
+                .updateMarket({
+                winningDirection: null,
+                allowPayout: true,
+                marketEnd: null
+            })
+                .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, options);
+        });
+    }
+    /**
+     * Create Sub User Trade
+     * @param user - User PublicKey the main user
+     *
+     * @param options - RPC options
+     *
+     */
+    createSubUserTrade(user, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            const userTrade = yield this.getUserTrade(user);
+            const subUserTradePDA = (0, pda_1.getSubUserTradePDA)(this.program.programId, user, userTrade.nonce + 1);
+            ixs.push(yield this.program.methods
+                .createSubUserTrade(subUserTradePDA)
+                .accounts({
+                signer: this.program.provider.publicKey
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Update Market
+     * @param marketId - The ID of the market
+     * @param marketEnd - The end time of the market
+     *
+     * @param options - RPC options
+     *
+     */
+    updateMarket(marketId, marketEnd, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            ixs.push(yield this.program.methods
+                .updateMarket({
+                marketEnd: new bn_js_1.default(marketEnd),
+                winningDirection: null,
+                allowPayout: null
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                pool: null
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Create Customer
+     * @param args.id - The ID of the customer
+     * @param args.name - The name of the customer
+     * @param args.authority - The authority of the customer
+     * @param args.feeRecipient - The fee recipient of the customer
+     *
+     * @param options - RPC options
+     *
+     */
+    createCustomer({ id, name, authority, feeRecipient }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            ixs.push(yield this.program.methods
+                .createCustomer({ id, name, authority, feeRecipient })
+                .accounts({
+                signer: this.program.provider.publicKey
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Get User Trade Nonce With Slots
+     * @param userTrades - User Trades
+     *
+     */
+    getUserTradeNonceWithSlots(userTrades) {
+        let nonce = null;
+        for (const userTrade of userTrades) {
+            if (nonce !== null) {
+                break;
+            }
+            userTrade.orders.forEach((order) => {
+                if (order.orderStatus !== types_1.OrderStatus.OPEN &&
+                    order.orderStatus !== types_1.OrderStatus.WAITING) {
+                    nonce = userTrade.isSubUser ? Number(userTrade.nonce) : 0;
+                }
+            });
+        }
+        if (nonce === null) {
+            throw new Error('No open orders found');
+        }
+        return this.getUserPDA(this.program.provider.publicKey, nonce);
+    }
+    /**
+     * Get User Trade Ixs
+     *
+     */
+    getUserTradeIxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            let myUserTrades = [];
+            myUserTrades = yield this.getMyUserTrades(this.program.provider.publicKey);
+            if (myUserTrades.length === 0) {
+                ixs.push(yield this.program.methods
+                    .createUserTrade()
+                    .accounts({
+                    signer: this.program.provider.publicKey
+                })
+                    .instruction());
+                return {
+                    userTradePDA: this.getUserPDA(this.program.provider.publicKey),
+                    ixs,
+                    nonce: 0
+                };
+            }
+            try {
+                const userTradePDA = this.getUserTradeNonceWithSlots(myUserTrades);
+                return { userTradePDA, ixs };
+            }
+            catch (_a) {
+                const mainUserTrade = myUserTrades.find((trade) => !trade.isSubUser);
+                const subUserTradePDA = (0, pda_1.getSubUserTradePDA)(this.program.programId, this.program.provider.publicKey, Number(mainUserTrade.nonce) + 1);
+                ixs.push(yield this.program.methods
+                    .createSubUserTrade(subUserTradePDA)
+                    .accounts({
+                    signer: this.program.provider.publicKey
+                })
+                    .instruction());
+                return {
+                    userTradePDA: (0, pda_1.getUserTradePDA)(this.program.programId, subUserTradePDA),
+                    ixs
+                };
+            }
+        });
+    }
+    /**
+     * Place Bid Order
+     * @param args.marketId - The ID of the Market
+     * @param args.amount - The amount of the Order
+     * @param args.direction - The direction of the Order
+     * @param args.mint - The mint of the Order
+     * @param args.price - The price of the Order
+     *
+     * @param options - RPC options
+     */
+    placeBidOrder({ marketId, amount, direction, mint, price }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            const { userTradePDA, ixs: userTradeIxs } = yield this.getUserTradeIxs();
+            if (userTradeIxs.length > 0) {
+                ixs.push(...userTradeIxs);
+            }
+            ixs.push(yield this.program.methods
+                .placeBidOrder({
+                amount: new bn_js_1.default(amount * Math.pow(10, this.decimals)),
+                price: new bn_js_1.default(price * Math.pow(10, this.decimals)),
+                orderDirection: direction
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                userTrade: userTradePDA,
+                mint,
+                tokenProgram: (0, helpers_1.getTokenProgram)(mint)
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Place Ask Order
+     * @param args.marketId - The ID of the Market
+     * @param args.amount - The amount of the Order
+     * @param args.direction - The direction of the Order
+     * @param args.price - The price of the Order
+     * @param args.bidOrderId - The ID of the Bid Order
+     * @param args.bidNonce - The nonce of the Bid Order
+     *
+     * @param options - RPC options
+     *
+     */
+    placeAskOrder({ marketId, orders }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .placeAskOrder({
+                    shares: new bn_js_1.default(order.amount * Math.pow(10, this.decimals)),
+                    price: new bn_js_1.default(order.price * Math.pow(10, this.decimals)),
+                    bidOrderId: new bn_js_1.default(order.bidOrderId)
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                    userTrade: this.getUserPDA(this.program.provider.publicKey, order.userNonce)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Cancel Bid Order
+     * @param args.marketId - The ID of the Market
+     * @param args.orderId - The ID of the Order
+     * @param args.userNonce - The nonce of the user
+     * @param args.direction - The direction of the Order
+     *
+     * @param options - RPC options
+     */
+    cancelBidOrder({ marketId, orderId, userNonce, mint, direction }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            ixs.push(yield this.program.methods
+                .cancelBidOrder({
+                orderId: new bn_js_1.default(orderId),
+                orderDirection: direction
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                userTrade: this.getUserPDA(this.program.provider.publicKey, userNonce),
+                mint,
+                tokenProgram: (0, helpers_1.getTokenProgram)(mint)
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Cancel Ask Order
+     * @param args.marketId - The ID of the Market
+     * @param args.orderId - The ID of the Order
+     * @param args.userNonce - The nonce of the user
+     * @param args.userNonceBidOrder - The nonce of the bid user
+     * @param args.direction - The direction of the Order
+     *
+     * @param options - RPC options
+     */
+    cancelAskOrder({ marketId, orderId, userNonce, direction }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            ixs.push(yield this.program.methods
+                .cancelAskOrder({
+                orderId: new bn_js_1.default(orderId),
+                orderDirection: direction
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                userTrade: this.getUserPDA(this.program.provider.publicKey, userNonce)
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Market Bid Order
+     * @param args.marketId - The ID of the Market
+     * @param args.amount - The amount of the Order
+     * @param args.direction - The direction of the Order
+     * @param args.mint - The mint of the Order
+     *
+     * @param options - RPC options
+     */
+    marketBidOrder({ marketId, amount, direction, mint, feeBps = 0 }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
+            const ixs = [];
+            const { userTradePDA, ixs: userTradeIxs } = yield this.getUserTradeIxs();
+            const orderBook = yield this.getOrderBook(marketId);
+            let remainingUSDC = new bn_js_1.default(amount * Math.pow(10, this.decimals));
+            const orders = Object.keys(direction)[0] === 'hype'
+                ? orderBook.hype.ask
+                : orderBook.flop.ask;
+            const sortedOrders = orders.sort((a, b) => Number(a.price) - Number(b.price));
+            const tokenProgram = (0, helpers_1.getTokenProgram)(mint);
+            for (const order of sortedOrders) {
+                if (remainingUSDC.lte(new bn_js_1.default(0)))
+                    break;
+                if (order.authority === this.program.provider.publicKey.toBase58()) {
+                    continue;
+                }
+                const orderPrice = new bn_js_1.default(order.price);
+                const availableShares = new bn_js_1.default(order.totalShares).sub(new bn_js_1.default(order.filledShares));
+                let adjustedPrice = orderPrice;
+                if (feeBps > 0) {
+                    const priceSpread = new bn_js_1.default(1000000).sub(orderPrice);
+                    const fee = priceSpread
+                        .mul(new bn_js_1.default(feeBps))
+                        .div(new bn_js_1.default(10000))
+                        .mul(orderPrice)
+                        .div(new bn_js_1.default(1000000));
+                    adjustedPrice = orderPrice.add(fee);
+                }
+                const maxSharesForPrice = remainingUSDC
+                    .mul(new bn_js_1.default(Math.pow(10, this.decimals)))
+                    .div(adjustedPrice);
+                const sharesToBuy = bn_js_1.default.min(maxSharesForPrice, availableShares);
+                if (sharesToBuy.lt(new bn_js_1.default(0)))
+                    continue;
+                const usdcAmount = sharesToBuy
+                    .mul(adjustedPrice)
+                    .div(new bn_js_1.default(Math.pow(10, this.decimals)));
+                ixs.push(yield this.program.methods
+                    .marketBidOrder({
+                    amount: new bn_js_1.default(usdcAmount),
+                    orderDirection: direction,
+                    askOrderId: new bn_js_1.default(order.id)
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: marketPDA,
+                    buyerTrade: userTradePDA,
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                    mint,
+                    tokenProgram,
+                    sellerAuthority: new web3_js_1.PublicKey(order.authority),
+                    sellerTrade: this.getUserPDA(new web3_js_1.PublicKey(order.authority), Number(order.userNonce)),
+                    marketAta: (0, pda_1.getTokenATA)(marketPDA, mint, tokenProgram),
+                    buyerAta: (0, pda_1.getTokenATA)(this.program.provider.publicKey, mint, tokenProgram)
+                })
+                    .instruction());
+                remainingUSDC = remainingUSDC.sub(usdcAmount);
+            }
+            if (userTradeIxs.length > 0) {
+                ixs.unshift(...userTradeIxs);
+            }
+            if (ixs.length === 0) {
+                throw new Error('No matching orders found to fill the requested amount');
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    marketAskOrder({ marketId, shares, bidOrderId, direction, mint }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
+            const ixs = [];
+            const { userTradePDA, ixs: userTradeIxs } = yield this.getUserTradeIxs();
+            const orderBook = yield this.getOrderBook(marketId);
+            let remainingShares = new bn_js_1.default(shares * Math.pow(10, this.decimals));
+            const orders = Object.keys(direction)[0] === 'hype'
+                ? orderBook.hype.bid
+                : orderBook.flop.bid;
+            const sortedOrders = orders.sort((a, b) => Number(b.price) - Number(a.price));
+            const tokenProgram = (0, helpers_1.getTokenProgram)(mint);
+            for (const order of sortedOrders) {
+                if (remainingShares.lte(new bn_js_1.default(0)))
+                    break;
+                if (order.authority === this.program.provider.publicKey.toBase58()) {
+                    continue;
+                }
+                const availableShares = new bn_js_1.default(order.totalShares).sub(new bn_js_1.default(order.filledShares));
+                const sharesToSell = bn_js_1.default.min(remainingShares, availableShares);
+                if (sharesToSell.lt(new bn_js_1.default(0)))
+                    continue;
+                ixs.push(yield this.program.methods
+                    .marketAskOrder({
+                    shares: new bn_js_1.default(sharesToSell),
+                    orderDirection: direction,
+                    bidOrderId: new bn_js_1.default(bidOrderId)
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: marketPDA,
+                    buyerTrade: this.getUserPDA(new web3_js_1.PublicKey(order.authority), Number(order.userNonce)),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                    mint,
+                    tokenProgram,
+                    marketAta: (0, pda_1.getTokenATA)(marketPDA, mint, tokenProgram),
+                    sellerTrade: userTradePDA
+                })
+                    .instruction());
+            }
+            if (userTradeIxs.length > 0) {
+                ixs.unshift(...userTradeIxs);
+            }
+            if (ixs.length === 0) {
+                throw new Error('No matching orders found to fill the requested amount');
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
+    /**
+     * Get Orders By Market ID
+     * @param marketId - The ID of the market
+     *
+     */
+    getOrderBook(marketId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = {
+                marketId: marketId,
+                rewardsAvailable: '0',
+                rewardsClaimed: '0',
+                spreadToReward: '0',
+                hype: { bid: [], ask: [] },
+                flop: { bid: [], ask: [] }
+            };
+            const orderBookPDA = (0, pda_1.getOrderBookPDA)(this.program.programId, marketId);
+            const orderBook = yield this.program.account.orderBook.fetch(orderBookPDA);
+            data.rewardsAvailable = orderBook.rewardsAvailable.toString();
+            data.rewardsClaimed = orderBook.rewardsClaimed.toString();
+            data.spreadToReward = orderBook.spreadToReward.toString();
+            const processOrders = (orders, side) => {
+                for (const order of orders) {
+                    if ((0, helpers_1.getOrderSideFromNumber)(order.orderSide) === types_1.OrderSide.BID) {
+                        data[side].bid.push((0, helpers_1.formatBookOrder)(order));
+                    }
+                    if ((0, helpers_1.getOrderSideFromNumber)(order.orderSide) === types_1.OrderSide.ASK) {
+                        data[side].ask.push((0, helpers_1.formatBookOrder)(order));
+                    }
+                }
+            };
+            processOrders(orderBook.hypeOrders, 'hype');
+            processOrders(orderBook.flopOrders, 'flop');
+            return data;
+        });
+    }
+    /**
+     * Collect Market Fee
+     * @param marketId - The ID of the market
+     *
+     * @param options - RPC options
+     */
+    collectMarketFee(marketId, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            ixs.push(yield this.program.methods
+                .collectMarketFee()
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
+                mint: constants_1.TRD_MINT
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
+        });
+    }
 }
 exports.default = TriadProtocolClient;