@trezor/connect 9.0.0-beta.1

package/lib/api/getAddress.js

@@ -0,0 +1,152 @@
+"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 constants_1 = require("../constants");
+const events_1 = require("../events");
+class GetAddress 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: 'coin', type: 'string' },
+                { name: 'address', type: 'string' },
+                { name: 'showOnTrezor', type: 'boolean' },
+                { name: 'multisig', type: 'object' },
+                { name: 'scriptType', type: 'string' },
+            ]);
+            const path = (0, pathUtils_1.validatePath)(batch.path, 1);
+            let coinInfo;
+            if (batch.coin) {
+                coinInfo = (0, coinInfo_1.getBitcoinNetwork)(batch.coin);
+            }
+            if (coinInfo && !batch.crossChain) {
+                (0, paramsValidator_1.validateCoinPath)(path, coinInfo);
+            }
+            else if (!coinInfo) {
+                coinInfo = (0, coinInfo_1.getBitcoinNetwork)(path);
+            }
+            if (!coinInfo) {
+                throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+            }
+            else if (coinInfo) {
+                this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+            }
+            coinInfo = (0, coinInfo_1.fixCoinInfoNetwork)(coinInfo, path);
+            return {
+                address_n: path,
+                address: batch.address,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+                multisig: batch.multisig,
+                script_type: batch.scriptType,
+                coinInfo,
+            };
+        });
+        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 = (0, pathUtils_1.getLabel)('Export #NETWORK address', this.params[0].coinInfo);
+        }
+        else {
+            const requestedNetworks = this.params.map(b => b.coinInfo);
+            const uniqNetworks = (0, coinInfo_1.getUniqueNetworks)(requestedNetworks);
+            if (uniqNetworks.length === 1 && uniqNetworks[0]) {
+                this.info = (0, pathUtils_1.getLabel)('Export multiple #NETWORK addresses', uniqNetworks[0]);
+            }
+            else {
+                this.info = 'Export multiple 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;
+    }
+    _call({ address_n, show_display, multisig, script_type, coinInfo }) {
+        const cmd = this.device.getCommands();
+        return cmd.getAddress({
+            address_n,
+            show_display,
+            multisig,
+            script_type,
+        }, coinInfo);
+    }
+    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(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 = GetAddress;
+//# sourceMappingURL=getAddress.js.map

package/lib/api/getCoinInfo.d.ts

@@ -0,0 +1,11 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    coinInfo: CoinInfo;
+};
+export default class GetCoinInfo extends AbstractMethod<'getCoinInfo', Params> {
+    init(): void;
+    run(): Promise<import("../types").BitcoinNetworkInfo | import("../types").EthereumNetworkInfo | import("../types").MiscNetworkInfo>;
+}
+export {};
+//# sourceMappingURL=getCoinInfo.d.ts.map

package/lib/api/getCoinInfo.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const coinInfo_1 = require("../data/coinInfo");
+class GetCoinInfo extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = [];
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [{ name: 'coin', type: 'string', required: true }]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        this.params = {
+            coinInfo,
+        };
+    }
+    run() {
+        return Promise.resolve(this.params.coinInfo);
+    }
+}
+exports.default = GetCoinInfo;
+//# sourceMappingURL=getCoinInfo.js.map

package/lib/api/getDeviceState.d.ts

@@ -0,0 +1,8 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class GetDeviceState extends AbstractMethod<'getDeviceState'> {
+    init(): void;
+    run(): Promise<{
+        state: string;
+    }>;
+}
+//# sourceMappingURL=getDeviceState.d.ts.map

package/lib/api/getDeviceState.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+class GetDeviceState extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = [];
+    }
+    run() {
+        return Promise.resolve({
+            state: this.device.getExternalState(),
+        });
+    }
+}
+exports.default = GetDeviceState;
+//# sourceMappingURL=getDeviceState.js.map

package/lib/api/getFeatures.d.ts

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

package/lib/api/getFeatures.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const events_1 = require("../events");
+class GetFeatures extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = [];
+        this.useUi = false;
+        this.allowDeviceMode = [...this.allowDeviceMode, events_1.UI.INITIALIZE, events_1.UI.BOOTLOADER];
+        this.useDeviceState = false;
+        this.skipFirmwareCheck = true;
+    }
+    run() {
+        return Promise.resolve(this.device.features);
+    }
+}
+exports.default = GetFeatures;
+//# sourceMappingURL=getFeatures.js.map

package/lib/api/getOwnershipId.d.ts

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

package/lib/api/getOwnershipId.js

