@drift-labs/sdk 2.145.0-beta.2 → 2.145.0

package/lib/browser/constituentMap/constituentMap.d.ts

@@ -0,0 +1,64 @@
+import { Commitment, Connection, MemcmpFilter } from '@solana/web3.js';
+import { DataAndSlot } from '../accounts/types';
+import { ConstituentAccount } from '../types';
+import { DriftClient } from '../driftClient';
+export type ConstituentMapConfig = {
+    driftClient: DriftClient;
+    connection?: Connection;
+    subscriptionConfig: {
+        type: 'polling';
+        frequency: number;
+        commitment?: Commitment;
+    } | {
+        type: 'websocket';
+        resubTimeoutMs?: number;
+        logResubMessages?: boolean;
+        commitment?: Commitment;
+    };
+    lpPoolId?: number;
+    additionalFilters?: MemcmpFilter[];
+};
+export interface ConstituentMapInterface {
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    has(key: string): boolean;
+    get(key: string): ConstituentAccount | undefined;
+    getFromSpotMarketIndex(spotMarketIndex: number): ConstituentAccount | undefined;
+    getFromConstituentIndex(constituentIndex: number): ConstituentAccount | undefined;
+    getWithSlot(key: string): DataAndSlot<ConstituentAccount> | undefined;
+    mustGet(key: string): Promise<ConstituentAccount>;
+    mustGetWithSlot(key: string): Promise<DataAndSlot<ConstituentAccount>>;
+}
+export declare class ConstituentMap implements ConstituentMapInterface {
+    private driftClient;
+    private constituentMap;
+    private constituentAccountSubscriber;
+    private additionalFilters?;
+    private commitment?;
+    private connection?;
+    private constituentIndexToKeyMap;
+    private spotMarketIndexToKeyMap;
+    private lpPoolId;
+    constructor(config: ConstituentMapConfig);
+    private getFilters;
+    private decode;
+    sync(): Promise<void>;
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    has(key: string): boolean;
+    get(key: string): ConstituentAccount | undefined;
+    getFromConstituentIndex(constituentIndex: number): ConstituentAccount | undefined;
+    getFromSpotMarketIndex(spotMarketIndex: number): ConstituentAccount | undefined;
+    getWithSlot(key: string): DataAndSlot<ConstituentAccount> | undefined;
+    mustGet(key: string): Promise<ConstituentAccount>;
+    mustGetWithSlot(key: string): Promise<DataAndSlot<ConstituentAccount>>;
+    size(): number;
+    values(): IterableIterator<ConstituentAccount>;
+    valuesWithSlot(): IterableIterator<DataAndSlot<ConstituentAccount>>;
+    entries(): IterableIterator<[string, ConstituentAccount]>;
+    entriesWithSlot(): IterableIterator<[
+        string,
+        DataAndSlot<ConstituentAccount>
+    ]>;
+    updateConstituentAccount(key: string, constituentAccount: ConstituentAccount, slot: number): void;
+}

