@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/core/AbstractMethod.d.ts

@@ -1,78 +1,63 @@
-import { Capability } from '@trezor/protobuf/lib/messages';
-import { NETWORK } from '../constants';
-import type { Device } from '../device/Device';
-import { CallMethodPayload, CallMethodResponse, CoreEventMessage, UI, UiPromiseCreator, UiRequestButtonData, UiRequestConfirmation } from '../events';
-import type { PrecomposeResultFinal } from '../types/api/composeTransaction';
-import type { DeviceState } from '../types/device';
-import type { FirmwareRange } from '../types/firmware';
-import type { ConnectSettings } from '../types/settings';
+import { UI_REQUEST } from '@trezor/connect-common';
+import type { CallMethodPayload, CallMethodResponse, CoinInfo, CoreEventMessage, DeviceState, FirmwareCapability, MethodInfo, MethodPermission, PermissionRequest, PrecomposeResultFinal, UiRequestButtonData, UiRequestConfirmation } from '@trezor/connect-common';
+import type { Capability } from '@trezor/protobuf/lib/definitions';
+import { DEFAULT_FIRMWARE_RANGE } from "../api/common/paramsValidator.js";
+import type { Device } from "../device/Device.js";
+import type { UiPromiseCreator } from "../events/ui-promise.js";
+export { DEFAULT_FIRMWARE_RANGE };
 export type Payload<M> = Extract<CallMethodPayload, {
-    method: M;
+  method: M;
 }> & {
-    override?: boolean;
+  override?: boolean;
 };
 export type MethodReturnType<M extends CallMethodPayload['method']> = CallMethodResponse<M>;
-export type MethodPermission = 'read' | 'write' | 'management' | 'push_tx';
-export type DeviceMode = typeof UI.SEEDLESS | typeof UI.BOOTLOADER | typeof UI.INITIALIZE;
-export type MethodInfo = {
-    useUi: boolean;
-    useDevice: boolean;
-    useDeviceState: boolean;
-    name: string;
-    requiredPermissions: MethodPermission[];
-    info: string;
-    precomposed?: PrecomposeResultFinal;
-    confirmation?: UiRequestConfirmation['payload'];
+export type DeviceMode = typeof UI_REQUEST.SEEDLESS | typeof UI_REQUEST.BOOTLOADER | typeof UI_REQUEST.INITIALIZE;
+export type MethodContext = {
+  sendCoreMessage: (message: CoreEventMessage) => void;
+  createUiPromise: UiPromiseCreator;
+};
+export type MethodMessage<Name extends CallMethodPayload['method']> = {
+  id?: string;
+  payload: Payload<Name>;
 };
-export declare const DEFAULT_FIRMWARE_RANGE: FirmwareRange;
 export declare abstract class AbstractMethod<Name extends CallMethodPayload['method'], Params = undefined> {
-    responseID: number;
-    device: Device;
-    params: Params;
-    deviceState?: DeviceState;
-    hasExpectedDeviceState: boolean;
-    keepSession: boolean;
-    skipFinalReload: boolean;
-    skipFirmwareCheck: boolean;
-    overridePreviousCall: boolean;
-    overridden: boolean;
-    name: Name;
-    payload: Payload<Name>;
-    get info(): string;
-    get confirmation(): UiRequestConfirmation['payload'] | undefined;
-    useUi: boolean;
-    useDevice: boolean;
-    useDeviceState: boolean;
-    preauthorized?: boolean;
-    useEmptyPassphrase: boolean;
-    allowSeedlessDevice: boolean;
-    firmwareRange: FirmwareRange;
-    requiredPermissions: MethodPermission[];
-    allowDeviceMode: DeviceMode[];
-    requireDeviceMode: DeviceMode[];
-    requiredDeviceCapabilities: Capability[];
-    network: NETWORK.NetworkType;
-    useCardanoDerivation: boolean;
-    noBackupConfirmationMode: 'never' | 'always' | 'popup-only';
-    getButtonRequestData?(code: string, name?: string): UiRequestButtonData | undefined;
-    postMessage: (message: CoreEventMessage) => void;
-    createUiPromise: UiPromiseCreator;
-    initAsync?(): Promise<void>;
-    constructor(message: {
-        id?: number;
-        payload: Payload<Name>;
-    });
-    setDevice(device: Device): void;
-    private getOriginPermissions;
-    checkPermissions({ origin }: Pick<ConnectSettings, 'origin'>): void;
-    savePermissions(temporary: boolean | undefined, { origin }: Pick<ConnectSettings, 'origin'>): void;
-    checkFirmwareRange(): "ui-device_firmware_old" | "ui-device_firmware_unsupported" | "ui-device_firmware_not_compatible" | "ui-device_firmware_not_installed" | undefined;
-    isManagementRestricted({ popup, origin }: Pick<ConnectSettings, 'popup' | 'origin'>): boolean | undefined;
-    abstract init(): void;
-    getMethodInfo(): MethodInfo;
-    payloadToPrecomposed(): Promise<PrecomposeResultFinal | undefined>;
-    checkDeviceCapability(): void;
-    abstract run(): Promise<MethodReturnType<Name>>;
-    dispose(): void;
-}
-//# sourceMappingURL=AbstractMethod.d.ts.map
+  responseID: string;
+  callId?: string;
+  device: Device | undefined;
+  protected params: Params;
+  deviceState?: DeviceState;
+  keepSession: boolean;
+  skipFinalReload: boolean;
+  overridePreviousCall: boolean;
+  overridden: boolean;
+  readonly name: Name;
+  protected get info(): string;
+  protected get confirmation(): UiRequestConfirmation['payload'] | undefined;
+  useUi: boolean;
+  useDevice: boolean;
+  useDeviceState: boolean;
+  preauthorized?: boolean;
+  useEmptyPassphrase: boolean;
+  abstract get requiredPermissions(): PermissionRequest[];
+  private toCoinSymbol;
+  protected coinPerm(permission: MethodPermission, coin?: CoinInfo): PermissionRequest;
+  protected coinPerms(permission: MethodPermission, coins: (CoinInfo | undefined)[]): PermissionRequest[];
+  allowDeviceMode: DeviceMode[];
+  protected requiredDeviceCapabilities: Capability[];
+  protected requiredFirmwareCapabilities: FirmwareCapability[];
+  protected requiredFirmwareCoins: (CoinInfo | undefined)[];
+  useCardanoDerivation: boolean;
+  confirmMissingBackup: boolean;
+  getButtonRequestData?(code: string, name?: string): UiRequestButtonData | undefined;
+  initAsync?(): Promise<void>;
+  constructor(message: MethodMessage<Name>, params: Params);
+  resolveCardanoCapability(): void;
+  setDevice(device: Device): void;
+  getDevice(): Device;
+  checkFirmwareRange(): "ui-device_firmware_old" | "ui-device_firmware_unsupported" | "ui-device_firmware_not_compatible" | "ui-device_firmware_not_installed" | undefined;
+  getMethodInfo(): MethodInfo;
+  payloadToPrecomposed(): Promise<PrecomposeResultFinal | undefined>;
+  checkDeviceCapability(): void;
+  abstract run(context: MethodContext): Promise<MethodReturnType<Name>>;
+  dispose(): void;
+}

