@kamino-finance/klend-sdk 5.0.4 → 5.0.6

package/src/classes/market.ts

@@ -31,9 +31,11 @@ import bs58 from 'bs58';
 import { OraclePrices, Scope } from '@kamino-finance/scope-sdk';
 import { Fraction } from './fraction';
 import { chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
-import { parseTokenSymbol } from './utils';
+import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
 import SwitchboardProgram from '@switchboard-xyz/sbv2-lite';
 import { ObligationZP } from '../idl_codegen/zero_padding';
+import { ReserveStatus } from '../idl_codegen/types';
+import { getProgramAccounts } from '../utils/rpc';
 
 export interface ReserveRewardInfo {
   rewardsPerSecond: Decimal; // not lamport
@@ -84,8 +86,11 @@ export class KaminoMarket {
    * Load a new market with all of its associated reserves
    * @param connection
    * @param marketAddress
+   * @param recentSlotDurationMs
    * @param programId
+   * @param withReserves
    * @param setupLocalTest
+   * @param withReserves
    */
   static async load(
     connection: Connection,
@@ -175,6 +180,10 @@ export class KaminoMarket {
     return lendingMarketAuthPda(this.getAddress(), this.programId)[0];
   }
 
+  getName(): string {
+    return parseZeroPaddedUtf8(this.state.name);
+  }
+
   async getObligationDepositByWallet(
     owner: PublicKey,
     mint: PublicKey,
@@ -524,7 +533,6 @@ export class KaminoMarket {
    * @param tag
    */
   async getAllObligationsForMarket(tag?: number): Promise<KaminoObligation[]> {
-    const { getProgramAccounts } = await import('../utils/rpc');
     const filters = [
       {
         dataSize: Obligation.layout.span + 8,
@@ -1082,6 +1090,10 @@ export class KaminoMarket {
     const spot: MintToPriceMap = {};
     const twaps: MintToPriceMap = {};
     for (const reserve of this.reserves.values()) {
+      if (reserve.state.config.status === ReserveStatus.Obsolete.discriminator) {
+        // skip obsolete reserves
+        continue;
+      }
       const tokenMint = reserve.getLiquidityMint().toString();
       const tokenName = reserve.getTokenSymbol();
       const oracle = reserve.state.config.tokenInfo.scopeConfiguration.priceFeed;
@@ -1119,6 +1131,11 @@ export class KaminoMarket {
     const switchboardV2 = await SwitchboardProgram.loadMainnet(this.connection);
 
     for (const reserve of this.reserves.values()) {
+      if (reserve.state.config.status === ReserveStatus.Obsolete.discriminator) {
+        // skip obsolete reserves
+        continue;
+      }
+
       const tokenMint = reserve.getLiquidityMint().toString();
       const tokenName = reserve.getTokenSymbol();
       const scopeOracle = reserve.state.config.tokenInfo.scopeConfiguration.priceFeed;

package/src/classes/obligation.ts

@@ -362,11 +362,14 @@ export class KaminoObligation {
     collateralExchangeRates: Map<PublicKey, Decimal>
   ): ObligationCollateral[] {
     const newDeposits: ObligationCollateral[] = [];
+    const depositIndex = obligationDeposits.findIndex((deposit) => deposit.depositReserve.equals(changeReserve));
+
+    // Always copy the previous deposits and modify the changeReserve one if it exists
     for (let i = 0; i < obligationDeposits.length; i++) {
       if (obligationDeposits[i].depositReserve.equals(changeReserve)) {
         const coll: ObligationCollateralFields = { ...obligationDeposits[i] };
         const exchangeRate = collateralExchangeRates.get(changeReserve)!;
-        const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate);
+        const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate).toFixed(0);
         const updatedDeposit = new Decimal(obligationDeposits[i].depositedAmount.toNumber()).add(changeInCollateral);
         coll.depositedAmount = new BN(positiveOrZero(updatedDeposit).toString());
         newDeposits.push(new ObligationCollateral(coll));
@@ -375,6 +378,25 @@ export class KaminoObligation {
       }
     }
 
+    if (depositIndex === -1) {
+      // If the reserve is not in the obligation, we add it
+      const firstBorrowIndexAvailable = obligationDeposits.findIndex((deposit) =>
+        deposit.depositReserve.equals(PublicKey.default)
+      );
+
+      if (firstBorrowIndexAvailable === -1) {
+        throw new Error('No available borrows to modify');
+      }
+
+      const coll: ObligationCollateralFields = { ...obligationDeposits[firstBorrowIndexAvailable] };
+      const exchangeRate = collateralExchangeRates.get(changeReserve)!;
+      const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate).toFixed(0);
+      coll.depositedAmount = new BN(positiveOrZero(new Decimal(changeInCollateral)).toString());
+      coll.depositReserve = changeReserve;
+
+      newDeposits[firstBorrowIndexAvailable] = new ObligationCollateral(coll);
+    }
+
     return newDeposits;
   }
 
@@ -387,17 +409,30 @@ export class KaminoObligation {
     const newBorrows: ObligationLiquidity[] = [];
     const borrowIndex = obligationBorrows.findIndex((borrow) => borrow.borrowReserve.equals(changeReserve));
 
-    if (borrowIndex !== -1) {
-      const borrow: ObligationLiquidityFields = { ...obligationBorrows[borrowIndex] };
-      const newBorrowedAmount: Decimal = new Fraction(borrow.borrowedAmountSf).toDecimal().add(changeInLamports);
-      const newBorrowedAmountSf = Fraction.fromDecimal(positiveOrZero(newBorrowedAmount)).getValue();
-      borrow.borrowedAmountSf = newBorrowedAmountSf;
-      newBorrows.push(new ObligationLiquidity(borrow));
-    } else {
+    // Always copy the previous borrows and modify the changeReserve one if it exists
+    for (let i = 0; i < obligationBorrows.length; i++) {
+      if (obligationBorrows[i].borrowReserve.equals(changeReserve)) {
+        const borrow: ObligationLiquidityFields = { ...obligationBorrows[borrowIndex] };
+        const newBorrowedAmount: Decimal = new Fraction(borrow.borrowedAmountSf).toDecimal().add(changeInLamports);
+        const newBorrowedAmountSf = Fraction.fromDecimal(positiveOrZero(newBorrowedAmount)).getValue();
+        borrow.borrowedAmountSf = newBorrowedAmountSf;
+
+        newBorrows.push(new ObligationLiquidity(borrow));
+      } else {
+        newBorrows.push(obligationBorrows[i]);
+      }
+    }
+
+    if (borrowIndex === -1) {
+      // If the reserve is not in the obligation, we add it
       const firstBorrowIndexAvailable = obligationBorrows.findIndex((borrow) =>
         borrow.borrowReserve.equals(PublicKey.default)
       );
 
+      if (firstBorrowIndexAvailable === -1) {
+        throw new Error('No available borrows to modify');
+      }
+
       const borrow: ObligationLiquidityFields = { ...obligationBorrows[firstBorrowIndexAvailable] };
       borrow.borrowedAmountSf = Fraction.fromDecimal(new Decimal(changeInLamports)).getValue();
       borrow.borrowReserve = changeReserve;
@@ -405,7 +440,7 @@ export class KaminoObligation {
         padding: [],
         value: [Fraction.fromDecimal(cumulativeBorrowRate).getValue(), new BN(0), new BN(0), new BN(0)],
       };
-      newBorrows.push(new ObligationLiquidity(borrow));
+      newBorrows[firstBorrowIndexAvailable] = new ObligationLiquidity(borrow);
     }
 
     return newBorrows;
@@ -433,7 +468,23 @@ export class KaminoObligation {
     const { amountCollateral, amountDebt, action, mintCollateral, mintDebt, market } = params;
     let newStats = { ...this.refreshedStats };
 
-    const { collateralExchangeRates } = KaminoObligation.getRatesForObligation(market, this.state, params.slot);
+    const collateralReservePk = mintCollateral ? market.getReserveByMint(mintCollateral)!.address : undefined;
+    const debtReservePk = mintDebt ? market.getReserveByMint(mintDebt)!.address : undefined;
+
+    const additionalReserves = [];
+    if (collateralReservePk !== undefined) {
+      additionalReserves.push(collateralReservePk);
+    }
+    if (debtReservePk !== undefined) {
+      additionalReserves.push(debtReservePk);
+    }
+
+    const { collateralExchangeRates } = KaminoObligation.getRatesForObligation(
+      market,
+      this.state,
+      params.slot,
+      additionalReserves
+    );
 
     const elevationGroup = params.elevationGroupOverride ?? this.state.elevationGroup;
 
@@ -444,8 +495,6 @@ export class KaminoObligation {
     // so we have to recalculate the entire position, not just an updated deposit or borrow
     // as both LTVs and borrow factors can change, affecting all calcs
 
-    const collateralReservePk = mintCollateral ? market.getReserveByMint(mintCollateral)!.address : undefined;
-    const debtReservePk = mintDebt ? market.getReserveByMint(mintDebt)!.address : undefined;
     const debtReserveCumulativeBorrowRate = mintDebt
       ? market.getReserveByMint(mintDebt)!.getCumulativeBorrowRate()
       : undefined;
@@ -453,6 +502,14 @@ 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) {
@@ -567,6 +624,14 @@ 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;
@@ -921,12 +986,17 @@ export class KaminoObligation {
       throw new Error('Reserve not found');
     }
 
-    const liquidityAvailable = reserve.getLiquidityAvailableForDebtReserveGivenCaps(market, [elevationGroup])[0];
+    const liquidityAvailable = reserve.getLiquidityAvailableForDebtReserveGivenCaps(
+      market,
+      [elevationGroup],
+      Array.from(this.deposits.keys())
+    )[0];
     const maxBorrowAmount = this.getBorrowPower(market, liquidityMint, slot, elevationGroup);
 
     if (elevationGroup === this.state.elevationGroup) {
       return Decimal.min(maxBorrowAmount, liquidityAvailable);
     } else {
+      // TODO: this is wrong, most liquidity caps are global, we should add up only the ones that are specific to this mode
       const { amount: debtThisReserve } = this.borrows.get(reserve.address) || { amount: new Decimal(0) };
       const liquidityAvailablePostMigration = Decimal.max(0, liquidityAvailable.minus(debtThisReserve));
       return Decimal.min(maxBorrowAmount, liquidityAvailablePostMigration);
@@ -1212,7 +1282,8 @@ export class KaminoObligation {
   public static getRatesForObligation(
     kaminoMarket: KaminoMarket,
     obligation: Obligation,
-    slot: number
+    slot: number,
+    additionalReserves: PublicKey[] = []
   ): {
     collateralExchangeRates: Map<PublicKey, Decimal>;
     cumulativeBorrowRates: Map<PublicKey, Decimal>;
@@ -1220,12 +1291,14 @@ export class KaminoObligation {
     const collateralExchangeRates = KaminoObligation.getCollateralExchangeRatesForObligation(
       kaminoMarket,
       obligation,
-      slot
+      slot,
+      additionalReserves
     );
     const cumulativeBorrowRates = KaminoObligation.getCumulativeBorrowRatesForObligation(
       kaminoMarket,
       obligation,
-      slot
+      slot,
+      additionalReserves
     );
 
     return {
@@ -1248,20 +1321,35 @@ export class KaminoObligation {
   static getCollateralExchangeRatesForObligation(
     kaminoMarket: KaminoMarket,
     obligation: Obligation,
-    slot: number
+    slot: number,
+    additionalReserves: PublicKey[]
   ): Map<PublicKey, Decimal> {
     const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
+
+    // Create a set of all reserves coming from deposit plus additional reserves
+    const allReserves = new Set<PublicKey>();
     for (let i = 0; i < obligation.deposits.length; i++) {
       const deposit = obligation.deposits[i];
-      if (isNotNullPubkey(deposit.depositReserve) && !collateralExchangeRates.has(deposit.depositReserve)) {
-        const reserve = kaminoMarket.getReserveByAddress(deposit.depositReserve)!;
-        const collateralExchangeRate = reserve.getEstimatedCollateralExchangeRate(
-          slot,
-          kaminoMarket.state.referralFeeBps
-        );
-        collateralExchangeRates.set(reserve.address, collateralExchangeRate);
+      if (isNotNullPubkey(deposit.depositReserve)) {
+        allReserves.add(deposit.depositReserve);
+      }
+    }
+    for (let i = 0; i < additionalReserves.length; i++) {
+      if (isNotNullPubkey(additionalReserves[i])) {
+        allReserves.add(additionalReserves[i]);
       }
     }
+
+    // Run through all reserves and get the exchange rate
+    for (const reserve of allReserves) {
+      const reserveInstance = kaminoMarket.getReserveByAddress(reserve)!;
+      const collateralExchangeRate = reserveInstance.getEstimatedCollateralExchangeRate(
+        slot,
+        kaminoMarket.state.referralFeeBps
+      );
+      collateralExchangeRates.set(reserve, collateralExchangeRate);
+    }
+
     return collateralExchangeRates;
   }
 
@@ -1284,16 +1372,39 @@ export class KaminoObligation {
     }
   }
 
-  static getCumulativeBorrowRatesForObligation(kaminoMarket: KaminoMarket, obligation: Obligation, slot: number) {
-    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
+  static getCumulativeBorrowRatesForObligation(
+    kaminoMarket: KaminoMarket,
+    obligation: Obligation,
+    slot: number,
+    additionalReserves: PublicKey[] = []
+  ): Map<PublicKey, Decimal> {
+    const allReserves = new Set<PublicKey>();
     for (let i = 0; i < obligation.borrows.length; i++) {
       const borrow = obligation.borrows[i];
-      if (isNotNullPubkey(borrow.borrowReserve) && !cumulativeBorrowRates.has(borrow.borrowReserve)) {
-        const reserve = kaminoMarket.getReserveByAddress(borrow.borrowReserve)!;
-        const cumulativeBorrowRate = reserve.getEstimatedCumulativeBorrowRate(slot, kaminoMarket.state.referralFeeBps);
-        cumulativeBorrowRates.set(reserve.address, cumulativeBorrowRate);
+      if (isNotNullPubkey(borrow.borrowReserve)) {
+        allReserves.add(borrow.borrowReserve);
       }
     }
+
+    // Add additional reserves
+    for (let i = 0; i < additionalReserves.length; i++) {
+      if (isNotNullPubkey(additionalReserves[i])) {
+        allReserves.add(additionalReserves[i]);
+      }
+    }
+
+    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
+
+    // Run through all reserves and get the cumulative borrow rate
+    for (const reserve of allReserves) {
+      const reserveInstance = kaminoMarket.getReserveByAddress(reserve)!;
+      const cumulativeBorrowRate = reserveInstance.getEstimatedCumulativeBorrowRate(
+        slot,
+        kaminoMarket.state.referralFeeBps
+      );
+      cumulativeBorrowRates.set(reserve, cumulativeBorrowRate);
+    }
+
     return cumulativeBorrowRates;
   }
 

package/src/classes/reserve.ts

@@ -23,7 +23,14 @@ import {
 import { FeeCalculation, Fees, ReserveDataType, ReserveFarmInfo, ReserveRewardYield, ReserveStatus } from './shared';
 import { Reserve, ReserveFields } from '../idl_codegen/accounts';
 import { BorrowRateCurve, CurvePointFields, ReserveConfig, UpdateConfigMode } from '../idl_codegen/types';
-import { calculateAPYFromAPR, getBorrowRate, lamportsToNumberDecimal, parseTokenSymbol, positiveOrZero } from './utils';
+import {
+  calculateAPYFromAPR,
+  getBorrowRate,
+  lamportsToNumberDecimal,
+  parseTokenSymbol,
+  positiveOrZero,
+  sameLengthArrayEquals,
+} from './utils';
 import { Fraction } from './fraction';
 import BN from 'bn.js';
 import { ActionType } from './action';
@@ -570,7 +577,7 @@ export class KaminoReserve {
     return Decimal.max(new Decimal(0), maxBorrowAmount);
   }
 
-  calcSimulatedBorrowAPR(
+  calcSimulatedBorrowRate(
     amount: Decimal,
     action: ActionType,
     slot: number,
@@ -580,7 +587,20 @@ export class KaminoReserve {
     const slotAdjustmentFactor = this.slotAdjustmentFactor();
     const newUtilization = this.calcSimulatedUtilizationRatio(amount, action, slot, referralFeeBps, outflowAmount);
     const curve = truncateBorrowCurve(this.state.config.borrowRateCurve.points);
-    return getBorrowRate(newUtilization, curve) * slotAdjustmentFactor + this.getFixedHostInterestRate().toNumber();
+    return getBorrowRate(newUtilization, curve) * slotAdjustmentFactor;
+  }
+
+  calcSimulatedBorrowAPR(
+    amount: Decimal,
+    action: ActionType,
+    slot: number,
+    referralFeeBps: number,
+    outflowAmount?: Decimal
+  ) {
+    return (
+      this.calcSimulatedBorrowRate(amount, action, slot, referralFeeBps, outflowAmount) +
+      this.getFixedHostInterestRate().toNumber()
+    );
   }
 
   calcSimulatedSupplyAPR(
@@ -591,7 +611,7 @@ export class KaminoReserve {
     outflowAmount?: Decimal
   ) {
     const newUtilization = this.calcSimulatedUtilizationRatio(amount, action, slot, referralFeeBps, outflowAmount);
-    const simulatedBorrowAPR = this.calcSimulatedBorrowAPR(amount, action, slot, referralFeeBps, outflowAmount);
+    const simulatedBorrowAPR = this.calcSimulatedBorrowRate(amount, action, slot, referralFeeBps, outflowAmount);
     const protocolTakeRatePct = 1 - this.state.config.protocolTakeRatePct / 100;
 
     return newUtilization * simulatedBorrowAPR * protocolTakeRatePct;
@@ -1033,7 +1053,11 @@ export class KaminoReserve {
   }
 
   /* This takes into account all the caps */
-  getLiquidityAvailableForDebtReserveGivenCaps(market: KaminoMarket, elevationGroups: number[]): Decimal[] {
+  getLiquidityAvailableForDebtReserveGivenCaps(
+    market: KaminoMarket,
+    elevationGroups: number[],
+    collateralReserves: PublicKey[] = []
+  ): Decimal[] {
     const caps = this.getBorrowCapForReserve(market);
 
     const liquidityAvailable = this.getLiquidityAvailableAmount();
@@ -1069,7 +1093,16 @@ export class KaminoReserve {
           (x) => x.elevationGroup === elevationGroup
         );
         if (capsGivenEgroup.length > 0) {
-          remainingInsideEmodeCaps = Decimal.min(...capsGivenEgroup.map((x) => x.maxDebt.minus(x.currentValue)));
+          remainingInsideEmodeCaps = Decimal.min(
+            ...capsGivenEgroup.map((x) => {
+              // check reserve is part of collReserves array
+              if (collateralReserves.find((collateralReserve) => collateralReserve.equals(x.collateralReserve))) {
+                return x.maxDebt.minus(x.currentValue);
+              } else {
+                return new Decimal(U64_MAX);
+              }
+            })
+          );
         }
         return Decimal.min(
           positiveOrZero(liquidityAvailable),
@@ -1746,17 +1779,11 @@ export function parseForChangesReserveConfigAndGetIxs(
           ),
         });
       } else {
-        for (let i = 0; i < tokenInfo.name.length; i++) {
-          if (reserve.config.tokenInfo.name[i] !== tokenInfo.name[i]) {
-            updateReserveIxnsArgs.push({
-              mode: UpdateConfigMode.UpdateTokenInfoName.discriminator,
-              value: updateReserveConfigEncodedValue(
-                UpdateConfigMode.UpdateTokenInfoName.discriminator,
-                tokenInfo.name
-              ),
-            });
-            break;
-          }
+        if (!sameLengthArrayEquals(reserve.config.tokenInfo.name, tokenInfo.name)) {
+          updateReserveIxnsArgs.push({
+            mode: UpdateConfigMode.UpdateTokenInfoName.discriminator,
+            value: updateReserveConfigEncodedValue(UpdateConfigMode.UpdateTokenInfoName.discriminator, tokenInfo.name),
+          });
         }
         if (!reserve.config.tokenInfo.heuristic.lower.eq(tokenInfo.heuristic.lower)) {
           updateReserveIxnsArgs.push({
@@ -1812,31 +1839,33 @@ export function parseForChangesReserveConfigAndGetIxs(
             ),
           });
         }
-        for (let i = 0; i < tokenInfo.scopeConfiguration.priceChain.length; i++) {
-          if (
-            reserve.config.tokenInfo.scopeConfiguration.priceChain[i] !== tokenInfo.scopeConfiguration.priceChain[i]
-          ) {
-            updateReserveIxnsArgs.push({
-              mode: UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator,
-              value: updateReserveConfigEncodedValue(
-                UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator,
-                tokenInfo.scopeConfiguration.priceChain
-              ),
-            });
-            break;
-          }
+        if (
+          !sameLengthArrayEquals(
+            reserve.config.tokenInfo.scopeConfiguration.priceChain,
+            tokenInfo.scopeConfiguration.priceChain
+          )
+        ) {
+          updateReserveIxnsArgs.push({
+            mode: UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator,
+            value: updateReserveConfigEncodedValue(
+              UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator,
+              tokenInfo.scopeConfiguration.priceChain
+            ),
+          });
         }
-        for (let i = 0; i < tokenInfo.scopeConfiguration.twapChain.length; i++) {
-          if (reserve.config.tokenInfo.scopeConfiguration.twapChain[i] !== tokenInfo.scopeConfiguration.twapChain[i]) {
-            updateReserveIxnsArgs.push({
-              mode: UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator,
-              value: updateReserveConfigEncodedValue(
-                UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator,
-                tokenInfo.scopeConfiguration.twapChain
-              ),
-            });
-            break;
-          }
+        if (
+          !sameLengthArrayEquals(
+            reserve.config.tokenInfo.scopeConfiguration.twapChain,
+            tokenInfo.scopeConfiguration.twapChain
+          )
+        ) {
+          updateReserveIxnsArgs.push({
+            mode: UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator,
+            value: updateReserveConfigEncodedValue(
+              UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator,
+              tokenInfo.scopeConfiguration.twapChain
+            ),
+          });
         }
         if (
           !reserve.config.tokenInfo.switchboardConfiguration.priceAggregator.equals(

package/src/classes/utils.ts

@@ -142,6 +142,29 @@ export const parseTokenSymbol = (tokenSymbol: number[]): string => {
   return String.fromCharCode(...tokenSymbol.filter((x) => x > 0));
 };
 
+export function parseZeroPaddedUtf8(utf8Array: number[]): string {
+  for (let last = utf8Array.length - 1; last >= 0; last--) {
+    const trailing_zero = utf8Array[last];
+    if (trailing_zero != 0) {
+      const encoding = new Uint8Array(last + 1);
+      for (let i = 0; i <= last; i++) {
+        encoding[i] = utf8Array[i];
+      }
+      break;
+    }
+  }
+  return new TextDecoder().decode();
+}
+
+export function renderZeroPaddedUtf8(str: string, utf8ArrayLength: number): number[] {
+  const encoding = new TextEncoder().encode(str);
+  const result = new Array<number>(utf8ArrayLength);
+  for (let i = 0; i < result.length; i++) {
+    result[i] = i < encoding.length ? encoding[i] : 0;
+  }
+  return result;
+}
+
 export function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -190,3 +213,10 @@ export function calculateAPRFromAPY(apy: Decimal.Value) {
     .minus(1)
     .times(SLOTS_PER_YEAR);
 }
+
+export function sameLengthArrayEquals(left: Array<number>, right: Array<number>): boolean {
+  if (left.length != right.length) {
+    throw new Error(`Not same length: ${left.length} != ${left.length}`);
+  }
+  return left.every((value, index) => value === right[index]);
+}