@triadxyz/triad-protocol 3.0.8-beta → 3.1.0-beta

package/dist/index.d.ts

@@ -45,6 +45,11 @@ export default class TriadProtocolClient {
      *
      */
     getUserOrdersByMarketId(wallet: PublicKey, marketId: number): Promise<import("./types").Order[]>;
+    /**
+     * Get User Book Orders
+     *
+     */
+    getUserBookOrders(wallet: PublicKey, marketId: number): Promise<BookOrder[]>;
     /**
      * Get Pool By ID
      * @param poolId - The ID of the pool
@@ -305,6 +310,7 @@ export default class TriadProtocolClient {
         mint: PublicKey;
         shares: number;
         isTrdPayout: boolean;
+        isWinner: boolean;
     }[], options?: RpcOptions): Promise<string>;
     /**
      * Allow Market to Payout
@@ -361,7 +367,7 @@ export default class TriadProtocolClient {
      * @param refer - The refer public key
      *
      */
-    getUserTradeIxs(refer?: PublicKey): Promise<{
+    getUserTradeIxs(): Promise<{
         userTradePDA: PublicKey;
         ixs: TransactionInstruction[];
         nonce: number;
@@ -391,7 +397,7 @@ export default class TriadProtocolClient {
      *
      * @param options - RPC options
      */
-    placeBidOrder({ marketId, amount, direction, mint, price, isTrdPayout }: PlaceBidOrderArgs, options?: RpcOptions): Promise<string>;
+    placeBidOrder({ marketId, orders, mint, isTrdPayout }: PlaceBidOrderArgs, options?: RpcOptions): Promise<string>;
     /**
      * Place Ask Order
      * @param args.marketId - The ID of the Market
@@ -414,7 +420,7 @@ export default class TriadProtocolClient {
      *
      * @param options - RPC options
      */
-    cancelBidOrder({ marketId, orderId, userNonce, mint, direction }: CancelBidOrderArgs, options?: RpcOptions): Promise<string>;
+    cancelBidOrder({ marketId, orders, mint }: CancelBidOrderArgs, options?: RpcOptions): Promise<string>;
     /**
      * Cancel Ask Order
      * @param args.marketId - The ID of the Market
@@ -425,7 +431,7 @@ export default class TriadProtocolClient {
      *
      * @param options - RPC options
      */
-    cancelAskOrder({ marketId, orderId, userNonce, direction }: CancelAskOrderArgs, options?: RpcOptions): Promise<string>;
+    cancelAskOrder({ marketId, orders }: CancelAskOrderArgs, options?: RpcOptions): Promise<string>;
     /**
      * Market Bid Order
      * @param args.marketId - The ID of the Market

package/dist/index.js

@@ -113,6 +113,20 @@ class TriadProtocolClient {
             return userTrades.flatMap((userTrade) => userTrade.orders.filter((order) => order.marketId === marketId.toString()));
         });
     }
+    /**
+     * Get User Book Orders
+     *
+     */
+    getUserBookOrders(wallet, marketId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const orderBook = yield this.program.account.orderBook.fetch((0, pda_1.getOrderBookPDA)(this.program.programId, marketId));
+            const orders = [...orderBook.hypeOrders, ...orderBook.flopOrders];
+            return orders
+                .map((order) => (0, helpers_1.formatBookOrder)(order))
+                .filter((order) => order.authority === wallet.toBase58() &&
+                order.linkedBookOrderId === constants_1.BOOK_ORDER_NULL.toString());
+        });
+    }
     /**
      * Get Pool By ID
      * @param poolId - The ID of the pool
@@ -496,8 +510,8 @@ class TriadProtocolClient {
     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');
+            if (orders.length > 6) {
+                throw new Error('Max 6 orders per transaction');
             }
             for (const order of orders) {
                 ixs.push(yield this.program.methods
@@ -510,13 +524,13 @@ class TriadProtocolClient {
                     tokenProgram: (0, helpers_1.getTokenProgram)(order.mint)
                 })
                     .instruction());
-                if (order.isTrdPayout) {
+                if (order.isTrdPayout && order.isWinner) {
                     const { setupInstructions, swapIxs, addressLookupTableAccounts } = yield (0, swap_1.swap)({
                         connection: this.program.provider.connection,
                         wallet: this.program.provider.publicKey.toBase58(),
                         inToken: constants_1.USDC_MINT.toBase58(),
                         outToken: constants_1.TRD_MINT.toString(),
-                        amount: order.shares / Math.pow(10, this.decimals)
+                        amount: Math.floor(order.shares / Math.pow(10, this.decimals))
                     });
                     if (swapIxs.length === 0) {
                         return;
@@ -644,8 +658,8 @@ class TriadProtocolClient {
                 break;
             }
             userTrade.orders.forEach((order) => {
-                if (order.orderStatus !== types_1.OrderStatus.OPEN &&
-                    order.orderStatus !== types_1.OrderStatus.WAITING) {
+                if (order.orderStatus === types_1.OrderStatus.INIT ||
+                    order.orderStatus === types_1.OrderStatus.CLOSED) {
                     nonce = userTrade.isSubUser ? Number(userTrade.nonce) : 0;
                 }
             });
@@ -660,15 +674,12 @@ class TriadProtocolClient {
      * @param refer - The refer public key
      *
      */
-    getUserTradeIxs(refer) {
+    getUserTradeIxs() {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
             let myUserTrades = [];
             myUserTrades = yield this.getMyUserTrades(this.program.provider.publicKey);
             let referPDA = null;
-            if (refer) {
-                referPDA = (0, pda_1.getReferPDA)(this.program.programId, refer);
-            }
             if (myUserTrades.length === 0) {
                 ixs.push(yield this.program.methods
                     .createUserTrade()
@@ -739,14 +750,21 @@ class TriadProtocolClient {
      *
      * @param options - RPC options
      */
-    placeBidOrder({ marketId, amount, direction, mint, price, isTrdPayout }, options) {
+    placeBidOrder({ marketId, orders, mint, isTrdPayout }, options) {
         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');
+            }
             let amountInUSDC = new bn_js_1.default(0);
+            let totalAmount = 0;
+            for (const order of orders) {
+                totalAmount += order.amount;
+            }
             if (isTrdPayout) {
                 const trdPrice = yield (0, swap_1.getPrice)(constants_1.TRD_MINT.toString());
-                const amountInTRD = (amount / trdPrice) * 1.06;
+                const amountInTRD = (totalAmount / trdPrice) * 1.06;
                 const { swapIxs, addressLookupTableAccounts: swapAddressLookupTableAccounts, outAmount, setupInstructions } = yield (0, swap_1.swap)({
                     connection: this.program.provider.connection,
                     wallet: this.program.provider.publicKey.toBase58(),
@@ -761,29 +779,31 @@ class TriadProtocolClient {
                 ixs.push(...setupInstructions);
                 ixs.push(...swapIxs);
                 addressLookupTableAccounts.push(...swapAddressLookupTableAccounts);
-                if (amountInUSDC.lt(new bn_js_1.default(amount * Math.pow(10, this.decimals)))) {
+                if (amountInUSDC.lt(new bn_js_1.default(totalAmount * Math.pow(10, this.decimals)))) {
                     return;
                 }
             }
-            const { userTradePDA, userTradeIxs } = yield this.getUserTradeNonce(marketId, Object.keys(direction)[0]);
+            const { userTradePDA, userTradeIxs } = yield this.getUserTradeNonce(marketId, Object.keys(orders[0].direction)[0]);
             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());
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .placeBidOrder({
+                    amount: 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)),
+                    orderDirection: order.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);
         });
     }
@@ -802,6 +822,9 @@ class TriadProtocolClient {
     placeAskOrder({ marketId, orders }, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
+            if (orders.length > 4) {
+                throw new Error('You can only place up to 4 orders at a time');
+            }
             for (const order of orders) {
                 ixs.push(yield this.program.methods
                     .placeAskOrder({
@@ -829,23 +852,28 @@ class TriadProtocolClient {
      *
      * @param options - RPC options
      */
-    cancelBidOrder({ marketId, orderId, userNonce, mint, direction }, options) {
+    cancelBidOrder({ marketId, orders, mint }, 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());
+            if (orders.length > 4) {
+                throw new Error('You can only cancel up to 4 orders at a time');
+            }
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .cancelBidOrder({
+                    orderId: new bn_js_1.default(order.orderId),
+                    orderDirection: order.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, order.userNonce),
+                    mint,
+                    tokenProgram: (0, helpers_1.getTokenProgram)(mint)
+                })
+                    .instruction());
+            }
             return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
         });
     }
@@ -859,21 +887,26 @@ class TriadProtocolClient {
      *
      * @param options - RPC options
      */
-    cancelAskOrder({ marketId, orderId, userNonce, direction }, options) {
+    cancelAskOrder({ marketId, orders }, 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());
+            if (orders.length > 4) {
+                throw new Error('You can only cancel up to 4 orders at a time');
+            }
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .cancelAskOrder({
+                    orderId: new bn_js_1.default(order.orderId),
+                    orderDirection: order.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, order.userNonce)
+                })
+                    .instruction());
+            }
             return (0, sendVersionedTransaction_1.default)(this.program, ixs, options);
         });
     }

package/dist/types/index.d.ts

@@ -108,13 +108,15 @@ export declare enum OrderSide {
 }
 export type PlaceBidOrderArgs = {
     marketId: number;
-    amount: number;
-    price: number;
-    direction: {
-        hype: {};
-    } | {
-        flop: {};
-    };
+    orders: {
+        amount: number;
+        price: number;
+        direction: {
+            hype: {};
+        } | {
+            flop: {};
+        };
+    }[];
     mint: PublicKey;
     isTrdPayout: boolean;
 };
@@ -188,24 +190,28 @@ export type CreatePoolArgs = {
 };
 export type CancelBidOrderArgs = {
     marketId: number;
-    orderId: number;
-    userNonce: number;
+    orders: {
+        orderId: number;
+        userNonce: number;
+        direction: {
+            hype: {};
+        } | {
+            flop: {};
+        };
+    }[];
     mint: PublicKey;
-    direction: {
-        hype: {};
-    } | {
-        flop: {};
-    };
 };
 export type CancelAskOrderArgs = {
     marketId: number;
-    orderId: number;
-    userNonce: number;
-    direction: {
-        hype: {};
-    } | {
-        flop: {};
-    };
+    orders: {
+        orderId: number;
+        userNonce: number;
+        direction: {
+            hype: {};
+        } | {
+            flop: {};
+        };
+    }[];
 };
 export type MarketBidOrderArgs = {
     marketId: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triadxyz/triad-protocol",
-  "version": "3.0.8-beta",
+  "version": "3.1.0-beta",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",