package/lib/core/AbstractMethod.js

@@ -1,55 +1,26 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AbstractMethod = exports.DEFAULT_FIRMWARE_RANGE = void 0;
-const connect_common_1 = require("@trezor/connect-common");
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../constants");
-const config_1 = require("../data/config");
-const events_1 = require("../events");
-const urlUtils_1 = require("../utils/urlUtils");
-exports.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'
-  }
-};
+import { ERRORS, UI_REQUEST } from "@trezor/connect-common";
+import { isStaticSessionId } from "@trezor/device-utils";
+import { isNotUndefined, isUUID, versionUtils } from "@trezor/utils";
+import { DEFAULT_FIRMWARE_RANGE, getFirmwareRange } from "../api/common/paramsValidator.js";
+import * as enabledNetworksStore from "../data/enabledNetworksStore.js";
+import { isDebugFirmware } from "../utils/firmwareUtils.js";
+export { DEFAULT_FIRMWARE_RANGE };
 function validateStaticSessionId(input) {
-  if (typeof input !== 'string') throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'DeviceState: invalid staticSessionId: ' + input);
-  const [firstTestnetAddress, rest] = input.split('@');
-  const [deviceId, instance] = rest.split(':');
-  if (typeof firstTestnetAddress === 'string' && typeof deviceId === 'string' && typeof instance === 'string' && Number.parseInt(instance) >= 0) {
-    return input;
+  if (!isStaticSessionId(input)) {
+    throw ERRORS.TypedError('Method_InvalidParameter', 'DeviceState: invalid staticSessionId: ' + input);
+  }
+  return input;
+}
+function validateCallId(callId) {
+  if (callId === undefined) return undefined;
+  if (!isUUID(callId)) {
+    throw ERRORS.TypedError('Method_InvalidParameter', `callId must be a valid UUID, got: ${callId}`);
   }
-  throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'DeviceState: invalid staticSessionId: ' + input);
+  return callId;
 }
