@shapeshiftoss/hdwallet-keepkey 1.62.41 → 1.62.42

package/dist/cjs/ethereum.js

@@ -0,0 +1,264 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ethVerifyMessage = exports.ethSignTypedData = exports.ethSignMessage = exports.ethGetAddress = exports.ethSignTx = exports.ethGetAccountPaths = exports.ethSupportsNativeShapeShift = exports.ethSupportsSecureTransfer = exports.ethSupportsNetwork = void 0;
+const common_1 = require("@ethereumjs/common");
+const tx_1 = require("@ethereumjs/tx");
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const Ethereum = __importStar(require("@keepkey/device-protocol/lib/messages-ethereum_pb"));
+const Types = __importStar(require("@keepkey/device-protocol/lib/types_pb"));
+const eth_sig_util_1 = require("@metamask/eth-sig-util");
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const eip55 = __importStar(require("eip55"));
+const utils_js_1 = require("ethers/lib/utils.js");
+const utils_1 = require("./utils");
+async function ethSupportsNetwork(_chainId) {
+    return true;
+}
+exports.ethSupportsNetwork = ethSupportsNetwork;
+async function ethSupportsSecureTransfer() {
+    return true;
+}
+exports.ethSupportsSecureTransfer = ethSupportsSecureTransfer;
+function ethSupportsNativeShapeShift() {
+    return true;
+}
+exports.ethSupportsNativeShapeShift = ethSupportsNativeShapeShift;
+function ethGetAccountPaths(msg) {
+    const slip44 = core.slip44ByCoin(msg.coin);
+    if (slip44 === undefined)
+        return [];
+    return [
+        {
+            addressNList: [0x80000000 + 44, 0x80000000 + slip44, 0x80000000 + msg.accountIdx, 0, 0],
+            hardenedPath: [0x80000000 + 44, 0x80000000 + slip44, 0x80000000 + msg.accountIdx],
+            relPath: [0, 0],
+            description: 'KeepKey',
+        },
+    ];
+}
+exports.ethGetAccountPaths = ethGetAccountPaths;
+function stripLeadingZeroes(buf) {
+    const firstZeroIndex = buf.findIndex(x => x !== 0);
+    return buf.slice(firstZeroIndex !== -1 ? firstZeroIndex : buf.length);
+}
+async function ethSignTx(transport, msg) {
+    return transport.lockDuring(async () => {
+        const est = new Ethereum.EthereumSignTx();
+        est.setAddressNList(msg.addressNList);
+        est.setNonce(stripLeadingZeroes(core.arrayify(msg.nonce)));
+        est.setGasLimit(core.arrayify(msg.gasLimit));
+        if (msg.gasPrice) {
+            est.setGasPrice(core.arrayify(msg.gasPrice));
+        }
+        if (msg.maxFeePerGas) {
+            est.setMaxFeePerGas(core.arrayify(msg.maxFeePerGas));
+            est.setType(core.ETHTransactionType.ETH_TX_TYPE_EIP_1559);
+            if (msg.maxPriorityFeePerGas) {
+                est.setMaxPriorityFeePerGas(core.arrayify(msg.maxPriorityFeePerGas));
+            }
+        }
+        if (msg.value.match('^0x0*$') === null) {
+            est.setValue(core.arrayify(msg.value));
+        }
+        if (msg.toAddressNList) {
+            est.setAddressType(Types.OutputAddressType.SPEND);
+            est.setToAddressNList(msg.toAddressNList);
+        }
+        else {
+            est.setAddressType(Types.OutputAddressType.SPEND);
+        }
+        if (msg.to) {
+            est.setTo(core.arrayify(msg.to));
+        }
+        let dataChunk = null;
+        let dataRemaining = undefined;
+        if (msg.data) {
+            dataRemaining = core.arrayify(msg.data);
+            est.setDataLength(dataRemaining.length);
+            dataChunk = dataRemaining.slice(0, 1024);
+            dataRemaining = dataRemaining.slice(dataChunk.length);
+            est.setDataInitialChunk(dataChunk);
+        }
+        if (msg.chainId !== undefined) {
+            est.setChainId(msg.chainId);
+        }
+        let response;
+        let nextResponse = await transport.call(Messages.MessageType.MESSAGETYPE_ETHEREUMSIGNTX, est, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        response = nextResponse.proto;
+        try {
+            const esa = new Ethereum.EthereumTxAck();
+            while (response.hasDataLength()) {
+                const dataLength = response.getDataLength();
+                dataRemaining = core.mustBeDefined(dataRemaining);
+                dataChunk = dataRemaining.slice(0, dataLength);
+                dataRemaining = dataRemaining.slice(dataLength, dataRemaining.length);
+                esa.setDataChunk(dataChunk);
+                nextResponse = await transport.call(Messages.MessageType.MESSAGETYPE_ETHEREUMTXACK, esa, {
+                    msgTimeout: core.LONG_TIMEOUT,
+                    omitLock: true,
+                });
+                response = nextResponse.proto;
+            }
+        }
+        catch (error) {
+            console.error({ error });
+            throw new Error('Failed to sign ETH transaction');
+        }
+        const utxBase = {
+            to: msg.to,
+            value: msg.value,
+            data: msg.data,
+            chainId: msg.chainId,
+            nonce: msg.nonce,
+            gasLimit: msg.gasLimit,
+            maxFeePerGas: msg.maxFeePerGas,
+            maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
+        };
+        const r = '0x' + core.toHexString(response.getSignatureR_asU8());
+        const s = '0x' + core.toHexString(response.getSignatureS_asU8());
+        if (!response.hasSignatureV())
+            throw new Error('could not get v');
+        const v = core.mustBeDefined(response.getSignatureV());
+        const v2 = '0x' + v.toString(16);
+        const common = common_1.Common.custom({ chainId: msg.chainId });
+        const tx = msg.maxFeePerGas
+            ? tx_1.FeeMarketEIP1559Transaction.fromTxData({
+                ...utxBase,
+                maxFeePerGas: msg.maxFeePerGas,
+                maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
+                r,
+                s,
+                v: v2,
+            })
+            : tx_1.Transaction.fromTxData({ ...utxBase, gasPrice: msg.gasPrice, r, s, v: v2 }, { common });
+        return {
+            r,
+            s,
+            v,
+            serialized: '0x' + core.toHexString(tx.serialize()),
+        };
+    });
+}
+exports.ethSignTx = ethSignTx;
+async function ethGetAddress(transport, msg) {
+    const getAddr = new Ethereum.EthereumGetAddress();
+    getAddr.setAddressNList(msg.addressNList);
+    getAddr.setShowDisplay(msg.showDisplay !== false);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_ETHEREUMGETADDRESS, getAddr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const ethAddress = response.proto;
+    let address;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    if (ethAddress.hasAddressStr())
+        address = ethAddress.getAddressStr();
+    else if (ethAddress.hasAddress())
+        address = '0x' + core.toHexString(ethAddress.getAddress_asU8());
+    else
+        throw new Error('Unable to obtain ETH address from device.');
+    return address;
+}
+exports.ethGetAddress = ethGetAddress;
+async function ethSignMessage(transport, msg) {
+    const { addressNList, message } = msg;
+    if (!(0, utils_js_1.isHexString)(message))
+        throw new Error('data is not an hex string');
+    const m = new Ethereum.EthereumSignMessage();
+    m.setAddressNList(addressNList);
+    const messageBytes = (0, utils_js_1.arrayify)(message);
+    m.setMessage(messageBytes);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_ETHEREUMSIGNMESSAGE, m, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const sig = response.proto;
+    return {
+        address: eip55.encode('0x' + core.toHexString(sig.getAddress_asU8())),
+        signature: '0x' + core.toHexString(sig.getSignature_asU8()),
+    };
+}
+exports.ethSignMessage = ethSignMessage;
+/**
+ * Supports EIP-712 eth_signTypedData_v4
+ * https://docs.metamask.io/wallet/how-to/sign-data/#use-eth_signtypeddata_v4
+ * Due to lack of firmware support, a hashed version of the data is
+ * displayed to the user on the device when signing
+ */
+async function ethSignTypedData(transport, msg) {
+    try {
+        const version = eth_sig_util_1.SignTypedDataVersion.V4;
+        const EIP_712_DOMAIN = 'EIP712Domain';
+        const { types, primaryType, domain, message } = msg.typedData;
+        const domainSeparatorHash = eth_sig_util_1.TypedDataUtils.hashStruct(EIP_712_DOMAIN, domain, types, version);
+        const ethereumSignTypedHash = new Ethereum.EthereumSignTypedHash();
+        ethereumSignTypedHash.setAddressNList(msg.addressNList);
+        ethereumSignTypedHash.setDomainSeparatorHash(domainSeparatorHash);
+        let messageHash = undefined;
+        // If "EIP712Domain" is the primaryType, messageHash is not required - look at T1 connect impl ;)
+        // todo: the firmware should define messageHash as an optional Uint8Array field for this case
+        if (primaryType !== EIP_712_DOMAIN) {
+            messageHash = eth_sig_util_1.TypedDataUtils.hashStruct(primaryType, message, types, version);
+            ethereumSignTypedHash.setMessageHash(messageHash);
+        }
+        const response = await transport.call(Messages.MessageType.MESSAGETYPE_ETHEREUMSIGNTYPEDHASH, ethereumSignTypedHash, {
+            msgTimeout: core.LONG_TIMEOUT,
+        });
+        const result = response.proto;
+        const res = {
+            address: result.getAddress() || '',
+            signature: '0x' + core.toHexString(result.getSignature_asU8()),
+        };
+        return res;
+    }
+    catch (error) {
+        console.error({ error });
+        throw new Error('Failed to sign typed ETH message');
+    }
+}
+exports.ethSignTypedData = ethSignTypedData;
+async function ethVerifyMessage(transport, msg) {
+    const m = new Ethereum.EthereumVerifyMessage();
+    m.setAddress(core.arrayify(msg.address));
+    m.setSignature(core.arrayify(msg.signature));
+    m.setMessage((0, utils_js_1.isBytes)(msg.message) ? (0, utils_js_1.arrayify)(msg.message) : (0, utils_1.toUTF8Array)(msg.message));
+    let event;
+    try {
+        event = await transport.call(Messages.MessageType.MESSAGETYPE_ETHEREUMVERIFYMESSAGE, m, {
+            msgTimeout: core.LONG_TIMEOUT,
+        });
+    }
+    catch (e) {
+        if (core.isIndexable(e) && e.message_enum === Messages.MessageType.MESSAGETYPE_FAILURE) {
+            return false;
+        }
+        throw e;
+    }
+    const success = event.proto;
+    return success.getMessage() === 'Message verified';
+}
+exports.ethVerifyMessage = ethVerifyMessage;

package/dist/cjs/index.d.ts

@@ -0,0 +1,5 @@
+export * from './adapter';
+export * from './keepkey';
+export * from './transport';
+export * from './typeRegistry';
+export * from './utils';

package/dist/{index.js → cjs/index.js}

@@ -19,4 +19,3 @@ __exportStar(require("./keepkey"), exports);
 __exportStar(require("./transport"), exports);
 __exportStar(require("./typeRegistry"), exports);
 __exportStar(require("./utils"), exports);
-//# sourceMappingURL=index.js.map

package/dist/{keepkey.d.ts → cjs/keepkey.d.ts}

@@ -1,8 +1,10 @@
-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 { Address } from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
+/// <reference types="node" />
+/// <reference types="node" />
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as Types from '@keepkey/device-protocol/lib/types_pb';
+import type { Address } from '@shapeshiftoss/hdwallet-core';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
 export declare function isKeepKey(wallet: core.HDWallet): wallet is KeepKeyHDWallet;
 export declare class KeepKeyHDWalletInfo implements core.HDWalletInfo, core.BTCWalletInfo, core.ETHWalletInfo, core.CosmosWalletInfo, core.OsmosisWalletInfo, core.BinanceWalletInfo, core.RippleWalletInfo, core.EosWalletInfo, core.ThorchainWalletInfo, core.MayachainWalletInfo {
     readonly _supportsBTCInfo = true;
@@ -19,24 +21,24 @@ export declare class KeepKeyHDWalletInfo implements core.HDWalletInfo, core.BTCW
     btcSupportsScriptType(coin: core.Coin, scriptType: core.BTCInputScriptType): Promise<boolean>;
     btcSupportsSecureTransfer(): Promise<boolean>;
     btcSupportsNativeShapeShift(): boolean;
-    btcGetAccountPaths(msg: core.BTCGetAccountPaths): Array<core.BTCAccountPath>;
+    btcGetAccountPaths(msg: core.BTCGetAccountPaths): core.BTCAccountPath[];
     ethSupportsNetwork(chain_id: number): Promise<boolean>;
     ethSupportsSecureTransfer(): Promise<boolean>;
     ethSupportsNativeShapeShift(): boolean;
     ethSupportsEIP1559(): Promise<boolean>;
-    ethGetAccountPaths(msg: core.ETHGetAccountPath): Array<core.ETHAccountPath>;
-    cosmosGetAccountPaths(msg: core.CosmosGetAccountPaths): Array<core.CosmosAccountPath>;
-    osmosisGetAccountPaths(msg: core.OsmosisGetAccountPaths): Array<core.OsmosisAccountPath>;
-    thorchainGetAccountPaths(msg: core.ThorchainGetAccountPaths): Array<core.ThorchainAccountPath>;
-    mayachainGetAccountPaths(msg: core.MayachainGetAccountPaths): Array<core.MayachainAccountPath>;
-    rippleGetAccountPaths(msg: core.RippleGetAccountPaths): Array<core.RippleAccountPath>;
-    binanceGetAccountPaths(msg: core.BinanceGetAccountPaths): Array<core.BinanceAccountPath>;
-    eosGetAccountPaths(msg: core.EosGetAccountPaths): Array<core.EosAccountPath>;
+    ethGetAccountPaths(msg: core.ETHGetAccountPath): core.ETHAccountPath[];
+    cosmosGetAccountPaths(msg: core.CosmosGetAccountPaths): core.CosmosAccountPath[];
+    osmosisGetAccountPaths(msg: core.OsmosisGetAccountPaths): core.OsmosisAccountPath[];
+    thorchainGetAccountPaths(msg: core.ThorchainGetAccountPaths): core.ThorchainAccountPath[];
+    mayachainGetAccountPaths(msg: core.MayachainGetAccountPaths): core.MayachainAccountPath[];
+    rippleGetAccountPaths(msg: core.RippleGetAccountPaths): core.RippleAccountPath[];
+    binanceGetAccountPaths(msg: core.BinanceGetAccountPaths): core.BinanceAccountPath[];
+    eosGetAccountPaths(msg: core.EosGetAccountPaths): core.EosAccountPath[];
     hasOnDevicePinEntry(): boolean;
     hasOnDevicePassphrase(): boolean;
     hasOnDeviceDisplay(): boolean;
     hasOnDeviceRecovery(): boolean;
-    hasNativeShapeShift(srcCoin: core.Coin, dstCoin: core.Coin): boolean;
+    hasNativeShapeShift(_srcCoin: core.Coin, _dstCoin: core.Coin): boolean;
     supportsBip44Accounts(): boolean;
     supportsOfflineSigning(): boolean;
     supportsBroadcast(): boolean;
@@ -66,8 +68,32 @@ export declare class KeepKeyHDWallet extends KeepKeyHDWalletInfo implements core
     readonly _supportsBase = true;
     readonly _supportsMonad = false;
     readonly _supportsPlasma = false;
+    readonly _supportsPlume = false;
     readonly _supportsKatana = false;
+    readonly _supportsEthereal = false;
+    readonly _supportsStory = false;
+    readonly _supportsSonic = false;
+    readonly _supportsBob = false;
+    readonly _supportsMode = false;
+    readonly _supportsSei = false;
     readonly _supportsHyperEvm = false;
+    readonly _supportsMantle = false;
+    readonly _supportsInk = false;
+    readonly _supportsMegaEth = false;
+    readonly _supportsZkSyncEra = false;
+    readonly _supportsBlast = false;
+    readonly _supportsAbstract = false;
+    readonly _supportsWorldChain = false;
+    readonly _supportsHemi = false;
+    readonly _supportsFlowEvm = false;
+    readonly _supportsCelo = false;
+    readonly _supportsBerachain = false;
+    readonly _supportsLinea = false;
+    readonly _supportsScroll = false;
+    readonly _supportsCronos = false;
+    readonly _supportsUnichain = false;
+    readonly _supportsSoneium = false;
+    readonly _supportsRobinhood = false;
     readonly _supportsBTC = true;
     _supportsCosmos: boolean;
     _supportsOsmosis: boolean;
@@ -88,7 +114,7 @@ export declare class KeepKeyHDWallet extends KeepKeyHDWalletInfo implements core
     getLabel(): Promise<string>;
     isInitialized(): Promise<boolean>;
     isLocked(): Promise<boolean>;
-    getPublicKeys(getPublicKeys: Array<core.GetPublicKey>): Promise<Array<core.PublicKey | null>>;
+    getPublicKeys(getPublicKeys: core.GetPublicKey[]): Promise<(core.PublicKey | null)[]>;
     ping(msg: core.Ping): Promise<core.Pong>;
     reset(msg: core.ResetDevice): Promise<void>;
     recover(r: core.RecoverDevice): Promise<void>;
@@ -100,15 +126,15 @@ export declare class KeepKeyHDWallet extends KeepKeyHDWalletInfo implements core
     sendCharacter(character: string): Promise<void>;
     sendCharacterDelete(): Promise<void>;
     sendCharacterDone(): Promise<void>;
-    sendWord(word: string): Promise<void>;
+    sendWord(_word: string): Promise<void>;
     sendCharacterProto(character: string, _delete: boolean, _done: boolean): Promise<any>;
     applyPolicy(p: Required<Types.PolicyType.AsObject>): Promise<void>;
     applySettings(s: Messages.ApplySettings.AsObject): Promise<void>;
     cancel(): Promise<void>;
     changePin(): Promise<void>;
-    cipherKeyValue(v: Messages.CipherKeyValue.AsObject & Required<Pick<Messages.CipherKeyValue.AsObject, "key">>): Promise<string | Uint8Array>;
+    cipherKeyValue(v: Messages.CipherKeyValue.AsObject & Required<Pick<Messages.CipherKeyValue.AsObject, 'key'>>): Promise<string | Uint8Array>;
     clearSession(): Promise<void>;
-    decryptKeyValue(v: Messages.CipherKeyValue.AsObject & Required<Pick<Messages.CipherKeyValue.AsObject, "key">>): Promise<string | Uint8Array>;
+    decryptKeyValue(v: Messages.CipherKeyValue.AsObject & Required<Pick<Messages.CipherKeyValue.AsObject, 'key'>>): Promise<string | Uint8Array>;
     firmwareErase(): Promise<void>;
     firmwareUpload(firmware: Buffer): Promise<void>;
     initialize(): Promise<Messages.Features.AsObject>;
@@ -149,4 +175,3 @@ export declare class KeepKeyHDWallet extends KeepKeyHDWalletInfo implements core
 }
 export declare function info(): KeepKeyHDWalletInfo;
 export declare function create(transport: Transport): KeepKeyHDWallet;
-//# sourceMappingURL=keepkey.d.ts.map