@triadxyz/triad-protocol 3.1.1-beta → 3.1.3-beta

package/dist/claim.d.ts

@@ -0,0 +1,47 @@
+import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { TriadProtocol } from './types/triad_protocol';
+import { RpcOptions, CreateClaimVaultArgs, ClaimTokenArgs, UpdateClaimVaultMerkleRootArgs, UpdateClaimVaultIsActiveArgs } from './types';
+export default class Claim {
+    private program;
+    private rpcOptions;
+    constructor(program: Program<TriadProtocol>, rpcOptions: RpcOptions);
+    /**
+     * Get All Claim Vaults
+     */
+    getAllClaimVaults(): Promise<import("./types").ClaimVault[]>;
+    /**
+     * Get Claim Vault
+     * @param name - Name of the claim vault
+     */
+    getClaimVault(name: string): Promise<import("./types").ClaimVault>;
+    /**
+     * Get Claimed User
+     * @param claimVault - Claim vault
+     * @param user - User
+     */
+    getClaimedUser(claimVault: PublicKey, user: PublicKey): Promise<import("./types").ClaimedUser>;
+    /**
+     * Claim Token
+     * @param amount - Amount to claim
+     * @param merkleProof - Merkle proof
+     */
+    claimToken({ amount, merkleProof, mint, claimVault }: ClaimTokenArgs): Promise<string>;
+    /**
+     * Create Claim Vault
+     * @param args - Create Claim Vault Args
+     */
+    createClaimVault({ totalAmount, totalUsers, name, isFirstComeFirstServed, endTs, merkleRoot, mint }: CreateClaimVaultArgs): Promise<string>;
+    /**
+     * Update Claim Vault Is Active
+     * @param isActive - Is active
+     * @param claimVault - Claim vault
+     */
+    updateClaimVaultIsActive({ isActive, claimVault }: UpdateClaimVaultIsActiveArgs): Promise<string>;
+    /**
+     * Update Claim Vault Merkle Root
+     * @param merkleRoot - Merkle root
+     * @param claimVault - Claim vault
+     */
+    updateClaimVaultMerkleRoot({ merkleRoot, claimVault }: UpdateClaimVaultMerkleRootArgs): Promise<string>;
+}

package/dist/claim.js

