@shapeshiftoss/hdwallet-keepkey 1.55.3 → 1.55.4

package/dist/keepkey.js

@@ -1,20 +1,61 @@
-import * as Messages from "@keepkey/device-protocol/lib/messages_pb";
-import * as Types from "@keepkey/device-protocol/lib/types_pb";
-import * as core from "@shapeshiftoss/hdwallet-core";
-import _ from "lodash";
-import semver from "semver";
-import * as Binance from "./binance";
-import * as Btc from "./bitcoin";
-import * as Cosmos from "./cosmos";
-import * as Eos from "./eos";
-import * as Eth from "./ethereum";
-import * as Osmosis from "./osmosis";
-import * as Ripple from "./ripple";
-import * as Thorchain from "./thorchain";
-import { messageTypeRegistry } from "./typeRegistry";
-import { protoFieldToSetMethod, translateInputScriptType } from "./utils";
-export function isKeepKey(wallet) {
-    return _.isObject(wallet) && wallet._isKeepKey;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeepKeyHDWallet = exports.KeepKeyHDWalletInfo = void 0;
+exports.isKeepKey = isKeepKey;
+exports.info = info;
+exports.create = create;
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const Types = __importStar(require("@keepkey/device-protocol/lib/types_pb"));
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const lodash_1 = __importDefault(require("lodash"));
+const semver_1 = __importDefault(require("semver"));
+const Binance = __importStar(require("./binance"));
+const Btc = __importStar(require("./bitcoin"));
+const Cosmos = __importStar(require("./cosmos"));
+const Eos = __importStar(require("./eos"));
+const Eth = __importStar(require("./ethereum"));
+const Osmosis = __importStar(require("./osmosis"));
+const Ripple = __importStar(require("./ripple"));
+const Thorchain = __importStar(require("./thorchain"));
+const typeRegistry_1 = require("./typeRegistry");
+const utils_1 = require("./utils");
+function isKeepKey(wallet) {
+    return lodash_1.default.isObject(wallet) && wallet._isKeepKey;
 }
 function describeETHPath(path) {
     const pathStr = core.addressNListToBIP32(path);
@@ -46,6 +87,7 @@ function describeETHPath(path) {
     };
 }
 function describeUTXOPath(path, coin, scriptType) {
+    var _a;
     const pathStr = core.addressNListToBIP32(path);
     const unknown = {
         verbose: pathStr,
@@ -74,11 +116,11 @@ function describeUTXOPath(path, coin, scriptType) {
         return unknown;
     const wholeAccount = path.length === 3;
     const script = scriptType
-        ? {
+        ? (_a = {
             [core.BTCInputScriptType.SpendAddress]: ["Legacy"],
             [core.BTCInputScriptType.SpendP2SHWitness]: [],
             [core.BTCInputScriptType.SpendWitness]: ["Segwit Native"],
-        }[scriptType] ?? []
+        }[scriptType]) !== null && _a !== void 0 ? _a : []
         : [];
     let isPrefork = false;
     const slip44 = core.slip44ByCoin(coin);
@@ -339,26 +381,34 @@ function describeBinancePath(path) {
         isPrefork: false,
     };
 }
-export class KeepKeyHDWalletInfo {
-    _supportsBTCInfo = true;
-    _supportsETHInfo = true;
-    _supportsCosmosInfo = true;
-    _supportsOsmosisInfo = true;
-    _supportsRippleInfo = true;
-    _supportsBinanceInfo = true;
-    _supportsEosInfo = true;
-    _supportsThorchainInfo = true;
+class KeepKeyHDWalletInfo {
+    constructor() {
+        this._supportsBTCInfo = true;
+        this._supportsETHInfo = true;
+        this._supportsCosmosInfo = true;
+        this._supportsOsmosisInfo = true;
+        this._supportsRippleInfo = true;
+        this._supportsBinanceInfo = true;
+        this._supportsEosInfo = true;
+        this._supportsThorchainInfo = true;
+    }
     getVendor() {
         return "KeepKey";
     }
-    async btcSupportsCoin(coin) {
-        return Btc.btcSupportsCoin(coin);
+    btcSupportsCoin(coin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSupportsCoin(coin);
+        });
     }
-    async btcSupportsScriptType(coin, scriptType) {
-        return Btc.btcSupportsScriptType(coin, scriptType);
+    btcSupportsScriptType(coin, scriptType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSupportsScriptType(coin, scriptType);
+        });
     }
-    async btcSupportsSecureTransfer() {
-        return Btc.btcSupportsSecureTransfer();
+    btcSupportsSecureTransfer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSupportsSecureTransfer();
+        });
     }
     btcSupportsNativeShapeShift() {
         return Btc.btcSupportsNativeShapeShift();
@@ -369,18 +419,24 @@ export class KeepKeyHDWalletInfo {
     btcIsSameAccount(msg) {
         return Btc.btcIsSameAccount(msg);
     }
-    async ethSupportsNetwork(chain_id) {
-        return Eth.ethSupportsNetwork(chain_id);
+    ethSupportsNetwork(chain_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethSupportsNetwork(chain_id);
+        });
     }
-    async ethSupportsSecureTransfer() {
-        return Eth.ethSupportsSecureTransfer();
+    ethSupportsSecureTransfer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethSupportsSecureTransfer();
+        });
     }
     ethSupportsNativeShapeShift() {
         return Eth.ethSupportsNativeShapeShift();
     }
-    async ethSupportsEIP1559() {
-        // disable EIP1559 support until edge case fail states are fixed across all evm chains
-        return false;
+    ethSupportsEIP1559() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // disable EIP1559 support until edge case fail states are fixed across all evm chains
+            return false;
+        });
     }
     ethGetAccountPaths(msg) {
         return Eth.ethGetAccountPaths(msg);
@@ -456,10 +512,7 @@ export class KeepKeyHDWalletInfo {
             addressNList[0] === 0x80000000 + 49 ||
             addressNList[0] === 0x80000000 + 84) {
             addressNList[2] += 1;
-            return {
-                ...msg,
-                addressNList,
-            };
+            return Object.assign(Object.assign({}, msg), { addressNList });
         }
         return undefined;
     }
