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

package/src/client/neutral.d.ts

@@ -1,111 +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";
-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>;
-    initializePermissionedBundleDepositorIx(accounts: InitializeBundleDepositorAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    initializePermissionedBundleDepositorTx(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>;
-    initializePermissionedBundleDepositor(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>;
-}
-export {};

package/src/client/price.d.ts

@@ -1,137 +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 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 {};

package/src/client/vault.d.ts

@@ -1,90 +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<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
-     *
-     * @param amount
-     * @param txOptions
-     */
-    wrap(amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Unwraps vault wSOL to SOL
-     *
-     * @param txOptions
-     */
-    unwrap(txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Transfers SOL from vault to another account
-     *
-     * @param amount
-     * @param to
-     * @param txOptions
-     */
-    systemTransfer(amount: BN | number, to: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Transfers token from vault to another account
-     *
-     * @param mint
-     * @param amount
-     * @param txOptions
-     */
-    tokenTransfer(mint: PublicKey | string, amount: number | BN, to: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Closes multiple vault token accounts
-     *
-     * @param tokenAccounts
-     * @param txOptions
-     */
-    closeTokenAccounts(tokenAccounts: PublicKey[] | string[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Deposits token to vault
-     *
-     * @param mint Token mint
-     * @param amount
-     * @param txOptions
-     */
-    deposit(mint: PublicKey | string, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Deposits SOL to vault
-     *
-     * @param lamports
-     * @param wrap Whether to wrap SOL to wSOL or not
-     * @param txOptions
-     */
-    depositSol(lamports: number | BN, wrap?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * 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, empty if wSOL is sufficient
-     */
-    maybeWrapSol(lamports: number | BN, signer?: PublicKey): Promise<TransactionInstruction[]>;
-}
-export {};

package/src/client.d.ts

@@ -1,68 +0,0 @@
-import { GlamClientConfig } from "./clientConfig";
-import { BaseClient } from "./client/base";
-import { JupiterSwapClient } from "./client/jupiter";
-import { MarinadeClient } from "./client/marinade";
-import { VaultClient } from "./client/vault";
-import { StateClient } from "./client/state";
-import { KaminoLendingClient, KaminoFarmClient, KaminoVaultsClient } from "./client/kamino";
-import { InvestClient } from "./client/invest";
-import { PriceClient } from "./client/price";
-import { FeesClient } from "./client/fees";
-import { MintClient } from "./client/mint";
-import { AccessClient } from "./client/access";
-import { TimelockClient } from "./client/timelock";
-import { StakeClient } from "./client/stake";
-import { StakePoolClient } from "./client/stake-pool";
-import { CctpClient } from "./client/cctp";
-import { BridgeClient } from "./client/bridge";
-import { EpiClient } from "./client/epi";
-import { LoopscaleClient } from "./client/loopscale";
-import { NeutralClient } from "./client/neutral";
-/**
- * Main entrypoint for the GLAM SDK
- *
- * Lazy loads each client/module at first use
- */
-export declare class GlamClient extends BaseClient {
-    private _invest?;
-    private _jupiterSwap?;
-    private _marinade?;
-    private _vault?;
-    private _price?;
-    private _stake?;
-    private _stakePool?;
-    private _state?;
-    private _mint?;
-    private _access?;
-    private _kaminoLending?;
-    private _kaminoFarm?;
-    private _kaminoVaults?;
-    private _fees?;
-    private _timelock?;
-    private _cctp?;
-    private _bridge?;
-    private _epi?;
-    private _loopscale?;
-    private _neutral?;
-    constructor(config?: GlamClientConfig);
-    get invest(): InvestClient;
-    get fees(): FeesClient;
-    get jupiterSwap(): JupiterSwapClient;
-    get marinade(): MarinadeClient;
-    get vault(): VaultClient;
-    get stake(): StakeClient;
-    get stakePool(): StakePoolClient;
-    get price(): PriceClient;
-    get state(): StateClient;
-    get access(): AccessClient;
-    get mint(): MintClient;
-    get kaminoLending(): KaminoLendingClient;
-    get kaminoFarm(): KaminoFarmClient;
-    get kaminoVaults(): KaminoVaultsClient;
-    get timelock(): TimelockClient;
-    get cctp(): CctpClient;
-    get bridge(): BridgeClient;
-    get epi(): EpiClient;
-    get loopscale(): LoopscaleClient;
-    get neutral(): NeutralClient;
-}

package/src/clientConfig.d.ts

@@ -1,29 +0,0 @@
-import { Provider, Wallet } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import { JupiterApiClient } from "./utils";
-export declare enum ClusterNetwork {
-    Mainnet = "mainnet-beta",
-    Testnet = "testnet",
-    Devnet = "devnet",
-    Localnet = "localnet",
-    Custom = "custom"
-}
-export declare namespace ClusterNetwork {
-    function fromStr(cluster: string): ClusterNetwork;
-    /**
-     * Detects the Solana cluster network from an RPC endpoint URL
-     *
-     * @param rpcUrl The RPC endpoint URL
-     * @returns The detected cluster network
-     */
-    function fromUrl(rpcUrl: string): ClusterNetwork;
-}
-export type GlamClientConfig = {
-    provider?: Provider;
-    wallet?: Wallet;
-    cluster?: ClusterNetwork;
-    statePda?: PublicKey;
-    jupiterApiKey?: string;
-    jupiterApiClient?: JupiterApiClient;
-    useStaging?: boolean;
-};