@triadxyz/triad-protocol 4.0.0 → 4.0.2

package/dist/index.js

@@ -26,22 +26,26 @@ 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 anchor_1 = require("@coral-xyz/anchor");
 const spl_token_1 = require("@solana/spl-token");
 const bn_js_1 = __importDefault(require("bn.js"));
 const bs58_1 = __importDefault(require("bs58"));
 const helpers_1 = require("./utils/helpers");
 const idl_triad_protocol_json_1 = __importDefault(require("./types/idl_triad_protocol.json"));
-const types_1 = require("./types");
 const constants_1 = require("./utils/constants");
 const helpers_2 = require("./utils/helpers");
 const pda_1 = require("./utils/pda");
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
-const feeCalculator_1 = require("./utils/feeCalculator");
 const stake_1 = __importDefault(require("./stake"));
 const poseidon_1 = __importDefault(require("./poseidon"));
+const predictor_1 = __importDefault(require("./predictor"));
+const trade_1 = __importDefault(require("./trade"));
+const customer_1 = __importDefault(require("./customer"));
 __exportStar(require("./types"), exports);
+__exportStar(require("./types/predictor"), exports);
+__exportStar(require("./types/stake"), exports);
+__exportStar(require("./types/trade"), exports);
+__exportStar(require("./types/customer"), exports);
 __exportStar(require("./utils/helpers"), exports);
 __exportStar(require("./utils/feeCalculator"), exports);
 __exportStar(require("./utils/constants"), exports);
@@ -60,6 +64,9 @@ class TriadProtocol {
         this.program = new anchor_1.Program(idl_triad_protocol_json_1.default, this.provider);
         this.stake = new stake_1.default(this.program, this.rpcOptions);
         this.poseidon = new poseidon_1.default(this.program, this.rpcOptions);
+        this.predictor = new predictor_1.default(this.program, this.rpcOptions);
+        this.trade = new trade_1.default(this.program, this.rpcOptions);
+        this.customer = new customer_1.default(this.program, this.rpcOptions);
     }
     /**
      * Get User Orders
@@ -136,34 +143,6 @@ class TriadProtocol {
                 order.linkedBookOrderId === constants_1.BOOK_ORDER_NULL.toString());
         });
     }
-    /**
-     * Get Costumer By Wallet Address
-     * @param wallet - The wallet address of the customer
-     */
-    getCustomerByWallet(wallet) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [customer] = yield this.program.account.customer.all([
-                {
-                    memcmp: {
-                        offset: 10 + 1,
-                        bytes: wallet.toBase58()
-                    }
-                }
-            ]);
-            return (0, helpers_2.formatCustomer)(customer.account, customer.publicKey);
-        });
-    }
-    /**
-     * Get Customer By ID
-     * @param customerId - The ID of the customer
-     */
-    getCustomerById(customerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const customerPDA = (0, pda_1.getCustomerPDA)(this.program.programId, customerId);
-            const customer = yield this.program.account.customer.fetch(customerPDA, this.provider.opts.commitment);
-            return (0, helpers_2.formatCustomer)(customer, customerPDA);
-        });
-    }
     /**
      * Get All Pools
      */
@@ -223,15 +202,6 @@ class TriadProtocol {
             return markets.length + 10;
         });
     }
-    /**
-     * Get Next Customer ID
-     */
-    nextCustomerId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const customers = yield this.program.account.customer.all();
-            return customers.length + 1;
-        });
-    }
     /**
      * Get Next Pool ID
      */
@@ -489,358 +459,5 @@ class TriadProtocol {
             return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
         });
     }
-    /**
-     * 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_2.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);
-        });
-    }
-    /**
-     * Create Customer
-     * @param args.id - The ID of the customer
-     * @param args.name - The name of the customer
-     * @param args.authority - The authority of the customer
-     * @param args.feeRecipient - The fee recipient of the customer
-     */
-    createCustomer({ id, name, authority, feeRecipient }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ixs = [
-                yield this.program.methods
-                    .createCustomer({ id, name, authority, feeRecipient })
-                    .accounts({
-                    signer: this.program.provider.publicKey
-                })
-                    .instruction()
-            ];
-            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
-        });
-    }
-    /**
-     * 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, 700);
-                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, 700);
-                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);
-        });
-    }
-    /**
-     * 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_2.getOrderSideFromNumber)(order.orderSide) === types_1.OrderSide.BID) {
-                        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, marketId));
-                    }
-                }
-            };
-            processOrders(orderBook.hypeOrders, 'hype');
-            processOrders(orderBook.flopOrders, 'flop');
-            return data;
-        });
-    }
-    /**
-     * Update Customer Fee
-     * @param customerId - Customer ID
-     * @param feeBps - Fee in basis points
-     */
-    updateCustomerFee({ customerId, feeBps }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ixs = [
-                yield this.program.methods
-                    .updateCustomerFee({ id: customerId, feeBps })
-                    .accounts({
-                    signer: this.program.provider.publicKey
-                })
-                    .instruction()
-            ];
-            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
-        });
-    }
 }
 exports.default = TriadProtocol;

