@triadxyz/triad-protocol 1.2.0-beta → 1.2.2-beta

package/dist/local-test.js

@@ -17,80 +17,97 @@ const _1 = __importDefault(require("./"));
 const anchor_1 = require("@coral-xyz/anchor");
 const axios_1 = __importDefault(require("axios"));
 const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
 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(), 'confirmed');
+const connection = new web3_js_1.Connection('https://mainnet.helius-rpc.com/?api-key=428d811e-ba57-4def-8876-de95d53b7c9d');
 const wallet = new anchor_1.Wallet(keypair);
 const triadProtocol = new _1.default(connection, wallet);
+const mint = new web3_js_1.PublicKey('X41iRJUPkKaEvhqWdxqrS5P7M5d8A9oathki5sT47KR');
 const markets = [
-// { name: 'Triad', marketId: 0 },
-// { name: 'PYTH', marketId: 1 },
-// { name: 'DRIFT', marketId: 2 },
-// { name: 'SYMMETRY', marketId: 3 },
-// { name: 'ORE', marketId: 4 },
-// { name: 'COLETA', marketId: 5 },
-// { name: 'UNDEADS', marketId: 6 }
+    // { name: 'Triad', marketId: 0 },
+    // { name: 'PYTH', marketId: 1 }
+    // { name: 'DRIFT', marketId: 2 }
+    // { name: 'SYMMETRY', marketId: 3 }
+    // { name: 'ORE', marketId: 4 }
+    // { name: 'COLETA', marketId: 5 }
+    // { name: 'UNDEADS', marketId: 6 },
+    // { name: 'SOL x ETH', marketId: 7 }
+    // { name: 'SOL vs ETH', marketId: 8 }
+    { name: 'SOL vs ETH 2', marketId: 9 }
+    // { name: 'PYTH x LINK', marketId: 8 },
+    // { name: 'SOL PRICE', marketId: 9 }
 ];
 const questions = [
     {
         name: 'Pyth',
         marketId: 1,
-        question: "$PYTH's market cap exceed $1.5B by the end of October?",
-        startTime: 1728415578,
-        endTime: 1730394000
-    },
-    {
-        name: 'Drift',
-        marketId: 2,
-        question: 'Drift surpass $33M in volume on prediction markets by the end of October?',
-        startTime: 1728415578,
-        endTime: 1730394000
-    },
-    {
-        name: 'Symmetry',
-        marketId: 3,
-        question: "Symmetry's TVL exceed $5.5M by the end of October?",
-        startTime: 1728415578,
-        endTime: 1730394000
-    },
-    {
-        name: 'Ore',
-        marketId: 4,
-        question: 'ORE surpass 20k on-chain miners by the end of October?',
-        startTime: 1728415578,
-        endTime: 1730394000
-    },
-    {
-        name: 'Coleta',
-        marketId: 5,
-        question: 'COLETA PFP reach 500 SOL in total volume by the end of October (based on Tensor)?',
-        startTime: 1728415578,
-        endTime: 1730394000
-    },
-    {
-        name: 'Undeads',
-        marketId: 6,
-        question: 'The Undeads reach more than 1,600 holders by the end of October?',
-        startTime: 1728415578,
+        question: 'test 2',
+        startTime: 1719513866,
         endTime: 1730394000
     }
+    // },
+    // {
+    //   name: 'Pyth',
+    //   marketId: 1,
+    //   question: "$PYTH's market cap exceed $1.5B by the end of October?",
+    //   startTime: 1728415578,
+    //   endTime: 1730394000
+    // },
+    // {
+    //   name: 'Drift',
+    //   marketId: 2,
+    //   question:
+    //     'Drift surpass $33M in volume on prediction markets by the end of October?',
+    //   startTime: 1728415578,
+    //   endTime: 1730394000
+    // },
+    // {
+    //   name: 'Symmetry',
+    //   marketId: 3,
+    //   question: "Symmetry's TVL exceed $5.5M by the end of October?",
+    //   startTime: 1728415578,
+    //   endTime: 1730394000
+    // },
+    // {
+    //   name: 'Ore',
+    //   marketId: 4,
+    //   question: 'ORE surpass 20k on-chain miners by the end of October?',
+    //   startTime: 1728415578,
+    //   endTime: 1730394000
+    // },
+    // {
+    //   name: 'Coleta',
+    //   marketId: 5,
+    //   question:
+    //     'COLETA PFP reach 500 SOL in total volume by the end of October (based on Tensor)?',
+    //   startTime: 1728415578,
+    //   endTime: 1730394000
+    // },
+    // {
+    //   name: 'Undeads',
+    //   marketId: 6,
+    //   question:
+    //     'The Undeads reach more than 1,600 holders by the end of October?',
+    //   startTime: 1728415578,
+    //   endTime: 1730394000
+    // }
 ];
 const ordersHypeAndFloopBot = [
     {
-        marketId: 0,
-        amount: 0.001,
+        marketId: 7,
+        amount: 5000,
         direction: {
             flop: {}
-        },
-        orderType: {
-            market: {}
         }
     }
 ];
 const updateStakeVault = () => __awaiter(void 0, void 0, void 0, function* () {
     const response = yield triadProtocol.stake.updateStakeVault({
-        wallet: wallet.publicKey
+        wallet: wallet.publicKey,
+        amount: new anchor_1.BN(5000 * Math.pow(10, 6)),
+        isLocked: false
     });
     console.log(response);
 });
