@kamino-finance/klend-sdk 2.10.6

package/README.md

@@ -0,0 +1,85 @@
+## Installation
+
+```shell
+# npm
+npm install @hubbleprotocol/kamino-lending-sdk
+
+# yarn
+yarn add @hubbleprotocol/kamino-lending-sdk
+```
+
+# Kamino Lending Typescript SDK
+
+This is the Kamino Lending Typescript SDK to interact with the Kamino Lend smart contract
+
+## Basic usage
+
+### Reading data
+
+```typescript
+// There are three levels of data you can request (and cache) about the lending market.
+// 1. Initalize market with parameters and metadata
+const market = await KaminoMarket.load(
+  connection,
+  new PublicKey("7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF") // main market address. Defaults to 'Main' market
+);
+console.log(market.reserves.map((reserve) => reserve.config.loanToValueRatio));
+
+// 2. Refresh reserves
+await market.loadReserves();
+
+const usdcReserve = market.getReserve("USDC");
+console.log(usdcReserve?.stats.totalDepositsWads.toString());
+
+
+// Refresh all cached data
+market.refreshAll();
+
+const obligation = market.getObligationByWallet("WALLET_PK");
+console.log(obligation.stats.borrowLimit);
+```
+
+### Perform lending action
+
+```typescript
+const kaminoAction = await KaminoAction.buildDepositTxns(
+  kaminoMarket,
+  amountBase,
+  symbol,
+  new VanillaObligation(PROGRAM_ID),
+);
+
+const env = await initEnv('mainnet-beta');
+await sendTransactionFromAction(env, sendTransaction); // sendTransaction from wallet adapter or custom
+```
+
+## FAQ
+
+## Client 
+* npx ts-node src/client.ts deposit --url <RPC> --owner ./keypair.json --token USDH --amount 10
+* npx ts-node src/client.ts deposit --url <RPC> --owner ./keypair.json --token SOL --amount 10
+
+## Codegen 
+* Copy the new `idl` from the kamino-lending program to `src/idl.json`
+* `yarn codegen`
+
+## Setup localnet 
+* Ensure `deps` contains the correct `.so` you want to test against. Either build it from the main repo or dump it from mainnet
+* `yarn start-validator`
+
+## Run tests
+* `yarn start-validator-and-test`
+* Or, if the local validator is already running, `yarn test`
+
+## TODO: 
+
+Better sdk documentation
+
+## Sync with smart contracts 
+* Copy the program .so, idl and codegen
+```sh
+$ yarn
+$ cp ../kamino-lending/target/deploy/kamino_lending.so deps/programs/kamino_lending.so
+$ cp ../kamino-lending/target/idl/kamino_lending.json src/idl.json
+$ yarn codegen
+```

package/dist/classes/action.d.ts

