@triadxyz/triad-protocol 1.3.1-beta → 1.3.3-beta

package/dist/index.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="bn.js" />
-import { AnchorProvider, BN, Program, Wallet } from '@coral-xyz/anchor';
-import { Connection, PublicKey } from '@solana/web3.js';
+import { AnchorProvider, Program, Wallet } from '@coral-xyz/anchor';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import { TriadProtocol } from './types/triad_protocol';
 import Trade from './trade';
 import Stake from './stake';
-import { CreateUserArgs, MintTicketArgs, RpcOptions } from './types';
+import { CreateUserArgs, MintTicketArgs, PrizeType, RpcOptions } from './types';
 export default class TriadProtocolClient {
     program: Program<TriadProtocol>;
     provider: AnchorProvider;
@@ -44,39 +43,44 @@ export default class TriadProtocolClient {
      *  @param options - RPC options
      *
      */
-    createUser({ wallet, name, referral }: CreateUserArgs, options?: RpcOptions): Promise<any>;
+    createUser({ wallet, name, referral }: CreateUserArgs, options?: RpcOptions): Promise<string>;
     /**
-     * Get User Positions with amount
-     * @param wallet - User wallet
+     * Create Collection
+     * @param args - Collection args
+     * @param options - RPC options
      *
      */
-    getUserPositionsWithAmount(wallet: PublicKey): Promise<{
-        ts: BN;
-        bump: number;
-        totalDeposited: BN;
-        totalWithdrawn: BN;
-        lpShare: BN;
-        totalPositions: number;
-        ticker: PublicKey;
-        authority: PublicKey;
-        positions: {
-            amount: BN;
-            entryPrice: BN;
-            ts: BN;
-            isLong: boolean;
-            isOpen: boolean;
-            pnl: BN;
-        }[];
-    }[]>;
-    withdrawV1({ wallet, ticker, positionIndex }: {
-        wallet: PublicKey;
-        ticker: PublicKey;
-        positionIndex: number;
-    }, options?: RpcOptions): Promise<any>;
     createCollection(args: {
         collectionName: string;
         collectionSymbol: string;
         supply: number;
     }, options?: RpcOptions): Promise<string>;
     mintTicket({ discount, isBoosted, rarity, verifier, nftMint }: MintTicketArgs, options?: RpcOptions): Promise<string>;
+    /**
+     * Add Spin Prize
+     * @param args - Spin prize args
+     * @param options - RPC options
+     *
+     */
+    addSpinPrize(args: {
+        rangeMin: number;
+        rangeMax: number;
+        prizeType: PrizeType;
+        availableQuantity: number;
+    }, options?: RpcOptions): Promise<string>;
+    /**
+     * Claim Spin Token
+     * @param amount - Amount of tokens to claim
+     * @param verifier - Verifier keypair
+     * @param options - RPC options
+     *
+     */
+    claimSpinToken(amount: number, verifier: Keypair, options?: RpcOptions): Promise<string>;
+    /**
+     * Spin Wheel
+     * @param isSol - Whether to pay with SOL or token
+     * @param verifier - Verifier keypair
+     * @param options - RPC options
+     */
+    spinWheel(isSol: boolean, options?: RpcOptions): Promise<any>;
 }

package/dist/index.js

@@ -17,7 +17,6 @@ const web3_js_1 = require("@solana/web3.js");
 const idl_triad_protocol_json_1 = __importDefault(require("./types/idl_triad_protocol.json"));
 const trade_1 = __importDefault(require("./trade"));
 const helpers_1 = require("./utils/helpers");
-const spl_token_1 = require("@solana/spl-token");
 const pda_1 = require("./utils/pda");
 const stake_1 = __importDefault(require("./stake"));
 const sendTransactionWithOptions_1 = __importDefault(require("./utils/sendTransactionWithOptions"));
@@ -123,36 +122,11 @@ class TriadProtocolClient {
         });
     }
     /**
-     * Get User Positions with amount
-     * @param wallet - User wallet
+     * Create Collection
+     * @param args - Collection args
+     * @param options - RPC options
      *
      */
