@triadxyz/triad-protocol 0.1.2-alpha.9 → 0.1.3-alpha.1

package/dist/index.d.ts

@@ -3,11 +3,13 @@ import { Connection, PublicKey } from '@solana/web3.js';
 import { TriadProtocol } from './types/triad_protocol';
 import Ticker from './ticker';
 import Vault from './vault';
+import Stake from './stake';
 export default class TriadProtocolClient {
     program: Program<TriadProtocol>;
     provider: AnchorProvider;
     ticker: Ticker;
     vault: Vault;
+    stake: Stake;
     constructor(connection: Connection, wallet: Wallet);
     getUserPositions: (userWallet: PublicKey) => Promise<{}[]>;
 }

package/dist/index.js

@@ -13,11 +13,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const anchor_1 = require("@coral-xyz/anchor");
-const triad_protocol_1 = require("./types/triad_protocol");
-const constants_1 = require("./utils/constants");
+const idl_triad_protocol_json_1 = __importDefault(require("./types/idl_triad_protocol.json"));
 const ticker_1 = __importDefault(require("./ticker"));
 const vault_1 = __importDefault(require("./vault"));
 const helpers_1 = require("./utils/helpers");
+const stake_1 = __importDefault(require("./stake"));
 class TriadProtocolClient {
     constructor(connection, wallet) {
         this.getUserPositions = (userWallet) => __awaiter(this, void 0, void 0, function* () {
@@ -42,9 +42,10 @@ class TriadProtocolClient {
             return positions;
         });
         this.provider = new anchor_1.AnchorProvider(connection, wallet, anchor_1.AnchorProvider.defaultOptions());
-        this.program = new anchor_1.Program(triad_protocol_1.IDL, constants_1.TRIAD_PROTOCOL_PROGRAM_ID, this.provider);
+        this.program = new anchor_1.Program(idl_triad_protocol_json_1.default, this.provider);
         this.ticker = new ticker_1.default(this.program, this.provider);
         this.vault = new vault_1.default(this.program, this.provider);
+        this.stake = new stake_1.default(this.program, this.provider);
     }
 }
 exports.default = TriadProtocolClient;

package/dist/stake.d.ts

@@ -0,0 +1,128 @@
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { TriadProtocol } from './types/triad_protocol';
+import BN from 'bn.js';
+export default class Stake {
+    program: Program<TriadProtocol>;
+    provider: AnchorProvider;
+    constructor(program: Program<TriadProtocol>, provider: AnchorProvider);
+    /**
+     * Get all stakes
+     */
+    getStakes(): Promise<import("@coral-xyz/anchor").ProgramAccount<{
+        bump: number;
+        authority: PublicKey;
+        initTs: BN;
+        isLocked: boolean;
+        withdrawTs: BN;
+        name: string;
+        collections: (({
+            undead?: never;
+            alligators?: never;
+            pyth?: never;
+        } & {
+            coleta: Record<string, never>;
+        }) | ({
+            coleta?: never;
+            alligators?: never;
+            pyth?: never;
+        } & {
+            undead: Record<string, never>;
+        }) | ({
+            coleta?: never;
+            undead?: never;
+            pyth?: never;
+        } & {
+            alligators: Record<string, never>;
+        }) | ({
+            coleta?: never;
+            undead?: never;
+            alligators?: never;
+        } & {
+            pyth: Record<string, never>;
+        }))[];
+        rarity: ({
+            uncommon?: never;
+            rare?: never;
+            epic?: never;
+            legendary?: never;
+        } & {
+            common: Record<string, never>;
+        }) | ({
+            common?: never;
+            rare?: never;
+            epic?: never;
+            legendary?: never;
+        } & {
+            uncommon: Record<string, never>;
+        }) | ({
+            common?: never;
+            uncommon?: never;
+            epic?: never;
+            legendary?: never;
+        } & {
+            rare: Record<string, never>;
+        }) | ({
+            common?: never;
+            uncommon?: never;
+            rare?: never;
+            legendary?: never;
+        } & {
+            epic: Record<string, never>;
+        }) | ({
+            common?: never;
+            uncommon?: never;
+            rare?: never;
+            epic?: never;
+        } & {
+            legendary: Record<string, never>;
+        });
+        mint: PublicKey;
+        stakeVault: PublicKey;
+    }>[]>;
+    /**
+     *  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 }: {
+        name: string;
+        wallet: PublicKey;
+        mint: PublicKey;
+        collections: {
+            alligators: boolean;
+            coleta: boolean;
+            undead: boolean;
+            pyth: boolean;
+        };
+        rarity: {
+            common: {};
+        } | {
+            uncommon: {};
+        } | {
+            rare: {};
+        } | {
+            epic: {};
+        } | {
+            legendary: {};
+        };
+    }): Promise<string>;
+    /**
+     * Update a ticker's price
+     *  @param name - The ticker's name
+     *  @param amount - Reward amount
+     *  @param slots - Amount available to users joining the vault
+     *  @param collection - The Collection name
+     *
+     */
+    initializeStakeVault({ name, amount, slots, collection }: {
+        name: string;
+        amount: BN;
+        slots: BN;
+        collection: string;
+    }): Promise<string>;
+}

package/dist/stake.js

@@ -0,0 +1,82 @@
+"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 helpers_1 = require("./utils/helpers");
+class Stake {
+    constructor(program, provider) {
+        this.provider = provider;
+        this.program = program;
+    }
+    /**
+     * Get all stakes
+     */
+    getStakes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.program.account.stake.all();
+        });
+    }
+    /**
+     *  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 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const FromAta = (0, helpers_1.getATASync)(wallet, mint);
+            let items = [];
+            Object.keys(collections).forEach((key) => {
+                if (collections[key]) {
+                    items.push({ [key]: {} });
+                }
+            });
+            return this.program.methods
+                .stake({
+                name,
+                collections: items,
+                collection: 'Triad',
+                rarity
+            })
+                .accounts({
+                signer: this.provider.wallet.publicKey,
+                fromAta: FromAta
+            })
+                .rpc();
+        });
+    }
+    /**
+     * Update a ticker's price
+     *  @param name - The ticker's name
+     *  @param amount - Reward amount
+     *  @param slots - Amount available to users joining the vault
+     *  @param collection - The Collection name
+     *
+     */
+    initializeStakeVault({ name, amount, slots, collection }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.program.methods
+                .initializeStakeVault({
+                name,
+                amount,
+                slots,
+                collection
+            })
+                .accounts({
+                signer: this.provider.wallet.publicKey
+            })
+                .rpc();
+        });
+    }
+}
+exports.default = Stake;