@@ -471,12 +524,7 @@ export class KeepKeyHDWalletInfo {
         }
         if (addressNList[0] === 0x80000000 + 44) {
             addressNList[2] += 1;
-            return {
-                ...msg,
-                addressNList,
-                hardenedPath: core.hardenedPath(addressNList),
-                relPath: core.relativePath(addressNList),
-            };
+            return Object.assign(Object.assign({}, msg), { addressNList, hardenedPath: core.hardenedPath(addressNList), relPath: core.relativePath(addressNList) });
         }
         return undefined;
     }
@@ -487,10 +535,7 @@ export class KeepKeyHDWalletInfo {
         }
         const addressNList = msg.addressNList;
         addressNList[2] += 1;
-        return {
-            ...msg,
-            addressNList,
-        };
+        return Object.assign(Object.assign({}, msg), { addressNList });
     }
     osmosisNextAccountPath(msg) {
         const description = describeOsmosisPath(msg.addressNList);
@@ -499,10 +544,7 @@ export class KeepKeyHDWalletInfo {
         }
         const addressNList = msg.addressNList;
         addressNList[2] += 1;
-        return {
-            ...msg,
-            addressNList,
-        };
+        return Object.assign(Object.assign({}, msg), { addressNList });
     }
     thorchainNextAccountPath(msg) {
         const description = describeThorchainPath(msg.addressNList);
@@ -511,10 +553,7 @@ export class KeepKeyHDWalletInfo {
         }
         const addressNList = msg.addressNList;
         addressNList[2] += 1;
-        return {
-            ...msg,
-            addressNList,
-        };
+        return Object.assign(Object.assign({}, msg), { addressNList });
     }
     rippleNextAccountPath(msg) {
         const description = describeRipplePath(msg.addressNList);
@@ -523,10 +562,7 @@ export class KeepKeyHDWalletInfo {
         }
         const addressNList = msg.addressNList;
         addressNList[2] += 1;
-        return {
-            ...msg,
-            addressNList,
-        };
+        return Object.assign(Object.assign({}, msg), { addressNList });
     }
     binanceNextAccountPath(msg) {
         const description = describeBinancePath(msg.addressNList);
@@ -535,10 +571,7 @@ export class KeepKeyHDWalletInfo {
         }
         const addressNList = msg.addressNList;
         addressNList[2] += 1;
-        return {
-            ...msg,
-            addressNList,
-        };
+        return Object.assign(Object.assign({}, msg), { addressNList });
     }
     eosNextAccountPath(msg) {
         const description = describeEosPath(msg.addressNList);
@@ -547,171 +580,193 @@ export class KeepKeyHDWalletInfo {
         }
         const addressNList = msg.addressNList;
         addressNList[2] += 1;
-        return {
-            ...msg,
-            addressNList,
-        };
+        return Object.assign(Object.assign({}, msg), { addressNList });
     }
 }
-export class KeepKeyHDWallet {
-    _supportsETHInfo = true;
-    _supportsBTCInfo = true;
-    _supportsCosmosInfo = true;
-    _supportsOsmosisInfo = true;
-    _supportsRippleInfo = true;
-    _supportsBinanceInfo = true;
-    _supportsEosInfo = true;
-    _supportsFioInfo = false;
-    _supportsDebugLink;
-    _isKeepKey = true;
-    _supportsETH = true;
-    _supportsEthSwitchChain = false;
-    _supportsAvalanche = false;
-    _supportsOptimism = true;
-    _supportsBSC = true;
-    _supportsPolygon = true;
-    _supportsGnosis = true;
-    _supportsArbitrum = true;
-    _supportsArbitrumNova = false;
-    _supportsBase = true;
-    _supportsBTC = true;
-    _supportsCosmos = true;
-    _supportsOsmosis = true;
-    _supportsRipple = true;
-    _supportsBinance = true;
-    _supportsEos = true;
-    _supportsFio = false;
-    _supportsThorchainInfo = true;
-    _supportsThorchain = true;
-    _supportsSecretInfo = false;
-    _supportsSecret = false;
-    _supportsKava = false;
-    _supportsKavaInfo = false;
-    _supportsTerra = false;
-    _supportsTerraInfo = false;
-    transport;
-    features;
-    info;
-    featuresCache;
+exports.KeepKeyHDWalletInfo = KeepKeyHDWalletInfo;
+class KeepKeyHDWallet {
     constructor(transport) {
+        this._supportsETHInfo = true;
+        this._supportsBTCInfo = true;
+        this._supportsCosmosInfo = true;
+        this._supportsOsmosisInfo = true;
+        this._supportsRippleInfo = true;
+        this._supportsBinanceInfo = true;
+        this._supportsEosInfo = true;
+        this._supportsFioInfo = false;
+        this._isKeepKey = true;
+        this._supportsETH = true;
+        this._supportsEthSwitchChain = false;
+        this._supportsAvalanche = false;
+        this._supportsOptimism = true;
+        this._supportsBSC = true;
+        this._supportsPolygon = true;
+        this._supportsGnosis = true;
+        this._supportsArbitrum = true;
+        this._supportsArbitrumNova = false;
+        this._supportsBase = true;
+        this._supportsBTC = true;
+        this._supportsCosmos = true;
+        this._supportsOsmosis = true;
+        this._supportsRipple = true;
+        this._supportsBinance = true;
+        this._supportsEos = true;
+        this._supportsFio = false;
+        this._supportsThorchainInfo = true;
+        this._supportsThorchain = true;
+        this._supportsSecretInfo = false;
+        this._supportsSecret = false;
+        this._supportsKava = false;
+        this._supportsKavaInfo = false;
+        this._supportsTerra = false;
+        this._supportsTerraInfo = false;
         this.transport = transport;
         this._supportsDebugLink = transport.debugLink;
         this.info = new KeepKeyHDWalletInfo();
     }
-    static async create(transport) {
-        return new KeepKeyHDWallet(transport);
+    static create(transport) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new KeepKeyHDWallet(transport);
+        });
     }
