@trezor/connect 9.5.3 → 9.5.4-beta.1

package/lib/api/ethereum/api/ethereumSignTypedData.d.ts

@@ -76,16 +76,14 @@ declare const Params: import("@trezor/schema-utils").TIntersect<[import("@trezor
         maxFee: import("@trezor/schema-utils").TNumber;
         defaultFees: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
             label: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"high">, import("@trezor/schema-utils").TLiteral<"normal">, import("@trezor/schema-utils").TLiteral<"economy">, import("@trezor/schema-utils").TLiteral<"low">, import("@trezor/schema-utils").TLiteral<"custom">]>;
-            feePerUnit: import("@trezor/schema-utils").TString;
             blocks: import("@trezor/schema-utils").TNumber;
-            feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            feePerUnit: import("@trezor/schema-utils").TString;
             feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
             baseFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
             maxFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-            effectiveGasPrice: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
             maxPriorityFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
             maxWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
-            minWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
         }>>;
     }>, import("@trezor/schema-utils").TObject<{
         type: import("@trezor/schema-utils").TLiteral<"ethereum">;

package/lib/api/ethereum/api/ethereumSignTypedData.js

@@ -153,7 +153,7 @@ class EthereumSignTypedData extends AbstractMethod_1.AbstractMethod {
                     memberData = memberData[memberTypeDefinition.name];
                 }
                 if (memberData === null || memberData === undefined) {
-                    cmd.typedCall('Cancel', 'Success');
+                    this.device.getCurrentSession().cancelCall();
                     throw constants_1.ERRORS.TypedError('Runtime', `Value from member path ${member_path} is missing in the data object`);
                 }
             }

package/lib/api/firmware/uploadFirmware.d.ts

@@ -3,11 +3,11 @@ import type { Device } from '../../device/Device';
 import type { TypedCall } from '../../device/DeviceCommands';
 import { CoreEventMessage } from '../../events';
 export declare const uploadFirmware: (typedCall: TypedCall, postMessage: (message: CoreEventMessage) => void, device: Device, { payload }: PROTO.FirmwareUpload) => Promise<{
+    message: string;
+} | {
     type: "Success";
     message: {
         message: string;
     };
-} | {
-    message: string;
 }>;
 //# sourceMappingURL=uploadFirmware.d.ts.map

package/lib/api/getAccountDescriptor.js