package/lib/browser/constituentMap/constituentMap.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstituentMap = void 0;
+const pollingConstituentAccountSubscriber_1 = require("./pollingConstituentAccountSubscriber");
+const webSocketConstituentAccountSubscriber_1 = require("./webSocketConstituentAccountSubscriber");
+const memcmp_1 = require("../memcmp");
+const zstddec_1 = require("zstddec");
+const pda_1 = require("../addresses/pda");
+const MAX_CONSTITUENT_SIZE_BYTES = 480; // TODO: update this when account is finalized
+class ConstituentMap {
+    constructor(config) {
+        var _a;
+        this.constituentMap = new Map();
+        this.constituentIndexToKeyMap = new Map();
+        this.spotMarketIndexToKeyMap = new Map();
+        this.driftClient = config.driftClient;
+        this.additionalFilters = config.additionalFilters;
+        this.commitment = config.subscriptionConfig.commitment;
+        this.connection = config.connection || this.driftClient.connection;
+        this.lpPoolId = (_a = config.lpPoolId) !== null && _a !== void 0 ? _a : 0;
+        if (config.subscriptionConfig.type === 'polling') {
+            this.constituentAccountSubscriber =
+                new pollingConstituentAccountSubscriber_1.PollingConstituentAccountSubscriber(this, this.driftClient.program, config.subscriptionConfig.frequency, config.subscriptionConfig.commitment, this.getFilters());
+        }
+        else if (config.subscriptionConfig.type === 'websocket') {
+            this.constituentAccountSubscriber =
+                new webSocketConstituentAccountSubscriber_1.WebSocketConstituentAccountSubscriber(this, this.driftClient.program, config.subscriptionConfig.resubTimeoutMs, config.subscriptionConfig.commitment, this.getFilters());
+        }
+        // Listen for account updates from the subscriber
+        this.constituentAccountSubscriber.eventEmitter.on('onAccountUpdate', (account, pubkey, slot) => {
+            this.updateConstituentAccount(pubkey.toString(), account, slot);
+        });
+    }
+    getFilters() {
+        const filters = [
+            (0, memcmp_1.getConstituentFilter)(),
+            (0, memcmp_1.getConstituentLpPoolFilter)((0, pda_1.getLpPoolPublicKey)(this.driftClient.program.programId, this.lpPoolId)),
+        ];
+        if (this.additionalFilters) {
+            filters.push(...this.additionalFilters);
+        }
+        return filters;
+    }
+    decode(name, buffer) {
+        return this.driftClient.program.account.constituent.coder.accounts.decodeUnchecked(name, buffer);
+    }
+    async sync() {
+        try {
+            const rpcRequestArgs = [
+                this.driftClient.program.programId.toBase58(),
+                {
+                    commitment: this.commitment,
+                    filters: this.getFilters(),
+                    encoding: 'base64+zstd',
+                    withContext: true,
+                },
+            ];
+            // @ts-ignore
+            const rpcJSONResponse = await this.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
+            const rpcResponseAndContext = rpcJSONResponse.result;
+            const slot = rpcResponseAndContext.context.slot;
+            const promises = rpcResponseAndContext.value.map(async (programAccount) => {
+                const compressedUserData = Buffer.from(programAccount.account.data[0], 'base64');
+                const decoder = new zstddec_1.ZSTDDecoder();
+                await decoder.init();
+                const buffer = Buffer.from(decoder.decode(compressedUserData, MAX_CONSTITUENT_SIZE_BYTES));
+                const key = programAccount.pubkey.toString();
+                const currAccountWithSlot = this.getWithSlot(key);
+                if (currAccountWithSlot) {
+                    if (slot >= currAccountWithSlot.slot) {
+                        const constituentAcc = this.decode('Constituent', buffer);
+                        this.updateConstituentAccount(key, constituentAcc, slot);
+                    }
+                }
+                else {
+                    const constituentAcc = this.decode('Constituent', buffer);
+                    this.updateConstituentAccount(key, constituentAcc, slot);
+                }
+            });
+            await Promise.all(promises);
+        }
+        catch (error) {
+            console.log(`ConstituentMap.sync() error: ${error.message}`);
+        }
+    }
+    async subscribe() {
+        await this.constituentAccountSubscriber.subscribe();
+    }
+    async unsubscribe() {
+        await this.constituentAccountSubscriber.unsubscribe();
+        this.constituentMap.clear();
+    }
+    has(key) {
+        return this.constituentMap.has(key);
+    }
+    get(key) {
+        var _a;
+        return (_a = this.constituentMap.get(key)) === null || _a === void 0 ? void 0 : _a.data;
+    }
+    getFromConstituentIndex(constituentIndex) {
+        const key = this.constituentIndexToKeyMap.get(constituentIndex);
+        return key ? this.get(key) : undefined;
+    }
+    getFromSpotMarketIndex(spotMarketIndex) {
+        const key = this.spotMarketIndexToKeyMap.get(spotMarketIndex);
+        return key ? this.get(key) : undefined;
+    }
+    getWithSlot(key) {
+        return this.constituentMap.get(key);
+    }
+    async mustGet(key) {
+        if (!this.has(key)) {
+            await this.sync();
+        }
+        const result = this.constituentMap.get(key);
+        if (!result) {
+            throw new Error(`ConstituentAccount not found for key: ${key}`);
+        }
+        return result.data;
+    }
+    async mustGetWithSlot(key) {
+        if (!this.has(key)) {
+            await this.sync();
+        }
+        const result = this.constituentMap.get(key);
+        if (!result) {
+            throw new Error(`ConstituentAccount not found for key: ${key}`);
+        }
+        return result;
+    }
+    size() {
+        return this.constituentMap.size;
+    }
+    *values() {
+        for (const dataAndSlot of this.constituentMap.values()) {
+            yield dataAndSlot.data;
+        }
+    }
+    valuesWithSlot() {
+        return this.constituentMap.values();
+    }
+    *entries() {
+        for (const [key, dataAndSlot] of this.constituentMap.entries()) {
+            yield [key, dataAndSlot.data];
+        }
+    }
+    entriesWithSlot() {
+        return this.constituentMap.entries();
+    }
+    updateConstituentAccount(key, constituentAccount, slot) {
+        const existingData = this.getWithSlot(key);
+        if (existingData) {
+            if (slot >= existingData.slot) {
+                this.constituentMap.set(key, {
+                    data: constituentAccount,
+                    slot,
+                });
+            }
+        }
+        else {
+            this.constituentMap.set(key, {
+                data: constituentAccount,
+                slot,
+            });
+        }
+        this.constituentIndexToKeyMap.set(constituentAccount.constituentIndex, key);
+        this.spotMarketIndexToKeyMap.set(constituentAccount.spotMarketIndex, key);
+    }
+}
+exports.ConstituentMap = ConstituentMap;

