@trezor/connect 9.4.2 → 9.4.3-beta.2

package/lib/factory.js

@@ -2,141 +2,137 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.factory = void 0;
 const events_1 = require("./events");
-const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse, renderWebUSBButton, disableWebUSB, requestWebUSBDevice, cancel, dispose, }) => {
-    const api = {
-        manifest,
-        init,
-        getSettings: () => call({ method: 'getSettings' }),
-        on: (type, fn) => {
-            eventEmitter.on(type, fn);
-        },
-        off: (type, fn) => {
-            eventEmitter.removeListener(type, fn);
-        },
-        removeAllListeners: type => {
-            if (typeof type === 'string') {
-                eventEmitter.removeAllListeners(type);
-            }
-            else {
-                eventEmitter.removeAllListeners();
-            }
-        },
-        uiResponse,
-        blockchainGetAccountBalanceHistory: params => call({ ...params, method: 'blockchainGetAccountBalanceHistory' }),
-        blockchainGetCurrentFiatRates: params => call({ ...params, method: 'blockchainGetCurrentFiatRates' }),
-        blockchainGetFiatRatesForTimestamps: params => call({ ...params, method: 'blockchainGetFiatRatesForTimestamps' }),
-        blockchainDisconnect: params => call({ ...params, method: 'blockchainDisconnect' }),
-        blockchainEstimateFee: params => call({ ...params, method: 'blockchainEstimateFee' }),
-        blockchainGetTransactions: params => call({ ...params, method: 'blockchainGetTransactions' }),
-        blockchainSetCustomBackend: params => call({ ...params, method: 'blockchainSetCustomBackend' }),
-        blockchainSubscribe: params => call({ ...params, method: 'blockchainSubscribe' }),
-        blockchainSubscribeFiatRates: params => call({ ...params, method: 'blockchainSubscribeFiatRates' }),
-        blockchainUnsubscribe: params => call({ ...params, method: 'blockchainUnsubscribe' }),
-        blockchainUnsubscribeFiatRates: params => call({ ...params, method: 'blockchainUnsubscribeFiatRates' }),
-        requestLogin: params => requestLogin(params),
-        cardanoGetAddress: params => call({
-            ...params,
-            method: 'cardanoGetAddress',
-            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
-        }),
-        cardanoGetNativeScriptHash: params => call({ ...params, method: 'cardanoGetNativeScriptHash' }),
-        cardanoGetPublicKey: params => call({ ...params, method: 'cardanoGetPublicKey' }),
-        cardanoSignTransaction: params => call({ ...params, method: 'cardanoSignTransaction' }),
-        cardanoComposeTransaction: params => call({ ...params, method: 'cardanoComposeTransaction' }),
-        cipherKeyValue: params => call({ ...params, method: 'cipherKeyValue' }),
-        composeTransaction: params => call({ ...params, method: 'composeTransaction' }),
-        ethereumGetAddress: params => call({
-            ...params,
-            method: 'ethereumGetAddress',
-            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
-        }),
-        ethereumGetPublicKey: params => call({ ...params, method: 'ethereumGetPublicKey' }),
-        ethereumSignMessage: params => call({ ...params, method: 'ethereumSignMessage' }),
-        ethereumSignTransaction: params => call({ ...params, method: 'ethereumSignTransaction' }),
-        ethereumSignTypedData: params => call({ ...params, method: 'ethereumSignTypedData' }),
-        ethereumVerifyMessage: params => call({ ...params, method: 'ethereumVerifyMessage' }),
-        getAccountDescriptor: params => call({ ...params, method: 'getAccountDescriptor' }),
-        getAccountInfo: params => call({ ...params, method: 'getAccountInfo' }),
-        getAddress: params => call({
-            ...params,
-            method: 'getAddress',
-            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
-        }),
-        getDeviceState: params => call({ ...params, method: 'getDeviceState' }),
-        getFeatures: params => call({ ...params, method: 'getFeatures' }),
-        getFirmwareHash: params => call({ ...params, method: 'getFirmwareHash' }),
-        getOwnershipId: params => call({ ...params, method: 'getOwnershipId' }),
-        getOwnershipProof: params => call({ ...params, method: 'getOwnershipProof' }),
-        getPublicKey: params => call({ ...params, method: 'getPublicKey' }),
-        nemGetAddress: params => call({
-            ...params,
-            method: 'nemGetAddress',
-            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
-        }),
-        nemSignTransaction: params => call({ ...params, method: 'nemSignTransaction' }),
-        pushTransaction: params => call({ ...params, method: 'pushTransaction' }),
-        rippleGetAddress: params => call({
-            ...params,
-            method: 'rippleGetAddress',
-            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
-        }),
-        rippleSignTransaction: params => call({ ...params, method: 'rippleSignTransaction' }),
-        signMessage: params => call({ ...params, method: 'signMessage' }),
-        signTransaction: params => call({ ...params, method: 'signTransaction' }),
-        solanaGetPublicKey: params => call({ ...params, method: 'solanaGetPublicKey' }),
-        solanaGetAddress: params => call({ ...params, method: 'solanaGetAddress' }),
-        solanaSignTransaction: params => call({ ...params, method: 'solanaSignTransaction' }),
-        stellarGetAddress: params => call({
-            ...params,
-            method: 'stellarGetAddress',
-            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
-        }),
-        stellarSignTransaction: params => call({ ...params, method: 'stellarSignTransaction' }),
-        tezosGetAddress: params => call({
-            ...params,
-            method: 'tezosGetAddress',
-            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
-        }),
-        tezosGetPublicKey: params => call({ ...params, method: 'tezosGetPublicKey' }),
-        tezosSignTransaction: params => call({ ...params, method: 'tezosSignTransaction' }),
-        unlockPath: params => call({ ...params, method: 'unlockPath' }),
-        eosGetPublicKey: params => call({ ...params, method: 'eosGetPublicKey' }),
-        eosSignTransaction: params => call({ ...params, method: 'eosSignTransaction' }),
-        binanceGetAddress: params => call({
-            ...params,
-            method: 'binanceGetAddress',
-            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
-        }),
-        binanceGetPublicKey: params => call({ ...params, method: 'binanceGetPublicKey' }),
-        binanceSignTransaction: params => call({ ...params, method: 'binanceSignTransaction' }),
-        verifyMessage: params => call({ ...params, method: 'verifyMessage' }),
-        resetDevice: params => call({ ...params, method: 'resetDevice' }),
-        wipeDevice: params => call({ ...params, method: 'wipeDevice' }),
-        checkFirmwareAuthenticity: params => call({ ...params, method: 'checkFirmwareAuthenticity' }),
-        applyFlags: params => call({ ...params, method: 'applyFlags' }),
-        applySettings: params => call({ ...params, method: 'applySettings' }),
-        authenticateDevice: params => call({ ...params, method: 'authenticateDevice' }),
-        authorizeCoinjoin: params => call({ ...params, method: 'authorizeCoinjoin' }),
-        cancelCoinjoinAuthorization: params => call({ ...params, method: 'cancelCoinjoinAuthorization' }),
-        showDeviceTutorial: params => call({ ...params, method: 'showDeviceTutorial' }),
-        backupDevice: params => call({ ...params, method: 'backupDevice' }),
-        changeLanguage: params => call({ ...params, method: 'changeLanguage' }),
-        changePin: params => call({ ...params, method: 'changePin' }),
-        changeWipeCode: params => call({ ...params, method: 'changeWipeCode' }),
-        firmwareUpdate: params => call({ ...params, method: 'firmwareUpdate' }),
-        recoveryDevice: params => call({ ...params, method: 'recoveryDevice' }),
-        getCoinInfo: params => call({ ...params, method: 'getCoinInfo' }),
-        rebootToBootloader: params => call({ ...params, method: 'rebootToBootloader' }),
-        setBrightness: params => call({ ...params, method: 'setBrightness' }),
-        setBusy: params => call({ ...params, method: 'setBusy' }),
-        setProxy: params => call({ ...params, method: 'setProxy' }),
-        dispose,
-        cancel,
-        renderWebUSBButton,
-        disableWebUSB,
-        requestWebUSBDevice,
-    };
-    return api;
-};
+const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse, cancel, dispose, }, extraMethods = {}) => ({
+    manifest,
+    init,
+    on: (type, fn) => {
+        eventEmitter.on(type, fn);
+    },
+    off: (type, fn) => {
+        eventEmitter.removeListener(type, fn);
+    },
+    removeAllListeners: type => {
+        if (typeof type === 'string') {
+            eventEmitter.removeAllListeners(type);
+        }
+        else {
+            eventEmitter.removeAllListeners();
+        }
+    },
+    uiResponse,
+    blockchainGetAccountBalanceHistory: params => call({ ...params, method: 'blockchainGetAccountBalanceHistory' }),
+    blockchainGetCurrentFiatRates: params => call({ ...params, method: 'blockchainGetCurrentFiatRates' }),
+    blockchainGetFiatRatesForTimestamps: params => call({ ...params, method: 'blockchainGetFiatRatesForTimestamps' }),
+    blockchainEvmRpcCall: params => call({ ...params, method: 'blockchainEvmRpcCall' }),
+    blockchainDisconnect: params => call({ ...params, method: 'blockchainDisconnect' }),
+    blockchainEstimateFee: params => call({ ...params, method: 'blockchainEstimateFee' }),
+    blockchainGetTransactions: params => call({ ...params, method: 'blockchainGetTransactions' }),
+    blockchainSetCustomBackend: params => call({ ...params, method: 'blockchainSetCustomBackend' }),
+    blockchainSubscribe: params => call({ ...params, method: 'blockchainSubscribe' }),
+    blockchainSubscribeFiatRates: params => call({ ...params, method: 'blockchainSubscribeFiatRates' }),
+    blockchainUnsubscribe: params => call({ ...params, method: 'blockchainUnsubscribe' }),
+    blockchainUnsubscribeFiatRates: params => call({ ...params, method: 'blockchainUnsubscribeFiatRates' }),
+    requestLogin: params => requestLogin(params),
+    cardanoGetAddress: params => call({
+        ...params,
+        method: 'cardanoGetAddress',
+        useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+    }),
+    cardanoGetNativeScriptHash: params => call({ ...params, method: 'cardanoGetNativeScriptHash' }),
+    cardanoGetPublicKey: params => call({ ...params, method: 'cardanoGetPublicKey' }),
+    cardanoSignTransaction: params => call({ ...params, method: 'cardanoSignTransaction' }),
+    cardanoComposeTransaction: params => call({ ...params, method: 'cardanoComposeTransaction' }),
+    cipherKeyValue: params => call({ ...params, method: 'cipherKeyValue' }),
+    composeTransaction: params => call({ ...params, method: 'composeTransaction' }),
+    ethereumGetAddress: params => call({
+        ...params,
+        method: 'ethereumGetAddress',
+        useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+    }),
+    ethereumGetPublicKey: params => call({ ...params, method: 'ethereumGetPublicKey' }),
+    ethereumSignMessage: params => call({ ...params, method: 'ethereumSignMessage' }),
+    ethereumSignTransaction: params => call({ ...params, method: 'ethereumSignTransaction' }),
+    ethereumSignTypedData: params => call({ ...params, method: 'ethereumSignTypedData' }),
+    ethereumVerifyMessage: params => call({ ...params, method: 'ethereumVerifyMessage' }),
+    getAccountDescriptor: params => call({ ...params, method: 'getAccountDescriptor' }),
+    getAccountInfo: params => call({ ...params, method: 'getAccountInfo' }),
+    getAddress: params => call({
+        ...params,
+        method: 'getAddress',
+        useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+    }),
+    getDeviceState: params => call({ ...params, method: 'getDeviceState' }),
+    getFeatures: params => call({ ...params, method: 'getFeatures' }),
+    getFirmwareHash: params => call({ ...params, method: 'getFirmwareHash' }),
+    getOwnershipId: params => call({ ...params, method: 'getOwnershipId' }),
+    getOwnershipProof: params => call({ ...params, method: 'getOwnershipProof' }),
+    getPublicKey: params => call({ ...params, method: 'getPublicKey' }),
+    nemGetAddress: params => call({
+        ...params,
+        method: 'nemGetAddress',
+        useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+    }),
+    nemSignTransaction: params => call({ ...params, method: 'nemSignTransaction' }),
+    pushTransaction: params => call({ ...params, method: 'pushTransaction' }),
+    rippleGetAddress: params => call({
+        ...params,
+        method: 'rippleGetAddress',
+        useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+    }),
+    rippleSignTransaction: params => call({ ...params, method: 'rippleSignTransaction' }),
+    signMessage: params => call({ ...params, method: 'signMessage' }),
+    signTransaction: params => call({ ...params, method: 'signTransaction' }),
+    solanaGetPublicKey: params => call({ ...params, method: 'solanaGetPublicKey' }),
+    solanaGetAddress: params => call({ ...params, method: 'solanaGetAddress' }),
+    solanaSignTransaction: params => call({ ...params, method: 'solanaSignTransaction' }),
+    stellarGetAddress: params => call({
+        ...params,
+        method: 'stellarGetAddress',
+        useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+    }),
+    stellarSignTransaction: params => call({ ...params, method: 'stellarSignTransaction' }),
+    tezosGetAddress: params => call({
+        ...params,
+        method: 'tezosGetAddress',
+        useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+    }),
+    tezosGetPublicKey: params => call({ ...params, method: 'tezosGetPublicKey' }),
+    tezosSignTransaction: params => call({ ...params, method: 'tezosSignTransaction' }),
+    unlockPath: params => call({ ...params, method: 'unlockPath' }),
+    eosGetPublicKey: params => call({ ...params, method: 'eosGetPublicKey' }),
+    eosSignTransaction: params => call({ ...params, method: 'eosSignTransaction' }),
+    binanceGetAddress: params => call({
+        ...params,
+        method: 'binanceGetAddress',
+        useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+    }),
+    binanceGetPublicKey: params => call({ ...params, method: 'binanceGetPublicKey' }),
+    binanceSignTransaction: params => call({ ...params, method: 'binanceSignTransaction' }),
+    verifyMessage: params => call({ ...params, method: 'verifyMessage' }),
+    resetDevice: params => call({ ...params, method: 'resetDevice' }),
+    loadDevice: params => call({ ...params, method: 'loadDevice' }),
+    wipeDevice: params => call({ ...params, method: 'wipeDevice' }),
+    applyFlags: params => call({ ...params, method: 'applyFlags' }),
+    applySettings: params => call({ ...params, method: 'applySettings' }),
+    getSettings: () => call({ method: 'getSettings' }),
+    authenticateDevice: params => call({ ...params, method: 'authenticateDevice' }),
+    authorizeCoinjoin: params => call({ ...params, method: 'authorizeCoinjoin' }),
+    cancelCoinjoinAuthorization: params => call({ ...params, method: 'cancelCoinjoinAuthorization' }),
+    showDeviceTutorial: params => call({ ...params, method: 'showDeviceTutorial' }),
+    backupDevice: params => call({ ...params, method: 'backupDevice' }),
+    changeLanguage: params => call({ ...params, method: 'changeLanguage' }),
+    changePin: params => call({ ...params, method: 'changePin' }),
+    changeWipeCode: params => call({ ...params, method: 'changeWipeCode' }),
+    firmwareUpdate: params => call({ ...params, method: 'firmwareUpdate' }),
+    recoveryDevice: params => call({ ...params, method: 'recoveryDevice' }),
+    getCoinInfo: params => call({ ...params, method: 'getCoinInfo' }),
+    rebootToBootloader: params => call({ ...params, method: 'rebootToBootloader' }),
+    setBrightness: params => call({ ...params, method: 'setBrightness' }),
+    setBusy: params => call({ ...params, method: 'setBusy' }),
+    setProxy: params => call({ ...params, method: 'setProxy' }),
+    dispose,
+    cancel,
+    ...extraMethods,
+});
 exports.factory = factory;
 //# sourceMappingURL=factory.js.map

