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

package/services/balance-service/index.d.ts

@@ -1,17 +1,50 @@
-import { AmountData } from '@subwallet/extension-base/background/KoniTypes';
+import { AmountData, DetectBalanceCache } from '@subwallet/extension-base/background/KoniTypes';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
-import { BalanceItem } from '@subwallet/extension-base/types';
+import { ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
+import { EventItem, EventType } from '@subwallet/extension-base/services/event-service/types';
+import { BalanceItem, BalanceJson } from '@subwallet/extension-base/types';
+import { PromiseHandler } from '@subwallet/extension-base/utils';
+import { BehaviorSubject } from 'rxjs';
 /**
  * Balance service
  * @class
 */
-export declare class BalanceService {
+export declare class BalanceService implements StoppableServiceInterface {
     private state;
+    private balanceMap;
+    private balanceUpdateCache;
+    startPromiseHandler: PromiseHandler<void>;
+    stopPromiseHandler: PromiseHandler<void>;
+    status: ServiceStatus;
+    private isReload;
+    private readonly detectAccountBalanceStore;
+    private readonly balanceDetectSubject;
+    private readonly intervalTime;
+    private readonly cacheTime;
     /**
      * @constructor
      * @param {KoniState} state - The state of extension.
      */
     constructor(state: KoniState);
+    /** Init service */
+    init(): Promise<void>;
+    /** Restore balance map */
+    loadData(): Promise<void>;
+    /** Start service */
+    start(): Promise<void>;
+    /** Stop service */
+    stop(): Promise<void>;
+    /** Wait service start */
+    waitForStarted(): Promise<void>;
+    /** Wait service stop */
+    waitForStopped(): Promise<void>;
+    /**
+     *  Handle when data change
+     *  */
+    handleEvents(events: EventItem<EventType>[], eventTypes: EventType[]): void;
+    getBalanceDetectCache(update: (value: DetectBalanceCache) => void): void;
+    setBalanceDetectCache(addresses: string[]): void;
+    /** Subscribe token free balance of a address on chain */
     subscribeTokenFreeBalance(address: string, chain: string, tokenSlug: string | undefined, callback?: (rs: AmountData) => void): Promise<[() => void, AmountData]>;
     /**
      * @public
@@ -24,5 +57,39 @@ export declare class BalanceService {
      * @return {Promise<AmountData>} - Free token balance of address on chain
     */
     getTokenFreeBalance(address: string, chain: string, tokenSlug?: string): Promise<AmountData>;
-    subscribeBalance(addresses: string[], chains: string[] | null, _callback: (rs: BalanceItem) => void): () => void;
+    /** Remove balance from the subject object by addresses */
+    removeBalanceByAddresses(addresses: string[]): void;
+    /** Remove inactive asset from the balance map */
+    removeInactiveChainBalances(): Promise<void>;
+    getBalance(reset?: boolean): Promise<BalanceJson>;
+    /** Get stored balance from db */
+    getStoredBalance(address: string): Promise<BalanceItem[]>;
+    handleResetBalance(forceRefresh?: boolean): Promise<void>;
+    /**
+     * Update value for balance map
+     * Note: items must be same tokenSlug */
+    setBalanceItem(items: BalanceItem[]): void;
+    /**
+     * Store balance map to db
+     * */
+    private updateBalanceStore;
+    /**
+     * Subscribe balance map with subject object
+     * */
+    subscribeBalanceMap(): BehaviorSubject<import("@subwallet/extension-base/types").BalanceMap>;
+    /** Subscribe area */
+    private _unsubscribeBalance;
+    /** Subscribe balance subscription */
+    runSubscribeBalances(): Promise<void>;
+    /** Unsubscribe balance subscription */
+    runUnsubscribeBalances(): void;
+    /** Reload balance subscription */
+    reloadBalance(): Promise<void>;
+    /** Subscribe area */
+    autoEnableChains(addresses: string[]): Promise<void>;
+    private _intervalScan;
+    private _unsubscribeBalanceDetectCache;
+    private startBalanceDetectCache;
+    private startScanBalance;
+    private stopScanBalance;
 }

package/services/balance-service/index.js

@@ -3,36 +3,163 @@
 
 import { BalanceError } from '@subwallet/extension-base/background/errors/BalanceError';
 import { BalanceErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { groupBalance } from '@subwallet/extension-base/services/balance-service/helpers/group';
-import { subscribeEVMBalance } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/evm';
-import { subscribeSubstrateBalance } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/substrate';
-import { _PURE_EVM_CHAINS } from '@subwallet/extension-base/services/chain-service/constants';
-import { _getChainNativeTokenSlug, _isChainEvmCompatible, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
-import { categoryAddresses } from '@subwallet/extension-base/utils';
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { _getChainNativeTokenSlug } from '@subwallet/extension-base/services/chain-service/utils';
+import DetectAccountBalanceStore from '@subwallet/extension-base/stores/DetectAccountBalance';
+import { addLazy, createPromiseHandler, isAccountAll, waitTimeout } from '@subwallet/extension-base/utils';
+import keyring from '@subwallet/ui-keyring';
 import { t } from 'i18next';
+import { BehaviorSubject } from 'rxjs';
+import { noop } from '@polkadot/util';
+import { BalanceMapImpl } from "./BalanceMapImpl.js";
+import { subscribeBalance } from "./helpers/index.js";
 
 /**
  * Balance service
  * @class
 */
 export class BalanceService {
+  balanceUpdateCache = [];
+  startPromiseHandler = createPromiseHandler();
+  stopPromiseHandler = createPromiseHandler();
+  status = ServiceStatus.NOT_INITIALIZED;
+  isReload = false;
+  detectAccountBalanceStore = new DetectAccountBalanceStore();
+  balanceDetectSubject = new 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.balanceMap = new BalanceMapImpl();
+  }
+
+  /** Init service */
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    await this.state.eventService.waitChainReady;
+    await this.state.eventService.waitAccountReady;
+
+    // Load data from db to balanceSubject
+    await this.loadData();
+    this.status = 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 === ServiceStatus.STOPPING) {
+      await this.waitForStopped();
+    }
+    if (this.status === ServiceStatus.STARTED || this.status === ServiceStatus.STARTING) {
+      return await this.waitForStarted();
+    }
+    this.status = ServiceStatus.STARTING;
+    await this.startScanBalance();
+
+    // Run subscribe balance
+    await this.runSubscribeBalances();
+
+    // Update status
+    this.stopPromiseHandler = createPromiseHandler();
+    this.status = ServiceStatus.STARTED;
+    this.startPromiseHandler.resolve();
+  }
+
+  /** Stop service */
+  async stop() {
+    if (this.status === ServiceStatus.STARTING) {
+      await this.waitForStarted();
+    }
+    if (this.status === ServiceStatus.STOPPED || this.status === ServiceStatus.STOPPING) {
+      return await this.waitForStopped();
+    }
+    this.runUnsubscribeBalances();
+    this.stopScanBalance();
+
+    // Update status
+    this.startPromiseHandler = createPromiseHandler();
+    this.status = 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;
+      }
+    }
+    events.forEach(event => {
+      if (event.type === 'account.remove') {
+        removedAddresses.push(event.data[0]);
+        lazyTime = 1000;
+      }
+    });
+    if (removedAddresses.length > 0) {
+      this.balanceMap.removeBalanceItems([...removedAddresses, ALL_ACCOUNT_KEY]); // Add all account key to recalculate all account balances
+      needReload = true;
+    }
+    if (needReload) {
+      addLazy('reloadBalanceByEvents', () => {
+        if (!this.isReload) {
+          this.runSubscribeBalances().catch(console.error);
+        }
+      }, lazyTime, undefined, true);
+    }
+  }
+  getBalanceDetectCache(update) {
+    this.detectAccountBalanceStore.get('DetectBalanceCache', value => {
+      update(value);
+    });
+  }
+  setBalanceDetectCache(addresses) {
+    this.detectAccountBalanceStore.get('DetectBalanceCache', value => {
+      const rs = {
+        ...value
+      };
+      for (const address of addresses) {
+        rs[address] = Date.now();
+      }
+      this.detectAccountBalanceStore.set('DetectBalanceCache', rs);
+    });
   }
 
