@triadxyz/triad-protocol 1.4.0-beta → 1.4.2-beta

package/dist/index.d.ts

@@ -80,7 +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
+     *
      */
-    spinWheel(isSol: boolean, options?: RpcOptions): Promise<number>;
+    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

@@ -14,7 +14,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
-const base64_js_1 = require("base64-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");
@@ -226,28 +225,43 @@ 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(isSol, options) {
-        var _a, _b, _c;
+    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.spinWheel(isSol).accounts({
+            const ix = yield this.program.methods
+                .spinWheel({
+                isSol: args.isSol,
+                prizeType: args.prizeType
+            })
+                .accounts({
                 signer: this.provider.wallet.publicKey,
+                verifier: constants_1.VERIFIER,
                 spin: spinPDA,
                 mint: constants_1.TCMAS_MINT
-            });
-            const tx = yield (0, sendTransactionWithOptions_1.default)(method, options);
-            const txResult = (yield this.provider.connection.getTransaction(tx, {
-                commitment: 'confirmed',
-                maxSupportedTransactionVersion: 0
-            }));
-            const returnData = (_b = (_a = txResult.meta) === null || _a === void 0 ? void 0 : _a.returnData) === null || _b === void 0 ? void 0 : _b.data;
-            if (!returnData) {
-                throw new Error('No return data found in transaction');
+            })
+                .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: {} };
             }
-            let value = (_c = txResult.meta) === null || _c === void 0 ? void 0 : _c.returnData.data[0];
-            return new anchor_1.BN((0, base64_js_1.toByteArray)(value), 'le').toNumber();
+            return prize.prizeType;
         });
     }
 }

package/dist/local-test.js

@@ -445,3 +445,11 @@ 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: {} },
+        verifier: keypair
+    });
+    console.log(response);
+});

package/dist/types/idl_triad_protocol.json

@@ -1239,6 +1239,11 @@
                     "writable": true,
                     "signer": true
                 },
+                {
+                    "name": "verifier",
+                    "writable": true,
+                    "signer": true
+                },
                 {
                     "name": "tresuary_account",
                     "writable": true,
@@ -1323,8 +1328,12 @@
             ],
             "args": [
                 {
-                    "name": "is_sol",
-                    "type": "bool"
+                    "name": "args",
+                    "type": {
+                        "defined": {
+                            "name": "SpinWheelArgs"
+                        }
+                    }
                 }
             ],
             "returns": {
@@ -1711,6 +1720,10 @@
         }
     ],
     "events": [
+        {
+            "name": "ClaimSpinTokenUpdate",
+            "discriminator": [162, 70, 212, 35, 0, 49, 120, 75]
+        },
         {
             "name": "MarketUpdate",
             "discriminator": [170, 101, 124, 32, 249, 253, 251, 96]
@@ -1938,6 +1951,26 @@
                 ]
             }
         },
+        {
+            "name": "ClaimSpinTokenUpdate",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "player",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "amount",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "timestamp",
+                        "type": "i64"
+                    }
+                ]
+            }
+        },
         {
             "name": "ClaimStakeRewardsArgs",
             "type": {
@@ -2970,6 +3003,26 @@
                 ]
             }
         },
+        {
+            "name": "SpinWheelArgs",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "is_sol",
+                        "type": "bool"
+                    },
+                    {
+                        "name": "prize_type",
+                        "type": {
+                            "defined": {
+                                "name": "PrizeType"
+                            }
+                        }
+                    }
+                ]
+            }
+        },
         {
             "name": "SpinWheelResult",
             "type": {

package/dist/types/triad_protocol.d.ts

@@ -1767,6 +1767,11 @@ export type TriadProtocol = {
                     writable: true;
                     signer: true;
                 },
+                {
+                    name: 'verifier';
+                    writable: true;
+                    signer: true;
+                },
                 {
                     name: 'tresuaryAccount';
                     writable: true;
@@ -1909,8 +1914,12 @@ export type TriadProtocol = {
             ];
             args: [
                 {
-                    name: 'isSol';
-                    type: 'bool';
+                    name: 'args';
+                    type: {
+                        defined: {
+                            name: 'spinWheelArgs';
+                        };
+                    };
                 }
             ];
             returns: {
@@ -2471,6 +2480,10 @@ export type TriadProtocol = {
         }
     ];
     events: [
+        {
+            name: 'claimSpinTokenUpdate';
+            discriminator: [162, 70, 212, 35, 0, 49, 120, 75];
+        },
         {
             name: 'marketUpdate';
             discriminator: [170, 101, 124, 32, 249, 253, 251, 96];
@@ -2698,6 +2711,26 @@ export type TriadProtocol = {
                 ];
             };
         },
+        {
+            name: 'claimSpinTokenUpdate';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'player';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'amount';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'timestamp';
+                        type: 'i64';
+                    }
+                ];
+            };
+        },
         {
             name: 'claimStakeRewardsArgs';
             type: {
@@ -3726,6 +3759,26 @@ export type TriadProtocol = {
                 ];
             };
         },
+        {
+            name: 'spinWheelArgs';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'isSol';
+                        type: 'bool';
+                    },
+                    {
+                        name: 'prizeType';
+                        type: {
+                            defined: {
+                                name: 'prizeType';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
         {
             name: 'spinWheelResult';
             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.0-beta",
+  "version": "1.4.2-beta",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",