@triadxyz/triad-protocol 1.4.1-beta → 1.4.3-beta

package/dist/index.d.ts

@@ -80,10 +80,242 @@ export default class TriadProtocolClient {
      * Spin Wheel
      * @param isSol - Whether to pay with SOL or token
      * @param verifier - Verifier keypair
+     * @param prizeType - Prize type
      * @param options - RPC options
+     *
      */
     spinWheel(args: {
         isSol: boolean;
         prizeType: PrizeType;
+        verifier: Keypair;
     }, options?: RpcOptions): Promise<string>;
+    /**
+     * Get Spin Wheel
+     *
+     */
+    getSpinWheel(): Promise<({
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        none: Record<string, never>;
+    }) | ({
+        none?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        undead: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        ticket: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        honeyland: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        trd100: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        trd50: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        flip: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        pengu: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        ore: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        lucksea: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trident2000?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        trd5: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident500?: never;
+        trd10000?: never;
+    } & {
+        trident2000: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trd10000?: never;
+    } & {
+        trident500: Record<string, never>;
+    }) | ({
+        none?: never;
+        undead?: never;
+        ticket?: never;
+        honeyland?: never;
+        trd100?: never;
+        trd50?: never;
+        flip?: never;
+        pengu?: never;
+        ore?: never;
+        lucksea?: never;
+        trd5?: never;
+        trident2000?: never;
+        trident500?: never;
+    } & {
+        trd10000: Record<string, never>;
+    })>;
 }

package/dist/index.js

@@ -208,13 +208,14 @@ class TriadProtocolClient {
      */
     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))
+                .claimSpinToken({
+                name: constants_1.SPIN_NAME,
+                amount: new anchor_1.BN(amount * Math.pow(10, 6))
+            })
                 .accounts({
                 signer: this.provider.wallet.publicKey,
                 verifier: verifier.publicKey,
-                spin: spinPDA,
                 mint: constants_1.TCMAS_MINT
             })
                 .instruction();
@@ -225,12 +226,14 @@ class TriadProtocolClient {
      * Spin Wheel
      * @param isSol - Whether to pay with SOL or token
      * @param verifier - Verifier keypair
+     * @param prizeType - Prize type
      * @param options - RPC options
+     *
      */
     spinWheel(args, 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
+            const ix = yield this.program.methods
                 .spinWheel({
                 isSol: args.isSol,
                 prizeType: args.prizeType
@@ -240,8 +243,26 @@ class TriadProtocolClient {
                 verifier: constants_1.VERIFIER,
                 spin: spinPDA,
                 mint: constants_1.TCMAS_MINT
-            });
-            return (0, sendTransactionWithOptions_1.default)(method, options);
+            })
+                .instruction();
+            return (0, sendVersionedTransaction_1.default)(this.provider, [ix], options, undefined, [], args.verifier);
+        });
+    }
+    /**
+     * Get Spin Wheel
+     *
+     */
+    getSpinWheel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [spin] = yield this.program.account.spin.all();
+            const randomNumber = Math.floor(Math.random() * 1000000) + 1;
+            const prize = spin.account.prizes.find((p) => randomNumber >= p.rangeMin.toNumber() &&
+                randomNumber <= p.rangeMax.toNumber() &&
+                p.status.claimed);
+            if (!prize) {
+                return { none: {} };
+            }
+            return prize.prizeType;
         });
     }
 }

package/dist/local-test.js

@@ -435,6 +435,14 @@ const addSpinPrize = () => __awaiter(void 0, void 0, void 0, function* () {
     });
     console.log(response);
 });
+const spinWheel = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.spinWheel({
+        isSol: false,
+        prizeType: { none: {} },
+        verifier: keypair
+    });
+    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) => ({
@@ -445,11 +453,4 @@ const getSpinPrize = () => __awaiter(void 0, void 0, void 0, function* () {
     }));
     console.log(prizes);
 });
-const spinWheel = () => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield triadProtocol.spinWheel({
-        isSol: false,
-        prizeType: { none: {} }
-    });
-    console.log(response);
-});
-spinWheel();
+getSpinPrize();

