@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/events/ui-promise.d.ts

@@ -1,20 +1,20 @@
+import type { DEVICE, UiResponseEvent } from '@trezor/connect-common';
 import type { Deferred } from '@trezor/utils';
-import type { DEVICE } from './device';
-import type { UiResponseEvent } from './ui-response';
-import type { Device } from '../device/Device';
-export type UiPromiseResponse = UiResponseEvent | {
-    type: typeof DEVICE.DISCONNECT;
-    payload?: undefined;
+import type { IDevice } from "../types/idevice.js";
+export type UiPromiseResponse = (UiResponseEvent & {
+  requestId?: string;
+}) | {
+  type: typeof DEVICE.DISCONNECT;
+  payload?: undefined;
+  requestId?: string;
 };
 export type UiPromise<T extends UiPromiseResponse['type']> = Deferred<Extract<UiPromiseResponse, {
-    type: T;
+  type: T;
 }>, T> & {
-    device?: Device;
-};
-type UiPromiseMap = {
-    [T in UiPromiseResponse['type']]: UiPromise<T>;
+  device?: IDevice;
+  requestId: string;
 };
+type UiPromiseMap = { [T in UiPromiseResponse['type']]: UiPromise<T> };
 export type AnyUiPromise = UiPromiseMap[UiPromiseResponse['type']];
-export type UiPromiseCreator = <T extends UiPromiseResponse['type']>(type: T, device?: Device) => UiPromise<T>;
-export {};
-//# sourceMappingURL=ui-promise.d.ts.map
+export type UiPromiseCreator = <T extends UiPromiseResponse['type']>(type: T, device?: IDevice) => UiPromise<T>;
+export {};

package/lib/events/ui-promise.js

@@ -1,6 +1 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=ui-promise.js.map
+export {};

package/lib/exports.d.ts

@@ -1,5 +1,3 @@
-export * from './constants';
-export * from './events';
-export * from './types';
-export { parseConnectSettings } from './data/connectSettings';
-//# sourceMappingURL=exports.d.ts.map
+export * from '@trezor/connect-common';
+export { MessagesSchema as PROTO } from '@trezor/protobuf';
+export { TRANSPORT } from '@trezor/transport-common';

package/lib/exports.js

@@ -1,18 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parseConnectSettings = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./constants"), exports);
-tslib_1.__exportStar(require("./events"), exports);
-tslib_1.__exportStar(require("./types"), exports);
-var connectSettings_1 = require("./data/connectSettings");
-Object.defineProperty(exports, "parseConnectSettings", {
-  enumerable: true,
-  get: function () {
-    return connectSettings_1.parseConnectSettings;
-  }
-});
-//# sourceMappingURL=exports.js.map
+export * from "@trezor/connect-common";
+export { MessagesSchema as PROTO } from "@trezor/protobuf";
+export { TRANSPORT } from "@trezor/transport-common";

package/lib/impl/core-in-module.d.ts

@@ -1,35 +1,33 @@
-import EventEmitter from 'events';
-import { CallMethodPayload, CoreEventMessage, CoreRequestMessage, UiResponseEvent } from '../events';
-import { ConnectFactoryDependencies } from '../factory';
-import type { ConnectSettings, ConnectSettingsPublic, DeviceIdentity, Manifest } from '../types';
-import type { SetTransports } from '../types/api/setTransports';
-export declare class CoreInModule implements ConnectFactoryDependencies<ConnectSettingsPublic> {
-    eventEmitter: EventEmitter<[never]>;
-    _settings: ConnectSettings;
-    private _coreManager?;
-    private _log;
-    private _messagePromises;
-    private readonly boundOnCoreEvent;
-    private onCoreHook?;
-    constructor(onCoreHook?: (message: CoreEventMessage) => CoreEventMessage);
-    private initCoreManager;
-    manifest(data: Manifest): void;
-    dispose(): Promise<undefined>;
-    cancel(error?: string): void;
-    handleCoreMessage(message: CoreRequestMessage): void;
-    private onCoreEvent;
-    init(settings?: Partial<ConnectSettings>): Promise<void>;
-    setTransports({ transports }: SetTransports): void;
-    call(params: CallMethodPayload): Promise<import("../types").Unsuccessful | {
-        id: number;
-        success: boolean;
-        payload: any;
-        device?: DeviceIdentity;
-    }>;
-    uiResponse(response: UiResponseEvent): void;
-}
-export declare const TrezorConnect: Omit<import("../types").TrezorConnect, "init"> & {
-    init: import("../types/api/init").InitType<Record<string, any>>;
-    call: import("../events").CallMethod;
-} & Record<string, any>;
-//# sourceMappingURL=core-in-module.d.ts.map
+import type { CallMethodPayload, ConnectSettings, CoreRequestMessage, MethodResponseMessage, TrezorConnectCore, UiResponseEvent, UpdateConnectSettings } from '@trezor/connect-common';
+import { ERRORS } from '@trezor/connect-common/lib/constants';
+import { ConnectEmitter } from '@trezor/connect-common/lib/types/emitter';
+import { type CancelParams } from '@trezor/connect-common/lib/utils/cancelParams';
+import { type AbstractTransportParams, type Transport } from '@trezor/transport-common';
+export declare abstract class CoreInModule implements TrezorConnectCore<ConnectSettings> {
+  private readonly eventEmitter;
+  on: ConnectEmitter['on'];
+  off: ConnectEmitter['removeListener'];
+  removeAllListeners: ConnectEmitter['removeAllListeners'];
+  protected settings: ConnectSettings;
+  private coreManager;
+  private log;
+  private messagePromises;
+  private readonly boundOnCoreEvent;
+  protected abstract defaultTransports(params: AbstractTransportParams): Transport[];
+  private buildDefaultTransports;
+  constructor();
+  protected handleCoreMessage(message: CoreRequestMessage): void;
+  private onCoreEvent;
+  init(settings: Partial<ConnectSettings>): Promise<void>;
+  protected abstract updateProxy(proxy: UpdateConnectSettings['proxy']): Promise<void>;
+  updateConnectSettings(params: UpdateConnectSettings): Promise<import("@trezor/type-utils").Err<ERRORS.SerializedError> | {
+    readonly success: true;
+    readonly payload: {
+      readonly message: "success";
+    };
+  }>;
+  call(params: CallMethodPayload): Promise<import("@trezor/type-utils").Err<ERRORS.SerializedError> | Omit<MethodResponseMessage, "type" | "event">>;
+  uiResponse(response: UiResponseEvent): void;
+  cancel(params?: CancelParams): void;
+  dispose(): void;
+}

package/lib/impl/core-in-module.js

@@ -1,216 +1,194 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TrezorConnect = exports.CoreInModule = void 0;
-const tslib_1 = require("tslib");
-const events_1 = tslib_1.__importDefault(require("events"));
-const utils_1 = require("@trezor/utils");
-const ERRORS = tslib_1.__importStar(require("../constants/errors"));
-const connectSettings_1 = require("../data/connectSettings");
-const events_2 = require("../events");
-const factory_1 = require("../factory");
-const debug_1 = require("../utils/debug");
-class CoreInModule {
-  eventEmitter = new events_1.default();
-  _settings;
-  _coreManager;
-  _log;
-  _messagePromises;
+import { BLOCKCHAIN_EVENT, CORE_CALL, DEVICE_EVENT, RESPONSE_EVENT, SET_ENABLED_NETWORKS, TRANSPORT_EVENT, UI_EVENT, createErrorMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { parseConnectSettings } from "@trezor/connect-common/lib/data/connectSettings.js";
+import { ConnectEmitter } from "@trezor/connect-common/lib/types/emitter.js";
+import { createCoreCallCancelMessage } from "@trezor/connect-common/lib/utils/cancelParams.js";
+import { noopLogger } from "@trezor/connect-common/lib/utils/debug.js";
+import { createUUIDDeferredManager } from "@trezor/connect-common/lib/utils/deferred.js";
+import { TRANSPORT } from "@trezor/transport-common";
+import { cloneObject } from "@trezor/utils";
+import { initCoreState } from "../core/index.js";
+export class CoreInModule {
+  eventEmitter = new ConnectEmitter();
+  on = this.eventEmitter.on.bind(this.eventEmitter);
+  off = this.eventEmitter.removeListener.bind(this.eventEmitter);
+  removeAllListeners = this.eventEmitter.removeAllListeners.bind(this.eventEmitter);
+  settings;
+  coreManager;
+  log;
+  messagePromises;
   boundOnCoreEvent = this.onCoreEvent.bind(this);
-  onCoreHook;
-  constructor(onCoreHook) {
-    this._settings = (0, connectSettings_1.parseConnectSettings)();
-    this._log = (0, debug_1.initLog)('@trezor/connect-web');
-    this._messagePromises = (0, utils_1.createDeferredManager)({
-      initialId: 1
+  buildDefaultTransports() {
+    return this.defaultTransports({
+      logger: this.settings.createLogger?.('@trezor/transport'),
+      id: this.settings.manifest?.appName || this.settings.manifest?.appUrl || 'unknown app'
     });
-    this.onCoreHook = onCoreHook;
   }
-  async initCoreManager() {
-    const {
-      connectSrc
-    } = this._settings;
-    const connectCorePath = `${connectSrc}js/core.js`;
-    const importResult = await Promise.resolve(`${connectCorePath}`).then(s => tslib_1.__importStar(require(s))).catch(_err => {
-      this._log.error(`_err: Cannot load "${connectCorePath}"`, _err);
-    });
-    if (!importResult) {
-      this._log.error(`importResult is empty! Cannot load "${connectCorePath}"`);
-      throw new Error(`importResult is empty! Cannot load "${connectCorePath}"`);
-    }
-    const {
-      initCoreState
-    } = importResult;
-    if (!initCoreState) return;
-    this._coreManager = initCoreState();
-    return this._coreManager;
-  }
-  manifest(data) {
-    this._settings = (0, connectSettings_1.parseConnectSettings)({
-      ...this._settings,
-      manifest: data
-    });
-  }
-  dispose() {
-    this.eventEmitter.removeAllListeners();
-    this._settings = (0, connectSettings_1.parseConnectSettings)();
-    if (this._coreManager) {
-      this._coreManager.dispose();
-    }
-    return Promise.resolve(undefined);
-  }
-  cancel(error) {
-    if (this._coreManager) {
-      const core = this._coreManager.get();
-      if (!core) {
-        throw ERRORS.TypedError('Runtime', 'postMessage: _core not found');
-      }
-      this.handleCoreMessage({
-        type: events_2.POPUP.CLOSED,
-        payload: error ? {
-          error
-        } : null
-      });
-    }
+  constructor() {
+    this.settings = parseConnectSettings();
+    this.log = noopLogger;
+    this.coreManager = initCoreState();
+    this.messagePromises = createUUIDDeferredManager();
   }
   handleCoreMessage(message) {
-    const core = this._coreManager.get();
+    const core = this.coreManager.get();
     if (!core) {
       throw ERRORS.TypedError('Runtime', 'postMessage: _core not found');
     }
     core.handleMessage(message);
   }
   onCoreEvent(rawMessage) {
-    let message = (0, utils_1.cloneObject)(rawMessage);
-    if (this.onCoreHook) {
-      message = this.onCoreHook(message);
-    }
+    const message = cloneObject(rawMessage);
     const {
       event,
       type,
       payload
     } = message;
-    if (type === events_2.UI.REQUEST_UI_WINDOW) {
-      this._coreManager.get()?.handleMessage({
-        type: events_2.POPUP.HANDSHAKE
-      });
-      return;
-    }
-    if (type === events_2.POPUP.CANCEL_POPUP_REQUEST) return;
     switch (event) {
-      case events_2.RESPONSE_EVENT:
+      case RESPONSE_EVENT:
         {
           const {
-            id = 0,
+            id = '',
             success,
             device
           } = message;
-          const resolved = this._messagePromises.resolve(id, {
+          const resolved = this.messagePromises.resolve(id, success ? {
             id,
             success,
-            payload,
+            payload: message.payload,
+            device
+          } : {
+            id,
+            success,
+            error: message.error,
             device
           });
-          if (!resolved) this._log.warn(`Unknown message id ${id}`);
+          if (!resolved) this.log.warn(`Unknown message id ${id}`);
           break;
         }
-      case events_2.DEVICE_EVENT:
+      case DEVICE_EVENT:
         this.eventEmitter.emit(event, message);
         this.eventEmitter.emit(type, payload);
         break;
-      case events_2.TRANSPORT_EVENT:
+      case TRANSPORT_EVENT:
         this.eventEmitter.emit(event, message);
         this.eventEmitter.emit(type, payload);
         break;
-      case events_2.BLOCKCHAIN_EVENT:
+      case BLOCKCHAIN_EVENT:
         this.eventEmitter.emit(event, message);
         this.eventEmitter.emit(type, payload);
         break;
-      case events_2.UI_EVENT:
+      case UI_EVENT:
         this.eventEmitter.emit(event, message);
         this.eventEmitter.emit(type, payload);
         break;
       default:
-        this._log.warn('Undefined message', event, message);
+        this.log.warn('Undefined message', event, message);
     }
   }
-  async init(settings = {}) {
-    if (this._coreManager && (this._coreManager.get() || this._coreManager.getPending())) {
+  async init(settings) {
+    if (this.coreManager.get() || this.coreManager.getPending()) {
       throw ERRORS.TypedError('Init_AlreadyInitialized');
     }
-    this._settings = (0, connectSettings_1.parseConnectSettings)({
-      ...this._settings,
+    this.settings = parseConnectSettings({
+      ...this.settings,
       ...settings
     });
-    if (!this._settings.manifest) {
+    if (!this.settings.manifest) {
       throw ERRORS.TypedError('Init_ManifestMissing');
     }
-    this._settings.lazyLoad = true;
-    if (!this._settings.transports?.length) {
-      this._settings.transports = ['BridgeTransport', 'WebUsbTransport'];
-    }
-    if (!this._coreManager) {
-      this._coreManager = await this.initCoreManager();
-      await this._coreManager.getOrInit(this._settings, this.boundOnCoreEvent);
+    this.log = this.settings.createLogger?.('@trezor/connect') ?? noopLogger;
+    if (!this.settings.transports?.length) {
+      this.settings.transports = this.buildDefaultTransports();
     }
-    this._log.enabled = !!this._settings.debug;
+    await this.coreManager.getOrInit(this.settings, this.boundOnCoreEvent);
   }
-  setTransports({
-    transports
-  }) {
-    if (!transports?.length) {
-      transports = ['BridgeTransport', 'WebUsbTransport'];
+  async updateConnectSettings(params) {
+    const {
+      proxy,
+      transports: newTransports,
+      enabledNetworks
+    } = params;
+    try {
+      await this.updateProxy(proxy);
+    } catch (err) {
+      return Promise.resolve(createErrorMessage(err));
     }
-    this._settings = (0, connectSettings_1.parseConnectSettings)({
-      ...this._settings,
-      transports
-    });
-    this.handleCoreMessage({
-      type: events_2.TRANSPORT.SET_TRANSPORTS,
+    if (!this.coreManager.get()) {
+      const pending = this.coreManager.getPending();
+      if (pending) {
+        await pending;
+      }
+    }
+    try {
+      if (newTransports !== undefined) {
+        const transports = newTransports?.length ? newTransports : this.buildDefaultTransports();
+        this.settings = parseConnectSettings({
+          ...this.settings,
+          transports
+        });
+        this.handleCoreMessage({
+          type: TRANSPORT.SET_TRANSPORTS,
+          payload: {
+            transports
+          }
+        });
+      }
+      if (enabledNetworks !== undefined) {
+        this.handleCoreMessage({
+          type: SET_ENABLED_NETWORKS,
+          payload: enabledNetworks
+        });
+      }
+    } catch (err) {
+      return Promise.resolve(createErrorMessage(err));
+    }
+    return {
+      success: true,
       payload: {
-        transports
+        message: 'success'
       }
-    });
+    };
   }
   async call(params) {
     try {
+      if (!this.settings.manifest) {
+        throw ERRORS.TypedError('Init_ManifestMissing');
+      }
+      if (!this.coreManager.get()) {
+        const pending = this.coreManager.getPending();
+        if (pending) {
+          await pending;
+        }
+      }
       const {
         promiseId,
         promise
-      } = this._messagePromises.create();
-      const payload = (0, utils_1.cloneObject)(params);
+      } = this.messagePromises.create();
+      const payload = cloneObject(params);
       this.handleCoreMessage({
-        type: events_2.IFRAME.CALL,
+        type: CORE_CALL,
         id: promiseId,
         payload
       });
-      const response = (0, utils_1.cloneObject)(await promise);
-      return response ?? (0, events_2.createErrorMessage)(ERRORS.TypedError('Method_NoResponse'));
+      const response = cloneObject(await promise);
+      return response ?? createErrorMessage(ERRORS.TypedError('Method_NoResponse'));
     } catch (error) {
-      this._log.error('call', error);
-      return (0, events_2.createErrorMessage)(error);
+      this.log.error('call', error);
+      return createErrorMessage(error);
     }
   }
   uiResponse(response) {
-    const core = this._coreManager.get();
-    if (!core) {
-      throw ERRORS.TypedError('Runtime', 'postMessage: _core not found');
-    }
     this.handleCoreMessage(response);
   }
-}
-exports.CoreInModule = CoreInModule;
-const impl = new CoreInModule();
-exports.TrezorConnect = (0, factory_1.factory)({
-  eventEmitter: impl.eventEmitter,
-  manifest: impl.manifest.bind(impl),
-  init: impl.init.bind(impl),
-  call: impl.call.bind(impl),
-  setTransports: impl.setTransports.bind(impl),
-  uiResponse: impl.uiResponse.bind(impl),
-  cancel: impl.cancel.bind(impl),
-  dispose: impl.dispose.bind(impl)
-});
-//# sourceMappingURL=core-in-module.js.map
+  cancel(params) {
+    this.handleCoreMessage(createCoreCallCancelMessage(params));
+  }
+  dispose() {
+    this.eventEmitter.removeAllListeners();
+    this.settings = parseConnectSettings();
+    if (this.coreManager.get()) {
+      this.coreManager.dispose();
+    }
+  }
+}

package/lib/index.browser.d.ts

@@ -0,0 +1,7 @@
+import { type TrezorConnectPrivilegedAPI } from '@trezor/connect-common';
+type TrezorConnectBrowserAPI = TrezorConnectPrivilegedAPI & {
+  requestWebUSBDevice: () => Promise<void>;
+};
+declare const TrezorConnect: TrezorConnectBrowserAPI;
+export default TrezorConnect;
+export * from "./exports.js";

package/lib/index.browser.js

@@ -0,0 +1,34 @@
+import { ERRORS, factoryPrivileged } from "@trezor/connect-common";
+import { BridgeTransport, TRANSPORT } from "@trezor/transport-common";
+import { WebUsbTransport } from "@trezor/transport-web";
+import { config } from "./data/config.js";
+import { CoreInModule } from "./impl/core-in-module.js";
+class CoreInModuleWeb extends CoreInModule {
+  defaultTransports(params) {
+    return [new BridgeTransport(params), new WebUsbTransport(params)];
+  }
+  updateProxy(proxy) {
+    if (proxy !== undefined) {
+      throw ERRORS.TypedError('Method_InvalidPackage', 'proxy setting is not supported in web environment');
+    }
+    return Promise.resolve();
+  }
+  async requestWebUSBDevice() {
+    try {
+      await window.navigator.usb.requestDevice({
+        filters: config.webusb
+      });
+      this.handleCoreMessage({
+        type: TRANSPORT.REQUEST_DEVICE
+      });
+    } catch {}
+  }
+}
+const TrezorConnect = factoryPrivileged(new CoreInModuleWeb());
+export default TrezorConnect;
+export * from "./exports.js";
+if (typeof window !== 'undefined') {
+  window.addEventListener('beforeunload', () => {
+    TrezorConnect.dispose();
+  });
+}

package/lib/index.d.ts

@@ -1,10 +1,4 @@
-import EventEmitter from 'events';
-import { CallMethod } from './events';
-export declare const eventEmitter: EventEmitter<[never]>;
-declare const TrezorConnect: Omit<import("./types").TrezorConnect, "init"> & {
-    init: import("./types/api/init").InitType<Record<string, any>>;
-    call: CallMethod;
-};
+import { type TrezorConnectPrivilegedAPI } from '@trezor/connect-common';
+declare const TrezorConnect: TrezorConnectPrivilegedAPI;
 export default TrezorConnect;
-export * from './exports';
-//# sourceMappingURL=index.d.ts.map
+export * from "./exports.js";