@scallop-io/sui-scallop-sdk 0.46.3 → 0.46.32

package/dist/index.mjs

@@ -1401,7 +1401,7 @@ var parseOriginBorrowIncentivePoolData = (originBorrowIncentivePoolData) => {
     )
   };
 };
-var calculateBorrowIncentivePoolPointData = (pasredBorrowIncentinvePoolData, parsedBorrowIncentivePoolPointData, rewardCoinPrice, rewardCoinDecimal, poolCoinPrice, poolCoinDecimal) => {
+var calculateBorrowIncentivePoolPointData = (parsedBorrowIncentivePoolData, parsedBorrowIncentivePoolPointData, rewardCoinPrice, rewardCoinDecimal, poolCoinPrice, poolCoinDecimal) => {
   const baseIndexRate = 1e9;
   const distributedPointPerSec = BigNumber(
     parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
@@ -1423,9 +1423,6 @@ var calculateBorrowIncentivePoolPointData = (pasredBorrowIncentinvePoolData, par
   const currentTotalDistributedPoint = BigNumber(
     parsedBorrowIncentivePoolPointData.distributedPoint
   ).plus(accumulatedPoints);
-  const stakedAmount = BigNumber(pasredBorrowIncentinvePoolData.staked);
-  const stakedCoin = stakedAmount.shiftedBy(-1 * poolCoinDecimal);
-  const stakedValue = stakedCoin.multipliedBy(poolCoinPrice);
   const baseWeight = BigNumber(parsedBorrowIncentivePoolPointData.baseWeight);
   const weightedStakedAmount = BigNumber(
     parsedBorrowIncentivePoolPointData.weightedAmount
@@ -1454,9 +1451,6 @@ var calculateBorrowIncentivePoolPointData = (pasredBorrowIncentinvePoolData, par
     accumulatedPoints: accumulatedPoints.toNumber(),
     currentPointIndex: currentPointIndex.toNumber(),
     currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
-    stakedAmount: stakedAmount.toNumber(),
-    stakedCoin: stakedCoin.toNumber(),
-    stakedValue: stakedValue.toNumber(),
     baseWeight: baseWeight.toNumber(),
     weightedStakedAmount: weightedStakedAmount.toNumber(),
     weightedStakedCoin: weightedStakedCoin.toNumber(),
@@ -2471,6 +2465,7 @@ var getStakeRewardPool = async (query, marketCoinName) => {
 
 // src/queries/borrowIncentiveQuery.ts
 import { normalizeStructTag as normalizeStructTag5 } from "@mysten/sui.js/utils";
+import BigNumber3 from "bignumber.js";
 var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames, indexer = false) => {
   borrowIncentiveCoinNames = borrowIncentiveCoinNames || [
     ...SUPPORT_BORROW_INCENTIVE_POOLS
@@ -2482,19 +2477,29 @@ var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames, indexer
   const queryResult = await query.cache.queryInspectTxn({ queryTarget, args });
   const borrowIncentivePoolsQueryData = queryResult.events[0].parsedJson;
   const borrowIncentivePools = {};
+  const coinPrices = await query.utils.getCoinPrices(
+    [
+      .../* @__PURE__ */ new Set([
+        ...borrowIncentiveCoinNames,
+        ...SUPPORT_BORROW_INCENTIVE_REWARDS
+      ])
+    ]
+  );
   if (indexer) {
+    const borrowIncentivePoolsIndexer = await query.indexer.getBorrowIncentivePools();
+    for (const borrowIncentivePool of Object.values(
+      borrowIncentivePoolsIndexer
+    )) {
+      if (!borrowIncentiveCoinNames.includes(borrowIncentivePool.coinName))
+        continue;
+      borrowIncentivePool.coinPrice = coinPrices[borrowIncentivePool.coinName] || borrowIncentivePool.coinPrice;
+      borrowIncentivePools[borrowIncentivePool.coinName] = borrowIncentivePool;
+    }
+    return borrowIncentivePools;
   }
   for (const pool of borrowIncentivePoolsQueryData.incentive_pools) {
     const borrowIncentivePoolPoints = {};
     const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(pool);
-    const coinPrices = await query.utils.getCoinPrices(
-      [
-        .../* @__PURE__ */ new Set([
-          ...borrowIncentiveCoinNames,
-          ...SUPPORT_BORROW_INCENTIVE_REWARDS
-        ])
-      ]
-    );
     const poolCoinType = normalizeStructTag5(pool.pool_type.name);
     const poolCoinName = query.utils.parseCoinNameFromType(
       poolCoinType
@@ -2535,14 +2540,19 @@ var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames, indexer
         ...calculatedPoolPoint
       };
     }
+    const stakedAmount = BigNumber3(parsedBorrowIncentivePoolData.staked);
+    const stakedCoin = stakedAmount.shiftedBy(-1 * poolCoinDecimal);
+    const stakedValue = stakedCoin.multipliedBy(poolCoinPrice);
     borrowIncentivePools[poolCoinName] = {
       coinName: poolCoinName,
       symbol: query.utils.parseSymbol(poolCoinName),
       coinType: poolCoinType,
       coinDecimal: poolCoinDecimal,
       coinPrice: poolCoinPrice,
-      points: borrowIncentivePoolPoints,
-      staked: parsedBorrowIncentivePoolData.staked
+      stakedAmount: stakedAmount.toNumber(),
+      stakedCoin: stakedCoin.toNumber(),
+      stakedValue: stakedValue.toNumber(),
+      points: borrowIncentivePoolPoints
     };
   }
   return borrowIncentivePools;
@@ -2689,7 +2699,7 @@ var getPythPrices = async (query, assetCoinNames) => {
 };
 
 // src/queries/portfolioQuery.ts
-import BigNumber3 from "bignumber.js";
+import BigNumber4 from "bignumber.js";
 var getLendings = async (query, poolCoinNames, ownerAddress, indexer = false) => {
   poolCoinNames = poolCoinNames || [...SUPPORT_POOLS];
   const marketCoinNames = poolCoinNames.map(
@@ -2740,18 +2750,18 @@ var getLending = async (query, poolCoinName, ownerAddress, indexer = false, mark
   marketCoinAmount = marketCoinAmount || await query.getMarketCoinAmount(marketCoinName, ownerAddress);
   coinPrice = coinPrice || (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
   const coinDecimal = query.utils.getCoinDecimal(poolCoinName);
-  let stakedMarketAmount = BigNumber3(0);
-  let stakedMarketCoin = BigNumber3(0);
-  let stakedAmount = BigNumber3(0);
-  let stakedCoin = BigNumber3(0);
-  let stakedValue = BigNumber3(0);
-  let availableUnstakeAmount = BigNumber3(0);
-  let availableUnstakeCoin = BigNumber3(0);
-  let availableClaimAmount = BigNumber3(0);
-  let availableClaimCoin = BigNumber3(0);
+  let stakedMarketAmount = BigNumber4(0);
+  let stakedMarketCoin = BigNumber4(0);
+  let stakedAmount = BigNumber4(0);
+  let stakedCoin = BigNumber4(0);
+  let stakedValue = BigNumber4(0);
+  let availableUnstakeAmount = BigNumber4(0);
+  let availableUnstakeCoin = BigNumber4(0);
+  let availableClaimAmount = BigNumber4(0);
+  let availableClaimCoin = BigNumber4(0);
   if (spool) {
     for (const stakeAccount of stakeAccounts) {
-      const accountStakedMarketCoinAmount = BigNumber3(stakeAccount.staked);
+      const accountStakedMarketCoinAmount = BigNumber4(stakeAccount.staked);
       const accountStakedMarketCoin = accountStakedMarketCoinAmount.shiftedBy(
         -1 * spool.coinDecimal
       );
@@ -2778,7 +2788,7 @@ var getLending = async (query, poolCoinName, ownerAddress, indexer = false, mark
         -1 * spool.coinDecimal
       );
       const baseIndexRate = 1e9;
-      const increasedPointRate = spool.currentPointIndex ? BigNumber3(spool.currentPointIndex - stakeAccount.index).dividedBy(
+      const increasedPointRate = spool.currentPointIndex ? BigNumber4(spool.currentPointIndex - stakeAccount.index).dividedBy(
         baseIndexRate
       ) : 1;
       availableClaimAmount = availableClaimAmount.plus(
@@ -2789,17 +2799,17 @@ var getLending = async (query, poolCoinName, ownerAddress, indexer = false, mark
       );
     }
   }
-  const suppliedAmount = BigNumber3(marketCoinAmount).multipliedBy(
+  const suppliedAmount = BigNumber4(marketCoinAmount).multipliedBy(
     marketPool?.conversionRate ?? 1
   );
   const suppliedCoin = suppliedAmount.shiftedBy(-1 * coinDecimal);
   const suppliedValue = suppliedCoin.multipliedBy(coinPrice ?? 0);
-  const marketCoinPrice = BigNumber3(coinPrice ?? 0).multipliedBy(
+  const marketCoinPrice = BigNumber4(coinPrice ?? 0).multipliedBy(
     marketPool?.conversionRate ?? 1
   );
-  const unstakedMarketAmount = BigNumber3(marketCoinAmount);
+  const unstakedMarketAmount = BigNumber4(marketCoinAmount);
   const unstakedMarketCoin = unstakedMarketAmount.shiftedBy(-1 * coinDecimal);
-  const availableSupplyAmount = BigNumber3(coinAmount);
+  const availableSupplyAmount = BigNumber4(coinAmount);
   const availableSupplyCoin = availableSupplyAmount.shiftedBy(-1 * coinDecimal);
   const availableWithdrawAmount = minBigNumber(
     suppliedAmount,
@@ -2853,17 +2863,19 @@ var getObligationAccounts = async (query, ownerAddress, indexer = false) => {
   const coinAmounts = await query.getCoinAmounts(void 0, ownerAddress);
   const obligations = await query.getObligations(ownerAddress);
   const obligationAccounts = {};
-  for (const obligation of obligations) {
-    obligationAccounts[obligation.keyId] = await getObligationAccount(
-      query,
-      obligation.id,
-      ownerAddress,
-      indexer,
-      market,
-      coinPrices,
-      coinAmounts
-    );
-  }
+  await Promise.allSettled(
+    obligations.map(async (obligation) => {
+      obligationAccounts[obligation.keyId] = await getObligationAccount(
+        query,
+        obligation.id,
+        ownerAddress,
+        indexer,
+        market,
+        coinPrices,
+        coinAmounts
+      );
+    })
+  );
   return obligationAccounts;
 };
 var getObligationAccount = async (query, obligationId, ownerAddress, indexer = false, market, coinPrices, coinAmounts) => {
@@ -2887,12 +2899,12 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
   const debts = {};
   const borrowIncentives = {};
   let totalDepositedPools = 0;
-  let totalDepositedValue = BigNumber3(0);
-  let totalBorrowCapacityValue = BigNumber3(0);
-  let totalRequiredCollateralValue = BigNumber3(0);
+  let totalDepositedValue = BigNumber4(0);
+  let totalBorrowCapacityValue = BigNumber4(0);
+  let totalRequiredCollateralValue = BigNumber4(0);
   let totalBorrowedPools = 0;
-  let totalBorrowedValue = BigNumber3(0);
-  let totalBorrowedValueWithWeight = BigNumber3(0);
+  let totalBorrowedValue = BigNumber4(0);
+  let totalBorrowedValueWithWeight = BigNumber4(0);
   for (const assetCoinName of collateralAssetCoinNames) {
     const collateral = obligationQuery.collaterals.find((collateral2) => {
       const collateralCoinName = query.utils.parseCoinNameFromType(
@@ -2905,7 +2917,7 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
     const coinPrice = coinPrices?.[assetCoinName];
     const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
     if (marketCollateral && coinPrice) {
-      const depositedAmount = BigNumber3(collateral?.amount ?? 0);
+      const depositedAmount = BigNumber4(collateral?.amount ?? 0);
       const depositedCoin = depositedAmount.shiftedBy(-1 * coinDecimal);
       const depositedValue = depositedCoin.multipliedBy(coinPrice);
       const borrowCapacityValue = depositedValue.multipliedBy(
@@ -2914,11 +2926,11 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
       const requiredCollateralValue2 = depositedValue.multipliedBy(
         marketCollateral.liquidationFactor
       );
-      const poolSizeAmount = BigNumber3(marketCollateral.maxDepositAmount).minus(
+      const poolSizeAmount = BigNumber4(marketCollateral.maxDepositAmount).minus(
         marketCollateral.depositAmount
       );
       const availableDepositAmount = minBigNumber(
-        BigNumber3(coinAmount),
+        BigNumber4(coinAmount),
         poolSizeAmount
       );
       const availableDepositCoin = availableDepositAmount.shiftedBy(
@@ -2966,13 +2978,13 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
     const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
     if (marketPool && coinPrice) {
       const increasedRate = debt?.borrowIndex ? marketPool.borrowIndex / Number(debt.borrowIndex) - 1 : 0;
-      const borrowedAmount = BigNumber3(debt?.amount ?? 0);
+      const borrowedAmount = BigNumber4(debt?.amount ?? 0);
       const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
       const requiredRepayAmount = borrowedAmount.multipliedBy(
         increasedRate + 1
       );
       const requiredRepayCoin = requiredRepayAmount.shiftedBy(-1 * coinDecimal);
-      const availableRepayAmount = BigNumber3(coinAmount);
+      const availableRepayAmount = BigNumber4(coinAmount);
       const availableRepayCoin = availableRepayAmount.shiftedBy(
         -1 * coinDecimal
       );
@@ -3018,11 +3030,11 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
         const accountPoint = borrowIncentiveAccount.pointList[rewardCoinName];
         const poolPoint = borrowIncentivePool.points[rewardCoinName];
         if (accountPoint && poolPoint) {
-          let availableClaimAmount = BigNumber3(0);
-          let availableClaimCoin = BigNumber3(0);
-          const accountBorrowedAmount = BigNumber3(accountPoint.weightedAmount);
+          let availableClaimAmount = BigNumber4(0);
+          let availableClaimCoin = BigNumber4(0);
+          const accountBorrowedAmount = BigNumber4(accountPoint.weightedAmount);
           const baseIndexRate = 1e9;
-          const increasedPointRate = poolPoint.currentPointIndex ? BigNumber3(
+          const increasedPointRate = poolPoint.currentPointIndex ? BigNumber4(
             poolPoint.currentPointIndex - accountPoint.index
           ).dividedBy(baseIndexRate) : 1;
           availableClaimAmount = availableClaimAmount.plus(
@@ -3031,11 +3043,11 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
           availableClaimCoin = availableClaimAmount.shiftedBy(
             -1 * poolPoint.coinDecimal
           );
-          const weightScale = BigNumber3(1e12);
-          const boostValue = BigNumber3(accountPoint.weightedAmount).div(
-            BigNumber3(borrowIncentiveAccount.debtAmount).multipliedBy(poolPoint.baseWeight).dividedBy(weightScale)
-          ).isFinite() ? BigNumber3(accountPoint.weightedAmount).div(
-            BigNumber3(borrowIncentiveAccount.debtAmount).multipliedBy(poolPoint.baseWeight).dividedBy(weightScale)
+          const weightScale = BigNumber4(1e12);
+          const boostValue = BigNumber4(accountPoint.weightedAmount).div(
+            BigNumber4(borrowIncentiveAccount.debtAmount).multipliedBy(poolPoint.baseWeight).dividedBy(weightScale)
+          ).isFinite() ? BigNumber4(accountPoint.weightedAmount).div(
+            BigNumber4(borrowIncentiveAccount.debtAmount).multipliedBy(poolPoint.baseWeight).dividedBy(weightScale)
           ).toNumber() : 1;
           if (availableClaimAmount.isGreaterThan(0)) {
             rewards.push({
@@ -3061,12 +3073,12 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
       };
     }
   }
-  let riskLevel = totalRequiredCollateralValue.isZero() ? BigNumber3(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
-  riskLevel = riskLevel.isLessThan(1) ? riskLevel : BigNumber3(1);
-  const accountBalanceValue = totalDepositedValue.minus(totalBorrowedValue).isGreaterThan(0) ? totalDepositedValue.minus(totalBorrowedValue) : BigNumber3(0);
-  const availableCollateralValue = totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight).isGreaterThan(0) ? totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight) : BigNumber3(0);
-  const requiredCollateralValue = totalBorrowedValueWithWeight.isGreaterThan(0) ? totalRequiredCollateralValue : BigNumber3(0);
-  const unhealthyCollateralValue = totalBorrowedValueWithWeight.minus(requiredCollateralValue).isGreaterThan(0) ? totalBorrowedValueWithWeight.minus(requiredCollateralValue) : BigNumber3(0);
+  let riskLevel = totalRequiredCollateralValue.isZero() ? BigNumber4(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
+  riskLevel = riskLevel.isLessThan(1) ? riskLevel : BigNumber4(1);
+  const accountBalanceValue = totalDepositedValue.minus(totalBorrowedValue).isGreaterThan(0) ? totalDepositedValue.minus(totalBorrowedValue) : BigNumber4(0);
+  const availableCollateralValue = totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight).isGreaterThan(0) ? totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight) : BigNumber4(0);
+  const requiredCollateralValue = totalBorrowedValueWithWeight.isGreaterThan(0) ? totalRequiredCollateralValue : BigNumber4(0);
+  const unhealthyCollateralValue = totalBorrowedValueWithWeight.minus(requiredCollateralValue).isGreaterThan(0) ? totalBorrowedValueWithWeight.minus(requiredCollateralValue) : BigNumber4(0);
   const obligationAccount = {
     obligationId,
     // Deposited collateral value (collateral balance)
@@ -3097,16 +3109,16 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
   )) {
     const marketCollateral = market.collaterals[collateralCoinName];
     if (marketCollateral) {
-      let estimatedAvailableWithdrawAmount = BigNumber3(
+      let estimatedAvailableWithdrawAmount = BigNumber4(
         obligationAccount.totalAvailableCollateralValue
       ).dividedBy(marketCollateral.collateralFactor).dividedBy(marketCollateral.coinPrice).shiftedBy(marketCollateral.coinDecimal);
       estimatedAvailableWithdrawAmount = obligationAccount.totalBorrowedValueWithWeight === 0 ? (
         // Note: when there is no debt record, there is no need to estimate and the deposited amount is directly used as available withdraw.
-        BigNumber3(obligationCollateral.depositedAmount)
+        BigNumber4(obligationCollateral.depositedAmount)
       ) : minBigNumber(
         estimatedAvailableWithdrawAmount.multipliedBy(
           estimatedFactor(
-            BigNumber3(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).toNumber(),
+            BigNumber4(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).toNumber(),
             3,
             "increase"
           )
@@ -3123,12 +3135,12 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
   )) {
     const marketPool = market.pools[poolCoinName];
     if (marketPool) {
-      const estimatedRequiredRepayAmount = BigNumber3(
+      const estimatedRequiredRepayAmount = BigNumber4(
         obligationDebt.requiredRepayAmount
       ).multipliedBy(
         estimatedFactor(obligationDebt.borrowedValue, 3, "decrease")
       );
-      let estimatedAvailableBorrowAmount = BigNumber3(
+      let estimatedAvailableBorrowAmount = BigNumber4(
         obligationAccount.totalAvailableCollateralValue
       ).dividedBy(marketPool.borrowWeight).shiftedBy(marketPool.coinDecimal).dividedBy(marketPool.coinPrice);
       estimatedAvailableBorrowAmount = obligationAccount.totalAvailableCollateralValue !== 0 ? minBigNumber(
@@ -3140,7 +3152,7 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
           )
         ).toNumber(),
         marketPool.supplyAmount
-      ) : BigNumber3(0);
+      ) : BigNumber4(0);
       obligationDebt.availableBorrowAmount = estimatedAvailableBorrowAmount.toNumber();
       obligationDebt.availableBorrowCoin = estimatedAvailableBorrowAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
       obligationDebt.requiredRepayAmount = estimatedRequiredRepayAmount.toNumber();
@@ -3151,8 +3163,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
 };
 var getTotalValueLocked = async (query, indexer = false) => {
   const market = await query.queryMarket(indexer);
-  let supplyValue = BigNumber3(0);
-  let borrowValue = BigNumber3(0);
+  let supplyValue = BigNumber4(0);
+  let borrowValue = BigNumber4(0);
   if (indexer) {
     const tvlIndexer = await query.indexer.getTotalValueLocked();
     const tvl2 = {
@@ -3167,15 +3179,15 @@ var getTotalValueLocked = async (query, indexer = false) => {
   }
   for (const pool of Object.values(market.pools)) {
     supplyValue = supplyValue.plus(
-      BigNumber3(pool.supplyCoin).multipliedBy(pool.coinPrice)
+      BigNumber4(pool.supplyCoin).multipliedBy(pool.coinPrice)
     );
     borrowValue = borrowValue.plus(
-      BigNumber3(pool.borrowCoin).multipliedBy(pool.coinPrice)
+      BigNumber4(pool.borrowCoin).multipliedBy(pool.coinPrice)
     );
   }
   for (const collateral of Object.values(market.collaterals)) {
     supplyValue = supplyValue.plus(
-      BigNumber3(collateral.depositCoin).multipliedBy(collateral.coinPrice)
+      BigNumber4(collateral.depositCoin).multipliedBy(collateral.coinPrice)
     );
   }
   const tvl = {
@@ -3187,7 +3199,7 @@ var getTotalValueLocked = async (query, indexer = false) => {
 };
 
 // src/queries/vescaQuery.ts
-import BigNumber4 from "bignumber.js";
+import BigNumber5 from "bignumber.js";
 import { SUI_CLOCK_OBJECT_ID, SuiTxBlock as SuiTxBlock2 } from "@scallop-io/sui-kit";
 import { bcs } from "@mysten/sui.js/bcs";
 var getVescaKeys = async (query, ownerAddress) => {
@@ -3248,7 +3260,7 @@ var getVeSca = async (query, veScaKeyId, ownerAddress) => {
       0
     );
     const lockedScaAmount = String(dynamicFields.locked_sca_amount);
-    const lockedScaCoin = BigNumber4(dynamicFields.locked_sca_amount).shiftedBy(-9).toNumber();
+    const lockedScaCoin = BigNumber5(dynamicFields.locked_sca_amount).shiftedBy(-9).toNumber();
     const currentVeScaBalance = lockedScaCoin * (Math.floor(remainingLockPeriodInMilliseconds / 1e3) / MAX_LOCK_DURATION);
     vesca = {
       id: veScaDynamicFieldObject.objectId,
@@ -3256,7 +3268,7 @@ var getVeSca = async (query, veScaKeyId, ownerAddress) => {
       lockedScaAmount,
       lockedScaCoin,
       currentVeScaBalance,
-      unlockAt: BigNumber4(dynamicFields.unlock_at * 1e3).toNumber()
+      unlockAt: BigNumber5(dynamicFields.unlock_at * 1e3).toNumber()
     };
   }
   return vesca;
@@ -3450,6 +3462,15 @@ var ScallopIndexer = class {
     if (response.status === 200) {
       return response.data.borrowIncentivePools.reduce(
         (borrowIncentivePools, borrowIncentivePool) => {
+          if (Array.isArray(borrowIncentivePool.points)) {
+            borrowIncentivePool.points = borrowIncentivePool.points.reduce(
+              (prev, curr) => {
+                prev[curr.coinName] = curr;
+                return prev;
+              },
+              {}
+            );
+          }
           borrowIncentivePools[borrowIncentivePool.coinName] = borrowIncentivePool;
           return borrowIncentivePools;
         },
@@ -5114,11 +5135,6 @@ var generateQuickVeScaMethod = ({
           newUnlockAt,
           veSca?.unlockAt
         );
-      console.log(
-        new Date(newUnlockAt * 1e3).toLocaleString("en-CA", {
-          hour12: true
-        })
-      );
       const isInitialLock = !veSca?.unlockAt;
       const isLockExpired = !isInitialLock && veSca.unlockAt * 1e3 <= (/* @__PURE__ */ new Date()).getTime();
       if (isInitialLock || isLockExpired) {