@shapeshiftoss/hdwallet-keepkey 1.62.41 → 1.62.42

package/dist/esm/keepkey.js

@@ -0,0 +1,925 @@
+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 isObject from 'lodash/isObject';
+import semver from 'semver';
+import * as Binance from './binance.js';
+import * as Btc from './bitcoin.js';
+import * as Cosmos from './cosmos.js';
+import * as Eos from './eos.js';
+import * as Eth from './ethereum.js';
+import * as Mayachain from './mayachain.js';
+import * as Osmosis from './osmosis.js';
+import * as Ripple from './ripple.js';
+import * as Thorchain from './thorchain.js';
+import { messageTypeRegistry } from './typeRegistry.js';
+import { protoFieldToSetMethod, translateInputScriptType } from './utils.js';
+export function isKeepKey(wallet) {
+    return isObject(wallet) && wallet._isKeepKey;
+}
+function describeUTXOPath(path, coin, scriptType) {
+    const pathStr = core.addressNListToBIP32(path);
+    const unknown = {
+        verbose: pathStr,
+        coin,
+        scriptType,
+        isKnown: false,
+    };
+    if (!scriptType)
+        return unknown;
+    if (!Btc.btcSupportsCoin(coin))
+        return unknown;
+    if (!Btc.btcSupportsScriptType(coin, scriptType))
+        return unknown;
+    if (path.length !== 3 && path.length !== 5)
+        return unknown;
+    if ((path[0] & 0x80000000) >>> 0 !== 0x80000000)
+        return unknown;
+    const purpose = path[0] & 0x7fffffff;
+    if (![44, 49, 84].includes(purpose))
+        return unknown;
+    if (purpose === 44 && scriptType !== core.BTCInputScriptType.SpendAddress)
+        return unknown;
+    if (purpose === 49 && scriptType !== core.BTCInputScriptType.SpendP2SHWitness)
+        return unknown;
+    if (purpose === 84 && scriptType !== core.BTCInputScriptType.SpendWitness)
+        return unknown;
+    const wholeAccount = path.length === 3;
+    const script = scriptType
+        ? {
+            [core.BTCInputScriptType.SpendAddress]: ['Legacy'],
+            [core.BTCInputScriptType.SpendP2SHWitness]: [],
+            [core.BTCInputScriptType.SpendWitness]: ['Segwit Native'],
+        }[scriptType] ?? []
+        : [];
+    let isPrefork = false;
+    const slip44 = core.slip44ByCoin(coin);
+    if (slip44 === undefined)
+        return unknown;
+    if (path[1] !== 0x80000000 + slip44) {
+        switch (coin) {
+            case 'BitcoinCash':
+            case 'BitcoinGold': {
+                if (path[1] === 0x80000000 + core.slip44ByCoin('Bitcoin')) {
+                    isPrefork = true;
+                    break;
+                }
+                return unknown;
+            }
+            case 'BitcoinSV': {
+                if (path[1] === 0x80000000 + core.slip44ByCoin('Bitcoin') ||
+                    path[1] === 0x80000000 + core.slip44ByCoin('BitcoinCash')) {
+                    isPrefork = true;
+                    break;
+                }
+                return unknown;
+            }
+            default:
+                return unknown;
+        }
+    }
+    let attributes = isPrefork ? ['Prefork'] : [];
+    switch (coin) {
+        case 'Bitcoin':
+        case 'Litecoin':
+        case 'BitcoinGold':
+        case 'Testnet': {
+            attributes = attributes.concat(script);
+            break;
+        }
+        default:
+            break;
+    }
+    const attr = attributes.length ? ` (${attributes.join(', ')})` : '';
+    const accountIdx = path[2] & 0x7fffffff;
+    if (wholeAccount) {
+        return {
+            coin,
+            verbose: `${coin} Account #${accountIdx}${attr}`,
+            accountIdx,
+            wholeAccount: true,
+            isKnown: true,
+            scriptType,
+            isPrefork,
+        };
+    }
+    else {
+        const change = path[3] === 1 ? 'Change ' : '';
+        const addressIdx = path[4];
+        return {
+            coin,
+            verbose: `${coin} Account #${accountIdx}, ${change}Address #${addressIdx}${attr}`,
+            accountIdx,
+            addressIdx,
+            wholeAccount: false,
+            isKnown: true,
+            isChange: path[3] === 1,
+            scriptType,
+            isPrefork,
+        };
+    }
+}
+function describeEosPath(path) {
+    const pathStr = core.addressNListToBIP32(path);
+    const unknown = {
+        verbose: pathStr,
+        coin: 'Eos',
+        isKnown: false,
+    };
+    if (path.length != 5) {
+        return unknown;
+    }
+    if (path[0] != 0x80000000 + 44) {
+        return unknown;
+    }
+    if (path[1] != 0x80000000 + core.slip44ByCoin('Eos')) {
+        return unknown;
+    }
+    if ((path[2] & 0x80000000) >>> 0 !== 0x80000000) {
+        return unknown;
+    }
+    if (path[3] !== 0 || path[4] !== 0) {
+        return unknown;
+    }
+    const index = path[2] & 0x7fffffff;
+    return {
+        verbose: `Eos Account #${index}`,
+        accountIdx: index,
+        wholeAccount: true,
+        coin: 'Eos',
+        isKnown: true,
+        isPrefork: false,
+    };
+}
+function describeRipplePath(path) {
+    const pathStr = core.addressNListToBIP32(path);
+    const unknown = {
+        verbose: pathStr,
+        coin: 'Ripple',
+        isKnown: false,
+    };
+    if (path.length != 5) {
+        return unknown;
+    }
+    if (path[0] != 0x80000000 + 44) {
+        return unknown;
+    }
+    if (path[1] != 0x80000000 + core.slip44ByCoin('Ripple')) {
+        return unknown;
+    }
+    if ((path[2] & 0x80000000) >>> 0 !== 0x80000000) {
+        return unknown;
+    }
+    if (path[3] !== 0 || path[4] !== 0) {
+        return unknown;
+    }
+    const index = path[2] & 0x7fffffff;
+    return {
+        verbose: `Ripple Account #${index}`,
+        accountIdx: index,
+        wholeAccount: true,
+        coin: 'Ripple',
+        isKnown: true,
+        isPrefork: false,
+    };
+}
+export class KeepKeyHDWalletInfo {
+    _supportsBTCInfo = true;
+    _supportsETHInfo = true;
+    _supportsCosmosInfo = true;
+    _supportsOsmosisInfo = true;
+    _supportsRippleInfo = true;
+    _supportsBinanceInfo = true;
+    _supportsEosInfo = true;
+    _supportsThorchainInfo = true;
+    _supportsMayachainInfo = true;
+    getVendor() {
+        return 'KeepKey';
+    }
+    async btcSupportsCoin(coin) {
+        return Btc.btcSupportsCoin(coin);
+    }
+    async btcSupportsScriptType(coin, scriptType) {
+        return Btc.btcSupportsScriptType(coin, scriptType);
+    }
+    async btcSupportsSecureTransfer() {
+        return Btc.btcSupportsSecureTransfer();
+    }
+    btcSupportsNativeShapeShift() {
+        return Btc.btcSupportsNativeShapeShift();
+    }
+    btcGetAccountPaths(msg) {
+        return Btc.btcGetAccountPaths(msg);
+    }
+    async ethSupportsNetwork(chain_id) {
+        return Eth.ethSupportsNetwork(chain_id);
+    }
+    async ethSupportsSecureTransfer() {
+        return Eth.ethSupportsSecureTransfer();
+    }
+    ethSupportsNativeShapeShift() {
+        return Eth.ethSupportsNativeShapeShift();
+    }
+    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;
+    }
+    ethGetAccountPaths(msg) {
+        return Eth.ethGetAccountPaths(msg);
+    }
+    cosmosGetAccountPaths(msg) {
+        return Cosmos.cosmosGetAccountPaths(msg);
+    }
+    osmosisGetAccountPaths(msg) {
+        return Osmosis.osmosisGetAccountPaths(msg);
+    }
+    thorchainGetAccountPaths(msg) {
+        return Thorchain.thorchainGetAccountPaths(msg);
+    }
+    mayachainGetAccountPaths(msg) {
+        return Mayachain.mayachainGetAccountPaths(msg);
+    }
+    rippleGetAccountPaths(msg) {
+        return Ripple.rippleGetAccountPaths(msg);
+    }
+    binanceGetAccountPaths(msg) {
+        return Binance.binanceGetAccountPaths(msg);
+    }
+    eosGetAccountPaths(msg) {
+        return Eos.eosGetAccountPaths(msg);
+    }
+    hasOnDevicePinEntry() {
+        return false;
+    }
+    hasOnDevicePassphrase() {
+        return false;
+    }
+    hasOnDeviceDisplay() {
+        return true;
+    }
+    hasOnDeviceRecovery() {
+        return false;
+    }
+    hasNativeShapeShift(_srcCoin, _dstCoin) {
+        return true;
+    }
+    supportsBip44Accounts() {
+        return true;
+    }
+    supportsOfflineSigning() {
+        return true;
+    }
+    supportsBroadcast() {
+        return false;
+    }
+    describePath(msg) {
+        switch (msg.coin) {
+            case 'Ethereum':
+                return core.describeETHPath(msg.path);
+            case 'Atom':
+                return core.cosmosDescribePath(msg.path);
+            case 'Osmo':
+                return core.osmosisDescribePath(msg.path);
+            case 'Binance':
+                return core.binanceDescribePath(msg.path);
+            case 'Ripple':
+                return describeRipplePath(msg.path);
+            case 'Eos':
+                return describeEosPath(msg.path);
+            case 'Thorchain':
+                return core.thorchainDescribePath(msg.path);
+            case 'Mayachain':
+                return core.mayachainDescribePath(msg.path);
+            default:
+                return describeUTXOPath(msg.path, msg.coin, msg.scriptType);
+        }
+    }
+    btcNextAccountPath(msg) {
+        const description = describeUTXOPath(msg.addressNList, msg.coin, msg.scriptType);
+        if (!description.isKnown) {
+            return undefined;
+        }
+        const addressNList = msg.addressNList;
+        if (addressNList[0] === 0x80000000 + 44 ||
+            addressNList[0] === 0x80000000 + 49 ||
+            addressNList[0] === 0x80000000 + 84) {
+            addressNList[2] += 1;
+            return {
+                ...msg,
+                addressNList,
+            };
+        }
+        return undefined;
+    }
+    ethNextAccountPath(msg) {
+        const addressNList = msg.hardenedPath.concat(msg.relPath);
+        const description = core.describeETHPath(addressNList);
+        if (!description.isKnown) {
+            return undefined;
+        }
+        if (addressNList[0] === 0x80000000 + 44) {
+            addressNList[2] += 1;
+            return {
+                ...msg,
+                addressNList,
+                hardenedPath: core.hardenedPath(addressNList),
+                relPath: core.relativePath(addressNList),
+            };
+        }
+        return undefined;
+    }
+    cosmosNextAccountPath(msg) {
+        const description = core.cosmosDescribePath(msg.addressNList);
+        if (!description.isKnown) {
+            return undefined;
+        }
+        const addressNList = msg.addressNList;
+        addressNList[2] += 1;
+        return {
+            ...msg,
+            addressNList,
+        };
+    }
+    osmosisNextAccountPath(msg) {
+        const description = core.osmosisDescribePath(msg.addressNList);
+        if (!description.isKnown) {
+            return undefined;
+        }
+        const addressNList = msg.addressNList;
+        addressNList[2] += 1;
+        return {
+            ...msg,
+            addressNList,
+        };
+    }
+    thorchainNextAccountPath(msg) {
+        const description = core.thorchainDescribePath(msg.addressNList);
+        if (!description.isKnown)
+            return undefined;
+        const addressNList = msg.addressNList;
+        addressNList[2] += 1;
+        return {
+            ...msg,
+            addressNList,
+        };
+    }
+    mayachainNextAccountPath(msg) {
+        const description = core.mayachainDescribePath(msg.addressNList);
+        if (!description.isKnown)
+            return undefined;
+        const addressNList = msg.addressNList;
+        addressNList[2] += 1;
+        return {
+            ...msg,
+            addressNList,
+        };
+    }
+    rippleNextAccountPath(msg) {
+        const description = describeRipplePath(msg.addressNList);
+        if (!description.isKnown) {
+            return undefined;
+        }
+        const addressNList = msg.addressNList;
+        addressNList[2] += 1;
+        return {
+            ...msg,
+            addressNList,
+        };
+    }
+    binanceNextAccountPath(msg) {
+        const description = core.binanceDescribePath(msg.addressNList);
+        if (!description.isKnown) {
+            return undefined;
+        }
+        const addressNList = msg.addressNList;
+        addressNList[2] += 1;
+        return {
+            ...msg,
+            addressNList,
+        };
+    }
+    eosNextAccountPath(msg) {
+        const description = describeEosPath(msg.addressNList);
+        if (!description.isKnown) {
+            return undefined;
+        }
+        const addressNList = msg.addressNList;
+        addressNList[2] += 1;
+        return {
+            ...msg,
+            addressNList,
+        };
+    }
+}
+export class KeepKeyHDWallet extends KeepKeyHDWalletInfo {
+    _supportsDebugLink;
+    _isKeepKey = true;
+    _supportsETH = true;
+    _supportsEthSwitchChain = false;
+    _supportsAvalanche = false;
+    _supportsOptimism = true;
+    _supportsBSC = true;
+    _supportsPolygon = true;
+    _supportsGnosis = true;
+    _supportsArbitrum = true;
+    _supportsArbitrumNova = false;
+    _supportsBase = true;
+    _supportsMonad = false;
+    _supportsPlasma = false;
+    _supportsPlume = false;
+    _supportsKatana = false;
+    _supportsEthereal = false;
+    _supportsStory = false;
+    _supportsSonic = false;
+    _supportsBob = false;
+    _supportsMode = false;
+    _supportsSei = false;
+    _supportsHyperEvm = false;
+    _supportsMantle = false;
+    _supportsInk = false;
+    _supportsMegaEth = false;
+    _supportsZkSyncEra = false;
+    _supportsBlast = false;
+    _supportsAbstract = false;
+    _supportsWorldChain = false;
+    _supportsHemi = false;
+    _supportsFlowEvm = false;
+    _supportsCelo = false;
+    _supportsBerachain = false;
+    _supportsLinea = false;
+    _supportsScroll = false;
+    _supportsCronos = false;
+    _supportsUnichain = false;
+    _supportsSoneium = false;
+    _supportsRobinhood = false;
+    _supportsBTC = true;
+    _supportsCosmos = true;
+    _supportsOsmosis = true;
+    _supportsRipple = true;
+    _supportsBinance = true;
+    _supportsEos = true;
+    _supportsThorchain = true;
+    _supportsMayachain = true;
+    transport;
+    features;
+    info;
+    featuresCache;
+    constructor(transport) {
+        super();
+        this.transport = transport;
+        this._supportsDebugLink = transport.debugLink;
+        this.info = new KeepKeyHDWalletInfo();
+    }
+    static async create(transport) {
+        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();
+    }
+    async getModel() {
+        return core.mustBeDefined((await this.getFeatures(/*cached=*/ true)).model);
+    }
+    async getFirmwareVersion() {
+        const features = await this.getFeatures(/*cached=*/ true);
+        return `v${features.majorVersion}.${features.minorVersion}.${features.patchVersion}`;
+    }
+    async getLabel() {
+        return (await this.getFeatures(/*cached=*/ true)).label ?? '';
+    }
+    async isInitialized() {
+        return !!(await 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;
+    }
+    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,
+            });
+            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()) };
+    }
+    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,
+        });
+        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,
+        });
+        this.cacheFeatures(undefined);
+    }
+    async pressYes() {
+        return this.press(true);
+    }
+    async pressNo() {
+        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,
+        });
+    }
+    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,
+        });
+    }
+    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,
+        });
+    }
+    async sendCharacter(character) {
+        await this.sendCharacterProto(character, false, false);
+    }
+    async sendCharacterDelete() {
+        await this.sendCharacterProto('', true, false);
+    }
+    async sendCharacterDone() {
+        await this.sendCharacterProto('', false, true);
+    }
+    async sendWord(_word) {
+        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,
+        });
+    }
+    // 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,
+        });
+        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);
+    }
+    // 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();
+    }
+    // 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,
+        });
+    }
+    // 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();
+    }
+    // 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);
+    }
+    // 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);
+    }
+    // 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);
+    }
+    // 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;
+    }
+    // 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;
+    }
+    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,
+        });
+        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());
+    }
+    // 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;
+    }
+    // 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,
+        });
+        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);
+        }
+    }
+    // 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);
+    }
+    // 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);
+    }
+    async btcGetAddress(msg) {
+        return Btc.btcGetAddress(this, this.transport, msg);
+    }
+    async btcSignTx(msg) {
+        return Btc.btcSignTx(this, this.transport, msg);
+    }
+    async btcSignMessage(msg) {
+        return Btc.btcSignMessage(this, this.transport, msg);
+    }
+    async btcVerifyMessage(msg) {
+        return Btc.btcVerifyMessage(this, this.transport, msg);
+    }
+    async ethSignTx(msg) {
+        return Eth.ethSignTx(this.transport, msg);
+    }
+    async ethGetAddress(msg) {
+        return Eth.ethGetAddress(this.transport, msg);
+    }
+    async ethSignMessage(msg) {
+        return Eth.ethSignMessage(this.transport, msg);
+    }
+    async ethSignTypedData(msg) {
+        return Eth.ethSignTypedData(this.transport, msg);
+    }
+    async ethVerifyMessage(msg) {
+        return Eth.ethVerifyMessage(this.transport, msg);
+    }
+    rippleGetAddress(msg) {
+        return Ripple.rippleGetAddress(this.transport, msg);
+    }
+    rippleSignTx(msg) {
+        return Ripple.rippleSignTx(this.transport, msg);
+    }
+    cosmosGetAddress(msg) {
+        return Cosmos.cosmosGetAddress(this.transport, msg);
+    }
+    cosmosSignTx(msg) {
+        return Cosmos.cosmosSignTx(this.transport, msg);
+    }
+    osmosisGetAddress(msg) {
+        return Osmosis.osmosisGetAddress(this.transport, msg);
+    }
+    osmosisSignTx(msg) {
+        return Osmosis.osmosisSignTx(this.transport, msg);
+    }
+    thorchainGetAddress(msg) {
+        return Thorchain.thorchainGetAddress(this.transport, msg);
+    }
+    thorchainSignTx(msg) {
+        return Thorchain.thorchainSignTx(this.transport, msg);
+    }
+    mayachainGetAddress(msg) {
+        return Mayachain.mayachainGetAddress(this.transport, msg);
+    }
+    mayachainSignTx(msg) {
+        return Mayachain.mayachainSignTx(this.transport, msg);
+    }
+    binanceGetAddress(msg) {
+        return Binance.binanceGetAddress(this.transport, msg);
+    }
+    binanceSignTx(msg) {
+        return Binance.binanceSignTx(this.transport, msg);
+    }
+    eosGetPublicKey(msg) {
+        return Eos.eosGetPublicKey(this.transport, msg);
+    }
+    eosSignTx(msg) {
+        return Eos.eosSignTx(this.transport, msg);
+    }
+    disconnect() {
+        return this.transport.disconnect();
+    }
+}
+export function info() {
+    return new KeepKeyHDWalletInfo();
+}
+export function create(transport) {
+    return new KeepKeyHDWallet(transport);
+}