@triadxyz/triad-protocol 1.7.0-beta → 1.7.1-beta

package/dist/index.js

@@ -24,7 +24,7 @@ const trade_2 = require("./utils/pda/trade");
 class TriadProtocolClient {
     constructor(connection, wallet) {
         this.provider = new anchor_1.AnchorProvider(connection, wallet, {
-            commitment: 'processed'
+            commitment: 'confirmed'
         });
         this.program = new anchor_1.Program(idl_triad_protocol_json_1.default, this.provider);
         this.trade = new trade_1.default(this.program, this.provider);

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

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

package/dist/local-test/index.js

@@ -0,0 +1,418 @@
+"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 anchor_2 = 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");
+// import { InitMarket } from './init-market'
+const sdk_1 = require("@shadow-drive/sdk");
+const init_market_1 = require("./init-market");
+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 = 133;
+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_2.BN(200 * 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('Fua99qprDG3YGijFDoGfWPnUjBqufgPPQgJTZEGKHFFL'), 1);
+    let sum = 0;
+    for (const stake of response) {
+        sum += stake.amount / Math.pow(10, 6);
+    }
+    console.log(sum);
+});
+getStakeByWallet();
+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);
+            const existingUser = usersLocked.find((user) => user.address === stake.authority);
+            if (!existingUser) {
+                usersLocked.push({
+                    address: stake.authority,
+                    amount: stake.amount / Math.pow(10, 6)
+                });
+            }
+            else {
+                existingUser.amount += stake.amount / Math.pow(10, 6);
+            }
+        }
+        else {
+            amountUnlocked += stake.amount / Math.pow(10, 6);
+            uniqueStakersUnlocked.add(stake.authority);
+            const existingUser = usersUnlocked.find((user) => user.address === stake.authority);
+            if (!existingUser) {
+                usersUnlocked.push({
+                    address: stake.authority,
+                    amount: stake.amount / Math.pow(10, 6)
+                });
+            }
+            else {
+                existingUser.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 ||
+            market.winningDirection !== trade_1.WinningDirection.NONE) {
+            continue;
+        }
+        let liquidity = (Number(market.hypeLiquidity) + Number(market.flopLiquidity)) /
+            Math.pow(10, 6);
+        liquidity = liquidity - Number(market.marketLiquidityAtStart) / Math.pow(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 (Number(market.hypePrice) > Number(market.flopPrice)) {
+            innerProfit += liquidity - Number(market.hypeShares) / Math.pow(10, 6);
+            console.log('Profit:', innerProfit);
+        }
+        if (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.toString(),
+            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 liquidityAtStart = 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 - liquidityAtStart / 2;
+        }
+        if (currentMarket.direction === 'hype') {
+            currentMarket.liquidityAvailable =
+                parseFloat(market.flopLiquidity.toString()) / Math.pow(10, 6);
+            currentMarket.liquidityAvailable =
+                currentMarket.liquidityAvailable - liquidityAtStart / 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);
+});
+// Order functions
+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: 163, winningDirection: { flop: {} } },
+        { marketId: 164, winningDirection: { flop: {} } },
+        { marketId: 165, winningDirection: { flop: {} } } // Atletico Madrid
+    ];
+    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 (_) { }
+    }
+});
+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
+        // Token creation code is commented out in the original
+        // Keeping it commented out here as well
+    }
+    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 = [34];
+    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 = [163, 164, 165];
+    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;
+});

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

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

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

@@ -0,0 +1,58 @@
+"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.markets = [];
+        this.initializeMarkets = () => __awaiter(this, void 0, void 0, function* () {
+            for (const market of this.markets) {
+                try {
+                    const response = yield this.triadProtocol.trade.createMarket({
+                        marketId: market.marketId,
+                        question: market.question,
+                        startTime: market.startTime,
+                        endTime: market.endTime,
+                        feeBps: 0,
+                        customer: null,
+                        liquidityAtStart: 12000
+                    });
+                    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;
+        });
+        this.triadProtocol = triadProtocol;
+    }
+}
+exports.InitMarket = InitMarket;

package/dist/local-test/order-book.d.ts

@@ -0,0 +1,9 @@
+export declare class OrderBook {
+    private bids;
+    private asks;
+    constructor();
+    addBid(price: number, quantity: number): void;
+    addAsk(price: number, quantity: number): void;
+    matchOrders(): void;
+    printOrderBook(): void;
+}

