@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/discoverAccounts.js

@@ -1,47 +1,57 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const utils_1 = require("@trezor/utils");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const coinInfo_1 = require("../data/coinInfo");
-const events_1 = require("../events");
-const paramsValidator_1 = require("./common/paramsValidator");
-const discoverAccounts_1 = require("../types/api/discoverAccounts");
-const accountUtils_1 = require("../utils/accountUtils");
-const pathUtils_1 = require("../utils/pathUtils");
+import { ACCOUNT_TYPES, CARDANO_DERIVATIONS, PAGING, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { arrayPartition, getSynchronize, versionUtils } from "@trezor/utils";
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+import { isUtxoBased } from "../utils/accountUtils.js";
+import { validatePath } from "../utils/pathUtils.js";
+import { getFirmwareRange, validateParams } from "./common/paramsValidator.js";
+import { checkXPubWithHashes } from "./firmware/calculateXPubHash.js";
+const {
+  CARDANO_TXS_PER_PAGE,
+  DEFAULT_TXS_PER_PAGE,
+  SOLANA_TXS_PER_PAGE
+} = PAGING;
 const ACCOUNT_LIMIT = 10;
-const TXS_PER_PAGE = 25;
 const DETAILS = 'txs';
-const isCardano = account => account.symbol === 'ada' || account.symbol === 'tada';
+const isCardano = account => account.symbol === 'ada';
 const isCardanoRequest = request => isCardano(request.account);
-const isEvmLedger = (account, coinInfo) => coinInfo.type === 'ethereum' && account.type === 'ledger';
+const shouldSkipFirstAccountIndex = (account, coinInfo) => (coinInfo.type === 'ethereum' || coinInfo.shortcut === 'TRX') && account.type === 'ledger';
 const getAccountTypeKey = ({
   symbol,
   type
 }) => `${symbol}-${type}`;
 const substituteBip43Path = (path, index) => path.replace('i', String(index));
-class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
+export const getTxsPerPage = account => {
+  switch (account.symbol) {
+    case 'ada':
+      return CARDANO_TXS_PER_PAGE;
+    case 'sol':
+      return SOLANA_TXS_PER_PAGE;
+    default:
+      return DEFAULT_TXS_PER_PAGE;
+  }
+};
+export default class DiscoverAccounts extends AbstractMethod {
   disposed = false;
-  init() {
-    this.requiredPermissions = ['read'];
-    this.useDevice = true;
-    this.useDeviceState = true;
-    this.useUi = false;
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    const {
+      entropyCheckResult
+    } = payload;
+    validateParams(payload, [{
       name: 'coins',
       type: 'array',
       required: true,
       allowEmpty: true
+    }, {
+      name: 'entropyCheckResult',
+      type: 'object'
     }]);
-    this.params = payload.coins.flatMap(coin => {
-      (0, paramsValidator_1.validateParams)(coin, [{
+    const coins = payload.coins.flatMap(coin => {
+      validateParams(coin, [{
         name: 'symbol',
         type: 'string',
         required: true
@@ -61,6 +71,9 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
       }, {
         name: 'pageSize',
         type: 'number'
+      }, {
+        name: 'protocols',
+        type: 'array'
       }]);
       const {
         symbol,
@@ -68,15 +81,12 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
         knownOnly,
         ...rest
       } = coin;
-      const coinInfo = (0, coinInfo_1.getCoinInfo)(symbol);
-      if (!coinInfo) {
-        throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-      }
-      (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-      const firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, AbstractMethod_1.DEFAULT_FIRMWARE_RANGE);
-      const symbolAccounts = discoverAccounts_1.ACCOUNT_TYPES.filter(a => a.symbol === symbol);
+      const coinInfo = getCoinInfoOrThrow(symbol);
+      assertBackendSupported(coinInfo);
+      const firmwareRange = getFirmwareRange([payload.method], [coinInfo]);
+      const symbolAccounts = ACCOUNT_TYPES.filter(a => a.symbol === symbol);
       knownAccs?.forEach(account => {
-        (0, paramsValidator_1.validateParams)(account, [{
+        validateParams(account, [{
           name: 'type',
           type: 'string',
           required: true
@@ -89,17 +99,28 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
         }
       });
       return symbolAccounts.map(account => [account, knownAccs?.find(t => t.type === account.type)]).filter(([_, known]) => known ? typeof known.skip === 'number' : !knownOnly).map(([account, known]) => ({
-        pageSize: isCardano(account) ? 8 : TXS_PER_PAGE,
+        pageSize: getTxsPerPage(account),
         details: DETAILS,
         coinInfo,
         firmwareRange,
         skip: known?.skip ?? 0,
         account,
         ...rest,
-        offset: isEvmLedger(account, coinInfo) ? 1 : 0,
-        derivation: isCardano(account) ? discoverAccounts_1.CARDANO_DERIVATIONS[account.type] : undefined
+        offset: shouldSkipFirstAccountIndex(account, coinInfo) ? 1 : 0,
+        derivation: isCardano(account) ? CARDANO_DERIVATIONS[account.type] : undefined
       }));
     });
+    const params = {
+      coins,
+      entropyCheckResult
+    };
+    super(message, params);
+    this.useDevice = true;
+    this.useDeviceState = true;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_account_info', this.params.coins.map(c => c.coinInfo));
   }
   progress = {};
   updateProgress(account, done, last = false) {
@@ -107,16 +128,18 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
     const key = getAccountTypeKey(account);
     this.progress[key] = progress;
   }
-  sendProgress(response) {
+  sendProgress(response, sendCoreMessage) {
     const progress = Object.values(this.progress).reduce((sum, typeProgress) => sum + typeProgress, 0) / (Object.keys(this.progress).length || 1);
-    this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+    sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
       total: 100,
       progress: 100 * progress,
       response
     }));
   }
-  async run() {
-    const [unsupported, supported] = this.filterUnsupportedAccounts(this.params);
+  async run({
+    sendCoreMessage
+  }) {
+    const [unsupported, supported] = this.filterUnsupportedAccounts(this.params.coins);
     unsupported.forEach(({
       account: {
         path: bip43,
@@ -136,16 +159,16 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
         error,
         path,
         backendType
-      });
+      }, sendCoreMessage);
     });
-    const [cardanoAccounts, otherAccounts] = (0, utils_1.arrayPartition)(supported, isCardanoRequest);
+    const [cardanoAccounts, otherAccounts] = arrayPartition(supported, isCardanoRequest);
     const [_, filteredCardanoAccounts] = await this.filterCardanoDerivations(cardanoAccounts);
     const accounts = [...otherAccounts, ...filteredCardanoAccounts];
     accounts.forEach(({
       account,
       skip
     }) => this.updateProgress(account, skip));
-    const counts = await Promise.all(accounts.map(account => this.discoverAccount(account)));
+    const counts = await Promise.all(accounts.map(account => this.discoverAccount(account, sendCoreMessage)));
     const nonempty = counts.reduce((sum, acc) => sum + acc.nonempty, 0);
     const failed = counts.filter(acc => acc.error).length;
     const empty = counts.length - failed;
@@ -156,21 +179,21 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
     };
   }
   filterUnsupportedAccounts(accounts) {
-    const version = this.device.getVersion();
-    const model = this.device.features?.internal_model;
+    const version = this.getDevice().getVersion();
+    const model = this.getDevice().features?.internal_model;
     if (!version || !model) return [[], accounts];
-    return (0, utils_1.arrayPartition)(accounts.map(item => {
+    return arrayPartition(accounts.map(item => {
       const {
         min,
         max
       } = item.firmwareRange[model];
       let error;
       if (min === '0') {
-        error = events_1.UI.FIRMWARE_NOT_SUPPORTED;
-      } else if (!utils_1.versionUtils.isNewerOrEqual(version, min)) {
-        error = events_1.UI.FIRMWARE_OLD;
-      } else if (max !== '0' && utils_1.versionUtils.isNewer(version, max)) {
-        error = events_1.UI.FIRMWARE_NOT_COMPATIBLE;
+        error = UI_REQUEST.FIRMWARE_NOT_SUPPORTED;
+      } else if (!versionUtils.isNewerOrEqual(version, min)) {
+        error = UI_REQUEST.FIRMWARE_OLD;
+      } else if (max !== '0' && versionUtils.isNewer(version, max)) {
+        error = UI_REQUEST.FIRMWARE_NOT_COMPATIBLE;
       }
       return error ? {
         ...item,
@@ -182,18 +205,18 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
     const legacyRequest = accounts.find(a => a.account.type === 'legacy');
     const ledgerRequest = accounts.find(a => a.account.type === 'ledger');
     const filterableRequest = legacyRequest ?? ledgerRequest;
-    const getDescriptor = derivation => filterableRequest && this.getDescriptor(filterableRequest.coinInfo, filterableRequest.account.path, discoverAccounts_1.CARDANO_DERIVATIONS[derivation], 0).then(({
+    const getDescriptor = derivation => filterableRequest && this.getDescriptor(filterableRequest.coinInfo, filterableRequest.account.path, CARDANO_DERIVATIONS[derivation], 0).then(({
       descriptor
     }) => descriptor);
     const normalDescriptor = await getDescriptor('normal');
     const omitLegacy = legacyRequest && (await getDescriptor('legacy')) === normalDescriptor;
     const omitLedger = ledgerRequest && (!legacyRequest || omitLegacy) && (await getDescriptor('ledger')) === normalDescriptor;
-    return (0, utils_1.arrayPartition)(accounts.map(item => item.account.type === 'legacy' && omitLegacy || item.account.type === 'ledger' && omitLedger ? {
+    return arrayPartition(accounts.map(item => item.account.type === 'legacy' && omitLegacy || item.account.type === 'ledger' && omitLedger ? {
       ...item,
       error: 'ignored cardano derivation'
     } : item), item => 'error' in item);
   }
-  descriptorLock = (0, utils_1.getSynchronize)();
+  descriptorLock = getSynchronize();
   descriptorCache = {};
   async getDescriptor(coinInfo, bip43PathTemplate, derivationType, index) {
     const path = substituteBip43Path(bip43PathTemplate, index);
@@ -203,8 +226,26 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
     } = await this.descriptorLock(async () => {
       const key = `${path}-${derivationType}`;
       if (!this.descriptorCache[key]) {
-        const address_n = (0, pathUtils_1.validatePath)(path, 3);
-        this.descriptorCache[key] = await this.device.getCommands().getAccountDescriptor(coinInfo, address_n, derivationType);
+        const address_n = validatePath(path, 3);
+        const descriptor = await this.getDevice().getCommands().getAccountDescriptor(coinInfo, address_n, derivationType);
+        this.descriptorCache[key] = descriptor;
+        const knownXPubHashes = this.params.entropyCheckResult?.xpubHashes;
+        const {
+          legacyXpub: xpub
+        } = descriptor;
+        const isPassphraseEnabled = this.getDevice().features?.passphrase_protection;
+        const alwaysPassphrase = this.getDevice().features?.passphrase_always_on_device;
+        const isStandardWallet = !isPassphraseEnabled || this.useEmptyPassphrase && !alwaysPassphrase;
+        if (xpub && knownXPubHashes && isStandardWallet) {
+          const isValid = checkXPubWithHashes({
+            xpub,
+            path,
+            knownXPubHashes
+          });
+          if (!isValid) {
+            console.error(`Entropy check failed at getAccountDescriptor on ${path}`);
+          }
+        }
       }
       return this.descriptorCache[key];
     });
@@ -213,11 +254,13 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
       ...descriptorRest
     };
   }
-  async discoverAccount(request) {
+  async discoverAccount(request, sendCoreMessage) {
     const {
       details,
       identity,
       pageSize,
+      gap,
+      protocols,
       coinInfo,
       derivation,
       offset,
@@ -228,16 +271,17 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
       ...accountKey
     } = request.account;
     const backendType = coinInfo.blockchainLink?.type;
-    const utxoRequired = (0, accountUtils_1.isUtxoBased)(coinInfo) && details && details !== 'basic';
+    const utxoRequired = isUtxoBased(coinInfo) && details && details !== 'basic';
     let index = skip;
+    const sendProgress = response => this.sendProgress(response, sendCoreMessage);
     let blockchain;
     try {
-      blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage, identity);
+      blockchain = await initBlockchain(coinInfo, sendCoreMessage, identity);
     } catch (err) {
       const path = substituteBip43Path(bip43, offset + index);
       this.updateProgress(accountKey, index + 1, true);
       const error = err.message;
-      this.sendProgress({
+      sendProgress({
         ...accountKey,
         index,
         failed: true,
@@ -263,11 +307,13 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
         const info = await blockchain.getAccountInfo({
           descriptor,
           details,
-          pageSize
+          pageSize,
+          protocols,
+          gap
         });
         const utxo = !utxoRequired ? undefined : info.empty ? [] : await blockchain.getAccountUtxo(descriptor);
         this.updateProgress(accountKey, index + 1, info.empty);
-        this.sendProgress({
+        sendProgress({
           ...info,
           descriptor,
           ...descRest,
@@ -291,7 +337,7 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
         } = err;
         const failed = true;
         this.updateProgress(accountKey, index + 1, true);
-        this.sendProgress({
+        sendProgress({
           ...accountKey,
           index,
           failed,
@@ -311,6 +357,4 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
   dispose() {
     this.disposed = true;
   }
-}
-exports.default = DiscoverAccounts;
-//# sourceMappingURL=discoverAccounts.js.map
+}

package/lib/api/ethereum/api/ethereumGetAddress.d.ts

@@ -1,28 +1,30 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import type { EthereumNetworkInfoDefinitionValues } from '../../../types';
-type Params = PROTO.EthereumGetAddress & {
-    address?: string;
-    network?: EthereumNetworkInfoDefinitionValues;
-    encoded_network?: ArrayBuffer;
+import type { EthereumNetworkInfoDefinitionValues, PROTO, PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.EthereumGetAddress;
+  address?: string;
+  network?: EthereumNetworkInfoDefinitionValues;
 };
 export default class EthereumGetAddress extends AbstractMethod<'ethereumGetAddress', Params[]> {
-    hasBundle?: boolean;
-    progress: number;
-    init(): void;
-    initAsync(): Promise<void>;
-    get info(): string;
-    getButtonRequestData(code: string): {
-        type: "address";
-        serializedPath: string;
-        address: string;
-    } | undefined;
-    get confirmation(): {
-        view: "export-address";
-        label: string;
-    };
-    private _call;
-    run(): Promise<import("../../../types").Address | import("../../../types").Address[]>;
+  hasBundle?: boolean;
+  progress: number;
+  constructor(message: MethodMessage<'ethereumGetAddress'>);
+  get requiredPermissions(): PermissionRequest[];
+  initAsync(): Promise<void>;
+  get info(): string;
+  getButtonRequestData(code: string): {
+    type: "address";
+    serializedPath: string;
+    address: string;
+  } | undefined;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  private _call;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<import("@trezor/connect-common").Address | import("@trezor/connect-common").Address[]>;
 }
-export {};
-//# sourceMappingURL=ethereumGetAddress.d.ts.map
+export {};

package/lib/api/ethereum/api/ethereumGetAddress.js

@@ -1,82 +1,93 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../../constants");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const events_1 = require("../../../events");
-const types_1 = require("../../../types");
-const getAddress_1 = require("../../../types/api/getAddress");
-const ethereumUtils_1 = require("../../../utils/ethereumUtils");
-const formatUtils_1 = require("../../../utils/formatUtils");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-const ethereumDefinitions_1 = require("../ethereumDefinitions");
-class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
+import { Bundle, GetAddress as GetAddressSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getEthereumNetwork, getUniqueNetworks } from "../../../data/coinInfo.js";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.js";
+import { stripHexPrefix } from "../../../utils/formatUtils.js";
+import { getSerializedPath, getSlip44ByPath, validatePath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+import { decodeEthereumDefinition, ethereumNetworkInfoFromDefinition, getEthereumDefinitions } from "../ethereumDefinitions.js";
+export default class EthereumGetAddress extends AbstractMethod {
   hasBundle;
   progress = 0;
-  init() {
-    this.noBackupConfirmationMode = 'always';
-    this.requiredPermissions = ['read'];
-    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
-    this.hasBundle = !!this.payload.bundle;
-    const payload = !this.payload.bundle ? {
-      ...this.payload,
-      bundle: [this.payload]
-    } : this.payload;
-    (0, schema_utils_1.Assert)((0, types_1.Bundle)(getAddress_1.GetAddress), payload);
-    this.params = payload.bundle.map(batch => {
-      const path = (0, pathUtils_1.validatePath)(batch.path, 3);
-      const network = (0, coinInfo_1.getEthereumNetwork)(path);
-      this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);
-      return {
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetAddressSchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 3);
+      const network = getEthereumNetwork(path);
+      const proto = {
         address_n: path,
         show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
-        address: batch.address,
-        network,
         chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
       };
+      return {
+        proto,
+        address: batch.address,
+        network
+      };
     });
-    const useEventListener = payload.useEventListener && this.params.length === 1 && typeof this.params[0].address === 'string' && this.params[0].show_display;
-    this.useUi = !useEventListener;
+    super(message, params);
+    this.requiredFirmwareCoins = params.map(({
+      network
+    }) => network);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = true;
+    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_address', this.requiredFirmwareCoins);
   }
   async initAsync() {
     for (let i = 0; i < this.params.length; i++) {
-      if (!this.params[i].network) {
-        const slip44 = (0, pathUtils_1.getSlip44ByPath)(this.params[i].address_n);
-        const definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
+      const {
+        params
+      } = this;
+      const param = params[i];
+      if (!param.network) {
+        const slip44 = getSlip44ByPath(param.proto.address_n);
+        const definitions = await getEthereumDefinitions({
           slip44
         });
-        const decoded = (0, ethereumDefinitions_1.decodeEthereumDefinition)(definitions);
+        const decoded = decodeEthereumDefinition(definitions);
         if (decoded.network) {
-          this.params[i].network = (0, ethereumDefinitions_1.ethereumNetworkInfoFromDefinition)(decoded.network);
+          param.network = ethereumNetworkInfoFromDefinition(decoded.network);
         }
         if (definitions.encoded_network) {
-          this.params[i].encoded_network = definitions.encoded_network;
+          param.proto.encoded_network = definitions.encoded_network;
         }
       }
     }
   }
   get info() {
     if (this.params.length === 1) {
-      return (0, ethereumUtils_1.getNetworkLabel)('Export #NETWORK address', this.params[0].network);
+      const {
+        params
+      } = this;
+      const first = params[0];
+      return getNetworkLabel('Export #NETWORK address', first.network);
     }
     const requestedNetworks = this.params.map(b => b.network);
-    const uniqNetworks = (0, coinInfo_1.getUniqueNetworks)(requestedNetworks);
+    const uniqNetworks = getUniqueNetworks(requestedNetworks);
     if (uniqNetworks.length === 1 && uniqNetworks[0]) {
-      return (0, ethereumUtils_1.getNetworkLabel)('Export multiple #NETWORK addresses', uniqNetworks[0]);
+      return getNetworkLabel('Export multiple #NETWORK addresses', uniqNetworks[0]);
     }
     return 'Export multiple addresses';
   }
   getButtonRequestData(code) {
     if (code === 'ButtonRequest_Address') {
+      const {
+        params
+      } = this;
+      const current = params[this.progress];
       return {
         type: 'address',
-        serializedPath: (0, pathUtils_1.getSerializedPath)(this.params[this.progress].address_n),
-        address: this.params[this.progress].address || 'not-set'
+        serializedPath: getSerializedPath(current.proto.address_n),
+        address: current.address || 'not-set'
       };
     }
   }
@@ -87,26 +98,34 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
     };
   }
   async _call(params) {
-    const response = await this.device.getCommands().ethereumGetAddress(params);
+    const response = await this.getDevice().getCommands().ethereumGetAddress(params.proto);
     return {
-      path: params.address_n,
-      serializedPath: (0, pathUtils_1.getSerializedPath)(params.address_n),
+      path: params.proto.address_n,
+      serializedPath: getSerializedPath(params.proto.address_n),
       address: response.address,
       mac: response.mac
     };
   }
-  async run() {
+  async run({
+    sendCoreMessage
+  }) {
     const responses = [];
     for (let i = 0; i < this.params.length; i++) {
-      const batch = this.params[i];
-      if (batch.show_display) {
+      const {
+        params
+      } = this;
+      const batch = params[i];
+      if (batch.proto.show_display) {
         const silent = await this._call({
           ...batch,
-          show_display: false
+          proto: {
+            ...batch.proto,
+            show_display: false
+          }
         });
         if (typeof batch.address === 'string') {
-          if ((0, formatUtils_1.stripHexPrefix)(batch.address).toLowerCase() !== (0, formatUtils_1.stripHexPrefix)(silent.address).toLowerCase()) {
-            throw constants_1.ERRORS.TypedError('Method_AddressNotMatch');
+          if (stripHexPrefix(batch.address).toLowerCase() !== stripHexPrefix(silent.address).toLowerCase()) {
+            throw ERRORS.TypedError('Method_AddressNotMatch');
           }
         } else {
           batch.address = silent.address;
@@ -117,7 +136,7 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
       });
       responses.push(response);
       if (this.hasBundle) {
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
           total: this.params.length,
           progress: i,
           response
@@ -125,8 +144,7 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
       }
       this.progress++;
     }
-    return this.hasBundle ? responses : responses[0];
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
   }
-}
-exports.default = EthereumGetAddress;
-//# sourceMappingURL=ethereumGetAddress.js.map
+}