-    getUserPositionsWithAmount(wallet) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userPositions = [];
-            const userPositionPDA = (0, pda_1.getUserPositionPDA)(this.program.programId, wallet, new web3_js_1.PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'));
-            userPositions.push(userPositionPDA);
-            const userPositionsWithAmount = yield this.program.account.userPosition.fetchMultiple(userPositions);
-            return userPositionsWithAmount.filter((item) => item &&
-                parseFloat(item.totalDeposited.toString()) >
-                    parseFloat(item.totalWithdrawn.toString()));
-        });
-    }
-    withdrawV1({ wallet, ticker, positionIndex }, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vaultPDA = (0, pda_1.getVaultAddressSync)(this.program.programId, ticker);
-            const userPositionPDA = (0, pda_1.getUserPositionPDA)(this.program.programId, wallet, ticker);
-            const VaultTokenAccountPDA = (0, pda_1.getTokenVaultAddressSync)(this.program.programId, vaultPDA);
-            const userTokenAccount = yield (0, spl_token_1.getAssociatedTokenAddress)(new web3_js_1.PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'), this.provider.wallet.publicKey);
-            return (0, sendTransactionWithOptions_1.default)(this.program.methods.withdrawV1(positionIndex).accounts({
-                signer: wallet,
-                userPosition: userPositionPDA,
-                userTokenAccount,
-                vault: vaultPDA,
-                vaultTokenAccount: VaultTokenAccountPDA
-            }), options);
-        });
-    }
     createCollection(args, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const keyPair = web3_js_1.Keypair.generate();
@@ -203,5 +177,77 @@ class TriadProtocolClient {
             return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options, asset, [], (0, convertSecretKeyToKeypair_1.convertSecretKeyToKeypair)(verifier));
         });
     }
+    /**
+     * Add Spin Prize
+     * @param args - Spin prize args
+     * @param options - RPC options
+     *
+     */
+    addSpinPrize(args, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const method = this.program.methods
+                .addSpinPrize({
+                name: 'christmas',
+                rangeMin: new anchor_1.BN(args.rangeMin),
+                rangeMax: new anchor_1.BN(args.rangeMax),
+                prizeType: args.prizeType,
+                availableQuantity: new anchor_1.BN(args.availableQuantity)
+            })
+                .accounts({
+                signer: this.provider.wallet.publicKey
+            });
+            return (0, sendTransactionWithOptions_1.default)(method, options);
+        });
+    }
+    /**
+     * Claim Spin Token
+     * @param amount - Amount of tokens to claim
+     * @param verifier - Verifier keypair
+     * @param options - RPC options
+     *
+     */
+    claimSpinToken(amount, verifier, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spinPDA = (0, pda_1.getSpinPDA)(this.program.programId, constants_1.SPIN_NAME);
+            const ix = yield this.program.methods
+                .claimSpinToken(new anchor_1.BN(amount))
+                .accounts({
+                signer: this.provider.wallet.publicKey,
+                verifier: verifier.publicKey,
+                spin: spinPDA,
+                mint: constants_1.TCMAS_MINT
+            })
+                .instruction();
+            return (0, sendVersionedTransaction_1.default)(this.provider, [ix], options, undefined, [], verifier);
+        });
+    }
+    /**
+     * Spin Wheel
+     * @param isSol - Whether to pay with SOL or token
+     * @param verifier - Verifier keypair
+     * @param options - RPC options
+     */
+    spinWheel(isSol, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spinPDA = (0, pda_1.getSpinPDA)(this.program.programId, constants_1.SPIN_NAME);
+            const method = this.program.methods.spinWheel(isSol).accounts({
+                signer: this.provider.wallet.publicKey,
+                spin: spinPDA,
+                mint: new web3_js_1.PublicKey('9LGNCsQsoeJK2jBMKNiX8UGJv5NPyBHhouTcQLLqWTt9')
+            });
+            const tx = yield (0, sendTransactionWithOptions_1.default)(method, options);
+            const txLogs = yield this.provider.connection.getTransaction(tx, {
+                commitment: 'confirmed',
+                maxSupportedTransactionVersion: 0
+            });
+            const eventLog = txLogs.meta.logMessages.find((log) => log.includes('RouletteSpinResult'));
+            if (!eventLog) {
+                throw new Error('Spin result not found in transaction logs');
+            }
+            const prizeType = JSON.parse(eventLog.split('RouletteSpinResult')[1]).data
+                .prize;
+            return prizeType;
+        });
+    }
 }
 exports.default = TriadProtocolClient;

