@subwallet/extension-base 1.1.51-2 → 1.1.52-0

package/cjs/services/balance-service/index.js

@@ -7,10 +7,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.BalanceService = void 0;
 var _BalanceError = require("@subwallet/extension-base/background/errors/BalanceError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
-var _group = require("@subwallet/extension-base/services/balance-service/helpers/group");
-var _evm = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/evm");
-var _substrate = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/substrate");
-var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/services/base/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _DetectAccountBalance = _interopRequireDefault(require("@subwallet/extension-base/stores/DetectAccountBalance"));
 var _utils2 = require("@subwallet/extension-base/utils");
@@ -18,6 +16,8 @@ var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
 var _i18next = require("i18next");
 var _rxjs = require("rxjs");
 var _util = require("@polkadot/util");
+var _BalanceMapImpl = require("./BalanceMapImpl");
+var _helpers = require("./helpers");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -26,56 +26,127 @@ var _util = require("@polkadot/util");
  * @class
 */
 class BalanceService {
+  balanceUpdateCache = [];
+  startPromiseHandler = (0, _utils2.createPromiseHandler)();
+  stopPromiseHandler = (0, _utils2.createPromiseHandler)();
+  status = _types.ServiceStatus.NOT_INITIALIZED;
+  isReload = false;
   detectAccountBalanceStore = new _DetectAccountBalance.default();
   balanceDetectSubject = new _rxjs.BehaviorSubject({});
   intervalTime = 3 * 60 * 1000;
   cacheTime = 15 * 60 * 1000;
+
   /**
    * @constructor
    * @param {KoniState} state - The state of extension.
    */
   constructor(state) {
     this.state = state;
-    // Todo: Load data from db to balanceSubject
-    // Todo: Start  subscribe balance and data
-    // Todo: Listen change and apply to balanceSubject
-    // Todo: Active/Chain
-    // Todo: Add/remove account
-    // Todo: Add new account
-    // Todo: Optimize get balance for single account and chain with cache
-    // Todo: Move everything of fetching balance to this service
-
-    this.startHandler = (0, _utils2.createPromiseHandler)();
-    const updateBalanceDetectCache = value => {
-      this.startHandler.resolve();
-      this.balanceDetectSubject.next(value || {});
-    };
-    this.getBalanceDetectCache(updateBalanceDetectCache);
-    this.detectAccountBalanceStore.getSubject().subscribe({
-      next: updateBalanceDetectCache
-    });
-    this.startDetectBalance().catch(console.error);
+    this.balanceMap = new _BalanceMapImpl.BalanceMapImpl();
   }
-  async startDetectBalance() {
-    const scanBalance = () => {
-      const addresses = _uiKeyring.default.getPairs().map(account => account.address);
-      const cache = this.balanceDetectSubject.value;
-      const now = Date.now();
-      const needDetectAddresses = [];
-      for (const address of addresses) {
-        if (!cache[address] || now - cache[address] > this.cacheTime) {
-          needDetectAddresses.push(address);
-        }
+
+  /** Init service */
+  async init() {
+    this.status = _types.ServiceStatus.INITIALIZING;
+    await this.state.eventService.waitChainReady;
+    await this.state.eventService.waitAccountReady;
+
+    // Load data from db to balanceSubject
+    await this.loadData();
+    this.status = _types.ServiceStatus.INITIALIZED;
+
+    // Start service
+    await this.start();
+
+    // Handle events
+    this.state.eventService.onLazy(this.handleEvents.bind(this));
+  }
+
+  /** Restore balance map */
+  async loadData() {
+    const backupBalanceData = await this.state.dbService.getStoredBalance();
+    this.balanceMap.updateBalanceItems(backupBalanceData, true);
+  }
+
+  /** Start service */
+  async start() {
+    if (this.status === _types.ServiceStatus.STOPPING) {
+      await this.waitForStopped();
+    }
+    if (this.status === _types.ServiceStatus.STARTED || this.status === _types.ServiceStatus.STARTING) {
+      return await this.waitForStarted();
+    }
+    this.status = _types.ServiceStatus.STARTING;
+    await this.startScanBalance();
+
+    // Run subscribe balance
+    await this.runSubscribeBalances();
+
+    // Update status
+    this.stopPromiseHandler = (0, _utils2.createPromiseHandler)();
+    this.status = _types.ServiceStatus.STARTED;
+    this.startPromiseHandler.resolve();
+  }
+
+  /** Stop service */
+  async stop() {
+    if (this.status === _types.ServiceStatus.STARTING) {
+      await this.waitForStarted();
+    }
+    if (this.status === _types.ServiceStatus.STOPPED || this.status === _types.ServiceStatus.STOPPING) {
+      return await this.waitForStopped();
+    }
+    this.runUnsubscribeBalances();
+    this.stopScanBalance();
+
+    // Update status
+    this.startPromiseHandler = (0, _utils2.createPromiseHandler)();
+    this.status = _types.ServiceStatus.STOPPING;
+    this.stopPromiseHandler.resolve();
+  }
+
+  /** Wait service start */
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+
+  /** Wait service stop */
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+
+  /**
+   *  Handle when data change
+   *  */
+  handleEvents(events, eventTypes) {
+    const removedAddresses = [];
+    let needReload = false;
+    let lazyTime = 2000;
+
+    // Account changed or chain changed (active or inactive)
+    if (eventTypes.includes('account.updateCurrent') || eventTypes.includes('account.add') || eventTypes.includes('chain.updateState') || eventTypes.includes('asset.updateState')) {
+      needReload = true;
+      if (eventTypes.includes('account.updateCurrent')) {
+        lazyTime = 1000;
       }
-      if (needDetectAddresses.length) {
-        this.autoEnableChains(needDetectAddresses).finally(_util.noop);
+    }
+    events.forEach(event => {
+      if (event.type === 'account.remove') {
+        removedAddresses.push(event.data[0]);
+        lazyTime = 1000;
       }
-    };
-    await this.state.eventService.waitAccountReady;
-    await this.state.eventService.waitChainReady;
-    await this.startHandler.promise;
-    scanBalance();
-    setInterval(scanBalance, this.intervalTime);
+    });
+    if (removedAddresses.length > 0) {
+      this.balanceMap.removeBalanceItems([...removedAddresses, _constants.ALL_ACCOUNT_KEY]); // Add all account key to recalculate all account balances
+      needReload = true;
+    }
+    if (needReload) {
+      (0, _utils2.addLazy)('reloadBalanceByEvents', () => {
+        if (!this.isReload) {
+          this.runSubscribeBalances().catch(console.error);
+        }
+      }, lazyTime, undefined, true);
+    }
   }
   getBalanceDetectCache(update) {
     this.detectAccountBalanceStore.get('DetectBalanceCache', value => {
@@ -94,7 +165,7 @@ class BalanceService {
     });
   }
 
-  /* Subscribe token free balance on chain */
+  /** Subscribe token free balance of a address on chain */
   async subscribeTokenFreeBalance(address, chain, tokenSlug, callback) {
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     const chainState = this.state.chainService.getChainStateByKey(chain);
@@ -116,7 +187,12 @@ class BalanceService {
     }
     return new Promise((resolve, reject) => {
       let hasError = true;
-      const unsub = this.subscribeBalance([address], [chain], rs => {
+      const assetMap = this.state.chainService.getAssetRegistry();
+      const chainInfoMap = this.state.chainService.getChainInfoMap();
+      const evmApiMap = this.state.chainService.getEvmApiMap();
+      const substrateApiMap = this.state.chainService.getSubstrateApiMap();
+      const unsub = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+        const rs = result[0];
         if (rs.tokenSlug === tSlug) {
           hasError = false;
           const balance = {
@@ -156,45 +232,131 @@ class BalanceService {
     const [, balance] = await this.subscribeTokenFreeBalance(address, chain, tokenSlug);
     return balance;
   }
-  subscribeBalance(addresses, chains, _callback) {
-    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
-    const chainInfoMap = this.state.chainService.getChainInfoMap();
-    const chainStateMap = this.state.chainService.getChainStateMap();
-    const substrateApiMap = this.state.chainService.getSubstrateApiMap();
-    const evmApiMap = this.state.chainService.getEvmApiMap();
 
-    // Get data from chain or all chains
-    const chainList = chains || Object.keys(chainInfoMap);
-    // Filter active chain only
-    const useChainInfos = chainList.filter(c => chainStateMap[c] && chainStateMap[c].active).map(c => chainInfoMap[c]);
-    const callback = items => {
-      if (items.length) {
-        _callback((0, _group.groupBalance)(items, 'GROUPED', items[0].tokenSlug));
-      }
+  /** Remove balance from the subject object by addresses */
+  removeBalanceByAddresses(addresses) {
+    this.balanceMap.removeBalanceItems([...addresses, _constants.ALL_ACCOUNT_KEY]);
+  }
+
+  /** Remove inactive asset from the balance map */
+  async removeInactiveChainBalances() {
+    const assetSettings = await this.state.chainService.getAssetSettings();
+    this.balanceMap.removeBalanceItemByFilter(item => {
+      return !assetSettings[item.tokenSlug];
+    });
+  }
+  async getBalance(reset) {
+    await this.removeInactiveChainBalances();
+    return {
+      details: this.balanceMap.map,
+      reset
     };
+  }
 
-    // Looping over each chain
-    const unsubList = useChainInfos.map(async chainInfo => {
-      const chainSlug = chainInfo.slug;
-      const useAddresses = (0, _utils._isChainEvmCompatible)(chainInfo) ? evmAddresses : substrateAddresses;
-      if ((0, _utils._isPureEvmChain)(chainInfo)) {
-        const nativeTokenInfo = this.state.getNativeTokenInfo(chainSlug);
-        return (0, _evm.subscribeEVMBalance)(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
-      }
-      if (!useAddresses || useAddresses.length === 0 || _constants._PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
-        return undefined;
+  /** Get stored balance from db */
+  async getStoredBalance(address) {
+    return await this.state.dbService.stores.balance.getBalanceMapByAddresses(address);
+  }
+  async handleResetBalance(forceRefresh) {
+    if (forceRefresh) {
+      this.balanceMap.setData({});
+      await this.state.dbService.stores.balance.clear();
+    } else {
+      await Promise.all([this.removeInactiveChainBalances()]);
+    }
+  }
+
+  /**
+   * Update value for balance map
+   * Note: items must be same tokenSlug */
+  setBalanceItem(items) {
+    if (items.length) {
+      const nowTime = new Date().getTime();
+      for (const item of items) {
+        const balance = {
+          timestamp: nowTime,
+          ...item
+        };
+        this.balanceUpdateCache.push(balance);
       }
-      const networkAPI = await substrateApiMap[chainSlug].isReady;
-      return (0, _substrate.subscribeSubstrateBalance)(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
+      (0, _utils2.addLazy)('updateBalanceStore', () => {
+        const isAllAccount = (0, _utils2.isAccountAll)(this.state.keyringService.currentAccount.address);
+        this.balanceMap.updateBalanceItems(this.balanceUpdateCache, isAllAccount);
+        if (isAllAccount) {
+          this.balanceUpdateCache = [...this.balanceUpdateCache, ...Object.values(this.balanceMap.map[_constants.ALL_ACCOUNT_KEY])];
+        }
+        this.updateBalanceStore(this.balanceUpdateCache);
+        this.balanceUpdateCache = [];
+      }, 300, 1800);
+    }
+  }
+
+  /**
+   * Store balance map to db
+   * */
+  updateBalanceStore(items) {
+    this.state.dbService.updateBulkBalanceStore(items).catch(console.warn);
+  }
+
+  /**
+   * Subscribe balance map with subject object
+   * */
+  subscribeBalanceMap() {
+    return this.balanceMap.mapSubject;
+  }
+
+  /** Subscribe area */
+
+  /** Subscribe balance subscription */
+  async runSubscribeBalances() {
+    await Promise.all([this.state.eventService.waitKeyringReady, this.state.eventService.waitChainReady]);
+    this.runUnsubscribeBalances();
+    const addresses = this.state.getDecodedAddresses();
+    if (!addresses.length) {
+      return;
+    }
+
+    // Reset balance before subscribe
+    await this.handleResetBalance();
+    let cancel = false;
+    const assetMap = this.state.chainService.getAssetRegistry();
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
+    const evmApiMap = this.state.chainService.getEvmApiMap();
+    const substrateApiMap = this.state.chainService.getSubstrateApiMap();
+    const activeChainSlugs = Object.keys(this.state.getActiveChainInfoMap());
+    const assetState = this.state.chainService.subscribeAssetSettings().value;
+    const assets = Object.values(assetMap).filter(asset => {
+      var _assetState$asset$slu;
+      return activeChainSlugs.includes(asset.originChain) && ((_assetState$asset$slu = assetState[asset.slug]) === null || _assetState$asset$slu === void 0 ? void 0 : _assetState$asset$slu.visible);
+    }).map(asset => asset.slug);
+    const unsub = (0, _helpers.subscribeBalance)(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+      !cancel && this.setBalanceItem(result);
     });
-    return () => {
-      unsubList.forEach(subProm => {
-        subProm.then(unsub => {
-          unsub && unsub();
-        }).catch(console.error);
-      });
+    const unsub2 = this.state.subscribeMantaPayBalance();
+    this._unsubscribeBalance = () => {
+      cancel = true;
+      unsub && unsub();
+      unsub2 && unsub2();
     };
   }
+
+  /** Unsubscribe balance subscription */
+  runUnsubscribeBalances() {
+    this._unsubscribeBalance && this._unsubscribeBalance();
+    this._unsubscribeBalance = undefined;
+  }
+
+  /** Reload balance subscription */
+  async reloadBalance() {
+    this.isReload = true;
+    await this.handleResetBalance(true);
+    await this.runSubscribeBalances();
+    await (0, _utils2.waitTimeout)(1800);
+    this.isReload = false;
+  }
+
+  /** Subscribe area */
+
   async autoEnableChains(addresses) {
     this.setBalanceDetectCache(addresses);
     const assetMap = this.state.chainService.getAssetRegistry();
@@ -263,5 +425,45 @@ class BalanceService {
       });
     }
   }
+  async startScanBalance() {
+    var _this$startBalanceDet2;
+    await Promise.all([this.state.eventService.waitAccountReady, this.state.eventService.waitChainReady]);
+    this.stopScanBalance();
+    this.startBalanceDetectCache = (0, _utils2.createPromiseHandler)();
+    const updateBalanceDetectCache = value => {
+      var _this$startBalanceDet;
+      (_this$startBalanceDet = this.startBalanceDetectCache) === null || _this$startBalanceDet === void 0 ? void 0 : _this$startBalanceDet.resolve();
+      this.balanceDetectSubject.next(value || {});
+    };
+    this.getBalanceDetectCache(updateBalanceDetectCache);
+    const subscription = this.detectAccountBalanceStore.getSubject().subscribe({
+      next: updateBalanceDetectCache
+    });
+    this._unsubscribeBalanceDetectCache = subscription.unsubscribe;
+    const scanBalance = () => {
+      const addresses = _uiKeyring.default.getPairs().map(account => account.address);
+      const cache = this.balanceDetectSubject.value;
+      const now = Date.now();
+      const needDetectAddresses = [];
+      for (const address of addresses) {
+        if (!cache[address] || now - cache[address] > this.cacheTime) {
+          needDetectAddresses.push(address);
+        }
+      }
+      if (needDetectAddresses.length) {
+        this.autoEnableChains(needDetectAddresses).finally(_util.noop);
+      }
+    };
+    await ((_this$startBalanceDet2 = this.startBalanceDetectCache) === null || _this$startBalanceDet2 === void 0 ? void 0 : _this$startBalanceDet2.promise);
+    scanBalance();
+    this._intervalScan = setInterval(scanBalance, this.intervalTime);
+  }
+  stopScanBalance() {
+    this._intervalScan && clearInterval(this._intervalScan);
+    this._unsubscribeBalanceDetectCache && this._unsubscribeBalanceDetectCache();
+    this._intervalScan = undefined;
+    this._unsubscribeBalanceDetectCache = undefined;
+    this.startBalanceDetectCache = undefined;
+  }
 }
 exports.BalanceService = BalanceService;

package/cjs/services/chain-service/constants.js

@@ -263,7 +263,8 @@ exports._DEFAULT_ACTIVE_CHAINS = _DEFAULT_ACTIVE_CHAINS;
 const EVM_PASS_CONNECT_STATUS = {
   arbitrum_one: ['*'],
   okxTest: ['*'],
-  astarZkEvm: ['*']
+  astarZkEvm: ['*'],
+  xlayer: ['*']
 };
 exports.EVM_PASS_CONNECT_STATUS = EVM_PASS_CONNECT_STATUS;
 const EVM_REFORMAT_DECIMALS = {

package/cjs/services/chain-service/health-check/utils/asset-info.js

@@ -227,9 +227,7 @@ const getEvmNativeInfo = async api => {
 exports.getEvmNativeInfo = getEvmNativeInfo;
 const getErc20AssetInfo = async (asset, api) => {
   const contractAddress = (0, _utils2._getContractAddressOfToken)(asset);
-  const tokenContract = (0, _web.getERC20Contract)('chain', contractAddress, {
-    chain: api
-  });
+  const tokenContract = (0, _web.getERC20Contract)(contractAddress, api);
   const [_decimals, _symbol, _name] = await Promise.all([
   // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
   tokenContract.methods.decimals().call(),

package/cjs/services/chain-service/index.js

@@ -286,13 +286,7 @@ class ChainService {
     return destinationTokenInfo;
   }
   getAssetByChainAndType(chainSlug, assetTypes) {
-    const result = {};
-    Object.values(this.getAssetRegistry()).forEach(assetInfo => {
-      if (assetTypes.includes(assetInfo.assetType) && assetInfo.originChain === chainSlug) {
-        result[assetInfo.slug] = assetInfo;
-      }
-    });
-    return result;
+    return (0, _utils2.filterAssetsByChainAndType)(this.getAssetRegistry(), chainSlug, assetTypes);
   }
   getSmartContractNfts() {
     const result = [];
@@ -578,8 +572,6 @@ class ChainService {
       const chainState = chainStateMap[originChain];
       if (!assetState) {
         // If this asset not has asset setting, this token is not enabled before (not turned off before)
-        // @ts-ignore
-        // TODO: Merge issue detect balance to define manualTurnOff props
         if (!chainState || !chainState.manualTurnOff) {
           await this.updateAssetSetting(assetSlug, {
             visible: true

package/cjs/services/chain-service/utils/patch.js

@@ -12,7 +12,7 @@ var _crossFetch = _interopRequireDefault(require("cross-fetch"));
 const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
-const ChainListVersion = '0.2.53';
+const ChainListVersion = '0.2.54';
 async function fetchPatchData(slug) {
   try {
     const fetchPromise = (0, _crossFetch.default)(`${fetchDomain}/patch/${ChainListVersion}/${slug}`);

package/cjs/services/earning-service/handlers/liquid-staking/stella-swap.js

@@ -201,7 +201,7 @@ class StellaSwapLiquidStakingPoolHandler extends _base.default {
     const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
     const inputTokenSlug = this.inputAsset;
     const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
-    const inputTokenContract = (0, _web.getERC20Contract)(this.chain, (0, _utils._getContractAddressOfToken)(inputTokenInfo), this.state.getEvmApiMap());
+    const inputTokenContract = (0, _web.getERC20Contract)((0, _utils._getContractAddressOfToken)(inputTokenInfo), evmApi);
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
     const allowanceCall = inputTokenContract.methods.allowance(params.address, (0, _utils._getContractAddressOfToken)(derivativeTokenInfo));
     const [allowance, gasPrice] = await Promise.all([
@@ -266,7 +266,7 @@ class StellaSwapLiquidStakingPoolHandler extends _base.default {
     const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
     const derivativeTokenContractAddress = (0, _utils._getContractAddressOfToken)(derivativeTokenInfo);
     const evmApi = this.evmApi;
-    const inputTokenContract = (0, _web.getERC20Contract)(this.chain, (0, _utils._getContractAddressOfToken)(inputTokenInfo), this.state.getEvmApiMap());
+    const inputTokenContract = (0, _web.getERC20Contract)((0, _utils._getContractAddressOfToken)(inputTokenInfo), evmApi);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
     const approveCall = inputTokenContract.methods.approve(derivativeTokenContractAddress, MAX_INT); // TODO: need test

package/cjs/services/storage-service/DatabaseService.js

@@ -15,6 +15,7 @@ var _NominatorMetadata = _interopRequireDefault(require("@subwallet/extension-ba
 var _YieldPoolStore = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/YieldPoolStore"));
 var _YieldPositionStore = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/YieldPositionStore"));
 var _utils = require("@subwallet/extension-base/utils");
+var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
 var _dexieExportImport = require("dexie-export-import");
 var _util = require("@polkadot/util");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
@@ -71,7 +72,15 @@ class DatabaseService {
 
   // Balance
   async getStoredBalance() {
-    return this.stores.balance.table.toArray();
+    const addresses = _uiKeyring.default.getPairs().map(_ref => {
+      let {
+        address
+      } = _ref;
+      return address;
+    });
+
+    // Filter not exist address
+    return this.stores.balance.table.filter(obj => addresses.includes(obj.address)).toArray();
   }
   async updateBalanceStore(item) {
     if (item.state === _KoniTypes.APIItemState.READY) {

package/cjs/utils/asset.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterAssetsByChainAndType = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const filterAssetsByChainAndType = (chainAssetMap, chain, assetTypes) => {
+  const result = {};
+  Object.values(chainAssetMap).forEach(assetInfo => {
+    if (assetTypes.includes(assetInfo.assetType) && assetInfo.originChain === chain) {
+      result[assetInfo.slug] = assetInfo;
+    }
+  });
+  return result;
+};
+exports.filterAssetsByChainAndType = filterAssetsByChainAndType;

package/cjs/utils/index.js

@@ -104,6 +104,18 @@ Object.keys(_array).forEach(function (key) {
     }
   });
 });
+var _asset = require("./asset");
+Object.keys(_asset).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _asset[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _asset[key];
+    }
+  });
+});
 var _environment = require("./environment");
 Object.keys(_environment).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/koni/api/tokens/evm/balance.d.ts

@@ -1,2 +1,2 @@
 import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
-export declare function getEVMBalance(networkKey: string, addresses: string[], evmApiMap: Record<string, _EvmApi>): Promise<string[]>;
+export declare function getEVMBalance(networkKey: string, addresses: string[], web3Api: _EvmApi): Promise<string[]>;

package/koni/api/tokens/evm/balance.js

@@ -1,8 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-export async function getEVMBalance(networkKey, addresses, evmApiMap) {
-  const web3Api = evmApiMap[networkKey];
+export async function getEVMBalance(networkKey, addresses, web3Api) {
   return await Promise.all(addresses.map(async address => {
     try {
       return await web3Api.api.eth.getBalance(address);

package/koni/api/tokens/evm/transfer.d.ts

@@ -11,7 +11,7 @@ interface HandleTransferBalanceResultProps {
     updateState?: (promise: Partial<ExternalRequestPromise>) => void;
 }
 export declare const handleTransferBalanceResult: ({ callback, changeValue, networkKey, receipt, response, updateState }: HandleTransferBalanceResultProps) => void;
-export declare function getEVMTransactionObject(chainInfo: _ChainInfo, from: string, to: string, value: string, transferAll: boolean, evmApiMap: Record<string, _EvmApi>): Promise<[TransactionConfig, string]>;
-export declare function getERC20TransactionObject(assetAddress: string, chainInfo: _ChainInfo, from: string, to: string, value: string, transferAll: boolean, evmApiMap: Record<string, _EvmApi>): Promise<[TransactionConfig, string]>;
+export declare function getEVMTransactionObject(chainInfo: _ChainInfo, from: string, to: string, value: string, transferAll: boolean, web3Api: _EvmApi): Promise<[TransactionConfig, string]>;
+export declare function getERC20TransactionObject(assetAddress: string, chainInfo: _ChainInfo, from: string, to: string, value: string, transferAll: boolean, evmApi: _EvmApi): Promise<[TransactionConfig, string]>;
 export declare function getERC721Transaction(web3Api: _EvmApi, chain: string, contractAddress: string, senderAddress: string, recipientAddress: string, tokenId: string): Promise<TransactionConfig>;
 export {};

package/koni/api/tokens/evm/transfer.js

@@ -34,10 +34,9 @@ export const handleTransferBalanceResult = ({
   });
   callback(response);
 };
-export async function getEVMTransactionObject(chainInfo, from, to, value, transferAll, evmApiMap) {
+export async function getEVMTransactionObject(chainInfo, from, to, value, transferAll, web3Api) {
   var _priority$maxFeePerGa, _priority$maxPriority;
   const networkKey = chainInfo.slug;
-  const web3Api = evmApiMap[networkKey];
   const priority = await calculateGasFeeParams(web3Api, networkKey);
   const transactionObject = {
     to: to,
@@ -63,11 +62,10 @@ export async function getEVMTransactionObject(chainInfo, from, to, value, transf
   }
   return [transactionObject, transactionObject.value.toString()];
 }
-export async function getERC20TransactionObject(assetAddress, chainInfo, from, to, value, transferAll, evmApiMap) {
+export async function getERC20TransactionObject(assetAddress, chainInfo, from, to, value, transferAll, evmApi) {
   var _priority$maxFeePerGa2, _priority$maxPriority2;
   const networkKey = chainInfo.slug;
-  const evmApi = evmApiMap[networkKey];
-  const erc20Contract = getERC20Contract(networkKey, assetAddress, evmApiMap);
+  const erc20Contract = getERC20Contract(assetAddress, evmApi);
   let freeAmount = new BigN(0);
   let transferValue = value;
   if (transferAll) {

package/koni/api/tokens/evm/web3.d.ts

@@ -1,3 +1,3 @@
 import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
 import { Contract } from 'web3-eth-contract';
-export declare const getERC20Contract: (networkKey: string, assetAddress: string, evmApiMap: Record<string, _EvmApi>, options?: {}) => Contract;
+export declare const getERC20Contract: (assetAddress: string, evmApi: _EvmApi, options?: {}) => Contract;

package/koni/api/tokens/evm/web3.js

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { _ERC20_ABI } from '@subwallet/extension-base/services/chain-service/helper';
-export const getERC20Contract = (networkKey, assetAddress, evmApiMap, options = {}) => {
+export const getERC20Contract = (assetAddress, evmApi, options = {}) => {
   // @ts-ignore
   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
-  return new evmApiMap[networkKey].api.eth.Contract(_ERC20_ABI, assetAddress, options);
+  return new evmApi.api.eth.Contract(_ERC20_ABI, assetAddress, options);
 };