@glamsystems/glam-sdk 1.0.14-alpha.4 → 1.0.14-alpha.6

package/src/client/invest.d.ts

@@ -1,37 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { PendingRequest } from "../models";
-declare class TxBuilder extends BaseTxBuilder<InvestClient> {
-    subscribeIxs(amount: BN, signer: PublicKey): Promise<TransactionInstruction[]>;
-    subscribeTx(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    queuedSubscribeIxs(amount: BN, signer: PublicKey): Promise<TransactionInstruction[]>;
-    queuedSubscribeTx(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    queuedRedeemIx(amount: BN, signer: PublicKey): Promise<TransactionInstruction>;
-    queuedRedeemTx(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelIx(pubkey: PublicKey | null, signer: PublicKey): Promise<TransactionInstruction>;
-    cancelTx(pubkey: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    fulfillIx(limit: number | null, signer: PublicKey): Promise<TransactionInstruction>;
-    fulfillTx(limit: number | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    claimIxs(user: PublicKey | null, signer: PublicKey): Promise<TransactionInstruction[]>;
-    claimTx(user: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class InvestClient {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    subscribe(amount: BN, queued?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    queuedRedeem(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancel(txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancelForUser(user: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    fulfill(limit: number | null, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Claims the pending request for the signer.
-     * @param txOptions
-     * @returns
-     */
-    claim(txOptions?: TxOptions): Promise<TransactionSignature>;
-    claimForUser(user: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    fetchPendingRequest(user?: PublicKey): Promise<PendingRequest | null>;
-}
-export {};

package/src/client/jupiter.d.ts

@@ -1,45 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { VaultClient } from "./vault";
-import { JupiterApiClient, JupiterInstruction, QuoteParams, QuoteResponse, SwapInstructions } from "../utils/jupiterApi";
-import { KaminoLendingClient } from "./kamino";
-export type JupiterSwapOptions = {
-    quoteParams?: QuoteParams;
-    quoteResponse?: QuoteResponse;
-    swapInstructions?: SwapInstructions;
-    trackingAccount?: PublicKey;
-};
-export type JupiterSwapV2OracleAccounts = {
-    solUsdOracle?: PublicKey;
-    inputTokenOracle?: PublicKey;
-    outputTokenOracle?: PublicKey;
-    kaminoReservesToRefresh: PublicKey[];
-};
-export type JupiterSwapV2Options = JupiterSwapOptions & {
-    skipQuotePriceCheck?: boolean;
-    oracleAccounts?: JupiterSwapV2OracleAccounts;
-};
-declare class TxBuilder extends BaseTxBuilder<JupiterSwapClient> {
-    private resolveSwapInstructionContext;
-    /**
-     * Returns the instructions for a Jupiter swap and the lookup tables
-     */
-    swapIxs(options: JupiterSwapOptions, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
-    swapV2Ixs(options: JupiterSwapV2Options, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
-    swapTx(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    swapV2Tx(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    getPreInstructions: (signer: PublicKey, inputMint: PublicKey, outputMint: PublicKey, amount: BN, outputTokenProgram?: PublicKey) => Promise<TransactionInstruction[]>;
-    toTransactionInstruction: (ix: JupiterInstruction) => TransactionInstruction;
-}
-export declare class JupiterSwapClient {
-    readonly base: BaseClient;
-    readonly vault: VaultClient;
-    readonly klend: KaminoLendingClient;
-    readonly txBuilder: TxBuilder;
-    readonly jupApi: JupiterApiClient;
-    constructor(base: BaseClient, vault: VaultClient, klend: KaminoLendingClient);
-    swap(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<TransactionSignature>;
-    swapV2(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

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

@@ -1,39 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "../base";
-import { PkMap } from "../../utils";
-import { KaminoLendingClient } from "./lending";
-import { ParsedFarmState, ParsedFarmUser } from "./types";
-declare class TxBuilder extends BaseTxBuilder<KaminoFarmClient> {
-    stakeTx(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    unstakeTx(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    harvestTx(farmUserStates: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class KaminoFarmClient {
-    readonly base: BaseClient;
-    readonly kaminoLending: KaminoLendingClient;
-    txBuilder: TxBuilder;
-    constructor(base: BaseClient, kaminoLending: KaminoLendingClient);
-    /**
-     * Finds and parses farm states for the given owner
-     */
-    findAndParseFarmUserStates(owner: PublicKey): Promise<ParsedFarmUser[]>;
-    parseFarmState(data: Buffer): Promise<ParsedFarmState>;
-    fetchAndParseFarmStates(farms: PublicKey[]): Promise<PkMap<ParsedFarmState>>;
-    farmVaultTokenAccount: (farm: PublicKey, mint: PublicKey) => PublicKey;
-    farmVaultsAuthority: (farm: PublicKey) => PublicKey;
-    rewardsTreasuryVault: (globalConfig: PublicKey, mint: PublicKey) => PublicKey;
-    /**
-     * Harvest rewards from Kamino farms
-     */
-    harvest(vaultFarmStates: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Stake tokens to a farm
-     */
-    stake(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Unstake tokens from a farm
-     */
-    unstake(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

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

@@ -1,4 +0,0 @@
-export * from "./types";
-export * from "./lending";
-export * from "./farm";
-export * from "./vaults";

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

@@ -1,86 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "../base";
-import { Reserve, Obligation } from "../../deser/kaminoLayouts";
-import { VaultClient } from "../vault";
-import { 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: Reserve[], skipPriceUpdates: boolean): TransactionInstruction;
-    refreshReservesIxs(reserves: Reserve[]): TransactionInstruction[];
-    refreshObligationCollateralFarmsForReservesIxs(obligation: PublicKey, reserves: Reserve[]): TransactionInstruction[];
-    refreshObligationDebtFarmsForReservesIxs(obligation: PublicKey, reserves: Reserve[]): TransactionInstruction[];
-    /**
-     * Returns two instructions that refresh reserves in batch and refresh obligation
-     */
-    refreshReservesAndObligationIxs(obligation: PublicKey, targetReserve: Reserve): 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, reserve: Reserve, mode: 0 | 1, signer?: PublicKey): Promise<{
-        farmUser: null;
-        initIx: null;
-    } | {
-        farmUser: PublicKey;
-        initIx: TransactionInstruction | null;
-    }>;
-    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>;
-    requestElevationGroupIxs(lendingMarket: PublicKey, elevationGroup: number, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    requestElevationGroupTx(lendingMarket: PublicKey, elevationGroup: number, 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>;
-    /**
-     * Requests an elevation group for an obligation.
-     */
-    requestElevationGroup(market: PublicKey | string, elevationGroup: 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;
-    fetchAndParseObligation(obligation: PublicKey): Promise<Obligation>;
-    fetchAndParseReserves(reserves: PublicKey[]): Promise<Reserve[]>;
-    findAndParseReserve(market: PublicKey, asset: PublicKey): Promise<Reserve>;
-    findAndParseObligations(owner: PublicKey, market?: PublicKey): Promise<Obligation[]>;
-}
-export {};

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

@@ -1,56 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-export declare const DEFAULT_OBLIGATION_ARGS: {
-    tag: number;
-    id: number;
-};
-export declare const KAMINO_VAULTS_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 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

@@ -1,31 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, AccountMeta, Commitment } 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(commitment?: Commitment): Promise<KVaultState[]>;
-    get globalConfigPda(): PublicKey;
-    getVaultPdasByShareMints(mints: PublicKey[]): Promise<PublicKey[]>;
-    fetchAndParseVaultState(vault: PublicKey): Promise<KVaultState>;
-    composeRemainingAccounts(allocations: KVaultAllocation[], pricingMode?: boolean): Promise<AccountMeta[]>;
-}
-export {};

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/price.d.ts

@@ -1,128 +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";
-/**
- * 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;
-}
-export declare class PriceClient {
-    readonly base: BaseClient;
-    readonly klend: KaminoLendingClient;
-    readonly kvaults: KaminoVaultsClient;
-    readonly bridge: BridgeClient;
-    private readonly getJupiterApi;
-    private _stateModel;
-    private _lookupTables;
-    private _kaminoVaults;
-    private _priceVaultIxsQueue;
-    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, bridge: BridgeClient, getJupiterApi: () => JupiterApiClient);
-    get jupiterApi(): JupiterApiClient;
-    get cachedStateModel(): StateModel | null;
-    set cachedStateModel(stateModel: StateModel);
-    get lookupTables(): PublicKey[];
-    get kaminoVaults(): PublicKey[];
-    /**
-     * 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<TransactionInstruction[]>;
-    priceKaminoVaultSharesIx(): Promise<TransactionInstruction[] | null>;
-    /**
-     * Returns an instruction that prices vault balance and tokens
-     */
-    priceVaultTokensIx(): Promise<TransactionInstruction[]>;
-    /**
-     * 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 priceEpiValidatedPositionsIx;
-    private _priceVaultIxsImpl;
-    validateAumIx(): Promise<TransactionInstruction>;
-    getBaseAssetOracle(): Promise<PublicKey>;
-    remainingAccountsForPricingVaultAssets(): Promise<[
-        AccountMeta[],
-        PublicKey[]
-    ]>;
-}

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 {};