@triadxyz/triad-protocol 1.5.4-beta → 1.5.6-beta

package/dist/index.js

@@ -126,9 +126,10 @@ class TriadProtocolClient {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
             for (const user of users) {
+                const userPDA = (0, pda_1.getUserPDA)(this.program.programId, user);
                 ixs.push(yield this.program.methods
                     .migrateUser()
-                    .accounts({ user })
+                    .accounts({ user: userPDA })
                     .instruction());
             }
             return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options, undefined, []);

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, OrderDirection } from './types/trade';
+import { InitializeMarketArgs, OpenOrderArgs, OrderDirection, UserTrade } from './types/trade';
 import { RpcOptions } from './types';
 import BN from 'bn.js';
 export default class Trade {
@@ -13,6 +13,18 @@ export default class Trade {
      *
      */
     getAllMarkets(): Promise<import("./types/trade").Market[]>;
+    /**
+     * Get My User Trades from a user authority
+     * @param user - User PublicKey
+     *
+     */
+    getMyUserTrades(user: PublicKey): Promise<UserTrade[]>;
+    /**
+     * Get User Orders
+     * @param user - User PublicKey
+     *
+     */
+    getUserOrders(user: PublicKey): Promise<import("./types/trade").Order[]>;
     /**
      * Get Market By ID
      * @param marketId - The ID of the market
@@ -28,9 +40,10 @@ export default class Trade {
     /**
      * Get User Trade
      * @param user - User PublicKey
+     * @param userNonce - The nonce of the user
      *
      */
-    getUserTrade(user: PublicKey): Promise<{
+    getUserTrade(user: PublicKey, userNonce?: number): Promise<{
         bump: number;
         authority: PublicKey;
         totalDeposits: BN;
@@ -44,38 +57,18 @@ export default class Trade {
             status: ({
                 open?: never;
                 closed?: never;
-                claimed?: never;
-                liquidated?: never;
             } & {
                 init: Record<string, never>;
             }) | ({
                 init?: never;
                 closed?: never;
-                claimed?: never;
-                liquidated?: never;
             } & {
                 open: Record<string, never>;
             }) | ({
                 init?: never;
                 open?: never;
-                claimed?: never;
-                liquidated?: never;
             } & {
                 closed: Record<string, never>;
-            }) | ({
-                init?: never;
-                open?: never;
-                closed?: never;
-                liquidated?: never;
-            } & {
-                claimed: Record<string, never>;
-            }) | ({
-                init?: never;
-                open?: never;
-                closed?: never;
-                claimed?: never;
-            } & {
-                liquidated: Record<string, never>;
             });
             price: BN;
             totalAmount: BN;
@@ -98,8 +91,11 @@ export default class Trade {
             } & {
                 flop: Record<string, never>;
             });
+            userNonce: number;
             padding: number[];
         }[];
+        nonce: number;
+        isSubUser: boolean;
         padding: number[];
     }>;
     /**
@@ -113,6 +109,12 @@ export default class Trade {
      *
      */
     initializeMarket({ marketId, startTime, endTime, question }: InitializeMarketArgs, options?: RpcOptions): Promise<string>;
+    /**
+     * Get User Trade Nonce With Slots
+     * @param userTrades - User Trades
+     *
+     */
+    getUserTradeNonceWithSlots(userTrades: UserTrade[]): Promise<PublicKey>;
     /**
      * Open Order
      * @param args.marketId - The ID of the Market
@@ -128,13 +130,15 @@ export default class Trade {
      * 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 }: {
+    closeOrder({ marketId, orderId, userNonce }: {
         marketId: number;
         orderId: number;
+        userNonce: number;
     }, options?: RpcOptions): Promise<string>;
     /**
      * Resolve Market
@@ -172,20 +176,6 @@ export default class Trade {
         marketToAddLiquidity: OrderDirection;
         amount: number;
     }, options?: RpcOptions): Promise<string>;
-    /**
-     * Settle an Order for a V1 Market
-     * @param args.marketId - The ID of the Market
-     * @param args.orderId - The ID of the Order to Settle
-     * @param args.user - The user to settle the order for
-     *
-     * @param options - RPC options
-     *
-     */
-    settleOrder({ marketId, orderId, user }: {
-        marketId: number;
-        orderId: number;
-        user: PublicKey;
-    }, options?: RpcOptions): Promise<string>;
     /**
      * Add Liquidity
      * @param marketId - The ID of the market
@@ -212,13 +202,30 @@ export default class Trade {
      * 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({ marketId, orderId }: {
+    payoutOrder({ marketId, orderId, userNonce }: {
         marketId: number;
         orderId: number;
+        userNonce: number;
     }, options?: RpcOptions): Promise<string>;
-    allowMarketPayout(marketId: number, options?: RpcOptions): Promise<string>;
+    /**
+     * Allow Market to Payout
+     * @param marketId - The ID of the market
+     *
+     * @param options - RPC options
+     *
+     */
+    allowMarketToPayout(marketId: number, options?: RpcOptions): Promise<string>;
+    /**
+     * Create Sub User Trade
+     * @param user - User PublicKey the main user
+     *
+     * @param options - RPC options
+     *
+     */
+    createSubUserTrade(user: PublicKey, options?: RpcOptions): Promise<string>;
 }

package/dist/trade.js

@@ -34,6 +34,36 @@ class Trade {
             return marketV2.map(({ account, publicKey }) => (0, helpers_1.formatMarket)(account, publicKey));
         });
     }