-    async getDeviceID() {
-        const featuresId = (await this.getFeatures(/*cached=*/ true)).deviceId;
-        // Devices in bootloader mode show up with empty string deviceId's in their features object.
-        if (featuresId)
-            return featuresId;
-        // Grabbing the one from the transport seems to be a reasonable fallback.
-        return await this.transport.getDeviceID();
+    getDeviceID() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const featuresId = (yield this.getFeatures(/*cached=*/ true)).deviceId;
+            // Devices in bootloader mode show up with empty string deviceId's in their features object.
+            if (featuresId)
+                return featuresId;
+            // Grabbing the one from the transport seems to be a reasonable fallback.
+            return yield this.transport.getDeviceID();
+        });
     }
     getVendor() {
         return "KeepKey";
     }
-    async getModel() {
-        return core.mustBeDefined((await this.getFeatures(/*cached=*/ true)).model);
+    getModel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return core.mustBeDefined((yield this.getFeatures(/*cached=*/ true)).model);
+        });
     }
-    async getFirmwareVersion() {
-        const features = await this.getFeatures(/*cached=*/ true);
-        return `v${features.majorVersion}.${features.minorVersion}.${features.patchVersion}`;
+    getFirmwareVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const features = yield this.getFeatures(/*cached=*/ true);
+            return `v${features.majorVersion}.${features.minorVersion}.${features.patchVersion}`;
+        });
     }
-    async getLabel() {
-        return (await this.getFeatures(/*cached=*/ true)).label ?? "";
+    getLabel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = (yield this.getFeatures(/*cached=*/ true)).label) !== null && _a !== void 0 ? _a : "";
+        });
     }
-    async isInitialized() {
-        return !!(await this.getFeatures()).initialized;
+    isInitialized() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return !!(yield this.getFeatures()).initialized;
+        });
     }
-    async isLocked() {
-        const features = await this.getFeatures();
-        if (features.pinProtection && !features.pinCached)
-            return true;
-        if (features.passphraseProtection && !features.passphraseCached)
-            return true;
-        return false;
+    isLocked() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const features = yield this.getFeatures();
+            if (features.pinProtection && !features.pinCached)
+                return true;
+            if (features.passphraseProtection && !features.passphraseCached)
+                return true;
+            return false;
+        });
     }
-    async getPublicKeys(getPublicKeys) {
-        const publicKeys = [];
-        for (let i = 0; i < getPublicKeys.length; i++) {
-            const { coin, addressNList, curve, showDisplay, scriptType } = getPublicKeys[i];
-            const GPK = new Messages.GetPublicKey();
-            if (coin)
-                GPK.setCoinName(coin);
-            GPK.setAddressNList(addressNList);
-            GPK.setShowDisplay(showDisplay || false);
-            GPK.setEcdsaCurveName(curve || "secp256k1");
-            GPK.setScriptType(translateInputScriptType(scriptType || core.BTCInputScriptType.SpendAddress));
-            const event = await this.transport.call(Messages.MessageType.MESSAGETYPE_GETPUBLICKEY, GPK, {
-                msgTimeout: showDisplay ? core.LONG_TIMEOUT : core.DEFAULT_TIMEOUT,
+    getPublicKeys(getPublicKeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const publicKeys = [];
+            for (let i = 0; i < getPublicKeys.length; i++) {
+                const { coin, addressNList, curve, showDisplay, scriptType } = getPublicKeys[i];
+                const GPK = new Messages.GetPublicKey();
+                if (coin)
+                    GPK.setCoinName(coin);
+                GPK.setAddressNList(addressNList);
+                GPK.setShowDisplay(showDisplay || false);
+                GPK.setEcdsaCurveName(curve || "secp256k1");
+                GPK.setScriptType((0, utils_1.translateInputScriptType)(scriptType || core.BTCInputScriptType.SpendAddress));
+                const event = yield this.transport.call(Messages.MessageType.MESSAGETYPE_GETPUBLICKEY, GPK, {
+                    msgTimeout: showDisplay ? core.LONG_TIMEOUT : core.DEFAULT_TIMEOUT,
+                });
+                const publicKey = event.proto;
+                publicKeys.push({ xpub: core.mustBeDefined(publicKey.getXpub()) });
+            }
+            return publicKeys;
+        });
+    }
+    ping(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ping = new Messages.Ping();
+            ping.setMessage(msg.msg);
+            ping.setButtonProtection(msg.button || false);
+            ping.setPinProtection(msg.pin || false);
+            ping.setPassphraseProtection(msg.passphrase || false);
+            const event = yield this.transport.call(Messages.MessageType.MESSAGETYPE_PING, ping, {
+                msgTimeout: msg.button || msg.pin || msg.passphrase ? core.LONG_TIMEOUT : core.DEFAULT_TIMEOUT,
             });
-            const publicKey = event.proto;
-            publicKeys.push({ xpub: core.mustBeDefined(publicKey.getXpub()) });
-        }
-        return publicKeys;
-    }
-    async ping(msg) {
-        const ping = new Messages.Ping();
-        ping.setMessage(msg.msg);
-        ping.setButtonProtection(msg.button || false);
-        ping.setPinProtection(msg.pin || false);
-        ping.setPassphraseProtection(msg.passphrase || false);
-        const event = await this.transport.call(Messages.MessageType.MESSAGETYPE_PING, ping, {
-            msgTimeout: msg.button || msg.pin || msg.passphrase ? core.LONG_TIMEOUT : core.DEFAULT_TIMEOUT,
+            const message = event.proto;
+            return { msg: core.mustBeDefined(message.getMessage()) };
         });
-        const message = event.proto;
-        return { msg: core.mustBeDefined(message.getMessage()) };
-    }
-    async reset(msg) {
-        const resetDevice = new Messages.ResetDevice();
-        resetDevice.setStrength(msg.entropy || 128);
-        resetDevice.setDisplayRandom(false);
-        resetDevice.setPassphraseProtection(msg.passphrase || false);
-        resetDevice.setPinProtection(msg.pin || false);
-        resetDevice.setLabel(msg.label);
-        if (msg.autoLockDelayMs) {
-            resetDevice.setAutoLockDelayMs(msg.autoLockDelayMs);
-        }
-        resetDevice.setU2fCounter(msg.u2fCounter || Math.floor(+new Date() / 1000));
-        // resetDevice.setWordsPerGape(wordsPerScreen) // Re-enable when patch gets in
-        // Send
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_RESETDEVICE, resetDevice, {
-            msgTimeout: core.LONG_TIMEOUT,
+    }
+    reset(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resetDevice = new Messages.ResetDevice();
+            resetDevice.setStrength(msg.entropy || 128);
+            resetDevice.setDisplayRandom(false);
+            resetDevice.setPassphraseProtection(msg.passphrase || false);
+            resetDevice.setPinProtection(msg.pin || false);
+            resetDevice.setLabel(msg.label);
+            if (msg.autoLockDelayMs) {
+                resetDevice.setAutoLockDelayMs(msg.autoLockDelayMs);
+            }
+            resetDevice.setU2fCounter(msg.u2fCounter || Math.floor(+new Date() / 1000));
+            // resetDevice.setWordsPerGape(wordsPerScreen) // Re-enable when patch gets in
+            // Send
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_RESETDEVICE, resetDevice, {
+                msgTimeout: core.LONG_TIMEOUT,
+            });
+            this.cacheFeatures(undefined);
         });
