@drift-labs/sdk 0.2.0-temp.1 → 2.0.0

package/lib/dlob/DLOBNode.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="bn.js" />
+import { BN, SpotMarketAccount, PerpMarketAccount, OraclePriceData, Order } from '..';
+import { PublicKey } from '@solana/web3.js';
+export interface DLOBNode {
+    getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
+    isVammNode(): boolean;
+    order: Order | undefined;
+    isBaseFilled(): boolean;
+    haveFilled: boolean;
+    userAccount: PublicKey | undefined;
+    market: SpotMarketAccount | PerpMarketAccount;
+}
+export declare abstract class OrderNode implements DLOBNode {
+    order: Order;
+    market: SpotMarketAccount | PerpMarketAccount;
+    userAccount: PublicKey;
+    sortValue: BN;
+    haveFilled: boolean;
+    haveTrigger: boolean;
+    constructor(order: Order, market: SpotMarketAccount | PerpMarketAccount, userAccount: PublicKey);
+    abstract getSortValue(order: Order): BN;
+    getLabel(): string;
+    getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
+    isBaseFilled(): boolean;
+    isVammNode(): boolean;
+}
+export declare class LimitOrderNode extends OrderNode {
+    next?: LimitOrderNode;
+    previous?: LimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class FloatingLimitOrderNode extends OrderNode {
+    next?: FloatingLimitOrderNode;
+    previous?: FloatingLimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class MarketOrderNode extends OrderNode {
+    next?: MarketOrderNode;
+    previous?: MarketOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class TriggerOrderNode extends OrderNode {
+    next?: TriggerOrderNode;
+    previous?: TriggerOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare type DLOBNodeMap = {
+    limit: LimitOrderNode;
+    floatingLimit: FloatingLimitOrderNode;
+    market: MarketOrderNode;
+    trigger: TriggerOrderNode;
+};
+export declare type DLOBNodeType = 'limit' | 'floatingLimit' | 'market' | ('trigger' & keyof DLOBNodeMap);
+export declare function createNode<T extends DLOBNodeType>(nodeType: T, order: Order, market: SpotMarketAccount | PerpMarketAccount, userAccount: PublicKey): DLOBNodeMap[T];

package/lib/dlob/DLOBNode.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNode = exports.TriggerOrderNode = exports.MarketOrderNode = exports.FloatingLimitOrderNode = exports.LimitOrderNode = exports.OrderNode = void 0;
+const __1 = require("..");
+const NodeList_1 = require("./NodeList");
+class OrderNode {
+    constructor(order, market, userAccount) {
+        this.haveFilled = false;
+        this.haveTrigger = false;
+        this.order = order;
+        this.market = market;
+        this.userAccount = userAccount;
+        this.sortValue = this.getSortValue(order);
+    }
+    getLabel() {
+        let msg = `Order ${(0, NodeList_1.getOrderSignature)(this.order.orderId, this.userAccount)}`;
+        msg += ` ${(0, __1.isVariant)(this.order.direction, 'long') ? 'LONG' : 'SHORT'} `;
+        msg += `${(0, __1.convertToNumber)(this.order.baseAssetAmount, __1.AMM_RESERVE_PRECISION).toFixed(3)}`;
+        if (this.order.price.gt(__1.ZERO)) {
+            msg += ` @ ${(0, __1.convertToNumber)(this.order.price, __1.PRICE_PRECISION).toFixed(3)}`;
+        }
+        if (this.order.triggerPrice.gt(__1.ZERO)) {
+            msg += ` ${(0, __1.isVariant)(this.order.triggerCondition, 'below') ? 'BELOW' : 'ABOVE'}`;
+            msg += ` ${(0, __1.convertToNumber)(this.order.triggerPrice, __1.PRICE_PRECISION).toFixed(3)}`;
+        }
+        return msg;
+    }
+    getPrice(oraclePriceData, slot) {
+        return (0, __1.getLimitPrice)(this.order, oraclePriceData, slot);
+    }
+    isBaseFilled() {
+        return this.order.baseAssetAmountFilled.eq(this.order.baseAssetAmount);
+    }
+    isVammNode() {
+        return false;
+    }
+}
+exports.OrderNode = OrderNode;
+class LimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.price;
+    }
+}
+exports.LimitOrderNode = LimitOrderNode;
+class FloatingLimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return new __1.BN(order.oraclePriceOffset);
+    }
+}
+exports.FloatingLimitOrderNode = FloatingLimitOrderNode;
+class MarketOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.slot;
+    }
+}
+exports.MarketOrderNode = MarketOrderNode;
+class TriggerOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.triggerPrice;
+    }
+}
+exports.TriggerOrderNode = TriggerOrderNode;
+function createNode(nodeType, order, market, userAccount) {
+    switch (nodeType) {
+        case 'floatingLimit':
+            return new FloatingLimitOrderNode(order, market, userAccount);
+        case 'limit':
+            return new LimitOrderNode(order, market, userAccount);
+        case 'market':
+            return new MarketOrderNode(order, market, userAccount);
+        case 'trigger':
+            return new TriggerOrderNode(order, market, userAccount);
+        default:
+            throw Error(`Unknown DLOBNode type ${nodeType}`);
+    }
+}
+exports.createNode = createNode;

