@triadxyz/poseidons-protocol 0.2.0 → 0.2.2

package/dist/game/index.d.ts

@@ -1,10 +1,24 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
 import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
 import { PoseidonsProtocol } from './../types/poseidons_protocol';
 import { RpcOptions } from './../types';
 import Chest from './chest';
+import Wheel from './wheel';
 export default class Game {
     private program;
     private rpcOptions;
     chest: Chest;
+    wheel: Wheel;
     constructor(program: Program<PoseidonsProtocol>, rpcOptions: RpcOptions);
+    /**
+     * Add spins to a user
+     * @param user - The user to add spins to
+     * @param spins - The number of spins to add
+     * @returns The transaction signature or versioned transaction
+     */
+    addSpin({ user, spins }: {
+        user: PublicKey;
+        spins: number;
+    }): Promise<string | import("@solana/web3.js").VersionedTransaction>;
 }

package/dist/game/index.js

@@ -1,14 +1,49 @@
 "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 anchor_1 = require("@coral-xyz/anchor");
 const chest_1 = __importDefault(require("./chest"));
+const wheel_1 = __importDefault(require("./wheel"));
+const sendVersionedTransaction_1 = __importDefault(require("../utils/sendVersionedTransaction"));
+const pda_1 = require("../utils/pda");
 class Game {
     constructor(program, rpcOptions) {
         this.program = program;
         this.rpcOptions = rpcOptions;
         this.chest = new chest_1.default(this.program, this.rpcOptions);
+        this.wheel = new wheel_1.default(this.program, this.rpcOptions);
+    }
+    /**
+     * Add spins to a user
+     * @param user - The user to add spins to
+     * @param spins - The number of spins to add
+     * @returns The transaction signature or versioned transaction
+     */
+    addSpin({ user, spins }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userPDA = (0, pda_1.getUserPDA)(user);
+            const instructions = [
+                yield this.program.methods
+                    .addSpin(new anchor_1.BN(spins))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    user: userPDA
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, instructions, this.rpcOptions);
+        });
     }
 }
 exports.default = Game;

package/dist/game/wheel.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
+import { PublicKey } from '@solana/web3.js';
+import { Program } from '@coral-xyz/anchor';
+import { PoseidonsProtocol } from './../types/poseidons_protocol';
+import { RpcOptions } from './../types';
+export default class Wheel {
+    private program;
+    private rpcOptions;
+    constructor(program: Program<PoseidonsProtocol>, rpcOptions: RpcOptions);
+    /**
+     * Get all wheels
+     * @returns The chests
+     */
+    getAllWheel(): Promise<import("./../types").Wheel[]>;
+    /**
+     * Get a wheel
+     * @param id - The id of the wheel
+     * @returns The wheel
+     */
+    getWheel(id: number): Promise<import("./../types").Wheel>;
+    /**
+     * Create a wheel
+     * @param id - The id of the wheel
+     * @param name - The name of the wheel
+     * @param prizes - The prizes of the wheel
+     * @returns The transaction signature or versioned transaction
+     */
+    createWheel({ id, name, prizes }: {
+        id: number;
+        name: string;
+        prizes: {
+            id: number;
+            name: string;
+            available: number;
+            rangeMin: number;
+            rangeMax: number;
+            unit: number;
+        }[];
+    }): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Add a prize to a wheel
+     * @param id - The id of the chest
+     * @param available - The available quantity of the prize
+     * @returns The transaction signature or versioned transaction
+     */
+    addWheelPrize({ id, available }: {
+        id: number;
+        available: number;
+    }): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Spin a wheel
+     * @param id - The id of the wheel
+     * @param spins - The number of spins
+     * @returns The transaction signature or versioned transaction
+     */
+    spinWheel({ user, id, spins }: {
+        user: PublicKey;
+        id: number;
+        spins: number;
+    }): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+}

package/dist/game/wheel.js

