@kamino-finance/kliquidity-sdk 8.4.5 → 8.4.7-beta.0

package/dist/Kamino.d.ts

@@ -1,36 +1,327 @@
 import { HubbleConfig, SolanaCluster } from '@hubbleprotocol/hubble-config';
-import { Account, Address, IInstruction, Option, Rpc, Slot, SolanaRpcApi, TransactionSigner } from '@solana/kit';
-import { GlobalConfig, TermsSignature, WhirlpoolStrategy } from './@codegen/kliquidity/accounts';
+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 as OrcaPosition, Whirlpool } from './@codegen/whirlpools/accounts';
-import { KaminoPosition, KaminoPrices, KaminoStrategyWithShareMint, ShareData, ShareDataWithAddress, StrategyHolder, StrategyPrices, StrategyWithPendingFees, TokenAmounts, TotalStrategyVaultTokens } from './models';
-import { OraclePrices } from '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/OraclePrices';
-import { DepositAmountsForSwap, Dex, GenericPoolInfo, GenericPositionRangeInfo, InitPoolTickIfNeeded, InitStrategyIxs, InputRebalanceFieldInfo, InstructionsWithLookupTables, LiquidityDistribution, LowerAndUpperTickPubkeys, MaybeTokensBalances, MetadataProgramAddressesOrca, MetadataProgramAddressesRaydium, PerformanceFees, PositionRange, PriceReferenceType, ProfiledFunctionExecution, RebalanceFieldInfo, StrategiesFilters, SwapperIxBuilder, TokensBalances, VaultParameters, WithdrawAllAndCloseIxns, WithdrawShares } from './utils';
+import { Position, Whirlpool } from './whirlpools-client';
+import { KaminoPosition, KaminoStrategyWithShareMint, ShareData, ShareDataWithAddress, StrategyHolder, StrategyWithPendingFees, TokenAmounts, TotalStrategyVaultTokens } from './models';
+import { OraclePrices } from '@kamino-finance/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 BN from 'bn.js';
 import StrategyWithAddress from './models/StrategyWithAddress';
-import { CollateralInfo, ExecutiveWithdrawActionKind, RebalanceTypeKind, ReferencePriceTypeKind, StrategyStatusKind } from './@codegen/kliquidity/types';
-import { AmmConfig, PersonalPositionState, PoolState } from './@codegen/raydium/accounts';
-import { Whirlpool as WhirlpoolAPIResponse, WhirlpoolAprApy } from './services';
+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 './@codegen/meteora/accounts';
+import { LbPair, PositionV2 } from './meteora_client/accounts';
 import LbPairWithAddress from './models/LbPairWithAddress';
-import { Token } from '@solana-program/token-2022';
-import { AddressLookupTable } from '@solana-program/address-lookup-table';
-import type { AccountInfoBase, AccountInfoWithJsonData, AccountInfoWithPubkey } from '@solana/rpc-types';
-import { Connection } from '@solana/web3.js';
+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 _rpc;
-    private readonly _legacyConnection;
+    private readonly _connection;
     readonly _config: HubbleConfig;
     private _globalConfig;
     private readonly _scope;
-    private readonly _kliquidityProgramId;
+    private readonly _provider;
+    private readonly _kaminoProgram;
+    private readonly _kaminoProgramId;
     private readonly _orcaService;
     private readonly _raydiumService;
     private readonly _meteoraService;
