@kamino-finance/klend-sdk 6.0.3 → 6.0.5-beta.0

package/src/classes/market.ts

@@ -1,125 +1,111 @@
-import {
-  Address,
-  address,
-  Base58EncodedBytes,
-  Commitment,
-  GetAccountInfoApi,
-  GetBalanceApi,
-  getBase58Decoder,
-  GetMinimumBalanceForRentExemptionApi,
-  GetMultipleAccountsApi,
-  GetProgramAccountsApi,
-  GetProgramAccountsDatasizeFilter,
-  GetProgramAccountsMemcmpFilter,
-  GetSlotApi,
-  GetTokenAccountBalanceApi,
-  Rpc,
-  Slot,
-} from '@solana/kit';
+import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
 import { KaminoObligation } from './obligation';
-import { KaminoReserve, KaminoReserveRpcApi } from './reserve';
-import { LendingMarket, Obligation, ReferrerTokenState, Reserve, UserMetadata } from '../@codegen/klend/accounts';
+import { KaminoReserve } from './reserve';
+import { LendingMarket, Obligation, UserMetadata, ReferrerTokenState, Reserve } from '../idl_codegen/accounts';
 import {
-  cacheOrGetPythPrices,
-  cacheOrGetScopePrice,
-  cacheOrGetSwitchboardPrice,
-  CandidatePrice,
-  DEFAULT_PUBLIC_KEY,
-  DEPOSITS_LIMIT,
-  getAllOracleAccounts,
-  getProgramAccounts,
-  getTokenOracleData,
-  isNotNullPubkey,
   lendingMarketAuthPda,
-  LendingObligation,
-  LeverageObligation,
-  MultiplyObligation,
   ObligationType,
-  PythPrices,
   referrerTokenStatePda,
   userMetadataPda,
+  getTokenOracleData,
   VanillaObligation,
+  LendingObligation,
+  MultiplyObligation,
+  LeverageObligation,
+  isNotNullPubkey,
+  getAllOracleAccounts,
+  PythPrices,
+  cacheOrGetScopePrice,
+  cacheOrGetPythPrices,
+  cacheOrGetSwitchboardPrice,
+  PubkeyHashMap,
+  CandidatePrice,
+  PublicKeySet,
+  DEPOSITS_LIMIT,
 } from '../utils';
-import BN from 'bn.js';
+import base58 from 'bs58';
+import { BN } from '@coral-xyz/anchor';
 import Decimal from 'decimal.js';
 import { FarmState } from '@kamino-finance/farms-sdk';
