@triadxyz/triad-protocol 1.5.2-beta → 1.5.4-beta

package/dist/index.d.ts

@@ -59,9 +59,9 @@ export default class TriadProtocolClient {
     }, options?: RpcOptions): Promise<string>;
     /**
      * Collect Royalty
-     * @param collection - Collection PublicKey
+     * @param collection - Collection Symbol
      *
      * @param options - RPC options
      */
-    collectRoyalty(collection: PublicKey, options?: RpcOptions): Promise<string>;
+    collectRoyalty(collection: string, options?: RpcOptions): Promise<string>;
 }

package/dist/index.js

@@ -24,7 +24,9 @@ const constants_1 = require("./utils/constants");
 const sendTransactionWithOptions_1 = __importDefault(require("./utils/sendTransactionWithOptions"));
 class TriadProtocolClient {
     constructor(connection, wallet) {
-        this.provider = new anchor_1.AnchorProvider(connection, wallet);
+        this.provider = new anchor_1.AnchorProvider(connection, wallet, {
+            commitment: 'processed'
+        });
         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);
@@ -154,15 +156,16 @@ class TriadProtocolClient {
     }
     /**
      * Collect Royalty
-     * @param collection - Collection PublicKey
+     * @param collection - Collection Symbol
      *
      * @param options - RPC options
      */
     collectRoyalty(collection, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            const collectionPDA = (0, pda_1.getCollectionPDA)(this.program.programId, collection);
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.collectRoyalty().accounts({
                 signer: this.provider.wallet.publicKey,
-                collection
+                collection: collectionPDA
             }), options);
         });
     }

package/dist/local-test.d.ts

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

package/dist/local-test.js

