@glamsystems/glam-sdk 1.0.3 → 1.0.4

package/src/client/kamino/lending.d.ts

@@ -0,0 +1,84 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "../base";
+import { VaultClient } from "../vault";
+import { ParsedReserve, ParsedObligation, RefreshObligationAccounts, RefreshReserveAccounts, RefreshObligationFarmsForReserveArgs, RefreshObligationFarmsForReserveAccounts } from "./types";
+declare class TxBuilder extends BaseTxBuilder<KaminoLendingClient> {
+    refreshObligationIx(accounts: RefreshObligationAccounts): TransactionInstruction;
+    refreshReserveIx(accounts: RefreshReserveAccounts): TransactionInstruction;
+    refreshObligationFarmsForReserveIx(args: RefreshObligationFarmsForReserveArgs, accounts: RefreshObligationFarmsForReserveAccounts): TransactionInstruction;
+    refreshReservesBatchIx(reserves: ParsedReserve[], skipPriceUpdates: boolean): TransactionInstruction;
+    refreshReservesIxs(lendingMarket: PublicKey, reserves: ParsedReserve[]): TransactionInstruction[];
+    refreshObligationCollateralFarmsForReservesIxs(obligation: PublicKey, lendingMarket: PublicKey, parsedReserves: ParsedReserve[]): TransactionInstruction[];
+    refreshObligationDebtFarmsForReservesIxs(obligation: PublicKey, lendingMarket: PublicKey, parsedReserves: ParsedReserve[]): TransactionInstruction[];
+    /**
+     * Returns two instructions that refresh reserves in batch and refresh obligation
+     */
+    refreshReservesAndObligationIxs(obligation: PublicKey, targetReserve: ParsedReserve): Promise<TransactionInstruction[]>;
+    /**
+     * Returns an instruction to initialize obligation farm user if it doesn't exist
+     *
+     * @param mode 0 collateral farm, 1 debt farm
+     */
+    initObligationFarmUserForReserveIx(obligation: PublicKey, { address, market, farmCollateral, farmDebt }: ParsedReserve, mode: 0 | 1, signer?: PublicKey): Promise<{
+        farmUser: PublicKey;
+        initIx: TransactionInstruction;
+    }>;
+    initUserMetadataTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositIxs(market: PublicKey, asset: PublicKey, amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    depositTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawIxs(market: PublicKey, asset: PublicKey, amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    withdrawTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    borrowIxs(market: PublicKey, asset: PublicKey, amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    borrowTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    repayIxs(market: PublicKey, asset: PublicKey, amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    repayTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class KaminoLendingClient {
+    readonly base: BaseClient;
+    readonly vault: VaultClient;
+    private reserves;
+    private obligations;
+    txBuilder: TxBuilder;
+    constructor(base: BaseClient, vault: VaultClient);
+    /**
+     * Initializes Kamino user metadata
+     */
+    initUserMetadata(txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Deposits asset to the lending market.
+     */
+    deposit(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Withdraws asset from the lending market.
+     */
+    withdraw(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Borrows asset from the lending market.
+     */
+    borrow(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Repays asset to the lending market.
+     */
+    repay(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    getUserMetadataPda(owner: PublicKey): PublicKey;
+    getObligationPda(owner: PublicKey, market: PublicKey, args?: {
+        tag: number;
+        id: number;
+    }): PublicKey;
+    getFarmUserState(farmUser: PublicKey, farm: PublicKey): PublicKey;
+    getMarketAuthority(market: PublicKey): PublicKey;
+    reservePdas(market: PublicKey, mint: PublicKey): {
+        liquiditySupplyVault: PublicKey;
+        collateralMint: PublicKey;
+        collateralSupplyVault: PublicKey;
+        feeVault: PublicKey;
+    };
+    parseObligation(obligation: PublicKey, data: Buffer): ParsedObligation;
+    fetchAndParseObligation(obligation: PublicKey): Promise<ParsedObligation>;
+    parseReserve(pubkey: PublicKey, data: Buffer): ParsedReserve;
+    fetchAndParseReserves(reserves: PublicKey[]): Promise<ParsedReserve[]>;
+    findAndParseReserve(market: PublicKey, asset: PublicKey): Promise<ParsedReserve>;
+    findAndParseObligations(owner: PublicKey, market?: PublicKey): Promise<ParsedObligation[]>;
+}
+export {};

package/src/client/kamino/types.d.ts

@@ -0,0 +1,88 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import Decimal from "decimal.js";
+import { BigFractionBytes } from "../../utils";
+export declare const DEFAULT_OBLIGATION_ARGS: {
+    tag: number;
+    id: number;
+};
+export declare const EVENT_AUTHORITY: PublicKey;
+export interface RefreshObligationAccounts {
+    lendingMarket: PublicKey;
+    obligation: PublicKey;
+    reserves: PublicKey[];
+}
+export interface RefreshReserveAccounts {
+    reserve: PublicKey;
+    lendingMarket: PublicKey;
+    pythOracle: PublicKey;
+    switchboardPriceOracle: PublicKey;
+    switchboardTwapOracle: PublicKey;
+    scopePrices: PublicKey;
+}
+export interface RefreshObligationFarmsForReserveArgs {
+    mode: number;
+}
+export interface RefreshObligationFarmsForReserveAccounts {
+    crank: PublicKey;
+    baseAccounts: {
+        obligation: PublicKey;
+        lendingMarketAuthority: PublicKey;
+        reserve: PublicKey;
+        reserveFarmState: PublicKey;
+        obligationFarmUserState: PublicKey;
+        lendingMarket: PublicKey;
+    };
+    farmsProgram: PublicKey;
+    rent: PublicKey;
+    systemProgram: PublicKey;
+}
+export interface ParsedReserve {
+    address: PublicKey;
+    market: PublicKey;
+    farmCollateral: PublicKey | null;
+    farmDebt: PublicKey | null;
+    liquidityMint: PublicKey;
+    liquidityMintDecimals: number;
+    liquiditySupplyVault: PublicKey;
+    collateralMint: PublicKey;
+    collateralSupplyVault: PublicKey;
+    scopePriceFeed: PublicKey;
+    feeVault: PublicKey;
+    collateralExchangeRate: Decimal;
+    cumulativeBorrowRate: Decimal;
+}
+export interface ParsedObligation {
+    address: PublicKey;
+    lendingMarket: PublicKey;
+    deposits: {
+        reserve: PublicKey;
+        depositedAmount: BN;
+        marketValueSf: BN;
+    }[];
+    borrows: {
+        reserve: PublicKey;
+        borrowedAmountSf: BN;
+        marketValueSf: BN;
+        cumulativeBorrowRateBsf: BigFractionBytes;
+    }[];
+}
+export interface ParsedFarmState {
+    globalConfig: PublicKey;
+    farmTokenMint: PublicKey;
+    farmTokenDecimals: BN;
+    farmTokenProgram: PublicKey;
+    farmVault: PublicKey;
+    rewards: {
+        index: number;
+        mint: PublicKey;
+        minClaimDurationSeconds: BN;
+        tokenProgram: PublicKey;
+        rewardsVault: PublicKey;
+    }[];
+}
+export interface ParsedFarmUser {
+    pubkey: PublicKey;
+    farmState: PublicKey;
+    unclaimedRewards: BN[];
+}

package/src/client/kamino/vaults.d.ts

@@ -0,0 +1,30 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature, AccountMeta } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "../base";
+import { KVaultAllocation, KVaultState } from "../../deser/kaminoLayouts";
+import { KaminoLendingClient } from "./lending";
+declare class TxBuilder extends BaseTxBuilder<KaminoVaultsClient> {
+    depositTx(vault: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawTx(vault: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class KaminoVaultsClient {
+    readonly base: BaseClient;
+    readonly kaminoLending: KaminoLendingClient;
+    private vaultStates;
+    private shareMintToVaultPdaMap;
+    txBuilder: TxBuilder;
+    constructor(base: BaseClient, kaminoLending: KaminoLendingClient);
+    /**
+     * Deposit to a Kamino vault
+     */
+    deposit(vault: PublicKey, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Withdraw from a Kamino vault
+     */
+    withdraw(vault: PublicKey, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    findAndParseKaminoVaults(): Promise<KVaultState[]>;
+    getVaultPdasByShareMints(mints: PublicKey[]): Promise<PublicKey[]>;
+    fetchAndParseVaultState(vault: PublicKey): Promise<KVaultState>;
+    composeRemainingAccounts(allocationStrategies: KVaultAllocation[], pricingMode?: boolean): Promise<AccountMeta[]>;
+}
+export {};

package/src/client/marinade.d.ts

@@ -1,8 +1,9 @@
 import { BN } from "@coral-xyz/anchor";
 import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction, Keypair } from "@solana/web3.js";
 import { MarinadeState } from "@marinade.finance/marinade-ts-sdk";
-import { BaseClient, TxOptions } from "./base";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
 import { StakeAccountInfo } from "../utils/accounts";
+import { StakeClient } from "./stake";
 export type Ticket = {
     address: PublicKey;
     lamports: number;
@@ -10,36 +11,32 @@ export type Ticket = {
     isDue: boolean;
     isClaimable: boolean;
 };
+declare class TxBuilder extends BaseTxBuilder<MarinadeClient> {
+    depositIxs(amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    depositTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    depositNativeIxs(amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    depositNativeTx(amount: BN, txOptions: TxOptions): Promise<any>;
+    depositStakeAccountIx(stakeAccount: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    depositStakeAccountTx(stakeAccount: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
+    withdrawStakeAccountIxs(amount: BN, deactivate: boolean, glamSigner: PublicKey): Promise<[TransactionInstruction[], Keypair]>;
+    withdrawStakeAccountTx(amount: BN, deactivate: boolean, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
+}
 export declare class MarinadeClient {
     readonly base: BaseClient;
-    constructor(base: BaseClient);
+    readonly stake: StakeClient;
+    private marinadeState;
+    txBuilder: TxBuilder;
+    constructor(base: BaseClient, stake: StakeClient);
     deposit(amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
     depositNative(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositStakeAccount(stakeAccount: PublicKey): Promise<TransactionSignature>;
+    depositStakeAccount(stakeAccount: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
     withdrawStakeAccount(amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * @deprecated Use Marinade.getMarinadeState() instead
-     */
-    get marinadeStateStatic(): {
-        marinadeStateAddress: PublicKey;
-        msolMintAddress: PublicKey;
-        treasuryMsolAccount: PublicKey;
-        reserveAddress: PublicKey;
-        mSolMintAuthority: PublicKey;
-        msolLeg: PublicKey;
-        msolLegAuthority: PublicKey;
-        solLeg: PublicKey;
-    };
     fetchMarinadeState(): Promise<MarinadeState>;
     getParsedStakeAccountInfo(stakeAccount: PublicKey): Promise<any>;
-    depositTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    createStakeAccount(signer: PublicKey): Promise<[PublicKey, TransactionInstruction]>;
-    depositNativeTx(amount: BN, txOptions: TxOptions): Promise<any>;
-    depositStakeAccountTx(stakeAccount: PublicKey, txOptions: TxOptions): Promise<any>;
     parseAccountList(data: Buffer, itemSize: number): any[];
     getIndexes(stakeAccount: StakeAccountInfo, stakeList: any, validatorList: any): Promise<{
         stakeIndex: number;
         validatorIndex: number;
     }>;
-    withdrawStakeAccountTx(amount: BN, deactivate: boolean, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
 }
+export {};

package/src/client/mint.d.ts

@@ -1,8 +1,7 @@
-import * as anchor from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TokenAccount, TxOptions } from "./base";
-import { MintIdlModel, StateAccountType } from "../models";
 import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TokenAccount, TxOptions } from "./base";
+import { MintIdlModel, RequestType, StateAccountType } from "../models";
 import { UpdateStateParams } from "./state";
 export type InitMintParams = {
     accountType: StateAccountType;
@@ -22,65 +21,31 @@ export type UpdateMintParams = {
     allowlist?: PublicKey[];
     blocklist?: PublicKey[];
 };
-declare class MintTxBuilder extends BaseTxBuilder {
-    /**
-     * Creates a glam mint token account
-     *
-     * @param owner Owner of the token account
-     * @param setFrozen If true, the token account will be frozen immediately
-     * @param txOptions
-     */
-    createTokenAccount(owner: PublicKey, setFrozen?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Freezes or unfreezes token accounts
-     *
-     * @param tokenAccounts List of token accounts to freeze or unfreeze
-     * @param frozen If true, the token accounts will be frozen; otherwise, they will be unfrozen
-     * @param txOptions
-     */
-    setTokenAccountsStates(tokenAccounts: PublicKey[], frozen: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Mints tokens to recipient. Token account will be created if it does not exist.
-     *
-     * @param recipient Recipient public key
-     * @param amount Amount of tokens to mint
-     * @param forceThaw If true, automatically unfreeze the token account before minting
-     * @param txOptions
-     */
-    mint(recipient: PublicKey, amount: anchor.BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Burns tokens from a token account
-     *
-     * @param from Owner of the token account
-     * @param amount Amount of tokens to burn
-     * @param forceThaw If true, automatically unfree the token account before burning
-     * @param txOptions
-     */
-    burn(from: PublicKey, amount: BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Transfers tokens from one token account to another
-     *
-     * @param from Owner of the sender token account
-     * @param to Owner of the recipient token account
-     * @param amount Amount of tokens to transfer
-     * @param forceThaw If true, automatically unfree the token accounts before transfer
-     * @param txOptions
-     */
-    forceTransfer(from: PublicKey, to: PublicKey, amount: BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-declare class TxBuilder extends BaseTxBuilder {
-    initialize(initMintParams: InitMintParams, stateParams: UpdateStateParams | null, txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
-    update(mintModel: Partial<MintIdlModel>, txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
-    pauseSubscription(txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
-    unpauseSubscription(txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
-    pauseRedemption(txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
-    unpauseRedemption(txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
-    closeMintIx(signer?: PublicKey): Promise<anchor.web3.TransactionInstruction>;
-    closeMint(txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
+declare class TxBuilder extends BaseTxBuilder<MintClient> {
+    setTokenAccountsStatesIx(tokenAccounts: PublicKey[], frozen: boolean, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    setTokenAccountsStatesTx(tokenAccounts: PublicKey[], frozen: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    createTokenAccountIxs(owner: PublicKey, setFrozen: boolean, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    createTokenAccountTx(owner: PublicKey, setFrozen?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    mintIxs(recipient: PublicKey, amount: BN, forceThaw: boolean, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    mintTx(recipient: PublicKey, amount: BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    burnIxs(from: PublicKey, amount: BN, forceThaw: boolean, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    burnTx(from: PublicKey, amount: BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    forceTransferIxs(from: PublicKey, to: PublicKey, amount: BN, forceThaw: boolean, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    forceTransferTx(from: PublicKey, to: PublicKey, amount: BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    initializeIxs(initMintParams: InitMintParams, stateParams: UpdateStateParams | null, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey]>;
+    initializeTx(initMintParams: InitMintParams, stateParams: UpdateStateParams | null, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
+    updateIx(mintModel: Partial<MintIdlModel>, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    updateTx(mintModel: Partial<MintIdlModel>, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    emergencyUpdateIx(requestType: RequestType, setPaused: boolean, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    pauseSubscriptionTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    unpauseSubscriptionTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    pauseRedemptionTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    unpauseRedemptionTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    closeMintIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    closeMintTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export declare class MintClient {
     readonly base: BaseClient;
-    readonly mintTxBuilder: MintTxBuilder;
     readonly txBuilder: TxBuilder;
     constructor(base: BaseClient);
     /**

package/src/client/price.d.ts

@@ -3,7 +3,7 @@ import { BN } from "@coral-xyz/anchor";
 import { KaminoLendingClient, KaminoVaultsClient, ParsedReserve } from "./kamino";
 import { BaseClient } from "./base";
 import { StateModel } from "../models";
-import { DriftClient, DriftVaultsClient, SpotMarket } from "./drift";
+import { DriftProtocolClient, DriftVaultsClient, SpotMarket } from "./drift";
 import { PkMap, PkSet } from "../utils";
 import { CctpClient } from "./cctp";
 import { TokenListItem } from "./jupiter";
@@ -34,32 +34,17 @@ export declare class PriceClient {
     readonly base: BaseClient;
     readonly klend: KaminoLendingClient;
     readonly kvaults: KaminoVaultsClient;
-    readonly drift: DriftClient;
+    readonly drift: DriftProtocolClient;
     readonly dvaults: DriftVaultsClient;
     readonly cctp: CctpClient;
     private _stateModel;
     private _lookupTables;
     private _kaminoVaults;
-    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, drift: DriftClient, dvaults: DriftVaultsClient, cctp: CctpClient);
+    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, drift: DriftProtocolClient, dvaults: DriftVaultsClient, cctp: CctpClient);
     get cachedStateModel(): StateModel | null;
     set cachedStateModel(stateModel: StateModel);
     get lookupTables(): PublicKey[];
     get kaminoVaults(): PublicKey[];
-    /**
-     * @deprecated
-     *
-     * Calculates the Assets Under Management (AUM) based on cached pricing data.
-     *
-     * @warning This is a convenience method for testing purposes only and should NOT be used in production.
-     * @warning The returned value may be inaccurate if:
-     *   - The vault has not been priced recently
-     *   - Pricing data is stale or outdated
-     *   - Not all assets have been included in the pricing calculation
-     *
-     * @returns The total AUM in the base asset denomination as a BN
-     * @see priceVaultIxs() to update pricing data before calling this method
-     */
-    getAum(): Promise<BN>;
     /**
      * Fetches all holdings in the vault.
      *
@@ -70,6 +55,8 @@ export declare class PriceClient {
     getVaultHoldings(commitment: Commitment, priceBaseAssetMint?: PublicKey): Promise<VaultHoldings>;
     getPubkeysForTokenHoldings(commitment?: Commitment): Promise<PublicKey[]>;
     getPubkeysForSpotHoldings(commitment?: Commitment): Promise<PkMap<PkSet>>;
+    getPubkeysForDriftVaultsHoldings(commitment?: Commitment): Promise<PkMap<PkSet>>;
+    getPubkeysForKaminoVaultsHoldings(commitment?: Commitment): Promise<PkMap<PkSet>>;
     getPubkeysForKaminoHoldings(commitment?: Commitment): Promise<PkMap<PkSet>>;
     getTokenHoldings(tokenAccountPubkeys: PublicKey[], accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Holding[];
     getDriftSpotHoldings(userPubkeys: Iterable<PublicKey>, spotMarketsMap: PkMap<SpotMarket>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Holding[];
@@ -98,10 +85,6 @@ export declare class PriceClient {
      * If there are no stake accounts, returns null.
      */
     priceStakeAccountsIx(): Promise<TransactionInstruction | null>;
-    /**
-     * Returns an instruction that prices Meteora positions.
-     * If there are no Meteora positions, returns null.
-     */
     priceVaultIxs(): Promise<TransactionInstruction[]>;
     validateAumIx(): Promise<TransactionInstruction>;
     getbaseAssetOracle(): Promise<PublicKey>;

package/src/client/stake-pool.d.ts

@@ -0,0 +1,39 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+import { MarinadeClient } from "./marinade";
+import { StakeClient } from "./stake";
+interface StakePoolAccountData {
+    programId: PublicKey;
+    depositAuthority: PublicKey;
+    withdrawAuthority: PublicKey;
+    poolMint: PublicKey;
+    feeAccount: PublicKey;
+    reserveStake: PublicKey;
+    tokenProgramId: PublicKey;
+    validatorList: PublicKey;
+}
+declare class TxBuilder extends BaseTxBuilder<StakePoolClient> {
+    depositSolIxs(stakePool: PublicKey, lamports: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    depositSolTx(stakePool: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositStakeIxs(stakePool: PublicKey, stakeAccount: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    depositStakeTx(stakePool: PublicKey, stakeAccount: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawStakeIxs(stakePool: PublicKey, amount: BN, deactivate: boolean, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey]>;
+    withdrawStakeTx(stakePool: PublicKey, amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
+}
+export declare class StakePoolClient {
+    readonly base: BaseClient;
+    readonly stake: StakeClient;
+    readonly marinade: MarinadeClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient, stake: StakeClient, marinade: MarinadeClient);
+    unstake(asset: PublicKey, amount: number | BN, deactivate?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    depositSol(stakePool: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    depositStake(stakePool: PublicKey, stakeAccount: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdrawStake(stakePool: PublicKey, amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    getStakePoolWithdrawAuthority(programId: PublicKey, stakePool: PublicKey): PublicKey;
+    getStakePoolDepositAuthority(programId: PublicKey, stakePool: PublicKey): PublicKey;
+    getStakeAccountVoter(stakeAccount: PublicKey): Promise<PublicKey | null>;
+    getStakePoolAccountData(stakePool: PublicKey): Promise<StakePoolAccountData>;
+}
+export {};

package/src/client/stake.d.ts

@@ -0,0 +1,34 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+declare class TxBuilder extends BaseTxBuilder<StakeClient> {
+    initializeAndDelegateStakeIxs(vote: PublicKey, amount: BN, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey]>;
+    initializeAndDelegateStakeTx(vote: PublicKey, amount: BN, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
+    deactivateStakesIx(stakeAccounts: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
+    deactivateStakesTx(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawStakesIx(stakeAccounts: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
+    withdrawStakesTx(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+    mergeStakeIx(destinationStake: PublicKey, sourceStake: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    mergeStakeTx(destinationStake: PublicKey, sourceStake: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    splitStakeIxs(existingStake: PublicKey, lamports: BN, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey]>;
+    splitStakeTx(existingStake: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
+    moveStakeIx(sourceStake: PublicKey, destinationStake: PublicKey, amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    moveStakeTx(sourceStake: PublicKey, destinationStake: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class StakeClient {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient);
+    initializeAndDelegateStake(vote: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    deactivate(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
+    merge(destinationStake: PublicKey, sourceStake: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    split(existingStake: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<{
+        newStake: PublicKey;
+        txSig: TransactionSignature;
+    }>;
+    move(sourceStake: PublicKey, destinationStake: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    getStakeAccountVoter(stakeAccount: PublicKey): Promise<PublicKey | null>;
+    createStakeAccount(signer: PublicKey): Promise<[PublicKey, TransactionInstruction]>;
+}
+export {};

package/src/client/state.d.ts

@@ -17,13 +17,15 @@ export type UpdateStateParams = {
     assets?: PublicKey[];
     borrowable?: PublicKey[];
 };
-declare class TxBuilder extends BaseTxBuilder {
-    initialize(params: InitStateParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    update(params: UpdateStateParams, txOptions: TxOptions): Promise<VersionedTransaction>;
-    updateIx(params: UpdateStateParams, signer?: PublicKey): Promise<TransactionInstruction>;
-    updateApplyTimelock(txOptions: TxOptions): Promise<VersionedTransaction>;
-    extend(newBytes: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    close(txOptions?: TxOptions): Promise<VersionedTransaction>;
+declare class TxBuilder extends BaseTxBuilder<StateClient> {
+    initializeIx(params: InitStateParams, glamSigner: PublicKey): Promise<[TransactionInstruction, PublicKey]>;
+    initializeTx(params: InitStateParams, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
+    updateIx(params: UpdateStateParams, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    updateTx(params: UpdateStateParams, txOptions: TxOptions): Promise<VersionedTransaction>;
+    extendIx(newBytes: number, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    extendTx(newBytes: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    closeIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
+    closeTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export declare class StateClient {
     readonly base: BaseClient;
@@ -42,10 +44,6 @@ export declare class StateClient {
      * Only the fields provided in `params` will be updated; omitted fields remain unchanged.
      */
     update(params: UpdateStateParams, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Applies timelock updates to GLAM state
-     */
-    updateApplyTimelock(txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Extends GLAM state account size
      */

package/src/client/timelock.d.ts

@@ -1,21 +1,13 @@
-import { VersionedTransaction, TransactionSignature } from "@solana/web3.js";
-import { BaseClient, TxOptions } from "./base";
+import { VersionedTransaction, TransactionSignature, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
 import { StateClient } from "./state";
-declare class TxBuilder {
-    private base;
-    constructor(base: BaseClient);
-    /**
-     * Builds transaction to apply pending state updates after timelock expires
-     */
-    applyStateTimelock(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Builds transaction to apply pending mint updates after timelock expires
-     */
-    applyMintTimelock(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Builds transaction to cancel pending timelock updates
-     */
-    cancelTimelock(txOptions?: TxOptions): Promise<VersionedTransaction>;
+declare class TxBuilder extends BaseTxBuilder<TimelockClient> {
+    applyStateTimelockIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
+    applyStateTimelockTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    applyMintTimelockIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
+    applyMintTimelockTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    cancelTimelockIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
+    cancelTimelockTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export declare class TimelockClient {
     readonly base: BaseClient;

package/src/client/vault.d.ts

@@ -1,8 +1,31 @@
 import { BN } from "@coral-xyz/anchor";
 import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, TxOptions } from "./base";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+declare class TxBuilder extends BaseTxBuilder<VaultClient> {
+    wrapIxs(amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    wrapTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    unwrapIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
+    unwrapTx(txOptions: TxOptions): Promise<VersionedTransaction>;
+    systemTransferIx(amount: BN, to: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    systemTransferTx(amount: BN, to: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
+    /**
+     * Returns an instruction that closes the specified vault token account
+     */
+    closeTokenAccountIx(tokenAccount: PublicKey, tokenProgram: PublicKey, signer?: PublicKey): Promise<TransactionInstruction>;
+    closeTokenAccountsTx(pubkeys: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
+    depositSolIxs(lamports: number | BN, wrap: boolean, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    depositSolTx(lamports: number | BN, wrap?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositIxs(asset: PublicKey, amount: number | BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    depositTx(asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    /**
+     * Transfers tokens held by the vault to the specified recipient
+     */
+    tokenTransferIxs(mint: PublicKey, amount: number | BN, to: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    tokenTransferTx(mint: PublicKey, amount: number | BN, to: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
+}
 export declare class VaultClient {
     readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
     constructor(base: BaseClient);
     /**
      * Wraps vault SOL to wSOL
@@ -60,19 +83,8 @@ export declare class VaultClient {
      * Generates instructions to wrap SOL into wSOL if the vault doesn't have enough wSOL
      *
      * @param lamports Desired amount of wSOL
-     * @returns Array of instructions, null if no instructions are needed
+     * @returns Array of instructions, empty if wSOL is sufficient
      */
     maybeWrapSol(lamports: number | BN, signer?: PublicKey): Promise<TransactionInstruction[]>;
-    wrapTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    unwrapTx(txOptions: TxOptions): Promise<VersionedTransaction>;
-    systemTransferTx(amount: BN, to: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Returns an instruction that closes the specified vault token account
-     */
-    closeTokenAccountIx(tokenAccount: PublicKey, tokenProgram?: PublicKey, txOptions?: TxOptions): Promise<TransactionInstruction>;
-    closeTokenAccountsTx(pubkeys: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
-    depositSolTx(lamports: number | BN, wrap?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    depositTx(asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    tokenTransferIxs(mint: PublicKey, amount: number | BN, to: PublicKey, txOptions?: TxOptions): Promise<TransactionInstruction[]>;
-    tokenTransferTx(mint: PublicKey, amount: number | BN, to: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
 }
+export {};