@kamino-finance/klend-sdk 6.1.0-beta.0 → 7.0.0

package/src/classes/curve.ts

@@ -1,4 +1,4 @@
-import { BorrowRateCurve, CurvePointFields } from '../idl_codegen/types';
+import { BorrowRateCurve, CurvePointFields } from '../@codegen/klend/types';
 
 export const CURVE_POINTS_LENGTH = 11;
 

package/src/classes/farm_utils.ts

@@ -1,4 +1,3 @@
-import { BN } from '@coral-xyz/anchor';
 import {
   Farms,
   FarmState,
@@ -9,94 +8,91 @@ import {
   scaleDownWads,
   WAD,
 } from '@kamino-finance/farms-sdk';
-import { Connection, Keypair, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import {
+  address,
+  Address,
+  fetchEncodedAccount,
+  generateKeyPairSigner,
+  IInstruction,
+  Rpc,
+  SolanaRpcApi,
+  TransactionSigner,
+} from '@solana/kit';
 import Decimal from 'decimal.js/decimal';
+import { DEFAULT_PUBLIC_KEY } from '../utils';
+import { getScopePricesFromFarm } from '@kamino-finance/farms-sdk/dist/utils/option';
 
-export const FARMS_GLOBAL_CONFIG_MAINNET: PublicKey = new PublicKey('6UodrBjL2ZreDy7QdR4YV1oxqMBjVYSEyrFpctqqwGwL');
+export const FARMS_GLOBAL_CONFIG_MAINNET: Address = address('6UodrBjL2ZreDy7QdR4YV1oxqMBjVYSEyrFpctqqwGwL');
 
 export async function getFarmStakeIxs(
-  connection: Connection,
-  user: PublicKey,
+  rpc: Rpc<SolanaRpcApi>,
+  user: TransactionSigner,
   lamportsToStake: Decimal,
-  farmAddress: PublicKey,
+  farmAddress: Address,
   fetchedFarmState?: FarmState
-): Promise<TransactionInstruction[]> {
-  const farmState = fetchedFarmState ? fetchedFarmState : await FarmState.fetch(connection, farmAddress);
+): Promise<IInstruction[]> {
+  const farmState = fetchedFarmState ? fetchedFarmState : await FarmState.fetch(rpc, farmAddress);
   if (!farmState) {
     throw new Error(`Farm state not found for ${farmAddress}`);
   }
 
-  const farmClient = new Farms(connection);
-  const scopePricesArg = farmState.scopePrices.equals(PublicKey.default)
-    ? farmClient.getProgramID()
-    : farmState!.scopePrices;
-
-  const stakeIxs: TransactionInstruction[] = [];
-  const userState = getUserStatePDA(farmClient.getProgramID(), farmAddress, user);
-  const userStateExists = await connection.getAccountInfo(userState);
-  if (!userStateExists) {
-    const createUserIx = farmClient.createNewUserIx(user, farmAddress);
+  const farmClient = new Farms(rpc);
+  const scopePricesArg = getScopePricesFromFarm(farmState);
+
+  const stakeIxs: IInstruction[] = [];
+  const userState = await getUserStatePDA(farmClient.getProgramID(), farmAddress, user.address);
+  const userStateExists = await fetchEncodedAccount(rpc, userState);
+  if (!userStateExists.exists) {
+    const createUserIx = await farmClient.createNewUserIx(user, farmAddress);
     stakeIxs.push(createUserIx);
   }
 
-  const stakeIx = farmClient.stakeIx(user, farmAddress, lamportsToStake, farmState.token.mint, scopePricesArg);
+  const stakeIx = await farmClient.stakeIx(user, farmAddress, lamportsToStake, farmState.token.mint, scopePricesArg);
   stakeIxs.push(stakeIx);
 
   return stakeIxs;
 }
 
-export async function getFarmUserStatePDA(
-  connection: Connection,
-  user: PublicKey,
-  farm: PublicKey
-): Promise<PublicKey> {
-  const farmClient = new Farms(connection);
+export async function getFarmUserStatePDA(rpc: Rpc<SolanaRpcApi>, user: Address, farm: Address): Promise<Address> {
+  const farmClient = new Farms(rpc);
   return getUserStatePDA(farmClient.getProgramID(), farm, user);
 }
 
 export async function getFarmUnstakeIx(
-  connection: Connection,
-  user: PublicKey,
+  rpc: Rpc<SolanaRpcApi>,
+  user: TransactionSigner,
   lamportsToUnstake: Decimal,
-  farmAddress: PublicKey,
+  farmAddress: Address,
   fetchedFarmState?: FarmState
-): Promise<TransactionInstruction> {
-  const farmState = fetchedFarmState ? fetchedFarmState : await FarmState.fetch(connection, farmAddress);
+): Promise<IInstruction> {
+  const farmState = fetchedFarmState ? fetchedFarmState : await FarmState.fetch(rpc, farmAddress);
   if (!farmState) {
     throw new Error(`Farm state not found for ${farmAddress}`);
   }
 
-  const farmClient = new Farms(connection);
-  const scopePricesArg = farmState.scopePrices.equals(PublicKey.default)
-    ? farmClient.getProgramID()
-    : farmState!.scopePrices;
-  const userState = getUserStatePDA(farmClient.getProgramID(), farmAddress, user);
-  if (!userState) {
-    throw new Error(`User state not found for ${user}`);
-  }
-
-  const scaledLamportsToUnstake = new BN(lamportsToUnstake.floor().toString()).mul(new BN(WAD.toString()));
-  return farmClient.unstakeIx(user, farmAddress, scaledLamportsToUnstake.toString(), scopePricesArg);
+  const farmClient = new Farms(rpc);
+  const scopePricesArg = getScopePricesFromFarm(farmState);
+  const scaledLamportsToUnstake = lamportsToUnstake.floor().mul(WAD);
+  return farmClient.unstakeIx(user, farmAddress, scaledLamportsToUnstake, scopePricesArg);
 }
 
 // withdrawing from a farm is a 2 step operation: first we unstake the tokens from the farm, then we withdraw them
 export async function getFarmWithdrawUnstakedDepositIx(
-  connection: Connection,
-  user: PublicKey,
-  farm: PublicKey,
-  stakeTokenMint: PublicKey
-): Promise<TransactionInstruction> {
-  const farmClient = new Farms(connection);
-
-  const userState = getUserStatePDA(farmClient.getProgramID(), farm, user);
+  rpc: Rpc<SolanaRpcApi>,
+  user: TransactionSigner,
+  farm: Address,
+  stakeTokenMint: Address
+): Promise<IInstruction> {
+  const farmClient = new Farms(rpc);
+  const userState = await getUserStatePDA(farmClient.getProgramID(), farm, user.address);
   return farmClient.withdrawUnstakedDepositIx(user, userState, farm, stakeTokenMint);
 }
 
 export async function getFarmUnstakeAndWithdrawIxs(
-  connection: Connection,
-  user: PublicKey,
+  connection: Rpc<SolanaRpcApi>,
+  user: TransactionSigner,
   lamportsToUnstake: Decimal,
-  farmAddress: PublicKey,
+  farmAddress: Address,
   fetchedFarmState?: FarmState
 ): Promise<UnstakeAndWithdrawFromFarmIxs> {
   const farmState = fetchedFarmState ? fetchedFarmState : await FarmState.fetch(connection, farmAddress);
@@ -110,13 +106,13 @@ export async function getFarmUnstakeAndWithdrawIxs(
 }
 
 export async function getSetupFarmIxsWithFarm(
-  connection: Connection,
-  farmAdmin: Keypair,
-  farmTokenMint: PublicKey
+  connection: Rpc<SolanaRpcApi>,
+  farmAdmin: TransactionSigner,
+  farmTokenMint: Address
 ): Promise<SetupFarmIxsWithFarm> {
   const farmClient = new Farms(connection);
-  const farm = new Keypair();
-  const ixs = await farmClient.createFarmIx(farmAdmin.publicKey, farm, FARMS_GLOBAL_CONFIG_MAINNET, farmTokenMint);
+  const farm = await generateKeyPairSigner();
+  const ixs = await farmClient.createFarmIxs(farmAdmin, farm, FARMS_GLOBAL_CONFIG_MAINNET, farmTokenMint);
   return { farm, setupFarmIxs: ixs };
 }
 
@@ -129,16 +125,16 @@ export async function getSetupFarmIxsWithFarm(
  * @returns the number of tokens the user has staked in the farm
  */
 export async function getUserSharesInTokensStakedInFarm(
-  connection: Connection,
-  user: PublicKey,
-  farm: PublicKey,
+  rpc: Rpc<SolanaRpcApi>,
+  user: Address,
+  farm: Address,
   farmTokenDecimals: number
 ): Promise<Decimal> {
-  const farmClient = new Farms(connection);
-  const userStatePDA = getUserStatePDA(farmClient.getProgramID(), farm, user);
+  const farmClient = new Farms(rpc);
+  const userStatePDA = await getUserStatePDA(farmClient.getProgramID(), farm, user);
   // if the user state does not exist, return 0
-  const userState = await connection.getAccountInfo(userStatePDA);
-  if (!userState) {
+  const userState = await fetchEncodedAccount(rpc, userStatePDA);
+  if (!userState.exists) {
     return new Decimal(0);
   }
 
@@ -147,13 +143,19 @@ export async function getUserSharesInTokensStakedInFarm(
 }
 
 export async function setVaultIdForFarmIx(
-  connection: Connection,
-  farmAdmin: PublicKey,
-  farm: PublicKey,
-  vault: PublicKey
-): Promise<TransactionInstruction> {
-  const farmClient = new Farms(connection);
-  return farmClient.updateFarmConfigIx(farmAdmin, farm, PublicKey.default, new FarmConfigOption.UpdateVaultId(), vault);
+  rpc: Rpc<SolanaRpcApi>,
+  farmAdmin: TransactionSigner,
+  farm: Address,
+  vault: Address
+): Promise<IInstruction> {
+  const farmClient = new Farms(rpc);
+  return farmClient.updateFarmConfigIx(
+    farmAdmin,
+    farm,
+    DEFAULT_PUBLIC_KEY,
+    new FarmConfigOption.UpdateVaultId(),
+    vault
+  );
 }
 
 export function getSharesInFarmUserPosition(userState: UserState, tokenDecimals: number): Decimal {
@@ -161,11 +163,11 @@ export function getSharesInFarmUserPosition(userState: UserState, tokenDecimals:
 }
 
 export type SetupFarmIxsWithFarm = {
-  farm: Keypair;
-  setupFarmIxs: TransactionInstruction[];
+  farm: TransactionSigner;
+  setupFarmIxs: IInstruction[];
 };
 
 export type UnstakeAndWithdrawFromFarmIxs = {
-  unstakeIx: TransactionInstruction;
-  withdrawIx: TransactionInstruction;
+  unstakeIx: IInstruction;
+  withdrawIx: IInstruction;
 };

package/src/classes/jupiterPerps.ts

@@ -1,7 +1,7 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { Pool } from '../idl_codegen_jupiter_perps/accounts/Pool';
+import { Rpc, Address, GetAccountInfoApi } from '@solana/kit';
+import { Pool } from '../@codegen/jupiter_perps/accounts/Pool';
 
-export async function getJLPApr(connection: Connection, poolAddress: PublicKey): Promise<number> {
+export async function getJLPApr(connection: Rpc<GetAccountInfoApi>, poolAddress: Address): Promise<number> {
   const jlpPool = await Pool.fetch(connection, poolAddress);
 
   if (!jlpPool) {