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

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulateMarket = void 0;
+const MAKER_FEE = 0.035; // 1% fee
+const TAKER_FEE = 0.035; // 1% fee
+class SimulateMarket {
+    constructor(triadProtocol) {
+        this.triadProtocol = triadProtocol;
+        this.market = {
+            hypePrice: 0.55283,
+            flopPrice: 0.447170,
+            liquidity: 2236.286652,
+            hypeLiquidity: 1236.286652,
+            flopLiquidity: 1000,
+            hypeShares: 0,
+            flopShares: 0
+        };
+        this.ordersOpen = [];
+        this.ordersClosed = [];
+        this.orders = [];
+        this.simulate = () => {
+            for (const order of this.orders) {
+                const result = this.openOrder(order);
+                this.ordersOpen.push({
+                    id: this.ordersOpen.length + 1,
+                    shares: result.shares,
+                    amount: order.amount,
+                    direction: order.direction,
+                    price: result.priceWithImpact,
+                    marketPrice: result.marketPrice
+                });
+            }
+            console.table(this.ordersOpen);
+            const ordersToClose = [];
+            for (const order of this.ordersOpen) {
+                if (ordersToClose.includes(order.id)) {
+                    const result = this.closeOrder(order);
+                    this.ordersClosed.push({
+                        id: order.id,
+                        shares: result.shares,
+                        amount: order.amount,
+                        direction: order.direction,
+                        price: result.price,
+                        priceWithImpact: result.priceWithImpact,
+                        payout: result.payout
+                    });
+                    this.ordersOpen = this.ordersOpen.filter((o) => o.id !== order.id);
+                }
+            }
+            if (this.ordersClosed.length > 0) {
+                console.table(this.ordersClosed);
+            }
+            console.table(this.market);
+        };
+        this.openOrder = (order) => {
+            let currentPool = order.direction === 'hype'
+                ? this.market.hypeLiquidity
+                : this.market.flopLiquidity;
+            let otherPool = order.direction === 'hype'
+                ? this.market.flopLiquidity
+                : this.market.hypeLiquidity;
+            const newCurrentPool = currentPool + order.amount;
+            const marketsLiquidity = newCurrentPool + otherPool;
+            let marketPrice = newCurrentPool / marketsLiquidity;
+            let orderPrice = marketPrice * (1 + MAKER_FEE);
+            const shares = order.amount / orderPrice;
+            if (marketPrice < 0.000001) {
+                marketPrice = 0.000001;
+            }
+            if (marketPrice > 0.999999) {
+                marketPrice = 0.999999;
+            }
+            if (orderPrice < 0.000001) {
+                orderPrice = 0.000001;
+            }
+            if (orderPrice > 0.999999) {
+                orderPrice = 0.999999;
+            }
+            if (order.direction === 'hype') {
+                this.market.hypeLiquidity = newCurrentPool;
+                this.market.flopLiquidity = otherPool;
+                this.market.hypePrice = marketPrice;
+                this.market.flopPrice = 1 - marketPrice;
+                this.market.hypeShares += shares;
+            }
+            else {
+                this.market.flopLiquidity = newCurrentPool;
+                this.market.hypeLiquidity = otherPool;
+                this.market.flopPrice = marketPrice;
+                this.market.hypePrice = 1 - marketPrice;
+                this.market.flopShares += shares;
+            }
+            this.market.liquidity = marketsLiquidity;
+            return {
+                shares,
+                priceWithImpact: orderPrice,
+                marketPrice
+            };
+        };
+        this.closeOrder = (order) => {
+            let currentPool = order.direction === 'hype'
+                ? this.market.hypeLiquidity
+                : this.market.flopLiquidity;
+            let otherPool = order.direction === 'hype'
+                ? this.market.flopLiquidity
+                : this.market.hypeLiquidity;
+            let currentShares = order.direction === 'hype'
+                ? this.market.hypeShares
+                : this.market.flopShares;
+            let otherShares = order.direction === 'hype'
+                ? this.market.flopShares
+                : this.market.hypeShares;
+            const k = currentPool * otherPool;
+            const currentPrice = currentPool / (currentPool + otherPool);
+            const tokensOut = order.shares * currentPrice;
+            const tokensOutAfterFee = tokensOut * (1 - TAKER_FEE);
+            const newCurrentPool = currentPool - tokensOutAfterFee;
+            const newOtherPool = k / newCurrentPool;
+            const newPrice = newCurrentPool / (newCurrentPool + newOtherPool);
+            if (newPrice < 0.000001) {
+                throw new Error('Price too low');
+            }
+            if (newPrice > 0.999999) {
+                throw new Error('Price too high');
+            }
+            if (order.direction === 'hype') {
+                this.market.hypeLiquidity = newCurrentPool;
+                this.market.flopLiquidity = newOtherPool;
+                this.market.hypePrice = newPrice;
+                this.market.flopPrice = 1 - newPrice;
+                this.market.hypeShares -= order.shares;
+            }
+            else {
+                this.market.flopLiquidity = newCurrentPool;
+                this.market.hypeLiquidity = newOtherPool;
+                this.market.flopPrice = newPrice;
+                this.market.hypePrice = 1 - newPrice;
+                this.market.flopShares -= order.shares;
+            }
+            this.market.liquidity = newCurrentPool + newOtherPool;
+            return {
+                payout: tokensOutAfterFee,
+                shares: order.shares,
+                price: newPrice,
+                priceWithImpact: tokensOutAfterFee / order.shares
+            };
+        };
+        for (let i = 0; i < 1; i++) {
+            this.orders.push({
+                amount: 1000,
+                direction: 'hype'
+            });
+        }
+    }
+}
+exports.SimulateMarket = SimulateMarket;