package/lib/dlob/NodeList.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="bn.js" />
+import { BN, MarketTypeStr, Order, PerpMarketAccount, SpotMarketAccount } from '..';
+import { PublicKey } from '@solana/web3.js';
+import { DLOBNode, DLOBNodeMap } from './DLOBNode';
+export declare type SortDirection = 'asc' | 'desc';
+export declare function getOrderSignature(orderId: number, userAccount: PublicKey): string;
+export interface DLOBNodeGenerator {
+    getGenerator(): Generator<DLOBNode>;
+}
+export declare class NodeList<NodeType extends keyof DLOBNodeMap> implements DLOBNodeGenerator {
+    private nodeType;
+    private sortDirection;
+    head?: DLOBNodeMap[NodeType];
+    length: number;
+    nodeMap: Map<string, DLOBNodeMap[NodeType]>;
+    constructor(nodeType: NodeType, sortDirection: SortDirection);
+    clear(): void;
+    insert(order: Order, marketType: MarketTypeStr, market: PerpMarketAccount | SpotMarketAccount, userAccount: PublicKey): void;
+    prependNode(currentNode: DLOBNodeMap[NodeType], newNode: DLOBNodeMap[NodeType]): boolean;
+    update(order: Order, userAccount: PublicKey): void;
+    remove(order: Order, userAccount: PublicKey): void;
+    getGenerator(): Generator<DLOBNode>;
+    has(order: Order, userAccount: PublicKey): boolean;
+    print(): void;
+    printTop(): void;
+}
+export declare function getVammNodeGenerator(price: BN | undefined): Generator<DLOBNode>;