@@ -0,0 +1,124 @@
+"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 anchor_1 = require("@coral-xyz/anchor");
+const sendVersionedTransaction_1 = __importDefault(require("./../utils/sendVersionedTransaction"));
+const pda_1 = require("./../utils/pda");
+const helpers_1 = require("./../utils/helpers");
+class Wheel {
+    constructor(program, rpcOptions) {
+        this.program = program;
+        this.rpcOptions = rpcOptions;
+    }
+    /**
+     * Get all wheels
+     * @returns The chests
+     */
+    getAllWheel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wheels = yield this.program.account.wheel.all();
+            return wheels.map((wheel) => (0, helpers_1.formatWheel)(wheel.account, wheel.publicKey));
+        });
+    }
+    /**
+     * Get a wheel
+     * @param id - The id of the wheel
+     * @returns The wheel
+     */
+    getWheel(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wheelPDA = (0, pda_1.getWheelPDA)(id);
+            const wheel = yield this.program.account.wheel.fetch(wheelPDA, this.rpcOptions.commitment);
+            return (0, helpers_1.formatWheel)(wheel, wheelPDA);
+        });
+    }
+    /**
+     * Create a wheel
+     * @param id - The id of the wheel
+     * @param name - The name of the wheel
+     * @param prizes - The prizes of the wheel
+     * @returns The transaction signature or versioned transaction
+     */
+    createWheel({ id, name, prizes }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instructions = [
+                yield this.program.methods
+                    .createWheel({
+                    id,
+                    name,
+                    prizes: prizes.map((prize) => ({
+                        id: prize.id,
+                        name: prize.name,
+                        available: new anchor_1.BN(prize.available),
+                        rangeMin: new anchor_1.BN(prize.rangeMin),
+                        rangeMax: new anchor_1.BN(prize.rangeMax),
+                        unit: new anchor_1.BN(prize.unit)
+                    }))
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, instructions, this.rpcOptions);
+        });
+    }
+    /**
+     * Add a prize to a wheel
+     * @param id - The id of the chest
+     * @param available - The available quantity of the prize
+     * @returns The transaction signature or versioned transaction
+     */
+    addWheelPrize({ id, available }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instructions = [
+                yield this.program.methods
+                    .addWheelPrize({
+                    id,
+                    available: new anchor_1.BN(available)
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, instructions, this.rpcOptions);
+        });
+    }
+    /**
+     * Spin a wheel
+     * @param id - The id of the wheel
+     * @param spins - The number of spins
+     * @returns The transaction signature or versioned transaction
+     */
+    spinWheel({ user, id, spins }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userPDA = (0, pda_1.getUserPDA)(user);
+            const instructions = [
+                yield this.program.methods
+                    .spinWheel({
+                    id,
+                    spins: new anchor_1.BN(spins)
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    user: userPDA
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, instructions, this.rpcOptions);
+        });
+    }
+}
+exports.default = Wheel;

package/dist/types/idl_poseidons_protocol.json

@@ -272,6 +272,77 @@
                 }
             ]
         },
+        {
+            "name": "add_spin",
+            "discriminator": [168, 78, 42, 73, 116, 58, 113, 193],
+            "accounts": [
+                {
+                    "name": "signer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "squads",
+                    "writable": true,
+                    "address": "Hk1r2NUL4LbUhx1agg1w44tyZiNr72mbeLsg6suF5MA4"
+                },
+                {
+                    "name": "user",
+                    "writable": true
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": [
+                {
+                    "name": "spins",
+                    "type": "u64"
+                }
+            ]
+        },
+        {
+            "name": "add_wheel_prize",
+            "discriminator": [171, 239, 227, 40, 5, 150, 213, 239],
+            "accounts": [
+                {
+                    "name": "signer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "wheel",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [119, 104, 101, 108, 108]
+                            },
+                            {
+                                "kind": "arg",
+                                "path": "args.id"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": [
+                {
+                    "name": "args",
+                    "type": {
+                        "defined": {
+                            "name": "AddWheelPrizeArgs"
+                        }
+                    }
+                }
+            ]
+        },
         {
             "name": "burn_nft",
             "discriminator": [119, 13, 183, 17, 194, 243, 38, 31],
@@ -628,6 +699,47 @@
                 }
             ]
         },
+        {
+            "name": "create_wheel",
+            "discriminator": [175, 177, 194, 49, 117, 130, 179, 161],
+            "accounts": [
+                {
+                    "name": "signer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "wheel",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [119, 104, 101, 108, 108]
+                            },
+                            {
+                                "kind": "arg",
+                                "path": "args.id"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": [
+                {
+                    "name": "args",
+                    "type": {
+                        "defined": {
+                            "name": "CreateWheelArgs"
+                        }
+                    }
+                }
+            ]
+        },
         {
             "name": "place_chest_bid",
             "discriminator": [82, 31, 146, 177, 220, 1, 7, 157],
@@ -750,6 +862,52 @@
                     }
                 }
             ]
