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

package/dist/index.d.ts

@@ -4,13 +4,11 @@ import { TriadProtocol } from './types/triad_protocol';
 import Trade from './trade';
 import Stake from './stake';
 import { RpcOptions, TransferPoseidonArgs } from './types';
-import Wheel from './wheel';
 export default class TriadProtocolClient {
     program: Program<TriadProtocol>;
     provider: AnchorProvider;
     trade: Trade;
     stake: Stake;
-    wheel: Wheel;
     constructor(connection: Connection, wallet: Wallet);
     /**
      * Transfer Poseidon
@@ -41,4 +39,32 @@ export default class TriadProtocolClient {
      * @param options - RPC options
      */
     collectRoyalty(collection: string, options?: RpcOptions): Promise<string>;
+    /**
+     * Add Default Poseidon
+     * @param users - Users
+     *
+     * @param options - RPC options
+     */
+    addDefaultPoseidon(users: PublicKey[], options?: RpcOptions): Promise<string>;
+    /**
+     * Add Trader Poseidon
+     * @param user - User
+     * @param poseidonAsset - Poseidon Asset
+     *
+     * @param options - RPC options
+     */
+    addTraderPoseidon({ user, poseidonAsset }: {
+        user: PublicKey;
+        poseidonAsset: PublicKey;
+    }, options?: RpcOptions): Promise<string>;
+    /**
+     * Remove Trader Poseidon
+     * @param user - User
+     *
+     * @param options - RPC options
+     */
+    removeTraderPoseidon({ user, poseidonAsset }: {
+        user: PublicKey;
+        poseidonAsset: PublicKey;
+    }, options?: RpcOptions): Promise<string>;
 }

package/dist/index.js

@@ -20,16 +20,15 @@ const stake_1 = __importDefault(require("./stake"));
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
 const constants_1 = require("./utils/constants");
 const sendTransactionWithOptions_1 = __importDefault(require("./utils/sendTransactionWithOptions"));
