@triadxyz/triad-protocol 1.7.3-beta → 1.7.4-beta

package/dist/trade.js

@@ -12,18 +12,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const trade_1 = require("./types/trade");
 const bn_js_1 = __importDefault(require("bn.js"));
 const constants_1 = require("./utils/constants");
 const helpers_1 = require("./utils/helpers");
-const trade_1 = require("./utils/pda/trade");
+const trade_2 = require("./utils/pda/trade");
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
 const sendTransactionWithOptions_1 = __importDefault(require("./utils/sendTransactionWithOptions"));
-const swap_1 = require("./utils/swap");
+const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
 class Trade {
     constructor(program, provider) {
         this.program = program;
         this.provider = provider;
         this.mint = constants_1.TRD_MINT;
+        this.decimals = constants_1.TRD_DECIMALS; // We're using only TRD or USDC so we can use the same decimals 6
     }
     /**
      * Get All Markets
@@ -72,7 +74,7 @@ class Trade {
      */
     getMarketById(marketId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
             const response = yield this.program.account.marketV2.fetch(marketPDA);
             return (0, helpers_1.formatMarket)(response, marketPDA);
         });
@@ -96,10 +98,10 @@ class Trade {
      */
     getUserTrade(user, userNonce = 0) {
         return __awaiter(this, void 0, void 0, function* () {
-            let userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, user);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, user);
             if (userNonce !== 0) {
-                const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, user, userNonce);
-                userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, user, userNonce);
+                userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
             }
             return this.program.account.userTrade.fetch(userTradePDA);
         });
@@ -110,11 +112,13 @@ class Trade {
      * @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 options - RPC options
      *
      */
-    createMarket({ marketId, startTime, endTime, question, feeBps, customer, mint }, options) {
+    createMarket({ marketId, startTime, endTime, question, feeBps, customer, payoutFee, mint }, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (question.length > 80) {
                 throw new Error('Question must be less than 80 characters');
@@ -125,7 +129,8 @@ class Trade {
                 question: (0, helpers_1.encodeString)(question, 80),
                 marketStart: new bn_js_1.default(startTime),
                 marketEnd: new bn_js_1.default(endTime),
-                feeBps
+                feeBps,
+                payoutFee
             })
                 .accounts({
                 signer: this.provider.publicKey,
@@ -135,53 +140,20 @@ class Trade {
             }), options);
         });
     }
-    /**
-     * Get User Trade Nonce With Slots
-     * @param userTrades - User Trades
-     *
-     */
-    getUserTradeNonceWithSlots(userTrades) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let nonce = null;
-            for (const userTrade of userTrades.reverse()) {
-                if (nonce !== null) {
-                    break;
-                }
-                userTrade.orders.forEach((order) => {
-                    if (nonce !== null) {
-                        return;
-                    }
-                    let status = Object.keys(order.status)[0];
-                    if (status !== 'open') {
-                        nonce = userTrade.isSubUser ? Number(userTrade.nonce) : 0;
-                    }
-                });
-            }
-            if (nonce === null) {
-                throw new Error('No open orders found');
-            }
-            if (nonce === 0) {
-                return (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
-            }
-            const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, nonce);
-            const userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
-            return userTradePDA;
-        });
-    }
     /**
      * 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.token - The token of the Order
+     * @param args.mint - The mint of the Order
      *
      * @param options - RPC options
      *
      */
