@scallop-io/sui-scallop-sdk 0.46.39 → 0.46.41

package/src/models/scallopAddress.ts

@@ -1,4 +1,4 @@
-import { API_BASE_URL, IS_VE_SCA_TEST } from '../constants';
+import { API_BASE_URL, USE_TEST_ADDRESS } from '../constants';
 import type { NetworkType } from '@scallop-io/sui-kit';
 import type {
   ScallopAddressParams,
@@ -309,6 +309,47 @@ const EMPTY_ADDRESSES: AddressesInterface = {
     rewardPool: '',
     userRewardTableId: '',
   },
+  scoin: {
+    id: '',
+    coins: {
+      ssui: {
+        coinType: '',
+        treasury: '',
+      },
+      scetus: {
+        coinType: '',
+        treasury: '',
+      },
+      ssca: {
+        coinType: '',
+        treasury: '',
+      },
+      susdc: {
+        coinType: '',
+        treasury: '',
+      },
+      susdt: {
+        coinType: '',
+        treasury: '',
+      },
+      seth: {
+        coinType: '',
+        treasury: '',
+      },
+      safsui: {
+        coinType: '',
+        treasury: '',
+      },
+      shasui: {
+        coinType: '',
+        treasury: '',
+      },
+      svsui: {
+        coinType: '',
+        treasury: '',
+      },
+    },
+  },
 };
 /**
  * @description
@@ -345,10 +386,10 @@ export class ScallopAddress {
     if (auth) this._auth = auth;
     this._id = id;
     this._network = network || 'mainnet';
-    this._addressesMap = IS_VE_SCA_TEST
+    this._addressesMap = USE_TEST_ADDRESS
       ? new Map([['mainnet', TEST_ADDRESSES]])
       : new Map();
-    if (IS_VE_SCA_TEST) this._currentAddresses = TEST_ADDRESSES;
+    if (USE_TEST_ADDRESS) this._currentAddresses = TEST_ADDRESSES;
   }
 
   /**

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

@@ -1,5 +1,5 @@
 import { SuiKit } from '@scallop-io/sui-kit';
-import { ADDRESSES_ID, SUPPORT_SPOOLS } from '../constants';
+import { ADDRESSES_ID, SUPPORT_POOLS, SUPPORT_SPOOLS } from '../constants';
 import {
   queryMarket,
   getObligations,
@@ -32,6 +32,7 @@ import {
   getPythPrices,
   getVeScaTreasuryInfo,
   getLoyaltyProgramInformations,
+  getFlashLoanFees,
 } from '../queries';
 import {
   ScallopQueryParams,
@@ -44,6 +45,7 @@ import {
   StakePools,
   StakeRewardPools,
   SupportBorrowIncentiveCoins,
+  SupportSCoin,
 } from '../types';
 import { ScallopAddress } from './scallopAddress';
 import { ScallopUtils } from './scallopUtils';
@@ -51,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
@@ -593,4 +600,53 @@ export class ScallopQuery {
   public async getLoyaltyProgramInfos(veScaKey?: string | SuiObjectData) {
     return await getLoyaltyProgramInformations(this, veScaKey);
   }
+
+  /**
+   * 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(
+    assetCoinNames: SupportAssetCoins[] = [...SUPPORT_POOLS]
+  ) {
+    return await getFlashLoanFees(this, assetCoinNames);
+  }
 }

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,8 @@ import {
   PROTOCOL_OBJECT_ID,
   SUPPORT_COLLATERALS,
   BORROW_FEE_PROTOCOL_ID,
+  USE_TEST_ADDRESS,
+  FlashLoanFeeObjectMap,
 } from '../constants';
 import {
   parseOriginMarketPoolData,
@@ -404,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,
@@ -418,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,
@@ -474,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 = {};
 
@@ -875,3 +882,94 @@ export const getMarketCoinAmount = async (
   });
   return BigNumber(amount).toNumber();
 };
+
+/**
+ * Get flashloan fee for specific asset
+ * @param query - The Scallop query instance.
+ * @param assetNames - Specific an array of support pool coin name.
+ * @returns Record of asset name to flashloan fee in decimal
+ */
+
+export const getFlashLoanFees = async (
+  query: ScallopQuery,
+  assetNames: SupportPoolCoins[]
+): Promise<Record<SupportPoolCoins, number>> => {
+  const FEE_RATE = 1e4;
+  const missingAssets: SupportPoolCoins[] = [];
+
+  // create mapping from asset type to asset name
+  const assetTypeMap = assetNames.reduce(
+    (prev, curr) => {
+      const assetType = query.utils.parseCoinType(curr).slice(2);
+      prev[assetType] = curr;
+      return prev;
+    },
+    {} as Record<string, SupportPoolCoins>
+  );
+
+  // use the mapped object first
+  const objIds = assetNames
+    .map((assetName) => {
+      if (!FlashLoanFeeObjectMap[assetName]) {
+        missingAssets.push(assetName);
+        return null;
+      } else {
+        return FlashLoanFeeObjectMap[assetName];
+      }
+    })
+    .filter((t) => !!t) as string[];
+
+  const flashloanFeeObjects = await query.cache.queryGetObjects(objIds, {
+    showContent: true,
+  });
+
+  if (missingAssets.length > 0) {
+    // get market object
+    const marketObjectId = query.address.get('core.market');
+    const marketObjectRes = await query.cache.queryGetObject(marketObjectId, {
+      showContent: true,
+    });
+    if (marketObjectRes.data?.content?.dataType !== 'moveObject')
+      throw new Error('Failed to get market object');
+
+    // get vault
+    const vault = (marketObjectRes.data.content.fields as any).vault;
+
+    // get vault balance sheet object id
+    const flashloanFeesTableId = vault.fields.flash_loan_fees.fields.table
+      .fields.id.id as string;
+
+    // the balance sheet is a VecSet<0x1::type_name::TypeName
+    const balanceSheetDynamicFields = await query.cache.queryGetDynamicFields({
+      parentId: flashloanFeesTableId,
+      limit: 50,
+    });
+
+    // get the dynamic object ids
+    const dynamicFieldObjectIds = balanceSheetDynamicFields.data
+      .filter((field) => {
+        const assetType = (field.name.value as any).name as string;
+        return !!assetTypeMap[assetType];
+      })
+      .map((field) => field.objectId);
+
+    flashloanFeeObjects.push(
+      ...(await query.cache.queryGetObjects(dynamicFieldObjectIds, {
+        showContent: true,
+      }))
+    );
+  }
+
+  return flashloanFeeObjects.reduce(
+    (prev, curr) => {
+      if (curr.content?.dataType === 'moveObject') {
+        const objectFields = curr.content.fields as any;
+        const assetType = (curr.content.fields as any).name.fields.name;
+        const feeNumerator = +objectFields.value;
+        prev[assetTypeMap[assetType]] = feeNumerator / FEE_RATE;
+      }
+      return prev;
+    },
+    {} as Record<SupportPoolCoins, number>
+  );
+};