refactor: remove remaining request (#52)

Author: sakulstra

.eslintrc.json

@@ -36,7 +36,8 @@
           "order": "asc"
         }
       }
-    ]
+    ],
+    "capitalized-comments": "off"
   },
   "overrides": [
     {

.github/workflows/ci.yaml

@@ -54,7 +54,7 @@ jobs:
           !contains(github.head_ref, 'dependabot') &&
           github.ref != 'refs/heads/master'
         run: |
-          yarn release:canary --yes --no-verify-access
+          yarn release:canary --yes --no-verify-access --dist-tag ${{ github.sha }}
       #- uses: actions/github-script@v4
       #  if: |
       #    github.event.pull_request.head.repo.full_name == github.repository &&

packages/math-utils/src/formatters/user/calculate-reward.ts

@@ -15,31 +15,42 @@ export interface CalculateRewardRequest {
   emissionEndTimestamp: number;
 }
 
-export function calculateReward(request: CalculateRewardRequest): string {
+export function calculateReward({
+  principalUserBalance,
+  reserveIndex,
+  userIndex,
+  precision,
+  rewardTokenDecimals,
+  reserveIndexTimestamp,
+  emissionPerSecond,
+  totalSupply,
+  currentTimestamp,
+  emissionEndTimestamp,
+}: CalculateRewardRequest): string {
   const actualCurrentTimestamp =
-    request.currentTimestamp > request.emissionEndTimestamp
-      ? request.emissionEndTimestamp
-      : request.currentTimestamp;
+    currentTimestamp > emissionEndTimestamp
+      ? emissionEndTimestamp
+      : currentTimestamp;
 
-  const timeDelta = actualCurrentTimestamp - request.reserveIndexTimestamp;
+  const timeDelta = actualCurrentTimestamp - reserveIndexTimestamp;
 
   let currentReserveIndex;
   if (
-    request.reserveIndexTimestamp === Number(request.currentTimestamp) ||
-    request.reserveIndexTimestamp >= request.emissionEndTimestamp
+    reserveIndexTimestamp === Number(currentTimestamp) ||
+    reserveIndexTimestamp >= emissionEndTimestamp
   ) {
-    currentReserveIndex = valueToZDBigNumber(request.reserveIndex);
+    currentReserveIndex = valueToZDBigNumber(reserveIndex);
   } else {
-    currentReserveIndex = valueToZDBigNumber(request.emissionPerSecond)
+    currentReserveIndex = valueToZDBigNumber(emissionPerSecond)
       .multipliedBy(timeDelta)
-      .shiftedBy(request.precision)
-      .dividedBy(request.totalSupply)
-      .plus(request.reserveIndex);
+      .shiftedBy(precision)
+      .dividedBy(totalSupply)
+      .plus(reserveIndex);
   }
 
-  const reward = valueToZDBigNumber(request.principalUserBalance)
-    .multipliedBy(currentReserveIndex.minus(request.userIndex))
-    .shiftedBy(request.precision * -1);
+  const reward = valueToZDBigNumber(principalUserBalance)
+    .multipliedBy(currentReserveIndex.minus(userIndex))
+    .shiftedBy(precision * -1);
 
-  return normalize(reward, request.rewardTokenDecimals);
+  return normalize(reward, rewardTokenDecimals);
 }

packages/math-utils/src/formatters/user/calculate-supplies.ts

@@ -24,18 +24,21 @@ interface ReserveSupplyData {
   lastUpdateTimestamp: number;
 }
 
-export function calculateSupplies(request: SuppliesRequest): SuppliesResponse {
+export function calculateSupplies({
+  reserve,
+  currentTimestamp,
+}: SuppliesRequest): SuppliesResponse {
   const {
     totalVariableDebt,
     totalStableDebt,
   } = calculateReserveDebtSuppliesRaw({
-    reserve: request.reserve,
-    currentTimestamp: request.currentTimestamp,
+    reserve: reserve,
+    currentTimestamp: currentTimestamp,
   });
 
   const totalDebt = totalVariableDebt.plus(totalStableDebt);
 
-  const totalLiquidity = totalDebt.plus(request.reserve.availableLiquidity);
+  const totalLiquidity = totalDebt.plus(reserve.availableLiquidity);
   return {
     totalVariableDebt,
     totalStableDebt,
@@ -58,26 +61,24 @@ interface ReserveDebtSuppliesRawResponse {
  * @param reserve
  * @param currentTimestamp unix timestamp which must be higher than reserve.lastUpdateTimestamp
  */
-function calculateReserveDebtSuppliesRaw(
-  request: ReserveDebtSuppliesRawRequest,
-): ReserveDebtSuppliesRawResponse {
+function calculateReserveDebtSuppliesRaw({
+  reserve,
+  currentTimestamp,
+}: ReserveDebtSuppliesRawRequest): ReserveDebtSuppliesRawResponse {
   const totalVariableDebt = rayMul(
-    rayMul(
-      request.reserve.totalScaledVariableDebt,
-      request.reserve.variableBorrowIndex,
-    ),
+    rayMul(reserve.totalScaledVariableDebt, reserve.variableBorrowIndex),
     calculateCompoundedInterest({
-      rate: request.reserve.variableBorrowRate,
-      currentTimestamp: request.currentTimestamp,
-      lastUpdateTimestamp: request.reserve.lastUpdateTimestamp,
+      rate: reserve.variableBorrowRate,
+      currentTimestamp,
+      lastUpdateTimestamp: reserve.lastUpdateTimestamp,
     }),
   );
   const totalStableDebt = rayMul(
-    request.reserve.totalPrincipalStableDebt,
+    reserve.totalPrincipalStableDebt,
     calculateCompoundedInterest({
-      rate: request.reserve.averageStableRate,
-      currentTimestamp: request.currentTimestamp,
-      lastUpdateTimestamp: request.reserve.stableDebtLastUpdateTimestamp,
+      rate: reserve.averageStableRate,
+      currentTimestamp,
+      lastUpdateTimestamp: reserve.stableDebtLastUpdateTimestamp,
     }),
   );
   return { totalVariableDebt, totalStableDebt };

packages/math-utils/src/formatters/user/calculate-user-reserve-totals.ts

@@ -14,16 +14,16 @@ interface UserReserveTotalsResponse {
   currentLiquidationThreshold: BigNumber;
 }
 
-export function calculateUserReserveTotals(
-  request: UserReserveTotalsRequest,
-): UserReserveTotalsResponse {
+export function calculateUserReserveTotals({
+  userReserves,
+}: UserReserveTotalsRequest): UserReserveTotalsResponse {
   let totalLiquidityETH = valueToZDBigNumber('0');
   let totalCollateralETH = valueToZDBigNumber('0');
   let totalBorrowsETH = valueToZDBigNumber('0');
   let currentLtv = valueToBigNumber('0');
   let currentLiquidationThreshold = valueToBigNumber('0');
 
-  request.userReserves.forEach(userReserveSummary => {
+  userReserves.forEach(userReserveSummary => {
     totalLiquidityETH = totalLiquidityETH.plus(
       userReserveSummary.underlyingBalanceETH,
     );

packages/math-utils/src/formatters/user/format-user-reserve.ts

@@ -16,11 +16,10 @@ export interface FormatUserReserveResponse {
   reserve: ComputedUserReserve;
 }
 
-export function formatUserReserve(
-  request: FormatUserReserveRequest,
-): ComputedUserReserve {
-  const rawUserReserve = request.reserve;
-  const userReserve = rawUserReserve.userReserve;
+export function formatUserReserve({
+  reserve: _reserve,
+}: FormatUserReserveRequest): ComputedUserReserve {
+  const userReserve = _reserve.userReserve;
   const reserve = userReserve.reserve;
   const reserveDecimals = reserve.decimals;
 
@@ -45,35 +44,26 @@ export function formatUserReserve(
       userReserve.variableBorrowIndex,
       RAY_DECIMALS,
     ),
-    underlyingBalance: normalize(
-      rawUserReserve.underlyingBalance,
-      reserveDecimals,
-    ),
+    underlyingBalance: normalize(_reserve.underlyingBalance, reserveDecimals),
     underlyingBalanceETH: normalize(
-      rawUserReserve.underlyingBalanceETH,
+      _reserve.underlyingBalanceETH,
       ETH_DECIMALS,
     ),
     underlyingBalanceUSD: normalize(
-      rawUserReserve.underlyingBalanceUSD,
-      USD_DECIMALS,
-    ),
-    stableBorrows: normalizeWithReserve(rawUserReserve.stableBorrows),
-    stableBorrowsETH: normalize(rawUserReserve.stableBorrowsETH, ETH_DECIMALS),
-    stableBorrowsUSD: normalize(rawUserReserve.stableBorrowsUSD, USD_DECIMALS),
-    variableBorrows: normalizeWithReserve(rawUserReserve.variableBorrows),
-    variableBorrowsETH: normalize(
-      rawUserReserve.variableBorrowsETH,
-      ETH_DECIMALS,
-    ),
-    variableBorrowsUSD: normalize(
-      rawUserReserve.variableBorrowsUSD,
+      _reserve.underlyingBalanceUSD,
       USD_DECIMALS,
     ),
-    totalBorrows: normalizeWithReserve(rawUserReserve.totalBorrows),
-    totalBorrowsETH: normalize(rawUserReserve.totalBorrowsETH, ETH_DECIMALS),
-    totalBorrowsUSD: normalize(rawUserReserve.totalBorrowsUSD, USD_DECIMALS),
-    totalLiquidity: normalizeWithReserve(rawUserReserve.totalLiquidity),
-    totalStableDebt: normalizeWithReserve(rawUserReserve.totalStableDebt),
-    totalVariableDebt: normalizeWithReserve(rawUserReserve.totalVariableDebt),
+    stableBorrows: normalizeWithReserve(_reserve.stableBorrows),
+    stableBorrowsETH: normalize(_reserve.stableBorrowsETH, ETH_DECIMALS),
+    stableBorrowsUSD: normalize(_reserve.stableBorrowsUSD, USD_DECIMALS),
+    variableBorrows: normalizeWithReserve(_reserve.variableBorrows),
+    variableBorrowsETH: normalize(_reserve.variableBorrowsETH, ETH_DECIMALS),
+    variableBorrowsUSD: normalize(_reserve.variableBorrowsUSD, USD_DECIMALS),
+    totalBorrows: normalizeWithReserve(_reserve.totalBorrows),
+    totalBorrowsETH: normalize(_reserve.totalBorrowsETH, ETH_DECIMALS),
+    totalBorrowsUSD: normalize(_reserve.totalBorrowsUSD, USD_DECIMALS),
+    totalLiquidity: normalizeWithReserve(_reserve.totalLiquidity),
+    totalStableDebt: normalizeWithReserve(_reserve.totalStableDebt),
+    totalVariableDebt: normalizeWithReserve(_reserve.totalVariableDebt),
   };
 }

packages/math-utils/src/formatters/user/generate-raw-user-summary.test.ts

@@ -40,7 +40,6 @@ describe('generateRawUserSummary', () => {
   const rawSummary: RawUserSummaryResponse = generateRawUserSummary({
     userReserves: [rawUSDCSummary, rawXSUSHISummary, rawETHSummary],
     usdPriceEth,
-    currentTimestamp,
   });
 
   const rawUSDCSummaryModified: UserReserveSummaryResponse = generateUserReserveSummary(
@@ -66,15 +65,13 @@ describe('generateRawUserSummary', () => {
     {
       userReserves: [rawUSDCSummaryModified, rawXSUSHISummary, rawETHSummary],
       usdPriceEth,
-      currentTimestamp,
     },
   );
 
   const rawSummaryBorrowChange: RawUserSummaryResponse = generateRawUserSummary(
     {
       userReserves: [rawUSDCSummary, rawXSUSHISummary, rawETHSummaryModified],
       usdPriceEth,
-      currentTimestamp,
     },
   );
 

packages/math-utils/src/formatters/user/generate-raw-user-summary.ts

@@ -11,7 +11,6 @@ import { UserReserveSummaryResponse } from './generate-user-reserve-summary';
 export interface RawUserSummaryRequest {
   userReserves: UserReserveSummaryResponse[];
   usdPriceEth: BigNumberValue;
-  currentTimestamp: number;
 }
 
 export interface RawUserSummaryResponse {
@@ -34,21 +33,22 @@ function convertToUsd(
   return value.shiftedBy(USD_DECIMALS).dividedBy(usdPriceEth);
 }
 
-export function generateRawUserSummary(
-  request: RawUserSummaryRequest,
-): RawUserSummaryResponse {
+export function generateRawUserSummary({
+  userReserves,
+  usdPriceEth,
+}: RawUserSummaryRequest): RawUserSummaryResponse {
   const {
     totalLiquidityETH,
     totalBorrowsETH,
     totalCollateralETH,
     currentLtv,
     currentLiquidationThreshold,
-  } = calculateUserReserveTotals({ userReserves: request.userReserves });
+  } = calculateUserReserveTotals({ userReserves: userReserves });
 
   return {
-    totalLiquidityUSD: convertToUsd(totalLiquidityETH, request.usdPriceEth),
-    totalCollateralUSD: convertToUsd(totalCollateralETH, request.usdPriceEth),
-    totalBorrowsUSD: convertToUsd(totalBorrowsETH, request.usdPriceEth),
+    totalLiquidityUSD: convertToUsd(totalLiquidityETH, usdPriceEth),
+    totalCollateralUSD: convertToUsd(totalCollateralETH, usdPriceEth),
+    totalBorrowsUSD: convertToUsd(totalBorrowsETH, usdPriceEth),
     totalLiquidityETH,
     totalCollateralETH,
     totalBorrowsETH,

packages/math-utils/src/formatters/user/generate-user-reserve-summary.ts

@@ -34,20 +34,22 @@ export interface UserReserveSummaryResponse {
   totalVariableDebt: BigNumber;
 }
 
-export function generateUserReserveSummary(
-  request: UserReserveSummaryRequest,
-): UserReserveSummaryResponse {
-  const poolReserve = request.userReserve.reserve;
+export function generateUserReserveSummary({
+  userReserve,
+  usdPriceEth,
+  currentTimestamp,
+}: UserReserveSummaryRequest): UserReserveSummaryResponse {
+  const poolReserve = userReserve.reserve;
   const {
     price: { priceInEth },
     decimals,
   } = poolReserve;
   const underlyingBalance = getLinearBalance({
-    balance: request.userReserve.scaledATokenBalance,
+    balance: userReserve.scaledATokenBalance,
     index: poolReserve.liquidityIndex,
     rate: poolReserve.liquidityRate,
     lastUpdateTimestamp: poolReserve.lastUpdateTimestamp,
-    currentTimestamp: request.currentTimestamp,
+    currentTimestamp,
   });
   const {
     ethBalance: underlyingBalanceETH,
@@ -56,15 +58,15 @@ export function generateUserReserveSummary(
     balance: underlyingBalance,
     priceInEth,
     decimals,
-    usdPriceEth: request.usdPriceEth,
+    usdPriceEth,
   });
 
   const variableBorrows = getCompoundedBalance({
-    principalBalance: request.userReserve.scaledVariableDebt,
+    principalBalance: userReserve.scaledVariableDebt,
     reserveIndex: poolReserve.variableBorrowIndex,
     reserveRate: poolReserve.variableBorrowRate,
     lastUpdateTimestamp: poolReserve.lastUpdateTimestamp,
-    currentTimestamp: request.currentTimestamp,
+    currentTimestamp,
   });
 
   const {
@@ -74,14 +76,14 @@ export function generateUserReserveSummary(
     balance: variableBorrows,
     priceInEth,
     decimals,
-    usdPriceEth: request.usdPriceEth,
+    usdPriceEth,
   });
 
   const stableBorrows = getCompoundedStableBalance({
-    principalBalance: request.userReserve.principalStableDebt,
-    userStableRate: request.userReserve.stableBorrowRate,
-    lastUpdateTimestamp: request.userReserve.stableBorrowLastUpdateTimestamp,
-    currentTimestamp: request.currentTimestamp,
+    principalBalance: userReserve.principalStableDebt,
+    userStableRate: userReserve.stableBorrowRate,
+    lastUpdateTimestamp: userReserve.stableBorrowLastUpdateTimestamp,
+    currentTimestamp,
   });
 
   const {
@@ -91,7 +93,7 @@ export function generateUserReserveSummary(
     balance: stableBorrows,
     priceInEth,
     decimals,
-    usdPriceEth: request.usdPriceEth,
+    usdPriceEth,
   });
 
   const {
@@ -109,11 +111,11 @@ export function generateUserReserveSummary(
       stableDebtLastUpdateTimestamp: poolReserve.stableDebtLastUpdateTimestamp,
       lastUpdateTimestamp: poolReserve.lastUpdateTimestamp,
     },
-    currentTimestamp: request.currentTimestamp,
+    currentTimestamp,
   });
 
   return {
-    userReserve: request.userReserve,
+    userReserve,
     underlyingBalance,
     underlyingBalanceETH,
     underlyingBalanceUSD,