package/lib/impl/dynamic.d.ts

@@ -0,0 +1,33 @@
+import EventEmitter from 'events';
+import { ConnectFactoryDependencies } from '../factory';
+import type { Manifest } from '../types/settings';
+import { CallMethodPayload } from '../events';
+import { InitFullSettings } from '../types/api/init';
+type TrezorConnectDynamicParams<ImplType, SettingsType extends Record<string, any>, ImplInterface extends ConnectFactoryDependencies<SettingsType>> = {
+    implementations: {
+        type: ImplType;
+        impl: ImplInterface;
+    }[];
+    getInitTarget: (settings: InitFullSettings<SettingsType>) => ImplType;
+    handleErrorFallback: (errorCode: string) => Promise<boolean>;
+};
+export declare class TrezorConnectDynamic<ImplType, SettingsType extends Record<string, any>, ImplInterface extends ConnectFactoryDependencies<SettingsType>> implements ConnectFactoryDependencies<SettingsType> {
+    eventEmitter: EventEmitter;
+    private currentTarget;
+    private implementations;
+    private getInitTarget;
+    private handleErrorFallback;
+    lastSettings?: InitFullSettings<SettingsType>;
+    constructor({ implementations, getInitTarget, handleErrorFallback, }: TrezorConnectDynamicParams<ImplType, SettingsType, ImplInterface>);
+    getTarget(): ImplInterface;
+    switchTarget(target: ImplType): Promise<void>;
+    manifest(manifest: Manifest): void;
+    init(settings: InitFullSettings<SettingsType>): Promise<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;
+}
+export {};
+//# sourceMappingURL=dynamic.d.ts.map

