@shapeshiftoss/hdwallet-keepkey 1.62.41 → 1.62.42

package/dist/cjs/thorchain.js

@@ -0,0 +1,169 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thorchainSignTx = exports.thorchainGetAddress = exports.thorchainGetAccountPaths = void 0;
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const ThorchainMessages = __importStar(require("@keepkey/device-protocol/lib/messages-thorchain_pb"));
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const bs58check_1 = __importDefault(require("bs58check"));
+const p_lazy_1 = __importDefault(require("p-lazy"));
+const protoTxBuilder = p_lazy_1.default.from(() => Promise.resolve().then(() => __importStar(require('@shapeshiftoss/proto-tx-builder'))));
+function thorchainGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Thorchain'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+exports.thorchainGetAccountPaths = thorchainGetAccountPaths;
+async function thorchainGetAddress(transport, msg) {
+    const getAddr = new ThorchainMessages.ThorchainGetAddress();
+    getAddr.setAddressNList(msg.addressNList);
+    getAddr.setShowDisplay(msg.showDisplay !== false);
+    if (msg.testnet !== undefined)
+        getAddr.setTestnet(msg.testnet);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_THORCHAINGETADDRESS, getAddr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const thorchainAddress = response.proto;
+    return core.mustBeDefined(thorchainAddress.getAddress());
+}
+exports.thorchainGetAddress = thorchainGetAddress;
+async function thorchainSignTx(transport, msg) {
+    const address = await thorchainGetAddress(transport, { addressNList: msg.addressNList });
+    const getPublicKeyMsg = new Messages.GetPublicKey();
+    getPublicKeyMsg.setAddressNList(msg.addressNList);
+    getPublicKeyMsg.setEcdsaCurveName('secp256k1');
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_GETPUBLICKEY, getPublicKeyMsg, {
+        msgTimeout: core.DEFAULT_TIMEOUT,
+    });
+    const pubkeyMsg = response.proto;
+    const pubkey = bs58check_1.default.decode(core.mustBeDefined(pubkeyMsg.getXpub())).slice(45);
+    return transport.lockDuring(async () => {
+        const signTx = new ThorchainMessages.ThorchainSignTx();
+        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_THORCHAINSIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        for (const m of msg.tx.msg) {
+            if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_THORCHAINMSGREQUEST) {
+                throw new Error(`THORChain: unexpected response ${resp.message_type}`);
+            }
+            let ack;
+            if (m.type === 'thorchain/MsgSend') {
+                if (m.value.amount.length !== 1) {
+                    throw new Error('THORChain: Multiple amounts per MsgSend not supported');
+                }
+                const denom = m.value.amount[0].denom;
+                if (denom !== 'rune') {
+                    throw new Error('THORChain: Unsupported denomination: ' + denom);
+                }
+                const send = new ThorchainMessages.ThorchainMsgSend();
+                send.setFromAddress(m.value.from_address);
+                send.setToAddress(m.value.to_address);
+                send.setAmount(m.value.amount[0].amount);
+                ack = new ThorchainMessages.ThorchainMsgAck();
+                ack.setSend(send);
+            }
+            else if (m.type === 'thorchain/MsgDeposit') {
+                if (m.value.coins.length !== 1) {
+                    throw new Error('THORChain: Multiple amounts per MsgDeposit not supported');
+                }
+                const coinAsset = m.value.coins[0].asset;
+                if (!['THOR.RUNE', 'THOR.TCY', 'THOR.RUJI'].includes(coinAsset)) {
+                    throw new Error('THORChain: Unsupported coin asset: ' + coinAsset);
+                }
+                const deposit = new ThorchainMessages.ThorchainMsgDeposit();
+                deposit.setAsset(m.value.coins[0].asset);
+                deposit.setAmount(m.value.coins[0].amount);
+                deposit.setMemo(m.value.memo);
+                deposit.setSigner(m.value.signer);
+                ack = new ThorchainMessages.ThorchainMsgAck();
+                ack.setDeposit(deposit);
+            }
+            else {
+                throw new Error(`THORChain: Message ${m.type} is not yet supported`);
+            }
+            resp = await transport.call(Messages.MessageType.MESSAGETYPE_THORCHAINMSGACK, ack, {
+                msgTimeout: core.LONG_TIMEOUT,
+                omitLock: true,
+            });
+        }
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_THORCHAINSIGNEDTX) {
+            throw new Error(`THORChain: 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, 'thor');
+    });
+}
+exports.thorchainSignTx = thorchainSignTx;

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

@@ -1,5 +1,5 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
-import * as jspb from "google-protobuf";
+import * as core from '@shapeshiftoss/hdwallet-core';
+import * as jspb from 'google-protobuf';
 export interface TransportDelegate {
     isOpened(): Promise<boolean>;
     getDeviceID(): Promise<string>;
@@ -53,4 +53,3 @@ export declare class Transport extends core.Transport {
     protected fromMessageBuffer(buf: Uint8Array): [number, jspb.Message];
     protected static failureMessageFactory(e?: Error | string): Uint8Array;
 }
-//# sourceMappingURL=transport.d.ts.map

package/dist/cjs/transport.js

@@ -0,0 +1,333 @@
+"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.Transport = void 0;
+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 crypto = __importStar(require("crypto"));
+const jspb = __importStar(require("google-protobuf"));
+const typeRegistry_1 = require("./typeRegistry");
+const utils_1 = require("./utils");
+class Transport extends core.Transport {
+    debugLink = false;
+    userActionRequired = false;
+    delegate;
+    /// One per transport, unlike on Trezor, since the contention is
+    /// only per-device, not global.
+    callInProgress = {
+        main: undefined,
+        debug: undefined,
+    };
+    constructor(keyring, delegate) {
+        super(keyring);
+        this.delegate = delegate;
+    }
+    static async create(keyring, delegate) {
+        return new Transport(keyring, delegate);
+    }
+    isOpened() {
+        return this.delegate.isOpened();
+    }
+    getDeviceID() {
+        return this.delegate.getDeviceID();
+    }
+    connect() {
+        return this.delegate.connect();
+    }
+    async tryConnectDebugLink() {
+        let out = false;
+        if (this.delegate.tryConnectDebugLink && (await this.delegate.tryConnectDebugLink()))
+            out = true;
+        this.debugLink = out;
+        return out;
+    }
+    disconnect() {
+        return this.delegate.disconnect();
+    }
+    async write(buf, debugLink) {
+        // break frame into segments
+        for (let i = 0; i < buf.length; i += utils_1.SEGMENT_SIZE) {
+            const segment = buf.slice(i, i + utils_1.SEGMENT_SIZE);
+            const padding = new Uint8Array(utils_1.SEGMENT_SIZE - segment.length);
+            const fragments = [];
+            fragments.push(new Uint8Array([utils_1.SEGMENT_SIZE]));
+            fragments.push(segment);
+            fragments.push(padding);
+            const fragmentBuffer = new Uint8Array(fragments.map(x => x.length).reduce((a, x) => a + x, 0));
+            fragments.reduce((a, x) => (fragmentBuffer.set(x, a), a + x.length), 0);
+            await this.delegate.writeChunk(fragmentBuffer, debugLink);
+        }
+    }
+    async read(debugLink) {
+        const first = await this.delegate.readChunk(debugLink);
+        // Check that buffer starts with: "?##" [ 0x3f, 0x23, 0x23 ]
+        // "?" = USB reportId, "##" = KeepKey magic bytes
+        // Message ID is bytes 4-5. Message length starts at byte 6.
+        const firstView = new DataView(first.buffer.slice(first.byteOffset, first.byteOffset + first.byteLength));
+        const valid = (firstView.getUint32(0) & 0xffffff00) === 0x3f232300;
+        const msgLength = firstView.getUint32(5);
+        if (!valid)
+            throw new Error('message not valid');
+        const buffer = new Uint8Array(9 + msgLength);
+        buffer.set(first.slice(0, Math.min(first.length, buffer.length)));
+        for (let offset = first.length; offset < buffer.length;) {
+            // Drop USB "?" reportId in the first byte
+            const next = (await this.delegate.readChunk(debugLink)).slice(1);
+            buffer.set(next.slice(0, Math.min(next.length, buffer.length - offset)), offset);
+            offset += next.length;
+        }
+        return buffer;
+    }
+    getVendor() {
+        return 'KeepKey';
+    }
+    getEntropy(length) {
+        if (typeof window !== 'undefined' && window?.crypto) {
+            return window.crypto.getRandomValues(new Uint8Array(length));
+        }
+        return crypto.randomBytes(length);
+    }
+    async getFirmwareHash(firmware) {
+        if (typeof window !== 'undefined' && window?.crypto) {
+            return new Uint8Array(await window.crypto.subtle.digest({ name: 'SHA-256' }, firmware));
+        }
+        const hash = crypto.createHash('sha256');
+        hash.update(firmware);
+        return hash.digest();
+    }
+    /**
+     * Utility function to cancel all pending calls whenver one of them is cancelled.
+     */
+    async cancellable(inProgress) {
+        try {
+            await inProgress;
+        }
+        catch (e) {
+            // Throw away the error, as the other context will handle it,
+            // unless it was a cancel, in which case we cancel everything.
+            if (core.isIndexable(e) && e.type === core.HDWalletErrorType.ActionCancelled) {
+                this.callInProgress = { main: undefined, debug: undefined };
+                throw e;
+            }
+        }
+    }
+    async lockDuring(action) {
+        this.callInProgress.main = (async () => {
+            await this.cancellable(this.callInProgress.main);
+            return action();
+        })();
+        return this.callInProgress.main;
+    }
+    async handleCancellableResponse() {
+        return this.readResponse(false);
+    }
+    async readResponse(debugLink) {
+        let buf;
+        do {
+            buf = await this.read(debugLink);
+        } while (!buf);
+        const [msgTypeEnum, msg] = this.fromMessageBuffer(buf);
+        const event = core.makeEvent({
+            message_type: typeRegistry_1.messageNameRegistry[msgTypeEnum],
+            message_enum: msgTypeEnum,
+            message: msg.toObject(),
+            proto: msg,
+            from_wallet: true,
+        });
+        this.emit(String(msgTypeEnum), event);
+        if (debugLink)
+            return event;
+        if (msgTypeEnum === Messages.MessageType.MESSAGETYPE_FAILURE) {
+            const failureEvent = core.makeEvent({
+                message_type: core.Events.FAILURE,
+                message_enum: msgTypeEnum,
+                message: msg.toObject(),
+                from_wallet: true,
+            });
+            this.emit(core.Events.FAILURE, failureEvent);
+            return failureEvent;
+        }
+        if (msgTypeEnum === Messages.MessageType.MESSAGETYPE_BUTTONREQUEST) {
+            this.emit(core.Events.BUTTON_REQUEST, core.makeEvent({
+                message_type: core.Events.BUTTON_REQUEST,
+                from_wallet: true,
+            }));
+            this.userActionRequired = true;
+            return this.call(Messages.MessageType.MESSAGETYPE_BUTTONACK, new Messages.ButtonAck(), {
+                msgTimeout: core.LONG_TIMEOUT,
+                omitLock: true,
+            });
+        }
+        if (msgTypeEnum === Messages.MessageType.MESSAGETYPE_ENTROPYREQUEST) {
+            const ack = new Messages.EntropyAck();
+            ack.setEntropy(this.getEntropy(32));
+            return this.call(Messages.MessageType.MESSAGETYPE_ENTROPYACK, ack, {
+                msgTimeout: core.LONG_TIMEOUT,
+                omitLock: true,
+            });
+        }
+        if (msgTypeEnum === Messages.MessageType.MESSAGETYPE_PINMATRIXREQUEST) {
+            this.emit(core.Events.PIN_REQUEST, core.makeEvent({
+                message_type: core.Events.PIN_REQUEST,
+                from_wallet: true,
+            }));
+            this.userActionRequired = true;
+            return this.handleCancellableResponse();
+        }
+        if (msgTypeEnum === Messages.MessageType.MESSAGETYPE_PASSPHRASEREQUEST) {
+            this.emit(core.Events.PASSPHRASE_REQUEST, core.makeEvent({
+                message_type: core.Events.PASSPHRASE_REQUEST,
+                from_wallet: true,
+            }));
+            this.userActionRequired = true;
+            return this.handleCancellableResponse();
+        }
+        if (msgTypeEnum === Messages.MessageType.MESSAGETYPE_CHARACTERREQUEST) {
+            this.emit(core.Events.CHARACTER_REQUEST, core.makeEvent({
+                message_type: core.Events.CHARACTER_REQUEST,
+                from_wallet: true,
+            }));
+            this.userActionRequired = true;
+            return this.handleCancellableResponse();
+        }
+        if (msgTypeEnum === Messages.MessageType.MESSAGETYPE_WORDREQUEST) {
+            this.emit(core.Events.WORD_REQUEST, core.makeEvent({
+                message_type: core.Events.WORD_REQUEST,
+                from_wallet: true,
+            }));
+            this.userActionRequired = true;
+            return this.handleCancellableResponse();
+        }
+        return event;
+    }
+    async call(msgTypeEnum, msg, options) {
+        options ??= {};
+        options.msgTimeout ??= core.DEFAULT_TIMEOUT;
+        this.emit(String(msgTypeEnum), core.makeEvent({
+            message_type: typeRegistry_1.messageNameRegistry[msgTypeEnum],
+            message_enum: msgTypeEnum,
+            message: msg.toObject(),
+            proto: msg,
+            from_wallet: false,
+        }));
+        const makePromise = async () => {
+            if ([
+                Messages.MessageType.MESSAGETYPE_BUTTONACK,
+                Messages.MessageType.MESSAGETYPE_PASSPHRASEACK,
+                Messages.MessageType.MESSAGETYPE_CHARACTERACK,
+                Messages.MessageType.MESSAGETYPE_PINMATRIXACK,
+                Messages.MessageType.MESSAGETYPE_WORDACK,
+            ].includes(msgTypeEnum)) {
+                this.userActionRequired = true;
+            }
+            await this.write(this.toMessageBuffer(msgTypeEnum, msg), !!options?.debugLink);
+            if (options?.noWait)
+                return undefined;
+            const response = await this.readResponse(!!options?.debugLink);
+            this.userActionRequired = false;
+            if (response.message_enum === Messages.MessageType.MESSAGETYPE_FAILURE &&
+                response.message.code === Types.FailureType.FAILURE_ACTIONCANCELLED) {
+                this.callInProgress = { main: undefined, debug: undefined };
+                throw new core.ActionCancelled();
+            }
+            if (response.message_type === core.Events.FAILURE)
+                throw response;
+            return response;
+        };
+        if (options?.omitLock)
+            return makePromise();
+        // See the comments in hdwallet-trezor-connect's call for why this weird
+        // sequence. We've got a very similar issue here that needs pretty much
+        // the same solution.
+        const lockKey = options?.debugLink ? 'debug' : 'main';
+        this.callInProgress[lockKey] = (async () => {
+            await this.cancellable(this.callInProgress[lockKey]);
+            try {
+                return makePromise();
+            }
+            finally {
+                this.userActionRequired = false;
+            }
+        })();
+        return await this.callInProgress[lockKey];
+    }
+    async cancel() {
+        if (!this.userActionRequired)
+            return;
+        try {
+            this.callInProgress = { main: undefined, debug: undefined };
+            const cancelMsg = new Messages.Cancel();
+            await this.call(Messages.MessageType.MESSAGETYPE_CANCEL, cancelMsg, {
+                omitLock: this.userActionRequired,
+                noWait: this.userActionRequired,
+            });
+        }
+        catch (e) {
+            console.error('Cancel Pending Error', e);
+        }
+        finally {
+            this.callInProgress = { main: undefined, debug: undefined };
+        }
+    }
+    toMessageBuffer(msgTypeEnum, msg) {
+        const messageBuffer = msg.serializeBinary();
+        const headerBuffer = new Uint8Array(8);
+        const headerView = new DataView(headerBuffer.buffer);
+        headerView.setUint8(0, 0x23);
+        headerView.setUint8(1, 0x23);
+        headerView.setUint16(2, msgTypeEnum);
+        headerView.setUint32(4, messageBuffer.byteLength);
+        const fragments = [headerBuffer, messageBuffer];
+        const fragmentBuffer = new Uint8Array(fragments.map(x => x.length).reduce((a, x) => a + x, 0));
+        fragments.reduce((a, x) => (fragmentBuffer.set(x, a), a + x.length), 0);
+        return fragmentBuffer;
+    }
+    fromMessageBuffer(buf) {
+        const typeID = new DataView(buf.buffer).getUint16(3);
+        const MType = typeRegistry_1.messageTypeRegistry[typeID];
+        if (!MType) {
+            const msg = new Messages.Failure();
+            msg.setCode(Types.FailureType.FAILURE_UNEXPECTEDMESSAGE);
+            msg.setMessage('Unknown message type received');
+            return [Messages.MessageType.MESSAGETYPE_FAILURE, msg];
+        }
+        const msg = new MType();
+        const reader = new jspb.BinaryReader(buf, 9, buf.length - 9);
+        return [typeID, MType.deserializeBinaryFromReader(msg, reader)];
+    }
+    static failureMessageFactory(e) {
+        const msg = new Messages.Failure();
+        msg.setCode(Types.FailureType.FAILURE_UNEXPECTEDMESSAGE);
+        if (typeof e === 'string') {
+            msg.setMessage(e);
+        }
+        else {
+            msg.setMessage(String(e));
+        }
+        return msg.serializeBinary();
+    }
+}
+exports.Transport = Transport;

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

@@ -1,5 +1,4 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
-import * as jspb from "google-protobuf";
+import type * as core from '@shapeshiftoss/hdwallet-core';
+import type * as jspb from 'google-protobuf';
 export declare const messageNameRegistry: Record<number, string>;
 export declare const messageTypeRegistry: Record<number, core.Constructor<jspb.Message>>;
-//# sourceMappingURL=typeRegistry.d.ts.map

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

@@ -37,27 +37,40 @@ const RippleMessages = __importStar(require("@keepkey/device-protocol/lib/messag
 const ThorchainMessages = __importStar(require("@keepkey/device-protocol/lib/messages-thorchain_pb"));
 const omit_1 = __importDefault(require("lodash/omit"));
 // Conflict between typedef and actual js export
+// When CJS modules are loaded in ESM context (e.g. vitest), `import * as X`
+// creates a namespace with only `default` and `module.exports` as enumerable keys.
+// Property access (X.Foo) works via proxy, but Object.entries() does not enumerate them.
+// Access the underlying CJS module.exports via `.default` for proper enumeration.
+const unwrapCjsModule = (mod) => mod.default ?? mod;
+const MessagesUnwrapped = unwrapCjsModule(Messages);
+const BinanceMessagesUnwrapped = unwrapCjsModule(BinanceMessages);
+const CosmosMessagesUnwrapped = unwrapCjsModule(CosmosMessages);
+const EosMessagesUnwrapped = unwrapCjsModule(EosMessages);
+const MayachainMessagesUnwrapped = unwrapCjsModule(MayachainMessages);
+const NanoMessagesUnwrapped = unwrapCjsModule(NanoMessages);
+const RippleMessagesUnwrapped = unwrapCjsModule(RippleMessages);
+const ThorchainMessagesUnwrapped = unwrapCjsModule(ThorchainMessages);
 const AllMessages = []
-    .concat(Object.entries((0, omit_1.default)(Messages, "MessageType", "MessageTypeMap")))
-    .concat(Object.entries(CosmosMessages))
-    .concat(Object.entries(BinanceMessages))
-    .concat(Object.entries(RippleMessages))
-    .concat(Object.entries(NanoMessages))
-    .concat(Object.entries((0, omit_1.default)(EosMessages, "EosPublicKeyKind", "EosPublicKeyKindMap")))
-    .concat(Object.entries(ThorchainMessages))
-    .concat(Object.entries(MayachainMessages));
+    .concat(Object.entries((0, omit_1.default)(MessagesUnwrapped, 'MessageType', 'MessageTypeMap')))
+    .concat(Object.entries(CosmosMessagesUnwrapped))
+    .concat(Object.entries(BinanceMessagesUnwrapped))
+    .concat(Object.entries(RippleMessagesUnwrapped))
+    .concat(Object.entries(NanoMessagesUnwrapped))
+    .concat(Object.entries((0, omit_1.default)(EosMessagesUnwrapped, 'EosPublicKeyKind', 'EosPublicKeyKindMap')))
+    .concat(Object.entries(ThorchainMessagesUnwrapped))
+    .concat(Object.entries(MayachainMessagesUnwrapped));
 const upperCasedMessageClasses = AllMessages.reduce((registry, entry) => {
     registry[entry[0].toUpperCase()] = entry[1];
     return registry;
 }, {});
 // Map of message type enums to human readable message name
-exports.messageNameRegistry = Object.entries(Messages.MessageType).reduce((registry, entry) => {
-    registry[entry[1]] = entry[0].split("_")[1];
+exports.messageNameRegistry = Object.entries(unwrapCjsModule(Messages).MessageType).reduce((registry, entry) => {
+    registry[entry[1]] = entry[0].split('_')[1] ?? '';
     return registry;
 }, {});
 // Map of message type enum to their protobuf constructor
-exports.messageTypeRegistry = Object.entries(Messages.MessageType).reduce((registry, entry) => {
-    registry[entry[1]] = upperCasedMessageClasses[entry[0].split("_")[1].toUpperCase()];
+exports.messageTypeRegistry = Object.entries(unwrapCjsModule(Messages).MessageType).reduce((registry, entry) => {
+    const part = entry[0].split('_')[1] ?? '';
+    registry[entry[1]] = upperCasedMessageClasses[part.toUpperCase()];
     return registry;
 }, {});
-//# sourceMappingURL=typeRegistry.js.map

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

@@ -1,7 +1,6 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
+import * as core from '@shapeshiftoss/hdwallet-core';
 export declare const SEGMENT_SIZE = 63;
 export declare function protoFieldToSetMethod(fieldName: string): string;
 export declare function toUTF8Array(str: string): Uint8Array;
 export declare function translateInputScriptType(scriptType: core.BTCInputScriptType): any;
 export declare function translateOutputScriptType(scriptType: core.BTCOutputScriptType): any;
-//# sourceMappingURL=utils.d.ts.map

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

@@ -23,11 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEGMENT_SIZE = void 0;
-exports.protoFieldToSetMethod = protoFieldToSetMethod;
-exports.toUTF8Array = toUTF8Array;
-exports.translateInputScriptType = translateInputScriptType;
-exports.translateOutputScriptType = translateOutputScriptType;
+exports.translateOutputScriptType = exports.translateInputScriptType = exports.toUTF8Array = exports.protoFieldToSetMethod = exports.SEGMENT_SIZE = void 0;
 const Types = __importStar(require("@keepkey/device-protocol/lib/types_pb"));
 const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
 exports.SEGMENT_SIZE = 63;
@@ -35,6 +31,7 @@ exports.SEGMENT_SIZE = 63;
 function protoFieldToSetMethod(fieldName) {
     return `set${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}`;
 }
+exports.protoFieldToSetMethod = protoFieldToSetMethod;
 // https://gist.github.com/joni/3760795/8f0c1a608b7f0c8b3978db68105c5b1d741d0446
 function toUTF8Array(str) {
     const utf8 = [];
@@ -57,6 +54,7 @@ function toUTF8Array(str) {
     }
     return new Uint8Array(utf8);
 }
+exports.toUTF8Array = toUTF8Array;
 function translateInputScriptType(scriptType) {
     switch (scriptType) {
         case core.BTCInputScriptType.CashAddr:
@@ -69,8 +67,9 @@ function translateInputScriptType(scriptType) {
         case core.BTCInputScriptType.SpendWitness:
             return Types.InputScriptType.SPENDWITNESS;
     }
-    throw new Error("unhandled InputSriptType enum: " + scriptType);
+    throw new Error('unhandled InputSriptType enum: ' + scriptType);
 }
+exports.translateInputScriptType = translateInputScriptType;
 function translateOutputScriptType(scriptType) {
     switch (scriptType) {
         case core.BTCOutputScriptType.PayToAddress:
@@ -82,6 +81,6 @@ function translateOutputScriptType(scriptType) {
         case core.BTCOutputScriptType.PayToWitness:
             return Types.OutputScriptType.PAYTOWITNESS;
     }
-    throw new Error("unhandled OutputScriptType enum: " + scriptType);
+    throw new Error('unhandled OutputScriptType enum: ' + scriptType);
 }
-//# sourceMappingURL=utils.js.map
+exports.translateOutputScriptType = translateOutputScriptType;