@triadxyz/triad-protocol 3.4.0-beta → 3.4.2-beta

package/dist/index.js

@@ -63,12 +63,12 @@ class TriadProtocol {
         this.claim = new claim_1.default(this.program, this.rpcOptions);
     }
     /**
-     * Get My User Trades from a user authority
+     * Get User Orders
      * @param wallet - User wallet PublicKey
      */
-    getMyUserTrades(wallet) {
+    getUserOrders(wallet) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.program.account.userTrade.all([
+            const orders = yield this.program.account.orderV2.all([
                 {
                     memcmp: {
                         offset: 8 + 1,
@@ -76,17 +76,7 @@ class TriadProtocol {
                     }
                 }
             ]);
-            return response.map(({ account, publicKey }) => (0, helpers_2.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);
+            return orders.map(({ account }) => (0, helpers_1.formatOrder)(account));
         });
     }
     /**
@@ -96,8 +86,8 @@ class TriadProtocol {
      */
     getUserOrdersByMarketId(wallet, marketId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userTrades = yield this.getMyUserTrades(wallet);
-            return userTrades.flatMap((userTrade) => userTrade.orders.filter((order) => order.marketId === marketId.toString()));
+            const orders = yield this.getUserOrders(wallet);
+            return orders.filter((order) => order.marketId === marketId.toString());
         });
     }
     /**
@@ -157,30 +147,6 @@ class TriadProtocol {
             return (0, helpers_2.formatCustomer)(customer, customerPDA);
         });
     }
-    /**
-     * 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
-     */
-    getUserTradeByNonce(wallet, userNonce = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userTradePDA = this.getUserPDA(wallet, userNonce);
-            return this.program.account.userTrade.fetch(userTradePDA);
-        });
-    }
     /**
      * Get All Pools
      */