package/dist/stake.js

@@ -16,7 +16,6 @@ const anchor_1 = require("@coral-xyz/anchor");
 const helpers_1 = require("./utils/helpers");
 const stake_1 = require("./utils/pda/stake");
 const constants_1 = require("./utils/constants");
-const getRarityRank_1 = __importDefault(require("./utils/getRarityRank"));
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
 const sendTransactionWithOptions_1 = __importDefault(require("./utils/sendTransactionWithOptions"));
 const convertSecretKeyToKeypair_1 = require("./utils/convertSecretKeyToKeypair");
@@ -194,7 +193,6 @@ class Stake {
                 items.push(stake);
             });
             for (const stake of items) {
-                const rank = (0, getRarityRank_1.default)(ranks, stake.mint, stake.name);
                 if (ixs.length >= 10) {
                     break;
                 }
@@ -203,7 +201,7 @@ class Stake {
                 ixs.push(yield this.program.methods
                     .claimStakeRewards({
                     collections,
-                    rank
+                    rank: 963
                 })
                     .accounts({
                     signer: wallet,

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 { InitializeMarketArgs, OpenOrderArgs, OrderDirection, UserTrade } from './types/trade';
+import { InitializeMarketArgs, OpenOrderArgs, UserTrade } from './types/trade';
 import { RpcOptions } from './types';
 import BN from 'bn.js';
 export default class Trade {
@@ -180,36 +180,6 @@ export default class Trade {
             draw: {};
         };
     }, options?: RpcOptions): Promise<string>;
-    /**
-     * Resolve Market With Liquidity
-     * @param args.marketId - The ID of the Market
-     * @param args.winningDirection - The Winning Direction of the Market
-     * @param args.marketToAddLiquidity - The Market to Add Liquidity
-     * @param args.amount - The amount of the Order
-     *
-     * @param options - RPC options
-     *
-     */
-    resolveMarketWithLiquidity({ marketId, winningDirection, marketToAddLiquidity, amount }: {
-        marketId: number;
-        winningDirection: OrderDirection;
-        marketToAddLiquidity: OrderDirection;
-        amount: number;
-    }, options?: RpcOptions): Promise<string>;
-    /**
-     * Add Liquidity
-     * @param marketId - The ID of the market
-     * @param amount - The amount of the order
-     * @param direction - The direction of the order
-     *
-     * @param options - RPC options
-     *
-     */
-    addLiquidity({ marketId, amount, direction }: {
-        marketId: number;
-        amount: number;
-        direction: OrderDirection;
-    }, options?: RpcOptions): Promise<string>;
     /**
      * Collect Remaining Liquidity
      * @param marketId - The ID of the market
@@ -248,4 +218,13 @@ export default class Trade {
      *
      */
     createSubUserTrade(user: PublicKey, options?: RpcOptions): Promise<string>;
+    /**
+     * Update Market
+     * @param marketId - The ID of the market
+     * @param marketEnd - The end time of the market
+     *
+     * @param options - RPC options
+     *
+     */
+    updateMarket(marketId: number, marketEnd: number, options?: RpcOptions): Promise<string>;
 }

package/dist/trade.js

@@ -282,65 +282,6 @@ class Trade {
             return (0, sendTransactionWithOptions_1.default)(method, options);
         });
     }
-    /**
-     * Resolve Market With Liquidity
-     * @param args.marketId - The ID of the Market
-     * @param args.winningDirection - The Winning Direction of the Market
-     * @param args.marketToAddLiquidity - The Market to Add Liquidity
-     * @param args.amount - The amount of the Order
-     *
-     * @param options - RPC options
-     *
-     */
-    resolveMarketWithLiquidity({ marketId, winningDirection, marketToAddLiquidity, amount }, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            const ixs = [];
-            ixs.push(yield this.program.methods
-                .resolveMarket(winningDirection)
-                .accounts({
-                signer: this.provider.publicKey,
-                market: marketPDA
-            })
-                .instruction());
-            ixs.push(yield this.program.methods
-                .addLiquidity({
-                amount: new bn_js_1.default(amount * Math.pow(10, constants_1.TRD_DECIMALS)),
-                direction: marketToAddLiquidity
-            })
-                .accounts({
-                signer: this.provider.publicKey,
-                market: marketPDA,
-                mint: constants_1.TRD_MINT
-            })
-                .instruction());
-            return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options);
-        });
-    }
-    /**
-     * Add Liquidity
-     * @param marketId - The ID of the market
-     * @param amount - The amount of the order
-     * @param direction - The direction of the order
-     *
-     * @param options - RPC options
-     *
-     */
-    addLiquidity({ marketId, amount, direction }, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            return (0, sendTransactionWithOptions_1.default)(this.program.methods
-                .addLiquidity({
-                amount: new bn_js_1.default(amount * Math.pow(10, constants_1.TRD_DECIMALS)),
-                direction: direction
-            })
-                .accounts({
-                signer: this.provider.publicKey,
-                market: marketPDA,
-                mint: constants_1.TRD_MINT
-            }), options);
-        });
-    }
     /**
      * Collect Remaining Liquidity
      * @param marketId - The ID of the market
@@ -415,5 +356,22 @@ class Trade {
             }), options);
         });
     }
+    /**
+     * Update Market
+     * @param marketId - The ID of the market
+     * @param marketEnd - The end time of the market
+     *
+     * @param options - RPC options
+     *
+     */
+    updateMarket(marketId, marketEnd, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.updateMarket(new bn_js_1.default(marketEnd)).accounts({
+                signer: this.provider.publicKey,
+                market: marketPDA
+            }), options);
+        });
+    }
 }
 exports.default = Trade;