@@ -38,24 +329,21 @@ export declare class Kamino {
     /**
      * Create a new instance of the Kamino SDK class.
      * @param cluster Name of the Solana cluster
-     * @param rpc Connection to the Solana cluster
-     * @param legacyConnection Connection to 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
-     * @param meteoraProgramId
-     * @param jupBaseAPI
-     */
-    constructor(cluster: SolanaCluster, rpc: Rpc<SolanaRpcApi>, legacyConnection: Connection, globalConfig?: Address, programId?: Address, whirlpoolProgramId?: Address, raydiumProgramId?: Address, meteoraProgramId?: Address, jupBaseAPI?: string);
-    getConnection: () => Rpc<import("@solana/kit").RequestAirdropApi & import("@solana/kit").GetAccountInfoApi & import("@solana/kit").GetBalanceApi & import("@solana/kit").GetBlockApi & import("@solana/kit").GetBlockCommitmentApi & import("@solana/kit").GetBlockHeightApi & import("@solana/kit").GetBlockProductionApi & import("@solana/kit").GetBlocksApi & import("@solana/kit").GetBlocksWithLimitApi & import("@solana/kit").GetBlockTimeApi & import("@solana/kit").GetClusterNodesApi & import("@solana/kit").GetEpochInfoApi & import("@solana/kit").GetEpochScheduleApi & import("@solana/kit").GetFeeForMessageApi & import("@solana/kit").GetFirstAvailableBlockApi & import("@solana/kit").GetGenesisHashApi & import("@solana/kit").GetHealthApi & import("@solana/kit").GetHighestSnapshotSlotApi & import("@solana/kit").GetIdentityApi & import("@solana/kit").GetInflationGovernorApi & import("@solana/kit").GetInflationRateApi & import("@solana/kit").GetInflationRewardApi & import("@solana/kit").GetLargestAccountsApi & import("@solana/kit").GetLatestBlockhashApi & import("@solana/kit").GetLeaderScheduleApi & import("@solana/kit").GetMaxRetransmitSlotApi & import("@solana/kit").GetMaxShredInsertSlotApi & import("@solana/kit").GetMinimumBalanceForRentExemptionApi & import("@solana/kit").GetMultipleAccountsApi & import("@solana/kit").GetProgramAccountsApi & import("@solana/kit").GetRecentPerformanceSamplesApi & import("@solana/kit").GetRecentPrioritizationFeesApi & import("@solana/kit").GetSignaturesForAddressApi & import("@solana/kit").GetSignatureStatusesApi & import("@solana/kit").GetSlotApi & import("@solana/kit").GetSlotLeaderApi & import("@solana/kit").GetSlotLeadersApi & import("@solana/kit").GetStakeMinimumDelegationApi & import("@solana/kit").GetSupplyApi & import("@solana/kit").GetTokenAccountBalanceApi & import("@solana/kit").GetTokenAccountsByDelegateApi & import("@solana/kit").GetTokenAccountsByOwnerApi & import("@solana/kit").GetTokenLargestAccountsApi & import("@solana/kit").GetTokenSupplyApi & import("@solana/kit").GetTransactionApi & import("@solana/kit").GetTransactionCountApi & import("@solana/kit").GetVersionApi & import("@solana/kit").GetVoteAccountsApi & import("@solana/kit").IsBlockhashValidApi & import("@solana/kit").MinimumLedgerSlotApi & import("@solana/kit").SendTransactionApi & import("@solana/kit").SimulateTransactionApi>;
-    getLegacyConnection: () => Connection;
-    getProgramID: () => Address;
-    setGlobalConfig: (globalConfig: Address) => void;
-    getGlobalConfig: () => Address;
+     */
+    constructor(cluster: SolanaCluster, connection: Connection, globalConfig?: PublicKey, programId?: PublicKey, whirlpoolProgramId?: PublicKey, raydiumProgramId?: PublicKey, meteoraProgramId?: PublicKey, jupBaseAPI?: string);
+    getConnection: () => Connection;
+    getProgramID: () => PublicKey;
+    getProgram: () => Program<Idl>;
+    setGlobalConfig: (globalConfig: PublicKey) => void;
+    getGlobalConfig: () => PublicKey;
     getDepositableTokens: () => Promise<CollateralInfo[]>;
     getCollateralInfos: () => Promise<CollateralInfo[]>;
-    getDisabledTokensPrices: (collateralInfos?: CollateralInfo[]) => Promise<Map<Address, Decimal>>;
+    getDisabledTokensPrices: (collateralInfos?: CollateralInfo[]) => Promise<PubkeyHashMap<PublicKey, Decimal>>;
     getSupportedDexes: () => Dex[];
     getFeeTiersForDex: (dex: Dex) => Decimal[];
     getRebalanceMethods: () => RebalanceMethod[];
@@ -71,71 +359,66 @@ export declare class Kamino {
      * Retunrs the rebalance method the fields represent with more details (description, enabled, etc)
      */
     getRebalanceMethodFromRebalanceFields: (rebalanceFields: RebalanceFieldInfo[]) => RebalanceMethod;
-    getReferencePriceTypeForStrategy: (strategy: Address | StrategyWithAddress) => Promise<PriceReferenceType>;
-    getFieldsForRebalanceMethod: (rebalanceMethod: RebalanceMethod, dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: Address, tokenBMint: Address, tickSpacing: number, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
-    getFieldsForManualRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: Address, tokenBMint: Address, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
-    getFieldsForPricePercentageMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: Address, tokenBMint: Address, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
-    getFieldsForPricePercentageWithResetMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: Address, tokenBMint: Address, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
-    getFieldsForDriftRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tickSpacing: number, tokenAMint: Address, tokenBMint: Address, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
-    getFieldsForTakeProfitRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: Address, tokenBMint: Address, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
-    getFieldsForPeriodicRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: Address, tokenBMint: Address, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
-    getFieldsForExpanderRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: Address, tokenBMint: Address, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
-    getFieldsForAutodriftRebalanceMethod: (dex: Dex, fieldOverrides: RebalanceFieldInfo[], tokenAMint: Address, tokenBMint: Address, tickSpacing: number, poolPrice?: Decimal) => Promise<RebalanceFieldInfo[]>;
+    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: Address, poolTokenB: Address) => Promise<number>;
-    getDefaultRebalanceFields: (dex: Dex, poolTokenA: Address, poolTokenB: Address, tickSpacing: number, rebalanceMethod: RebalanceMethod) => Promise<RebalanceFieldInfo[]>;
+    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: Address, poolTokenB: Address, feeBPS: Decimal) => Promise<Address>;
+    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: Address, tokenMintB: Address): Promise<GenericPoolInfo[]>;
-    getOrcaPoolsForTokens: (poolTokenA: Address, poolTokenB: Address) => Promise<WhirlpoolAPIResponse[]>;
-    getRaydiumPoolsForTokens: (poolTokenA: Address, poolTokenB: Address) => Promise<Pool[]>;
-    getMeteoraPoolsForTokens: (poolTokenA: Address, poolTokenB: Address) => Promise<MeteoraPool[]>;
+    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<Address>) => Promise<Array<WhirlpoolStrategy | null>>;
+    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<Address>) => Promise<Array<StrategyWithAddress>>;
+    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: Address) => Promise<WhirlpoolStrategy | null>;
+    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: Address) => Promise<StrategyWithAddress | null>;
+    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: Address | StrategyWithAddress, scopePrices?: OraclePrices) => Promise<ShareData>;
-    /**
-     * Get the token A and B per share for the specified Kamino whirlpool strategy
-     * @param strategy
-     */
-    getTokenAAndBPerShare: (strategy: Address | StrategyWithAddress) => Promise<TokenAmounts>;
+    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 | Address[], stratsWithAddresses?: StrategyWithAddress[], collateralInfos?: CollateralInfo[], disabledTokensPrices?: Map<Address, Decimal>) => Promise<Array<ShareDataWithAddress>>;
+    getStrategiesShareData: (strategyFilters: StrategiesFilters | PublicKey[], stratsWithAddresses?: StrategyWithAddress[], collateralInfos?: CollateralInfo[], disabledTokensPrices?: PubkeyHashMap<PublicKey, Decimal>) => Promise<Array<ShareDataWithAddress>>;
     private getBalance;
     private getRaydiumBalances;
     private getMeteoraBalances;
