@triadxyz/triad-protocol 0.0.1-beta

package/dist/stake.js

@@ -0,0 +1,325 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const helpers_1 = require("./utils/helpers");
+const constants_1 = require("./utils/constants");
+class Stake {
+    constructor(program, provider) {
+        this.provider = provider;
+        this.program = program;
+    }
+    /**
+     * Get all Stake Vaults
+     */
+    getStakeVaults() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.program.account.stakeVault.all();
+            return response.map((stakeVault) => ({
+                name: stakeVault.account.name,
+                collection: stakeVault.account.collection,
+                slots: stakeVault.account.slots.toNumber(),
+                amount: stakeVault.account.amount.toNumber(),
+                isLocked: stakeVault.account.isLocked,
+                usersPaid: stakeVault.account.usersPaid,
+                amountPaid: stakeVault.account.amountPaid.toNumber(),
+                amountUsers: stakeVault.account.amountUsers.toNumber(),
+                apr: stakeVault.account.apr,
+                initTs: stakeVault.account.initTs.toNumber(),
+                endTs: stakeVault.account.endTs.toNumber()
+            }));
+        });
+    }
+    /**
+     * Get Stake Vault by name
+     * @param stakeVault - Stake Vault name
+     */
+    getStakeVaultByName(stakeVault) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const StakeVault = (0, helpers_1.getStakeVaultAddressSync)(this.program.programId, stakeVault);
+            const response = yield this.program.account.stakeVault.fetch(StakeVault);
+            return {
+                name: response.name,
+                collection: response.collection,
+                slots: response.slots.toNumber(),
+                amount: response.amount.toNumber(),
+                isLocked: response.isLocked,
+                usersPaid: response.usersPaid,
+                amountPaid: response.amountPaid.toNumber(),
+                amountUsers: response.amountUsers.toNumber(),
+                apr: response.apr,
+                initTs: response.initTs.toNumber(),
+                endTs: response.endTs.toNumber()
+            };
+        });
+    }
+    /**
+     * Get all stakes
+     */
+    getStakes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.program.account.stake.all();
+            return response.map((stake) => ({
+                name: stake.account.name,
+                collections: stake.account.collections,
+                rarity: Object.keys(stake.account.rarity)[0],
+                stakeVault: stake.account.stakeVault.toBase58(),
+                authority: stake.account.authority.toBase58(),
+                initTs: stake.account.initTs.toNumber(),
+                isLocked: stake.account.isLocked,
+                withdrawTs: stake.account.withdrawTs.toNumber(),
+                mint: stake.account.mint.toBase58(),
+                stakeRewards: stake.account.stakeRewards.toBase58()
+            }));
+        });
+    }
+    /**
+     * Get Stake by wallet
+     * @param wallet - User wallet
+     */
+    getStakeByWallet(wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.program.account.stake.all();
+            return response
+                .filter((stake) => stake.account.authority.equals(wallet))
+                .map((stake) => ({
+                name: stake.account.name,
+                collections: stake.account.collections,
+                rarity: Object.keys(stake.account.rarity)[0],
+                stakeVault: stake.account.stakeVault.toBase58(),
+                authority: stake.account.authority.toBase58(),
+                initTs: stake.account.initTs.toNumber(),
+                isLocked: stake.account.isLocked,
+                withdrawTs: stake.account.withdrawTs.toNumber(),
+                mint: stake.account.mint.toBase58(),
+                stakeRewards: stake.account.stakeRewards.toBase58()
+            }));
+        });
+    }
+    getStakeVaultRewards(stakeVault) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const StakeVault = (0, helpers_1.getStakeVaultAddressSync)(this.program.programId, stakeVault);
+            const response = yield this.program.account.stakeVault.fetch(StakeVault);
+            const data = {
+                amount: 0,
+                perDay: 0,
+                perWeek: 0,
+                perMonth: 0,
+                period: 0,
+                days: []
+            };
+            const amount = response.amount.toNumber() / Math.pow(10, constants_1.TTRIAD_DECIMALS);
+            data.period =
+                (response.endTs.toNumber() * 1000 - response.initTs.toNumber() * 1000) /
+                    (1000 * 60 * 60 * 24);
+            data.amount = amount - (amount * constants_1.TTRIAD_FEE) / 100;
+            data.perDay = data.amount / data.period;
+            data.perWeek = data.perDay * 7;
+            data.perMonth = data.perDay * 30;
+            const endTsInMs = response.endTs.toNumber() * 1000;
+            const initTsInMs = response.initTs.toNumber() * 1000;
+            let currentTs = initTsInMs;
+            while (currentTs <= endTsInMs) {
+                data.days.push(currentTs);
+                currentTs = currentTs + 1000 * 60 * 60 * 24;
+            }
+            return data;
+        });
+    }
+    getStakeRewardsByWallet(wallet, stakeVaultRewards) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stakes = yield this.getStakeByWallet(wallet);
+            const rewards = {};
+            for (const day of stakeVaultRewards.days) {
+                stakes.forEach((stake) => {
+                    const date = stake.initTs * 1000;
+                    const currentDate = new Date().getTime();
+                    if (date <= day && day <= currentDate) {
+                        const key = new Date(day).toISOString().split('T')[0];
+                        if (!rewards[key]) {
+                            rewards[key] = [];
+                        }
+                        rewards[key].push(stake);
+                    }
+                });
+            }
+            return rewards;
+        });
+    }
+    /**
+     *  Stake NFT
+     *  @param name - NFT name
+     *  @param wallet - User wallet
+     *  @param mint - NFT mint
+     *  @param collections - NFT collections
+     *  @param rarity - NFT rarity
+     *
+     */
+    stake({ name, wallet, mint, collections, rarity, stakeVault }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const FromAta = (0, helpers_1.getATASync)(wallet, mint);
+            const StakeVault = (0, helpers_1.getStakeVaultAddressSync)(this.program.programId, stakeVault);
+            const ToAta = (0, helpers_1.getATASync)(StakeVault, mint);
+            let items = [];
+            Object.keys(collections).forEach((key) => {
+                if (collections[key]) {
+                    items.push({ [key]: {} });
+                }
+            });
+            const method = this.program.methods
+                .stake({
+                name,
+                collections: items,
+                rarity,
+                stakeVault
+            })
+                .accounts({
+                signer: wallet,
+                fromAta: FromAta,
+                toAta: ToAta,
+                mint: mint
+            });
+            if (options === null || options === void 0 ? void 0 : options.microLamports) {
+                method.postInstructions([
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                        microLamports: options.microLamports
+                    })
+                ]);
+            }
+            return method.rpc({ skipPreflight: options === null || options === void 0 ? void 0 : options.skipPreflight });
+        });
+    }
+    /**
+     *  Initialize Stake Vault
+     *  @param name - The ticker's name
+     *  @param slots - Amount available to users joining the vault
+     *  @param collection - The Collection name
+     *
+     */
+    initializeStakeVault({ name, slots, collection, amount }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const method = this.program.methods
+                .initializeStakeVault({
+                name,
+                slots,
+                collection,
+                amount
+            })
+                .accounts({
+                signer: this.provider.wallet.publicKey
+            });
+            if (options === null || options === void 0 ? void 0 : options.microLamports) {
+                method.postInstructions([
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                        microLamports: options.microLamports
+                    })
+                ]);
+            }
+            return method.rpc({ skipPreflight: options === null || options === void 0 ? void 0 : options.skipPreflight });
+        });
+    }
+    /**
+     *  Deposit Stake Rewards
+     *  @param wallet - User wallet
+     *  @param mint - NFT mint
+     *  @param amount - Reward amount
+     *
+     */
+    depositStakeRewards({ wallet, mint, amount, stakeVault }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const FromAta = (0, helpers_1.getATASync)(wallet, mint);
+            const StakeVault = (0, helpers_1.getStakeVaultAddressSync)(this.program.programId, stakeVault);
+            const ToAta = (0, helpers_1.getATASync)(StakeVault, mint);
+            const method = this.program.methods
+                .depositStakeRewards({
+                amount,
+                stakeVault
+            })
+                .accounts({
+                signer: wallet,
+                fromAta: FromAta,
+                toAta: ToAta,
+                mint: mint
+            });
+            if (options === null || options === void 0 ? void 0 : options.microLamports) {
+                method.postInstructions([
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                        microLamports: options.microLamports
+                    })
+                ]);
+            }
+            return method.rpc({ skipPreflight: options === null || options === void 0 ? void 0 : options.skipPreflight });
+        });
+    }
+    /**
+     *  Request Withdraw
+     *  @param wallet - User wallet
+     *  @param nftName - NFT name
+     *  @param stakeVault - Name of the stake vault
+     *
+     */
+    requestWithdraw({ wallet, nftName, mint, stakeVault }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const method = this.program.methods
+                .requestWithdrawNft({
+                nftName,
+                stakeVault
+            })
+                .accounts({
+                signer: wallet,
+                mint: mint
+            });
+            if (options === null || options === void 0 ? void 0 : options.microLamports) {
+                method.postInstructions([
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                        microLamports: options.microLamports
+                    })
+                ]);
+            }
+            return method.rpc({ skipPreflight: options === null || options === void 0 ? void 0 : options.skipPreflight });
+        });
+    }
+    /**
+     *  Withdraw NFT
+     *  @param wallet - User wallet
+     *  @param nftName - NFT name
+     *  @param mint - NFT mint
+     *  @param stakeVault - Name of the stake vault
+     *
+     */
+    withdraw({ wallet, nftName, mint, stakeVault }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const StakeVault = (0, helpers_1.getStakeVaultAddressSync)(this.program.programId, stakeVault);
+            const FromAta = (0, helpers_1.getATASync)(StakeVault, mint);
+            const ToAta = (0, helpers_1.getATASync)(wallet, mint);
+            const method = this.program.methods
+                .withdrawNft({
+                nftName,
+                stakeVault
+            })
+                .accounts({
+                signer: wallet,
+                fromAta: FromAta,
+                toAta: ToAta,
+                mint: mint
+            });
+            if (options === null || options === void 0 ? void 0 : options.microLamports) {
+                method.postInstructions([
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                        microLamports: options.microLamports
+                    })
+                ]);
+            }
+            return method.rpc({ skipPreflight: options === null || options === void 0 ? void 0 : options.skipPreflight });
+        });
+    }
+}
+exports.default = Stake;

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,110 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const web3_js_1 = require("@solana/web3.js");
+const index_1 = __importDefault(require("./index"));
+const anchor_1 = require("@coral-xyz/anchor");
+const constants_1 = require("./utils/constants");
+const stakes_json_1 = __importDefault(require("./utils/stakes.json"));
+const file = fs_1.default.readFileSync('/Users/dannpl/.config/solana/triad-man.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(), 'confirmed');
+const wallet = new anchor_1.Wallet(keypair);
+const triadProtocol = new index_1.default(connection, wallet);
+const requestWithdraw = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.stake.requestWithdraw({
+        wallet: wallet.publicKey,
+        nftName: 'Triad 0',
+        mint: new web3_js_1.PublicKey('FXRhaGeYue7bMCwcksNw4hJRY7jZ1YMwgmCu1Y8fyUNd'),
+        stakeVault: 'Rev 1'
+    }, {
+        microLamports: 10000,
+        skipPreflight: true
+    });
+    console.log(response);
+});
+const withdraw = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.stake.withdraw({
+        wallet: wallet.publicKey,
+        nftName: 'Triad 0',
+        mint: new web3_js_1.PublicKey('FXRhaGeYue7bMCwcksNw4hJRY7jZ1YMwgmCu1Y8fyUNd'),
+        stakeVault: 'Rev 1'
+    }, {
+        microLamports: 10000,
+        skipPreflight: true
+    });
+    console.log(response);
+});
+const getStake = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.stake.getStakeByWallet(wallet.publicKey);
+    const stakeVaults = yield triadProtocol.stake.getStakeVaults();
+    console.log(response);
+    console.log(stakeVaults);
+});
+const stake = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.stake.stake({
+        name: 'Triad 0',
+        wallet: wallet.publicKey,
+        stakeVault: 'Rev 1',
+        rarity: { mythic: {} },
+        collections: {
+            coleta: false,
+            undead: false,
+            alligators: false,
+            pyth: false
+        },
+        mint: new web3_js_1.PublicKey('FXRhaGeYue7bMCwcksNw4hJRY7jZ1YMwgmCu1Y8fyUNd')
+    }, {
+        skipPreflight: true,
+        microLamports: 20000
+    });
+    console.log(response);
+});
+stake();
+const getDailyBaseRewards = () => __awaiter(void 0, void 0, void 0, function* () {
+    const stakeVaultRewards = yield triadProtocol.stake.getStakeVaultRewards(constants_1.STAKE_SEASON);
+    const days = {};
+    stakes_json_1.default.forEach((stake) => {
+        const keys = Object.keys(stake.rewards);
+        keys.forEach((key) => {
+            if (!days[key]) {
+                days[key] = 0;
+            }
+            days[key] += Object.values(stake.rewards[key]).length;
+        });
+    });
+    const values = {};
+    Object.keys(days).forEach((key) => {
+        values[key] = stakeVaultRewards.perDay / days[key];
+    });
+    console.log('Daily Rewards:', values);
+});
+const getStakesByWallet = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.stake.getStakes();
+    const stakeVaultRewards = yield triadProtocol.stake.getStakeVaultRewards(constants_1.STAKE_SEASON);
+    const users = response
+        .map((stake) => stake.authority)
+        .filter((value, index, self) => self.indexOf(value) === index);
+    const data = [];
+    for (const user of users) {
+        const rewardsByWallet = yield triadProtocol.stake.getStakeRewardsByWallet(new web3_js_1.PublicKey(user), stakeVaultRewards);
+        data.push({
+            wallet: user,
+            rewards: rewardsByWallet
+        });
+    }
+    fs_1.default.writeFileSync('./src/utils/stakes.json', JSON.stringify(data, null, 2));
+});

