@subwallet/extension-base 1.2.25-0 → 1.2.26-0

package/services/balance-service/helpers/subscribe/substrate/index.js

@@ -112,29 +112,37 @@ const subscribeWithSystemAccountPallet = async ({
   extrinsicType,
   substrateApi
 }) => {
+  var _substrateApi$api$tx, _substrateApi$api$tx$;
   const systemAccountKey = 'query_system_account';
   const poolMembersKey = 'query_nominationPools_poolMembers';
+  const isNominationPoolMigrated = !!((_substrateApi$api$tx = substrateApi.api.tx) !== null && _substrateApi$api$tx !== void 0 && (_substrateApi$api$tx$ = _substrateApi$api$tx.nominationPools) !== null && _substrateApi$api$tx$ !== void 0 && _substrateApi$api$tx$.migrateDelegation);
   const params = [{
     section: 'query',
     module: systemAccountKey.split('_')[1],
     method: systemAccountKey.split('_')[2],
     args: addresses
-  }, {
-    section: 'query',
-    module: poolMembersKey.split('_')[1],
-    method: poolMembersKey.split('_')[2],
-    args: addresses
   }];
+  if (!isNominationPoolMigrated) {
+    params.push({
+      section: 'query',
+      module: poolMembersKey.split('_')[1],
+      method: poolMembersKey.split('_')[2],
+      args: addresses
+    });
+  }
   const subscription = substrateApi.subscribeDataWithMulti(params, rs => {
     const balances = rs[systemAccountKey];
     const poolMemberInfos = rs[poolMembersKey];
     const items = balances.map((_balance, index) => {
       const balanceInfo = _balance;
-      const poolMemberInfo = poolMemberInfos[index];
-      const nominationPoolBalance = poolMemberInfo ? _getTotalStakeInNominationPool(poolMemberInfo) : BigInt(0);
       const transferableBalance = _getSystemPalletTransferable(balanceInfo, _getChainExistentialDeposit(chainInfo), extrinsicType);
       const totalBalance = _getSystemPalletTotalBalance(balanceInfo);
-      const totalLockedFromTransfer = totalBalance - transferableBalance + nominationPoolBalance;
+      let totalLockedFromTransfer = totalBalance - transferableBalance;
+      if (!isNominationPoolMigrated) {
+        const poolMemberInfo = poolMemberInfos[index];
+        const nominationPoolBalance = poolMemberInfo ? _getTotalStakeInNominationPool(poolMemberInfo) : BigInt(0);
+        totalLockedFromTransfer += nominationPoolBalance;
+      }
       return {
         address: addresses[index],
         tokenSlug: _getChainNativeTokenSlug(chainInfo),

package/services/chain-service/constants.js

@@ -129,7 +129,8 @@ export const _EXPECTED_BLOCK_TIME = {
   manta_network: 12,
   enjin_relaychain: 6,
   availTuringTest: 20,
-  avail_mainnet: 20
+  avail_mainnet: 20,
+  dentnet: 3
 };
 export const _PARACHAIN_INFLATION_DISTRIBUTION = {
   moonbeam: {
@@ -226,6 +227,10 @@ export const _KNOWN_CHAIN_INFLATION_PARAMS = {
     ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
     maxInflation: 0.05,
     minInflation: 0.01
+  },
+  dentnet: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    falloff: 0.5
   }
 };
 

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

@@ -27,12 +27,19 @@ export declare class ChainService {
     private swapRefMapSubject;
     private assetLogoMapSubject;
     private chainLogoMapSubject;
+    private ledgerGenericAllowChainsSubject;
     private assetMapPatch;
     private assetLogoPatch;
     private store;
     private assetSettingSubject;
     private logger;
     constructor(dbService: DatabaseService, eventService: EventService);
+    get value(): {
+        readonly ledgerGenericAllowChains: string[];
+    };
+    get observable(): {
+        readonly ledgerGenericAllowChains: import("rxjs").Observable<string[]>;
+    };
     subscribeSwapRefMap(): Subject<Record<string, _AssetRef>>;
     get xcmRefMap(): Record<string, _AssetRef>;
     get swapRefMap(): Record<string, _AssetRef>;
@@ -92,6 +99,7 @@ export declare class ChainService {
     handleLatestPriceId(latestPriceIds: Record<string, string | null>): void;
     handleLatestAssetData(latestAssetInfo: Record<string, _ChainAsset> | null, latestAssetLogoMap: Record<string, string> | null): void;
     autoEnableTokens(): Promise<void>;
+    handleLatestLedgerGenericAllowChains(latestledgerGenericAllowChains: string[]): void;
     handleLatestData(): void;
     private initApis;
     initSingleApi(slug: string): Promise<boolean>;
@@ -106,6 +114,7 @@ export declare class ChainService {
     private fetchLatestAssetData;
     private fetchLatestPriceIdsData;
     private fetchLatestAssetRef;
+    private fetchLatestLedgerGenericAllowChains;
     private initChains;
     private initAssetRegistry;
     private updateChainStateMapSubscription;

package/services/chain-service/index.js

@@ -18,7 +18,7 @@ import { logger as createLogger } from '@polkadot/util/logger';
 const filterChainInfoMap = (data, ignoredChains) => {
   return Object.fromEntries(Object.entries(data).filter(([slug, info]) => !info.bitcoinInfo && !ignoredChains.includes(slug)));
 };
-const ignoredList = ['bevm', 'bevmTest', 'bevm_testnet', 'layerEdge_testnet', 'merlinEvm', 'botanixEvmTest', 'syscoin_evm', 'syscoin_evm_testnet', 'rollux_evm', 'rollux_testnet', 'boolAlpha', 'boolBeta_testnet', 'core', 'satoshivm', 'satoshivm_testnet'];
+const ignoredList = ['bevm', 'bevmTest', 'bevm_testnet', 'layerEdge_testnet', 'merlinEvm', 'botanixEvmTest', 'syscoin_evm', 'syscoin_evm_testnet', 'rollux_evm', 'rollux_testnet', 'boolAlpha', 'boolBeta_testnet', 'core', 'satoshivm', 'satoshivm_testnet', 'ton', 'ton_testnet'];
 const filterAssetInfoMap = (chainInfo, assets) => {
   return Object.fromEntries(Object.entries(assets).filter(([, info]) => chainInfo[info.originChain]));
 };
@@ -62,6 +62,7 @@ export class ChainService {
   swapRefMapSubject = new Subject();
   assetLogoMapSubject = new BehaviorSubject(AssetLogoMap);
   chainLogoMapSubject = new BehaviorSubject(ChainLogoMap);
+  ledgerGenericAllowChainsSubject = new BehaviorSubject([]);
   assetMapPatch = JSON.stringify({});
   assetLogoPatch = JSON.stringify({});
 
@@ -84,6 +85,22 @@ export class ChainService {
     this.evmChainHandler = new EvmChainHandler(this);
     this.logger = createLogger('chain-service');
   }
+  get value() {
+    const ledgerGenericAllowChains = this.ledgerGenericAllowChainsSubject;
+    return {
+      get ledgerGenericAllowChains() {
+        return ledgerGenericAllowChains.value;
+      }
+    };
+  }
+  get observable() {
+    const ledgerGenericAllowChains = this.ledgerGenericAllowChainsSubject;
+    return {
+      get ledgerGenericAllowChains() {
+        return ledgerGenericAllowChains.asObservable();
+      }
+    };
+  }
   subscribeSwapRefMap() {
     return this.swapRefMapSubject;
   }
@@ -600,6 +617,11 @@ export class ChainService {
       }
     }
   }
+  handleLatestLedgerGenericAllowChains(latestledgerGenericAllowChains) {
+    this.ledgerGenericAllowChainsSubject.next(latestledgerGenericAllowChains);
+    this.eventService.emit('ledger.ready', true);
+    this.logger.log('Finished updating latest ledger generic allow chains');
+  }
   handleLatestData() {
     this.fetchLatestAssetData().then(([latestAssetInfo, latestAssetLogoMap]) => {
       this.eventService.waitAssetReady.then(() => {
@@ -615,6 +637,9 @@ export class ChainService {
     this.fetchLatestPriceIdsData().then(latestPriceIds => {
       this.handleLatestPriceId(latestPriceIds);
     }).catch(console.error);
+    this.fetchLatestLedgerGenericAllowChains().then(latestledgerGenericAllowChains => {
+      this.handleLatestLedgerGenericAllowChains(latestledgerGenericAllowChains);
+    }).catch(console.error);
   }
   async initApis() {
     const chainInfoMap = this.getChainInfoMap();
@@ -870,6 +895,9 @@ export class ChainService {
   async fetchLatestAssetRef() {
     return await Promise.all([fetchStaticData('chain-assets/disabled-xcm-channels'), fetchPatchData('AssetRef.json')]);
   }
+  async fetchLatestLedgerGenericAllowChains() {
+    return (await fetchStaticData('chains/ledger-generic-allow-chains')) || [];
+  }
   async initChains() {
     const storedChainSettings = await this.dbService.getAllChainStore();
     const defaultChainInfoMap = filterChainInfoMap(ChainInfoMap, ignoredList);
@@ -982,7 +1010,7 @@ export class ChainService {
             deprecatedChainMap[storedSlug] = duplicatedDefaultSlug;
             deprecatedChains.push(storedSlug);
           } else {
-            var _storedChainInfo$bitc;
+            var _storedChainInfo$bitc, _storedChainInfo$tonI;
             mergedChainInfoMap[storedSlug] = {
               slug: storedSlug,
               name: storedChainInfo.name,
@@ -991,6 +1019,7 @@ export class ChainService {
               evmInfo: storedChainInfo.evmInfo,
               substrateInfo: storedChainInfo.substrateInfo,
               bitcoinInfo: (_storedChainInfo$bitc = storedChainInfo.bitcoinInfo) !== null && _storedChainInfo$bitc !== void 0 ? _storedChainInfo$bitc : null,
+              tonInfo: (_storedChainInfo$tonI = storedChainInfo.tonInfo) !== null && _storedChainInfo$tonI !== void 0 ? _storedChainInfo$tonI : null,
               isTestnet: storedChainInfo.isTestnet,
               chainStatus: storedChainInfo.chainStatus,
               icon: storedChainInfo.icon,
@@ -1204,6 +1233,7 @@ export class ChainService {
       substrateInfo,
       evmInfo,
       bitcoinInfo: null,
+      tonInfo: null,
       isTestnet: false,
       chainStatus: _ChainStatus.ACTIVE,
       icon: '',

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

@@ -47,10 +47,10 @@ export function _isEqualSmartContractAsset(asset1, asset2) {
   return false;
 }
 export function _isPureEvmChain(chainInfo) {
-  return chainInfo.evmInfo !== null && chainInfo.substrateInfo === null;
+  return !!chainInfo.evmInfo && !chainInfo.substrateInfo;
 }
 export function _isPureSubstrateChain(chainInfo) {
-  return chainInfo.evmInfo === null && chainInfo.substrateInfo !== null;
+  return !chainInfo.evmInfo && !!chainInfo.substrateInfo;
 }
 export function _getOriginChainOfAsset(assetSlug) {
   if (assetSlug.startsWith(_CUSTOM_PREFIX)) {

package/services/earning-service/constants/chains.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export const _STAKING_CHAIN_GROUP = {
-  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin', 'vara_network', 'goldberg_testnet', 'availTuringTest', 'avail_mainnet', 'vara_testnet'],
+  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin', 'vara_network', 'goldberg_testnet', 'availTuringTest', 'avail_mainnet', 'vara_testnet', 'dentnet'],
   para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari', 'manta_network', 'polimec'],
   astar: ['astar', 'shiden', 'shibuya'],
   amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum', 'krest_network'],
@@ -18,7 +18,7 @@ export const _STAKING_CHAIN_GROUP = {
   krest_network: ['krest_network'],
   manta: ['manta_network']
 };
-export const _UPDATED_RUNTIME_STAKING_GROUP = ['kusama', 'polkadot', 'westend', 'availTuringTest', 'avail_mainnet'];
+export const _UPDATED_RUNTIME_STAKING_GROUP = ['kusama', 'polkadot', 'westend', 'availTuringTest', 'avail_mainnet', 'dentnet'];
 export const MaxEraRewardPointsEras = 14;
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment

package/services/earning-service/handlers/native-staking/relay-chain.js

@@ -301,7 +301,7 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
     const endEraForPoints = parseInt(activeEra) - 1;
     const startEraForPoints = Math.max(endEraForPoints - maxEraRewardPointsEras + 1, 0);
     let _eraStakersPromise;
-    if (_UPDATED_RUNTIME_STAKING_GROUP.includes(this.chain)) {
+    if (chainApi.api.query.staking.erasStakersOverview) {
       // todo: review all relaychains later
       _eraStakersPromise = chainApi.api.query.staking.erasStakersOverview.entries(parseInt(currentEra));
     } else {
@@ -318,8 +318,9 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
     const waitingValidatorLedger = {};
     if (_waitingValidatorLedger) {
       waitingValidatorList.forEach((validator, i) => {
-        const validatorLedger = _waitingValidatorLedger[i].toPrimitive();
-        waitingValidatorLedger[validator] = new BigN(validatorLedger.total).toFixed();
+        var _waitingValidatorLedg;
+        const validatorLedger = (_waitingValidatorLedg = _waitingValidatorLedger[i]) === null || _waitingValidatorLedg === void 0 ? void 0 : _waitingValidatorLedg.toPrimitive();
+        waitingValidatorLedger[validator] = new BigN((validatorLedger === null || validatorLedger === void 0 ? void 0 : validatorLedger.total) || 0).toFixed();
       });
     }
     const unlimitedNominatorRewarded = chainApi.api.consts.staking.maxExposurePageSize !== undefined;

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

@@ -17,6 +17,7 @@ export declare class EventService extends EventEmitter<EventRegistry> {
     readonly waitBuyTokenReady: Promise<boolean>;
     readonly waitBuyServiceReady: Promise<boolean>;
     readonly waitEarningReady: Promise<boolean>;
+    readonly waitLedgerReady: Promise<boolean>;
     constructor();
     private generateWaitPromise;
     private setLazyTimeout;

package/services/event-service/index.js

@@ -28,6 +28,7 @@ export class EventService extends EventEmitter {
     this.waitBuyTokenReady = this.generateWaitPromise('buy.tokens.ready');
     this.waitBuyServiceReady = this.generateWaitPromise('buy.services.ready');
     this.waitEarningReady = this.generateWaitPromise('earning.ready');
+    this.waitLedgerReady = this.generateWaitPromise('ledger.ready');
   }
   generateWaitPromise(eventType) {
     return new Promise(resolve => {

package/services/event-service/types.d.ts

@@ -39,6 +39,7 @@ export interface EventRegistry {
     'buy.services.ready': [boolean];
     'earning.ready': [boolean];
     'swap.ready': [boolean];
+    'ledger.ready': [boolean];
 }
 export declare type EventType = keyof EventRegistry;
 export declare const COMMON_RELOAD_EVENTS: EventType[];

package/services/request-service/handler/EvmRequestHandler.js

@@ -22,7 +22,8 @@ export default class EvmRequestHandler {
     switchNetworkRequest: {},
     evmSignatureRequest: {},
     evmSendTransactionRequest: {},
-    evmWatchTransactionRequest: {}
+    evmWatchTransactionRequest: {},
+    errorConnectNetwork: {}
   });
   confirmationsPromiseMap = {};
   constructor(requestService) {

package/services/transaction-service/index.js

@@ -821,6 +821,7 @@ export default class TransactionService {
     const payload = transaction;
     const evmApi = this.state.chainService.getEvmApi(chain);
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
+    const hasError = !!(payload.errors && payload.errors.length > 0);
     const accountPair = keyring.getPair(address);
     const account = {
       address,
@@ -835,9 +836,9 @@ export default class TransactionService {
 
     // Fill contract info
     if (!payload.parseData) {
-      const isToContract = await isContractAddress(payload.to || '', evmApi);
-      payload.isToContract = isToContract;
       try {
+        const isToContract = await isContractAddress(payload.to || '', evmApi);
+        payload.isToContract = isToContract;
         payload.parseData = isToContract ? payload.data ? (await parseContractInput(payload.data || '', payload.to || '', chainInfo)).result : '' : payload.data || '';
       } catch (e) {
         console.warn('Unable to parse contract input data');
@@ -851,11 +852,13 @@ export default class TransactionService {
     // Set unique nonce to avoid transaction errors
     if (!payload.nonce) {
       const evmApi = this.state.chainService.getEvmApi(chain);
-      payload.nonce = await evmApi.api.eth.getTransactionCount(address);
+      if (evmApi.isApiConnected) {
+        payload.nonce = await (evmApi === null || evmApi === void 0 ? void 0 : evmApi.api.eth.getTransactionCount(address));
+      }
     }
     if (!payload.chainId) {
       var _chainInfo$evmInfo$ev, _chainInfo$evmInfo;
-      payload.chainId = (_chainInfo$evmInfo$ev = (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.evmChainId) !== null && _chainInfo$evmInfo$ev !== void 0 ? _chainInfo$evmInfo$ev : 1;
+      payload.chainId = (_chainInfo$evmInfo$ev = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.evmChainId) !== null && _chainInfo$evmInfo$ev !== void 0 ? _chainInfo$evmInfo$ev : 1;
     }
 
     // Autofill from
@@ -864,9 +867,10 @@ export default class TransactionService {
     }
     const isExternal = !!account.isExternal;
     const isInjected = !!account.isInjected;
-
-    // generate hashPayload for EVM transaction
-    payload.hashPayload = this.generateHashPayload(chain, payload);
+    if (!hasError) {
+      // generate hashPayload for EVM transaction
+      payload.hashPayload = this.generateHashPayload(chain, payload);
+    }
     const emitter = new EventEmitter();
     const txObject = {
       nonce: (_payload$nonce = payload.nonce) !== null && _payload$nonce !== void 0 ? _payload$nonce : 0,

package/services/wallet-connect-service/handler/Eip155RequestHandler.js

@@ -4,22 +4,17 @@ import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateF
 // SPDX-License-Identifier: Apache-2.0
 
 import { formatJsonRpcError, formatJsonRpcResult } from '@json-rpc-tools/utils';
-import { getEip155MessageAddress, getWCId, parseRequestParams } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
+import { getWCId, parseRequestParams } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { EIP155_SIGNING_METHODS } from '@subwallet/extension-base/services/wallet-connect-service/types';
-import { isSameAddress } from '@subwallet/extension-base/utils';
 import { getSdkError } from '@walletconnect/utils';
 var _walletConnectService = /*#__PURE__*/_classPrivateFieldLooseKey("walletConnectService");
 var _koniState = /*#__PURE__*/_classPrivateFieldLooseKey("koniState");
-var _checkAccount = /*#__PURE__*/_classPrivateFieldLooseKey("checkAccount");
 var _handleError = /*#__PURE__*/_classPrivateFieldLooseKey("handleError");
 export default class Eip155RequestHandler {
   constructor(koniState, walletConnectService) {
     Object.defineProperty(this, _handleError, {
       value: _handleError2
     });
-    Object.defineProperty(this, _checkAccount, {
-      value: _checkAccount2
-    });
     Object.defineProperty(this, _walletConnectService, {
       writable: true,
       value: void 0
@@ -44,11 +39,8 @@ export default class Eip155RequestHandler {
     const method = request.method;
     const requestSession = _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].getSession(topic);
     const url = requestSession.peer.metadata.url;
-    const sessionAccounts = requestSession.namespaces.eip155.accounts.map(account => account.split(':')[2]);
     if ([EIP155_SIGNING_METHODS.PERSONAL_SIGN, EIP155_SIGNING_METHODS.ETH_SIGN, EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA, EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V3, EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4].includes(method)) {
-      const address = getEip155MessageAddress(method, request.params);
-      _classPrivateFieldLooseBase(this, _checkAccount)[_checkAccount](address, sessionAccounts);
-      _classPrivateFieldLooseBase(this, _koniState)[_koniState].evmSign(getWCId(id), url, method === EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA ? EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4 : method, request.params, sessionAccounts).then(async signature => {
+      _classPrivateFieldLooseBase(this, _koniState)[_koniState].evmSign(getWCId(id), url, method === EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA ? EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4 : method, request.params, topic).then(async signature => {
         await _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].responseRequest({
           topic: topic,
           response: formatJsonRpcResult(id, signature)
@@ -59,40 +51,24 @@ export default class Eip155RequestHandler {
     } else if (method === EIP155_SIGNING_METHODS.ETH_SEND_TRANSACTION) {
       const [tx] = parseRequestParams(request.params);
       const address = tx.from;
-      _classPrivateFieldLooseBase(this, _checkAccount)[_checkAccount](address, sessionAccounts);
       const chainId = parseInt(_chainId.split(':')[1]);
       const [networkKey, chainInfo] = _classPrivateFieldLooseBase(this, _koniState)[_koniState].findNetworkKeyByChainId(chainId);
       if (!networkKey || !chainInfo) {
         throw new Error(getSdkError('UNSUPPORTED_CHAINS').message + ' ' + address);
       }
-      const chainState = _classPrivateFieldLooseBase(this, _koniState)[_koniState].getChainStateByKey(networkKey);
-      const createRequest = () => {
-        _classPrivateFieldLooseBase(this, _koniState)[_koniState].evmSendTransaction(getWCId(id), url, networkKey, sessionAccounts, tx).then(async signature => {
-          await _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].responseRequest({
-            topic: topic,
-            response: formatJsonRpcResult(id, signature)
-          });
-        }).catch(e => {
-          _classPrivateFieldLooseBase(this, _handleError)[_handleError](topic, id, e);
-        });
-      };
-      if (!chainState.active) {
-        _classPrivateFieldLooseBase(this, _koniState)[_koniState].chainService.enableChain(networkKey).then(createRequest).catch(() => {
-          throw new Error(getSdkError('USER_REJECTED').message + ' Can not active chain: ' + chainInfo.name);
+      _classPrivateFieldLooseBase(this, _koniState)[_koniState].evmSendTransaction(getWCId(id), url, tx, networkKey, topic).then(async signature => {
+        await _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].responseRequest({
+          topic: topic,
+          response: formatJsonRpcResult(id, signature)
         });
-      } else {
-        createRequest();
-      }
+      }).catch(e => {
+        _classPrivateFieldLooseBase(this, _handleError)[_handleError](topic, id, e);
+      });
     } else {
       throw Error(getSdkError('INVALID_METHOD').message + ' ' + method);
     }
   }
 }
-function _checkAccount2(address, accounts) {
-  if (!accounts.find(account => isSameAddress(account, address))) {
-    throw new Error(getSdkError('UNSUPPORTED_ACCOUNTS').message + ' ' + address);
-  }
-}
 function _handleError2(topic, id, e) {
   console.log(e);
   let message = e.message;