@trezor/connect 9.6.2 → 9.6.3-beta.1

package/CHANGELOG.md

@@ -1,16 +1,25 @@
-|             Package              | Stable | Canary |
-| :------------------------------: | :----: | :----: |
-|       npm @trezor/connect        | 9.6.2  |   -    |
-|     npm @trezor/connect-web      | 9.6.2  |   -    |
-| npm @trezor/connect-webextension | 9.6.2  |   -    |
-|    npm @trezor/connect-mobile    | 9.6.2  |   -    |
+|             Package              | Stable |    Canary    |
+| :------------------------------: | :----: | :----------: |
+|       npm @trezor/connect        | 9.6.2  | 9.6.3-beta.1 |
+|     npm @trezor/connect-web      | 9.6.2  | 9.6.3-beta.1 |
+| npm @trezor/connect-webextension | 9.6.2  | 9.6.3-beta.1 |
+|    npm @trezor/connect-mobile    | 9.6.2  | 9.6.3-beta.1 |
 
-|     Deployment     | Stable | Canary |
-| :----------------: | :----: | :----: |
-| connect.trezor.io/ | 9.6.2  |   -    |
+|     Deployment     | Stable |    Canary    |
+| :----------------: | :----: | :----------: |
+| connect.trezor.io/ | 9.6.2  | 9.6.3-beta.1 |
 
 Use the persistent link [connect.trezor.io/9](https://connect.trezor.io/9/) to access the latest stable version of Connect Explorer.
 
+# 9.6.3-beta.1
+
+We’ve added support for Cardano message signing based on the CIP-8 standard, available through the new cardanoSignMessage method.
+
+    - feat(connect-explorer): Add cardanoSignMessage (bc88818)
+    - feat(connect): Cardano message signing (01c4a0f)
+
+Other than that only bug fixing, refactorings and chores are present.
+
 # 9.6.2
 
 This release is important for smooth support of 2.9.0 trezor firmware, namely commits:

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.6.2
+API version 9.6.3-beta.1
 
 [![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/test-connect.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/test-connect.yml)
 [![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)

package/lib/api/applySettings.js

@@ -27,7 +27,22 @@ class ApplySettings extends AbstractMethod_1.AbstractMethod {
     }
     async run() {
         const cmd = this.device.getCommands();
-        const response = await cmd.typedCall('ApplySettings', 'Success', this.params);
+        const homescreenBytes = this.params.homescreen
+            ? Buffer.from(this.params.homescreen, 'hex')
+            : undefined;
+        if (this.device.atLeast('2.9.0') && homescreenBytes) {
+            this.params.homescreen = undefined;
+            this.params.homescreen_length = homescreenBytes.length;
+        }
+        let response = await cmd.typedCall('ApplySettings', ['DataChunkRequest', 'Success'], this.params);
+        while (response.type !== 'Success') {
+            const start = response.message.data_offset;
+            const end = start + response.message.data_length;
+            const data_chunk = homescreenBytes?.subarray(start, end).toString('hex') || '';
+            response = await cmd.typedCall('DataChunkAck', ['DataChunkRequest', 'Success'], {
+                data_chunk,
+            });
+        }
         return response.message;
     }
 }

package/lib/api/bitcoin/signtx.d.ts

@@ -8,7 +8,7 @@ export interface SignTxHelperProps {
     refTxs: Record<string, RefTransaction>;
     inputs: PROTO.TxInputType[];
     outputs: PROTO.TxOutputType[];
-    paymentRequests: PROTO.TxAckPaymentRequest[];
+    paymentRequests: PROTO.PaymentRequest[];
     serializedTx: string[];
     signatures: string[];
 }
@@ -16,7 +16,7 @@ export interface SignTxHelperParams {
     typedCall: TypedCall;
     inputs: PROTO.TxInputType[];
     outputs: PROTO.TxOutputType[];
-    paymentRequests?: PROTO.TxAckPaymentRequest[];
+    paymentRequests?: PROTO.PaymentRequest[];
     refTxs: RefTransaction[];
     options: TransactionOptions;
     coinInfo: BitcoinNetworkInfo;

package/lib/api/bitcoin/signtx.js

@@ -88,7 +88,7 @@ const requestSignedTxInfo = ({ typedCall, txRequest: { request_type, details },
         if (!req) {
             throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown payment request at ${details.request_index}`);
         }
-        return typedCall('TxAckPaymentRequest', 'TxRequest', {
+        return typedCall('PaymentRequest', 'TxRequest', {
             nonce: req.nonce,
             recipient_name: req.recipient_name,
             memos: req.memos,

package/lib/api/bleUnpair.js

@@ -9,7 +9,6 @@ class BleUnpair extends AbstractMethod_1.AbstractMethod {
     init() {
         this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
         this.requiredPermissions = ['management'];
-        this.skipFinalReload = false;
         this.useDeviceState = false;
         this.skipFinalReload = true;
         const { payload } = this;

package/lib/api/cardano/api/cardanoGetAddress.d.ts

@@ -18,6 +18,7 @@ export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress
         label: string;
     } | undefined;
     _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, chunkify, }: Params): Promise<{
+        mac?: string | undefined;
         address: string;
     }>;
     run(): Promise<import("../../../types").CardanoAddress | import("../../../types").CardanoAddress[]>;

package/lib/api/cardano/api/cardanoSignMessage.d.ts

@@ -0,0 +1,25 @@
+import { PROTO } from '../../../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import { CardanoMessageHeaders, CardanoSignedMessage } from '../../../types/api/cardano';
+import { Path } from '../cardanoInputs';
+export type CardanoSignMessageParams = {
+    path: Path;
+    payload: string;
+    preferHexDisplay: boolean;
+    networkId?: number;
+    protocolMagic?: number;
+    addressParameters?: PROTO.CardanoAddressParametersType;
+    derivationType: PROTO.CardanoDerivationType;
+};
+export default class CardanoSignMessage extends AbstractMethod<'cardanoSignMessage', CardanoSignMessageParams> {
+    static readonly VERSION = 1;
+    init(): void;
+    run(): Promise<CardanoSignedMessage>;
+    _createHeaders(address: string): CardanoMessageHeaders;
+    _createCose(payload: string, signature: string, address: string, pubKey: string): {
+        coseSignature: string;
+        coseKey: string;
+    };
+    get info(): string;
+}
+//# sourceMappingURL=cardanoSignMessage.d.ts.map

package/lib/api/cardano/api/cardanoSignMessage.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const cbor = tslib_1.__importStar(require("cbor"));
+const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../../../constants");
+const AbstractMethod_1 = require("../../../core/AbstractMethod");
+const coinInfo_1 = require("../../../data/coinInfo");
+const cardano_1 = require("../../../types/api/cardano");
+const formatUtils_1 = require("../../../utils/formatUtils");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const paramsValidator_1 = require("../../common/paramsValidator");
+const cardanoAddressParameters_1 = require("../cardanoAddressParameters");
+const cardanoUtils_1 = require("../cardanoUtils");
+class CardanoSignMessage extends AbstractMethod_1.AbstractMethod {
+    static VERSION = 1;
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
+        const { payload } = this;
+        (0, schema_utils_1.Assert)(cardano_1.CardanoSignMessage, payload);
+        if (!(0, formatUtils_1.isHexString)(payload.payload) || (0, formatUtils_1.hasHexPrefix)(payload.payload)) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Message payload must be a hexadecimal string without a "0x" prefix.');
+        }
+        this.params = {
+            path: (0, pathUtils_1.validatePath)(payload.path, 5),
+            payload: payload.payload,
+            preferHexDisplay: payload.preferHexDisplay ?? false,
+            networkId: payload.networkId,
+            protocolMagic: payload.protocolMagic,
+            addressParameters: payload.addressParameters && (0, cardanoAddressParameters_1.addressParametersToProto)(payload.addressParameters),
+            derivationType: payload.derivationType ?? constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        };
+    }
+    async run() {
+        const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+        const payloadSize = (0, cardanoUtils_1.hexStringByteLength)(this.params.payload);
+        let response = await typedCall('CardanoSignMessageInit', ['CardanoMessageSignature', 'CardanoMessageDataRequest'], {
+            signing_path: this.params.path,
+            payload_size: payloadSize,
+            network_id: this.params.networkId,
+            protocol_magic: this.params.protocolMagic,
+            address_parameters: this.params.addressParameters,
+            prefer_hex_display: this.params.preferHexDisplay,
+            derivation_type: this.params.derivationType,
+        });
+        while (response.type !== 'CardanoMessageSignature') {
+            const { length, offset } = response.message;
+            const data = this.params.payload.slice(offset * 2, (offset + length) * 2);
+            response = await typedCall('CardanoMessageDataResponse', ['CardanoMessageSignature', 'CardanoMessageDataRequest'], { data });
+        }
+        const { signature, address, pub_key } = response.message;
+        return {
+            signature,
+            payload: this.params.payload,
+            headers: this._createHeaders(address),
+            pubKey: pub_key,
+            ...this._createCose(this.params.payload, signature, address, pub_key),
+        };
+    }
+    _createHeaders(address) {
+        return {
+            protected: {
+                1: constants_1.CARDANO.ALGORITHM_IDS.EdDSA,
+                address,
+            },
+            unprotected: {
+                hashed: false,
+                version: CardanoSignMessage.VERSION,
+            },
+        };
+    }
+    _createCose(payload, signature, address, pubKey) {
+        const coseSignature = cbor.encode([
+            Buffer.from(cbor.encode(new Map()
+                .set(1, -8)
+                .set('address', Buffer.from(address, 'hex')))),
+            new Map().set('hashed', false),
+            Buffer.from(payload, 'hex'),
+            Buffer.from(signature, 'hex'),
+        ]);
+        const coseKey = cbor.encode(new Map()
+            .set(1, 1)
+            .set(3, -8)
+            .set(-1, 6)
+            .set(-2, Buffer.from(pubKey, 'hex')));
+        return {
+            coseSignature: Buffer.from(coseSignature).toString('hex'),
+            coseKey: Buffer.from(coseKey).toString('hex'),
+        };
+    }
+    get info() {
+        return 'Sign Cardano message';
+    }
+}
+exports.default = CardanoSignMessage;
+//# sourceMappingURL=cardanoSignMessage.js.map

package/lib/api/cardano/api/index.d.ts

@@ -3,4 +3,5 @@ export { default as cardanoGetNativeScriptHash } from './cardanoGetNativeScriptH
 export { default as cardanoGetPublicKey } from './cardanoGetPublicKey';
 export { default as cardanoSignTransaction } from './cardanoSignTransaction';
 export { default as cardanoComposeTransaction } from './cardanoComposeTransaction';
+export { default as cardanoSignMessage } from './cardanoSignMessage';
 //# sourceMappingURL=index.d.ts.map

package/lib/api/cardano/api/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cardanoComposeTransaction = exports.cardanoSignTransaction = exports.cardanoGetPublicKey = exports.cardanoGetNativeScriptHash = exports.cardanoGetAddress = void 0;
+exports.cardanoSignMessage = exports.cardanoComposeTransaction = exports.cardanoSignTransaction = exports.cardanoGetPublicKey = exports.cardanoGetNativeScriptHash = exports.cardanoGetAddress = void 0;
 const tslib_1 = require("tslib");
 var cardanoGetAddress_1 = require("./cardanoGetAddress");
 Object.defineProperty(exports, "cardanoGetAddress", { enumerable: true, get: function () { return tslib_1.__importDefault(cardanoGetAddress_1).default; } });
@@ -12,4 +12,6 @@ var cardanoSignTransaction_1 = require("./cardanoSignTransaction");
 Object.defineProperty(exports, "cardanoSignTransaction", { enumerable: true, get: function () { return tslib_1.__importDefault(cardanoSignTransaction_1).default; } });
 var cardanoComposeTransaction_1 = require("./cardanoComposeTransaction");
 Object.defineProperty(exports, "cardanoComposeTransaction", { enumerable: true, get: function () { return tslib_1.__importDefault(cardanoComposeTransaction_1).default; } });
+var cardanoSignMessage_1 = require("./cardanoSignMessage");
+Object.defineProperty(exports, "cardanoSignMessage", { enumerable: true, get: function () { return tslib_1.__importDefault(cardanoSignMessage_1).default; } });
 //# sourceMappingURL=index.js.map

package/lib/api/cardano/cardanoUtils.d.ts

@@ -5,5 +5,5 @@ export declare const prepareCertificates: (certs: CardanoCertificate[]) => types
 export declare const getTtl: (testnet: boolean) => number;
 export declare const composeTxPlan: (descriptor: string, utxo: AccountUtxo[], outputs: types.UserOutput[], certificates: CardanoCertificate[], withdrawals: types.Withdrawal[], changeAddress: string, isTestnet: boolean, options?: types.Options) => types.PrecomposedTransaction;
 export declare const hexStringByteLength: (s: string) => number;
-export declare const sendChunkedHexString: (typedCall: any, data: string, chunkSize: number, messageType: string) => Promise<void>;
+export declare const sendChunkedHexString: (typedCall: any, data: string, chunkSize: number, messageType: string, responseType?: string) => Promise<void>;
 //# sourceMappingURL=cardanoUtils.d.ts.map

package/lib/api/cardano/cardanoUtils.js

@@ -95,11 +95,11 @@ const composeTxPlan = (descriptor, utxo, outputs, certificates, withdrawals, cha
 exports.composeTxPlan = composeTxPlan;
 const hexStringByteLength = (s) => s.length / 2;
 exports.hexStringByteLength = hexStringByteLength;
-const sendChunkedHexString = async (typedCall, data, chunkSize, messageType) => {
+const sendChunkedHexString = async (typedCall, data, chunkSize, messageType, responseType = 'CardanoTxItemAck') => {
     let processedSize = 0;
     while (processedSize < data.length) {
         const chunk = data.slice(processedSize, processedSize + chunkSize);
-        await typedCall(messageType, 'CardanoTxItemAck', {
+        await typedCall(messageType, responseType, {
             data: chunk,
         });
         processedSize += chunkSize;

package/lib/api/discoverAccounts.js

@@ -17,6 +17,7 @@ const isCardano = (account) => account.symbol === 'ada' || account.symbol === 't
 const isCardanoRequest = (request) => isCardano(request.account);
 const isEvmLedger = (account, coinInfo) => coinInfo.type === 'ethereum' && account.type === 'ledger';
 const getAccountTypeKey = ({ symbol, type }) => `${symbol}-${type}`;
+const substituteBip43Path = (path, index) => path.replace('i', String(index));
 class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
     disposed = false;
     init() {
@@ -25,29 +26,44 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
         this.useDeviceState = true;
         this.useUi = false;
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [{ name: 'accounts', type: 'array' }]);
-        this.params = payload.accounts.flatMap(item => {
-            (0, paramsValidator_1.validateParams)(item, [
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'coins', type: 'array', required: true, allowEmpty: true },
+        ]);
+        this.params = payload.coins.flatMap(coin => {
+            (0, paramsValidator_1.validateParams)(coin, [
                 { name: 'symbol', type: 'string', required: true },
-                { name: 'type', type: 'string' },
+                { name: 'known', type: 'array', allowEmpty: true },
+                { name: 'knownOnly', type: 'boolean' },
                 { name: 'identity', type: 'string' },
                 { name: 'details', type: 'string' },
                 { name: 'pageSize', type: 'number' },
-                { name: 'skip', type: 'number' },
             ]);
-            const { symbol, type, ...rest } = item;
-            const coinInfo = (0, coinInfo_1.getCoinInfo)(item.symbol);
+            const { symbol, known: knownAccs, knownOnly, ...rest } = coin;
+            const coinInfo = (0, coinInfo_1.getCoinInfo)(symbol);
             if (!coinInfo) {
                 throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
             }
             (0, BlockchainLink_1.isBackendSupported)(coinInfo);
             const firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, AbstractMethod_1.DEFAULT_FIRMWARE_RANGE);
-            return discoverAccounts_1.ACCOUNT_TYPES.filter(a => a.symbol === symbol && (!type || a.type === type)).map(account => ({
+            const symbolAccounts = discoverAccounts_1.ACCOUNT_TYPES.filter(a => a.symbol === symbol);
+            knownAccs?.forEach(account => {
+                (0, paramsValidator_1.validateParams)(account, [
+                    { name: 'type', type: 'string', required: true },
+                    { name: 'skip', type: 'number' },
+                ]);
+                if (!symbolAccounts.some(a => a.type === account.type)) {
+                    throw new Error(`Unknown account type: ${symbol}/${account.type}`);
+                }
+            });
+            return symbolAccounts
+                .map(account => [account, knownAccs?.find(t => t.type === account.type)])
+                .filter(([_, known]) => (known ? typeof known.skip === 'number' : !knownOnly))
+                .map(([account, known]) => ({
                 pageSize: TXS_PER_PAGE,
                 details: DETAILS,
                 coinInfo,
                 firmwareRange,
-                skip: 0,
+                skip: known?.skip ?? 0,
                 account,
                 ...rest,
                 offset: isEvmLedger(account, coinInfo) ? 1 : 0,
@@ -61,18 +77,18 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
         const key = getAccountTypeKey(account);
         this.progress[key] = progress;
     }
-    sendProgress(account) {
+    sendProgress(response) {
         const progress = Object.values(this.progress).reduce((sum, typeProgress) => sum + typeProgress, 0) /
             (Object.keys(this.progress).length || 1);
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
-            total: 100,
-            progress: 100 * progress,
-            response: account,
-        }));
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, { total: 100, progress: 100 * progress, response }));
     }
     async run() {
         const [unsupported, supported] = this.filterUnsupportedAccounts(this.params);
-        unsupported.forEach(({ account: { path, ...rest }, error }) => this.sendProgress({ ...rest, index: 0, error }));
+        unsupported.forEach(({ account: { path: bip43, ...rest }, error, coinInfo, skip, offset }) => {
+            const path = substituteBip43Path(bip43, skip + offset);
+            const backendType = coinInfo.blockchainLink?.type;
+            this.sendProgress({ ...rest, index: skip, failed: true, error, path, backendType });
+        });
         const [cardanoAccounts, otherAccounts] = (0, utils_1.arrayPartition)(supported, isCardanoRequest);
         const [_, filteredCardanoAccounts] = await this.filterCardanoDerivations(cardanoAccounts);
         const accounts = [...otherAccounts, ...filteredCardanoAccounts];
@@ -104,12 +120,16 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
         }), item => 'error' in item);
     }
     async filterCardanoDerivations(accounts) {
-        const tryGetDescriptor = (coin) => coin && this.getDescriptor(coin.coinInfo, coin.account.path, coin.derivation, 0);
-        const normal = await tryGetDescriptor(accounts.find(a => a.account.type === 'normal'));
-        const ledger = await tryGetDescriptor(accounts.find(a => a.account.type === 'ledger'));
-        const legacy = await tryGetDescriptor(accounts.find(a => a.account.type === 'legacy'));
-        const omitLegacy = legacy && legacy.descriptor === (normal ?? ledger)?.descriptor;
-        const omitLedger = ledger && ledger.descriptor === normal?.descriptor;
+        const legacyRequest = accounts.find(a => a.account.type === 'legacy');
+        const ledgerRequest = accounts.find(a => a.account.type === 'ledger');
+        const filterableRequest = legacyRequest ?? ledgerRequest;
+        const getDescriptor = (derivation) => filterableRequest &&
+            this.getDescriptor(filterableRequest.coinInfo, filterableRequest.account.path, discoverAccounts_1.CARDANO_DERIVATIONS[derivation], 0).then(({ descriptor }) => descriptor);
+        const normalDescriptor = await getDescriptor('normal');
+        const omitLegacy = legacyRequest && (await getDescriptor('legacy')) === normalDescriptor;
+        const omitLedger = ledgerRequest &&
+            (!legacyRequest || omitLegacy) &&
+            (await getDescriptor('ledger')) === normalDescriptor;
         return (0, utils_1.arrayPartition)(accounts.map(item => (item.account.type === 'legacy' && omitLegacy) ||
             (item.account.type === 'ledger' && omitLedger)
             ? { ...item, error: 'ignored cardano derivation' }
@@ -118,7 +138,7 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
     descriptorLock = (0, utils_1.getSynchronize)();
     descriptorCache = {};
     async getDescriptor(coinInfo, bip43PathTemplate, derivationType, index) {
-        const path = bip43PathTemplate.replace('i', String(index));
+        const path = substituteBip43Path(bip43PathTemplate, index);
         const { address_n: _, ...descriptorRest } = await this.descriptorLock(async () => {
             const key = `${path}-${derivationType}`;
             if (!this.descriptorCache[key]) {
@@ -133,23 +153,28 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
     }
     async discoverAccount(request) {
         const { details, identity, pageSize, coinInfo, derivation, offset, skip } = request;
-        const { path, ...accountKey } = request.account;
+        const { path: bip43, ...accountKey } = request.account;
+        const backendType = coinInfo.blockchainLink?.type;
         const utxoRequired = (0, accountUtils_1.isUtxoBased)(coinInfo) && details && details !== 'basic';
         let index = skip;
         let blockchain;
         try {
             blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage, identity);
         }
-        catch (error) {
+        catch (err) {
+            const path = substituteBip43Path(bip43, offset + index);
             this.updateProgress(accountKey, index + 1, true);
-            this.sendProgress({ ...accountKey, index, error: error.message });
-            return { nonempty: 0, error: error.message };
+            const error = err.message;
+            this.sendProgress({ ...accountKey, index, failed: true, error, path, backendType });
+            return { nonempty: 0, error };
         }
-        let descPromise = this.getDescriptor(coinInfo, path, derivation, offset + index);
+        let descPromise = this.getDescriptor(coinInfo, bip43, derivation, offset + index);
+        descPromise.catch(() => { });
         while (true) {
             try {
                 const { descriptor, ...descRest } = await descPromise;
-                descPromise = this.getDescriptor(coinInfo, path, derivation, offset + index + 1);
+                descPromise = this.getDescriptor(coinInfo, bip43, derivation, offset + index + 1);
+                descPromise.catch(() => { });
                 const info = await blockchain.getAccountInfo({ descriptor, details, pageSize });
                 const utxo = !utxoRequired
                     ? undefined
@@ -164,17 +189,20 @@ class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
                     utxo,
                     ...accountKey,
                     index,
-                    backendType: request.coinInfo.blockchainLink?.type,
+                    backendType,
+                    failed: false,
                 });
                 if (info.empty) {
                     await descPromise.catch(() => { });
                     return { nonempty: index - skip };
                 }
             }
-            catch (error) {
-                descPromise.catch(() => { });
+            catch (err) {
+                const path = substituteBip43Path(bip43, offset + index);
+                const { message: error, code } = err;
+                const failed = true;
                 this.updateProgress(accountKey, index + 1, true);
-                this.sendProgress({ ...accountKey, index, error: error.message, code: error.code });
+                this.sendProgress({ ...accountKey, index, failed, error, code, path, backendType });
                 return { nonempty: index - skip, error };
             }
             index++;

package/lib/api/ethereum/api/ethereumGetAddress.js

@@ -91,6 +91,7 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
             path: params.address_n,
             serializedPath: (0, pathUtils_1.getSerializedPath)(params.address_n),
             address: response.address,
+            mac: response.mac,
         };
     }
     async run() {

package/lib/api/ethereum/api/ethereumSignTransaction.js

@@ -32,10 +32,28 @@ class EthereumSignTransaction extends AbstractMethod_1.AbstractMethod {
         const isEIP1559 = typeof tx.maxFeePerGas === 'string' && typeof tx.maxPriorityFeePerGas === 'string';
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(isEIP1559 ? 'eip1559' : this.name, network, this.firmwareRange);
         if (isEIP1559) {
-            this.params = { path, network, type: 'eip1559', tx: strip(tx), chunkify };
+            this.params = {
+                path,
+                network,
+                type: 'eip1559',
+                tx: {
+                    ...strip(tx),
+                    payment_req: tx.payment_req,
+                },
+                chunkify,
+            };
         }
         else {
-            this.params = { path, network, type: 'legacy', tx: strip(tx), chunkify };
+            this.params = {
+                path,
+                network,
+                type: 'legacy',
+                tx: {
+                    ...strip(tx),
+                    payment_req: tx.payment_req,
+                },
+                chunkify,
+            };
         }
         if (typeof tx.chainId !== 'number') {
             console.warn('TrezorConnect.ethereumSignTransaction: Missing chainId parameter!');
@@ -129,8 +147,8 @@ class EthereumSignTransaction extends AbstractMethod_1.AbstractMethod {
         const { type, tx, definitions, chunkify } = this.params;
         const isLegacy = type === 'legacy';
         const signature = isLegacy
-            ? await helper.ethereumSignTx(this.device.getCommands().typedCall, this.params.path, tx.to, tx.value, tx.gasLimit, tx.gasPrice, tx.nonce, tx.chainId, chunkify, tx.data, tx.txType, definitions)
-            : await helper.ethereumSignTxEIP1559(this.device.getCommands().typedCall, this.params.path, tx.to, tx.value, tx.gasLimit, tx.maxFeePerGas, tx.maxPriorityFeePerGas, tx.nonce, tx.chainId, chunkify, tx.data, tx.accessList, definitions);
+            ? await helper.ethereumSignTx(this.device.getCommands().typedCall, this.params.path, tx.to, tx.value, tx.gasLimit, tx.gasPrice, tx.nonce, tx.chainId, chunkify, tx.data, tx.txType, definitions, tx.payment_req)
+            : await helper.ethereumSignTxEIP1559(this.device.getCommands().typedCall, this.params.path, tx.to, tx.value, tx.gasLimit, tx.maxFeePerGas, tx.maxPriorityFeePerGas, tx.nonce, tx.chainId, chunkify, tx.data, tx.accessList, definitions, tx.payment_req);
         const serializedTx = helper.serializeEthereumTx(tx, signature, isLegacy);
         return { ...signature, serializedTx };
     }

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

@@ -1,5 +1,6 @@
 import { Common } from '@ethereumjs/common';
 import { MessagesSchema } from '@trezor/protobuf';
+import { PROTO } from '../../constants';
 import type { TypedCall } from '../../device/DeviceCommands';
 import type { EthereumAccessList, EthereumTransaction, EthereumTransactionEIP1559 } from '../../types/api/ethereum';
 export declare const getCommonForChain: (chainId: number) => Common;
@@ -8,12 +9,12 @@ export declare const serializeEthereumTx: (tx: EthereumTransactionEIP1559 | Ethe
     r: `0x${string}`;
     s: `0x${string}`;
 }, isLegacy: boolean) => string;
-export declare const ethereumSignTx: (typedCall: TypedCall, address_n: number[], to: string | null, value: string, gas_limit: string, gas_price: string, nonce: string, chain_id: number, chunkify: boolean, data?: string, tx_type?: number, definitions?: MessagesSchema.EthereumDefinitions) => Promise<{
+export declare const ethereumSignTx: (typedCall: TypedCall, address_n: number[], to: string | null, value: string, gas_limit: string, gas_price: string, nonce: string, chain_id: number, chunkify: boolean, data?: string, tx_type?: number, definitions?: MessagesSchema.EthereumDefinitions, payment_req?: PROTO.PaymentRequest) => Promise<{
     v: `0x${string}`;
     r: `0x${string}`;
     s: `0x${string}`;
 }>;
-export declare const ethereumSignTxEIP1559: (typedCall: TypedCall, address_n: number[], to: string | null, value: string, gas_limit: string, max_gas_fee: string, max_priority_fee: string, nonce: string, chain_id: number, chunkify: boolean, data?: string, access_list?: EthereumAccessList[], definitions?: MessagesSchema.EthereumDefinitions) => Promise<{
+export declare const ethereumSignTxEIP1559: (typedCall: TypedCall, address_n: number[], to: string | null, value: string, gas_limit: string, max_gas_fee: string, max_priority_fee: string, nonce: string, chain_id: number, chunkify: boolean, data?: string, access_list?: EthereumAccessList[], definitions?: MessagesSchema.EthereumDefinitions, payment_req?: PROTO.PaymentRequest) => Promise<{
     v: `0x${string}`;
     r: `0x${string}`;
     s: `0x${string}`;

package/lib/api/ethereum/ethereumSignTx.js

@@ -76,7 +76,7 @@ const stripLeadingZeroes = (str) => {
     }
     return str;
 };
-const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_price, nonce, chain_id, chunkify, data, tx_type, definitions) => {
+const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_price, nonce, chain_id, chunkify, data, tx_type, definitions, payment_req) => {
     const length = data == null ? 0 : data.length / 2;
     const [first, rest] = splitString(data, 1024 * 2);
     let message = {
@@ -89,6 +89,7 @@ const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_pr
         value: stripLeadingZeroes(value),
         definitions,
         chunkify,
+        payment_req,
     };
     if (length !== 0) {
         message = {
@@ -107,7 +108,7 @@ const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_pr
     return processTxRequest(typedCall, response.message, rest, chain_id);
 };
 exports.ethereumSignTx = ethereumSignTx;
-const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit, max_gas_fee, max_priority_fee, nonce, chain_id, chunkify, data, access_list, definitions) => {
+const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit, max_gas_fee, max_priority_fee, nonce, chain_id, chunkify, data, access_list, definitions, payment_req) => {
     const length = data == null ? 0 : data.length / 2;
     const [first, rest] = splitString(data, 1024 * 2);
     const message = {
@@ -127,6 +128,7 @@ const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit,
         })),
         definitions,
         chunkify,
+        payment_req,
     };
     const response = await typedCall('EthereumSignTxEIP1559', 'EthereumTxRequest', message);
     return processTxRequest(typedCall, response.message, rest);

package/lib/api/evoluGetNode.d.ts

@@ -0,0 +1,11 @@
+import { PROTO } from '../constants';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class EvoluGetNode extends AbstractMethod<'evoluGetNode', PROTO.EvoluGetNode> {
+    hasBundle?: boolean;
+    init(): void;
+    get info(): string;
+    run(): Promise<{
+        data: string;
+    }>;
+}
+//# sourceMappingURL=evoluGetNode.d.ts.map

package/lib/api/evoluGetNode.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../constants");
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+class EvoluGetNode extends AbstractMethod_1.AbstractMethod {
+    hasBundle;
+    init() {
+        this.requiredPermissions = ['read'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+        const { payload } = this;
+        (0, schema_utils_1.Assert)(constants_1.PROTO.EvoluGetNode, payload);
+        this.params = {};
+    }
+    get info() {
+        return 'Evolu get node';
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('EvoluGetNode', 'EvoluNode', this.params);
+        return response.message;
+    }
+}
+exports.default = EvoluGetNode;
+//# sourceMappingURL=evoluGetNode.js.map

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

@@ -1,4 +1,5 @@
-export declare const calculateFirmwareHash: (major_version: number, fw: ArrayBuffer, key?: Buffer) => {
+import { DeviceModelInternal } from '@trezor/device-utils';
+export declare const calculateFirmwareHash: (internal_model: DeviceModelInternal, fw: ArrayBuffer, key?: Buffer) => {
     hash: string;
     challenge: string;
 };