@triadxyz/triad-protocol 3.3.1-beta → 3.3.3-beta

package/dist/index.d.ts

@@ -2,7 +2,7 @@
 import { Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
 import { AnchorProvider, Program, Wallet } from '@coral-xyz/anchor';
 import BN from 'bn.js';
-import { TriadProtocol } from './types/triad_protocol';
+import { TriadProtocol as TriadProtocolIDL } from './types/triad_protocol';
 import { OpenOrderArgs, UserTrade, CreateCustomerArgs, MarketBidOrderArgs, CancelBidOrderArgs, CancelAskOrderArgs, PlaceBidOrderArgs, PlaceAskOrderArgs, BookOrder, MarketAskOrderArgs, RpcOptions, OrderDirection, CloseOrderArgs, CreateMarketArgs, CreatePoolArgs, UpdateMarketWinningDirectionArgs } from './types';
 import Stake from './stake';
 import Poseidon from './poseidon';
@@ -10,11 +10,14 @@ import Claim from './claim';
 export * from './types';
 export * from './utils/helpers';
 export * from './utils/merkle';
-export default class TriadProtocolClient {
+export * from './utils/feeCalculator';
+export * from './utils/constants';
+export * from './utils/pda';
+export default class TriadProtocol {
     private connection;
     private wallet;
     private rpcOptions;
-    program: Program<TriadProtocol>;
+    program: Program<TriadProtocolIDL>;
     provider: AnchorProvider;
     stake: Stake;
     poseidon: Poseidon;
@@ -37,9 +40,14 @@ export default class TriadProtocolClient {
      */
     getUserOrdersByMarketId(wallet: PublicKey, marketId: number): Promise<import("./types").Order[]>;
     /**
-     * Get User Book Orders
+     * Get all User Book Orders
+     * @param wallet - User wallet PublicKey
+     */
+    getUserBookOrders(wallet: PublicKey): Promise<BookOrder[]>;
+    /**
+     * Get User Book Orders By Market ID
      */
-    getUserBookOrders(wallet: PublicKey, marketId: number): Promise<BookOrder[]>;
+    getUserBookOrdersByMarketId(wallet: PublicKey, marketId: number): Promise<BookOrder[]>;
     /**
      * Get Costumer By Wallet Address
      * @param wallet - The wallet address of the customer
@@ -342,33 +350,32 @@ export default class TriadProtocolClient {
     }>;
     /**
      * Place Bid Order
-     * @param args.marketId - The ID of the Market
      * @param args.orders - Array of orders to execute
+     * @param args.orders.marketId - The ID of the Market
      * @param args.orders.amount - The amount of the Order
      * @param args.orders.price - The price of the Order
      * @param args.orders.orderDirection - The direction of the Order
      * @param args.mint - The mint of the Order
      * @param args.isTrdPayout - Whether to payout in TRD or not
      */
-    placeBidOrder({ marketId, orders, isTrdPayout }: PlaceBidOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    placeBidOrder({ orders, isTrdPayout }: PlaceBidOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Place Ask Order
-     * @param args.marketId - The ID of the Market
      * @param args.orders - Array of orders to execute
+     * @param args.orders.marketId - The ID of the Market
      * @param args.orders.amount - The amount of the Order
      * @param args.orders.price - The price of the Order
      * @param args.orders.bidOrderId - The ID of the Bid Order
      * @param args.orders.bidNonce - The nonce of the Bid Order
      */
-    placeAskOrder({ marketId, orders }: PlaceAskOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    placeAskOrder({ orders }: PlaceAskOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Cancel Bid Order
-     * @param args.marketId - The ID of the Market
      * @param args.orders.orderId - The ID of the Order
      * @param args.orders.userNonce - The nonce of the user
      * @param args.orders.orderDirection - The direction of the Order
      */
-    cancelBidOrder({ marketId, orders }: CancelBidOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    cancelBidOrder({ orders }: CancelBidOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Cancel Ask Order
      * @param args.marketId - The ID of the Market
@@ -394,9 +401,8 @@ export default class TriadProtocolClient {
      * @param args.orders.userNonce - The nonce of the user
      * @param args.orderDirection - The direction of the Order
      * @param args.isTrdPayout - Whether to payout in TRD or not
-     * @param args.feeBps - The fee in basis points
      */
-    marketAskOrder({ marketId, orders, orderDirection, isTrdPayout, feeBps }: MarketAskOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    marketAskOrder({ marketId, orders, orderDirection, isTrdPayout }: MarketAskOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Get Orders By Market ID
      * @param marketId - Market ID

package/dist/index.js

@@ -38,13 +38,17 @@ const helpers_2 = require("./utils/helpers");
 const pda_1 = require("./utils/pda");
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
 const swap_1 = require("./utils/swap");
+const feeCalculator_1 = require("./utils/feeCalculator");
 const stake_1 = __importDefault(require("./stake"));
 const poseidon_1 = __importDefault(require("./poseidon"));
 const claim_1 = __importDefault(require("./claim"));
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/helpers"), exports);
 __exportStar(require("./utils/merkle"), exports);
-class TriadProtocolClient {
+__exportStar(require("./utils/feeCalculator"), exports);
+__exportStar(require("./utils/constants"), exports);
+__exportStar(require("./utils/pda"), exports);
+class TriadProtocol {
     constructor(connection, wallet, rpcOptions) {
         this.connection = connection;
         this.wallet = wallet;
@@ -99,14 +103,30 @@ class TriadProtocolClient {
         });
     }
     /**
-     * Get User Book Orders
+     * Get all User Book Orders
+     * @param wallet - User wallet PublicKey
+     */
+    getUserBookOrders(wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const orderbooks = yield this.program.account.orderBook.all();
+            const bookOrders = orderbooks.map((orderbook) => {
+                return [...orderbook.account.hypeOrders, ...orderbook.account.flopOrders]
+                    .map((order) => (0, helpers_2.formatBookOrder)(order, orderbook.account.marketId.toNumber()))
+                    .filter((order) => order.authority === wallet.toBase58() &&
+                    order.linkedBookOrderId === constants_1.BOOK_ORDER_NULL.toString());
+            });
+            return bookOrders.flat();
+        });
+    }
+    /**
+     * Get User Book Orders By Market ID
      */
-    getUserBookOrders(wallet, marketId) {
+    getUserBookOrdersByMarketId(wallet, marketId) {
         return __awaiter(this, void 0, void 0, function* () {
             const orderBook = yield this.program.account.orderBook.fetch((0, pda_1.getOrderBookPDA)(this.program.programId, marketId));
             const orders = [...orderBook.hypeOrders, ...orderBook.flopOrders];
             return orders
-                .map((order) => (0, helpers_2.formatBookOrder)(order))
+                .map((order) => (0, helpers_2.formatBookOrder)(order, marketId))
                 .filter((order) => order.authority === wallet.toBase58() &&
                 order.linkedBookOrderId === constants_1.BOOK_ORDER_NULL.toString());
         });
@@ -723,20 +743,20 @@ class TriadProtocolClient {
     }
     /**
      * Place Bid Order
-     * @param args.marketId - The ID of the Market
      * @param args.orders - Array of orders to execute
+     * @param args.orders.marketId - The ID of the Market
      * @param args.orders.amount - The amount of the Order
      * @param args.orders.price - The price of the Order
      * @param args.orders.orderDirection - The direction of the Order
      * @param args.mint - The mint of the Order
      * @param args.isTrdPayout - Whether to payout in TRD or not
      */
-    placeBidOrder({ marketId, orders, isTrdPayout }) {
+    placeBidOrder({ orders, isTrdPayout }) {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
             const addressLookupTableAccounts = [];
-            if (orders.length > 4) {
-                throw new Error('You can only place up to 4 orders at a time');
+            if (orders.length > 5) {
+                throw new Error('You can only place up to 5 orders at a time');
             }
             let amountInUSDC = new bn_js_1.default(0);
             let totalAmount = 0;
@@ -765,10 +785,6 @@ class TriadProtocolClient {
                     return;
                 }
             }
-            const { userTradePDA, userTradeIxs } = yield this.getUserTradeNonce(marketId, Object.keys(orders[0].orderDirection)[0]);
-            if (userTradeIxs.length > 0) {
-                ixs.push(...userTradeIxs);
-            }
             for (const order of orders) {
                 ixs.push(yield this.program.methods
                     .placeBidOrder({
@@ -778,9 +794,9 @@ class TriadProtocolClient {
                 })
                     .accounts({
                     signer: this.program.provider.publicKey,
-                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
-                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
-                    userTrade: userTradePDA
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId),
+                    userTrade: this.getUserPDA(this.program.provider.publicKey)
                 })
                     .instruction());
             }
@@ -789,18 +805,18 @@ class TriadProtocolClient {
     }
     /**
      * Place Ask Order
-     * @param args.marketId - The ID of the Market
      * @param args.orders - Array of orders to execute
+     * @param args.orders.marketId - The ID of the Market
      * @param args.orders.amount - The amount of the Order
      * @param args.orders.price - The price of the Order
      * @param args.orders.bidOrderId - The ID of the Bid Order
      * @param args.orders.bidNonce - The nonce of the Bid Order
      */
-    placeAskOrder({ marketId, orders }) {
+    placeAskOrder({ orders }) {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
-            if (orders.length > 4) {
-                throw new Error('You can only place up to 4 orders at a time');
+            if (orders.length > 5) {
+                throw new Error('You can only place up to 5 orders at a time');
             }
             for (const order of orders) {
                 ixs.push(yield this.program.methods
@@ -811,8 +827,8 @@ class TriadProtocolClient {
                 })
                     .accounts({
                     signer: this.program.provider.publicKey,
-                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
-                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId),
                     userTrade: this.getUserPDA(this.program.provider.publicKey, order.userNonce)
                 })
                     .instruction());
@@ -822,12 +838,11 @@ class TriadProtocolClient {
     }
     /**
      * Cancel Bid Order
-     * @param args.marketId - The ID of the Market
      * @param args.orders.orderId - The ID of the Order
      * @param args.orders.userNonce - The nonce of the user
      * @param args.orders.orderDirection - The direction of the Order
      */
-    cancelBidOrder({ marketId, orders }) {
+    cancelBidOrder({ orders }) {
         return __awaiter(this, void 0, void 0, function* () {
             const ixs = [];
             if (orders.length > 4) {
@@ -842,8 +857,8 @@ class TriadProtocolClient {
                     .accounts({
                     signer: this.program.provider.publicKey,
                     payer: this.rpcOptions.payer,
-                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId),
-                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId),
                     userTrade: this.getUserPDA(this.program.provider.publicKey, order.userNonce)
                 })
                     .instruction());
@@ -916,14 +931,8 @@ class TriadProtocolClient {
                     }
                     const orderPrice = new bn_js_1.default(order.price);
                     const availableShares = new bn_js_1.default(order.totalShares).sub(new bn_js_1.default(order.filledShares));
-                    let adjustedPrice = orderPrice;
-                    const priceSpread = new bn_js_1.default(1000000).sub(orderPrice);
-                    const fee = priceSpread
-                        .mul(orderPrice)
-                        .mul(new bn_js_1.default(700))
-                        .div(new bn_js_1.default(10000))
-                        .div(new bn_js_1.default(1000000));
-                    adjustedPrice = orderPrice.add(fee);
+                    const effectivePriceDecimal = (0, feeCalculator_1.applyBuyFee)(orderPrice.toNumber() / 1000000);
+                    const adjustedPrice = new bn_js_1.default(Math.floor(effectivePriceDecimal * 1000000));
                     const maxSharesForPrice = tempRemainingUSDC
                         .mul(new bn_js_1.default(Math.pow(10, constants_1.BASE_DECIMALS)))
                         .div(adjustedPrice);
@@ -964,14 +973,8 @@ class TriadProtocolClient {
                 }
                 const orderPrice = new bn_js_1.default(order.price);
                 const availableShares = new bn_js_1.default(order.totalShares).sub(new bn_js_1.default(order.filledShares));
-                let adjustedPrice = orderPrice;
-                const priceSpread = new bn_js_1.default(1000000).sub(orderPrice);
-                const fee = priceSpread
-                    .mul(orderPrice)
-                    .mul(new bn_js_1.default(700))
-                    .div(new bn_js_1.default(10000))
-                    .div(new bn_js_1.default(1000000));
-                adjustedPrice = orderPrice.add(fee);
+                const effectivePriceDecimal = (0, feeCalculator_1.applyBuyFee)(orderPrice.toNumber() / 1000000);
+                const adjustedPrice = new bn_js_1.default(Math.floor(effectivePriceDecimal * 1000000));
                 const maxSharesForPrice = remainingUSDC
                     .mul(new bn_js_1.default(Math.pow(10, constants_1.BASE_DECIMALS)))
                     .div(adjustedPrice);
@@ -1021,9 +1024,8 @@ class TriadProtocolClient {
      * @param args.orders.userNonce - The nonce of the user
      * @param args.orderDirection - The direction of the Order
      * @param args.isTrdPayout - Whether to payout in TRD or not
-     * @param args.feeBps - The fee in basis points
      */
-    marketAskOrder({ marketId, orders, orderDirection, isTrdPayout, feeBps = 0 }) {
+    marketAskOrder({ marketId, orders, orderDirection, isTrdPayout }) {
         return __awaiter(this, void 0, void 0, function* () {
             const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
             const ixs = [];
@@ -1049,16 +1051,8 @@ class TriadProtocolClient {
                         continue;
                     remainingShares = remainingShares.sub(sharesToSell);
                     const orderPrice = new bn_js_1.default(order.price);
-                    let adjustedPrice = orderPrice;
-                    if (feeBps > 0) {
-                        const priceSpread = new bn_js_1.default(1000000).sub(orderPrice);
-                        const fee = priceSpread
-                            .mul(orderPrice)
-                            .mul(new bn_js_1.default(feeBps))
-                            .div(new bn_js_1.default(10000))
-                            .div(new bn_js_1.default(1000000));
-                        adjustedPrice = orderPrice.sub(fee);
-                    }
+                    const effectivePriceDecimal = (0, feeCalculator_1.applySellFee)(orderPrice.toNumber() / 1000000);
+                    const adjustedPrice = new bn_js_1.default(Math.floor(effectivePriceDecimal * 1000000));
                     amountOfUSDC = amountOfUSDC.add(sharesToSell.mul(adjustedPrice).div(new bn_js_1.default(Math.pow(10, constants_1.BASE_DECIMALS))));
                     ixs.push(yield this.program.methods
                         .marketAskOrder({
@@ -1125,10 +1119,10 @@ class TriadProtocolClient {
                     if (order.price.eq(new bn_js_1.default(0)))
                         continue;
                     if ((0, helpers_2.getOrderSideFromNumber)(order.orderSide) === types_1.OrderSide.BID) {
-                        data[side].bid.push((0, helpers_2.formatBookOrder)(order));
+                        data[side].bid.push((0, helpers_2.formatBookOrder)(order, marketId));
                     }
                     if ((0, helpers_2.getOrderSideFromNumber)(order.orderSide) === types_1.OrderSide.ASK) {
-                        data[side].ask.push((0, helpers_2.formatBookOrder)(order));
+                        data[side].ask.push((0, helpers_2.formatBookOrder)(order, marketId));
                     }
                 }
             };
@@ -1156,4 +1150,4 @@ class TriadProtocolClient {
         });
     }
 }
-exports.default = TriadProtocolClient;
+exports.default = TriadProtocol;

package/dist/poseidon.d.ts

@@ -41,4 +41,13 @@ export default class Poseidon {
      * @param poseidonAsset - Poseidon Asset
      */
     removeTraderPoseidon(user: PublicKey, poseidonAsset: PublicKey): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Update Metadata
+     * @param poseidons.uri - URI
+     * @param poseidons.asset - Asset
+     */
+    updateMetadata(poseidons: {
+        uri: string;
+        asset: PublicKey;
+    }[]): Promise<string | import("@solana/web3.js").VersionedTransaction>;
 }

package/dist/poseidon.js

@@ -130,5 +130,27 @@ class Poseidon {
             return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
         });
     }
+    /**
+     * Update Metadata
+     * @param poseidons.uri - URI
+     * @param poseidons.asset - Asset
+     */
+    updateMetadata(poseidons) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const poseidon of poseidons) {
+                ixs.push(yield this.program.methods
+                    .updateMetadata(poseidon.uri)
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    corePoseidonCollection: constants_1.POSEIDON_CORE_COLLECTION,
+                    poseidonCollection: (0, pda_1.getCollectionPDA)(this.program.programId, constants_1.POSEIDON_COLLECTION_SYMBOL),
+                    poseidonAsset: poseidon.asset
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
 }
 exports.default = Poseidon;

package/dist/types/idl_triad_protocol.json

@@ -852,6 +852,94 @@
             ],
             "args": []
         },
+        {
+            "name": "collect_remaining_liquidity",
+            "discriminator": [153, 107, 201, 83, 183, 195, 59, 186],
+            "accounts": [
+                {
+                    "name": "signer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "market",
+                    "writable": true
+                },
+                {
+                    "name": "mint",
+                    "writable": true
+                },
+                {
+                    "name": "market_ata",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "account",
+                                "path": "market"
+                            },
+                            {
+                                "kind": "account",
+                                "path": "token_program"
+                            },
+                            {
+                                "kind": "account",
+                                "path": "mint"
+                            }
+                        ],
+                        "program": {
+                            "kind": "const",
+                            "value": [
+                                140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142,
+                                13, 131, 11, 90, 19, 153, 218, 255, 16, 132, 4, 142, 123, 216,
+                                219, 233, 248, 89
+                            ]
+                        }
+                    }
+                },
+                {
+                    "name": "signer_ata",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "account",
+                                "path": "signer"
+                            },
+                            {
+                                "kind": "account",
+                                "path": "token_program"
+                            },
+                            {
+                                "kind": "account",
+                                "path": "mint"
+                            }
+                        ],
+                        "program": {
+                            "kind": "const",
+                            "value": [
+                                140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142,
+                                13, 131, 11, 90, 19, 153, 218, 255, 16, 132, 4, 142, 123, 216,
+                                219, 233, 248, 89
+                            ]
+                        }
+                    }
+                },
+                {
+                    "name": "token_program",
+                    "address": "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+                },
+                {
+                    "name": "associated_token_program",
+                    "address": "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": []
+        },
         {
             "name": "collect_royalty",
             "discriminator": [189, 235, 7, 168, 255, 50, 30, 75],
@@ -1638,11 +1726,6 @@
                     "writable": true,
                     "signer": true
                 },
-                {
-                    "name": "squads",
-                    "writable": true,
-                    "address": "Hk1r2NUL4LbUhx1agg1w44tyZiNr72mbeLsg6suF5MA4"
-                },
                 {
                     "name": "user_trade",
                     "writable": true
@@ -2568,6 +2651,43 @@
                 }
             ]
         },
+        {
+            "name": "update_metadata",
+            "discriminator": [170, 182, 43, 239, 97, 78, 225, 186],
+            "accounts": [
+                {
+                    "name": "signer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "poseidon_collection",
+                    "writable": true
+                },
+                {
+                    "name": "poseidon_asset",
+                    "writable": true
+                },
+                {
+                    "name": "core_poseidon_collection",
+                    "writable": true
+                },
+                {
+                    "name": "core_program",
+                    "address": "CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d"
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": [
+                {
+                    "name": "uri",
+                    "type": "string"
+                }
+            ]
+        },
         {
             "name": "update_pool_question",
             "discriminator": [248, 60, 128, 181, 157, 182, 51, 166],
@@ -2750,6 +2870,10 @@
             "name": "MarketEvent",
             "discriminator": [212, 67, 145, 23, 58, 104, 52, 83]
         },
+        {
+            "name": "MarketFeeEvent",
+            "discriminator": [191, 148, 93, 112, 63, 139, 16, 186]
+        },
         {
             "name": "OrderEvent",
             "discriminator": [209, 51, 146, 206, 88, 127, 112, 69]
@@ -3766,6 +3890,26 @@
                 ]
             }
         },
+        {
+            "name": "MarketFeeEvent",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "market_id",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "fee",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "timestamp",
+                        "type": "i64"
+                    }
+                ]
+            }
+        },
         {
             "name": "MarketV2",
             "type": {

package/dist/types/index.d.ts

@@ -79,6 +79,7 @@ export type BookOrder = {
     orderSide: OrderSide;
     userNonce: string;
     linkedBookOrderId: string;
+    marketId: number;
 };
 export declare enum WinningDirection {
     HYPE = "Hype",
@@ -219,21 +220,21 @@ export interface MerkleProof {
     proof: number[][];
 }
 export type PlaceBidOrderArgs = {
-    marketId: number;
     orders: {
         amount: number;
         price: number;
         orderDirection: OrderDirectionEncoded;
+        marketId: number;
     }[];
     isTrdPayout: boolean;
 };
 export type PlaceAskOrderArgs = {
-    marketId: number;
     orders: {
         amount: number;
         price: number;
         bidOrderId: number;
         userNonce: number;
+        marketId: number;
     }[];
 };
 export type InitializeMarketArgs = {
@@ -284,8 +285,8 @@ export type CreatePoolArgs = {
     isFast?: boolean;
 };
 export type CancelBidOrderArgs = {
-    marketId: number;
     orders: {
+        marketId: number;
         orderId: number;
         userNonce: number;
         orderDirection: OrderDirectionEncoded;
@@ -314,7 +315,6 @@ export type MarketAskOrderArgs = {
     }[];
     orderDirection: OrderDirectionEncoded;
     isTrdPayout: boolean;
-    feeBps: number;
 };
 export type CreateClaimVaultArgs = {
     totalAmount: number;

package/dist/types/triad_protocol.d.ts

@@ -1298,6 +1298,152 @@ export type TriadProtocol = {
             ];
             args: [];
         },
+        {
+            name: 'collectRemainingLiquidity';
+            discriminator: [153, 107, 201, 83, 183, 195, 59, 186];
+            accounts: [
+                {
+                    name: 'signer';
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: 'market';
+                    writable: true;
+                },
+                {
+                    name: 'mint';
+                    writable: true;
+                },
+                {
+                    name: 'marketAta';
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'account';
+                                path: 'market';
+                            },
+                            {
+                                kind: 'account';
+                                path: 'tokenProgram';
+                            },
+                            {
+                                kind: 'account';
+                                path: 'mint';
+                            }
+                        ];
+                        program: {
+                            kind: 'const';
+                            value: [
+                                140,
+                                151,
+                                37,
+                                143,
+                                78,
+                                36,
+                                137,
+                                241,
+                                187,
+                                61,
+                                16,
+                                41,
+                                20,
+                                142,
+                                13,
+                                131,
+                                11,
+                                90,
+                                19,
+                                153,
+                                218,
+                                255,
+                                16,
+                                132,
+                                4,
+                                142,
+                                123,
+                                216,
+                                219,
+                                233,
+                                248,
+                                89
+                            ];
+                        };
+                    };
+                },
+                {
+                    name: 'signerAta';
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'account';
+                                path: 'signer';
+                            },
+                            {
+                                kind: 'account';
+                                path: 'tokenProgram';
+                            },
+                            {
+                                kind: 'account';
+                                path: 'mint';
+                            }
+                        ];
+                        program: {
+                            kind: 'const';
+                            value: [
+                                140,
+                                151,
+                                37,
+                                143,
+                                78,
+                                36,
+                                137,
+                                241,
+                                187,
+                                61,
+                                16,
+                                41,
+                                20,
+                                142,
+                                13,
+                                131,
+                                11,
+                                90,
+                                19,
+                                153,
+                                218,
+                                255,
+                                16,
+                                132,
+                                4,
+                                142,
+                                123,
+                                216,
+                                219,
+                                233,
+                                248,
+                                89
+                            ];
+                        };
+                    };
+                },
+                {
+                    name: 'tokenProgram';
+                    address: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
+                },
+                {
+                    name: 'associatedTokenProgram';
+                    address: 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL';
+                },
+                {
+                    name: 'systemProgram';
+                    address: '11111111111111111111111111111111';
+                }
+            ];
+            args: [];
+        },
         {
             name: 'collectRoyalty';
             discriminator: [189, 235, 7, 168, 255, 50, 30, 75];
@@ -2287,11 +2433,6 @@ export type TriadProtocol = {
                     writable: true;
                     signer: true;
                 },
-                {
-                    name: 'squads';
-                    writable: true;
-                    address: 'Hk1r2NUL4LbUhx1agg1w44tyZiNr72mbeLsg6suF5MA4';
-                },
                 {
                     name: 'userTrade';
                     writable: true;
@@ -3543,6 +3684,43 @@ export type TriadProtocol = {
                 }
             ];
         },
+        {
+            name: 'updateMetadata';
+            discriminator: [170, 182, 43, 239, 97, 78, 225, 186];
+            accounts: [
+                {
+                    name: 'signer';
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: 'poseidonCollection';
+                    writable: true;
+                },
+                {
+                    name: 'poseidonAsset';
+                    writable: true;
+                },
+                {
+                    name: 'corePoseidonCollection';
+                    writable: true;
+                },
+                {
+                    name: 'coreProgram';
+                    address: 'CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d';
+                },
+                {
+                    name: 'systemProgram';
+                    address: '11111111111111111111111111111111';
+                }
+            ];
+            args: [
+                {
+                    name: 'uri';
+                    type: 'string';
+                }
+            ];
+        },
         {
             name: 'updatePoolQuestion';
             discriminator: [248, 60, 128, 181, 157, 182, 51, 166];
@@ -3737,6 +3915,10 @@ export type TriadProtocol = {
             name: 'marketEvent';
             discriminator: [212, 67, 145, 23, 58, 104, 52, 83];
         },
+        {
+            name: 'marketFeeEvent';
+            discriminator: [191, 148, 93, 112, 63, 139, 16, 186];
+        },
         {
             name: 'orderEvent';
             discriminator: [209, 51, 146, 206, 88, 127, 112, 69];
@@ -4753,6 +4935,26 @@ export type TriadProtocol = {
                 ];
             };
         },
+        {
+            name: 'marketFeeEvent';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'marketId';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'fee';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'timestamp';
+                        type: 'i64';
+                    }
+                ];
+            };
+        },
         {
             name: 'marketV2';
             type: {

package/dist/utils/feeCalculator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Calculate dynamic fee based on price
+ * Returns fee in basis points (bps)
+ */
+export declare function calculateDynamicFeeBps(price: number): number;
+/**
+ * Apply dynamic fee to price for buy orders (adds fee)
+ */
+export declare function applyBuyFee(price: number): number;
+/**
+ * Apply dynamic fee to price for sell orders (subtracts fee)
+ */
+export declare function applySellFee(price: number): number;
+/**
+ * Simulate a buy order with given amount and price
+ */
+export declare function simulateBuyOrder(amount: number, price: number): {
+    entryPrice: number;
+    effectivePrice: number;
+    sharesReceived: number;
+    feeAmount: number;
+    feePercentage: number;
+};
+/**
+ * Simulate a sell order with given shares and price
+ */
+export declare function simulateSellOrder(shares: number, price: number): {
+    entryPrice: number;
+    effectivePrice: number;
+    sharesReceived: number;
+    feeAmount: number;
+    feePercentage: number;
+};
+/**
+ * Generate fee curve data for visualization
+ */
+export declare function generateFeeCurve(step?: number): Array<{
+    price: number;
+    feeBps: number;
+    feePercentage: number;
+}>;

package/dist/utils/feeCalculator.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFeeCurve = exports.simulateSellOrder = exports.simulateBuyOrder = exports.applySellFee = exports.applyBuyFee = exports.calculateDynamicFeeBps = void 0;
+/**
+ * Calculate dynamic fee based on price
+ * Returns fee in basis points (bps)
+ */
+function calculateDynamicFeeBps(price) {
+    const internalPrice = Math.floor(price * 1000000);
+    if (internalPrice <= 500000) {
+        return 190;
+    }
+    const priceAbove50 = internalPrice - 500000;
+    const feeReduction = Math.floor((priceAbove50 * 100) / 490000);
+    const calculatedFee = Math.max(0, 190 - feeReduction);
+    const maxPossibleFee = internalPrice < 999999
+        ? Math.floor(((999999 - internalPrice) * 10000) / internalPrice)
+        : 0;
+    return Math.max(90, Math.min(calculatedFee, maxPossibleFee));
+}
+exports.calculateDynamicFeeBps = calculateDynamicFeeBps;
+/**
+ * Apply dynamic fee to price for buy orders (adds fee)
+ */
+function applyBuyFee(price) {
+    const feeBps = calculateDynamicFeeBps(price);
+    const internalPrice = Math.floor(price * 1000000);
+    const effectiveInternalPrice = Math.floor((internalPrice * (10000 + feeBps)) / 10000);
+    const clampedPrice = Math.min(effectiveInternalPrice, 999999);
+    return clampedPrice / 1000000;
+}
+exports.applyBuyFee = applyBuyFee;
+/**
+ * Apply dynamic fee to price for sell orders (subtracts fee)
+ */
+function applySellFee(price) {
+    const feeBps = calculateDynamicFeeBps(price);
+    const internalPrice = Math.floor(price * 1000000);
+    const effectiveInternalPrice = Math.floor((internalPrice * (10000 - feeBps)) / 10000);
+    const clampedPrice = Math.max(effectiveInternalPrice, 1);
+    return clampedPrice / 1000000;
+}
+exports.applySellFee = applySellFee;
+/**
+ * Simulate a buy order with given amount and price
+ */
+function simulateBuyOrder(amount, price) {
+    const effectivePrice = applyBuyFee(price);
+    const sharesReceived = amount / effectivePrice;
+    const valueAtOriginalPrice = sharesReceived * price;
+    const feeAmount = amount - valueAtOriginalPrice;
+    const feePercentage = (feeAmount / amount) * 100;
+    return {
+        entryPrice: price,
+        effectivePrice,
+        sharesReceived,
+        feeAmount,
+        feePercentage
+    };
+}
+exports.simulateBuyOrder = simulateBuyOrder;
+/**
+ * Simulate a sell order with given shares and price
+ */
+function simulateSellOrder(shares, price) {
+    const effectivePrice = applySellFee(price);
+    const amountReceived = shares * effectivePrice;
+    const valueAtOriginalPrice = shares * price;
+    const feeAmount = valueAtOriginalPrice - amountReceived;
+    const feePercentage = (feeAmount / valueAtOriginalPrice) * 100;
+    return {
+        entryPrice: price,
+        effectivePrice,
+        sharesReceived: shares,
+        feeAmount,
+        feePercentage
+    };
+}
+exports.simulateSellOrder = simulateSellOrder;
+/**
+ * Generate fee curve data for visualization
+ */
+function generateFeeCurve(step = 0.01) {
+    const curve = [];
+    for (let price = 0.01; price <= 0.99; price += step) {
+        const feeBps = calculateDynamicFeeBps(price);
+        curve.push({
+            price: Math.round(price * 100) / 100,
+            feeBps,
+            feePercentage: feeBps / 100
+        });
+    }
+    return curve;
+}
+exports.generateFeeCurve = generateFeeCurve;

package/dist/utils/helpers.d.ts

@@ -11,7 +11,7 @@ export declare const formatPool: (account: IdlAccounts<TriadProtocol>['pool'], a
 export declare const formatMarket: (account: IdlAccounts<TriadProtocol>['marketV2'], address: PublicKey) => Market;
 export declare const formatUserTrade: (account: IdlAccounts<TriadProtocol>['userTrade'], address: PublicKey) => UserTrade;
 export declare const formatOrder: (order: IdlAccounts<TriadProtocol>['userTrade']['orders'][number], authority?: string) => Order;
-export declare const formatBookOrder: (order: IdlAccounts<TriadProtocol>['orderBook']['hypeOrders'][number] | IdlAccounts<TriadProtocol>['orderBook']['flopOrders'][number]) => BookOrder;
+export declare const formatBookOrder: (order: IdlAccounts<TriadProtocol>['orderBook']['hypeOrders'][number] | IdlAccounts<TriadProtocol>['orderBook']['flopOrders'][number], marketId: number) => BookOrder;
 export declare const formatCustomer: (account: IdlAccounts<TriadProtocol>['customer'], publicKey: PublicKey) => Customer;
 export declare const formatClaimVault: (account: IdlAccounts<TriadProtocol>['claimVault'], address: PublicKey) => ClaimVault;
 export declare const formatClaimedUser: (account: IdlAccounts<TriadProtocol>['claimedUser'], address: PublicKey) => ClaimedUser;

package/dist/utils/helpers.js

@@ -101,7 +101,7 @@ const formatMarket = (account, address) => {
         payoutFee: account.payoutFee,
         customer: account.customerId === 0 ? 'Triad' : account.customerId.toString(),
         poolId: account.poolId.toNumber(),
-        feeRecipient: account.feeRecipient.toString(),
+        feeRecipient: account.feeRecipient.toString()
     };
 };
 exports.formatMarket = formatMarket;
@@ -134,7 +134,7 @@ const formatOrder = (order, authority) => {
     };
 };
 exports.formatOrder = formatOrder;
-const formatBookOrder = (order) => {
+const formatBookOrder = (order, marketId) => {
     return {
         id: order.id.toString(),
         price: order.price.toString(),
@@ -144,6 +144,7 @@ const formatBookOrder = (order) => {
         orderDirection: (0, exports.getOrderDirectionFromNumber)(order.orderDirection),
         orderSide: (0, exports.getOrderSideFromNumber)(order.orderSide),
         userNonce: order.userNonce.toString(),
+        marketId,
         linkedBookOrderId: order.linkedBookOrderId.toString()
     };
 };

package/dist/utils/merkle.js

@@ -61,6 +61,9 @@ class MerkleTree {
             if (siblingIndex < this.tree[level].length) {
                 proof.push(this.tree[level][siblingIndex]);
             }
+            else {
+                proof.push(this.tree[level][currentIndex]);
+            }
             currentIndex = Math.floor(currentIndex / 2);
         }
         return proof.map((hash) => Array.from(hash));

package/package.json

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