package/dist/predictor.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="@coral-xyz/anchor/node_modules/@solana/web3.js" />
+import { Program } from '@coral-xyz/anchor';
+import { TriadProtocol } from './types/triad_protocol';
+import { RpcOptions } from './types';
+import { DepositArgs, WithdrawArgs } from './types/predictor';
+export default class Predictor {
+    private program;
+    private rpcOptions;
+    constructor(program: Program<TriadProtocol>, rpcOptions: RpcOptions);
+    /**
+     * Deposit
+     * @param args.authority - Authority of the deposit
+     * @param args.amount - Amount to deposit
+     * @param args.refer - Referral public key (optional) defaults to Triadmarkets public key
+     * @param args.customer - Customer ID (optional) defaults to 7 from Triadmarkets
+     */
+    deposit({ authority, amount, refer, customer }: DepositArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    /**
+     * Withdraw
+     * @param args.authority - Authority of the withdraw
+     * @param args.amount - Amount to deposit
+     * @param args.customer - Customer ID (optional) defaults to 7 from Triadmarkets
+     */
+    withdraw({ authority, amount, customer }: WithdrawArgs): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+}

package/dist/predictor.js

@@ -0,0 +1,84 @@
+"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 bn_js_1 = __importDefault(require("bn.js"));
+const constants_1 = require("./utils/constants");
+const pda_1 = require("./utils/pda");
+const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
+class Predictor {
+    constructor(program, rpcOptions) {
+        this.program = program;
+        this.rpcOptions = rpcOptions;
+    }
+    /**
+     * Deposit
+     * @param args.authority - Authority of the deposit
+     * @param args.amount - Amount to deposit
+     * @param args.refer - Referral public key (optional) defaults to Triadmarkets public key
+     * @param args.customer - Customer ID (optional) defaults to 7 from Triadmarkets
+     */
+    deposit({ authority, amount, refer = new web3_js_1.PublicKey('DqL77dzdTruyY9qssbU1aQNeDDywxL587k9FquxVv6iX'), customer = 7 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            const predictorPDA = (0, pda_1.getPredictorPDA)(this.program.programId, authority, customer);
+            try {
+                yield this.program.account.predictor.fetch(predictorPDA);
+            }
+            catch (e) {
+                ixs.push(yield this.program.methods
+                    .createPredictor({
+                    customer,
+                    refer
+                })
+                    .accounts({
+                    signer: authority,
+                    payer: this.rpcOptions.payer
+                })
+                    .instruction());
+            }
+            ixs.push(yield this.program.methods
+                .deposit(new bn_js_1.default(amount * Math.pow(10, constants_1.BASE_DECIMALS)))
+                .accounts({
+                signer: authority,
+                payer: this.rpcOptions.payer,
+                predictor: predictorPDA
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Withdraw
+     * @param args.authority - Authority of the withdraw
+     * @param args.amount - Amount to deposit
+     * @param args.customer - Customer ID (optional) defaults to 7 from Triadmarkets
+     */
+    withdraw({ authority, amount, customer = 7 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            const predictorPDA = (0, pda_1.getPredictorPDA)(this.program.programId, authority, customer);
+            ixs.push(yield this.program.methods
+                .withdraw(new bn_js_1.default(amount * Math.pow(10, constants_1.BASE_DECIMALS)))
+                .accounts({
+                signer: authority,
+                payer: this.rpcOptions.payer,
+                predictor: predictorPDA
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+}
+exports.default = Predictor;

package/dist/stake.d.ts

@@ -10,11 +10,11 @@ export default class Stake {
     /**
      * Get all Stake Vaults
      */
-    getStakeVaults(): Promise<import("./types").StakeVault[]>;
+    getStakeVaults(): Promise<import(".").StakeVault[]>;
     /**
      * Get all Stakes
      */
-    getStakes(): Promise<import("./types").Stake[]>;
+    getStakes(): Promise<import(".").Stake[]>;
     /**
      * Get Stake By Wallet
      * @param wallet - User wallet
@@ -35,7 +35,7 @@ export default class Stake {
      * Get Unstake By Wallet
      * @param wallet - User wallet
      */
-    getUnstakeByWallet(wallet: PublicKey): Promise<import("./types").Unstake[]>;
+    getUnstakeByWallet(wallet: PublicKey): Promise<import(".").Unstake[]>;
     /**
      * Stake Token
      * @param amount - Amount to stake

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>;
+}