@trezor/connect 9.0.0-beta.1

package/lib/api/tezos/tezosSignTx.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTx = void 0;
+const tslib_1 = require("tslib");
+const bs58check = (0, tslib_1.__importStar)(require("bs58check"));
+const constants_1 = require("../../constants");
+const paramsValidator_1 = require("../common/paramsValidator");
+const PREFIX = {
+    B: new Uint8Array([1, 52]),
+    tz1: new Uint8Array([6, 161, 159]),
+    tz2: new Uint8Array([6, 161, 161]),
+    tz3: new Uint8Array([6, 161, 164]),
+    KT1: new Uint8Array([2, 90, 121]),
+    edpk: new Uint8Array([13, 15, 37, 217]),
+    sppk: new Uint8Array([3, 254, 226, 86]),
+    p2pk: new Uint8Array([3, 178, 139, 127]),
+};
+const bs58checkDecode = (prefix, enc) => bs58check.decode(enc).slice(prefix.length);
+const concatArray = (first, second) => {
+    const result = new Uint8Array(first.length + second.length);
+    result.set(first);
+    result.set(second, first.length);
+    return result;
+};
+const publicKeyHash2buffer = (publicKeyHash) => {
+    switch (publicKeyHash.substring(0, 3)) {
+        case 'tz1':
+            return {
+                originated: 0,
+                hash: concatArray(new Uint8Array([0]), bs58checkDecode(PREFIX.tz1, publicKeyHash)),
+            };
+        case 'tz2':
+            return {
+                originated: 0,
+                hash: concatArray(new Uint8Array([1]), bs58checkDecode(PREFIX.tz2, publicKeyHash)),
+            };
+        case 'tz3':
+            return {
+                originated: 0,
+                hash: concatArray(new Uint8Array([2]), bs58checkDecode(PREFIX.tz3, publicKeyHash)),
+            };
+        case 'KT1':
+            return {
+                originated: 1,
+                hash: concatArray(bs58checkDecode(PREFIX.KT1, publicKeyHash), new Uint8Array([0])),
+            };
+        default:
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Wrong Tezos publicKeyHash address');
+    }
+};
+const publicKey2buffer = (publicKey) => {
+    switch (publicKey.substring(0, 4)) {
+        case 'edpk':
+            return concatArray(new Uint8Array([0]), bs58checkDecode(PREFIX.edpk, publicKey));
+        case 'sppk':
+            return concatArray(new Uint8Array([1]), bs58checkDecode(PREFIX.sppk, publicKey));
+        case 'p2pk':
+            return concatArray(new Uint8Array([2]), bs58checkDecode(PREFIX.p2pk, publicKey));
+        default:
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Wrong Tezos publicKey');
+    }
+};
+const createTx = (address_n, branch, operation) => {
+    let message = {
+        address_n,
+        branch: bs58checkDecode(PREFIX.B, branch),
+    };
+    if (operation.reveal) {
+        const { reveal } = operation;
+        (0, paramsValidator_1.validateParams)(reveal, [
+            { name: 'source', type: 'string', required: true },
+            { name: 'public_key', type: 'string', required: true },
+            { name: 'fee', type: 'uint', required: true },
+            { name: 'counter', type: 'number', required: true },
+            { name: 'gas_limit', type: 'number', required: true },
+            { name: 'storage_limit', type: 'number', required: true },
+        ]);
+        message = {
+            ...message,
+            reveal: {
+                source: publicKeyHash2buffer(reveal.source).hash,
+                public_key: publicKey2buffer(reveal.public_key),
+                fee: reveal.fee,
+                counter: reveal.counter,
+                gas_limit: reveal.gas_limit,
+                storage_limit: reveal.storage_limit,
+            },
+        };
+    }
+    if (operation.transaction) {
+        const { transaction } = operation;
+        (0, paramsValidator_1.validateParams)(transaction, [
+            { name: 'source', type: 'string', required: true },
+            { name: 'destination', type: 'string', required: true },
+            { name: 'amount', type: 'uint', required: true },
+            { name: 'counter', type: 'number', required: true },
+            { name: 'fee', type: 'uint', required: true },
+            { name: 'gas_limit', type: 'number', required: true },
+            { name: 'storage_limit', type: 'number', required: true },
+        ]);
+        message = {
+            ...message,
+            transaction: {
+                source: publicKeyHash2buffer(transaction.source).hash,
+                destination: {
+                    tag: publicKeyHash2buffer(transaction.destination).originated,
+                    hash: publicKeyHash2buffer(transaction.destination).hash,
+                },
+                amount: transaction.amount,
+                counter: transaction.counter,
+                fee: transaction.fee,
+                gas_limit: transaction.gas_limit,
+                storage_limit: transaction.storage_limit,
+            },
+        };
+        if (Object.prototype.hasOwnProperty.call(transaction, 'parameters')) {
+            message = {
+                ...message,
+                transaction: {
+                    ...message.transaction,
+                    parameters: transaction.parameters,
+                },
+            };
+        }
+        if (transaction.parameters_manager) {
+            const { parameters_manager } = transaction;
+            (0, paramsValidator_1.validateParams)(parameters_manager, [
+                { name: 'set_delegate', type: 'string', required: false },
+                { name: 'cancel_delegate', type: 'boolean', required: false },
+                { name: 'transfer', type: 'object', required: false },
+            ]);
+            if (parameters_manager.set_delegate) {
+                message = {
+                    ...message,
+                    transaction: {
+                        ...message.transaction,
+                        parameters_manager: {
+                            set_delegate: publicKeyHash2buffer(parameters_manager.set_delegate)
+                                .hash,
+                        },
+                    },
+                };
+            }
+            if (Object.prototype.hasOwnProperty.call(parameters_manager, 'cancel_delegate')) {
+                message = {
+                    ...message,
+                    transaction: {
+                        ...message.transaction,
+                        parameters_manager: {
+                            cancel_delegate: true,
+                        },
+                    },
+                };
+            }
+            if (parameters_manager.transfer) {
+                const { transfer } = parameters_manager;
+                (0, paramsValidator_1.validateParams)(transfer, [
+                    { name: 'amount', type: 'uint', required: true },
+                    { name: 'destination', type: 'string', required: true },
+                ]);
+                message = {
+                    ...message,
+                    transaction: {
+                        ...message.transaction,
+                        parameters_manager: {
+                            transfer: {
+                                destination: {
+                                    tag: publicKeyHash2buffer(transfer.destination).originated,
+                                    hash: publicKeyHash2buffer(transfer.destination).hash,
+                                },
+                                amount: transfer.amount,
+                            },
+                        },
+                    },
+                };
+            }
+        }
+    }
+    if (operation.origination) {
+        const { origination } = operation;
+        (0, paramsValidator_1.validateParams)(origination, [
+            { name: 'source', type: 'string', required: true },
+            { name: 'balance', type: 'number', required: true },
+            { name: 'fee', type: 'uint', required: true },
+            { name: 'counter', type: 'number', required: true },
+            { name: 'gas_limit', type: 'number', required: true },
+            { name: 'storage_limit', type: 'number', required: true },
+            { name: 'script', type: 'string', required: true },
+        ]);
+        message = {
+            ...message,
+            origination: {
+                source: publicKeyHash2buffer(origination.source).hash,
+                balance: origination.balance,
+                fee: origination.fee,
+                counter: origination.counter,
+                gas_limit: origination.gas_limit,
+                storage_limit: origination.storage_limit,
+                script: origination.script,
+            },
+        };
+        if (origination.delegate) {
+            message = {
+                ...message,
+                origination: {
+                    ...message.origination,
+                    delegate: publicKeyHash2buffer(origination.delegate).hash,
+                },
+            };
+        }
+    }
+    if (operation.delegation) {
+        const { delegation } = operation;
+        (0, paramsValidator_1.validateParams)(delegation, [
+            { name: 'source', type: 'string', required: true },
+            { name: 'delegate', type: 'string', required: true },
+            { name: 'fee', type: 'uint', required: true },
+            { name: 'counter', type: 'number', required: true },
+            { name: 'gas_limit', type: 'number', required: true },
+            { name: 'storage_limit', type: 'number', required: true },
+        ]);
+        message = {
+            ...message,
+            delegation: {
+                source: publicKeyHash2buffer(delegation.source).hash,
+                delegate: publicKeyHash2buffer(delegation.delegate).hash,
+                fee: delegation.fee,
+                counter: delegation.counter,
+                gas_limit: delegation.gas_limit,
+                storage_limit: delegation.storage_limit,
+            },
+        };
+    }
+    return message;
+};
+exports.createTx = createTx;
+//# sourceMappingURL=tezosSignTx.js.map

