@glamsystems/glam-sdk 1.1.0-alpha.1 → 1.1.0-alpha.2

package/src/client/marinade.d.ts

@@ -1,42 +0,0 @@
-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, BaseTxBuilder, TxOptions } from "./base";
-import { StakeAccountInfo } from "../utils/accounts";
-import { StakeClient } from "./stake";
-export type Ticket = {
-    address: PublicKey;
-    lamports: number;
-    createdEpoch: number;
-    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 | undefined, glamSigner: PublicKey): Promise<[TransactionInstruction[], Keypair]>;
-    withdrawStakeAccountTx(amount: BN, deactivate: boolean | undefined, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
-}
-export declare class MarinadeClient {
-    readonly 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, txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdrawStakeAccount(amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    fetchMarinadeState(): Promise<MarinadeState>;
-    getParsedStakeAccountInfo(stakeAccount: PublicKey): Promise<any>;
-    parseAccountList(data: Buffer, itemSize: number): PublicKey[];
-    getIndexes(stakeAccount: StakeAccountInfo, stakeList: any, validatorList: any): Promise<{
-        stakeIndex: number;
-        validatorIndex: number;
-    }>;
-}
-export {};

package/src/client/mint.d.ts

@@ -1,127 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { Connection, PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TokenAccount, TxOptions } from "./base";
-import { PriceClient } from "./price";
-import { MintIdlModel, RequestType, StateAccountType } from "../models";
-import { UpdateStateParams } from "./state";
-export type InitMintParams = {
-    accountType: StateAccountType;
-    name: number[];
-    symbol: string;
-    uri: string;
-    baseAssetMint: PublicKey;
-    decimals?: number;
-} & Partial<MintIdlModel>;
-export type UpdateMintParams = {
-    permanentDelegate?: PublicKey;
-    defaultAccountStateFrozen?: boolean;
-    lockupPeriod?: number;
-    maxCap?: BN;
-    minSubscription?: BN;
-    minRedemption?: BN;
-    allowlist?: PublicKey[];
-    blocklist?: PublicKey[];
-};
-/**
- * Resolves the list config + wallet entry pairs needed for permissionless thaw.
- * Returns empty array if Token ACL is not enabled or no matching pairs found.
- */
-export declare function resolveThawAccounts(connection: Connection, mintPda: PublicKey, wallet: PublicKey): Promise<{
-    listConfig: PublicKey;
-    walletEntry: PublicKey;
-}[]>;
-/**
- * Builds a permissionless thaw instruction for the Token ACL program.
- * Standalone version of TxBuilder.thawPermissionlessIx for use outside
- * the MintClient context (e.g., in invest.ts).
- */
-export declare function buildThawPermissionlessIx(mintPda: PublicKey, wallet: PublicKey, listAndWalletPairs: {
-    listConfig: PublicKey;
-    walletEntry: PublicKey;
-}[], signer: PublicKey): TransactionInstruction;
-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 | undefined, 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]>;
-    crystallizeFeesIxs(glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    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>;
-    enableTokenAclIx(gatingProgram: PublicKey | undefined, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    enableTokenAclTx(gatingProgram: PublicKey | undefined, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    aclGateCreateListIx(seed: Buffer, mode: number, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    aclGateCreateListTx(seed: Buffer, mode: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    aclGateAddWalletIx(listConfig: PublicKey, wallet: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    aclGateAddWalletTx(listConfig: PublicKey, wallet: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    aclGateRemoveWalletIx(listConfig: PublicKey, walletEntry: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    aclGateRemoveWalletTx(listConfig: PublicKey, walletEntry: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    aclGateDeleteListIx(listConfig: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    aclGateDeleteListTx(listConfig: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    aclGateSetupExtraMetasIx(listConfigs: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
-    aclGateSetupExtraMetasTx(listConfigs: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-    tokenAclFreezeIx(tokenAccounts: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
-    tokenAclFreezeTx(tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-    tokenAclThawIx(tokenAccounts: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
-    tokenAclThawTx(tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-    thawPermissionlessIx(wallet: PublicKey, listAndWalletPairs: {
-        listConfig: PublicKey;
-        walletEntry: PublicKey;
-    }[], signer: PublicKey): TransactionInstruction;
-    thawPermissionlessTx(wallet: PublicKey, listAndWalletPairs: {
-        listConfig: PublicKey;
-        walletEntry: PublicKey;
-    }[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class MintClient {
-    readonly base: BaseClient;
-    private readonly getPrice?;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient, getPrice?: (() => PriceClient) | undefined);
-    get price(): PriceClient;
-    /**
-     * Fetches token holders of the GLAM mint using helius RPC
-     */
-    fetchTokenHolders(showZeroBalance?: boolean): Promise<TokenAccount[]>;
-    getHolders(showZeroBalance?: boolean): Promise<TokenAccount[]>;
-    initialize(initMintParams: InitMintParams, txOptions?: TxOptions): Promise<string>;
-    initializeWithStateParams(initMintParams: InitMintParams, stateParams: UpdateStateParams, txOptions?: TxOptions): Promise<string>;
-    update(mintModel: Partial<MintIdlModel>, txOptions?: TxOptions): Promise<string>;
-    pauseSubscription(txOptions?: TxOptions): Promise<string>;
-    unpauseSubscription(txOptions?: TxOptions): Promise<string>;
-    pauseRedemption(txOptions?: TxOptions): Promise<string>;
-    unpauseRedemption(txOptions?: TxOptions): Promise<string>;
-    close(txOptions?: TxOptions): Promise<string>;
-    mint(to: PublicKey, amount: BN | number, unfreeze?: boolean, txOptions?: TxOptions): Promise<string>;
-    burn(from: PublicKey, amount: BN | number, unfreeze?: boolean, txOptions?: TxOptions): Promise<string>;
-    createTokenAccount(owner: PublicKey, setFrozen: boolean, txOptions?: TxOptions): Promise<string>;
-    setTokenAccountsStates(tokenAccounts: PublicKey[], frozen: boolean, txOptions?: TxOptions): Promise<string>;
-    enableTokenAcl(gatingProgram?: PublicKey, txOptions?: TxOptions): Promise<string>;
-    forceTransfer(from: PublicKey, to: PublicKey, amount: BN | number, unfreeze?: boolean, txOptions?: TxOptions): Promise<string>;
-    tokenAclFreeze(tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<string>;
-    tokenAclThaw(tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<string>;
-    aclGateCreateList(seed: Buffer, mode?: number, txOptions?: TxOptions): Promise<string>;
-    aclGateAddWallet(listConfig: PublicKey, wallet: PublicKey, txOptions?: TxOptions): Promise<string>;
-    aclGateRemoveWallet(listConfig: PublicKey, walletEntry: PublicKey, txOptions?: TxOptions): Promise<string>;
-    aclGateDeleteList(listConfig: PublicKey, txOptions?: TxOptions): Promise<string>;
-    aclGateSetupExtraMetas(listConfigs: PublicKey[], txOptions?: TxOptions): Promise<string>;
-    thawPermissionless(wallet: PublicKey, listAndWalletPairs: {
-        listConfig: PublicKey;
-        walletEntry: PublicKey;
-    }[], txOptions?: TxOptions): Promise<string>;
-}
-export {};

package/src/client/neutral.d.ts

@@ -1,109 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { NeutralPolicy } from "../deser/integrationPolicies";
-import { NTBUNDLE_PROGRAM_ID } from "../constants";
-export { NTBUNDLE_PROGRAM_ID };
-export declare const NEUTRAL_PROTOCOL = 1;
-export declare const NEUTRAL_BUNDLE_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export type InitializeBundleDepositorAccounts = {
-    bundle: PublicKey;
-    userBundleAccount?: PublicKey;
-};
-export type RequestDepositAccounts = {
-    bundle: PublicKey;
-    userTokenAccount?: PublicKey;
-    pendingDepositTokenAccount?: PublicKey;
-    treasuryAccount?: PublicKey;
-    userBundleAccount?: PublicKey;
-    assetAddress?: PublicKey;
-    oracleData?: PublicKey;
-    bundleTempData?: PublicKey;
-    pendingBundleAssetAuthority?: PublicKey;
-    tokenProgram?: PublicKey;
-};
-export type NeutralBundleView = {
-    treasuryAccount: PublicKey;
-    assetAddress: PublicKey;
-    assetDecimals: number;
-    permissioned: boolean;
-};
-export declare class NeutralBundleAccount {
-    readonly _address: PublicKey;
-    discriminator: number[];
-    name: number[];
-    manager: PublicKey;
-    keeper: PublicKey;
-    treasuryAccount: PublicKey;
-    allocatedReceivers: PublicKey[];
-    bundleUnderlyingBalance: BN;
-    maxDepositAmount: BN;
-    withdrawalDelay: BN;
-    performanceFee: number;
-    managementFeeBps: number;
-    depositFee: number;
-    withdrawalFee: number;
-    managerPfeeShares: BN;
-    currentAllocationBps: number;
-    oracleBuffer: BN;
-    totalShares: BN;
-    assetPrecision: BN;
-    assetAddress: PublicKey;
-    assetDecimals: number;
-    withdrawalTMin: BN;
-    withdrawalTMax: BN;
-    withdrawalCurve: number;
-    permissionned: boolean;
-    managerMfeeShares: BN;
-    minDepositAmount: BN;
-    oracleUpdateTimeLimit: BN;
-    oracleMaxAge: BN;
-    withdrawalRedemptionRequestCutoffTs: BN;
-    withdrawalRedemptionUnlockCurrentCycleTs: BN;
-    withdrawalRedemptionUnlockNextCycleTs: BN;
-    padding: number[];
-    static _layout: any;
-    static decode(address: PublicKey, buffer: Buffer): NeutralBundleAccount;
-    getAddress(): PublicKey;
-    get permissioned(): boolean;
-    toView(): NeutralBundleView;
-}
-export declare function getNeutralUserBundlePda(authority: PublicKey, bundle: PublicKey): PublicKey;
-export declare function getNeutralOracleDataPda(bundle: PublicKey): PublicKey;
-export declare function getNeutralBundleTempDataPda(bundle: PublicKey): PublicKey;
-export declare function getNeutralPendingBundleAssetAuthorityPda(bundle: PublicKey): PublicKey;
-export declare function getNeutralPendingDepositTokenAccountPda(pendingBundleAssetAuthority: PublicKey, assetAddress: PublicKey): PublicKey;
-declare class TxBuilder extends BaseTxBuilder<NeutralClient> {
-    setNeutralPolicyIx(policy: NeutralPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
-    setNeutralPolicyTx(policy: NeutralPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    initializeBundleDepositorIx(accounts: InitializeBundleDepositorAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    initializeBundleDepositorTx(accounts: InitializeBundleDepositorAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    requestDepositIx(accounts: RequestDepositAccounts, amount: BN | bigint | number | string, signer?: PublicKey): Promise<TransactionInstruction>;
-    requestDepositTx(accounts: RequestDepositAccounts, amount: BN | bigint | number | string, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class NeutralClient {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    baseAccounts(signer?: PublicKey): {
-        glamState: PublicKey;
-        glamVault: PublicKey;
-        glamSigner: PublicKey;
-        integrationAuthority: PublicKey;
-        cpiProgram: PublicKey;
-        glamProtocolProgram: PublicKey;
-        systemProgram: PublicKey;
-    };
-    getIntegrationAuthorityPda(): PublicKey;
-    getUserBundlePda(bundle: PublicKey): PublicKey;
-    getOracleDataPda(bundle: PublicKey): PublicKey;
-    getBundleTempDataPda(bundle: PublicKey): PublicKey;
-    getPendingBundleAssetAuthorityPda(bundle: PublicKey): PublicKey;
-    fetchBundle(bundle: PublicKey): Promise<NeutralBundleAccount>;
-    fetchPolicy(): Promise<NeutralPolicy | null>;
-    setPolicy(policy: NeutralPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    allowlistBundle(bundle: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    initializeBundleDepositor(bundle: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    requestDeposit(bundle: PublicKey, amount: BN | bigint | number | string, txOptions?: TxOptions): Promise<TransactionSignature>;
-    requestDepositUiAmount(bundle: PublicKey, amount: number | string, txOptions?: TxOptions): Promise<TransactionSignature>;
-}

package/src/client/price.d.ts

@@ -1,138 +0,0 @@
-import { AccountMeta, Commitment, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { BN } from "@coral-xyz/anchor";
-import { KaminoLendingClient, KaminoVaultsClient } from "./kamino";
-import { BaseClient } from "./base";
-import { StateModel } from "../models";
-import { PkMap, PkSet } from "../utils";
-import { KVaultState, Reserve } from "../deser";
-import { JupiterApiClient, TokenListItem } from "../utils/jupiterApi";
-import { BridgeClient } from "./bridge";
-import { EpiClient } from "./epi";
-/**
- * Represents a single asset holding within a vault.
- *
- * @param mintAddress - The SPL token mint address of the held asset
- * @param decimals - Number of decimal places for the token (e.g., 6 for USDC, 9 for SOL)
- * @param amount - Unsigned token amount in native units; direction (deposit/borrow) is in protocolMeta
- * @param price - Current price of the asset denominated in the base asset (e.g., USD, SOL)
- * @param priceMeta - Additional pricing context (e.g., source, slot, base asset). Default base asset, if not specified, is USD.
- * @param protocol - Protocol identifier where the asset is allocated
- * @param protocolMeta - Protocol-specific metadata (e.g., market index, position direction, reserve address)
- */
-export declare class Holding {
-    readonly mintAddress: PublicKey;
-    readonly decimals: number;
-    readonly amount: BN;
-    readonly price: number;
-    readonly priceMeta: Record<string, any>;
-    readonly protocol: string;
-    readonly protocolMeta: Record<string, any>;
-    readonly uiAmount: number;
-    constructor(mintAddress: PublicKey, decimals: number, amount: BN, price: number, priceMeta: Record<string, any> | undefined, protocol: string, protocolMeta?: Record<string, any>);
-}
-/**
- * Aggregates all holdings for a GLAM vault.
- * Includes token balances and supported DeFi positions.
- *
- * @param vaultState - The vault's state account address (stores vault configuration)
- * @param vaultPda - The vault's PDA that holds tokens and positions
- * @param priceBaseAssetMint - The base asset mint used for pricing (e.g., PublicKey.default for USD, So11111111111111111111111111111111111111112 for SOL)
- * @param slot - The Solana slot at which holdings were fetched
- * @param timestamp - Unix timestamp (seconds) when holdings were fetched
- * @param commitment - The Solana commitment level used for fetching account data
- */
-export declare class VaultHoldings {
-    readonly vaultState: PublicKey;
-    readonly vaultPda: PublicKey;
-    readonly priceBaseAssetMint: PublicKey;
-    readonly slot: number;
-    readonly timestamp: number;
-    readonly commitment: Commitment;
-    holdings: Holding[];
-    constructor(vaultState: PublicKey, vaultPda: PublicKey, priceBaseAssetMint: PublicKey, slot: number, timestamp: number, commitment: Commitment);
-    add(holding: Holding): void;
-    toJson(): string;
-}
-type PricingChunk = {
-    ixs: TransactionInstruction[];
-    kaminoReserves: PublicKey[];
-};
-export declare class PriceClient {
-    readonly base: BaseClient;
-    readonly klend: KaminoLendingClient;
-    readonly kvaults: KaminoVaultsClient;
-    readonly bridge: BridgeClient;
-    readonly epi: EpiClient;
-    private readonly getJupiterApi;
-    private _stateModel;
-    private _lookupTables;
-    private _kaminoVaults;
-    private _priceVaultIxsQueue;
-    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, bridge: BridgeClient, epi: EpiClient, getJupiterApi: () => JupiterApiClient);
-    get jupiterApi(): JupiterApiClient;
-    get cachedStateModel(): StateModel | null;
-    set cachedStateModel(stateModel: StateModel);
-    get lookupTables(): PublicKey[];
-    get kaminoVaults(): PublicKey[];
-    private getKaminoObligationReserveSets;
-    /**
-     * Fetches all holdings in the vault.
-     *
-     * The source of truth for external positions is the `externalPositions` array
-     * from the state account, which tracks:
-     * - Kamino obligation accounts (lending positions)
-     * - Kamino vault share ATAs (shares in kamino vaults)
-     *
-     * @param commitment Commitment level for fetching accounts
-     * @param priceBaseAssetMint Price reference/numeraire asset mint (default: PublicKey.default for USD).
-     *                           Pass a token mint (e.g., WSOL) to get prices denominated in that asset.
-     * @returns VaultHoldings object containing all holdings
-     */
-    getVaultHoldings(commitment: Commitment, priceBaseAssetMint?: PublicKey): Promise<VaultHoldings>;
-    getPubkeysForTokenHoldings(externalPositionsSet: PkSet, commitment?: Commitment): Promise<PublicKey[]>;
-    /**
-     * Gets kamino obligation reserves from known obligation pubkeys.
-     */
-    getPubkeysForKaminoHoldings(obligationPubkeys: PublicKey[], commitment?: Commitment): Promise<PkMap<PkSet>>;
-    /**
-     * Gets kamino vault states from known share ATA pubkeys.
-     * Used by getVaultHoldingsV2 to process vault shares from externalPositions.
-     */
-    getKaminoVaultStatesFromAtas(shareAtaPubkeys: PublicKey[], commitment?: Commitment): Promise<PkMap<KVaultState>>;
-    /**
-     * Fetches token price from the prefetched map, falling back to Jupiter API if not found.
-     * @throws Error if price cannot be fetched from either source
-     */
-    private getTokenPrice;
-    getTokenHoldings(tokenAccountPubkeys: PublicKey[], accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
-    getKaminoLendHoldings(obligationPubkeys: Iterable<PublicKey>, reservesMap: PkMap<Reserve>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
-    getKaminoVaultsHoldings(kvaultAtasAndStates: PkMap<KVaultState>, reservesMap: PkMap<Reserve>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
-    /**
-     * Returns an instruction that prices Kamino obligations.
-     * If there are no Kamino obligations, returns null.
-     */
-    priceKaminoObligationsIxs(): Promise<PricingChunk>;
-    priceKaminoVaultSharesIx(): Promise<PricingChunk | null>;
-    /**
-     * Returns an instruction that prices vault balance and tokens
-     */
-    priceVaultTokensIx(): Promise<PricingChunk>;
-    /**
-     * Returns an instruction that prices stake accounts.
-     * If there are no stake accounts, returns null.
-     */
-    priceStakeAccountsIx(): Promise<TransactionInstruction | null>;
-    priceVaultIxs(): Promise<TransactionInstruction[]>;
-    private enqueuePriceVaultIxs;
-    private priceManagedTransfersIxs;
-    private priceNeutralBundleDepositorsIx;
-    private priceEpiValidatedPositionsIx;
-    private _priceVaultIxsImpl;
-    validateAumIx(): Promise<TransactionInstruction>;
-    getBaseAssetOracle(): Promise<PublicKey>;
-    remainingAccountsForPricingVaultAssets(): Promise<[
-        AccountMeta[],
-        PublicKey[]
-    ]>;
-}
-export {};

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

@@ -1,39 +0,0 @@
-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 | undefined, 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

@@ -1,34 +0,0 @@
-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<any>;
-    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

@@ -1,56 +0,0 @@
-import { VersionedTransaction, TransactionSignature, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { StateIdlModel, StateAccountType } from "../models";
-export type InitStateParams = {
-    accountType: StateAccountType;
-    name: number[];
-    baseAssetMint: PublicKey;
-} & Partial<StateIdlModel>;
-/**
- * A subset of StateIdlModel fields that are updatable using updateState instruction
- */
-export type UpdateStateParams = {
-    name?: number[];
-    owner?: PublicKey;
-    portfolioManagerName?: number[];
-    timelockDuration?: number;
-    assets?: PublicKey[];
-    borrowable?: PublicKey[];
-};
-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;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    /**
-     * Creates a new GLAM state
-     */
-    initialize(params: InitStateParams, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Updates the GLAM state account.
-     *
-     * If no timelock , the updates will be applied immediately.
-     * If timelock is enabled, the updates will be staged and can be applied after the timelock period.
-     *
-     * Only the fields provided in `params` will be updated; omitted fields remain unchanged.
-     */
-    update(params: UpdateStateParams, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Extends GLAM state account size
-     */
-    extend(newBytes: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Closes GLAM state account
-     */
-    close(txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

package/src/client/timelock.d.ts

@@ -1,31 +0,0 @@
-import { VersionedTransaction, TransactionSignature, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { StateClient } from "./state";
-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;
-    readonly stateClient: StateClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient, stateClient: StateClient);
-    /**
-     * Sets the timelock duration in seconds
-     * @param durationSeconds Duration in seconds for timelock period
-     */
-    set(durationSeconds: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Applies pending timelock updates after timelock expires.
-     */
-    apply(txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Cancels pending timelock updates
-     */
-    cancel(txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};