@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/cipherKeyValue.js

@@ -1,29 +1,19 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
-const paramsValidator_1 = require("./common/paramsValidator");
-const cipherKeyValue_1 = require("../types/api/cipherKeyValue");
-const params_1 = require("../types/params");
-const pathUtils_1 = require("../utils/pathUtils");
-class CipherKeyValue extends AbstractMethod_1.AbstractMethod {
+import { CipherKeyValue as CipherKeyValueSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { Bundle } from "@trezor/connect-common/lib/types/params.js";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { bundlify } from "./common/paramsValidator.js";
+import { validatePath } from "../utils/pathUtils.js";
+export default class CipherKeyValue extends AbstractMethod {
   hasBundle;
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
-    this.hasBundle = !!this.payload.bundle;
-    const payload = !this.payload.bundle ? {
-      ...this.payload,
-      bundle: [this.payload]
-    } : this.payload;
-    this.useEmptyPassphrase = typeof payload.useEmptyPassphrase === 'boolean' ? payload.useEmptyPassphrase : true;
-    (0, schema_utils_1.Assert)((0, params_1.Bundle)(cipherKeyValue_1.CipherKeyValue), payload);
-    this.params = payload.bundle.map(batch => ({
-      address_n: (0, pathUtils_1.validatePath)(batch.path),
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(CipherKeyValueSchema), payload);
+    const params = payload.bundle.map(batch => ({
+      address_n: validatePath(batch.path),
       key: batch.key,
       value: batch.value instanceof Buffer ? batch.value.toString('hex') : batch.value,
       encrypt: batch.encrypt,
@@ -31,26 +21,38 @@ class CipherKeyValue extends AbstractMethod_1.AbstractMethod {
       ask_on_decrypt: batch.askOnDecrypt,
       iv: batch.iv instanceof Buffer ? batch.iv.toString('hex') : batch.iv
     }));
+    super(message, params);
+    this.hasBundle = hasBundle;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'sign'
+    }];
   }
   get info() {
     return 'Cipher key value';
   }
-  async run() {
+  async run({
+    sendCoreMessage
+  }) {
     const responses = [];
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     for (let i = 0; i < this.params.length; i++) {
-      const response = await cmd.typedCall('CipherKeyValue', 'CipheredKeyValue', this.params[i]);
+      const {
+        params
+      } = this;
+      const batch = params[i];
+      const response = await cmd.typedCall('CipherKeyValue', 'CipheredKeyValue', batch);
       responses.push(response.message);
       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
         }));
       }
     }
-    return this.hasBundle ? responses : responses[0];
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
   }
-}
-exports.default = CipherKeyValue;
-//# sourceMappingURL=cipherKeyValue.js.map
+}

package/lib/api/common/AbstractMiscGetAddress.d.ts

@@ -0,0 +1,37 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, MethodReturnType } from "../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../core/AbstractMethod.js";
+export type MiscGetAddressMethodName = 'rippleGetAddress' | 'stellarGetAddress' | 'tezosGetAddress' | 'solanaGetAddress' | 'tronGetAddress';
+type MiscProto = {
+  address_n: number[];
+  show_display: boolean;
+  chunkify: boolean;
+};
+export type MiscGetAddressParams = {
+  proto: MiscProto;
+  address?: string;
+};
+export declare abstract class AbstractMiscGetAddress<Name extends MiscGetAddressMethodName> extends AbstractMethod<Name, MiscGetAddressParams[]> {
+  hasBundle?: boolean;
+  progress: number;
+  constructor(message: MethodMessage<Name>, pathDepth: number);
+  get requiredPermissions(): PermissionRequest[];
+  protected getInfo(coinName: string, showAccountInInfo: boolean): string;
+  getButtonRequestData(code: string): {
+    type: "address";
+    serializedPath: string;
+    address: string;
+  } | undefined;
+  protected getConfirmation(coinName: string): {
+    view: "export-address";
+    label: string;
+  };
+  protected abstract _call(params: MiscGetAddressParams): Promise<{
+    address: string;
+    mac?: string;
+  }>;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<MethodReturnType<Name>>;
+}
+export {};