-        this.cacheFeatures(undefined);
-    }
-    async recover(r) {
-        const msg = new Messages.RecoveryDevice();
-        msg.setWordCount({ 128: 12, 192: 18, 256: 24 }[r.entropy]);
-        msg.setPassphraseProtection(r.passphrase);
-        msg.setPinProtection(r.pin);
-        msg.setLabel(r.label);
-        msg.setLanguage(r.language || "english");
-        msg.setEnforceWordlist(true);
-        msg.setUseCharacterCipher(true);
-        if (r.autoLockDelayMs) {
-            msg.setAutoLockDelayMs(r.autoLockDelayMs);
-        }
-        msg.setU2fCounter(r.u2fCounter || Math.floor(+new Date() / 1000));
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_RECOVERYDEVICE, msg, {
-            msgTimeout: core.LONG_TIMEOUT,
+    }
+    recover(r) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const msg = new Messages.RecoveryDevice();
+            msg.setWordCount({ 128: 12, 192: 18, 256: 24 }[r.entropy]);
+            msg.setPassphraseProtection(r.passphrase);
+            msg.setPinProtection(r.pin);
+            msg.setLabel(r.label);
+            msg.setLanguage(r.language || "english");
+            msg.setEnforceWordlist(true);
+            msg.setUseCharacterCipher(true);
+            if (r.autoLockDelayMs) {
+                msg.setAutoLockDelayMs(r.autoLockDelayMs);
+            }
+            msg.setU2fCounter(r.u2fCounter || Math.floor(+new Date() / 1000));
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_RECOVERYDEVICE, msg, {
+                msgTimeout: core.LONG_TIMEOUT,
+            });
+            this.cacheFeatures(undefined);
         });
-        this.cacheFeatures(undefined);
     }
-    async pressYes() {
-        return this.press(true);
+    pressYes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.press(true);
+        });
     }
-    async pressNo() {
-        return this.press(false);
+    pressNo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.press(false);
+        });
     }
-    async press(isYes) {
-        const decision = new Messages.DebugLinkDecision();
-        decision.setYesNo(isYes);
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_DEBUGLINKDECISION, decision, {
-            noWait: true,
-            debugLink: true,
+    press(isYes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const decision = new Messages.DebugLinkDecision();
+            decision.setYesNo(isYes);
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_DEBUGLINKDECISION, decision, {
+                noWait: true,
+                debugLink: true,
+            });
         });
     }
     hasOnDevicePinEntry() {
@@ -739,295 +794,363 @@ export class KeepKeyHDWallet {
     supportsBroadcast() {
         return false;
     }
-    async sendPin(pin) {
-        const matrixAck = new Messages.PinMatrixAck();
-        matrixAck.setPin(pin);
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_PINMATRIXACK, matrixAck, {
-            msgTimeout: core.DEFAULT_TIMEOUT,
-            omitLock: true,
-            noWait: true,
+    sendPin(pin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matrixAck = new Messages.PinMatrixAck();
+            matrixAck.setPin(pin);
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_PINMATRIXACK, matrixAck, {
+                msgTimeout: core.DEFAULT_TIMEOUT,
+                omitLock: true,
+                noWait: true,
+            });
         });
     }
-    async sendPassphrase(passphrase) {
-        const passphraseAck = new Messages.PassphraseAck();
-        passphraseAck.setPassphrase(passphrase);
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_PASSPHRASEACK, passphraseAck, {
-            msgTimeout: core.DEFAULT_TIMEOUT,
-            omitLock: true,
-            noWait: true,
+    sendPassphrase(passphrase) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const passphraseAck = new Messages.PassphraseAck();
+            passphraseAck.setPassphrase(passphrase);
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_PASSPHRASEACK, passphraseAck, {
+                msgTimeout: core.DEFAULT_TIMEOUT,
+                omitLock: true,
+                noWait: true,
+            });
         });
     }
-    async sendCharacter(character) {
-        await this.sendCharacterProto(character, false, false);
+    sendCharacter(character) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sendCharacterProto(character, false, false);
+        });
     }