@@ -0,0 +1,154 @@
+import { Connection, PublicKey, RpcResponseAndContext, SimulatedTransactionResponse, Transaction, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
+import BN from 'bn.js';
+import { ObligationType } from '../utils';
+import { KaminoMarket } from './market';
+import { KaminoObligation } from './obligation';
+import { KaminoReserve } from './reserve';
+export declare const POSITION_LIMIT = 10;
+export declare const BORROWS_LIMIT = 5;
+export declare const DEPOSITS_LIMIT = 8;
+export type ActionType = 'deposit' | 'borrow' | 'withdraw' | 'repay' | 'mint' | 'redeem' | 'depositCollateral' | 'liquidate' | 'depositAndBorrow' | 'repayAndWithdraw' | 'refreshObligation' | 'withdrawReferrerFees';
+export declare class KaminoAction {
+    kaminoMarket: KaminoMarket;
+    reserve: KaminoReserve;
+    outflowReserve: KaminoReserve | undefined;
+    owner: PublicKey;
+    payer: PublicKey;
+    obligation: KaminoObligation | null;
+    referrer: PublicKey;
+    userTokenAccountAddress: PublicKey;
+    userCollateralAccountAddress: PublicKey;
+    additionalTokenAccountAddress?: PublicKey;
+    /**
+     * Null unless the obligation is not passed
+     */
+    obligationType: ObligationType | null;
+    mint: PublicKey;
+    secondaryMint?: PublicKey;
+    positions?: number;
+    amount: BN;
+    outflowAmount?: BN;
+    hostAta?: PublicKey;
+    setupIxs: Array<TransactionInstruction>;
+    setupIxsLabels: Array<string>;
+    inBetweenIxs: Array<TransactionInstruction>;
+    inBetweenIxsLabels: Array<string>;
+    lendingIxs: Array<TransactionInstruction>;
+    lendingIxsLabels: Array<string>;
+    cleanupIxs: Array<TransactionInstruction>;
+    cleanupIxsLabels: Array<string>;
+    preTxnIxs: Array<TransactionInstruction>;
+    preTxnIxsLabels: Array<string>;
+    postTxnIxs: Array<TransactionInstruction>;
+    postTxnIxsLabels: Array<string>;
+    refreshFarmsCleanupTxnIxs: Array<TransactionInstruction>;
+    refreshFarmsCleanupTxnIxsLabels: Array<string>;
+    depositReserves: Array<PublicKey>;
+    borrowReserves: Array<PublicKey>;
+    preLoadedDepositReservesSameTx: Array<PublicKey>;
+    preLoadedBorrowReservesSameTx: Array<PublicKey>;
+    currentSlot: number;
+    private constructor();
+    static initialize(action: ActionType, amount: string | BN, mint: PublicKey, owner: PublicKey, kaminoMarket: KaminoMarket, obligation: KaminoObligation | ObligationType, referrer?: PublicKey, currentSlot?: number, hostAta?: PublicKey, payer?: PublicKey): Promise<KaminoAction>;
+    private static getUserAccountAddresses;
+    private static loadObligation;
+    static buildRefreshObligationTxns(kaminoMarket: KaminoMarket, payer: PublicKey, obligation: KaminoObligation, extraComputeBudget?: number, // if > 0 then adds the ixn
+    currentSlot?: number): Promise<KaminoAction>;
+    static buildDepositTxns(kaminoMarket: KaminoMarket, amount: string | BN, mint: PublicKey, owner: PublicKey, obligation: KaminoObligation | ObligationType, extraComputeBudget?: number, // if > 0 then adds the ixn
+    includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas,
+    requestElevationGroup?: boolean, includeUserMetadata?: boolean, // if true it includes user metadata
+    referrer?: PublicKey, currentSlot?: number): Promise<KaminoAction>;
+    static buildBorrowTxns(kaminoMarket: KaminoMarket, amount: string | BN, mint: PublicKey, owner: PublicKey, obligation: KaminoObligation | ObligationType, extraComputeBudget?: number, // if > 0 then adds the ixn
+    includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas,
+    requestElevationGroup?: boolean, includeUserMetadata?: boolean, // if true it includes user metadata
+    referrer?: PublicKey, currentSlot?: number, hostAta?: PublicKey): Promise<KaminoAction>;
+    static buildDepositReserveLiquidityTxns(kaminoMarket: KaminoMarket, amount: string | BN, mint: PublicKey, owner: PublicKey, obligation: KaminoObligation | ObligationType, extraComputeBudget?: number, // if > 0 then adds the ixn
+    includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas
+    requestElevationGroup?: boolean, includeUserMetadata?: boolean, // if true it includes user metadata
+    referrer?: PublicKey, currentSlot?: number): Promise<KaminoAction>;
+    static buildRedeemReserveCollateralTxns(kaminoMarket: KaminoMarket, amount: string | BN, mint: PublicKey, owner: PublicKey, obligation: KaminoObligation | ObligationType, extraComputeBudget?: number, // if > 0 then adds the ixn
+    includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas
+    requestElevationGroup?: boolean, includeUserMetadata?: boolean, // if true it includes user metadata,
+    referrer?: PublicKey, currentSlot?: number): Promise<KaminoAction>;
+    static buildDepositObligationCollateralTxns(kaminoMarket: KaminoMarket, amount: string | BN, mint: PublicKey, owner: PublicKey, obligation: KaminoObligation | ObligationType, extraComputeBudget?: number, // if > 0 then adds the ixn
+    includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas
+    requestElevationGroup?: boolean, includeUserMetadata?: boolean, // if true it includes user metadata
+    referrer?: PublicKey, currentSlot?: number): Promise<KaminoAction>;
+    static buildDepositAndBorrowTxns(kaminoMarket: KaminoMarket, depositAmount: string | BN, depositMint: PublicKey, borrowAmount: string | BN, borrowMint: PublicKey, payer: PublicKey, obligation: KaminoObligation | ObligationType, extraComputeBudget?: number, // if > 0 then adds the ixn
+    includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas,
+    requestElevationGroup?: boolean, includeUserMetadata?: boolean, // if true it includes user metadata,
+    referrer?: PublicKey, currentSlot?: number): Promise<KaminoAction>;
+    static buildRepayAndWithdrawTxns(kaminoMarket: KaminoMarket, repayAmount: string | BN, repayMint: PublicKey, withdrawAmount: string | BN, withdrawMint: PublicKey, payer: PublicKey, currentSlot: number, obligation: KaminoObligation | ObligationType, extraComputeBudget?: number, // if > 0 then adds the ixn
+    includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas,
+    requestElevationGroup?: boolean, includeUserMetadata?: boolean, // if true it includes user metadata,
+    isClosingPosition?: boolean, referrer?: PublicKey): Promise<KaminoAction>;
+    static buildWithdrawTxns(kaminoMarket: KaminoMarket, amount: string | BN, mint: PublicKey, owner: PublicKey, obligation: KaminoObligation | ObligationType, extraComputeBudget?: number, // if > 0 then adds the ixn
+    includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas,
+    requestElevationGroup?: boolean, includeUserMetadata?: boolean, // if true it includes user metadata
+    referrer?: PublicKey, currentSlot?: number): Promise<KaminoAction>;
+    /**
+     *
+     * @param kaminoMarket
+     * @param amount
+     * @param mint
+     * @param owner
+     * @param obligation - obligation to repay or the PDA seeds
+     * @param currentSlot
+     * @param payer - if not set then owner is used
+     * @param extraComputeBudget - if > 0 then adds the ixn
+     * @param includeAtaIxns - if true it includes create and close wsol and token atas
+     * @param requestElevationGroup
+     * @param includeUserMetadata - if true it includes user metadata
+     * @param referrer
+     */
+    static buildRepayTxns(kaminoMarket: KaminoMarket, amount: string | BN, mint: PublicKey, owner: PublicKey, obligation: KaminoObligation | ObligationType, currentSlot: number, payer?: PublicKey | undefined, extraComputeBudget?: number, includeAtaIxns?: boolean, requestElevationGroup?: boolean, includeUserMetadata?: boolean, referrer?: PublicKey): Promise<KaminoAction>;
+    static buildLiquidateTxns(kaminoMarket: KaminoMarket, amount: string | BN, minCollateralReceiveAmount: string | BN, repayTokenMint: PublicKey, withdrawTokenMint: PublicKey, liquidator: PublicKey, obligationOwner: PublicKey, obligation: KaminoObligation | ObligationType, extraComputeBudget?: number, // if > 0 then adds the ixn
+    includeAtaIxns?: boolean, // if true it includes create and close wsol and token atas, and creates all other token atas if they don't exist
+    requestElevationGroup?: boolean, includeUserMetadata?: boolean, // if true it includes user metadata
+    referrer?: PublicKey, maxAllowedLtvOverridePercent?: number, currentSlot?: number): Promise<KaminoAction>;
+    static buildWithdrawReferrerFeeTxns(owner: PublicKey, tokenMint: PublicKey, kaminoMarket: KaminoMarket, currentSlot?: number): Promise<KaminoAction>;
+    getTransactions(): Promise<{
+        preLendingTxn: Transaction | null;
+        lendingTxn: Transaction | null;
+        postLendingTxn: Transaction | null;
+    }>;
+    sendTransactions(sendTransaction: (txn: Transaction, connection: Connection) => Promise<TransactionSignature>): Promise<string>;
+    private sendSingleTransaction;
+    simulateTransactions(sendTransaction: (txn: Transaction, connection: Connection) => Promise<RpcResponseAndContext<SimulatedTransactionResponse>>): Promise<"" | RpcResponseAndContext<SimulatedTransactionResponse>>;
+    private simulateSingleTransaction;
+    addDepositIx(): void;
+    addDepositReserveLiquidityIx(): void;
+    addRedeemReserveCollateralIx(): void;
+    addDepositObligationCollateralIx(): void;
+    addBorrowIx(): void;
+    addDepositAndBorrowIx(): Promise<void>;
+    addRepayAndWithdrawIxs(): Promise<void>;
+    addWithdrawIx(): Promise<void>;
+    addRepayIx(): Promise<void>;
+    addLiquidateIx(maxAllowedLtvOverridePercent?: number): Promise<void>;
+    addInBetweenIxs(action: ActionType, includeAtaIxns: boolean, requestElevationGroup: boolean, addInitObligationForFarm: boolean, isClosingPosition?: boolean): Promise<void>;
+    addRefreshObligation(crank: PublicKey): void;
+    addSupportIxsWithoutInitObligation(action: ActionType, includeAtaIxns: boolean, addToSetupIxs?: boolean, requestElevationGroup?: boolean, addInitObligationForFarm?: boolean, isClosingPosition?: boolean, twoTokenAction?: boolean): Promise<void>;
+    addSupportIxs(action: ActionType, includeAtaIxns: boolean, requestElevationGroup: boolean, includeUserMetadata: boolean, addInitObligationForFarm: boolean, twoTokenAction?: boolean): Promise<void>;
+    private static optionalAccount;
+    private addRefreshReserveIxs;
+    static getRefreshAllReserves(kaminoMarket: KaminoMarket, reserves: PublicKey[]): TransactionInstruction[];
+    private addRefreshObligationIx;
+    private addRequestElevationIx;
+    private addRefreshFarmsForReserve;
+    private addRefreshFarmsCleanupTxnIxsToCleanupIxs;
+    private addInitObligationForFarm;
+    private addInitObligationIxs;
+    private addInitUserMetadataIxs;
+    private addInitReferrerTokenStateIxs;
+    private addWithdrawReferrerFeesIxs;
+    private addComputeBudgetIxn;
+    private addAtaIxs;
+    private updateWSOLAccount;
+    static initializeMultiTokenAction(kaminoMarket: KaminoMarket, action: ActionType, inflowAmount: string | BN, inflowTokenMint: PublicKey, outflowTokenMint: PublicKey, payer: PublicKey, obligationOwner: PublicKey, obligation: KaminoObligation | ObligationType, outflowAmount?: string | BN, referrer?: PublicKey, currentSlot?: number): Promise<KaminoAction>;
+    static initializeWithdrawReferrerFees(mint: PublicKey, owner: PublicKey, kaminoMarket: KaminoMarket, currentSlot?: number, hostAta?: PublicKey): Promise<{
+        axn: KaminoAction;
+        createAtasIxns: TransactionInstruction[];
+    }>;
+    getObligationPda(): PublicKey;
+}