package/lib/api/common/AbstractMiscGetAddress.js

@@ -0,0 +1,126 @@
+import { Bundle, GetAddress as GetAddressSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { Assert } from "@trezor/schema-utils";
+import { bundlify } from "./paramsValidator.js";
+import { AbstractMethod } from "../../core/AbstractMethod.js";
+import { getSerializedPath, validatePath } from "../../utils/pathUtils.js";
+export class AbstractMiscGetAddress extends AbstractMethod {
+  hasBundle;
+  progress = 0;
+  constructor(message, pathDepth) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetAddressSchema), payload);
+    const params = payload.bundle.map(batch => ({
+      proto: {
+        address_n: validatePath(batch.path, pathDepth),
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
+      },
+      address: batch.address
+    }));
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = true;
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_address', this.requiredFirmwareCoins);
+  }
+  getInfo(coinName, showAccountInInfo) {
+    if (this.params.length > 1) {
+      return `Export multiple ${coinName} addresses`;
+    }
+    if (showAccountInInfo) {
+      const {
+        params
+      } = this;
+      const firstParam = params[0];
+      const {
+        address_n
+      } = firstParam.proto;
+      const accountIndex = address_n[2];
+      return `Export ${coinName} address for account #${fromHardenedPathPart(accountIndex) + 1}`;
+    }
+    return `Export ${coinName} address`;
+  }
+  getButtonRequestData(code) {
+    if (code === 'ButtonRequest_Address') {
+      const {
+        params,
+        progress
+      } = this;
+      const currentParam = params[progress];
+      return {
+        type: 'address',
+        serializedPath: getSerializedPath(currentParam.proto.address_n),
+        address: currentParam.address || 'not-set'
+      };
+    }
+  }
+  getConfirmation(coinName) {
+    if (this.params.length > 1) {
+      return {
+        view: 'export-address',
+        label: `Export multiple ${coinName} addresses`
+      };
+    }
+    const {
+      params
+    } = this;
+    const firstParam = params[0];
+    const {
+      address_n
+    } = firstParam.proto;
+    const accountIndex = address_n[2];
+    return {
+      view: 'export-address',
+      label: `Export ${coinName} address for account #${fromHardenedPathPart(accountIndex) + 1}`
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const {
+      params
+    } = this;
+    for (let i = 0; i < params.length; i++) {
+      const batch = params[i];
+      if (batch.proto.show_display) {
+        const silent = await this._call({
+          ...batch,
+          proto: {
+            ...batch.proto,
+            show_display: false
+          }
+        });
+        if (typeof batch.address === 'string') {
+          if (batch.address !== silent.address) {
+            throw ERRORS.TypedError('Method_AddressNotMatch');
+          }
+        } else {
+          batch.address = silent.address;
+        }
+      }
+      const response = await this._call(batch);
+      responses.push({
+        path: batch.proto.address_n,
+        serializedPath: getSerializedPath(batch.proto.address_n),
+        address: response.address,
+        mac: response.mac
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: params.length,
+          progress: i,
+          response
+        }));
+      }
+      this.progress++;
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/lib/api/common/Discovery.d.ts

@@ -1,36 +1,33 @@
+import type { DiscoveryAccount, DiscoveryAccountType, GetAccountInfo } from '@trezor/connect-common';
 import { TypedEmitter } from '@trezor/utils';
-import { Blockchain } from '../../backend/BlockchainLink';
-import type { DeviceCommands } from '../../device/DeviceCommands';
-import type { DiscoveryAccount, DiscoveryAccountType } from '../../types';
-import type { GetAccountInfo } from '../../types/api/getAccountInfo';
+import type { Blockchain } from "../../backend/BlockchainLink.js";
+import type { DeviceCommands } from "../../device/DeviceCommands.js";
 type DiscoveryType = {
-    type: DiscoveryAccountType;
-    getPath: (index: number) => number[];
+  type: DiscoveryAccountType;
+  getPath: (index: number) => number[];
 };
 type GetDescriptor = (path: number[]) => ReturnType<ReturnType<typeof DeviceCommands>['getAccountDescriptor']>;
 type DiscoveryOptions = {
-    blockchain: Blockchain;
-    getDescriptor: GetDescriptor;
-    limit?: number;
+  blockchain: Blockchain;
+  getDescriptor: GetDescriptor;
+  limit?: number;
 };
 interface Events {
-    progress: DiscoveryAccount[];
-    complete: void;
+  progress: DiscoveryAccount[];
+  complete: void;
 }
 export declare class Discovery extends TypedEmitter<Events> {
-    types: DiscoveryType[];
-    private typeIndex;
-    accounts: DiscoveryAccount[];
-    private coinInfo;
-    private blockchain;
-    getDescriptor: GetDescriptor;
-    private index;
-    private interrupted;
-    completed: boolean;
-    constructor(options: DiscoveryOptions);
-    start(details?: GetAccountInfo['details']): Promise<void>;
-    stop(): void;
-    dispose(): void;
+  types: DiscoveryType[];
+  private typeIndex;
+  accounts: DiscoveryAccount[];
+  private coinInfo;
+  private blockchain;
+  getDescriptor: GetDescriptor;
+  private index;
+  private interrupted;
+  completed: boolean;
+  constructor(options: DiscoveryOptions);
+  start(details?: GetAccountInfo['details']): Promise<void>;
+  stop(): void;
 }
-export {};
-//# sourceMappingURL=Discovery.d.ts.map
+export {};

package/lib/api/common/Discovery.js

@@ -1,14 +1,8 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Discovery = void 0;
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../../constants");
-const accountUtils_1 = require("../../utils/accountUtils");
-const formatUtils_1 = require("../../utils/formatUtils");
-class Discovery extends utils_1.TypedEmitter {
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { TypedEmitter } from "@trezor/utils";
+import { getAccountAddressN } from "../../utils/accountUtils.js";
+import { formatAmount } from "../../utils/formatUtils.js";
+export class Discovery extends TypedEmitter {
   types = [];
   typeIndex;
   accounts;
@@ -32,7 +26,7 @@ class Discovery extends utils_1.TypedEmitter {
       coinInfo
     } = this;
     if (coinInfo.type === 'bitcoin') {
-      const getDescriptor = (purpose, index) => (0, accountUtils_1.getAccountAddressN)(coinInfo, index, {
+      const getDescriptor = (purpose, index) => getAccountAddressN(coinInfo, index, {
         purpose
       });
       if (coinInfo.xPubMagicSegwitNative) {
@@ -60,7 +54,7 @@ class Discovery extends utils_1.TypedEmitter {
     } else {
       this.types.push({
         type: 'p2pkh',
-        getPath: accountUtils_1.getAccountAddressN.bind(this, coinInfo)
+        getPath: getAccountAddressN.bind(this, coinInfo)
       });
     }
   }
@@ -68,13 +62,16 @@ class Discovery extends utils_1.TypedEmitter {
     const limit = 10;
     this.interrupted = false;
     while (!this.completed && !this.interrupted) {
-      const accountType = this.types[this.typeIndex];
+      const {
+        types
+      } = this;
+      const accountType = types[this.typeIndex];
       const label = `Account #${this.index + 1}`;
       const overTheLimit = this.index >= limit;
       const path = accountType.getPath(this.index);
       const descriptor = await this.getDescriptor(path);
       if (!descriptor) {
-        throw constants_1.ERRORS.TypedError('Runtime', 'Discovery: descriptor not found');
+        throw ERRORS.TypedError('Runtime', 'Discovery: descriptor not found');
       }
       if (this.interrupted) return;
       const account = {
@@ -94,7 +91,7 @@ class Discovery extends utils_1.TypedEmitter {
       if (this.interrupted) return;
       this.accounts = this.accounts.filter(a => a.descriptor !== account.descriptor);
       if (!overTheLimit || overTheLimit && !info.empty) {
-        const balance = (0, formatUtils_1.formatAmount)(info.availableBalance, this.coinInfo);
+        const balance = formatAmount(info.availableBalance, this.coinInfo);
         this.accounts.push({
           ...account,
           empty: info.empty,
@@ -119,9 +116,4 @@ class Discovery extends utils_1.TypedEmitter {
   stop() {
     this.interrupted = !this.completed;
   }
-  dispose() {
-    this.accounts = [];
-  }
-}
-exports.Discovery = Discovery;
-//# sourceMappingURL=Discovery.js.map
+}

package/lib/api/common/paramsValidator.d.ts

@@ -1,14 +1,24 @@
-import type { CoinInfo, FirmwareRange } from '../../types';
+import type { CallMethodKeys, CoinInfo, FirmwareCapability, FirmwareRange, FirmwareRule } from '@trezor/connect-common';
+type MethodOrCapability = CallMethodKeys | FirmwareCapability;
 type ParamType = 'string' | 'number' | 'array' | 'array-buffer' | 'boolean' | 'uint' | 'object';
 type Param = {
-    name: string;
-    type?: ParamType | ParamType[];
-    required?: boolean;
-    allowEmpty?: boolean;
-    allowNegative?: boolean;
+  name: string;
+  type?: ParamType | ParamType[];
+  required?: boolean;
+  allowEmpty?: boolean;
+  allowNegative?: boolean;
+};
+export declare const bundlify: <T extends {
+  bundle?: unknown[];
+}>(payload: T) => {
+  hasBundle: boolean;
+  payload: T & {
+    bundle: unknown[];
+  };
 };
 export declare function validateParams<P extends Record<string, any>>(params: P, schema: Param[]): P;
 export declare const validateCoinPath: (path: number[], coinInfo?: CoinInfo) => void;
-export declare const getFirmwareRange: (method: string, coinInfo: CoinInfo | null | undefined, currentRange: FirmwareRange) => FirmwareRange;
-export {};
-//# sourceMappingURL=paramsValidator.d.ts.map
+export declare const DEFAULT_FIRMWARE_RANGE: FirmwareRange;
+export declare const filterByFirmwareType: (isDebug: boolean) => (rule: FirmwareRule) => boolean;
+export declare const getFirmwareRange: (methodsOrCapabilities: MethodOrCapability[], coins: CoinInfo[], currentRange?: FirmwareRange, isDebug?: boolean) => FirmwareRange;
+export {};

package/lib/api/common/paramsValidator.js

@@ -1,16 +1,16 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { typedObjectTransformValues, versionUtils } from "@trezor/utils";
+import { config } from "../../data/config.js";
+const invalidParameter = message => ERRORS.TypedError('Method_InvalidParameter', message);
+export const bundlify = payload => ({
+  hasBundle: !!payload.bundle,
+  payload: {
+    ...payload,
+    bundle: payload.bundle ?? [payload]
+  }
 });
-exports.getFirmwareRange = exports.validateCoinPath = void 0;
-exports.validateParams = validateParams;
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../../constants");
-const config_1 = require("../../data/config");
-const pathUtils_1 = require("../../utils/pathUtils");
-const invalidParameter = message => constants_1.ERRORS.TypedError('Method_InvalidParameter', message);
-function validateParams(params, schema) {
+export function validateParams(params, schema) {
   schema.forEach(field => {
     const value = params[field.name];
     if (field.required && value == null) {
@@ -64,67 +64,73 @@ function validateParams(params, schema) {
   });
   return params;
 }
-const validateCoinPath = (path, coinInfo) => {
-  if (coinInfo && coinInfo.slip44 !== (0, pathUtils_1.fromHardened)(path[1])) {
+export const validateCoinPath = (path, coinInfo) => {
+  const slip44Component = path[1];
+  if (coinInfo && coinInfo.slip44 !== fromHardenedPathPart(slip44Component)) {
     throw invalidParameter('Parameters "path" and "coin" do not match.');
   }
 };
-exports.validateCoinPath = validateCoinPath;
-const getFirmwareRange = (method, coinInfo, currentRange) => {
-  const range = JSON.parse(JSON.stringify(currentRange));
-  const models = (0, utils_1.typedObjectKeys)(range);
-  if (coinInfo) {
-    models.forEach(model => {
-      const supportVersion = coinInfo.support ? coinInfo.support[model] : false;
-      if (supportVersion === false) {
-        range[model].min = '0';
-      } else if (range[model].min !== '0' && typeof supportVersion === 'string' && utils_1.versionUtils.isNewer(supportVersion, range[model].min)) {
-        range[model].min = supportVersion;
-      }
-    });
+export const DEFAULT_FIRMWARE_RANGE = {
+  UNKNOWN: {
+    min: '1.0.0',
+    max: '0'
+  },
+  T1B1: {
+    min: '1.0.0',
+    max: '0'
+  },
+  T2T1: {
+    min: '2.0.0',
+    max: '0'
+  },
+  T2B1: {
+    min: '2.6.1',
+    max: '0'
+  },
+  T3B1: {
+    min: '2.8.1',
+    max: '0'
+  },
+  T3T1: {
+    min: '2.7.1',
+    max: '0'
+  },
+  T3W1: {
+    min: '2.7.1',
+    max: '0'
   }
-  const coinType = coinInfo?.type;
-  const shortcut = coinInfo?.shortcut.toLowerCase();
-  const configRules = config_1.config.supportedFirmware.filter(rule => {
-    if (rule.methods) {
-      return rule.methods.includes(method);
-    }
-    if (rule.capabilities) {
-      return rule.capabilities.includes(method);
-    }
-    return true;
-  }).filter(rule => {
-    if (rule.coinType) {
-      return rule.coinType === coinType;
-    }
-    if (rule.coin) {
-      return (typeof rule.coin === 'string' ? [rule.coin] : rule.coin).includes(shortcut);
-    }
-    return rule.methods || rule.capabilities;
-  });
-  configRules.forEach(rule => {
-    if (rule.min) {
-      models.forEach(model => {
-        const modelMin = rule.min[model];
-        if (modelMin) {
-          if (modelMin === '0' || range[model].min === '0' || !utils_1.versionUtils.isNewerOrEqual(range[model].min, modelMin)) {
-            range[model].min = modelMin;
-          }
-        }
-      });
-    }
-    if (rule.max) {
-      models.forEach(model => {
-        const modelMax = rule.max[model];
-        if (modelMax) {
-          if (modelMax === '0' || range[model].max === '0' || !utils_1.versionUtils.isNewerOrEqual(range[model].max, modelMax)) {
-            range[model].max = modelMax;
-          }
-        }
-      });
-    }
-  });
-  return range;
 };
-exports.getFirmwareRange = getFirmwareRange;
-//# sourceMappingURL=paramsValidator.js.map
+const intersectMin = (a, b) => a === '0' || b !== '0' && versionUtils.isNewer(a, b) ? a : b;
+const intersectMax = (a, b) => a === '0' || b !== '0' && versionUtils.isNewer(a, b) ? b : a;
+const intersectRange = (a, b) => typedObjectTransformValues(a, (value, model) => ({
+  min: intersectMin(value.min, b[model].min),
+  max: intersectMax(value.max, b[model].max)
+}));
+const ensureArray = (item = []) => Array.isArray(item) ? item : [item];
+const filterByCoins = coins => {
+  const coinSet = new Set(coins.map(coin => coin.shortcut.toLowerCase()));
+  const coinTypeSet = new Set(coins.map(coin => coin.type));
+  return rule => !rule.coin && !rule.coinType || ensureArray(rule.coin).some(coinSet.has.bind(coinSet)) || ensureArray(rule.coinType).some(coinTypeSet.has.bind(coinTypeSet));
+};
+const filterByMethods = methodsOrCapabilities => {
+  const methodSet = new Set(methodsOrCapabilities);
+  return rule => !rule.methods && !rule.capabilities || ensureArray(rule.methods).some(methodSet.has.bind(methodSet)) || ensureArray(rule.capabilities).some(methodSet.has.bind(methodSet));
+};
+export const filterByFirmwareType = isDebug => rule => !rule.firmwareType || rule.firmwareType === 'debug' === isDebug;
+const getCoinRules = (coins, currentRange) => coins.map(({
+  support = typedObjectTransformValues(DEFAULT_FIRMWARE_RANGE, () => false)
+}) => ({
+  ...currentRange,
+  ...typedObjectTransformValues(support, value => ({
+    min: value || '0',
+    max: '0'
+  }))
+}));
+const getConfigRules = (methodsOrCapabilities, coins, currentRange, isDebug) => config.supportedFirmware.filter(filterByCoins(coins)).filter(filterByMethods(methodsOrCapabilities)).filter(filterByFirmwareType(isDebug)).map(({
+  min,
+  max
+}) => typedObjectTransformValues(currentRange, (value, key) => ({
+  min: min?.[key] ?? value.min,
+  max: max?.[key] ?? value.max
+})));
+export const getFirmwareRange = (methodsOrCapabilities, coins, currentRange = DEFAULT_FIRMWARE_RANGE, isDebug = false) => getCoinRules(coins, currentRange).concat(getConfigRules(methodsOrCapabilities, coins, currentRange, isDebug)).reduce(intersectRange, currentRange);

package/lib/api/common/requestExistingAccounts.d.ts

@@ -0,0 +1,14 @@
+import { type CoinInfo, type CoreEventMessage, type DiscoveryAccount } from '@trezor/connect-common';
+import type { UiPromiseCreator } from "../../events/ui-promise.js";
+import type { IDevice } from "../../types/idevice.js";
+export declare const requestExistingAccounts: ({
+  postMessage,
+  createUiPromise,
+  device,
+  coinInfo
+}: {
+  postMessage: (message: CoreEventMessage) => void;
+  createUiPromise: UiPromiseCreator;
+  device: IDevice;
+  coinInfo: CoinInfo;
+}) => Promise<DiscoveryAccount[] | null>;

package/lib/api/common/requestExistingAccounts.js

@@ -0,0 +1,20 @@
+import { UI_REQUEST, UI_RESPONSE, createUiMessage } from "@trezor/connect-common";
+import { resolveAfter } from "@trezor/utils/lib/resolveAfter.js";
+const REQUEST_TIMEOUT_MS = 200;
+export const requestExistingAccounts = async ({
+  postMessage,
+  createUiPromise,
+  device,
+  coinInfo
+}) => {
+  const dfd = createUiPromise(UI_RESPONSE.RECEIVE_DISCOVERY_ACCOUNTS, device);
+  postMessage(createUiMessage(UI_REQUEST.REQUEST_DISCOVERY_ACCOUNTS, {
+    coinInfo
+  }));
+  const result = await Promise.race([dfd.promise.then(response => response.payload), resolveAfter(REQUEST_TIMEOUT_MS).then(() => null)]);
+  if (result === null) {
+    dfd.reject(new Error('No discovery accounts handler'));
+    return null;
+  }
+  return result.accounts.length > 0 ? result.accounts : null;
+};