-    async sendCharacterDelete() {
-        await this.sendCharacterProto("", true, false);
+    sendCharacterDelete() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sendCharacterProto("", true, false);
+        });
     }
-    async sendCharacterDone() {
-        await this.sendCharacterProto("", false, true);
+    sendCharacterDone() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sendCharacterProto("", false, true);
+        });
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async sendWord(word) {
-        throw new Error("Not Yet Implemented :(");
+    sendWord(word) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Not Yet Implemented :(");
+        });
     }
-    async sendCharacterProto(character, _delete, _done) {
-        const characterAck = new Messages.CharacterAck();
-        if (character !== "") {
-            characterAck.setCharacter(character);
-        }
-        else if (_delete) {
-            characterAck.setDelete(_delete);
-        }
-        else if (_done) {
-            characterAck.setDone(_done);
-        }
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_CHARACTERACK, characterAck, {
-            msgTimeout: core.DEFAULT_TIMEOUT,
-            omitLock: true,
-            noWait: true,
+    sendCharacterProto(character, _delete, _done) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const characterAck = new Messages.CharacterAck();
+            if (character !== "") {
+                characterAck.setCharacter(character);
+            }
+            else if (_delete) {
+                characterAck.setDelete(_delete);
+            }
+            else if (_done) {
+                characterAck.setDone(_done);
+            }
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_CHARACTERACK, characterAck, {
+                msgTimeout: core.DEFAULT_TIMEOUT,
+                omitLock: true,
+                noWait: true,
+            });
         });
     }
     // ApplyPolicy enables or disables a named policy such as "ShapeShift" on the device
-    async applyPolicy(p) {
-        const policy = new Types.PolicyType();
-        policy.setPolicyName(p.policyName);
-        policy.setEnabled(p.enabled);
-        const applyPolicies = new Messages.ApplyPolicies();
-        applyPolicies.setPolicyList([policy]);
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_APPLYPOLICIES, applyPolicies, {
-            msgTimeout: core.LONG_TIMEOUT,
+    applyPolicy(p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policy = new Types.PolicyType();
+            policy.setPolicyName(p.policyName);
+            policy.setEnabled(p.enabled);
+            const applyPolicies = new Messages.ApplyPolicies();
+            applyPolicies.setPolicyList([policy]);
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_APPLYPOLICIES, applyPolicies, {
+                msgTimeout: core.LONG_TIMEOUT,
+            });
+            this.cacheFeatures(undefined);
         });
-        this.cacheFeatures(undefined);
     }
     // ApplySettings changes the label, language, and enabling/disabling the passphrase
     // The default language is english
-    async applySettings(s) {
-        const applySettings = new Messages.ApplySettings();
-        if (s.label) {
-            applySettings.setLabel(s.label);
-        }
-        if (s.language) {
-            applySettings.setLanguage(s.language);
-        }
-        if (s.usePassphrase !== undefined) {
-            applySettings.setUsePassphrase(s.usePassphrase);
-        }
-        if (s.autoLockDelayMs) {
-            applySettings.setAutoLockDelayMs(s.autoLockDelayMs);
-        }
-        if (s.u2fCounter) {
-            applySettings.setU2fCounter(s.u2fCounter);
-        }
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_APPLYSETTINGS, applySettings);
-        this.cacheFeatures(undefined);
+    applySettings(s) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const applySettings = new Messages.ApplySettings();
+            if (s.label) {
+                applySettings.setLabel(s.label);
+            }
+            if (s.language) {
+                applySettings.setLanguage(s.language);
+            }
+            if (s.usePassphrase !== undefined) {
+                applySettings.setUsePassphrase(s.usePassphrase);
+            }
+            if (s.autoLockDelayMs) {
+                applySettings.setAutoLockDelayMs(s.autoLockDelayMs);
+            }
+            if (s.u2fCounter) {
+                applySettings.setU2fCounter(s.u2fCounter);
+            }
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_APPLYSETTINGS, applySettings);
+            this.cacheFeatures(undefined);
+        });
     }
     // Cancel aborts the last device action that required user interaction
     // It can follow a button request, passphrase request, or pin request
-    async cancel() {
-        await this.transport.cancel();
+    cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transport.cancel();
+        });
     }
     // ChangePin requests setting/changing the pin
-    async changePin() {
-        const changePin = new Messages.ChangePin();
-        // User may be propmpted for button press up to 2 times
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_CHANGEPIN, changePin, {
-            msgTimeout: core.LONG_TIMEOUT,
+    changePin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const changePin = new Messages.ChangePin();
+            // User may be propmpted for button press up to 2 times
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_CHANGEPIN, changePin, {
+                msgTimeout: core.LONG_TIMEOUT,
+            });
         });
     }
     // CipherKeyValue encrypts or decrypts a value with a given key, nodepath, and initializationVector
     // This method encrypts if encrypt is true and decrypts if false, the confirm paramater determines wether
     // the user is prompted on the device. See EncryptKeyValue() and DecryptKeyValue() for convenience methods
     // NOTE: If the length of the value in bytes is not divisible by 16 it will be zero padded