-function validateDeviceState(input) {
+function validateDeviceState(device) {
+  if (!device || !('state' in device)) return {};
+  const input = device.state;
   if (typeof input === 'string') {
     return {
       staticSessionId: validateStaticSessionId(input)
@@ -70,19 +41,17 @@ function validateDeviceState(input) {
   }
   return undefined;
 }
-class AbstractMethod {
+export class AbstractMethod {
   responseID;
+  callId;
   device;
   params;
   deviceState;
-  hasExpectedDeviceState;
   keepSession;
   skipFinalReload;
-  skipFirmwareCheck;
   overridePreviousCall;
   overridden;
   name;
-  payload;
   get info() {
     return '';
   }
@@ -94,147 +63,102 @@ class AbstractMethod {
   useDeviceState;
   preauthorized;
   useEmptyPassphrase;
-  allowSeedlessDevice;
-  firmwareRange;
-  requiredPermissions;
+  toCoinSymbol(shortcut) {
+    return shortcut.toLowerCase();
+  }
+  coinPerm(permission, coin) {
+    return coin ? {
+      permission,
+      coin: this.toCoinSymbol(coin.shortcut)
+    } : {
+      permission
+    };
+  }
+  coinPerms(permission, coins) {
+    const seen = new Set();
+    const out = [];
+    let hasCoinless = false;
+    for (const c of coins) {
+      if (!c) {
+        if (!hasCoinless) {
+          hasCoinless = true;
+          out.push({
+            permission
+          });
+        }
+        continue;
+      }
+      const coin = this.toCoinSymbol(c.shortcut);
+      if (seen.has(coin)) continue;
+      seen.add(coin);
+      out.push({
+        permission,
+        coin
+      });
+    }
+    return out;
+  }
   allowDeviceMode;
-  requireDeviceMode;
   requiredDeviceCapabilities = [];
-  network;
+  requiredFirmwareCapabilities = [];
+  requiredFirmwareCoins = [];
   useCardanoDerivation;
-  noBackupConfirmationMode;
-  postMessage;
-  createUiPromise;
-  constructor(message) {
+  confirmMissingBackup;
+  constructor(message, params) {
     const {
       payload
     } = message;
     this.name = payload.method;
-    this.payload = payload;
-    this.responseID = message.id || 0;
-    this.deviceState = validateDeviceState(payload.device?.state);
-    this.hasExpectedDeviceState = payload.device ? Object.prototype.hasOwnProperty.call(payload.device, 'state') : false;
+    this.params = params;
+    this.responseID = message.id ?? '';
+    this.callId = validateCallId(payload.callId);
+    this.deviceState = validateDeviceState(payload.device);
     this.keepSession = typeof payload.keepSession === 'boolean' ? payload.keepSession : false;
-    this.skipFinalReload = typeof payload.skipFinalReload === 'boolean' ? payload.skipFinalReload : true;
-    this.skipFirmwareCheck = false;
-    this.overridePreviousCall = typeof payload.override === 'boolean' ? payload.override : false;
+    this.skipFinalReload = true;
+    this.overridePreviousCall = false;
     this.overridden = false;
-    this.useEmptyPassphrase = typeof payload.useEmptyPassphrase === 'boolean' ? payload.useEmptyPassphrase : false;
-    this.allowSeedlessDevice = typeof payload.allowSeedlessDevice === 'boolean' ? payload.allowSeedlessDevice : false;
-    this.allowDeviceMode = [];
-    this.requireDeviceMode = [];
-    if (this.allowSeedlessDevice) {
-      this.allowDeviceMode = [events_1.UI.SEEDLESS];
-    }
-    this.network = 'bitcoin';
-    (0, utils_1.typedObjectKeys)(constants_1.NETWORK.TYPES).forEach(key => {
-      if (this.name.startsWith(key)) {
-        this.network = key;
-      }
-    });
-    this.firmwareRange = exports.DEFAULT_FIRMWARE_RANGE;
-    this.requiredPermissions = [];
+    this.useEmptyPassphrase = typeof payload.device?.useEmptyPassphrase === 'boolean' ? payload.device.useEmptyPassphrase : false;
+    this.allowDeviceMode = [UI_REQUEST.SEEDLESS];
     this.useDevice = true;
     this.useDeviceState = true;
     this.useUi = true;
-    this.useCardanoDerivation = typeof payload.useCardanoDerivation === 'boolean' ? payload.useCardanoDerivation : payload.method.startsWith('cardano');
-    this.noBackupConfirmationMode = 'never';
+    this.useCardanoDerivation = false;
+    this.confirmMissingBackup = false;
+  }
+  resolveCardanoCapability() {
+    this.useCardanoDerivation = enabledNetworksStore.has('ada') || enabledNetworksStore.has('tada');
   }
   setDevice(device) {
     this.device = device;
-    const originalFn = this.createUiPromise;
-    this.createUiPromise = (t, d) => originalFn(t, d || device);
   }
-  getOriginPermissions({
-    origin
-  }) {
-    if (!origin) {
-      return [];
-    }
-    return connect_common_1.storage.loadForOrigin(origin)?.permissions || [];
-  }
-  checkPermissions({
-    origin
-  }) {
-    const originPermissions = this.getOriginPermissions({
-      origin
-    });
-    let notPermitted = [...this.requiredPermissions];
-    if (originPermissions.length > 0) {
-      notPermitted = notPermitted.filter(np => {
-        const granted = originPermissions.find(p => p.type === np && p.device === this.device.features.device_id);
-        return !granted;
-      });
-    }
-    this.requiredPermissions = notPermitted;
-  }
-  savePermissions(temporary = false, {
-    origin
-  }) {
-    const originPermissions = this.getOriginPermissions({
-      origin
-    });
-    let permissionsToSave = this.requiredPermissions.map(p => ({
-      type: p,
-      device: this.device.features.device_id || undefined
-    }));
-    let emitEvent = false;
-    if (this.requiredPermissions.indexOf('read') >= 0) {
-      const wasAlreadyGranted = originPermissions.filter(p => p.type === 'read' && p.device === this.device.features.device_id);
-      if (wasAlreadyGranted.length < 1) {
-        emitEvent = true;
-      }
-    }
-    if (originPermissions.length > 0) {
-      permissionsToSave = permissionsToSave.filter(p2s => {
-        const granted = originPermissions.find(p => p.type === p2s.type && p.device === p2s.device);
-        return !granted;
-      });
-    }
-    connect_common_1.storage.saveForOrigin(state => ({
-      ...state,
-      permissions: [...(state.permissions || []), ...permissionsToSave]
-    }), origin, temporary);
-    if (emitEvent) {
-      this.postMessage((0, events_1.createDeviceMessage)(events_1.DEVICE.CONNECT, this.device.toMessageObject()));
+  getDevice() {
+    if (!this.device) {
+      throw ERRORS.TypedError('Device_NotFound');
     }
+    return this.device;
   }
   checkFirmwareRange() {
-    if (this.skipFirmwareCheck) {
-      return;
-    }
-    const {
-      device
-    } = this;
+    const device = this.getDevice();
     if (!device.features || device.isBootloader()) return;
     if (device.isSeedless()) return;
-    const range = this.firmwareRange[device.features.internal_model];
+    const firmwareRange = getFirmwareRange([this.name, ...this.requiredFirmwareCapabilities], this.requiredFirmwareCoins.filter(isNotUndefined), DEFAULT_FIRMWARE_RANGE, isDebugFirmware(device.features));
+    const range = firmwareRange[device.features.internal_model];
     if (device.firmwareStatus === 'none') {
-      return events_1.UI.FIRMWARE_NOT_INSTALLED;
+      return UI_REQUEST.FIRMWARE_NOT_INSTALLED;
     }
     if (!range) {
       return;
     }
     if (range.min === '0') {
-      return events_1.UI.FIRMWARE_NOT_SUPPORTED;
+      return UI_REQUEST.FIRMWARE_NOT_SUPPORTED;
     }
     const version = device.getVersion();
     if (!version) return;
-    if (this.name !== 'backupDevice' && this.name !== 'recoveryDevice' && (device.firmwareStatus === 'required' || !utils_1.versionUtils.isNewerOrEqual(version, range.min))) {
-      return events_1.UI.FIRMWARE_OLD;
+    if (this.name !== 'backupDevice' && this.name !== 'recoveryDevice' && (device.firmwareStatus === 'required' || !versionUtils.isNewerOrEqual(version, range.min))) {
+      return UI_REQUEST.FIRMWARE_OLD;
     }
-    if (range.max !== '0' && utils_1.versionUtils.isNewer(version, range.max)) {
-      return events_1.UI.FIRMWARE_NOT_COMPATIBLE;
-    }
-  }
-  isManagementRestricted({
-    popup,
-    origin
-  }) {
-    if (popup && this.requiredPermissions.includes('management')) {
-      const host = (0, urlUtils_1.getHost)(origin);
-      const allowed = config_1.config.management.find(item => item.origin === host || item.origin === origin);
-      return !allowed;
+    if (range.max !== '0' && versionUtils.isNewer(version, range.max)) {
+      return UI_REQUEST.FIRMWARE_NOT_COMPATIBLE;
     }
   }
   getMethodInfo() {
@@ -253,15 +177,13 @@ class AbstractMethod {
     return Promise.resolve(undefined);
   }
   checkDeviceCapability() {
-    const deviceHasAllRequiredCapabilities = (this.requiredDeviceCapabilities || []).every(capability => this.device.features.capabilities.includes(capability));
+    const deviceHasAllRequiredCapabilities = (this.requiredDeviceCapabilities || []).every(capability => this.getDevice().features.capabilities.includes(capability));
     if (!deviceHasAllRequiredCapabilities) {
-      if (this.device.firmwareType === 'bitcoin-only') {
-        throw constants_1.ERRORS.TypedError('Device_MissingCapabilityBtcOnly', `Trezor has Bitcoin-only firmware installed, which does not support this operation. Please install Universal firmware through Trezor Suite.`);
+      if (this.getDevice().firmwareType === 'bitcoin-only') {
+        throw ERRORS.TypedError('Device_MissingCapabilityBtcOnly', `Trezor has Bitcoin-only firmware installed, which does not support this operation. Please install Universal firmware through Trezor Suite.`);
       }
-      throw constants_1.ERRORS.TypedError('Device_MissingCapability', 'Device does not have capability to call this method. Make sure you have the latest firmware installed.');
+      throw ERRORS.TypedError('Device_MissingCapability', 'Device does not have capability to call this method. Make sure you have the latest firmware installed.');
     }
   }
   dispose() {}
-}
-exports.AbstractMethod = AbstractMethod;
-//# sourceMappingURL=AbstractMethod.js.map
+}

package/lib/core/index.d.ts

@@ -1,32 +1,29 @@
 import EventEmitter from 'events';
-import { AbstractMethod } from './AbstractMethod';
-import { CoreEventMessage, CoreRequestMessage, TransportInfo } from '../events';
-import type { ConnectSettings } from '../types';
-import { LogWriter } from '../utils/debug';
+import type { ConnectSettings, CoreEventMessage, CoreRequestMessage, TransportInfo } from '@trezor/connect-common';
+import { type LogWriter } from '@trezor/connect-common/lib/utils/debug';
+import type { AbstractMethod } from "./AbstractMethod.js";
 export declare class Core extends EventEmitter {
-    private abortController;
-    private callMethods;
-    private popupPromise;
-    private methodSynchronize;
-    private uiPromises;
-    private waitForFirstMethod;
-    private _interactionTimeout?;
-    private get interactionTimeout();
-    private _deviceList?;
-    private get deviceList();
-    private sendCoreMessage;
-    private getCoreContext;
-    handleMessage(message: CoreRequestMessage): void;
-    dispose(): void;
-    getCurrentMethod(): Promise<AbstractMethod<any, undefined>>;
-    getActiveTransports(): TransportInfo[] | undefined;
-    enumerate(): void;
-    init(settings: ConnectSettings, onCoreEvent: (message: CoreEventMessage) => void, logWriterFactory?: () => LogWriter | undefined): Promise<void>;
+  private abortController;
+  private callMethods;
+  private methodSynchronize;
+  private uiPromises;
+  private createLogger;
+  private coreLogger;
+  private waitForFirstMethod;
+  private _deviceList?;
+  private get deviceList();
+  private sendCoreMessage;
+  private getCoreContext;
+  handleMessage(message: CoreRequestMessage): void;
+  dispose(): void;
+  getCurrentMethod(): Promise<AbstractMethod<any, undefined> | undefined>;
+  getActiveTransports(): TransportInfo[] | undefined;
+  enumerate(): void;
+  init(settings: ConnectSettings, onCoreEvent: (message: CoreEventMessage) => void, logWriterFactory?: () => LogWriter | undefined): Promise<void>;
 }
 export declare const initCoreState: () => {
-    get: () => Core | undefined;
-    getPending: () => Promise<Core> | undefined;
-    getOrInit: (settings: ConnectSettings, onCoreEvent: (message: CoreEventMessage) => void, logWriterFactory?: (() => LogWriter | undefined) | undefined) => Promise<Core>;
-    dispose: () => void;
-};
-//# sourceMappingURL=index.d.ts.map
+  get: () => Core | undefined;
+  getPending: () => Promise<Core> | undefined;
+  getOrInit: (settings: ConnectSettings, onCoreEvent: (message: CoreEventMessage) => void, logWriterFactory?: (() => LogWriter | undefined) | undefined) => Promise<Core>;
+  dispose: () => void;
+};