package/lib/browser/constituentMap/pollingConstituentAccountSubscriber.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ConstituentAccountEvents, ConstituentAccountSubscriber } from '../accounts/types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, MemcmpFilter } from '@solana/web3.js';
+import { ConstituentMap } from './constituentMap';
+export declare class PollingConstituentAccountSubscriber implements ConstituentAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    frequency: number;
+    commitment?: Commitment;
+    additionalFilters?: MemcmpFilter[];
+    eventEmitter: StrictEventEmitter<EventEmitter, ConstituentAccountEvents>;
+    intervalId?: NodeJS.Timeout;
+    constituentMap: ConstituentMap;
+    constructor(constituentMap: ConstituentMap, program: Program, frequency: number, commitment?: Commitment, additionalFilters?: MemcmpFilter[]);
+    subscribe(): Promise<boolean>;
+    sync(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    didSubscriptionSucceed(): boolean;
+}

package/lib/browser/constituentMap/pollingConstituentAccountSubscriber.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingConstituentAccountSubscriber = void 0;
+const types_1 = require("../accounts/types");
+const events_1 = require("events");
+class PollingConstituentAccountSubscriber {
+    constructor(constituentMap, program, frequency, commitment, additionalFilters) {
+        this.constituentMap = constituentMap;
+        this.isSubscribed = false;
+        this.program = program;
+        this.frequency = frequency;
+        this.commitment = commitment;
+        this.additionalFilters = additionalFilters;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        if (this.isSubscribed || this.frequency <= 0) {
+            return true;
+        }
+        const executeSync = async () => {
+            await this.sync();
+            this.intervalId = setTimeout(executeSync, this.frequency);
+        };
+        // Initial sync
+        await this.sync();
+        // Start polling
+        this.intervalId = setTimeout(executeSync, this.frequency);
+        this.isSubscribed = true;
+        return true;
+    }
+    async sync() {
+        try {
+            await this.constituentMap.sync();
+            this.eventEmitter.emit('update');
+        }
+        catch (error) {
+            console.log(`PollingConstituentAccountSubscriber.sync() error: ${error.message}`);
+            this.eventEmitter.emit('error', error);
+        }
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        if (this.intervalId) {
+            clearTimeout(this.intervalId);
+            this.intervalId = undefined;
+        }
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    didSubscriptionSucceed() {
+        return this.isSubscribed;
+    }
+}
+exports.PollingConstituentAccountSubscriber = PollingConstituentAccountSubscriber;

package/lib/browser/constituentMap/webSocketConstituentAccountSubscriber.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { ConstituentAccountEvents, ConstituentAccountSubscriber } from '../accounts/types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, MemcmpFilter } from '@solana/web3.js';
+import { ConstituentAccount } from '../types';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { ConstituentMap } from './constituentMap';
+export declare class WebSocketConstituentAccountSubscriber implements ConstituentAccountSubscriber {
+    isSubscribed: boolean;
+    resubTimeoutMs?: number;
+    commitment?: Commitment;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, ConstituentAccountEvents>;
+    constituentDataAccountSubscriber: WebSocketProgramAccountSubscriber<ConstituentAccount>;
+    constituentMap: ConstituentMap;
+    private additionalFilters?;
+    constructor(constituentMap: ConstituentMap, program: Program, resubTimeoutMs?: number, commitment?: Commitment, additionalFilters?: MemcmpFilter[]);
+    subscribe(): Promise<boolean>;
+    sync(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+}

package/lib/browser/constituentMap/webSocketConstituentAccountSubscriber.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketConstituentAccountSubscriber = void 0;
+const types_1 = require("../accounts/types");
+const events_1 = require("events");
+const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
+const memcmp_1 = require("../memcmp");
+class WebSocketConstituentAccountSubscriber {
+    constructor(constituentMap, program, resubTimeoutMs, commitment, additionalFilters) {
+        this.constituentMap = constituentMap;
+        this.isSubscribed = false;
+        this.program = program;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.resubTimeoutMs = resubTimeoutMs;
+        this.commitment = commitment;
+        this.additionalFilters = additionalFilters;
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.constituentDataAccountSubscriber =
+            new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('LpPoolConstituent', 'Constituent', this.program, this.program.account.constituent.coder.accounts.decode.bind(this.program.account.constituent.coder.accounts), {
+                filters: [(0, memcmp_1.getConstituentFilter)(), ...(this.additionalFilters || [])],
+                commitment: this.commitment,
+            });
+        await this.constituentDataAccountSubscriber.subscribe((accountId, account, context) => {
+            this.constituentMap.updateConstituentAccount(accountId.toBase58(), account, context.slot);
+            this.eventEmitter.emit('onAccountUpdate', account, accountId, context.slot);
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+    async sync() {
+        try {
+            await this.constituentMap.sync();
+            this.eventEmitter.emit('update');
+        }
+        catch (error) {
+            console.log(`WebSocketConstituentAccountSubscriber.sync() error: ${error.message}`);
+            this.eventEmitter.emit('error', error);
+        }
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await Promise.all([this.constituentDataAccountSubscriber.unsubscribe()]);
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+}
+exports.WebSocketConstituentAccountSubscriber = WebSocketConstituentAccountSubscriber;

package/lib/browser/driftClient.d.ts

@@ -5,7 +5,7 @@
 import * as anchor from '@coral-xyz/anchor';
 import { AnchorProvider, BN, Program, ProgramAccount } from '@coral-xyz/anchor';
 import { Idl as Idl30, Program as Program30 } from '@coral-xyz/anchor-30';
-import { DriftClientMetricsEvents, HighLeverageModeConfig, IWallet, MakerInfo, MappedRecord, MarketType, ModifyOrderPolicy, OpenbookV2FulfillmentConfigAccount, OptionalOrderParams, OracleSource, Order, OrderParams, OrderTriggerCondition, PerpMarketAccount, PerpMarketExtendedInfo, PhoenixV1FulfillmentConfigAccount, PlaceAndTakeOrderSuccessCondition, PositionDirection, ReferrerInfo, ReferrerNameAccount, SerumV3FulfillmentConfigAccount, SettlePnlMode, SignedTxData, SpotMarketAccount, SpotPosition, StateAccount, SwapReduceOnly, SignedMsgOrderParamsMessage, TakerInfo, TxParams, UserAccount, UserStatsAccount, ProtectedMakerModeConfig, SignedMsgOrderParamsDelegateMessage, PostOnlyParams } from './types';
+import { DriftClientMetricsEvents, HighLeverageModeConfig, IWallet, MakerInfo, MappedRecord, MarketType, ModifyOrderPolicy, OpenbookV2FulfillmentConfigAccount, OptionalOrderParams, OracleSource, Order, OrderParams, OrderTriggerCondition, PerpMarketAccount, PerpMarketExtendedInfo, PhoenixV1FulfillmentConfigAccount, PlaceAndTakeOrderSuccessCondition, PositionDirection, ReferrerInfo, ReferrerNameAccount, SerumV3FulfillmentConfigAccount, SettlePnlMode, SignedTxData, SpotMarketAccount, SpotPosition, StateAccount, SwapReduceOnly, SignedMsgOrderParamsMessage, TakerInfo, TxParams, UserAccount, UserStatsAccount, ProtectedMakerModeConfig, SignedMsgOrderParamsDelegateMessage, PostOnlyParams, LPPoolAccount, ConstituentAccount, ConstituentTargetBaseAccount, AmmCache } from './types';
 import { AccountMeta, AddressLookupTableAccount, BlockhashWithExpiryBlockHeight, ConfirmOptions, Connection, Keypair, PublicKey, Signer, Transaction, TransactionInstruction, TransactionSignature, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
@@ -26,6 +26,7 @@ import { WormholeCoreBridgeSolana } from '@pythnetwork/pyth-solana-receiver/lib/
 import { PythSolanaReceiver } from '@pythnetwork/pyth-solana-receiver/lib/idl/pyth_solana_receiver';
 import { Slothash } from './slot/SlothashSubscriber';
 import { SignedMsgOrderParams } from './types';
+import { ConstituentMap } from './constituentMap/constituentMap';
 import { RevenueShareEscrowMap } from './userMap/revenueShareEscrowMap';
 import { TitanClient } from './titan/titanClient';
 import { UnifiedSwapClient } from './swap/UnifiedSwapClient';
@@ -351,7 +352,7 @@ export declare class DriftClient {
      * @param useNative
      * @param tokenProgram
      */
-    getAssociatedTokenAccount(marketIndex: number, useNative?: boolean, tokenProgram?: anchor.web3.PublicKey): Promise<PublicKey>;
+    getAssociatedTokenAccount(marketIndex: number, useNative?: boolean, tokenProgram?: anchor.web3.PublicKey, authority?: anchor.web3.PublicKey, allowOwnerOffCurve?: boolean): Promise<PublicKey>;
     createAssociatedTokenAccountIdempotentInstruction(account: PublicKey, payer: PublicKey, owner: PublicKey, mint: PublicKey, tokenProgram?: anchor.web3.PublicKey): TransactionInstruction;
     getDepositTxnIx(amount: BN, marketIndex: number, associatedTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean): Promise<TransactionInstruction[]>;
     buildSwiftDepositTx(signedOrderParams: SignedMsgOrderParams, takerInfo: {
@@ -1098,6 +1099,92 @@ export declare class DriftClient {
     getUpdateMmOracleNativeIx(marketIndex: number, oraclePrice: BN, oracleSequenceId: BN): Promise<TransactionInstruction>;
     updateAmmSpreadAdjustmentNative(marketIndex: number, ammSpreadAdjustment: number): Promise<TransactionSignature>;
     getUpdateAmmSpreadAdjustmentNativeIx(marketIndex: number, ammSpreadAdjustment: number): TransactionInstruction;
+    getLpPoolAccount(lpPoolId: number): Promise<LPPoolAccount>;
+    getConstituentTargetBaseAccount(lpPoolId: number): Promise<ConstituentTargetBaseAccount>;
+    getAmmCache(): Promise<AmmCache>;
+    updateLpConstituentTargetBase(lpPoolId: number, constituents: PublicKey[], txParams?: TxParams): Promise<TransactionSignature>;
+    getUpdateLpConstituentTargetBaseIx(lpPoolId: number, constituents: PublicKey[]): Promise<TransactionInstruction>;
+    updateLpPoolAum(lpPool: LPPoolAccount, spotMarketIndexOfConstituents: number[], txParams?: TxParams): Promise<TransactionSignature>;
+    getUpdateLpPoolAumIxs(lpPool: LPPoolAccount, spotMarketIndexOfConstituents: number[]): Promise<TransactionInstruction>;
+    updateAmmCache(perpMarketIndexes: number[], txParams?: TxParams): Promise<TransactionSignature>;
+    getUpdateAmmCacheIx(perpMarketIndexes: number[]): Promise<TransactionInstruction>;
+    updateConstituentOracleInfo(constituent: ConstituentAccount): Promise<TransactionSignature>;
+    getUpdateConstituentOracleInfoIx(constituent: ConstituentAccount): Promise<TransactionInstruction>;
+    lpPoolSwap(inMarketIndex: number, outMarketIndex: number, inAmount: BN, minOutAmount: BN, lpPool: PublicKey, userAuthority: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    getLpPoolSwapIx(inMarketIndex: number, outMarketIndex: number, inAmount: BN, minOutAmount: BN, lpPool: PublicKey, userAuthority: PublicKey): Promise<TransactionInstruction>;
+    viewLpPoolSwapFees(inMarketIndex: number, outMarketIndex: number, inAmount: BN, inTargetWeight: BN, outTargetWeight: BN, lpPool: PublicKey, constituentTargetBase: PublicKey, constituentInTokenAccount: PublicKey, constituentOutTokenAccount: PublicKey, inConstituent: PublicKey, outConstituent: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    getViewLpPoolSwapFeesIx(inMarketIndex: number, outMarketIndex: number, inAmount: BN, inTargetWeight: BN, outTargetWeight: BN, lpPool: PublicKey, constituentTargetBase: PublicKey, constituentInTokenAccount: PublicKey, constituentOutTokenAccount: PublicKey, inConstituent: PublicKey, outConstituent: PublicKey): Promise<TransactionInstruction>;
+    getCreateLpPoolTokenAccountIx(lpPool: LPPoolAccount): Promise<TransactionInstruction>;
+    createLpPoolTokenAccount(lpPool: LPPoolAccount, txParams?: TxParams): Promise<TransactionSignature>;
+    lpPoolAddLiquidity({ inMarketIndex, inAmount, minMintAmount, lpPool, txParams, }: {
+        inMarketIndex: number;
+        inAmount: BN;
+        minMintAmount: BN;
+        lpPool: LPPoolAccount;
+        txParams?: TxParams;
+    }): Promise<TransactionSignature>;
+    getLpPoolAddLiquidityIx({ inMarketIndex, inAmount, minMintAmount, lpPool, }: {
+        inMarketIndex: number;
+        inAmount: BN;
+        minMintAmount: BN;
+        lpPool: LPPoolAccount;
+    }): Promise<TransactionInstruction[]>;
+    viewLpPoolAddLiquidityFees({ inMarketIndex, inAmount, lpPool, txParams, }: {
+        inMarketIndex: number;
+        inAmount: BN;
+        lpPool: LPPoolAccount;
+        txParams?: TxParams;
+    }): Promise<TransactionSignature>;
+    getViewLpPoolAddLiquidityFeesIx({ inMarketIndex, inAmount, lpPool, }: {
+        inMarketIndex: number;
+        inAmount: BN;
+        lpPool: LPPoolAccount;
+    }): Promise<TransactionInstruction>;
+    lpPoolRemoveLiquidity({ outMarketIndex, lpToBurn, minAmountOut, lpPool, txParams, }: {
+        outMarketIndex: number;
+        lpToBurn: BN;
+        minAmountOut: BN;
+        lpPool: LPPoolAccount;
+        txParams?: TxParams;
+    }): Promise<TransactionSignature>;
+    getLpPoolRemoveLiquidityIx({ outMarketIndex, lpToBurn, minAmountOut, lpPool, }: {
+        outMarketIndex: number;
+        lpToBurn: BN;
+        minAmountOut: BN;
+        lpPool: LPPoolAccount;
+    }): Promise<TransactionInstruction[]>;
+    viewLpPoolRemoveLiquidityFees({ outMarketIndex, lpToBurn, lpPool, txParams, }: {
+        outMarketIndex: number;
+        lpToBurn: BN;
+        lpPool: LPPoolAccount;
+        txParams?: TxParams;
+    }): Promise<TransactionSignature>;
+    getViewLpPoolRemoveLiquidityFeesIx({ outMarketIndex, lpToBurn, lpPool, }: {
+        outMarketIndex: number;
+        lpToBurn: BN;
+        lpPool: LPPoolAccount;
+    }): Promise<TransactionInstruction>;
+    getAllLpPoolAddLiquidityIxs({ inMarketIndex, inAmount, minMintAmount, lpPool, }: {
+        inMarketIndex: number;
+        inAmount: BN;
+        minMintAmount: BN;
+        lpPool: LPPoolAccount;
+    }, constituentMap: ConstituentMap, includeUpdateConstituentOracleInfo?: boolean, view?: boolean): Promise<TransactionInstruction[]>;
+    getAllLpPoolRemoveLiquidityIxs({ outMarketIndex, lpToBurn, minAmountOut, lpPool, }: {
+        outMarketIndex: number;
+        lpToBurn: BN;
+        minAmountOut: BN;
+        lpPool: LPPoolAccount;
+    }, constituentMap: ConstituentMap, includeUpdateConstituentOracleInfo?: boolean, view?: boolean): Promise<TransactionInstruction[]>;
+    getAllUpdateLpPoolAumIxs(lpPool: LPPoolAccount, constituentMap: ConstituentMap, includeUpdateConstituentOracleInfo?: boolean): Promise<TransactionInstruction[]>;
+    getAllUpdateConstituentTargetBaseIxs(perpMarketIndexes: number[], lpPool: LPPoolAccount, constituentMap: ConstituentMap, includeUpdateConstituentOracleInfo?: boolean): Promise<TransactionInstruction[]>;
+    getAllLpPoolSwapIxs(lpPool: LPPoolAccount, constituentMap: ConstituentMap, inMarketIndex: number, outMarketIndex: number, inAmount: BN, minOutAmount: BN, userAuthority: PublicKey): Promise<TransactionInstruction[]>;
+    settlePerpToLpPool(lpPoolId: number, perpMarketIndexes: number[]): Promise<TransactionSignature>;
+    getSettlePerpToLpPoolIx(lpPoolId: number, perpMarketIndexes: number[]): Promise<TransactionInstruction>;
+    getAllSettlePerpToLpPoolIxs(lpPoolId: number, marketIndexes: number[]): Promise<TransactionInstruction[]>;
+    /**
+     * Below here are the transaction sending functions
+     */
     private handleSignedTransaction;
     private handlePreSignedTransaction;
     private isVersionedTransaction;