package/lib/dlob/NodeList.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVammNodeGenerator = exports.NodeList = exports.getOrderSignature = void 0;
+const __1 = require("..");
+const DLOBNode_1 = require("./DLOBNode");
+function getOrderSignature(orderId, userAccount) {
+    return `${userAccount.toString()}-${orderId.toString()}`;
+}
+exports.getOrderSignature = getOrderSignature;
+class NodeList {
+    constructor(nodeType, sortDirection) {
+        this.nodeType = nodeType;
+        this.sortDirection = sortDirection;
+        this.length = 0;
+        this.nodeMap = new Map();
+    }
+    clear() {
+        this.head = undefined;
+        this.length = 0;
+        this.nodeMap.clear();
+    }
+    insert(order, marketType, market, userAccount) {
+        if ((0, __1.isVariant)(order.status, 'init')) {
+            return;
+        }
+        if (marketType === 'spot') {
+            market = market;
+        }
+        else if (marketType === 'perp') {
+            market = market;
+        }
+        const newNode = (0, DLOBNode_1.createNode)(this.nodeType, order, market, userAccount);
+        const orderSignature = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderSignature)) {
+            return;
+        }
+        this.nodeMap.set(orderSignature, newNode);
+        this.length += 1;
+        if (this.head === undefined) {
+            this.head = newNode;
+            return;
+        }
+        if (this.prependNode(this.head, newNode)) {
+            this.head.previous = newNode;
+            newNode.next = this.head;
+            this.head = newNode;
+            return;
+        }
+        let currentNode = this.head;
+        while (currentNode.next !== undefined &&
+            !this.prependNode(currentNode.next, newNode)) {
+            currentNode = currentNode.next;
+        }
+        newNode.next = currentNode.next;
+        if (currentNode.next !== undefined) {
+            newNode.next.previous = newNode;
+        }
+        currentNode.next = newNode;
+        newNode.previous = currentNode;
+    }
+    prependNode(currentNode, newNode) {
+        const currentOrder = currentNode.order;
+        const newOrder = newNode.order;
+        const currentOrderSortPrice = currentNode.sortValue;
+        const newOrderSortPrice = newNode.sortValue;
+        if (newOrderSortPrice.eq(currentOrderSortPrice)) {
+            return newOrder.slot.lt(currentOrder.slot);
+        }
+        if (this.sortDirection === 'asc') {
+            return newOrderSortPrice.lt(currentOrderSortPrice);
+        }
+        else {
+            return newOrderSortPrice.gt(currentOrderSortPrice);
+        }
+    }
+    update(order, userAccount) {
+        const orderId = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderId)) {
+            const node = this.nodeMap.get(orderId);
+            Object.assign(node.order, order);
+            node.haveFilled = false;
+        }
+    }
+    remove(order, userAccount) {
+        const orderId = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderId)) {
+            const node = this.nodeMap.get(orderId);
+            if (node.next) {
+                node.next.previous = node.previous;
+            }
+            if (node.previous) {
+                node.previous.next = node.next;
+            }
+            if (this.head && node.order.orderId === this.head.order.orderId) {
+                this.head = node.next;
+            }
+            node.previous = undefined;
+            node.next = undefined;
+            this.nodeMap.delete(orderId);
+            this.length--;
+        }
+    }
+    *getGenerator() {
+        let node = this.head;
+        while (node !== undefined) {
+            yield node;
+            node = node.next;
+        }
+    }
+    has(order, userAccount) {
+        return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
+    }
+    print() {
+        let currentNode = this.head;
+        while (currentNode !== undefined) {
+            console.log(currentNode.getLabel());
+            currentNode = currentNode.next;
+        }
+    }
+    printTop() {
+        if (this.head) {
+            console.log(this.sortDirection.toUpperCase(), this.head.getLabel());
+        }
+        else {
+            console.log('---');
+        }
+    }
+}
+exports.NodeList = NodeList;
+function* getVammNodeGenerator(price) {
+    if (!price) {
+        return;
+    }
+    yield {
+        getPrice: () => price,
+        isVammNode: () => true,
+        order: undefined,
+        market: undefined,
+        userAccount: undefined,
+        isBaseFilled: () => false,
+        haveFilled: false,
+    };
+}
+exports.getVammNodeGenerator = getVammNodeGenerator;

package/lib/driftClient.d.ts