package/lib/impl/dynamic.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrezorConnectDynamic = void 0;
+const constants_1 = require("../constants");
+const proxy_event_emitter_1 = require("../utils/proxy-event-emitter");
+class TrezorConnectDynamic {
+    constructor({ implementations, getInitTarget, handleErrorFallback, }) {
+        this.implementations = implementations;
+        this.currentTarget = this.implementations[0].type;
+        this.getInitTarget = getInitTarget;
+        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;
+    }
+    async switchTarget(target) {
+        if (this.currentTarget === target) {
+            return;
+        }
+        if (!this.lastSettings) {
+            throw constants_1.ERRORS.TypedError('Init_NotInitialized');
+        }
+        await this.getTarget().dispose();
+        this.currentTarget = target;
+        await this.getTarget().init(this.lastSettings);
+    }
+    manifest(manifest) {
+        this.lastSettings = {
+            ...this.lastSettings,
+            manifest,
+        };
+        this.getTarget().manifest(manifest);
+    }
+    async init(settings) {
+        if (!(settings === null || settings === void 0 ? void 0 : settings.manifest)) {
+            throw constants_1.ERRORS.TypedError('Init_ManifestMissing');
+        }
+        this.lastSettings = settings;
+        this.currentTarget = this.getInitTarget(settings);
+        try {
+            return await this.getTarget().init(this.lastSettings);
+        }
+        catch (error) {
+            if (await this.handleErrorFallback(error.code)) {
+                return await this.getTarget().init(settings);
+            }
+            throw error;
+        }
+    }
+    async call(params) {
+        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;
+    }
+    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();
+        return this.getTarget().dispose();
+    }
+}
+exports.TrezorConnectDynamic = TrezorConnectDynamic;
+//# sourceMappingURL=dynamic.js.map

