@scallop-io/sui-scallop-sdk 1.5.3 → 2.0.0-alpha.2

package/src/queries/flashloanFeeQuery.ts

@@ -0,0 +1,86 @@
+import { SuiObjectData } from '@mysten/sui/client';
+import { ScallopUtils } from 'src/models';
+import { ScallopConstants } from 'src/models/scallopConstants';
+
+const FLASHLOAN_FEES_TABLE_ID =
+  '0x00481a93b819d744a7d79ecdc6c62c74f2f7cb4779316c4df640415817ac61bb' as const;
+
+export const queryFlashLoanFees = async (
+  utils: ScallopUtils,
+  assetNames: string[],
+  feeRate: number
+) => {
+  const assetNamesSet = new Set(assetNames);
+  const assetTypeMap = Object.fromEntries(
+    Object.entries(utils.constants.coinTypeToCoinNameMap).filter(([_, value]) =>
+      assetNamesSet.has(value!)
+    )
+  );
+
+  let cursor: string | null | undefined = null;
+  let nextPage: boolean = false;
+  const flashloanFeeObjects: SuiObjectData[] = [];
+  do {
+    const resp = await utils.cache.queryGetDynamicFields({
+      parentId: FLASHLOAN_FEES_TABLE_ID,
+      limit: 10,
+      cursor,
+    });
+
+    if (!resp) break;
+    const { data, hasNextPage, nextCursor } = resp;
+    // get the dynamic object ids
+    const dynamicFieldObjectIds =
+      data
+        .filter((field) => {
+          const assetType = `0x${(field.name.value as any).name as string}`;
+          return !!assetTypeMap[assetType];
+        })
+        .map((field) => field.objectId) ?? [];
+
+    flashloanFeeObjects.push(
+      ...(await utils.cache.queryGetObjects(dynamicFieldObjectIds))
+    );
+    nextPage = hasNextPage;
+    cursor = nextCursor;
+  } while (nextPage);
+
+  return flashloanFeeObjects.reduce(
+    (prev, curr) => {
+      if (curr.content?.dataType === 'moveObject') {
+        const assetType = `0x${(curr.content.fields as any).name.fields.name}`;
+        const assetName = assetTypeMap[assetType];
+        if (!assetName) return prev;
+
+        const objectFields = curr.content.fields as any;
+        const feeNumerator = +objectFields.value;
+        prev[assetName] = feeNumerator / feeRate;
+      }
+      return prev;
+    },
+    {} as Record<string, number>
+  );
+};
+
+export const parseFlashloanFeeObjects = (
+  constants: ScallopConstants,
+  objects: SuiObjectData[],
+  feeRate: number
+) => {
+  const assetTypeMap = constants.coinTypeToCoinNameMap;
+  return objects.reduce(
+    (prev, curr) => {
+      if (curr.content?.dataType === 'moveObject') {
+        const assetType = `0x${(curr.content.fields as any).name.fields.name}`;
+        const assetName = assetTypeMap[assetType];
+        if (!assetName) return prev;
+
+        const objectFields = curr.content.fields as any;
+        const feeNumerator = +objectFields.value;
+        prev[assetName] = feeNumerator / feeRate;
+      }
+      return prev;
+    },
+    {} as Record<string, number>
+  );
+};

package/src/queries/isolatedAssetQuery.ts

@@ -1,8 +1,6 @@
 import { DynamicFieldInfo, DynamicFieldName } from '@mysten/sui/client';
 import { ScallopQuery, ScallopUtils } from '../models';
-import { SupportPoolCoins } from '../types';
 import { z as zod } from 'zod';
