@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/unlockPath.js

@@ -1,30 +1,27 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const pathUtils_1 = require("../utils/pathUtils");
-const paramsValidator_1 = require("./common/paramsValidator");
-const unlockPath_1 = require("../types/api/unlockPath");
-class UnlockPath extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read'];
-    this.skipFinalReload = true;
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, undefined, this.firmwareRange);
+import { UnlockPathParams } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validatePath } from "../utils/pathUtils.js";
+export default class UnlockPath extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(unlockPath_1.UnlockPathParams, payload);
-    const path = (0, pathUtils_1.validatePath)(payload.path, 1);
-    this.params = {
+    } = message;
+    Assert(UnlockPathParams, payload);
+    const path = validatePath(payload.path, 1);
+    const params = {
       address_n: path,
       mac: payload.mac
     };
+    super(message, params);
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'read_xpub'
+    }];
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const {
       message
     } = await cmd.unlockPath(this.params);
@@ -33,6 +30,4 @@ class UnlockPath extends AbstractMethod_1.AbstractMethod {
       mac: message.mac
     };
   }
-}
-exports.default = UnlockPath;
-//# sourceMappingURL=unlockPath.js.map
+}

package/lib/api/verifyMessage.d.ts

@@ -1,10 +1,16 @@
-import { PROTO } from '../constants';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class VerifyMessage extends AbstractMethod<'verifyMessage', PROTO.VerifyMessage> {
-    init(): void;
-    get info(): string;
-    run(): Promise<{
-        message: string;
-    }>;
+import type { CoinInfo, PROTO, PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.VerifyMessage;
+  coinInfo: CoinInfo;
+};
+export default class VerifyMessage extends AbstractMethod<'verifyMessage', Params> {
+  constructor(message: MethodMessage<'verifyMessage'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    message: string;
+  }>;
 }
-//# sourceMappingURL=verifyMessage.d.ts.map
+export {};

package/lib/api/verifyMessage.js

@@ -1,50 +1,46 @@
-"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 paramsValidator_1 = require("./common/paramsValidator");
-const coinInfo_1 = require("../data/coinInfo");
-const types_1 = require("../types");
-const formatUtils_1 = require("../utils/formatUtils");
-const pathUtils_1 = require("../utils/pathUtils");
-class VerifyMessage extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read', 'write'];
+import { VerifyMessage as VerifyMessageSchema } 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 { getBitcoinNetwork } from "../data/coinInfo.js";
+import { validateModelOneMessageSize } from "../device/validateMessageSize.js";
+import { messageToHex } from "../utils/formatUtils.js";
+import { getLabel } from "../utils/pathUtils.js";
+export default class VerifyMessage extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(types_1.VerifyMessage, payload);
-    const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
+    } = message;
+    Assert(VerifyMessageSchema, payload);
+    const coinInfo = getBitcoinNetwork(payload.coin);
     if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    } else {
-      this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+      throw ERRORS.TypedError('Method_UnknownCoin');
     }
-    const messageHex = payload.hex ? (0, formatUtils_1.messageToHex)(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
+    const messageHex = payload.hex ? messageToHex(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
     const signatureHex = Buffer.from(payload.signature, 'base64').toString('hex');
-    this.params = {
+    const proto = {
       address: payload.address,
       signature: signatureHex,
       message: messageHex,
       coin_name: coinInfo.name
     };
+    const params = {
+      proto,
+      coinInfo
+    };
+    super(message, params);
+    this.requiredFirmwareCoins = [coinInfo];
+  }
+  get requiredPermissions() {
+    return [this.coinPerm('verify_message', this.params.coinInfo)];
   }
   get info() {
-    const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(this.payload.coin);
-    if (!coinInfo) {
-      return 'Verify message';
-    }
-    return (0, pathUtils_1.getLabel)('Verify #NETWORK message', coinInfo);
+    return getLabel('Verify #NETWORK message', this.params.coinInfo);
   }
   async run() {
-    const cmd = this.device.getCommands();
-    const response = await cmd.typedCall('VerifyMessage', 'Success', this.params);
+    validateModelOneMessageSize(this.getDevice(), this.params.proto.message);
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('VerifyMessage', 'Success', this.params.proto);
     return response.message;
   }
-}
-exports.default = VerifyMessage;
-//# sourceMappingURL=verifyMessage.js.map
+}