package/dist/local-test.js

@@ -16,20 +16,21 @@ const fs_1 = __importDefault(require("fs"));
 const _1 = __importDefault(require("./"));
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
+const trade_1 = require("./types/trade");
 const spl_token_1 = require("@solana/spl-token");
 const constants_1 = require("./utils/constants");
-const file = fs_1.default.readFileSync('/Users/dannpl/.config/solana/triad.json');
+const file = fs_1.default.readFileSync('/Users/dannpl/.config/solana/id.json');
 const rpc_file = fs_1.default.readFileSync('/Users/dannpl/.config/solana/rpc.txt');
 const keypair = web3_js_1.Keypair.fromSecretKey(new Uint8Array(JSON.parse(file.toString())));
-const connection = new web3_js_1.Connection(rpc_file.toString());
+const connection = new web3_js_1.Connection('https://mainnet.helius-rpc.com/?api-key=05843ded-2085-4567-aff3-85af84ea71d2');
 const wallet = new anchor_1.Wallet(keypair);
 const triadProtocol = new _1.default(connection, wallet);
 const markets = [
     {
-        marketId: 37,
-        question: 'Will $STREAM price be above $1 on December 17?',
-        startTime: 1733940000,
-        endTime: 1734404340
+        marketId: 38,
+        question: 'Will $PENGU be above 0.10$ on December 18?',
+        startTime: 1734379200,
+        endTime: 1734440400
     }
 ];
 const ordersHypeAndFloopBot = [
@@ -44,7 +45,7 @@ const ordersHypeAndFloopBot = [
 const updateStakeVault = () => __awaiter(void 0, void 0, void 0, function* () {
     const response = yield triadProtocol.stake.updateStakeVault({
         wallet: wallet.publicKey,
-        amount: new anchor_1.BN(2000 * Math.pow(10, 6)),
+        amount: new anchor_1.BN(1000 * Math.pow(10, 6)),
         isLocked: false
     });
     console.log(response);
@@ -53,9 +54,55 @@ const getStakeVault = () => __awaiter(void 0, void 0, void 0, function* () {
     const response = yield triadProtocol.stake.getStakeVaults();
     console.log(response);
 });
-const getStaked = () => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield triadProtocol.stake.getUserStakes(new web3_js_1.PublicKey('3umHQwkz2r8E6K6xWJuSDziDoWgkWwRckDPGEYzD8TPf'));
-    console.log(response);
+const getStakes = () => __awaiter(void 0, void 0, void 0, function* () {
+    const stakes = yield triadProtocol.stake.getStakes();
+    fs_1.default.writeFileSync('stakes.json', JSON.stringify(stakes, null, 2));
+    const stakesJson = JSON.parse(fs_1.default.readFileSync('stakes.json', 'utf8'));
+    let amountLocked = 0;
+    let amountUnlocked = 0;
+    let uniqueStakersLocked = new Set();
+    let uniqueStakersUnlocked = new Set();
+    let usersUnlocked = [];
+    let usersLocked = [];
+    for (const stake of stakesJson) {
+        if (stake.withdrawTs === 0) {
+            amountLocked += stake.amount / Math.pow(10, 6);
+            uniqueStakersLocked.add(stake.authority);
+            if (!usersLocked.find((user) => user.address === stake.authority)) {
+                usersLocked.push({
+                    address: stake.authority,
+                    amount: stake.amount / Math.pow(10, 6)
+                });
+            }
+            else {
+                usersLocked.find((user) => user.address === stake.authority).amount +=
+                    stake.amount / Math.pow(10, 6);
+            }
+        }
+        else {
+            amountUnlocked += stake.amount / Math.pow(10, 6);
+            uniqueStakersUnlocked.add(stake.authority);
+            if (!usersUnlocked.find((user) => user.address === stake.authority)) {
+                usersUnlocked.push({
+                    address: stake.authority,
+                    amount: stake.amount / Math.pow(10, 6)
+                });
+            }
+            else {
+                usersUnlocked.find((user) => user.address === stake.authority).amount +=
+                    stake.amount / Math.pow(10, 6);
+            }
+        }
+    }
+    const orders = usersLocked.sort((a, b) => b.amount - a.amount);
+    const ordersUnlocked = usersUnlocked.sort((a, b) => b.amount - a.amount);
+    console.log('Amount locked:', amountLocked);
+    console.log('Amount unlocked:', amountUnlocked);
+    console.log('Unique stakers:', uniqueStakersLocked.size);
+    console.log('Unique stakers unlocked:', uniqueStakersUnlocked.size);
+    console.log(JSON.stringify(orders, null, 2));
+    console.log('--------------------------------');
+    console.log(JSON.stringify(ordersUnlocked, null, 2));
 });
 const getAllMarkets = () => __awaiter(void 0, void 0, void 0, function* () {
     const markets = yield triadProtocol.trade.getAllMarkets();
@@ -105,6 +152,10 @@ const getLiquidityToRecovery = () => __awaiter(void 0, void 0, void 0, function*
     const liquidityToRecovery = {};
     for (const market of allMarkets) {
         let currentMarket = liquidityToRecovery[market.marketId];
+        if (market.marketId === '31') {
+            console.log(market);
+            market.winningDirection = trade_1.WinningDirection.HYPE;
+        }
         if (market.winningDirection.toLowerCase() === 'none') {
             continue;
         }
@@ -134,7 +185,7 @@ const getLiquidityToRecovery = () => __awaiter(void 0, void 0, void 0, function*
         let liquidity_coeficient = 1;
         if ('flop' in currentMarket.direction) {
             let shares = parseFloat(market.flopShares.toString()) / Math.pow(10, 6);
-            currentMarket.sharesToPay = shares + 10000;
+            currentMarket.sharesToPay = shares;
             currentMarket.liquidityToPay =
                 parseFloat(market.hypeLiquidity.toString()) / Math.pow(10, 6);
             currentMarket.liquidityToPay =
@@ -142,7 +193,7 @@ const getLiquidityToRecovery = () => __awaiter(void 0, void 0, void 0, function*
         }
         else {
             let shares = parseFloat(market.hypeShares.toString()) / Math.pow(10, 6);
-            currentMarket.sharesToPay = shares + 10000;
+            currentMarket.sharesToPay = shares;
             currentMarket.liquidityToPay =
                 parseFloat(market.flopLiquidity.toString()) / Math.pow(10, 6);
             currentMarket.liquidityToPay =
@@ -205,7 +256,7 @@ const closeOrders = () => __awaiter(void 0, void 0, void 0, function* () {
     }
 });
 const resolveMarket = () => __awaiter(void 0, void 0, void 0, function* () {
-    const marketsToResolve = [{ marketId: 33, winningDirection: { flop: {} } }];
+    const marketsToResolve = [{ marketId: 38, winningDirection: { flop: {} } }];
     for (const market of marketsToResolve) {
         const response = yield triadProtocol.trade.resolveMarket({
             marketId: market.marketId,
@@ -216,7 +267,6 @@ const resolveMarket = () => __awaiter(void 0, void 0, void 0, function* () {
         console.log(response);
     }
 });
-resolveMarket();
 const addLiquidity = () => __awaiter(void 0, void 0, void 0, function* () {
     const response = yield triadProtocol.trade.addLiquidity({
         marketId: 5,
@@ -258,3 +308,148 @@ const getReferral = () => __awaiter(void 0, void 0, void 0, function* () {
     const response = yield triadProtocol.getUser(new web3_js_1.PublicKey('in6cFcFF2eawkdtrGvV4mM33dRhBymJcf1Fk8mrqGJt'));
     console.log(response);
 });
+const resolveWithLiquidity = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.trade.resolveMarketWithLiquidity({
+        marketId: 37,
+        winningDirection: { flop: {} },
+        marketToAddLiquidity: { hype: {} },
+        amount: 1000
+    });
+    console.log(response);
+});
+const mintToken = () => __awaiter(void 0, void 0, void 0, function* () {
+    const filekey = fs_1.default.readFileSync('./tCMraBSGHeMcQS76hNnBhnfbMzrtnnT3nbt3vAnSCE2.json');
+    const token = web3_js_1.Keypair.fromSecretKey(new Uint8Array(JSON.parse(filekey.toString())));
+    try {
+        const decimals = 6; // Common decimal places for tokens
+        const amount = 1000000 * Math.pow(10, decimals); // 1,000,000 tokens with decimals
+        // Calculate space needed for mint account including metadata pointer
+        // const mintLen = getMintLen([ExtensionType.MetadataPointer])
+        // const mintTransaction = new Transaction().add(
+        //   // Create mint account
+        //   SystemProgram.createAccount({
+        //     fromPubkey: wallet.publicKey,
+        //     newAccountPubkey: token.publicKey,
+        //     space: mintLen,
+        //     lamports: 6786240,
+        //     programId: TOKEN_2022_PROGRAM_ID
+        //   }),
+        //   createInitializeMetadataPointerInstruction(
+        //     token.publicKey,
+        //     wallet.publicKey,
+        //     token.publicKey,
+        //     TOKEN_2022_PROGRAM_ID
+        //   ),
+        //   createInitializeMintInstruction(
+        //     token.publicKey,
+        //     decimals,
+        //     wallet.publicKey,
+        //     null,
+        //     TOKEN_2022_PROGRAM_ID
+        //   ),
+        //   createInitializeInstruction({
+        //     programId: TOKEN_2022_PROGRAM_ID,
+        //     metadata: token.publicKey,
+        //     updateAuthority: wallet.publicKey,
+        //     mint: token.publicKey,
+        //     mintAuthority: wallet.publicKey,
+        //     name: 'Triad Christmas',
+        //     symbol: 'tCMAS',
+        //     uri: 'https://shdw-drive.genesysgo.net/DRRe9dZkP199W6GLrySn2xj2ayfr8gin8iaBt1YVMN9M/tCMAS.json'
+        //   })
+        // )
+        // const transactionSignature = await sendAndConfirmTransaction(
+        //   connection,
+        //   mintTransaction,
+        //   [keypair, token], // Signers,
+        //   { skipPreflight: false }
+        // )
+        // console.log(
+        //   '\nCreate Mint Account:',
+        //   `https://solana.fm/tx/${transactionSignature}?cluster=devnet-solana`
+        // )
+        // const associatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+        //   connection,
+        //   keypair,
+        //   token.publicKey,
+        //   wallet.publicKey,
+        //   true,
+        //   undefined,
+        //   undefined,
+        //   TOKEN_2022_PROGRAM_ID
+        // )
+        // const mintToResponse = await mintTo(
+        //   connection,
+        //   keypair,
+        //   token.publicKey,
+        //   associatedTokenAccount.address,
+        //   wallet.publicKey,
+        //   amount,
+        //   [keypair, token],
+        //   undefined,
+        //   TOKEN_2022_PROGRAM_ID
+        // )
+        // console.log('Token created:', token.publicKey.toString())
+        // console.log('Associated Token Account:', associatedTokenAccount.toString())
+        // console.log('Mint tx:', mintToResponse)
+    }
+    catch (e) {
+        console.log(e);
+    }
+});
+const removeMintAuthority = () => __awaiter(void 0, void 0, void 0, function* () {
+    const filekey = fs_1.default.readFileSync('./tCMraBSGHeMcQS76hNnBhnfbMzrtnnT3nbt3vAnSCE2.json');
+    const token = web3_js_1.Keypair.fromSecretKey(new Uint8Array(JSON.parse(filekey.toString())));
+    try {
+        const response = yield (0, spl_token_1.setAuthority)(connection, keypair, token.publicKey, wallet.publicKey, spl_token_1.AuthorityType.MetadataPointer, null, [], undefined, spl_token_1.TOKEN_2022_PROGRAM_ID);
+        console.log('Mint authority removed:', response);
+    }
+    catch (error) {
+        console.error('Error removing mint authority:', error);
+    }
+});
+const getMinteds = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.program.account.collection.all();
+    console.log(response);
+});
+// let prize_ranges = [
+//   (1, 14, PrizeType::Undead), // 0.0014%
+//   (15, 114, PrizeType::Ticket), // 0.01%
+//   (115, 614, PrizeType::Honeyland), // 0.05%
+//   (615, 1614, PrizeType::Trd100), // 0.1%
+//   (1615, 6614, PrizeType::Trd50), // 0.5%
+//   (6615, 16614, PrizeType::Flip), // 1%
+//   (16615, 26614, PrizeType::Pengu), // 1%
+//   (26615, 66614, PrizeType::Ore), // 4%
+//   (66615, 166614, PrizeType::Lucksea), // 10%
+//   (166615, 286614, PrizeType::Trd5), // 12%
+//   (286615, 499999, PrizeType::Trident2000), // 21.3385%
+//   (500000, 1000000, PrizeType::Trident500), // 50%
+// ];
+const addSpinPrize = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.addSpinPrize({
+        rangeMin: 66615,
+        rangeMax: 166614,
+        prizeType: { lucksea: {} },
+        availableQuantity: 2000
+    });
+    console.log(response);
+});
+const getSpinPrize = () => __awaiter(void 0, void 0, void 0, function* () {
+    let response = yield triadProtocol.program.account.spin.fetch(new web3_js_1.PublicKey('EQ6ZJbdT2V8ZYcHRpJx6wBkGWmM1e3mimtPKshTVuw8h'));
+    const prizes = response.prizes.map((prize) => ({
+        rangeMin: prize.rangeMin.toNumber(),
+        rangeMax: prize.rangeMax.toNumber(),
+        prizeType: prize.prizeType,
+        availableQuantity: prize.availableQuantity.toNumber()
+    }));
+    console.log(prizes);
+});
+const spinWheel = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.spinWheel(false, {
+        skipPreflight: true,
+        microLamports: 5000
+    });
+    console.log(response);
+});
+spinWheel();

package/dist/stake.d.ts

@@ -30,11 +30,7 @@ export default class Stake {
      * @param collections - NFT collections
      * @param tensor rank
      */
-    getStakeByWallet(wallet: PublicKey, collections: number, ranks: {
-        onchainId: string;
-        name: string;
-        rarityRankHrtt: number;
-    }[]): Promise<StakeResponse[]>;
+    getStakeByWallet(wallet: PublicKey, collections: number): Promise<StakeResponse[]>;
     /**
      *  Stake Token
      *  @param name - Index
@@ -42,7 +38,7 @@ export default class Stake {
      *  @param amount - Amount to stake
      *
      */
-    stakeToken({ name, wallet, amount }: StakeTokenArgs, options?: RpcOptions): Promise<any>;
+    stakeToken({ name, wallet, amount }: StakeTokenArgs, options?: RpcOptions): Promise<string>;
     /**
      *  Update Stake Vault
      *  @param wallet - User wallet
@@ -50,7 +46,7 @@ export default class Stake {
      *  @param isLocked - is locked stake vault (optional)
      *
      */
-    updateStakeVault({ wallet, amount, isLocked }: UpdateStakeVaultArgs, options?: RpcOptions): Promise<any>;
+    updateStakeVault({ wallet, amount, isLocked }: UpdateStakeVaultArgs, options?: RpcOptions): Promise<string>;
     /**
      *  Request Withdraw
      *  @param wallet - User wallet
@@ -65,7 +61,7 @@ export default class Stake {
      *  @param mint - NFT mint
      *
      */
-    withdrawStake({ wallet, name, mint }: WithdrawArgs, options?: RpcOptions): Promise<any>;
+    withdrawStake({ wallet, name, mint }: WithdrawArgs, options?: RpcOptions): Promise<string>;
     /**
      *  Claim All Stake Rewards
      *  @param wallet - User wallet
@@ -84,19 +80,4 @@ export default class Stake {
         verifier: string;
         isToken?: boolean;
     }, options?: RpcOptions): Promise<string>;
-    /**
-     *  Withdraw NFT
-     *  @param wallet - User wallet
-     *  @param name - Stake name
-     *  @param mint - NFT mint
-     *
-     */
-    withdrawNft({ wallet, name, nftMint, tokenMint, rank, collections }: {
-        wallet: PublicKey;
-        name: string;
-        nftMint: PublicKey;
-        tokenMint: PublicKey;
-        rank: number;
-        collections: number;
-    }, options?: RpcOptions): Promise<any>;
 }

package/dist/stake.js

@@ -92,12 +92,11 @@ class Stake {
      * @param collections - NFT collections
      * @param tensor rank
      */
-    getStakeByWallet(wallet, collections, ranks) {
+    getStakeByWallet(wallet, collections) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.getUserStakes(wallet);
             const data = [];
             for (const stake of response) {
-                yield new Promise((resolve) => setTimeout(resolve, 5000));
                 let available = 0;
                 try {
                     available = yield this.getStakeRewards({
@@ -254,27 +253,5 @@ class Stake {
             return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options, (0, convertSecretKeyToKeypair_1.convertSecretKeyToKeypair)(verifier));
         });
     }
-    /**
-     *  Withdraw NFT
-     *  @param wallet - User wallet
-     *  @param name - Stake name
-     *  @param mint - NFT mint
-     *
-     */
-    withdrawNft({ wallet, name, nftMint, tokenMint, rank, collections }, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stakeVaultPDA = (0, stake_1.getStakeVaultPDA)(this.program.programId, this.stakeVaultName);
-            const userPDA = (0, pda_1.getUserPDA)(this.program.programId, wallet);
-            const stakePDA = (0, stake_1.getStakePDA)(this.program.programId, wallet, name);
-            return (0, sendTransactionWithOptions_1.default)(this.program.methods.withdrawNft(rank, collections).accounts({
-                signer: this.provider.wallet.publicKey,
-                stake: stakePDA,
-                stakeVault: stakeVaultPDA,
-                tokenMint: tokenMint,
-                nftMint: nftMint,
-                user: userPDA
-            }), options);
-        });
-    }
 }
 exports.default = Stake;

package/dist/trade.d.ts

@@ -110,7 +110,7 @@ export default class Trade {
      * @param options - RPC options
      *
      */
-    initializeMarket({ marketId, startTime, endTime, question }: InitializeMarketArgs, options?: RpcOptions): Promise<any>;
+    initializeMarket({ marketId, startTime, endTime, question }: InitializeMarketArgs, options?: RpcOptions): Promise<string>;
     /**
      * Open Order
      * @param marketId - The ID of the market
@@ -153,6 +153,22 @@ export default class Trade {
             none: {};
         };
     }, options?: RpcOptions): Promise<string>;
+    /**
+     * Resolve Market With Liquidity
+     * @param marketId - The ID of the market
+     * @param winningDirection - The winning direction of the market
+     * @param marketToAddLiquidity - The market to add liquidity
+     * @param amount - The amount of the order
+     *
+     * @param options - RPC options
+     *
+     */
+    resolveMarketWithLiquidity({ marketId, winningDirection, marketToAddLiquidity, amount }: {
+        marketId: number;
+        winningDirection: OrderDirection;
+        marketToAddLiquidity: OrderDirection;
+        amount: number;
+    }, options?: RpcOptions): Promise<string>;
     /**
      * Settle an order
      * @param marketId - The ID of the market

package/dist/trade.js

@@ -203,6 +203,41 @@ class Trade {
             return (0, sendTransactionWithOptions_1.default)(method, options);
         });
     }
+    /**
+     * Resolve Market With Liquidity
+     * @param marketId - The ID of the market
+     * @param winningDirection - The winning direction of the market
+     * @param marketToAddLiquidity - The market to add liquidity
+     * @param amount - The amount of the order
+     *
+     * @param options - RPC options
+     *
+     */
+    resolveMarketWithLiquidity({ marketId, winningDirection, marketToAddLiquidity, amount }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            const ixs = [];
+            ixs.push(yield this.program.methods
+                .resolveMarket(winningDirection)
+                .accounts({
+                signer: this.provider.publicKey,
+                market: marketPDA
+            })
+                .instruction());
+            ixs.push(yield this.program.methods
+                .addLiquidity({
+                amount: new bn_js_1.default(amount * Math.pow(10, constants_1.TRD_DECIMALS)),
+                direction: marketToAddLiquidity
+            })
+                .accounts({
+                signer: this.provider.publicKey,
+                market: marketPDA,
+                mint: this.mint
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options);
+        });
+    }
     /**
      * Settle an order
      * @param marketId - The ID of the market