+    /**
+     * Get My User Trades from a user authority
+     * @param user - User PublicKey
+     *
+     */
+    getMyUserTrades(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.program.account.userTrade.all([
+                {
+                    memcmp: {
+                        offset: 8 + 1,
+                        bytes: user.toBase58()
+                    }
+                }
+            ]);
+            return response.map(({ account, publicKey }) => (0, helpers_1.formatUserTrade)(account, publicKey));
+        });
+    }
+    /**
+     * Get User Orders
+     * @param user - User PublicKey
+     *
+     */
+    getUserOrders(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const myUserTrades = yield this.getMyUserTrades(user);
+            const orders = myUserTrades.flatMap((userTrade) => userTrade.orders);
+            return orders;
+        });
+    }
     /**
      * Get Market By ID
      * @param marketId - The ID of the market
@@ -60,11 +90,16 @@ class Trade {
     /**
      * Get User Trade
      * @param user - User PublicKey
+     * @param userNonce - The nonce of the user
      *
      */
-    getUserTrade(user) {
+    getUserTrade(user, userNonce = 0) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, user);
+            let userTradePDA = (0, trade_1.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);
+            }
             return this.program.account.userTrade.fetch(userTradePDA);
         });
     }
@@ -96,6 +131,39 @@ 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) {
+                if (nonce !== null) {
+                    break;
+                }
+                userTrade.orders.forEach((order) => {
+                    if (nonce !== null) {
+                        return;
+                    }
+                    let status = Object.keys(order.status)[0];
+                    if (status !== 'open') {
+                        nonce = userTrade.nonce;
+                    }
+                });
+            }
+            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
@@ -109,12 +177,13 @@ class Trade {
     openOrder({ marketId, amount, direction, token }, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            const userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            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 = [];
             try {
-                yield this.program.account.userTrade.fetch(userTradePDA);
+                myUserTrades = yield this.getMyUserTrades(this.provider.publicKey);
             }
             catch (_a) {
                 ixs.push(yield this.program.methods
@@ -124,6 +193,21 @@ class Trade {
                 })
                     .instruction());
             }
+            try {
+                userTradePDA = yield this.getUserTradeNonceWithSlots(myUserTrades);
+                console.log(userTradePDA);
+            }
+            catch (_b) {
+                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);
+                ixs.push(yield this.program.methods
+                    .createSubUserTrade(subUserTradePDA)
+                    .accounts({
+                    signer: this.provider.publicKey
+                })
+                    .instruction());
+            }
             if (token !== constants_1.TRD_MINT.toBase58()) {
                 const { setupInstructions, swapIxs, addressLookupTableAccounts, trdAmount } = yield (0, swap_1.swap)({
                     connection: this.provider.connection,
@@ -158,14 +242,19 @@ class Trade {
      * 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 }, options) {
+    closeOrder({ marketId, orderId, userNonce }, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            const userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            let userTradePDA = (0, trade_1.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);
+            }
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.closeOrder(new bn_js_1.default(orderId)).accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA,
@@ -229,28 +318,6 @@ class Trade {
             return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options);
         });
     }
-    /**
-     * Settle an Order for a V1 Market
-     * @param args.marketId - The ID of the Market
-     * @param args.orderId - The ID of the Order to Settle
-     * @param args.user - The user to settle the order for
-     *
-     * @param options - RPC options
-     *
-     */
-    settleOrder({ marketId, orderId, user }, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            const userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, user);
-            return (0, sendTransactionWithOptions_1.default)(this.program.methods.settleOrder(new bn_js_1.default(orderId)).accounts({
-                signer: this.provider.publicKey,
-                user: user,
-                userTrade: userTradePDA,
-                market: marketPDA,
-                mint: constants_1.TRD_MINT
-            }), options);
-        });
-    }
     /**
      * Add Liquidity
      * @param marketId - The ID of the market
@@ -296,14 +363,19 @@ class Trade {
      * 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({ marketId, orderId }, options) {
+    payoutOrder({ marketId, orderId, userNonce }, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            const userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            let userTradePDA = (0, trade_1.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);
+            }
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.payoutOrder(new bn_js_1.default(orderId)).accounts({
                 signer: this.provider.publicKey,
                 userTrade: userTradePDA,
@@ -312,14 +384,37 @@ class Trade {
             }), options);
         });
     }
-    allowMarketPayout(marketId, options) {
+    /**
+     * Allow Market to Payout
+     * @param marketId - The ID of the market
+     *
+     * @param options - RPC options
+     *
+     */
+    allowMarketToPayout(marketId, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            return (0, sendTransactionWithOptions_1.default)(this.program.methods.allowMarketPayout().accounts({
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.allowMarketToPayout().accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA
             }), 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 userTrade = yield this.getUserTrade(user);
+            const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, user, userTrade.nonce + 1);
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.createSubUserTrade(subUserTradePDA).accounts({
+                signer: this.provider.publicKey
+            }), options);
+        });
+    }
 }
 exports.default = Trade;