@trezor/connect 9.7.0-beta.1 → 9.7.0

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

@@ -1,5 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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"));
@@ -10,211 +13,204 @@ 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;
-    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 });
-        this.onCoreHook = onCoreHook;
+  eventEmitter = new events_1.default();
+  _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
+    });
+    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}"`);
     }
-    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;
+    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();
     }
-    manifest(data) {
-        this._settings = (0, connectSettings_1.parseConnectSettings)({
-            ...this._settings,
-            manifest: data,
-        });
+    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
+      });
     }
-    dispose() {
-        this.eventEmitter.removeAllListeners();
-        this._settings = (0, connectSettings_1.parseConnectSettings)();
-        if (this._coreManager) {
-            this._coreManager.dispose();
-        }
-        return Promise.resolve(undefined);
+  }
+  handleCoreMessage(message) {
+    const core = this._coreManager.get();
+    if (!core) {
+      throw ERRORS.TypedError('Runtime', 'postMessage: _core not found');
     }
-    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,
-            });
-        }
+    core.handleMessage(message);
+  }
+  onCoreEvent(rawMessage) {
+    let message = (0, utils_1.cloneObject)(rawMessage);
+    if (this.onCoreHook) {
+      message = this.onCoreHook(message);
     }
-    handleCoreMessage(message) {
-        const core = this._coreManager.get();
-        if (!core) {
-            throw ERRORS.TypedError('Runtime', 'postMessage: _core not found');
-        }
-        core.handleMessage(message);
+    const {
+      event,
+      type,
+      payload
+    } = message;
+    if (type === events_2.UI.REQUEST_UI_WINDOW) {
+      this._coreManager.get()?.handleMessage({
+        type: events_2.POPUP.HANDSHAKE
+      });
+      return;
     }
-    onCoreEvent(rawMessage) {
-        let message = (0, utils_1.cloneObject)(rawMessage);
-        if (this.onCoreHook) {
-            message = this.onCoreHook(message);
-        }
-        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: {
-                const { id = 0, success, device } = message;
-                const resolved = this._messagePromises.resolve(id, {
-                    id,
-                    success,
-                    payload,
-                    device,
-                });
-                if (!resolved)
-                    this._log.warn(`Unknown message id ${id}`);
-                break;
-            }
-            case events_2.DEVICE_EVENT:
-                this.eventEmitter.emit(event, message);
-                this.eventEmitter.emit(type, payload);
-                break;
-            case events_2.TRANSPORT_EVENT:
-                this.eventEmitter.emit(event, message);
-                this.eventEmitter.emit(type, payload);
-                break;
-            case events_2.BLOCKCHAIN_EVENT:
-                this.eventEmitter.emit(event, message);
-                this.eventEmitter.emit(type, payload);
-                break;
-            case events_2.UI_EVENT:
-                this.eventEmitter.emit(event, message);
-                this.eventEmitter.emit(type, payload);
-                break;
-            default:
-                this._log.warn('Undefined message', event, message);
-        }
+    if (type === events_2.POPUP.CANCEL_POPUP_REQUEST) return;
+    switch (event) {
+      case events_2.RESPONSE_EVENT:
+        {
+          const {
+            id = 0,
+            success,
+            device
+          } = message;
+          const resolved = this._messagePromises.resolve(id, {
+            id,
+            success,
+            payload,
+            device
+          });
+          if (!resolved) this._log.warn(`Unknown message id ${id}`);
+          break;
+        }
+      case events_2.DEVICE_EVENT:
+        this.eventEmitter.emit(event, message);
+        this.eventEmitter.emit(type, payload);
+        break;
+      case events_2.TRANSPORT_EVENT:
+        this.eventEmitter.emit(event, message);
+        this.eventEmitter.emit(type, payload);
+        break;
+      case events_2.BLOCKCHAIN_EVENT:
+        this.eventEmitter.emit(event, message);
+        this.eventEmitter.emit(type, payload);
+        break;
+      case events_2.UI_EVENT:
+        this.eventEmitter.emit(event, message);
+        this.eventEmitter.emit(type, payload);
+        break;
+      default:
+        this._log.warn('Undefined message', event, message);
     }
-    async init(settings = {}) {
-        if (this._coreManager && (this._coreManager.get() || this._coreManager.getPending())) {
-            throw ERRORS.TypedError('Init_AlreadyInitialized');
-        }
-        this._settings = (0, connectSettings_1.parseConnectSettings)({ ...this._settings, ...settings });
-        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.enabled = !!this._settings.debug;
+  }
+  async init(settings = {}) {
+    if (this._coreManager && (this._coreManager.get() || this._coreManager.getPending())) {
+      throw ERRORS.TypedError('Init_AlreadyInitialized');
     }
-    setTransports({ transports }) {
-        if (!transports?.length) {
-            transports = ['BridgeTransport', 'WebUsbTransport'];
-        }
-        this._settings = (0, connectSettings_1.parseConnectSettings)({ ...this._settings, transports });
-        this.handleCoreMessage({
-            type: events_2.TRANSPORT.SET_TRANSPORTS,
-            payload: { transports },
-        });
+    this._settings = (0, connectSettings_1.parseConnectSettings)({
+      ...this._settings,
+      ...settings
+    });
+    if (!this._settings.manifest) {
+      throw ERRORS.TypedError('Init_ManifestMissing');
     }
-    async call(params) {
-        try {
-            const { promiseId, promise } = this._messagePromises.create();
-            const payload = (0, utils_1.cloneObject)(params);
-            this.handleCoreMessage({
-                type: events_2.IFRAME.CALL,
-                id: promiseId,
-                payload,
-            });
-            const response = (0, utils_1.cloneObject)(await promise);
-            return response ?? (0, events_2.createErrorMessage)(ERRORS.TypedError('Method_NoResponse'));
-        }
-        catch (error) {
-            this._log.error('call', error);
-            return (0, events_2.createErrorMessage)(error);
-        }
+    this._settings.lazyLoad = true;
+    if (!this._settings.transports?.length) {
+      this._settings.transports = ['BridgeTransport', 'WebUsbTransport'];
     }
-    uiResponse(response) {
-        const core = this._coreManager.get();
-        if (!core) {
-            throw ERRORS.TypedError('Runtime', 'postMessage: _core not found');
-        }
-        this.handleCoreMessage(response);
+    if (!this._coreManager) {
+      this._coreManager = await this.initCoreManager();
+      await this._coreManager.getOrInit(this._settings, this.boundOnCoreEvent);
     }
-    async requestLogin(params) {
-        if (typeof params.callback === 'function') {
-            const { callback } = params;
-            const core = this._coreManager.get();
-            const loginChallengeListener = async (event) => {
-                const { data } = event;
-                if (data && data.type === events_2.UI.LOGIN_CHALLENGE_REQUEST) {
-                    try {
-                        const payload = await callback();
-                        this.handleCoreMessage({
-                            type: events_2.UI.LOGIN_CHALLENGE_RESPONSE,
-                            payload,
-                        });
-                    }
-                    catch (error) {
-                        this.handleCoreMessage({
-                            type: events_2.UI.LOGIN_CHALLENGE_RESPONSE,
-                            payload: error.message,
-                        });
-                    }
-                }
-            };
-            core?.on(events_2.CORE_EVENT, loginChallengeListener);
-            const response = await this.call({
-                method: 'requestLogin',
-                ...params,
-                asyncChallenge: true,
-                callback: null,
-            });
-            core?.removeListener(events_2.CORE_EVENT, loginChallengeListener);
-            return response;
-        }
-        return this.call({ method: 'requestLogin', ...params });
+    this._log.enabled = !!this._settings.debug;
+  }
+  setTransports({
+    transports
+  }) {
+    if (!transports?.length) {
+      transports = ['BridgeTransport', 'WebUsbTransport'];
+    }
+    this._settings = (0, connectSettings_1.parseConnectSettings)({
+      ...this._settings,
+      transports
+    });
+    this.handleCoreMessage({
+      type: events_2.TRANSPORT.SET_TRANSPORTS,
+      payload: {
+        transports
+      }
+    });
+  }
+  async call(params) {
+    try {
+      const {
+        promiseId,
+        promise
+      } = this._messagePromises.create();
+      const payload = (0, utils_1.cloneObject)(params);
+      this.handleCoreMessage({
+        type: events_2.IFRAME.CALL,
+        id: promiseId,
+        payload
+      });
+      const response = (0, utils_1.cloneObject)(await promise);
+      return response ?? (0, events_2.createErrorMessage)(ERRORS.TypedError('Method_NoResponse'));
+    } catch (error) {
+      this._log.error('call', error);
+      return (0, events_2.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),
-    requestLogin: impl.requestLogin.bind(impl),
-    uiResponse: impl.uiResponse.bind(impl),
-    cancel: impl.cancel.bind(impl),
-    dispose: impl.dispose.bind(impl),
+  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

package/lib/impl/dynamic.d.ts

@@ -31,7 +31,6 @@ export declare class TrezorConnectDynamic<ImplType, SettingsType extends Record<
     init(settings: InitFullSettings<SettingsType>): Promise<void>;
     setTransports({ transports }: SetTransports): void;
     call(params: CallMethodPayload): Promise<any>;
-    requestLogin(params: any): import("..").Response<import("../types/api/requestLogin").Login>;
     uiResponse(params: any): void;
     cancel(error?: string): void;
     dispose(): void;

package/lib/impl/dynamic.js

@@ -1,114 +1,125 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.TrezorConnectDynamic = void 0;
 const utils_1 = require("@trezor/utils");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const proxy_event_emitter_1 = require("../utils/proxy-event-emitter");
 class TrezorConnectDynamic {
-    eventEmitter;
-    currentTarget;
-    implementations;
-    getInitTarget;
-    handleBeforeCall;
-    handleErrorFallback;
-    lastSettings;
-    callPending = 0;
-    beforeCallSynchronize = (0, utils_1.getSynchronize)();
-    constructor({ implementations, getInitTarget, handleBeforeCall, handleErrorFallback, }) {
-        this.implementations = implementations;
-        this.currentTarget = this.implementations[0].type;
-        this.getInitTarget = getInitTarget;
-        this.handleBeforeCall = handleBeforeCall;
-        this.handleErrorFallback = handleErrorFallback;
-        this.eventEmitter = new proxy_event_emitter_1.ProxyEventEmitter(this.implementations.map(impl => impl.impl.eventEmitter));
+  eventEmitter;
+  currentTarget;
+  implementations;
+  getInitTarget;
+  handleBeforeCall;
+  handleErrorFallback;
+  lastSettings;
+  callPending = 0;
+  beforeCallSynchronize = (0, utils_1.getSynchronize)();
+  constructor({
+    implementations,
+    getInitTarget,
+    handleBeforeCall,
+    handleErrorFallback
+  }) {
+    this.implementations = implementations;
+    this.currentTarget = this.implementations[0].type;
+    this.getInitTarget = getInitTarget;
+    this.handleBeforeCall = handleBeforeCall;
+    this.handleErrorFallback = handleErrorFallback;
+    this.eventEmitter = new proxy_event_emitter_1.ProxyEventEmitter(this.implementations.map(impl => impl.impl.eventEmitter));
+  }
+  getTarget() {
+    return this.implementations.find(impl => impl.type === this.currentTarget).impl;
+  }
+  getTargetType() {
+    return this.currentTarget;
+  }
+  async switchTarget(target) {
+    if (this.currentTarget === target) {
+      return;
     }
-    getTarget() {
-        return this.implementations.find(impl => impl.type === this.currentTarget).impl;
+    if (!this.lastSettings) {
+      throw constants_1.ERRORS.TypedError('Init_ManifestMissing');
     }
-    getTargetType() {
-        return this.currentTarget;
+    const oldTargetType = this.getTargetType();
+    const oldTarget = this.getTarget();
+    try {
+      this.currentTarget = target;
+      await this.getTarget().init(this.lastSettings);
+      await oldTarget.dispose();
+    } catch {
+      this.currentTarget = oldTargetType;
     }
-    async switchTarget(target) {
-        if (this.currentTarget === target) {
-            return;
-        }
-        if (!this.lastSettings) {
-            throw constants_1.ERRORS.TypedError('Init_ManifestMissing');
-        }
-        const oldTargetType = this.getTargetType();
-        const oldTarget = this.getTarget();
-        try {
-            this.currentTarget = target;
-            await this.getTarget().init(this.lastSettings);
-            await oldTarget.dispose();
-        }
-        catch {
-            this.currentTarget = oldTargetType;
-        }
+  }
+  manifest(manifest) {
+    this.lastSettings = {
+      ...this.lastSettings,
+      manifest
+    };
+    this.getTarget().manifest(manifest);
+  }
+  async init(settings) {
+    if (!settings?.manifest) {
+      throw constants_1.ERRORS.TypedError('Init_ManifestMissing');
     }
-    manifest(manifest) {
-        this.lastSettings = { ...this.lastSettings, manifest };
-        this.getTarget().manifest(manifest);
+    this.lastSettings = settings;
+    this.currentTarget = this.getInitTarget(settings);
+    this.callPending = 0;
+    try {
+      return await this.getTarget().init(this.lastSettings);
+    } catch (error) {
+      if (await this.handleErrorFallback(error.code)) {
+        return;
+      }
+      throw error;
     }
-    async init(settings) {
-        if (!settings?.manifest) {
-            throw constants_1.ERRORS.TypedError('Init_ManifestMissing');
+  }
+  setTransports({
+    transports
+  }) {
+    this.lastSettings = {
+      ...this.lastSettings,
+      transports
+    };
+    this.getTarget().setTransports({
+      transports
+    });
+  }
+  async call(params) {
+    try {
+      if (this.callPending === 0) {
+        await this.beforeCallSynchronize(async () => {
+          this.callPending++;
+          await this.handleBeforeCall();
+        });
+      }
+      const response = await this.getTarget().call(params);
+      if (!response.success) {
+        if (await this.handleErrorFallback(response.payload.code)) {
+          return await this.getTarget().call(params);
         }
-        this.lastSettings = settings;
-        this.currentTarget = this.getInitTarget(settings);
-        this.callPending = 0;
-        try {
-            return await this.getTarget().init(this.lastSettings);
-        }
-        catch (error) {
-            if (await this.handleErrorFallback(error.code)) {
-                return;
-            }
-            throw error;
-        }
-    }
-    setTransports({ transports }) {
-        this.lastSettings = { ...this.lastSettings, transports };
-        this.getTarget().setTransports({ transports });
-    }
-    async call(params) {
-        try {
-            if (this.callPending === 0) {
-                await this.beforeCallSynchronize(async () => {
-                    this.callPending++;
-                    await this.handleBeforeCall();
-                });
-            }
-            const response = await this.getTarget().call(params);
-            if (!response.success) {
-                if (await this.handleErrorFallback(response.payload.code)) {
-                    return await this.getTarget().call(params);
-                }
-            }
-            return response;
-        }
-        catch (error) {
-            return (0, events_1.createErrorMessage)(error);
-        }
-        finally {
-            this.callPending--;
-        }
-    }
-    requestLogin(params) {
-        return this.getTarget().requestLogin(params);
-    }
-    uiResponse(params) {
-        return this.getTarget().uiResponse(params);
-    }
-    cancel(error) {
-        return this.getTarget().cancel(error);
-    }
-    dispose() {
-        this.eventEmitter.removeAllListeners();
-        this.callPending = 0;
-        return this.getTarget().dispose();
+      }
+      return response;
+    } catch (error) {
+      return (0, events_1.createErrorMessage)(error);
+    } finally {
+      this.callPending--;
     }
+  }
+  uiResponse(params) {
+    return this.getTarget().uiResponse(params);
+  }
+  cancel(error) {
+    return this.getTarget().cancel(error);
+  }
+  dispose() {
+    this.eventEmitter.removeAllListeners();
+    this.callPending = 0;
+    return this.getTarget().dispose();
+  }
 }
 exports.TrezorConnectDynamic = TrezorConnectDynamic;
 //# sourceMappingURL=dynamic.js.map

package/lib/index-browser.d.ts

@@ -1,5 +1,6 @@
 declare const TrezorConnect: Omit<import("./exports").TrezorConnect, "init"> & {
     init: import("./types/api/init").InitType<Record<string, any>>;
+    call: import("./exports").CallMethod;
 } & Record<string, any>;
 export default TrezorConnect;
 export * from './exports';