package/dist/types/idl_triad_protocol.json

@@ -161,7 +161,19 @@
                 },
                 {
                     "name": "spin",
-                    "writable": true
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [115, 112, 105, 110]
+                            },
+                            {
+                                "kind": "arg",
+                                "path": "args.name"
+                            }
+                        ]
+                    }
                 },
                 {
                     "name": "mint",
@@ -238,8 +250,12 @@
             ],
             "args": [
                 {
-                    "name": "amount",
-                    "type": "u64"
+                    "name": "args",
+                    "type": {
+                        "defined": {
+                            "name": "ClaimSpinTokenArgs"
+                        }
+                    }
                 }
             ]
         },
@@ -1951,6 +1967,22 @@
                 ]
             }
         },
+        {
+            "name": "ClaimSpinTokenArgs",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "name",
+                        "type": "string"
+                    },
+                    {
+                        "name": "amount",
+                        "type": "u64"
+                    }
+                ]
+            }
+        },
         {
             "name": "ClaimSpinTokenUpdate",
             "type": {

package/dist/types/triad_protocol.d.ts

@@ -226,6 +226,18 @@ export type TriadProtocol = {
                 {
                     name: 'spin';
                     writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [115, 112, 105, 110];
+                            },
+                            {
+                                kind: 'arg';
+                                path: 'args.name';
+                            }
+                        ];
+                    };
                 },
                 {
                     name: 'mint';
@@ -360,8 +372,12 @@ export type TriadProtocol = {
             ];
             args: [
                 {
-                    name: 'amount';
-                    type: 'u64';
+                    name: 'args';
+                    type: {
+                        defined: {
+                            name: 'claimSpinTokenArgs';
+                        };
+                    };
                 }
             ];
         },
@@ -2711,6 +2727,22 @@ export type TriadProtocol = {
                 ];
             };
         },
+        {
+            name: 'claimSpinTokenArgs';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'name';
+                        type: 'string';
+                    },
+                    {
+                        name: 'amount';
+                        type: 'u64';
+                    }
+                ];
+            };
+        },
         {
             name: 'claimSpinTokenUpdate';
             type: {

package/dist/utils/sendVersionedTransaction.d.ts

@@ -3,5 +3,5 @@ import { RpcOptions } from '../types';
 import { AddressLookupTableAccount } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
 import { Keypair } from '@solana/web3.js';
-declare const sendVersionedTransaction: (provider: AnchorProvider, ixs: TransactionInstruction[], options?: RpcOptions, payer?: Keypair, addressLookupTableAccounts?: AddressLookupTableAccount[], verifier?: Keypair, assets?: Keypair[]) => Promise<string>;
+declare const sendVersionedTransaction: (provider: AnchorProvider, ixs: TransactionInstruction[], options?: RpcOptions, payer?: Keypair, addressLookupTableAccounts?: AddressLookupTableAccount[], verifier?: Keypair) => Promise<string>;
 export default sendVersionedTransaction;

package/dist/utils/sendVersionedTransaction.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const web3_js_1 = require("@solana/web3.js");
-const sendVersionedTransaction = (provider, ixs, options, payer, addressLookupTableAccounts, verifier, assets) => __awaiter(void 0, void 0, void 0, function* () {
+const sendVersionedTransaction = (provider, ixs, options, payer, addressLookupTableAccounts, verifier) => __awaiter(void 0, void 0, void 0, function* () {
     if (options === null || options === void 0 ? void 0 : options.microLamports) {
         ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
             microLamports: options.microLamports
@@ -31,12 +31,6 @@ const sendVersionedTransaction = (provider, ixs, options, payer, addressLookupTa
         tx.sign([verifier]);
         signers.push(verifier);
     }
-    if (assets) {
-        for (const asset of assets) {
-            tx.sign([asset]);
-            signers.push(asset);
-        }
-    }
     return provider.sendAndConfirm(tx, signers, {
         skipPreflight: options === null || options === void 0 ? void 0 : options.skipPreflight,
         commitment: 'confirmed'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triadxyz/triad-protocol",
-  "version": "1.4.1-beta",
+  "version": "1.4.3-beta",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",