package/lib/index-browser.d.ts

@@ -1,4 +1,6 @@
-declare const TrezorConnect: import("./exports").TrezorConnect;
+declare const TrezorConnect: Omit<import("./exports").TrezorConnect, "init"> & {
+    init: import("./types/api/init").InitType<Record<string, any>>;
+} & Record<string, any>;
 export default TrezorConnect;
 export * from './exports';
 //# sourceMappingURL=index-browser.d.ts.map

package/lib/index-browser.js

@@ -17,10 +17,7 @@ const TrezorConnect = (0, factory_1.factory)({
     init: fallback,
     call: fallback,
     requestLogin: fallback,
-    requestWebUSBDevice: fallback,
     uiResponse: fallback,
-    renderWebUSBButton: fallback,
-    disableWebUSB: fallback,
     cancel: fallback,
     dispose: fallback,
 });

package/lib/index.d.ts

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

package/lib/index.js

@@ -162,15 +162,6 @@ const cancel = (error) => {
         payload: error ? { error } : null,
     });
 };
-const renderWebUSBButton = (_className) => {
-    throw constants_1.ERRORS.TypedError('Method_InvalidPackage');
-};
-const disableWebUSB = () => {
-    throw constants_1.ERRORS.TypedError('Method_InvalidPackage');
-};
-const requestWebUSBDevice = () => {
-    throw constants_1.ERRORS.TypedError('Method_InvalidPackage');
-};
 const TrezorConnect = (0, factory_1.factory)({
     eventEmitter: exports.eventEmitter,
     manifest,
@@ -178,12 +169,9 @@ const TrezorConnect = (0, factory_1.factory)({
     call,
     requestLogin,
     uiResponse,
-    renderWebUSBButton,
-    disableWebUSB,
-    requestWebUSBDevice,
     cancel,
     dispose,
-});
+}, {});
 exports.default = TrezorConnect;
 tslib_1.__exportStar(require("./exports"), exports);
 //# sourceMappingURL=index.js.map