+        },
+        {
+            "name": "spin_wheel",
+            "discriminator": [25, 214, 214, 83, 131, 150, 190, 91],
+            "accounts": [
+                {
+                    "name": "signer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "wheel",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [119, 104, 101, 108, 108]
+                            },
+                            {
+                                "kind": "arg",
+                                "path": "args.id"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "user",
+                    "writable": true
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": [
+                {
+                    "name": "args",
+                    "type": {
+                        "defined": {
+                            "name": "SpinWheelArgs"
+                        }
+                    }
+                }
+            ],
+            "returns": "u8"
         }
     ],
     "accounts": [
@@ -776,6 +934,10 @@
         {
             "name": "User",
             "discriminator": [159, 117, 95, 227, 239, 151, 58, 236]
+        },
+        {
+            "name": "Wheel",
+            "discriminator": [196, 41, 11, 47, 123, 180, 10, 219]
         }
     ],
     "events": [
@@ -783,6 +945,10 @@
             "name": "BidChestEvent",
             "discriminator": [162, 64, 11, 176, 231, 173, 217, 89]
         },
+        {
+            "name": "BuySpinEvent",
+            "discriminator": [253, 97, 83, 130, 75, 128, 156, 7]
+        },
         {
             "name": "ChestCreatedEvent",
             "discriminator": [27, 178, 135, 161, 240, 189, 246, 238]
@@ -806,6 +972,14 @@
         {
             "name": "PoseidonRewardsEvent",
             "discriminator": [93, 26, 205, 192, 107, 244, 92, 119]
+        },
+        {
+            "name": "SpinWheelEvent",
+            "discriminator": [136, 0, 170, 174, 167, 129, 91, 187]
+        },
+        {
+            "name": "UserCreatedEvent",
+            "discriminator": [41, 186, 252, 198, 103, 111, 139, 224]
         }
     ],
     "errors": [
@@ -838,6 +1012,16 @@
             "code": 6005,
             "name": "InvalidRefer",
             "msg": "Invalid refer"
+        },
+        {
+            "code": 6006,
+            "name": "InsufficientFunds",
+            "msg": "Insufficient funds"
+        },
+        {
+            "code": 6007,
+            "name": "InsufficientSpins",
+            "msg": "Insufficient spins"
         }
     ],
     "types": [
@@ -874,6 +1058,22 @@
                 ]
             }
         },
+        {
+            "name": "AddWheelPrizeArgs",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "id",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "available",
+                        "type": "u64"
+                    }
+                ]
+            }
+        },
         {
             "name": "BaseAssetV1",
             "type": {
@@ -984,6 +1184,30 @@
                 ]
             }
         },
+        {
+            "name": "BuySpinEvent",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "user",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "spins",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "fee",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "timestamp",
+                        "type": "i64"
+                    }
+                ]
+            }
+        },
         {
             "name": "Chest",
             "type": {
@@ -1236,6 +1460,35 @@
                 ]
             }
         },
+        {
+            "name": "CreateWheelArgs",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "id",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "name",
+                        "type": "string"
+                    },
+                    {
+                        "name": "prizes",
+                        "type": {
+                            "array": [
+                                {
+                                    "defined": {
+                                        "name": "Prize"
+                                    }
+                                },
+                                12
+                            ]
+                        }
+                    }
+                ]
+            }
+        },
         {
             "name": "Key",
             "type": {
@@ -1450,6 +1703,74 @@
                 ]
             }
         },