@@ -109,9 +109,7 @@ class GetAccountDescriptor extends AbstractMethod_1.AbstractMethod {
             try {
                 const { descriptor, address_n, legacyXpub } = await this.device
                     .getCommands()
-                    .getAccountDescriptor(request.coinInfo, request.address_n, typeof request.derivationType !== 'undefined'
-                    ? request.derivationType
-                    : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR);
+                    .getAccountDescriptor(request.coinInfo, request.address_n, request.derivationType);
                 const response = {
                     descriptor,
                     path: (0, pathUtils_1.getSerializedPath)(address_n),

package/lib/api/getAccountInfo.js

@@ -144,7 +144,7 @@ class GetAccountInfo extends AbstractMethod_1.AbstractMethod {
         }
         const responses = [];
         const sendProgress = (progress, response, error) => {
-            if (!this.hasBundle || (this.device && this.device.getCommands().disposed))
+            if (!this.hasBundle || this.device?.getCurrentSession().isDisposed())
                 return;
             this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
                 total: this.params.length,
@@ -165,9 +165,7 @@ class GetAccountInfo extends AbstractMethod_1.AbstractMethod {
                 try {
                     const accountDescriptor = await this.device
                         .getCommands()
-                        .getAccountDescriptor(request.coinInfo, address_n, typeof request.derivationType !== 'undefined'
-                        ? request.derivationType
-                        : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR);
+                        .getAccountDescriptor(request.coinInfo, address_n, request.derivationType);
                     if (accountDescriptor) {
                         descriptor = accountDescriptor.descriptor;
                         legacyXpub = accountDescriptor.legacyXpub;
@@ -244,15 +242,12 @@ class GetAccountInfo extends AbstractMethod_1.AbstractMethod {
         return this.hasBundle ? responses : responses[0];
     }
     async discover(request) {
-        const { coinInfo, identity, defaultAccountType } = request;
+        const { coinInfo, identity, defaultAccountType, derivationType } = request;
         const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage, identity);
         const dfd = this.createUiPromise(events_1.UI.RECEIVE_ACCOUNT);
         const discovery = new Discovery_1.Discovery({
             blockchain,
-            commands: this.device.getCommands(),
-            derivationType: typeof request.derivationType !== 'undefined'
-                ? request.derivationType
-                : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
+            getDescriptor: path => this.device.getCommands().getAccountDescriptor(coinInfo, path, derivationType),
         });
         discovery.on('progress', accounts => {
             this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {

package/lib/api/getAddress.js

@@ -94,13 +94,12 @@ class GetAddress extends AbstractMethod_1.AbstractMethod {
         if (unlockPath) {
             await cmd.unlockPath(unlockPath);
         }
-        return cmd.getAddress({
-            address_n,
-            show_display,
-            multisig,
-            script_type,
-            chunkify,
-        }, coinInfo);
+        const response = await cmd.getAddress({ address_n, show_display, multisig, script_type, chunkify }, coinInfo);
+        return {
+            path: address_n,
+            serializedPath: (0, pathUtils_1.getSerializedPath)(address_n),
+            address: response.address,
+        };
     }
     async run() {
         const responses = [];

package/lib/api/getCoinInfo.d.ts

@@ -29,17 +29,15 @@ export default class GetCoinInfo extends AbstractMethod<'getCoinInfo', Params> {
         };
         decimals: number;
         defaultFees: {
+            feePerTx?: string | undefined;
+            feeLimit?: string | undefined;
+            baseFeePerGas?: string | undefined;
             maxFeePerGas?: string | undefined;
             maxPriorityFeePerGas?: string | undefined;
             maxWaitTimeEstimate?: number | undefined;
-            minWaitTimeEstimate?: number | undefined;
-            feeLimit?: string | undefined;
-            feePerTx?: string | undefined;
-            baseFeePerGas?: string | undefined;
-            effectiveGasPrice?: string | undefined;
             label: "normal" | "custom" | "high" | "economy" | "low";
-            feePerUnit: string;
             blocks: number;
+            feePerUnit: string;
         }[];
     } & {
         cashAddrPrefix?: string | undefined;
@@ -94,17 +92,15 @@ export default class GetCoinInfo extends AbstractMethod<'getCoinInfo', Params> {
         };
         decimals: number;
         defaultFees: {
+            feePerTx?: string | undefined;
+            feeLimit?: string | undefined;
+            baseFeePerGas?: string | undefined;
             maxFeePerGas?: string | undefined;
             maxPriorityFeePerGas?: string | undefined;
             maxWaitTimeEstimate?: number | undefined;
-            minWaitTimeEstimate?: number | undefined;
-            feeLimit?: string | undefined;
-            feePerTx?: string | undefined;
-            baseFeePerGas?: string | undefined;
-            effectiveGasPrice?: string | undefined;
             label: "normal" | "custom" | "high" | "economy" | "low";
-            feePerUnit: string;
             blocks: number;
+            feePerUnit: string;
         }[];
     } & {
         network?: undefined;
@@ -134,17 +130,15 @@ export default class GetCoinInfo extends AbstractMethod<'getCoinInfo', Params> {
         };
         decimals: number;
         defaultFees: {
+            feePerTx?: string | undefined;
+            feeLimit?: string | undefined;
+            baseFeePerGas?: string | undefined;
             maxFeePerGas?: string | undefined;
             maxPriorityFeePerGas?: string | undefined;
             maxWaitTimeEstimate?: number | undefined;
-            minWaitTimeEstimate?: number | undefined;
-            feeLimit?: string | undefined;
-            feePerTx?: string | undefined;
-            baseFeePerGas?: string | undefined;
-            effectiveGasPrice?: string | undefined;
             label: "normal" | "custom" | "high" | "economy" | "low";
-            feePerUnit: string;
             blocks: number;
+            feePerUnit: string;
         }[];
     } & {
         network?: undefined;

package/lib/api/getPublicKey.d.ts

@@ -14,29 +14,33 @@ export default class GetPublicKey extends AbstractMethod<'getPublicKey', Params[
         view: "export-xpub";
         label: string;
     };
-    run(): Promise<{
-        xpubSegwit?: string | undefined;
-        descriptorChecksum?: string | undefined;
+    run(): Promise<({
         path: number[];
         publicKey: string;
         serializedPath: string;
+    } & {
+        descriptor?: string | undefined;
+        xpubSegwit?: string | undefined;
+        descriptorChecksum?: string | undefined;
         depth: number;
         fingerprint: number;
         chainCode: string;
         childNum: number;
         xpub: string;
-    } | {
-        xpubSegwit?: string | undefined;
-        descriptorChecksum?: string | undefined;
+    }) | ({
         path: number[];
         publicKey: string;
         serializedPath: string;
+    } & {
+        descriptor?: string | undefined;
+        xpubSegwit?: string | undefined;
+        descriptorChecksum?: string | undefined;
         depth: number;
         fingerprint: number;
         chainCode: string;
         childNum: number;
         xpub: string;
-    }[]>;
+    })[]>;
 }
 export {};
 //# sourceMappingURL=getPublicKey.d.ts.map

package/lib/api/resetDevice.js

@@ -6,7 +6,6 @@ const utils_1 = require("@trezor/utils");
 const verifyEntropy_1 = require("../api/firmware/verifyEntropy");
 const constants_1 = require("../constants");
 const AbstractMethod_1 = require("../core/AbstractMethod");
-const prompts_1 = require("../device/prompts");
 const events_1 = require("../events");
 const paramsValidator_1 = require("./common/paramsValidator");
 const pathUtils_1 = require("../utils/pathUtils");
@@ -70,8 +69,7 @@ class ResetDevice extends AbstractMethod_1.AbstractMethod {
             xpubs,
         });
         if (res.error) {
-            await (0, prompts_1.cancelPrompt)(this.device).catch(() => {
-            });
+            await this.device.getCurrentSession().cancelCall();
             throw new Error(res.error);
         }
         return currentData;

package/lib/api/signTransaction.js

@@ -162,17 +162,17 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
         const response = await signTxMethod({
             ...params,
             refTxs,
-            typedCall: device.getCommands().typedCall.bind(device.getCommands()),
+            typedCall: device.getCommands().typedCall,
         });
         if (!response.serializedTx) {
             return response;
         }
         let bitcoinTx;
         if (params.options.decred_staking_ticket) {
-            await (0, bitcoin_1.verifyTicketTx)(device.getCommands().getHDNode.bind(device.getCommands()), params.inputs, params.outputs, response.serializedTx, params.coinInfo);
+            await (0, bitcoin_1.verifyTicketTx)(device.getCommands().getHDNode, params.inputs, params.outputs, response.serializedTx, params.coinInfo);
         }
         else {
-            bitcoinTx = await (0, bitcoin_1.verifyTx)(device.getCommands().getHDNode.bind(device.getCommands()), params.inputs, params.outputs, response.serializedTx, params.coinInfo, params.unlockPath);
+            bitcoinTx = await (0, bitcoin_1.verifyTx)(device.getCommands().getHDNode, params.inputs, params.outputs, response.serializedTx, params.coinInfo, params.unlockPath);
             if (bitcoinTx.hasWitnesses()) {
                 response.witnesses = bitcoinTx.ins.map((_, i) => bitcoinTx?.getWitness(i)?.toString('hex'));
             }

package/lib/api/stellar/api/stellarSignTransaction.js

@@ -52,7 +52,7 @@ class StellarSignTransaction extends AbstractMethod_1.AbstractMethod {
     }
     async run() {
         this._ensureFirmwareSupportsParams();
-        const response = await helper.stellarSignTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.networkPassphrase, this.params.transaction);
+        const response = await helper.stellarSignTx(this.device.getCommands().typedCall, this.params.path, this.params.networkPassphrase, this.params.transaction);
         return {
             publicKey: response.public_key,
             signature: response.signature,

package/lib/constants/errors.d.ts

@@ -5,8 +5,8 @@ export declare const ERROR_CODES: {
     readonly Init_IframeTimeout: "Iframe timeout";
     readonly Init_ManifestMissing: "Manifest not set. Read more at https://github.com/trezor/trezor-suite/blob/develop/docs/packages/connect/index.md";
     readonly Popup_ConnectionMissing: "Unable to establish connection with iframe";
+    readonly Desktop_ConnectionMissing: "Unable to establish connection with Suite";
     readonly Transport_Missing: "Transport is missing";
-    readonly Transport_InvalidProtobuf: "";
     readonly Method_InvalidPackage: "This package is not suitable to work with browser. Use @trezor/connect-web package instead";
     readonly Method_InvalidParameter: "";
     readonly Method_NotAllowed: "Method not allowed for this configuration";
@@ -15,7 +15,6 @@ export declare const ERROR_CODES: {
     readonly Method_Interrupted: "Popup closed";
     readonly Method_UnknownCoin: "Coin not found";
     readonly Method_AddressNotMatch: "Addresses do not match";
-    readonly Method_FirmwareUpdate_DownloadFailed: "Failed to download firmware binary";
     readonly Method_Discovery_BundleException: "";
     readonly Method_Override: "override";
     readonly Method_NoResponse: "Call resolved without response";

package/lib/constants/errors.js

@@ -8,8 +8,8 @@ exports.ERROR_CODES = {
     Init_IframeTimeout: 'Iframe timeout',
     Init_ManifestMissing: 'Manifest not set. Read more at https://github.com/trezor/trezor-suite/blob/develop/docs/packages/connect/index.md',
     Popup_ConnectionMissing: 'Unable to establish connection with iframe',
+    Desktop_ConnectionMissing: 'Unable to establish connection with Suite',
     Transport_Missing: 'Transport is missing',
-    Transport_InvalidProtobuf: '',
     Method_InvalidPackage: 'This package is not suitable to work with browser. Use @trezor/connect-web package instead',
     Method_InvalidParameter: '',
     Method_NotAllowed: 'Method not allowed for this configuration',
@@ -18,7 +18,6 @@ exports.ERROR_CODES = {
     Method_Interrupted: 'Popup closed',
     Method_UnknownCoin: 'Coin not found',
     Method_AddressNotMatch: 'Addresses do not match',
-    Method_FirmwareUpdate_DownloadFailed: 'Failed to download firmware binary',
     Method_Discovery_BundleException: '',
     Method_Override: 'override',
     Method_NoResponse: 'Call resolved without response',
@@ -71,7 +70,13 @@ const serializeError = (payload) => {
     if (payload instanceof TrezorError) {
         return { error: payload.message, code: payload.code };
     }
-    return payload;
+    if (payload instanceof Error) {
+        return {
+            error: payload.message,
+            code: 'code' in payload ? payload.code : 'Failure_UnknownCode',
+        };
+    }
+    return { ...payload };
 };
 exports.serializeError = serializeError;
 exports.LIBUSB_ERROR_MESSAGE = 'LIBUSB_ERROR';

package/lib/core/index.js

@@ -460,7 +460,7 @@ const closePopup = ({ popupPromise, sendCoreMessage }) => {
     }
     sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.CLOSE_UI_WINDOW));
 };
-const onDeviceButtonHandler = (context, method) => async ({ device, payload: request }) => {
+const onDeviceButtonHandler = (device, context, method) => async ({ payload: request }) => {
     const { sendCoreMessage } = context;
     const addressRequest = request.code === 'ButtonRequest_Address';
     if (!addressRequest || (addressRequest && method?.useUi)) {
@@ -480,54 +480,75 @@ const onDeviceButtonHandler = (context, method) => async ({ device, payload: req
         sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.ADDRESS_VALIDATION, data));
     }
 };
-const onDevicePinHandler = (context) => async ({ device, type, callback }) => {
+const onDevicePinHandler = (device, context) => async ({ type, callback }) => {
     const { uiPromises, sendCoreMessage } = context;
     await waitForPopup(context);
     const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PIN, device);
     sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PIN, { device: device.toMessageObject(), type }));
     try {
         const uiResp = await uiPromise.promise;
-        callback(uiResp.payload);
+        if (uiResp.payload == null) {
+            callback({ success: false, error: new Error(`${events_2.UI.RECEIVE_PIN} missing payload`) });
+        }
+        else {
+            callback({ success: true, payload: uiResp.payload });
+        }
     }
     catch (error) {
-        callback(null, error);
+        callback({ success: false, error });
     }
 };
-const onDeviceWordHandler = (context) => async ({ device, type, callback }) => {
+const onDeviceWordHandler = (device, context) => async ({ type, callback }) => {
     const { uiPromises, sendCoreMessage } = context;
     await waitForPopup(context);
     const uiPromise = uiPromises.create(events_2.UI.RECEIVE_WORD, device);
     sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_WORD, { device: device.toMessageObject(), type }));
     try {
         const uiResp = await uiPromise.promise;
-        callback(uiResp.payload);
+        if (uiResp.payload == null) {
+            callback({
+                success: false,
+                error: new Error(`${events_2.UI.RECEIVE_WORD} missing payload`),
+            });
+        }
+        else {
+            callback({ success: true, payload: uiResp.payload });
+        }
     }
     catch (error) {
-        callback(null, error);
+        callback({ success: false, error });
     }
 };
-const onDevicePassphraseHandler = (context) => async ({ device, callback }) => {
+const onDevicePassphraseHandler = (device, context) => async ({ callback }) => {
     const { uiPromises, sendCoreMessage } = context;
     await waitForPopup(context);
     const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PASSPHRASE, device);
     sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE, { device: device.toMessageObject() }));
     try {
         const uiResp = await uiPromise.promise;
-        callback(uiResp.payload);
+        if (uiResp.payload == null) {
+            callback({
+                success: false,
+                error: new Error(`${events_2.UI.RECEIVE_PASSPHRASE} missing payload`),
+            });
+        }
+        else {
+            callback({ success: true, payload: uiResp.payload });
+        }
     }
     catch (error) {
-        callback(null, error);
+        callback({ success: false, error });
     }
 };
 const onEmptyPassphraseHandler = () => ({ callback }) => {
-    callback({ value: '' });
+    callback({ success: true, payload: { value: '' } });
 };
 const registerDeviceEvents = (context, method) => (device) => {
     device.removeAllListeners();
-    device.on(events_2.DEVICE.BUTTON, onDeviceButtonHandler(context, method));
-    device.on(events_2.DEVICE.PIN, onDevicePinHandler(context));
-    device.on(events_2.DEVICE.WORD, onDeviceWordHandler(context));
-    device.on(events_2.DEVICE.PASSPHRASE, (method?.useEmptyPassphrase ? onEmptyPassphraseHandler : onDevicePassphraseHandler)(context));
+    device.on(events_2.DEVICE.BUTTON, onDeviceButtonHandler(device, context, method));
+    device.on(events_2.DEVICE.PIN, onDevicePinHandler(device, context));
+    device.on(events_2.DEVICE.WORD, onDeviceWordHandler(device, context));
+    device.on(events_2.DEVICE.PASSPHRASE, (method?.useEmptyPassphrase ? onEmptyPassphraseHandler : onDevicePassphraseHandler)(device, context));
     device.on(events_2.DEVICE.PASSPHRASE_ON_DEVICE, () => {
         context.sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE_ON_DEVICE, {
             device: device.toMessageObject(),

package/lib/core/onCallFirmwareUpdate.js

@@ -95,7 +95,8 @@ const getInstallationParams = (device, params) => {
         const upgrade = device.atLeast('2.6.3') && isUpdatingToNewerVersion && isUpdatingToEqualFirmwareType;
         const manual = !device.atLeast(['1.10.0', '2.6.0']) && !upgrade;
         const language = device.atLeast('2.7.0') &&
-            device.features.internal_model !== constants_1.PROTO.DeviceModelInternal.T2T1;
+            device.features.internal_model !== constants_1.PROTO.DeviceModelInternal.T2T1 &&
+            device.features.internal_model !== constants_1.PROTO.DeviceModelInternal.T3T1;
         return {
             manual,
             upgrade,
@@ -230,7 +231,7 @@ const onCallFirmwareUpdate = async ({ params, context, }) => {
     const bootloaderVersion = reconnectedDevice.getVersion();
     await reconnectedDevice.initialize(false);
     let stripped = (0, firmware_1.stripFwHeaders)(binary);
-    await (0, firmware_1.uploadFirmware)(reconnectedDevice.getCommands().typedCall.bind(reconnectedDevice.getCommands()), postMessage, reconnectedDevice, { payload: !intermediary && (0, firmware_1.shouldStripFwHeaders)(device.features) ? stripped : binary });
+    await (0, firmware_1.uploadFirmware)(reconnectedDevice.getCommands().typedCall, postMessage, reconnectedDevice, { payload: !intermediary && (0, firmware_1.shouldStripFwHeaders)(device.features) ? stripped : binary });
     log.info('onCallFirmwareUpdate', 'firmware uploaded');
     if (intermediary) {
         log.info('onCallFirmwareUpdate', '...but it was the intermediary firmware, so one more go');
@@ -238,7 +239,7 @@ const onCallFirmwareUpdate = async ({ params, context, }) => {
         binaryInfo = await getBinaryHelper(reconnectedDevice, params, log, postMessage, btcOnly);
         stripped = (0, firmware_1.stripFwHeaders)(binaryInfo.binary);
         await reconnectedDevice.initialize(false);
-        await (0, firmware_1.uploadFirmware)(reconnectedDevice.getCommands().typedCall.bind(reconnectedDevice.getCommands()), postMessage, reconnectedDevice, { payload: stripped });
+        await (0, firmware_1.uploadFirmware)(reconnectedDevice.getCommands().typedCall, postMessage, reconnectedDevice, { payload: stripped });
     }
     reconnectedDevice = await waitForReconnectedDevice({ bootloader: false, method: 'wait' }, { ...context, device: reconnectedDevice });
     if (reconnectedDevice.atLeast('2.7.0') &&
@@ -259,6 +260,8 @@ const onCallFirmwareUpdate = async ({ params, context, }) => {
     const { binaryVersion, releaseVersion } = binaryInfo;
     const assertBinaryVersion = (0, versionUtils_1.isEqual)(installedVersion, binaryVersion);
     const assertReleaseVersion = releaseVersion ? (0, versionUtils_1.isEqual)(installedVersion, releaseVersion) : true;
+    await reconnectedDevice.release();
+    log.info('onCallFirmwareUpdate', `firmware updated to version ${installedVersion}`);
     return {
         versionCheck: assertBinaryVersion && assertReleaseVersion,
         bootloaderVersion,