package/lib/api/tezosGetAddress.d.ts

@@ -0,0 +1,22 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+declare type Params = PROTO.TezosGetAddress & {
+    address?: string;
+};
+export default class TezosGetAddress extends AbstractMethod<'tezosGetAddress', 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.TezosAddress>;
+    run(): Promise<import("..").Address | import("..").Address[]>;
+}
+export {};
+//# sourceMappingURL=tezosGetAddress.d.ts.map

package/lib/api/tezosGetAddress.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 TezosGetAddress 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)('Tezos'), 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 Tezos address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
+        }
+        else {
+            this.info = 'Export multiple Tezos 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('TezosGetAddress', 'TezosAddress', {
+            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 = TezosGetAddress;
+//# sourceMappingURL=tezosGetAddress.js.map

package/lib/api/tezosGetPublicKey.d.ts

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

package/lib/api/tezosGetPublicKey.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 TezosGetPublicKey extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Tezos'), this.firmwareRange);
+        this.info = 'Export Tezos 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 Tezos public keys';
+        }
+        else {
+            label = `Export Tezos 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('TezosGetPublicKey', 'TezosPublicKey', 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 = TezosGetPublicKey;
+//# sourceMappingURL=tezosGetPublicKey.js.map

package/lib/api/tezosSignTransaction.d.ts

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

package/lib/api/tezosSignTransaction.js

@@ -0,0 +1,30 @@
+"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 coinInfo_1 = require("../data/coinInfo");
+const pathUtils_1 = require("../utils/pathUtils");
+const helper = (0, tslib_1.__importStar)(require("./tezos/tezosSignTx"));
+class TezosSignTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Tezos'), this.firmwareRange);
+        this.info = 'Sign Tezos transaction';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'branch', type: 'string', required: true },
+            { name: 'operation', required: true },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+        this.params = helper.createTx(path, payload.branch, payload.operation);
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('TezosSignTx', 'TezosSignedTx', this.params);
+        return response.message;
+    }
+}
+exports.default = TezosSignTransaction;
+//# sourceMappingURL=tezosSignTransaction.js.map

package/lib/api/verifyMessage.d.ts

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

package/lib/api/verifyMessage.js

@@ -0,0 +1,47 @@
+"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 formatUtils_1 = require("../utils/formatUtils");
+const constants_1 = require("../constants");
+class VerifyMessage extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        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: 'coin', type: 'string', required: true },
+            { name: 'hex', type: 'boolean' },
+        ]);
+        const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        else {
+            this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+            this.info = (0, pathUtils_1.getLabel)('Verify #NETWORK message', coinInfo);
+        }
+        const messageHex = payload.hex
+            ? (0, formatUtils_1.messageToHex)(payload.message)
+            : Buffer.from(payload.message, 'utf8').toString('hex');
+        const signatureHex = Buffer.from(payload.signature, 'base64').toString('hex');
+        this.params = {
+            address: payload.address,
+            signature: signatureHex,
+            message: messageHex,
+            coin_name: coinInfo.name,
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('VerifyMessage', 'Success', this.params);
+        return response.message;
+    }
+}
+exports.default = VerifyMessage;
+//# sourceMappingURL=verifyMessage.js.map

package/lib/api/wipeDevice.d.ts

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

package/lib/api/wipeDevice.js

@@ -0,0 +1,41 @@
+"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 WipeDevice extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS, events_1.UI.BOOTLOADER];
+        this.useDeviceState = false;
+        this.requiredPermissions = ['management'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+        this.info = 'Wipe device';
+    }
+    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: 'device-management',
+            customConfirmButton: {
+                className: 'wipe',
+                label: `Wipe ${this.device.toMessageObject().label}`,
+            },
+            label: 'Are you sure you want to wipe your device?',
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        if (this.device.isBootloader()) {
+            this.device.emit(events_1.DEVICE.BUTTON, this.device, { code: 'ButtonRequest_WipeDevice' });
+        }
+        const response = await cmd.typedCall('WipeDevice', 'Success');
+        return response.message;
+    }
+}
+exports.default = WipeDevice;
+//# sourceMappingURL=wipeDevice.js.map