@shapeshiftoss/hdwallet-keepkey 1.62.41 → 1.62.42

package/dist/esm/cosmos.js

@@ -0,0 +1,187 @@
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as CosmosMessages from '@keepkey/device-protocol/lib/messages-cosmos_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import bs58check from 'bs58check';
+import PLazy from 'p-lazy';
+const protoTxBuilder = PLazy.from(() => import('@shapeshiftoss/proto-tx-builder'));
+export function cosmosGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Atom'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+export async function cosmosGetAddress(transport, msg) {
+    const getAddr = new CosmosMessages.CosmosGetAddress();
+    getAddr.setAddressNList(msg.addressNList);
+    getAddr.setShowDisplay(msg.showDisplay !== false);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_COSMOSGETADDRESS, getAddr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const cosmosAddress = response.proto;
+    return core.mustBeDefined(cosmosAddress.getAddress());
+}
+export async function cosmosSignTx(transport, msg) {
+    const address = await cosmosGetAddress(transport, { addressNList: msg.addressNList });
+    const getPublicKeyMsg = new Messages.GetPublicKey();
+    getPublicKeyMsg.setAddressNList(msg.addressNList);
+    getPublicKeyMsg.setEcdsaCurveName('secp256k1');
+    const pubkeyMsg = (await transport.call(Messages.MessageType.MESSAGETYPE_GETPUBLICKEY, getPublicKeyMsg, {
+        msgTimeout: core.DEFAULT_TIMEOUT,
+    })).proto;
+    const pubkey = bs58check.decode(core.mustBeDefined(pubkeyMsg.getXpub())).slice(45);
+    return transport.lockDuring(async () => {
+        const signTx = new CosmosMessages.CosmosSignTx();
+        signTx.setAddressNList(msg.addressNList);
+        signTx.setAccountNumber(msg.account_number);
+        signTx.setChainId(msg.chain_id);
+        signTx.setFeeAmount(parseInt(msg.tx.fee.amount[0].amount));
+        signTx.setGas(parseInt(msg.tx.fee.gas));
+        signTx.setSequence(msg.sequence);
+        if (msg.tx.memo !== undefined) {
+            signTx.setMemo(msg.tx.memo);
+        }
+        signTx.setMsgCount(1);
+        let resp = await transport.call(Messages.MessageType.MESSAGETYPE_COSMOSSIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        for (const m of msg.tx.msg) {
+            if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_COSMOSMSGREQUEST) {
+                throw new Error(`cosmos: unexpected response ${resp.message_type}`);
+            }
+            let ack;
+            if (m.type === 'cosmos-sdk/MsgSend') {
+                if (m.value.amount.length !== 1) {
+                    throw new Error('cosmos: Multiple amounts per msg not supported');
+                }
+                const denom = m.value.amount[0].denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const send = new CosmosMessages.CosmosMsgSend();
+                send.setFromAddress(m.value.from_address);
+                send.setToAddress(m.value.to_address);
+                send.setAmount(m.value.amount[0].amount);
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setSend(send);
+            }
+            else if (m.type === 'cosmos-sdk/MsgDelegate') {
+                const denom = m.value.amount.denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const delegate = new CosmosMessages.CosmosMsgDelegate();
+                delegate.setDelegatorAddress(m.value.delegator_address);
+                delegate.setValidatorAddress(m.value.validator_address);
+                delegate.setAmount(m.value.amount.amount);
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setDelegate(delegate);
+            }
+            else if (m.type === 'cosmos-sdk/MsgUndelegate') {
+                const denom = m.value.amount.denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const undelegate = new CosmosMessages.CosmosMsgUndelegate();
+                undelegate.setDelegatorAddress(m.value.delegator_address);
+                undelegate.setValidatorAddress(m.value.validator_address);
+                undelegate.setAmount(m.value.amount.amount);
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setUndelegate(undelegate);
+            }
+            else if (m.type === 'cosmos-sdk/MsgBeginRedelegate') {
+                const denom = m.value.amount.denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const redelegate = new CosmosMessages.CosmosMsgRedelegate();
+                redelegate.setDelegatorAddress(m.value.delegator_address);
+                redelegate.setValidatorSrcAddress(m.value.validator_src_address);
+                redelegate.setValidatorDstAddress(m.value.validator_dst_address);
+                redelegate.setAmount(m.value.amount.amount);
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setRedelegate(redelegate);
+            }
+            else if (m.type === 'cosmos-sdk/MsgWithdrawDelegationReward') {
+                const rewards = new CosmosMessages.CosmosMsgRewards();
+                rewards.setDelegatorAddress(m.value.delegator_address);
+                rewards.setValidatorAddress(m.value.validator_address);
+                if (m.value.amount) {
+                    const denom = m.value.amount.denom;
+                    if (denom !== 'uatom') {
+                        throw new Error('cosmos: Unsupported denomination: ' + denom);
+                    }
+                    rewards.setAmount(m.value.amount.amount);
+                }
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setRewards(rewards);
+            }
+            else if (m.type === 'cosmos-sdk/MsgTransfer') {
+                const denom = m.value.token.denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const ibcTransfer = new CosmosMessages.CosmosMsgIBCTransfer();
+                ibcTransfer.setReceiver(m.value.receiver);
+                ibcTransfer.setSender(m.value.sender);
+                ibcTransfer.setSourceChannel(m.value.source_channel);
+                ibcTransfer.setSourcePort(m.value.source_port);
+                ibcTransfer.setRevisionHeight(m.value.timeout_height.revision_height);
+                ibcTransfer.setRevisionNumber(m.value.timeout_height.revision_number);
+                ibcTransfer.setAmount(m.value.token.amount);
+                ibcTransfer.setDenom(m.value.token.denom);
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setIbcTransfer(ibcTransfer);
+            }
+            else {
+                throw new Error(`cosmos: Message ${m.type} is not yet supported`);
+            }
+            resp = await transport.call(Messages.MessageType.MESSAGETYPE_COSMOSMSGACK, ack, {
+                msgTimeout: core.LONG_TIMEOUT,
+                omitLock: true,
+            });
+        }
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_COSMOSSIGNEDTX) {
+            throw new Error(`cosmos: unexpected response ${resp.message_type}`);
+        }
+        const signedTx = resp.proto;
+        const offlineSigner = {
+            async getAccounts() {
+                return [
+                    {
+                        address,
+                        algo: 'secp256k1',
+                        pubkey,
+                    },
+                ];
+            },
+            async signAmino(signerAddress, signDoc) {
+                if (signerAddress !== address)
+                    throw new Error('expected signerAddress to match address');
+                return {
+                    signed: signDoc,
+                    signature: {
+                        pub_key: {
+                            type: 'tendermint/PubKeySecp256k1',
+                            value: signedTx.getPublicKey_asB64(),
+                        },
+                        signature: signedTx.getSignature_asB64(),
+                    },
+                };
+            },
+        };
+        const signerData = {
+            sequence: Number(msg.sequence),
+            accountNumber: Number(msg.account_number),
+            chainId: msg.chain_id,
+        };
+        return (await protoTxBuilder).sign(address, msg.tx, offlineSigner, signerData, 'cosmos');
+    });
+}