-    openOrder({ marketId, amount, direction, token }, options) {
+    openOrder({ marketId, amount, direction, mint }, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            let userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
             const ixs = [];
             const addressLookupTableAccounts = [];
             let amountInTRD = amount * Math.pow(10, constants_1.TRD_DECIMALS);
@@ -201,8 +173,8 @@ class Trade {
                 }
                 catch (_a) {
                     const mainUserTrade = myUserTrades.find((userTrade) => !userTrade.isSubUser);
-                    const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, Number(mainUserTrade.nonce) + 1);
-                    userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                    const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, Number(mainUserTrade.nonce) + 1);
+                    userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
                     ixs.push(yield this.program.methods
                         .createSubUserTrade(subUserTradePDA)
                         .accounts({
@@ -211,21 +183,6 @@ class Trade {
                         .instruction());
                 }
             }
-            if (token !== constants_1.TRD_MINT.toBase58()) {
-                const { setupInstructions, swapIxs, addressLookupTableAccounts, trdAmount } = yield (0, swap_1.swap)({
-                    connection: this.provider.connection,
-                    wallet: this.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),
@@ -235,7 +192,7 @@ class Trade {
                 signer: this.provider.publicKey,
                 market: marketPDA,
                 userTrade: userTradePDA,
-                mint: this.mint
+                mint
             })
                 .instruction());
             return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options, undefined, addressLookupTableAccounts);
@@ -252,11 +209,11 @@ class Trade {
      */
     closeOrder({ marketId, orderId, userNonce }, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            let userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
             if (userNonce !== 0) {
-                const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
-                userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
+                userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
             }
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.closeOrder(new bn_js_1.default(orderId)).accounts({
                 signer: this.provider.publicKey,
@@ -276,7 +233,7 @@ class Trade {
      */
     resolveMarket({ marketId, winningDirection }, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
             const method = this.program.methods
                 .resolveMarket(winningDirection)
                 .accounts({
@@ -295,7 +252,7 @@ class Trade {
      */
     collectRemainingLiquidity(marketId, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
             const market = yield this.getMarketByAddress(marketPDA);
             if (market.isAllowedToPayout) {
                 return;
@@ -318,11 +275,11 @@ class Trade {
      */
     payoutOrder({ marketId, orderId, userNonce, mint }, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            let userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
             if (userNonce !== 0) {
-                const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
-                userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
+                userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
             }
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.payoutOrder(new bn_js_1.default(orderId)).accounts({
                 signer: this.provider.publicKey,
@@ -341,7 +298,7 @@ class Trade {
      */
     allowMarketToPayout(marketId, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.allowMarketToPayout().accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA
@@ -358,7 +315,7 @@ class Trade {
     createSubUserTrade(user, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const userTrade = yield this.getUserTrade(user);
-            const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, user, userTrade.nonce + 1);
+            const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, user, userTrade.nonce + 1);
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.createSubUserTrade(subUserTradePDA).accounts({
                 signer: this.provider.publicKey
             }), options);
@@ -374,7 +331,7 @@ class Trade {
      */
     updateMarket(marketId, marketEnd, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.updateMarket(new bn_js_1.default(marketEnd)).accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA
@@ -390,12 +347,305 @@ class Trade {
      * @param options - RPC options
      *
      */
-    createCustomer({ id, name, authority }, options) {
+    createCustomer({ id, name, authority, feeRecipient }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods
+                .createCustomer({ id, name, authority, feeRecipient })
+                .accounts({
+                signer: this.provider.publicKey
+            }), options);
+        });
+    }
+    /**
+     * Get User Trade Nonce With Slots
+     * @param userTrades - User Trades
+     *
+     */
+    getUserTradeNonceWithSlots(userTrades) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let nonce = null;
+            for (const userTrade of userTrades.reverse()) {
+                if (nonce !== null) {
+                    break;
+                }
+                let freeSlots = 0;
+                userTrade.orders.forEach((order) => {
+                    if (nonce !== null) {
+                        return;
+                    }
+                    if (order.orderStatus !== trade_1.OrderStatus.OPEN &&
+                        order.orderStatus !== trade_1.OrderStatus.WAITING &&
+                        freeSlots >= 2) {
+                        nonce = userTrade.isSubUser ? Number(userTrade.nonce) : 0;
+                    }
+                    if (order.orderStatus !== trade_1.OrderStatus.OPEN &&
+                        order.orderStatus !== trade_1.OrderStatus.WAITING) {
+                        freeSlots += 1;
+                    }
+                });
+            }
+            if (nonce === null) {
+                throw new Error('No open orders found');
+            }
+            if (nonce === 0) {
+                return (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            }
+            const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, nonce);
+            const userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
+            return userTradePDA;
+        });
+    }
+    getUserTradeIxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            const ixs = [];
+            let myUserTrades = [];
+            myUserTrades = yield this.getMyUserTrades(this.provider.publicKey);
+            if (myUserTrades.length === 0) {
+                ixs.push(yield this.program.methods
+                    .createUserTrade()
+                    .accounts({
+                    signer: this.provider.publicKey
+                })
+                    .instruction());
+            }
+            if (myUserTrades.length > 0) {
+                try {
+                    userTradePDA = yield this.getUserTradeNonceWithSlots(myUserTrades);
+                    // Check if we need to create a new sub user trade
+                    // This happens when all existing slots have open orders
+                    const allSlotsHaveOpenOrders = myUserTrades.every((trade) => trade.orders.some((order) => order.orderStatus === trade_1.OrderStatus.OPEN ||
+                        order.orderStatus === trade_1.OrderStatus.WAITING));
+                    if (allSlotsHaveOpenOrders) {
+                        // Find the main user trade to get the current nonce
+                        const mainUserTrade = myUserTrades.find((userTrade) => !userTrade.isSubUser);
+                        if (!mainUserTrade) {
+                            throw new Error('No main user trade found');
+                        }
+                        const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, Number(mainUserTrade.nonce) + 1);
+                        ixs.push(yield this.program.methods
+                            .createSubUserTrade(subUserTradePDA)
+                            .accounts({
+                            signer: this.provider.publicKey
+                        })
+                            .instruction());
+                    }
+                }
+                catch (error) {
+                    const mainUserTrade = myUserTrades.find((userTrade) => !userTrade.isSubUser);
+                    const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, Number(mainUserTrade.nonce) + 1);
+                    userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                    ixs.push(yield this.program.methods
+                        .createSubUserTrade(subUserTradePDA)
+                        .accounts({
+                        signer: this.provider.publicKey
+                    })
+                        .instruction());
+                }
+            }
+            return {
+                userTradePDA,
+                ixs
+            };
+        });
+    }
+    /**
+     * Place 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.orderSide - The side of the Order
+     * @param args.mint - The mint of the Order
+     * @param args.price - The price of the Order
+     *
+     * @param options - RPC options
+     *
+     */
+    placeOrder({ marketId, amount, direction, orderSide, mint, price, bidOrderId }, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return (0, sendTransactionWithOptions_1.default)(this.program.methods.createCustomer({ id, name, authority }).accounts({
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            const ixs = [];
+            const { userTradePDA, ixs: userTradeIxs } = yield this.getUserTradeIxs();
+            ixs.push(...userTradeIxs);
+            if (Object.keys(orderSide)[0] === 'bid') {
+                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.provider.publicKey,
+                    market: marketPDA,
+                    userTrade: userTradePDA,
+                    mint,
+                    tokenProgram: (0, helpers_1.getTokenProgram)(mint)
+                })
+                    .instruction());
+            }
+            if (Object.keys(orderSide)[0] === 'ask' && bidOrderId) {
+                ixs.push(yield this.program.methods
+                    .placeAskOrder({
+                    shares: new bn_js_1.default(amount * Math.pow(10, this.decimals)),
+                    price: new bn_js_1.default(price * Math.pow(10, this.decimals)),
+                    bidOrderId: new bn_js_1.default(bidOrderId),
+                    orderDirection: direction
+                })
+                    .accounts({
+                    signer: this.provider.publicKey,
+                    market: marketPDA,
+                    userTrade: userTradePDA
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options);
+        });
+    }
+    /**
+     * Cancel 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.orderSide - The side of the Order
+     *
+     * @param options - RPC options
+     */
+    cancelOrder({ marketId, orderId, userNonce, orderSide, mint, userNonceBidOrder }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            let bidUserTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            if (userNonce !== 0) {
+                const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
+                userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
+            }
+            if (userNonceBidOrder !== null && userNonceBidOrder !== 0) {
+                const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonceBidOrder);
+                bidUserTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
+            }
+            if (orderSide === trade_1.OrderSide.BID) {
+                return (0, sendTransactionWithOptions_1.default)(this.program.methods.cancelBidOrder(new bn_js_1.default(orderId)).accounts({
+                    signer: this.provider.publicKey,
+                    market: marketPDA,
+                    userTrade: userTradePDA,
+                    mint
+                }), options);
+            }
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.cancelAskOrder(new bn_js_1.default(orderId)).accounts({
+                signer: this.provider.publicKey,
+                market: marketPDA,
+                userTrade: userTradePDA,
+                bidUserTrade: bidUserTradePDA
+            }), options);
+        });
+    }
+    /**
+     * Update Customer Fee
+     * @param args.id - The ID of the Customer
+     * @param args.feeRecipient - The fee account
+     *
+     * @param options - RPC options
+     */
+    updateCustomerFee({ id, feeRecipient }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.updateCustomerFee({ id, feeRecipient }).accounts({
                 signer: this.provider.publicKey
             }), 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 }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            const ixs = [];
+            const { userTradePDA: buyerTrade, ixs: userTradeIxs } = yield this.getUserTradeIxs();
+            // TODO: Get dynamic until fill all order
+            const sellerTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            ixs.push(...userTradeIxs);
+            ixs.push(yield this.program.methods
+                .marketBidOrder({
+                amount: new bn_js_1.default(amount * Math.pow(10, this.decimals)),
+                direction
+            })
+                .accounts({
+                signer: this.provider.publicKey,
+                market: marketPDA,
+                buyerTrade,
+                sellerTrade: sellerTradePDA,
+                mint
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.provider, 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 marketIdBytes = bytes_1.bs58.encode(new bn_js_1.default(marketId).toArrayLike(Buffer, 'le', 8));
+            const memcmpFilters = Array.from({ length: 10 }).map((_, index) => ({
+                memcmp: {
+                    offset: 8 + // discriminator
+                        1 + // bump
+                        32 + // authority
+                        8 + // total_deposits
+                        8 + // total_withdraws
+                        8 + // opened_orders
+                        // Per order: index * (8 + 8 + 8 + 8 + 1 + 8 + 8 + 8 + 1 + 1 + 4 + 28)
+                        index * (8 + 8 + 8 + 8 + 1 + 8 + 8 + 8 + 1 + 1 + 4 + 1 + 27) +
+                        // Then offset to market_id: 8 + 8 + 8
+                        (8 + 8 + 8),
+                    bytes: marketIdBytes
+                }
+            }));
+            const allResponses = yield Promise.all(memcmpFilters.map((filter) => this.program.account.userTrade.all([filter])));
+            const uniqueResponses = Array.from(new Map(allResponses.flat().map((item) => [item.publicKey.toString(), item])).values());
+            const userTrades = uniqueResponses.map(({ account, publicKey }) => (0, helpers_1.formatUserTrade)(account, publicKey));
+            const orders = userTrades.flatMap((userTrade) => userTrade.orders.map((order) => (Object.assign({}, order))));
+            const filteredOrders = orders.filter((order) => order.marketId === marketId.toString() &&
+                order.orderType === trade_1.OrderType.LIMIT &&
+                order.orderStatus === trade_1.OrderStatus.WAITING);
+            const orderBook = {
+                hype: {
+                    bid: [],
+                    ask: []
+                },
+                flop: {
+                    bid: [],
+                    ask: []
+                }
+            };
+            filteredOrders.forEach((order) => {
+                if (order.orderSide === trade_1.OrderSide.BID &&
+                    order.orderDirection === trade_1.OrderDirection.HYPE) {
+                    orderBook.hype.bid.push(order);
+                    return;
+                }
+                if (order.orderSide === trade_1.OrderSide.ASK &&
+                    order.orderDirection === trade_1.OrderDirection.HYPE) {
+                    orderBook.hype.ask.push(order);
+                    return;
+                }
+                if (order.orderSide === trade_1.OrderSide.BID &&
+                    order.orderDirection === trade_1.OrderDirection.FLOP) {
+                    orderBook.flop.bid.push(order);
+                    return;
+                }
+                orderBook.flop.ask.push(order);
+            });
+            return orderBook;
+        });
+    }
 }
 exports.default = Trade;