-const wheel_1 = __importDefault(require("./wheel"));
+const trade_2 = require("./utils/pda/trade");
 class TriadProtocolClient {
     constructor(connection, wallet) {
         this.provider = new anchor_1.AnchorProvider(connection, wallet, {
-            commitment: 'confirmed'
+            commitment: 'processed'
         });
         this.program = new anchor_1.Program(idl_triad_protocol_json_1.default, this.provider);
         this.trade = new trade_1.default(this.program, this.provider);
         this.stake = new stake_1.default(this.program, this.provider);
-        this.wheel = new wheel_1.default(this.program, this.provider);
     }
     /**
      * Transfer Poseidon
@@ -101,5 +100,64 @@ class TriadProtocolClient {
             }), options);
         });
     }
+    /**
+     * Add Default Poseidon
+     * @param users - Users
+     *
+     * @param options - RPC options
+     */
+    addDefaultPoseidon(users, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const user of users) {
+                const UserTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, user);
+                ixs.push(yield this.program.methods
+                    .addDefaultPoseidon()
+                    .accounts({
+                    signer: this.provider.wallet.publicKey,
+                    userTrade: UserTradePDA
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options);
+        });
+    }
+    /**
+     * Add Trader Poseidon
+     * @param user - User
+     * @param poseidonAsset - Poseidon Asset
+     *
+     * @param options - RPC options
+     */
+    addTraderPoseidon({ user, poseidonAsset }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const UserTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, user);
+            const PoseidonCollectionPDA = (0, pda_1.getCollectionPDA)(this.program.programId, constants_1.POSEIDON_COLLECTION_SYMBOL);
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.addTraderPoseidon().accounts({
+                poseidonAsset,
+                userTrade: UserTradePDA,
+                corePoseidonCollection: constants_1.POSEIDON_CORE_COLLECTION,
+                poseidonCollection: PoseidonCollectionPDA
+            }), options);
+        });
+    }
+    /**
+     * Remove Trader Poseidon
+     * @param user - User
+     *
+     * @param options - RPC options
+     */
+    removeTraderPoseidon({ user, poseidonAsset }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const UserTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, user);
+            const PoseidonCollectionPDA = (0, pda_1.getCollectionPDA)(this.program.programId, constants_1.POSEIDON_COLLECTION_SYMBOL);
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.removeTraderPoseidon().accounts({
+                userTrade: UserTradePDA,
+                poseidonAsset,
+                corePoseidonCollection: constants_1.POSEIDON_CORE_COLLECTION,
+                poseidonCollection: PoseidonCollectionPDA
+            }), options);
+        });
+    }
 }
 exports.default = TriadProtocolClient;

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, PlaceOrderArgs, OrderDirection, UserTrade, OrderStatus } from './types/trade';
+import { InitializeMarketArgs, OpenOrderArgs, UserTrade } from './types/trade';
 import { RpcOptions } from './types';
 import BN from 'bn.js';
 export default class Trade {
@@ -25,25 +25,6 @@ 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
@@ -71,14 +52,13 @@ export default class Trade {
         orders: {
             ts: BN;
             orderId: BN;
-            filledShares: BN;
+            questionId: BN;
             marketId: BN;
             status: ({
                 open?: never;
                 closed?: never;
                 claimed?: never;
                 liquidated?: never;
-                waiting?: never;
             } & {
                 init: Record<string, never>;
             }) | ({
@@ -86,7 +66,6 @@ export default class Trade {
                 closed?: never;
                 claimed?: never;
                 liquidated?: never;
-                waiting?: never;
             } & {
                 open: Record<string, never>;
             }) | ({
@@ -94,7 +73,6 @@ export default class Trade {
                 open?: never;
                 claimed?: never;
                 liquidated?: never;
-                waiting?: never;
             } & {
                 closed: Record<string, never>;
             }) | ({
@@ -102,7 +80,6 @@ export default class Trade {
                 open?: never;
                 closed?: never;
                 liquidated?: never;
-                waiting?: never;
             } & {
                 claimed: Record<string, never>;
             }) | ({
@@ -110,17 +87,8 @@ 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;
@@ -134,7 +102,7 @@ export default class Trade {
             } & {
                 limit: Record<string, never>;
             });
-            orderDirection: ({
+            direction: ({
                 flop?: never;
             } & {
                 hype: Record<string, never>;
@@ -144,15 +112,6 @@ 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;
@@ -178,21 +137,18 @@ export default class Trade {
      */
     getUserTradeNonceWithSlots(userTrades: UserTrade[]): Promise<PublicKey>;
     /**
-     * Place Order
+     * 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.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 args.token - The token to use for the Order
      *
      * @param options - RPC options
      *
      */
-    placeOrder({ marketId, amount, direction, orderType, orderSide, mint, price }: PlaceOrderArgs, options?: RpcOptions): Promise<string>;
+    openOrder({ marketId, amount, direction, token }: OpenOrderArgs, options?: RpcOptions): Promise<string>;
     /**
-     * Cancel Order
+     * 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
@@ -200,7 +156,7 @@ export default class Trade {
      * @param options - RPC options
      *
      */
-    cancelOrder({ marketId, orderId, userNonce }: {
+    closeOrder({ marketId, orderId, userNonce }: {
         marketId: number;
         orderId: number;
         userNonce: number;
@@ -272,4 +228,20 @@ export default class Trade {
      *
      */
     updateMarket(marketId: number, marketEnd: number, options?: RpcOptions): Promise<string>;
+    /**
+     * Force Cancel Order
+     * @param args.marketId - The ID of the Market
+     * @param args.user - The user to force cancel the order for
+     * @param args.orderId - The ID of the Order
+     * @param args.userNonce - The nonce of the user
+     *
+     * @param options - RPC options
+     *
+     */
+    forceCancelOrder({ marketId, user, orderId, userNonce }: {
+        marketId: number;
+        user: PublicKey;
+        orderId: number;
+        userNonce: number;
+    }, options?: RpcOptions): Promise<string>;
 }

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 bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const swap_1 = require("./utils/swap");
 class Trade {
     constructor(program, provider) {
         this.program = program;
@@ -64,37 +64,6 @@ 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
@@ -196,24 +165,22 @@ class Trade {
         });
     }
     /**
-     * Place Order
+     * 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.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 args.token - The token to use for the Order
      *
      * @param options - RPC options
      *
      */
-    placeOrder({ marketId, amount, direction, orderType, orderSide, mint, price }, options) {
+    openOrder({ marketId, amount, direction, token }, 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) {
@@ -240,27 +207,38 @@ 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
-                .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
+                .openOrder({
+                amount: new bn_js_1.default(amountInTRD),
+                direction: direction
             })
                 .accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA,
                 userTrade: userTradePDA,
-                mint,
-                tokenProgram: (0, helpers_1.getTokenProgram)(mint)
+                mint: constants_1.TRD_MINT
             })
                 .instruction());
             return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options, undefined, addressLookupTableAccounts);
         });
     }
     /**
-     * Cancel Order
+     * 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
@@ -268,7 +246,7 @@ class Trade {
      * @param options - RPC options
      *
      */
-    cancelOrder({ marketId, orderId, userNonce }, options) {
+    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);
@@ -276,12 +254,11 @@ 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.cancelOrder(new bn_js_1.default(orderId)).accounts({
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.closeOrder(new bn_js_1.default(orderId)).accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA,
                 mint: constants_1.TRD_MINT,
-                userTrade: userTradePDA,
-                tokenProgram: (0, helpers_1.getTokenProgram)(constants_1.TRD_MINT)
+                userTrade: userTradePDA
             }), options);
         });
     }
@@ -396,5 +373,32 @@ class Trade {
             }), options);
         });
     }
+    /**
+     * Force Cancel Order
+     * @param args.marketId - The ID of the Market
+     * @param args.user - The user to force cancel the order for
+     * @param args.orderId - The ID of the Order
+     * @param args.userNonce - The nonce of the user
+     *
+     * @param options - RPC options
+     *
+     */
+    forceCancelOrder({ marketId, user, 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, 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 (0, sendTransactionWithOptions_1.default)(this.program.methods.forceCancelOrder(new bn_js_1.default(orderId)).accounts({
+                signer: this.provider.publicKey,
+                user,
+                market: marketPDA,
+                mint: constants_1.TRD_MINT,
+                userTrade: userTradePDA
+            }), options);
+        });
+    }
 }
 exports.default = Trade;