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

package/src/client/cctp.d.ts

@@ -1,156 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, Keypair, Commitment, Finality, TransactionInstruction, VersionedTransactionResponse } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-export declare class CctpBridgeEvent {
-    readonly amount: BN;
-    readonly sourceDomain: number;
-    readonly sourceAddress: string;
-    readonly destinationDomain: number;
-    readonly destinationCaller: string;
-    readonly destinationAddress: string;
-    readonly attestation: string;
-    readonly nonce: string;
-    readonly status: string;
-    readonly txHash: string;
-    readonly uiAmount: number;
-    slot?: number;
-    constructor(amount: BN, sourceDomain: number, sourceAddress: string, destinationDomain: number, destinationCaller: string, destinationAddress: string, attestation: string, nonce: string, status: string, txHash: string);
-}
-declare class TxBuilder extends BaseTxBuilder<CctpClient> {
-    /**
-     * Returns a transaction that calls CCTP's `depositForBurn` instruction that bridges USDC to another chain.
-     * A keypair is generated for the message sent event account, which must be included as a transaction signer.
-     */
-    bridgeUsdcIx(amount: BN, domain: number, destinationAddress: PublicKey, params: {
-        maxFee: BN;
-        minFinalityThreshold: number;
-        destinationCaller?: PublicKey;
-    }, glamSigner: PublicKey): Promise<[TransactionInstruction, Keypair]>;
-    bridgeUsdcTx(amount: BN, domain: number, destinationAddress: PublicKey, params: {
-        maxFee: BN;
-        minFinalityThreshold: number;
-        destinationCaller?: PublicKey;
-    }, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
-    receiveMessageIx(sourceDomain: number, messageObj: any): Promise<TransactionInstruction>;
-    receiveUsdcTx(sourceDomain: number, params: {
-        txHash?: string;
-        nonce?: string;
-    }, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class CctpClient {
-    readonly base: BaseClient;
-    txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    /**
-     * Bridge USDC to another chain using Circle's CCTP protocol
-     *
-     * @param amount Amount of USDC to bridge (in smallest units)
-     * @param domain Destination domain (e.g., 0 for Ethereum, 1 for Avalanche)
-     * @param destinationAddress Destination address on target chain (EVM address as PublicKey)
-     * @param params Additional parameters (maxFee, minFinalityThreshold)
-     * @param txOptions Transaction options
-     */
-    bridgeUsdc(amount: BN | number, domain: number, destinationAddress: PublicKey, params: {
-        maxFee: BN;
-        minFinalityThreshold: number;
-        destinationCaller?: PublicKey;
-    }, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Receive USDC from another chain using Circle's CCTP protocol
-     *
-     * @param sourceDomain Source domain (e.g., 0 for Ethereum, 6 for Base)
-     * @param params Additional parameters (txHash, nonce)
-     * @param txOptions Transaction options
-     */
-    receiveUsdc(sourceDomain: number, params: {
-        txHash?: string;
-        nonce?: string;
-    }, txOptions?: TxOptions): Promise<string>;
-    getReceiveMessagePdas(messageTransmitterProgram: PublicKey, tokenMessengerMinterProgram: PublicKey, solUsdcMint: PublicKey, remoteUsdcAddressHex: string, remoteDomain: string, nonceHex: string): Promise<{
-        messageTransmitter: PublicKey;
-        tokenMessenger: PublicKey;
-        tokenMinter: PublicKey;
-        localToken: PublicKey;
-        remoteTokenMessengerKey: PublicKey;
-        remoteTokenKey: PublicKey;
-        tokenPair: PublicKey;
-        custodyTokenAccount: PublicKey;
-        authorityPda: PublicKey;
-        tokenMessengerEventAuthority: PublicKey;
-        usedNonce: PublicKey;
-        feeRecipientTokenAccount: PublicKey;
-    }>;
-    /**
-     * Get all PDAs required for CCTP deposit for burn operation
-     *
-     * @param messageTransmitterProgram Message transmitter program ID
-     * @param tokenMessengerMinterProgram Token messenger minter program ID
-     * @param usdcAddress USDC mint address
-     * @param destinationDomain Destination domain
-     * @returns Object containing all required PDAs
-     */
-    getDepositForBurnPdas(messageTransmitterProgram: PublicKey, tokenMessengerMinterProgram: PublicKey, usdcAddress: PublicKey, destinationDomain: Number): {
-        messageTransmitterAccount: PublicKey;
-        tokenMessengerAccount: PublicKey;
-        tokenMinterAccount: PublicKey;
-        localToken: PublicKey;
-        remoteTokenMessengerKey: PublicKey;
-        authorityPda: PublicKey;
-        tokenMessengerEventAuthority: PublicKey;
-    };
-    /**
-     * Find all message accounts onchain for a given sender wallet
-     *
-     * TODO: filter by burned token mint
-     */
-    findV2Messages(senderWallet: PublicKey, options: {
-        commitment?: Commitment;
-        minSlot?: number;
-    }): Promise<PublicKey[]>;
-    fetchV2Messages(sourceDomain: number, params: {
-        txHash?: string;
-        nonce?: string;
-    }): Promise<any[]>;
-    /**
-     * Get bridge events from Circle API using either txHash or nonce
-     *
-     * @param sourceDomain Source domain
-     * @param params Either txHash or nonce is required
-     * @returns Array of bridge events
-     */
-    parseEventsFromAttestion(sourceDomain: number, { txHash, nonce }: {
-        txHash?: string;
-        nonce?: string;
-    }): Promise<CctpBridgeEvent[]>;
-    getTransactions(signatures: string[], batchSize: number, commitment?: Finality): Promise<VersionedTransactionResponse[]>;
-    /**
-     * Get incoming bridge events (EVM -> Solana)
-     *
-     * Unlike outgoing bridge events, incoming bridge events are not stored in Message accounts on Solana.
-     * We need to examine all transactions to find the ones that contain the bridge events.
-     * 1. Fetch all transactions involing the vault's USDC token account
-     * 2. Filter transactions that contain the bridge events
-     * 3. Parse the bridge events from the transactions
-     */
-    getIncomingBridgeEvents(options: {
-        batchSize?: number;
-        commitment?: Finality;
-        txHashes?: string[];
-        minSlot?: number;
-    }): Promise<CctpBridgeEvent[]>;
-    /**
-     * Get outgoing bridge events (Solana -> EVM)
-     *
-     * Each transfer has a Message account on Solana. To get all events:
-     * 1. Find all Message accounts for the vault
-     * 2. Get the created transaction for each message account
-     * 3. Call iris api to get the attestation status and parsed message using each tx hash
-     */
-    getOutgoingBridgeEvents(options: {
-        batchSize?: number;
-        commitment?: Commitment;
-        txHashes?: string[];
-        minSlot?: number;
-    }): Promise<CctpBridgeEvent[]>;
-}
-export {};

package/src/client/epi.d.ts

@@ -1,78 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-type BufferLike32 = Uint8Array | number[] | Buffer;
-export type EpiDenominationKindInput = {
-    usd: Record<string, never>;
-} | {
-    mint: Record<string, never>;
-};
-export type EpiDenominationSpecInput = {
-    denom: EpiDenominationKindInput;
-    mint: PublicKey;
-};
-export type EpiExternalPositionTypeInput = {
-    valued: Record<string, never>;
-} | {
-    tokenized: Record<string, never>;
-};
-export type EpiExternalSourceTypeInput = {
-    trusted: Record<string, never>;
-} | {
-    native: Record<string, never>;
-};
-export type EpiNativeCustodyKindInput = {
-    splToken: Record<string, never>;
-} | {
-    nativeSol: Record<string, never>;
-};
-export type UpsertExternalPositionParams = {
-    positionId: BufferLike32;
-    positionType: EpiExternalPositionTypeInput;
-    sourceType: EpiExternalSourceTypeInput;
-    denomination: EpiDenominationSpecInput;
-    nativeCustodyAccount?: PublicKey;
-    nativeCustodyKind?: EpiNativeCustodyKindInput;
-    enabled?: boolean;
-    freshnessOverrideSecs?: number;
-    submitAllowlist?: PublicKey[];
-    validateAllowlist?: PublicKey[];
-    configureAllowlist?: PublicKey[];
-};
-export type SubmitExternalObservationParams = {
-    positionId: BufferLike32;
-    amount: BN;
-    denomination: EpiDenominationSpecInput;
-    observationTimestamp: BN;
-    externalShares?: BN;
-    reserved?: Uint8Array | number[] | Buffer;
-};
-declare class TxBuilder extends BaseTxBuilder<EpiClient> {
-    upsertExternalPositionIx(params: UpsertExternalPositionParams, signer?: PublicKey): Promise<TransactionInstruction>;
-    submitExternalObservationIx(params: SubmitExternalObservationParams, signer?: PublicKey): Promise<TransactionInstruction>;
-    validateExternalObservationIx(positionId: BufferLike32, normalizedBaseAssetAmount: BN | null, signer?: PublicKey): Promise<TransactionInstruction>;
-    refreshPricedProtocolIx(signer?: PublicKey): Promise<TransactionInstruction>;
-    submitExternalObservationTx(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    upsertExternalPositionTx(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    validateExternalObservationTx(positionId: BufferLike32, normalizedBaseAssetAmount: BN | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    refreshPricedProtocolTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class EpiClient {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    getObservationStatePda(): PublicKey;
-    getIntegrationAuthorityPda(): PublicKey;
-    fetchObservationState(): Promise<{
-        glamState: PublicKey;
-        bump: number;
-        positionsLen: number;
-        reserved: number[];
-        positions: any[];
-    } | null>;
-    submitExternalObservation(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<TransactionSignature>;
-    upsertExternalPosition(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<TransactionSignature>;
-    validateExternalObservation(positionId: BufferLike32, normalizedBaseAssetAmount: BN | null, txOptions?: TxOptions): Promise<TransactionSignature>;
-    refreshPricedProtocol(txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

package/src/client/fees.d.ts

@@ -1,33 +0,0 @@
-import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { PriceClient } from "./price";
-declare class TxBuilder extends BaseTxBuilder<FeesClient> {
-    crystallizeFeesIxs(glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    crystallizeFeesTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    claimFeesIxs(glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    claimFeesTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    chargeProtocolFeeIxs(glamSigner: PublicKey, protocolFeeAuthority: PublicKey): Promise<TransactionInstruction[]>;
-    chargeProtocolFeeTx(protocolFeeAuthority: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    setProtocolFeesIx(baseFeeBps: number, flowFeeBps: number, signer?: PublicKey): Promise<TransactionInstruction>;
-    setProtocolFeesTx(baseFeeBps: number, flowFeeBps: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class FeesClient {
-    readonly base: BaseClient;
-    readonly price: PriceClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient, price: PriceClient);
-    /**
-     * Returns claimable fees object
-     */
-    getClaimableFees(): Promise<any>;
-    /**
-     * Returns claimed fees object
-     */
-    getClaimedFees(): Promise<any>;
-    crystallizeFees(txOptions?: TxOptions): Promise<TransactionSignature>;
-    claimFees(txOptions?: TxOptions): Promise<TransactionSignature>;
-    chargeProtocolFee(protocolFeeAuthority: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    setProtocolFeesIx(baseFeeBps: number, flowFeeBps: number, signer?: PublicKey): Promise<TransactionInstruction>;
-    setProtocolFees(baseFeeBps: number, flowFeeBps: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

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;
-};
-declare class TxBuilder extends BaseTxBuilder<JupiterSwapClient> {
-    private resolveSwapInstructionContext;
-    getSwapV2OracleAccounts(inputMint: PublicKey, outputMint: PublicKey, skipQuotePriceCheck: boolean): Promise<JupiterSwapV2OracleAccounts>;
-    /**
-     * 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/loopscale.d.ts

@@ -1,84 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction, AccountMeta } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-export declare const LOOPSCALE_BS_AUTH: PublicKey;
-export type LoopscaleExpectedLoanValues = {
-    expectedApy: BN;
-    expectedLqt: [number, number, number, number, number];
-};
-export type CreateLoanParams = {
-    nonce: BN;
-};
-export type DepositCollateralParams = {
-    amount: BN;
-    assetType: number;
-    assetIdentifier: PublicKey;
-    assetIndexGuidance: Buffer;
-};
-export type UpdateWeightMatrixParams = {
-    collateralIndex: number;
-    weightMatrix: [number, number, number, number, number];
-    expectedLoanValues: LoopscaleExpectedLoanValues;
-    assetIndexGuidance: Buffer;
-};
-export type BorrowPrincipalParams = {
-    amount: BN;
-    assetIndexGuidance: Buffer;
-    duration: number;
-    expectedLoanValues: LoopscaleExpectedLoanValues;
-    skipSolUnwrap: boolean;
-};
-export type CreateLoanAccounts = {
-    loan: PublicKey;
-};
-export type DepositCollateralAccounts = {
-    loan: PublicKey;
-    depositMint: PublicKey;
-    borrowerCollateralTa?: PublicKey;
-    loanCollateralTa?: PublicKey;
-    assetIdentifier?: PublicKey;
-    tokenProgram?: PublicKey;
-    associatedTokenProgram?: PublicKey;
-};
-export type UpdateWeightMatrixAccounts = {
-    loan: PublicKey;
-};
-export type BorrowPrincipalAccounts = {
-    loan: PublicKey;
-    strategy: PublicKey;
-    marketInformation: PublicKey;
-    principalMint: PublicKey;
-    borrowerTa?: PublicKey;
-    strategyTa?: PublicKey;
-    tokenProgram?: PublicKey;
-    associatedTokenProgram?: PublicKey;
-    remainingAccounts?: AccountMeta[];
-};
-export declare function getLoopscaleEventAuthorityPda(programId?: PublicKey): PublicKey;
-export declare function getLoopscaleLoanPda(borrower: PublicKey, nonce: BN | bigint | number, programId?: PublicKey): PublicKey;
-declare class TxBuilder extends BaseTxBuilder<LoopscaleClient> {
-    createLoanIx(params: CreateLoanParams, accounts: CreateLoanAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    createLoanTx(params: CreateLoanParams, accounts: CreateLoanAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    depositCollateralIx(params: DepositCollateralParams, accounts: DepositCollateralAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    depositCollateralTx(params: DepositCollateralParams, accounts: DepositCollateralAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    updateWeightMatrixIx(params: UpdateWeightMatrixParams, accounts: UpdateWeightMatrixAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    updateWeightMatrixTx(params: UpdateWeightMatrixParams, accounts: UpdateWeightMatrixAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    borrowPrincipalIx(params: BorrowPrincipalParams, accounts: BorrowPrincipalAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    borrowPrincipalTx(params: BorrowPrincipalParams, accounts: BorrowPrincipalAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class LoopscaleClient {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    getIntegrationAuthorityPda(): PublicKey;
-    getEventAuthorityPda(): PublicKey;
-    getBsAuth(): PublicKey;
-    getLoanPda(nonce: BN | bigint | number, borrower?: PublicKey): PublicKey;
-    getLoanTokenAta(loan: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): PublicKey;
-    getStrategyTokenAta(strategy: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): PublicKey;
-    createLoan(params: CreateLoanParams, accounts: CreateLoanAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositCollateral(params: DepositCollateralParams, accounts: DepositCollateralAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    updateWeightMatrix(params: UpdateWeightMatrixParams, accounts: UpdateWeightMatrixAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    borrowPrincipal(params: BorrowPrincipalParams, accounts: BorrowPrincipalAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};