@glamsystems/glam-sdk 1.1.0-alpha.5 → 1.1.0

package/src/client/jupiter-lend/shared.d.ts

@@ -0,0 +1,129 @@
+import { AccountMeta, AddressLookupTableAccount, Connection, PublicKey } from "@solana/web3.js";
+import { U64_MAX_BN as U64_MAX } from "../../utils/common";
+export { JUPITER_BORROW_PROTOCOL, JUPITER_EARN_PROTOCOL, } from "../../protocols";
+export type JupiterTransferType = {
+    skip: Record<string, never>;
+} | {
+    direct: Record<string, never>;
+} | {
+    claim: Record<string, never>;
+};
+export declare const PUBKEY_BYTES = 32;
+export { U64_MAX };
+export declare const LENDING_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const TOKEN_RESERVE_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const VAULT_STATE_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const VAULT_CONFIG_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const VAULT_METADATA_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const POSITION_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const ORACLE_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const TICK_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const TICK_ID_LIQUIDATION_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const LIQUIDITY_SUPPLY_POSITION_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const LIQUIDITY_BORROW_POSITION_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const LENDING_REWARDS_RATE_MODEL_OFFSET: number;
+export declare const LENDING_TOKEN_RESERVES_LIQUIDITY_OFFSET: number;
+export declare const LENDING_SUPPLY_POSITION_OFFSET: number;
+export declare const TOKEN_RESERVE_VAULT_OFFSET: number;
+export declare const VAULT_CONFIG_ORACLE_OFFSET: number;
+export declare const VAULT_CONFIG_SUPPLY_TOKEN_OFFSET: number;
+export declare const VAULT_CONFIG_BORROW_TOKEN_OFFSET: number;
+export declare const VAULT_METADATA_LOOKUP_TABLE_OFFSET: number;
+export declare const VAULT_STATE_VAULT_ID_OFFSET = 8;
+export declare const VAULT_STATE_CURRENT_BRANCH_ID_OFFSET: number;
+export declare const VAULT_STATE_NEXT_POSITION_ID_OFFSET: number;
+export declare const POSITION_VAULT_ID_OFFSET = 8;
+export declare const POSITION_MINT_OFFSET: number;
+export declare const POSITION_IS_SUPPLY_ONLY_OFFSET: number;
+export declare const POSITION_TICK_OFFSET: number;
+export declare const POSITION_TICK_ID_OFFSET: number;
+export declare const ORACLE_SOURCE_BYTES: number;
+export declare const TICK_VALUE_OFFSET: number;
+export declare const TICK_TOTAL_IDS_OFFSET: number;
+export declare const TICK_ID_VALUE_OFFSET: number;
+export declare const TICK_ID_MAP_OFFSET: number;
+export declare const MIN_TICK = -16383;
+export declare const TICKS_PER_TICK_HAS_DEBT_ARRAY = 2048;
+export declare const LIQUIDITY_POSITION_VAULT_CONFIG_OFFSET = 8;
+export declare const LIQUIDITY_POSITION_MINT_OFFSET: number;
+export declare const LIQUIDITY_SUPPLY_POSITION_SIZE = 124;
+export declare const LIQUIDITY_BORROW_POSITION_SIZE = 120;
+export declare const BORROW_OPERATE_EXPECTED_TICK_RE: RegExp;
+export type JupiterPosition = {
+    pubkey: PublicKey;
+    vaultId: number;
+    positionMint: PublicKey;
+    isSupplyOnlyPosition: boolean;
+    tick: number;
+    tickId: number;
+};
+export type JupiterVault = {
+    vaultId: number;
+    vaultConfig: PublicKey;
+    vaultState: PublicKey;
+    oracle: PublicKey;
+    supplyToken: PublicKey;
+    borrowToken: PublicKey;
+};
+export type VaultStateInfo = {
+    vaultId: number;
+    currentBranchId: number;
+    nextPositionId: number;
+};
+export type TickInfo = {
+    pubkey: PublicKey;
+    tick: number;
+    totalIds: number;
+};
+export type BorrowOperateRemainingAccounts = {
+    indices: Buffer;
+    accounts: AccountMeta[];
+};
+export declare function decodePositionInfo(pubkey: PublicKey, data: Buffer): JupiterPosition;
+export declare function u16LeBytes(value: number): Buffer;
+export declare function u32LeBytes(value: number): Buffer;
+export declare function i32LeBytes(value: number): Buffer;
+export declare function memcmpFilter(offset: number, data: Buffer): {
+    memcmp: {
+        offset: number;
+        bytes: string;
+        encoding: "base64";
+    };
+};
+export declare function toU8Buffer(value: Buffer | Uint8Array | number[]): Buffer;
+export declare function getTokenMetadataPda(mint: PublicKey): PublicKey;
+export declare function getLendingAdminPda(): PublicKey;
+export declare function getFTokenMintPda(mint: PublicKey): PublicKey;
+export declare function getLendingPda(mint: PublicKey, fTokenMint: PublicKey): PublicKey;
+export declare function getClaimAccountPda(mint: PublicKey, lendingAdmin: PublicKey): PublicKey;
+export declare function getRateModelPda(mint: PublicKey): PublicKey;
+export declare function getLiquidityPda(): PublicKey;
+export declare function getVaultAdminPda(): PublicKey;
+export declare function getVaultConfigPda(vaultId: number): PublicKey;
+export declare function getVaultMetadataPda(vaultId: number): PublicKey;
+export declare function getVaultStatePda(vaultId: number): PublicKey;
+export declare function getPositionPda(vaultId: number, positionId: number): PublicKey;
+export declare function getPositionMintPda(vaultId: number, positionId: number): PublicKey;
+export declare function getBranchPda(vaultId: number, branchId: number): PublicKey;
+export declare function getTickHasDebtPda(vaultId: number, index: number): PublicKey;
+export declare function getTickHasDebtIndex(tick: number): number;
+export declare function fetchAndValidate(connection: Connection, pubkey: PublicKey, expectedOwner: PublicKey, expectedDiscriminator: Buffer, label: string): Promise<Buffer>;
+export declare function resolveLookupTableAccounts(connection: Connection, statePda: PublicKey, vaultPda: PublicKey, lookupTable?: PublicKey): Promise<AddressLookupTableAccount[]>;
+export declare function fetchPositionInfo(connection: Connection, position: PublicKey): Promise<JupiterPosition>;
+export declare function fetchVaultStateInfo(connection: Connection, vaultState: PublicKey): Promise<VaultStateInfo>;
+export declare function fetchVaultConfigInfo(connection: Connection, vaultConfig: PublicKey): Promise<{
+    oracle: PublicKey;
+    supplyToken: PublicKey;
+    borrowToken: PublicKey;
+}>;
+export declare function fetchVaultMetadataLookupTable(connection: Connection, vaultMetadata: PublicKey): Promise<PublicKey | null>;
+export declare function fetchReserveVault(connection: Connection, reserve: PublicKey, expectedMint: PublicKey): Promise<PublicKey>;
+export declare function fetchLendingReserveAndVault(connection: Connection, mint: PublicKey): Promise<{
+    reserve: PublicKey;
+    vault: PublicKey;
+}>;
+export declare function fetchLiquidityPosition(connection: Connection, discriminator: Buffer, dataSize: number, vaultConfig: PublicKey, mint: PublicKey, label: string): Promise<PublicKey>;
+export declare function fetchTickByValue(connection: Connection, vaultId: number, tick: number): Promise<TickInfo>;
+export declare function fetchTickIdLiquidationByTick(connection: Connection, vaultId: number, tick: number, tickMap: number): Promise<PublicKey>;
+export declare function resolveOracleRemainingAccounts(connection: Connection, oracle: PublicKey): Promise<AccountMeta[]>;
+export declare function buildBorrowOperateRemainingAccounts(vaultId: number, oracleAccounts: AccountMeta[], currentTickValue: number, finalTickValue: number): BorrowOperateRemainingAccounts;

