@scallop-io/sui-scallop-sdk 1.4.24-alpha.1 → 1.5.0-alpha.1

package/src/queries/index.ts

@@ -12,3 +12,4 @@ export * from './vescaQuery';
 export * from './borrowLimitQuery';
 export * from './poolAddressesQuery';
 export * from './objectsQuery';
+export * from './xOracleQuery';

package/src/queries/poolAddressesQuery.ts

@@ -1,10 +1,10 @@
-import { PYTH_FEED_IDS } from 'src/constants';
+import { PYTH_FEED_IDS, SUPPORT_POOLS } from 'src/constants';
 import { ScallopQuery } from 'src/models';
 import { OptionalKeys, SupportPoolCoins } from 'src/types';
 
 export const getAllAddresses = async (
   query: ScallopQuery,
-  pools: SupportPoolCoins[]
+  pools: SupportPoolCoins[] = [...SUPPORT_POOLS]
 ) => {
   const results: OptionalKeys<
     Record<

package/src/queries/priceQuery.ts

@@ -133,16 +133,23 @@ export const getPythPrices = async (
 export const getAllCoinPrices = async (
   query: ScallopQuery,
   marketPools?: MarketPools,
-  coinPrices?: CoinPrices
+  coinPrices?: CoinPrices,
+  indexer: boolean = false
 ) => {
-  coinPrices = coinPrices ?? (await query.utils.getCoinPrices());
+  coinPrices =
+    coinPrices ??
+    (indexer
+      ? await query.getCoinPricesByIndexer()
+      : await query.utils.getCoinPrices());
+
   marketPools =
     marketPools ??
-    (await query.getMarketPools(undefined, { coinPrices })).pools;
+    (await query.getMarketPools(undefined, { coinPrices, indexer })).pools;
 
   if (!marketPools) {
     throw new Error(`Failed to fetch market pool for getAllCoinPrices`);
   }
+
   const sCoinPrices: OptionalKeys<Record<SupportSCoin, number>> = {};
   SUPPORT_SCOIN.forEach((sCoinName) => {
     const coinName = query.utils.parseCoinName(sCoinName);

package/src/queries/vescaQuery.ts

@@ -184,28 +184,19 @@ const getTotalVeScaTreasuryAmount = async (
   veScaTreasury = veScaTreasury ?? utils.address.get('vesca.treasury');
 
   const txb = new SuiTxBlock();
+  const clockObjectRef = txb.sharedObjectRef({
+    objectId: SUI_CLOCK_OBJECT_ID,
+    mutable: false,
+    initialSharedVersion: '1',
+  });
+
   // refresh query
   const refreshQueryTarget = `${veScaPkgId}::treasury::refresh`;
-  const refreshArgs = [
-    veScaConfig,
-    veScaTreasury,
-    txb.sharedObjectRef({
-      objectId: SUI_CLOCK_OBJECT_ID,
-      mutable: false,
-      initialSharedVersion: '1',
-    }),
-  ];
+  const refreshArgs = [veScaConfig, veScaTreasury, clockObjectRef];
 
   // query total veSca amount
   const veScaAmountQueryTarget = `${veScaPkgId}::treasury::total_ve_sca_amount`;
-  const veScaAmountArgs = [
-    veScaTreasury,
-    txb.sharedObjectRef({
-      objectId: SUI_CLOCK_OBJECT_ID,
-      mutable: false,
-      initialSharedVersion: '1',
-    }),
-  ];
+  const veScaAmountArgs = [veScaTreasury, clockObjectRef];
 
   // resolve each args
   const resolvedRefreshArgs = await Promise.all(

package/src/queries/xOracleQuery.ts

@@ -0,0 +1,124 @@
+import { SuiObjectResponse } from '@mysten/sui/client';
+import { ScallopAddress, ScallopUtils } from 'src/models';
+import {
+  SupportAssetCoins,
+  SupportOracleType,
+  xOracleRuleType,
+} from 'src/types';
+
+const PRIMARY_PRICE_UPDATE_POLICY =
+  '0xbcd908d0ee6d63d726e61676f3feeec3d19817f4849bbecf372dd3399f247f6b'; // @TODO: move this constant to api address
+const SECONDARY_PRICE_UPDDATE_POLICY =
+  '0x624a6f120777bb30e718b86e836c205ef4229448052377dc3d78272a6662b2c0'; // @TODO: move this constant to api address
+
+/**
+ * Query the price update policy table ids. Usually the value for these table will be constant.
+ * @param query
+ * @returns
+ */
+export const getPriceUpdatePolicies = async (
+  address: ScallopAddress
+): Promise<{
+  primary: SuiObjectResponse | null;
+  secondary: SuiObjectResponse | null;
+}> => {
+  const priceUpdatePolicyRulesKeyType = `${address.get('core.packages.xOracle.object')}::price_update_policy::PriceUpdatePolicyRulesKey`;
+
+  const [primaryPriceUpdatePolicyTable, secondaryPriceUpdatePolicyTable] =
+    await Promise.all([
+      address.cache.queryGetDynamicFieldObject({
+        parentId: PRIMARY_PRICE_UPDATE_POLICY,
+        name: {
+          type: priceUpdatePolicyRulesKeyType,
+          value: { dummy_field: false },
+        },
+      }),
+      address.cache.queryGetDynamicFieldObject({
+        parentId: SECONDARY_PRICE_UPDDATE_POLICY,
+        name: {
+          type: priceUpdatePolicyRulesKeyType,
+          value: { dummy_field: false },
+        },
+      }),
+    ]);
+
+  return {
+    primary: primaryPriceUpdatePolicyTable,
+    secondary: secondaryPriceUpdatePolicyTable,
+  };
+};
+
+// const PRIMARY_PRICE_UPDATE_POLICY_KEY =
+//   '0x856d0930acc36780eda9ea47019c979ca6ad34fd36f158b181eb7350195acc00';
+// const SECONDARY_PRICE_UPDATE_POLICY_KEY =
+//   '0x304d226734fa5e376423c9ff0f1d49aeb1e2572d4b617d31e11e2f69865b73ed';
+const PRIMARY_PRICE_UPDATE_POLICY_VECSET_ID =
+  '0xfb1330aa028ed6a159b742c71b5a79b3b6824cf71efa40ea82b52486ad209264';
+const SECONDARY_PRICE_UPDATE_POLICY_VECSET_ID =
+  '0x4b827acc73f3f53f808dd73a7ee0a60ae61e84322176bece72b26467030b467c';
+
+export const getAssetOracles = async (
+  utils: ScallopUtils,
+  ruleType: xOracleRuleType
+): Promise<Record<SupportAssetCoins, SupportOracleType[]>> => {
+  const ruleTypeNameToOracleType: Record<string, SupportOracleType> = {
+    [`${utils.address.get('core.packages.pyth.object')}::rule::Rule`]: 'pyth',
+    [`${utils.address.get('core.packages.supra.object')}::rule::Rule`]: 'supra',
+    [`${utils.address.get('core.packages.switchboard.object')}::rule::Rule`]:
+      'switchboard',
+  };
+
+  const assetPrimaryOracles = {} as Record<
+    SupportAssetCoins,
+    SupportOracleType[]
+  >;
+  let cursor = null;
+  do {
+    const response = await utils.cache.queryGetDynamicFields({
+      parentId:
+        ruleType === 'primary'
+          ? PRIMARY_PRICE_UPDATE_POLICY_VECSET_ID
+          : SECONDARY_PRICE_UPDATE_POLICY_VECSET_ID,
+      cursor,
+      limit: 10,
+    });
+    if (!response) break;
+    const { data, hasNextPage, nextCursor } = response;
+    cursor = nextCursor;
+
+    // Group object ids
+    const objectIds = data.map((dynamicField) => dynamicField.objectId);
+
+    // batch fetch object responses
+    const objectResponses = await utils.cache.queryGetObjects(objectIds);
+    objectResponses.forEach((object) => {
+      if (!object.content || object.content.dataType !== 'moveObject') return;
+      const fields = object.content.fields as any;
+      const typeName = (
+        fields.name as { type: string; fields: { name: string } }
+      ).fields.name;
+
+      const assetName = utils.parseCoinNameFromType(`0x${typeName}`);
+      if (!assetName) throw new Error(`Invalid asset name: ${assetName}`);
+      if (!assetPrimaryOracles[assetName]) {
+        assetPrimaryOracles[assetName] = [];
+      }
+
+      const value = fields.value as {
+        type: string;
+        fields: {
+          contents: Array<{ type: string; fields: { name: string } }>;
+        };
+      };
+
+      value.fields.contents.forEach((content) => {
+        assetPrimaryOracles[assetName].push(
+          ruleTypeNameToOracleType[`0x${content.fields.name}`]
+        );
+      });
+    });
+    if (!hasNextPage) break;
+  } while (cursor);
+
+  return assetPrimaryOracles;
+};

package/src/types/address.ts

@@ -65,6 +65,7 @@ export interface AddressesInterface {
         SupportPackageType,
         {
           id: string;
+          object?: string;
           upgradeCap: string;
         }
       >

package/src/types/constant/index.ts

@@ -1,2 +1,3 @@
 export type * from './common';
 export type * from './enum';
+export type * from './xOracle';

package/src/types/constant/xOracle.ts

@@ -0,0 +1,11 @@
+import { SupportAssetCoins, SupportOracleType } from './common';
+
+export type xOracleRules = {
+  primary: SupportOracleType[];
+  secondary: SupportOracleType[];
+};
+export type xOracleRuleType = keyof xOracleRules;
+
+export type xOracleListType = {
+  [key in SupportAssetCoins]: xOracleRules;
+};

package/src/utils/util.ts

@@ -55,13 +55,10 @@ export const parseAssetSymbol = (coinName: SupportCoins): string => {
     return `w${coinName.slice(1).toUpperCase()}`;
   }
   if (isSuiBridgeAsset(coinName)) {
-    switch (coinName) {
-      case 'sbwbtc':
-        return 'sbwBTC';
-      default: {
-        return `sb${coinName.slice(2).toUpperCase()}`;
-      }
+    if (coinName.startsWith('sbw') && coinName.length > 3) {
+      return `sbw${coinName.slice(3).toUpperCase()}`;
     }
+    return `sb${coinName.slice(2).toUpperCase()}`;
   }
   if (isMarketCoin(coinName)) {
     const assetCoinName = coinName.slice(1).toLowerCase() as SupportAssetCoins;
@@ -74,8 +71,6 @@ export const parseAssetSymbol = (coinName: SupportCoins): string => {
       return 'haSUI';
     case 'vsui':
       return 'vSUI';
-    case 'musd':
-      return 'mUSD';
     default:
       return coinName.toUpperCase();
   }
@@ -107,7 +102,7 @@ export const parseDataFromPythPriceFeed = (
       publishTime: Number(feed.price.publishTime) * 10 ** 3,
     };
   } else {
-    throw new Error('Invalid feed id');
+    throw new Error(`Invalid feed id: ${feed.id}`);
   }
 };