-    async cipherKeyValue(v) {
-        // if(val.length % 16 !== 0) val = val.concat() TODO THIS
-        const cipherKeyValue = new Messages.CipherKeyValue();
-        cipherKeyValue.setAddressNList(v.addressNList);
-        cipherKeyValue.setKey(v.key);
-        cipherKeyValue.setValue(v.value);
-        cipherKeyValue.setEncrypt(!!v.encrypt);
-        cipherKeyValue.setAskOnEncrypt(v.askOnEncrypt || false);
-        cipherKeyValue.setAskOnDecrypt(v.askOnDecrypt || false);
-        cipherKeyValue.setIv(v.iv || "");
-        const response = await this.transport.call(Messages.MessageType.MESSAGETYPE_CIPHERKEYVALUE, cipherKeyValue);
-        const ckv = response.message;
-        return ckv.getValue();
+    cipherKeyValue(v) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // if(val.length % 16 !== 0) val = val.concat() TODO THIS
+            const cipherKeyValue = new Messages.CipherKeyValue();
+            cipherKeyValue.setAddressNList(v.addressNList);
+            cipherKeyValue.setKey(v.key);
+            cipherKeyValue.setValue(v.value);
+            cipherKeyValue.setEncrypt(!!v.encrypt);
+            cipherKeyValue.setAskOnEncrypt(v.askOnEncrypt || false);
+            cipherKeyValue.setAskOnDecrypt(v.askOnDecrypt || false);
+            cipherKeyValue.setIv(v.iv || "");
+            const response = yield this.transport.call(Messages.MessageType.MESSAGETYPE_CIPHERKEYVALUE, cipherKeyValue);
+            const ckv = response.message;
+            return ckv.getValue();
+        });
     }
     // ClearSession clears cached session values such as the pin and passphrase
-    async clearSession() {
-        const clearSession = new Messages.ClearSession();
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_CLEARSESSION, clearSession);
-        this.cacheFeatures(undefined);
+    clearSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clearSession = new Messages.ClearSession();
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_CLEARSESSION, clearSession);
+            this.cacheFeatures(undefined);
+        });
     }
     // DecryptKeyValue is a convenience method around decrypting with CipherKeyValue().
     // For more granular control of the process use CipherKeyValue()
-    async decryptKeyValue(v) {
-        return this.cipherKeyValue(v);
+    decryptKeyValue(v) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cipherKeyValue(v);
+        });
     }
     // FirmwareErase askes the device to erase its firmware
-    async firmwareErase() {
-        const firmwareErase = new Messages.FirmwareErase();
-        // send
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_FIRMWAREERASE, firmwareErase);
-        this.cacheFeatures(undefined);
-    }
-    async firmwareUpload(firmware) {
-        const firmwareUpload = new Messages.FirmwareUpload();
-        const hash = await this.transport.getFirmwareHash(firmware);
-        firmwareUpload.setPayload(firmware);
-        firmwareUpload.setPayloadHash(hash);
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_FIRMWAREUPLOAD, firmwareUpload);
-        this.cacheFeatures(undefined);
+    firmwareErase() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const firmwareErase = new Messages.FirmwareErase();
+            // send
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_FIRMWAREERASE, firmwareErase);
+            this.cacheFeatures(undefined);
+        });
+    }
+    firmwareUpload(firmware) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const firmwareUpload = new Messages.FirmwareUpload();
+            const hash = yield this.transport.getFirmwareHash(firmware);
+            firmwareUpload.setPayload(firmware);
+            firmwareUpload.setPayloadHash(hash);
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_FIRMWAREUPLOAD, firmwareUpload);
+            this.cacheFeatures(undefined);
+        });
     }
     // Initialize assigns a hid connection to this KeepKey and send initialize message to device
-    async initialize() {
-        const initialize = new Messages.Initialize();
-        const event = await this.transport.call(Messages.MessageType.MESSAGETYPE_INITIALIZE, initialize);
-        if (!event.message)
-            throw event;
-        const out = event.message;
-        this.features = out;
-        // v6.1.0 firmware changed usb serial numbers to match STM32 desig_device_id
-        // If the deviceId in the features table doesn't match, then we need to
-        // add another k-v pair to the keyring so it can be looked up either way.
-        const transportDeviceID = await this.transport.getDeviceID();
-        if (out.deviceId && transportDeviceID !== out.deviceId) {
-            this.transport.keyring.addAlias(transportDeviceID, out.deviceId);
-        }
-        const fwVersion = `v${out.majorVersion}.${out.minorVersion}.${out.patchVersion}`;
-        //Lost Support per proto 44.3
-        this._supportsOsmosis = semver.gte(fwVersion, "v7.7.0");
-        this._supportsCosmos = semver.gte(fwVersion, "v7.3.0");
-        this._supportsRipple = semver.gte(fwVersion, "v6.4.0");
-        this._supportsBinance = semver.gte(fwVersion, "v6.4.0");
-        this._supportsEos = semver.gte(fwVersion, "v6.4.0");
-        // this._supportsThorchain = semver.get(fwVersion, "v7.3.0");
-        this.cacheFeatures(out);
-        return out;
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const initialize = new Messages.Initialize();
+            const event = yield this.transport.call(Messages.MessageType.MESSAGETYPE_INITIALIZE, initialize);
+            if (!event.message)
+                throw event;
+            const out = event.message;
+            this.features = out;
+            // v6.1.0 firmware changed usb serial numbers to match STM32 desig_device_id
+            // If the deviceId in the features table doesn't match, then we need to
+            // add another k-v pair to the keyring so it can be looked up either way.
+            const transportDeviceID = yield this.transport.getDeviceID();
+            if (out.deviceId && transportDeviceID !== out.deviceId) {
+                this.transport.keyring.addAlias(transportDeviceID, out.deviceId);
+            }
+            const fwVersion = `v${out.majorVersion}.${out.minorVersion}.${out.patchVersion}`;
+            //Lost Support per proto 44.3
+            this._supportsOsmosis = semver_1.default.gte(fwVersion, "v7.7.0");
+            this._supportsCosmos = semver_1.default.gte(fwVersion, "v7.3.0");
+            this._supportsRipple = semver_1.default.gte(fwVersion, "v6.4.0");
+            this._supportsBinance = semver_1.default.gte(fwVersion, "v6.4.0");
+            this._supportsEos = semver_1.default.gte(fwVersion, "v6.4.0");
+            // this._supportsThorchain = semver.get(fwVersion, "v7.3.0");
+            this.cacheFeatures(out);
+            return out;
+        });
     }
     // GetFeatures returns the features and other device information such as the version, label, and supported coins
