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

package/src/classes/reserve.ts

@@ -1,23 +1,14 @@
 /* eslint-disable max-classes-per-file */
 import {
-  Address,
-  IInstruction,
-  Slot,
-  TransactionSigner,
-  Rpc,
-  GetMinimumBalanceForRentExemptionApi,
-  Option,
-  none,
-  some,
-  isSome,
-  GetProgramAccountsApi,
-  GetAccountInfoApi,
-  GetMultipleAccountsApi,
-} from '@solana/kit';
+  AccountInfo,
+  Connection,
+  PublicKey,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  TransactionInstruction,
+} from '@solana/web3.js';
 import Decimal from 'decimal.js';
 import {
-  DEFAULT_PUBLIC_KEY,
-  getTokenOracleData,
   globalConfigPda,
   INITIAL_COLLATERAL_RATE,
   lendingMarketAuthPda,
@@ -32,8 +23,8 @@ import {
   U64_MAX,
 } from '../utils';
 import { FeeCalculation, Fees, ReserveDataType, ReserveFarmInfo, ReserveRewardYield, ReserveStatus } from './shared';
-import { Reserve, ReserveFields } from '../@codegen/klend/accounts';
-import { CurvePointFields, ReserveConfig, UpdateConfigMode, UpdateConfigModeKind } from '../@codegen/klend/types';
+import { Reserve, ReserveFields } from '../idl_codegen/accounts';
+import { CurvePointFields, ReserveConfig, UpdateConfigMode, UpdateConfigModeKind } from '../idl_codegen/types';
 import { calculateAPYFromAPR, getBorrowRate, lamportsToNumberDecimal, parseTokenSymbol, positiveOrZero } from './utils';
 import { CompositeConfigItem, encodeUsingLayout, ConfigUpdater } from './configItems';
 import { bfToDecimal, Fraction } from './fraction';
@@ -46,77 +37,56 @@ import {
   UpdateReserveConfigAccounts,
   UpdateReserveConfigArgs,
 } from '../lib';
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { aprToApy, KaminoPrices } from '@kamino-finance/kliquidity-sdk';
 import { FarmState, RewardInfo } from '@kamino-finance/farms-sdk';
-import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
-import { maxBigInt } from '../utils/bigint';
-import { getCreateAccountInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
-import { SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
-import { noopSigner } from '../utils/signer';
-
-export type KaminoReserveRpcApi = GetProgramAccountsApi & GetAccountInfoApi & GetMultipleAccountsApi;
 
 export const DEFAULT_RECENT_SLOT_DURATION_MS = 450;
 
 export class KaminoReserve {
   state: Reserve;
-  address: Address;
+  address: PublicKey;
   symbol: string;
 
   tokenOraclePrice: TokenOracleData;
   stats: ReserveDataType;
   private farmData: ReserveFarmInfo = { fetched: false, farmStates: [] };
 
-  private rpc: Rpc<KaminoReserveRpcApi>;
+  private buffer: AccountInfo<Buffer> | null;
+  private connection: Connection;
   private readonly recentSlotDurationMs: number;
 
   constructor(
     state: Reserve,
-    address: Address,
+    address: PublicKey,
     tokenOraclePrice: TokenOracleData,
-    connection: Rpc<KaminoReserveRpcApi>,
+    connection: Connection,
     recentSlotDurationMs: number
   ) {
     this.state = state;
     this.address = address;
+    this.buffer = null;
     this.tokenOraclePrice = tokenOraclePrice;
     this.stats = {} as ReserveDataType;
-    this.rpc = connection;
+    this.connection = connection;
     this.symbol = parseTokenSymbol(state.config.tokenInfo.name);
     this.recentSlotDurationMs = recentSlotDurationMs;
   }
 
   static initialize(
-    address: Address,
+    accountData: AccountInfo<Buffer>,
+    address: PublicKey,
     state: Reserve,
     tokenOraclePrice: TokenOracleData,
-    rpc: Rpc<KaminoReserveRpcApi>,
+    connection: Connection,
     recentSlotDurationMs: number
-  ): KaminoReserve {
-    const reserve = new KaminoReserve(state, address, tokenOraclePrice, rpc, recentSlotDurationMs);
+  ) {
+    const reserve = new KaminoReserve(state, address, tokenOraclePrice, connection, recentSlotDurationMs);
+    reserve.setBuffer(accountData);
     reserve.stats = reserve.formatReserveData(state);
     return reserve;
   }
 
-  static async initializeFromAddress(
-    address: Address,
-    rpc: Rpc<KaminoReserveRpcApi>,
-    recentSlotDurationMs: number,
-    reserveState?: Reserve
-  ) {
-    const reserve = reserveState ?? (await Reserve.fetch(rpc, address));
-    if (reserve === null) {
-      throw new Error(`Reserve account ${address} does not exist`);
-    }
-
-    const tokenOracleDataWithReserve = await getTokenOracleData(rpc, [reserve]);
-    if (!tokenOracleDataWithReserve[0]) {
-      throw new Error('Token oracle data not found');
-    }
-    const tokenOracleData = tokenOracleDataWithReserve[0]![1]!;
-    return new KaminoReserve(reserve, address, tokenOracleData, rpc, recentSlotDurationMs);
-  }
-
   /// GETTERS
 
   /**
@@ -218,7 +188,7 @@ export class KaminoReserve {
   /**
    * Calculates the total liquidity supply of the reserve
    */
-  getEstimatedTotalSupply(slot: Slot, referralFeeBps: number): Decimal {
+  getEstimatedTotalSupply(slot: number, referralFeeBps: number): Decimal {
     const { totalSupply } = this.getEstimatedDebtAndSupply(slot, referralFeeBps);
     return totalSupply;
   }
@@ -234,9 +204,9 @@ export class KaminoReserve {
   /**
    * @Returns estimated cumulative borrow rate of the reserve
    */
-  getEstimatedCumulativeBorrowRate(currentSlot: Slot, referralFeeBps: number): Decimal {
+  getEstimatedCumulativeBorrowRate(currentSlot: number, referralFeeBps: number): Decimal {
     const currentBorrowRate = new Decimal(this.calculateBorrowAPR(currentSlot, referralFeeBps));
-    const slotsElapsed = maxBigInt(currentSlot - BigInt(this.state.lastUpdate.slot.toString()), 0n);
+    const slotsElapsed = Math.max(currentSlot - this.state.lastUpdate.slot.toNumber(), 0);
 
     const compoundInterest = this.approximateCompoundedInterest(currentBorrowRate, slotsElapsed);
 
@@ -263,7 +233,7 @@ export class KaminoReserve {
    *
    * @returns the estimated exchange rate between the collateral tokens and the liquidity - this is a decimal number scaled by 1e18
    */
-  getEstimatedCollateralExchangeRate(slot: Slot, referralFeeBps: number): Decimal {
+  getEstimatedCollateralExchangeRate(slot: number, referralFeeBps: number): Decimal {
     const totalSupply = this.getEstimatedTotalSupply(slot, referralFeeBps);
     const mintTotalSupply = this.state.collateral.mintTotalSupply;
     if (mintTotalSupply.isZero() || totalSupply.isZero()) {
@@ -303,26 +273,6 @@ export class KaminoReserve {
     return this.state.liquidity.mintDecimals.toNumber();
   }
 
-  /**
-   * @returns the collateral farm address if it is set, otherwise none
-   */
-  getCollateralFarmAddress(): Option<Address> {
-    if (this.state.farmCollateral === DEFAULT_PUBLIC_KEY) {
-      return none();
-    }
-    return some(this.state.farmCollateral);
-  }
-
-  /**
-   * @returns the debt farm address if it is set, otherwise none
-   */
-  getDebtFarmAddress(): Option<Address> {
-    if (this.state.farmDebt === DEFAULT_PUBLIC_KEY) {
-      return none();
-    }
-    return some(this.state.farmDebt);
-  }
-
   /**
    * @Returns true if the total liquidity supply of the reserve is greater than the deposit limit
    */
@@ -349,8 +299,8 @@ export class KaminoReserve {
    *
    * @returns the current capacity of the daily deposit withdrawal cap
    */
-  getDepositWithdrawalCapCurrent(slot: Slot): Decimal {
-    const slotsElapsed = maxBigInt(slot - BigInt(this.state.lastUpdate.slot.toString()), 0n);
+  getDepositWithdrawalCapCurrent(slot: number): Decimal {
+    const slotsElapsed = Math.max(slot - this.state.lastUpdate.slot.toNumber(), 0);
     if (slotsElapsed > SLOTS_PER_DAY) {
       return new Decimal(0);
     } else {
@@ -404,8 +354,8 @@ export class KaminoReserve {
    *
    * @returns the current capacity of the daily debt withdrawal cap
    */
-  getDebtWithdrawalCapCurrent(slot: Slot): Decimal {
-    const slotsElapsed = maxBigInt(slot - BigInt(this.state.lastUpdate.slot.toString()), 0n);
+  getDebtWithdrawalCapCurrent(slot: number): Decimal {
+    const slotsElapsed = Math.max(slot - this.state.lastUpdate.slot.toNumber(), 0);
     if (slotsElapsed > SLOTS_PER_DAY) {
       return new Decimal(0);
     } else {
@@ -417,7 +367,7 @@ export class KaminoReserve {
     return new Decimal(this.state.config.borrowFactorPct.toString()).div(100);
   }
 
-  calculateSupplyAPR(slot: Slot, referralFeeBps: number) {
+  calculateSupplyAPR(slot: number, referralFeeBps: number) {
     const currentUtilization = this.calculateUtilizationRatio();
 
     const borrowRate = this.calculateEstimatedBorrowRate(slot, referralFeeBps);
@@ -425,11 +375,11 @@ export class KaminoReserve {
     return currentUtilization * borrowRate * protocolTakeRatePct;
   }
 
-  getEstimatedDebtAndSupply(slot: Slot, referralFeeBps: number): { totalBorrow: Decimal; totalSupply: Decimal } {
-    const slotsElapsed = maxBigInt(slot - BigInt(this.state.lastUpdate.slot.toNumber()), 0n);
+  getEstimatedDebtAndSupply(slot: number, referralFeeBps: number): { totalBorrow: Decimal; totalSupply: Decimal } {
+    const slotsElapsed = Math.max(slot - this.state.lastUpdate.slot.toNumber(), 0);
     let totalBorrow: Decimal;
     let totalSupply: Decimal;
-    if (slotsElapsed === 0n) {
+    if (slotsElapsed === 0) {
       totalBorrow = this.getBorrowedAmount();
       totalSupply = this.getTotalSupply();
     } else {
@@ -446,14 +396,14 @@ export class KaminoReserve {
   }
 
   getEstimatedAccumulatedProtocolFees(
-    slot: Slot,
+    slot: number,
     referralFeeBps: number
   ): { accumulatedProtocolFees: Decimal; compoundedVariableProtocolFee: Decimal; compoundedFixedHostFee: Decimal } {
-    const slotsElapsed = maxBigInt(slot - BigInt(this.state.lastUpdate.slot.toString()), 0n);
+    const slotsElapsed = Math.max(slot - this.state.lastUpdate.slot.toNumber(), 0);
     let accumulatedProtocolFees: Decimal;
     let compoundedVariableProtocolFee: Decimal;
     let compoundedFixedHostFee: Decimal;
-    if (slotsElapsed === 0n) {
+    if (slotsElapsed === 0) {
       accumulatedProtocolFees = this.getAccumulatedProtocolFees();
       compoundedVariableProtocolFee = new Decimal(0);
       compoundedFixedHostFee = new Decimal(0);
@@ -478,7 +428,7 @@ export class KaminoReserve {
     return totalBorrows.dividedBy(totalSupply).toNumber();
   }
 
-  getEstimatedUtilizationRatio(slot: Slot, referralFeeBps: number): number {
+  getEstimatedUtilizationRatio(slot: number, referralFeeBps: number): number {
     const { totalBorrow: estimatedTotalBorrowed, totalSupply: estimatedTotalSupply } = this.getEstimatedDebtAndSupply(
       slot,
       referralFeeBps
@@ -493,7 +443,7 @@ export class KaminoReserve {
   calcSimulatedUtilizationRatio(
     amount: Decimal,
     action: ActionType,
-    slot: Slot,
+    slot: number,
     referralFeeBps: number,
     outflowAmount?: Decimal
   ): number {
@@ -549,7 +499,7 @@ export class KaminoReserve {
     }
   }
 
-  getMaxBorrowAmountWithCollReserve(market: KaminoMarket, collReserve: KaminoReserve, slot: Slot): Decimal {
+  getMaxBorrowAmountWithCollReserve(market: KaminoMarket, collReserve: KaminoReserve, slot: number): Decimal {
     const groups = market.state.elevationGroups;
     const commonElevationGroups = market.getCommonElevationGroupsForPair(collReserve, this);
 
@@ -624,7 +574,7 @@ export class KaminoReserve {
   calcSimulatedBorrowRate(
     amount: Decimal,
     action: ActionType,
-    slot: Slot,
+    slot: number,
     referralFeeBps: number,
     outflowAmount?: Decimal
   ) {
@@ -637,7 +587,7 @@ export class KaminoReserve {
   calcSimulatedBorrowAPR(
     amount: Decimal,
     action: ActionType,
-    slot: Slot,
+    slot: number,
     referralFeeBps: number,
     outflowAmount?: Decimal
   ) {
@@ -650,7 +600,7 @@ export class KaminoReserve {
   calcSimulatedSupplyAPR(
     amount: Decimal,
     action: ActionType,
-    slot: Slot,
+    slot: number,
     referralFeeBps: number,
     outflowAmount?: Decimal
   ) {
@@ -673,14 +623,14 @@ export class KaminoReserve {
     return getBorrowRate(currentUtilization, curve) * slotAdjustmentFactor;
   }
 
-  calculateEstimatedBorrowRate(slot: Slot, referralFeeBps: number) {
+  calculateEstimatedBorrowRate(slot: number, referralFeeBps: number) {
     const slotAdjustmentFactor = this.slotAdjustmentFactor();
     const estimatedCurrentUtilization = this.getEstimatedUtilizationRatio(slot, referralFeeBps);
     const curve = truncateBorrowCurve(this.state.config.borrowRateCurve.points);
     return getBorrowRate(estimatedCurrentUtilization, curve) * slotAdjustmentFactor;
   }
 
-  calculateBorrowAPR(slot: Slot, referralFeeBps: number) {
+  calculateBorrowAPR(slot: number, referralFeeBps: number) {
     const slotAdjustmentFactor = this.slotAdjustmentFactor();
     const borrowRate = this.calculateEstimatedBorrowRate(slot, referralFeeBps);
     return borrowRate + this.getFixedHostInterestRate().toNumber() * slotAdjustmentFactor;
@@ -689,21 +639,21 @@ export class KaminoReserve {
   /**
    * @returns the mint of the reserve liquidity token
    */
-  getLiquidityMint(): Address {
+  getLiquidityMint(): PublicKey {
     return this.state.liquidity.mintPubkey;
   }
 
   /**
    * @returns the token program of the reserve liquidity mint
    */
-  getLiquidityTokenProgram(): Address {
+  getLiquidityTokenProgram(): PublicKey {
     return this.state.liquidity.tokenProgram;
   }
 
   /**
    * @returns the mint of the reserve collateral token , i.e. the cToken minted for depositing the liquidity token
    */
-  getCTokenMint(): Address {
+  getCTokenMint(): PublicKey {
     return this.state.collateral.mintPubkey;
   }
 
@@ -754,8 +704,20 @@ export class KaminoReserve {
     );
   }
 
+  setBuffer(buffer: AccountInfo<Buffer> | null) {
+    this.buffer = buffer;
+  }
+
   async load(tokenOraclePrice: TokenOracleData) {
-    const parsedData = await Reserve.fetch(this.rpc, this.address);
+    if (!this.buffer) {
+      this.setBuffer(await this.connection.getAccountInfo(this.address, 'processed'));
+    }
+
+    if (!this.buffer) {
+      throw Error(`Error requesting account info for ${this.symbol}`);
+    }
+
+    const parsedData = await Reserve.fetch(this.connection, this.address);
     if (!parsedData) {
       throw Error(`Unable to parse data of reserve ${this.symbol}`);
     }
@@ -764,7 +726,7 @@ export class KaminoReserve {
     this.stats = this.formatReserveData(parsedData);
   }
 
-  totalSupplyAPY(currentSlot: Slot) {
+  totalSupplyAPY(currentSlot: number) {
     const { stats } = this;
     if (!stats) {
       throw Error('KaminoMarket must call loadRewards.');
@@ -773,7 +735,7 @@ export class KaminoReserve {
     return calculateAPYFromAPR(this.calculateSupplyAPR(currentSlot, 0));
   }
 
-  totalBorrowAPY(currentSlot: Slot) {
+  totalBorrowAPY(currentSlot: number) {
     const { stats } = this;
     if (!stats) {
       throw Error('KaminoMarket must call loadRewards.');
@@ -785,16 +747,14 @@ export class KaminoReserve {
   async loadFarmStates() {
     if (!this.farmData.fetched) {
       const farmStates: FarmState[] = [];
-      const debtFarmAddress = this.getDebtFarmAddress();
-      if (isSome(debtFarmAddress)) {
-        const farmState = await FarmState.fetch(this.rpc, debtFarmAddress.value);
+      if (!this.state.farmDebt.equals(PublicKey.default)) {
+        const farmState = await FarmState.fetch(this.connection, this.state.farmDebt);
         if (farmState !== null) {
           farmStates.push(farmState);
         }
       }
-      const collateralFarmAddress = this.getCollateralFarmAddress();
-      if (isSome(collateralFarmAddress)) {
-        const farmState = await FarmState.fetch(this.rpc, collateralFarmAddress.value);
+      if (!this.state.farmCollateral.equals(PublicKey.default)) {
+        const farmState = await FarmState.fetch(this.connection, this.state.farmCollateral);
         if (farmState !== null) {
           farmStates.push(farmState);
         }
@@ -810,12 +770,12 @@ export class KaminoReserve {
       throw Error('KaminoMarket must call loadReserves.');
     }
 
-    const isDebtReward = this.state.farmDebt === this.address;
+    const isDebtReward = this.state.farmDebt.equals(this.address);
     await this.loadFarmStates();
     const yields: ReserveRewardYield[] = [];
     for (const farmState of this.farmData.farmStates) {
       for (const rewardInfo of farmState.rewardInfos.filter(
-        (x) => x.token.mint !== DEFAULT_PUBLIC_KEY && !x.rewardsAvailable.isZero()
+        (x) => !x.token.mint.equals(PublicKey.default) && !x.rewardsAvailable.isZero()
       )) {
         const { apy, apr } = this.calculateRewardYield(prices, rewardInfo, isDebtReward);
         if (apy.isZero() && apr.isZero()) {
@@ -932,7 +892,7 @@ export class KaminoReserve {
    * @param referralFeeBps
    */
   private compoundInterest(
-    slotsElapsed: bigint,
+    slotsElapsed: number,
     referralFeeBps: number
   ): {
     newDebt: Decimal;
@@ -991,32 +951,32 @@ export class KaminoReserve {
    * @param elapsedSlots
    * @private
    */
-  private approximateCompoundedInterest(rate: Decimal, elapsedSlots: bigint): Decimal {
+  private approximateCompoundedInterest(rate: Decimal, elapsedSlots: number): Decimal {
     const base = rate.div(SLOTS_PER_YEAR);
     switch (elapsedSlots) {
-      case 0n:
+      case 0:
         return new Decimal(1);
-      case 1n:
+      case 1:
         return base.add(1);
-      case 2n:
+      case 2:
         return base.add(1).mul(base.add(1));
-      case 3n:
+      case 3:
         return base.add(1).mul(base.add(1)).mul(base.add(1));
-      case 4n:
+      case 4:
         // eslint-disable-next-line no-case-declarations
         const pow2 = base.add(1).mul(base.add(1));
         return pow2.mul(pow2);
     }
     const exp = elapsedSlots;
-    const expMinus1 = exp - 1n;
-    const expMinus2 = exp - 2n;
+    const expMinus1 = exp - 1;
+    const expMinus2 = exp - 2;
 
     const basePow2 = base.mul(base);
     const basePow3 = basePow2.mul(base);
 
-    const firstTerm = base.mul(exp.toString());
-    const secondTerm = basePow2.mul(exp.toString()).mul(expMinus1.toString()).div(2);
-    const thirdTerm = basePow3.mul(exp.toString()).mul(expMinus1.toString()).mul(expMinus2.toString()).div(6);
+    const firstTerm = base.mul(exp);
+    const secondTerm = basePow2.mul(exp).mul(expMinus1).div(2);
+    const thirdTerm = basePow3.mul(exp).mul(expMinus1).mul(expMinus2).div(6);
 
     return new Decimal(1).add(firstTerm).add(secondTerm).add(thirdTerm);
   }
@@ -1031,16 +991,16 @@ export class KaminoReserve {
 
     // Debt against collaterals in elevation groups
     const debtAgainstCollateralReserveCaps: {
-      collateralReserve: Address;
+      collateralReserve: PublicKey;
       elevationGroup: number;
       maxDebt: Decimal;
       currentValue: Decimal;
     }[] = market
       .getMarketElevationGroupDescriptions()
-      .filter((x) => x.debtReserve === this.address)
+      .filter((x) => x.debtReserve.equals(this.address))
       .map((elevationGroupDescription: ElevationGroupDescription) =>
-        [...elevationGroupDescription.collateralReserves].map((collateralReserveAddress) => {
-          const collRes = market.reserves.get(collateralReserveAddress)!;
+        elevationGroupDescription.collateralReserves.toArray().map((collateralReserveAddress) => {
+          const collRes = market.reserves.get(new PublicKey(collateralReserveAddress))!;
 
           const debtLimitAgainstThisCollInGroup =
             collRes.state.config.borrowLimitAgainstThisCollateralInElevationGroup[
@@ -1091,7 +1051,7 @@ export class KaminoReserve {
   getLiquidityAvailableForDebtReserveGivenCaps(
     market: KaminoMarket,
     elevationGroups: number[],
-    collateralReserves: Address[] = []
+    collateralReserves: PublicKey[] = []
   ): Decimal[] {
     const caps = this.getBorrowCapForReserve(market);
 
@@ -1131,7 +1091,7 @@ export class KaminoReserve {
           remainingInsideEmodeCaps = Decimal.min(
             ...capsGivenEgroup.map((x) => {
               // check reserve is part of collReserves array
-              if (collateralReserves.find((collateralReserve) => collateralReserve === x.collateralReserve)) {
+              if (collateralReserves.find((collateralReserve) => collateralReserve.equals(x.collateralReserve))) {
                 return x.maxDebt.minus(x.currentValue);
               } else {
                 return new Decimal(U64_MAX);
@@ -1166,46 +1126,46 @@ const truncateBorrowCurve = (points: CurvePointFields[]): [number, number][] =>
 };
 
 export async function createReserveIxs(
-  rpc: Rpc<GetMinimumBalanceForRentExemptionApi>,
-  owner: TransactionSigner,
-  ownerLiquiditySource: Address,
-  lendingMarket: Address,
-  liquidityMint: Address,
-  liquidityMintTokenProgram: Address,
-  reserveAddress: TransactionSigner,
-  programId: Address
-): Promise<IInstruction[]> {
-  const size = BigInt(Reserve.layout.span + 8);
-  const createReserveIx = getCreateAccountInstruction({
-    payer: owner,
+  connection: Connection,
+  owner: PublicKey,
+  ownerLiquiditySource: PublicKey,
+  lendingMarket: PublicKey,
+  liquidityMint: PublicKey,
+  reserveAddress: PublicKey,
+  programId: PublicKey
+): Promise<TransactionInstruction[]> {
+  const size = Reserve.layout.span + 8;
+
+  const createReserveIx = SystemProgram.createAccount({
+    fromPubkey: owner,
+    newAccountPubkey: reserveAddress,
+    lamports: await connection.getMinimumBalanceForRentExemption(size),
     space: size,
-    lamports: await rpc.getMinimumBalanceForRentExemption(size).send(),
-    programAddress: programId,
-    newAccount: reserveAddress,
+    programId: programId,
   });
 
-  const { liquiditySupplyVault, collateralMint, collateralSupplyVault, feeVault } = await reservePdas(
+  const { liquiditySupplyVault, collateralMint, collateralSupplyVault, feeVault } = reservePdas(
     programId,
     lendingMarket,
     liquidityMint
   );
-  const [lendingMarketAuthority] = await lendingMarketAuthPda(lendingMarket, programId);
+  const [lendingMarketAuthority, _] = lendingMarketAuthPda(lendingMarket, programId);
 
   const accounts: InitReserveAccounts = {
     lendingMarketOwner: owner,
     lendingMarket: lendingMarket,
     lendingMarketAuthority: lendingMarketAuthority,
-    reserve: reserveAddress.address,
+    reserve: reserveAddress,
     reserveLiquidityMint: liquidityMint,
     reserveLiquiditySupply: liquiditySupplyVault,
     feeReceiver: feeVault,
     reserveCollateralMint: collateralMint,
     reserveCollateralSupply: collateralSupplyVault,
     initialLiquiditySource: ownerLiquiditySource,
-    liquidityTokenProgram: liquidityMintTokenProgram,
-    collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
-    systemProgram: SYSTEM_PROGRAM_ADDRESS,
-    rent: SYSVAR_RENT_ADDRESS,
+    liquidityTokenProgram: TOKEN_PROGRAM_ID,
+    collateralTokenProgram: TOKEN_PROGRAM_ID,
+    systemProgram: SystemProgram.programId,
+    rent: SYSVAR_RENT_PUBKEY,
   };
 
   const initReserveIx = initReserve(accounts, programId);
@@ -1213,22 +1173,22 @@ export async function createReserveIxs(
   return [createReserveIx, initReserveIx];
 }
 
-export async function updateReserveConfigIx(
-  signer: TransactionSigner,
-  marketAddress: Address,
-  reserveAddress: Address,
+export function updateReserveConfigIx(
+  signer: PublicKey,
+  marketAddress: PublicKey,
+  reserveAddress: PublicKey,
   mode: UpdateConfigModeKind,
   value: Uint8Array,
-  programId: Address,
+  programId: PublicKey,
   skipConfigIntegrityValidation: boolean = false
-): Promise<IInstruction> {
+): TransactionInstruction {
   const args: UpdateReserveConfigArgs = {
     mode,
     value,
     skipConfigIntegrityValidation,
   };
 
-  const globalConfig = await globalConfigPda(programId);
+  const [globalConfig] = globalConfigPda(programId);
   const accounts: UpdateReserveConfigAccounts = {
     signer,
     lendingMarket: marketAddress,
@@ -1299,20 +1259,20 @@ export const RESERVE_CONFIG_UPDATER = new ConfigUpdater(UpdateConfigMode.fromDec
   [UpdateConfigMode.UpdateProtocolOrderExecutionFee.kind]: config.protocolOrderExecutionFeePct,
 }));
 
-export async function updateEntireReserveConfigIx(
-  signer: TransactionSigner,
-  marketAddress: Address,
-  reserveAddress: Address,
+export function updateEntireReserveConfigIx(
+  signer: PublicKey,
+  marketAddress: PublicKey,
+  reserveAddress: PublicKey,
   reserveConfig: ReserveConfig,
-  programId: Address
-): Promise<IInstruction> {
+  programId: PublicKey
+): TransactionInstruction {
   const args: UpdateReserveConfigArgs = {
     mode: new UpdateConfigMode.UpdateEntireReserveConfig(),
     value: encodeUsingLayout(ReserveConfig.layout(), reserveConfig),
     skipConfigIntegrityValidation: false,
   };
 
-  const globalConfig = await globalConfigPda(programId);
+  const [globalConfig] = globalConfigPda(programId);
   const accounts: UpdateReserveConfigAccounts = {
     signer,
     lendingMarket: marketAddress,
@@ -1328,30 +1288,27 @@ export async function updateEntireReserveConfigIx(
 export function parseForChangesReserveConfigAndGetIxs(
   marketWithAddress: MarketWithAddress,
   reserve: Reserve | undefined,
-  reserveAddress: Address,
+  reserveAddress: PublicKey,
   reserveConfig: ReserveConfig,
-  programId: Address,
-  lendingMarketOwner: TransactionSigner = noopSigner(marketWithAddress.state.lendingMarketOwner)
-): Promise<IInstruction[]> {
+  programId: PublicKey
+) {
   const encodedConfigUpdates = RESERVE_CONFIG_UPDATER.encodeAllUpdates(reserve?.config, reserveConfig);
   encodedConfigUpdates.sort((left, right) => priorityOf(left.mode) - priorityOf(right.mode));
-  return Promise.all(
-    encodedConfigUpdates.map(async (encodedConfigUpdate) =>
-      updateReserveConfigIx(
-        lendingMarketOwner,
-        marketWithAddress.address,
-        reserveAddress,
-        encodedConfigUpdate.mode,
-        encodedConfigUpdate.value,
-        programId,
-        shouldSkipValidation(encodedConfigUpdate.mode, reserve)
-      )
+  return encodedConfigUpdates.map((encodedConfigUpdate) =>
+    updateReserveConfigIx(
+      marketWithAddress.state.lendingMarketOwner,
+      marketWithAddress.address,
+      reserveAddress,
+      encodedConfigUpdate.mode,
+      encodedConfigUpdate.value,
+      programId,
+      shouldSkipValidation(encodedConfigUpdate.mode, reserve)
     )
   );
 }
 
 export type ReserveWithAddress = {
-  address: Address;
+  address: PublicKey;
   state: Reserve;
 };