@scallop-io/sui-scallop-sdk 0.46.40 → 0.46.42

package/src/models/scallopBuilder.ts

@@ -14,6 +14,7 @@ import type {
   ScallopTxBlock,
   SupportMarketCoins,
   SupportAssetCoins,
+  SupportSCoin,
 } from '../types';
 import { ScallopCache } from './scallopCache';
 import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
@@ -124,7 +125,7 @@ export class ScallopBuilder {
     sender: string
   ) {
     const coinType = this.utils.parseCoinType(assetCoinName);
-    const coins = await this.utils.selectCoinIds(amount, coinType, sender);
+    const coins = await this.utils.selectCoins(amount, coinType, sender);
     const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(coins, amount);
     return { takeCoin, leftCoin };
   }
@@ -145,13 +146,48 @@ export class ScallopBuilder {
     sender: string
   ) {
     const marketCoinType = this.utils.parseMarketCoinType(marketCoinName);
-    const coins = await this.utils.selectCoinIds(
-      amount,
-      marketCoinType,
-      sender
+    const coins = await this.utils.selectCoins(amount, marketCoinType, sender);
+    const totalAmount = coins.reduce((prev, coin) => {
+      prev += Number(coin.balance);
+      return prev;
+    }, 0);
+    const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(
+      coins,
+      Math.min(amount, totalAmount)
     );
-    const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(coins, amount);
-    return { takeCoin, leftCoin };
+    return { takeCoin, leftCoin, totalAmount };
+  }
+
+  /**
+   * Specifying the sender's amount of sCoins to get coins args from transaction result.
+   *
+   * @param txBlock - Scallop txBlock or txBlock created by SuiKit .
+   * @param marketCoinName - Specific support sCoin name.
+   * @param amount - Amount of coins to be selected.
+   * @param sender - Sender address.
+   * @return Take coin and left coin.
+   */
+  public async selectSCoin(
+    txBlock: ScallopTxBlock | SuiKitTxBlock,
+    sCoinName: SupportSCoin,
+    amount: number,
+    sender: string
+  ) {
+    const sCoinType = this.utils.parseSCoinType(sCoinName);
+    const coins = await this.utils.selectCoins(amount, sCoinType, sender);
+    const totalAmount = coins.reduce((prev, coin) => {
+      prev += Number(coin.balance);
+      return prev;
+    }, 0);
+    const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(
+      coins,
+      Math.min(totalAmount, amount)
+    );
+    return {
+      takeCoin,
+      leftCoin,
+      totalAmount,
+    };
   }
 
   /**

package/src/models/scallopCache.ts

@@ -1,5 +1,10 @@
 import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
-import { SuiTxArg, SuiTxBlock, normalizeStructTag } from '@scallop-io/sui-kit';
+import {
+  SuiTxArg,
+  SuiTxBlock,
+  normalizeStructTag,
+  normalizeSuiAddress,
+} from '@scallop-io/sui-kit';
 import { SuiKit } from '@scallop-io/sui-kit';
 import type {
   SuiObjectResponse,
@@ -162,6 +167,7 @@ export class ScallopCache {
     objectIds: string[],
     options?: SuiObjectDataOptions
   ): Promise<SuiObjectData[]> {
+    if (objectIds.length === 0) return [];
     const queryKey = [
       'getObjects',
       JSON.stringify(objectIds),
@@ -171,7 +177,7 @@ export class ScallopCache {
       queryKey.push(JSON.stringify(options));
     }
     return this.queryClient.fetchQuery({
-      queryKey,
+      queryKey: queryKey,
       queryFn: async () => {
         return await this.suiKit.getObjects(objectIds, options);
       },
@@ -254,7 +260,7 @@ export class ScallopCache {
         const allBalances = await this.suiKit
           .client()
           .getAllBalances({ owner });
-        return allBalances.reduce(
+        const balances = allBalances.reduce(
           (acc, coinBalance) => {
             if (coinBalance.totalBalance !== '0') {
               acc[normalizeStructTag(coinBalance.coinType)] =
@@ -264,12 +270,34 @@ export class ScallopCache {
           },
           {} as { [k: string]: string }
         );
+
+        // Set query data for each coin balance
+        for (const coinType in balances) {
+          const coinBalanceQueryKey = [
+            'getCoinBalance',
+            normalizeSuiAddress(owner),
+            normalizeStructTag(coinType),
+          ];
+          this.queryClient.setQueryData(
+            coinBalanceQueryKey,
+            balances[coinType]
+          );
+        }
+
+        return balances;
       },
+      staleTime: 5000,
     });
   }
 
   public async queryGetCoinBalance(input: GetBalanceParams): Promise<string> {
-    const queryKey = ['getCoinBalance', input.owner, input.coinType];
+    if (!input.coinType) return '0';
+
+    const queryKey = [
+      'getCoinBalance',
+      normalizeSuiAddress(input.owner),
+      normalizeStructTag(input.coinType),
+    ];
     return this.queryClient.fetchQuery({
       queryKey,
       queryFn: async () => {

package/src/models/scallopClient.ts

@@ -4,6 +4,8 @@ import {
   ADDRESSES_ID,
   SUPPORT_BORROW_INCENTIVE_POOLS,
   SUPPORT_BORROW_INCENTIVE_REWARDS,
+  SUPPORT_SCOIN,
+  SUPPORT_SPOOLS,
 } from '../constants';
 import { ScallopAddress } from './scallopAddress';
 import { ScallopUtils } from './scallopUtils';
@@ -23,6 +25,7 @@ import type {
   SupportStakeMarketCoins,
   SupportBorrowIncentiveCoins,
   ScallopTxBlock,
+  SupportSCoin,
 } from '../types';
 import { ScallopCache } from './scallopCache';
 import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
@@ -959,6 +962,124 @@ export class ScallopClient {
     }
   }
 
+  /* ==================== Migrate market coin to sCoin method ==================== */
+  /**
+   * Function to migrate all market coin in user wallet into sCoin
+   * @returns Transaction response
+   */
+  public async migrateAllMarketCoin<S extends boolean>(
+    sign: S = true as S
+  ): Promise<ScallopClientFnReturnType<S>> {
+    const txBlock = this.builder.createTxBlock();
+    txBlock.setSender(this.walletAddress);
+
+    const toTransfer: SuiObjectArg[] = [];
+    await Promise.all(
+      SUPPORT_SCOIN.map(async (sCoinName) => {
+        /**
+         * First check marketCoin inside mini wallet
+         * Then check stakedMarketCoin inside spool
+         */
+        let toDestroyMarketCoin: SuiObjectArg | undefined;
+
+        // check market coin in mini wallet
+        try {
+          const marketCoins = await this.utils.selectCoins(
+            Number.MAX_SAFE_INTEGER,
+            this.utils.parseMarketCoinType(sCoinName as SupportSCoin),
+            this.walletAddress
+          ); // throw error no coins found
+
+          const mergedMarketCoin = marketCoins[0];
+          if (marketCoins.length > 1) {
+            txBlock.mergeCoins(mergedMarketCoin, marketCoins.slice(1));
+          }
+
+          toDestroyMarketCoin = mergedMarketCoin;
+        } catch (e: any) {
+          // Ignore
+          const errMsg = e.toString() as String;
+          if (!errMsg.includes('No valid coins found for the transaction'))
+            throw e;
+        }
+
+        // check for staked market coin in spool
+        if (SUPPORT_SPOOLS.includes(sCoinName as SupportStakeMarketCoins)) {
+          try {
+            const stakedMarketCoins = await txBlock.unstakeQuick(
+              Number.MAX_SAFE_INTEGER,
+              sCoinName as SupportStakeMarketCoins
+            );
+            if (stakedMarketCoins.length > 0) {
+              const mergedStakedMarketCoin = stakedMarketCoins[0];
+              if (stakedMarketCoins.length > 1) {
+                txBlock.mergeCoins(
+                  mergedStakedMarketCoin,
+                  stakedMarketCoins.slice(1)
+                );
+              }
+              // merge with takeMarketCoin
+              if (toDestroyMarketCoin) {
+                txBlock.mergeCoins(toDestroyMarketCoin, [
+                  mergedStakedMarketCoin,
+                ]);
+              } else {
+                toDestroyMarketCoin = mergedStakedMarketCoin;
+              }
+            }
+          } catch (e: any) {
+            // ignore
+            const errMsg = e.toString();
+            if (!errMsg.includes('No stake account found')) throw e;
+          }
+        }
+
+        // if market coin found, mint sCoin
+        if (toDestroyMarketCoin) {
+          // mint new sCoin
+          const sCoin = txBlock.mintSCoin(
+            sCoinName as SupportSCoin,
+            toDestroyMarketCoin
+          );
+
+          // check if current sCoin exist
+          try {
+            const existSCoins = await this.utils.selectCoins(
+              Number.MAX_SAFE_INTEGER,
+              this.utils.parseSCoinType(sCoinName as SupportSCoin),
+              this.walletAddress
+            ); // throw error on no coins found
+            const mergedSCoin = existSCoins[0];
+            if (existSCoins.length > 1) {
+              txBlock.mergeCoins(mergedSCoin, existSCoins.slice(1));
+            }
+
+            // merge existing sCoin to new sCoin
+            txBlock.mergeCoins(sCoin, [mergedSCoin]);
+          } catch (e: any) {
+            // ignore
+            const errMsg = e.toString() as String;
+            if (!errMsg.includes('No valid coins found for the transaction'))
+              throw e;
+          }
+          toTransfer.push(sCoin);
+        }
+      })
+    );
+
+    if (toTransfer.length > 0) {
+      txBlock.transferObjects(toTransfer, this.walletAddress);
+    }
+
+    if (sign) {
+      return (await this.suiKit.signAndSendTxn(
+        txBlock
+      )) as ScallopClientFnReturnType<S>;
+    } else {
+      return txBlock.txBlock as ScallopClientFnReturnType<S>;
+    }
+  }
+
   /* ==================== Other Method ==================== */
 
   /**

package/src/models/scallopQuery.ts

@@ -45,6 +45,7 @@ import {
   StakePools,
   StakeRewardPools,
   SupportBorrowIncentiveCoins,
+  SupportSCoin,
 } from '../types';
 import { ScallopAddress } from './scallopAddress';
 import { ScallopUtils } from './scallopUtils';
@@ -52,6 +53,11 @@ import { ScallopIndexer } from './scallopIndexer';
 import { ScallopCache } from './scallopCache';
 import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 import { SuiObjectData } from '@mysten/sui.js/src/client';
+import {
+  getSCoinAmount,
+  getSCoinAmounts,
+  getSCoinTotalSupply,
+} from 'src/queries/sCoinQuery';
 
 /**
  * @description
@@ -596,6 +602,46 @@ export class ScallopQuery {
   }
 
   /**
+   * Get total supply of sCoin
+   * @param sCoinName - Supported sCoin name
+   * @returns Total Supply
+   */
+  public async getSCoinTotalSupply(sCoinName: SupportSCoin) {
+    return await getSCoinTotalSupply(this, sCoinName);
+  }
+
+  /**
+   * Get all sCoin amounts.
+   *
+   * @param sCoinNames - Specific an array of support sCoin name.
+   * @param ownerAddress - The owner address.
+   * @return All market sCoin amounts.
+   */
+  public async getSCoinAmounts(
+    sCoinNames?: SupportSCoin[],
+    ownerAddress?: string
+  ) {
+    return await getSCoinAmounts(this, sCoinNames, ownerAddress);
+  }
+
+  /**
+   * Get sCoin amount.
+   *
+   * @param coinNames - Specific support sCoin name.
+   * @param ownerAddress - The owner address.
+   * @return sCoin amount.
+   */
+  public async getSCoinAmount(
+    sCoinName: SupportSCoin | SupportMarketCoins,
+    ownerAddress?: string
+  ) {
+    const parsedSCoinName = this.utils.parseSCoinName(sCoinName);
+    return parsedSCoinName
+      ? await getSCoinAmount(this, parsedSCoinName, ownerAddress)
+      : 0;
+  }
+
+  /*
    * Get flashloan fee for specified assets
    */
   public async getFlashLoanFees(

package/src/models/scallopUtils.ts

@@ -16,6 +16,8 @@ import {
   coinIds,
   UNLOCK_ROUND_DURATION,
   MAX_LOCK_DURATION,
+  SUPPORT_SCOIN,
+  sCoinIds,
 } from '../constants';
 import { queryObligation } from '../queries';
 import {
@@ -35,6 +37,7 @@ import type {
   CoinPrices,
   PriceMap,
   CoinWrappedType,
+  SupportSCoin,
 } from '../types';
 import { PYTH_ENDPOINTS } from 'src/constants/pyth';
 import { ScallopCache } from './scallopCache';
@@ -170,6 +173,57 @@ export class ScallopUtils {
     }
   }
 
+  /**
+   * Convert coin name to sCoin name.
+   *
+   * @param coinName - Specific support coin name.
+   * @return sCoin name.
+   */
+  public parseSCoinName<T extends SupportSCoin>(
+    coinName: SupportCoins | SupportMarketCoins
+  ) {
+    // need more check because sbtc, ssol and sapt has no sCoin type
+    if (
+      isMarketCoin(coinName) &&
+      SUPPORT_SCOIN.includes(coinName as SupportSCoin)
+    ) {
+      return coinName as T;
+    } else {
+      const marketCoinName = `s${coinName}`;
+      if (SUPPORT_SCOIN.includes(marketCoinName as SupportSCoin)) {
+        return marketCoinName as T;
+      }
+      return undefined;
+    }
+  }
+  /**
+   * Convert sCoin name into sCoin type
+   * @param sCoinName
+   * @returns sCoin type
+   */
+  public parseSCoinType(sCoinName: SupportSCoin) {
+    return sCoinIds[sCoinName];
+  }
+
+  /**
+   * Convert sCoin name into its underlying coin type
+   * @param sCoinName
+   * @returns coin type
+   */
+  public parseUnderlyingSCoinType(sCoinName: SupportSCoin) {
+    const coinName = this.parseCoinName(sCoinName);
+    return this.parseCoinType(coinName);
+  }
+
+  /**
+   * Get sCoin treasury id from sCoin name
+   * @param sCoinName
+   * @returns sCoin treasury id
+   */
+  public getSCoinTreasury(sCoinName: SupportSCoin) {
+    return this._address.get(`scoin.coins.${sCoinName}.treasury`);
+  }
+
   /**
    * Convert coin name to market coin type.
    *
@@ -328,7 +382,7 @@ export class ScallopUtils {
    * @param coinType - The coin type, default is 0x2::SUI::SUI.
    * @return The selected transaction coin arguments.
    */
-  public async selectCoinIds(
+  public async selectCoins(
     amount: number,
     coinType: string = SUI_TYPE_ARG,
     ownerAddress?: string
@@ -339,7 +393,7 @@ export class ScallopUtils {
       amount,
       coinType
     );
-    return coins.map((c) => c.objectId);
+    return coins;
   }
 
   /**

package/src/queries/coreQuery.ts

@@ -4,6 +4,7 @@ import {
   PROTOCOL_OBJECT_ID,
   SUPPORT_COLLATERALS,
   BORROW_FEE_PROTOCOL_ID,
+  USE_TEST_ADDRESS,
   FlashLoanFeeObjectMap,
 } from '../constants';
 import {
@@ -405,7 +406,12 @@ export const getMarketPool = async (
     }
   }
 
-  if (balanceSheet && borrowIndex && interestModel && borrowFeeRate) {
+  if (
+    balanceSheet &&
+    borrowIndex &&
+    interestModel &&
+    (USE_TEST_ADDRESS || borrowFeeRate)
+  ) {
     const parsedMarketPoolData = parseOriginMarketPoolData({
       type: interestModel.type.fields,
       maxBorrowRate: interestModel.max_borrow_rate.fields,
@@ -419,7 +425,7 @@ export const getMarketPool = async (
       reserve: balanceSheet.revenue,
       reserveFactor: interestModel.revenue_factor.fields,
       borrowWeight: interestModel.borrow_weight.fields,
-      borrowFeeRate: borrowFeeRate,
+      borrowFeeRate: borrowFeeRate || { value: '0' },
       baseBorrowRatePerSec: interestModel.base_borrow_rate_per_sec.fields,
       borrowRateOnHighKink: interestModel.borrow_rate_on_high_kink.fields,
       borrowRateOnMidKink: interestModel.borrow_rate_on_mid_kink.fields,
@@ -475,10 +481,10 @@ export const getMarketCollaterals = async (
   collateralCoinNames = collateralCoinNames || [...SUPPORT_COLLATERALS];
   const marketId = query.address.get('core.market');
   const [marketObjectResponse, coinPrices] = await Promise.all([
-    query.cache.queryGetObject(marketId, {
+    await query.cache.queryGetObject(marketId, {
       showContent: true,
     }),
-    query.utils.getCoinPrices(collateralCoinNames ?? []),
+    await query.utils.getCoinPrices(collateralCoinNames ?? []),
   ]);
   const marketCollaterals: MarketCollaterals = {};
 

package/src/queries/portfolioQuery.ts

@@ -24,6 +24,7 @@ import type {
   TotalValueLocked,
   SupportBorrowIncentiveCoins,
   ObligationBorrowIcentiveReward,
+  SupportBorrowIncentiveRewardCoins,
 } from '../types';
 
 /**
@@ -118,7 +119,8 @@ export const getLending = async (
   stakeAccounts?: StakeAccount[],
   coinAmount?: number,
   marketCoinAmount?: number,
-  coinPrice?: number
+  coinPrice?: number,
+  sCoinAmount?: number
 ) => {
   const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
   marketPool = marketPool || (await query.getMarketPool(poolCoinName, indexer));
@@ -140,6 +142,8 @@ export const getLending = async (
   marketCoinAmount =
     marketCoinAmount ||
     (await query.getMarketCoinAmount(marketCoinName, ownerAddress));
+  sCoinAmount =
+    sCoinAmount || (await query.getSCoinAmount(marketCoinName, ownerAddress));
   coinPrice =
     coinPrice ||
     (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
@@ -206,9 +210,9 @@ export const getLending = async (
   }
 
   // Handle supplied coin
-  const suppliedAmount = BigNumber(marketCoinAmount).multipliedBy(
-    marketPool?.conversionRate ?? 1
-  );
+  const suppliedAmount = BigNumber(marketCoinAmount)
+    .plus(BigNumber(sCoinAmount))
+    .multipliedBy(marketPool?.conversionRate ?? 1);
   const suppliedCoin = suppliedAmount.shiftedBy(-1 * coinDecimal);
   const suppliedValue = suppliedCoin.multipliedBy(coinPrice ?? 0);
 
@@ -351,6 +355,7 @@ export const getObligationAccount = async (
   let totalBorrowCapacityValue = BigNumber(0);
   let totalRequiredCollateralValue = BigNumber(0);
   let totalBorrowedPools = 0;
+  let totalRewardedPools = 0;
   let totalBorrowedValue = BigNumber(0);
   let totalBorrowedValueWithWeight = BigNumber(0);
 
@@ -555,6 +560,22 @@ export const getObligationAccount = async (
         }
       }
 
+      if (
+        Object.keys(borrowIncentivePool.points).some((coinName: any) => {
+          const rewardApr =
+            borrowIncentivePool.points[
+              coinName as SupportBorrowIncentiveRewardCoins
+            ]?.rewardApr;
+          return (
+            rewardApr !== Infinity &&
+            typeof rewardApr == 'number' &&
+            rewardApr > 0
+          );
+        }) &&
+        borrowIncentiveAccount.debtAmount > 0
+      ) {
+        totalRewardedPools++;
+      }
       borrowIncentives[coinName] = {
         coinName: borrowIncentivePool.coinName,
         coinType: borrowIncentivePool.coinType,
@@ -612,6 +633,7 @@ export const getObligationAccount = async (
     totalRiskLevel: riskLevel.toNumber(),
     totalDepositedPools,
     totalBorrowedPools,
+    totalRewardedPools,
     collaterals,
     debts,
     borrowIncentives,

package/src/queries/sCoinQuery.ts

@@ -0,0 +1,94 @@
+import { bcs } from '@mysten/sui.js/bcs';
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import { SUPPORT_SCOIN } from 'src/constants';
+import { ScallopQuery } from 'src/models';
+import { OptionalKeys, SupportSCoin, sCoinBalance } from 'src/types';
+
+/**
+ * Get total supply of sCoin
+ * @param query
+ * @param sCoinName
+ * @returns `number`
+ */
+export const getSCoinTotalSupply = async (
+  query: ScallopQuery,
+  sCoinName: SupportSCoin
+): Promise<sCoinBalance> => {
+  const sCoinPkgId = query.address.get('scoin.id');
+  // get treasury
+  const args = [query.utils.getSCoinTreasury(sCoinName)];
+  const typeArgs = [
+    query.utils.parseSCoinType(sCoinName),
+    query.utils.parseUnderlyingSCoinType(sCoinName),
+  ];
+  const queryTarget = `${sCoinPkgId}::s_coin_converter::total_supply`;
+  const queryResults = await query.cache.queryInspectTxn({
+    queryTarget,
+    args,
+    typeArgs,
+  });
+  const results = queryResults.results;
+  if (results && results[0].returnValues) {
+    const value = Uint8Array.from(results[0].returnValues[0][0]);
+    const type = results[0].returnValues[0][1]; // should be u64
+    assert(type === 'u64', 'Result type is not u64');
+
+    return BigNumber(bcs.de(type, value))
+      .shiftedBy(
+        query.utils.getCoinDecimal(query.utils.parseCoinName(sCoinName))
+      )
+      .toNumber();
+  }
+
+  return 0;
+};
+
+/**
+ * Query all owned sCoin amount.
+ *
+ * @param query - The Scallop query instance.
+ * @param sCoinNames - Specific an array of support sCoin name.
+ * @param ownerAddress - The owner address.
+ * @return All owned sCoins amount.
+ */
+export const getSCoinAmounts = async (
+  query: ScallopQuery,
+  sCoinNames?: SupportSCoin[],
+  ownerAddress?: string
+) => {
+  sCoinNames = sCoinNames || [...SUPPORT_SCOIN];
+  const owner = ownerAddress || query.suiKit.currentAddress();
+  const sCoins = {} as OptionalKeys<Record<SupportSCoin, number>>;
+
+  await Promise.allSettled(
+    sCoinNames.map(async (sCoinName) => {
+      const sCoin = await getSCoinAmount(query, sCoinName, owner);
+      sCoins[sCoinName] = sCoin;
+    })
+  );
+
+  return sCoins;
+};
+
+/**
+ * Query owned sCoin amount.
+ *
+ * @param query - The Scallop query instance.
+ * @param sCoinNames - Specific support sCoin name.
+ * @param ownerAddress - The owner address.
+ * @return Owned sCoin amount.
+ */
+export const getSCoinAmount = async (
+  query: ScallopQuery,
+  sCoinName: SupportSCoin,
+  ownerAddress?: string
+) => {
+  const owner = ownerAddress || query.suiKit.currentAddress();
+  const sCoinType = query.utils.parseSCoinType(sCoinName);
+  const amount = await query.cache.queryGetCoinBalance({
+    owner,
+    coinType: sCoinType,
+  });
+  return BigNumber(amount).toNumber();
+};

package/src/queries/vescaQuery.ts

@@ -244,7 +244,6 @@ export const getVeScaTreasuryInfo = async (
   const treasuryFields = veScaTreasury.data.content
     .fields as VeScaTreasuryFields;
 
-  console.log(treasuryFields);
   const totalLockedSca = BigNumber(
     treasuryFields.unlock_schedule.fields.locked_sca_amount
   )

package/src/test.ts

@@ -0,0 +1,19 @@
+import { Scallop } from './models';
+import * as dotenv from 'dotenv';
+dotenv.config();
+const scallop = new Scallop({
+  secretKey: process.env.SECRET_KEY as string,
+});
+
+const main = async () => {
+  const query = await scallop.createScallopQuery();
+
+  const res = await query.getVeScas(
+    '0xd1a70cfe7332e994a950b9c570e93def4b6d2ec53b34ff5c0cc9946226a7cf3d'
+  );
+  console.dir(res, { depth: null });
+};
+main()
+  .then()
+  .catch(console.error)
+  .finally(() => process.exit(0));