@subwallet/extension-base 1.0.2-3 → 1.0.4-0

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

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PriceService = void 0;
 var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/services/base/types");
 var _coingecko = require("@subwallet/extension-base/services/price-service/coingecko");
+var _promise = require("@subwallet/extension-base/utils/promise");
 var _rxjs = require("rxjs");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -20,34 +22,14 @@ class PriceService {
   priceSubject = new _rxjs.BehaviorSubject(DEFAULT_PRICE_SUBJECT);
   priceIds = new Set();
   constructor(dbService, eventService, chainService) {
+    this.status = _types.ServiceStatus.NOT_INITIALIZED;
     this.dbService = dbService;
     this.eventService = eventService;
     this.chainService = chainService;
-
-    // Fetch data from storage
-    this.getPrice().catch(console.error);
-    const eventHandler = () => {
-      const newPriceIds = this.getPriceIds();
-
-      // Compare two set newPriceIds and this.priceIds
-      if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
-        this.priceIds = newPriceIds;
-        this.refreshPriceData(this.priceIds);
-      }
-    };
-    this.eventService.waitAssetReady.then(() => {
-      this.refreshPriceData();
-      this.eventService.on('asset.updateState', eventHandler);
-      this.eventService.on('asset.updateState', eventHandler);
-    }).catch(console.error);
+    this.init().catch(console.error);
   }
   async getPrice() {
-    const isReady = this.priceSubject.value.ready;
-    if (!isReady) {
-      const data = await this.dbService.getPriceStore();
-      this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);
-    }
-    return this.priceSubject.value;
+    return Promise.resolve(this.priceSubject.value);
   }
   getPriceSubject() {
     return this.priceSubject;
@@ -71,5 +53,71 @@ class PriceService {
     }).catch(console.error);
     this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), _constants.CRON_REFRESH_PRICE_INTERVAL);
   }
+  async init() {
+    this.status = _types.ServiceStatus.INITIALIZING;
+    // Fetch data from storage
+    await this.loadData();
+    const eventHandler = () => {
+      const newPriceIds = this.getPriceIds();
+
+      // Compare two set newPriceIds and this.priceIds
+      if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
+        this.priceIds = newPriceIds;
+        this.refreshPriceData(this.priceIds);
+      }
+    };
+    await this.eventService.waitAssetReady;
+    this.status = _types.ServiceStatus.INITIALIZED;
+    this.eventService.on('asset.updateState', eventHandler);
+    this.eventService.on('asset.updateState', eventHandler);
+  }
+  async loadData() {
+    const data = await this.dbService.getPriceStore();
+    this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);
+  }
+  async persistData() {
+    await this.dbService.updatePriceStore(this.priceSubject.value).catch(console.error);
+  }
+  startPromiseHandler = (0, _promise.createPromiseHandler)();
+  async start() {
+    console.debug('Start price service');
+    try {
+      this.startPromiseHandler = (0, _promise.createPromiseHandler)();
+      this.status = _types.ServiceStatus.STARTING;
+      await this.startCron();
+      this.status = _types.ServiceStatus.STARTED;
+      this.startPromiseHandler.resolve();
+    } catch (e) {
+      this.startPromiseHandler.reject(e);
+    }
+  }
+  async startCron() {
+    this.refreshPriceData();
+    return Promise.resolve();
+  }
+  stopPromiseHandler = (0, _promise.createPromiseHandler)();
+  async stop() {
+    console.debug('Stop price service');
+    try {
+      this.status = _types.ServiceStatus.STOPPING;
+      this.stopPromiseHandler = (0, _promise.createPromiseHandler)();
+      await this.stopCron();
+      await this.persistData();
+      this.status = _types.ServiceStatus.STOPPED;
+      this.stopPromiseHandler.resolve();
+    } catch (e) {
+      this.stopPromiseHandler.reject(e);
+    }
+  }
+  stopCron() {
+    clearTimeout(this.refreshTimeout);
+    return Promise.resolve(undefined);
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
 }
 exports.PriceService = PriceService;

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

@@ -133,6 +133,16 @@ class DatabaseService {
     const cleanedHistory = histories.filter(x => x && x.address && x.chain && x.extrinsicHash);
     return this.stores.transaction.bulkUpsert(cleanedHistory);
   }