-import { PROGRAM_ID } from '../@codegen/klend/programId';
-import { Scope, U16_MAX } from '@kamino-finance/scope-sdk';
-import { OraclePrices } from '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/OraclePrices';
+import { PROGRAM_ID } from '../idl_codegen/programId';
+import bs58 from 'bs58';
+import { OraclePrices, Scope, U16_MAX } from '@kamino-finance/scope-sdk';
 import { Fraction } from './fraction';
 import { chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
 import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
-import { ObligationZP } from '../@codegen/klend/zero_padding';
+import SwitchboardProgram from '@switchboard-xyz/sbv2-lite';
+import { ObligationZP } from '../idl_codegen/zero_padding';
+import { getProgramAccounts } from '../utils';
 import { checkDefined } from '../utils/validations';
-import { Buffer } from 'buffer';
-
-export type KaminoMarketRpcApi = GetAccountInfoApi &
-  GetMultipleAccountsApi &
-  GetProgramAccountsApi &
-  GetSlotApi &
-  GetMinimumBalanceForRentExemptionApi &
-  GetTokenAccountBalanceApi &
-  GetBalanceApi;
-
-const base58Decoder = getBase58Decoder();
 
 export interface ReserveRewardInfo {
   rewardsPerSecond: Decimal; // not lamport
   rewardsRemaining: Decimal; // not lamport
   rewardApr: Decimal;
-  rewardMint: Address;
+  rewardMint: PublicKey;
   totalInvestmentUsd: Decimal;
   rewardPrice: number;
 }
 
 export class KaminoMarket {
-  private readonly rpc: Rpc<KaminoMarketRpcApi>;
+  private readonly connection: Connection;
 
-  readonly address: Address;
+  readonly address: string;
 
   state: LendingMarket;
 
-  reserves: Map<Address, KaminoReserve>;
+  reserves: Map<PublicKey, KaminoReserve>;
 
-  reservesActive: Map<Address, KaminoReserve>;
+  reservesActive: Map<PublicKey, KaminoReserve>;
 
-  readonly programId: Address;
+  readonly programId: PublicKey;
 
   private readonly recentSlotDurationMs: number;
 
+  // key = scope feed (oracle prices) pubkey
+  // value = reserve pubkey
+  private readonly reserveScopeFeeds: PubkeyHashMap<PublicKey, PublicKey>;
+
   private constructor(
-    rpc: Rpc<KaminoMarketRpcApi>,
+    connection: Connection,
     state: LendingMarket,
-    marketAddress: Address,
-    reserves: Map<Address, KaminoReserve>,
+    marketAddress: string,
+    reserves: Map<PublicKey, KaminoReserve>,
     recentSlotDurationMs: number,
-    programId: Address = PROGRAM_ID
+    programId: PublicKey = PROGRAM_ID
   ) {
     this.address = marketAddress;
-    this.rpc = rpc;
+    this.connection = connection;
     this.state = state;
     this.reserves = reserves;
     this.reservesActive = getReservesActive(this.reserves);
     this.programId = programId;
     this.recentSlotDurationMs = recentSlotDurationMs;
+    this.reserveScopeFeeds = new PubkeyHashMap(
+      Array.from(this.reserves.values())
+        .filter((r) => isNotNullPubkey(r.state.config.tokenInfo.scopeConfiguration.priceFeed))
+        .map((r) => [r.address, r.state.config.tokenInfo.scopeConfiguration.priceFeed])
+    );
   }
 
   /**
    * Load a new market with all of its associated reserves
-   * @param rpc
+   * @param connection
    * @param marketAddress
    * @param recentSlotDurationMs
    * @param programId
    * @param withReserves
+   * @param setupLocalTest
+   * @param withReserves
    */
   static async load(
-    rpc: Rpc<KaminoMarketRpcApi>,
-    marketAddress: Address,
+    connection: Connection,
+    marketAddress: PublicKey,
     recentSlotDurationMs: number,
-    programId: Address = PROGRAM_ID,
+    programId: PublicKey = PROGRAM_ID,
     withReserves: boolean = true
   ) {
-    const market = await LendingMarket.fetch(rpc, marketAddress, programId);
+    const market = await LendingMarket.fetch(connection, marketAddress, programId);
 
     if (market === null) {
       return null;
@@ -130,36 +116,41 @@ export class KaminoMarket {
     }
 
     const reserves = withReserves
-      ? await getReservesForMarket(marketAddress, rpc, programId, recentSlotDurationMs)
-      : new Map<Address, KaminoReserve>();
+      ? await getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs)
+      : new Map<PublicKey, KaminoReserve>();
 
-    return new KaminoMarket(rpc, market, marketAddress, reserves, recentSlotDurationMs, programId);
+    return new KaminoMarket(connection, market, marketAddress.toString(), reserves, recentSlotDurationMs, programId);
   }
 
   static loadWithReserves(
-    connection: Rpc<KaminoMarketRpcApi>,
+    connection: Connection,
     market: LendingMarket,
-    reserves: Map<Address, KaminoReserve>,
-    marketAddress: Address,
+    reserves: Map<PublicKey, KaminoReserve>,
+    marketAddress: PublicKey,
     recentSlotDurationMs: number,
-    programId: Address = PROGRAM_ID
+    programId: PublicKey = PROGRAM_ID
   ) {
-    return new KaminoMarket(connection, market, marketAddress, reserves, recentSlotDurationMs, programId);
+    return new KaminoMarket(connection, market, marketAddress.toString(), reserves, recentSlotDurationMs, programId);
   }
 
   async reload(): Promise<void> {
-    const market = await LendingMarket.fetch(this.rpc, this.getAddress(), this.programId);
+    const market = await LendingMarket.fetch(this.connection, this.getAddress(), this.programId);
     if (market === null) {
       return;
     }
 
     this.state = market;
-    this.reserves = await getReservesForMarket(this.getAddress(), this.rpc, this.programId, this.recentSlotDurationMs);
+    this.reserves = await getReservesForMarket(
+      this.getAddress(),
+      this.connection,
+      this.programId,
+      this.recentSlotDurationMs
+    );
     this.reservesActive = getReservesActive(this.reserves);
   }
 
-  async reloadSingleReserve(reservePk: Address, reserveData?: Reserve): Promise<void> {
-    const reserve = await getSingleReserve(reservePk, this.rpc, this.recentSlotDurationMs, reserveData);
+  async reloadSingleReserve(reservePk: PublicKey, accountData?: AccountInfo<Buffer>): Promise<void> {
+    const reserve = await getSingleReserve(reservePk, this.connection, this.recentSlotDurationMs, accountData);
     this.reserves.set(reservePk, reserve);
     this.reservesActive.set(reservePk, reserve);
   }
@@ -168,8 +159,8 @@ export class KaminoMarket {
    * Get the address of this market
    * @return market address public key
    */
-  getAddress(): Address {
-    return this.address;
+  getAddress(): PublicKey {
+    return new PublicKey(this.address);
   }
 
   /**
@@ -208,20 +199,28 @@ export class KaminoMarket {
    * Get the authority PDA of this market
    * @return market authority public key
    */
-  async getLendingMarketAuthority(): Promise<Address> {
-    return (await lendingMarketAuthPda(this.getAddress(), this.programId))[0];
+  getLendingMarketAuthority(): PublicKey {
+    return lendingMarketAuthPda(this.getAddress(), this.programId)[0];
   }
 
   getName(): string {
     return parseZeroPaddedUtf8(this.state.name);
   }
 
-  async getObligationDepositByWallet(owner: Address, mint: Address, obligationType: ObligationType): Promise<Decimal> {
+  async getObligationDepositByWallet(
+    owner: PublicKey,
+    mint: PublicKey,
+    obligationType: ObligationType
+  ): Promise<Decimal> {
     const obligation = await this.getObligationByWallet(owner, obligationType);
     return obligation?.getDepositByMint(mint)?.amount ?? new Decimal(0);
   }
 
-  async getObligationBorrowByWallet(owner: Address, mint: Address, obligationType: ObligationType): Promise<Decimal> {
+  async getObligationBorrowByWallet(
+    owner: PublicKey,
+    mint: PublicKey,
+    obligationType: ObligationType
+  ): Promise<Decimal> {
     const obligation = await this.getObligationByWallet(owner, obligationType);
     return obligation?.getBorrowByMint(mint)?.amount ?? new Decimal(0);
   }
@@ -242,7 +241,7 @@ export class KaminoMarket {
     return tvl;
   }
 
-  getMaxLeverageForPair(collTokenMint: Address, debtTokenMint: Address): number {
+  getMaxLeverageForPair(collTokenMint: PublicKey, debtTokenMint: PublicKey): number {
     const { maxLtv: maxCollateralLtv, borrowFactor } = this.getMaxAndLiquidationLtvAndBorrowFactorForPair(
       collTokenMint,
       debtTokenMint
@@ -265,13 +264,13 @@ export class KaminoMarket {
         item !== 0 &&
         this.state.elevationGroups[item - 1].allowNewLoans !== 0 &&
         collReserve.state.config.borrowLimitAgainstThisCollateralInElevationGroup[item - 1].gt(new BN(0)) &&
-        this.state.elevationGroups[item - 1].debtReserve === debtReserve.address
+        this.state.elevationGroups[item - 1].debtReserve.equals(debtReserve.address)
     );
   }
 
   getMaxAndLiquidationLtvAndBorrowFactorForPair(
-    collTokenMint: Address,
-    debtTokenMint: Address
+    collTokenMint: PublicKey,
+    debtTokenMint: PublicKey
   ): { maxLtv: number; liquidationLtv: number; borrowFactor: number } {
     const collReserve: KaminoReserve | undefined = this.getReserveByMint(collTokenMint);
     const debtReserve: KaminoReserve | undefined = this.getReserveByMint(debtTokenMint);
@@ -362,12 +361,12 @@ export class KaminoMarket {
       .reduce((acc, _obligation) => acc + 1, 0);
   }
 
-  async getObligationByWallet(Address: Address, obligationType: ObligationType): Promise<KaminoObligation | null> {
+  async getObligationByWallet(publicKey: PublicKey, obligationType: ObligationType): Promise<KaminoObligation | null> {
     const { address } = this;
     if (!address) {
       throw Error('Market must be initialized to call initialize.');
     }
-    const obligationAddress = await obligationType.toPda(this.getAddress(), Address);
+    const obligationAddress = obligationType.toPda(this.getAddress(), publicKey);
     return KaminoObligation.load(this, obligationAddress);
   }
 
@@ -377,7 +376,7 @@ export class KaminoMarket {
   async getMaxLeverageBorrowableAmount(
     collReserve: KaminoReserve,
     debtReserve: KaminoReserve,
-    slot: Slot,
+    slot: number,
     requestElevationGroup: boolean,
     obligation?: KaminoObligation
   ): Promise<Decimal> {
@@ -388,31 +387,30 @@ export class KaminoMarket {
 
   async loadReserves() {
     const addresses = [...this.reserves.keys()];
-    const reserveAccounts = await this.rpc
-      .getMultipleAccounts(addresses, { commitment: 'processed', encoding: 'base64' })
-      .send();
-    const deserializedReserves = reserveAccounts.value.map((reserve, i) => {
+    const reserveAccounts = await this.connection.getMultipleAccountsInfo(addresses, 'processed');
+    const deserializedReserves = reserveAccounts.map((reserve, i) => {
       if (reserve === null) {
         // maybe reuse old here
-        throw new Error(`Reserve account ${addresses[i]} was not found`);
+        throw new Error(`Reserve account ${addresses[i].toBase58()} was not found`);
       }
-      const reserveAccount = Reserve.decode(Buffer.from(reserve.data[0], 'base64'));
+      const reserveAccount = Reserve.decode(reserve.data);
       if (!reserveAccount) {
-        throw Error(`Could not parse reserve ${addresses[i]}`);
+        throw Error(`Could not parse reserve ${addresses[i].toBase58()}`);
       }
       return reserveAccount;
     });
-    const reservesAndOracles = await getTokenOracleData(this.getRpc(), deserializedReserves);
-    const kaminoReserves = new Map<Address, KaminoReserve>();
+    const reservesAndOracles = await getTokenOracleData(this.connection, deserializedReserves);
+    const kaminoReserves = new PubkeyHashMap<PublicKey, KaminoReserve>();
     reservesAndOracles.forEach(([reserve, oracle], index) => {
       if (!oracle) {
         throw Error(`Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} reserve`);
       }
       const kaminoReserve = KaminoReserve.initialize(
+        reserveAccounts[index]!,
         addresses[index],
         reserve,
         oracle,
-        this.rpc,
+        this.connection,
         this.recentSlotDurationMs
       );
       kaminoReserves.set(kaminoReserve.address, kaminoReserve);
@@ -431,7 +429,7 @@ export class KaminoMarket {
     this.reservesActive = getReservesActive(this.reserves);
   }
 
-  getReserveByAddress(address: Address) {
+  getReserveByAddress(address: PublicKey) {
     return this.reserves.get(address);
   }
 
@@ -439,13 +437,13 @@ export class KaminoMarket {
    * Returns this market's reserve of the given address, or throws an error (including the given description) if such
    * reserve does not exist.
    */
-  getExistingReserveByAddress(address: Address, description: string = 'Requested'): KaminoReserve {
+  getExistingReserveByAddress(address: PublicKey, description: string = 'Requested'): KaminoReserve {
     return checkDefined(this.getReserveByAddress(address), `${description} reserve ${address} not found`);
   }
 
-  getReserveByMint(address: Address): KaminoReserve | undefined {
+  getReserveByMint(address: PublicKey): KaminoReserve | undefined {
     for (const reserve of this.reserves.values()) {
-      if (reserve.getLiquidityMint() === address) {
+      if (reserve.getLiquidityMint().equals(address)) {
         return reserve;
       }
     }
@@ -456,7 +454,7 @@ export class KaminoMarket {
    * Returns this market's reserve of the given mint address, or throws an error (including the given description) if
    * such reserve does not exist.
    */
-  getExistingReserveByMint(address: Address, description: string = 'Requested'): KaminoReserve {
+  getExistingReserveByMint(address: PublicKey, description: string = 'Requested'): KaminoReserve {
     return checkDefined(this.getReserveByMint(address), `${description} reserve with mint ${address} not found`);
   }
 
@@ -482,8 +480,8 @@ export class KaminoMarket {
   }
 
   async getReserveFarmInfo(
-    mint: Address,
-    getRewardPrice: (mint: Address) => Promise<number>
+    mint: PublicKey,
+    getRewardPrice: (mint: PublicKey) => Promise<number>
   ): Promise<{ borrowingRewards: ReserveRewardInfo; depositingRewards: ReserveRewardInfo }> {
     const { address } = this;
     if (!address) {
@@ -514,7 +512,7 @@ export class KaminoMarket {
         rewardsPerSecond: new Decimal(0),
         rewardsRemaining: new Decimal(0),
         rewardApr: new Decimal(0),
-        rewardMint: DEFAULT_PUBLIC_KEY,
+        rewardMint: PublicKey.default,
         totalInvestmentUsd: new Decimal(0),
         rewardPrice: 0,
       },
@@ -522,7 +520,7 @@ export class KaminoMarket {
         rewardsPerSecond: new Decimal(0),
         rewardsRemaining: new Decimal(0),
         rewardApr: new Decimal(0),
-        rewardMint: DEFAULT_PUBLIC_KEY,
+        rewardMint: PublicKey.default,
         totalInvestmentUsd: new Decimal(0),
         rewardPrice: 0,
       },
@@ -544,11 +542,11 @@ export class KaminoMarket {
   }
 
   async getRewardInfoForFarm(
-    farmAddress: Address,
+    farmAddress: PublicKey,
     totalInvestmentUsd: Decimal,
-    getRewardPrice: (mint: Address) => Promise<number>
+    getRewardPrice: (mint: PublicKey) => Promise<number>
   ): Promise<ReserveRewardInfo> {
-    const farmState = await FarmState.fetch(this.getRpc(), farmAddress);
+    const farmState = await FarmState.fetch(this.connection, farmAddress);
     if (!farmState) {
       throw Error(`Could not parse farm state. ${farmAddress}`);
     }
@@ -595,15 +593,14 @@ export class KaminoMarket {
    * @param tag
    */
   async getAllObligationsForMarket(tag?: number): Promise<KaminoObligation[]> {
-    const filters: (GetProgramAccountsDatasizeFilter | GetProgramAccountsMemcmpFilter)[] = [
+    const filters = [
       {
-        dataSize: BigInt(Obligation.layout.span + 8),
+        dataSize: Obligation.layout.span + 8,
       },
       {
         memcmp: {
-          offset: 32n,
-          bytes: this.address.toString() as Base58EncodedBytes,
-          encoding: 'base58',
+          offset: 32,
+          bytes: this.address,
         },
       },
     ];
@@ -611,33 +608,30 @@ export class KaminoMarket {
     if (tag !== undefined) {
       filters.push({
         memcmp: {
-          offset: 8n,
-          bytes: base58Decoder.decode(new BN(tag).toBuffer()) as Base58EncodedBytes,
-          encoding: 'base58',
+          offset: 8,
+          bytes: base58.encode(new BN(tag).toBuffer()),
         },
       });
     }
 
-    const collateralExchangeRates = new Map<Address, Decimal>();
-    const cumulativeBorrowRates = new Map<Address, Decimal>();
+    const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
+    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
 
     const [slot, obligations] = await Promise.all([
-      this.rpc.getSlot().send(),
-      getProgramAccounts(
-        this.rpc,
-        this.programId,
-        ObligationZP.layout.span + 8,
+      this.connection.getSlot(),
+      getProgramAccounts(this.connection, this.programId, ObligationZP.layout.span + 8, {
+        commitment: this.connection.commitment ?? 'processed',
         filters,
-        { offset: 0, length: ObligationZP.layout.span + 8 } // truncate the padding
-      ),
+        dataSlice: { offset: 0, length: ObligationZP.layout.span + 8 }, // truncate the padding
+      }),
     ]);
 
     return obligations.map((obligation) => {
-      if (obligation.data === null) {
+      if (obligation.account === null) {
         throw new Error('Invalid account');
       }
 
-      const obligationAccount = ObligationZP.decode(obligation.data);
+      const obligationAccount = ObligationZP.decode(obligation.account.data);
       if (!obligationAccount) {
         throw Error('Could not parse obligation.');
       }
@@ -651,7 +645,7 @@ export class KaminoMarket {
       );
       return new KaminoObligation(
         this,
-        obligation.address,
+        obligation.pubkey,
         obligationAccount,
         collateralExchangeRates,
         cumulativeBorrowRates
@@ -669,15 +663,14 @@ export class KaminoMarket {
    * }
    */
   async *batchGetAllObligationsForMarket(tag?: number): AsyncGenerator<KaminoObligation[], void, unknown> {
-    const filters: (GetProgramAccountsDatasizeFilter | GetProgramAccountsMemcmpFilter)[] = [
+    const filters = [
       {
-        dataSize: BigInt(Obligation.layout.span + 8),
+        dataSize: Obligation.layout.span + 8,
       },
       {
         memcmp: {
-          offset: 32n,
-          bytes: this.address.toString() as Base58EncodedBytes,
-          encoding: 'base58',
+          offset: 32,
+          bytes: this.address,
         },
       },
     ];
@@ -685,41 +678,37 @@ export class KaminoMarket {
     if (tag !== undefined) {
       filters.push({
         memcmp: {
-          offset: 8n,
-          bytes: base58Decoder.decode(new BN(tag).toBuffer()) as Base58EncodedBytes,
-          encoding: 'base58',
+          offset: 8,
+          bytes: base58.encode(new BN(tag).toBuffer()),
         },
       });
     }
 
-    const collateralExchangeRates = new Map<Address, Decimal>();
-    const cumulativeBorrowRates = new Map<Address, Decimal>();
+    const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
+    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
 
     const [obligationPubkeys, slot] = await Promise.all([
-      this.rpc
-        .getProgramAccounts(this.programId, {
-          filters,
-          encoding: 'base64',
-          dataSlice: { offset: 0, length: 0 },
-        })
-        .send(),
-      this.rpc.getSlot().send(),
+      this.connection.getProgramAccounts(this.programId, {
+        filters,
+        dataSlice: { offset: 0, length: 0 },
+      }),
+      this.connection.getSlot(),
     ]);
 
     for (const batch of chunks(
       obligationPubkeys.map((x) => x.pubkey),
       100
     )) {
-      const obligationAccounts = await this.rpc.getMultipleAccounts(batch, { encoding: 'base64' }).send();
+      const obligationAccounts = await this.connection.getMultipleAccountsInfo(batch);
       const obligationsBatch: KaminoObligation[] = [];
-      for (let i = 0; i < obligationAccounts.value.length; i++) {
-        const obligation = obligationAccounts.value[i];
+      for (let i = 0; i < obligationAccounts.length; i++) {
+        const obligation = obligationAccounts[i];
         const pubkey = batch[i];
         if (obligation === null) {
           continue;
         }
 
-        const obligationAccount = Obligation.decode(Buffer.from(obligation.data[0], 'base64'));
+        const obligationAccount = Obligation.decode(obligation.data);
 
         if (!obligationAccount) {
           throw Error(`Could not decode obligation ${pubkey.toString()}`);
@@ -740,46 +729,41 @@ export class KaminoMarket {
     }
   }
 
-  async getAllObligationsByTag(tag: number, market: Address) {
+  async getAllObligationsByTag(tag: number, market: PublicKey) {
     const [slot, obligations] = await Promise.all([
-      this.rpc.getSlot().send(),
-      this.rpc
-        .getProgramAccounts(this.programId, {
-          filters: [
-            {
-              dataSize: BigInt(Obligation.layout.span + 8),
-            },
-            {
-              memcmp: {
-                offset: 8n,
-                bytes: base58Decoder.decode(new BN(tag).toBuffer()) as Base58EncodedBytes,
-                encoding: 'base58',
-              },
+      this.connection.getSlot(),
+      this.connection.getProgramAccounts(this.programId, {
+        filters: [
+          {
+            dataSize: Obligation.layout.span + 8,
+          },
+          {
+            memcmp: {
+              offset: 8,
+              bytes: base58.encode(new BN(tag).toBuffer()),
             },
-            {
-              memcmp: {
-                offset: 32n,
-                bytes: market.toString() as Base58EncodedBytes,
-                encoding: 'base58',
-              },
+          },
+          {
+            memcmp: {
+              offset: 32,
+              bytes: market.toBase58(),
             },
-          ],
-          encoding: 'base64',
-        })
-        .send(),
+          },
+        ],
+      }),
     ]);
-    const collateralExchangeRates = new Map<Address, Decimal>();
-    const cumulativeBorrowRates = new Map<Address, Decimal>();
+    const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
+    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
 
     return obligations.map((obligation) => {
       if (obligation.account === null) {
         throw new Error('Invalid account');
       }
-      if (obligation.account.owner !== this.programId) {
+      if (!obligation.account.owner.equals(this.programId)) {
         throw new Error("account doesn't belong to this program");
       }
 
-      const obligationAccount = Obligation.decode(Buffer.from(obligation.account.data[0], 'base64'));
+      const obligationAccount = Obligation.decode(obligation.account.data);
 
       if (!obligationAccount) {
         throw Error('Could not parse obligation.');
@@ -803,49 +787,44 @@ export class KaminoMarket {
     });
   }
 
-  async getAllObligationsByDepositedReserve(reserve: Address) {
+  async getAllObligationsByDepositedReserve(reserve: PublicKey) {
     const finalObligations: KaminoObligation[] = [];
     for (let i = 0; i < DEPOSITS_LIMIT; i++) {
       const [slot, obligations] = await Promise.all([
-        this.rpc.getSlot().send(),
-        this.rpc
-          .getProgramAccounts(this.programId, {
-            filters: [
-              {
-                dataSize: BigInt(Obligation.layout.span + 8),
-              },
-              {
-                memcmp: {
-                  offset: 96n + 136n * BigInt(i),
-                  bytes: reserve.toString() as Base58EncodedBytes,
-                  encoding: 'base58',
-                },
+        this.connection.getSlot(),
+        this.connection.getProgramAccounts(this.programId, {
+          filters: [
+            {
+              dataSize: Obligation.layout.span + 8,
+            },
+            {
+              memcmp: {
+                offset: 96 + 136 * i,
+                bytes: reserve.toBase58(),
               },
-              {
-                memcmp: {
-                  offset: 32n,
-                  bytes: this.address.toString() as Base58EncodedBytes,
-                  encoding: 'base58',
-                },
+            },
+            {
+              memcmp: {
+                offset: 32,
+                bytes: this.address,
               },
-            ],
-            encoding: 'base64',
-          })
-          .send(),
+            },
+          ],
+        }),
       ]);
 
-      const collateralExchangeRates = new Map<Address, Decimal>();
-      const cumulativeBorrowRates = new Map<Address, Decimal>();
+      const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
+      const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
 
       const obligationsBatch = obligations.map((obligation) => {
         if (obligation.account === null) {
           throw new Error('Invalid account');
         }
-        if (obligation.account.owner !== this.programId) {
+        if (!obligation.account.owner.equals(this.programId)) {
           throw new Error("account doesn't belong to this program");
         }
 
-        const obligationAccount = Obligation.decode(Buffer.from(obligation.account.data[0], 'base64'));
+        const obligationAccount = Obligation.decode(obligation.account.data);
 
         if (!obligationAccount) {
           throw Error('Could not parse obligation.');
@@ -872,51 +851,48 @@ export class KaminoMarket {
     return finalObligations;
   }
 
-  async getAllUserObligations(user: Address, commitment: Commitment = 'processed'): Promise<KaminoObligation[]> {
+  async getAllUserObligations(user: PublicKey, commitment = this.connection.commitment): Promise<KaminoObligation[]> {
     const [currentSlot, obligations] = await Promise.all([
-      this.rpc.getSlot().send(),
-      this.rpc
-        .getProgramAccounts(this.programId, {
-          filters: [
-            {
-              dataSize: BigInt(Obligation.layout.span + 8),
-            },
-            {
-              memcmp: {
-                offset: 0n,
-                bytes: base58Decoder.decode(Obligation.discriminator) as Base58EncodedBytes,
-                encoding: 'base58',
-              },
+      this.connection.getSlot(),
+      this.connection.getProgramAccounts(this.programId, {
+        filters: [
+          {
+            dataSize: Obligation.layout.span + 8,
+          },
+          {
+            memcmp: {
+              offset: 0,
+              bytes: bs58.encode(Obligation.discriminator),
             },
-            {
-              memcmp: {
-                offset: 64n,
-                bytes: user.toString() as Base58EncodedBytes,
-                encoding: 'base58',
-              },
+          },
+          {
+            memcmp: {
+              offset: 64,
+              bytes: user.toBase58(),
             },
-            {
-              memcmp: {
-                offset: 32n,
-                bytes: this.address.toString() as Base58EncodedBytes,
-                encoding: 'base58',
-              },
+          },
+          {
+            memcmp: {
+              offset: 32,
+              bytes: this.address,
             },
-          ],
-          encoding: 'base64',
-          commitment,
-        })
-        .send(),
+          },
+        ],
+        commitment,
+      }),
     ]);
 
-    const collateralExchangeRates = new Map<Address, Decimal>();
-    const cumulativeBorrowRates = new Map<Address, Decimal>();
+    const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
+    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
     return obligations.map((obligation) => {
-      if (obligation.account.owner !== this.programId) {
+      if (obligation.account === null) {
+        throw new Error('Invalid account');
+      }
+      if (!obligation.account.owner.equals(this.programId)) {
         throw new Error("account doesn't belong to this program");
       }
 
-      const obligationAccount = Obligation.decode(Buffer.from(obligation.account.data[0], 'base64'));
+      const obligationAccount = Obligation.decode(obligation.account.data);
 
       if (!obligationAccount) {
         throw Error('Could not parse obligation.');
@@ -939,41 +915,41 @@ export class KaminoMarket {
     });
   }
 
-  async getAllUserObligationsForReserve(user: Address, reserve: Address): Promise<KaminoObligation[]> {
-    const obligationAddresses: Address[] = [];
-    obligationAddresses.push(await new VanillaObligation(this.programId).toPda(this.getAddress(), user));
-    const targetReserve = new Map<Address, KaminoReserve>(Array.from(this.reserves.entries())).get(reserve);
+  async getAllUserObligationsForReserve(user: PublicKey, reserve: PublicKey): Promise<KaminoObligation[]> {
+    const obligationAddresses: PublicKey[] = [];
+    obligationAddresses.push(new VanillaObligation(this.programId).toPda(this.getAddress(), user));
+    const targetReserve = new PubkeyHashMap<PublicKey, KaminoReserve>(Array.from(this.reserves.entries())).get(reserve);
     if (!targetReserve) {
       throw Error('Could not find reserve.');
     }
     for (const [key, kaminoReserve] of this.reserves) {
-      if (targetReserve.address === key) {
+      if (targetReserve.address.equals(key)) {
         // skip target reserve
         continue;
       }
       obligationAddresses.push(
-        await new MultiplyObligation(
+        new MultiplyObligation(
           targetReserve.getLiquidityMint(),
           kaminoReserve.getLiquidityMint(),
           this.programId
         ).toPda(this.getAddress(), user)
       );
       obligationAddresses.push(
-        await new MultiplyObligation(
+        new MultiplyObligation(
           kaminoReserve.getLiquidityMint(),
           targetReserve.getLiquidityMint(),
           this.programId
         ).toPda(this.getAddress(), user)
       );
       obligationAddresses.push(
-        await new LeverageObligation(
+        new LeverageObligation(
           targetReserve.getLiquidityMint(),
           kaminoReserve.getLiquidityMint(),
           this.programId
         ).toPda(this.getAddress(), user)
       );
       obligationAddresses.push(
-        await new LeverageObligation(
+        new LeverageObligation(
           kaminoReserve.getLiquidityMint(),
           targetReserve.getLiquidityMint(),
           this.programId
@@ -989,12 +965,12 @@ export class KaminoMarket {
       obligations.forEach((obligation) => {
         if (obligation !== null) {
           for (const deposits of obligation.deposits.keys()) {
-            if (deposits === reserve) {
+            if (deposits.equals(reserve)) {
               finalObligations.push(obligation);
             }
           }
           for (const borrows of obligation.borrows.keys()) {
-            if (borrows === reserve) {
+            if (borrows.equals(reserve)) {
               finalObligations.push(obligation);
             }
           }
@@ -1005,8 +981,8 @@ export class KaminoMarket {
     return finalObligations;
   }
 
-  async getUserVanillaObligation(user: Address): Promise<KaminoObligation> {
-    const vanillaObligationAddress = await new VanillaObligation(this.programId).toPda(this.getAddress(), user);
+  async getUserVanillaObligation(user: PublicKey): Promise<KaminoObligation> {
+    const vanillaObligationAddress = new VanillaObligation(this.programId).toPda(this.getAddress(), user);
 
     const obligation = await this.getObligationByAddress(vanillaObligationAddress);
 
@@ -1017,14 +993,14 @@ export class KaminoMarket {
     return obligation;
   }
 
-  isReserveInObligation(obligation: KaminoObligation, reserve: Address): boolean {
+  isReserveInObligation(obligation: KaminoObligation, reserve: PublicKey): boolean {
     for (const deposits of obligation.deposits.keys()) {
-      if (deposits === reserve) {
+      if (deposits.equals(reserve)) {
         return true;
       }
     }
     for (const borrows of obligation.borrows.keys()) {
-      if (borrows === reserve) {
+      if (borrows.equals(reserve)) {
         return true;
       }
     }
@@ -1032,49 +1008,46 @@ export class KaminoMarket {
     return false;
   }
 
-  async getUserObligationsByTag(tag: number, user: Address): Promise<KaminoObligation[]> {
+  async getUserObligationsByTag(tag: number, user: PublicKey): Promise<KaminoObligation[]> {
     const [currentSlot, obligations] = await Promise.all([
-      this.rpc.getSlot().send(),
-      this.rpc
-        .getProgramAccounts(this.programId, {
-          filters: [
-            {
-              dataSize: BigInt(Obligation.layout.span + 8),
-            },
-            {
-              memcmp: {
-                offset: 8n,
-                bytes: base58Decoder.decode(new BN(tag).toBuffer()) as Base58EncodedBytes,
-                encoding: 'base58',
-              },
+      this.connection.getSlot(),
+      this.connection.getProgramAccounts(this.programId, {
+        filters: [
+          {
+            dataSize: Obligation.layout.span + 8,
+          },
+          {
+            memcmp: {
+              offset: 8,
+              bytes: base58.encode(new BN(tag).toBuffer()),
             },
-            {
-              memcmp: {
-                offset: 32n,
-                bytes: this.address.toString() as Base58EncodedBytes,
-                encoding: 'base58',
-              },
+          },
+          {
+            memcmp: {
+              offset: 32,
+              bytes: this.address,
             },
-            {
-              memcmp: {
-                offset: 64n,
-                bytes: user.toString() as Base58EncodedBytes,
-                encoding: 'base58',
-              },
+          },
+          {
+            memcmp: {
+              offset: 64,
+              bytes: user.toBase58(),
             },
-          ],
-          encoding: 'base64',
-        })
-        .send(),
+          },
+        ],
+      }),
     ]);
-    const collateralExchangeRates = new Map<Address, Decimal>();
-    const cumulativeBorrowRates = new Map<Address, Decimal>();
+    const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
+    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
     return obligations.map((obligation) => {
-      if (obligation.account.owner !== this.programId) {
+      if (obligation.account === null) {
+        throw new Error('Invalid account');
+      }
+      if (!obligation.account.owner.equals(this.programId)) {
         throw new Error("account doesn't belong to this program");
       }
 
-      const obligationAccount = Obligation.decode(Buffer.from(obligation.account.data[0], 'base64'));
+      const obligationAccount = Obligation.decode(obligation.account.data);
 
       if (!obligationAccount) {
         throw Error('Could not parse obligation.');
@@ -1096,14 +1069,14 @@ export class KaminoMarket {
     });
   }
 
-  async getObligationByAddress(address: Address) {
+  async getObligationByAddress(address: PublicKey) {
     if (!this.getReserves().every((reserve) => reserve.stats)) {
       await this.loadReserves();
     }
     return KaminoObligation.load(this, address);
   }
 
-  async getMultipleObligationsByAddress(addresses: Address[]) {
+  async getMultipleObligationsByAddress(addresses: PublicKey[]) {
     return KaminoObligation.loadAll(this, addresses);
   }
 
@@ -1111,57 +1084,51 @@ export class KaminoMarket {
    * Get the user metadata PDA and fetch and return the user metadata state if it exists
    * @return [address, userMetadataState] - The address of the user metadata PDA and the user metadata state, or null if it doesn't exist
    */
-  async getUserMetadata(user: Address): Promise<[Address, UserMetadata | null]> {
-    const [address, _bump] = await userMetadataPda(user, this.programId);
+  async getUserMetadata(user: PublicKey): Promise<[PublicKey, UserMetadata | null]> {
+    const [address, _bump] = userMetadataPda(user, this.programId);
 
-    const userMetadata = await UserMetadata.fetch(this.rpc, address, this.programId);
+    const userMetadata = await UserMetadata.fetch(this.connection, address, this.programId);
 
     return [address, userMetadata];
   }
 
   async getReferrerTokenStateForReserve(
-    referrer: Address,
-    reserve: Address
-  ): Promise<[Address, ReferrerTokenState | null]> {
-    const address = await referrerTokenStatePda(referrer, reserve, this.programId);
+    referrer: PublicKey,
+    reserve: PublicKey
+  ): Promise<[PublicKey, ReferrerTokenState | null]> {
+    const [address, _bump] = referrerTokenStatePda(referrer, reserve, this.programId);
 
-    const referrerTokenState = await ReferrerTokenState.fetch(this.rpc, address, this.programId);
+    const referrerTokenState = await ReferrerTokenState.fetch(this.connection, address, this.programId);
 
     return [address, referrerTokenState];
   }
 
-  async getAllReferrerTokenStates(referrer: Address) {
-    const referrerTokenStates = await this.rpc
-      .getProgramAccounts(this.programId, {
-        filters: [
-          {
-            dataSize: BigInt(ReferrerTokenState.layout.span + 8),
-          },
-          {
-            memcmp: {
-              offset: 8n,
-              bytes: referrer.toString() as Base58EncodedBytes,
-              encoding: 'base58',
-            },
+  async getAllReferrerTokenStates(referrer: PublicKey) {
+    const referrerTokenStates = await this.connection.getProgramAccounts(this.programId, {
+      filters: [
+        {
+          dataSize: ReferrerTokenState.layout.span + 8,
+        },
+        {
+          memcmp: {
+            offset: 8,
+            bytes: referrer.toBase58(),
           },
-        ],
-        encoding: 'base64',
-      })
-      .send();
+        },
+      ],
+    });
 
-    const referrerTokenStatesForMints = new Map<Address, ReferrerTokenState>();
+    const referrerTokenStatesForMints = new PubkeyHashMap<PublicKey, ReferrerTokenState>();
 
     referrerTokenStates.forEach((referrerTokenState) => {
       if (referrerTokenState.account === null) {
         throw new Error('Invalid account');
       }
-      if (referrerTokenState.account.owner !== this.programId) {
+      if (!referrerTokenState.account.owner.equals(this.programId)) {
         throw new Error("account doesn't belong to this program");
       }
 
-      const referrerTokenStateDecoded = ReferrerTokenState.decode(
-        Buffer.from(referrerTokenState.account.data[0], 'base64')
-      );
+      const referrerTokenStateDecoded = ReferrerTokenState.decode(referrerTokenState.account.data);
 
       if (!referrerTokenStateDecoded) {
         throw Error('Could not parse obligation.');
@@ -1173,10 +1140,10 @@ export class KaminoMarket {
     return referrerTokenStatesForMints;
   }
 
-  async getAllReferrerFeesUnclaimed(referrer: Address) {
+  async getAllReferrerFeesUnclaimed(referrer: PublicKey) {
     const referrerTokenStatesForMints = await this.getAllReferrerTokenStates(referrer);
 
-    const referrerFeesUnclaimedForMints = new Map<Address, Decimal>();
+    const referrerFeesUnclaimedForMints = new PubkeyHashMap<PublicKey, Decimal>();
 
     for (const mint of referrerTokenStatesForMints.keys()) {
       referrerFeesUnclaimedForMints.set(
@@ -1188,20 +1155,20 @@ export class KaminoMarket {
     return referrerFeesUnclaimedForMints;
   }
 
-  async getReferrerFeesUnclaimedForReserve(referrer: Address, reserve: KaminoReserve): Promise<Decimal> {
+  async getReferrerFeesUnclaimedForReserve(referrer: PublicKey, reserve: KaminoReserve): Promise<Decimal> {
     const [, referrerTokenState] = await this.getReferrerTokenStateForReserve(referrer, reserve.address);
     return referrerTokenState ? new Fraction(referrerTokenState.amountUnclaimedSf).toDecimal() : new Decimal(0);
   }
 
-  async getReferrerFeesCumulativeForReserve(referrer: Address, reserve: KaminoReserve): Promise<Decimal> {
+  async getReferrerFeesCumulativeForReserve(referrer: PublicKey, reserve: KaminoReserve): Promise<Decimal> {
     const [, referrerTokenState] = await this.getReferrerTokenStateForReserve(referrer, reserve.address);
     return referrerTokenState ? new Fraction(referrerTokenState.amountCumulativeSf).toDecimal() : new Decimal(0);
   }
 
-  async getAllReferrerFeesCumulative(referrer: Address) {
+  async getAllReferrerFeesCumulative(referrer: PublicKey) {
     const referrerTokenStatesForMints = await this.getAllReferrerTokenStates(referrer);
 
-    const referrerFeesCumulativeForMints = new Map<Address, Decimal>();
+    const referrerFeesCumulativeForMints = new PubkeyHashMap<PublicKey, Decimal>();
 
     for (const mint of referrerTokenStatesForMints.keys()) {
       referrerFeesCumulativeForMints.set(
@@ -1213,29 +1180,52 @@ export class KaminoMarket {
     return referrerFeesCumulativeForMints;
   }
 
-  getReferrerUrl(baseUrl: string, referrer: Address) {
-    return `${baseUrl}${referrer.toString()}`;
+  async getReferrerUrl(baseUrl: string, referrer: PublicKey) {
+    return baseUrl + this.encodeReferrer(referrer);
+  }
+
+  async getReferrerFromUrl(baseUrl: string, url: string) {
+    return this.decodeReferrer(url.split(baseUrl)[1]);
+  }
+
+  async encodeReferrer(referrer: PublicKey) {
+    return bs58.encode(referrer.toBuffer());
   }
 
-  getReferrerFromUrl(baseUrl: string, url: string) {
-    return address(url.split(baseUrl)[1]);
+  async decodeReferrer(encoded_referrer: string) {
+    const referrer_buffer = bs58.decode(encoded_referrer);
+    return new PublicKey(referrer_buffer.toString());
   }
 
   /**
-   * Get the underlying rpc passed when instantiating this market
-   * @return rpc
+   * Get the underlying connection passed when instantiating this market
+   * @return connection
    */
-  getRpc(): Rpc<KaminoMarketRpcApi> {
-    return this.rpc;
+  getConnection() {
+    return this.connection;
   }
 
   /**
-   * Get all Scope prices used by all the market reserves
+   * Get all scope OraclePrices accounts for all market reserves
+   * @param scope
    */
-  async getAllScopePrices(scope: Scope, oraclePrices?: OraclePrices): Promise<KaminoPrices> {
-    if (!oraclePrices) {
-      oraclePrices = await scope.getOraclePrices();
+  async getReserveOraclePrices(scope: Scope): Promise<PubkeyHashMap<PublicKey, OraclePrices>> {
+    const reserveOraclePrices: PubkeyHashMap<PublicKey, OraclePrices> = new PubkeyHashMap();
+    const oraclePrices = await scope.getMultipleOraclePrices(Array.from(this.reserveScopeFeeds.keys()));
+    for (const [feed, oraclePricesAccount] of oraclePrices) {
+      const reserve = this.reserveScopeFeeds.get(feed);
+      if (reserve) {
+        reserveOraclePrices.set(reserve, oraclePricesAccount);
+      }
     }
+    return reserveOraclePrices;
+  }
+
+  /**
+   * Get all Scope prices used by all the market reserves
+   */
+  async getAllScopePrices(scope: Scope): Promise<KaminoPrices> {
+    const allOraclePrices = await this.getReserveOraclePrices(scope);
     const spot: MintToPriceMap = {};
     const twaps: MintToPriceMap = {};
     for (const reserve of this.reserves.values()) {
@@ -1244,11 +1234,12 @@ export class KaminoMarket {
       const oracle = reserve.state.config.tokenInfo.scopeConfiguration.priceFeed;
       const chain = reserve.state.config.tokenInfo.scopeConfiguration.priceChain;
       const twapChain = reserve.state.config.tokenInfo.scopeConfiguration.twapChain.filter((x) => x > 0);
-      if (oracle && isNotNullPubkey(oracle) && chain && Scope.isScopeChainValid(chain)) {
+      const oraclePrices = allOraclePrices.get(reserve.address);
+      if (oraclePrices && oracle && isNotNullPubkey(oracle) && chain && Scope.isScopeChainValid(chain)) {
         const spotPrice = await scope.getPriceFromChain(chain, oraclePrices);
         spot[tokenMint] = { price: spotPrice.price, name: tokenName };
       }
-      if (oracle && isNotNullPubkey(oracle) && twapChain && Scope.isScopeChainValid(twapChain)) {
+      if (oraclePrices && oracle && isNotNullPubkey(oracle) && twapChain && Scope.isScopeChainValid(twapChain)) {
         const twap = await scope.getPriceFromChain(twapChain, oraclePrices);
         twaps[tokenMint] = { price: twap.price, name: tokenName };
       }
@@ -1266,12 +1257,14 @@ export class KaminoMarket {
       switchboard: { spot: {}, twap: {} },
     };
     const allOracleAccounts = await getAllOracleAccounts(
-      this.rpc,
+      this.connection,
       this.getReserves().map((x) => x.state)
     );
-    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>();
+
+    const switchboardV2 = await SwitchboardProgram.loadMainnet(this.connection);
 
     for (const reserve of this.reserves.values()) {
       const tokenMint = reserve.getLiquidityMint().toString();
@@ -1296,9 +1289,9 @@ export class KaminoMarket {
       }
       if (isNotNullPubkey(switchboardSpotOracle)) {
         const switchboardPrices = {
-          spot: cacheOrGetSwitchboardPrice(switchboardSpotOracle, switchboardCache, allOracleAccounts),
+          spot: cacheOrGetSwitchboardPrice(switchboardSpotOracle, switchboardCache, allOracleAccounts, switchboardV2),
           twap: isNotNullPubkey(switchboardTwapOracle)
-            ? cacheOrGetSwitchboardPrice(switchboardTwapOracle, switchboardCache, allOracleAccounts)
+            ? cacheOrGetSwitchboardPrice(switchboardTwapOracle, switchboardCache, allOracleAccounts, switchboardV2)
             : null,
         };
         this.setPriceIfExist(
@@ -1313,8 +1306,8 @@ export class KaminoMarket {
     return klendPrices;
   }
 
-  getCumulativeBorrowRatesByReserve(slot: Slot): Map<Address, Decimal> {
-    const cumulativeBorrowRates = new Map<Address, Decimal>();
+  getCumulativeBorrowRatesByReserve(slot: number): Map<PublicKey, Decimal> {
+    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
     for (const reserve of this.reserves.values()) {
       cumulativeBorrowRates.set(
         reserve.address,
@@ -1324,8 +1317,8 @@ export class KaminoMarket {
     return cumulativeBorrowRates;
   }
 
-  getCollateralExchangeRatesByReserve(slot: Slot): Map<Address, Decimal> {
-    const collateralExchangeRates = new Map<Address, Decimal>();
+  getCollateralExchangeRatesByReserve(slot: number): Map<PublicKey, Decimal> {
+    const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
     for (const reserve of this.reserves.values()) {
       collateralExchangeRates.set(
         reserve.address,
@@ -1364,10 +1357,10 @@ export class KaminoMarket {
         continue;
       }
       elevationGroups.push({
-        collateralReserves: new Set<Address>([]),
-        collateralLiquidityMints: new Set<Address>([]),
+        collateralReserves: new PublicKeySet<PublicKey>([]),
+        collateralLiquidityMints: new PublicKeySet<PublicKey>([]),
         debtReserve: elevationGroup.debtReserve,
-        debtLiquidityMint: DEFAULT_PUBLIC_KEY,
+        debtLiquidityMint: PublicKey.default,
         elevationGroup: elevationGroup.id,
         maxReservesAsCollateral: elevationGroup.maxReservesAsCollateral,
       });
@@ -1385,7 +1378,7 @@ export class KaminoMarket {
 
         const elevationGroupDescription = elevationGroups[elevationGroupId - 1];
         if (elevationGroupDescription) {
-          if (reserveAddress === elevationGroupDescription.debtReserve) {
+          if (reserveAddress.equals(elevationGroupDescription.debtReserve)) {
             elevationGroups[elevationGroupId - 1].debtLiquidityMint = reserveLiquidityMint;
           } else {
             elevationGroups[elevationGroupId - 1].collateralReserves.add(reserveAddress);
@@ -1402,30 +1395,30 @@ export class KaminoMarket {
 
   /* Returns all elevation groups for a given combination of liquidity mints, except the default one */
   getElevationGroupsForMintsCombination(
-    collLiquidityMints: Address[],
-    debtLiquidityMint?: Address
+    collLiquidityMints: PublicKey[],
+    debtLiquidityMint?: PublicKey
   ): ElevationGroupDescription[] {
     const allElevationGroups = this.getMarketElevationGroupDescriptions();
 
     return allElevationGroups.filter((elevationGroupDescription) => {
       return (
-        collLiquidityMints.every((mint) => elevationGroupDescription.collateralLiquidityMints.has(mint)) &&
-        (debtLiquidityMint == undefined || debtLiquidityMint === elevationGroupDescription.debtLiquidityMint)
+        collLiquidityMints.every((mint) => elevationGroupDescription.collateralLiquidityMints.contains(mint)) &&
+        (debtLiquidityMint == undefined || debtLiquidityMint.equals(elevationGroupDescription.debtLiquidityMint))
       );
     });
   }
 
   /* Returns all elevation groups for a given combination of reserves, except the default one */
   getElevationGroupsForReservesCombination(
-    collReserves: Address[],
-    debtReserve?: Address
+    collReserves: PublicKey[],
+    debtReserve?: PublicKey
   ): ElevationGroupDescription[] {
     const allElevationGroups = this.getMarketElevationGroupDescriptions();
 
     return allElevationGroups.filter((elevationGroupDescription) => {
       return (
-        collReserves.every((mint) => elevationGroupDescription.collateralReserves.has(mint)) &&
-        (debtReserve == undefined || debtReserve === elevationGroupDescription.debtReserve)
+        collReserves.every((mint) => elevationGroupDescription.collateralReserves.contains(mint)) &&
+        (debtReserve == undefined || debtReserve.equals(elevationGroupDescription.debtReserve))
       );
     });
   }
@@ -1452,7 +1445,7 @@ export type BorrowCapsAndCounters = {
 
   // Debt against collateral caps
   debtAgainstCollateralReserveCaps: {
-    collateralReserve: Address;
+    collateralReserve: PublicKey;
     elevationGroup: number;
     maxDebt: Decimal;
     currentValue: Decimal;
@@ -1460,10 +1453,10 @@ export type BorrowCapsAndCounters = {
 };
 
 export type ElevationGroupDescription = {
-  collateralReserves: Set<Address>;
-  collateralLiquidityMints: Set<Address>;
-  debtReserve: Address;
-  debtLiquidityMint: Address;
+  collateralReserves: PublicKeySet<PublicKey>;
+  collateralLiquidityMints: PublicKeySet<PublicKey>;
+  debtReserve: PublicKey;
+  debtLiquidityMint: PublicKey;
   elevationGroup: number;
   maxReservesAsCollateral: number;
 };
@@ -1475,74 +1468,94 @@ export type KlendPrices = {
 };
 
 export async function getReservesForMarket(
-  marketAddress: Address,
-  rpc: Rpc<KaminoReserveRpcApi>,
-  programId: Address,
+  marketAddress: PublicKey,
+  connection: Connection,
+  programId: PublicKey,
   recentSlotDurationMs: number
-): Promise<Map<Address, KaminoReserve>> {
-  const reserves = await rpc
-    .getProgramAccounts(programId, {
-      filters: [
-        {
-          dataSize: BigInt(Reserve.layout.span + 8),
-        },
-        {
-          memcmp: {
-            offset: 32n,
-            bytes: marketAddress.toString() as Base58EncodedBytes,
-            encoding: 'base58',
-          },
+): Promise<Map<PublicKey, KaminoReserve>> {
+  const reserves = await connection.getProgramAccounts(programId, {
+    filters: [
+      {
+        dataSize: Reserve.layout.span + 8,
+      },
+      {
+        memcmp: {
+          offset: 32,
+          bytes: marketAddress.toBase58(),
         },
-      ],
-      encoding: 'base64',
-    })
-    .send();
+      },
+    ],
+  });
   const deserializedReserves = reserves.map((reserve) => {
     if (reserve.account === null) {
-      throw new Error(`Reserve account ${reserve.pubkey} does not exist`);
+      throw new Error(`Reserve account ${reserve.pubkey.toBase58()} does not exist`);
     }
 
-    const reserveAccount = Reserve.decode(Buffer.from(reserve.account.data[0], 'base64'));
+    const reserveAccount = Reserve.decode(reserve.account.data);
 
     if (!reserveAccount) {
-      throw Error(`Could not parse reserve ${reserve.pubkey}`);
+      throw Error(`Could not parse reserve ${reserve.pubkey.toBase58()}`);
     }
     return reserveAccount;
   });
-  const reservesAndOracles = await getTokenOracleData(rpc, deserializedReserves);
-  const reservesByAddress = new Map<Address, KaminoReserve>();
+  const allBuffers = reserves.map((reserve) => reserve.account);
+  const reservesAndOracles = await getTokenOracleData(connection, deserializedReserves);
+  const reservesByAddress = new PubkeyHashMap<PublicKey, KaminoReserve>();
   reservesAndOracles.forEach(([reserve, oracle], index) => {
     if (!oracle) {
       throw Error(`Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} reserve`);
     }
-    const kaminoReserve = KaminoReserve.initialize(reserves[index].pubkey, reserve, oracle, rpc, recentSlotDurationMs);
+    const kaminoReserve = KaminoReserve.initialize(
+      allBuffers[index],
+      reserves[index].pubkey,
+      reserve,
+      oracle,
+      connection,
+      recentSlotDurationMs
+    );
     reservesByAddress.set(kaminoReserve.address, kaminoReserve);
   });
   return reservesByAddress;
 }
 
 export async function getSingleReserve(
-  reservePk: Address,
-  rpc: Rpc<KaminoReserveRpcApi>,
+  reservePk: PublicKey,
+  connection: Connection,
   recentSlotDurationMs: number,
-  reserveData?: Reserve
+  accountData?: AccountInfo<Buffer>
 ): Promise<KaminoReserve> {
-  const reserve = reserveData ?? (await Reserve.fetch(rpc, reservePk));
+  const reserve = accountData ? accountData : await connection.getAccountInfo(reservePk);
 
   if (reserve === null) {
-    throw new Error(`Reserve account ${reservePk} does not exist`);
+    throw new Error(`Reserve account ${reservePk.toBase58()} does not exist`);
   }
-  const reservesAndOracles = await getTokenOracleData(rpc, [reserve]);
-  const [, oracle] = reservesAndOracles[0];
 
-  if (!oracle) {
-    throw Error(`Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} reserve`);
+  const reserveAccount = Reserve.decode(reserve.data);
+
+  if (!reserveAccount) {
+    throw Error(`Could not parse reserve ${reservePk.toBase58()}`);
   }
-  return KaminoReserve.initialize(reservePk, reserve, oracle, rpc, recentSlotDurationMs);
+
+  const reservesAndOracles = await getTokenOracleData(connection, [reserveAccount]);
+  const [reserveState, oracle] = reservesAndOracles[0];
+
+  if (!oracle) {
+    throw Error(`Could not find oracle for ${parseTokenSymbol(reserveState.config.tokenInfo.name)} reserve`);
+  }
+  const kaminoReserve = KaminoReserve.initialize(
+    reserve,
+    reservePk,
+    reserveState,
+    oracle,
+    connection,
+    recentSlotDurationMs
+  );
+
+  return kaminoReserve;
 }
 
-export function getReservesActive(reserves: Map<Address, KaminoReserve>): Map<Address, KaminoReserve> {
-  const reservesActive = new Map<Address, KaminoReserve>();
+export function getReservesActive(reserves: Map<PublicKey, KaminoReserve>): Map<PublicKey, KaminoReserve> {
+  const reservesActive = new PubkeyHashMap<PublicKey, KaminoReserve>();
   for (const [key, reserve] of reserves) {
     if (reserve.state.config.status === 0) {
       reservesActive.set(key, reserve);
@@ -1551,16 +1564,16 @@ export function getReservesActive(reserves: Map<Address, KaminoReserve>): Map<Ad
   return reservesActive;
 }
 
-export function getTokenIdsForScopeRefresh(kaminoMarket: KaminoMarket, reserves: Address[]): number[] {
+export function getTokenIdsForScopeRefresh(kaminoMarket: KaminoMarket, reserves: PublicKey[]): number[] {
   const tokenIds: number[] = [];
 
   for (const reserveAddress of reserves) {
     const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
     if (!reserve) {
-      throw new Error(`Reserve not found for reserve ${reserveAddress}`);
+      throw new Error(`Reserve not found for reserve ${reserveAddress.toBase58()}`);
     }
 
-    if (reserve.state.config.tokenInfo.scopeConfiguration.priceFeed !== DEFAULT_PUBLIC_KEY) {
+    if (!reserve.state.config.tokenInfo.scopeConfiguration.priceFeed.equals(PublicKey.default)) {
       let x = 0;
 
       while (reserve.state.config.tokenInfo.scopeConfiguration.priceChain[x] !== U16_MAX) {
@@ -1579,6 +1592,44 @@ export function getTokenIdsForScopeRefresh(kaminoMarket: KaminoMarket, reserves:
   return tokenIds;
 }
 
+export async function getReserveFromMintAndMarket(
+  connection: Connection,
+  market: KaminoMarket,
+  mint: string,
+  programId: PublicKey = PROGRAM_ID
+): Promise<[PublicKey, AccountInfo<Buffer>]> {
+  const reserve = (
+    await connection.getProgramAccounts(programId, {
+      filters: [
+        {
+          dataSize: Reserve.layout.span + 8,
+        },
+        {
+          memcmp: {
+            offset: 32,
+            bytes: market.address,
+          },
+        },
+        {
+          memcmp: {
+            offset: 128,
+            bytes: mint,
+          },
+        },
+      ],
+    })
+  )[0];
+
+  if (reserve.account === null) {
+    throw new Error('Invalid account');
+  }
+  if (!reserve.account.owner.equals(programId)) {
+    throw new Error("Account doesn't belong to this program");
+  }
+
+  return [reserve.pubkey, reserve.account];
+}
+
 const lamportsToNumberDecimal = (amount: Decimal.Value, decimals: number): Decimal => {
   const factor = 10 ** decimals;
   return new Decimal(amount).div(factor);