@scallop-io/sui-scallop-sdk 2.0.13-merge-split-ve-sca-alpha.5 → 2.1.0

package/src/models/scallopConstants.ts

@@ -1,102 +1,106 @@
-import axios, { AxiosInstance } from 'axios';
+import { PoolAddress, Whitelist } from 'src/types';
+import ScallopAddress, { ScallopAddressParams } from './scallopAddress';
+import { NetworkType, parseStructTag } from '@scallop-io/sui-kit';
+import ScallopAxios from './scallopAxios';
 import { queryKeys } from 'src/constants';
-import {
-  PoolAddress,
-  ScallopConstantsInstanceParams,
-  ScallopConstantsParams,
-  Whitelist,
-} from 'src/types';
-import { ScallopCache } from './scallopCache';
 import { QueryKey } from '@tanstack/query-core';
-import { newSuiKit } from './suiKit';
-import { ScallopAddress } from './scallopAddress';
-import { parseStructTag } from '@scallop-io/sui-kit';
+
+const isEmptyObject = (obj: object) => {
+  return Object.keys(obj).length === 0;
+};
+
+type CoinName = string;
+type CoinType = string;
+type SCoinType = string;
+type OldMarketCoinType = string;
 
 /**
- * @description
- * It provides methods to construct constants for Scallop SDK instances.
- *
- * @example
- * ```typescript
- * const scallopConstants = new ScallopConstants();
- * await scallopConstants.init();
- * ```
+ *  @description `scallop_sui`, `scallop_usdt`, etc (parsed directly from coin type, ex: `0x...::scallop_sui::SCALLOP_SUI`)
  */