package/dist/local-test/order-book.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderBook = void 0;
+class OrderBook {
+    constructor() {
+        this.bids = [];
+        this.asks = [];
+        this.bids = []; // Lista de compras (bids)
+        this.asks = []; // Lista de vendas (asks)
+    }
+    addBid(price, quantity) {
+        this.bids.push({ price, quantity });
+        this.bids.sort((a, b) => b.price - a.price);
+        this.matchOrders();
+    }
+    addAsk(price, quantity) {
+        this.asks.push({ price, quantity });
+        this.asks.sort((a, b) => a.price - b.price);
+        this.matchOrders();
+    }
+    matchOrders() {
+        while (this.bids.length > 0 && this.asks.length > 0) {
+            let highestBid = this.bids[0];
+            let lowestAsk = this.asks[0];
+            if (highestBid.price >= lowestAsk.price) {
+                let tradeQuantity = Math.min(highestBid.quantity, lowestAsk.quantity);
+                console.log(`🔥 Trade Executado: ${tradeQuantity} unidades a ${lowestAsk.price}`);
+                highestBid.quantity -= tradeQuantity;
+                lowestAsk.quantity -= tradeQuantity;
+                if (highestBid.quantity === 0)
+                    this.bids.shift();
+                if (lowestAsk.quantity === 0)
+                    this.asks.shift();
+            }
+            else {
+                break;
+            }
+        }
+    }
+    printOrderBook() {
+        console.log('\n📊 ORDER BOOK:');
+        console.log('BIDS (Compradores):', this.bids);
+        console.log('ASKS (Vendedores):', this.asks);
+    }
+}
+exports.OrderBook = OrderBook;

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

@@ -0,0 +1,5 @@
+import TriadProtocol from '..';
+export declare class SimulateMarket {
+    private triadProtocol;
+    constructor(triadProtocol: TriadProtocol);
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulateMarket = void 0;
+class SimulateMarket {
+    constructor(triadProtocol) {
+        this.triadProtocol = triadProtocol;
+    }
+}
+exports.SimulateMarket = SimulateMarket;

package/dist/stake.js

@@ -51,14 +51,8 @@ class Stake {
      */
     getUserStakes(wallet) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.program.account.stakeV2.all([
-                {
-                    memcmp: {
-                        offset: 8 + 1,
-                        bytes: wallet.toBase58()
-                    }
-                }
-            ]);
+            const stakes = yield this.program.account.stakeV2.all();
+            const response = stakes.filter((stake) => stake.account.authority.toBase58() === wallet.toBase58());
             return response.map((stake) => (0, helpers_1.formatStake)(stake.account));
         });
     }

package/dist/trade.d.ts

@@ -130,7 +130,7 @@ export default class Trade {
      * @param options - RPC options
      *
      */
-    createMarket({ marketId, startTime, endTime, question, feeBps, customer }: CreateMarketArgs, options?: RpcOptions): Promise<string>;
+    createMarket({ marketId, startTime, endTime, question, feeBps, customer, liquidityAtStart }: CreateMarketArgs, options?: RpcOptions): Promise<string>;
     /**
      * Get User Trade Nonce With Slots
      * @param userTrades - User Trades

package/dist/trade.js

@@ -114,7 +114,7 @@ class Trade {
      * @param options - RPC options
      *
      */
-    createMarket({ marketId, startTime, endTime, question, feeBps, customer }, options) {
+    createMarket({ marketId, startTime, endTime, question, feeBps, customer, liquidityAtStart }, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (question.length > 80) {
                 throw new Error('Question must be less than 80 characters');
@@ -125,6 +125,7 @@ class Trade {
                 question: (0, helpers_1.encodeString)(question, 80),
                 marketStart: new bn_js_1.default(startTime),
                 marketEnd: new bn_js_1.default(endTime),
+                liquidityAtStart: new bn_js_1.default(liquidityAtStart * Math.pow(10, constants_1.TRD_DECIMALS)),
                 feeBps
             })
                 .accounts({

package/dist/types/idl_triad_protocol.json

@@ -1706,6 +1706,10 @@
                     {
                         "name": "fee_bps",
                         "type": "u8"
+                    },
+                    {
+                        "name": "liquidity_at_start",
+                        "type": "u64"
                     }
                 ]
             }

package/dist/types/trade.d.ts

@@ -86,6 +86,7 @@ export type CreateMarketArgs = {
     question: string;
     feeBps: number;
     customer: PublicKey;
+    liquidityAtStart: number;
 };
 export type CreateCustomerArgs = {
     id: number;

package/dist/types/triad_protocol.d.ts

@@ -2205,6 +2205,10 @@ export type TriadProtocol = {
                     {
                         name: 'feeBps';
                         type: 'u8';
+                    },
+                    {
+                        name: 'liquidityAtStart';
+                        type: 'u64';
                     }
                 ];
             };

package/package.json

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