+        {
+            "name": "Prize",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "id",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "name",
+                        "type": "string"
+                    },
+                    {
+                        "name": "available",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "range_min",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "range_max",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "unit",
+                        "type": "u64"
+                    }
+                ]
+            }
+        },
+        {
+            "name": "SpinWheelArgs",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "id",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "spins",
+                        "type": "u64"
+                    }
+                ]
+            }
+        },
+        {
+            "name": "SpinWheelEvent",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "user",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "prize_id",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "timestamp",
+                        "type": "i64"
+                    }
+                ]
+            }
+        },
         {
             "name": "UpdateAuthority",
             "type": {
@@ -1494,10 +1815,81 @@
                         "name": "coins",
                         "type": "u64"
                     },
+                    {
+                        "name": "spins",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "padding",
+                        "type": {
+                            "array": ["u8", 48]
+                        }
+                    }
+                ]
+            }
+        },
+        {
+            "name": "UserCreatedEvent",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "user",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "authority",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "refer",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "created_at",
+                        "type": "i64"
+                    }
+                ]
+            }
+        },
+        {
+            "name": "Wheel",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "bump",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "id",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "name",
+                        "type": "string"
+                    },
+                    {
+                        "name": "count",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "prizes",
+                        "type": {
+                            "array": [
+                                {
+                                    "defined": {
+                                        "name": "Prize"
+                                    }
+                                },
+                                12
+                            ]
+                        }
+                    },
                     {
                         "name": "padding",
                         "type": {
-                            "array": ["u8", 56]
+                            "array": ["u8", 32]
                         }
                     }
                 ]

package/dist/types/index.d.ts

@@ -51,3 +51,18 @@ export type Chest = {
     createdAt: number;
     finishedAt: number;
 };
+export type Wheel = {
+    address: string;
+    id: number;
+    name: string;
+    count: number;
+    prizes: Prize[];
+};
+export type Prize = {
+    id: number;
+    name: string;
+    available: number;
+    rangeMin: number;
+    rangeMax: number;
+    unit: number;
+};

package/dist/types/poseidons_protocol.d.ts

@@ -377,6 +377,77 @@ export type PoseidonsProtocol = {
                 }
             ];
         },
+        {
+            name: 'addSpin';
+            discriminator: [168, 78, 42, 73, 116, 58, 113, 193];
+            accounts: [
+                {
+                    name: 'signer';
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: 'squads';
+                    writable: true;
+                    address: 'Hk1r2NUL4LbUhx1agg1w44tyZiNr72mbeLsg6suF5MA4';
+                },
+                {
+                    name: 'user';
+                    writable: true;
+                },
+                {
+                    name: 'systemProgram';
+                    address: '11111111111111111111111111111111';
+                }
+            ];
+            args: [
+                {
+                    name: 'spins';
+                    type: 'u64';
+                }
+            ];
+        },
+        {
+            name: 'addWheelPrize';
+            discriminator: [171, 239, 227, 40, 5, 150, 213, 239];
+            accounts: [
+                {
+                    name: 'signer';
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: 'wheel';
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [119, 104, 101, 108, 108];
+                            },
+                            {
+                                kind: 'arg';
+                                path: 'args.id';
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: 'systemProgram';
+                    address: '11111111111111111111111111111111';
+                }
+            ];
+            args: [
+                {
+                    name: 'args';
+                    type: {
+                        defined: {
+                            name: 'addWheelPrizeArgs';
+                        };
+                    };
+                }
+            ];
+        },
         {
             name: 'burnNft';
             discriminator: [119, 13, 183, 17, 194, 243, 38, 31];
@@ -861,6 +932,47 @@ export type PoseidonsProtocol = {
                 }
             ];
         },
+        {
+            name: 'createWheel';
+            discriminator: [175, 177, 194, 49, 117, 130, 179, 161];
+            accounts: [
+                {
+                    name: 'signer';
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: 'wheel';
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [119, 104, 101, 108, 108];
+                            },
+                            {
+                                kind: 'arg';
+                                path: 'args.id';
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: 'systemProgram';
+                    address: '11111111111111111111111111111111';
+                }
+            ];
+            args: [
+                {
+                    name: 'args';
+                    type: {
+                        defined: {
+                            name: 'createWheelArgs';
+                        };
+                    };
+                }
+            ];
+        },
         {
             name: 'placeChestBid';
             discriminator: [82, 31, 146, 177, 220, 1, 7, 157];
@@ -1041,6 +1153,52 @@ export type PoseidonsProtocol = {
                     };
                 }
             ];
