@triadxyz/triad-protocol 1.6.2-beta → 1.6.4-beta

package/dist/index.d.ts

@@ -4,11 +4,13 @@ import { TriadProtocol } from './types/triad_protocol';
 import Trade from './trade';
 import Stake from './stake';
 import { RpcOptions, TransferPoseidonArgs } from './types';
+import Wheel from './wheel';
 export default class TriadProtocolClient {
     program: Program<TriadProtocol>;
     provider: AnchorProvider;
     trade: Trade;
     stake: Stake;
+    wheel: Wheel;
     constructor(connection: Connection, wallet: Wallet);
     /**
      * Transfer Poseidon

package/dist/index.js

@@ -20,6 +20,7 @@ const stake_1 = __importDefault(require("./stake"));
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
 const constants_1 = require("./utils/constants");
 const sendTransactionWithOptions_1 = __importDefault(require("./utils/sendTransactionWithOptions"));
+const wheel_1 = __importDefault(require("./wheel"));
 class TriadProtocolClient {
     constructor(connection, wallet) {
         this.provider = new anchor_1.AnchorProvider(connection, wallet, {
@@ -28,6 +29,7 @@ class TriadProtocolClient {
         this.program = new anchor_1.Program(idl_triad_protocol_json_1.default, this.provider);
         this.trade = new trade_1.default(this.program, this.provider);
         this.stake = new stake_1.default(this.program, this.provider);
+        this.wheel = new wheel_1.default(this.program, this.provider);
     }
     /**
      * Transfer Poseidon

package/dist/local-test/index.d.ts

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

package/dist/local-test/index.js

@@ -0,0 +1,524 @@
+"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 __1 = __importDefault(require(".."));
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const trade_1 = require("../types/trade");
+const spl_token_1 = require("@solana/spl-token");
+const constants_1 = require("../utils/constants");
+const simulate_market_1 = require("./simulate-market");
+const init_market_1 = require("./init-market");
+const sdk_1 = require("@shadow-drive/sdk");
+const pda_1 = require("../utils/pda");
+const file = fs_1.default.readFileSync('/Users/dannpl/.config/solana/id.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());
+const wallet = new anchor_1.Wallet(keypair);
+const triadProtocol = new __1.default(connection, wallet);
+const marketId = 1001;
+const simulateMarket = new simulate_market_1.SimulateMarket(triadProtocol);
+const initMarket = new init_market_1.InitMarket(triadProtocol);
+const updateStakeVault = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.stake.updateStakeVault({
+        amount: new anchor_1.BN(1000 * Math.pow(10, 6)),
+        isLocked: false
+    });
+    console.log(response);
+});
+const getStakeVault = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.stake.getStakeVaults();
+    console.log(response);
+});
+const getStakeByWallet = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.stake.getStakeByWallet(new web3_js_1.PublicKey('4k8qFA1i7fv6YGWJnoLZPSHj9nhLn3bokAdXWnuAteBV'), 1);
+    let sum = 0;
+    for (const stake of response) {
+        sum += stake.amount / Math.pow(10, 6);
+    }
+    console.log(sum);
+});
+const getAllStakes = () => __awaiter(void 0, void 0, void 0, function* () {
+    const stakes = yield triadProtocol.stake.getStakes();
+    console.log(stakes.length);
+});
+const getStakes = () => __awaiter(void 0, void 0, void 0, function* () {
+    const stakes = yield triadProtocol.stake.getStakes();
+    fs_1.default.writeFileSync('stakes.json', JSON.stringify(stakes, null, 2));
+    const stakesJson = JSON.parse(fs_1.default.readFileSync('stakes.json', 'utf8'));
+    let amountLocked = 0;
+    let amountUnlocked = 0;
+    let uniqueStakersLocked = new Set();
+    let uniqueStakersUnlocked = new Set();
+    let usersUnlocked = [];
+    let usersLocked = [];
+    for (const stake of stakesJson) {
+        if (stake.withdrawTs === 0) {
+            amountLocked += stake.amount / Math.pow(10, 6);
+            uniqueStakersLocked.add(stake.authority);
+            if (!usersLocked.find((user) => user.address === stake.authority)) {
+                usersLocked.push({
+                    address: stake.authority,
+                    amount: stake.amount / Math.pow(10, 6)
+                });
+            }
+            else {
+                const user = usersLocked === null || usersLocked === void 0 ? void 0 : usersLocked.find((user) => user.address === stake.authority);
+                if (user) {
+                    user.amount += stake.amount / Math.pow(10, 6);
+                }
+            }
+        }
+        else {
+            amountUnlocked += stake.amount / Math.pow(10, 6);
+            uniqueStakersUnlocked.add(stake.authority);
+            if (!usersUnlocked.find((user) => user.address === stake.authority)) {
+                usersUnlocked.push({
+                    address: stake.authority,
+                    amount: stake.amount / Math.pow(10, 6)
+                });
+            }
+            else {
+                const user = usersUnlocked.find((user) => user.address === stake.authority);
+                if (user) {
+                    user.amount += stake.amount / Math.pow(10, 6);
+                }
+            }
+        }
+    }
+    const orders = usersLocked.sort((a, b) => b.amount - a.amount);
+    const ordersUnlocked = usersUnlocked.sort((a, b) => b.amount - a.amount);
+    console.log('Amount locked:', amountLocked);
+    console.log('Amount unlocked:', amountUnlocked);
+    console.log('Unique stakers:', uniqueStakersLocked.size);
+    console.log('Unique stakers unlocked:', uniqueStakersUnlocked.size);
+    console.log(JSON.stringify(orders, null, 2));
+    console.log('--------------------------------');
+    console.log(JSON.stringify(ordersUnlocked, null, 2));
+});
+const getAllMarkets = () => __awaiter(void 0, void 0, void 0, function* () {
+    let markets = yield triadProtocol.trade.getAllMarkets();
+    markets = markets.sort((a, b) => Number(a.marketId) - Number(b.marketId));
+    let totalFlopToPay = 0;
+    let totalHypeToPay = 0;
+    let totalLiquidity = 0;
+    let profit = 0;
+    const items = {};
+    for (const market of markets) {
+        if (Number(market.marketId) < 39) {
+            continue;
+        }
+        let liquidity = (Number(market.hypeLiquidity) + Number(market.flopLiquidity)) / Math.pow(10, 6);
+        // liquidity -= Number(market.marketLiquidityAtStart) / 10 ** 6
+        console.log('Market ID:', market.question);
+        console.log('Liquidity:', liquidity);
+        console.log('Hype Shares:', Number(market.hypeShares) / Math.pow(10, 6));
+        console.log('Flop Shares:', Number(market.flopShares) / Math.pow(10, 6));
+        let innerProfit = 0;
+        if (market.winningDirection === trade_1.WinningDirection.HYPE ||
+            Number(market.hypePrice) > Number(market.flopPrice)) {
+            innerProfit += liquidity - Number(market.hypeShares) / Math.pow(10, 6);
+            console.log('Profit:', innerProfit);
+        }
+        if (market.winningDirection === trade_1.WinningDirection.FLOP ||
+            Number(market.hypePrice) < Number(market.flopPrice)) {
+            innerProfit += liquidity - Number(market.flopShares) / Math.pow(10, 6);
+            console.log('Profit:', profit);
+        }
+        totalFlopToPay += Number(market.flopShares) / Math.pow(10, 6);
+        totalHypeToPay += Number(market.hypeShares) / Math.pow(10, 6);
+        totalLiquidity += liquidity;
+        profit += innerProfit;
+        items[market.marketId] = {
+            question: market.question,
+            liquidity: liquidity,
+            hypeShares: Number(market.hypeShares) / Math.pow(10, 6),
+            flopShares: Number(market.flopShares) / Math.pow(10, 6),
+            profit: innerProfit
+        };
+        console.log('--------------------------------');
+    }
+    console.log('Total Liquidity:', totalLiquidity);
+    console.log('Total Hype to Pay:', totalHypeToPay);
+    console.log('Total Flop to Pay:', totalFlopToPay);
+    console.log('Triad Profit:', profit);
+    console.table(items);
+});
+const getMarket = () => __awaiter(void 0, void 0, void 0, function* () {
+    const market = yield triadProtocol.trade.getMarketById(marketId);
+    console.log(market);
+});
+const getOrders = (walletAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = (yield triadProtocol.program.account.userTrade.all()).find((userTrade) => userTrade.account.authority.toBase58() === walletAddress.toBase58());
+    if (!response) {
+        return [];
+    }
+    let orders = [];
+    for (const order of response.account.orders) {
+        console.log(order);
+        if (!order.status.open) {
+            continue;
+        }
+        orders.push({
+            marketId: order.marketId.toNumber(),
+            orderId: order.orderId.toNumber(),
+            totalShares: order.totalShares.toString(),
+            amount: order.totalAmount.toString(),
+            direction: order.direction,
+            questionId: order.questionId,
+            price: order.price.toString(),
+            status: order.status
+        });
+    }
+    console.log(orders);
+    return orders;
+});
+const getAllTraders = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.program.account.userTrade.all();
+    console.log(response);
+});
+const getLiquidityToRecovery = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.program.account.userTrade.all();
+    const allMarkets = yield triadProtocol.trade.getAllMarkets();
+    const liquidityToRecovery = {};
+    for (const market of allMarkets) {
+        let currentMarket = liquidityToRecovery[market.marketId];
+        if (market.marketId === '58') {
+            // market.winningDirection = WinningDirection.FLOP
+        }
+        if (market.winningDirection.toLowerCase() === 'none') {
+            continue;
+        }
+        if (!currentMarket) {
+            currentMarket = {
+                address: market.address,
+                name: market.question,
+                liquidityAvailable: 0,
+                openOrders: 0,
+                amountInPDA: 0,
+                sharesToPay: 0,
+                direction: market.winningDirection.toLowerCase()
+            };
+            liquidityToRecovery[market.marketId] = currentMarket;
+        }
+        const marketLiquidityAtStart = parseFloat(market.marketLiquidityAtStart.toString()) / Math.pow(10, 6);
+        if (currentMarket.direction === 'flop') {
+            currentMarket.liquidityAvailable =
+                parseFloat(market.hypeLiquidity.toString()) / Math.pow(10, 6);
+            currentMarket.liquidityAvailable =
+                currentMarket.liquidityAvailable - marketLiquidityAtStart / 2;
+        }
+        if (currentMarket.direction === 'hype') {
+            currentMarket.liquidityAvailable =
+                parseFloat(market.flopLiquidity.toString()) / Math.pow(10, 6);
+            currentMarket.liquidityAvailable =
+                currentMarket.liquidityAvailable - marketLiquidityAtStart / 2;
+        }
+        const token = yield (0, spl_token_1.getAssociatedTokenAddress)(constants_1.TRD_MINT, new web3_js_1.PublicKey(market.address), true, spl_token_1.TOKEN_2022_PROGRAM_ID);
+        const account = yield (0, spl_token_1.getAccount)(connection, token, 'finalized', spl_token_1.TOKEN_2022_PROGRAM_ID);
+        currentMarket.amountInPDA = Number(account.amount) / Math.pow(10, 6);
+    }
+    for (const userTrade of response) {
+        for (const order of userTrade.account.orders) {
+            const market = liquidityToRecovery[order.marketId.toNumber()];
+            if (!market) {
+                continue;
+            }
+            if (order.status.open &&
+                Object.keys(order.direction)[0] === market.direction) {
+                market.openOrders += 1;
+                const payout = parseFloat(order.totalShares.toString());
+                market.sharesToPay += payout / Math.pow(10, 6);
+            }
+        }
+    }
+    console.log(JSON.stringify(liquidityToRecovery, null, 2));
+    let amountAllowToWithdraw = 0;
+    let amountToPay = 0;
+    let amountInPDA = 0;
+    for (const market of Object.values(liquidityToRecovery)) {
+        amountAllowToWithdraw += market.amountInPDA - market.sharesToPay;
+        amountToPay += market.sharesToPay;
+        amountInPDA += market.amountInPDA;
+    }
+    console.log('Amount allow to withdraw:', amountAllowToWithdraw);
+    console.log('Amount to pay:', amountToPay);
+    console.log('Amount in PDA:', amountInPDA);
+});
+const closeOrders = () => __awaiter(void 0, void 0, void 0, function* () {
+    for (const order of yield getOrders(wallet.publicKey)) {
+        try {
+            const response = yield triadProtocol.trade.closeOrder({
+                marketId: order.marketId,
+                orderId: order.orderId,
+                userNonce: 0
+            });
+            console.log(response);
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+});
+const resolveMarket = () => __awaiter(void 0, void 0, void 0, function* () {
+    const marketsToResolve = [{ marketId: 130, winningDirection: { hype: {} } }];
+    for (const market of marketsToResolve) {
+        const response = yield triadProtocol.trade.resolveMarket({
+            marketId: market.marketId,
+            winningDirection: market.winningDirection
+        });
+        console.log(response);
+    }
+});
+const collectRemainingLiquidityFromAllMarkets = () => __awaiter(void 0, void 0, void 0, function* () {
+    console.log('Collecting fees');
+    const allMarkets = yield triadProtocol.trade.getAllMarkets();
+    for (const market of allMarkets) {
+        console.log(`Collecting fees for market ${market.marketId}`);
+        console.log(market);
+        if (market.openedOrders !== '0') {
+            continue;
+        }
+        try {
+            const response = yield triadProtocol.trade.collectRemainingLiquidity(Number(market.marketId));
+            console.log(response);
+        }
+        catch (_a) { }
+    }
+});
+const burnLP = () => __awaiter(void 0, void 0, void 0, function* () {
+    const SOL_LP = new web3_js_1.PublicKey('8yXmXEQh8M1vyjKKhN6L12EZiXCY3cJS4xL45wwQExep');
+    const getTokenAccount = yield (0, spl_token_1.getAssociatedTokenAddress)(SOL_LP, wallet.publicKey, true);
+    console.log(getTokenAccount);
+    const amount = 191.360098123 * Math.pow(10, 9);
+    const response = yield (0, spl_token_1.burn)(connection, keypair, getTokenAccount, SOL_LP, wallet.publicKey, amount);
+    console.log(response);
+});
+const mintToken = () => __awaiter(void 0, void 0, void 0, function* () {
+    const filekey = fs_1.default.readFileSync('./tCMraBSGHeMcQS76hNnBhnfbMzrtnnT3nbt3vAnSCE2.json');
+    const token = web3_js_1.Keypair.fromSecretKey(new Uint8Array(JSON.parse(filekey.toString())));
+    try {
+        const decimals = 6; // Common decimal places for tokens
+        const amount = 1000000 * Math.pow(10, decimals); // 1,000,000 tokens with decimals
+        // Calculate space needed for mint account including metadata pointer
+        // const mintLen = getMintLen([ExtensionType.MetadataPointer])
+        // const mintTransaction = new Transaction().add(
+        //   // Create mint account
+        //   SystemProgram.createAccount({
+        //     fromPubkey: wallet.publicKey,
+        //     newAccountPubkey: token.publicKey,
+        //     space: mintLen,
+        //     lamports: 6786240,
+        //     programId: TOKEN_2022_PROGRAM_ID
+        //   }),
+        //   createInitializeMetadataPointerInstruction(
+        //     token.publicKey,
+        //     wallet.publicKey,
+        //     token.publicKey,
+        //     TOKEN_2022_PROGRAM_ID
+        //   ),
+        //   createInitializeMintInstruction(
+        //     token.publicKey,
+        //     decimals,
+        //     wallet.publicKey,
+        //     null,
+        //     TOKEN_2022_PROGRAM_ID
+        //   ),
+        //   createInitializeInstruction({
+        //     programId: TOKEN_2022_PROGRAM_ID,
+        //     metadata: token.publicKey,
+        //     updateAuthority: wallet.publicKey,
+        //     mint: token.publicKey,
+        //     mintAuthority: wallet.publicKey,
+        //     name: 'Triad Christmas',
+        //     symbol: 'tCMAS',
+        //     uri: 'https://shdw-drive.genesysgo.net/DRRe9dZkP199W6GLrySn2xj2ayfr8gin8iaBt1YVMN9M/tCMAS.json'
+        //   })
+        // )
+        // const transactionSignature = await sendAndConfirmTransaction(
+        //   connection,
+        //   mintTransaction,
+        //   [keypair, token], // Signers,
+        //   { skipPreflight: false }
+        // )
+        // console.log(
+        //   '\nCreate Mint Account:',
+        //   `https://solana.fm/tx/${transactionSignature}?cluster=devnet-solana`
+        // )
+        // const associatedTokenAccount = await getOrCreateAssociatedTokenAccount(
+        //   connection,
+        //   keypair,
+        //   token.publicKey,
+        //   wallet.publicKey,
+        //   true,
+        //   undefined,
+        //   undefined,
+        //   TOKEN_2022_PROGRAM_ID
+        // )
+        // const mintToResponse = await mintTo(
+        //   connection,
+        //   keypair,
+        //   token.publicKey,
+        //   associatedTokenAccount.address,
+        //   wallet.publicKey,
+        //   amount,
+        //   [keypair, token],
+        //   undefined,
+        //   TOKEN_2022_PROGRAM_ID
+        // )
+        // console.log('Token created:', token.publicKey.toString())
+        // console.log('Associated Token Account:', associatedTokenAccount.toString())
+        // console.log('Mint tx:', mintToResponse)
+    }
+    catch (e) {
+        console.log(e);
+    }
+});
+const updateTokenMetadata = () => __awaiter(void 0, void 0, void 0, function* () {
+    const mintTransaction = new web3_js_1.Transaction().add((0, spl_token_1.createUpdateFieldInstruction)({
+        programId: spl_token_1.TOKEN_2022_PROGRAM_ID,
+        metadata: new web3_js_1.PublicKey('tCMraBSGHeMcQS76hNnBhnfbMzrtnnT3nbt3vAnSCE2'),
+        updateAuthority: wallet.publicKey,
+        field: 'uri',
+        value: 'https://shdw-drive.genesysgo.net/DRRe9dZkP199W6GLrySn2xj2ayfr8gin8iaBt1YVMN9M/tEVENT.json'
+    }));
+    const transactionSignature = yield (0, web3_js_1.sendAndConfirmTransaction)(connection, mintTransaction, [keypair] // Signers,
+    );
+    console.log(transactionSignature);
+});
+const withdrawPoseidon = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.withdrawPoseidon({
+        poseidonAsset: new web3_js_1.PublicKey('DMoyQ6pAj9bGu3WoMcVeYv4rgrU96Xjzyzudfs4fkJw3'),
+        nft: 430
+    });
+    console.log(response);
+});
+const openOrderTriad = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response3 = yield triadProtocol.trade.openOrder({
+        marketId: marketId,
+        amount: 1000,
+        direction: {
+            hype: {}
+        },
+        token: constants_1.TRD_MINT.toBase58()
+    });
+    console.log(response3);
+    yield getMarket();
+});
+const closeOrderTriad = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.trade.closeOrder({
+        marketId: marketId,
+        orderId: 1,
+        userNonce: 8
+    });
+    console.log(response);
+});
+const collectRoyalties = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.collectRoyalty(constants_1.POSEIDON_COLLECTION_SYMBOL, {
+        skipPreflight: false
+    });
+    console.log(response);
+});
+const collectRemainingLiquidity = () => __awaiter(void 0, void 0, void 0, function* () {
+    const markets = [105];
+    for (const market of markets) {
+        const response = yield triadProtocol.trade.collectRemainingLiquidity(market);
+        console.log(response);
+    }
+});
+const allowMarketToPayout = () => __awaiter(void 0, void 0, void 0, function* () {
+    const markets = [130];
+    for (const market of markets) {
+        try {
+            const response = yield triadProtocol.trade.allowMarketToPayout(Number(market));
+            console.log(response);
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+});
+const getUserOrders = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.trade.getUserOrders(wallet.publicKey);
+    const filteredResponse = response.filter((order) => order.marketId === marketId.toString());
+    console.log(response);
+});
+const updateMarket = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.trade.updateMarket(128, 1751327940);
+    console.log(response);
+});
+const getStorage = () => __awaiter(void 0, void 0, void 0, function* () {
+    const drive = yield new sdk_1.ShdwDrive(triadProtocol.provider.connection, triadProtocol.provider.wallet).init();
+    console.log(yield drive.getStorageAccount(new web3_js_1.PublicKey('DRRe9dZkP199W6GLrySn2xj2ayfr8gin8iaBt1YVMN9M')));
+    const jsonFile = {
+        name: `tCMAS.json`,
+        file: fs_1.default.readFileSync(`./src/tCMAS.json`)
+    };
+    const file = yield drive.editFile(new web3_js_1.PublicKey('DRRe9dZkP199W6GLrySn2xj2ayfr8gin8iaBt1YVMN9M'), jsonFile);
+    console.log(file);
+    return file;
+});
+const deployImage = (image) => __awaiter(void 0, void 0, void 0, function* () {
+    const TRIAD_STORAGE_ACCOUNT = new web3_js_1.PublicKey('DRRe9dZkP199W6GLrySn2xj2ayfr8gin8iaBt1YVMN9M');
+    const drive = yield new sdk_1.ShdwDrive(triadProtocol.provider.connection, triadProtocol.provider.wallet).init();
+    const jsonFile = {
+        name: `${image}`,
+        file: fs_1.default.readFileSync(`./src/${image}`)
+    };
+    const file = yield drive.uploadFile(TRIAD_STORAGE_ACCOUNT, jsonFile);
+    console.log(file);
+    return file;
+});
+// 1 - TRD 10k - 10,000 / 1 to 20
+// 2 - TRD 50 - 10,000 / 21 to 2021
+// 3 - TRD 5 - 50,000 / 2022 to 102022
+// 4 - Honeyland NFT - 30 NFT / 102023 to 132023
+// 5 - Poseidon NFT - 20 NFT / 132024 to 152024
+// 6 - SMB 3 - 2 NFT / 152025 to 157025
+// 7 - 500 tridents / 157026 to 657026
+// 8 - 2k tridents / 657027 to 857027
+// 9 - 50 HXD - 10,000 / 857028 to 864008
+// 10 - 0.01 ORE - 10 ORE / 864009 to 924009
+// 11 - TRD 100 - 5,000 / 924010 to 925010
+// 12 - 10 STREAM - 15K STREAM / 925011 to 1000000
+const addWheelPrize = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.wheel.addWheelPrize({
+        prize: 11,
+        amount: 20,
+        rangeMin: 924010,
+        rangeMax: 925010,
+        availableQuantity: 50
+    });
+    console.log(response);
+});
+const getWheel = () => __awaiter(void 0, void 0, void 0, function* () {
+    const [response] = yield triadProtocol.program.account.wheel.all();
+    const prizes = response.account.prizes
+        .filter((prize) => prize.status.claimed)
+        .map((prize) => ({
+        prize: prize.prize.toString(),
+        amount: prize.amount.toString(),
+        rangeMin: prize.rangeMin.toString(),
+        rangeMax: prize.rangeMax.toString(),
+        availableQuantity: prize.availableQuantity.toString()
+    }));
+    console.log(prizes);
+});
+const spinWheel = () => __awaiter(void 0, void 0, void 0, function* () {
+    const spin = (0, pda_1.getWheelPDA)(triadProtocol.program.programId, constants_1.VALENT_SPIN_NAME);
+    console.log(spin);
+});
+spinWheel();

package/dist/local-test/init-market.d.ts

@@ -0,0 +1,8 @@
+import TriadProtocol from '..';
+export declare class InitMarket {
+    private triadProtocol;
+    markets: Partial<any>[];
+    constructor(triadProtocol: TriadProtocol);
+    initializeMarkets: () => Promise<void>;
+    deployImage: (image: string) => Promise<import("@shadow-drive/sdk").ShadowUploadResponse>;
+}

package/dist/local-test/init-market.js

@@ -0,0 +1,63 @@
+"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 });
+exports.InitMarket = void 0;
+const fs_1 = __importDefault(require("fs"));
+const web3_js_1 = require("@solana/web3.js");
+const sdk_1 = require("@shadow-drive/sdk");
+class InitMarket {
+    constructor(triadProtocol) {
+        this.triadProtocol = triadProtocol;
+        this.markets = [
+            {
+                marketId: 1001,
+                question: 'Will PHOTOM flip TRON in 7D revenue by february 15?',
+                startTime: 1239663940,
+                endTime: 1739663940,
+                image: ''
+            }
+        ];
+        this.initializeMarkets = () => __awaiter(this, void 0, void 0, function* () {
+            for (const market of this.markets) {
+                try {
+                    const response = yield this.triadProtocol.trade.initializeMarket({
+                        marketId: market.marketId,
+                        question: market.question,
+                        startTime: market.startTime,
+                        endTime: market.endTime
+                    });
+                    if (market.image) {
+                        yield this.deployImage(market.image);
+                    }
+                    console.log(`Initialized market ${market.question}:`, response);
+                }
+                catch (error) {
+                    console.error(`Error initializing market ${market.question}:`, error);
+                }
+            }
+        });
+        this.deployImage = (image) => __awaiter(this, void 0, void 0, function* () {
+            const TRIAD_STORAGE_ACCOUNT = new web3_js_1.PublicKey('8Tp66VQmgHXQfd8ui2VZHPLZfkKu8mMwywmRsnVfTRBm');
+            const drive = yield new sdk_1.ShdwDrive(this.triadProtocol.provider.connection, this.triadProtocol.provider.wallet).init();
+            const jsonFile = {
+                name: `${image}`,
+                file: fs_1.default.readFileSync(`./src/${image}`)
+            };
+            const file = yield drive.uploadFile(TRIAD_STORAGE_ACCOUNT, jsonFile);
+            console.log(file);
+            return file;
+        });
+    }
+}
+exports.InitMarket = InitMarket;

package/dist/local-test/simulate-market.d.ts

@@ -0,0 +1,54 @@
+import TriadProtocol from '..';
+export declare class SimulateMarket {
+    private triadProtocol;
+    market: {
+        hypePrice: number;
+        flopPrice: number;
+        liquidity: number;
+        hypeLiquidity: number;
+        flopLiquidity: number;
+        hypeShares: number;
+        flopShares: number;
+    };
+    ordersOpen: {
+        id: number;
+        shares: number;
+        amount: number;
+        direction: 'hype' | 'flop';
+        price: number;
+        marketPrice: number;
+    }[];
+    ordersClosed: {
+        id: number;
+        shares: number;
+        amount: number;
+        direction: 'hype' | 'flop';
+        price: number;
+        priceWithImpact: number;
+        payout: number;
+    }[];
+    orders: {
+        amount: number;
+        direction: 'hype' | 'flop';
+    }[];
+    constructor(triadProtocol: TriadProtocol);
+    simulate: () => void;
+    openOrder: (order: {
+        amount: number;
+        direction: 'hype' | 'flop';
+    }) => {
+        shares: number;
+        priceWithImpact: number;
+        marketPrice: number;
+    };
+    closeOrder: (order: {
+        amount: number;
+        shares: number;
+        direction: 'hype' | 'flop';
+    }) => {
+        payout: number;
+        shares: number;
+        price: number;
+        priceWithImpact: number;
+    };
+}