-    async getFeatures(cached = false) {
-        if (cached && this.featuresCache)
-            return this.featuresCache;
-        const features = new Messages.GetFeatures();
-        const event = await this.transport.call(Messages.MessageType.MESSAGETYPE_GETFEATURES, features);
-        this.cacheFeatures(event.message);
-        return event.message;
+    getFeatures() {
+        return __awaiter(this, arguments, void 0, function* (cached = false) {
+            if (cached && this.featuresCache)
+                return this.featuresCache;
+            const features = new Messages.GetFeatures();
+            const event = yield this.transport.call(Messages.MessageType.MESSAGETYPE_GETFEATURES, features);
+            this.cacheFeatures(event.message);
+            return event.message;
+        });
     }
     cacheFeatures(features) {
         this.featuresCache = features;
     }
     // GetEntropy requests sample data from the hardware RNG
-    async getEntropy(size) {
-        const getEntropy = new Messages.GetEntropy();
-        getEntropy.setSize(size);
-        // send
-        const event = await this.transport.call(Messages.MessageType.MESSAGETYPE_GETENTROPY, getEntropy, {
-            msgTimeout: core.LONG_TIMEOUT,
+    getEntropy(size) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getEntropy = new Messages.GetEntropy();
+            getEntropy.setSize(size);
+            // send
+            const event = yield this.transport.call(Messages.MessageType.MESSAGETYPE_GETENTROPY, getEntropy, {
+                msgTimeout: core.LONG_TIMEOUT,
+            });
+            return core.mustBeDefined(event.proto).getEntropy_asU8();
         });
-        return core.mustBeDefined(event.proto).getEntropy_asU8();
     }
     // GetNumCoins returns the number of coins supported by the device regardless of if the hanve funds.
-    async getNumCoins() {
-        const getCoinTable = new Messages.GetCoinTable();
-        const response = await this.transport.call(Messages.MessageType.MESSAGETYPE_GETCOINTABLE, getCoinTable);
-        return core.mustBeDefined(core.mustBeDefined(response.proto).getNumCoins());
+    getNumCoins() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getCoinTable = new Messages.GetCoinTable();
+            const response = yield this.transport.call(Messages.MessageType.MESSAGETYPE_GETCOINTABLE, getCoinTable);
+            return core.mustBeDefined(core.mustBeDefined(response.proto).getNumCoins());
+        });
     }
     // GetCoinTable returns an array of Types.CoinTypes, with start and end arguments for paging.
     // You cannot request more than 10 at a time.
-    async getCoinTable(start = 0, end = start + 10) {
-        const getCoinTable = new Messages.GetCoinTable();
-        getCoinTable.setStart(start);
-        getCoinTable.setEnd(end);
-        const response = await this.transport.call(Messages.MessageType.MESSAGETYPE_GETCOINTABLE, getCoinTable);
-        const coinTable = response.message;
-        return coinTable.tableList;
+    getCoinTable() {
+        return __awaiter(this, arguments, void 0, function* (start = 0, end = start + 10) {
+            const getCoinTable = new Messages.GetCoinTable();
+            getCoinTable.setStart(start);
+            getCoinTable.setEnd(end);
+            const response = yield this.transport.call(Messages.MessageType.MESSAGETYPE_GETCOINTABLE, getCoinTable);
+            const coinTable = response.message;
+            return coinTable.tableList;
+        });
     }
     // LoadDevice loads a provided seed onto the device and applies the provided settings
     // including setting a pin/device label, enabling/disabling the passphrase, and whether to
     // check the checksum of the provided mnemonic
-    async loadDevice(msg) {
-        const loadDevice = new Messages.LoadDevice();
-        loadDevice.setMnemonic(msg.mnemonic);
-        loadDevice.setPassphraseProtection(!!msg.passphrase);
-        loadDevice.setSkipChecksum(!!msg.skipChecksum);
-        if (msg.pin)
-            loadDevice.setPin(msg.pin);
-        if (msg.label)
-            loadDevice.setLabel(msg.label);
-        // send
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_LOADDEVICE, loadDevice, {
-            msgTimeout: core.LONG_TIMEOUT,
+    loadDevice(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loadDevice = new Messages.LoadDevice();
+            loadDevice.setMnemonic(msg.mnemonic);
+            loadDevice.setPassphraseProtection(!!msg.passphrase);
+            loadDevice.setSkipChecksum(!!msg.skipChecksum);
+            if (msg.pin)
+                loadDevice.setPin(msg.pin);
+            if (msg.label)
+                loadDevice.setLabel(msg.label);
+            // send
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_LOADDEVICE, loadDevice, {
+                msgTimeout: core.LONG_TIMEOUT,
+            });
+            this.cacheFeatures(undefined);
         });
-        this.cacheFeatures(undefined);
     }
     // RemovePin disables pin protection for the device. If a pin is currently enabled
     // it will prompt the user to enter the current pin
-    async removePin() {
-        const changePin = new Messages.ChangePin();
-        changePin.setRemove(true);
-        // send
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_CHANGEPIN, changePin);
-        this.cacheFeatures(undefined);
-    }
-    async send(events) {
-        for (const event of events) {
-            const MessageType = messageTypeRegistry[core.mustBeDefined(event.message_enum)];
-            const msg = new MessageType();
-            Object.entries(event.message).forEach(([key, value]) => {
-                const setterMethod = protoFieldToSetMethod(key);
-                if (msg[setterMethod]) {
-                    // Assume setter methods are always of the format: strength -> setStrength
-                    // until this exists https://github.com/protocolbuffers/protobuf/issues/1591
-                    msg[setterMethod](value);
-                }
-            });
-            await this.transport.call(core.mustBeDefined(event.message_enum), msg);
-        }
+    removePin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const changePin = new Messages.ChangePin();
+            changePin.setRemove(true);
+            // send
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_CHANGEPIN, changePin);
+            this.cacheFeatures(undefined);
+        });
+    }
+    send(events) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const event of events) {
+                const MessageType = typeRegistry_1.messageTypeRegistry[core.mustBeDefined(event.message_enum)];
+                const msg = new MessageType();
+                Object.entries(event.message).forEach(([key, value]) => {
+                    const setterMethod = (0, utils_1.protoFieldToSetMethod)(key);
+                    if (msg[setterMethod]) {
+                        // Assume setter methods are always of the format: strength -> setStrength
+                        // until this exists https://github.com/protocolbuffers/protobuf/issues/1591
+                        msg[setterMethod](value);
+                    }
+                });
+                yield this.transport.call(core.mustBeDefined(event.message_enum), msg);
+            }
+        });
     }
     // SoftReset power cycles the device. The device only responds to
     // this message while in manufacturer mode