package/lib/types/api/applySettings.d.ts

@@ -3,19 +3,19 @@ import { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
 export type ApplySettings = Static<typeof ApplySettings>;
 export declare const ApplySettings: import("@trezor/schema-utils").TObject<{
-    language: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    passphrase_always_on_device: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    safety_checks: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/keyof-enum").TKeyOfEnum<typeof PROTO.Enum_SafetyCheckLevel>>;
-    auto_lock_delay_ms: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    display_rotation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    experimental_features: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    hide_passphrase_from_host: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    haptic_feedback: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    use_passphrase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    homescreen: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    _passphrase_source: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    passphrase_source: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    language: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    label: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    passphrase_always_on_device: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    safety_checks: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/keyof-enum").TKeyOfEnum<typeof PROTO.Enum_SafetyCheckLevel>>;
+    auto_lock_delay_ms: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+    display_rotation: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+    experimental_features: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    hide_passphrase_from_host: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    haptic_feedback: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    use_passphrase: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    homescreen: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    _passphrase_source: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+    passphrase_source: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
 }>;
 export declare function applySettings(params: Params<ApplySettings>): Response<PROTO.Success>;
 //# sourceMappingURL=applySettings.d.ts.map

package/lib/types/api/authenticateDevice.d.ts

@@ -2,42 +2,51 @@ import { Static } from '@trezor/schema-utils';
 import type { Params, Response } from '../params';
 export type AuthenticateDeviceParams = Static<typeof AuthenticateDeviceParams>;
 export declare const AuthenticateDeviceParams: import("@trezor/schema-utils").TObject<{
-    config: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TIntersect<[import("@trezor/schema-utils").TObject<{
-        T2B1: import("@sinclair/typebox").TIntersect<[import("@trezor/schema-utils").TObject<{
-            rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-            caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    config: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+        T2B1: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+            rootPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+            caPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
         }>, import("@trezor/schema-utils").TObject<{
-            debug: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils").TObject<{
-                rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-                caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            debug: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                rootPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+                caPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
             }>>;
         }>]>;
-        T3B1: import("@sinclair/typebox").TIntersect<[import("@trezor/schema-utils").TObject<{
-            rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-            caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        T3B1: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+            rootPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+            caPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
         }>, import("@trezor/schema-utils").TObject<{
-            debug: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils").TObject<{
-                rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-                caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            debug: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                rootPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+                caPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
             }>>;
         }>]>;
-        T3T1: import("@sinclair/typebox").TIntersect<[import("@trezor/schema-utils").TObject<{
-            rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-            caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        T3T1: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+            rootPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+            caPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
         }>, import("@trezor/schema-utils").TObject<{
-            debug: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils").TObject<{
-                rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-                caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            debug: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                rootPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+                caPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+            }>>;
+        }>]>;
+        T3W1: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+            rootPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+            caPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+        }>, import("@trezor/schema-utils").TObject<{
+            debug: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                rootPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+                caPubKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
             }>>;
         }>]>;
     }>, import("@trezor/schema-utils").TObject<{
-        T1B1: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
-        T2T1: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+        T1B1: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
+        T2T1: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
     }>]>, import("@trezor/schema-utils").TObject<{
-        version: import("@sinclair/typebox").TNumber;
-        timestamp: import("@sinclair/typebox").TString;
+        version: import("@trezor/schema-utils").TNumber;
+        timestamp: import("@trezor/schema-utils").TString;
     }>]>>;
