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

package/services/earning-service/service.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { BasicTxErrorType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { CRON_REFRESH_CHAIN_STAKING_METADATA, CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL, CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { _isChainEnabled, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
@@ -33,11 +33,15 @@ export default class EarningService {
   yieldPositionSubject = new BehaviorSubject({});
   yieldPositionListSubject = new 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 = [];
@@ -125,6 +129,7 @@ export default class EarningService {
   }
   handleActions() {
     this.eventService.onLazy((events, eventTypes) => {
+      let delayReload = false;
       (async () => {
         const removedAddresses = [];
         const removeChains = [];
@@ -138,6 +143,13 @@ export default class EarningService {
               removeChains.push(event.data[0]);
             }
           }
+          if (event.type === 'transaction.done') {
+            const transactionData = event.data[0];
+            const notRequireReloadTypes = [ExtrinsicType.TRANSFER_BALANCE, ExtrinsicType.TRANSFER_TOKEN, ExtrinsicType.TRANSFER_XCM, ExtrinsicType.SEND_NFT, ExtrinsicType.CROWDLOAN];
+            if (notRequireReloadTypes.indexOf(transactionData.extrinsicType) === -1) {
+              delayReload = true;
+            }
+          }
         });
         if (removeChains.length || removedAddresses.length) {
           await this.removeYieldPositions(removeChains, removedAddresses);
@@ -146,8 +158,16 @@ export default 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);
     });
@@ -241,20 +261,25 @@ export default 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 === YieldPoolType.LIQUID_STAKING || handler.type === YieldPoolType.LENDING;
+      if (!this.useOnlineCacheOnly || forceSubscribe) {
+        handler.subscribePoolInfo(callback).then(unsub => {
+          if (!cancel) {
+            unsubList.push(unsub);
+          } else {
+            unsub();
+          }
+        }).catch(console.error);
+      }
     }
     return () => {
       cancel = true;
@@ -306,19 +331,20 @@ export default 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);
     }, CRON_REFRESH_CHAIN_STAKING_METADATA);
 
     // Fetching from chains
-    this.subscribePoolsInfo(data => {
+    this.subscribePoolsInfo(onlineData, data => {
       data.lastUpdated = Date.now();
       this.updateYieldPoolInfo(data);
     }).then(rs => {
@@ -460,6 +486,10 @@ export default class EarningService {
     (_this$yieldPositionUn = this.yieldPositionUnsub) === null || _this$yieldPositionUn === void 0 ? void 0 : _this$yieldPositionUn.call(this);
     removeLazy('persistYieldPositionInfo');
     this.yieldPositionPersistQueue = [];
+
+    // Remove delay reload
+    this.delayReloadTimeout && clearTimeout(this.delayReloadTimeout);
+    this.delayReloadTimeout = undefined;
   }
 
   /* Pools' position methods */
@@ -608,13 +638,16 @@ export default class EarningService {
    * @return {Promise<YieldPoolTarget[]>} List of pool's target
    * */
   async getPoolTargets(slug) {
-    await this.eventService.waitChainReady;
+    let targets = [];
+    if (this.useOnlineCacheOnly) {
+      targets = await 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/services/fee-service/service.d.ts

@@ -0,0 +1,12 @@
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { EvmFeeInfo } from '@subwallet/extension-base/types';
+export default class FeeService {
+    protected readonly state: KoniState;
+    private evmFeeSubject;
+    private useInfura;
+    constructor(state: KoniState);
+    changeMode(useInfura: boolean): void;
+    private updateFees;
+    private updateChainFee;
+    subscribeFees(callback: (data: Record<string, EvmFeeInfo>) => void): () => void;
+}

package/services/fee-service/service.js

@@ -0,0 +1,63 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
+import { BehaviorSubject } from 'rxjs';
+export default class FeeService {
+  evmFeeSubject = new 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 => _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 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);
+    };
+  }
+}

package/services/fee-service/utils/index.d.ts

@@ -0,0 +1,8 @@
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { EvmFeeInfo, InfuraFeeInfo } from '@subwallet/extension-base/types';
+export declare const parseInfuraFee: (info: InfuraFeeInfo) => EvmFeeInfo;
+export declare const fetchInfuraFeeData: (chainId: number, infuraAuth?: string) => Promise<EvmFeeInfo | null>;
+export declare const fetchSubWalletFeeData: (chainId: number, networkKey: string) => Promise<EvmFeeInfo | null>;
+export declare const fetchOnlineFeeData: (chainId: number, networkKey: string, useInfura?: boolean) => Promise<EvmFeeInfo | null>;
+export declare const recalculateGasPrice: (_price: string, chain: string) => string;
+export declare const calculateGasFeeParams: (web3: _EvmApi, networkKey: string, useOnline?: boolean, useInfura?: boolean) => Promise<EvmFeeInfo>;

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

@@ -0,0 +1,193 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { GAS_PRICE_RATIO, NETWORK_MULTI_GAS_FEE } from '@subwallet/extension-base/constants';
+import { BN_WEI, BN_ZERO } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
+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');
+export const parseInfuraFee = info => {
+  const base = new BigN(info.estimatedBaseFee).multipliedBy(BN_WEI);
+  const low = new BigN(info.low.suggestedMaxPriorityFeePerGas).multipliedBy(BN_WEI);
+  const busyNetwork = base.gt(BN_ZERO) ? low.dividedBy(base).gte(0.3) : false;
+  const data = !busyNetwork ? info.low : info.medium;
+  return {
+    busyNetwork,
+    gasPrice: undefined,
+    baseGasFee: base,
+    maxFeePerGas: new BigN(data.suggestedMaxFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP),
+    maxPriorityFeePerGas: new BigN(data.suggestedMaxPriorityFeePerGas).multipliedBy(BN_WEI).integerValue(BigN.ROUND_UP)
+  };
+};
+export 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);
+    });
+  });
+};
+export 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 BigN(info.baseGasFee),
+          maxFeePerGas: new BigN(info.maxFeePerGas),
+          maxPriorityFeePerGas: new BigN(info.maxPriorityFeePerGas)
+        });
+      }
+    }).catch(e => {
+      console.warn(e);
+      resolve(null);
+    });
+  });
+};
+export const fetchOnlineFeeData = async (chainId, networkKey, useInfura = 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);
+    });
+  });
+};
+export const recalculateGasPrice = (_price, chain) => {
+  const needMulti = NETWORK_MULTI_GAS_FEE.includes(chain) || NETWORK_MULTI_GAS_FEE.includes('*');
+  return needMulti ? new BigN(_price).multipliedBy(GAS_PRICE_RATIO).toFixed(0) : _price;
+};
+export const calculateGasFeeParams = async (web3, networkKey, useOnline = true, useInfura = 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 BigN(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 BigN(firstPriority);
+      const baseBN = new BigN(base);
+
+      /*
+      * True if priority >= 0.3 * base
+      *  */
+      const blockIsBusy = baseBN.gt(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 = 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 BigN(current);
+        if (currentBN.gt(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 BigN(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(BN_ZERO)) {
+          return current; // get min priority
+        } else if (current.eq(BN_ZERO)) {
+          return previous;
+        }
+        return current.lte(previous) ? current : previous; // get min priority
+      }
+    }, BN_ZERO);
+    if (maxPriorityFeePerGas.eq(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
+    };
+  }
+};

package/services/migration-service/scripts/DeleteChainStaking.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class DeleteChainStaking extends BaseMigrationJob {
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class DeleteChainStaking extends BaseMigrationJob {
+  async run() {
+    try {
+      await this.state.dbService.stores.yieldPoolInfo.table.where({
+        slug: 'CAPS___native_staking___ternoa_alphanet'
+      }).delete();
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}

package/services/migration-service/scripts/databases/MigrateAssetSetting.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateAssetSetting extends BaseMigrationJob {
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,42 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateAssetSetting extends BaseMigrationJob {
+  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);
+    }
+  }
+}

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import DeleteEarningData from '@subwallet/extension-base/services/migration-service/scripts/DeleteEarningData';
+// import MigrateAssetSetting from './databases/MigrateAssetSetting';
 import MigrateEarningVersion from "./databases/MigrateEarningVersion.js";
 import MigrateEthProvider from "./providers/MigrateEthProvider.js";
 import MigratePioneerProvider from "./providers/MigratePioneerProvider.js";
@@ -9,6 +10,7 @@ import MigrateProvidersV1M1P24 from "./providers/MigrateProvidersV1M1P24.js";
 import MigratePolygonUSDCProvider from "./tokens/MigratePolygonUSDCProvider.js";
 import AutoEnableChainsTokens from "./AutoEnableChainsTokens.js";
 import DeleteChain from "./DeleteChain.js";
+import DeleteChainStaking from "./DeleteChainStaking.js";
 import EnableVaraChain from "./EnableVaraChain.js";
 import MigrateAuthUrls from "./MigrateAuthUrls.js";
 import MigrateAutoLock from "./MigrateAutoLock.js";
@@ -41,6 +43,8 @@ export default {
   '1.1.17-03': EnableVaraChain,
   '1.1.24-01': MigrateProvidersV1M1P24,
   '1.1.26-01': MigratePolygonUSDCProvider,
-  '1.1.28-01': MigrateEarningVersion
+  '1.1.28-01': MigrateEarningVersion,
+  '1.1.41-01': DeleteChainStaking
+  // '1.1.41-02': MigrateAssetSetting
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };

package/services/transaction-service/index.js

@@ -7,6 +7,7 @@ import { BasicTxErrorType, BasicTxWarningCode, ChainType, EvmProviderErrorType,
 import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getEvmChainId, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
 import { TRANSACTION_TIMEOUT } from '@subwallet/extension-base/services/transaction-service/constants';
 import { parseLiquidStakingEvents, parseLiquidStakingFastUnstakeEvents, parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
@@ -14,8 +15,7 @@ import { getBaseTransactionInfo, getTransactionId, isSubstrateTransaction } from
 import { getExplorerLink, parseTransactionData } from '@subwallet/extension-base/services/transaction-service/utils';
 import { isWalletConnectRequest } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { YieldPoolType } from '@subwallet/extension-base/types';
-import { reformatAddress } from '@subwallet/extension-base/utils';
-import { anyNumberToBN, calculateGasFeeParams } from '@subwallet/extension-base/utils/eth';
+import { anyNumberToBN, reformatAddress } from '@subwallet/extension-base/utils';
 import { mergeTransactionAndSignature } from '@subwallet/extension-base/utils/eth/mergeTransactionAndSignature';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { BN_ZERO } from '@subwallet/extension-base/utils/number';

package/types/fee/index.d.ts

@@ -0,0 +1,49 @@
+import BigN from 'bignumber.js';
+interface BaseFeeInfo {
+    busyNetwork: boolean;
+}
+export interface EvmLegacyFeeInfo extends BaseFeeInfo {
+    gasPrice: string;
+    maxFeePerGas: undefined;
+    maxPriorityFeePerGas: undefined;
+    baseGasFee: undefined;
+}
+export interface EvmEIP1995FeeInfo extends BaseFeeInfo {
+    gasPrice: undefined;
+    maxFeePerGas: BigN;
+    maxPriorityFeePerGas: BigN;
+    baseGasFee: BigN;
+}
+export declare type EvmFeeInfo = EvmLegacyFeeInfo | EvmEIP1995FeeInfo;
+export interface EvmLegacyFeeInfoCache extends BaseFeeInfo {
+    gasPrice: string;
+    maxFeePerGas: undefined;
+    maxPriorityFeePerGas: undefined;
+    baseGasFee: undefined;
+}
+export interface EvmEIP1995FeeInfoCache extends BaseFeeInfo {
+    gasPrice: undefined;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    baseGasFee: string;
+}
+export declare type EvmFeeInfoCache = EvmLegacyFeeInfoCache | EvmEIP1995FeeInfoCache;
+export interface InfuraFeeDetail {
+    suggestedMaxPriorityFeePerGas: string;
+    suggestedMaxFeePerGas: string;
+    minWaitTimeEstimate: number;
+    maxWaitTimeEstimate: number;
+}
+export interface InfuraFeeInfo {
+    low: InfuraFeeDetail;
+    medium: InfuraFeeDetail;
+    high: InfuraFeeDetail;
+    networkCongestion: number;
+    estimatedBaseFee: string;
+    latestPriorityFeeRange: [string, string];
+    historicalPriorityFeeRange: [string, string];
+    historicalBaseFeeRange: [string, string];
+    priorityFeeTrend: 'down' | 'up';
+    baseFeeTrend: 'down' | 'up';
+}
+export {};

package/types/fee/index.js

@@ -0,0 +1 @@
+export {};

package/types/index.d.ts

@@ -11,6 +11,7 @@ export interface Message extends MessageEvent {
 export * from './balance';
 export * from './buy';
 export * from './campaigns';
+export * from './fee';
 export * from './ordinal';
 export * from './transaction';
 export * from './yield';

package/types/index.js

@@ -4,6 +4,7 @@
 export * from "./balance.js";
 export * from "./buy.js";
 export * from "./campaigns/index.js";
+export * from "./fee/index.js";
 export * from "./ordinal.js";
 export * from "./transaction.js";
 export * from "./yield/index.js";

package/types/yield/info/account/unstake.d.ts

@@ -26,6 +26,8 @@ export interface UnstakingInfo {
     claimable: string;
     /** Time remains to wait (in hours) */
     waitingTime?: number;
+    /** Timestamp to withdraw */
+    targetTimestampMs?: number;
     /** Address of validator */
     validatorAddress?: string;
 }

package/types/yield/info/pallet.d.ts

@@ -136,6 +136,10 @@ export interface PalletStakingStakingLedger {
     unlocking: UnlockingChunk[];
     claimedRewards: number[];
 }
+export interface PalletStakingActiveEraInfo {
+    index: string;
+    start: string;
+}
 export interface RuntimeDispatchInfo {
     weight: {
         refTime: number;

package/utils/eth.d.ts

@@ -1,4 +1,3 @@
-import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
 import BigN from 'bignumber.js';
 import BNEther from 'bn.js';
 import { SignedTransaction } from 'web3-core';
@@ -16,17 +15,3 @@ export declare class Transaction {
 export declare const anyNumberToBN: (value?: string | number | BNEther) => BigN;
 export declare const createTransactionFromRLP: (rlp: string) => Transaction | null;
 export declare const signatureToHex: (sig: SignedTransaction) => string;
-export declare const recalculateGasPrice: (_price: string, chain: string) => string;
-export declare const calculateGasFeeParams: (web3: _EvmApi, networkKey: string) => Promise<{
-    gasPrice: string;
-    busyNetwork: boolean;
-    maxFeePerGas?: undefined;
-    maxPriorityFeePerGas?: undefined;
-    baseGasFee?: undefined;
-} | {
-    maxFeePerGas: BigN;
-    maxPriorityFeePerGas: BigN;
-    baseGasFee: BigN;
-    busyNetwork: boolean;
-    gasPrice?: undefined;
-}>;