@@ -152,21 +435,21 @@ export declare class Kamino {
      * Get the strategy share price of the specified Kamino whirlpool strategy
      * @param strategy
      */
-    getStrategySharePrice: (strategy: Address | StrategyWithAddress) => Promise<Decimal>;
-    getTokenAccountBalance: (tokenAccount: Address) => Promise<Decimal>;
+    getStrategySharePrice: (strategy: PublicKey | StrategyWithAddress) => Promise<Decimal>;
+    private getTokenAccountBalance;
     /**
      * Get the balance of a token account or 0 if it doesn't exist
      * @param tokenAccount
      */
-    getTokenAccountBalanceOrZero: (tokenAccount: Address) => Promise<Decimal>;
+    private getTokenAccountBalanceOrZero;
     private getStrategyBalances;
     private getStrategyTokensBalances;
     /**
      * Get amount of specified token in all Kamino live strategies
      * @param tokenMint token mint pubkey
      */
-    getTotalTokensInStrategies: (tokenMint: Address | string) => Promise<TotalStrategyVaultTokens>;
-    getAccountOwner: (pk: Address) => Promise<Address>;
+    getTotalTokensInStrategies: (tokenMint: PublicKey | string) => Promise<TotalStrategyVaultTokens>;
+    getAccountOwner: (pk: PublicKey) => Promise<PublicKey>;
     private getStrategyBalancesOrca;
     private getStrategyBalancesRaydium;
     private getStrategyBalancesMeteora;
@@ -177,7 +460,7 @@ export declare class Kamino {
      * @param oraclePrices (optional) Scope Oracle prices
      * @param collateralInfos (optional) Kamino Collateral Infos
      */
-    getAllPrices: (oraclePrices?: OraclePrices, collateralInfos?: CollateralInfo[], disabledTokensPrices?: Map<Address, Decimal>) => Promise<KaminoPrices>;
+    getAllPrices: (oraclePrices?: OraclePrices, collateralInfos?: CollateralInfo[], disabledTokensPrices?: PubkeyHashMap<PublicKey, Decimal>) => Promise<KaminoPrices>;
     private getOraclePricesAndCollateralInfos;
     /**
      * Get the prices of all tokens in the specified strategy, or null if the reward token does not exist
@@ -185,89 +468,79 @@ export declare class Kamino {
      * @param collateralInfos
      * @param scopePrices
      */
-    getStrategyPrices: (strategy: WhirlpoolStrategy, collateralInfos: CollateralInfo[], scopePrices?: OraclePrices, disabledTokensPrices?: Map<Address, Decimal>) => Promise<StrategyPrices>;
+    getStrategyPrices: (strategy: WhirlpoolStrategy, collateralInfos: CollateralInfo[], scopePrices?: OraclePrices, disabledTokensPrices?: PubkeyHashMap<PublicKey, Decimal>) => Promise<StrategyPrices>;
     /**
      * Get all token accounts for the specified share mint
      */
-    getShareTokenAccounts: (shareMint: Address) => Promise<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithJsonData>[]>;
+    getShareTokenAccounts: (shareMint: PublicKey) => Promise<{
+        pubkey: PublicKey;
+        account: AccountInfo<Buffer | ParsedAccountData>;
+    }[]>;
     /**
      * Get all token accounts for the specified wallet
      */
-    getAllTokenAccounts: (wallet: Address) => Promise<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithJsonData>[]>;
+    getAllTokenAccounts: (wallet: PublicKey) => Promise<{
+        pubkey: PublicKey;
+        account: AccountInfo<Buffer | ParsedAccountData>;
+    }[]>;
     /**
      * Get all token accounts that are holding a specific Kamino whirlpool strategy
      */
-    getStrategyTokenAccounts: (strategy: Address | StrategyWithAddress) => Promise<Readonly<{
-        account: Readonly<{
-            executable: boolean;
-            lamports: import("@solana/kit").Lamports;
-            owner: Address;
-            rentEpoch: bigint;
-            space: bigint;
-        }> & Readonly<{
-            data: import("@solana/kit").Base64EncodedDataResponse | Readonly<{
-                parsed: {
-                    info?: object;
-                    type: string;
-                };
-                program: string;
-                space: bigint;
-            }>;
-        }>;
-        pubkey: Address;
-    }>[]>;
+    getStrategyTokenAccounts: (strategy: PublicKey | StrategyWithAddress) => Promise<{
+        pubkey: PublicKey;
+        account: AccountInfo<Buffer | ParsedAccountData>;
+    }[]>;
     /**
      * Get strategy range in which liquidity is deposited
      */
-    getStrategyRange: (strategy: Address | StrategyWithAddress) => Promise<PositionRange>;
-    getStrategyRangeOrca: (strategy: Address | StrategyWithAddress) => Promise<PositionRange>;
-    getStrategyRangeRaydium: (strategy: Address | StrategyWithAddress) => Promise<PositionRange>;
-    getStrategyRangeMeteora: (strategy: Address | StrategyWithAddress) => Promise<PositionRange>;
-    getPositionRange: (dex: Dex, position: Address, decimalsA: number, decimalsB: number) => Promise<PositionRange>;
-    getPositionRangeOrca: (positionPk: Address, decimalsA: number, decimalsB: number) => Promise<PositionRange>;
-    getPositionRangeRaydium: (positionPk: Address, decimalsA: number, decimalsB: number) => Promise<PositionRange>;
-    getPositionRangeMeteora: (positionPk: Address, decimalsA: number, decimalsB: number) => Promise<PositionRange>;
+    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: Address | StrategyWithAddress) => Promise<StrategyHolder[]>;
+    getStrategyHolders: (strategy: PublicKey | StrategyWithAddress) => Promise<StrategyHolder[]>;
     /**
      * Get a list of Orca whirlpools from public keys
      * @param whirlpools
      */
-    getWhirlpools: (whirlpools: Address[]) => Promise<Map<Address, Whirlpool | null>>;
-    getAllWhirlpoolsFromAPI: (tokens?: Address[]) => Promise<WhirlpoolAPIResponse[]>;
+    getWhirlpools: (whirlpools: PublicKey[]) => Promise<PubkeyHashMap<PublicKey, Whirlpool | null>>;
     /**
      * Get a list of Orca positions from public keys
      * @param positions
      */
-    getOrcaPositions: (positions: Address[]) => Promise<(OrcaPosition | null)[]>;
+    getOrcaPositions: (positions: PublicKey[]) => Promise<(Position | null)[]>;
     /**
      * Get a list of Raydium positions from public keys
      * @param positions
      */
-    getRaydiumPositions: (positions: Address[]) => Promise<(PersonalPositionState | null)[]>;
-    getMeteoraPositions: (positions: Address[]) => Promise<(PositionV2 | null)[]>;
+    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: Address) => Promise<Whirlpool | null>;
+    getWhirlpoolByAddress: (whirlpool: PublicKey) => Promise<Whirlpool | null>;
     /**
      * Get a list of Raydium pools from public keys
      * @param pools
      */