package/lib/api/wipeDevice.d.ts

@@ -1,17 +1,21 @@
-import { AbstractMethod } from '../core/AbstractMethod';
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import type { Device } from "../device/Device.js";
 export default class WipeDevice extends AbstractMethod<'wipeDevice'> {
-    init(): void;
-    get confirmation(): {
-        view: "device-management";
-        customConfirmButton: {
-            className: string;
-            label: string;
-        };
-        label: string;
+  constructor(message: MethodMessage<'wipeDevice'>);
+  get requiredPermissions(): PermissionRequest[];
+  get confirmation(): {
+    view: "device-management";
+    customConfirmButton: {
+      className: string;
+      label: string;
     };
-    get info(): string;
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=wipeDevice.d.ts.map
+    label: string;
+  };
+  get info(): string;
+  setDevice(device: Device): void;
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/wipeDevice.js

@@ -1,18 +1,16 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
-const paramsValidator_1 = require("./common/paramsValidator");
-class WipeDevice extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS, events_1.UI.BOOTLOADER];
+import { DEVICE, UI_REQUEST } from "@trezor/connect-common";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class WipeDevice extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS, UI_REQUEST.BOOTLOADER];
     this.useDeviceState = false;
-    this.requiredPermissions = ['management'];
-    this.skipFinalReload = this.payload.skipFinalReload ?? false;
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+    this.skipFinalReload = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
   get confirmation() {
     return {
@@ -27,23 +25,25 @@ class WipeDevice extends AbstractMethod_1.AbstractMethod {
   get info() {
     return 'Wipe device';
   }
+  setDevice(device) {
+    super.setDevice(device);
+    this.skipFinalReload = device.features?.bootloader_mode || !!device.getThpState();
+  }
   async run() {
-    const cmd = this.device.getCommands();
-    if (this.device.isBootloader()) {
-      this.device.emit(events_1.DEVICE.BUTTON, {
-        device: this.device,
+    const cmd = this.getDevice().getCommands();
+    if (this.getDevice().isBootloader()) {
+      this.getDevice().emit(DEVICE.BUTTON, {
+        device: this.getDevice(),
         payload: {
           code: 'ButtonRequest_WipeDevice'
         }
       });
     }
     const response = await cmd.typedCall('WipeDevice', 'Success');
-    const thpState = this.device.getThpState();
+    const thpState = this.getDevice().getThpState();
     if (thpState) {
       thpState.resetState();
     }
     return response.message;
   }
-}
-exports.default = WipeDevice;
-//# sourceMappingURL=wipeDevice.js.map
+}

package/lib/backend/BackendManager.d.ts

@@ -1,24 +1,30 @@
-import { Blockchain, BlockchainOptions } from './Blockchain';
-import type { BlockchainLink, CoinInfo } from '../types';
+import type { BlockchainLink, CoinInfo, Proxy } from '@trezor/connect-common';
+import type { BlockchainOptions } from "./Blockchain.js";
+import { Blockchain } from "./Blockchain.js";
 type CoinShortcut = CoinInfo['shortcut'];
 type BackendParams = Pick<BlockchainOptions, 'coinInfo' | 'postMessage' | 'identity'>;
 export declare class BackendManager {
-    private readonly instances;
-    private readonly reconnect;
-    private readonly custom;
-    private readonly preferred;
-    get(shortcut: CoinShortcut, identity?: string): Blockchain | null;
-    getOrConnect({ coinInfo, postMessage, identity }: BackendParams): Promise<Blockchain>;
-    dispose(): void;
-    reconnectAll(coin?: CoinInfo): Promise<Blockchain[]>;
-    isSupported(coinInfo: CoinInfo): void;
-    setCustom(shortcut: CoinShortcut, blockchainLink?: BlockchainLink): void;
-    private setInstance;
-    private setPreferred;
-    private onDisconnect;
-    private clearReconnect;
-    private patchCoinInfo;
-    private getReconnectFilter;
+  private proxy?;
+  private readonly instances;
+  private readonly reconnect;
+  private readonly custom;
+  private readonly preferred;
+  get(shortcut: CoinShortcut, identity?: string): Blockchain | null;
+  getOrConnect({
+    coinInfo,
+    postMessage,
+    identity
+  }: BackendParams): Promise<Blockchain>;
+  dispose(): void;
+  reconnectAll(coin?: CoinInfo): Promise<Blockchain[]>;
+  isSupported(coinInfo: CoinInfo): boolean;
+  setCustom(shortcut: CoinShortcut, blockchainLink?: BlockchainLink): void;
+  updateProxy(proxy: Proxy | undefined): Promise<void>;
+  private setInstance;
+  private setPreferred;
+  private onDisconnect;
+  private clearReconnect;
+  private patchCoinInfo;
+  private getReconnectFilter;
 }
-export {};
-//# sourceMappingURL=BackendManager.d.ts.map
+export {};

package/lib/backend/BackendManager.js

@@ -1,15 +1,10 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.BackendManager = void 0;
-const constants_1 = require("../constants");
-const Blockchain_1 = require("./Blockchain");
-const DataManager_1 = require("../data/DataManager");
-const events_1 = require("../events");
+import { BLOCKCHAIN, createBlockchainMessage } from "@trezor/connect-common";
+import { deepEqual } from "@trezor/utils";
+import { Blockchain } from "./Blockchain.js";
+import * as settingsStore from "../data/settingsStore.js";
 const DEFAULT_IDENTITY = 'default';
-class BackendManager {
+export class BackendManager {
+  proxy;
   instances = {};
   reconnect = {};
   custom = {};
@@ -25,11 +20,11 @@ class BackendManager {
     const coinIdentity = `${coinInfo.shortcut}/${identity ?? DEFAULT_IDENTITY}`;
     let backend = this.instances[coinIdentity];
     if (!backend) {
-      backend = new Blockchain_1.Blockchain({
+      backend = new Blockchain({
         coinInfo: this.patchCoinInfo(coinInfo),
         identity,
-        debug: DataManager_1.DataManager.getSettings('debug'),
-        proxy: DataManager_1.DataManager.getSettings('proxy'),
+        debug: settingsStore.get('debug'),
+        proxy: this.proxy,
         postMessage,
         onDisconnected: pendingSubscriptions => {
           const reconnectAttempts = pendingSubscriptions ? 0 : undefined;
@@ -67,9 +62,7 @@ class BackendManager {
   }
   isSupported(coinInfo) {
     const info = this.custom[coinInfo.shortcut] || coinInfo.blockchainLink;
-    if (!info) {
-      throw constants_1.ERRORS.TypedError('Backend_NotSupported');
-    }
+    return !!info;
   }
   setCustom(shortcut, blockchainLink) {
     this.setPreferred(shortcut, undefined);
@@ -79,6 +72,12 @@ class BackendManager {
       delete this.custom[shortcut];
     }
   }
+  async updateProxy(proxy) {
+    if (proxy !== undefined && !deepEqual(this.proxy, proxy)) {
+      this.proxy = proxy;
+      await this.reconnectAll();
+    }
+  }
   setInstance(coinIdentity, instance) {
     if (!instance) delete this.instances[coinIdentity];else this.instances[coinIdentity] = instance;
   }
@@ -112,7 +111,7 @@ class BackendManager {
       attempts: reconnectAttempt + 1,
       handle
     };
-    postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.RECONNECTING, {
+    postMessage(createBlockchainMessage(BLOCKCHAIN.RECONNECTING, {
       coin: coinInfo,
       identity,
       time
@@ -125,21 +124,22 @@ class BackendManager {
     return reconnect;
   }
   patchCoinInfo(coinInfo) {
-    const custom = this.custom[coinInfo.shortcut];
-    const preferred = this.preferred[coinInfo.shortcut];
-    const url = preferred ? [preferred] : custom?.url ?? coinInfo.blockchainLink?.url;
+    const thisCustom = this.custom;
+    const custom = thisCustom[coinInfo.shortcut];
+    const thisPreferred = this.preferred;
+    const preferred = thisPreferred[coinInfo.shortcut];
+    const url = preferred ? [preferred] : custom?.url ?? coinInfo.blockchainLink?.url ?? [];
+    const patchedBlockchainLink = {
+      ...coinInfo.blockchainLink,
+      ...custom,
+      url
+    };
     return {
       ...coinInfo,
-      blockchainLink: {
-        ...coinInfo.blockchainLink,
-        ...custom,
-        url
-      }
+      blockchainLink: patchedBlockchainLink
     };
   }
   getReconnectFilter(coinInfo) {
     return key => !coinInfo || key.startsWith(`${coinInfo.shortcut}/`);
   }
-}
-exports.BackendManager = BackendManager;
-//# sourceMappingURL=BackendManager.js.map
+}

package/lib/backend/Blockchain.d.ts

@@ -1,82 +1,81 @@
-import BlockchainLink, { BlockchainLinkParams, ServerInfo, SubscriptionAccountInfo } from '@trezor/blockchain-link';
-import { CoreEventMessage } from '../events';
-import type { CoinInfo, Proxy } from '../types';
-import { PushTransaction } from '../types/api/pushTransaction';
+import type { BlockchainLinkParams, ServerInfo, SubscriptionAccountInfo } from '@trezor/blockchain-link';
+import { BlockchainLink } from '@trezor/blockchain-link';
+import type { CoinInfo, CoreEventMessage, Proxy, PushTransaction } from '@trezor/connect-common';
 export type BlockchainOptions = {
-    coinInfo: CoinInfo;
-    postMessage: (message: CoreEventMessage) => void;
-    proxy?: Proxy;
-    debug?: boolean;
-    identity?: string;
-    onDisconnected?: (pendingSubscriptions?: boolean) => void;
+  coinInfo: CoinInfo;
+  postMessage: (message: CoreEventMessage) => void;
+  proxy?: Proxy;
+  debug?: boolean;
+  identity?: string;
+  onDisconnected?: (pendingSubscriptions?: boolean) => void;
 };
 export declare class Blockchain {
-    readonly link: BlockchainLink;
-    serverInfo?: ServerInfo;
-    readonly identity?: string;
-    readonly coinInfo: BlockchainOptions['coinInfo'];
-    readonly postMessage: BlockchainOptions['postMessage'];
-    private onDisconnected;
-    private initPromise?;
-    constructor(options: BlockchainOptions);
-    private onBackendDisconnected;
-    private initLink;
-    init(): Promise<ServerInfo>;
-    getTransactions(txs: string[]): Promise<import("@trezor/blockchain-link").Transaction[]>;
-    getTransactionHexes(txids: string[]): Promise<string[]>;
-    getCurrentFiatRates(params: {
-        currencies?: string[];
-        token?: string;
-    }): Promise<{
-        ts: number;
-        rates: import("@trezor/blockchain-link").FiatRatesBySymbol;
-    }>;
-    getFiatRatesForTimestamps(params: {
-        currencies?: string[];
-        timestamps: number[];
-        token?: string;
-    }): Promise<{
-        tickers: {
-            ts: number;
-            rates: import("@trezor/blockchain-link").FiatRatesBySymbol;
-        }[];
-    }>;
-    getAccountBalanceHistory(params: BlockchainLinkParams<'getAccountBalanceHistory'>): Promise<import("@trezor/blockchain-link").AccountBalanceHistory[]>;
-    getNetworkInfo(): Promise<ServerInfo>;
-    getAccountInfo(request: BlockchainLinkParams<'getAccountInfo'>): Promise<import("@trezor/blockchain-link").AccountInfo>;
-    getAccountUtxo(descriptor: string): Promise<import("@trezor/blockchain-link").Utxo[]>;
-    rpcCall(params: BlockchainLinkParams<'rpcCall'>): Promise<{
-        data: string;
-    }>;
-    estimateFee(request: Parameters<typeof this.link.estimateFee>[0]): Promise<{
-        feePerUnit: string;
-        feePerTx?: string;
-        feePayer?: string;
-        feeLimit?: string;
-        eip1559?: import("@trezor/blockchain-link-types/lib/blockbook-api").Eip1559Fees;
-    }[]>;
-    subscribeBlocks(): Promise<{
-        subscribed: boolean;
-    }>;
-    subscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
-        subscribed: boolean;
-    }>;
-    subscribeFiatRates(_currency?: string): Promise<{
-        subscribed: boolean;
-    }>;
-    unsubscribeBlocks(): Promise<{
-        subscribed: boolean;
-    }>;
-    unsubscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
-        subscribed: boolean;
-    }>;
-    unsubscribeFiatRates(): Promise<{
-        subscribed: boolean;
-    }>;
-    unsubscribeAll(): Promise<{
-        subscribed: boolean;
-    }>;
-    pushTransaction(tx: PushTransaction['tx']): Promise<string>;
-    disconnect(): void;
-}
-//# sourceMappingURL=Blockchain.d.ts.map
+  readonly link: BlockchainLink;
+  serverInfo?: ServerInfo;
+  readonly identity?: string;
+  readonly coinInfo: BlockchainOptions['coinInfo'];
+  readonly postMessage: BlockchainOptions['postMessage'];
+  private onDisconnected;
+  private initPromise?;
+  constructor(options: BlockchainOptions);
+  private onBackendDisconnected;
+  private initLink;
+  init(): Promise<ServerInfo>;
+  getTransactions(txs: string[], descriptor?: string): Promise<import("@trezor/blockchain-link-types").Transaction[]>;
+  getTransactionHexes(txids: string[]): Promise<string[]>;
+  getCurrentFiatRates(params: {
+    currencies?: string[];
+    token?: string;
+  }): Promise<{
+    ts: number;
+    rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
+  }>;
+  getContractInfo(params: BlockchainLinkParams<'getContractInfo'>): Promise<import("@trezor/blockchain-link-types/lib/blockbook-api").ContractInfoResult>;
+  getFiatRatesForTimestamps(params: {
+    currencies?: string[];
+    timestamps: number[];
+    token?: string;
+  }): Promise<{
+    tickers: {
+      ts: number;
+      rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
+    }[];
+  }>;
+  getAccountBalanceHistory(params: BlockchainLinkParams<'getAccountBalanceHistory'>): Promise<import("@trezor/blockchain-link-types").AccountBalanceHistory[]>;
+  getNetworkInfo(): Promise<ServerInfo>;
+  getAccountInfo(request: BlockchainLinkParams<'getAccountInfo'>): Promise<import("@trezor/blockchain-link-types").AccountInfo>;
+  getAccountUtxo(descriptor: string): Promise<import("@trezor/blockchain-link-types").Utxo[]>;
+  rpcCall(params: BlockchainLinkParams<'rpcCall'>): Promise<{
+    data: string;
+  }>;
+  estimateFee(request: Parameters<typeof this.link.estimateFee>[0]): Promise<{
+    feePerUnit: string;
+    feePerTx?: string;
+    feePayer?: string;
+    feeLimit?: string;
+    eip1559?: import("@trezor/blockchain-link-types").Eip1559Fees;
+  }[]>;
+  subscribeBlocks(): Promise<{
+    subscribed: boolean;
+  }>;
+  subscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
+    subscribed: boolean;
+  }>;
+  subscribeFiatRates(_currency?: string): Promise<{
+    subscribed: boolean;
+  }>;
+  unsubscribeBlocks(): Promise<{
+    subscribed: boolean;
+  }>;
+  unsubscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
+    subscribed: boolean;
+  }>;
+  unsubscribeFiatRates(): Promise<{
+    subscribed: boolean;
+  }>;
+  unsubscribeAll(): Promise<{
+    subscribed: boolean;
+  }>;
+  pushTransaction(tx: PushTransaction['tx']): Promise<string>;
+  disconnect(): void;
+}