@kamino-finance/klend-sdk 6.0.4 → 6.0.5-beta.1

package/src/utils/managerTypes.ts

@@ -1,4 +1,4 @@
-import { Address, TransactionSigner } from '@solana/kit';
+import { PublicKey } from '@solana/web3.js';
 import {
   BorrowRateCurve,
   BorrowRateCurveFields,
@@ -11,43 +11,42 @@ import {
   SwitchboardConfiguration,
   TokenInfo,
   WithdrawalCaps,
-} from '../@codegen/klend/types';
+} from '../idl_codegen/types';
 import Decimal from 'decimal.js';
 import { Fraction, ZERO_FRACTION } from '../classes/fraction';
 import BN from 'bn.js';
 import { numberToLamportsDecimal } from '../classes';
 import { NULL_PUBKEY } from './pubkey';
-import { U16_MAX } from '@kamino-finance/scope-sdk';
-import { OracleType } from '@kamino-finance/scope-sdk/dist/@codegen/scope/types';
+import { OracleType, U16_MAX } from '@kamino-finance/scope-sdk';
 import { LendingMarket } from '../lib';
 
 export type ScopeOracleConfig = {
-  scopePriceConfigAddress: Address;
+  scopePriceConfigAddress: PublicKey;
   name: string;
   oracleType: string;
   oracleId: number;
-  oracleAccount: Address;
+  oracleAccount: PublicKey;
   twapEnabled: boolean;
   twapSourceId: number;
   max_age: number;
 };
 
 export type CreateKaminoMarketParams = {
-  admin: TransactionSigner;
+  admin: PublicKey;
 };
 
 export type AddAssetToMarketParams = {
-  admin: TransactionSigner;
-  adminLiquiditySource: Address;
-  marketAddress: Address;
+  admin: PublicKey;
+  adminLiquiditySource: PublicKey;
+  marketAddress: PublicKey;
   assetConfig: AssetConfig;
 };
 
 export interface AssetConfig {
-  readonly mint: Address;
+  readonly mint: PublicKey;
   readonly tokenName: string;
   readonly mintDecimals: number;
-  readonly mintTokenProgram: Address;
+  readonly mintTokenProgram: PublicKey;
   assetReserveConfigParams: AssetReserveConfigParams;
 
   setAssetConfigParams(assetReserveConfigParams: AssetReserveConfigParams): void;
@@ -56,15 +55,15 @@ export interface AssetConfig {
 }
 
 export class AssetReserveConfig implements AssetConfig {
-  readonly mint: Address;
+  readonly mint: PublicKey;
   readonly tokenName: string;
   readonly mintDecimals: number;
-  readonly mintTokenProgram: Address;
+  readonly mintTokenProgram: PublicKey;
   assetReserveConfigParams: AssetReserveConfigParams;
 
   constructor(fields: {
-    mint: Address;
-    mintTokenProgram: Address;
+    mint: PublicKey;
+    mintTokenProgram: PublicKey;
     tokenName: string;
     mintDecimals: number;
     priceFeed: PriceFeed;
@@ -103,14 +102,14 @@ export class AssetReserveConfig implements AssetConfig {
 }
 
 export class AssetReserveConfigCli implements AssetConfig {
-  readonly mint: Address;
+  readonly mint: PublicKey;
   readonly tokenName: string;
   readonly mintDecimals: number;
-  readonly mintTokenProgram: Address;
+  readonly mintTokenProgram: PublicKey;
   private reserveConfig: ReserveConfig | undefined;
   assetReserveConfigParams: AssetReserveConfigParams;
 
-  constructor(mint: Address, mintTokenProgram: Address, reserveConfig: ReserveConfig) {
+  constructor(mint: PublicKey, mintTokenProgram: PublicKey, reserveConfig: ReserveConfig) {
     this.reserveConfig = reserveConfig;
     this.tokenName = '';
     this.mintDecimals = 0;
@@ -139,15 +138,15 @@ export class AssetReserveConfigCli implements AssetConfig {
 }
 
 export class CollateralConfig implements AssetConfig {
-  readonly mint: Address;
+  readonly mint: PublicKey;
   readonly tokenName: string;
   readonly mintDecimals: number;
-  readonly mintTokenProgram: Address;
+  readonly mintTokenProgram: PublicKey;
   assetReserveConfigParams: AssetReserveConfigParams;
 
   constructor(fields: {
-    mint: Address;
-    mintTokenProgram: Address;
+    mint: PublicKey;
+    mintTokenProgram: PublicKey;
     tokenName: string;
     mintDecimals: number;
     priceFeed: PriceFeed;
@@ -181,17 +180,17 @@ export class CollateralConfig implements AssetConfig {
 }
 
 export class DebtConfig implements AssetConfig {
-  readonly mint: Address;
+  readonly mint: PublicKey;
   readonly tokenName: string;
   readonly mintDecimals: number;
-  readonly mintTokenProgram: Address;
+  readonly mintTokenProgram: PublicKey;
   assetReserveConfigParams: AssetReserveConfigParams;
   borrowLimitOutsideElevationGroup?: Decimal;
   debtWithdrawalCapConfigCapacity?: Decimal;
 
   constructor(fields: {
-    mint: Address;
-    mintTokenProgram: Address;
+    mint: PublicKey;
+    mintTokenProgram: PublicKey;
     tokenName: string;
     mintDecimals: number;
     priceFeed: PriceFeed;
@@ -228,12 +227,12 @@ export class DebtConfig implements AssetConfig {
 }
 
 export type PriceFeed = {
-  scopePriceConfigAddress?: Address;
+  scopePriceConfigAddress?: PublicKey;
   scopeChain?: number[];
   scopeTwapChain?: number[];
-  pythPrice?: Address;
-  switchboardPrice?: Address;
-  switchboardTwapPrice?: Address;
+  pythPrice?: PublicKey;
+  switchboardPrice?: PublicKey;
+  switchboardTwapPrice?: PublicKey;
 };
 
 export type AssetReserveConfigParams = {
@@ -434,6 +433,6 @@ export function parseOracleType(type: number): string {
 }
 
 export type MarketWithAddress = {
-  address: Address;
+  address: PublicKey;
   state: LendingMarket;
 };

package/src/utils/metadata.ts

@@ -1,3 +1,4 @@
+import { Connection, PublicKey, SystemProgram, SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@solana/web3.js';
 import {
   getKVaultSharesMetadataPda,
   initializeSharesMetadata,
@@ -8,12 +9,9 @@ import {
   UpdateSharesMetadataAccounts,
   UpdateSharesMetadataArgs,
 } from '../lib';
-import { Address, IInstruction, TransactionSigner } from '@solana/kit';
-import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
-import { SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
 
 export function resolveMetadata(
-  kTokenMint: Address,
+  kTokenMint: PublicKey,
   extra: string,
   inputToken?: string,
   inputName?: string,
@@ -49,20 +47,21 @@ export function resolveMetadataFromToken(token: string, extra: string): { name:
   return { name, symbol };
 }
 
-export function resolveMetadataUriFromMint(mint: Address): string {
-  return `https://api.kamino.finance/kvault-tokens/${mint}/metadata`;
+export function resolveMetadataUriFromMint(mint: PublicKey): string {
+  return `https://api.kamino.finance/kvault-tokens/${mint.toBase58()}/metadata`;
 }
 
 export async function getInitializeKVaultSharesMetadataIx(
-  vaultAdmin: TransactionSigner,
-  vault: Address,
-  sharesMint: Address,
-  baseVaultAuthority: Address,
+  connection: Connection,
+  vaultAdmin: PublicKey,
+  vault: PublicKey,
+  sharesMint: PublicKey,
+  baseVaultAuthority: PublicKey,
   name: string,
   symbol: string,
   uri: string
-): Promise<IInstruction> {
-  const [sharesMintMetadata] = await getKVaultSharesMetadataPda(sharesMint);
+): Promise<TransactionInstruction> {
+  const [sharesMintMetadata] = getKVaultSharesMetadataPda(sharesMint);
 
   const args: InitializeSharesMetadataArgs = {
     name,
@@ -76,8 +75,8 @@ export async function getInitializeKVaultSharesMetadataIx(
     sharesMint,
     baseVaultAuthority,
     sharesMetadata: sharesMintMetadata,
-    systemProgram: SYSTEM_PROGRAM_ADDRESS,
-    rent: SYSVAR_RENT_ADDRESS,
+    systemProgram: SystemProgram.programId,
+    rent: SYSVAR_RENT_PUBKEY,
     metadataProgram: METADATA_PROGRAM_ID,
   };
 
@@ -86,15 +85,16 @@ export async function getInitializeKVaultSharesMetadataIx(
 }
 
 export async function getUpdateSharesMetadataIx(
-  vaultAdmin: TransactionSigner,
-  vault: Address,
-  sharesMint: Address,
-  baseVaultAuthority: Address,
+  connection: Connection,
+  vaultAdmin: PublicKey,
+  vault: PublicKey,
+  sharesMint: PublicKey,
+  baseVaultAuthority: PublicKey,
   name: string,
   symbol: string,
   uri: string
-): Promise<IInstruction> {
-  const [sharesMintMetadata] = await getKVaultSharesMetadataPda(sharesMint);
+): Promise<TransactionInstruction> {
+  const [sharesMintMetadata] = getKVaultSharesMetadataPda(sharesMint);
 
   const args: UpdateSharesMetadataArgs = {
     name,

package/src/utils/multisig.ts

@@ -1,20 +1,20 @@
-import { Address } from '@solana/kit';
+import { PublicKey } from '@solana/web3.js';
 
 const SQUADS_API_BASE_URL = 'https://4fnetmviidiqkjzenwxe66vgoa0soerr.lambda-url.us-east-1.on.aws';
 
-export async function walletIsSquadsMultisig(wallet: Address) {
-  const response = await fetch(`${SQUADS_API_BASE_URL}/isSquad/${wallet}`);
+export async function walletIsSquadsMultisig(wallet: PublicKey) {
+  const response = await fetch(`${SQUADS_API_BASE_URL}/isSquad/${wallet.toBase58()}`);
   const data = await response.json();
   const squadsResponse = data as SquadsMultisigResponse;
   return squadsResponse.isSquad;
 }
 
 // todo: find a way to get the admins number and threshold
-export async function getSquadsMultisigAdminsAndThreshold(wallet: Address): Promise<{
+export async function getSquadsMultisigAdminsAndThreshold(wallet: PublicKey): Promise<{
   adminsNumber: number;
   threshold: number;
 }> {
-  const response = await fetch(`${SQUADS_API_BASE_URL}/multisig/${wallet}`);
+  const response = await fetch(`${SQUADS_API_BASE_URL}/multisig/${wallet.toBase58()}`);
   const data = await response.json();
   const squadsResponse = data as SquadsMultisigAccountResponse;
   return {

package/src/utils/oracle.ts

@@ -1,17 +1,15 @@
-import { Account, address, Address, Base64EncodedDataResponse, GetMultipleAccountsApi, Rpc } from '@solana/kit';
+import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
 import Decimal from 'decimal.js';
-import { Scope } from '@kamino-finance/scope-sdk';
-import { OraclePrices } from '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/OraclePrices';
-import { isNotNullPubkey } from './pubkey';
+import { OraclePrices, Scope } from '@kamino-finance/scope-sdk';
+import { isNotNullPubkey, PubkeyHashMap, PublicKeySet } from './pubkey';
 import { parseTokenSymbol } from '../classes';
+import SwitchboardProgram from '@switchboard-xyz/sbv2-lite';
 import { Reserve } from '../lib';
 import { batchFetch } from '@kamino-finance/kliquidity-sdk';
 import BN from 'bn.js';
-import { priceUpdateV2 } from '../@codegen/pyth_rec/accounts/priceUpdateV2';
-import { AggregatorAccountData } from '../@codegen/switchboard_v2/accounts/AggregatorAccountData';
-import { Buffer } from 'buffer';
-import { getLatestAggregatorValue } from './switchboard';
-import { PROGRAM_ID as SWITCHBOARD_V2_PROGRAM_ID } from '../@codegen/switchboard_v2/programId';
+import { PriceUpdateV2 } from '../pyth/accounts';
+
+const SWITCHBOARD_V2_PROGRAM_ID = new PublicKey('SW1TCH7qEPTdLsDHRgPuMQjbQxKdH2aBStViMFnt64f');
 
 // validate price confidence - confidence/price ratio should be less than 2%
 export const MAX_CONFIDENCE_PERCENTAGE: Decimal = new Decimal('2');
@@ -20,11 +18,11 @@ export const MAX_CONFIDENCE_PERCENTAGE: Decimal = new Decimal('2');
 export const CONFIDENCE_FACTOR: Decimal = new Decimal('100').div(MAX_CONFIDENCE_PERCENTAGE);
 
 const getScopeAddress = () => {
-  return address('HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ');
+  return 'HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ';
 };
 
 export type TokenOracleData = {
-  mintAddress: Address;
+  mintAddress: PublicKey;
   decimals: Decimal;
   price: Decimal;
   timestamp: bigint;
@@ -42,11 +40,15 @@ export type ScopePriceRefreshConfig = {
   scopeFeed: string;
 };
 
-export function getTokenOracleDataSync(allOracleAccounts: AllOracleAccounts, reserves: Reserve[]) {
+export function getTokenOracleDataSync(
+  allOracleAccounts: AllOracleAccounts,
+  switchboardV2: SwitchboardProgram,
+  reserves: Reserve[]
+) {
   const tokenOracleDataForReserves: Array<[Reserve, TokenOracleData | undefined]> = [];
-  const pythCache = new Map<Address, PythPrices>();
-  const switchboardCache = new Map<Address, CandidatePrice>();
-  const scopeCache = new Map<Address, OraclePrices>();
+  const pythCache = new PubkeyHashMap<PublicKey, PythPrices>();
+  const switchboardCache = new PubkeyHashMap<PublicKey, CandidatePrice>();
+  const scopeCache = new PubkeyHashMap<PublicKey, OraclePrices>();
   for (const reserve of reserves) {
     let currentBest: CandidatePrice | undefined = undefined;
     const oracle = {
@@ -65,7 +67,8 @@ export function getTokenOracleDataSync(allOracleAccounts: AllOracleAccounts, res
       const switchboardPrice = cacheOrGetSwitchboardPrice(
         oracle.switchboardFeedAddress,
         switchboardCache,
-        allOracleAccounts
+        allOracleAccounts,
+        switchboardV2
       );
       if (switchboardPrice) {
         currentBest = getBestPrice(currentBest, switchboardPrice);
@@ -103,20 +106,18 @@ export function getTokenOracleDataSync(allOracleAccounts: AllOracleAccounts, res
 
 // TODO: Add freshness of the latest price to match sc logic
 export async function getTokenOracleData(
-  rpc: Rpc<GetMultipleAccountsApi>,
+  connection: Connection,
   reserves: Reserve[]
 ): Promise<Array<[Reserve, TokenOracleData | undefined]>> {
-  const allOracleAccounts = await getAllOracleAccounts(rpc, reserves);
-  return getTokenOracleDataSync(allOracleAccounts, reserves);
+  const allOracleAccounts = await getAllOracleAccounts(connection, reserves);
+  const switchboardV2 = await SwitchboardProgram.loadMainnet(connection);
+  return getTokenOracleDataSync(allOracleAccounts, switchboardV2, reserves);
 }
 
-export type AllOracleAccounts = Map<Address, Account<Base64EncodedDataResponse>>;
+export type AllOracleAccounts = PubkeyHashMap<PublicKey, AccountInfo<Buffer>>;
 
-export async function getAllOracleAccounts(
-  rpc: Rpc<GetMultipleAccountsApi>,
-  reserves: Reserve[]
-): Promise<AllOracleAccounts> {
-  const allAccounts: Address[] = [];
+export async function getAllOracleAccounts(connection: Connection, reserves: Reserve[]): Promise<AllOracleAccounts> {
+  const allAccounts: PublicKey[] = [];
   reserves.forEach((reserve) => {
     if (isNotNullPubkey(reserve.config.tokenInfo.pythConfiguration.price)) {
       allAccounts.push(reserve.config.tokenInfo.pythConfiguration.price);
@@ -132,21 +133,18 @@ export async function getAllOracleAccounts(
     }
   });
   const allAccountsDeduped = dedupKeys(allAccounts);
-  const allAccs = await batchFetch(
-    allAccountsDeduped,
-    async (chunk) => (await rpc.getMultipleAccounts(chunk).send()).value
-  );
-  const allAccsMap = new Map<Address, Account<Base64EncodedDataResponse>>();
+  const allAccs = await batchFetch(allAccountsDeduped, (chunk) => connection.getMultipleAccountsInfo(chunk));
+  const allAccsMap = new PubkeyHashMap<PublicKey, AccountInfo<Buffer>>();
   allAccs.forEach((acc, i) => {
-    if (acc !== null) {
-      allAccsMap.set(allAccountsDeduped[i], { ...acc, programAddress: acc.owner, address: allAccountsDeduped[i] });
+    if (acc) {
+      allAccsMap.set(allAccountsDeduped[i], acc);
     }
   });
   return allAccsMap;
 }
 
-function dedupKeys(keys: Address[]): Address[] {
-  return [...new Set<Address>(keys)];
+function dedupKeys(keys: PublicKey[]): PublicKey[] {
+  return new PublicKeySet(keys).toArray();
 }
 
 export type PythPrices = {
@@ -161,8 +159,8 @@ export type PythPrices = {
  * @param oracleAccounts all oracle accounts
  */
 export function cacheOrGetPythPrices(
-  oracle: Address,
-  cache: Map<Address, PythPrices>,
+  oracle: PublicKey,
+  cache: Map<PublicKey, PythPrices>,
   oracleAccounts: AllOracleAccounts
 ): PythPrices | null {
   const prices: PythPrices = {};
@@ -173,7 +171,7 @@ export function cacheOrGetPythPrices(
     const result = oracleAccounts.get(oracle);
     if (result) {
       try {
-        const { priceMessage } = priceUpdateV2.decode(Buffer.from(result.data[0], 'base64'));
+        const { priceMessage } = PriceUpdateV2.decode(result.data);
         const { price, exponent, conf: confidence, publishTime: timestamp, emaPrice } = priceMessage;
         if (price) {
           const px = new Decimal(price.toString()).div(10 ** Math.abs(exponent));
@@ -211,11 +209,13 @@ export function cacheOrGetPythPrices(
  * @param oracle oracle address
  * @param switchboardCache cache for oracle prices
  * @param oracleAccounts all oracle accounts
+ * @param switchboardV2 loaded switchboard program
  */
 export function cacheOrGetSwitchboardPrice(
-  oracle: Address,
-  switchboardCache: Map<Address, CandidatePrice>,
-  oracleAccounts: AllOracleAccounts
+  oracle: PublicKey,
+  switchboardCache: Map<PublicKey, CandidatePrice>,
+  oracleAccounts: AllOracleAccounts,
+  switchboardV2: SwitchboardProgram
 ): CandidatePrice | null {
   const cached = switchboardCache.get(oracle);
   if (cached) {
@@ -223,9 +223,10 @@ export function cacheOrGetSwitchboardPrice(
   } else {
     const info = oracleAccounts.get(oracle);
     if (info) {
-      if (info.programAddress === SWITCHBOARD_V2_PROGRAM_ID) {
-        const agg = AggregatorAccountData.decode(Buffer.from(info.data[0], 'base64'));
-        const result = getLatestAggregatorValue(agg);
+      if (info.owner.equals(SWITCHBOARD_V2_PROGRAM_ID)) {
+        const agg = switchboardV2.decodeAggregator(info!);
+        // @ts-ignore
+        const result: Big.Big | null = switchboardV2.getLatestAggregatorValue(agg);
         if (result !== undefined && result !== null) {
           const switchboardPx = new Decimal(result.toString());
           const latestRoundTimestamp: BN = agg.latestConfirmedRound.roundOpenTimestamp;
@@ -238,7 +239,7 @@ export function cacheOrGetSwitchboardPrice(
           };
         }
       } else {
-        console.error('Unrecognized switchboard owner address: ', info.programAddress);
+        console.error('Unrecognized switchboard owner address: ', info.owner.toString());
         return null;
       }
     }
@@ -254,8 +255,8 @@ export function cacheOrGetSwitchboardPrice(
  * @param chain scope chain
  */
 export function cacheOrGetScopePrice(
-  oracle: Address,
-  scopeCache: Map<Address, OraclePrices>,
+  oracle: PublicKey,
+  scopeCache: Map<PublicKey, OraclePrices>,
   allOracleAccounts: AllOracleAccounts,
   chain: number[]
 ): CandidatePrice | null {
@@ -269,9 +270,9 @@ export function cacheOrGetScopePrice(
   }
   const info = allOracleAccounts.get(oracle);
   if (info) {
-    const owner = info.programAddress;
+    const owner = info.owner.toString();
     if (owner === getScopeAddress()) {
-      const prices = OraclePrices.decode(Buffer.from(info.data[0], 'base64'));
+      const prices = OraclePrices.decode(info.data);
       scopeCache.set(oracle, prices);
       return scopeChainToCandidatePrice(chain, prices);
     } else {
@@ -307,7 +308,7 @@ function validatePythPx(price: Decimal, confidence: Decimal): boolean {
   return !price.isZero() && price.gt(conf50x);
 }
 
-function validateSwitchboardV2Px(agg: AggregatorAccountData): boolean {
+function validateSwitchboardV2Px(agg: any): boolean {
   const pxMantissa = new Decimal(agg.latestConfirmedRound.result.mantissa.toString());
   const pxScale = new Decimal(agg.latestConfirmedRound.result.scale.toString());
   const stDevMantissa = new Decimal(agg.latestConfirmedRound.stdDeviation.mantissa.toString());