@@ -0,0 +1,75 @@
+"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 events_1 = require("../events");
+class GetOwnershipId extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.info = 'Export ownership id';
+        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: 'coin', type: 'string' },
+                { name: 'multisig', type: 'object' },
+                { name: 'scriptType', type: 'string' },
+            ]);
+            const address_n = (0, pathUtils_1.validatePath)(batch.path, 1);
+            const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(batch.coin || address_n);
+            const script_type = batch.scriptType || (0, pathUtils_1.getScriptType)(address_n);
+            this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+            return {
+                address_n,
+                coin_name: coinInfo ? coinInfo.name : undefined,
+                multisig: batch.multisig,
+                script_type,
+            };
+        });
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION, this.device);
+        let label = this.info;
+        if (this.params.length > 1) {
+            label = 'Export multiple ownership proof ids';
+        }
+        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('GetOwnershipId', 'OwnershipId', batch);
+            responses.push({
+                ...message,
+                path: batch.address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
+            });
+            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 = GetOwnershipId;
+//# sourceMappingURL=getOwnershipId.js.map

package/lib/api/getOwnershipProof.d.ts

@@ -0,0 +1,14 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+interface Params extends PROTO.GetOwnershipProof {
+    preauthorized?: boolean;
+}
+export default class GetOwnershipProof extends AbstractMethod<'getOwnershipProof', Params[]> {
+    hasBundle?: boolean;
+    confirmed?: boolean;
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("../types/api/getOwnershipProof").OwnershipProof | import("../types/api/getOwnershipProof").OwnershipProof[]>;
+}
+export {};
+//# sourceMappingURL=getOwnershipProof.d.ts.map

package/lib/api/getOwnershipProof.js

@@ -0,0 +1,86 @@
+"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 events_1 = require("../events");
+class GetOwnershipProof extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.info = 'Export ownership proof';
+        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: 'coin', type: 'string' },
+                { name: 'multisig', type: 'object' },
+                { name: 'scriptType', type: 'string' },
+                { name: 'userConfirmation', type: 'boolean' },
+                { name: 'ownershipIds', type: 'array' },
+                { name: 'commitmentData', type: 'string' },
+                { name: 'preauthorized', type: 'boolean' },
+            ]);
+            const address_n = (0, pathUtils_1.validatePath)(batch.path, 1);
+            const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(batch.coin || address_n);
+            const script_type = batch.scriptType || (0, pathUtils_1.getScriptType)(address_n);
+            this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+            return {
+                address_n,
+                coin_name: coinInfo ? coinInfo.name : undefined,
+                multisig: batch.multisig,
+                script_type,
+                user_confirmation: batch.userConfirmation,
+                ownership_ids: batch.ownershipIds,
+                commitment_data: batch.commitmentData,
+                preauthorized: batch.preauthorized,
+            };
+        });
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION, this.device);
+        let label = this.info;
+        if (this.params.length > 1) {
+            label = 'Export multiple ownership proofs';
+        }
+        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];
+            if (batch.preauthorized) {
+                await cmd.typedCall('DoPreauthorized', 'PreauthorizedRequest', {});
+            }
+            const { message } = await cmd.typedCall('GetOwnershipProof', 'OwnershipProof', batch);
+            responses.push({
+                ...message,
+                path: batch.address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
+            });
+            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 = GetOwnershipProof;
+//# sourceMappingURL=getOwnershipProof.js.map

package/lib/api/getPublicKey.d.ts

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

package/lib/api/getPublicKey.js

@@ -0,0 +1,84 @@
+"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 events_1 = require("../events");
+const coinInfo_1 = require("../data/coinInfo");
+const accountUtils_1 = require("../utils/accountUtils");
+class GetPublicKey extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.info = 'Export 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: 'coin', type: 'string' },
+                { name: 'crossChain', type: 'boolean' },
+                { name: 'showOnTrezor', type: 'boolean' },
+            ]);
+            let coinInfo;
+            if (batch.coin) {
+                coinInfo = (0, coinInfo_1.getBitcoinNetwork)(batch.coin);
+            }
+            const path = (0, pathUtils_1.validatePath)(batch.path, coinInfo ? 3 : 0);
+            if (coinInfo && !batch.crossChain) {
+                (0, paramsValidator_1.validateCoinPath)(path, coinInfo);
+            }
+            else if (!coinInfo) {
+                coinInfo = (0, coinInfo_1.getBitcoinNetwork)(path);
+            }
+            if (coinInfo) {
+                this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+            }
+            return {
+                address_n: path,
+                coinInfo,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
+            };
+        });
+    }
+    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 public keys';
+        }
+        else {
+            label = (0, accountUtils_1.getPublicKeyLabel)(this.params[0].address_n, this.params[0].coinInfo);
+        }
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'export-xpub',
+            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 response = await cmd.getHDNode(batch.address_n, batch.coinInfo, true, 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 = GetPublicKey;
+//# sourceMappingURL=getPublicKey.js.map

package/lib/api/getSettings.d.ts

@@ -0,0 +1,6 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class GetSettings extends AbstractMethod<'getSettings'> {
+    init(): void;
+    run(): Promise<import("..").ConnectSettings>;
+}
+//# sourceMappingURL=getSettings.d.ts.map

package/lib/api/getSettings.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const DataManager_1 = require("../data/DataManager");
+class GetSettings extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = [];
+        this.useDevice = false;
+        this.useUi = false;
+    }
+    run() {
+        return Promise.resolve(DataManager_1.DataManager.getSettings());
+    }
+}
+exports.default = GetSettings;
+//# sourceMappingURL=getSettings.js.map

