@trezor/connect 9.0.0-beta.1

package/lib/api/ethereumGetAddress.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const pathUtils_1 = require("../utils/pathUtils");
+const ethereumUtils_1 = require("../utils/ethereumUtils");
+const coinInfo_1 = require("../data/coinInfo");
+const formatUtils_1 = require("../utils/formatUtils");
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
+    constructor() {
+        super(...arguments);
+        this.progress = 0;
+    }
+    init() {
+        this.requiredPermissions = ['read'];
+        this.hasBundle = !!this.payload.bundle;
+        const payload = !this.payload.bundle
+            ? { ...this.payload, bundle: [this.payload] }
+            : this.payload;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'bundle', type: 'array' },
+            { name: 'useEventListener', type: 'boolean' },
+        ]);
+        this.params = payload.bundle.map(batch => {
+            (0, paramsValidator_1.validateParams)(batch, [
+                { name: 'path', required: true },
+                { name: 'address', type: 'string' },
+                { name: 'showOnTrezor', type: 'boolean' },
+            ]);
+            const path = (0, pathUtils_1.validatePath)(batch.path, 3);
+            const network = (0, coinInfo_1.getEthereumNetwork)(path);
+            this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);
+            return {
+                address_n: path,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+                address: batch.address,
+                network,
+            };
+        });
+        if (this.params.length === 1) {
+            this.info = (0, ethereumUtils_1.getNetworkLabel)('Export #NETWORK address', this.params[0].network);
+        }
+        else {
+            const requestedNetworks = this.params.map(b => b.network);
+            const uniqNetworks = (0, coinInfo_1.getUniqueNetworks)(requestedNetworks);
+            if (uniqNetworks.length === 1 && uniqNetworks[0]) {
+                this.info = (0, ethereumUtils_1.getNetworkLabel)('Export multiple #NETWORK addresses', uniqNetworks[0]);
+            }
+            else {
+                this.info = 'Export multiple addresses';
+            }
+        }
+        const useEventListener = payload.useEventListener &&
+            this.params.length === 1 &&
+            typeof this.params[0].address === 'string' &&
+            this.params[0].show_display;
+        this.confirmed = useEventListener;
+        this.useUi = !useEventListener;
+    }
+    getButtonRequestData(code) {
+        if (code === 'ButtonRequest_Address') {
+            return {
+                type: 'address',
+                serializedPath: (0, pathUtils_1.getSerializedPath)(this.params[this.progress].address_n),
+                address: this.params[this.progress].address || 'not-set',
+            };
+        }
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'export-address',
+            label: this.info,
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async noBackupConfirmation() {
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'no-backup',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    _call({ address_n, show_display }) {
+        const cmd = this.device.getCommands();
+        return cmd.ethereumGetAddress({
+            address_n,
+            show_display,
+        });
+    }
+    async run() {
+        const responses = [];
+        for (let i = 0; i < this.params.length; i++) {
+            const batch = this.params[i];
+            if (batch.show_display) {
+                const silent = await this._call({
+                    ...batch,
+                    show_display: false,
+                });
+                if (typeof batch.address === 'string') {
+                    if ((0, formatUtils_1.stripHexPrefix)(batch.address).toLowerCase() !==
+                        (0, formatUtils_1.stripHexPrefix)(silent.address).toLowerCase()) {
+                        throw constants_1.ERRORS.TypedError('Method_AddressNotMatch');
+                    }
+                }
+                else {
+                    batch.address = silent.address;
+                }
+            }
+            const response = await this._call(batch);
+            responses.push(response);
+            if (this.hasBundle) {
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                    progress: i,
+                    response,
+                }));
+            }
+            this.progress++;
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = EthereumGetAddress;
+//# sourceMappingURL=ethereumGetAddress.js.map

package/lib/api/ethereumGetPublicKey.d.ts

@@ -0,0 +1,15 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+import type { EthereumNetworkInfo } from '../types';
+declare type Params = PROTO.EthereumGetPublicKey & {
+    network?: EthereumNetworkInfo;
+};
+export default class EthereumGetPublicKey extends AbstractMethod<'ethereumGetPublicKey', Params[]> {
+    hasBundle?: boolean;
+    confirmed?: boolean;
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("../types/api/getPublicKey").HDNodeResponse | import("../types/api/getPublicKey").HDNodeResponse[]>;
+}
+export {};
+//# sourceMappingURL=ethereumGetPublicKey.d.ts.map

package/lib/api/ethereumGetPublicKey.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const pathUtils_1 = require("../utils/pathUtils");
+const ethereumUtils_1 = require("../utils/ethereumUtils");
+const coinInfo_1 = require("../data/coinInfo");
+const events_1 = require("../events");
+class EthereumGetPublicKey extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.hasBundle = !!this.payload.bundle;
+        const payload = !this.payload.bundle
+            ? { ...this.payload, bundle: [this.payload] }
+            : this.payload;
+        (0, paramsValidator_1.validateParams)(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = payload.bundle.map(batch => {
+            (0, paramsValidator_1.validateParams)(batch, [
+                { name: 'path', required: true },
+                { name: 'showOnTrezor', type: 'boolean' },
+            ]);
+            const path = (0, pathUtils_1.validatePath)(batch.path, 3);
+            const network = (0, coinInfo_1.getEthereumNetwork)(path);
+            this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);
+            return {
+                address_n: path,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
+                network,
+            };
+        });
+        if (this.params.length === 1) {
+            this.info = (0, ethereumUtils_1.getNetworkLabel)('Export #NETWORK public key', this.params[0].network);
+        }
+        else {
+            const requestedNetworks = this.params.map(b => b.network);
+            const uniqNetworks = (0, coinInfo_1.getUniqueNetworks)(requestedNetworks);
+            if (uniqNetworks.length === 1 && uniqNetworks[0]) {
+                this.info = (0, ethereumUtils_1.getNetworkLabel)('Export multiple #NETWORK public keys', uniqNetworks[0]);
+            }
+            else {
+                this.info = 'Export multiple public keys';
+            }
+        }
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'export-xpub',
+            label: this.info,
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async run() {
+        const responses = [];
+        const cmd = this.device.getCommands();
+        for (let i = 0; i < this.params.length; i++) {
+            const batch = this.params[i];
+            const response = await cmd.ethereumGetPublicKey({
+                address_n: batch.address_n,
+                show_display: batch.show_display,
+            });
+            responses.push(response);
+            if (this.hasBundle) {
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                    progress: i,
+                    response,
+                }));
+            }
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = EthereumGetPublicKey;
+//# sourceMappingURL=ethereumGetPublicKey.js.map

package/lib/api/ethereumSignMessage.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class EthereumSignMessage extends AbstractMethod<'ethereumSignMessage', PROTO.EthereumSignMessage> {
+    init(): void;
+    run(): Promise<PROTO.EthereumMessageSignature>;
+}
+//# sourceMappingURL=ethereumSignMessage.d.ts.map

package/lib/api/ethereumSignMessage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const pathUtils_1 = require("../utils/pathUtils");
+const coinInfo_1 = require("../data/coinInfo");
+const ethereumUtils_1 = require("../utils/ethereumUtils");
+const formatUtils_1 = require("../utils/formatUtils");
+class EthereumSignMessage extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'message', type: 'string', required: true },
+            { name: 'hex', type: 'boolean' },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+        const network = (0, coinInfo_1.getEthereumNetwork)(path);
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);
+        this.info = (0, ethereumUtils_1.getNetworkLabel)('Sign #NETWORK message', network);
+        const messageHex = payload.hex
+            ? (0, formatUtils_1.messageToHex)(payload.message)
+            : Buffer.from(payload.message, 'utf8').toString('hex');
+        this.params = {
+            address_n: path,
+            message: messageHex,
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const { address_n, message } = this.params;
+        const response = await cmd.typedCall('EthereumSignMessage', 'EthereumMessageSignature', {
+            address_n,
+            message,
+        });
+        return response.message;
+    }
+}
+exports.default = EthereumSignMessage;
+//# sourceMappingURL=ethereumSignMessage.js.map

package/lib/api/ethereumSignTransaction.d.ts

@@ -0,0 +1,20 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { EthereumTransaction, EthereumTransactionEIP1559 } from '../types/api/ethereumSignTransaction';
+declare type Params = {
+    path: number[];
+    tx: ({
+        type: 'legacy';
+    } & EthereumTransaction) | ({
+        type: 'eip1559';
+    } & EthereumTransactionEIP1559);
+};
+export default class EthereumSignTransaction extends AbstractMethod<'ethereumSignTransaction', Params> {
+    init(): void;
+    run(): Promise<{
+        v: string;
+        r: string;
+        s: string;
+    }>;
+}
+export {};
+//# sourceMappingURL=ethereumSignTransaction.d.ts.map

package/lib/api/ethereumSignTransaction.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const pathUtils_1 = require("../utils/pathUtils");
+const coinInfo_1 = require("../data/coinInfo");
+const ethereumUtils_1 = require("../utils/ethereumUtils");
+const formatUtils_1 = require("../utils/formatUtils");
+const helper = (0, tslib_1.__importStar)(require("./ethereum/ethereumSignTx"));
+const strip = value => {
+    if (typeof value === 'string') {
+        let stripped = (0, formatUtils_1.stripHexPrefix)(value);
+        if (stripped.length % 2 !== 0) {
+            stripped = `0${stripped}`;
+        }
+        return stripped;
+    }
+    if (Array.isArray(value)) {
+        return value.map(strip);
+    }
+    if (typeof value === 'object') {
+        return Object.entries(value).reduce((acc, [k, v]) => ({ ...acc, [k]: strip(v) }), {});
+    }
+    return value;
+};
+class EthereumSignTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'transaction', required: true },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+        const network = (0, coinInfo_1.getEthereumNetwork)(path);
+        this.info = (0, ethereumUtils_1.getNetworkLabel)('Sign #NETWORK transaction', network);
+        const tx = payload.transaction;
+        const isEIP1559 = tx.maxFeePerGas && tx.maxPriorityFeePerGas;
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(isEIP1559 ? 'eip1559' : this.name, network, this.firmwareRange);
+        const schema = isEIP1559
+            ? [
+                { name: 'to', type: 'string', required: true },
+                { name: 'value', type: 'string', required: true },
+                { name: 'gasLimit', type: 'string', required: true },
+                { name: 'maxFeePerGas', type: 'string', required: true },
+                { name: 'maxPriorityFeePerGas', type: 'string', required: true },
+                { name: 'nonce', type: 'string', required: true },
+                { name: 'data', type: 'string' },
+                { name: 'chainId', type: 'number', required: true },
+            ]
+            : [
+                { name: 'to', type: 'string', required: true },
+                { name: 'value', type: 'string', required: true },
+                { name: 'gasLimit', type: 'string', required: true },
+                { name: 'gasPrice', type: 'string', required: true },
+                { name: 'nonce', type: 'string', required: true },
+                { name: 'data', type: 'string' },
+                { name: 'chainId', type: 'number' },
+                { name: 'txType', type: 'number' },
+            ];
+        (0, paramsValidator_1.validateParams)(tx, schema);
+        if (typeof tx.chainId !== 'number') {
+            console.warn('TrezorConnect.ethereumSignTransaction: Missing chainId parameter!');
+        }
+        this.params = {
+            path,
+            tx: {
+                type: isEIP1559 ? 'eip1559' : 'legacy',
+                ...strip(tx),
+            },
+        };
+    }
+    run() {
+        const { tx } = this.params;
+        return tx.type === 'eip1559'
+            ? helper.ethereumSignTxEIP1559(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.maxFeePerGas, tx.maxPriorityFeePerGas, tx.nonce, tx.chainId, tx.data, tx.accessList)
+            : helper.ethereumSignTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.gasPrice, tx.nonce, tx.chainId, tx.data, tx.txType);
+    }
+}
+exports.default = EthereumSignTransaction;
+//# sourceMappingURL=ethereumSignTransaction.js.map

package/lib/api/ethereumSignTypedData.d.ts

@@ -0,0 +1,14 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { EthereumSignTypedDataTypes, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from '../types/api/ethereumSignTypedData';
+declare type Params = (Omit<EthereumSignTypedDataParams<EthereumSignTypedDataTypes>, 'path'> | Omit<EthereumSignTypedHashParams<EthereumSignTypedDataTypes>, 'path'>) & {
+    address_n: number[];
+};
+export default class EthereumSignTypedData extends AbstractMethod<'ethereumSignTypedData', Params> {
+    init(): void;
+    run(): Promise<{
+        address: string;
+        signature: string;
+    }>;
+}
+export {};
+//# sourceMappingURL=ethereumSignTypedData.d.ts.map

package/lib/api/ethereumSignTypedData.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const pathUtils_1 = require("../utils/pathUtils");
+const coinInfo_1 = require("../data/coinInfo");
+const ethereumUtils_1 = require("../utils/ethereumUtils");
+const constants_1 = require("../constants");
+const ethereumSignTypedData_1 = require("./ethereum/ethereumSignTypedData");
+const formatUtils_1 = require("../utils/formatUtils");
+class EthereumSignTypedData extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'metamask_v4_compat', type: 'boolean', required: true },
+            { name: 'data', type: 'object', required: true },
+            { name: 'domain_separator_hash', type: 'string' },
+            { name: 'message_hash', type: 'string' },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+        const network = (0, coinInfo_1.getEthereumNetwork)(path);
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);
+        this.info = (0, ethereumUtils_1.getNetworkLabel)('Sign #NETWORK typed data', network);
+        this.params = {
+            address_n: path,
+            metamask_v4_compat: payload.metamask_v4_compat,
+            data: payload.data,
+        };
+        if (payload.domain_separator_hash) {
+            this.params = {
+                ...this.params,
+                domain_separator_hash: (0, formatUtils_1.messageToHex)(payload.domain_separator_hash),
+            };
+            if (payload.message_hash) {
+                this.params = {
+                    ...this.params,
+                    message_hash: (0, formatUtils_1.messageToHex)(payload.message_hash),
+                };
+            }
+            else if (this.params.data.primaryType !== 'EIP712Domain') {
+                throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'message_hash should only be empty when data.primaryType=EIP712Domain');
+            }
+        }
+        if (this.params.data.primaryType === 'EIP712Domain') {
+            this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)('eip712-domain-only', network, this.firmwareRange);
+            if ('message_hash' in this.params) {
+                throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'message_hash should be empty when data.primaryType=EIP712Domain');
+            }
+        }
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const { address_n } = this.params;
+        if (this.device.features.model === '1') {
+            (0, paramsValidator_1.validateParams)(this.params, [
+                { name: 'domain_separator_hash', type: 'string', required: true },
+                { name: 'message_hash', type: 'string' },
+            ]);
+            const { domain_separator_hash, message_hash } = this.params;
+            const response = await cmd.typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
+                address_n,
+                domain_separator_hash: domain_separator_hash,
+                message_hash,
+            });
+            const { address, signature } = response.message;
+            return {
+                address,
+                signature: `0x${signature}`,
+            };
+        }
+        const { data, metamask_v4_compat } = this.params;
+        const { types, primaryType, domain, message } = data;
+        let response = await cmd.typedCall('EthereumSignTypedData', [
+            'EthereumTypedDataStructRequest',
+            'EthereumTypedDataValueRequest',
+            'EthereumTypedDataSignature',
+        ], {
+            address_n,
+            primary_type: primaryType,
+            metamask_v4_compat,
+        });
+        while (response.type === 'EthereumTypedDataStructRequest') {
+            const { name: typeDefinitionName } = response.message;
+            const typeDefinition = types[typeDefinitionName];
+            if (typeDefinition === undefined) {
+                throw constants_1.ERRORS.TypedError('Runtime', `Type ${typeDefinitionName} was not defined in types object`);
+            }
+            const dataStruckAck = {
+                members: typeDefinition.map(({ name, type: typeName }) => ({
+                    name,
+                    type: (0, ethereumSignTypedData_1.getFieldType)(typeName, types),
+                })),
+            };
+            response = await cmd.typedCall('EthereumTypedDataStructAck', [
+                'EthereumTypedDataStructRequest',
+                'EthereumTypedDataValueRequest',
+                'EthereumTypedDataSignature',
+            ], dataStruckAck);
+        }
+        while (response.type === 'EthereumTypedDataValueRequest') {
+            const { member_path } = response.message;
+            let memberData;
+            let memberTypeName;
+            const [rootIndex, ...nestedMemberPath] = member_path;
+            switch (rootIndex) {
+                case 0:
+                    memberData = domain;
+                    memberTypeName = 'EIP712Domain';
+                    break;
+                case 1:
+                    memberData = message;
+                    memberTypeName = primaryType;
+                    break;
+                default:
+                    throw constants_1.ERRORS.TypedError('Runtime', 'Root index can only be 0 or 1');
+            }
+            for (const index of nestedMemberPath) {
+                if (Array.isArray(memberData)) {
+                    memberTypeName = (0, ethereumSignTypedData_1.parseArrayType)(memberTypeName).entryTypeName;
+                    memberData = memberData[index];
+                }
+                else if (typeof memberData === 'object' && memberData !== null) {
+                    const memberTypeDefinition = types[memberTypeName][index];
+                    memberTypeName = memberTypeDefinition.type;
+                    memberData = memberData[memberTypeDefinition.name];
+                }
+                else {
+                }
+            }
+            let encodedData;
+            if (Array.isArray(memberData)) {
+                encodedData = (0, ethereumSignTypedData_1.encodeData)('uint16', memberData.length);
+            }
+            else {
+                encodedData = (0, ethereumSignTypedData_1.encodeData)(memberTypeName, memberData);
+            }
+            response = await cmd.typedCall('EthereumTypedDataValueAck', ['EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'], {
+                value: encodedData,
+            });
+        }
+        const { address, signature } = response.message;
+        return {
+            address,
+            signature: `0x${signature}`,
+        };
+    }
+}
+exports.default = EthereumSignTypedData;
+//# sourceMappingURL=ethereumSignTypedData.js.map

package/lib/api/ethereumVerifyMessage.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class EthereumVerifyMessage extends AbstractMethod<'ethereumVerifyMessage', PROTO.EthereumVerifyMessage> {
+    init(): void;
+    run(): Promise<PROTO.Success>;
+}
+//# sourceMappingURL=ethereumVerifyMessage.d.ts.map

package/lib/api/ethereumVerifyMessage.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const formatUtils_1 = require("../utils/formatUtils");
+class EthereumVerifyMessage extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+        this.info = 'Verify message';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'address', type: 'string', required: true },
+            { name: 'signature', type: 'string', required: true },
+            { name: 'message', type: 'string', required: true },
+            { name: 'hex', type: 'boolean' },
+        ]);
+        const messageHex = payload.hex
+            ? (0, formatUtils_1.messageToHex)(payload.message)
+            : Buffer.from(payload.message, 'utf8').toString('hex');
+        this.params = {
+            address: (0, formatUtils_1.stripHexPrefix)(payload.address),
+            signature: (0, formatUtils_1.stripHexPrefix)(payload.signature),
+            message: messageHex,
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('EthereumVerifyMessage', 'Success', this.params);
+        return response.message;
+    }
+}
+exports.default = EthereumVerifyMessage;
+//# sourceMappingURL=ethereumVerifyMessage.js.map

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

@@ -0,0 +1,20 @@
+import { GetInfoProps } from '../../data/firmwareInfo';
+interface GetBinaryProps extends GetInfoProps {
+    baseUrl: string;
+    btcOnly?: boolean;
+    version?: number[];
+    intermediary?: boolean;
+}
+export declare const getBinary: ({ features, releases, baseUrl, version, btcOnly, intermediary, }: GetBinaryProps) => Promise<{
+    binary: ArrayBuffer;
+} | {
+    binary: ArrayBuffer;
+    changelog: import("../..").FirmwareRelease[] | null;
+    release: import("../..").FirmwareRelease;
+    isLatest: boolean;
+    latest: import("../..").FirmwareRelease;
+    isRequired: boolean | null;
+    isNewer: boolean | null;
+}>;
+export {};
+//# sourceMappingURL=getBinary.d.ts.map

package/lib/api/firmware/getBinary.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBinary = void 0;
+const utils_1 = require("@trezor/utils");
+const assets_1 = require("../../utils/assets");
+const firmwareUtils_1 = require("../../utils/firmwareUtils");
+const firmwareInfo_1 = require("../../data/firmwareInfo");
+const modifyFirmware_1 = require("./modifyFirmware");
+const getBinary = async ({ features, releases, baseUrl, version, btcOnly, intermediary = false, }) => {
+    if (!(0, firmwareUtils_1.isStrictFeatures)(features)) {
+        throw new Error('Features of unexpected shape provided');
+    }
+    if (intermediary && features.major_version !== 2) {
+        const fw = await (0, assets_1.httpRequest)(`${baseUrl}/firmware/1/trezor-inter-1.10.0.bin`, 'binary');
+        return { binary: (0, modifyFirmware_1.modifyFirmware)({ fw, features }) };
+    }
+    const infoByBootloader = (0, firmwareInfo_1.getInfo)({ features, releases });
+    const releaseByFirmware = releases.find(r => version &&
+        utils_1.versionUtils.isVersionArray(version) &&
+        utils_1.versionUtils.isEqual(r.version, version));
+    if (!infoByBootloader || !releaseByFirmware) {
+        throw new Error('no firmware found for this device');
+    }
+    if (btcOnly && !releaseByFirmware.url_bitcoinonly) {
+        throw new Error(`firmware version ${version} does not exist in btc only variant`);
+    }
+    if (!utils_1.versionUtils.isEqual(releaseByFirmware.version, infoByBootloader.release.version)) {
+        throw new Error('version provided as param does not match firmware version found by features in bootloader');
+    }
+    const fw = await (0, assets_1.httpRequest)(`${baseUrl}/${btcOnly ? releaseByFirmware.url_bitcoinonly : releaseByFirmware.url}`, 'binary');
+    return {
+        ...infoByBootloader,
+        binary: (0, modifyFirmware_1.modifyFirmware)({ fw, features }),
+    };
+};
+exports.getBinary = getBinary;
+//# sourceMappingURL=getBinary.js.map

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

@@ -0,0 +1,6 @@
+import type { StrictFeatures } from '../../types';
+export declare const modifyFirmware: ({ fw, features }: {
+    fw: ArrayBuffer;
+    features: StrictFeatures;
+}) => ArrayBuffer;
+//# sourceMappingURL=modifyFirmware.d.ts.map