-  /* 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);
@@ -54,7 +181,12 @@ export 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 = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+        const rs = result[0];
         if (rs.tokenSlug === tSlug) {
           hasError = false;
           const balance = {
@@ -94,43 +226,237 @@ export class BalanceService {
     const [, balance] = await this.subscribeTokenFreeBalance(address, chain, tokenSlug);
     return balance;
   }
-  subscribeBalance(addresses, chains, _callback) {
-    const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
+
+  /** Remove balance from the subject object by addresses */
+  removeBalanceByAddresses(addresses) {
+    this.balanceMap.removeBalanceItems([...addresses, 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
+    };
+  }
+
+  /** 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);
+      }
+      addLazy('updateBalanceStore', () => {
+        const isAllAccount = isAccountAll(this.state.keyringService.currentAccount.address);
+        this.balanceMap.updateBalanceItems(this.balanceUpdateCache, isAllAccount);
+        if (isAllAccount) {
+          this.balanceUpdateCache = [...this.balanceUpdateCache, ...Object.values(this.balanceMap.map[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 chainStateMap = this.state.chainService.getChainStateMap();
-    const substrateApiMap = this.state.chainService.getSubstrateApiMap();
     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 = subscribeBalance(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+      !cancel && this.setBalanceItem(result);
+    });
+    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 waitTimeout(1800);
+    this.isReload = false;
+  }
 
-    // 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(groupBalance(items, 'GROUPED', items[0].tokenSlug));
+  /** Subscribe area */
+
+  async autoEnableChains(addresses) {
+    this.setBalanceDetectCache(addresses);
+    const assetMap = this.state.chainService.getAssetRegistry();
+    const promiseList = addresses.map(address => {
+      return this.state.subscanService.getMultiChainBalance(address).catch(e => {
+        console.error(e);
+        return null;
+      });
+    });
+    const needEnableChains = [];
+    const needActiveTokens = [];
+    const balanceDataList = await Promise.all(promiseList);
+    const currentAssetSettings = await this.state.chainService.getAssetSettings();
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
+    const detectBalanceChainSlugMap = this.state.chainService.detectBalanceChainSlugMap;
+    for (const balanceData of balanceDataList) {
+      if (balanceData) {
+        for (const balanceDatum of balanceData) {
+          var _currentAssetSettings;
+          const {
+            balance,
+            bonded,
+            category,
+            locked,
+            network,
+            symbol
+          } = balanceDatum;
+          const chain = detectBalanceChainSlugMap[network];
+          const chainInfo = chain ? chainInfoMap[chain] : null;
+          const chainState = this.state.chainService.getChainStateByKey(chain);
+          const balanceIsEmpty = (!balance || balance === '0') && (!locked || locked === '0') && (!bonded || bonded === '0');
+          const tokenKey = `${chain}-${category === 'native' ? 'NATIVE' : 'LOCAL'}-${symbol.toUpperCase()}`;
+          const existedKey = Object.keys(assetMap).find(v => v.toLowerCase() === tokenKey.toLowerCase());
+
+          // Cancel if chain is not supported or is testnet
+          if (!chainInfo || chainInfo.isTestnet) {
+            continue;
+          }
+
+          // Cancel is balance is 0
+          if (balanceIsEmpty) {
+            continue;
+          }
+
+          // Cancel is chain is turned off by user
+          if (chainState && chainState.manualTurnOff) {
+            continue;
+          }
+
+          // const a = this.state.chainService.getChainStateByKey(chain);
+
+          if (existedKey && !((_currentAssetSettings = currentAssetSettings[existedKey]) !== null && _currentAssetSettings !== void 0 && _currentAssetSettings.visible)) {
+            needEnableChains.push(chain);
+            needActiveTokens.push(existedKey);
+            currentAssetSettings[existedKey] = {
+              visible: true
+            };
+          }
+        }
       }
+    }
+    if (needActiveTokens.length) {
+      await this.state.chainService.enableChains(needEnableChains);
+      this.state.chainService.setAssetSettings({
+        ...currentAssetSettings
+      });
+    }
+  }
+  async startScanBalance() {
+    var _this$startBalanceDet2;
+    await Promise.all([this.state.eventService.waitAccountReady, this.state.eventService.waitChainReady]);
+    this.stopScanBalance();
+    this.startBalanceDetectCache = 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 || {});
     };
