@subwallet/extension-base 1.1.40-1 → 1.1.42-0

package/cjs/services/earning-service/service.js

@@ -40,11 +40,15 @@ class EarningService {
   yieldPositionSubject = new _rxjs.BehaviorSubject({});
   yieldPositionListSubject = new _rxjs.BehaviorSubject([]); // virtual list of yieldPositionSubject with filter values
 
+  useOnlineCacheOnly = true;
   constructor(state) {
     this.state = state;
     this.dbService = state.dbService;
     this.eventService = state.eventService;
   }
+  disableOnlineCacheOnly() {
+    this.useOnlineCacheOnly = false;
+  }
   async initHandlers() {
     await this.eventService.waitChainReady;
     const chains = [];
@@ -132,6 +136,7 @@ class EarningService {
   }
   handleActions() {
     this.eventService.onLazy((events, eventTypes) => {
+      let delayReload = false;
       (async () => {
         const removedAddresses = [];
         const removeChains = [];
@@ -145,6 +150,13 @@ class EarningService {
               removeChains.push(event.data[0]);
             }
           }
+          if (event.type === 'transaction.done') {
+            const transactionData = event.data[0];
+            const notRequireReloadTypes = [_KoniTypes.ExtrinsicType.TRANSFER_BALANCE, _KoniTypes.ExtrinsicType.TRANSFER_TOKEN, _KoniTypes.ExtrinsicType.TRANSFER_XCM, _KoniTypes.ExtrinsicType.SEND_NFT, _KoniTypes.ExtrinsicType.CROWDLOAN];
+            if (notRequireReloadTypes.indexOf(transactionData.extrinsicType) === -1) {
+              delayReload = true;
+            }
+          }
         });
         if (removeChains.length || removedAddresses.length) {
           await this.removeYieldPositions(removeChains, removedAddresses);
@@ -153,8 +165,16 @@ class EarningService {
         // Account changed or chain changed (active or inactive)
         // Chain changed (active or inactive)
         // Todo: Optimize performance of chain active or inactive in the future
-        if (eventTypes.includes('account.updateCurrent') || eventTypes.includes('account.remove') || eventTypes.includes('chain.updateState')) {
-          await this.reloadEarning();
+        if (eventTypes.includes('account.updateCurrent') || eventTypes.includes('account.remove') || eventTypes.includes('chain.updateState') || delayReload) {
+          if (delayReload) {
+            this.delayReloadTimeout = setTimeout(() => {
+              this.reloadEarning().catch(console.error); // Timeout is removed inside reloadEarning > runUnsubscribePoolsPosition
+            }, 3000);
+          } else {
+            this.delayReloadTimeout && clearTimeout(this.delayReloadTimeout);
+            this.delayReloadTimeout = undefined;
+            await this.reloadEarning();
+          }
         }
       })().catch(console.error);
     });
@@ -248,20 +268,25 @@ class EarningService {
   }
   async getYieldPool(slug) {
     await this.eventService.waitEarningReady;
-    return this.yieldPoolInfoSubject.getValue()[slug];
+    const poolInfoMap = this.yieldPoolInfoSubject.getValue();
+    return poolInfoMap[slug];
   }
-  async subscribePoolsInfo(callback) {
+  async subscribePoolsInfo(onlineData, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
-      handler.subscribePoolInfo(callback).then(unsub => {
-        if (!cancel) {
-          unsubList.push(unsub);
-        } else {
-          unsub();
-        }
-      }).catch(console.error);
+      // Force subscribe onchain data
+      const forceSubscribe = handler.type === _types2.YieldPoolType.LIQUID_STAKING || handler.type === _types2.YieldPoolType.LENDING;
+      if (!this.useOnlineCacheOnly || forceSubscribe) {
+        handler.subscribePoolInfo(callback).then(unsub => {
+          if (!cancel) {
+            unsubList.push(unsub);
+          } else {
+            unsub();
+          }
+        }).catch(console.error);
+      }
     }
     return () => {
       cancel = true;
@@ -313,19 +338,20 @@ class EarningService {
     Object.values(onlineData).forEach(item => {
       this.updateYieldPoolInfo(item);
     });
+    return onlineData;
   }
   async runSubscribePoolsInfo() {
     await this.eventService.waitChainReady;
     this.runUnsubscribePoolsInfo();
 
     // Fetching online data
-    this.fetchingPoolsInfoOnline().catch(console.error);
+    const onlineData = await this.fetchingPoolsInfoOnline();
     const interval = setInterval(() => {
       this.fetchingPoolsInfoOnline().catch(console.error);
     }, _constants.CRON_REFRESH_CHAIN_STAKING_METADATA);
 
     // Fetching from chains
-    this.subscribePoolsInfo(data => {
+    this.subscribePoolsInfo(onlineData, data => {
       data.lastUpdated = Date.now();
       this.updateYieldPoolInfo(data);
     }).then(rs => {
@@ -470,6 +496,10 @@ class EarningService {
     (_this$yieldPositionUn = this.yieldPositionUnsub) === null || _this$yieldPositionUn === void 0 ? void 0 : _this$yieldPositionUn.call(this);
     (0, _utils2.removeLazy)('persistYieldPositionInfo');
     this.yieldPositionPersistQueue = [];
+
+    // Remove delay reload
+    this.delayReloadTimeout && clearTimeout(this.delayReloadTimeout);
+    this.delayReloadTimeout = undefined;
   }
 
   /* Pools' position methods */
@@ -618,13 +648,16 @@ class EarningService {
    * @return {Promise<YieldPoolTarget[]>} List of pool's target
    * */
   async getPoolTargets(slug) {
-    await this.eventService.waitChainReady;
+    let targets = [];
+    if (this.useOnlineCacheOnly) {
+      targets = await (0, _fetchStaticCache.fetchStaticCache)(`earning/targets/${slug}.json`, []);
+    }
     const handler = this.getPoolHandler(slug);
-    if (handler) {
-      return await handler.getPoolTargets();
-    } else {
-      return [];
+    if (!targets.length && handler) {
+      await this.eventService.waitChainReady;
+      targets = await handler.getPoolTargets();
     }
+    return targets;
   }
 
   /* Get pool's targets */

package/cjs/services/fee-service/service.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/services/fee-service/utils");
+var _rxjs = require("rxjs");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class FeeService {
+  evmFeeSubject = new _rxjs.BehaviorSubject({});
+  constructor(state) {
+    this.state = state;
+    this.useInfura = true;
+  }
+  changeMode(useInfura) {
+    this.useInfura = useInfura;
+  }
+  async updateFees() {
+    await this.state.eventService.waitChainReady;
+    const activeNetworks = this.state.activeNetworks;
+    const chains = Object.values(activeNetworks).filter(chainInfo => (0, _utils._isChainEvmCompatible)(chainInfo)).map(chainInfo => chainInfo.slug);
+    const promises = [];
+    for (const chain of chains) {
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises,no-async-promise-executor
+      const promise = new Promise(async resolve => {
+        const api = this.state.getEvmApi(chain);
+        const result = await (0, _utils2.calculateGasFeeParams)(api, chain, this.useInfura);
+        this.updateChainFee(chain, result);
+        resolve();
+      });
+      promises.push(promise);
+    }
+    await Promise.all(promises);
+  }
+  updateChainFee(chain, info) {
+    const rs = Object.assign({}, this.evmFeeSubject.getValue());
+    rs[chain] = info;
+    this.evmFeeSubject.next(rs);
+  }
+  subscribeFees(callback) {
+    let cancel = false;
+
+    // eslint-disable-next-line prefer-const
+
+    const fetchData = () => {
+      this.updateFees().finally(() => {
+        if (!cancel) {
+          callback(this.evmFeeSubject.getValue());
+        }
+      });
+    };
+    fetchData();
+    const interval = setInterval(() => {
+      if (cancel) {
+        clearInterval(interval);
+      } else {
+        fetchData();
+      }
+    }, 30 * 1000);
+    return () => {
+      cancel = true;
+      clearInterval(interval);
+    };
+  }
+}
+exports.default = FeeService;

package/cjs/services/fee-service/utils/index.js

@@ -0,0 +1,209 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.recalculateGasPrice = exports.parseInfuraFee = exports.fetchSubWalletFeeData = exports.fetchOnlineFeeData = exports.fetchInfuraFeeData = exports.calculateGasFeeParams = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const INFURA_API_KEY = process.env.INFURA_API_KEY || '';
+const INFURA_API_KEY_SECRET = process.env.INFURA_API_KEY_SECRET || '';
+const INFURA_AUTH = 'Basic ' + Buffer.from(INFURA_API_KEY + ':' + INFURA_API_KEY_SECRET).toString('base64');
+const parseInfuraFee = info => {
+  const base = new _bignumber.default(info.estimatedBaseFee).multipliedBy(_utils.BN_WEI);
+  const low = new _bignumber.default(info.low.suggestedMaxPriorityFeePerGas).multipliedBy(_utils.BN_WEI);
+  const busyNetwork = base.gt(_utils.BN_ZERO) ? low.dividedBy(base).gte(0.3) : false;
+  const data = !busyNetwork ? info.low : info.medium;
+  return {
+    busyNetwork,
+    gasPrice: undefined,
+    baseGasFee: base,
+    maxFeePerGas: new _bignumber.default(data.suggestedMaxFeePerGas).multipliedBy(_utils.BN_WEI).integerValue(_bignumber.default.ROUND_UP),
+    maxPriorityFeePerGas: new _bignumber.default(data.suggestedMaxPriorityFeePerGas).multipliedBy(_utils.BN_WEI).integerValue(_bignumber.default.ROUND_UP)
+  };
+};
+exports.parseInfuraFee = parseInfuraFee;
+const fetchInfuraFeeData = async (chainId, infuraAuth) => {
+  return await new Promise(resolve => {
+    const baseUrl = 'https://gas.api.infura.io/networks/{{chainId}}/suggestedGasFees';
+    const url = baseUrl.replaceAll('{{chainId}}', chainId.toString());
+    fetch(url, {
+      method: 'GET',
+      headers: {
+        Authorization: infuraAuth || INFURA_AUTH
+      }
+    }).then(rs => {
+      return rs.json();
+    }).then(info => {
+      resolve(parseInfuraFee(info));
+    }).catch(e => {
+      console.warn(e);
+      resolve(null);
+    });
+  });
+};
+exports.fetchInfuraFeeData = fetchInfuraFeeData;
+const fetchSubWalletFeeData = async (chainId, networkKey) => {
+  return await new Promise(resolve => {
+    const baseUrl = 'https://api-cache.subwallet.app/sw-evm-gas/{{chain}}';
+    const url = baseUrl.replaceAll('{{chain}}', networkKey);
+    fetch(url, {
+      method: 'GET'
+    }).then(rs => {
+      return rs.json();
+    }).then(info => {
+      if (info.gasPrice !== undefined) {
+        resolve(info);
+      } else {
+        resolve({
+          busyNetwork: info.busyNetwork,
+          gasPrice: info.gasPrice,
+          baseGasFee: new _bignumber.default(info.baseGasFee),
+          maxFeePerGas: new _bignumber.default(info.maxFeePerGas),
+          maxPriorityFeePerGas: new _bignumber.default(info.maxPriorityFeePerGas)
+        });
+      }
+    }).catch(e => {
+      console.warn(e);
+      resolve(null);
+    });
+  });
+};
+exports.fetchSubWalletFeeData = fetchSubWalletFeeData;
+const fetchOnlineFeeData = async function (chainId, networkKey) {
+  let useInfura = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return await new Promise(resolve => {
+    const fetchFunction = useInfura ? fetchInfuraFeeData : fetchSubWalletFeeData;
+    fetchFunction(chainId, networkKey).then(info => {
+      resolve(info);
+    }).catch(e => {
+      console.warn(e);
+      resolve(null);
+    });
+  });
+};
+exports.fetchOnlineFeeData = fetchOnlineFeeData;
+const recalculateGasPrice = (_price, chain) => {
+  const needMulti = _constants.NETWORK_MULTI_GAS_FEE.includes(chain) || _constants.NETWORK_MULTI_GAS_FEE.includes('*');
+  return needMulti ? new _bignumber.default(_price).multipliedBy(_constants.GAS_PRICE_RATIO).toFixed(0) : _price;
+};
+exports.recalculateGasPrice = recalculateGasPrice;
+const calculateGasFeeParams = async function (web3, networkKey) {
+  let useOnline = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  let useInfura = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (useOnline) {
+    try {
+      const chainId = await web3.api.eth.getChainId();
+      const onlineData = await fetchOnlineFeeData(chainId, networkKey, useInfura);
+      if (onlineData) {
+        return onlineData;
+      }
+    } catch (e) {}
+  }
+  try {
+    const numBlock = 20;
+    const rewardPercent = [];
+    for (let i = 0; i <= 100; i = i + 5) {
+      rewardPercent.push(i);
+    }
+    const history = await web3.api.eth.getFeeHistory(numBlock, 'latest', rewardPercent);
+    const baseGasFee = new _bignumber.default(history.baseFeePerGas[history.baseFeePerGas.length - 1]); // Last element is latest
+
+    const blocksBusy = history.reward.reduce((previous, rewards, currentIndex) => {
+      const [firstPriority] = rewards;
+      const base = history.baseFeePerGas[currentIndex];
+      const priorityBN = new _bignumber.default(firstPriority);
+      const baseBN = new _bignumber.default(base);
+
+      /*
+      * True if priority >= 0.3 * base
+      *  */
+      const blockIsBusy = baseBN.gt(_utils.BN_ZERO) ? priorityBN.dividedBy(baseBN).gte(0.3) ? 1 : 0 : 0; // Special for bsc, base fee = 0
+
+      return previous + blockIsBusy;
+    }, 0);
+    const busyNetwork = blocksBusy >= numBlock / 2; // True, if half of block is busy
+
+    const maxPriorityFeePerGas = history.reward.reduce((previous, rewards) => {
+      let firstBN = _utils.BN_ZERO;
+      let firstIndex = 0;
+
+      /* Get first priority which greater than 0 */
+      for (let i = 0; i < rewards.length; i++) {
+        firstIndex = i;
+        const current = rewards[i];
+        const currentBN = new _bignumber.default(current);
+        if (currentBN.gt(_utils.BN_ZERO)) {
+          firstBN = currentBN;
+          break;
+        }
+      }
+      let secondBN = firstBN;
+
+      /* Get second priority which greater than first priority */
+      for (let i = firstIndex; i < rewards.length; i++) {
+        const current = rewards[i];
+        const currentBN = new _bignumber.default(current);
+        if (currentBN.gt(firstBN)) {
+          secondBN = currentBN;
+          break;
+        }
+      }
+      let current;
+      if (busyNetwork) {
+        current = secondBN.dividedBy(2).gte(firstBN) ? firstBN : secondBN; // second too larger than first (> 2 times), use first else use second
+      } else {
+        current = firstBN;
+      }
+      if (busyNetwork) {
+        /* Get max value */
+        return current.gte(previous) ? current : previous; // get max priority
+      } else {
+        /* Get min value which greater than 0 */
+        if (previous.eq(_utils.BN_ZERO)) {
+          return current; // get min priority
+        } else if (current.eq(_utils.BN_ZERO)) {
+          return previous;
+        }
+        return current.lte(previous) ? current : previous; // get min priority
+      }
+    }, _utils.BN_ZERO);
+    if (maxPriorityFeePerGas.eq(_utils.BN_ZERO)) {
+      const _price = await web3.api.eth.getGasPrice();
+      const gasPrice = recalculateGasPrice(_price, networkKey);
+      return {
+        gasPrice,
+        maxFeePerGas: undefined,
+        maxPriorityFeePerGas: undefined,
+        baseGasFee: undefined,
+        busyNetwork: false
+      };
+    }
+
+    /* Max gas = (base + priority) * 1.5 (if not busy or 2 when busy); */
+    const maxFeePerGas = baseGasFee.plus(maxPriorityFeePerGas).multipliedBy(busyNetwork ? 2 : 1.5).decimalPlaces(0);
+    return {
+      gasPrice: undefined,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      baseGasFee,
+      busyNetwork
+    };
+  } catch (e) {
+    const _price = await web3.api.eth.getGasPrice();
+    const gasPrice = recalculateGasPrice(_price, networkKey);
+    return {
+      gasPrice,
+      maxFeePerGas: undefined,
+      maxPriorityFeePerGas: undefined,
+      baseGasFee: undefined,
+      busyNetwork: false
+    };
+  }
+};
+exports.calculateGasFeeParams = calculateGasFeeParams;

package/cjs/services/migration-service/scripts/DeleteChainStaking.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class DeleteChainStaking extends _Base.default {
+  async run() {
+    try {
+      await this.state.dbService.stores.yieldPoolInfo.table.where({
+        slug: 'CAPS___native_staking___ternoa_alphanet'
+      }).delete();
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = DeleteChainStaking;

package/cjs/services/migration-service/scripts/databases/MigrateAssetSetting.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateAssetSetting extends _Base.default {
+  async run() {
+    try {
+      const oldSlugs = ['ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870', 'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F', 'astar-LOCAL-aUSD', 'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001',
+      //
+      'moonriver-LOCAL-xcaUSD',
+      //
+      'moonriver-LOCAL-xckBTC', 'bifrost-LOCAL-aUSD', 'calamari-LOCAL-AUSD', 'shiden-LOCAL-aUSD', 'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000',
+      //
+      'ethereum_goerli-NATIVE-GoerliETH', 'binance_test-NATIVE-BNB',
+      //
+      'pangolin-LOCAL-CKTON',
+      //
+      'zeta_test-NATIVE-aZETA' //
+      ];
+
+      const newSlugs = ['ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870', 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F', 'astar-LOCAL-aSEED', 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001', 'moonriver-LOCAL-xcaSeed', 'moonriver-LOCAL-xcKBTC', 'bifrost-LOCAL-KUSD', 'calamari-LOCAL-AUSD', 'shiden-LOCAL-aSEED', 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000', 'ethereum_goerli-NATIVE-ETH', 'binance_test-NATIVE-tBNB', 'pangolin-LOCAL-PKTON', 'zeta_test-NATIVE-ZETA'];
+      const assetSetting = await this.state.chainService.getAssetSettings();
+      const migratedAssetSetting = {};
+      for (let i = 0; i < oldSlugs.length; i++) {
+        const slug = oldSlugs[i];
+        if (Object.keys(assetSetting).includes(slug)) {
+          const isVisible = assetSetting[slug].visible;
+          const newSlug = newSlugs[i];
+          migratedAssetSetting[newSlug] = {
+            visible: isVisible
+          };
+        }
+      }
+      this.state.chainService.setAssetSettings({
+        ...assetSetting,
+        ...migratedAssetSetting
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = MigrateAssetSetting;

package/cjs/services/migration-service/scripts/index.js

@@ -13,6 +13,7 @@ var _MigrateProvidersV1M1P = _interopRequireDefault(require("./providers/Migrate
 var _MigratePolygonUSDCProvider = _interopRequireDefault(require("./tokens/MigratePolygonUSDCProvider"));
 var _AutoEnableChainsTokens = _interopRequireDefault(require("./AutoEnableChainsTokens"));
 var _DeleteChain = _interopRequireDefault(require("./DeleteChain"));
+var _DeleteChainStaking = _interopRequireDefault(require("./DeleteChainStaking"));
 var _EnableVaraChain = _interopRequireDefault(require("./EnableVaraChain"));
 var _MigrateAuthUrls = _interopRequireDefault(require("./MigrateAuthUrls"));
 var _MigrateAutoLock = _interopRequireDefault(require("./MigrateAutoLock"));
@@ -27,6 +28,8 @@ var _MigrateWalletReference = _interopRequireDefault(require("./MigrateWalletRef
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+// import MigrateAssetSetting from './databases/MigrateAssetSetting';
+
 const EVERYTIME = '__everytime__';
 exports.EVERYTIME = EVERYTIME;
 var _default = {
@@ -49,7 +52,9 @@ var _default = {
   '1.1.17-03': _EnableVaraChain.default,
   '1.1.24-01': _MigrateProvidersV1M1P.default,
   '1.1.26-01': _MigratePolygonUSDCProvider.default,
-  '1.1.28-01': _MigrateEarningVersion.default
+  '1.1.28-01': _MigrateEarningVersion.default,
+  '1.1.41-01': _DeleteChainStaking.default
+  // '1.1.41-02': MigrateAssetSetting
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };
 exports.default = _default;