package/dist/esm/eos.d.ts

@@ -0,0 +1,5 @@
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport.js';
+export declare function eosGetAccountPaths(msg: core.EosGetAccountPaths): core.EosAccountPath[];
+export declare function eosGetPublicKey(transport: Transport, msg: core.EosGetPublicKey): Promise<string>;
+export declare function eosSignTx(transport: Transport, msg: core.EosToSignTx): Promise<core.EosTxSigned>;

package/dist/esm/eos.js

@@ -0,0 +1,212 @@
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as EosMessages from '@keepkey/device-protocol/lib/messages-eos_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import bs58 from 'bs58';
+import createHash from 'create-hash';
+import Long from 'long';
+function eosSigFormatter(r, s, _v) {
+    const recoverId = 0x1f;
+    let signature = 'SIG_K1_';
+    console.debug('formatter logs');
+    const keyBuffer = Buffer.alloc(65);
+    const rbuf = Buffer.from(r);
+    const sbuf = Buffer.from(s);
+    keyBuffer.writeUInt8(recoverId, 0);
+    rbuf.copy(keyBuffer, 1);
+    sbuf.copy(keyBuffer, 33);
+    console.debug(keyBuffer);
+    const check = [keyBuffer];
+    const keyType = 'K1'; // we only sign using K1 curve
+    check.push(Buffer.from(keyType));
+    console.debug(check);
+    console.debug('hash');
+    console.debug(createHash('ripemd160').update(core.compatibleBufferConcat(check)).digest());
+    const chksum = createHash('ripemd160')
+        .update(core.compatibleBufferConcat(check))
+        .digest()
+        .slice(0, 4);
+    console.debug(chksum);
+    signature = signature.concat(bs58.encode(core.compatibleBufferConcat([keyBuffer, chksum])));
+    console.debug(signature);
+    return signature;
+}
+function charToSymbol(c) {
+    if (c.charCodeAt(0) >= 'a'.charCodeAt(0) && c.charCodeAt(0) <= 'z'.charCodeAt(0)) {
+        return c.charCodeAt(0) - 'a'.charCodeAt(0) + 6;
+    }
+    if (c.charCodeAt(0) >= '1'.charCodeAt(0) && c.charCodeAt(0) <= '5'.charCodeAt(0)) {
+        return c.charCodeAt(0) - '1'.charCodeAt(0) + 1;
+    }
+    return 0;
+}
+function nameToNumber(name) {
+    let value = new Long(0, 0, true);
+    let c = new Long(0, 0, true);
+    for (let i = 0; i < 13; i++) {
+        if (i < name.length && i < 13) {
+            c = Long.fromNumber(charToSymbol(name[i]), true);
+        }
+        if (i < 12) {
+            c = c.and(Long.fromString('1f', true, 16));
+            c = c.shl(64 - 5 * (i + 1));
+        }
+        else {
+            // last iteration
+            c = c.and(Long.fromString('0f', true, 16));
+        }
+        value = value.or(c);
+    }
+    return value.toString();
+}
+function symbolFromString(p, name) {
+    let result = 0;
+    for (let i = 0; i < name.length; i++) {
+        result |= name.charCodeAt(i) << (8 * (i + 1));
+    }
+    result |= p;
+    return result;
+}
+function assetToNumber(asset) {
+    const assetSplit = asset.split(' '); // amount, symbol
+    const amountStr = assetSplit[0] ?? '';
+    const symbolStr = assetSplit[1] ?? '';
+    const dot_pos = amountStr.indexOf('.');
+    let fract_part = 0;
+    let int_part = 0;
+    let precision_digit = 0;
+    // parse symbol
+    if (dot_pos != -1) {
+        precision_digit = amountStr.length - dot_pos - 1;
+    }
+    else {
+        precision_digit = 0;
+    }
+    const sym = symbolFromString(precision_digit, symbolStr);
+    //parse amount
+    if (dot_pos != -1) {
+        int_part = parseInt(amountStr.slice(0, dot_pos));
+        fract_part = parseInt(amountStr.slice(dot_pos + 1));
+        if (int_part < 0) {
+            fract_part *= -1;
+        }
+    }
+    else {
+        int_part = parseInt(amountStr);
+    }
+    let amount = int_part;
+    amount *= Math.pow(10, sym & 0xff);
+    amount += fract_part;
+    return [amount, sym];
+}
+export function eosGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Eos'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+export async function eosGetPublicKey(transport, msg) {
+    const getPubkey = new EosMessages.EosGetPublicKey();
+    getPubkey.setAddressNList(msg.addressNList);
+    getPubkey.setShowDisplay(msg.showDisplay !== false);
+    getPubkey.setKind(msg.kind);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_EOSGETPUBLICKEY, getPubkey, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const eosPubkey = response.proto;
+    return core.mustBeDefined(eosPubkey.getWifPublicKey());
+}
+export async function eosSignTx(transport, msg) {
+    return transport.lockDuring(async () => {
+        let resp;
+        // check some params
+        if (msg.tx.actions.length > 1) {
+            throw new Error(`Too many actions in Eos transaction: Keepkey only supports one!`);
+        }
+        const signTx = new EosMessages.EosSignTx();
+        signTx.setAddressNList(msg.addressNList);
+        signTx.setChainId(core.fromHexString(msg.chain_id));
+        const txHeader = new EosMessages.EosTxHeader();
+        txHeader.setExpiration((Date.parse(msg.tx.expiration) -
+            Date.parse('01 Jan 1970 00:00:00Z') -
+            new Date().getTimezoneOffset() * 60 * 1000) /
+            1000);
+        txHeader.setRefBlockNum(msg.tx.ref_block_num);
+        txHeader.setRefBlockPrefix(msg.tx.ref_block_prefix);
+        txHeader.setMaxNetUsageWords(msg.tx.max_net_usage_words);
+        txHeader.setMaxCpuUsageMs(msg.tx.max_cpu_usage_ms);
+        txHeader.setDelaySec(msg.tx.delay_sec);
+        signTx.setHeader(txHeader);
+        signTx.setNumActions(msg.tx.actions.length);
+        console.debug('tx header');
+        console.debug(txHeader);
+        resp = await transport.call(Messages.MessageType.MESSAGETYPE_EOSSIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_EOSTXACTIONREQUEST) {
+            throw new Error(`eos: unexpected response ${resp.message_type}`);
+        }
+        // parse the common block of the action
+        const actCommon = new EosMessages.EosActionCommon();
+        actCommon.setAccount(nameToNumber(msg.tx.actions[0].account).toString());
+        actCommon.setName(nameToNumber(msg.tx.actions[0].name).toString());
+        // interate through authorizations and add them
+        for (let n = 0; n < msg.tx.actions[0].authorization.length; n++) {
+            const actPerm = new EosMessages.EosPermissionLevel();
+            actPerm.setActor(nameToNumber(msg.tx.actions[0].authorization[n].actor).toString());
+            actPerm.setPermission(nameToNumber(msg.tx.actions[0].authorization[n].permission).toString());
+            actCommon.addAuthorization(actPerm);
+        }
+        const actAck = new EosMessages.EosTxActionAck();
+        actAck.setCommon(actCommon);
+        // parse the various action types here.
+        switch (msg.tx.actions[0].name) {
+            case 'transfer': {
+                // build the transfer action
+                const actType = new EosMessages.EosActionTransfer();
+                actType.setSender(nameToNumber(msg.tx.actions[0].data.from).toString());
+                actType.setReceiver(nameToNumber(msg.tx.actions[0].data.to).toString());
+                const actAsset = new EosMessages.EosAsset();
+                const assetParse = assetToNumber(msg.tx.actions[0].data.quantity);
+                actAsset.setAmount(assetParse[0].toString());
+                actAsset.setSymbol(assetParse[1].toString());
+                actType.setQuantity(actAsset);
+                actType.setMemo(msg.tx.actions[0].data.memo);
+                actAck.setTransfer(actType);
+                break;
+            }
+        }
+        console.debug('action data');
+        console.debug(actAck);
+        resp = await transport.call(Messages.MessageType.MESSAGETYPE_EOSTXACTIONACK, actAck, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_EOSSIGNEDTX) {
+            throw new Error(`eos: unexpected response ${resp.message_type}`);
+        }
+        const signedTx = resp.proto;
+        // format signature for use in the eos system
+        //    const EosFormatSig = eosSigFormatter(signedTx.getSignatureR() as Uint8Array, signedTx.getSignatureS() as Uint8Array, signedTx.getSignatureV())
+        const signatureR = signedTx.getSignatureR_asU8();
+        const signatureS = signedTx.getSignatureS_asU8();
+        const signatureV = signedTx.getSignatureV();
+        if (signatureV === undefined)
+            throw new Error('missing signatureV');
+        const sig = {
+            signatureV,
+            signatureR,
+            signatureS,
+            hash: signedTx.getHash(),
+            eosFormSig: eosSigFormatter(signatureR, signatureS, signatureV),
+        };
+        return sig;
+    });
+}

