@triadxyz/triad-protocol 1.6.6-beta → 1.6.7-beta-dev

package/dist/trade.d.ts

@@ -1,7 +1,7 @@
 import { AnchorProvider, Program } from '@coral-xyz/anchor';
 import { TriadProtocol } from './types/triad_protocol';
 import { PublicKey } from '@solana/web3.js';
-import { InitializeMarketArgs, OpenOrderArgs, UserTrade } from './types/trade';
+import { InitializeMarketArgs, PlaceOrderArgs, OrderDirection, UserTrade, OrderStatus } from './types/trade';
 import { RpcOptions } from './types';
 import BN from 'bn.js';
 export default class Trade {
@@ -25,6 +25,25 @@ export default class Trade {
      *
      */
     getUserOrders(user: PublicKey): Promise<import("./types/trade").Order[]>;
+    /**
+     * Get Orders By Market ID
+     * @param marketId - The ID of the market
+     *
+     */
+    getLimitOrdersByMarketId(marketId: number): Promise<{
+        userAuthority: string;
+        ts: string;
+        orderId: string;
+        questionId: string;
+        marketId: string;
+        status: OrderStatus;
+        price: string;
+        totalAmount: string;
+        totalShares: string;
+        orderType: import("./types/trade").OrderType;
+        direction: OrderDirection;
+        userNonce: string;
+    }[]>;
     /**
      * Get Market By ID
      * @param marketId - The ID of the market
@@ -52,13 +71,14 @@ export default class Trade {
         orders: {
             ts: BN;
             orderId: BN;
-            questionId: BN;
+            filledShares: BN;
             marketId: BN;
             status: ({
                 open?: never;
                 closed?: never;
                 claimed?: never;
                 liquidated?: never;
+                waiting?: never;
             } & {
                 init: Record<string, never>;
             }) | ({
@@ -66,6 +86,7 @@ export default class Trade {
                 closed?: never;
                 claimed?: never;
                 liquidated?: never;
+                waiting?: never;
             } & {
                 open: Record<string, never>;
             }) | ({
@@ -73,6 +94,7 @@ export default class Trade {
                 open?: never;
                 claimed?: never;
                 liquidated?: never;
+                waiting?: never;
             } & {
                 closed: Record<string, never>;
             }) | ({
@@ -80,6 +102,7 @@ export default class Trade {
                 open?: never;
                 closed?: never;
                 liquidated?: never;
+                waiting?: never;
             } & {
                 claimed: Record<string, never>;
             }) | ({
@@ -87,8 +110,17 @@ export default class Trade {
                 open?: never;
                 closed?: never;
                 claimed?: never;
+                waiting?: never;
             } & {
                 liquidated: Record<string, never>;
+            }) | ({
+                init?: never;
+                open?: never;
+                closed?: never;
+                claimed?: never;
+                liquidated?: never;
+            } & {
+                waiting: Record<string, never>;
             });
             price: BN;
             totalAmount: BN;
@@ -102,7 +134,7 @@ export default class Trade {
             } & {
                 limit: Record<string, never>;
             });
-            direction: ({
+            orderDirection: ({
                 flop?: never;
             } & {
                 hype: Record<string, never>;
@@ -112,10 +144,20 @@ export default class Trade {
                 flop: Record<string, never>;
             });
             userNonce: number;
+            orderSide: ({
+                ask?: never;
+            } & {
+                bid: Record<string, never>;
+            }) | ({
+                bid?: never;
+            } & {
+                ask: Record<string, never>;
+            });
             padding: number[];
         }[];
         nonce: number;
         isSubUser: boolean;
+        poseidon: number;
         padding: number[];
     }>;
     /**
@@ -136,18 +178,21 @@ export default class Trade {
      */
     getUserTradeNonceWithSlots(userTrades: UserTrade[]): Promise<PublicKey>;
     /**
-     * Open Order
+     * 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.token - The token to use for the Order
+     * @param args.orderType - The type 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
      *
      */
-    openOrder({ marketId, amount, direction, token }: OpenOrderArgs, options?: RpcOptions): Promise<string>;
+    placeOrder({ marketId, amount, direction, orderType, orderSide, mint, price }: PlaceOrderArgs, options?: RpcOptions): Promise<string>;
     /**
-     * Close Order
+     * 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
@@ -155,7 +200,7 @@ export default class Trade {
      * @param options - RPC options
      *
      */
-    closeOrder({ marketId, orderId, userNonce }: {
+    cancelOrder({ marketId, orderId, userNonce }: {
         marketId: number;
         orderId: number;
         userNonce: number;

package/dist/trade.js

@@ -18,7 +18,7 @@ const helpers_1 = require("./utils/helpers");
 const trade_1 = 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;
@@ -64,6 +64,37 @@ class Trade {
             return orders;
         });
     }
+    /**
+     * Get Orders By Market ID
+     * @param marketId - The ID of the market
+     *
+     */
+    getLimitOrdersByMarketId(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 + 28) +
+                        // 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(Object.assign({}, order), { userAuthority: userTrade.user }))));
+            const filteredOrders = orders.filter((order) => order.marketId === marketId.toString());
+            return filteredOrders;
+        });
+    }
     /**
      * Get Market By ID
      * @param marketId - The ID of the market
@@ -165,22 +196,24 @@ class Trade {
         });
     }
     /**
-     * Open Order
+     * 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.token - The token to use for the Order
+     * @param args.orderType - The type 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
      *
      */
-    openOrder({ marketId, amount, direction, token }, options) {
+    placeOrder({ marketId, amount, direction, orderType, orderSide, mint, price }, 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 ixs = [];
             const addressLookupTableAccounts = [];
-            let amountInTRD = amount * Math.pow(10, constants_1.TRD_DECIMALS);
             let myUserTrades = [];
             myUserTrades = yield this.getMyUserTrades(this.provider.publicKey);
             if (myUserTrades.length === 0) {
@@ -207,38 +240,27 @@ 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),
-                direction: direction
+                .placeOrder({
+                amount: new bn_js_1.default(amount * Math.pow(10, constants_1.TRD_DECIMALS)),
+                price: new bn_js_1.default(price),
+                orderDirection: direction,
+                orderType,
+                orderSide
             })
                 .accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA,
                 userTrade: userTradePDA,
-                mint: constants_1.TRD_MINT
+                mint,
+                tokenProgram: (0, helpers_1.getTokenProgram)(mint)
             })
                 .instruction());
             return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options, undefined, addressLookupTableAccounts);
         });
     }
     /**
-     * Close Order
+     * 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
@@ -246,7 +268,7 @@ class Trade {
      * @param options - RPC options
      *
      */
-    closeOrder({ marketId, orderId, userNonce }, options) {
+    cancelOrder({ 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);
@@ -254,11 +276,12 @@ class Trade {
                 const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
                 userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
             }
-            return (0, sendTransactionWithOptions_1.default)(this.program.methods.closeOrder(new bn_js_1.default(orderId)).accounts({
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.cancelOrder(new bn_js_1.default(orderId)).accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA,
                 mint: constants_1.TRD_MINT,
-                userTrade: userTradePDA
+                userTrade: userTradePDA,
+                tokenProgram: (0, helpers_1.getTokenProgram)(constants_1.TRD_MINT)
             }), options);
         });
     }