@@ -0,0 +1,143 @@
+"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 anchor_1 = require("@coral-xyz/anchor");
+const helpers_1 = require("./utils/helpers");
+const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
+const pda_1 = require("./utils/pda");
+class Claim {
+    constructor(program, rpcOptions) {
+        this.program = program;
+        this.rpcOptions = rpcOptions;
+    }
+    /**
+     * Get All Claim Vaults
+     */
+    getAllClaimVaults() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const claimVaults = yield this.program.account.claimVault.all();
+            return claimVaults.map(({ account, publicKey }) => (0, helpers_1.formatClaimVault)(account, publicKey));
+        });
+    }
+    /**
+     * Get Claim Vault
+     * @param name - Name of the claim vault
+     */
+    getClaimVault(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const claimVaultPDA = (0, pda_1.getClaimVaultPDA)(this.program.programId, name);
+            const claimVault = yield this.program.account.claimVault.fetch(claimVaultPDA);
+            return (0, helpers_1.formatClaimVault)(claimVault, claimVaultPDA);
+        });
+    }
+    /**
+     * Get Claimed User
+     * @param claimVault - Claim vault
+     * @param user - User
+     */
+    getClaimedUser(claimVault, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const claimedUserPDA = (0, pda_1.getClaimedUserPDA)(this.program.programId, claimVault, user);
+            const claimedUser = yield this.program.account.claimedUser.fetch(claimedUserPDA);
+            return (0, helpers_1.formatClaimedUser)(claimedUser, claimedUserPDA);
+        });
+    }
+    /**
+     * Claim Token
+     * @param amount - Amount to claim
+     * @param merkleProof - Merkle proof
+     */
+    claimToken({ amount, merkleProof, mint, claimVault }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .claimToken({
+                    amount: new anchor_1.BN(amount),
+                    merkleProof
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    mint,
+                    claimVault
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Create Claim Vault
+     * @param args - Create Claim Vault Args
+     */
+    createClaimVault({ totalAmount, totalUsers, name, isFirstComeFirstServed, endTs, merkleRoot, mint }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .createClaimVault({
+                    totalAmount: new anchor_1.BN(totalAmount),
+                    totalUsers: new anchor_1.BN(totalUsers),
+                    name,
+                    isFirstComeFirstServed,
+                    endTs: new anchor_1.BN(endTs),
+                    merkleRoot
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    mint
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Claim Vault Is Active
+     * @param isActive - Is active
+     * @param claimVault - Claim vault
+     */
+    updateClaimVaultIsActive({ isActive, claimVault }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .updateClaimVaultIsActive(isActive)
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    claimVault
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Claim Vault Merkle Root
+     * @param merkleRoot - Merkle root
+     * @param claimVault - Claim vault
+     */
+    updateClaimVaultMerkleRoot({ merkleRoot, claimVault }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .updateClaimVaultMerkleRoot(merkleRoot)
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    claimVault
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+}
+exports.default = Claim;

package/dist/index.d.ts

@@ -1,119 +1,103 @@
-import { Connection, PublicKey, TransactionInstruction, Commitment } from '@solana/web3.js';
+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 { CreateMarketArgs, OpenOrderArgs, UserTrade, CreateCustomerArgs, MarketBidOrderArgs, CancelBidOrderArgs, CancelAskOrderArgs, PlaceBidOrderArgs, PlaceAskOrderArgs, CreatePoolArgs, BookOrder, MarketAskOrderArgs, RpcOptions, UpdateCustomerFeeArgs, OrderDirection } from './types';
+import { CreateMarketArgs, OpenOrderArgs, UserTrade, CreateCustomerArgs, MarketBidOrderArgs, CancelBidOrderArgs, CancelAskOrderArgs, PlaceBidOrderArgs, PlaceAskOrderArgs, CollectMarketFeeArgs, CreatePoolArgs, BookOrder, MarketAskOrderArgs, RpcOptions, OrderDirection } from './types';
 import Stake from './stake';
 import Poseidon from './poseidon';
 export * from './types';
-export * from './types/stake';
-export * from './types/poseidon';
 export * from './utils/helpers';
 export default class TriadProtocolClient {
+    private connection;
+    private wallet;
+    private rpcOptions;
     program: Program<TriadProtocol>;
     provider: AnchorProvider;
     stake: Stake;
     poseidon: Poseidon;
-    decimals: number;
-    constructor(connection: Connection, wallet: Wallet, commitment?: Commitment);
+    constructor(connection: Connection, wallet: Wallet, rpcOptions: RpcOptions);
     /**
      * Get All Pools
-     *
      */
     getAllPools(): Promise<import("./types").Pool[]>;
     /**
      * Get All Markets
-     *
      */
     getAllMarkets(): Promise<import("./types").Market[]>;
     /**
      * Get My User Trades from a user authority
      * @param wallet - User wallet PublicKey
-     *
      */
     getMyUserTrades(wallet: PublicKey): Promise<UserTrade[]>;
     /**
      * Get User Orders
      * @param wallet - User wallet PublicKey
-     *
      */
     getUserOrders(wallet: PublicKey): Promise<import("./types").Order[]>;
     /**
      * Get User Orders By Market ID
      * @param wallet - User wallet PublicKey
      * @param marketId - The ID of the market
-     *
      */
     getUserOrdersByMarketId(wallet: PublicKey, marketId: number): Promise<import("./types").Order[]>;
     /**
      * Get User Book Orders
-     *
      */
     getUserBookOrders(wallet: PublicKey, marketId: number): Promise<BookOrder[]>;
     /**
      * Get Pool By ID
      * @param poolId - The ID of the pool
-     *
      */
     getPoolById(poolId: number): Promise<import("./types").Pool>;
     /**
      * Get Market By ID
      * @param marketId - The ID of the market
-     *
      */
     getMarketById(marketId: number): Promise<import("./types").Market>;
     /**
      * Get Market By Address
      * @param marketAddress - The address of the market
-     *
      */
     getMarketByAddress(marketAddress: PublicKey): Promise<import("./types").Market>;
     /**
      * Get Costumer By Wallet Address
      * @param wallet - The wallet address of the customer
-     *
      */
     getCustomerByWallet(wallet: PublicKey): Promise<import("./types").Customer>;
     /**
      * Get Customer By ID
      * @param customerId - The ID of the customer
-     *
      */
     getCustomerById(customerId: number): Promise<import("./types").Customer>;
     /**
      * Get Current Market ID
-     *
      */
     nextMarketId(): Promise<number>;
     /**
      * Get Next Customer ID
-     *
      */
     nextCustomerId(): Promise<number>;
     /**
      * Get Next Pool ID
-     *
      */
     nextPoolId(): Promise<number>;
     /**
      * Get User Trade PDA
      * @param wallet - User wallet PublicKey
      * @param userNonce - The nonce of the user
-     *
      */
     getUserPDA(wallet: PublicKey, userNonce?: number): PublicKey;
     /**
      * Get User Trade
      * @param wallet - User wallet PublicKey
      * @param userNonce - The nonce of the user
-     *
      */
     getUserTrade(wallet: PublicKey, userNonce?: number): Promise<{
         bump: number;
         authority: PublicKey;
-        totalDeposits: BN;
-        totalWithdraws: BN;
         padding1: number[];
+        padding2: number[];
+        padding3: number[];
         orders: {
             ts: BN;
             orderId: BN;
@@ -212,26 +196,24 @@ export default class TriadProtocolClient {
     }>;
     /**
      * Create Market
-     * @param args.marketId - new markert id - length + 1
-     * @param args.startTime - start time
-     * @param args.endTime - end time
-     * @param args.question - question (max 80 characters)
-     * @param args.liquidityAtStart - liquidity at start
-     * @param args.payoutFee - payout fee (to add affiliate system)
-     *
-     * @param options - RPC options
-     *
-     */
-    createMarket({ markets, customer, mint, poolId }: CreateMarketArgs, options?: RpcOptions): Promise<string>;
+     * @param args.markets - Array of markets to create
+     * @param args.markets.marketId - Market ID
+     * @param args.markets.startTime - start time
+     * @param args.markets.endTime - end time
+     * @param args.markets.question - question (max 80 characters)
+     * @param args.markets.liquidityAtStart - liquidity at start
+     * @param args.markets.payoutFee - payout fee (to add affiliate system)
+     * @param args.customer - The customer of the market
+     * @param args.poolId - The ID of the pool
+     */
+    createMarket({ markets, customer, poolId }: CreateMarketArgs): Promise<string>;
     /**
      * Create Pool
      * @param poolId - The ID of the pool
      * @param question - The question of the pool
      * @param markets - The markets of the pool
-     *
-     * @param options - RPC options
      */
-    createPool({ poolId, question, markets, mint, customer, startTime, endTime, feeBps, payoutFee, isFast }: CreatePoolArgs, options?: RpcOptions): Promise<string>;
+    createPool({ poolId, question, markets, customer, startTime, endTime, feeBps, payoutFee, isFast }: CreatePoolArgs): Promise<string>;
     /**
      * Open Order
      * @param args.marketId - The ID of the Market
@@ -239,34 +221,26 @@ export default class TriadProtocolClient {
      * @param args.direction - The direction of the Order
      * @param args.mint - The mint of the Order
      * @param args.token - The token to use for the Order
-     *
-     * @param options - RPC options
-     *
      */
-    openOrder({ marketId, amount, direction, mint, token }: OpenOrderArgs, options?: RpcOptions): Promise<string>;
+    openOrder({ marketId, amount, direction, mint, token }: OpenOrderArgs): Promise<string>;
     /**
      * Close Order
      * @param args.marketId - The ID of the Market
      * @param args.orderId - The ID of the Order
      * @param args.userNonce - The nonce of the user
-     *
-     * @param options - RPC options
-     *
      */
     closeOrder({ marketId, orderId, userNonce }: {
         marketId: number;
         orderId: number;
         userNonce: number;
-    }, options?: RpcOptions): Promise<string>;
+    }): Promise<string>;
     /**
      * Resolve Market
      * @param args.marketId - The ID of the Market
+     * @param args.poolId - The ID of the Pool
      * @param args.winningDirection - The Winning Direction of the Market
-     *
-     * @param options - RPC options
-     *
      */
-    resolveMarket({ marketId, poolId, winningDirection }: {
+    updateMarketWinningDirection({ marketId, poolId, winningDirection }: {
         marketId: number;
         poolId?: number;
         winningDirection: {
@@ -278,86 +252,69 @@ export default class TriadProtocolClient {
         } | {
             draw: {};
         };
-    }, options?: RpcOptions): Promise<string>;
-    /**
-     * Collect Remaining Liquidity
-     * @param marketId - The ID of the market
-     *
-     * @param options - RPC options
-     *
-     */
-    collectRemainingLiquidity(marketId: number, options?: RpcOptions): Promise<string>;
+    }): Promise<string>;
     /**
      * Payout Order
      * @param args.marketId - The ID of the Market
      * @param args.orderId - The ID of the Order to Payout
      * @param args.userNonce - The nonce of the user
      * @param args.mint - The mint of the market
-     * @param args.shares - The shares of the order
-     *
-     * @param options - RPC options
-     *
      */
     payoutOrder(orders: {
         marketId: number;
         orderId: number;
         userNonce: number;
         mint: PublicKey;
-        shares: number;
-    }[], options?: RpcOptions): Promise<string>;
+    }[]): Promise<string>;
     /**
-     * Allow Market to Payout
+     * Update Market Payout
      * @param marketId - The ID of the market
      * @param poolId - The ID of the pool
-     *
-     * @param options - RPC options
-     *
+     * @param allowPayout - Whether to allow the market to payout
      */
-    allowMarketToPayout({ marketId, poolId }: {
+    updateMarketPayout({ marketId, poolId, allowPayout }: {
         marketId: number;
         poolId?: number;
-    }, options?: RpcOptions): Promise<string>;
+        allowPayout: boolean;
+    }): Promise<string>;
     /**
      * Create Sub User Trade
      * @param user - User PublicKey the main user
-     *
-     * @param options - RPC options
-     *
      */
-    createSubUserTrade(user: PublicKey, options?: RpcOptions): Promise<string>;
+    createSubUserTrade(user: PublicKey): Promise<string>;
     /**
-     * Update Market
+     * Update Market End
      * @param marketId - The ID of the market
      * @param marketEnd - The end time of the market
-     *
-     * @param options - RPC options
-     *
      */
-    updateMarket({ marketId, marketEnd, poolId }: {
+    updateMarketEnd({ marketId, marketEnd }: {
         marketId: number;
         marketEnd: number;
-        poolId?: number;
-    }, options?: RpcOptions): Promise<string>;
+    }): Promise<string>;
+    /**
+     * Update Market Question
+     * @param marketId - The ID of the market
+     * @param question - The question of the market
+     */
+    updateMarketQuestion({ marketId, question }: {
+        marketId: number;
+        question: string;
+    }): Promise<string>;
     /**
      * 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
-     *
-     * @param options - RPC options
-     *
      */
-    createCustomer({ id, name, authority, feeRecipient }: CreateCustomerArgs, options?: RpcOptions): Promise<string>;
+    createCustomer({ id, name, authority, feeRecipient }: CreateCustomerArgs): Promise<string>;
     /**
      * Get User Trade Nonce With Slots
      * @param userTrades - User Trades
-     *
      */
     getUserTradeNonceWithSlots(userTrades: UserTrade[]): PublicKey;
     /**
      * Get User Trade Ixs
-     *
      */
     getUserTradeIxs(): Promise<{
         userTradePDA: PublicKey;
@@ -371,85 +328,73 @@ export default class TriadProtocolClient {
     /**
      * Get User Trade Nonce
      * @param marketId - The ID of the Market
-     * @param direction - The direction of the Order
-     *
+     * @param orderDirection - The direction of the Order
      */
-    getUserTradeNonce(marketId: number, direction: OrderDirection): Promise<{
+    getUserTradeNonce(marketId: number, orderDirection: OrderDirection): Promise<{
         userTradePDA: PublicKey;
         userTradeIxs: TransactionInstruction[];
     }>;
     /**
      * Place Bid Order
      * @param args.marketId - The ID of the Market
-     * @param args.amount - The amount of the Order
-     * @param args.direction - The direction of the 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.orderDirection - The direction of the Order
      * @param args.mint - The mint of the Order
-     * @param args.price - The price of the Order
      * @param args.isTrdPayout - Whether to payout in TRD or not
-     *
-     * @param options - RPC options
      */
-    placeBidOrder({ marketId, orders, mint, isTrdPayout }: PlaceBidOrderArgs, options?: RpcOptions): Promise<string>;
+    placeBidOrder({ marketId, orders, isTrdPayout }: PlaceBidOrderArgs): Promise<string>;
     /**
      * Place Ask Order
      * @param args.marketId - The ID of the Market
-     * @param args.amount - The amount of the Order
-     * @param args.direction - The direction of the Order
-     * @param args.price - The price of the Order
-     * @param args.bidOrderId - The ID of the Bid Order
-     * @param args.bidNonce - The nonce of the Bid Order
-     *
-     * @param options - RPC options
-     *
+     * @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.bidOrderId - The ID of the Bid Order
+     * @param args.orders.bidNonce - The nonce of the Bid Order
      */
-    placeAskOrder({ marketId, orders }: PlaceAskOrderArgs, options?: RpcOptions): Promise<string>;
+    placeAskOrder({ marketId, orders }: PlaceAskOrderArgs): Promise<string>;
     /**
      * Cancel Bid Order
      * @param args.marketId - The ID of the Market
-     * @param args.orderId - The ID of the Order
-     * @param args.userNonce - The nonce of the user
-     * @param args.direction - The direction of the Order
-     *
-     * @param options - RPC options
+     * @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, mint }: CancelBidOrderArgs, options?: RpcOptions): Promise<string>;
+    cancelBidOrder({ marketId, orders }: CancelBidOrderArgs): Promise<string>;
     /**
      * Cancel Ask Order
      * @param args.marketId - The ID of the Market
-     * @param args.orderId - The ID of the Order
-     * @param args.userNonce - The nonce of the user
-     * @param args.userNonceBidOrder - The nonce of the bid user
-     * @param args.direction - The direction of the Order
-     *
-     * @param options - RPC options
+     * @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
      */
-    cancelAskOrder({ marketId, orders }: CancelAskOrderArgs, options?: RpcOptions): Promise<string>;
+    cancelAskOrder({ marketId, orders }: CancelAskOrderArgs): Promise<string>;
     /**
      * Market Bid Order
      * @param args.marketId - The ID of the Market
      * @param args.amount - The amount of the Order
-     * @param args.direction - The direction of the Order
-     * @param args.mint - The mint of the Order
+     * @param args.orderDirection - The direction of the Order
      * @param args.feeBps - The fee in basis points
      * @param args.isTrdPayout - Whether to payout in TRD or not
-     *
-     * @param options - RPC options
      */
-    marketBidOrder({ marketId, amount, direction, mint, feeBps, isTrdPayout }: MarketBidOrderArgs, options?: RpcOptions): Promise<string>;
+    marketBidOrder({ marketId, amount, orderDirection, feeBps, isTrdPayout }: MarketBidOrderArgs): Promise<string>;
     /**
      * Market Ask Order
      * @param args.marketId - The ID of the Market
      * @param args.orders - Array of orders to execute
-     * @param args.direction - The direction of the Order
+     * @param args.orders.shares - The amount of shares to sell
+     * @param args.orders.bidOrderId - The ID of the Bid Order
+     * @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 options - RPC options
+     * @param args.feeBps - The fee in basis points
      */
-    marketAskOrder({ marketId, orders, direction, isTrdPayout, feeBps }: MarketAskOrderArgs, options?: RpcOptions): Promise<string>;
+    marketAskOrder({ marketId, orders, orderDirection, isTrdPayout, feeBps }: MarketAskOrderArgs): Promise<string>;
     /**
      * Get Orders By Market ID
-     * @param marketId - The ID of the market
-     *
+     * @param marketId - Market ID
      */
     getOrderBook(marketId: number): Promise<{
         marketId: number;
@@ -468,32 +413,14 @@ export default class TriadProtocolClient {
     /**
      * Collect Market Fee
      * @param args.markets - The markets to collect the fee from
-     * @param args.markets.mint - The mint of the market
      * @param args.markets.marketAddress - The address of the market
      * @param args.markets.customerId - The ID of the customer
      * @param args.markets.customerFeeRecipient - The address of the customer fee recipient
-     *
-     * @param options - RPC options
      */
-    collectMarketFee(markets: {
-        mint: PublicKey;
-        marketAddress: PublicKey;
-        customerId: number;
-        customerFeeRecipient: PublicKey;
-    }[], options?: RpcOptions): Promise<string>;
+    collectMarketFee({ markets }: CollectMarketFeeArgs): Promise<string>;
     /**
      * Close Order Book
-     * @param marketId - The ID of the market
-     *
-     * @param options - RPC options
-     */
-    closeOrderBook(marketIds: number[], options?: RpcOptions): Promise<string>;
-    /**
-     * Update Customer Fee
-     * @param feeBps - The fee in basis points
-     * @param wallet - The wallet of the customer to update the fee for
-     *
-     * @param options - RPC options
+     * @param marketIds - Market IDs
      */
-    updateCustomerFee({ feeBps, wallet }: UpdateCustomerFeeArgs, options?: RpcOptions): Promise<string>;
+    closeOrderBook(marketIds: number[]): Promise<string>;
 }