@kamino-finance/kliquidity-sdk 6.0.0

package/dist/Kamino.d.ts

@@ -0,0 +1,962 @@
+import { HubbleConfig, SolanaCluster } from '@hubbleprotocol/hubble-config';
+import { AccountInfo, Connection, PublicKey, TransactionInstruction, AddressLookupTableAccount, MessageV0, Keypair, ParsedAccountData } from '@solana/web3.js';
+import { GlobalConfig, TermsSignature, WhirlpoolStrategy } from './kamino-client/accounts';
+import Decimal from 'decimal.js';
+import { Position, Whirlpool } from './whirlpools-client';
+import { KaminoPosition, KaminoStrategyWithShareMint, ShareData, ShareDataWithAddress, StrategyHolder, StrategyWithPendingFees, TokenAmounts, TotalStrategyVaultTokens } from './models';
+import { OraclePrices } from '@hubbleprotocol/scope-sdk';
+import { DepositAmountsForSwap, Dex, GenericPoolInfo, GenericPositionRangeInfo, LiquidityDistribution, RebalanceFieldInfo, StrategiesFilters, VaultParameters, PositionRange, TokensBalances, SwapperIxBuilder, InstructionsWithLookupTables, ProfiledFunctionExecution, MaybeTokensBalances, PerformanceFees, PriceReferenceType, InputRebalanceFieldInfo, InitStrategyIxs, WithdrawShares, MetadataProgramAddressesOrca, MetadataProgramAddressesRaydium, WithdrawAllAndCloseIxns, InitPoolTickIfNeeded } from './utils';
+import { MintInfo } from '@solana/spl-token';
+import BN from 'bn.js';
+import StrategyWithAddress from './models/StrategyWithAddress';
+import { Idl, Program } from '@coral-xyz/anchor';
+import { CollateralInfo, ExecutiveWithdrawActionKind, RebalanceTypeKind, ReferencePriceTypeKind, StrategyStatusKind } from './kamino-client/types';
+import { AmmConfig, PersonalPositionState, PoolState } from './raydium_client';
+import { Whirlpool as OrcaPool, WhirlpoolAprApy } from './services';
+import { Pool } from './services/RaydiumPoolsResponse';
+import { RebalanceMethod } from './utils/CreationParameters';
+import { SimulationPercentagePoolParameters } from './services/PoolSimulationService';
+import { StrategyPrices } from './models';
+import WhirlpoolWithAddress from './models/WhirlpoolWithAddress';
+import { PoolSimulationResponse } from './models/PoolSimulationResponseData';
+import { KaminoPrices } from './models';
+import { MeteoraPool } from './services/MeteoraService';
+import { LbPair, PositionV2 } from './meteora_client/accounts';
+import LbPairWithAddress from './models/LbPairWithAddress';
+import { PubkeyHashMap } from './utils/pubkey';
+export declare const KAMINO_IDL: {
+    version: string;
+    name: string;
+    instructions: ({
+        name: string;
+        accounts: {
+            name: string;
+            isMut: boolean;
+            isSigner: boolean;
+        }[];
+        args: ({
+            name: string;
+            type: string;
+        } | {
+            name: string;
+            type: {
+                array: (string | number)[];
+            };
+        })[];
+        docs?: undefined;
+    } | {
+        name: string;
+        accounts: {
+            name: string;
+            isMut: boolean;
+            isSigner: boolean;
+        }[];
+        args: ({
+            name: string;
+            type: string;
+        } | {
+            name: string;
+            type: {
+                defined: string;
+            };
+        })[];
+        docs?: undefined;
+    } | {
+        name: string;
+        accounts: ({
+            name: string;
+            isMut: boolean;
+            isSigner: boolean;
+            docs?: undefined;
+            isOptional?: undefined;
+        } | {
+            name: string;
+            isMut: boolean;
+            isSigner: boolean;
+            docs: string[];
+            isOptional?: undefined;
+        } | {
+            name: string;
+            isMut: boolean;
+            isSigner: boolean;
+            isOptional: boolean;
+            docs?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        docs?: undefined;
+    } | {
+        name: string;
+        docs: string[];
+        accounts: {
+            name: string;
+            isMut: boolean;
+            isSigner: boolean;
+        }[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+    })[];
+    accounts: ({
+        name: string;
+        docs: string[];
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: string;
+            } | {
+                name: string;
+                type: {
+                    array: (string | number)[];
+                };
+            } | {
+                name: string;
+                type: {
+                    array: (number | {
+                        defined: string;
+                    })[];
+                };
+            })[];
+        };
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                docs: string[];
+                type: string;
+            } | {
+                name: string;
+                type: string;
+                docs?: undefined;
+            } | {
+                name: string;
+                docs: string[];
+                type: {
+                    array: (string | number)[];
+                };
+            } | {
+                name: string;
+                type: {
+                    array: (number | {
+                        defined: string;
+                    })[];
+                };
+                docs?: undefined;
+            } | {
+                name: string;
+                type: {
+                    array: (string | number)[];
+                };
+                docs?: undefined;
+            })[];
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: string;
+                docs?: undefined;
+            } | {
+                name: string;
+                type: {
+                    array: (string | number)[];
+                    defined?: undefined;
+                };
+                docs?: undefined;
+            } | {
+                name: string;
+                type: {
+                    defined: string;
+                    array?: undefined;
+                };
+                docs?: undefined;
+            } | {
+                name: string;
+                type: {
+                    array: (number | {
+                        defined: string;
+                    })[];
+                    defined?: undefined;
+                };
+                docs?: undefined;
+            } | {
+                name: string;
+                docs: string[];
+                type: string;
+            })[];
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: {
+                name: string;
+                type: {
+                    array: (number | {
+                        array: (string | number)[];
+                    })[];
+                };
+            }[];
+        };
+        docs?: undefined;
+    })[];
+    types: ({
+        name: string;
+        type: {
+            kind: string;
+            fields: {
+                name: string;
+                docs: string[];
+                type: string;
+            }[];
+            variants?: undefined;
+        };
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: {
+                    array: (string | number)[];
+                };
+            } | {
+                name: string;
+                type: string;
+            })[];
+            variants?: undefined;
+        };
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: string;
+            } | {
+                name: string;
+                type: {
+                    defined: string;
+                };
+            })[];
+            variants?: undefined;
+        };
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: {
+                    option: {
+                        defined: string;
+                    };
+                };
+            } | {
+                name: string;
+                type: string;
+            })[];
+            variants?: undefined;
+        };
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            variants: ({
+                name: string;
+                fields: string[];
+            } | {
+                name: string;
+                fields: ({
+                    name: string;
+                    docs: string[];
+                    type: string;
+                } | {
+                    name: string;
+                    type: string;
+                    docs?: undefined;
+                })[];
+            })[];
+            fields?: undefined;
+        };
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            variants: ({
+                name: string;
+                fields: {
+                    defined: string;
+                }[];
+            } | {
+                name: string;
+                fields: string[];
+            } | {
+                name: string;
+                fields?: undefined;
+            })[];
+            fields?: undefined;
+        };
+    })[];
+    errors: {
+        code: number;
+        name: string;
+        msg: string;
+    }[];
+};
+export declare class Kamino {
+    private readonly _cluster;
+    private readonly _connection;
+    readonly _config: HubbleConfig;
+    private _globalConfig;
+    private readonly _scope;
+    private readonly _provider;
+    private readonly _kaminoProgram;
+    private readonly _kaminoProgramId;
+    private readonly _orcaService;
+    private readonly _raydiumService;
+    private readonly _meteoraService;
+    /**
+     * Create a new instance of the Kamino SDK class.
+     * @param cluster Name of the Solana cluster
+     * @param connection Connection to the Solana cluster
+     * @param globalConfig override kamino global config
+     * @param programId override kamino program id
+     * @param whirlpoolProgramId override whirlpool program id
+     * @param raydiumProgramId override raydium program id
+     */
+    constructor(cluster: SolanaCluster, connection: Connection, globalConfig?: PublicKey, programId?: PublicKey, whirlpoolProgramId?: PublicKey, raydiumProgramId?: PublicKey, meteoraProgramId?: PublicKey);
+    getConnection: () => Connection;
+    getProgramID: () => PublicKey;
+    getProgram: () => Program<Idl>;
+    setGlobalConfig: (globalConfig: PublicKey) => void;
+    getGlobalConfig: () => PublicKey;
+    getDepositableTokens: () => Promise<CollateralInfo[]>;
+    getCollateralInfos: () => Promise<CollateralInfo[]>;
+    getSupportedDexes: () => Dex[];
+    getFeeTiersForDex: (dex: Dex) => Decimal[];
+    getRebalanceMethods: () => RebalanceMethod[];
+    getEnabledRebalanceMethods: () => RebalanceMethod[];
+    getPriceReferenceTypes: () => PriceReferenceType[];
+    getDefaultRebalanceMethod: () => RebalanceMethod;
+    getDefaultParametersForNewVault: () => Promise<VaultParameters>;
+    /**
+     * Retunrs what type of rebalance method the fields represent
+     */
+    getRebalanceTypeFromRebalanceFields: (rebalanceFields: RebalanceFieldInfo[]) => RebalanceTypeKind;
+    /**
+     * Retunrs the rebalance method the fields represent with more details (description, enabled, etc)
+     */
+    getRebalanceMethodFromRebalanceFields: (rebalanceFields: RebalanceFieldInfo[]) => RebalanceMethod;
+    getReferencePriceTypeForStrategy: (strategy: PublicKey | StrategyWithAddress) => Promise<PriceReferenceType>;
+    getFieldsForRebalanceMethod: (rebalanceMethod: RebalanceMethod, dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: PublicKey, tokenBMint: PublicKey, tickSpacing: number, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    getFieldsForManualRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: PublicKey, tokenBMint: PublicKey, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    getFieldsForPricePercentageMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: PublicKey, tokenBMint: PublicKey, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    getFieldsForPricePercentageWithResetMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: PublicKey, tokenBMint: PublicKey, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    getFieldsForDriftRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tickSpacing: number, tokenAMint: PublicKey, tokenBMint: PublicKey, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    getFieldsForTakeProfitRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: PublicKey, tokenBMint: PublicKey, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    getFieldsForPeriodicRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: PublicKey, tokenBMint: PublicKey, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    getFieldsForExpanderRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: PublicKey, tokenBMint: PublicKey, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    getFieldsForAutodriftRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: PublicKey, tokenBMint: PublicKey, tickSpacing: number, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    /**
+     * Get the price for a given pair of tokens in a given dex; The price comes from any pool having those tokens, not a specific one, so the price may not be exactly the same between different pools with the same tokens. For a specific pool price use getPoolPrice
+     * @param strategy
+     * @param amountA
+     */
+    getPriceForPair: (dex: Dex, poolTokenA: PublicKey, poolTokenB: PublicKey) => Promise<number>;
+    getDefaultRebalanceFields: (dex: Dex, poolTokenA: PublicKey, poolTokenB: PublicKey, tickSpacing: number, rebalanceMethod: RebalanceMethod) => Promise<RebalanceFieldInfo[]>;
+    /**
+     * Return a the pubkey of the pool in a given dex, for given mints and fee tier; if that pool doesn't exist, return default pubkey
+     */
+    getPoolInitializedForDexPairTier: (dex: Dex, poolTokenA: PublicKey, poolTokenB: PublicKey, feeBPS: Decimal) => Promise<PublicKey>;
+    /**
+     * Return generic information for all pools in a given dex, for given mints and fee tier
+     */
+    getExistentPoolsForPair(dex: Dex, tokenMintA: PublicKey, tokenMintB: PublicKey): Promise<GenericPoolInfo[]>;
+    getOrcaPoolsForTokens: (poolTokenA: PublicKey, poolTokenB: PublicKey) => Promise<OrcaPool[]>;
+    getRaydiumPoolsForTokens: (poolTokenA: PublicKey, poolTokenB: PublicKey) => Promise<Pool[]>;
+    getMeteoraPoolsForTokens: (poolTokenA: PublicKey, poolTokenB: PublicKey) => Promise<MeteoraPool[]>;
+    /**
+     * Return a list of all Kamino whirlpool strategies
+     * @param strategies Limit results to these strategy addresses
+     */
+    getStrategies: (strategies?: Array<PublicKey>) => Promise<Array<WhirlpoolStrategy | null>>;
+    /**
+     * Return a list of all Kamino whirlpool strategies with their addresses
+     * @param strategies Limit results to these strategy addresses
+     */
+    getStrategiesWithAddresses: (strategies?: Array<PublicKey>) => Promise<Array<StrategyWithAddress>>;
+    getAllStrategiesWithFilters: (strategyFilters: StrategiesFilters) => Promise<Array<StrategyWithAddress>>;
+    /**
+     * Get a Kamino whirlpool strategy by its public key address
+     * @param address
+     */
+    getStrategyByAddress: (address: PublicKey) => Promise<WhirlpoolStrategy | null>;
+    /**
+     * Get a Kamino whirlpool strategy by its kToken mint address
+     * @param kTokenMint - mint address of the kToken
+     */
+    getStrategyByKTokenMint: (kTokenMint: PublicKey) => Promise<StrategyWithAddress | null>;
+    /**
+     * Get the strategy share data (price + balances) of the specified Kamino whirlpool strategy
+     * @param strategy
+     * @param scopePrices
+     */
+    getStrategyShareData: (strategy: PublicKey | StrategyWithAddress, scopePrices?: OraclePrices) => Promise<ShareData>;
+    /**
+     * Batch fetch share data for all or a filtered list of strategies
+     * @param strategyFilters strategy filters or a list of strategy public keys
+     */
+    getStrategiesShareData: (strategyFilters: StrategiesFilters | PublicKey[], stratsWithAddresses?: StrategyWithAddress[], collateralInfos?: CollateralInfo[]) => Promise<Array<ShareDataWithAddress>>;
+    private getBalance;
+    private getRaydiumBalances;
+    private getMeteoraBalances;
+    private getRaydiumTokensBalances;
+    private getMeteoraTokensBalances;
+    private getOrcaBalances;
+    private getOrcaTokensBalances;
+    /**
+     * Get the strategies share data (price + balances) of the Kamino whirlpool strategies that match the filters
+     * @param strategyFilters
+     */
+    getStrategyShareDataForStrategies: (strategyFilters: StrategiesFilters) => Promise<Array<ShareDataWithAddress>>;
+    /**
+     * Get the strategy share price of the specified Kamino whirlpool strategy
+     * @param strategy
+     */
+    getStrategySharePrice: (strategy: PublicKey | StrategyWithAddress) => Promise<Decimal>;
+    private getTokenAccountBalance;
+    /**
+     * Get the balance of a token account or 0 if it doesn't exist
+     * @param tokenAccount
+     */
+    private getTokenAccountBalanceOrZero;
+    private getStrategyBalances;
+    private getStrategyTokensBalances;
+    /**
+     * Get amount of specified token in all Kamino live strategies
+     * @param tokenMint token mint pubkey
+     */
+    getTotalTokensInStrategies: (tokenMint: PublicKey | string) => Promise<TotalStrategyVaultTokens>;
+    getAccountOwner: (pk: PublicKey) => Promise<PublicKey>;
+    private getStrategyBalancesOrca;
+    private getStrategyBalancesRaydium;
+    private getStrategyBalancesMeteora;
+    private getStrategyHoldingsUsd;
+    getAllOraclePrices: () => Promise<OraclePrices>;
+    /**
+     * Get all Kamino token spot and twap prices
+     * @param oraclePrices (optional) Scope Oracle prices
+     * @param collateralInfos (optional) Kamino Collateral Infos
+     */
+    getAllPrices: (oraclePrices?: OraclePrices, collateralInfos?: CollateralInfo[]) => Promise<KaminoPrices>;
+    private getOraclePricesAndCollateralInfos;
+    /**
+     * Get the prices of all tokens in the specified strategy, or null if the reward token does not exist
+     * @param strategy
+     * @param collateralInfos
+     * @param scopePrices
+     */
+    getStrategyPrices: (strategy: WhirlpoolStrategy, collateralInfos: CollateralInfo[], scopePrices?: OraclePrices) => Promise<StrategyPrices>;
+    /**
+     * Get all token accounts for the specified share mint
+     */
+    getShareTokenAccounts: (shareMint: PublicKey) => Promise<{
+        pubkey: PublicKey;
+        account: AccountInfo<Buffer | ParsedAccountData>;
+    }[]>;
+    /**
+     * Get all token accounts for the specified wallet
+     */
+    getAllTokenAccounts: (wallet: PublicKey) => Promise<{
+        pubkey: PublicKey;
+        account: AccountInfo<Buffer | ParsedAccountData>;
+    }[]>;
+    /**
+     * Get all token accounts that are holding a specific Kamino whirlpool strategy
+     */
+    getStrategyTokenAccounts: (strategy: PublicKey | StrategyWithAddress) => Promise<{
+        pubkey: PublicKey;
+        account: AccountInfo<Buffer | ParsedAccountData>;
+    }[]>;
+    /**
+     * Get strategy range in which liquidity is deposited
+     */
+    getStrategyRange: (strategy: PublicKey | StrategyWithAddress) => Promise<PositionRange>;
+    getStrategyRangeOrca: (strategy: PublicKey | StrategyWithAddress) => Promise<PositionRange>;
+    getStrategyRangeRaydium: (strategy: PublicKey | StrategyWithAddress) => Promise<PositionRange>;
+    getStrategyRangeMeteora: (strategy: PublicKey | StrategyWithAddress) => Promise<PositionRange>;
+    getPositionRange: (dex: Dex, position: PublicKey, decimalsA: number, decimalsB: number) => Promise<PositionRange>;
+    getPositionRangeOrca: (positionPk: PublicKey, decimalsA: number, decimalsB: number) => Promise<PositionRange>;
+    getPositionRangeRaydium: (positionPk: PublicKey, decimalsA: number, decimalsB: number) => Promise<PositionRange>;
+    getPositionRangeMeteora: (positionPk: PublicKey, decimalsA: number, decimalsB: number) => Promise<PositionRange>;
+    /**
+     * Get all strategy token holders
+     * @param strategy
+     */
+    getStrategyHolders: (strategy: PublicKey | StrategyWithAddress) => Promise<StrategyHolder[]>;
+    /**
+     * Get a list of Orca whirlpools from public keys
+     * @param whirlpools
+     */
+    getWhirlpools: (whirlpools: PublicKey[]) => Promise<PubkeyHashMap<PublicKey, Whirlpool | null>>;
+    /**
+     * Get a list of Orca positions from public keys
+     * @param positions
+     */
+    getOrcaPositions: (positions: PublicKey[]) => Promise<(Position | null)[]>;
+    /**
+     * Get a list of Raydium positions from public keys
+     * @param positions
+     */
+    getRaydiumPositions: (positions: PublicKey[]) => Promise<(PersonalPositionState | null)[]>;
+    getMeteoraPositions: (positions: PublicKey[]) => Promise<(PositionV2 | null)[]>;
+    /**
+     * Get whirlpool from public key
+     * @param whirlpool pubkey of the orca whirlpool
+     */
+    getWhirlpoolByAddress: (whirlpool: PublicKey) => Promise<Whirlpool | null>;
+    /**
+     * Get a list of Raydium pools from public keys
+     * @param pools
+     */
+    getRaydiumPools: (pools: PublicKey[]) => Promise<PubkeyHashMap<PublicKey, PoolState | null>>;
+    getMeteoraPools: (pools: PublicKey[]) => Promise<PubkeyHashMap<PublicKey, LbPair | null>>;
+    getRaydiumAmmConfig: (config: PublicKey) => Promise<AmmConfig | null>;
+    /**
+     * Get Raydium pool from public key
+     * @param pool pubkey of the orca whirlpool
+     */
+    getRaydiumPoolByAddress: (pool: PublicKey) => Promise<PoolState | null>;
+    getMeteoraPoolByAddress: (pool: PublicKey) => Promise<LbPair | null>;
+    getEventAuthorityPDA: (dex: BN) => PublicKey;
+    /**
+     * Return transaction instruction to withdraw shares from a strategy owner (wallet) and get back token A and token B
+     * @param strategy strategy public key
+     * @param sharesAmount amount of shares (decimal representation), NOT in lamports
+     * @param owner shares owner (wallet with shares)
+     * @returns transaction instruction
+     */
+    withdrawShares: (strategy: PublicKey | StrategyWithAddress, sharesAmount: Decimal, owner: PublicKey, sharesAtaBalance?: Decimal) => Promise<WithdrawShares>;
+    /**
+     * Get transaction instructions that create associated token accounts if they don't exist (token A, B and share)
+     * @param owner wallet owner (shareholder)
+     * @param strategyState kamino strategy state
+     * @param tokenAData token A data of the owner's wallet
+     * @param tokenAAta associated token account for token B
+     * @param tokenBData token B data of the owner's wallet
+     * @param tokenBAta associated token account for token B
+     * @param sharesMintData shares data of the owner's wallet
+     * @param sharesAta associated token account for shares
+     * @returns list of transaction instructions (empty if all accounts already exist)
+     */
+    getCreateAssociatedTokenAccountInstructionsIfNotExist: (owner: PublicKey, strategyState: StrategyWithAddress, tokenAData: AccountInfo<Buffer> | null, tokenAAta: PublicKey, tokenBData: AccountInfo<Buffer> | null, tokenBAta: PublicKey, sharesMintData: AccountInfo<Buffer> | null, sharesAta: PublicKey) => Promise<TransactionInstruction[]>;
+    /**
+     * Check if strategy has already been fetched (is StrategyWithAddress type) and return that,
+     * otherwise fetch it first from PublicKey and return it
+     * @param strategy
+     * @private
+     */
+    private getStrategyStateIfNotFetched;
+    private getWhirlpoolStateIfNotFetched;
+    private getMeteoraStateIfNotFetched;
+    /**
+     * Get treasury fee vault program addresses from for token A and B mints
+     * @param tokenAMint
+     * @param tokenBMint
+     * @private
+     */
+    private getTreasuryFeeVaultPDAs;
+    /**
+     * Get a transaction instruction to withdraw all strategy shares from a specific wallet into token A and B
+     * @param strategy public key of the strategy
+     * @param owner public key of the owner (shareholder)
+     * @returns transaction instruction or null if no shares or no sharesMint ATA present in the wallet
+     */
+    withdrawAllShares: (strategy: PublicKey | StrategyWithAddress, owner: PublicKey) => Promise<WithdrawShares | null>;
+    /**
+     * Get all the accounts needed by the deposit tx, without the swap.
+     * @param strategy Kamino strategy public key or on-chain object
+     * @param owner Owner (wallet, shareholder) public key
+     * @returns list of pubkeys needed for the deposit transaction
+     */
+    getAllDepositAccounts: (strategy: PublicKey | StrategyWithAddress, owner: PublicKey) => Promise<PublicKey[]>;
+    /**
+     * Get transaction instruction to deposit token A and B into a strategy.
+     * @param strategy Kamino strategy public key or on-chain object
+     * @param amountA Amount of token A to deposit into strategy
+     * @param amountB Amount of token B to deposit into strategy
+     * @param owner Owner (wallet, shareholder) public key
+     * @returns transaction instruction for depositing tokens into a strategy
+     */
+    deposit: (strategy: PublicKey | StrategyWithAddress, amountA: Decimal, amountB: Decimal, owner: PublicKey) => Promise<TransactionInstruction>;
+    singleSidedDepositTokenA: (strategy: PublicKey | StrategyWithAddress, amountToDeposit: Decimal, owner: PublicKey, slippageBps: Decimal, profiler?: ProfiledFunctionExecution, swapIxsBuilder?: SwapperIxBuilder, initialUserTokenAtaBalances?: TokensBalances, priceAInB?: Decimal, includeAtaIxns?: boolean, onlyDirectRoutes?: boolean) => Promise<InstructionsWithLookupTables>;
+    singleSidedDepositTokenB: (strategy: PublicKey | StrategyWithAddress, amountToDeposit: Decimal, owner: PublicKey, slippageBps: Decimal, profiler?: ProfiledFunctionExecution, swapIxsBuilder?: SwapperIxBuilder, initialUserTokenAtaBalances?: TokensBalances, priceAInB?: Decimal, includeAtaIxns?: boolean, onlyDirectRoutes?: boolean) => Promise<InstructionsWithLookupTables>;
+    getInitialUserTokenBalances: (owner: PublicKey, tokenAMint: PublicKey, tokenBMint: PublicKey, initialUserTokenBalances?: MaybeTokensBalances) => Promise<TokensBalances>;
+    private getSingleSidedDepositIxs;
+    static retryAsync(fn: () => Promise<any>, retriesLeft?: number, interval?: number): Promise<any>;
+    /**
+     * Get transaction instruction to deposit SOL into topup vault.
+     * @param owner Owner (wallet, shareholder) public key
+     * @param amountLamports Amount of SOL to deposit into topup vault
+     * @returns transaction instruction for adding SOL to topup vault
+     */
+    upkeepTopupVault: (owner: PublicKey, amountLamports: Decimal) => TransactionInstruction;
+    /**
+     * Get the topup vault balance in SOL.
+     * @param owner Owner (wallet, shareholder) public key
+     * @returns SOL amount in topup vault
+     */
+    topupVaultBalance: (owner: PublicKey) => Promise<Decimal>;
+    /**
+     * Get transaction instruction to withdraw SOL from the topup vault.
+     * @param owner Owner (wallet, shareholder) public key
+     * @param amount Amount of SOL to withdraw from the topup vault
+     * @returns transaction instruction for removing SOL from the topup vault
+     */
+    withdrawTopupVault: (owner: PublicKey, amount: Decimal) => Promise<TransactionInstruction>;
+    getJupSwapIxsWithMaxAccounts: (input: DepositAmountsForSwap, tokenAMint: PublicKey, tokenBMint: PublicKey, owner: PublicKey, slippageBps: Decimal, useOnlyLegacyTransaction: boolean, existingAccounts: PublicKey[], maxAccounts: number, profiler?: ProfiledFunctionExecution, onlyDirectRoutes?: boolean) => Promise<[TransactionInstruction[], PublicKey[]]>;
+    getJupSwapIxsV6: (input: DepositAmountsForSwap, tokenAMint: PublicKey, tokenBMint: PublicKey, owner: PublicKey, slippageBps: Decimal, useOnlyLegacyTransaction: boolean, existingAccounts: PublicKey[], profiledFunctionExecution?: ProfiledFunctionExecution, onlyDirectRoutes?: boolean) => Promise<[TransactionInstruction[], PublicKey[]]>;
+    getCheckExpectedVaultsBalancesIx: (strategy: StrategyWithAddress, user: PublicKey, tokenAAta: PublicKey, tokenBAta: PublicKey, expectedTokensBalances?: MaybeTokensBalances) => Promise<TransactionInstruction>;
+    /**
+     * Get transaction instruction to create a new Kamino strategy.
+     * Current limitations:
+     *   - strategy can only be created by the owner (admin) of the global config, we will need to allow non-admins to bypass this check
+     *   - after the strategy is created, only the owner (admin) can update the treasury fee vault with token A/B, we need to allow non-admins to be able to do (and require) this as well
+     * @param strategy public key of the new strategy to create
+     * @param pool public key of the CLMM pool (either Orca or Raydium)
+     * @param owner public key of the strategy owner (admin authority)
+     * @param dex decentralized exchange specifier
+     * @returns transaction instruction for Kamino strategy creation
+     */
+    createStrategy: (strategy: PublicKey, pool: PublicKey, owner: PublicKey, dex: Dex) => Promise<TransactionInstruction>;
+    /**
+     * Get transaction instruction to close Kamino strategy, including its position if there is any
+     * and strategy token accounts.
+     * @param strategy public key of the strategy
+     * @returns instruction to close the strategy
+     */
+    withdrawAllAndCloseStrategy: (strategy: PublicKey | StrategyWithAddress) => Promise<WithdrawAllAndCloseIxns | null>;
+    /**
+     * Get transaction instruction to close Kamino strategy, including its position if there is any
+     * and strategy token accounts.
+     * @param strategy public key of the strategy
+     * @returns instruction to close the strategy
+     */
+    closeStrategy: (strategy: PublicKey | StrategyWithAddress) => Promise<TransactionInstruction>;
+    getUserTopupVault: (user: PublicKey) => PublicKey;
+    /**
+     * Find program adresses required for kamino strategy creation
+     * @param strategy
+     * @param tokenMintA
+     * @param tokenMintB
+     * @private
+     * @returns object with program addresses for kamino strategy creation
+     */
+    private getStrategyProgramAddresses;
+    /**
+     * Get transaction instruction to create a new rent exempt strategy account
+     * @param payer transaction payer (signer) public key
+     * @param newStrategy public key of the new strategy
+     * @returns transaction instruction to create the account
+     */
+    createStrategyAccount: (payer: PublicKey, newStrategy: PublicKey) => Promise<TransactionInstruction>;
+    createAccountRentExempt: (payer: PublicKey, newAccountPubkey: PublicKey, size: number) => Promise<TransactionInstruction>;
+    /**
+     * Get transaction instruction to collect strategy fees from the treasury fee
+     * vaults and rewards from the reward vaults.
+     * @param strategy strategy public key or already fetched object
+     * @param owner signer of the tx
+     * @returns transaction instruction to collect strategy fees and rewards
+     */
+    collectFeesAndRewards: (strategy: PublicKey | StrategyWithAddress, owner?: PublicKey) => Promise<TransactionInstruction>;
+    /**
+     * Get orca position metadata program addresses
+     * @param positionMint mint account of the position
+     */
+    getMetadataProgramAddressesOrca: (positionMint: PublicKey) => MetadataProgramAddressesOrca;
+    getMetadataProgramAddressesRaydium: (positionMint: PublicKey, pool: PublicKey, tickLowerIndex: number, tickUpperIndex: number) => MetadataProgramAddressesRaydium;
+    private getStartEndTicketIndexProgramAddressesOrca;
+    private getStartEndTicketIndexProgramAddressesRaydium;
+    private readMeteoraPosition;
+    private getStartEndTicketIndexProgramAddressesMeteora;
+    /**
+     * Get a transaction to open liquidity position for a Kamino strategy
+     * @param strategy strategy you want to open liquidity position for
+     * @param positionMint position mint pubkey
+     * @param priceLower new position's lower price of the range
+     * @param priceUpper new position's upper price of the range
+     * @param status strategy status
+     */
+    openPosition: (strategy: PublicKey | StrategyWithAddress, positionMint: PublicKey, priceLower: Decimal, priceUpper: Decimal, status?: StrategyStatusKind) => Promise<TransactionInstruction>;
+    /**
+     * Get a transaction to open liquidity position for a Kamino strategy
+     * @param strategy strategy you want to open liquidity position for
+     * @param positionMint new liquidity position account pubkey
+     * @param priceLower new position's lower price of the range
+     * @param priceUpper new position's upper price of the range
+     * @param status strategy status
+     */
+    openPositionOrca: (adminAuthority: PublicKey, strategy: PublicKey, baseVaultAuthority: PublicKey, pool: PublicKey, positionMint: PublicKey, priceLower: Decimal, priceUpper: Decimal, tokenAVault: PublicKey, tokenBVault: PublicKey, tokenAMint: PublicKey, tokenBMint: PublicKey, tokenATokenProgram: PublicKey, tokenBTokenProgram: PublicKey, oldPositionOrBaseVaultAuthority: PublicKey, oldPositionMintOrBaseVaultAuthority: PublicKey, oldPositionTokenAccountOrBaseVaultAuthority: PublicKey, oldTickArrayLowerOrBaseVaultAuthority: PublicKey, oldTickArrayUpperOrBaseVaultAuthority: PublicKey, eventAuthority: PublicKey, status?: StrategyStatusKind) => Promise<TransactionInstruction>;
+    /**
+     * Get a transaction to open liquidity position for a Kamino strategy
+     * @param strategy strategy you want to open liquidity position for
+     * @param positionMint new liquidity position account pubkey
+     * @param priceLower new position's lower price of the range
+     * @param priceUpper new position's upper price of the range
+     * @param status strategy status
+     */
+    openPositionRaydium: (adminAuthority: PublicKey, strategy: PublicKey, baseVaultAuthority: PublicKey, pool: PublicKey, positionMint: PublicKey, priceLower: Decimal, priceUpper: Decimal, tokenAVault: PublicKey, tokenBVault: PublicKey, tokenAMint: PublicKey, tokenBMint: PublicKey, tokenATokenProgram: PublicKey, tokenBTokenProgram: PublicKey, oldTickArrayLowerOrBaseVaultAuthority: PublicKey, oldTickArrayUpperOrBaseVaultAuthority: PublicKey, oldPositionOrBaseVaultAuthority: PublicKey, oldPositionMintOrBaseVaultAuthority: PublicKey, oldPositionTokenAccountOrBaseVaultAuthority: PublicKey, oldProtocolPositionOrBaseVaultAuthority: PublicKey, eventAuthority: PublicKey, status?: StrategyStatusKind, strategyRewardOVault?: PublicKey, strategyReward1Vault?: PublicKey, strategyReward2Vault?: PublicKey) => Promise<TransactionInstruction>;
+    /**
+     * Get a transaction to open liquidity position for a Kamino strategy
+     * @param strategy strategy you want to open liquidity position for
+     * @param positionMint new liquidity position account pubkey
+     * @param priceLower new position's lower price of the range
+     * @param priceUpper new position's upper price of the range
+     * @param status strategy status
+     */
+    openPositionMeteora: (adminAuthority: PublicKey, strategy: PublicKey, baseVaultAuthority: PublicKey, pool: PublicKey, position: PublicKey, priceLower: Decimal, priceUpper: Decimal, tokenAVault: PublicKey, tokenBVault: PublicKey, tokenAMint: PublicKey, tokenBMint: PublicKey, tokenATokenProgram: PublicKey, tokenBTokenProgram: PublicKey, oldPositionOrBaseVaultAuthority: PublicKey, oldPositionMintOrBaseVaultAuthority: PublicKey, oldPositionTokenAccountOrBaseVaultAuthority: PublicKey, oldTickArrayLowerOrBaseVaultAuthority: PublicKey, oldTickArrayUpperOrBaseVaultAuthority: PublicKey, eventAuthority: PublicKey, status?: StrategyStatusKind) => Promise<TransactionInstruction>;
+    /**
+     * Get a transaction for executive withdrawal from a Kamino strategy.
+     * @param strategy strategy pubkey or object
+     * @param action withdrawal action
+     * @returns transaction for executive withdrawal
+     */
+    executiveWithdraw: (strategy: PublicKey | StrategyWithAddress, action: ExecutiveWithdrawActionKind) => Promise<TransactionInstruction>;
+    /**
+     * Get a an instruction to update the reference price type of a strategy
+     * @param strategy strategy pubkey or object
+     * @param referencePriceType new reference price type
+     */
+    getUpdateReferencePriceTypeIx: (strategy: PublicKey | StrategyWithAddress, referencePriceType: ReferencePriceTypeKind) => Promise<TransactionInstruction>;
+    /**
+     * Get a transaction to invest funds from the Kamino vaults and put them into the DEX pool as liquidity.
+     * @param strategy strategy pubkey or object
+     * @param payer transaction payer
+     */
+    invest: (strategy: PublicKey | StrategyWithAddress, payer: PublicKey) => Promise<TransactionInstruction>;
+    /**
+     * Get a list of instructions to collect the pending fees and invest them into the Kamino strategy's position.
+     * @param strategy strategy pubkey or object
+     * @param payer transaction payer
+     */
+    compound: (strategy: PublicKey | StrategyWithAddress, payer: PublicKey) => Promise<TransactionInstruction[]>;
+    /**
+     * Get a the pending fees in lamports of a strategy.
+     * @param strategy strategy pubkey or object
+     */
+    getPendingFees: (strategies: PublicKey[]) => Promise<StrategyWithPendingFees[]>;
+    getUpdateRebalancingParamsFromRebalanceFieldsIx: (strategyAdmin: PublicKey, strategy: PublicKey | StrategyWithAddress, rebalanceFieldInfos: RebalanceFieldInfo[]) => Promise<TransactionInstruction>;
+    processRebalanceParams: (dex: Dex, pool: PublicKey | WhirlpoolWithAddress, rebalanceType: Decimal, rebalanceParams: Decimal[]) => Promise<Decimal[]>;
+    getUpdateRebalancingParmsIxns: (strategyAdmin: PublicKey, strategy: PublicKey | StrategyWithAddress, rebalanceParams: Decimal[], rebalanceType?: RebalanceTypeKind, tokenADecimals?: number, tokenBDecimals?: number) => Promise<TransactionInstruction>;
+    getUpdateRebalancingParamsForUninitializedStratIx: (strategyAdmin: PublicKey, strategy: PublicKey, rebalanceParams: Decimal[], rebalanceType: RebalanceTypeKind, tokenADecimals: number, tokenBDecimals: number) => Promise<TransactionInstruction>;
+    buildStrategyRebalanceParams: (strategy: PublicKey | StrategyWithAddress) => Promise<number[]>;
+    /**
+     * Get a list of instructions to initialize and set up a strategy
+     * @param dex the dex to use (Orca or Raydium)
+     * @param feeTierBps which fee tier for that specific pair should be used (in BPS)
+     * @param tokenAMint the mint of TokenA in the pool
+     * @param tokenBMint the mint of TokenB in the pool
+     * @param depositCap the maximum amount in USD in lamports (6 decimals) that can be deposited into the strategy
+     * @param depositCapPerIx the maximum amount in USD in lamports (6 decimals) that can be deposited into the strategy per instruction
+     */
+    getBuildStrategyIxns: (dex: Dex, feeTierBps: Decimal, strategy: PublicKey, positionMint: PublicKey, strategyAdmin: PublicKey, rebalanceType: Decimal, rebalanceParams: Decimal[], tokenAMint: PublicKey, tokenBMint: PublicKey, depositCap?: Decimal, depositCapPerIx?: Decimal, withdrawFeeBps?: Decimal, depositFeeBps?: Decimal, performanceFeeBps?: Decimal) => Promise<InitStrategyIxs>;
+    getNewPositionRange(strategy: PublicKey | StrategyWithAddress, rebalanceKind: RebalanceTypeKind, rebalanceParams: Decimal[]): Promise<PositionRange>;
+    private getRebalancePositionRange;
+    getCurrentPrice(strategy: PublicKey | StrategyWithAddress): Promise<Decimal>;
+    getCurrentPriceFromPool(dex: Dex, pool: PublicKey): Promise<Decimal>;
+    getPoolTickSpacing(dex: Dex, pool: PublicKey): Promise<number>;
+    getPriceRangePercentageBasedFromPool(dex: Dex, pool: PublicKey, lowerPriceBpsDifference: Decimal, upperPriceBpsDifference: Decimal): Promise<[Decimal, Decimal]>;
+    /**
+     * Get the raw rebalancing params given the strategy type
+     */
+    readRebalancingParamsFromChain(strategy: PublicKey | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
+    /**
+     * Get the raw rebalancing params given the strategy type
+     */
+    readRebalancingStateFromChain(strategy: PublicKey | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
+    /**
+     * Get the prices for rebalancing params (range and reset range, if strategy involves a reset range)
+     */
+    readRebalancingParams(strategy: PublicKey | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
+    /**
+     * Get the rebalancing params from chain, alongside the current details of the position, reset range, etc
+     */
+    readRebalancingParamsWithState(strategy: PublicKey | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
+    /**
+     * Get a list of updated rebalance field infos.
+     * @param initialRebalanceFieldInfos the initial list of rebalance field infos
+     * @param updatedFields the fields to be updated, with label and value
+     * @returns list of RebalanceFieldInfo with updated values
+     */
+    getUpdatedRebalanceFieldInfos(initialRebalanceFieldInfos: RebalanceFieldInfo[], updatedFields: InputRebalanceFieldInfo[]): RebalanceFieldInfo[];
+    getPriceRangePercentageBasedFromPrice(price: Decimal, lowerPriceBpsDifference: Decimal, upperPriceBpsDifference: Decimal): [Decimal, Decimal];
+    /**
+     * Read the pool price for a specific dex and pool
+     */
+    getPoolPrice(dex: Dex, pool: PublicKey): Promise<Decimal>;
+    getOrcaPoolPrice(pool: PublicKey): Promise<Decimal>;
+    getRaydiumPoolPrice(pool: PublicKey): Promise<Decimal>;
+    getMeteoraPoolPrice(pool: PublicKey): Promise<Decimal>;
+    getGenericPoolInfo(dex: Dex, pool: PublicKey): Promise<GenericPoolInfo>;
+    mintIsSupported: (collateralInfos: CollateralInfo[], tokenMint: PublicKey) => boolean;
+    getCollateralInfoFromMint: (mint: PublicKey, collateralInfos: CollateralInfo[]) => CollateralInfo | undefined;
+    getCollateralIdFromMint: (mint: PublicKey, collateralInfos: CollateralInfo[]) => number;
+    getMainLookupTablePks: () => Promise<PublicKey[]>;
+    getMainLookupTable: () => Promise<AddressLookupTableAccount[] | undefined>;
+    getInitLookupTableIx: (authority: PublicKey, slot?: number) => Promise<[TransactionInstruction, PublicKey]>;
+    getPopulateLookupTableIxs: (authority: PublicKey, lookupTable: PublicKey, strategy: PublicKey | StrategyWithAddress) => Promise<TransactionInstruction[]>;
+    getAddLookupTableEntriesIxs: (authority: PublicKey, lookupTable: PublicKey, entries: PublicKey[]) => TransactionInstruction[];
+    getLookupTable: (tablePk: PublicKey) => Promise<AddressLookupTableAccount>;
+    setupStrategyLookupTable: (authority: Keypair, strategy: PublicKey | StrategyWithAddress, slot?: number) => Promise<PublicKey>;
+    getTransactionV2Message: (payer: PublicKey, instructions: Array<TransactionInstruction>, lookupTables?: Array<PublicKey>) => Promise<MessageV0>;
+    getTransactionV2MessageWithFetchedLookupTables: (payer: PublicKey, instructions: Array<TransactionInstruction>, lookupTables?: Array<AddressLookupTableAccount>) => Promise<MessageV0>;
+    getEstimatedApyAndVolumeOnRangeOrca: () => Promise<GenericPositionRangeInfo>;
+    getEstimatedApyAndVolumeOnRangeRaydium: () => Promise<GenericPositionRangeInfo>;
+    getEstimatedApyAndVolumeOnRangeMeteora: () => Promise<GenericPositionRangeInfo>;
+    getManualPoolSimulatedValues: (params: {
+        pool: PublicKey;
+        priceLower: Decimal;
+        priceUpper: Decimal;
+        startDate: string;
+        endDate: string;
+    }) => Promise<PoolSimulationResponse>;
+    getPercentagePoolSimulatedValues: (params: SimulationPercentagePoolParameters) => Promise<PoolSimulationResponse>;
+    /**
+     * Get a list of transactions to rebalance a Kamino strategy.
+     * @param strategy strategy pubkey or object
+     * @param newPosition new liquidity position account pubkey
+     * @param priceLower new position's lower price of the range
+     * @param priceUpper new position's upper price of the range
+     * @returns list of transactions to rebalance (executive withdraw, collect fees/rewards, open new position, invest)
+     */
+    rebalance: (strategy: PublicKey | StrategyWithAddress, newPosition: PublicKey, priceLower: Decimal, priceUpper: Decimal) => Promise<TransactionInstruction[]>;
+    /**
+     * Deserialize a buffer to MintInfo
+     * @param data Buffer
+     * @returns
+     */
+    _deserializeMint(data: Buffer): MintInfo;
+    /**
+     * Get a list of user's Kamino strategy positions
+     * @param wallet user wallet address
+     * @param strategyFilters
+     * @returns list of kamino strategy positions
+     */
+    getUserPositions: (wallet: PublicKey, strategyFilters?: StrategiesFilters) => Promise<KaminoPosition[]>;
+    /**
+     * Get a list of user's Kamino strategy positions
+     * @param wallet user wallet address
+     * @returns list of kamino strategy positions
+     */
+    getUserPositionsByStrategiesMap: (wallet: PublicKey, strategiesWithShareMintsMap: PubkeyHashMap<PublicKey, KaminoStrategyWithShareMint>, strategiesWithAddressMap?: PubkeyHashMap<PublicKey, WhirlpoolStrategy>) => Promise<KaminoPosition[]>;
+    /**
+     * Get Kamino strategy vault APY/APR
+     * @param strategy strategy pubkey or onchain state
+     * @param orcaPools not required, but you can add orca whirlpools if you're caching them, and we don't refetch every time
+     * @param raydiumPools not required, but you can add raydium pools if you're caching them, and we don't refetch every time
+     */
+    getStrategyAprApy: (strategy: PublicKey | StrategyWithAddress, orcaPools?: OrcaPool[], raydiumPools?: Pool[]) => Promise<WhirlpoolAprApy>;
+    getStrategyPerformanceFees: (strategy: PublicKey | StrategyWithAddress, globalConfig?: GlobalConfig) => Promise<PerformanceFees>;
+    getLiquidityDistributionRaydiumPool: (pool: PublicKey, keepOrder?: boolean, lowestTick?: number, highestTick?: number) => Promise<LiquidityDistribution>;
+    getLiquidityDistributionMeteoraPool: (pool: PublicKey, keepOrder?: boolean, lowestTick?: number, highestTick?: number) => Promise<LiquidityDistribution>;
+    getLiquidityDistributionOrcaWhirlpool: (pool: PublicKey, keepOrder?: boolean, lowestTick?: number, highestTick?: number) => Promise<LiquidityDistribution>;
+    getLiquidityDistribution: (dex: Dex, pool: PublicKey, keepOrder?: boolean, lowestTick?: number, highestTick?: number) => Promise<LiquidityDistribution>;
+    getPositionsCountForPool: (dex: Dex, pool: PublicKey) => Promise<number>;
+    getStrategyTokensHoldings: (strategy: PublicKey | StrategyWithAddress, mode?: "DEPOSIT" | "WITHDRAW") => Promise<TokenAmounts>;
+    /**
+     * Get ratio of total_a_in_strategy/total_b_in_strategy; if the total_b_in_strategy is 0 throws;
+     * @param strategy
+     * @param amountA
+     */
+    getStrategyTokensRatio: (strategy: PublicKey | StrategyWithAddress) => Promise<Decimal>;
+    calculateAmountsToBeDepositedWithSwap: (strategy: PublicKey | StrategyWithAddress, tokenAAmountUserDeposit: Decimal, tokenBAmountUserDeposit: Decimal, profiler?: ProfiledFunctionExecution, priceAInB?: Decimal) => Promise<DepositAmountsForSwap>;
+    /**
+     * @deprecated The method should not be used
+     */
+    calculateAmountsDistributionWithPriceRange: (dex: Dex, pool: PublicKey, lowerPrice: Decimal, upperPrice: Decimal) => Promise<[Decimal, Decimal]>;
+    calculateAmountsToBeDeposited: (strategy: PublicKey | StrategyWithAddress, tokenAAmount?: Decimal, tokenBAmount?: Decimal, profiledFunctionExecution?: ProfiledFunctionExecution) => Promise<[Decimal, Decimal]>;
+    calculateAmountsRatioToBeDeposited: (strategy: PublicKey | StrategyWithAddress, holdings?: TokenAmounts, profiler?: ProfiledFunctionExecution) => Promise<[Decimal, Decimal]>;
+    calculateDepositAmountsProportional: (strategy: PublicKey | StrategyWithAddress, tokenAAmount?: Decimal, tokenBAmount?: Decimal, profiler?: ProfiledFunctionExecution) => Promise<[Decimal, Decimal]>;
+    private calculateDepositAmountsProportionalWithTotalTokens;
+    calculateDepostAmountsDollarBased: (strategy: PublicKey | StrategyWithAddress, tokenAAmount?: Decimal, tokenBAmount?: Decimal) => Promise<[Decimal, Decimal]>;
+    calculateAmountsOrca: ({ whirlpoolConfig, tokenAMint, tokenBMint, positionAddress, tokenAAmount, tokenBAmount, }: {
+        whirlpoolConfig: PublicKey;
+        tokenAMint: PublicKey;
+        tokenBMint: PublicKey;
+        positionAddress: PublicKey;
+        tokenAAmount?: Decimal;
+        tokenBAmount?: Decimal;
+    }) => Promise<[Decimal, Decimal]>;
+    calculateAmountsRaydium: ({ strategyState, tokenAAmount, tokenBAmount, }: {
+        strategyState: WhirlpoolStrategy;
+        tokenAAmount?: Decimal;
+        tokenBAmount?: Decimal;
+    }) => Promise<[Decimal, Decimal]>;
+    calculateAmountsMeteora: ({ strategyState, tokenAAmount, tokenBAmount, }: {
+        strategyState: WhirlpoolStrategy;
+        tokenAAmount?: Decimal;
+        tokenBAmount?: Decimal;
+    }) => Promise<[Decimal, Decimal]>;
+    /**
+     * @deprecated The method should not be used
+     */
+    getDepositRatioFromTokenA: (strategy: PublicKey | StrategyWithAddress, amountA: BN) => Promise<{
+        amountSlippageA: BN;
+        amountSlippageB: BN;
+    }>;
+    /**
+     * @deprecated The method should not be used
+     */
+    getDepositRatioFromTokenB: (strategy: PublicKey | StrategyWithAddress, amountB: BN) => Promise<{
+        amountSlippageA: BN;
+        amountSlippageB: BN;
+    }>;
+    /**
+     * Get the on-chain state of the terms&conditions signature for the owner
+     * @param owner
+     */
+    getUserTermsSignatureState(owner: PublicKey): Promise<TermsSignature | null>;
+    /**
+     * Get the instruction to store the on chain owner signature of terms&conditions
+     * @param owner
+     * @param signature
+     */
+    getUserTermsSignatureIx(owner: PublicKey, signature: Uint8Array): Promise<TransactionInstruction>;
+    private getDepositRatioFromAOrca;
+    private getDepositRatioFromAMeteora;
+    private getDepositRatioFromBMeteora;
+    private getDepositRatioFromBOrca;
+    private getDepositRatioFromARaydium;
+    private getDepositRatioFromBRaydium;
+    getCollateralInfo: (address: PublicKey) => Promise<CollateralInfo[]>;
+    getGlobalConfigState: (address: PublicKey) => Promise<GlobalConfig | null>;
+    getWhirlpoolStrategy: (address: PublicKey) => Promise<WhirlpoolStrategy | null>;
+    getWhirlpoolStrategies: (addresses: PublicKey[]) => Promise<Array<WhirlpoolStrategy | null>>;
+    getStrategyVaultBalances: (strategy: PublicKey | StrategyWithAddress) => Promise<{
+        aVault: Decimal;
+        bVault: Decimal;
+    }>;
+    getUpdateStrategyParamsIxs: (strategyAdmin: PublicKey, strategy: PublicKey, rebalanceType: Decimal, withdrawFeeBps?: Decimal, performanceFeeBps?: Decimal) => Promise<TransactionInstruction[]>;
+    getUpdateRewardsIxs: (strategyOwner: PublicKey, strategy: PublicKey | StrategyWithAddress) => Promise<[TransactionInstruction, Keypair][]>;
+    /**
+     * Get the instruction to create an Orca Whirlpool tick, if it does not exist
+     * @param payer
+     * @param pool
+     * @param price
+     * @return tickPubkey, (tickInstruction | undefined)
+     */
+    initializeTickForOrcaPool: (payer: PublicKey, pool: PublicKey | WhirlpoolWithAddress, price: Decimal) => Promise<InitPoolTickIfNeeded>;
+    initializeTickForMeteoraPool: (payer: PublicKey, pool: PublicKey | LbPairWithAddress, price: Decimal) => Promise<InitPoolTickIfNeeded>;
+}
+export default Kamino;