package/dist/test.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Connection, Keypair } from '@solana/web3.js';
+import TriadProtocol from './index';
+import { Wallet } from '@coral-xyz/anchor';
+export default class Test {
+    file: Buffer;
+    Keypair: Keypair;
+    connection: Connection;
+    wallet: Wallet;
+    triadProtocol: TriadProtocol;
+    constructor();
+    init: () => Promise<void>;
+    initializeStakeVault: () => Promise<void>;
+    stakeNFT: () => Promise<void>;
+}

package/dist/test.js

@@ -0,0 +1,50 @@
+"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");
+class Test {
+    constructor() {
+        this.file = fs_1.default.readFileSync('/Users/dannpl/.config/solana/id.json');
+        this.Keypair = web3_js_1.Keypair.fromSecretKey(new Uint8Array(JSON.parse(this.file.toString())));
+        this.connection = new web3_js_1.Connection('http://127.0.0.1:8899');
+        this.wallet = new anchor_1.Wallet(this.Keypair);
+        this.triadProtocol = new index_1.default(this.connection, this.wallet);
+        this.init = () => __awaiter(this, void 0, void 0, function* () { });
+        this.initializeStakeVault = () => __awaiter(this, void 0, void 0, function* () {
+            const reponse = yield this.triadProtocol.stake.initializeStakeVault({
+                name: 'Rev Share 1',
+                collection: 'Triad',
+                slots: new anchor_1.BN(1939),
+                amount: new anchor_1.BN(1000000000)
+            });
+            console.log('Initialize Stake Vault:', reponse);
+        });
+        this.stakeNFT = () => __awaiter(this, void 0, void 0, function* () {
+            const reponse = yield this.triadProtocol.stake.stake({
+                name: 'Rev Share 1',
+                wallet: this.wallet.publicKey,
+                collections: { alligators: true, coleta: true, undead: true, pyth: true },
+                mint: new web3_js_1.PublicKey('DQ3Uq6GDX6HA99jVBaErtZcvhm1AsCpkB421a2MEDJ7B'),
+                rarity: { common: {} }
+            });
+            console.log('Initialize Stake Vault:', reponse);
+        });
+    }
+}
+exports.default = Test;
+const test = new Test();
+test.stakeNFT();

package/dist/ticker.js

@@ -34,16 +34,10 @@ class Ticker {
      */
     createTicker({ name, protocolProgramId, tokenMint }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const TickerPDA = (0, helpers_1.getTickerAddressSync)(this.program.programId, name);
-            const VaultPDA = (0, helpers_1.getVaultAddressSync)(this.program.programId, TickerPDA);
-            const TokenAccountPDA = (0, helpers_1.getTokenVaultAddressSync)(this.program.programId, VaultPDA);
             return this.program.methods
                 .createTicker({ name, protocolProgramId })
                 .accounts({
                 signer: this.provider.wallet.publicKey,
-                ticker: TickerPDA,
-                vault: VaultPDA,
-                tokenAccount: TokenAccountPDA,
                 payerTokenMint: tokenMint
             })
                 .rpc();