-export class ScallopConstants {
-  private readonly _requestClient: AxiosInstance;
-  public address: ScallopAddress;
-  public cache: ScallopCache;
+type SCoinRawName = string;
 
+/**
+ * @description `ssui`, `susdc`, etc..
+ */
+type SCoinName = string;
+
+export type ScallopConstantsParams = {
+  poolAddressesApiUrl?: string;
+  whitelistApiUrl?: string;
+  forcePoolAddressInterface?: Record<string, PoolAddress>;
+  forceWhitelistInterface?: Whitelist;
+} & ScallopAddressParams;
+
+const DEFAULT_WHITELIST = {
+  lending: new Set(),
+  borrowing: new Set(),
+  collateral: new Set(),
+  packages: new Set(),
+  scoin: new Set(),
+  spool: new Set(),
+  borrowIncentiveRewards: new Set(),
+  rewardsAsPoint: new Set(),
+  suiBridge: new Set(),
+  wormhole: new Set(),
+  oracles: new Set(),
+  pythEndpoints: new Set(),
+  deprecated: new Set(),
+  emerging: new Set(),
+} as Whitelist;
+
+class ScallopConstants extends ScallopAddress {
   private _poolAddresses: Record<string, PoolAddress | undefined> = {};
-  private _whitelist: Whitelist = {
-    lending: new Set(),
-    borrowing: new Set(),
-    collateral: new Set(),
-    packages: new Set(),
-    scoin: new Set(),
-    spool: new Set(),
-    borrowIncentiveRewards: new Set(),
-    rewardsAsPoint: new Set(),
-    suiBridge: new Set(),
-    wormhole: new Set(),
-    oracles: new Set(),
-    pythEndpoints: new Set(),
-    deprecated: new Set(),
-    emerging: new Set(),
-  };
-
-  private _coinDecimals: Record<string, number | undefined> = {};
-  private _coinNameToOldMarketCoinTypeMap: Record<string, string | undefined> =
-    {};
-  private _scoinRawNameToSCoinNameMap: Record<string, string | undefined> = {};
-  private _scoinTypeToSCoinNameMap: Record<string, string | undefined> = {};
-  private _wormholeCoinTypeToCoinNameMap: Record<string, string | undefined> =
-    {};
-  private _voloCoinTypeToCoinNameMap: Record<string, string | undefined> = {};
-  private _suiBridgeCoinTypeToCoinNameMap: Record<string, string | undefined> =
+  private _whitelist: Whitelist = DEFAULT_WHITELIST;
+
+  /**
+   * @description coin names to coin decimal map
+   */
+  public coinDecimals: Record<CoinName, number | undefined> = {};
+  public coinNameToOldMarketCoinTypeMap: Record<
+    CoinName,
+    OldMarketCoinType | undefined
+  > = {};
+  public scoinRawNameToSCoinNameMap: Record<
+    SCoinRawName,
+    SCoinName | undefined
+  > = {};
+  public scoinTypeToSCoinNameMap: Record<SCoinType, SCoinName | undefined> = {};
+  public wormholeCoinTypeToCoinNameMap: Record<CoinType, CoinName | undefined> =
     {};
-  private _coinTypes: Record<string, string | undefined> = {};
-  private _sCoinTypes: Record<string, string | undefined> = {};
-  private _coinTypeToCoinNameMap: Record<string, string | undefined> = {};
-  private _supportedBorrowIncentiveRewards: Set<string> = new Set();
-
-  constructor(
-    public readonly params: ScallopConstantsParams,
-    instance?: ScallopConstantsInstanceParams
-  ) {
-    this.params = params;
-    this._requestClient = axios.create({
-      headers: {
-        'Content-Type': 'application/json',
-        Accept: 'application/json',
-      },
-      timeout: 8000,
-    });
+  public voloCoinTypeToCoinNameMap: Record<CoinType, CoinName | undefined> = {};
+  public suiBridgeCoinTypeToCoinNameMap: Record<
+    CoinType,
+    CoinName | undefined
+  > = {};
 
-    this.cache =
-      instance?.address?.cache ??
-      instance?.cache ??
-      new ScallopCache(this.params, {
-        suiKit: newSuiKit(this.params),
-      });
-
-    this.address =
-      instance?.address ??
-      new ScallopAddress(this.params, {
-        cache: this.cache,
-      });
-
-    if (params.forcePoolAddressInterface) {
-      this._poolAddresses = params.forcePoolAddressInterface;
-    }
+  /**
+   * @description coin names to coin types map
+   */
+  public coinTypes: Record<CoinName, CoinType | undefined> = {};
 
-    if (params.forceWhitelistInterface) {
-      this._whitelist = params.forceWhitelistInterface;
-    }
+  /**
+   * @description scoin names to scoin types map
+   */
+  public sCoinTypes: Record<SCoinName, SCoinType | undefined> = {};
+  public coinTypeToCoinNameMap: Record<CoinType, CoinName | undefined> = {};
+
+  /**
+   * @description Supported borrow incentive reward coin names
+   */
+  public supportedBorrowIncentiveRewards: Set<CoinName> = new Set();
+
+  private scallopConstantAxios: ScallopAxios;
+
+  constructor(public readonly params: ScallopConstantsParams = {}) {
+    super(params);
+    this.scallopConstantAxios = new ScallopAxios();
   }
 
-  get isAddressInitialized() {
-    return !this.isEmptyObject(this.address.getAllAddresses());
+  get protocolObjectId() {
+    return (
+      (this.get('core.object') as string | undefined) ??
+      ('0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf' as const)
+    );
   }
 
   get isInitialized() {
@@ -112,210 +116,193 @@ export class ScallopConstants {
       'emerging',
     ] as const;
     return (
-      this.isAddressInitialized && // address is initialized
-      !this.isEmptyObject(this._poolAddresses) && // poolAddresses is initialized
-      REQUIRED_WHITELIST_KEYS.every(
-        (t) => this.whitelist[t] && this.whitelist[t].size > 0
-      ) // whitelist is initialized
+      this.isAddressInitialized() && // address is initialized
+      !isEmptyObject(this.poolAddresses) && // poolAddresses is initialized
+      REQUIRED_WHITELIST_KEYS.every((t) => this.whitelist[t].size > 0) // whitelist is initialized
     );
   }
 
-  get queryClient() {
-    return this.cache.queryClient;
+  get whitelist() {
+    return new Proxy(this._whitelist, {
+      get: (target, key: keyof Whitelist) => {
+        return target[key] ?? DEFAULT_WHITELIST[key];
+      },
+    });
   }
 
   get poolAddresses() {
-    return this._poolAddresses;
+    return new Proxy(this._poolAddresses, {
+      get: (target, key: string) => {
+        return target[key] ?? undefined;
+      },
+    });
   }
 
-  get whitelist() {
-    return this._whitelist;
+  private isAddressInitialized({
+    networkType = 'mainnet',
+  }: {
+    networkType?: NetworkType;
+  } = {}) {
+    const addresses = this.getAddresses(networkType);
+    return !addresses || isEmptyObject(addresses);
   }
 
   parseToOldMarketCoin(coinType: string) {
     return `${this.protocolObjectId}::reserve::MarketCoin<${coinType}>`;
   }
 
-  get protocolObjectId() {
-    return (
-      (this.address.get('core.object') as string | undefined) ??
-      ('0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf' as const)
-    );
-  }
+  async init({
+    networkType = 'mainnet',
+    force = false,
+    addressId,
+    constantsParams = this.params,
+  }: {
+    networkType?: NetworkType;
+    force?: boolean;
+    addressId?: string;
+    constantsParams?: Partial<ScallopConstantsParams>;
+  } = {}) {
+    // check if scallop address is initialized
+    const addresses = this.getAddresses(networkType);
+    if (!addresses || Object.keys(addresses).length === 0 || force) {
+      await this.read(addressId); // ScallopAddress read()
+    }
 
-  /**
-   * @description
-   * Return maps of coin names to coin decimals.
-   */
-  get coinDecimals() {
-    if (this.isEmptyObject(this._coinDecimals)) {
-      this._coinDecimals = Object.fromEntries([
-        ...Object.entries(this.poolAddresses)
-          .filter(([_, value]) => !!value)
-          .map(([key, value]) => [key, value!.decimals]),
-        ...Object.entries(this.poolAddresses)
-          .filter(([_, value]) => !!value?.sCoinName)
-          .map(([_, value]) => [value!.sCoinName, value!.decimals]),
-      ]);
+    // Initialization function
+    if (constantsParams.forcePoolAddressInterface) {
+      this._poolAddresses = constantsParams.forcePoolAddressInterface;
     }
-    return this._coinDecimals;
-  }
 
-  /**
-   * @description
-   * Return maps of coin names to coin types.
-   */
-  get coinTypes() {
-    if (this.isEmptyObject(this._coinTypes))
-      this._coinTypes = Object.fromEntries([
-        ...Object.entries(this.poolAddresses)
-          .filter(([_, value]) => !!value)
-          .map(([key, value]) => [key, value?.coinType]),
-        ...Object.entries(this.poolAddresses)
-          .filter(([_, value]) => !!value && value.sCoinName && value.sCoinType)
-          .map(([_, value]) => [value!.sCoinName, value!.sCoinType]),
-      ]);
-    return this._coinTypes;
-  }
+    if (constantsParams.forceWhitelistInterface) {
+      this._whitelist = constantsParams.forceWhitelistInterface;
+    }
 
-  /**
-   * @description
-   * Return maps of coin types to its coin name
-   */
-  get coinTypeToCoinNameMap() {
-    if (this.isEmptyObject(this._coinTypeToCoinNameMap))
-      this._coinTypeToCoinNameMap = Object.fromEntries(
-        Object.entries(this.coinTypes).map(([key, val]) => [val, key])
-      );
-    return this._coinTypeToCoinNameMap;
-  }
+    if (this.isInitialized && !force) {
+      return;
+    }
 
-  /**
-   * @description
-   * Return maps of wormhole coin types to its coin name.
-   */
-  get wormholeCoinTypeToCoinName() {
-    if (this.isEmptyObject(this._wormholeCoinTypeToCoinNameMap))
-      this._wormholeCoinTypeToCoinNameMap = Object.fromEntries(
-        Object.entries(this.poolAddresses)
-          .filter(([key, value]) => !!value && this.whitelist.wormhole.has(key))
-          .map(([_, value]) => [value!.coinType, value!.coinName])
-      );
-    return this._wormholeCoinTypeToCoinNameMap;
-  }
+    const [whitelistResponse, poolAddressesResponse] = await Promise.all([
+      this.readWhiteList(),
+      this.readPoolAddresses(),
+    ]);
 
-  /**
-   * @description
-   * Return maps of coin name to its old market coin type (...::reserve::MarketCoin<coinType>)
-   */
-  get coinNameToOldMarketCoinTypeMap() {
-    if (this.isEmptyObject(this._coinNameToOldMarketCoinTypeMap))
-      this._coinNameToOldMarketCoinTypeMap = Object.fromEntries(
-        Object.entries(this.poolAddresses)
-          .filter(([_, value]) => !!value)
-          .map(([_, value]) => [
-            value!.coinName,
-            this.parseToOldMarketCoin(value!.coinType),
-          ])
+    if (!this.params.forceWhitelistInterface) {
+      this._whitelist = Object.keys(this._whitelist).reduce(
+        (acc, key: unknown) => {
+          const whiteListKey = key as keyof Whitelist;
+          const whiteListValue = whitelistResponse[whiteListKey];
+          acc[whiteListKey] =
+            whiteListValue instanceof Set
+              ? whiteListValue
+              : Array.isArray(whiteListValue)
+                ? new Set(whiteListValue)
+                : new Set();
+          return acc;
+        },
+        {} as Whitelist
       );
-    return this._coinNameToOldMarketCoinTypeMap;
-  }
+    }
 
-  /**
-   * @description
-   * Return maps of sCoin raw name from its type to its sCoin name. (e.g. 'scallop_sui' -> 'ssui')
-   */
-  get sCoinRawNameToScoinNameMap() {
-    if (this.isEmptyObject(this._scoinRawNameToSCoinNameMap))
-      this._scoinRawNameToSCoinNameMap = Object.fromEntries(
-        Object.entries(this.poolAddresses)
-          .filter(([_, value]) => !!value && value.sCoinType && value.sCoinName)
-          .map(([_, value]) => {
-            const scoinRawName = parseStructTag(value!.sCoinType!).name;
-            return [scoinRawName, value!.sCoinName!];
+    if (!this.params.forcePoolAddressInterface) {
+      this._poolAddresses = Object.fromEntries(
+        Object.entries(poolAddressesResponse)
+          .filter(([key]) =>
+            Object.values(this._whitelist).some((set) => set.has(key))
+          )
+          .map(([key, value]) => {
+            const parsedValue = Object.fromEntries(
+              Object.entries(value).map(([k, v]) => [
+                k,
+                typeof v === 'boolean' ? (v ?? false) : v || undefined,
+              ])
+            );
+            return [key, parsedValue as PoolAddress];
           })
       );
-
-    return this._scoinRawNameToSCoinNameMap;
+    }
+    this.initConstants();
   }
 
-  /**
-   * @description
-   * Return maps of scoin type to its sCoin name
-   */
-  get sCoinTypeToSCoinNameMap() {
-    if (this.isEmptyObject(this._scoinTypeToSCoinNameMap))
-      this._scoinTypeToSCoinNameMap = Object.fromEntries(
-        Object.entries(this.poolAddresses)
-          .filter(([_, value]) => !!value && value.sCoinType && value.sCoinName)
-          .map(([_, value]) => [value!.sCoinType!, value!.sCoinName!])
-      );
+  private initConstants() {
+    this.coinDecimals = Object.fromEntries([
+      ...Object.entries(this.poolAddresses)
+        .filter(([_, value]) => !!value)
+        .map(([key, value]) => [key, value!.decimals]),
+      ...Object.entries(this.poolAddresses)
+        .filter(([_, value]) => !!value?.sCoinName)
+        .map(([_, value]) => [value!.sCoinName, value!.decimals]),
+    ]);
 
-    return this._scoinTypeToSCoinNameMap;
-  }
+    this.coinTypes = Object.fromEntries([
+      ...Object.entries(this.poolAddresses)
+        .filter(([_, value]) => !!value)
+        .map(([key, value]) => [key, value?.coinType]),
+      ...Object.entries(this.poolAddresses)
+        .filter(([_, value]) => !!value && value.sCoinName && value.sCoinType)
+        .map(([_, value]) => [value!.sCoinName, value!.sCoinType]),
+    ]);
 
-  /**
-   * @description
-   * Return maps of volo coin type to its coin name
-   */
-  get voloCoinTypeToCoinNameMap() {
-    if (this.isEmptyObject(this._voloCoinTypeToCoinNameMap))
-      this._voloCoinTypeToCoinNameMap = {
-        [this.poolAddresses['vsui']!.coinType]: 'vsui',
-      };
-    return this._voloCoinTypeToCoinNameMap;
-  }
+    this.coinTypeToCoinNameMap = Object.fromEntries(
+      Object.entries(this.coinTypes).map(([key, val]) => [val, key])
+    );
 
-  /**
-   * @description
-   * Return maps of sui bridge coin type to its coin name
-   */
-  get suiBridgeCoinTypeToCoinNameMap() {
-    if (this.isEmptyObject(this._suiBridgeCoinTypeToCoinNameMap))
-      this._suiBridgeCoinTypeToCoinNameMap = Object.fromEntries(
-        Object.entries(this.poolAddresses)
-          .filter(
-            ([_, value]) =>
-              !!value && this.whitelist.suiBridge.has(value.coinName)
-          )
-          .map(([_, value]) => [value!.coinType, value!.coinName])
-      );
-    return this._suiBridgeCoinTypeToCoinNameMap;
-  }
+    this.wormholeCoinTypeToCoinNameMap = Object.fromEntries(
+      Object.entries(this.poolAddresses)
+        .filter(([key, value]) => !!value && this.whitelist.wormhole.has(key))
+        .map(([_, value]) => [value!.coinType, value!.coinName])
+    );
 
-  /**
-   * @description
-   * Return maps of sCoin coin name to its coin type
-   */
-  get sCoinTypes() {
-    if (this.isEmptyObject(this._sCoinTypes))
-      this._sCoinTypes = Object.fromEntries(
-        Object.entries(this.poolAddresses)
-          .filter(([_, value]) => !!value && value.sCoinName && value.sCoinType)
-          .map(([_, value]) => [value!.sCoinName, value!.sCoinType!])
-      );
+    this.coinNameToOldMarketCoinTypeMap = Object.fromEntries(
+      Object.entries(this.poolAddresses)
+        .filter(([_, value]) => !!value)
+        .map(([_, value]) => [
+          value!.coinName,
+          this.parseToOldMarketCoin(value!.coinType),
+        ])
+    );
 
-    return this._sCoinTypes;
-  }
+    this.scoinRawNameToSCoinNameMap = Object.fromEntries(
+      Object.entries(this.poolAddresses)
+        .filter(([_, value]) => !!value && value.sCoinType && value.sCoinName)
+        .map(([_, value]) => {
+          const scoinRawName = parseStructTag(value!.sCoinType!).name;
+          return [scoinRawName, value!.sCoinName!];
+        })
+    );
 
-  /**
-   * @description
-   * Return set of supported coin types for borrow incentive rewards
-   * (all supported pools + sCoins + custom coins from `whitelist.borrowIncentiveRewards`)
-   */
-  get supportedBorrowIncentiveRewards() {
-    if (!this._supportedBorrowIncentiveRewards.size)
-      this._supportedBorrowIncentiveRewards = new Set([
-        ...Object.values(this.poolAddresses)
-          .filter((t) => !!t)
-          .map((t) => (t.sCoinName ? [t.coinName, t.sCoinName] : [t.coinName]))
-          .flat(),
-      ]);
-    return this._supportedBorrowIncentiveRewards;
-  }
+    this.scoinTypeToSCoinNameMap = Object.fromEntries(
+      Object.entries(this.poolAddresses)
+        .filter(([_, value]) => !!value && value.sCoinType && value.sCoinName)
+        .map(([_, value]) => [value!.sCoinType!, value!.sCoinName!])
+    );
+
+    const vSuiCoinType = this.poolAddresses['vsui']?.coinType;
+    if (vSuiCoinType)
+      this.voloCoinTypeToCoinNameMap = {
+        [vSuiCoinType]: 'vsui',
+      };
 
-  private isEmptyObject(obj: Record<string, unknown>) {
-    return Object.keys(obj).length === 0;
+    this.suiBridgeCoinTypeToCoinNameMap = Object.fromEntries(
+      Object.entries(this.poolAddresses)
+        .filter(
+          ([_, value]) =>
+            !!value && this.whitelist.suiBridge.has(value.coinName)
+        )
+        .map(([_, value]) => [value!.coinType, value!.coinName])
+    );
+
+    this.sCoinTypes = Object.fromEntries(
+      Object.entries(this.poolAddresses)
+        .filter(([_, value]) => !!value && value.sCoinName && value.sCoinType)
+        .map(([_, value]) => [value!.sCoinName, value!.sCoinType!])
+    );
+
+    this.supportedBorrowIncentiveRewards = new Set([
+      ...Object.values(this.poolAddresses)
+        .filter((t) => !!t)
+        .map((t) => (t.sCoinName ? [t.coinName, t.sCoinName] : [t.coinName]))
+        .flat(),
+    ]);
   }
 
   private async readApi<T>({
@@ -325,15 +312,7 @@ export class ScallopConstants {
     url: string;
     queryKey: QueryKey;
   }) {
-    const resp = await this.queryClient.fetchQuery({
-      queryKey,
-      queryFn: async () => {
-        return await this._requestClient.get(url, {
-          timeout: 4000,
-        });
-      },
-    });
-
+    const resp = await this.scallopConstantAxios.get<T>(url, queryKey);
     if (resp.status === 200) {
       return resp.data as T;
     } else {
@@ -366,60 +345,6 @@ export class ScallopConstants {
       queryKey: queryKeys.api.getPoolAddresses(),
     });
   }
-
-  async init(params?: Partial<ScallopConstantsParams>) {
-    if (!this.isAddressInitialized) {
-      await this.address.read();
-    }
-
-    if (params?.forcePoolAddressInterface) {
-      this._poolAddresses = params?.forcePoolAddressInterface;
-    }
-
-    if (params?.forceWhitelistInterface) {
-      this._whitelist = params?.forceWhitelistInterface;
-    }
-
-    if (this.isInitialized) return;
-
-    const [whitelistResponse, poolAddressesResponse] = await Promise.all([
-      this.readWhiteList(),
-      this.readPoolAddresses(),
-    ]);
-
-    if (!this.params.forceWhitelistInterface) {
-      this._whitelist = Object.keys(this._whitelist).reduce(
-        (acc, key: unknown) => {
-          const whiteListKey = key as keyof Whitelist;
-          const whiteListValue = whitelistResponse[whiteListKey];
-          acc[whiteListKey] =
-            whiteListValue instanceof Set
-              ? whiteListValue
-              : Array.isArray(whiteListValue)
-                ? new Set(whiteListValue)
-                : new Set();
-          return acc;
-        },
-        {} as Whitelist
-      );
-    }
-
-    if (!this.params.forcePoolAddressInterface) {
-      this._poolAddresses = Object.fromEntries(
-        Object.entries(poolAddressesResponse)
-          .filter(([key]) =>
-            Object.values(this.whitelist).some((set) => set.has(key))
-          )
-          .map(([key, value]) => {
-            const parsedValue = Object.fromEntries(
-              Object.entries(value).map(([k, v]) => [
-                k,
-                typeof v === 'boolean' ? (v ?? false) : v || undefined,
-              ])
-            );
-            return [key, parsedValue as PoolAddress];
-          })
-      );
-    }
-  }
 }
+
+export default ScallopConstants;