-
-    // Looping over each chain
-    const unsubList = useChainInfos.map(async chainInfo => {
-      const chainSlug = chainInfo.slug;
-      const useAddresses = _isChainEvmCompatible(chainInfo) ? evmAddresses : substrateAddresses;
-      if (_isPureEvmChain(chainInfo)) {
-        const nativeTokenInfo = this.state.getNativeTokenInfo(chainSlug);
-        return subscribeEVMBalance(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
+    this.getBalanceDetectCache(updateBalanceDetectCache);
+    const subscription = this.detectAccountBalanceStore.getSubject().subscribe({
+      next: updateBalanceDetectCache
+    });
+    this._unsubscribeBalanceDetectCache = subscription.unsubscribe;
+    const scanBalance = () => {
+      const addresses = keyring.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 (!useAddresses || useAddresses.length === 0 || _PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
-        return undefined;
+      if (needDetectAddresses.length) {
+        this.autoEnableChains(needDetectAddresses).finally(noop);
       }
-      const networkAPI = await substrateApiMap[chainSlug].isReady;
-      return subscribeSubstrateBalance(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
-    });
-    return () => {
-      unsubList.forEach(subProm => {
-        subProm.then(unsub => {
-          unsub && unsub();
-        }).catch(console.error);
-      });
     };
+    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;
   }
 }

package/services/chain-service/constants.js

@@ -240,7 +240,8 @@ export const _DEFAULT_ACTIVE_CHAINS = [..._DEFAULT_CHAINS, 'vara_network'];
 export const EVM_PASS_CONNECT_STATUS = {
   arbitrum_one: ['*'],
   okxTest: ['*'],
-  astarZkEvm: ['*']
+  astarZkEvm: ['*'],
+  xlayer: ['*']
 };
 export const EVM_REFORMAT_DECIMALS = {
   acala: ['acala_evm', 'karura_evm']

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

@@ -216,9 +216,7 @@ export const getEvmNativeInfo = async api => {
 };
 export const getErc20AssetInfo = async (asset, api) => {
   const contractAddress = _getContractAddressOfToken(asset);
-  const tokenContract = getERC20Contract('chain', contractAddress, {
-    chain: api
-  });
+  const tokenContract = 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/services/chain-service/index.d.ts

@@ -83,7 +83,7 @@ export declare class ChainService {
     initAssetRefMap(): void;
     checkLatestData(): void;
     stopCheckLatestChainData(): void;
-    handleLatestProviderData(latestChainInfo: _ChainInfo[]): void;
+    handleLatestChainData(latestChainInfo: _ChainInfo[]): void;
     handleLatestAssetRef(latestBlockedAssetRefList: string[], latestAssetRefMap: Record<string, _AssetRef> | null): void;
     handleLatestPriceId(latestPriceIds: Record<string, string | null>): void;
     handleLatestAssetData(latestAssetInfo: Record<string, _ChainAsset> | null, latestAssetLogoMap: Record<string, string> | null): void;
@@ -138,4 +138,5 @@ export declare class ChainService {
     upsertMetadata(chain: string, metadata: IMetadataItem): import("dexie").PromiseExtended<unknown>;
     getMetadataByHash(hash: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
     getSubscanChainMap(reverse?: boolean): Record<string, string>;
+    get detectBalanceChainSlugMap(): Record<string, string>;
 }