@@ -98,16 +115,8 @@ const getStakeVault = () => __awaiter(void 0, void 0, void 0, function* () {
     const response = yield triadProtocol.stake.getStakeVaults();
     console.log(response);
 });
-const updateStakeVaultStatus = () => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield triadProtocol.stake.updateStakeVault({
-        wallet: wallet.publicKey,
-        amount: new anchor_1.BN(0),
-        status: false
-    });
-    console.log(response);
-});
 const updateBoost = () => __awaiter(void 0, void 0, void 0, function* () {
-    const response = (yield axios_1.default.get('https://api.triadfi.co/boost'))
+    const response = (yield axios_1.default.get('http://localhost:8080/boost'))
         .data;
     const stakes = yield triadProtocol.stake.getStakes();
     const update = [];
@@ -130,78 +139,208 @@ const getAllMarkets = () => __awaiter(void 0, void 0, void 0, function* () {
     const markets = yield triadProtocol.trade.getAllMarkets();
     console.log(markets);
 });
-getAllMarkets();
 const getMarket = () => __awaiter(void 0, void 0, void 0, function* () {
-    const market = yield triadProtocol.trade.getMarketById(2);
+    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, {
-                skipPreflight: true
-            });
-            console.log(`Initialized market ${market.name}:`, response);
-        }
-        catch (error) {
-            console.error(`Error initializing market ${market.name}:`, 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());
-    console.log(response.account);
-});
-// const openOrder = async () => {
-//   for (const order of ordersHypeAndFloopBot) {
-//     const response = await triadProtocol.trade.openOrder(
-//       {
-//         marketId: 0,
-//         amount: order.amount,
-//         direction: order.direction as any,
-//         token: 'So11111111111111111111111111111111111111112',
-//         comment: `hype/flop bot ${order.amount} - ${order.direction}`
-//       },
-//       {
-//         skipPreflight: true
-//       }
-//     )
-//     console.log(response)
-//   }
-// }
-// const closeOrder = async () => {
-//   for (const order of await getOrders()) {
+// const initializeAllMarkets = async () => {
+//   for (const market of markets) {
 //     try {
-//       const response = await triadProtocol.trade.closeOrder({
-//         marketId: 1,
-//         orderId: order
+//       const response = await triadProtocol.trade.initializeMarket(market, {
+//         skipPreflight: false,
+//         microLamports: 5000
 //       })
-//       console.log(response)
-//     } catch (e) {
-//       console.log('Error closing order')
+//       console.log(`Initialized market ${market.name}:`, response)
+//     } catch (error) {
+//       console.error(`Error initializing market ${market.name}:`, error)
 //     }
 //   }
 // }
-// const runBot = async () => {
-//   while (true) {
-//     const hasOpenOrders = (await getOrders()).find((order) => order !== 0)
-//     if (hasOpenOrders) {
-//       await closeOrder()
-//     }
-//     await openOrder()
-//     await new Promise((resolve) => setTimeout(resolve, 40000))
-//   }
-// }
-const initializeQuestion = () => __awaiter(void 0, void 0, void 0, function* () {
-    for (const question of questions) {
+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());
+    let orders = [];
+    for (const order of response.account.orders) {
+        if (!order.status.open) {
+            continue;
+        }
+        orders.push({
+            marketId: order.marketId,
+            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;
+});
+// getOrders(new PublicKey('HjJQdfTHgC3EBX3471w4st8BXbBmtbaMyCAXNgcUb7dq'))
+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 = {
+        0: {
+            name: 'triad',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                flop: {}
+            }
+        },
+        1: {
+            name: 'pyth',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                flop: {}
+            }
+        },
+        2: {
+            name: 'drift',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                flop: {}
+            }
+        },
+        3: {
+            name: 'symmetry',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                flop: {}
+            }
+        },
+        4: {
+            name: 'ore',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                hype: {}
+            }
+        },
+        5: {
+            name: 'coleta',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                flop: {}
+            }
+        },
+        6: {
+            name: 'undead',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                hype: {}
+            }
+        },
+        7: {
+            name: 'solxeth',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                flop: {}
+            }
+        },
+        8: {
+            name: 'solxeth2',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                flop: {}
+            }
+        },
+        9: {
+            name: 'solxeth3',
+            liquidityToPay: 0,
+            sharesToPay: 0,
+            openOrders: 0,
+            medPrice: 0,
+            direction: {
+                flop: {}
+            }
+        }
+    };
+    for (const market of allMarkets) {
+        let currentMarket = liquidityToRecovery[market.marketId];
+        if ('flop' in currentMarket.direction) {
+            let shares = parseFloat(market.flopShares.toString()) / Math.pow(10, 6);
+            currentMarket.medPrice =
+                parseFloat(market.hypeLiquidity.toString()) / Math.pow(10, 6) / shares;
+            currentMarket.sharesToPay = shares;
+            currentMarket.liquidityToPay =
+                parseFloat(market.hypeLiquidity.toString()) / Math.pow(10, 6);
+        }
+        else {
+            let shares = parseFloat(market.hypeShares.toString()) / Math.pow(10, 6);
+            currentMarket.medPrice =
+                parseFloat(market.flopLiquidity.toString()) / Math.pow(10, 6) / shares;
+            currentMarket.sharesToPay = shares;
+            currentMarket.liquidityToPay =
+                parseFloat(market.flopLiquidity.toString()) / Math.pow(10, 6);
+        }
+    }
+    for (const userTrade of response) {
+        for (const order of userTrade.account.orders) {
+            const market = liquidityToRecovery[order.marketId.toNumber()];
+            if (Object.keys(order.direction)[0] === Object.keys(market.direction)[0]) {
+                market.openOrders += 1;
+            }
+        }
+    }
+    console.log(liquidityToRecovery);
+});
+getLiquidityToRecovery();
+const openOrder = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield getMarket();
+    for (const order of ordersHypeAndFloopBot) {
+        const response = yield triadProtocol.trade.openOrder({
+            marketId: order.marketId,
+            amount: order.amount,
+            direction: order.direction,
+            token: mint.toBase58(),
+            comment: `hype/flop bot ${order.amount} - ${order.direction}`
+        });
+        console.log(response);
+    }
+    yield new Promise((resolve) => setTimeout(resolve, 50000));
+    getMarket();
+});
+const closeOrder = (orderId) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield triadProtocol.trade.closeOrder({
+        marketId: 7,
+        orderId: orderId
+    });
+    console.log(response);
+});
+const closeOrders = () => __awaiter(void 0, void 0, void 0, function* () {
+    for (const order of yield getOrders(wallet.publicKey)) {
         try {
-            const response = yield triadProtocol.trade.initializeQuestion({
-                marketId: question.marketId,
-                question: question.question,
-                startTime: question.startTime,
-                endTime: question.endTime
-            }, {
-                skipPreflight: true
+            const response = yield triadProtocol.trade.closeOrder({
+                marketId: order.marketId,
+                orderId: order.orderId
             });
             console.log(response);
         }
@@ -210,11 +349,65 @@ const initializeQuestion = () => __awaiter(void 0, void 0, void 0, function* ()
         }
     }
 });
-const resolveQuestion = () => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield triadProtocol.trade.resolveQuestion(0);
-    console.log(response);
+const mintTokens = () => __awaiter(void 0, void 0, void 0, function* () {
+    // const mint = await createMint(
+    //   connection,
+    //   keypair,
+    //   keypair.publicKey,
+    //   null,
+    //   6,
+    //   undefined,
+    //   undefined,
+    //   TOKEN_2022_PROGRAM_ID
+    // )
+    // console.log(mint)
+    const ataAddress = yield (0, spl_token_1.getAssociatedTokenAddress)(keypair.publicKey, mint);
+    console.log(ataAddress);
+    const ata = yield (0, spl_token_1.createAssociatedTokenAccount)(connection, keypair, mint, keypair.publicKey, undefined, spl_token_1.TOKEN_2022_PROGRAM_ID);
+    const mintTx = yield (0, spl_token_1.mintTo)(connection, keypair, mint, ata, keypair, 1000000 * Math.pow(10, 6), [keypair], undefined, spl_token_1.TOKEN_2022_PROGRAM_ID);
+    console.log(mintTx);
 });
-const getReferral = () => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield triadProtocol.getReferral('dannpl');
+const resolveMarket = () => __awaiter(void 0, void 0, void 0, function* () {
+    const marketsToResolve = [
+        { marketId: 8, winningDirection: { flop: {} } },
+        { marketId: 9, winningDirection: { flop: {} } }
+    ];
+    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 collectFees = () => __awaiter(void 0, void 0, void 0, function* () {
+    console.log('Collecting fees');
+    const allMarkets = yield triadProtocol.trade.getAllMarkets();
+    for (const market of allMarkets) {
+        if (Number(market.marketId) === 0 || Number(market.marketId) === 7) {
+            continue;
+        }
+        console.log(`Collecting fees for market ${market.marketId}`);
+        try {
+            const response = yield triadProtocol.trade.collectFee({
+                marketId: Number(market.marketId)
+            });
+            console.log(response);
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+});

package/dist/stake.d.ts

@@ -54,10 +54,10 @@ export default class Stake {
      *  Update Stake Vault
      *  @param wallet - User wallet
      *  @param amount - Reward amount to deposit (optional)
-     *  @param status - Status of the stake vault (optional)
+     *  @param isLocked - is locked stake vault (optional)
      *
      */
-    updateStakeVault({ wallet, amount, status }: UpdateStakeVaultArgs, options?: RpcOptions): Promise<any>;
+    updateStakeVault({ wallet, amount, isLocked }: UpdateStakeVaultArgs, options?: RpcOptions): Promise<any>;
     /**
      *  Request Withdraw
      *  @param wallet - User wallet

package/dist/stake.js

@@ -166,15 +166,15 @@ class Stake {
      *  Update Stake Vault
      *  @param wallet - User wallet
      *  @param amount - Reward amount to deposit (optional)
-     *  @param status - Status of the stake vault (optional)
+     *  @param isLocked - is locked stake vault (optional)
      *
      */
-    updateStakeVault({ wallet, amount, status }, options) {
+    updateStakeVault({ wallet, amount, isLocked }, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return (0, sendTransactionWithOptions_1.default)(this.program.methods
                 .updateStakeVault({
                 amount,
-                status,
+                isLocked,
                 stakeVault: this.stakeVaultName
             })
                 .accounts({

package/dist/trade.d.ts

@@ -1,7 +1,7 @@
 import { AnchorProvider, Program } from '@coral-xyz/anchor';
 import { TriadProtocol } from './types/triad_protocol';
 import { PublicKey } from '@solana/web3.js';
-import { FeeVault, InitializeQuestionArgs, Market, OpenOrderArgs } from './types/trade';
+import { InitializeMarketArgs, Market, OpenOrderArgs, OrderDirection } from './types/trade';
 import { RpcOptions } from './types';
 import BN from 'bn.js';
 export default class Trade {
@@ -13,7 +13,6 @@ export default class Trade {
      * Get all Markets
      */
     getAllMarkets(): Promise<Market[]>;
-    getFeeVault(marketId: number): Promise<FeeVault>;
     /**
      * Get Market by ID
      * @param marketId - The ID of the market
@@ -111,10 +110,7 @@ export default class Trade {
      * @param options - RPC options
      *
      */
-    initializeMarket({ marketId, name }: {
-        marketId: number;
-        name: string;
-    }, options?: RpcOptions): Promise<any>;
+    initializeMarket({ marketId, name, startTime, endTime, question }: InitializeMarketArgs, options?: RpcOptions): Promise<any>;
     /**
      * Open Order
      * @param marketId - The ID of the market
@@ -140,34 +136,57 @@ export default class Trade {
         orderId: number;
     }, options?: RpcOptions): Promise<string>;
     /**
-     * Initialize a new question for a market
+     * Resolve Market
      * @param marketId - The ID of the market
-     * @param question - The question to initialize
-     * @param startTime - The start time of the question
-     * @param endTime - The end time of the question
+     * @param winningDirection - The winning direction of the market
      *
      * @param options - RPC options
      *
      */
-    initializeQuestion({ marketId, question, startTime, endTime }: InitializeQuestionArgs, options?: RpcOptions): Promise<string>;
+    resolveMarket({ marketId, winningDirection }: {
+        marketId: number;
+        winningDirection: {
+            hype: {};
+        } | {
+            flop: {};
+        } | {
+            none: {};
+        };
+    }, options?: RpcOptions): Promise<string>;
     /**
-     * Resolve the current question for a market
+     * Settle an order
      * @param marketId - The ID of the market
+     * @param orderId - The ID of the order to settle
      *
      * @param options - RPC options
      *
      */
-    resolveQuestion(marketId: number, options?: RpcOptions): Promise<string>;
+    settleOrder({ marketId, orderId }: {
+        marketId: number;
+        orderId: number;
+    }, options?: RpcOptions): Promise<string>;
     /**
-     * Settle an order
+     * Add Liquidity
      * @param marketId - The ID of the market
-     * @param orderId - The ID of the order to settle
+     * @param amount - The amount of the order
+     * @param direction - The direction of the order
      *
      * @param options - RPC options
      *
      */
-    settleOrder({ marketId, orderId }: {
+    addLiquidity({ marketId, amount, direction }: {
+        marketId: number;
+        amount: number;
+        direction: OrderDirection;
+    }, options?: RpcOptions): Promise<string>;
+    /**
+     * Collect Fee
+     * @param marketId - The ID of the market
+     *
+     * @param options - RPC options
+     *
+     */
+    collectFee({ marketId }: {
         marketId: number;
-        orderId: number;
     }, options?: RpcOptions): Promise<string>;
 }