+        },
+        {
+            name: 'spinWheel';
+            discriminator: [25, 214, 214, 83, 131, 150, 190, 91];
+            accounts: [
+                {
+                    name: 'signer';
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: 'wheel';
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [119, 104, 101, 108, 108];
+                            },
+                            {
+                                kind: 'arg';
+                                path: 'args.id';
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: 'user';
+                    writable: true;
+                },
+                {
+                    name: 'systemProgram';
+                    address: '11111111111111111111111111111111';
+                }
+            ];
+            args: [
+                {
+                    name: 'args';
+                    type: {
+                        defined: {
+                            name: 'spinWheelArgs';
+                        };
+                    };
+                }
+            ];
+            returns: 'u8';
         }
     ];
     accounts: [
@@ -1067,6 +1225,10 @@ export type PoseidonsProtocol = {
         {
             name: 'user';
             discriminator: [159, 117, 95, 227, 239, 151, 58, 236];
+        },
+        {
+            name: 'wheel';
+            discriminator: [196, 41, 11, 47, 123, 180, 10, 219];
         }
     ];
     events: [
@@ -1074,6 +1236,10 @@ export type PoseidonsProtocol = {
             name: 'bidChestEvent';
             discriminator: [162, 64, 11, 176, 231, 173, 217, 89];
         },
+        {
+            name: 'buySpinEvent';
+            discriminator: [253, 97, 83, 130, 75, 128, 156, 7];
+        },
         {
             name: 'chestCreatedEvent';
             discriminator: [27, 178, 135, 161, 240, 189, 246, 238];
@@ -1097,6 +1263,14 @@ export type PoseidonsProtocol = {
         {
             name: 'poseidonRewardsEvent';
             discriminator: [93, 26, 205, 192, 107, 244, 92, 119];
+        },
+        {
+            name: 'spinWheelEvent';
+            discriminator: [136, 0, 170, 174, 167, 129, 91, 187];
+        },
+        {
+            name: 'userCreatedEvent';
+            discriminator: [41, 186, 252, 198, 103, 111, 139, 224];
         }
     ];
     errors: [
@@ -1129,6 +1303,16 @@ export type PoseidonsProtocol = {
             code: 6005;
             name: 'invalidRefer';
             msg: 'Invalid refer';
+        },
+        {
+            code: 6006;
+            name: 'insufficientFunds';
+            msg: 'Insufficient funds';
+        },
+        {
+            code: 6007;
+            name: 'insufficientSpins';
+            msg: 'Insufficient spins';
         }
     ];
     types: [
@@ -1165,6 +1349,22 @@ export type PoseidonsProtocol = {
                 ];
             };
         },
+        {
+            name: 'addWheelPrizeArgs';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'id';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'available';
+                        type: 'u64';
+                    }
+                ];
+            };
+        },
         {
             name: 'baseAssetV1';
             type: {
@@ -1275,6 +1475,30 @@ export type PoseidonsProtocol = {
                 ];
             };
         },
+        {
+            name: 'buySpinEvent';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'user';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'spins';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'fee';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'timestamp';
+                        type: 'i64';
+                    }
+                ];
+            };
+        },
         {
             name: 'chest';
             type: {
@@ -1527,6 +1751,35 @@ export type PoseidonsProtocol = {
                 ];
             };
         },
+        {
+            name: 'createWheelArgs';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'id';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'name';
+                        type: 'string';
+                    },
+                    {
+                        name: 'prizes';
+                        type: {
+                            array: [
+                                {
+                                    defined: {
+                                        name: 'prize';
+                                    };
+                                },
+                                12
+                            ];
+                        };
+                    }
+                ];
+            };
+        },
         {
             name: 'key';
             type: {
@@ -1741,6 +1994,74 @@ export type PoseidonsProtocol = {
                 ];
             };
         },
