@strkfarm/sdk 2.0.0-dev.3 → 2.0.0-dev.31

package/src/strategies/universal-adapters/usdc<>usdce-adapter.ts

@@ -0,0 +1,200 @@
+import {
+  BaseAdapter,
+  DepositParams,
+  WithdrawParams,
+  BaseAdapterConfig,
+} from "./baseAdapter";
+import { toBigInt } from "./adapter-utils";
+import { Protocols } from "@/interfaces";
+import { SupportedPosition } from "./baseAdapter";
+import { PositionAPY, APYType, PositionAmount } from "./baseAdapter";
+import { Web3Number } from "@/dataTypes";
+import { PositionInfo } from "./baseAdapter";
+import { ManageCall } from "./baseAdapter";
+import { ContractAddr } from "@/dataTypes";
+import { AVNU_EXCHANGE } from "./adapter-utils";
+import { hash, uint256 } from "starknet";
+import { AVNU_EXCHANGE_FOR_LEGACY_USDC } from "./adapter-utils";
+import { AVNU_LEGACY_SANITIZER } from "./adapter-utils";
+import { assert, logger } from "@/utils";
+import { ERC20 } from "@/modules";
+
+export class UsdcToUsdceAdapter extends BaseAdapter<
+  DepositParams,
+  WithdrawParams
+> {
+  readonly config: BaseAdapterConfig;
+
+  private _approveProofReadableId(usdcToUsdce: boolean): string {
+    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
+    return `approve_${method}`;
+  }
+
+  private _swapProofReadableId(usdcToUsdce: boolean): string {
+    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
+    const target = usdcToUsdce
+      ? this.config.supportedPositions[0].asset
+      : this.config.supportedPositions[1].asset;
+    return `${method}_${target.symbol}`;
+  }
+
+  private buildSwapLeafConfigs(usdcToUsdce: boolean): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
+    const target = usdcToUsdce
+      ? this.config.supportedPositions[0].asset
+      : this.config.supportedPositions[1].asset;
+    return [
+      {
+        target: target.address,
+        method: "approve",
+        packedArguments: [AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()],
+        id: this._approveProofReadableId(usdcToUsdce),
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+      {
+        target: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+        method: method,
+        packedArguments: [],
+        id: this._swapProofReadableId(usdcToUsdce),
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+    ];
+  }
+
+  private async buildSwapCalls(
+    params: DepositParams | WithdrawParams,
+    usdcToUsdce: boolean,
+  ): Promise<ManageCall[]> {
+    const approveAmount = uint256.bnToUint256(params.amount.toWei());
+    const target = usdcToUsdce
+      ? this.config.supportedPositions[0].asset
+      : this.config.supportedPositions[1].asset;
+    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
+    return [
+      {
+        proofReadableId: this._approveProofReadableId(usdcToUsdce),
+        sanitizer: AVNU_LEGACY_SANITIZER,
+        call: {
+          contractAddress: target.address,
+          selector: hash.getSelectorFromName("approve"),
+          calldata: [
+            AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
+            toBigInt(approveAmount.low.toString()),
+            toBigInt(approveAmount.high.toString()),
+          ],
+        },
+      },
+      {
+        proofReadableId: this._swapProofReadableId(usdcToUsdce),
+        sanitizer: AVNU_LEGACY_SANITIZER,
+        call: {
+          contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+          selector: hash.getSelectorFromName(method),
+          calldata: [
+            toBigInt(approveAmount.low.toString()), // amount low
+            toBigInt(approveAmount.high.toString()), // amount high
+          ],
+        },
+      },
+    ];
+  }
+
+  constructor(config: BaseAdapterConfig) {
+    super(config, UsdcToUsdceAdapter.name, Protocols.AVNU);
+    this.config = config as BaseAdapterConfig;
+    assert(this.config.supportedPositions.length === 2, "UsdcToUsdceAdapter must have 2 supported positions");
+    assert(this.config.supportedPositions[0].asset.symbol === "USDC", "UsdcToUsdceAdapter must have USDC as the first supported position");
+    assert(this.config.supportedPositions[1].asset.symbol === "USDC.e", "UsdcToUsdceAdapter must have USDCE as the second supported position");
+  }
+  //abstract means the method has no implementation in this class; instead, child classes must implement it.
+  protected async getAPY(
+    supportedPosition: SupportedPosition,
+  ): Promise<PositionAPY> {
+    return Promise.resolve({ apy: 0, type: APYType.BASE });
+  }
+
+  protected async getPosition(
+    supportedPosition: SupportedPosition,
+  ): Promise<PositionAmount | null> {
+    const toToken = this.config.supportedPositions[1].asset;
+    if (supportedPosition.asset.symbol != toToken.symbol) {
+      return null;
+    }
+    try {
+      // only measure balance of toToken, bcz from token usually gets trakced in unused balance or a previous avnu adapter
+      const balance = await new ERC20(this.config.networkConfig).balanceOf(
+        toToken.address,
+        this.config.vaultAllocator.address,
+        toToken.decimals,
+      );
+      return { amount: balance, remarks: `USDC.e unused balance (VA)` };
+    } catch (_e) {
+      logger.error(`${UsdcToUsdceAdapter.name}::getPosition: failed for ${toToken.symbol}`);
+      throw new Error(`${UsdcToUsdceAdapter.name}: failed to get balance for ${toToken.symbol}`);
+    }
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    return Promise.resolve({
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, 0),
+      usdValue: 0,
+      apy: { apy: 0, type: APYType.BASE },
+      protocol: Protocols.AVNU,
+      remarks: "",
+    });
+  }
+
+  async maxWithdraw(): Promise<PositionInfo> {
+    return Promise.resolve({
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, 0),
+      usdValue: 0,
+      apy: { apy: 0, type: APYType.BASE },
+      protocol: Protocols.AVNU,
+      remarks: "",
+    });
+  }
+
+  protected _getDepositLeaf(): {
+    // considering deposit is converting usdc to usdce
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    return this.buildSwapLeafConfigs(true);
+  }
+
+  protected _getWithdrawLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    return this.buildSwapLeafConfigs(false);
+  }
+
+  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+      const calls = await this.buildSwapCalls(params, true);
+      return calls;
+  }
+
+  //Swap wbtc to usdc
+  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+      const calls = await this.buildSwapCalls(params, false);
+      return calls;
+  }
+
+  async getHealthFactor(): Promise<number> {
+    return Promise.resolve(1);
+  }
+}

