@kamino-finance/klend-sdk 5.13.21-beta.0 → 5.13.22

package/src/classes/farm_utils.ts

@@ -1,3 +1,4 @@
+import { BN } from '@coral-xyz/anchor';
 import {
   Farms,
   FarmState,
@@ -74,9 +75,8 @@ export async function getFarmUnstakeIx(
     throw new Error(`User state not found for ${user}`);
   }
 
-  const x = new Decimal(lamportsToUnstake.toString()).mul(WAD);
-  console.log('lamportsToUnstake', lamportsToUnstake.toString());
-  return farmClient.unstakeIx(user, farmAddress, x.toString(), scopePricesArg);
+  const scaledLamportsToUnstake = new BN(lamportsToUnstake.floor().toString()).mul(new BN(WAD.toString()));
+  return farmClient.unstakeIx(user, farmAddress, scaledLamportsToUnstake.toString(), scopePricesArg);
 }
 
 // withdrawing from a farm is a 2 step operation: first we unstake the tokens from the farm, then we withdraw them
@@ -127,6 +127,14 @@ export async function getUserSharesInFarm(
   farmTokenDecimals: number
 ): Promise<Decimal> {
   const farmClient = new Farms(connection);
+  const userStatePDA = getUserStatePDA(farmClient.getProgramID(), farm, user);
+  // if the user state does not exist, return 0
+  const userState = await connection.getAccountInfo(userStatePDA);
+  if (!userState) {
+    return new Decimal(0);
+  }
+
+  // if the user state exists, return the user shares
   return farmClient.getUserTokensInUndelegatedFarm(user, farm, farmTokenDecimals);
 }
 

package/src/classes/manager.ts