+        {
+            name: 'prize';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'id';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'name';
+                        type: 'string';
+                    },
+                    {
+                        name: 'available';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'rangeMin';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'rangeMax';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'unit';
+                        type: 'u64';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'spinWheelArgs';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'id';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'spins';
+                        type: 'u64';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'spinWheelEvent';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'user';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'prizeId';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'timestamp';
+                        type: 'i64';
+                    }
+                ];
+            };
+        },
         {
             name: 'updateAuthority';
             type: {
@@ -1785,10 +2106,81 @@ export type PoseidonsProtocol = {
                         name: 'coins';
                         type: 'u64';
                     },
+                    {
+                        name: 'spins';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'padding';
+                        type: {
+                            array: ['u8', 48];
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'userCreatedEvent';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'user';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'authority';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'refer';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'createdAt';
+                        type: 'i64';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'wheel';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'bump';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'id';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'name';
+                        type: 'string';
+                    },
+                    {
+                        name: 'count';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'prizes';
+                        type: {
+                            array: [
+                                {
+                                    defined: {
+                                        name: 'prize';
+                                    };
+                                },
+                                12
+                            ];
+                        };
+                    },
                     {
                         name: 'padding';
                         type: {
-                            array: ['u8', 56];
+                            array: ['u8', 32];
                         };
                     }
                 ];

package/dist/utils/helpers.d.ts

@@ -1,8 +1,9 @@
 import { IdlAccounts } from '@coral-xyz/anchor';
 import { PublicKey } from '@solana/web3.js';
 import { PoseidonsProtocol } from '../types/poseidons_protocol';
-import { PoseidonVault, Poseidon, Chest, User } from '../types';
+import { PoseidonVault, Poseidon, Chest, User, Wheel } from '../types';
 export declare const formatPoseidonVault: (account: IdlAccounts<PoseidonsProtocol>['poseidonVault'], address: PublicKey) => PoseidonVault;
 export declare const formatPoseidon: (account: IdlAccounts<PoseidonsProtocol>['poseidon'], address: PublicKey) => Poseidon;
 export declare const formatUser: (account: IdlAccounts<PoseidonsProtocol>['user'], address: PublicKey) => User;
 export declare const formatChest: (account: IdlAccounts<PoseidonsProtocol>['chest'], address: PublicKey) => Chest;
+export declare const formatWheel: (account: IdlAccounts<PoseidonsProtocol>['wheel'], address: PublicKey) => Wheel;

package/dist/utils/helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatChest = exports.formatUser = exports.formatPoseidon = exports.formatPoseidonVault = void 0;
+exports.formatWheel = exports.formatChest = exports.formatUser = exports.formatPoseidon = exports.formatPoseidonVault = void 0;
 const formatPoseidonVault = (account, address) => {
     return {
         address: address.toString(),
@@ -60,3 +60,20 @@ const formatChest = (account, address) => {
     };
 };
 exports.formatChest = formatChest;
+const formatWheel = (account, address) => {
+    return {
+        address: address.toString(),
+        id: account.id,
+        name: account.name,
+        count: account.count.toNumber(),
+        prizes: account.prizes.map((prize) => ({
+            id: prize.id,
+            name: prize.name,
+            available: prize.available.toNumber(),
+            rangeMin: prize.rangeMin.toNumber(),
+            rangeMax: prize.rangeMax.toNumber(),
+            unit: prize.unit.toNumber()
+        }))
+    };
+};
+exports.formatWheel = formatWheel;

package/dist/utils/pda.d.ts

@@ -4,3 +4,4 @@ export declare const getPoseidonVaultPDA: () => PublicKey;
 export declare const getPoseidonPDA: (mint: PublicKey) => PublicKey;
 export declare const getUserPDA: (authority: PublicKey) => PublicKey;
 export declare const getChestPDA: (id: number) => PublicKey;
+export declare const getWheelPDA: (id: number) => PublicKey;

package/dist/utils/pda.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChestPDA = exports.getUserPDA = exports.getPoseidonPDA = exports.getPoseidonVaultPDA = exports.getTokenATA = void 0;
+exports.getWheelPDA = exports.getChestPDA = exports.getUserPDA = exports.getPoseidonPDA = exports.getPoseidonVaultPDA = exports.getTokenATA = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const constants_1 = require("./constants");
@@ -25,3 +25,7 @@ const getChestPDA = (id) => {
     return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('chest'), new anchor_1.BN(id).toArrayLike(Buffer, 'le', 8)], constants_1.POSEIDON_VAULT_PROGRAM_ID)[0];
 };
 exports.getChestPDA = getChestPDA;
+const getWheelPDA = (id) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('wheel'), new anchor_1.BN(id).toArrayLike(Buffer, 'le', 8)], constants_1.POSEIDON_VAULT_PROGRAM_ID)[0];
+};
+exports.getWheelPDA = getWheelPDA;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triadxyz/poseidons-protocol",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",