package/lib/api/index.d.ts

@@ -0,0 +1,64 @@
+export { default as applyFlags } from './applyFlags';
+export { default as applySettings } from './applySettings';
+export { default as authorizeCoinJoin } from './authorizeCoinJoin';
+export { default as backupDevice } from './backupDevice';
+export { default as binanceGetAddress } from './binanceGetAddress';
+export { default as binanceGetPublicKey } from './binanceGetPublicKey';
+export { default as binanceSignTransaction } from './binanceSignTransaction';
+export { default as blockchainDisconnect } from './blockchainDisconnect';
+export { default as blockchainEstimateFee } from './blockchainEstimateFee';
+export { default as blockchainGetAccountBalanceHistory } from './blockchainGetAccountBalanceHistory';
+export { default as blockchainGetCurrentFiatRates } from './blockchainGetCurrentFiatRates';
+export { default as blockchainGetFiatRatesForTimestamps } from './blockchainGetFiatRatesForTimestamps';
+export { default as blockchainGetTransactions } from './blockchainGetTransactions';
+export { default as blockchainSetCustomBackend } from './blockchainSetCustomBackend';
+export { default as blockchainSubscribe } from './blockchainSubscribe';
+export { default as blockchainSubscribeFiatRates } from './blockchainSubscribeFiatRates';
+export { default as blockchainUnsubscribe } from './blockchainUnsubscribe';
+export { default as blockchainUnsubscribeFiatRates } from './blockchainUnsubscribeFiatRates';
+export { default as cardanoGetAddress } from './cardanoGetAddress';
+export { default as cardanoGetNativeScriptHash } from './cardanoGetNativeScriptHash';
+export { default as cardanoGetPublicKey } from './cardanoGetPublicKey';
+export { default as cardanoSignTransaction } from './cardanoSignTransaction';
+export { default as changePin } from './changePin';
+export { default as cipherKeyValue } from './cipherKeyValue';
+export { default as composeTransaction } from './composeTransaction';
+export { default as customMessage } from './customMessage';
+export { default as eosGetPublicKey } from './eosGetPublicKey';
+export { default as eosSignTransaction } from './eosSignTransaction';
+export { default as ethereumGetAddress } from './ethereumGetAddress';
+export { default as ethereumGetPublicKey } from './ethereumGetPublicKey';
+export { default as ethereumSignMessage } from './ethereumSignMessage';
+export { default as ethereumSignTransaction } from './ethereumSignTransaction';
+export { default as ethereumSignTypedData } from './ethereumSignTypedData';
+export { default as ethereumVerifyMessage } from './ethereumVerifyMessage';
+export { default as firmwareUpdate } from './firmwareUpdate';
+export { default as getAccountInfo } from './getAccountInfo';
+export { default as getAddress } from './getAddress';
+export { default as getCoinInfo } from './getCoinInfo';
+export { default as getDeviceState } from './getDeviceState';
+export { default as getFeatures } from './getFeatures';
+export { default as getOwnershipId } from './getOwnershipId';
+export { default as getOwnershipProof } from './getOwnershipProof';
+export { default as getPublicKey } from './getPublicKey';
+export { default as getSettings } from './getSettings';
+export { default as nemGetAddress } from './nemGetAddress';
+export { default as nemSignTransaction } from './nemSignTransaction';
+export { default as pushTransaction } from './pushTransaction';
+export { default as rebootToBootloader } from './rebootToBootloader';
+export { default as recoveryDevice } from './recoveryDevice';
+export { default as requestLogin } from './requestLogin';
+export { default as resetDevice } from './resetDevice';
+export { default as rippleGetAddress } from './rippleGetAddress';
+export { default as rippleSignTransaction } from './rippleSignTransaction';
+export { default as setProxy } from './setProxy';
+export { default as signMessage } from './signMessage';
+export { default as signTransaction } from './signTransaction';
+export { default as stellarGetAddress } from './stellarGetAddress';
+export { default as stellarSignTransaction } from './stellarSignTransaction';
+export { default as tezosGetAddress } from './tezosGetAddress';
+export { default as tezosGetPublicKey } from './tezosGetPublicKey';
+export { default as tezosSignTransaction } from './tezosSignTransaction';
+export { default as verifyMessage } from './verifyMessage';
+export { default as wipeDevice } from './wipeDevice';
+//# sourceMappingURL=index.d.ts.map