@subwallet/extension-base 1.1.33-beta.0 → 1.1.33-beta.2

package/services/chain-service/index.js

@@ -3,15 +3,15 @@
 
 import { AssetLogoMap, AssetRefMap, ChainAssetMap, ChainInfoMap, ChainLogoMap, MultiChainAssetMap } from '@subwallet/chain-list';
 import { _AssetRefPath, _AssetType, _ChainStatus, _SubstrateChainType } from '@subwallet/chain-list/types';
-import { _ASSET_LOGO_MAP_SRC, _ASSET_REF_SRC, _CHAIN_ASSET_SRC, _CHAIN_INFO_SRC, _CHAIN_LOGO_MAP_SRC, _DEFAULT_ACTIVE_CHAINS, _MANTA_ZK_CHAIN_GROUP, _MULTI_CHAIN_ASSET_SRC, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
+import { _DEFAULT_ACTIVE_CHAINS, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX, LATEST_CHAIN_DATA_FETCHING_INTERVAL } from '@subwallet/extension-base/services/chain-service/constants';
 import { EvmChainHandler } from '@subwallet/extension-base/services/chain-service/handler/EvmChainHandler';
 import { MantaPrivateHandler } from '@subwallet/extension-base/services/chain-service/handler/manta/MantaPrivateHandler';
 import { SubstrateChainHandler } from '@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { _ChainConnectionStatus, _CUSTOM_PREFIX, _NFT_CONTRACT_STANDARDS, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
-import { _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isCustomProvider, _isEqualContractAddress, _isEqualSmartContractAsset, _isMantaZkAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isCustomProvider, _isEqualContractAddress, _isEqualSmartContractAsset, _isMantaZkAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey, randomizeProvider, updateLatestChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import AssetSettingStore from '@subwallet/extension-base/stores/AssetSetting';
-import { MODULE_SUPPORT } from '@subwallet/extension-base/utils';
+import { fetchStaticData, MODULE_SUPPORT } from '@subwallet/extension-base/utils';
 import { BehaviorSubject, Subject } from 'rxjs';
 import Web3 from 'web3';
 import { logger as createLogger } from '@polkadot/util/logger';
@@ -396,9 +396,11 @@ export class ChainService {
     await this.eventService.waitDatabaseReady;
 
     // TODO: reconsider the flow of initiation
-    const [latestAssetRefMap, latestMultiChainAssetMap] = await Promise.all([this.fetchLatestData(_ASSET_REF_SRC, AssetRefMap), this.fetchLatestData(_MULTI_CHAIN_ASSET_SRC, MultiChainAssetMap)]);
-    this.multiChainAssetMapSubject.next(latestMultiChainAssetMap);
-    this.dataMap.assetRefMap = latestAssetRefMap;
+    this.multiChainAssetMapSubject.next(MultiChainAssetMap);
+    // const storedAssetRefMap = await this.dbService.getAssetRefMap();
+    //
+    // this.dataMap.assetRefMap = storedAssetRefMap && Object.values(storedAssetRefMap).length > 0 ? storedAssetRefMap : AssetRefMap;
+
     await this.initChains();
     this.chainInfoMapSubject.next(this.getChainInfoMap());
     this.updateChainStateMapSubscription();
@@ -406,7 +408,93 @@ export class ChainService {
     this.xcmRefMapSubject.next(this.dataMap.assetRefMap);
     await this.initApis();
     await this.initAssetSettings();
+    await this.initAssetRefMap();
+    this.checkLatestData();
+  }
+  async initAssetRefMap() {
+    try {
+      const fetchPromise = this.fetchLatestBlockedAssetRef();
+      const timeout = new Promise(resolve => {
+        const id = setTimeout(() => {
+          clearTimeout(id);
+          resolve(null);
+        }, 1000);
+      });
+      const disabledAssetRefs = (await Promise.race([timeout, fetchPromise])) || null;
+      if (disabledAssetRefs) {
+        this.handleLatestBlockedAssetRef(disabledAssetRefs);
+      } else {
+        this.dataMap.assetRefMap = AssetRefMap;
+      }
+    } catch (e) {
+      this.dataMap.assetRefMap = AssetRefMap;
+    }
+  }
+  checkLatestData() {
+    clearInterval(this.refreshLatestChainDataTimeOut);
+    this.handleLatestData();
+    this.handleLatestData();
+    this.handleLatestData();
+    this.refreshLatestChainDataTimeOut = setInterval(this.handleLatestData.bind(this), LATEST_CHAIN_DATA_FETCHING_INTERVAL);
+  }
+  stopCheckLatestChainData() {
+    clearInterval(this.refreshLatestChainDataTimeOut);
   }
+  handleLatestProviderData(latestChainInfo) {
+    try {
+      if (latestChainInfo && latestChainInfo.length > 0) {
+        const {
+          needUpdateChainApiList,
+          storedChainInfoList
+        } = updateLatestChainInfo(this.dataMap, latestChainInfo);
+        this.dbService.bulkUpdateChainStore(storedChainInfoList).catch(console.error);
+        this.updateChainSubscription();
+        needUpdateChainApiList.forEach(chainInfo => {
+          console.log('Updating chain API for', chainInfo.slug);
+          this.initApiForChain(chainInfo).catch(console.error);
+        });
+        this.logger.log('Finished updating latest RPC providers');
+      }
+    } catch (e) {
+      console.error('Error fetching latest chain data');
+    }
+  }
+  handleLatestBlockedAssetRef(latestBlockedAssetRefList) {
+    const updatedAssetRefMap = {
+      ...AssetRefMap
+    };
+    latestBlockedAssetRefList.forEach(blockedAssetRef => {
+      delete updatedAssetRefMap[blockedAssetRef];
+    });
+    this.dataMap.assetRefMap = updatedAssetRefMap;
+
+    // this.dbService.setAssetRef(this.dataMap.assetRefMap).catch(console.error);
+    this.xcmRefMapSubject.next(this.dataMap.assetRefMap);
+    this.logger.log('Finished updating latest asset ref');
+  }
+  handleLatestPriceId(latestPriceIds) {
+    Object.entries(latestPriceIds).forEach(([slug, priceId]) => {
+      if (this.dataMap.assetRegistry[slug]) {
+        this.dataMap.assetRegistry[slug].priceId = priceId;
+      }
+    });
+    this.assetRegistrySubject.next(this.dataMap.assetRegistry);
+    this.eventService.emit('asset.updateState', '');
+    this.logger.log('Finished updating latest price IDs');
+  }
+  handleLatestData() {
+    this.fetchLatestChainData().then(latestChainInfo => {
+      this.handleLatestProviderData(latestChainInfo);
+    }).catch(console.error);
+    this.fetchLatestBlockedAssetRef().then(latestAssetRef => {
+      this.handleLatestBlockedAssetRef(latestAssetRef);
+    }).catch(console.error);
+
+    // this.fetchLatestPriceIdsData().then((latestPriceIds) => {
+    //   this.handleLatestPriceId(latestPriceIds);
+    // }).catch(console.error);
+  }
+
   async initApis() {
     const chainInfoMap = this.getChainInfoMap();
     const chainStateMap = this.getChainStateMap();
@@ -562,8 +650,8 @@ export class ChainService {
     }
     return duplicatedSlug;
   }
-  async fetchLatestData(src, defaultValue) {
-    return Promise.resolve(defaultValue);
+  async fetchLatestChainData() {
+    return await fetchStaticData('chains');
     // try {
     //   const timeout = new Promise((resolve) => {
     //     const id = setTimeout(() => {
@@ -600,9 +688,16 @@ export class ChainService {
     // }
   }
 
+  // @ts-ignore
+  async fetchLatestPriceIdsData() {
+    return await fetchStaticData('chain-assets/price-map');
+  }
+  async fetchLatestBlockedAssetRef() {
+    return await fetchStaticData('chain-assets/disabled-xcm-channels');
+  }
   async initChains() {
     const storedChainSettings = await this.dbService.getAllChainStore();
-    const latestChainInfoMap = await this.fetchLatestData(_CHAIN_INFO_SRC, ChainInfoMap);
+    const defaultChainInfoMap = ChainInfoMap;
     const storedChainSettingMap = {};
     storedChainSettings.forEach(chainStoredSetting => {
       storedChainSettingMap[chainStoredSetting.slug] = chainStoredSetting;
@@ -611,10 +706,13 @@ export class ChainService {
     const deprecatedChains = [];
     const deprecatedChainMap = {};
     if (storedChainSettings.length === 0) {
-      this.dataMap.chainInfoMap = latestChainInfoMap;
-      Object.values(latestChainInfoMap).forEach(chainInfo => {
+      this.dataMap.chainInfoMap = defaultChainInfoMap;
+      Object.values(defaultChainInfoMap).forEach(chainInfo => {
+        const {
+          providerKey
+        } = randomizeProvider(chainInfo.providers);
         this.dataMap.chainStateMap[chainInfo.slug] = {
-          currentProvider: Object.keys(chainInfo.providers)[0],
+          currentProvider: providerKey,
           slug: chainInfo.slug,
           connectionStatus: _ChainConnectionStatus.DISCONNECTED,
           active: _DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug)
@@ -624,15 +722,15 @@ export class ChainService {
         newStorageData.push({
           ...chainInfo,
           active: _DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug),
-          currentProvider: Object.keys(chainInfo.providers)[0]
+          currentProvider: providerKey
         });
       });
     } else {
-      const mergedChainInfoMap = latestChainInfoMap;
+      const mergedChainInfoMap = defaultChainInfoMap;
       for (const [storedSlug, storedChainInfo] of Object.entries(storedChainSettingMap)) {
-        const chainInfo = latestChainInfoMap[storedSlug];
+        const chainInfo = defaultChainInfoMap[storedSlug];
 
-        // Network is existed on change list
+        // Network existed on change list
         // check predefined chains first, keep setting for providers and currentProvider
         if (chainInfo) {
           // Keep customer provider only
@@ -647,23 +745,27 @@ export class ChainService {
             }
           }
           mergedChainInfoMap[storedSlug].providers = providers;
-
-          // Merge current provider
-          let currentProvider = storedChainInfo.currentProvider;
-          const providerValue = storedChainInfo.providers[currentProvider] || '';
-          if (!providers[currentProvider]) {
-            currentProvider = Object.keys(providers)[0];
-            for (const [key, value] of Object.entries(providers)) {
-              if (providerValue === value) {
-                currentProvider = key;
-                break;
-              }
+          const {
+            providerKey
+          } = randomizeProvider(providers);
+          let selectedProvider = providerKey;
+          const storedProviderKey = storedChainInfo.currentProvider;
+          const storedProviderValue = storedChainInfo.providers[storedProviderKey] || '';
+          if (storedProviderValue !== null && storedProviderValue !== void 0 && storedProviderValue.startsWith('light') || storedProviderKey !== null && storedProviderKey !== void 0 && storedProviderKey.startsWith(_CUSTOM_PREFIX)) {
+            const savedProviderKey = Object.keys(providers).find(key => providers[key] === storedProviderValue);
+            if (savedProviderKey) {
+              selectedProvider = savedProviderKey;
             }
           }
+
+          // Merge current provider
+          // let currentProvider = storedChainInfo.currentProvider;
+          // const providerValue = storedChainInfo.providers[selectedProvider] || '';
+
           const hasProvider = Object.values(providers).length > 0;
           const canActive = hasProvider && chainInfo.chainStatus === _ChainStatus.ACTIVE;
           this.dataMap.chainStateMap[storedSlug] = {
-            currentProvider: currentProvider,
+            currentProvider: selectedProvider,
             slug: storedSlug,
             connectionStatus: _ChainConnectionStatus.DISCONNECTED,
             active: canActive && storedChainInfo.active
@@ -671,13 +773,13 @@ export class ChainService {
           newStorageData.push({
             ...mergedChainInfoMap[storedSlug],
             active: canActive && storedChainInfo.active,
-            currentProvider: currentProvider
+            currentProvider: selectedProvider
           });
         } else if (_isCustomChain(storedSlug)) {
           var _storedChainInfo$subs, _storedChainInfo$evmI;
           // only custom chains are left
           // check custom chain duplicated with predefined chain => merge into predefined chain
-          const duplicatedDefaultSlug = this.checkExistedPredefinedChain(latestChainInfoMap, (_storedChainInfo$subs = storedChainInfo.substrateInfo) === null || _storedChainInfo$subs === void 0 ? void 0 : _storedChainInfo$subs.genesisHash, (_storedChainInfo$evmI = storedChainInfo.evmInfo) === null || _storedChainInfo$evmI === void 0 ? void 0 : _storedChainInfo$evmI.evmChainId);
+          const duplicatedDefaultSlug = this.checkExistedPredefinedChain(defaultChainInfoMap, (_storedChainInfo$subs = storedChainInfo.substrateInfo) === null || _storedChainInfo$subs === void 0 ? void 0 : _storedChainInfo$subs.genesisHash, (_storedChainInfo$evmI = storedChainInfo.evmInfo) === null || _storedChainInfo$evmI === void 0 ? void 0 : _storedChainInfo$evmI.evmChainId);
           if (duplicatedDefaultSlug.length > 0) {
             // merge custom chain with existed chain
             mergedChainInfoMap[duplicatedDefaultSlug].providers = {
@@ -702,6 +804,7 @@ export class ChainService {
               slug: storedSlug,
               name: storedChainInfo.name,
               providers: storedChainInfo.providers,
+              // TODO: review
               evmInfo: storedChainInfo.evmInfo,
               substrateInfo: storedChainInfo.substrateInfo,
               isTestnet: storedChainInfo.isTestnet,
@@ -711,6 +814,7 @@ export class ChainService {
             };
             this.dataMap.chainStateMap[storedSlug] = {
               currentProvider: storedChainInfo.currentProvider,
+              // TODO: review
               slug: storedSlug,
               connectionStatus: _ChainConnectionStatus.DISCONNECTED,
               active: storedChainInfo.active
@@ -718,7 +822,7 @@ export class ChainService {
             newStorageData.push({
               ...mergedChainInfoMap[storedSlug],
               active: storedChainInfo.active,
-              currentProvider: storedChainInfo.currentProvider
+              currentProvider: storedChainInfo.currentProvider // TODO: review
             });
           }
         } else {
@@ -750,7 +854,7 @@ export class ChainService {
   }
   async initAssetRegistry(deprecatedCustomChainMap) {
     const storedAssetRegistry = await this.dbService.getAllAssetStore();
-    const latestAssetRegistry = await this.fetchLatestData(_CHAIN_ASSET_SRC, ChainAssetMap);
+    const latestAssetRegistry = ChainAssetMap;
     const availableChains = Object.values(this.dataMap.chainInfoMap).filter(info => info.chainStatus === _ChainStatus.ACTIVE).map(chainInfo => chainInfo.slug);
 
     // Fill out zk assets from latestAssetRegistry if not supported
@@ -1200,9 +1304,11 @@ export class ChainService {
   }
   async stopAllChainApis() {
     await Promise.all([this.substrateChainHandler.sleep(), this.evmChainHandler.sleep()]);
+    this.stopCheckLatestChainData();
   }
   async resumeAllChainApis() {
     await Promise.all([this.substrateChainHandler.wakeUp(), this.evmChainHandler.wakeUp()]);
+    this.checkLatestData();
   }
   checkAndUpdateStatusMapForChain(chainSlug) {
     const substrateApiMap = this.getSubstrateApiMap();
@@ -1337,10 +1443,10 @@ export class ChainService {
     return this.assetSettingSubject;
   }
   async getChainLogoMap() {
-    return await this.fetchLatestData(_CHAIN_LOGO_MAP_SRC, ChainLogoMap);
+    return Promise.resolve(ChainLogoMap);
   }
   async getAssetLogoMap() {
-    return await this.fetchLatestData(_ASSET_LOGO_MAP_SRC, AssetLogoMap);
+    return Promise.resolve(AssetLogoMap);
   }
   resetWallet(resetAll) {
     if (resetAll) {

package/services/chain-service/utils.d.ts

@@ -1,6 +1,7 @@
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
 import { BasicTokenInfo } from '@subwallet/extension-base/background/KoniTypes';
-import { _ChainState } from '@subwallet/extension-base/services/chain-service/types';
+import { _ChainState, _DataMap } from '@subwallet/extension-base/services/chain-service/types';
+import { IChain } from '@subwallet/extension-base/services/storage-service/databases';
 export declare function _isCustomChain(slug: string): boolean;
 export declare function _isCustomAsset(slug: string): boolean;
 export declare function _getCustomAssets(assetRegistry: Record<string, _ChainAsset>): Record<string, _ChainAsset>;
@@ -67,3 +68,11 @@ export declare function _generateCustomProviderKey(index: number): string;
 export declare const findChainInfoByHalfGenesisHash: (chainMap: Record<string, _ChainInfo>, halfGenesisHash?: string) => _ChainInfo | null;
 export declare const findChainInfoByChainId: (chainMap: Record<string, _ChainInfo>, chainId?: number) => _ChainInfo | null;
 export declare function _isMantaZkAsset(chainAsset: _ChainAsset): boolean;
+export declare function randomizeProvider(providers: Record<string, string>, excludedKeys?: string[]): {
+    providerKey: string;
+    providerValue: string;
+};
+export declare function updateLatestChainInfo(currentDataMap: _DataMap, latestChainInfoList: _ChainInfo[]): {
+    storedChainInfoList: IChain[];
+    needUpdateChainApiList: _ChainInfo[];
+};

package/services/chain-service/utils.js

@@ -1,7 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { _AssetRefPath, _AssetType, _SubstrateChainType } from '@subwallet/chain-list/types';
+import { _AssetRefPath, _AssetType, _ChainStatus, _SubstrateChainType } from '@subwallet/chain-list/types';
 import { _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { _CUSTOM_PREFIX, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
 import { isEthereumAddress } from '@polkadot/util-crypto';
@@ -362,4 +362,69 @@ export const findChainInfoByChainId = (chainMap, chainId) => {
 };
 export function _isMantaZkAsset(chainAsset) {
   return _MANTA_ZK_CHAIN_GROUP.includes(chainAsset.originChain) && chainAsset.symbol.startsWith(_ZK_ASSET_PREFIX);
+}
+export function randomizeProvider(providers, excludedKeys) {
+  if (Object.keys(providers).length === 0) {
+    return {
+      providerKey: '',
+      providerValue: ''
+    };
+  }
+  let isValid = false;
+  let selectedProviderKey = '';
+  let selectedProviderValue = '';
+  while (!isValid) {
+    var _selectedProviderValu, _selectedProviderKey;
+    const randomProvider = Math.floor(Math.random() * Object.keys(providers).length);
+    selectedProviderKey = Object.keys(providers)[randomProvider];
+    selectedProviderValue = providers[selectedProviderKey];
+    if (!((_selectedProviderValu = selectedProviderValue) !== null && _selectedProviderValu !== void 0 && _selectedProviderValu.startsWith('light')) && !((_selectedProviderKey = selectedProviderKey) !== null && _selectedProviderKey !== void 0 && _selectedProviderKey.startsWith(_CUSTOM_PREFIX)) && !(excludedKeys !== null && excludedKeys !== void 0 && excludedKeys.includes(selectedProviderKey))) {
+      // if it's light client, then re-randomize
+      isValid = true;
+    }
+  }
+  return {
+    providerKey: selectedProviderKey,
+    providerValue: selectedProviderValue
+  };
+}
+export function updateLatestChainInfo(currentDataMap, latestChainInfoList) {
+  const currentChainInfoMap = currentDataMap.chainInfoMap;
+  const currentChainStateMap = currentDataMap.chainStateMap;
+  const storedChainInfoList = [];
+  const needUpdateChainApiList = [];
+  latestChainInfoList.forEach(latestChainInfo => {
+    const currentChainInfo = currentChainInfoMap[latestChainInfo.slug];
+    const currentChainState = currentChainStateMap[latestChainInfo.slug];
+    const currentChainProviderValue = currentChainInfo === null || currentChainInfo === void 0 ? void 0 : currentChainInfo.providers[currentChainState === null || currentChainState === void 0 ? void 0 : currentChainState.currentProvider];
+    if (currentChainInfo && currentChainState) {
+      const preservedProvider = {};
+      Object.entries(currentChainInfo.providers).forEach(([providerKey, providerValue]) => {
+        if (providerValue !== null && providerValue !== void 0 && providerValue.startsWith('light') || providerKey !== null && providerKey !== void 0 && providerKey.startsWith(_CUSTOM_PREFIX)) {
+          preservedProvider[providerKey] = providerValue;
+        }
+      });
+      currentChainInfo.providers = {
+        ...latestChainInfo.providers,
+        ...preservedProvider
+      };
+      const currentProviderNotFound = !Object.keys(currentChainInfo.providers).includes(currentChainState.currentProvider);
+      const currentProviderUpdated = Object.keys(currentChainInfo.providers).includes(currentChainState.currentProvider) && !Object.values(currentChainInfo.providers).includes(currentChainProviderValue);
+      if (currentChainInfo.chainStatus === _ChainStatus.ACTIVE && (currentProviderNotFound || currentProviderUpdated)) {
+        const {
+          providerKey
+        } = randomizeProvider(currentChainInfo.providers);
+        currentChainState.currentProvider = providerKey;
+        needUpdateChainApiList.push(currentChainInfo);
+      }
+      storedChainInfoList.push({
+        ...currentChainInfo,
+        ...currentChainState
+      });
+    }
+  });
+  return {
+    storedChainInfoList,
+    needUpdateChainApiList
+  };
 }

package/services/earning-service/handlers/liquid-staking/base.d.ts

@@ -6,6 +6,6 @@ export default abstract class BaseLiquidStakingPoolHandler extends BaseSpecialSt
     /** Rate convert token when redeem */
     readonly minAmountPercent: number;
     static get defaultMinAmountPercent(): number;
-    createParamToRedeem(amount: string, address: string): Promise<number>;
+    createParamToRedeem(amount: string, address: string): Promise<string>;
     validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string): Promise<TransactionError[]>;
 }

package/services/earning-service/handlers/liquid-staking/base.js

@@ -6,6 +6,7 @@ import { BasicTxErrorType, StakingTxErrorType } from '@subwallet/extension-base/
 import { convertDerivativeToOriginToken } from '@subwallet/extension-base/koni/api/yield/helper/utils';
 import { YieldPoolType } from '@subwallet/extension-base/types';
 import { formatNumber } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
 import { t } from 'i18next';
 import { BN, BN_ZERO } from '@polkadot/util';
 import BaseSpecialStakingPoolHandler from "../special.js";
@@ -31,7 +32,7 @@ export default class BaseLiquidStakingPoolHandler extends BaseSpecialStakingPool
       return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
     }
     const formattedMinAmount = convertDerivativeToOriginToken(amount, poolInfo, derivativeTokenInfo, originTokenInfo);
-    return Math.floor(this.minAmountPercent * formattedMinAmount);
+    return new BigN(formattedMinAmount).multipliedBy(this.minAmountPercent).toFixed(0);
   }
   async validateYieldLeave(amount, address, fastLeave, selectedTarget) {
     const poolInfo = await this.getPoolInfo();

package/services/earning-service/handlers/liquid-staking/bifrost-manta.d.ts

@@ -0,0 +1,37 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { BaseYieldStepDetail, HandleYieldStepData, LiquidYieldPoolInfo, OptimalYieldPath, SubmitYieldJoinData, TransactionData } from '@subwallet/extension-base/types';
+import BifrostLiquidStakingPoolHandler from './bifrost';
+export interface BifrostLiquidStakingMeta {
+    apy: string;
+    apyBase: string;
+    apyReward: string;
+    tvl: number;
+    tvm: number;
+    holders: number;
+}
+export interface BifrostVtokenExchangeRateResp {
+    ratio: BifrostVtokenExchangeRate[];
+}
+export interface BifrostVtokenExchangeRate {
+    ratio: string;
+    key: string;
+    timestamp: string;
+    total_issuance: number;
+    token_pool: number;
+}
+export default class BifrostMantaLiquidStakingPoolHandler extends BifrostLiquidStakingPoolHandler {
+    protected readonly altInputAsset: string;
+    protected readonly derivativeAssets: string[];
+    protected readonly inputAsset: string;
+    protected readonly rewardAssets: string[];
+    protected readonly feeAssets: string[];
+    readonly minAmountPercent: number;
+    constructor(state: KoniState, chain: string);
+    protected getDescription(): string;
+    getPoolStat(): Promise<LiquidYieldPoolInfo>;
+    get submitJoinStepInfo(): BaseYieldStepDetail;
+    handleSubmitStep(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<HandleYieldStepData>;
+    handleYieldRedeem(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+}

package/services/earning-service/handlers/liquid-staking/bifrost-manta.js

@@ -0,0 +1,132 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getAssetDecimals, _getTokenOnChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { YieldStepType } from '@subwallet/extension-base/types';
+import fetch from 'cross-fetch';
+import BifrostLiquidStakingPoolHandler from "./bifrost.js";
+const STATS_URL = 'https://api.bifrost.app/api/site';
+const RATIO_URL = 'https://api.bifrost.app/api/omni/MANTA';
+export default class BifrostMantaLiquidStakingPoolHandler extends BifrostLiquidStakingPoolHandler {
+  altInputAsset = 'manta_network-NATIVE-MANTA';
+  derivativeAssets = ['bifrost_dot-LOCAL-vMANTA'];
+  inputAsset = 'bifrost_dot-LOCAL-MANTA';
+  rewardAssets = ['bifrost_dot-LOCAL-MANTA'];
+  feeAssets = ['bifrost_dot-NATIVE-BNC', 'bifrost_dot-LOCAL-MANTA'];
+  minAmountPercent = 0.985;
+  constructor(state, chain) {
+    super(state, chain);
+    const chainInfo = this.chainInfo;
+    this.slug = `MANTA___liquid_staking___${chain}`;
+    this.name = `${chainInfo.name} Liquid Staking Manta`;
+    this.shortName = chainInfo.name.replaceAll(' Relay Chain', '');
+  }
+  getDescription() {
+    return 'Stake MANTA to earn yield on vMANTA';
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const substrateApi = await this.substrateApi.isReady;
+    const stakingMetaPromise = new Promise(function (resolve) {
+      fetch(STATS_URL, {
+        method: 'GET'
+      }).then(res => {
+        resolve(res.json());
+      }).catch(console.error);
+    });
+    const exchangeRatePromise = new Promise(function (resolve) {
+      fetch(RATIO_URL, {
+        method: 'GET'
+      }).then(resp => {
+        resolve(resp.json());
+      }).catch(console.error);
+    });
+    const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
+    const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
+    const [_stakingMeta, _exchangeRate, _minimumRedeem, _minimumMint] = await Promise.all([stakingMetaPromise, exchangeRatePromise, substrateApi.api.query.vtokenMinting.minimumRedeem(_getTokenOnChainInfo(derivativeTokenInfo)), substrateApi.api.query.vtokenMinting.minimumMint(_getTokenOnChainInfo(inputTokenInfo))]);
+    const minimumRedeem = _minimumRedeem.toString();
+    const minimumMint = _minimumMint.toString();
+    const stakingMeta = _stakingMeta;
+    const exchangeRate = _exchangeRate;
+    const vMANTAStats = stakingMeta.vMANTA;
+    const assetInfo = this.state.getAssetBySlug(this.inputAsset);
+    const assetDecimals = 10 ** _getAssetDecimals(assetInfo);
+    const rate = parseFloat(exchangeRate.ratio[exchangeRate.ratio.length - 1].ratio); // TODO
+
+    this.updateExchangeRate(rate);
+    return {
+      ...this.baseInfo,
+      type: this.type,
+      metadata: {
+        ...this.metadataInfo,
+        description: this.getDescription()
+      },
+      statistic: {
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apy: parseFloat(vMANTAStats.apyBase),
+          exchangeRate: rate
+        }],
+        farmerCount: vMANTAStats.holders,
+        unstakingPeriod: 24 * 7,
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        earningThreshold: {
+          join: minimumMint,
+          defaultUnstake: minimumRedeem,
+          fastUnstake: '0'
+        },
+        totalApy: parseFloat(vMANTAStats.apyBase),
+        tvl: (vMANTAStats.tvm * assetDecimals).toString()
+      }
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint vMANTA',
+      type: YieldStepType.MINT_VMANTA
+    };
+  }
+  async handleSubmitStep(data, path) {
+    const substrateApi = await this.substrateApi.isReady;
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const extrinsic = substrateApi.api.tx.vtokenMinting.mint(_getTokenOnChainInfo(inputTokenInfo), data.amount, undefined, undefined);
+    return {
+      txChain: this.chain,
+      extrinsicType: ExtrinsicType.MINT_VMANTA,
+      extrinsic,
+      txData: data,
+      transferNativeAmount: '0',
+      chainType: ChainType.SUBSTRATE
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    const substrateApi = await this.substrateApi.isReady;
+    const weightedMinAmount = await this.createParamToRedeem(amount, address);
+    const extrinsic = substrateApi.api.tx.stablePool.swap(5, 1, 0, amount, weightedMinAmount);
+    return [ExtrinsicType.REDEEM_VMANTA, extrinsic];
+  }
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const chainApi = await this.substrateApi.isReady;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const extrinsic = chainApi.api.tx.vtokenMinting.redeem(_getTokenOnChainInfo(derivativeTokenInfo), amount);
+    return [ExtrinsicType.UNSTAKE_VMANTA, extrinsic];
+  }
+
+  /* Leave pool action */
+}

package/services/earning-service/handlers/liquid-staking/bifrost.d.ts

@@ -24,14 +24,14 @@ export interface BifrostVtokenExchangeRate {
 }
 export default class BifrostLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
     slug: string;
-    protected readonly name: string;
-    protected readonly shortName: string;
+    protected name: string;
+    protected shortName: string;
     protected readonly altInputAsset: string;
     protected readonly derivativeAssets: string[];
     protected readonly inputAsset: string;
     protected readonly rewardAssets: string[];
     protected readonly feeAssets: string[];
-    readonly minAmountPercent = 0.99;
+    readonly minAmountPercent: number;
     protected readonly availableMethod: YieldPoolMethodInfo;
     protected readonly rateDecimals = 0;
     constructor(state: KoniState, chain: string);

package/services/earning-service/handlers/liquid-staking/bifrost.js

@@ -34,7 +34,7 @@ export default class BifrostLiquidStakingPoolHandler extends BaseLiquidStakingPo
     super(state, chain);
     const chainInfo = this.chainInfo;
     this.slug = `DOT___liquid_staking___${chain}`;
-    this.name = `${chainInfo.name} Liquid Staking`;
+    this.name = `${chainInfo.name} Liquid Staking DOT`;
     this.shortName = chainInfo.name.replaceAll(' Relay Chain', '');
   }
   getDescription() {
@@ -93,6 +93,7 @@ export default class BifrostLiquidStakingPoolHandler extends BaseLiquidStakingPo
         unstakingPeriod: 24 * 28,
         maxCandidatePerFarmer: 1,
         maxWithdrawalRequestPerFarmer: 1,
+        farmerCount: vDOTStats.holders,
         earningThreshold: {
           join: minimumMint,
           defaultUnstake: minimumRedeem,

package/services/earning-service/handlers/liquid-staking/index.d.ts

@@ -1,4 +1,5 @@
 export { default as AcalaLiquidStakingPoolHandler } from './acala';
 export { default as BifrostLiquidStakingPoolHandler } from './bifrost';
+export { default as BifrostMantaLiquidStakingPoolHandler } from './bifrost-manta';
 export { default as ParallelLiquidStakingPoolHandler } from './parallel';
 export { default as StellaSwapLiquidStakingPoolHandler } from './stella-swap';

package/services/earning-service/handlers/liquid-staking/index.js

@@ -3,5 +3,6 @@
 
 export { default as AcalaLiquidStakingPoolHandler } from "./acala.js";
 export { default as BifrostLiquidStakingPoolHandler } from "./bifrost.js";
+export { default as BifrostMantaLiquidStakingPoolHandler } from "./bifrost-manta.js";
 export { default as ParallelLiquidStakingPoolHandler } from "./parallel.js";
 export { default as StellaSwapLiquidStakingPoolHandler } from "./stella-swap.js";