@@ -0,0 +1,619 @@
+"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 sdk_1 = require("@shadow-drive/sdk");
+const spl_token_1 = require("@solana/spl-token");
+const constants_1 = require("./utils/constants");
+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 markets = [
+    {
+        marketId: 90,
+        question: 'Real Madrid',
+        startTime: 1737963756,
+        endTime: 1748131141
+    },
+    {
+        marketId: 91,
+        question: 'Barcelona',
+        startTime: 1737963756,
+        endTime: 1748131141
+    },
+    {
+        marketId: 92,
+        question: 'Atletico Madrid',
+        startTime: 1737963756,
+        endTime: 1748131141
+    }
+];
+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* () {
+    const markets = yield triadProtocol.trade.getAllMarkets();
+    console.log(markets.sort((a, b) => Number(a.marketId) - Number(b.marketId)));
+});
+const getMarket = () => __awaiter(void 0, void 0, void 0, function* () {
+    const market = yield triadProtocol.trade.getMarketById(9);
+    console.log(market);
+});
+const initializeAllMarkets = () => __awaiter(void 0, void 0, void 0, function* () {
+    for (const market of markets) {
+        try {
+            const response = yield triadProtocol.trade.initializeMarket(market, {
+                microLamports: 5000
+            });
+            console.log(`Initialized market ${market.question}:`, response);
+        }
+        catch (error) {
+            console.error(`Error initializing market ${market.question}:`, error);
+        }
+    }
+});
+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) {
+        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 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
+            });
+            console.log(response);
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+});
+const resolveMarket = () => __awaiter(void 0, void 0, void 0, function* () {
+    const marketsToResolve = [{ marketId: 47, winningDirection: { hype: {} } }];
+    for (const market of marketsToResolve) {
+        const response = yield triadProtocol.trade.resolveMarket({
+            marketId: market.marketId,
+            winningDirection: market.winningDirection
+        }, {
+            microLamports: 5000
+        });
+        console.log(response);
+    }
+});
+const addLiquidity = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.trade.addLiquidity({
+        marketId: 5,
+        amount: 4729,
+        direction: {
+            hype: {}
+        }
+    });
+    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}`);
+        if (market.openedOrders !== '0') {
+            continue;
+        }
+        try {
+            const response = yield triadProtocol.trade.collectRemainingLiquidity(Number(market.marketId));
+            console.log(response);
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+});
+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 resolveWithLiquidity = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.trade.resolveMarketWithLiquidity({
+        marketId: 0,
+        winningDirection: { flop: {} },
+        marketToAddLiquidity: { hype: {} },
+        amount: 0
+    });
+    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 removeMintAuthority = () => __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 response = yield (0, spl_token_1.setAuthority)(connection, keypair, token.publicKey, wallet.publicKey, spl_token_1.AuthorityType.MetadataPointer, null, [], undefined, spl_token_1.TOKEN_2022_PROGRAM_ID);
+        console.log('Mint authority removed:', response);
+    }
+    catch (error) {
+        console.error('Error removing mint authority:', error);
+    }
+});
+const getMinteds = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.program.account.collection.all();
+    console.log(response);
+});
+const closeOrder = (market, order) => {
+    let currentLiquidity = 0;
+    let othersideLiquidity = 0;
+    let current_price = 0;
+    if (order.direction === 'hype') {
+        currentLiquidity = market.hypeLiquidity;
+        othersideLiquidity = market.flopLiquidity;
+        current_price = market.hypePrice;
+    }
+    else {
+        currentLiquidity = market.flopLiquidity;
+        othersideLiquidity = market.hypeLiquidity;
+        current_price = market.flopPrice;
+    }
+    const marketLiquidity = currentLiquidity + othersideLiquidity;
+    const shares = order.shares;
+    let payout = shares * current_price;
+    let newDirectionalLiquidity = currentLiquidity - payout;
+    let newMarketLiquidity = marketLiquidity - payout;
+    let price_with_impact = Math.min(Math.max((newDirectionalLiquidity * 1000000) / newMarketLiquidity, 1), 999999);
+    payout = shares * (price_with_impact / 1000000);
+    newDirectionalLiquidity = currentLiquidity - payout;
+    newMarketLiquidity = marketLiquidity - payout;
+    let price = Math.min(Math.max((newDirectionalLiquidity * 1000000) / newMarketLiquidity, 1), 999999);
+    if (order.direction === 'hype') {
+        market.hypePrice = price / 1000000;
+        market.hypeLiquidity = currentLiquidity - payout;
+        market.flopPrice = (1000000 - price) / 1000000;
+        market.hypeShares -= shares;
+    }
+    else {
+        market.flopPrice = price / 1000000;
+        market.flopLiquidity = currentLiquidity - payout;
+        market.hypePrice = (1000000 - price) / 1000000;
+        market.flopShares -= shares;
+    }
+    market.liquidity = newMarketLiquidity;
+    return {
+        payout,
+        shares,
+        price: price / 1000000,
+        priceWithImpact: price_with_impact / 1000000,
+        market
+    };
+};
+const openOrder = (market, order) => {
+    let currentLiquidity = 0;
+    let othersideLiquidity = 0;
+    if (order.direction === 'hype') {
+        currentLiquidity = market.hypeLiquidity;
+        othersideLiquidity = market.flopLiquidity;
+    }
+    else {
+        currentLiquidity = market.flopLiquidity;
+        othersideLiquidity = market.hypeLiquidity;
+    }
+    const newDirectionalLiquidity = currentLiquidity + order.amount;
+    const marketsLiquidity = newDirectionalLiquidity + othersideLiquidity;
+    let newPrice = (newDirectionalLiquidity * 1000000) / marketsLiquidity;
+    if (newPrice > 999999) {
+        newPrice = 999999;
+    }
+    if (newPrice < 1) {
+        newPrice = 1;
+    }
+    const netAmount = order.amount * 1000000;
+    const max_shares = netAmount / newPrice;
+    let shares = max_shares;
+    let improved_shares = market.hypeShares + max_shares;
+    const maxValue = improved_shares > market.flopShares ? improved_shares : market.flopShares;
+    let correction_factor = marketsLiquidity / maxValue;
+    if (order.direction === 'flop') {
+        improved_shares = market.flopShares + max_shares;
+        const maxValue = market.hypeShares > improved_shares ? market.hypeShares : improved_shares;
+        correction_factor = marketsLiquidity / maxValue;
+    }
+    if (correction_factor > 1) {
+        correction_factor = 1;
+    }
+    if (correction_factor < 1) {
+        shares = max_shares + (marketsLiquidity - improved_shares);
+    }
+    if (order.direction === 'hype') {
+        market.hypePrice = newPrice / 1000000;
+        market.hypeLiquidity = newDirectionalLiquidity;
+        market.flopPrice = (1000000 - newPrice) / 1000000;
+        market.hypeShares += shares;
+    }
+    if (order.direction === 'flop') {
+        market.flopPrice = newPrice / 1000000;
+        market.flopLiquidity = newDirectionalLiquidity;
+        market.hypePrice = (1000000 - newPrice) / 1000000;
+        market.flopShares += shares;
+    }
+    market.liquidity = marketsLiquidity;
+    return { market, shares, priceWithImpact: newPrice / 1000000 };
+};
+let i = 0;
+const simulateMarket = () => {
+    const market = {
+        hypePrice: 0.5,
+        flopPrice: 0.5,
+        liquidity: 0,
+        hypeLiquidity: 500,
+        flopLiquidity: 500,
+        hypeShares: 0,
+        flopShares: 0
+    };
+    const orders = [
+        {
+            amount: 10,
+            direction: 'hype'
+        },
+        {
+            amount: 1000,
+            direction: 'flop'
+        }
+    ];
+    let ordersOpen = [];
+    for (const order of orders) {
+        const result = openOrder(market, order);
+        ordersOpen.push({
+            id: ordersOpen.length + 1,
+            shares: result.shares,
+            amount: order.amount,
+            direction: order.direction,
+            price: result.priceWithImpact
+        });
+        market.hypePrice = result.market.hypePrice;
+        market.flopPrice = result.market.flopPrice;
+        market.liquidity = result.market.liquidity;
+        market.hypeLiquidity = result.market.hypeLiquidity;
+        market.flopLiquidity = result.market.flopLiquidity;
+        market.hypeShares = result.market.hypeShares;
+        market.flopShares = result.market.flopShares;
+    }
+    console.table(ordersOpen);
+    console.log(market);
+    let ordersClosed = [];
+    // for (const order of ordersOpen) {
+    //   const result = closeOrder(market, order)
+    //   ordersClosed.push({
+    //     id: order.id,
+    //     shares: result.shares,
+    //     amount: order.amount,
+    //     direction: order.direction,
+    //     price: result.price,
+    //     priceWithImpact: result.priceWithImpact,
+    //     payout: result.payout
+    //   })
+    //   ordersOpen = ordersOpen.filter((o) => o.id !== order.id)
+    //   market.hypePrice = result.market.hypePrice
+    //   market.flopPrice = result.market.flopPrice
+    //   market.liquidity = result.market.liquidity
+    //   market.hypeLiquidity = result.market.hypeLiquidity
+    //   market.flopLiquidity = result.market.flopLiquidity
+    //   market.hypeShares = result.market.hypeShares
+    //   market.flopShares = result.market.flopShares
+    // }
+    // console.table(ordersClosed)
+    // console.log(market)
+};
+const withdrawPoseidon = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.withdrawPoseidon({
+        poseidonAsset: new web3_js_1.PublicKey('9PJNHY7CztR6jGdFW9XtCUfBjhrrVD99d4UpQEoDfd9F'),
+        nft: 531
+    });
+    console.log(response);
+});
+const openOrderTriad = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.trade.openOrder({
+        marketId: 42,
+        amount: 10,
+        direction: {
+            hype: {}
+        },
+        token: constants_1.TRD_MINT.toBase58()
+    }, {
+        skipPreflight: true
+    });
+    console.log(response);
+});
+const collectRoyalties = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.collectRoyalty(constants_1.TICKET_COLLECTION_SYMBOL, {
+        skipPreflight: true
+    });
+    console.log(response);
+});
+const collectRemainingLiquidity = () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.trade.collectRemainingLiquidity(8);
+    console.log(response);
+});
+const createShadowDrive = () => __awaiter(void 0, void 0, void 0, function* () {
+    const TRIAD_STORAGE_ACCOUNT = new web3_js_1.PublicKey('8Tp66VQmgHXQfd8ui2VZHPLZfkKu8mMwywmRsnVfTRBm');
+    const drive = yield new sdk_1.ShdwDrive(connection, wallet).init();
+    const images = [];
+    for (const image of images) {
+        const jsonFile = {
+            name: `${image}`,
+            file: fs_1.default.readFileSync(`./src/${image}`)
+        };
+        const file = yield drive.uploadFile(TRIAD_STORAGE_ACCOUNT, jsonFile);
+        console.log(file);
+    }
+});
+const allowToPayout = () => __awaiter(void 0, void 0, void 0, function* () {
+    const markets = yield triadProtocol.trade.getAllMarkets();
+    for (const market of markets) {
+        try {
+            const response = yield triadProtocol.trade.allowMarketPayout(Number(market.marketId));
+            console.log(response);
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+});

package/dist/trade.js

@@ -30,13 +30,8 @@ class Trade {
      */
     getAllMarkets() {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketV1 = yield this.program.account.market
-                .all()
-                .then((markets) => markets.map(({ account, publicKey }) => (0, helpers_1.accountToMarketV1)(account, publicKey)));
-            const marketV2 = yield this.program.account.marketV2
-                .all()
-                .then((markets) => markets.map(({ account, publicKey }) => (0, helpers_1.formatMarket)(account, publicKey)));
-            return [...marketV1, ...marketV2];
+            const marketV2 = yield this.program.account.marketV2.all();
+            return marketV2.map(({ account, publicKey }) => (0, helpers_1.formatMarket)(account, publicKey));
         });
     }
     /**

package/dist/types/idl_triad_protocol.json

@@ -240,6 +240,11 @@
                     "writable": true,
                     "signer": true
                 },
+                {
+                    "name": "squads",
+                    "writable": true,
+                    "address": "6fcSf6qfwPNR9AUUNC1UWYZDy5cQ4TzTb2aaipN2zFdq"
+                },
                 {
                     "name": "user_trade",
                     "writable": true

package/dist/types/triad_protocol.d.ts

@@ -362,6 +362,11 @@ export type TriadProtocol = {
                     writable: true;
                     signer: true;
                 },
+                {
+                    name: 'squads';
+                    writable: true;
+                    address: '6fcSf6qfwPNR9AUUNC1UWYZDy5cQ4TzTb2aaipN2zFdq';
+                },
                 {
                     name: 'userTrade';
                     writable: true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triadxyz/triad-protocol",
-  "version": "1.5.2-beta",
+  "version": "1.5.4-beta",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -32,6 +32,7 @@
   "license": "ISC",
   "dependencies": {
     "@coral-xyz/anchor": "0.30.1",
+    "@shadow-drive/sdk": "^6.0.0",
     "@solana/spl-token": "0.4.8",
     "@solana/web3.js": "^1.95.3",
     "axios": "^1.5.1",