+  async updateHistoryByNewExtrinsicHash(extrinsicHash, updateData) {
+    // this.logger.log('Updating transaction histories');
+    const canUpdate = updateData && extrinsicHash;
+    if (!canUpdate) {
+      return;
+    }
+    return this.stores.transaction.updateWithQuery({
+      extrinsicHash
+    }, updateData);
+  }
 
   // NFT Collection
   async addNftCollection(collection) {

package/cjs/services/storage-service/db-stores/Transaction.js

@@ -36,16 +36,12 @@ class TransactionStore extends _BaseStoreWithAddressAndChain.default {
   }
   async bulkUpsert(records) {
     await this.table.bulkPut(records);
-
-    // await Promise.all(records.map((record) => {
-    //   return this.table.where({
-    //     chain: record.chain,
-    //     address: record.address,
-    //     extrinsicHash: record.extrinsicHash
-    //   }).filter((item) => (item.origin === 'app' && record.origin !== 'app'))
-    //     .delete();
-    // }));
-
+    return true;
+  }
+  async updateWithQuery(query, update) {
+    await this.table.where(query).modify(record => {
+      return Object.assign(record, update);
+    });
     return true;
   }
 }

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

@@ -44,7 +44,7 @@ class TransactionService {
     return Object.values(this.transactions);
   }
   get processingTransactions() {
-    return this.allTransactions.filter(t => t.status === _KoniTypes.ExtrinsicStatus.PENDING || t.status === _KoniTypes.ExtrinsicStatus.PROCESSING);
+    return this.allTransactions.filter(t => t.status === _KoniTypes.ExtrinsicStatus.QUEUED || t.status === _KoniTypes.ExtrinsicStatus.PROCESSING);
   }
   getTransaction(id) {
     return this.transactions[id];
@@ -164,6 +164,7 @@ class TransactionService {
   }
   fillTransactionDefaultInfo(transaction) {
     const isInternal = !transaction.url;
+    const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, isInternal);
     return {
       ...transaction,
       createdAt: new Date(),
@@ -171,10 +172,10 @@ class TransactionService {
       errors: transaction.errors || [],
       warnings: transaction.warnings || [],
       url: transaction.url || _constants2.EXTENSION_REQUEST_URL,
-      status: _KoniTypes.ExtrinsicStatus.PENDING,
+      status: _KoniTypes.ExtrinsicStatus.QUEUED,
       isInternal,
-      id: (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, isInternal),
-      extrinsicHash: ''
+      id: transactionId,
+      extrinsicHash: transactionId
     };
   }
   async addTransaction(inputTransaction) {
@@ -187,8 +188,6 @@ class TransactionService {
     this.transactionSubject.next({
       ...transactions
     });
-
-    // Send transaction
     return await this.sendTransaction(transaction);
   }
   generateBeforeHandleResponseErrors(errors) {
@@ -215,7 +214,8 @@ class TransactionService {
     validatedTransaction.warnings = [];
     const emitter = await this.addTransaction(validatedTransaction);
     await new Promise(resolve => {
-      emitter.on('extrinsicHash', data => {
+      emitter.on('signed', data => {
+        validatedTransaction.id = data.id;
         validatedTransaction.extrinsicHash = data.extrinsicHash;
         resolve();
       });
@@ -231,6 +231,12 @@ class TransactionService {
   async sendTransaction(transaction) {
     // Send Transaction
     const emitter = transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : await this.signAndSendEvmTransaction(transaction);
+    emitter.on('signed', data => {
+      this.onSigned(data);
+    });
+    emitter.on('send', data => {
+      this.onSend(data);
+    });
     emitter.on('extrinsicHash', data => {
       this.onHasTransactionHash(data);
     });
@@ -283,7 +289,8 @@ class TransactionService {
       to: '',
       chainType: transaction.chainType,
       address: transaction.address,
-      status: _KoniTypes.ExtrinsicStatus.PROCESSING,
+      status: transaction.status,
+      transactionId: transaction.id,
       extrinsicHash: transaction.extrinsicHash,
       time: transaction.createdAt.getTime(),
       fee: transaction.estimateFee,
@@ -426,8 +433,14 @@ class TransactionService {
           break;
         }
       case _KoniTypes.ExtrinsicType.EVM_EXECUTE:
-        // Todo: Update historyItem.to
-        break;
+        {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const data = (0, _utils2.parseTransactionData)(transaction.data);
+
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+          historyItem.to = (data === null || data === void 0 ? void 0 : data.to) || '';
+          break;
+        }
       case _KoniTypes.ExtrinsicType.UNKNOWN:
         break;
     }
@@ -446,18 +459,39 @@ class TransactionService {
     }
     return [historyItem];
   }
-  onHasTransactionHash(_ref) {
+  onSigned(_ref) {
     let {
-      eventLogs,
-      extrinsicHash,
       id
     } = _ref;
-    // Write processing transaction history
+    console.log(`Transaction "${id}" is signed`);
+  }
+  onSend(_ref2) {
+    let {
+      id
+    } = _ref2;
+    // Update transaction status
     this.updateTransaction(id, {
+      status: _KoniTypes.ExtrinsicStatus.SUBMITTING
+    });
+
+    // Create Input History Transaction History
+    this.historyService.insertHistories(this.transactionToHistories(id)).catch(console.error);
+    console.log(`Transaction "${id}" is sent`);
+  }
+  onHasTransactionHash(_ref3) {
+    let {
+      extrinsicHash,
+      id
+    } = _ref3;
+    // Write processing transaction history
+    const updateData = {
       extrinsicHash,
       status: _KoniTypes.ExtrinsicStatus.PROCESSING
-    });
-    this.historyService.insertHistories(this.transactionToHistories(id, eventLogs)).catch(console.error);
+    };
+    this.updateTransaction(id, updateData);
+
+    // In this case transaction id is the same as extrinsic hash and will change after below update
+    this.historyService.updateHistoryByExtrinsicHash(id, updateData).catch(console.error);
     console.log(`Transaction "${id}" is submitted with hash ${extrinsicHash || ''}`);
   }
   handlePostProcessing(id) {
@@ -486,12 +520,12 @@ class TransactionService {
       this.eventService.emit('transaction.submitStaking', transaction.chain);
     }
   }
-  onSuccess(_ref2) {
+  onSuccess(_ref4) {
     let {
       blockHash,
       blockNumber,
       id
-    } = _ref2;
+    } = _ref4;
     const transaction = this.getTransaction(id);
     this.updateTransaction(id, {
       status: _KoniTypes.ExtrinsicStatus.SUCCESS
@@ -515,24 +549,25 @@ class TransactionService {
     });
     this.eventService.emit('transaction.done', transaction);
   }
-  onFailed(_ref3) {
+  onFailed(_ref5) {
     let {
       blockHash,
       blockNumber,
       errors,
       id
-    } = _ref3;
+    } = _ref5;
     const transaction = this.getTransaction(id);
+    const nextStatus = _KoniTypes.ExtrinsicStatus.FAIL;
     if (transaction) {
       this.updateTransaction(id, {
-        status: _KoniTypes.ExtrinsicStatus.FAIL,
+        status: nextStatus,
         errors
       });
       console.log('Transaction failed', id, transaction.extrinsicHash);
 
       // Write failed transaction history
       this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
-        status: _KoniTypes.ExtrinsicStatus.FAIL,
+        status: nextStatus,
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
@@ -566,14 +601,14 @@ class TransactionService {
     const encoded = _rlp.default.encode(data);
     return (0, _util.u8aToHex)(encoded);
   }
-  async signAndSendEvmTransaction(_ref4) {
+  async signAndSendEvmTransaction(_ref6) {
     let {
       address,
       chain,
       id,
       transaction,
       url
-    } = _ref4;
+    } = _ref6;
     const payload = transaction;
     const evmApi = this.chainService.getEvmApi(chain);
     const chainInfo = this.chainService.getChainInfoByKey(chain);
@@ -633,11 +668,11 @@ class TransactionService {
       errors: [],
       warnings: []
     };
-    this.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(_ref5 => {
+    this.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(_ref7 => {
       let {
         isApproved,
         payload
-      } = _ref5;
+      } = _ref7;
       if (isApproved) {
         let signedTransaction;
         if (!payload) {
@@ -654,6 +689,12 @@ class TransactionService {
           }
           signedTransaction = signed;
         }
+
+        // Emit signed event
+        emitter.emit('signed', eventData);
+
+        // Send transaction
+        emitter.emit('send', eventData); // This event is needed after sending transaction with queue
         signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
           eventData.extrinsicHash = hash;
           emitter.emit('extrinsicHash', eventData);
@@ -680,20 +721,19 @@ class TransactionService {
     });
     return emitter;
   }
-  signAndSendSubstrateTransaction(_ref6) {
+  signAndSendSubstrateTransaction(_ref8) {
     let {
       address,
       id,
       transaction,
       url
-    } = _ref6;
+    } = _ref8;
     const emitter = new _eventemitter.default();
     const eventData = {
       id,
       errors: [],
       warnings: []
     };
-    console.debug(address, transaction);
     transaction.signAsync(address, {
       signer: {
         signPayload: async payload => {
@@ -705,6 +745,11 @@ class TransactionService {
         }
       }
     }).then(rs => {
+      // Emit signed event
+      emitter.emit('signed', eventData);
+
+      // Send transaction
+      emitter.emit('send', eventData); // This event is needed after sending transaction with queue
       rs.send(txState => {
         // handle events, logs, history
         if (!txState || !txState.status) {
@@ -720,20 +765,20 @@ class TransactionService {
         if (txState.status.isFinalized) {
           eventData.eventLogs = txState.events;
           // TODO: push block hash and block number into eventData
-          txState.events.filter(_ref7 => {
+          txState.events.filter(_ref9 => {
             let {
               event: {
                 section
               }
-            } = _ref7;
+            } = _ref9;
             return section === 'system';
-          }).forEach(_ref8 => {
+          }).forEach(_ref10 => {
             let {
               event: {
                 method,
                 data: [error]
               }
-            } = _ref8;
+            } = _ref10;
             if (method === 'ExtrinsicFailed') {
               eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
               emitter.emit('error', eventData);

package/cjs/services/transaction-service/utils.js

@@ -15,15 +15,17 @@ function parseTransactionData(data) {
   return data;
 }
 function getTransactionLink(chainInfo, extrinsicHash) {
-  const explorerLink = (0, _utils._getBlockExplorerFromChain)(chainInfo);
-  if ((0, _utils._isPureEvmChain)(chainInfo)) {
-    if (explorerLink) {
-      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}tx/${extrinsicHash}`;
-    }
-  } else {
+  if (extrinsicHash.startsWith('0x')) {
     const explorerLink = (0, _utils._getBlockExplorerFromChain)(chainInfo);
-    if (explorerLink) {
-      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${extrinsicHash}`;
+    if ((0, _utils._isPureEvmChain)(chainInfo)) {
+      if (explorerLink) {
+        return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}tx/${extrinsicHash}`;
+      }
+    } else {
+      const explorerLink = (0, _utils._getBlockExplorerFromChain)(chainInfo);
+      if (explorerLink) {
+        return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${extrinsicHash}`;
+      }
     }
   }
   return undefined;

package/cjs/utils/promise.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPromiseHandler = createPromiseHandler;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function createPromiseHandler() {
+  let _resolve = () => {
+    console.warn('This promise handler is not implemented');
+  };
+  let _reject = () => {
+    console.warn('This promise handler is not implemented');
+  };
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    resolve: _resolve,
+    reject: _reject,
+    promise
+  };
+}

package/koni/background/handlers/Extension.d.ts

@@ -184,5 +184,6 @@ export default class KoniExtension {
     private subscribeTransactions;
     private subscribeNotifications;
     private reloadCron;
+    private getLogoMap;
     handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
 }

package/koni/background/handlers/Extension.js

@@ -2814,6 +2814,13 @@ export default class KoniExtension {
     }
     return Promise.resolve(false);
   }
+  async getLogoMap() {
+    const [chainLogoMap, assetLogoMap] = await Promise.all([this.#koniState.chainService.getChainLogoMap(), this.#koniState.chainService.getAssetLogoMap()]);
+    return {
+      chainLogoMap,
+      assetLogoMap
+    };
+  }
 
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
@@ -3173,6 +3180,8 @@ export default class KoniExtension {
         return this.subscribeNotifications(id, port);
       case 'pri(cron.reload)':
         return await this.reloadCron(request);
+      case 'pri(settings.getLogoMaps)':
+        return await this.getLogoMap();
 
       // Default
       default:

package/koni/background/handlers/State.js

@@ -211,6 +211,8 @@ export default class KoniState {
   onReady() {
     this.subscription.start();
     this.cron.start();
+    this.historyService.start().catch(console.error);
+    this.priceService.start().catch(console.error);
     this.ready = true;
     this.logger.log('State is ready');
   }
@@ -556,7 +558,8 @@ export default class KoniState {
           assetType: tokenInfo.type,
           metadata: _parseMetadataForSmartContractAsset(tokenInfo.contractAddress),
           multiChainAsset: null,
-          hasValue: _isChainTestNet(this.chainService.getChainInfoByKey(tokenInfo.originChain))
+          hasValue: _isChainTestNet(this.chainService.getChainInfoByKey(tokenInfo.originChain)),
+          icon: ''
         });
         return isApproved;
       } else {
@@ -1321,11 +1324,15 @@ export default class KoniState {
     this.cron.stop();
     this.subscription.stop();
     await this.pauseAllNetworks(undefined, 'IDLE mode');
+    await this.historyService.stop();
+    await this.priceService.stop();
   }
   async wakeup() {
     await this.resumeAllNetworks();
     this.cron.start();
     this.subscription.start();
+    await this.historyService.start();
+    await this.priceService.start();
   }
   cancelSubscription(id) {
     if (isSubscriptionRunning(id)) {

package/koni/background/subscription.d.ts

@@ -1,4 +1,5 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ChainStakingMetadata } from '@subwallet/extension-base/background/KoniTypes';
 import { _ChainState, _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import KoniState from './handlers/State';
@@ -26,6 +27,7 @@ export declare class KoniSubscription {
     initNftSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>): void;
     subscribeStakingReward(address: string): Promise<void>;
     subscribeStakingRewardFastInterval(address: string): Promise<void>;
+    fetchingStakingFromApi(): Promise<Record<string, ChainStakingMetadata>>;
     fetchChainStakingMetadata(chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>): Promise<void>;
     fetchNominatorMetadata(currentAddress: string, chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>): Promise<void>;
 }

package/koni/background/subscription.js

@@ -12,6 +12,7 @@ import { nftHandler } from '@subwallet/extension-base/koni/background/handlers';
 import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _isChainEnabled, _isChainEvmCompatible, _isChainSupportSubstrateStaking, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { COMMON_RELOAD_EVENTS } from '@subwallet/extension-base/services/event-service/types';
+import axios from 'axios';
 import { logger as createLogger } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 export class KoniSubscription {
@@ -223,6 +224,17 @@ export class KoniSubscription {
     const result = [...poolingStakingRewards, ...amplitudeUnclaimedStakingRewards];
     this.state.updateStakingReward(result, 'fastInterval');
   }
+  async fetchingStakingFromApi() {
+    try {
+      const response = await axios.get('https://staking-data.subwallet.app/api/staking/get');
+      if (response.status === 200) {
+        return response.data;
+      }
+    } catch (e) {
+      this.logger.error(e);
+    }
+    return {};
+  }
   async fetchChainStakingMetadata(chainInfoMap, chainStateMap, substrateApiMap) {
     const filteredChainInfoMap = {};
     Object.values(chainInfoMap).forEach(chainInfo => {
@@ -234,9 +246,18 @@ export class KoniSubscription {
     if (Object.values(filteredChainInfoMap).length === 0) {
       return;
     }
+
+    // Fetch data from helper API
+    const dataFromApi = await this.fetchingStakingFromApi();
     await Promise.all(Object.values(filteredChainInfoMap).map(async chainInfo => {
-      const chainStakingMetadata = await getChainStakingMetadata(chainInfo, substrateApiMap[chainInfo.slug]);
-      this.state.updateChainStakingMetadata(chainStakingMetadata);
+      // Use fetch API data if available
+      if (dataFromApi[chainInfo.slug]) {
+        this.state.updateChainStakingMetadata(dataFromApi[chainInfo.slug]);
+      } else {
+        console.warn('Not found staking data from api', chainInfo.slug);
+        const chainStakingMetadata = await getChainStakingMetadata(chainInfo, substrateApiMap[chainInfo.slug]);
+        this.state.updateChainStakingMetadata(chainStakingMetadata);
+      }
     }));
   }
   async fetchNominatorMetadata(currentAddress, chainInfoMap, chainStateMap, substrateApiMap) {