-import { POOL_ADDRESSES, SUPPORT_POOLS } from 'src/constants';
 
 const isolatedAssetZod = zod.object({
   dataType: zod.string(),
@@ -28,14 +26,16 @@ const isolatedAssetKeyType = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da2
  * @returns list of isolated assets coin types
  */
 export const getIsolatedAssets = async (
-  query: ScallopQuery
+  query: ScallopQuery,
+  useOnChainQuery: boolean = false
 ): Promise<string[]> => {
-  if (SUPPORT_POOLS.every((t) => !!POOL_ADDRESSES[t])) {
-    return SUPPORT_POOLS.filter(
-      (t): t is typeof t & { coinType: string; isolatedAssetKey: string } =>
-        !!POOL_ADDRESSES[t]?.isolatedAssetKey && !!POOL_ADDRESSES[t]?.coinType
-    ).map((t) => POOL_ADDRESSES[t as SupportPoolCoins]?.coinType!);
+  if (!useOnChainQuery) {
+    return query.utils
+      .getSupportedPoolAddresses()
+      .filter((t) => !!t.isolatedAssetKey)
+      .map((t) => t.coinName);
   }
+
   try {
     const marketObject = query.address.get('core.market');
     const isolatedAssets: string[] = [];
@@ -86,10 +86,11 @@ export const getIsolatedAssets = async (
  */
 export const isIsolatedAsset = async (
   utils: ScallopUtils,
-  coinName: SupportPoolCoins
+  coinName: string
 ): Promise<boolean> => {
-  if (POOL_ADDRESSES[coinName]) {
-    return !!POOL_ADDRESSES[coinName].isolatedAssetKey;
+  const assetInPoolAddresses = utils.constants.poolAddresses[coinName];
+  if (assetInPoolAddresses) {
+    return !!assetInPoolAddresses.isolatedAssetKey;
   }
 
   const marketObject = utils.address.get('core.market');

package/src/queries/poolAddressesQuery.ts

@@ -1,59 +1,118 @@
-import { PYTH_FEED_IDS } from 'src/constants';
-import { ScallopQuery } from 'src/models';
-import { OptionalKeys, SupportPoolCoins } from 'src/types';
+import { getFullnodeUrl, SuiClient } from '@mysten/sui/client';
+import { AddressesInterface, OptionalKeys, PoolAddress } from 'src/types';
 
-export const getAllAddresses = async (
-  query: ScallopQuery,
-  pools: SupportPoolCoins[]
+const RPC_PROVIDERS = [
+  getFullnodeUrl('mainnet'),
+  'https://sui-mainnet.public.blastapi.io',
+  'https://sui-mainnet-ca-2.cosmostation.io',
+  'https://sui-mainnet-eu-4.cosmostation.io',
+  'https://sui-mainnet-endpoint.blockvision.org',
+  'https://sui-rpc.publicnode.com',
+  'https://sui-mainnet-rpc.allthatnode.com',
+  'https://mainnet.suiet.app',
+  'https://mainnet.sui.rpcpool.com',
+  'https://sui1mainnet-rpc.chainode.tech',
+  'https://fullnode.mainnet.apis.scallop.io',
+  'https://sui-mainnet-us-2.cosmostation.io',
+];
+
+const tryRequest = async <T>(fn: (client: SuiClient) => T) => {
+  for (const rpc of RPC_PROVIDERS) {
+    try {
+      const res = await fn(new SuiClient({ url: rpc }));
+      return res;
+    } catch (e: any) {
+      if (e.status !== 429) {
+        throw e;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+  }
+  throw new Error('Failed to fetch data');
+};
+
+const queryFlashloanFeeObjectIds = async (
+  client: SuiClient,
+  coinTypeMap: Set<string>, // set of coin types
+  flashloanFeeTableId: string = '0x00481a93b819d744a7d79ecdc6c62c74f2f7cb4779316c4df640415817ac61bb'
 ) => {
-  const results: OptionalKeys<
-    Record<
-      SupportPoolCoins,
-      {
-        coinName: string;
-        symbol: string;
-        lendingPoolAddress?: string;
-        collateralPoolAddress?: string; // not all pool has collateral
-        borrowDynamic?: string;
-        spoolReward?: string;
-        spool?: string;
-        sCoinType?: string;
-        sCoinName?: string;
-        sCoinSymbol?: string;
-        sCoinTreasury?: string;
-        interestModel?: string;
-        riskModel?: string;
-        borrowFeeKey?: string;
-        supplyLimitKey?: string;
-        borrowLimitKey?: string;
-        isolatedAssetKey?: string;
-        coinMetadataId?: string;
-        borrowIncentivePoolId?: string;
-        coinType?: string;
-        sCoinMetadataId?: string;
-        spoolName?: string;
-        decimals: number;
-        pythFeed?: string;
-        pythFeedObjectId?: string;
+  let cursor: string | null | undefined = null;
+  let nextPage: boolean = false;
+  const flashloanFeeObjectIds: Record<string, string> = {}; // <coinType, flashloanFeeObjectId>
+
+  do {
+    const resp = await client.getDynamicFields({
+      parentId: flashloanFeeTableId,
+      limit: 10,
+      cursor,
+    });
+    if (!resp) break;
+    const { data, hasNextPage, nextCursor } = resp;
+    // get the dynamic object ids
+    data.forEach((field) => {
+      const assetType = `0x${(field.name.value as any).name as string}`;
+      if (coinTypeMap.has(assetType)) {
+        flashloanFeeObjectIds[assetType] = field.objectId;
       }
-    >
-  > = {};
+    });
+    nextPage = hasNextPage;
+    cursor = nextCursor;
+  } while (nextPage);
+
+  return flashloanFeeObjectIds;
+};
 
-  const marketId = query.address.get('core.market');
-  const marketObject = (await query.cache.queryGetObject(marketId))?.data;
+export const getPoolAddresses = async (
+  addressId: string,
+  poolNames: string[] = []
+) => {
+  const poolNameSet = new Set(poolNames);
+  const results: OptionalKeys<Record<string, PoolAddress>> = {};
 
-  if (!(marketObject && marketObject.content?.dataType === 'moveObject'))
-    throw new Error(`Failed to fetch marketObject`);
+  // fetch the Address API
+  const URL = 'https://sui.apis.scallop.io';
+  const addressApiResponse = (
+    await fetch(`${URL}/addresses/${addressId}`).then((res) => res.json())
+  ).mainnet as unknown as AddressesInterface;
 
-  const fields = marketObject.content.fields as any;
+  if (!addressApiResponse) throw new Error('Failed to fetch addresses');
+
+  // Compose pools based on addresses
+  const pools = Object.keys(addressApiResponse.core.coins);
+  if (pools.length === 0) throw new Error('Pools empty');
 
   const coinTypesPairs = pools.reduce(
-    (acc, pool) => {
-      acc.push([pool, query.utils.parseCoinType(pool).substring(2)]);
+    (acc, poolName) => {
+      if (poolNameSet.size > 0 && !poolNameSet.has(poolName)) return acc;
+      const value =
+        addressApiResponse.core.coins[
+          poolName as keyof typeof addressApiResponse.core.coins
+        ];
+      if (value && value.coinType) {
+        acc.push([poolName, value.coinType]);
+      }
       return acc;
     },
-    [] as [SupportPoolCoins, string][]
+    [] as [string, string][]
   );
+  if (coinTypesPairs.length === 0) throw new Error('No coinTypesPairs');
+
+  const marketId = addressApiResponse.core.market;
+  const marketObject = (
+    await tryRequest(async (client) => {
+      return await client.getObject({
+        id: marketId,
+        options: {
+          showContent: true,
+        },
+      });
+    })
+  ).data;
+
+  if (!(marketObject && marketObject.content?.dataType === 'moveObject'))
+    throw new Error(`Failed to fetch marketObject`);
+
+  const fields = marketObject.content.fields as any;
 
   const balanceSheetParentId =
     fields.vault.fields.balance_sheets.fields.table.fields.id.id;
@@ -79,111 +138,127 @@ export const getAllAddresses = async (
     type: string,
     value: any
   ) => {
-    try {
-      return (
-        await query.cache.queryGetDynamicFieldObject({
+    return (
+      await tryRequest(async (client) => {
+        return await client.getDynamicFieldObject({
           parentId,
           name: {
             type,
             value,
           },
-        })
-      )?.data?.objectId;
-    } catch (e: any) {
-      console.error(e.message);
-      return undefined;
-    }
+        });
+      })
+    ).data?.objectId;
   };
 
+  // query flashloan fee objects first
+  const flashloanFeeObjectIds = await tryRequest(async (client) => {
+    return await queryFlashloanFeeObjectIds(
+      client,
+      new Set(coinTypesPairs.map(([, coinType]) => coinType))
+    );
+  });
+
   await Promise.all(
     coinTypesPairs.map(async ([coinName, coinType]) => {
+      const coinTypeKey = coinType.slice(2);
       const addresses = await Promise.all([
         fetchDynamicObject(balanceSheetParentId, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
         fetchDynamicObject(collateralStatsParentId, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
         fetchDynamicObject(borrowDynamicsParentid, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
         fetchDynamicObject(interestModelParentId, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
         fetchDynamicObject(riskModelParentId, ADDRESS_TYPE, {
-          name: coinType,
+          name: coinTypeKey,
         }),
-        fetchDynamicObject(marketId, BORROW_FEE_TYPE, coinType),
-        fetchDynamicObject(marketId, SUPPLY_LIMIT_TYPE, coinType),
-        fetchDynamicObject(marketId, BORROW_LIMIT_TYPE, coinType),
-        fetchDynamicObject(marketId, ISOLATED_ASSET_KEY, coinType),
+        fetchDynamicObject(marketId, BORROW_FEE_TYPE, coinTypeKey),
+        fetchDynamicObject(marketId, SUPPLY_LIMIT_TYPE, coinTypeKey),
+        fetchDynamicObject(marketId, BORROW_LIMIT_TYPE, coinTypeKey),
+        fetchDynamicObject(marketId, ISOLATED_ASSET_KEY, coinTypeKey),
       ]);
 
-      const spool = query.address.get(
-        // @ts-ignore
-        `spool.pools.s${coinName}.id`
-      );
-      const rewardPool = query.address.get(
-        // @ts-ignore
-        `spool.pools.s${coinName}.rewardPoolId`
-      );
-      const sCoinType = query.address.get(
-        // @ts-ignore
-        `scoin.coins.s${coinName}.coinType`
-      );
-      const sCoinName = sCoinType
-        ? query.utils.parseSCoinName(coinName)
-        : undefined;
-      const sCoinSymbol = sCoinName
-        ? query.utils.parseSymbol(sCoinName)
-        : undefined;
-      const sCoinTreasury = query.address.get(
-        // @ts-ignore
-        `scoin.coins.s${coinName}.treasury`
-      );
-      const coinMetadataId = query.address.get(
-        `core.coins.${coinName}.metaData`
-      );
-      const sCoinMetadataId = query.address.get(
+      // @ts-ignore
+      const { symbol, metaData: coinMetadataId } =
+        addressApiResponse.core.coins[coinName];
+
+      let spoolData = undefined;
+      const _spoolData = addressApiResponse.spool.pools[`s${coinName}`];
+      // @ts-ignore
+      if (_spoolData) {
         // @ts-ignore
-        `scoin.coins.s${coinName}.metaData`
-      );
+        const { id: spool, rewardPoolId: spoolReward } = _spoolData;
+        spoolData = {
+          spool,
+          spoolReward,
+          coinMetadataId,
+        };
+      }
 
-      const pythFeed = PYTH_FEED_IDS[coinName];
-      const pythFeedObjectId = query.address.get(
+      let sCoinData = undefined;
+      const sCoinName = `s${coinName}`;
+      const _sCoinData = addressApiResponse.scoin.coins[sCoinName];
+      if (_sCoinData) {
+        const {
+          coinType: sCoinType,
+          treasury: sCoinTreasury,
+          metaData: sCoinMetadataId,
+          symbol: sCoinSymbol,
+        } = _sCoinData;
+        sCoinData = {
+          sCoinType,
+          sCoinTreasury,
+          sCoinMetadataId,
+          sCoinSymbol,
+        };
+      }
+
+      const { feed: pythFeed, feedObject: pythFeedObjectId } =
         //@ts-ignore
-        `core.coins.${coinName}.oracle.pyth.feedObject`
-      );
-      const decimals = query.utils.getCoinDecimal(coinName);
-      const spoolName = spool ? `s${coinName}` : undefined;
-      results[coinName as SupportPoolCoins] = {
+        addressApiResponse.core.coins[coinName].oracle.pyth;
+
+      const decimals =
+        (
+          await tryRequest(async (client) => {
+            return await client.getCoinMetadata({
+              coinType: coinType,
+            });
+          })
+        )?.decimals ?? 0;
+      const spoolName = spoolData ? `s${coinName}` : undefined;
+
+      // @TODO: add query for flashloanFeeObject
+      results[coinName] = {
         coinName,
-        symbol: query.utils.parseSymbol(coinName),
-        lendingPoolAddress: addresses[0],
-        collateralPoolAddress: addresses[1],
-        borrowDynamic: addresses[2],
-        interestModel: addresses[3],
+        symbol,
+        lendingPoolAddress: addresses[0] ?? '',
+        collateralPoolAddress: addresses[1] ?? '',
+        borrowDynamic: addresses[2] ?? '',
+        interestModel: addresses[3] ?? '',
         riskModel: addresses[4],
-        borrowFeeKey: addresses[5],
+        borrowFeeKey: addresses[5] ?? '',
         supplyLimitKey: addresses[6],
         borrowLimitKey: addresses[7],
         isolatedAssetKey: addresses[8],
-        spool,
-        spoolReward: rewardPool,
-        sCoinTreasury,
-        sCoinType,
+        ...(spoolData ?? {}),
+        ...(sCoinData ?? {}),
         sCoinName,
-        sCoinSymbol,
         coinMetadataId,
-        coinType: `0x${coinType}`,
-        sCoinMetadataId,
+        coinType,
         spoolName,
         decimals,
         pythFeed,
         pythFeedObjectId,
+        flashloanFeeObject: flashloanFeeObjectIds[coinType] ?? '',
       };
 
-      await new Promise((resolve) => setTimeout(resolve, 500));
+      await new Promise((resolve) => setTimeout(resolve, 1000));
     })
   );