package/dist/ticker.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="bn.js" />
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { TriadProtocol } from './types/triad_protocol';
+export default class Ticker {
+    program: Program<TriadProtocol>;
+    provider: AnchorProvider;
+    constructor(program: Program<TriadProtocol>, provider: AnchorProvider);
+    /**
+     * Get all tickers
+     */
+    getTickers(): Promise<import("@coral-xyz/anchor").ProgramAccount<{
+        initTs: import("bn.js");
+        updatedTs: import("bn.js");
+        bump: number;
+        authority: PublicKey;
+        name: string;
+        protocolProgramId: PublicKey;
+        price: import("bn.js");
+        vault: PublicKey;
+    }>[]>;
+    /**
+     * Create a new ticker
+     *  @param name - The ticker's name
+     *  @param protocolProgramId - The program ID of the protocol
+     *  @param token mint - Token mint for the ticker (e.g. USDC)
+     *
+     */
+    createTicker({ name, protocolProgramId, tokenMint }: {
+        name: string;
+        protocolProgramId: PublicKey;
+        tokenMint: PublicKey;
+    }): Promise<string>;
+    /**
+     * Update a ticker's price
+     *  @param name - The ticker's name
+     *  @param price - The ticker's price
+     *
+     */
+    updateTickerPrice({ name, price }: {
+        name: string;
+        price: string;
+    }): Promise<string>;
+}