package/dist/esm/ethereum.d.ts

@@ -0,0 +1,17 @@
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport.js';
+export declare function ethSupportsNetwork(_chainId: number): Promise<boolean>;
+export declare function ethSupportsSecureTransfer(): Promise<boolean>;
+export declare function ethSupportsNativeShapeShift(): boolean;
+export declare function ethGetAccountPaths(msg: core.ETHGetAccountPath): core.ETHAccountPath[];
+export declare function ethSignTx(transport: Transport, msg: core.ETHSignTx): Promise<core.ETHSignedTx>;
+export declare function ethGetAddress(transport: Transport, msg: core.ETHGetAddress): Promise<core.Address>;
+export declare function ethSignMessage(transport: Transport, msg: core.ETHSignMessage): Promise<core.ETHSignedMessage>;
+/**
+ * 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
+ */
+export declare function ethSignTypedData(transport: Transport, msg: core.ETHSignTypedData): Promise<core.ETHSignedTypedData>;
+export declare function ethVerifyMessage(transport: Transport, msg: core.ETHVerifyMessage): Promise<boolean>;

package/dist/esm/ethereum.js

@@ -0,0 +1,229 @@
+import { Common } from '@ethereumjs/common';
+import { FeeMarketEIP1559Transaction, Transaction } from '@ethereumjs/tx';
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as Ethereum from '@keepkey/device-protocol/lib/messages-ethereum_pb';
+import * as Types from '@keepkey/device-protocol/lib/types_pb';
+import { SignTypedDataVersion, TypedDataUtils } from '@metamask/eth-sig-util';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import * as eip55 from 'eip55';
+import { arrayify, isBytes, isHexString } from 'ethers/lib/utils.js';
+import { toUTF8Array } from './utils.js';
+export async function ethSupportsNetwork(_chainId) {
+    return true;
+}
+export async function ethSupportsSecureTransfer() {
+    return true;
+}
+export function ethSupportsNativeShapeShift() {
+    return true;
+}
+export 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',
+        },
+    ];
+}
+function stripLeadingZeroes(buf) {
+    const firstZeroIndex = buf.findIndex(x => x !== 0);
+    return buf.slice(firstZeroIndex !== -1 ? firstZeroIndex : buf.length);
+}
+export 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.custom({ chainId: msg.chainId });
+        const tx = msg.maxFeePerGas
+            ? FeeMarketEIP1559Transaction.fromTxData({
+                ...utxBase,
+                maxFeePerGas: msg.maxFeePerGas,
+                maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
+                r,
+                s,
+                v: v2,
+            })
+            : Transaction.fromTxData({ ...utxBase, gasPrice: msg.gasPrice, r, s, v: v2 }, { common });
+        return {
+            r,
+            s,
+            v,
+            serialized: '0x' + core.toHexString(tx.serialize()),
+        };
+    });
+}
+export 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;
+}
+export async function ethSignMessage(transport, msg) {
+    const { addressNList, message } = msg;
+    if (!isHexString(message))
+        throw new Error('data is not an hex string');
+    const m = new Ethereum.EthereumSignMessage();
+    m.setAddressNList(addressNList);
+    const messageBytes = 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()),
+    };
+}
+/**
+ * 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
+ */
+export async function ethSignTypedData(transport, msg) {
+    try {
+        const version = SignTypedDataVersion.V4;
+        const EIP_712_DOMAIN = 'EIP712Domain';
+        const { types, primaryType, domain, message } = msg.typedData;
+        const domainSeparatorHash = 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 = 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');
+    }
+}
+export async function ethVerifyMessage(transport, msg) {
+    const m = new Ethereum.EthereumVerifyMessage();
+    m.setAddress(core.arrayify(msg.address));
+    m.setSignature(core.arrayify(msg.signature));
+    m.setMessage(isBytes(msg.message) ? arrayify(msg.message) : 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';
+}

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

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