package/src/strategies/universal-adapters/vesu-adapter.ts

@@ -16,6 +16,7 @@ import { EkuboPoolKey } from "../ekubo-cl-vault";
 import VesuPoolV2Abi from '@/data/vesu-pool-v2.abi.json';
 import VesuExtensionAbi from '@/data/vesu-extension.abi.json';
 import { CacheClass } from "@/utils/cacheClass";
+import { PricerFromApi } from "@/modules";
 
 interface VesuPoolsInfo { pools: any[]; isErrorPoolsAPI: boolean };
 
@@ -178,7 +179,7 @@ function getVesuMultiplyParams(isIncrease: boolean, params: IncreaseLeverParams
     }
   }
 
-  const _params = params as DecreaseLeverParams;  
+  const _params = params as DecreaseLeverParams;
   return {
     action: new CairoCustomEnum({ DecreaseLever: {
       pool_id: _params.pool_id.toBigInt(),
@@ -235,6 +236,29 @@ export const VesuPools = {
   Re7xSTRK: ContractAddr.from('0x052fb52363939c3aa848f8f4ac28f0a51379f8d1b971d8444de25fbd77d8f161'),
   Re7xBTC: ContractAddr.from('0x3a8416bf20d036df5b1cf3447630a2e1cb04685f6b0c3a70ed7fb1473548ecf'),
   Re7USDCPrime: ContractAddr.from('0x02eef0c13b10b487ea5916b54c0a7f98ec43fb3048f60fdeedaf5b08f6f88aaf'),
+  Prime: ContractAddr.from('0x451fe483d5921a2919ddd81d0de6696669bccdacd859f72a4fba7656b97c3b5'),
+  Re7STRK: ContractAddr.from('0x01fcdacc1d8184eca7b472b5acbaf1500cec9d5683ca95fede8128b46c8f9cc2'),
+}
+
+export const VesuPoolMetadata = {
+  [VesuPools.Genesis.address]: {
+    name: 'Genesis',
+  },
+  [VesuPools.Re7xSTRK.address]: {
+    name: 'Re7 xSTRK',
+  },
+  [VesuPools.Re7xBTC.address]: {
+    name: 'Re7 xBTC',
+  },
+  [VesuPools.Prime.address]: {
+    name: 'Prime',
+  },
+  [VesuPools.Re7STRK.address]: {
+    name: 'Re7 STRK',
+  },
+  [VesuPools.Re7USDCPrime.address]: {
+    name: 'Re7 USDC Prime',
+  },
 }
 
 export const extensionMap: {[key: string]: ContractAddr} = {};
@@ -251,6 +275,7 @@ export function getVesuSingletonAddress(vesuPool: ContractAddr) {
 export class VesuAdapter extends CacheClass {
   VESU_MULTIPLY_V1 = ContractAddr.from('0x3630f1f8e5b8f5c4c4ae9b6620f8a570ae55cddebc0276c37550e7c118edf67');
   VESU_MULTIPLY = ContractAddr.from('0x027fef272d0a9a3844767c851a64b36fe4f0115141d81134baade95d2b27b781');
+  VESU_WITHDRAW_SWAP_FIXED_MULTIPLIER = ContractAddr.from('0xd2b0006de39992e78d457b7607a606c00bd6b601e9d9a77a8e1870c5e19e73');
   config: VesuAdapterConfig;
   networkConfig: IConfig | undefined;
   pricer: PricerBase | undefined;
@@ -286,31 +311,31 @@ export class VesuAdapter extends CacheClass {
   //   return { leaf: output, callConstructor: this.getModifyPositionCall.bind(this) };
   // }
 
-  // static getDefaultModifyPositionCallParams(params: {
-  //   collateralAmount: Web3Number,
-  //   isAddCollateral: boolean,
-  //   debtAmount: Web3Number,
-  //   isBorrow: boolean
-  // }) {
-  //   return {
-  //       collateralAmount: {
-  //           amount_type: VesuAmountType.Delta,
-  //           denomination: VesuAmountDenomination.Assets,
-  //           value: {
-  //               abs: params.collateralAmount,
-  //               is_negative: !params.isAddCollateral
-  //           }
-  //       },
-  //       debtAmount: {
-  //           amount_type: VesuAmountType.Delta,
-  //           denomination: VesuAmountDenomination.Assets,
-  //           value: {
-  //               abs: params.debtAmount,
-  //               is_negative: !params.isBorrow
-  //           }
-  //       }
-  //   }
-  // }
+  static getDefaultModifyPositionCallParams(params: {
+    collateralAmount: Web3Number,
+    isAddCollateral: boolean,
+    debtAmount: Web3Number,
+    isBorrow: boolean
+  }) {
+    return {
+        collateralAmount: {
+            amount_type: VesuAmountType.Delta,
+            denomination: VesuAmountDenomination.Assets,
+            value: {
+                abs: params.collateralAmount,
+                is_negative: !params.isAddCollateral
+            }
+        },
+        debtAmount: {
+            amount_type: VesuAmountType.Delta,
+            denomination: VesuAmountDenomination.Assets,
+            value: {
+                abs: params.debtAmount,
+                is_negative: !params.isBorrow
+            }
+        }
+    }
+  }
 
   // getModifyPositionCall = (params: VesuModifyPositionCallParams): ManageCall => {
   //   // pub pool_id: felt252,
@@ -439,29 +464,31 @@ export class VesuAdapter extends CacheClass {
   //   }
   // }
 
-  getVesuModifyDelegationCall = (params: VesuModifyDelegationCallParams): ManageCall => {
-    const VESU_SINGLETON = getVesuSingletonAddress(this.config.poolId).addr;
-    const { contract, isV2 } = this.getVesuSingletonContract(getMainnetConfig(), this.config.poolId);
-    const call = contract.populate('modify_delegation', isV2 ? {
-      delegatee: this.VESU_MULTIPLY.toBigInt(),
-      delegation: params.delegation,
-    } : {
-      pool_id: this.config.poolId.toBigInt(),
-      delegatee: this.VESU_MULTIPLY_V1.toBigInt(),
-      delegation: params.delegation,
-    });
-    return {
-      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
-      call: {
-        contractAddress: VESU_SINGLETON,
-        selector: hash.getSelectorFromName('modify_delegation'),
-        calldata: [
-          ...call.calldata as bigint[]
-        ]
+  getVesuModifyDelegationCall = (delegatee: ContractAddr) => {
+    return (params: VesuModifyDelegationCallParams) => {
+      const VESU_SINGLETON = getVesuSingletonAddress(this.config.poolId).addr;
+      const { contract, isV2 } = this.getVesuSingletonContract(getMainnetConfig(), this.config.poolId);
+      const call = contract.populate('modify_delegation', isV2 ? {
+        delegatee: delegatee.toBigInt(),
+        delegation: params.delegation,
+      } : {
+        pool_id: this.config.poolId.toBigInt(),
+        delegatee: delegatee.toBigInt(),
+        delegation: params.delegation,
+      });
+      return {
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
+        call: {
+          contractAddress: VESU_SINGLETON,
+          selector: hash.getSelectorFromName('modify_delegation'),
+          calldata: [
+            ...call.calldata as bigint[]
+          ]
+        }
       }
     }
   }
-  
+
   // getDefispringRewardsAdapter = (id: string): () => AdapterLeafType<VesuDefiSpringRewardsCallParams> => {
   //   return () => {
   //     const packedArguments: bigint[] = [];
@@ -538,7 +565,7 @@ export class VesuAdapter extends CacheClass {
     }
     const output: any = await contract.call('pair_config', [this.config.collateral.address.address, this.config.debt.address.address]);
     logger.verbose(`${this.config.debt.symbol}::VesuAdapter::getDebtCap debt_cap: ${output.debt_cap.toString()}`);
-    
+
     if (!isV2) {
       throw new Error('getDebtCap is not supported for v1');
     }
@@ -568,7 +595,7 @@ export class VesuAdapter extends CacheClass {
 
     }
     const _interestRateConfig: any = await interestRateConfigContract.call(
-      'interest_rate_config', 
+      'interest_rate_config',
       isV2 ? [this.config.debt.address.address] : [this.config.poolId.address, this.config.debt.address.address]
     );
     const interestRateConfig: InterestRateConfig = {
@@ -581,24 +608,25 @@ export class VesuAdapter extends CacheClass {
       min_full_utilization_rate: _interestRateConfig.min_full_utilization_rate,
       max_full_utilization_rate: _interestRateConfig.max_full_utilization_rate,
     };
-    
+
     const _assetConfig: any = await contract.call(
-      isV2 ? 'asset_config' : 'asset_config_unsafe', 
+      isV2 ? 'asset_config' : 'asset_config_unsafe',
       isV2 ? [asset.address.address] : [this.config.poolId.address, asset.address.address]
     );
     const assetConfig = isV2 ? _assetConfig : _assetConfig['0'];
     const timeDelta = assetConfig.last_updated;
     const lastFullUtilizationRate = assetConfig.last_full_utilization_rate;
-    const currentDebt = new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals);
+    const debtSharePrice = Web3Number.fromWei(assetConfig.last_rate_accumulator, 18);
+    const currentDebt = (new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals)).multipliedBy(debtSharePrice);
     const totalSupply = currentDebt.plus(Web3Number.fromWei(assetConfig.reserve, asset.decimals));
 
     const ratePerSecond = BigInt(Math.round(maxBorrowAPY / 365 / 24 / 60 / 60 * Number(SCALE)));
     const maxUtilisation = this.getMaxUtilizationGivenRatePerSecond(interestRateConfig, ratePerSecond, timeDelta, lastFullUtilizationRate);
     logger.verbose(`${asset.symbol}::VesuAdapter::getMaxBorrowableByInterestRate maxUtilisation: ${Number(maxUtilisation) / 1e18}, totalSupply: ${totalSupply.toString()}`);
-   
+
     const maxDebtToHave = totalSupply.multipliedBy(Number(maxUtilisation) / 1e18);
     logger.verbose(`${asset.symbol}::VesuAdapter::getMaxBorrowableByInterestRate currentDebt: ${currentDebt.toString()}, maxDebtToHave: ${maxDebtToHave.toString()}`);
-    return maxDebtToHave.minus(currentDebt);
+    return {maxDebtToHave: maxDebtToHave.minus(currentDebt), currentDebt: currentDebt, totalSupply: totalSupply};
   }
 
   async getLTVConfig(config: IConfig, blockNumber: BlockIdentifier = 'latest') {
@@ -620,7 +648,7 @@ export class VesuAdapter extends CacheClass {
       throw new Error('LTV is 0');
     }
     this.setCache(CACHE_KEY, ltv, 300000); // ttl: 5min
-    return this.getCache<number>(CACHE_KEY) as number;
+    return ltv;
   }
 
   async getPositions(config: IConfig, blockNumber: BlockIdentifier = 'latest'): Promise<VaultPosition[]> {
@@ -628,40 +656,39 @@ export class VesuAdapter extends CacheClass {
       throw new Error('Pricer is not initialized');
     }
     //  { '0': { collateral_shares: 0n, nominal_debt: 0n }, '1': 0n, '2': 0n }
-    const CACHE_KEY = `positions_${blockNumber}_${this.config.poolId.shortString()}_${this.config.collateral.symbol}_${this.config.debt.symbol}`;
-    const cacheData = this.getCache<VaultPosition[]>(CACHE_KEY);
-    if (cacheData) {
-      return cacheData;
-    }
+    // const CACHE_KEY = `positions_${blockNumber}_${this.config.poolId.shortString()}_${this.config.collateral.symbol}_${this.config.debt.symbol}`;
+    // const cacheData = this.getCache<VaultPosition[]>(CACHE_KEY);
+    // if (cacheData) {
+    //   return cacheData;
+    // }
 
     const { contract, isV2} = this.getVesuSingletonContract(config, this.config.poolId);
     const output: any = await contract
-      .call(isV2 ? 'position' : 'position_unsafe', [...(isV2 ? 
+      .call(isV2 ? 'position' : 'position_unsafe', [...(isV2 ?
         []: [this.config.poolId.address]), // exclude pool id in v2
         this.config.collateral.address.address,
         this.config.debt.address.address,
         this.config.vaultAllocator.address
       ], { blockIdentifier: blockNumber });
 
-      console.log(output)
     const token1Price = await this.pricer.getPrice(this.config.collateral.symbol);
     const token2Price = await this.pricer.getPrice(this.config.debt.symbol);
     logger.verbose(`VesuAdapter::getPositions token1Price: ${token1Price.price}, token2Price: ${token2Price.price}`);
-    
+
     const collateralAmount = Web3Number.fromWei(output['1'].toString(), this.config.collateral.decimals);
     const debtAmount = Web3Number.fromWei(output['2'].toString(), this.config.debt.decimals);
     const value = [{
       amount: collateralAmount,
       token: this.config.collateral,
       usdValue: collateralAmount.multipliedBy(token1Price.price).toNumber(),
-      remarks: "Collateral"
+      remarks: `Collateral - ${VesuPoolMetadata[this.config.poolId.address].name} pool`
     }, {
       amount: debtAmount,
       token: this.config.debt,
       usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
-      remarks: "Debt"
+      remarks: `Debt - ${VesuPoolMetadata[this.config.poolId.address].name} pool`
     }];
-    this.setCache(CACHE_KEY, value, 60000); // ttl: 1min
+    // this.setCache(CACHE_KEY, value, 60000); // ttl: 1min
     return value.map(v => ({ ...v, protocol: Protocols.VESU }));
   }
 
@@ -678,7 +705,7 @@ export class VesuAdapter extends CacheClass {
     const { contract, isV2 } = this.getVesuSingletonContract(config, this.config.poolId);
     const output: any = await contract
       .call(isV2 ? 'check_collateralization' : 'check_collateralization_unsafe', [
-        ...(isV2 ? 
+        ...(isV2 ?
           []: [this.config.poolId.address]), // exclude pool id in v2
         this.config.collateral.address.address,
         this.config.debt.address.address,
@@ -711,12 +738,23 @@ export class VesuAdapter extends CacheClass {
 
     const collateralTokenAmount = positions[0].amount;
     const collateralUSDAmount = collateralization[0].usdValue;
-    const collateralPrice = collateralUSDAmount / collateralTokenAmount.toNumber();
+    let collateralPrice = collateralUSDAmount / collateralTokenAmount.toNumber();
 
     const debtTokenAmount = positions[1].amount;
     const debtUSDAmount = collateralization[1].usdValue;
-    const debtPrice = debtUSDAmount / debtTokenAmount.toNumber();
-    
+    let debtPrice = debtUSDAmount / debtTokenAmount.toNumber();
+    if (isNaN(collateralPrice)) {
+      const pricer = new PricerFromApi(this.networkConfig!, Global.getDefaultTokens())
+      collateralPrice = (await pricer.getPrice(this.config.collateral.priceProxySymbol || this.config.collateral.symbol)).price;
+    }
+    if (isNaN(debtPrice)) {
+      const pricer = new PricerFromApi(this.networkConfig!, Global.getDefaultTokens())
+      debtPrice = (await pricer.getPrice(this.config.debt.priceProxySymbol || this.config.debt.symbol)).price;
+    }
+    logger.verbose(`VesuAdapter::getAssetPrices collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+    if (isNaN(collateralPrice) || isNaN(debtPrice) || collateralPrice == 0 || debtPrice == 0) {
+      throw new Error(`VesuAdapter::getAssetPrices collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+    }
     return {
       collateralTokenAmount,
       collateralUSDAmount,
@@ -747,7 +785,7 @@ export class VesuAdapter extends CacheClass {
       let pools: any[] = [];
       try {
         const data = await getAPIUsingHeadlessBrowser(
-          `${ENDPOINTS.VESU_BASE_STAGING}/pools`
+          `${ENDPOINTS.VESU_BASE}/pools`
         );
         pools = data.data;
 
@@ -792,11 +830,11 @@ export class VesuAdapter extends CacheClass {
       min_full_utilization_rate,
       max_full_utilization_rate,
     } = interestRateConfig;
-  
+
     const halfLifeScaled = rate_half_life * SCALE;
-  
+
     let nextFullUtilizationRate: bigint;
-  
+
     if (utilization < min_target_utilization) {
       const utilizationDelta =
         ((min_target_utilization - utilization) * SCALE) / min_target_utilization;
@@ -811,7 +849,7 @@ export class VesuAdapter extends CacheClass {
     } else {
       nextFullUtilizationRate = fullUtilizationRate;
     }
-  
+
     if (nextFullUtilizationRate > max_full_utilization_rate) {
       return max_full_utilization_rate;
     } else if (nextFullUtilizationRate < min_full_utilization_rate) {
@@ -831,26 +869,26 @@ export class VesuAdapter extends CacheClass {
     lastFullUtilizationRate: bigint
   ): { newRatePerSecond: bigint; nextFullUtilizationRate: bigint } {
     const scaledUtilization = utilization / UTILIZATION_SCALE_TO_SCALE;
-  
+
     const {
       target_utilization,
       zero_utilization_rate,
       target_rate_percent,
     } = interestRateConfig;
-  
+
     const nextFullUtilizationRate = this.fullUtilizationRate(
       interestRateConfig,
       timeDelta,
       scaledUtilization,
       lastFullUtilizationRate
     );
-  
+
     const targetRate =
       (((nextFullUtilizationRate - zero_utilization_rate) * target_rate_percent) / SCALE) +
       zero_utilization_rate;
-  
+
     let newRatePerSecond: bigint;
-  
+
     if (scaledUtilization < target_utilization) {
       newRatePerSecond =
         zero_utilization_rate +
@@ -863,10 +901,10 @@ export class VesuAdapter extends CacheClass {
           (nextFullUtilizationRate - targetRate)) /
           (UTILIZATION_SCALE - target_utilization);
     }
-  
+
     return { newRatePerSecond, nextFullUtilizationRate };
   }
-  
+
   /**
    * Calculates utilization given a specific rate per second.
    * This is an inverse function of the piecewise interest rate formula above.
@@ -893,4 +931,4 @@ export class VesuAdapter extends CacheClass {
     }
     throw new Error('Max utilization not found');
   }
-}
+}