@@ -0,0 +1,234 @@
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { AnchorProvider, BN, Program } from '@project-serum/anchor';
+import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, SerumV3FulfillmentConfigAccount } from './types';
+import * as anchor from '@project-serum/anchor';
+import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta } from '@solana/web3.js';
+import { TokenFaucet } from './tokenFaucet';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { DriftClientAccountSubscriber, DriftClientAccountEvents, DataAndSlot } from './accounts/types';
+import { TxSender } from './tx/types';
+import { OraclePriceData } from './oracles/types';
+import { DriftClientConfig } from './driftClientConfig';
+import { User } from './user';
+import { UserSubscriptionConfig } from './userConfig';
+import { UserStats } from './userStats';
+declare type RemainingAccountParams = {
+    userAccounts: UserAccount[];
+    writablePerpMarketIndexes?: number[];
+    writableSpotMarketIndexes?: number[];
+    readablePerpMarketIndex?: number;
+    readableSpotMarketIndexes?: number[];
+    useMarketLastSlotCache?: boolean;
+};
+/**
+ * # DriftClient
+ * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
+ */
+export declare class DriftClient {
+    connection: Connection;
+    wallet: IWallet;
+    program: Program;
+    provider: AnchorProvider;
+    opts?: ConfirmOptions;
+    users: Map<number, User>;
+    userStats?: UserStats;
+    activeSubAccountId: number;
+    userAccountSubscriptionConfig: UserSubscriptionConfig;
+    accountSubscriber: DriftClientAccountSubscriber;
+    eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
+    _isSubscribed: boolean;
+    txSender: TxSender;
+    perpMarketLastSlotCache: Map<number, number>;
+    spotMarketLastSlotCache: Map<number, number>;
+    authority: PublicKey;
+    get isSubscribed(): boolean;
+    set isSubscribed(val: boolean);
+    constructor(config: DriftClientConfig);
+    createUsers(subAccountIds: number[], accountSubscriptionConfig: UserSubscriptionConfig): void;
+    createUser(subAccountId: number, accountSubscriptionConfig: UserSubscriptionConfig): User;
+    subscribe(): Promise<boolean>;
+    subscribeUsers(): Promise<boolean>[];
+    /**
+     *	Forces the accountSubscriber to fetch account updates from rpc
+     */
+    fetchAccounts(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    unsubscribeUsers(): Promise<void>[];
+    statePublicKey?: PublicKey;
+    getStatePublicKey(): Promise<PublicKey>;
+    signerPublicKey?: PublicKey;
+    getSignerPublicKey(): PublicKey;
+    getStateAccount(): StateAccount;
+    getPerpMarketAccount(marketIndex: number): PerpMarketAccount | undefined;
+    getPerpMarketAccounts(): PerpMarketAccount[];
+    getSpotMarketAccount(marketIndex: number): SpotMarketAccount | undefined;
+    getSpotMarketAccounts(): SpotMarketAccount[];
+    getQuoteSpotMarketAccount(): SpotMarketAccount;
+    getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
+    getSerumV3FulfillmentConfig(serumMarket: PublicKey): Promise<SerumV3FulfillmentConfigAccount>;
+    /**
+     * Update the wallet to use for drift transactions and linked user account
+     * @param newWallet
+     * @param subAccountIds
+     * @param activeSubAccountId
+     */
+    updateWallet(newWallet: IWallet, subAccountIds?: number[], activeSubAccountId?: number): Promise<void>;
+    switchActiveUser(subAccountId: number): Promise<void>;
+    addUser(subAccountId: number): Promise<void>;
+    initializeUserAccount(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    getInitializeUserInstructions(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[PublicKey, TransactionInstruction]>;
+    getInitializeUserStatsIx(): Promise<TransactionInstruction>;
+    updateUserName(name: string, subAccountId?: number): Promise<TransactionSignature>;
+    updateUserCustomMarginRatio(marginRatio: number, subAccountId?: number): Promise<TransactionSignature>;
+    updateUserDelegate(delegate: PublicKey, subAccountId?: number): Promise<TransactionSignature>;
+    getUserAccountsForDelegate(delegate: PublicKey): Promise<UserAccount[]>;
+    getUserAccountsForAuthority(authority: PublicKey): Promise<UserAccount[]>;
+    deleteUser(subAccountId?: number): Promise<TransactionSignature>;
+    getUser(subAccountId?: number): User;
+    getUsers(): User[];
+    getUserStats(): UserStats;
+    userStatsAccountPublicKey: PublicKey;
+    getUserStatsAccountPublicKey(): PublicKey;
+    getUserAccountPublicKey(): Promise<PublicKey>;
+    getUserAccount(subAccountId?: number): UserAccount | undefined;
+    getUserAccountAndSlot(subAccountId?: number): DataAndSlot<UserAccount> | undefined;
+    getSpotPosition(marketIndex: number): SpotPosition | undefined;
+    getQuoteAssetTokenAmount(): BN;
+    getTokenAmount(marketIndex: number): BN;
+    getRemainingAccounts(params: RemainingAccountParams): AccountMeta[];
+    getRemainingAccountMapsForUsers(userAccounts: UserAccount[]): {
+        oracleAccountMap: Map<string, AccountMeta>;
+        spotMarketAccountMap: Map<number, AccountMeta>;
+        perpMarketAccountMap: Map<number, AccountMeta>;
+    };
+    getOrder(orderId: number): Order | undefined;
+    getOrderByUserId(userOrderId: number): Order | undefined;
+    deposit(amount: BN, marketIndex: number, collateralAccountPublicKey: PublicKey, subAccountId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
+    getDepositInstruction(amount: BN, marketIndex: number, userTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
+    private checkIfAccountExists;
+    private getWrappedSolAccountCreationIxs;
+    getAssociatedTokenAccountCreationIx(tokenMintAddress: PublicKey, associatedTokenAddress: PublicKey): anchor.web3.TransactionInstruction;
+    /**
+     * Creates the Clearing House User account for a user, and deposits some initial collateral
+     * @param amount
+     * @param userTokenAccount
+     * @param marketIndex
+     * @param subAccountId
+     * @param name
+     * @param fromSubAccountId
+     * @returns
+     */
+    initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, marketIndex?: number, subAccountId?: number, name?: string, fromSubAccountId?: number, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    initializeUserAccountForDevnet(subAccountId: number, name: string, marketIndex: number, tokenFaucet: TokenFaucet, amount: BN, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    withdraw(amount: BN, marketIndex: number, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionSignature>;
+    getWithdrawIx(amount: BN, marketIndex: number, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionInstruction>;
+    transferDeposit(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number): Promise<TransactionSignature>;
+    getTransferDepositIx(amount: BN, marketIndex: number, fromSubAccountId: number, toSubAccountId: number): Promise<TransactionInstruction>;
+    updateSpotMarketCumulativeInterest(marketIndex: number): Promise<TransactionSignature>;
+    updateSpotMarketCumulativeInterestIx(marketIndex: number): Promise<TransactionInstruction>;
+    settleLP(settleeUserAccountPublicKey: PublicKey, marketIndex: number): Promise<TransactionSignature>;
+    settleLPIx(settleeUserAccountPublicKey: PublicKey, marketIndex: number): Promise<TransactionInstruction>;
+    removePerpLpShares(marketIndex: number, sharesToBurn?: BN): Promise<TransactionSignature>;
+    removePerpLpSharesInExpiringMarket(marketIndex: number, userAccountPublicKey: PublicKey, sharesToBurn?: BN): Promise<TransactionSignature>;
+    getRemovePerpLpSharesInExpiringMarket(marketIndex: number, userAccountPublicKey: PublicKey, sharesToBurn?: BN): Promise<TransactionInstruction>;
+    getRemovePerpLpSharesIx(marketIndex: number, sharesToBurn?: BN): Promise<TransactionInstruction>;
+    addPerpLpShares(amount: BN, marketIndex: number): Promise<TransactionSignature>;
+    getAddPerpLpSharesIx(amount: BN, marketIndex: number): Promise<TransactionInstruction>;
+    openPosition(direction: PositionDirection, amount: BN, marketIndex: number, limitPrice?: BN): Promise<TransactionSignature>;
+    sendSignedTx(tx: Transaction): Promise<TransactionSignature>;
+    /**
+     * Sends a market order and returns a signed tx which can fill the order against the vamm, which the caller can use to fill their own order if required.
+     * @param orderParams
+     * @param userAccountPublicKey
+     * @param userAccount
+     * @returns
+     */
+    sendMarketOrderAndGetSignedFillTx(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<{
+        txSig: TransactionSignature;
+        signedFillTx: Transaction;
+    }>;
+    placePerpOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
+    getOrderParams(optionalOrderParams: OptionalOrderParams, marketType: MarketType): OrderParams;
+    getPlacePerpOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
+    updateAMMs(marketIndexes: number[]): Promise<TransactionSignature>;
+    getUpdateAMMsIx(marketIndexes: number[]): Promise<TransactionInstruction>;
+    settleExpiredMarket(marketIndex: number): Promise<TransactionSignature>;
+    getSettleExpiredMarketIx(marketIndex: number): Promise<TransactionInstruction>;
+    settleExpiredMarketPoolsToRevenuePool(perpMarketIndex: number): Promise<TransactionSignature>;
+    cancelOrder(orderId?: number): Promise<TransactionSignature>;
+    getCancelOrderIx(orderId?: number): Promise<TransactionInstruction>;
+    cancelOrderByUserId(userOrderId: number): Promise<TransactionSignature>;
+    getCancelOrderByUserIdIx(userOrderId: number): Promise<TransactionInstruction>;
+    cancelOrders(marketType?: MarketType, marketIndex?: number, direction?: PositionDirection): Promise<TransactionSignature>;
+    getCancelOrdersIx(marketType: MarketType | null, marketIndex: number | null, direction: PositionDirection | null): Promise<TransactionInstruction>;
+    fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    placeSpotOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
+    getPlaceSpotOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
+    fillSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    addSpotFulfillmentAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig?: SerumV3FulfillmentConfigAccount): void;
+    addSerumRemainingAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig: SerumV3FulfillmentConfigAccount): void;
+    triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
+    getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
+    placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    placeAndTakeSpotOrder(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getPlaceAndTakeSpotOrderIx(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    placeAndMakeSpotOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getPlaceAndMakeSpotOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    /**
+     * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
+     * @param marketIndex
+     * @returns
+     */
+    closePosition(marketIndex: number, limitPrice?: BN): Promise<TransactionSignature>;
+    /**
+     * Modifies an open order by closing it and replacing it with a new order.
+     * @param orderId: The open order to modify
+     * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @returns
+     */
+    modifyPerpOrder(orderId: number, newBaseAmount?: BN, newLimitPrice?: BN, newOraclePriceOffset?: number): Promise<TransactionSignature>;
+    settlePNLs(users: {
+        settleeUserAccountPublicKey: PublicKey;
+        settleeUserAccount: UserAccount;
+    }[], marketIndex: number): Promise<TransactionSignature>;
+    settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
+    settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
+    liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN, limitPrice?: BN): Promise<TransactionSignature>;
+    getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN, limitPrice?: BN): Promise<TransactionInstruction>;
+    liquidateSpot(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN): Promise<TransactionSignature>;
+    getLiquidateSpotIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN): Promise<TransactionInstruction>;
+    liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN): Promise<TransactionSignature>;
+    getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN): Promise<TransactionInstruction>;
+    liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN, limitPrice?: BN): Promise<TransactionSignature>;
+    getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN, limitPrice?: BN): Promise<TransactionInstruction>;
+    resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
+    getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
+    resolveSpotBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
+    getResolveSpotBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
+    updateFundingRate(perpMarketIndex: number, oracle: PublicKey): Promise<TransactionSignature>;
+    getUpdateFundingRateIx(perpMarketIndex: number, oracle: PublicKey): Promise<TransactionInstruction>;
+    settleFundingPayment(userAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    getSettleFundingPaymentIx(userAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
+    triggerEvent(eventName: keyof DriftClientAccountEvents, data?: any): void;
+    getOracleDataForPerpMarket(marketIndex: number): OraclePriceData;
+    getOracleDataForSpotMarket(marketIndex: number): OraclePriceData;
+    initializeInsuranceFundStake(marketIndex: number): Promise<TransactionSignature>;
+    getInitializeInsuranceFundStakeIx(marketIndex: number): Promise<TransactionInstruction>;
+    addInsuranceFundStake(marketIndex: number, amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    requestRemoveInsuranceFundStake(marketIndex: number, amount: BN): Promise<TransactionSignature>;
+    cancelRequestRemoveInsuranceFundStake(marketIndex: number): Promise<TransactionSignature>;
+    removeInsuranceFundStake(marketIndex: number, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    settleRevenueToInsuranceFund(marketIndex: number): Promise<TransactionSignature>;
+    resolvePerpPnlDeficit(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionSignature>;
+    getResolvePerpPnlDeficitIx(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionInstruction>;
+}
+export {};