@kamino-finance/klend-sdk 6.0.5-beta.5 → 6.0.5

package/src/utils/managerTypes.ts

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

package/src/utils/metadata.ts

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

package/src/utils/multisig.ts

@@ -1,26 +1,33 @@
-import { PublicKey } from '@solana/web3.js';
+import { Address } from '@solana/kit';
 
 const SQUADS_API_BASE_URL = 'https://4fnetmviidiqkjzenwxe66vgoa0soerr.lambda-url.us-east-1.on.aws';
 
-export async function walletIsSquadsMultisig(wallet: PublicKey) {
-  const response = await fetch(`${SQUADS_API_BASE_URL}/isSquad/${wallet.toBase58()}`);
+export async function walletIsSquadsMultisig(wallet: Address) {
+  const response = await fetch(`${SQUADS_API_BASE_URL}/isSquad/${wallet}`);
   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: PublicKey): Promise<{
+export async function getSquadsMultisigAdminsAndThreshold(wallet: Address): Promise<{
   adminsNumber: number;
   threshold: number;
 }> {
-  const response = await fetch(`${SQUADS_API_BASE_URL}/multisig/${wallet.toBase58()}`);
+  const response = await fetch(`${SQUADS_API_BASE_URL}/multisig/${wallet}`);
   const data = await response.json();
-  const squadsResponse = data as SquadsMultisigAccountResponse;
-  return {
-    adminsNumber: squadsResponse.keys.length,
-    threshold: squadsResponse.threshold,
-  };
+  try {
+    const squadsResponse = data as SquadsV4MultisigAccountResponse;
+    return {
+      adminsNumber: squadsResponse.account.members.length,
+      threshold: squadsResponse.account.threshold,
+    };
+  } catch (e) {
+    const squadsResponse = data as SquadsV3MultisigAccountResponse;
+    return {
+      adminsNumber: squadsResponse.keys.length,
+      threshold: squadsResponse.threshold,
+    };
+  }
 }
 
 // {"isSquad":true,"version":"v3"}
@@ -35,7 +42,25 @@ export interface WalletType {
   walletThreshold: number;
 }
 
-export type SquadsMultisigAccountResponse = {
+export type SquadsV4MultisigAccountResponse = {
+  account: {
+    bump: number;
+    configAuthority: string;
+    createKey: string;
+    members: number[][];
+    rentCollector: string;
+    staleTransactionIndex: string;
+    threshold: number;
+    timeLock: number;
+    total_signers: number;
+    transactionIndex: string;
+  };
+  address: string;
+  defaultVault: string;
+  metadata: { version: string };
+};
+
+export type SquadsV3MultisigAccountResponse = {
   allow_external_execute: boolean;
   authority_index: number;
   bump: number;

package/src/utils/option.ts

@@ -0,0 +1,9 @@
+import { Address, isNone, Option } from '@solana/kit';
+import { DEFAULT_PUBLIC_KEY } from './pubkey';
+
+export function defaultPubkeyIfNone(address: Option<Address>): Address {
+  if (isNone(address)) {
+    return DEFAULT_PUBLIC_KEY;
+  }
+  return address.value;
+}

package/src/utils/oracle.ts

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