-    getRaydiumPools: (pools: Address[]) => Promise<Map<Address, PoolState | null>>;
-    getMeteoraPools: (pools: Address[]) => Promise<Map<Address, LbPair | null>>;
-    getRaydiumAmmConfig: (config: Address) => Promise<AmmConfig | null>;
+    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: Address) => Promise<PoolState | null>;
-    getMeteoraPoolByAddress: (pool: Address) => Promise<LbPair | null>;
-    getEventAuthorityPDA: (dex: BN) => Promise<Option<Address>>;
+    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
@@ -275,7 +548,7 @@ export declare class Kamino {
      * @param owner shares owner (wallet with shares)
      * @returns transaction instruction
      */
-    withdrawShares: (strategy: Address | StrategyWithAddress, sharesAmount: Decimal, owner: TransactionSigner, sharesAtaBalance?: Decimal) => Promise<WithdrawShares>;
+    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)
@@ -288,10 +561,10 @@ export declare class Kamino {
      * @param sharesAta associated token account for shares
      * @returns list of transaction instructions (empty if all accounts already exist)
      */
-    getCreateAssociatedTokenAccountInstructionsIfNotExist: (owner: TransactionSigner, strategyState: StrategyWithAddress, tokenAData: Account<Token> | null, tokenAAta: Address, tokenBData: Account<Token> | null, tokenBAta: Address, sharesMintData: Account<Token> | null, sharesAta: Address) => Promise<IInstruction[]>;
+    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 Address and return it
+     * otherwise fetch it first from PublicKey and return it
      * @param strategy
      * @private
      */
@@ -311,14 +584,14 @@ export declare class Kamino {
      * @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: Address | StrategyWithAddress, owner: TransactionSigner) => Promise<WithdrawShares | null>;
+    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: Address | StrategyWithAddress, owner: Address) => Promise<Address[]>;
+    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
@@ -327,12 +600,10 @@ export declare class Kamino {
      * @param owner Owner (wallet, shareholder) public key
      * @returns transaction instruction for depositing tokens into a strategy
      */
-    deposit: (strategy: Address | StrategyWithAddress, amountA: Decimal, amountB: Decimal, owner: TransactionSigner) => Promise<IInstruction>;
-    singleSidedDepositTokenA: (strategy: Address | StrategyWithAddress, amountToDeposit: Decimal, owner: TransactionSigner, slippageBps: Decimal, profiler?: ProfiledFunctionExecution, swapIxsBuilder?: SwapperIxBuilder, initialUserTokenAtaBalances?: TokensBalances, priceAInB?: Decimal, includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas,
-    onlyDirectRoutes?: boolean) => Promise<InstructionsWithLookupTables>;
-    singleSidedDepositTokenB: (strategy: Address | StrategyWithAddress, amountToDeposit: Decimal, owner: TransactionSigner, slippageBps: Decimal, profiler?: ProfiledFunctionExecution, swapIxsBuilder?: SwapperIxBuilder, initialUserTokenAtaBalances?: TokensBalances, priceAInB?: Decimal, includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas,
-    onlyDirectRoutes?: boolean) => Promise<InstructionsWithLookupTables>;
-    getInitialUserTokenBalances: (owner: Address, tokenAMint: Address, tokenBMint: Address, initialUserTokenBalances?: MaybeTokensBalances) => Promise<TokensBalances>;
+    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>;
     /**
@@ -341,23 +612,23 @@ export declare class Kamino {
      * @param amountLamports Amount of SOL to deposit into topup vault
      * @returns transaction instruction for adding SOL to topup vault
      */
-    upkeepTopupVault: (owner: TransactionSigner, amountLamports: Decimal) => Promise<IInstruction>;
+    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: Address) => Promise<Decimal>;
+    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: TransactionSigner, amount: Decimal) => Promise<IInstruction>;
-    getJupSwapIxsWithMaxAccounts: (input: DepositAmountsForSwap, tokenAMint: Address, tokenBMint: Address, owner: Address, slippageBps: Decimal, useOnlyLegacyTransaction: boolean, existingAccounts: Address[], maxAccounts: number, profiler?: ProfiledFunctionExecution, onlyDirectRoutes?: boolean) => Promise<[IInstruction[], Address[]]>;
-    getJupSwapIxsV6: (input: DepositAmountsForSwap, tokenAMint: Address, tokenBMint: Address, owner: Address, slippageBps: Decimal, useOnlyLegacyTransaction: boolean, existingAccounts: Address[], profiledFunctionExecution?: ProfiledFunctionExecution, onlyDirectRoutes?: boolean) => Promise<[IInstruction[], Address[]]>;
-    getCheckExpectedVaultsBalancesIx: (strategy: StrategyWithAddress, user: TransactionSigner, tokenAAta: Address, tokenBAta: Address, expectedTokensBalances?: MaybeTokensBalances) => Promise<IInstruction>;
+    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:
@@ -369,24 +640,22 @@ export declare class Kamino {
      * @param dex decentralized exchange specifier
      * @returns transaction instruction for Kamino strategy creation
      */
-    createStrategy: (strategy: Address, pool: Address, owner: TransactionSigner, dex: Dex) => Promise<IInstruction>;
+    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
-     * @param admin signer to close the strategy
      * @returns instruction to close the strategy
      */
-    withdrawAllAndCloseStrategy: (admin: TransactionSigner, strategy: Address | StrategyWithAddress) => Promise<WithdrawAllAndCloseIxns | null>;
+    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 admin signer to close the strategy
      * @param strategy public key of the strategy
      * @returns instruction to close the strategy
      */
-    closeStrategy: (admin: TransactionSigner, strategy: Address | StrategyWithAddress) => Promise<IInstruction<string, readonly (import("@solana/kit").IAccountMeta<string> | import("@solana/kit").IAccountLookupMeta<string, string>)[]>>;
-    getUserTopupVault: (user: Address) => Promise<Address>;
+    closeStrategy: (strategy: PublicKey | StrategyWithAddress) => Promise<TransactionInstruction>;
+    getUserTopupVault: (user: PublicKey) => PublicKey;
     /**
      * Find program adresses required for kamino strategy creation
      * @param strategy
@@ -402,8 +671,8 @@ export declare class Kamino {
      * @param newStrategy public key of the new strategy
      * @returns transaction instruction to create the account
      */
-    createStrategyAccount: (payer: TransactionSigner, newStrategy: TransactionSigner) => Promise<IInstruction>;
-    createAccountRentExempt: (payer: TransactionSigner, newAccount: TransactionSigner, size: bigint) => Promise<IInstruction>;
+    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.
@@ -411,27 +680,26 @@ export declare class Kamino {
      * @param owner signer of the tx
      * @returns transaction instruction to collect strategy fees and rewards
      */
-    collectFeesAndRewards: (strategy: Address | StrategyWithAddress, owner: TransactionSigner) => Promise<IInstruction>;
+    collectFeesAndRewards: (strategy: PublicKey | StrategyWithAddress, owner?: PublicKey) => Promise<TransactionInstruction>;
     /**
      * Get orca position metadata program addresses
      * @param positionMint mint account of the position
      */
-    getMetadataProgramAddressesOrca: (positionMint: Address) => Promise<MetadataProgramAddressesOrca>;
-    getMetadataProgramAddressesRaydium: (positionMint: Address, pool: Address, tickLowerIndex: number, tickUpperIndex: number) => Promise<MetadataProgramAddressesRaydium>;
-    getStartEndTickIndexProgramAddressesOrca: (whirlpool: Address, whirlpoolState: Whirlpool, tickLowerIndex: number, tickUpperIndex: number) => Promise<LowerAndUpperTickPubkeys>;
+    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 admin strategy admin authority
      * @param strategy strategy you want to open liquidity position for
-     * @param positionMint position mint keypair
+     * @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: (admin: TransactionSigner, strategy: Address | StrategyWithAddress, positionMint: TransactionSigner, priceLower: Decimal, priceUpper: Decimal, status?: StrategyStatusKind) => Promise<IInstruction>;
+    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
@@ -440,7 +708,7 @@ export declare class Kamino {
      * @param priceUpper new position's upper price of the range
      * @param status strategy status
      */
-    openPositionOrca: (adminAuthority: TransactionSigner, strategy: Address, baseVaultAuthority: Address, pool: Address, positionMint: TransactionSigner, priceLower: Decimal, priceUpper: Decimal, tokenAVault: Address, tokenBVault: Address, tokenAMint: Address, tokenBMint: Address, tokenATokenProgram: Address, tokenBTokenProgram: Address, oldPositionOrBaseVaultAuthority: Address, oldPositionMintOrBaseVaultAuthority: Address, oldPositionTokenAccountOrBaseVaultAuthority: Address, oldTickArrayLowerOrBaseVaultAuthority: Address, oldTickArrayUpperOrBaseVaultAuthority: Address, status?: StrategyStatusKind) => Promise<IInstruction>;
+    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
@@ -449,7 +717,7 @@ export declare class Kamino {
      * @param priceUpper new position's upper price of the range
      * @param status strategy status
      */
-    openPositionRaydium: (adminAuthority: TransactionSigner, strategy: Address, baseVaultAuthority: Address, pool: Address, positionMint: TransactionSigner, priceLower: Decimal, priceUpper: Decimal, tokenAVault: Address, tokenBVault: Address, tokenAMint: Address, tokenBMint: Address, tokenATokenProgram: Address, tokenBTokenProgram: Address, oldTickArrayLowerOrBaseVaultAuthority: Address, oldTickArrayUpperOrBaseVaultAuthority: Address, oldPositionOrBaseVaultAuthority: Address, oldPositionMintOrBaseVaultAuthority: Address, oldPositionTokenAccountOrBaseVaultAuthority: Address, oldProtocolPositionOrBaseVaultAuthority: Address, eventAuthority: Option<Address>, status?: StrategyStatusKind, strategyRewardOVault?: Address, strategyReward1Vault?: Address, strategyReward2Vault?: Address) => Promise<IInstruction>;
+    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
@@ -458,43 +726,42 @@ export declare class Kamino {
      * @param priceUpper new position's upper price of the range
      * @param status strategy status
      */
-    openPositionMeteora: (adminAuthority: TransactionSigner, strategy: Address, baseVaultAuthority: Address, pool: Address, position: TransactionSigner, priceLower: Decimal, priceUpper: Decimal, tokenAVault: Address, tokenBVault: Address, tokenAMint: Address, tokenBMint: Address, tokenATokenProgram: Address, tokenBTokenProgram: Address, oldPositionOrBaseVaultAuthority: Address, oldPositionMintOrBaseVaultAuthority: Address, oldPositionTokenAccountOrBaseVaultAuthority: Address, oldTickArrayLowerOrBaseVaultAuthority: Address, oldTickArrayUpperOrBaseVaultAuthority: Address, eventAuthority: Option<Address>, status?: StrategyStatusKind) => Promise<IInstruction>;
+    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: (admin: TransactionSigner, strategy: Address | StrategyWithAddress, action: ExecutiveWithdrawActionKind) => Promise<IInstruction>;
+    executiveWithdraw: (strategy: PublicKey | StrategyWithAddress, action: ExecutiveWithdrawActionKind) => Promise<TransactionInstruction>;
     /**
      * Get a an instruction to update the reference price type of a strategy
-     * @param admin transaction signer
      * @param strategy strategy pubkey or object
      * @param referencePriceType new reference price type
      */
-    getUpdateReferencePriceTypeIx: (admin: TransactionSigner, strategy: Address | StrategyWithAddress, referencePriceType: ReferencePriceTypeKind) => Promise<IInstruction>;
+    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: Address | StrategyWithAddress, payer: TransactionSigner) => Promise<IInstruction>;
+    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: Address | StrategyWithAddress, payer: TransactionSigner) => Promise<IInstruction[]>;
+    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: Address[]) => Promise<StrategyWithPendingFees[]>;
-    getUpdateRebalancingParamsFromRebalanceFieldsIx: (strategyAdmin: TransactionSigner, strategy: Address | StrategyWithAddress, rebalanceFieldInfos: RebalanceFieldInfo[]) => Promise<IInstruction>;
-    processRebalanceParams: (dex: Dex, pool: Address | WhirlpoolWithAddress, rebalanceType: Decimal, rebalanceParams: Decimal[]) => Promise<Decimal[]>;
-    getUpdateRebalancingParamsIxns: (strategyAdmin: TransactionSigner, strategy: Address | StrategyWithAddress, rebalanceParams: Decimal[], rebalanceType?: RebalanceTypeKind, tokenADecimals?: number, tokenBDecimals?: number) => Promise<IInstruction>;
-    getUpdateRebalancingParamsForUninitializedStratIx: (strategyAdmin: TransactionSigner, strategy: Address, rebalanceParams: Decimal[], rebalanceType: RebalanceTypeKind, tokenADecimals: number, tokenBDecimals: number) => Promise<IInstruction>;
-    buildStrategyRebalanceParams: (strategy: Address | StrategyWithAddress) => Promise<number[]>;
+    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)
@@ -504,38 +771,29 @@ export declare class Kamino {
      * @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: Address, positionMint: TransactionSigner, strategyAdmin: TransactionSigner, rebalanceType: Decimal, rebalanceParams: Decimal[], tokenAMint: Address, tokenBMint: Address, depositCap?: Decimal, depositCapPerIx?: Decimal, withdrawFeeBps?: Decimal, depositFeeBps?: Decimal, performanceFeeBps?: Decimal) => Promise<InitStrategyIxs>;
-    getNewPositionRange(strategy: Address | StrategyWithAddress, rebalanceKind: RebalanceTypeKind, rebalanceParams: Decimal[]): Promise<PositionRange>;
+    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: Address | StrategyWithAddress): Promise<Decimal>;
-    getCurrentPriceFromPool(dex: Dex, pool: Address, tokenADecimals?: number, tokenBDecimals?: number): Promise<Decimal>;
-    getPoolTickSpacing(dex: Dex, pool: Address): Promise<number>;
-    getPriceRangePercentageBasedFromPool(dex: Dex, pool: Address, lowerPriceBpsDifference: Decimal, upperPriceBpsDifference: Decimal): Promise<[Decimal, Decimal]>;
+    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: Address | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
+    readRebalancingParamsFromChain(strategy: PublicKey | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
     /**
      * Get the raw rebalancing params given the strategy type
      */
-    readRebalancingStateFromChain(strategy: Address | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
-    /**
-     * Get the current withdrawal caps for a strategy
-     */
-    getStrategyCurrentWithdrawalCaps(strategy: Address | StrategyWithAddress): Promise<TokenAmounts>;
-    /**
-     * Get the max USD value that can be deposited per ix for a strategy
-     */
-    getStrategyDepositCapInUSDPerIx(strategy: Address | StrategyWithAddress): Promise<Decimal>;
-    getStrategyMaxDepositInUSD(strategy: Address | StrategyWithAddress): Promise<Decimal>;
+    readRebalancingStateFromChain(strategy: PublicKey | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
     /**
      * Get the prices for rebalancing params (range and reset range, if strategy involves a reset range)
      */
-    readRebalancingParams(strategy: Address | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
+    readRebalancingParams(strategy: PublicKey | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
     /**
      * Get the rebalancing params from chain, alongside the current details of the position, reset range, etc
      */
-    readRebalancingParamsWithState(strategy: Address | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
+    readRebalancingParamsWithState(strategy: PublicKey | StrategyWithAddress): Promise<RebalanceFieldInfo[]>;
     /**
      * Get a list of updated rebalance field infos.
      * @param initialRebalanceFieldInfos the initial list of rebalance field infos
@@ -547,31 +805,28 @@ export declare class Kamino {
     /**
      * Read the pool price for a specific dex and pool
      */
-    getPoolPrice(dex: Dex, pool: Address, tokenADecimals: number, tokenBDecimals: number): Promise<Decimal>;
-    getOrcaPoolPrice(pool: Address, tokenADecimals?: number, tokenBDecimals?: number): Promise<Decimal>;
-    getRaydiumPoolPrice(pool: Address): Promise<Decimal>;
-    getMeteoraPoolPrice(pool: Address): Promise<Decimal>;
-    getGenericPoolInfo(dex: Dex, pool: Address): Promise<GenericPoolInfo>;
-    mintIsSupported: (collateralInfos: CollateralInfo[], tokenMint: Address) => boolean;
-    getCollateralInfoFromMint: (mint: Address, collateralInfos: CollateralInfo[]) => CollateralInfo | undefined;
-    getCollateralIdFromMint: (mint: Address, collateralInfos: CollateralInfo[]) => number;
-    getMainLookupTablePks: () => Promise<Address[]>;
-    getMainLookupTable: () => Promise<Account<AddressLookupTable>[] | undefined>;
-    getInitLookupTableIx: (authority: TransactionSigner, slot?: Slot) => Promise<[IInstruction, Address]>;
-    getPopulateLookupTableIxs: (authority: TransactionSigner, lookupTable: Address, strategy: Address | StrategyWithAddress) => Promise<IInstruction[]>;
-    getAddLookupTableEntriesIxs: (authority: TransactionSigner, lookupTable: Address, entries: Address[]) => IInstruction[];
-    getLookupTable: (tablePk: Address) => Promise<Account<AddressLookupTable>>;
-    setupStrategyLookupTable: (authority: TransactionSigner, strategy: Address | StrategyWithAddress, slot?: Slot) => Promise<{
-        lookupTable: Address;
-        createLookupTableIx: IInstruction;
-        populateLookupTableIxs: IInstruction[];
-        updateStrategyLookupTableIx: IInstruction;
-    }>;
+    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: Address;
+        pool: PublicKey;
         priceLower: Decimal;
         priceUpper: Decimal;
         startDate: string;
@@ -580,62 +835,61 @@ export declare class Kamino {
     getPercentagePoolSimulatedValues: (params: SimulationPercentagePoolParameters) => Promise<PoolSimulationResponse>;
     /**
      * Get a list of transactions to rebalance a Kamino strategy.
-     * @param admin pool admin
      * @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: (admin: TransactionSigner, strategy: Address | StrategyWithAddress, newPosition: TransactionSigner, priceLower: Decimal, priceUpper: Decimal) => Promise<IInstruction[]>;
+    rebalance: (strategy: PublicKey | StrategyWithAddress, newPosition: PublicKey, priceLower: Decimal, priceUpper: Decimal) => Promise<TransactionInstruction[]>;
     /**
      * Get a list of user's Kamino strategy positions
      * @param wallet user wallet address
      * @param strategyFilters
      * @returns list of kamino strategy positions
      */
-    getUserPositions: (wallet: Address, strategyFilters?: StrategiesFilters) => Promise<KaminoPosition[]>;
+    getUserPositions: (wallet: PublicKey, strategyFilters?: StrategiesFilters) => Promise<KaminoPosition[]>;
     /**
      * Get a list of user's Kamino strategy positions
      * @param wallet user wallet address
-     * @param strategiesWithShareMintsMap
-     * @param strategiesWithAddressMap
      * @returns list of kamino strategy positions
      */
-    getUserPositionsByStrategiesMap: (wallet: Address, strategiesWithShareMintsMap: Map<Address, KaminoStrategyWithShareMint>, strategiesWithAddressMap?: Map<Address, WhirlpoolStrategy>) => Promise<KaminoPosition[]>;
+    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: Address | StrategyWithAddress, orcaPools?: WhirlpoolAPIResponse[], raydiumPools?: Pool[]) => Promise<WhirlpoolAprApy>;
-    getStrategyPerformanceFees: (strategy: Address | StrategyWithAddress, globalConfig?: GlobalConfig) => Promise<PerformanceFees>;
-    getLiquidityDistributionRaydiumPool: (pool: Address, keepOrder?: boolean, lowestTick?: number, highestTick?: number) => Promise<LiquidityDistribution>;
-    getLiquidityDistributionMeteoraPool: (pool: Address, keepOrder?: boolean, lowestTick?: number, highestTick?: number) => Promise<LiquidityDistribution>;
-    getLiquidityDistributionOrcaWhirlpool: (pool: Address, keepOrder?: boolean, lowestTick?: number, highestTick?: number) => Promise<LiquidityDistribution>;
-    getLiquidityDistribution: (dex: Dex, pool: Address, keepOrder?: boolean, lowestTick?: number, highestTick?: number) => Promise<LiquidityDistribution>;
-    getPositionsCountForPool: (dex: Dex, pool: Address) => Promise<number>;
-    getStrategyTokensHoldings: (strategy: Address | StrategyWithAddress, mode?: "DEPOSIT" | "WITHDRAW") => Promise<TokenAmounts>;
+    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: Address | StrategyWithAddress) => Promise<Decimal>;
-    calculateAmountsToBeDepositedWithSwap: (strategy: Address | StrategyWithAddress, tokenAAmountUserDeposit: Decimal, tokenBAmountUserDeposit: Decimal, profiler?: ProfiledFunctionExecution, priceAInB?: Decimal) => Promise<DepositAmountsForSwap>;
+    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: Address, lowerPrice: Decimal, upperPrice: Decimal) => Promise<[Decimal, Decimal]>;
-    calculateAmountsToBeDeposited: (strategy: Address | StrategyWithAddress, tokenAAmount?: Decimal, tokenBAmount?: Decimal, profiledFunctionExecution?: ProfiledFunctionExecution) => Promise<[Decimal, Decimal]>;
-    calculateAmountsRatioToBeDeposited: (strategy: Address | StrategyWithAddress, holdings?: TokenAmounts, profiler?: ProfiledFunctionExecution) => Promise<[Decimal, Decimal]>;
-    calculateDepositAmountsProportional: (strategy: Address | StrategyWithAddress, tokenAAmount?: Decimal, tokenBAmount?: Decimal, profiler?: ProfiledFunctionExecution) => Promise<[Decimal, Decimal]>;
+    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: Address | StrategyWithAddress, tokenAAmount?: Decimal, tokenBAmount?: Decimal) => Promise<[Decimal, Decimal]>;
-    calculateAmountsOrca: ({ whirlpoolState, positionAddress, tokenAAmount, tokenBAmount, }: {
-        whirlpoolState: Whirlpool;
-        positionAddress: Address;
+    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]>;
@@ -652,14 +906,14 @@ export declare class Kamino {
     /**
      * @deprecated The method should not be used
      */
-    getDepositRatioFromTokenA: (strategy: Address | StrategyWithAddress, amountA: BN) => Promise<{
+    getDepositRatioFromTokenA: (strategy: PublicKey | StrategyWithAddress, amountA: BN) => Promise<{
         amountSlippageA: BN;
         amountSlippageB: BN;
     }>;
     /**
      * @deprecated The method should not be used
      */
-    getDepositRatioFromTokenB: (strategy: Address | StrategyWithAddress, amountB: BN) => Promise<{
+    getDepositRatioFromTokenB: (strategy: PublicKey | StrategyWithAddress, amountB: BN) => Promise<{
         amountSlippageA: BN;
         amountSlippageB: BN;
     }>;
@@ -667,29 +921,29 @@ export declare class Kamino {
      * Get the on-chain state of the terms&conditions signature for the owner
      * @param owner
      */
-    getUserTermsSignatureState(owner: Address): Promise<TermsSignature | null>;
+    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: TransactionSigner, signature: Uint8Array): Promise<IInstruction>;
+    getUserTermsSignatureIx(owner: PublicKey, signature: Uint8Array): Promise<TransactionInstruction>;
     private getDepositRatioFromAOrca;
     private getDepositRatioFromAMeteora;
     private getDepositRatioFromBMeteora;
     private getDepositRatioFromBOrca;
     private getDepositRatioFromARaydium;
     private getDepositRatioFromBRaydium;
-    getCollateralInfo: (address: Address) => Promise<CollateralInfo[]>;
-    getGlobalConfigState: (address: Address) => Promise<GlobalConfig | null>;
-    getWhirlpoolStrategy: (address: Address) => Promise<WhirlpoolStrategy | null>;
-    getWhirlpoolStrategies: (addresses: Address[]) => Promise<Array<WhirlpoolStrategy | null>>;
-    getStrategyVaultBalances: (strategy: Address | StrategyWithAddress) => Promise<{
+    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: TransactionSigner, strategy: Address, rebalanceType: Decimal, withdrawFeeBps?: Decimal, performanceFeeBps?: Decimal) => Promise<IInstruction[]>;
-    getUpdateRewardsIxs: (strategyOwner: TransactionSigner, strategy: Address | StrategyWithAddress) => Promise<[IInstruction, TransactionSigner][]>;
+    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
@@ -697,9 +951,8 @@ export declare class Kamino {
      * @param price
      * @return tickPubkey, (tickInstruction | undefined)
      */
-    initializeTickForOrcaPool: (payer: TransactionSigner, pool: Address | WhirlpoolWithAddress, price: Decimal) => Promise<InitPoolTickIfNeeded>;
-    initializeTickForMeteoraPool: (payer: TransactionSigner, pool: Address | LbPairWithAddress, price: Decimal) => Promise<InitPoolTickIfNeeded>;
-    getDexProgramId(strategyState: WhirlpoolStrategy): Address;
+    initializeTickForOrcaPool: (payer: PublicKey, pool: PublicKey | WhirlpoolWithAddress, price: Decimal) => Promise<InitPoolTickIfNeeded>;
+    initializeTickForMeteoraPool: (payer: PublicKey, pool: PublicKey | LbPairWithAddress, price: Decimal) => Promise<InitPoolTickIfNeeded>;
 }
 export default Kamino;
 //# sourceMappingURL=Kamino.d.ts.map