-    async softReset() {
-        const softReset = new Messages.SoftReset();
-        // send
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_SOFTRESET, softReset);
-        this.cacheFeatures(undefined);
+    softReset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const softReset = new Messages.SoftReset();
+            // send
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_SOFTRESET, softReset);
+            this.cacheFeatures(undefined);
+        });
     }
     // WipeDevice wipes all sensitive data and settings
-    async wipe() {
-        const wipeDevice = new Messages.WipeDevice();
-        // send
-        await this.transport.call(Messages.MessageType.MESSAGETYPE_WIPEDEVICE, wipeDevice);
-        this.cacheFeatures(undefined);
+    wipe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wipeDevice = new Messages.WipeDevice();
+            // send
+            yield this.transport.call(Messages.MessageType.MESSAGETYPE_WIPEDEVICE, wipeDevice);
+            this.cacheFeatures(undefined);
+        });
     }
-    async btcSupportsCoin(coin) {
-        return this.info.btcSupportsCoin(coin);
+    btcSupportsCoin(coin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.btcSupportsCoin(coin);
+        });
     }
-    async btcSupportsScriptType(coin, scriptType) {
-        return this.info.btcSupportsScriptType(coin, scriptType);
+    btcSupportsScriptType(coin, scriptType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.btcSupportsScriptType(coin, scriptType);
+        });
     }
-    async btcGetAddress(msg) {
-        return Btc.btcGetAddress(this, this.transport, msg);
+    btcGetAddress(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcGetAddress(this, this.transport, msg);
+        });
     }
-    async btcSignTx(msg) {
-        return Btc.btcSignTx(this, this.transport, msg);
+    btcSignTx(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSignTx(this, this.transport, msg);
+        });
     }
-    async btcSupportsSecureTransfer() {
-        return this.info.btcSupportsSecureTransfer();
+    btcSupportsSecureTransfer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.btcSupportsSecureTransfer();
+        });
     }
     btcSupportsNativeShapeShift() {
         return this.info.btcSupportsNativeShapeShift();
     }
-    async ethSupportsEIP1559() {
-        // EIP1559 support starts in v7.2.1
-        // return semver.gte(await this.getFirmwareVersion(), "v7.2.1");
-        // disable EIP1559 support until edge case fail states are fixed across all evm chains
-        return false;
+    ethSupportsEIP1559() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // EIP1559 support starts in v7.2.1
+            // return semver.gte(await this.getFirmwareVersion(), "v7.2.1");
+            // disable EIP1559 support until edge case fail states are fixed across all evm chains
+            return false;
+        });
     }
-    async btcSignMessage(msg) {
-        return Btc.btcSignMessage(this, this.transport, msg);
+    btcSignMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSignMessage(this, this.transport, msg);
+        });
     }
-    async btcVerifyMessage(msg) {
-        return Btc.btcVerifyMessage(this, this.transport, msg);
+    btcVerifyMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcVerifyMessage(this, this.transport, msg);
+        });
     }
     btcGetAccountPaths(msg) {
         return this.info.btcGetAccountPaths(msg);
@@ -1039,26 +1162,40 @@ export class KeepKeyHDWallet {
         //  return false
         return this.info.btcIsSameAccount(msg);
     }
-    async ethSignTx(msg) {
-        return Eth.ethSignTx(this.transport, msg);
+    ethSignTx(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethSignTx(this.transport, msg);
+        });
     }
-    async ethGetAddress(msg) {
-        return Eth.ethGetAddress(this.transport, msg);
+    ethGetAddress(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethGetAddress(this.transport, msg);
+        });
     }
-    async ethSignMessage(msg) {
-        return Eth.ethSignMessage(this.transport, msg);
+    ethSignMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethSignMessage(this.transport, msg);
+        });
     }
-    async ethSignTypedData(msg) {
-        return Eth.ethSignTypedData(this.transport, msg);
+    ethSignTypedData(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethSignTypedData(this.transport, msg);
+        });
     }
-    async ethVerifyMessage(msg) {
-        return Eth.ethVerifyMessage(this.transport, msg);
+    ethVerifyMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethVerifyMessage(this.transport, msg);
+        });
     }
-    async ethSupportsNetwork(chain_id) {
-        return this.info.ethSupportsNetwork(chain_id);
+    ethSupportsNetwork(chain_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.ethSupportsNetwork(chain_id);
+        });
     }
-    async ethSupportsSecureTransfer() {
-        return this.info.ethSupportsSecureTransfer();
+    ethSupportsSecureTransfer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.ethSupportsSecureTransfer();
+        });
     }
     ethSupportsNativeShapeShift() {
         return this.info.ethSupportsNativeShapeShift();
@@ -1148,10 +1285,11 @@ export class KeepKeyHDWallet {
         return this.info.binanceNextAccountPath(msg);
     }
 }
-export function info() {
+exports.KeepKeyHDWallet = KeepKeyHDWallet;
+function info() {
     return new KeepKeyHDWalletInfo();
 }
-export function create(transport) {
+function create(transport) {
     return new KeepKeyHDWallet(transport);
 }
 //# sourceMappingURL=keepkey.js.map