@@ -517,18 +483,14 @@ class TriadProtocol {
      * 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.orderDirection - The direction of the Order
      * @param args.mint - The mint of the Order
      * @param args.token - The token to use for the Order
      */
-    openOrder({ marketId, amount, direction, mint, token }) {
+    openOrder({ marketId, amount, orderDirection, mint, token }) {
         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.BASE_DECIMALS);
             if (token !== constants_1.TRD_MINT.toBase58()) {
                 const { setupInstructions, swapIxs, addressLookupTableAccounts, outAmount } = yield (0, swap_1.swap)({
@@ -550,13 +512,12 @@ class TriadProtocol {
             ixs.push(yield this.program.methods
                 .openOrder({
                 amount: new bn_js_1.default(amountInTRD),
-                direction: direction
+                orderDirection
             })
                 .accounts({
                 signer: this.program.provider.publicKey,
                 payer: this.rpcOptions.payer,
                 market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
-                userTrade: userTradePDA,
                 mint
             })
                 .instruction());
@@ -566,21 +527,18 @@ class TriadProtocol {
     /**
      * 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 args.orderDirection - The direction of the Order
      */
-    closeOrder({ marketId, orderId, userNonce }) {
+    closeOrder({ marketId, orderDirection }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userTrade = this.getUserPDA(this.program.provider.publicKey, userNonce);
             const ixs = [
                 yield this.program.methods
-                    .closeOrder(new bn_js_1.default(orderId))
+                    .closeOrder(orderDirection)
                     .accounts({
                     signer: this.program.provider.publicKey,
                     payer: this.rpcOptions.payer,
                     market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
-                    mint: constants_1.TRD_MINT,
-                    userTrade
+                    mint: constants_1.TRD_MINT
                 })
                     .instruction()
             ];
@@ -590,8 +548,7 @@ class TriadProtocol {
     /**
      * 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 args.orderDirection - The direction of the Order to Payout
      * @param args.mint - The mint of the market
      */
     payoutOrder(orders) {
@@ -602,11 +559,10 @@ class TriadProtocol {
             }
             for (const order of orders) {
                 ixs.push(yield this.program.methods
-                    .payoutOrder(new bn_js_1.default(order.orderId))
+                    .payoutOrder(order.orderDirection)
                     .accounts({
                     signer: this.program.provider.publicKey,
                     payer: this.rpcOptions.payer,
-                    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_2.getTokenProgram)(order.mint)
@@ -616,25 +572,6 @@ class TriadProtocol {
             return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
         });
     }
-    /**
-     * Create Sub User Trade
-     * @param user - User PublicKey the main user
-     */
-    createSubUserTrade(user) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ixs = [];
-            const userTrade = yield this.getUserTradeByNonce(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,
-                payer: this.rpcOptions.payer
-            })
-                .instruction());
-            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
-        });
-    }
     /**
      * Create Customer
      * @param args.id - The ID of the customer
@@ -655,90 +592,6 @@ class TriadProtocol {
             return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
         });
     }
-    /**
-     * 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,
-                    payer: this.rpcOptions.payer
-                })
-                    .instruction());
-                return {
-                    userTradePDA: this.getUserPDA(this.program.provider.publicKey),
-                    ixs,
-                    nonce: 0
-                };
-            }
-            try {
-                let nonce = null;
-                for (const userTrade of myUserTrades) {
-                    if (nonce !== null) {
-                        break;
-                    }
-                    userTrade.orders.forEach((order) => {
-                        if (order.orderStatus !== types_1.OrderStatus.OPEN) {
-                            nonce = userTrade.isSubUser ? Number(userTrade.nonce) : 0;
-                        }
-                    });
-                }
-                if (nonce === null) {
-                    throw new Error('No open orders found');
-                }
-                return {
-                    userTradePDA: this.getUserPDA(this.program.provider.publicKey, nonce),
-                    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,
-                    payer: this.rpcOptions.payer
-                })
-                    .instruction());
-                return {
-                    userTradePDA: (0, pda_1.getUserTradePDA)(this.program.programId, subUserTradePDA),
-                    ixs
-                };
-            }
-        });
-    }
-    /**
-     * Get User Trade Nonce
-     * @param marketId - The ID of the Market
-     * @param orderDirection - The direction of the Order
-     */
-    getUserTradeNonce(marketId, orderDirection) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const userOrders = yield this.getUserOrdersByMarketId(this.program.provider.publicKey, marketId);
-            const userNonce = (_a = userOrders.find((order) => order.orderDirection === orderDirection &&
-                order.orderStatus === types_1.OrderStatus.OPEN &&
-                Number(order.marketId) === marketId)) === null || _a === void 0 ? void 0 : _a.userNonce;
-            let userTradePDA = null;
-            let userTradeIxs = [];
-            if (userNonce) {
-                userTradePDA = this.getUserPDA(this.program.provider.publicKey, Number(userNonce));
-            }
-            if (!userNonce) {
-                const { userTradePDA: user, ixs: ixsUser } = yield this.getUserTradeIxs();
-                userTradePDA = user;
-                userTradeIxs = ixsUser;
-            }
-            return { userTradePDA, userTradeIxs };
-        });
-    }
     /**
      * Place Bid Order
      * @param args.orders - Array of orders to execute
@@ -746,15 +599,14 @@ class TriadProtocol {
      * @param args.orders.amount - The amount of the Order
      * @param args.orders.price - The price of the Order
      * @param args.orders.orderDirection - The direction of the Order
-     * @param args.mint - The mint of the Order
      * @param args.isTrdPayout - Whether to payout in TRD or not
      */
     placeBidOrder({ orders, isTrdPayout }) {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
             const addressLookupTableAccounts = [];
-            if (orders.length > 4) {
-                throw new Error('You can only place up to 4 orders at a time');
+            if (orders.length > 5) {
+                throw new Error('Max 5 orders per transaction');
             }
             let amountInUSDC = new bn_js_1.default(0);
             let totalAmount = 0;
@@ -783,10 +635,6 @@ class TriadProtocol {
                     return;
                 }
             }
-            const { userTradePDA, userTradeIxs } = yield this.getUserTradeNonce(orders[0].marketId, Object.keys(orders[0].orderDirection)[0]);
-            if (userTradeIxs.length > 0) {
-                ixs.push(...userTradeIxs);
-            }
             for (const order of orders) {
                 ixs.push(yield this.program.methods
                     .placeBidOrder({
@@ -797,8 +645,7 @@ class TriadProtocol {
                     .accounts({
                     signer: this.program.provider.publicKey,
                     market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
-                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId),
-                    userTrade: userTradePDA
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId)
                 })
                     .instruction());
             }
@@ -818,20 +665,19 @@ class TriadProtocol {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
             if (orders.length > 5) {
-                throw new Error('You can only place up to 5 orders at a time');
+                throw new Error('Max 5 orders per transaction');
             }
             for (const order of orders) {
                 ixs.push(yield this.program.methods
                     .placeAskOrder({
                     shares: new bn_js_1.default(order.amount * Math.pow(10, constants_1.BASE_DECIMALS)),
                     price: new bn_js_1.default(order.price * Math.pow(10, constants_1.BASE_DECIMALS)),
-                    bidOrderId: new bn_js_1.default(order.bidOrderId)
+                    orderDirection: order.orderDirection
                 })
                     .accounts({
                     signer: this.program.provider.publicKey,
                     market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
-                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId),
-                    userTrade: this.getUserPDA(this.program.provider.publicKey, order.userNonce)
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId)
                 })
                     .instruction());
             }
@@ -840,28 +686,27 @@ class TriadProtocol {
     }
     /**
      * Cancel Bid Order
-     * @param args.orders.orderId - The ID of the Order
-     * @param args.orders.userNonce - The nonce of the user
+     * @param args.orders.bookOrderId - The ID of the Book Order
+     * @param args.orders.marketId - The ID of the Market
      * @param args.orders.orderDirection - The direction of the Order
      */
     cancelBidOrder({ orders }) {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
-            if (orders.length > 5) {
-                throw new Error('You can only cancel up to 5 orders at a time');
+            if (orders.length > 6) {
+                throw new Error('You can only cancel up to 6 orders at a time');
             }
             for (const order of orders) {
                 ixs.push(yield this.program.methods
                     .cancelBidOrder({
-                    orderId: new bn_js_1.default(order.orderId),
+                    bookOrderId: new bn_js_1.default(order.bookOrderId),
                     orderDirection: order.orderDirection
                 })
                     .accounts({
                     signer: this.program.provider.publicKey,
                     payer: this.rpcOptions.payer,
                     market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
-                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId),
-                    userTrade: this.getUserPDA(this.program.provider.publicKey, order.userNonce)
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId)
                 })
                     .instruction());
             }
@@ -870,28 +715,26 @@ class TriadProtocol {
     }
     /**
      * Cancel Ask Order
-     * @param args.marketId - The ID of the Market
-     * @param args.orders.orderId - The ID of the Order
-     * @param args.orders.userNonce - The nonce of the user
+     * @param args.orders.marketId - The ID of the Market
+     * @param args.orders.bookOrderId - The ID of the Book Order
      * @param args.orders.orderDirection - The direction of the Order
      */
-    cancelAskOrder({ marketId, orders }) {
+    cancelAskOrder({ orders }) {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
-            if (orders.length > 4) {
-                throw new Error('You can only cancel up to 4 orders at a time');
+            if (orders.length > 5) {
+                throw new Error('Max 5 orders per transaction');
             }
             for (const order of orders) {
                 ixs.push(yield this.program.methods
                     .cancelAskOrder({
-                    orderId: new bn_js_1.default(order.orderId),
+                    bookOrderId: new bn_js_1.default(order.bookOrderId),
                     orderDirection: order.orderDirection
                 })
                     .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)
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId)
                 })
                     .instruction());
             }
@@ -910,7 +753,6 @@ class TriadProtocol {
             const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
             const ixs = [];
             const addressLookupTableAccounts = [];
-            const { userTradePDA, userTradeIxs } = yield this.getUserTradeNonce(marketId, Object.keys(orderDirection)[0]);
             const orderBook = yield this.getOrderBook(marketId);
             let remainingUSDC = new bn_js_1.default(amount * Math.pow(10, constants_1.BASE_DECIMALS));
             if (isTrdPayout) {
@@ -992,25 +834,19 @@ class TriadProtocol {
                     .marketBidOrder({
                     amount: new bn_js_1.default(usdcAmount),
                     orderDirection,
-                    askOrderId: new bn_js_1.default(order.id),
-                    isTrdPayout
+                    bookOrderAskId: new bn_js_1.default(order.id),
+                    oppositeOrderDirection: (0, helpers_1.getOppositeOrderDirectionEncoded)(orderDirection)
                 })
                     .accounts({
                     signer: this.program.provider.publicKey,
                     market: marketPDA,
-                    buyerTrade: userTradePDA,
                     orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
-                    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, constants_1.USDC_MINT, spl_token_1.TOKEN_PROGRAM_ID),
-                    buyerAta: (0, pda_1.getTokenATA)(this.program.provider.publicKey, constants_1.USDC_MINT, spl_token_1.TOKEN_PROGRAM_ID)
+                    bookOrderAskAuthority: new web3_js_1.PublicKey(order.authority),
+                    oppositeOrder: (0, pda_1.getOrderPDA)(this.program.programId, new web3_js_1.PublicKey(order.authority), marketId, (0, helpers_1.getOppositeOrderDirection)(order.orderDirection))
                 })
                     .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');
             }
@@ -1020,13 +856,11 @@ class TriadProtocol {
     /**
      * Market Ask Order
      * @param args.marketId - The ID of the Market
-     * @param args.orders - Array of orders to execute
-     * @param args.orders.shares - The amount of shares to sell
-     * @param args.orders.bidOrderId - The ID of the Bid Order
-     * @param args.orders.userNonce - The nonce of the user
+     * @param args.shares - The amount of shares to sell
+     * @param args.bookOrderBidId - The ID of the Bid Order
      * @param args.orderDirection - The direction of the Order
      */
-    marketAskOrder({ marketId, orders, orderDirection }) {
+    marketAskOrder({ marketId, shares, orderDirection }) {
         return __awaiter(this, void 0, void 0, function* () {
             const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
             const ixs = [];
@@ -1037,43 +871,38 @@ class TriadProtocol {
                 : orderBook.flop.bid;
             const sortedOrders = bidOrders.sort((a, b) => Number(b.price) - Number(a.price));
             let amountOfUSDC = new bn_js_1.default(0);
-            for (const inputOrder of orders) {
-                let remainingShares = new bn_js_1.default(inputOrder.shares * Math.pow(10, constants_1.BASE_DECIMALS));
-                for (const order of sortedOrders) {
-                    if (remainingShares.lte(new bn_js_1.default(0)))
-                        break;
-                    if (order.authority === this.program.provider.publicKey.toBase58() ||
-                        order.linkedBookOrderId !== constants_1.BOOK_ORDER_NULL.toString()) {
-                        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;
-                    remainingShares = remainingShares.sub(sharesToSell);
-                    const orderPrice = new bn_js_1.default(order.price);
-                    const effectivePriceDecimal = (0, feeCalculator_1.applySellFee)(orderPrice.toNumber() / 1000000);
-                    const adjustedPrice = new bn_js_1.default(Math.floor(effectivePriceDecimal * 1000000));
-                    amountOfUSDC = amountOfUSDC.add(sharesToSell.mul(adjustedPrice).div(new bn_js_1.default(Math.pow(10, constants_1.BASE_DECIMALS))));
-                    ixs.push(yield this.program.methods
-                        .marketAskOrder({
-                        shares: new bn_js_1.default(sharesToSell),
-                        orderDirection,
-                        bidOrderId: new bn_js_1.default(inputOrder.bidOrderId),
-                        bookOrderBidId: new bn_js_1.default(order.id)
-                    })
-                        .accounts({
-                        signer: this.program.provider.publicKey,
-                        payer: this.rpcOptions.payer,
-                        market: marketPDA,
-                        buyerAuthority: new web3_js_1.PublicKey(order.authority),
-                        buyerTrade: this.getUserPDA(new web3_js_1.PublicKey(order.authority), Number(order.userNonce)),
-                        orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
-                        marketAta: (0, pda_1.getTokenATA)(marketPDA, constants_1.USDC_MINT, spl_token_1.TOKEN_PROGRAM_ID),
-                        sellerTrade: this.getUserPDA(this.program.provider.publicKey, inputOrder.userNonce)
-                    })
-                        .instruction());
+            let remainingShares = new bn_js_1.default(shares * Math.pow(10, constants_1.BASE_DECIMALS));
+            for (const order of sortedOrders) {
+                if (remainingShares.lte(new bn_js_1.default(0)))
+                    break;
+                if (order.authority === this.program.provider.publicKey.toBase58() ||
+                    order.linkedBookOrderId !== constants_1.BOOK_ORDER_NULL.toString()) {
+                    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;
+                remainingShares = remainingShares.sub(sharesToSell);
+                const orderPrice = new bn_js_1.default(order.price);
+                const effectivePriceDecimal = (0, feeCalculator_1.applySellFee)(orderPrice.toNumber() / 1000000);
+                const adjustedPrice = new bn_js_1.default(Math.floor(effectivePriceDecimal * 1000000));
+                amountOfUSDC = amountOfUSDC.add(sharesToSell.mul(adjustedPrice).div(new bn_js_1.default(Math.pow(10, constants_1.BASE_DECIMALS))));
+                ixs.push(yield this.program.methods
+                    .marketAskOrder({
+                    shares: new bn_js_1.default(sharesToSell),
+                    orderDirection,
+                    bookOrderBidId: new bn_js_1.default(order.id)
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    payer: this.rpcOptions.payer,
+                    market: marketPDA,
+                    buyerAuthority: new web3_js_1.PublicKey(order.authority),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                    marketAta: (0, pda_1.getTokenATA)(marketPDA, constants_1.USDC_MINT, spl_token_1.TOKEN_PROGRAM_ID)
+                })
+                    .instruction());
             }
             if (ixs.length === 0) {
                 throw new Error('No matching orders found to fill the requested amount');
@@ -1135,5 +964,31 @@ class TriadProtocol {
             return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
         });
     }
+    closeUser(userTrade) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .closeUser()
+                    .accounts({ userTrade })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    migrateUserTradeToOrder(userTrade, marketId, orderId, orderDirection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .migrateUserTradeToOrder({
+                    marketId: new bn_js_1.default(marketId),
+                    orderId: new bn_js_1.default(orderId),
+                    orderDirection
+                })
+                    .accounts({ userTrade })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
 }
 exports.default = TriadProtocol;

package/dist/poseidon.js

@@ -15,7 +15,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("./utils/constants");
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
 const pda_1 = require("./utils/pda");
-const pda_2 = require("./utils/pda");
 class Poseidon {
     constructor(program, rpcOptions) {
         this.program = program;
@@ -100,7 +99,6 @@ class Poseidon {
                     .addTraderPoseidon()
                     .accounts({
                     poseidonAsset,
-                    userTrade: (0, pda_2.getUserTradePDA)(this.program.programId, user),
                     corePoseidonCollection: constants_1.POSEIDON_CORE_COLLECTION,
                     poseidonCollection: (0, pda_1.getCollectionPDA)(this.program.programId, constants_1.POSEIDON_COLLECTION_SYMBOL)
                 })
@@ -120,7 +118,6 @@ class Poseidon {
                 yield this.program.methods
                     .removeTraderPoseidon()
                     .accounts({
-                    userTrade: (0, pda_2.getUserTradePDA)(this.program.programId, user),
                     poseidonAsset,
                     corePoseidonCollection: constants_1.POSEIDON_CORE_COLLECTION,
                     poseidonCollection: (0, pda_1.getCollectionPDA)(this.program.programId, constants_1.POSEIDON_COLLECTION_SYMBOL)

package/dist/stake.js

@@ -81,6 +81,7 @@ class Stake {
                     amount: new anchor_1.BN(amount * Math.pow(10, 6))
                 })
                     .accounts({
+                    signer: this.program.provider.publicKey,
                     mint: constants_1.TRD_MINT
                 })
                     .instruction()
@@ -98,6 +99,7 @@ class Stake {
                 yield this.program.methods
                     .addStakeVaultRewards(new anchor_1.BN(amount * Math.pow(10, 6)))
                     .accounts({
+                    signer: this.program.provider.publicKey,
                     mint: constants_1.TRD_MINT
                 })
                     .instruction()
@@ -114,6 +116,9 @@ class Stake {
             const ixs = [
                 yield this.program.methods
                     .updateStakeVaultIsLocked(isLocked)
+                    .accounts({
+                    signer: this.program.provider.publicKey
+                })
                     .instruction()
             ];
             return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);