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

package/dist/index.d.ts

@@ -39,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,10 +20,11 @@ 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 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);
@@ -99,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/stake.d.ts

@@ -72,12 +72,20 @@ export default class Stake {
      *  Claim Stake Rewards
      *  @param args.wallet - User wallet
      *  @param args.collections - NFT collections
+     *  @param args.ranks - Tensor ranks
      *  @param args.verifier - Verifier
      *
      *  @param options - RPC options
      *
      */
-    claimStakeRewards({ wallet }: {
+    claimStakeRewards({ wallet, collections, ranks, verifier }: {
         wallet: PublicKey;
+        collections: number;
+        ranks: {
+            onchainId: string;
+            name: string;
+            rarityRankHrtt: number;
+        }[];
+        verifier: string;
     }, options?: RpcOptions): Promise<string>;
 }

package/dist/stake.js

@@ -18,6 +18,7 @@ const stake_1 = require("./utils/pda/stake");
 const constants_1 = require("./utils/constants");
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
 const sendTransactionWithOptions_1 = __importDefault(require("./utils/sendTransactionWithOptions"));
+const convertSecretKeyToKeypair_1 = require("./utils/convertSecretKeyToKeypair");
 class Stake {
     constructor(program, provider) {
         this.program = program;
@@ -174,12 +175,13 @@ class Stake {
      *  Claim Stake Rewards
      *  @param args.wallet - User wallet
      *  @param args.collections - NFT collections
+     *  @param args.ranks - Tensor ranks
      *  @param args.verifier - Verifier
      *
      *  @param options - RPC options
      *
      */
-    claimStakeRewards({ wallet }, options) {
+    claimStakeRewards({ wallet, collections, ranks, verifier }, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const stakes = (yield this.getUserStakes(wallet)).sort((a, b) => a.claimedTs - b.claimedTs);
             const ixs = [];
@@ -197,16 +199,20 @@ class Stake {
                 const stakeVaultPDA = (0, stake_1.getStakeVaultPDA)(this.program.programId, constants_1.STAKE_VAULT_NAME);
                 const stakePDA = (0, stake_1.getStakePDA)(this.program.programId, wallet, stake.name);
                 ixs.push(yield this.program.methods
-                    .claimStakeRewards()
+                    .claimStakeRewards({
+                    collections,
+                    rank: 963
+                })
                     .accounts({
                     signer: wallet,
                     mint: constants_1.TRD_MINT,
                     stake: stakePDA,
-                    stakeVault: stakeVaultPDA
+                    stakeVault: stakeVaultPDA,
+                    verifier: constants_1.VERIFIER
                 })
                     .instruction());
             }
-            return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options);
+            return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options, (0, convertSecretKeyToKeypair_1.convertSecretKeyToKeypair)(verifier));
         });
     }
 }

package/dist/trade.d.ts

@@ -1,14 +1,12 @@
 import { AnchorProvider, Program } from '@coral-xyz/anchor';
 import { TriadProtocol } from './types/triad_protocol';
 import { PublicKey } from '@solana/web3.js';
-import { InitializeMarketArgs, PlaceOrderArgs, UpdateMarketArgs, CreateCustomerArgs, UserTrade, OpenOrderArgs } from './types/trade';
+import { InitializeMarketArgs, OpenOrderArgs, UserTrade } from './types/trade';
 import { RpcOptions } from './types';
 import BN from 'bn.js';
 export default class Trade {
     private program;
     private provider;
-    mint: PublicKey;
-    decimals: number;
     constructor(program: Program<TriadProtocol>, provider: AnchorProvider);
     /**
      * Get All Markets
@@ -27,21 +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<{
-        hype: {
-            bid: any[];
-            ask: any[];
-        };
-        flop: {
-            bid: any[];
-            ask: any[];
-        };
-    }>;
     /**
      * Get Market By ID
      * @param marketId - The ID of the market
@@ -69,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>;
             }) | ({
@@ -84,7 +66,6 @@ export default class Trade {
                 closed?: never;
                 claimed?: never;
                 liquidated?: never;
-                waiting?: never;
             } & {
                 open: Record<string, never>;
             }) | ({
@@ -92,7 +73,6 @@ export default class Trade {
                 open?: never;
                 claimed?: never;
                 liquidated?: never;
-                waiting?: never;
             } & {
                 closed: Record<string, never>;
             }) | ({
@@ -100,7 +80,6 @@ export default class Trade {
                 open?: never;
                 closed?: never;
                 liquidated?: never;
-                waiting?: never;
             } & {
                 claimed: Record<string, never>;
             }) | ({
@@ -108,21 +87,12 @@ 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;
-            amount: BN;
-            shares: BN;
+            totalAmount: BN;
+            totalShares: BN;
             orderType: ({
                 limit?: never;
             } & {
@@ -132,7 +102,7 @@ export default class Trade {
             } & {
                 limit: Record<string, never>;
             });
-            orderDirection: ({
+            direction: ({
                 flop?: never;
             } & {
                 hype: Record<string, never>;
@@ -142,16 +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>;
-            });
-            linkedOrderId: BN;
             padding: number[];
         }[];
         nonce: number;
@@ -160,7 +120,7 @@ export default class Trade {
         padding: number[];
     }>;
     /**
-     * Create Market
+     * Initialize Market
      * @param args.marketId - new markert id - length + 1
      * @param args.startTime - start time
      * @param args.endTime - end time
@@ -169,7 +129,7 @@ export default class Trade {
      * @param options - RPC options
      *
      */
-    createMarket({ marketId, startTime, endTime, question, feeBps, customer }: InitializeMarketArgs, options?: RpcOptions): Promise<string>;
+    initializeMarket({ marketId, startTime, endTime, question }: InitializeMarketArgs, options?: RpcOptions): Promise<string>;
     /**
      * Get User Trade Nonce With Slots
      * @param userTrades - User Trades
@@ -177,20 +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.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, 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
@@ -198,11 +156,31 @@ export default class Trade {
      * @param options - RPC options
      *
      */
-    cancelOrder({ marketId, orderId, userNonce }: {
+    closeOrder({ marketId, orderId, userNonce }: {
         marketId: number;
         orderId: number;
         userNonce: number;
     }, options?: RpcOptions): Promise<string>;
+    /**
+     * Resolve Market
+     * @param args.marketId - The ID of the Market
+     * @param args.winningDirection - The Winning Direction of the Market
+     *
+     * @param options - RPC options
+     *
+     */
+    resolveMarket({ marketId, winningDirection }: {
+        marketId: number;
+        winningDirection: {
+            hype: {};
+        } | {
+            flop: {};
+        } | {
+            none: {};
+        } | {
+            draw: {};
+        };
+    }, options?: RpcOptions): Promise<string>;
     /**
      * Collect Remaining Liquidity
      * @param marketId - The ID of the market
@@ -245,44 +223,24 @@ export default class Trade {
      * Update Market
      * @param marketId - The ID of the market
      * @param marketEnd - The end time of the market
-     * @param winningDirection - The winning direction of the market
-     *
-     * @param options - RPC options
-     *
-     */
-    updateMarket({ marketId, marketEnd, winningDirection }: UpdateMarketArgs, options?: RpcOptions): Promise<string>;
-    /**
-     * Create Customer
-     * @param args.id - The ID of the customer
-     * @param args.name - The name of the customer
-     * @param args.authority - The authority of the customer
-     * @param args.shadowStorage - The shadow storage of the customer
      *
      * @param options - RPC options
      *
      */
-    createCustomer({ id, name, authority, shadowStorage }: CreateCustomerArgs, options?: RpcOptions): Promise<string>;
+    updateMarket(marketId: number, marketEnd: number, options?: RpcOptions): Promise<string>;
     /**
-     * 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 options - RPC options
-     *
-     */
-    openOrder({ marketId, amount, direction }: OpenOrderArgs, options?: RpcOptions): Promise<string>;
-    /**
-     * Close Order
+     * 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
      *
      */
-    closeOrder({ marketId, orderId, userNonce }: {
+    forceCancelOrder({ marketId, user, orderId, userNonce }: {
         marketId: number;
+        user: PublicKey;
         orderId: number;
         userNonce: number;
     }, options?: RpcOptions): Promise<string>;