-    allowDebugKeys: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    allowDebugKeys: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;
 export type AuthenticateDeviceResult = {
     valid: true;

package/lib/types/api/authorizeCoinjoin.d.ts

@@ -1,17 +1,17 @@
-import type { Params, Response } from '../params';
 import { Static } from '@trezor/schema-utils';
+import type { Params, Response } from '../params';
 import { PROTO } from '../../constants';
 export type AuthorizeCoinjoin = Static<typeof AuthorizeCoinjoin>;
 export declare const AuthorizeCoinjoin: import("@trezor/schema-utils").TObject<{
-    path: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
-    coordinator: import("@sinclair/typebox").TString;
-    maxRounds: import("@sinclair/typebox").TNumber;
-    maxCoordinatorFeeRate: import("@sinclair/typebox").TNumber;
-    maxFeePerKvbyte: import("@sinclair/typebox").TNumber;
-    coin: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    scriptType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"SPENDADDRESS">, import("@sinclair/typebox").TLiteral<"SPENDMULTISIG">, import("@sinclair/typebox").TLiteral<"SPENDWITNESS">, import("@sinclair/typebox").TLiteral<"SPENDP2SHWITNESS">, import("@sinclair/typebox").TLiteral<"SPENDTAPROOT">]>>;
-    amountUnit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<typeof PROTO.AmountUnit>>;
-    preauthorized: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    path: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;
+    coordinator: import("@trezor/schema-utils").TString;
+    maxRounds: import("@trezor/schema-utils").TNumber;
+    maxCoordinatorFeeRate: import("@trezor/schema-utils").TNumber;
+    maxFeePerKvbyte: import("@trezor/schema-utils").TNumber;
+    coin: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    scriptType: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"SPENDADDRESS">, import("@trezor/schema-utils").TLiteral<"SPENDMULTISIG">, import("@trezor/schema-utils").TLiteral<"SPENDWITNESS">, import("@trezor/schema-utils").TLiteral<"SPENDP2SHWITNESS">, import("@trezor/schema-utils").TLiteral<"SPENDTAPROOT">]>>;
+    amountUnit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TEnum<typeof PROTO.AmountUnit>>;
+    preauthorized: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;
 export declare function authorizeCoinjoin(params: Params<AuthorizeCoinjoin>): Response<PROTO.Success>;
 //# sourceMappingURL=authorizeCoinjoin.d.ts.map