@triadxyz/triad-protocol 4.0.1 → 4.0.3

package/dist/trade.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
+import { PublicKey } from '@solana/web3.js';
+import { Program } from '@coral-xyz/anchor';
+import { TriadProtocol } from './types/triad_protocol';
+import { RpcOptions, OrderDirectionEncoded, BookOrder } from './types';
+import { MarketBidOrderArgs, CancelBidOrderArgs, CancelAskOrderArgs, PlaceBidOrderArgs, PlaceAskOrderArgs, MarketAskOrderArgs } from './types/trade';
+export default class Trade {
+    private program;
+    private rpcOptions;
+    constructor(program: Program<TriadProtocol>, rpcOptions: RpcOptions);
+    /**
+     * Get Orders By Market ID
+     * @param marketId - Market ID
+     */
+    getOrderBook(marketId: number): Promise<{
+        marketId: number;
+        rewardsAvailable: string;
+        rewardsClaimed: string;
+        spreadToReward: string;
+        hype: {
+            bid: BookOrder[];
+            ask: BookOrder[];
+        };
+        flop: {
+            bid: BookOrder[];
+            ask: BookOrder[];
+        };
+    }>;
+    /**
+     * Place Bid Order
+     * @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
+     */
+    placeBidOrder({ orders }: PlaceBidOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Place Ask Order
+     * @param args.orders - Array of orders to execute
+     * @param args.orders.amount - The amount of the Order
+     * @param args.orders.price - The price of the Order
+     * @param args.orders.marketId - The Id from the market
+     * @param args.orders.orderDirection - The direction of the Order
+     */
+    placeAskOrder({ orders }: PlaceAskOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Cancel Bid Order
+     * @param args.orders.bookOrderId - The ID of the Book Order
+     * @param args.orders.marketId - The ID of the Market
+     * @param args.orders.orderDirection - The direction of the Order
+     */
+    cancelBidOrder({ orders }: CancelBidOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Cancel Ask Order
+     * @param args.orders.marketId - The ID of the Market
+     * @param args.orders.authority - The authority of the order
+     * @param args.orders.bookOrderId - The ID of the Book Order
+     * @param args.orders.orderDirection - The direction of the Order
+     */
+    cancelAskOrder({ orders }: CancelAskOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Market Bid Order
+     * @param args.marketId - The ID of the Market
+     * @param args.amount - The amount of the Order
+     * @param args.orderDirection - The direction of the Order
+     */
+    marketBidOrder({ marketId, amount, orderDirection }: MarketBidOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Market Ask Order
+     * @param args.marketId - The ID of the Market
+     * @param args.shares - The amount of shares to sell
+     * @param args.bookOrderBidId - The ID of the Bid Order
+     * @param args.orderDirection - The direction of the Order
+     */
+    marketAskOrder({ marketId, shares, orderDirection }: MarketAskOrderArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Payout Order
+     * @param args.marketId - The ID of the Market
+     * @param args.authority - The authority of the order
+     * @param args.orderDirection - The direction of the Order to Payout
+     */
+    payoutOrder(orders: {
+        marketId: number;
+        orderDirection: OrderDirectionEncoded;
+        authority: PublicKey;
+    }[]): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+}

package/dist/trade.js

@@ -0,0 +1,345 @@
+"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 web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const bn_js_1 = __importDefault(require("bn.js"));
+const helpers_1 = require("./utils/helpers");
+const types_1 = require("./types");
+const constants_1 = require("./utils/constants");
+const pda_1 = require("./utils/pda");
+const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
+const feeCalculator_1 = require("./utils/feeCalculator");
+class Trade {
+    constructor(program, rpcOptions) {
+        this.program = program;
+        this.rpcOptions = rpcOptions;
+    }
+    /**
+     * Get Orders By Market ID
+     * @param marketId - Market ID
+     */
+    getOrderBook(marketId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = {
+                marketId: marketId,
+                rewardsAvailable: '0',
+                rewardsClaimed: '0',
+                spreadToReward: '0',
+                hype: { bid: [], ask: [] },
+                flop: { bid: [], ask: [] }
+            };
+            const orderBookPDA = (0, pda_1.getOrderBookPDA)(this.program.programId, marketId);
+            const orderBook = yield this.program.account.orderBook.fetch(orderBookPDA);
+            data.rewardsAvailable = orderBook.rewardsAvailable.toString();
+            data.rewardsClaimed = orderBook.rewardsClaimed.toString();
+            data.spreadToReward = orderBook.spreadToReward.toString();
+            const processOrders = (orders, side) => {
+                for (const order of orders) {
+                    if (order.price.eq(new bn_js_1.default(0)))
+                        continue;
+                    if ((0, helpers_1.getOrderSideFromNumber)(order.orderSide) === types_1.OrderSide.BID) {
+                        data[side].bid.push((0, helpers_1.formatBookOrder)(order, marketId));
+                    }
+                    if ((0, helpers_1.getOrderSideFromNumber)(order.orderSide) === types_1.OrderSide.ASK) {
+                        data[side].ask.push((0, helpers_1.formatBookOrder)(order, marketId));
+                    }
+                }
+            };
+            processOrders(orderBook.hypeOrders, 'hype');
+            processOrders(orderBook.flopOrders, 'flop');
+            return data;
+        });
+    }
+    /**
+     * Place Bid Order
+     * @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
+     */
+    placeBidOrder({ orders }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            if (orders.length > 6) {
+                throw new Error('Max 6 orders per transaction');
+            }
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .placeBidOrder({
+                    amount: new bn_js_1.default(order.amount * Math.pow(10, constants_1.BASE_DECIMALS)),
+                    price: new bn_js_1.default(order.price * Math.pow(10, constants_1.BASE_DECIMALS)),
+                    marketId: new bn_js_1.default(order.marketId),
+                    orderDirection: order.orderDirection
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    payer: this.rpcOptions.payer,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId),
+                    order: (0, pda_1.getOrderPDA)(this.program.programId, this.program.provider.publicKey, order.marketId, (0, helpers_1.getOrderDirection)(order.orderDirection))
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Place Ask Order
+     * @param args.orders - Array of orders to execute
+     * @param args.orders.amount - The amount of the Order
+     * @param args.orders.price - The price of the Order
+     * @param args.orders.marketId - The Id from the market
+     * @param args.orders.orderDirection - The direction of the Order
+     */
+    placeAskOrder({ orders }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            if (orders.length > 6) {
+                throw new Error('Max 6 orders per transaction');
+            }
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .placeAskOrder({
+                    shares: new bn_js_1.default(order.amount * Math.pow(10, constants_1.BASE_DECIMALS)),
+                    price: new bn_js_1.default(order.price * Math.pow(10, constants_1.BASE_DECIMALS)),
+                    orderDirection: order.orderDirection
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    order: (0, pda_1.getOrderPDA)(this.program.programId, this.program.provider.publicKey, order.marketId, (0, helpers_1.getOrderDirection)(order.orderDirection)),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Cancel Bid Order
+     * @param args.orders.bookOrderId - The ID of the Book Order
+     * @param args.orders.marketId - The ID of the Market
+     * @param args.orders.orderDirection - The direction of the Order
+     */
+    cancelBidOrder({ orders }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            if (orders.length > 6) {
+                throw new Error('You can only cancel up to 6 orders at a time');
+            }
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .cancelBidOrder({
+                    marketId: new bn_js_1.default(order.marketId),
+                    bookOrderId: new bn_js_1.default(order.bookOrderId),
+                    orderDirection: order.orderDirection
+                })
+                    .accounts({
+                    signer: new web3_js_1.PublicKey(order.authority),
+                    payer: this.rpcOptions.payer,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Cancel Ask Order
+     * @param args.orders.marketId - The ID of the Market
+     * @param args.orders.authority - The authority of the order
+     * @param args.orders.bookOrderId - The ID of the Book Order
+     * @param args.orders.orderDirection - The direction of the Order
+     */
+    cancelAskOrder({ orders }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            if (orders.length > 5) {
+                throw new Error('Max 5 orders per transaction');
+            }
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .cancelAskOrder({
+                    marketId: new bn_js_1.default(order.marketId),
+                    bookOrderId: new bn_js_1.default(order.bookOrderId),
+                    orderDirection: order.orderDirection
+                })
+                    .accounts({
+                    signer: order.authority,
+                    payer: this.rpcOptions.payer,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, order.marketId),
+                    order: (0, pda_1.getOrderPDA)(this.program.programId, order.authority, order.marketId, (0, helpers_1.getOrderDirection)(order.orderDirection))
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Market Bid Order
+     * @param args.marketId - The ID of the Market
+     * @param args.amount - The amount of the Order
+     * @param args.orderDirection - The direction of the Order
+     */
+    marketBidOrder({ marketId, amount, orderDirection }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
+            const ixs = [];
+            const addressLookupTableAccounts = [];
+            const orderBook = yield this.getOrderBook(marketId);
+            let remainingUSDC = new bn_js_1.default(amount * Math.pow(10, constants_1.BASE_DECIMALS));
+            const orders = Object.keys(orderDirection)[0] === 'hype'
+                ? orderBook.hype.ask
+                : orderBook.flop.ask;
+            const sortedOrders = orders.sort((a, b) => Number(a.price) - Number(b.price));
+            for (const order of sortedOrders) {
+                if (remainingUSDC.lte(new bn_js_1.default(0)))
+                    break;
+                if (order.authority === this.program.provider.publicKey.toBase58()) {
+                    continue;
+                }
+                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));
+                const effectivePriceDecimal = (0, feeCalculator_1.applyBuyFee)(orderPrice.toNumber() / 1000000, 500);
+                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);
+                const sharesToBuy = bn_js_1.default.min(maxSharesForPrice, availableShares);
+                if (sharesToBuy.lte(new bn_js_1.default(0)))
+                    continue;
+                const usdcAmount = sharesToBuy
+                    .mul(adjustedPrice)
+                    .div(new bn_js_1.default(Math.pow(10, constants_1.BASE_DECIMALS)));
+                if (usdcAmount.lte(new bn_js_1.default(0)))
+                    continue;
+                const oppositeOrderDirection = (0, helpers_1.getOppositeOrderDirectionEncoded)(orderDirection);
+                ixs.push(yield this.program.methods
+                    .marketBidOrder({
+                    amount: new bn_js_1.default(usdcAmount),
+                    marketId: new bn_js_1.default(marketId),
+                    orderDirection,
+                    bookOrderAskId: new bn_js_1.default(order.id),
+                    oppositeOrderDirection
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    payer: this.rpcOptions.payer,
+                    market: marketPDA,
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                    bookOrderAskAuthority: new web3_js_1.PublicKey(order.authority),
+                    order: (0, pda_1.getOrderPDA)(this.program.programId, this.program.provider.publicKey, marketId, (0, helpers_1.getOrderDirection)(orderDirection)),
+                    oppositeOrder: (0, pda_1.getOrderPDA)(this.program.programId, new web3_js_1.PublicKey(order.authority), marketId, (0, helpers_1.getOrderDirection)(oppositeOrderDirection))
+                })
+                    .instruction());
+                remainingUSDC = remainingUSDC.sub(usdcAmount);
+            }
+            if (ixs.length === 0) {
+                throw new Error('No matching orders found to fill the requested amount');
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions, addressLookupTableAccounts);
+        });
+    }
+    /**
+     * Market Ask Order
+     * @param args.marketId - The ID of the Market
+     * @param args.shares - The amount of shares to sell
+     * @param args.bookOrderBidId - The ID of the Bid Order
+     * @param args.orderDirection - The direction of the Order
+     */
+    marketAskOrder({ marketId, shares, orderDirection }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
+            const ixs = [];
+            const addressLookupTableAccounts = [];
+            const orderBook = yield this.getOrderBook(marketId);
+            const bidOrders = Object.keys(orderDirection)[0] === 'hype'
+                ? orderBook.hype.bid
+                : orderBook.flop.bid;
+            const sortedOrders = bidOrders.sort((a, b) => Number(b.price) - Number(a.price));
+            let amountOfUSDC = new bn_js_1.default(0);
+            let remainingShares = new bn_js_1.default(shares * Math.pow(10, constants_1.BASE_DECIMALS));
+            for (const order of sortedOrders) {
+                if (remainingShares.lte(new bn_js_1.default(0)))
+                    break;
+                if (order.authority === this.program.provider.publicKey.toBase58() ||
+                    order.linkedBookOrderId !== constants_1.BOOK_ORDER_NULL.toString()) {
+                    continue;
+                }
+                const availableShares = new bn_js_1.default(order.totalShares).sub(new bn_js_1.default(order.filledShares));
+                const sharesToSell = bn_js_1.default.min(remainingShares, availableShares);
+                if (sharesToSell.lt(new bn_js_1.default(0)))
+                    continue;
+                remainingShares = remainingShares.sub(sharesToSell);
+                const orderPrice = new bn_js_1.default(order.price);
+                const effectivePriceDecimal = (0, feeCalculator_1.applySellFee)(orderPrice.toNumber() / 1000000, 500);
+                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({
+                    shares: new bn_js_1.default(sharesToSell),
+                    orderDirection,
+                    bookOrderBidId: new bn_js_1.default(order.id)
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    payer: this.rpcOptions.payer,
+                    market: marketPDA,
+                    buyerAuthority: new web3_js_1.PublicKey(order.authority),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, marketId),
+                    marketAta: (0, pda_1.getTokenATA)(marketPDA, constants_1.USDC_MINT, spl_token_1.TOKEN_PROGRAM_ID),
+                    bidOrder: (0, pda_1.getOrderPDA)(this.program.programId, new web3_js_1.PublicKey(order.authority), marketId, (0, helpers_1.getOrderDirection)(orderDirection)),
+                    askOrder: (0, pda_1.getOrderPDA)(this.program.programId, this.program.provider.publicKey, marketId, (0, helpers_1.getOrderDirection)(orderDirection))
+                })
+                    .instruction());
+            }
+            if (ixs.length === 0) {
+                throw new Error('No matching orders found to fill the requested amount');
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions, addressLookupTableAccounts);
+        });
+    }
+    /**
+     * Payout Order
+     * @param args.marketId - The ID of the Market
+     * @param args.authority - The authority of the order
+     * @param args.orderDirection - The direction of the Order to Payout
+     */
+    payoutOrder(orders) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            if (orders.length > 4) {
+                throw new Error('Max 4 orders per transaction');
+            }
+            for (const order of orders) {
+                ixs.push(yield this.program.methods
+                    .payoutOrder()
+                    .accounts({
+                    signer: order.authority,
+                    payer: this.rpcOptions.payer,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, order.marketId),
+                    tokenProgram: (0, helpers_1.getTokenProgram)(constants_1.USDC_MINT),
+                    order: (0, pda_1.getOrderPDA)(this.program.programId, order.authority, order.marketId, (0, helpers_1.getOrderDirection)(order.orderDirection))
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+}
+exports.default = Trade;

package/dist/types/customer.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
+import { PublicKey } from '@solana/web3.js';
+export type Customer = {
+    id: number;
+    authority: string;
+    name: string;
+    feeRecipient: string;
+    feeBps: number;
+    isVerified: boolean;
+    address: string;
+};
+export type CreateCustomerArgs = {
+    id: number;
+    name: string;
+    authority: PublicKey;
+    feeRecipient: PublicKey;
+};
+export type UpdateCustomerFeeArgs = {
+    customerId: number;
+    feeBps: number;
+    feeRecipient: PublicKey | null;
+};

package/dist/types/customer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/idl_triad_protocol.json

@@ -847,7 +847,7 @@
                             },
                             {
                                 "kind": "arg",
-                                "path": "args.customer"
+                                "path": "args.customer_id"
                             }
                         ]
                     }
@@ -3106,7 +3106,7 @@
                         "type": "pubkey"
                     },
                     {
-                        "name": "customer",
+                        "name": "customer_id",
                         "type": "u16"
                     }
                 ]
@@ -3886,7 +3886,7 @@
                         "type": "pubkey"
                     },
                     {
-                        "name": "customer",
+                        "name": "customer_id",
                         "type": "u16"
                     },
                     {

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
 import { Commitment, PublicKey } from '@solana/web3.js';
 export type RpcOptions = {
     skipPreflight?: boolean;
@@ -130,65 +131,6 @@ export type WinningDirectionEncoded = {
 } | {
     none: {};
 };
-export type Customer = {
-    id: number;
-    authority: string;
-    name: string;
-    feeRecipient: string;
-    feeBps: number;
-    isVerified: boolean;
-    address: string;
-};
-export type StakeVault = {
-    name: string;
-    collection: string;
-    authority: string;
-    amount: number;
-    isLocked: boolean;
-    tokenMint: string;
-    amountPaid: number;
-    tokenDecimals: number;
-    tokenStaked: number;
-    week: number;
-    initTs: number;
-    endTs: number;
-    revShareClaimed: number;
-    revShareAvailable: number;
-};
-export type Stake = {
-    address: string;
-    authority: string;
-    initTs: number;
-    checkedTs: number;
-    claimed: number;
-    available: number;
-    amount: number;
-    revShareCheckedTs: number;
-    revShareClaimed: number;
-    revShareAvailable: number;
-};
-export type Unstake = {
-    address: string;
-    authority: string;
-    amount: number;
-    withdrawTs: number;
-};
-export type PlaceBidOrderArgs = {
-    orders: {
-        amount: number;
-        price: number;
-        orderDirection: OrderDirectionEncoded;
-        marketId: number;
-    }[];
-};
-export type PlaceAskOrderArgs = {
-    orders: {
-        amount: number;
-        price: number;
-        orderDirection: OrderDirectionEncoded;
-        marketId: number;
-    }[];
-};
 export type InitializeMarketArgs = {
     marketId: number;
     startTime: number;
@@ -197,12 +139,6 @@ export type InitializeMarketArgs = {
     feeBps: number;
     customer: PublicKey | null;
 };
-export type CreateCustomerArgs = {
-    id: number;
-    name: string;
-    authority: PublicKey;
-    feeRecipient: PublicKey;
-};
 export type CreateMarketArgs = {
     markets: {
         marketId: number;
@@ -229,36 +165,6 @@ export type CreatePoolArgs = {
     }[];
     isFast?: boolean;
 };
-export type CancelBidOrderArgs = {
-    orders: {
-        authority: PublicKey;
-        marketId: number;
-        bookOrderId: number;
-        orderDirection: OrderDirectionEncoded;
-    }[];
-};
-export type CancelAskOrderArgs = {
-    orders: {
-        authority: PublicKey;
-        marketId: number;
-        bookOrderId: number;
-        orderDirection: OrderDirectionEncoded;
-    }[];
-};
-export type MarketBidOrderArgs = {
-    marketId: number;
-    amount: number;
-    orderDirection: OrderDirectionEncoded;
-};
-export type MarketAskOrderArgs = {
-    marketId: number;
-    shares: number;
-    orderDirection: OrderDirectionEncoded;
-};
-export type UpdateClaimVaultIsActiveArgs = {
-    isActive: boolean;
-    claimVaultName: string;
-};
 export type UpdateMarketWinningDirectionArgs = {
     marketId: number;
     winningDirection: WinningDirectionEncoded;

package/dist/types/predictor.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
+import { PublicKey } from '@solana/web3.js';
+export type Predictor = {
+    address: string;
+    authority: string;
+    refer: string;
+    customerId: number;
+    balance: number;
+};
+export type DepositArgs = {
+    authority: PublicKey;
+    amount: number;
+    refer?: PublicKey;
+    customerId?: number;
+};
+export type WithdrawArgs = {
+    authority: PublicKey;
+    amount: number;
+    customerId?: number;
+};

package/dist/types/predictor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/stake.d.ts

@@ -0,0 +1,34 @@
+export type StakeVault = {
+    name: string;
+    collection: string;
+    authority: string;
+    amount: number;
+    isLocked: boolean;
+    tokenMint: string;
+    amountPaid: number;
+    tokenDecimals: number;
+    tokenStaked: number;
+    week: number;
+    initTs: number;
+    endTs: number;
+    revShareClaimed: number;
+    revShareAvailable: number;
+};
+export type Stake = {
+    address: string;
+    authority: string;
+    initTs: number;
+    checkedTs: number;
+    claimed: number;
+    available: number;
+    amount: number;
+    revShareCheckedTs: number;
+    revShareClaimed: number;
+    revShareAvailable: number;
+};
+export type Unstake = {
+    address: string;
+    authority: string;
+    amount: number;
+    withdrawTs: number;
+};

package/dist/types/stake.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });