@trezor/connect 9.0.0-beta.1

package/LICENSE.md

@@ -0,0 +1,50 @@
+# TREZOR REFERENCE SOURCE LICENSE (T-RSL)
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+## 1. Definitions
+
+The terms "reproduce," "reproduction" and "distribution" have the same meaning
+here as under U.S. copyright law.
+
+"You" means the licensee of the software.
+
+"Your company" means the company you worked for when you downloaded the
+software.
+
+"Reference use" means use of the software within your company as a reference,
+in read only form, for the sole purposes of debugging your products,
+maintaining your products, or enhancing the interoperability of your products
+with the software, and specifically excludes the right to distribute the
+software outside of your company.
+
+"Licensed patents" means any Licensor patent claims which read directly on the
+software as distributed by the Licensor under this license.
+
+## 2. Grant of Rights
+
+(A) Copyright Grant - Subject to the terms of this license, the Licensor grants
+you a non-transferable, non-exclusive, worldwide, royalty-free copyright
+license to reproduce the software for reference use.
+
+(B) Patent Grant - Subject to the terms of this license, the Licensor grants
+you a non-transferable, non-exclusive, worldwide, royalty-free patent license
+under licensed patents for reference use.
+
+## 3. Limitations
+
+(A) No Trademark License - This license does not grant you any rights to use
+the Licensor's name, logo, or trademarks.
+
+(B) If you begin patent litigation against the Licensor over patents that you
+think may apply to the software (including a cross-claim or counterclaim in
+a lawsuit), your license to the software ends automatically.
+
+(C) The software is licensed "as-is." You bear the risk of using it. The
+Licensor gives no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the Licensor excludes
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.

package/README.md

@@ -0,0 +1,38 @@
+# @trezor/connect API version 9.0.0-beta.1
+
+[![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml)
+[![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)
+[![Known Vulnerabilities](https://snyk.io/test/github/trezor/connect/badge.svg?targetFile=package.json)](https://snyk.io/test/github/trezor/trezor-suite?targetFile=packages/connect/package.json)
+
+Trezor Connect is a platform for easy integration of Trezor into 3rd party services, as well as into Trezor Suite. It provides an API with functionality to access public keys, sign transactions and authenticate users.
+
+User interface is presented in a secure popup window served from `connect.trezor.io/<version>/popup.html`. To try it out, use [@trezor/connect-explorer](../connect-explorer) hosted [here](https://trezor.github.io/trezor-suite/connect-explorer).
+
+-   [Integration](https://github.com/trezor/trezor-suite/blob/develop/docs/packages/connect/index.md)
+
+## Versions
+
+### Version 9+ (experimental)
+
+Since version 9 we are adopting a new versioning strategy. With every release, we are going to update two urls
+
+-   A] The latest release will always be available on https://connect.trezor.io/9/trezor-connect.js.
+-   B] For those who like to have more control over their dependencies, there will be also a new url created in form of https://connect.trezor.io/9.1../trezor-connect.js. Please note that these endpoints will not receive any further updates including security updates.
+
+Version 9+ will be available as `@trezor/connect` and `@trezor/connect-web` npm packages.
+
+### Version 8 (stable)
+
+Currently, we are at version 8, which has an url https://connect.trezor.io/8/trezor-connect.js.
+
+Version 8 is available as `trezor-connect` npm package.
+
+If you would like to find out which version is deployed precisely simply run:
+
+`curl -s https://connect.trezor.io/8/trezor-connect.js | grep VERSION`
+
+With regards to this repo - All updates should go to current version branch, the previous releases are in corresponding branches. The gh-pages is the same older version, that is used at trezor.github.io/connect/connect.js, and it's there for backwards compatibility; please don't touch.
+
+## Tests
+
+For integration testing against trezord and emulator refer to [this document](https://github.com/trezor/trezor-suite/blob/develop/packages/integration-tests/projects/connect/README.md).

package/lib/api/applyFlags.d.ts

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

package/lib/api/applyFlags.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const events_1 = require("../events");
+class ApplyFlags extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['management'];
+        this.useDeviceState = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [{ name: 'flags', type: 'number', required: true }]);
+        this.params = {
+            flags: payload.flags,
+        };
+    }
+    async confirmation() {
+        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: 'device-management',
+            customConfirmButton: {
+                className: 'confirm',
+                label: 'Proceed',
+            },
+            label: 'Do you really want to apply flags?',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('ApplyFlags', 'Success', this.params);
+        return response.message;
+    }
+}
+exports.default = ApplyFlags;
+//# sourceMappingURL=applyFlags.js.map

package/lib/api/applySettings.d.ts

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

package/lib/api/applySettings.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const events_1 = require("../events");
+const paramsValidator_1 = require("./common/paramsValidator");
+class ApplySettings extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['management'];
+        this.useDeviceState = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'language', type: 'string' },
+            { name: 'label', type: 'string' },
+            { name: 'use_passphrase', type: 'boolean' },
+            { name: 'homescreen', type: 'string' },
+            { name: 'passphrase_source', type: 'number' },
+            { name: 'passphrase_always_on_device', type: 'boolean' },
+            { name: 'auto_lock_delay_ms', type: 'number' },
+            { name: 'display_rotation', type: 'number' },
+            { name: 'safety_checks', type: 'string' },
+            { name: 'experimental_features', type: 'boolean' },
+        ]);
+        this.params = {
+            language: payload.language,
+            label: payload.label,
+            use_passphrase: payload.use_passphrase,
+            homescreen: payload.homescreen,
+            passphrase_always_on_device: payload.passphrase_always_on_device,
+            auto_lock_delay_ms: payload.auto_lock_delay_ms,
+            display_rotation: payload.display_rotation,
+            safety_checks: payload.safety_checks,
+            experimental_features: payload.experimental_features,
+            _passphrase_source: payload.passphrase_source,
+        };
+    }
+    async confirmation() {
+        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: 'device-management',
+            customConfirmButton: {
+                className: 'confirm',
+                label: 'Proceed',
+            },
+            label: 'Do you really want to change device settings?',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('ApplySettings', 'Success', this.params);
+        return response.message;
+    }
+}
+exports.default = ApplySettings;
+//# sourceMappingURL=applySettings.js.map

package/lib/api/authorizeCoinJoin.d.ts

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

package/lib/api/authorizeCoinJoin.js

@@ -0,0 +1,45 @@
+"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");
+class AuthorizeCoinJoin extends AbstractMethod_1.AbstractMethod {
+    init() {
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'coordinator', type: 'string', required: true },
+            { name: 'maxRounds', type: 'number', required: true },
+            { name: 'maxCoordinatorFeeRate', type: 'number', required: true },
+            { name: 'maxFeePerKvbyte', type: 'number', required: true },
+            { name: 'coin', type: 'string' },
+            { name: 'scriptType', type: 'string' },
+            { name: 'amountUnit', type: 'uint' },
+        ]);
+        const address_n = (0, pathUtils_1.validatePath)(payload.path, 3);
+        const script_type = payload.scriptType || (0, pathUtils_1.getScriptType)(address_n);
+        const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin || address_n);
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+        this.params = {
+            coordinator: payload.coordinator,
+            max_rounds: payload.maxRounds,
+            max_coordinator_fee_rate: payload.maxCoordinatorFeeRate,
+            max_fee_per_kvbyte: payload.maxFeePerKvbyte,
+            address_n,
+            coin_name: coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.name,
+            script_type,
+            amount_unit: payload.amountUnit,
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        if (!this.device.features.experimental_features) {
+            await cmd.typedCall('ApplySettings', 'Success', { experimental_features: true });
+        }
+        const response = await cmd.typedCall('AuthorizeCoinJoin', 'Success', this.params);
+        return response.message;
+    }
+}
+exports.default = AuthorizeCoinJoin;
+//# sourceMappingURL=authorizeCoinJoin.js.map

package/lib/api/backupDevice.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class BackupDevice extends AbstractMethod<'backupDevice'> {
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("packages/transport/lib/types/messages").Success>;
+}
+//# sourceMappingURL=backupDevice.d.ts.map

package/lib/api/backupDevice.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const events_1 = require("../events");
+class BackupDevice extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['management'];
+        this.useDeviceState = false;
+    }
+    async confirmation() {
+        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: 'device-management',
+            customConfirmButton: {
+                className: 'confirm',
+                label: 'Proceed',
+            },
+            label: 'Do you want to initiate backup procedure?',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('BackupDevice', 'Success');
+        return response.message;
+    }
+}
+exports.default = BackupDevice;
+//# sourceMappingURL=backupDevice.js.map

package/lib/api/binance/binanceSignTx.d.ts

@@ -0,0 +1,6 @@
+import { PROTO } from '../../constants';
+import type { BinanceSDKTransaction, BinancePreparedTransaction } from '../../types/api/binanceSignTransaction';
+import type { TypedCall } from '../../device/DeviceCommands';
+export declare const validate: (tx: BinanceSDKTransaction) => BinancePreparedTransaction;
+export declare const signTx: (typedCall: TypedCall, address_n: number[], tx: BinancePreparedTransaction) => Promise<PROTO.BinanceSignedTx>;
+//# sourceMappingURL=binanceSignTx.d.ts.map

package/lib/api/binance/binanceSignTx.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTx = exports.validate = void 0;
+const constants_1 = require("../../constants");
+const paramsValidator_1 = require("../common/paramsValidator");
+const processTxRequest = async (typedCall, messages, index) => {
+    const { type, ...params } = messages[index];
+    const lastOp = index + 1 >= messages.length;
+    if (lastOp) {
+        const response = await typedCall(type, 'BinanceSignedTx', params);
+        return response.message;
+    }
+    await typedCall(type, 'BinanceTxRequest', params);
+    index++;
+    return processTxRequest(typedCall, messages, index);
+};
+const validate = (tx) => {
+    (0, paramsValidator_1.validateParams)(tx, [
+        { name: 'chain_id', type: 'string', required: true },
+        { name: 'account_number', type: 'number' },
+        { name: 'memo', type: 'string' },
+        { name: 'sequence', type: 'number' },
+        { name: 'source', type: 'number' },
+        { name: 'message', type: 'object' },
+    ]);
+    const preparedTx = {
+        chain_id: tx.chain_id,
+        account_number: tx.account_number || 0,
+        memo: tx.memo,
+        sequence: tx.sequence || 0,
+        source: tx.source || 0,
+        messages: [],
+    };
+    const { transfer, placeOrder, cancelOrder } = tx;
+    if (transfer) {
+        (0, paramsValidator_1.validateParams)(transfer, [
+            { name: 'inputs', type: 'array', required: true },
+            { name: 'outputs', type: 'array', required: true },
+        ]);
+        preparedTx.messages.push({
+            ...transfer,
+            type: 'BinanceTransferMsg',
+        });
+    }
+    if (placeOrder) {
+        (0, paramsValidator_1.validateParams)(placeOrder, [
+            { name: 'id', type: 'string' },
+            { name: 'ordertype', type: 'number' },
+            { name: 'price', type: 'number' },
+            { name: 'quantity', type: 'number' },
+            { name: 'sender', type: 'string' },
+            { name: 'side', type: 'number' },
+        ]);
+        preparedTx.messages.push({
+            ...placeOrder,
+            type: 'BinanceOrderMsg',
+        });
+    }
+    if (cancelOrder) {
+        (0, paramsValidator_1.validateParams)(cancelOrder, [
+            { name: 'refid', type: 'string', required: true },
+            { name: 'sender', type: 'string', required: true },
+            { name: 'symbol', type: 'string', required: true },
+        ]);
+        preparedTx.messages.push({
+            ...cancelOrder,
+            type: 'BinanceCancelMsg',
+        });
+    }
+    if (preparedTx.messages.length < 1) {
+        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Transaction does not have any message');
+    }
+    return preparedTx;
+};
+exports.validate = validate;
+const signTx = async (typedCall, address_n, tx) => {
+    const { account_number, chain_id, memo, sequence, source, messages } = tx;
+    const msg_count = messages.length;
+    await typedCall('BinanceSignTx', 'BinanceTxRequest', {
+        address_n,
+        msg_count,
+        account_number,
+        chain_id,
+        memo,
+        sequence,
+        source,
+    });
+    return processTxRequest(typedCall, messages, 0);
+};
+exports.signTx = signTx;
+//# sourceMappingURL=binanceSignTx.js.map

package/lib/api/binanceGetAddress.d.ts

@@ -0,0 +1,22 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+declare type Params = PROTO.BinanceGetAddress & {
+    address?: string;
+};
+export default class BinanceGetAddress extends AbstractMethod<'binanceGetAddress', Params[]> {
+    hasBundle?: boolean;
+    progress: number;
+    confirmed?: boolean;
+    init(): void;
+    getButtonRequestData(code: string): {
+        type: "address";
+        serializedPath: string;
+        address: string;
+    } | undefined;
+    confirmation(): Promise<boolean>;
+    noBackupConfirmation(): Promise<boolean>;
+    _call({ address_n, show_display }: Params): Promise<PROTO.BinanceAddress>;
+    run(): Promise<import("..").Address | import("..").Address[]>;
+}
+export {};
+//# sourceMappingURL=binanceGetAddress.d.ts.map

package/lib/api/binanceGetAddress.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const coinInfo_1 = require("../data/coinInfo");
+const pathUtils_1 = require("../utils/pathUtils");
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+class BinanceGetAddress extends AbstractMethod_1.AbstractMethod {
+    constructor() {
+        super(...arguments);
+        this.progress = 0;
+    }
+    init() {
+        this.requiredPermissions = ['read'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('BNB'), this.firmwareRange);
+        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);
+            return {
+                address_n: path,
+                address: batch.address,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+            };
+        });
+        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;
+        if (this.params.length === 1) {
+            this.info = `Export Binance address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
+        }
+        else {
+            this.info = 'Export multiple Binance addresses';
+        }
+    }
+    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;
+    }
+    async _call({ address_n, show_display }) {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('BinanceGetAddress', 'BinanceAddress', {
+            address_n,
+            show_display,
+        });
+        return response.message;
+    }
+    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 (batch.address !== silent.address) {
+                        throw constants_1.ERRORS.TypedError('Method_AddressNotMatch');
+                    }
+                }
+                else {
+                    batch.address = silent.address;
+                }
+            }
+            const response = await this._call(batch);
+            responses.push({
+                path: batch.address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
+                address: response.address,
+            });
+            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 = BinanceGetAddress;
+//# sourceMappingURL=binanceGetAddress.js.map

package/lib/api/binanceGetPublicKey.d.ts

@@ -0,0 +1,10 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class BinanceGetPublicKey extends AbstractMethod<'binanceGetPublicKey', PROTO.BinanceGetPublicKey[]> {
+    hasBundle?: boolean;
+    confirmed?: boolean;
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("..").PublicKey | import("..").PublicKey[]>;
+}
+//# sourceMappingURL=binanceGetPublicKey.d.ts.map

package/lib/api/binanceGetPublicKey.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const coinInfo_1 = require("../data/coinInfo");
+const pathUtils_1 = require("../utils/pathUtils");
+const events_1 = require("../events");
+class BinanceGetPublicKey extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('BNB'), this.firmwareRange);
+        this.info = 'Export Binance public key';
+        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);
+            return {
+                address_n: path,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+            };
+        });
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        let label;
+        if (this.params.length > 1) {
+            label = 'Export multiple Binance public keys';
+        }
+        else {
+            label = `Export Binance public key for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
+        }
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'export-address',
+            label,
+        }));
+        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 { message } = await cmd.typedCall('BinanceGetPublicKey', 'BinancePublicKey', batch);
+            responses.push({
+                path: batch.address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
+                publicKey: message.public_key,
+            });
+            if (this.hasBundle) {
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                    progress: i,
+                    response: message,
+                }));
+            }
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = BinanceGetPublicKey;
+//# sourceMappingURL=binanceGetPublicKey.js.map

package/lib/api/binanceSignTransaction.d.ts

@@ -0,0 +1,12 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { BinancePreparedTransaction } from '../types/api/binanceSignTransaction';
+declare type Params = {
+    path: number[];
+    transaction: BinancePreparedTransaction;
+};
+export default class BinanceSignTransaction extends AbstractMethod<'binanceSignTransaction', Params> {
+    init(): void;
+    run(): Promise<import("packages/transport/lib/types/messages").BinanceSignedTx>;
+}
+export {};
+//# sourceMappingURL=binanceSignTransaction.d.ts.map