package/dist/ticker.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const helpers_1 = require("./utils/helpers");
+const bn_js_1 = require("bn.js");
+class Ticker {
+    constructor(program, provider) {
+        this.provider = provider;
+        this.program = program;
+    }
+    /**
+     * Get all tickers
+     */
+    getTickers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.program.account.ticker.all();
+        });
+    }
+    /**
+     * Create a new ticker
+     *  @param name - The ticker's name
+     *  @param protocolProgramId - The program ID of the protocol
+     *  @param token mint - Token mint for the ticker (e.g. USDC)
+     *
+     */
+    createTicker({ name, protocolProgramId, tokenMint }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.program.methods
+                .createTicker({ name, protocolProgramId })
+                .accounts({
+                signer: this.provider.wallet.publicKey,
+                payerTokenMint: tokenMint
+            })
+                .rpc();
+        });
+    }
+    /**
+     * Update a ticker's price
+     *  @param name - The ticker's name
+     *  @param price - The ticker's price
+     *
+     */
+    updateTickerPrice({ name, price }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const TickerPDA = (0, helpers_1.getTickerAddressSync)(this.program.programId, name);
+            const instructions = [
+                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                    microLamports: 12000
+                })
+            ];
+            instructions.push(yield this.program.methods
+                .updateTickerPrice({ price: new bn_js_1.BN(price) })
+                .accounts({
+                signer: this.provider.wallet.publicKey,
+                ticker: TickerPDA
+            })
+                .instruction());
+            const { blockhash } = yield this.provider.connection.getLatestBlockhash();
+            const message = new web3_js_1.TransactionMessage({
+                payerKey: this.provider.wallet.publicKey,
+                recentBlockhash: blockhash,
+                instructions
+            }).compileToV0Message();
+            return this.provider.sendAndConfirm(new web3_js_1.VersionedTransaction(message));
+        });
+    }
+}
+exports.default = Ticker;