package/src/client/jupiter.d.ts

@@ -0,0 +1,53 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "./base";
+import { JupiterSwapPolicy } from "../deser/integrationPolicies";
+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> implements ProtocolPolicyTxBuilder<JupiterSwapPolicy> {
+    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>;
+    setPolicyIx(policy: JupiterSwapPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
+    setPolicyTx(policy: JupiterSwapPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    clearPolicyTx(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 implements ProtocolPolicyClient<JupiterSwapPolicy> {
+    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>;
+    fetchPolicy(): Promise<JupiterSwapPolicy | null>;
+    setPolicy(policy: JupiterSwapPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export {};

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

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

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

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

@@ -0,0 +1,94 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "../base";
+import { KaminoLendingPolicy } from "../../deser/integrationPolicies";
+import { Reserve, Obligation } from "../../deser/kaminoLayouts";
+import { VaultClient } from "../vault";
+import { RefreshObligationAccounts, RefreshReserveAccounts, RefreshObligationFarmsForReserveArgs, RefreshObligationFarmsForReserveAccounts } from "./types";
+declare class TxBuilder extends BaseTxBuilder<KaminoLendingClient> implements ProtocolPolicyTxBuilder<KaminoLendingPolicy> {
+    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>;
+    setPolicyIx(policy: KaminoLendingPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
+    setPolicyTx(policy: KaminoLendingPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class KaminoLendingClient implements ProtocolPolicyClient<KaminoLendingPolicy> {
+    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>;
+    fetchPolicy(): Promise<KaminoLendingPolicy | null>;
+    setPolicy(policy: KaminoLendingPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    clearPolicy(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

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

@@ -0,0 +1,39 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, VersionedTransaction, TransactionSignature, AccountMeta, Commitment } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "../base";
+import { KVaultAllocation, KVaultState } from "../../deser/kaminoLayouts";
+import { KaminoVaultsPolicy } from "../../deser/integrationPolicies";
+import { KaminoLendingClient } from "./lending";
+declare class TxBuilder extends BaseTxBuilder<KaminoVaultsClient> implements ProtocolPolicyTxBuilder<KaminoVaultsPolicy> {
+    depositTx(vault: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawTx(vault: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    setPolicyIx(policy: KaminoVaultsPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
+    setPolicyTx(policy: KaminoVaultsPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class KaminoVaultsClient implements ProtocolPolicyClient<KaminoVaultsPolicy> {
+    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>;
+    fetchPolicy(): Promise<KaminoVaultsPolicy | null>;
+    setPolicy(policy: KaminoVaultsPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    clearPolicy(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/borrow.d.ts

@@ -0,0 +1,118 @@
+import { BN } from "@coral-xyz/anchor";
+import { Commitment, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, type ProtocolPolicyClient, type TxOptions } from "../base";
+import { LoopscaleBorrowPolicy } from "../../deser/integrationPolicies";
+import { LoopscaleLoan, LoopscaleMarketInformation, LoopscaleStrategy } from "../../deser";
+import { BorrowMarketAccounts, BorrowPrincipalAccounts, BorrowPrincipalParams, CreateLoanParams, DepositCollateralAccounts, DepositCollateralParams, LoopscaleBorrowPrincipalTerms, LoopscaleBorrowQuoteTerms, LoopscaleBorrowTxBuilder, LoopscaleCoreClient, LoopscaleMaxQuoteParams, LoopscaleQuote, PriceLoansAccounts, RepayPrincipalAccounts, RepayPrincipalParams, UpdateWeightMatrixAccounts, UpdateWeightMatrixParams, WithdrawCollateralAccounts, WithdrawCollateralParams } from "./core";
+export type Tuple5 = [number, number, number, number, number];
+export declare class LoopscaleBorrowClient implements ProtocolPolicyClient<LoopscaleBorrowPolicy> {
+    private readonly core;
+    readonly txBuilder: LoopscaleBorrowTxBuilder;
+    constructor(core: LoopscaleCoreClient);
+    get base(): BaseClient;
+    get programId(): PublicKey;
+    get integrationAuthorityPda(): PublicKey;
+    getEventAuthorityPda(): PublicKey;
+    getLoanPda: (nonce: BN, borrower?: PublicKey) => PublicKey;
+    getLoanTokenAta(loan: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): PublicKey;
+    fetchPolicy(): Promise<LoopscaleBorrowPolicy | null>;
+    setPolicy(policy: LoopscaleBorrowPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
+    fetchLoan(loan: PublicKey): Promise<LoopscaleLoan>;
+    fetchOwnedLoan(loan: PublicKey, borrower?: PublicKey): Promise<LoopscaleLoan>;
+    fetchRegisteredLoans(commitment?: Commitment): Promise<LoopscaleLoan[]>;
+    fetchMarketInformation(marketInformation: PublicKey): Promise<LoopscaleMarketInformation>;
+    fetchStrategy(strategy: PublicKey): Promise<LoopscaleStrategy>;
+    fetchMaxQuotes(params: LoopscaleMaxQuoteParams): Promise<LoopscaleQuote[]>;
+    selectBestQuote(quotes: LoopscaleQuote[], externalYieldSource?: number, borrowAmount?: BN): Promise<LoopscaleQuote>;
+    fetchBestQuote(params: LoopscaleMaxQuoteParams): Promise<LoopscaleQuote>;
+    resolveBorrowMarketAccounts(params: {
+        strategy: PublicKey | LoopscaleStrategy;
+        collateralMint: PublicKey;
+        expectedApy: BN;
+    }): Promise<BorrowMarketAccounts>;
+    resolveBorrowTermsFromStrategy(params: {
+        strategy: PublicKey | LoopscaleStrategy;
+        principalMint: PublicKey;
+        assetIdentifier: PublicKey;
+        expectedApy: BN;
+        expectedLqt: Tuple5;
+    }): Promise<LoopscaleBorrowPrincipalTerms>;
+    resolveBorrowTermsFromTargetStrategy(params: {
+        strategy: PublicKey | LoopscaleStrategy;
+        principalMint: PublicKey;
+        assetIdentifier: PublicKey;
+        requestedDurationIndex?: number;
+    }): Promise<LoopscaleBorrowPrincipalTerms>;
+    resolveBorrowTermsFromQuote(params: {
+        principalMint: PublicKey;
+        collateralMint: PublicKey;
+        assetIdentifier: PublicKey;
+        collateralAmount: BN;
+        borrowAmount: BN;
+        durationType: number;
+        duration: number;
+        externalYieldSource?: number;
+    }): Promise<LoopscaleBorrowQuoteTerms>;
+    buildApiCreateLoanIxs(params: CreateLoanParams): Promise<{
+        loan: PublicKey;
+        ixs: TransactionInstruction[];
+    }>;
+    buildApiDepositCollateralIxs(params: {
+        loan: PublicKey;
+        depositMint: PublicKey;
+        amount: BN;
+        assetType: number;
+        assetIdentifier: PublicKey;
+        assetIndexGuidance: number[];
+    }): Promise<TransactionInstruction[]>;
+    buildApiBorrowPrincipalIxs(params: {
+        loan: PublicKey;
+        strategy: PublicKey;
+        amount: BN;
+        assetIndexGuidance: number[];
+        duration: number;
+        expectedLoanValues: {
+            expectedApy: BN;
+            expectedLqt: Tuple5;
+        };
+        skipSolUnwrap: boolean;
+    }): Promise<TransactionInstruction[]>;
+    buildApiWithdrawCollateralIxs(params: {
+        loan: PublicKey;
+        collateralMint: PublicKey;
+        amount: BN;
+        collateralIndex: number;
+        assetIndexGuidance: number[];
+        expectedLoanValues: {
+            expectedApy: BN;
+            expectedLqt: Tuple5;
+        };
+    }): Promise<TransactionInstruction[]>;
+    buildApiRepayPrincipalIxs(params: {
+        loan: PublicKey;
+        strategy: PublicKey;
+        amount: BN;
+        ledgerIndex: number;
+        repayAll: boolean;
+    }): Promise<TransactionInstruction[]>;
+    cosignTransaction(params: {
+        tx: VersionedTransaction;
+        identifier: string;
+    }): Promise<VersionedTransaction>;
+    createLoan(params: CreateLoanParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    closeLoan(loan: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    depositCollateral(params: DepositCollateralParams, accounts: DepositCollateralAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /** @deprecated */
+    updateWeightMatrix(params: UpdateWeightMatrixParams, accounts: UpdateWeightMatrixAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
+    borrowPrincipal(params: BorrowPrincipalParams, accounts: BorrowPrincipalAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdrawCollateral(params: WithdrawCollateralParams, accounts: WithdrawCollateralAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
+    repayPrincipal(params: RepayPrincipalParams, accounts: RepayPrincipalAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /** @deprecated */
+    resolveLedgerStrategyAccounts(strategy: PublicKey): Promise<{
+        strategy: PublicKey;
+        marketInformation: PublicKey;
+        principalMint: PublicKey;
+    }>;
+    getPriceLoansAccounts(commitment?: Commitment): Promise<PriceLoansAccounts | null>;
+}