@@ -28,6 +28,7 @@ import {
 } from './vault';
 import {
   AddAssetToMarketParams,
+  assertNever,
   CreateKaminoMarketParams,
   createReserveIxs,
   ENV,
@@ -44,6 +45,7 @@ import {
   KaminoReserve,
   LendingMarket,
   lendingMarketAuthPda,
+  LendingMarketFields,
   MarketWithAddress,
   parseForChangesReserveConfigAndGetIxs,
   parseOracleType,
@@ -51,6 +53,7 @@ import {
   PubkeyHashMap,
   Reserve,
   ReserveWithAddress,
+  sameLengthArrayEquals,
   ScopeOracleConfig,
   updateEntireReserveConfigIx,
   updateLendingMarket,
@@ -62,7 +65,12 @@ import {
 import { PROGRAM_ID } from '../idl_codegen/programId';
 import { Scope, TokenMetadatas, U16_MAX } from '@kamino-finance/scope-sdk';
 import BN from 'bn.js';
-import { ReserveConfig, UpdateLendingMarketMode, UpdateLendingMarketModeKind } from '../idl_codegen/types';
+import {
+  ElevationGroup,
+  ReserveConfig,
+  UpdateLendingMarketMode,
+  UpdateLendingMarketModeKind,
+} from '../idl_codegen/types';
 import Decimal from 'decimal.js';
 import * as anchor from '@coral-xyz/anchor';
 import { VaultState } from '../idl_codegen_kamino_vault/accounts';
@@ -88,7 +96,6 @@ import { FarmState } from '@kamino-finance/farms-sdk/dist';
 import SwitchboardProgram from '@switchboard-xyz/sbv2-lite';
 import { getSquadsMultisigAdminsAndThreshold, walletIsSquadsMultisig, WalletType } from '../utils/multisig';
 import { decodeVaultState } from '../utils/vault';
-import { arrayElementConfigItems, ConfigUpdater } from './configItems';
 
 /**
  * KaminoManager is a class that provides a high-level interface to interact with the Kamino Lend and Kamino Vault programs, in order to create and manage a market, as well as vaults
@@ -384,15 +391,7 @@ export class KaminoManager {
     const ixs: TransactionInstruction[] = [];
 
     if (!reserveState || updateEntireConfig) {
-      ixs.push(
-        updateEntireReserveConfigIx(
-          marketWithAddress.state.lendingMarketOwner,
-          marketWithAddress.address,
-          reserve,
-          config,
-          this._kaminoLendProgramId
-        )
-      );
+      ixs.push(updateEntireReserveConfigIx(marketWithAddress, reserve, config, this._kaminoLendProgramId));
     } else {
       ixs.push(
         ...parseForChangesReserveConfigAndGetIxs(
@@ -658,9 +657,9 @@ export class KaminoManager {
    * Get all lending markets
    * @returns an array of all lending markets
    */
-  async getAllMarkets(): Promise<KaminoMarket[]> {
+  async getAllMarkets(programId: PublicKey = PROGRAM_ID): Promise<KaminoMarket[]> {
     // Get all lending markets
-    const marketGenerator = getAllLendingMarketAccounts(this.getConnection());
+    const marketGenerator = getAllLendingMarketAccounts(this.getConnection(), programId);
     const slotDuration = await getMedianSlotDurationInMsFromLastEpochs();
 
     const lendingMarketPairs: [PublicKey, LendingMarket][] = [];
@@ -1014,6 +1013,13 @@ export class KaminoManager {
     return this._vaultClient.calculateSimulatedFees(vaultState, simulatedCurrentHoldingsWithInterest, currentTimestamp);
   }
 
+  /**
+   * This will compute the PDA that is used as delegatee in Farms program to compute the user state PDA
+   */
+  computeUserFarmStateForUserInVault(farmProgramID: PublicKey, vault: PublicKey, reserve: PublicKey, user: PublicKey) {
+    return this._vaultClient.computeUserFarmStateDelegateePDAForUserInVault(farmProgramID, reserve, vault, user);
+  }
+
   /**
    * This will load the onchain state for all the reserves that the vault has allocations for
    * @param vaultState - the vault state to load reserves for
@@ -1248,51 +1254,383 @@ export class KaminoManager {
     };
   }
 } // KaminoManager
+export type BaseLendingMarketKey = keyof LendingMarketFields;
+const EXCLUDED_LENDING_MARKET_KEYS = [
+  'version',
+  'bumpSeed',
+  'reserved0',
+  'reserved1',
+  'padding1',
+  'padding2',
+  'elevationGroupPadding',
+  'quoteCurrency',
+] as const;
+export type ExcludedLendingMarketKey = (typeof EXCLUDED_LENDING_MARKET_KEYS)[number];
+
+function isExcludedLendingMarketKey(value: unknown): value is ExcludedLendingMarketKey {
+  return EXCLUDED_LENDING_MARKET_KEYS.includes(value as ExcludedLendingMarketKey);
+}
 
-export const MARKET_UPDATER = new ConfigUpdater(UpdateLendingMarketMode.fromDecoded, LendingMarket, (config) => ({
-  [UpdateLendingMarketMode.UpdateOwner.kind]: config.lendingMarketOwnerCached,
-  [UpdateLendingMarketMode.UpdateImmutableFlag.kind]: config.immutable,
-  [UpdateLendingMarketMode.UpdateEmergencyMode.kind]: config.emergencyMode,
-  [UpdateLendingMarketMode.UpdateLiquidationCloseFactor.kind]: config.liquidationMaxDebtCloseFactorPct,
-  [UpdateLendingMarketMode.UpdateLiquidationMaxValue.kind]: config.maxLiquidatableDebtMarketValueAtOnce,
-  [UpdateLendingMarketMode.DeprecatedUpdateGlobalUnhealthyBorrow.kind]: [], // deprecated
-  [UpdateLendingMarketMode.UpdateGlobalAllowedBorrow.kind]: config.globalAllowedBorrowValue,
-  [UpdateLendingMarketMode.UpdateRiskCouncil.kind]: config.riskCouncil,
-  [UpdateLendingMarketMode.UpdateMinFullLiquidationThreshold.kind]: config.minFullLiquidationValueThreshold,
-  [UpdateLendingMarketMode.UpdateInsolvencyRiskLtv.kind]: config.insolvencyRiskUnhealthyLtvPct,
-  [UpdateLendingMarketMode.UpdateElevationGroup.kind]: arrayElementConfigItems(config.elevationGroups),
-  [UpdateLendingMarketMode.UpdateReferralFeeBps.kind]: config.referralFeeBps,
-  [UpdateLendingMarketMode.DeprecatedUpdateMultiplierPoints.kind]: [], // deprecated
-  [UpdateLendingMarketMode.UpdatePriceRefreshTriggerToMaxAgePct.kind]: config.priceRefreshTriggerToMaxAgePct,
-  [UpdateLendingMarketMode.UpdateAutodeleverageEnabled.kind]: config.autodeleverageEnabled,
-  [UpdateLendingMarketMode.UpdateBorrowingDisabled.kind]: config.borrowDisabled,
-  [UpdateLendingMarketMode.UpdateMinNetValueObligationPostAction.kind]: config.minNetValueInObligationSf,
-  [UpdateLendingMarketMode.UpdateMinValueLtvSkipPriorityLiqCheck.kind]: config.minValueSkipLiquidationLtvChecks,
-  [UpdateLendingMarketMode.UpdateMinValueBfSkipPriorityLiqCheck.kind]: config.minValueSkipLiquidationBfChecks,
-  [UpdateLendingMarketMode.UpdatePaddingFields.kind]: [], // we do not update padding this way
-  [UpdateLendingMarketMode.UpdateName.kind]: config.name,
-  [UpdateLendingMarketMode.UpdateIndividualAutodeleverageMarginCallPeriodSecs.kind]:
-    config.individualAutodeleverageMarginCallPeriodSecs,
-  [UpdateLendingMarketMode.UpdateInitialDepositAmount.kind]: config.minInitialDepositAmount,
-  [UpdateLendingMarketMode.UpdateObligationOrderCreationEnabled.kind]: config.obligationOrderCreationEnabled,
-  [UpdateLendingMarketMode.UpdateObligationOrderExecutionEnabled.kind]: config.obligationOrderExecutionEnabled,
-}));
+export type LendingMarketKey = Exclude<BaseLendingMarketKey, ExcludedLendingMarketKey>;
+
+const updateLendingMarketConfig = (
+  key: LendingMarketKey,
+  market: LendingMarket,
+  newMarket: LendingMarket
+): { mode: number; value: Buffer }[] => {
+  const updateLendingMarketIxsArgs: { mode: number; value: Buffer }[] = [];
+  switch (key) {
+    case 'lendingMarketOwner': {
+      if (!market.lendingMarketOwner.equals(newMarket.lendingMarketOwner)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateOwner.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateOwner.discriminator,
+            newMarket.lendingMarketOwner
+          ),
+        });
+      }
+      break;
+    }
+    case 'lendingMarketOwnerCached':
+      if (!market.lendingMarketOwnerCached.equals(newMarket.lendingMarketOwnerCached)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateOwner.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateOwner.discriminator,
+            newMarket.lendingMarketOwnerCached
+          ),
+        });
+      }
+      break;
+    case 'referralFeeBps':
+      if (market.referralFeeBps !== newMarket.referralFeeBps) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateReferralFeeBps.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateReferralFeeBps.discriminator,
+            newMarket.referralFeeBps
+          ),
+        });
+      }
+      break;
+    case 'emergencyMode':
+      if (market.emergencyMode !== newMarket.emergencyMode) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateEmergencyMode.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateEmergencyMode.discriminator,
+            newMarket.emergencyMode
+          ),
+        });
+      }
+      break;
+    case 'autodeleverageEnabled':
+      if (market.autodeleverageEnabled !== newMarket.autodeleverageEnabled) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateAutodeleverageEnabled.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateAutodeleverageEnabled.discriminator,
+            newMarket.autodeleverageEnabled
+          ),
+        });
+      }
+      break;
+    case 'borrowDisabled':
+      if (market.borrowDisabled !== newMarket.borrowDisabled) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateBorrowingDisabled.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateBorrowingDisabled.discriminator,
+            newMarket.borrowDisabled
+          ),
+        });
+      }
+      break;
+    case 'priceRefreshTriggerToMaxAgePct':
+      if (market.priceRefreshTriggerToMaxAgePct !== newMarket.priceRefreshTriggerToMaxAgePct) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdatePriceRefreshTriggerToMaxAgePct.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdatePriceRefreshTriggerToMaxAgePct.discriminator,
+            newMarket.priceRefreshTriggerToMaxAgePct
+          ),
+        });
+      }
+      break;
+    case 'liquidationMaxDebtCloseFactorPct':
+      if (market.liquidationMaxDebtCloseFactorPct !== newMarket.liquidationMaxDebtCloseFactorPct) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateLiquidationCloseFactor.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateLiquidationCloseFactor.discriminator,
+            newMarket.liquidationMaxDebtCloseFactorPct
+          ),
+        });
+      }
+      break;
+    case 'insolvencyRiskUnhealthyLtvPct':
+      if (market.insolvencyRiskUnhealthyLtvPct !== newMarket.insolvencyRiskUnhealthyLtvPct) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateInsolvencyRiskLtv.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateInsolvencyRiskLtv.discriminator,
+            newMarket.insolvencyRiskUnhealthyLtvPct
+          ),
+        });
+      }
+      break;
+    case 'minFullLiquidationValueThreshold':
+      if (!market.minFullLiquidationValueThreshold.eq(newMarket.minFullLiquidationValueThreshold)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateMinFullLiquidationThreshold.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateMinFullLiquidationThreshold.discriminator,
+            newMarket.minFullLiquidationValueThreshold.toNumber()
+          ),
+        });
+      }
+      break;
+    case 'maxLiquidatableDebtMarketValueAtOnce':
+      if (!market.maxLiquidatableDebtMarketValueAtOnce.eq(newMarket.maxLiquidatableDebtMarketValueAtOnce)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateLiquidationMaxValue.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateLiquidationMaxValue.discriminator,
+            newMarket.maxLiquidatableDebtMarketValueAtOnce.toNumber()
+          ),
+        });
+      }
+      break;
+    case 'globalAllowedBorrowValue':
+      if (!market.globalAllowedBorrowValue.eq(newMarket.globalAllowedBorrowValue)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateGlobalAllowedBorrow.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateGlobalAllowedBorrow.discriminator,
+            newMarket.globalAllowedBorrowValue.toNumber()
+          ),
+        });
+      }
+      break;
+    case 'riskCouncil':
+      if (!market.riskCouncil.equals(newMarket.riskCouncil)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateRiskCouncil.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateRiskCouncil.discriminator,
+            newMarket.riskCouncil
+          ),
+        });
+      }
+      break;
+    case 'elevationGroups':
+      let elevationGroupsDiffs = 0;
+      for (let i = 0; i < market.elevationGroups.length; i++) {
+        if (
+          market.elevationGroups[i].id !== newMarket.elevationGroups[i].id ||
+          market.elevationGroups[i].maxLiquidationBonusBps !== newMarket.elevationGroups[i].maxLiquidationBonusBps ||
+          market.elevationGroups[i].ltvPct !== newMarket.elevationGroups[i].ltvPct ||
+          market.elevationGroups[i].liquidationThresholdPct !== newMarket.elevationGroups[i].liquidationThresholdPct ||
+          market.elevationGroups[i].allowNewLoans !== newMarket.elevationGroups[i].allowNewLoans ||
+          market.elevationGroups[i].maxReservesAsCollateral !== newMarket.elevationGroups[i].maxReservesAsCollateral ||
+          !market.elevationGroups[i].debtReserve.equals(newMarket.elevationGroups[i].debtReserve)
+        ) {
+          updateLendingMarketIxsArgs.push({
+            mode: UpdateLendingMarketMode.UpdateElevationGroup.discriminator,
+            value: updateMarketConfigEncodedValue(
+              UpdateLendingMarketMode.UpdateElevationGroup.discriminator,
+              newMarket.elevationGroups[i]
+            ),
+          });
+          elevationGroupsDiffs++;
+        }
+      }
+      if (elevationGroupsDiffs > 1) {
+        throw new Error('Can only update 1 elevation group at a time');
+      }
+      break;
+    case 'minNetValueInObligationSf':
+      if (!market.minNetValueInObligationSf.eq(newMarket.minNetValueInObligationSf)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateMinNetValueObligationPostAction.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateMinNetValueObligationPostAction.discriminator,
+            newMarket.minNetValueInObligationSf.toString()
+          ),
+        });
+      }
+      break;
+    case 'minValueSkipLiquidationBfChecks':
+      if (!market.minValueSkipLiquidationBfChecks.eq(newMarket.minValueSkipLiquidationBfChecks)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateMinValueBfSkipPriorityLiqCheck.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateMinValueBfSkipPriorityLiqCheck.discriminator,
+            newMarket.minValueSkipLiquidationBfChecks.toNumber()
+          ),
+        });
+      }
+      break;
+    case 'minValueSkipLiquidationLtvChecks':
+      if (!market.minValueSkipLiquidationLtvChecks.eq(newMarket.minValueSkipLiquidationLtvChecks)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateMinValueLtvSkipPriorityLiqCheck.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateMinValueLtvSkipPriorityLiqCheck.discriminator,
+            newMarket.minValueSkipLiquidationLtvChecks.toNumber()
+          ),
+        });
+      }
+      break;
+    case 'individualAutodeleverageMarginCallPeriodSecs':
+      if (
+        market.individualAutodeleverageMarginCallPeriodSecs !== newMarket.individualAutodeleverageMarginCallPeriodSecs
+      ) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateIndividualAutodeleverageMarginCallPeriodSecs.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateIndividualAutodeleverageMarginCallPeriodSecs.discriminator,
+            newMarket.individualAutodeleverageMarginCallPeriodSecs.toNumber()
+          ),
+        });
+      }
+      break;
+    case 'name':
+      if (!sameLengthArrayEquals(market.name, newMarket.name)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateName.discriminator,
+          value: updateMarketConfigEncodedValue(UpdateLendingMarketMode.UpdateName.discriminator, newMarket.name),
+        });
+      }
+      break;
+    case 'minInitialDepositAmount':
+      if (!market.minInitialDepositAmount.eq(newMarket.minInitialDepositAmount)) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateInitialDepositAmount.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateInitialDepositAmount.discriminator,
+            newMarket.minInitialDepositAmount.toNumber()
+          ),
+        });
+      }
+      break;
+    case 'obligationOrdersEnabled':
+      if (market.obligationOrdersEnabled !== newMarket.obligationOrdersEnabled) {
+        updateLendingMarketIxsArgs.push({
+          mode: UpdateLendingMarketMode.UpdateObligationOrdersEnabled.discriminator,
+          value: updateMarketConfigEncodedValue(
+            UpdateLendingMarketMode.UpdateObligationOrdersEnabled.discriminator,
+            newMarket.obligationOrdersEnabled
+          ),
+        });
+      }
+      break;
+    default:
+      assertNever(key);
+  }
+  return updateLendingMarketIxsArgs;
+};
 
 function parseForChangesMarketConfigAndGetIxs(
   marketWithAddress: MarketWithAddress,
   newMarket: LendingMarket,
   programId: PublicKey
 ): TransactionInstruction[] {
-  const encodedMarketUpdates = MARKET_UPDATER.encodeAllUpdates(marketWithAddress.state, newMarket);
-  return encodedMarketUpdates.map((encodedMarketUpdate) =>
-    updateMarketConfigIx(marketWithAddress, encodedMarketUpdate.mode, encodedMarketUpdate.value, programId)
-  );
+  const market = marketWithAddress.state;
+  const updateLendingMarketIxsArgs: { mode: number; value: Buffer }[] = [];
+
+  for (const key in market.toJSON()) {
+    if (isExcludedLendingMarketKey(key)) {
+      continue;
+    }
+    updateLendingMarketIxsArgs.push(...updateLendingMarketConfig(key as LendingMarketKey, market, newMarket));
+  }
+
+  const ixs: TransactionInstruction[] = [];
+
+  updateLendingMarketIxsArgs.forEach((updateLendingMarketConfigArgs) => {
+    ixs.push(
+      updateMarketConfigIx(
+        marketWithAddress,
+        updateLendingMarketConfigArgs.mode,
+        updateLendingMarketConfigArgs.value,
+        programId
+      )
+    );
+  });
+
+  return ixs;
+}
+
+function updateMarketConfigEncodedValue(
+  discriminator: UpdateLendingMarketModeKind['discriminator'],
+  value: number | number[] | PublicKey | ElevationGroup | string
+): Buffer {
+  let buffer: Buffer = Buffer.alloc(72);
+  let pkBuffer: Buffer;
+  let valueBigInt: bigint;
+  let valueArray: number[];
+
+  switch (discriminator) {
+    case UpdateLendingMarketMode.UpdateEmergencyMode.discriminator:
+    case UpdateLendingMarketMode.UpdateLiquidationCloseFactor.discriminator:
+    case UpdateLendingMarketMode.UpdateInsolvencyRiskLtv.discriminator:
+    case UpdateLendingMarketMode.UpdatePriceRefreshTriggerToMaxAgePct.discriminator:
+    case UpdateLendingMarketMode.UpdateAutodeleverageEnabled.discriminator:
+    case UpdateLendingMarketMode.UpdateObligationOrdersEnabled.discriminator:
+    case UpdateLendingMarketMode.UpdateBorrowingDisabled.discriminator:
+      buffer.writeUIntLE(value as number, 0, 1);
+      break;
+    case UpdateLendingMarketMode.UpdateReferralFeeBps.discriminator:
+      buffer.writeUInt16LE(value as number, 0);
+      break;
+    case UpdateLendingMarketMode.UpdateLiquidationMaxValue.discriminator:
+    case UpdateLendingMarketMode.UpdateGlobalAllowedBorrow.discriminator:
+    case UpdateLendingMarketMode.UpdateMinFullLiquidationThreshold.discriminator:
+    case UpdateLendingMarketMode.UpdateMinValueBfSkipPriorityLiqCheck.discriminator:
+    case UpdateLendingMarketMode.UpdateMinValueLtvSkipPriorityLiqCheck.discriminator:
+    case UpdateLendingMarketMode.UpdateIndividualAutodeleverageMarginCallPeriodSecs.discriminator:
+    case UpdateLendingMarketMode.UpdateInitialDepositAmount.discriminator:
+      value = value as number;
+      buffer.writeBigUint64LE(BigInt(value), 0);
+      break;
+    case UpdateLendingMarketMode.UpdateOwner.discriminator:
+    case UpdateLendingMarketMode.UpdateRiskCouncil.discriminator:
+      pkBuffer = (value as PublicKey).toBuffer();
+      pkBuffer.copy(buffer, 0);
+      break;
+    case UpdateLendingMarketMode.UpdateElevationGroup.discriminator:
+      buffer = serializeElevationGroup(value as ElevationGroup);
+      break;
+    case UpdateLendingMarketMode.UpdateMinNetValueObligationPostAction.discriminator:
+      valueBigInt = BigInt(value as string);
+      for (let i = 0; i < 16; i++) {
+        buffer[15 - i] = Number((valueBigInt >> BigInt(i * 8)) & BigInt(0xff));
+      }
+      break;
+    case UpdateLendingMarketMode.UpdateName.discriminator:
+      valueArray = value as number[];
+      for (let i = 0; i < valueArray.length; i++) {
+        buffer.writeUIntLE(valueArray[i], i, 1);
+      }
+      break;
+    case UpdateLendingMarketMode.UpdatePaddingFields.discriminator:
+    case UpdateLendingMarketMode.DeprecatedUpdateGlobalUnhealthyBorrow.discriminator:
+    case UpdateLendingMarketMode.DeprecatedUpdateMultiplierPoints.discriminator:
+      // Deliberately skipped - we are not updating padding or deprecated fields using this method
+      break;
+    default:
+      assertNever(discriminator);
+  }
+
+  return buffer;
 }
 
 function updateMarketConfigIx(
   marketWithAddress: MarketWithAddress,
-  mode: UpdateLendingMarketModeKind,
-  value: Uint8Array,
+  modeDiscriminator: number,
+  value: Buffer,
   programId: PublicKey
 ): TransactionInstruction {
   const accounts: UpdateLendingMarketAccounts = {
@@ -1301,13 +1639,25 @@ function updateMarketConfigIx(
   };
 
   const args: UpdateLendingMarketArgs = {
-    mode: new anchor.BN(mode.discriminator),
-    // NOTE: the Market's update handler expects a `[u8; 72]` (contrary to e.g. the Reserve's update handler accepting
-    // `Vec<u8>`). Hence, we need to add explicit padding here:
-    value: [...value, ...Array(72 - value.length).fill(0)],
+    mode: new anchor.BN(modeDiscriminator),
+    value: [...value],
   };
 
   const ix = updateLendingMarket(args, accounts, programId);
 
   return ix;
 }
+
+function serializeElevationGroup(elevationGroup: ElevationGroup): Buffer {
+  const buffer = Buffer.alloc(72);
+  buffer.writeUInt16LE(elevationGroup.maxLiquidationBonusBps, 0);
+  buffer.writeUIntLE(elevationGroup.id, 2, 1);
+  buffer.writeUIntLE(elevationGroup.ltvPct, 3, 1);
+  buffer.writeUIntLE(elevationGroup.liquidationThresholdPct, 4, 1);
+  buffer.writeUIntLE(elevationGroup.allowNewLoans, 5, 1);
+  buffer.writeUIntLE(elevationGroup.maxReservesAsCollateral, 6, 1);
+  buffer.writeUIntLE(elevationGroup.padding0, 7, 1);
+  const debtReserveBuffer = elevationGroup.debtReserve.toBuffer();
+  debtReserveBuffer.copy(buffer, 8);
+  return buffer;
+}

package/src/classes/obligation.ts

@@ -636,14 +636,6 @@ export class KaminoObligation {
     let newObligationDeposits = this.state.deposits;
     let newObligationBorrows = this.state.borrows;
 
-    // Print deposits and borrows before
-    for (const deposit of this.state.deposits) {
-      console.log(`Before Deposit: ${deposit.depositReserve.toBase58()} - ${deposit.depositedAmount}`);
-    }
-    for (const borrow of this.state.borrows) {
-      console.log(`Before Borrow: ${borrow.borrowReserve.toBase58()} - ${borrow.borrowedAmountSf}`);
-    }
-
     switch (action) {
       case 'deposit': {
         if (amountCollateral === undefined || mintCollateral === undefined) {
@@ -758,14 +750,6 @@ export class KaminoObligation {
       null
     );
 
-    // Print deposits and borrows after
-    for (const deposit of newObligationDeposits) {
-      console.log(`After Deposit: ${deposit.depositReserve.toBase58()} - ${deposit.depositedAmount}`);
-    }
-    for (const borrow of newObligationBorrows) {
-      console.log(`After Borrow: ${borrow.borrowReserve.toBase58()} - ${borrow.borrowedAmountSf}`);
-    }
-
     newStats = refreshedStats;
     newDeposits = deposits;
     newBorrows = borrows;