@shapeshiftoss/hdwallet-keepkey 1.62.39 → 1.62.42

package/dist/esm/bitcoin.js

@@ -0,0 +1,511 @@
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as Types from '@keepkey/device-protocol/lib/types_pb';
+import * as bitcoinjs from '@shapeshiftoss/bitcoinjs-lib';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import assert from 'assert';
+import { thaw } from 'icepick';
+import { toUTF8Array, translateInputScriptType, translateOutputScriptType } from './utils.js';
+// FIXME: load this from the device's coin table, or from some static features
+// table... instead of, you know, adding another God-forsaken coin table.
+// :facepalm:
+const supportedCoins = [
+    'Bitcoin',
+    'Testnet',
+    'BitcoinCash',
+    'BitcoinGold',
+    'Litecoin',
+    'Dash',
+    'DigiByte',
+    'Dogecoin',
+];
+const segwitCoins = ['Bitcoin', 'Testnet', 'BitcoinGold', 'Litecoin'];
+function legacyAccount(coin, slip44, accountIdx) {
+    return {
+        coin,
+        scriptType: core.BTCInputScriptType.SpendAddress,
+        addressNList: [0x80000000 + 44, 0x80000000 + slip44, 0x80000000 + accountIdx],
+    };
+}
+function segwitAccount(coin, slip44, accountIdx) {
+    return {
+        coin,
+        scriptType: core.BTCInputScriptType.SpendP2SHWitness,
+        addressNList: [0x80000000 + 49, 0x80000000 + slip44, 0x80000000 + accountIdx],
+    };
+}
+function segwitNativeAccount(coin, slip44, accountIdx) {
+    return {
+        coin,
+        scriptType: core.BTCInputScriptType.SpendWitness,
+        addressNList: [0x80000000 + 84, 0x80000000 + slip44, 0x80000000 + accountIdx],
+    };
+}
+function packVarint(n) {
+    if (n < 253)
+        return n.toString(16).padStart(2, '0');
+    else if (n < 0xffff)
+        return 'FD' + n.toString(16).padStart(4, '0');
+    else if (n < 0xffffffff)
+        return 'FE' + n.toString(16).padStart(8, '0');
+    else
+        return 'FF' + n.toString(16).padStart(16, '0');
+}
+function prepareSignTx(coin, inputs, outputs) {
+    const unsignedTx = new Types.TransactionType();
+    unsignedTx.setInputsCnt(inputs.length);
+    unsignedTx.setOutputsCnt(outputs.length);
+    inputs.forEach((input, i) => {
+        const utxo = new Types.TxInputType();
+        utxo.setPrevHash(core.fromHexString(input.txid));
+        utxo.setPrevIndex(input.vout);
+        if (input.sequence !== undefined)
+            utxo.setSequence(input.sequence);
+        utxo.setScriptType(translateInputScriptType(input.scriptType));
+        utxo.setAddressNList(input.addressNList);
+        utxo.setAmount(Number(input.amount));
+        unsignedTx.addInputs(utxo, i);
+    });
+    outputs.forEach((o, k) => {
+        const output = o;
+        const newOutput = new Types.TxOutputType();
+        newOutput.setAmount(Number(output.amount));
+        // map to BCH address format
+        if (coin === 'BitcoinCash') {
+            if (output.address && !output.address.startsWith('bitcoincash:')) {
+                output.address = 'bitcoincash:' + output.address;
+            }
+        }
+        if (output.isChange || output.addressType === core.BTCOutputAddressType.Transfer) {
+            // BTCSignTxOutputTranfer ||  BTCSignTxOutputChange
+            newOutput.setScriptType(translateOutputScriptType(output.scriptType));
+            newOutput.setAddressNList(output.addressNList);
+            newOutput.setAddressType(output.isChange ? Types.OutputAddressType.CHANGE : Types.OutputAddressType.TRANSFER);
+        }
+        else if (output.opReturnData !== undefined && output.opReturnData !== null) {
+            // BTCSignTxOutputMemo
+            newOutput.setScriptType(Types.OutputScriptType.PAYTOOPRETURN);
+            newOutput.setAddressType(Types.OutputAddressType.SPEND);
+            newOutput.setOpReturnData(output.opReturnData);
+        }
+        else {
+            // BTCSignTxOutputSpend
+            newOutput.setScriptType(Types.OutputScriptType.PAYTOADDRESS);
+            assert(output.address !== undefined, 'Output must have a valid BTC address.');
+            newOutput.setAddress(output.address);
+            newOutput.setAddressType(Types.OutputAddressType.SPEND);
+        }
+        unsignedTx.addOutputs(newOutput, k);
+    });
+    const txmap = {}; // Create a map of transactions by txid needed for the KeepKey signing flow.
+    txmap['unsigned'] = unsignedTx;
+    const forceBip143Coins = ['BitcoinGold', 'BitcoinCash', 'BitcoinSV'];
+    if (forceBip143Coins.includes(coin))
+        return txmap;
+    inputs.forEach(inputTx => {
+        if (inputTx.txid in txmap)
+            return;
+        if (inputTx.scriptType === core.BTCInputScriptType.SpendP2SHWitness ||
+            inputTx.scriptType === core.BTCInputScriptType.SpendWitness ||
+            inputTx.scriptType === core.BTCInputScriptType.External)
+            return;
+        const prevTx = (() => {
+            if (inputTx.tx)
+                return inputTx.tx;
+            if (!inputTx.hex)
+                throw new Error('non-segwit inputs must have the associated prev tx');
+            const tx = bitcoinjs.Transaction.fromHex(inputTx.hex);
+            return {
+                version: tx.version,
+                locktime: tx.locktime,
+                vin: tx.ins.map(input => ({
+                    txid: Buffer.from(input.hash).reverse().toString('hex'),
+                    vout: input.index,
+                    scriptSig: {
+                        hex: Buffer.from(input.script).toString('hex'),
+                    },
+                    sequence: input.sequence,
+                })),
+                vout: tx.outs.map(output => ({
+                    value: String(output.value),
+                    scriptPubKey: {
+                        hex: Buffer.from(output.script).toString('hex'),
+                    },
+                })),
+            };
+        })();
+        const tx = new Types.TransactionType();
+        tx.setVersion(prevTx.version);
+        tx.setLockTime(prevTx.locktime);
+        tx.setInputsCnt(prevTx.vin.length);
+        tx.setOutputsCnt(prevTx.vout.length);
+        prevTx.vin.forEach((vin, i) => {
+            const txInput = new Types.TxInputType();
+            if ('coinbase' in vin) {
+                txInput.setPrevHash(core.fromHexString('\0'.repeat(64)));
+                txInput.setPrevIndex(0xffffffff);
+                txInput.setScriptSig(core.fromHexString(core.mustBeDefined(vin.coinbase)));
+                txInput.setSequence(vin.sequence);
+            }
+            else {
+                txInput.setPrevHash(core.fromHexString(vin.txid));
+                txInput.setPrevIndex(vin.vout);
+                txInput.setScriptSig(core.fromHexString(vin.scriptSig.hex));
+                txInput.setSequence(vin.sequence);
+            }
+            tx.addInputs(txInput, i);
+        });
+        prevTx.vout.forEach((vout, i) => {
+            const txOutput = new Types.TxOutputBinType();
+            txOutput.setAmount(Number(vout.value));
+            txOutput.setScriptPubkey(core.fromHexString(vout.scriptPubKey.hex));
+            tx.addBinOutputs(txOutput, i);
+        });
+        if (coin === 'Dash') {
+            const dip2_type = prevTx.type || 0;
+            // DIP2 Special Tx with payload
+            if (prevTx.version === 3 && dip2_type !== 0) {
+                if (!prevTx.extraPayload)
+                    throw new Error('Payload missing in DIP2 transaction');
+                tx.setExtraData(core.fromHexString(packVarint(prevTx.extraPayload.length * 2) + prevTx.extraPayload));
+            }
+            // Trezor (and therefore KeepKey) firmware doesn't understand the
+            // split of version and type, so let's mimic the old serialization
+            // format
+            tx.setVersion(prevTx.version | (dip2_type << 16));
+        }
+        txmap[inputTx.txid] = tx;
+    });
+    return txmap;
+}
+async function ensureCoinSupport(wallet, coin) {
+    if (!supportedCoins.includes(coin))
+        throw new Error(`'${coin}' not yet supported in HDWalletKeepKey`);
+    if (!wallet.btcSupportsCoin(coin))
+        throw new Error(`'${coin} is not supported in this firmware version`);
+}
+function validateVoutOrdering(msg) {
+    // From THORChain specification:
+    /* ignoreTx checks if we can already ignore a tx according to preset rules
+      
+       we expect array of "vout" for a BTC to have this format
+       OP_RETURN is mandatory only on inbound tx
+       vout:0 is our vault
+       vout:1 is any any change back to themselves
+       vout:2 is OP_RETURN (first 80 bytes)
+       vout:3 is OP_RETURN (next 80 bytes)
+      
+       Rules to ignore a tx are:
+       - vout:0 doesn't have coins (value)
+       - vout:0 doesn't have address
+       - count vouts > 4
+       - count vouts with coins (value) > 2
+    */
+    // Check that vout:0 contains the vault address
+    if (msg.outputs[0].address != msg.vaultAddress) {
+        return false;
+    }
+    // Check that vout:1 is change address
+    if (msg.outputs[1].addressType != core.BTCOutputAddressType.Change) {
+        return false;
+    }
+    // Check and make sure vout:2 has OP_RETURN data
+    if (!(msg.outputs[2] && msg.outputs[2]?.opReturnData)) {
+        return false;
+    }
+    return true;
+}
+export async function btcSupportsCoin(coin) {
+    // FIXME: inspect the CoinTable to determine which coins are actually supported by the device.
+    return supportedCoins.includes(coin);
+}
+export async function btcSupportsScriptType(coin, scriptType) {
+    if (!supportedCoins.includes(coin))
+        return false;
+    if (!segwitCoins.includes(coin) && scriptType === core.BTCInputScriptType.SpendP2SHWitness)
+        return false;
+    if (!segwitCoins.includes(coin) && scriptType === core.BTCInputScriptType.SpendWitness)
+        return false;
+    return true;
+}
+export async function btcGetAddress(wallet, transport, msg) {
+    await ensureCoinSupport(wallet, msg.coin);
+    const addr = new Messages.GetAddress();
+    addr.setAddressNList(msg.addressNList);
+    addr.setCoinName(msg.coin);
+    addr.setShowDisplay(msg.showDisplay || false);
+    addr.setScriptType(translateInputScriptType(msg.scriptType || core.BTCInputScriptType.SpendAddress));
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_GETADDRESS, addr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    if (response.message_type === core.Events.CANCEL)
+        throw response;
+    const btcAddress = response.proto;
+    return core.mustBeDefined(btcAddress.getAddress());
+}
+export async function btcSignTx(wallet, transport, msgIn) {
+    return transport.lockDuring(async () => {
+        // Make a copy of the input parameter so as to not mutate the caller's data.
+        // Unfreezing a recursively-frozen object is nontrivial, so we leverage an existing package
+        const msg = thaw(msgIn);
+        msg.outputs = thaw(msgIn.outputs);
+        await ensureCoinSupport(wallet, msg.coin);
+        if (msg.opReturnData) {
+            if (msg.opReturnData.length > 80) {
+                throw new Error('OP_RETURN output character count is too damn high.');
+            }
+            msg.outputs.push({
+                addressType: core.BTCOutputAddressType.Spend,
+                opReturnData: Buffer.from(msg.opReturnData).toString('base64'),
+                amount: '0',
+                isChange: false,
+            });
+        }
+        // If this is a THORChain transaction, validate the vout ordering
+        if (msg.vaultAddress && !validateVoutOrdering(msg)) {
+            throw new Error('Improper vout ordering for BTC Thorchain transaction');
+        }
+        const txmap = prepareSignTx(msg.coin, msg.inputs, msg.outputs);
+        // Prepare and send initial message
+        const tx = new Messages.SignTx();
+        tx.setInputsCount(msg.inputs.length);
+        tx.setOutputsCount(msg.outputs.length);
+        tx.setCoinName(msg.coin);
+        if (msg.version !== undefined)
+            tx.setVersion(msg.version);
+        tx.setLockTime(msg.locktime || 0);
+        let responseType;
+        let response;
+        const { message_enum, proto } = await transport.call(Messages.MessageType.MESSAGETYPE_SIGNTX, tx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        }); // 5 Minute timeout
+        responseType = message_enum;
+        response = proto;
+        // Prepare structure for signatures
+        const signatures = new Array(msg.inputs.length).fill(null);
+        let serializedTx = '';
+        try {
+            // Begin callback loop
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                if (responseType !== Messages.MessageType.MESSAGETYPE_TXREQUEST) {
+                    throw new Error(`Unexpected message type: ${responseType}`);
+                }
+                const txRequest = response;
+                // If there's some part of signed transaction, add it
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                if (txRequest.hasSerialized() && txRequest.getSerialized().hasSerializedTx()) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    serializedTx += core.toHexString(txRequest.getSerialized().getSerializedTx_asU8());
+                }
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                if (txRequest.hasSerialized() && txRequest.getSerialized().hasSignatureIndex()) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const sigIdx = txRequest.getSerialized().getSignatureIndex();
+                    if (signatures[sigIdx] !== null) {
+                        throw new Error(`Signature for index ${sigIdx} already filled`);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    signatures[sigIdx] = core.toHexString(txRequest.getSerialized().getSignature_asU8());
+                }
+                if (txRequest.getRequestType() === Types.RequestType.TXFINISHED) {
+                    // Device didn't ask for more information, finish workflow
+                    break;
+                }
+                let currentTx;
+                let currentMsg;
+                let txAck;
+                // Device asked for one more information, let's process it.
+                if (!txRequest.hasDetails())
+                    throw new Error('expected details');
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const reqDetails = txRequest.getDetails();
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                if (!reqDetails.hasTxHash()) {
+                    currentTx = txmap['unsigned'];
+                }
+                else {
+                    currentTx = txmap[core.toHexString(reqDetails.getTxHash_asU8())];
+                }
+                if (txRequest.getRequestType() === Types.RequestType.TXMETA) {
+                    currentMsg = new Types.TransactionType();
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    if (currentTx.hasVersion())
+                        currentMsg.setVersion(currentTx.getVersion());
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    if (currentTx.hasLockTime())
+                        currentMsg.setLockTime(currentTx.getLockTime());
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    if (currentTx.hasInputsCnt())
+                        currentMsg.setInputsCnt(currentTx.getInputsCnt());
+                    if (reqDetails.hasTxHash()) {
+                        currentMsg.setOutputsCnt(currentTx.getBinOutputsList().length);
+                    }
+                    else {
+                        currentMsg.setOutputsCnt(currentTx.getOutputsList().length);
+                    }
+                    if (currentTx.hasExtraData()) {
+                        currentMsg.setExtraDataLen(currentTx.getExtraData_asU8().length);
+                    }
+                    else {
+                        currentMsg.setExtraDataLen(0);
+                    }
+                    txAck = new Messages.TxAck();
+                    txAck.setTx(currentMsg);
+                    const message = await transport.call(Messages.MessageType.MESSAGETYPE_TXACK, txAck, {
+                        msgTimeout: core.LONG_TIMEOUT,
+                        omitLock: true,
+                    }); // 5 Minute timeout
+                    responseType = message.message_enum;
+                    response = message.proto;
+                    continue;
+                }
+                if (txRequest.getRequestType() === Types.RequestType.TXINPUT) {
+                    if (!reqDetails.hasRequestIndex())
+                        throw new Error('expected request index');
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const reqIndex = reqDetails.getRequestIndex();
+                    currentMsg = new Types.TransactionType();
+                    currentMsg.setInputsList([currentTx.getInputsList()[reqIndex]]);
+                    txAck = new Messages.TxAck();
+                    txAck.setTx(currentMsg);
+                    const message = await transport.call(Messages.MessageType.MESSAGETYPE_TXACK, txAck, {
+                        msgTimeout: core.LONG_TIMEOUT,
+                        omitLock: true,
+                    }); // 5 Minute timeout
+                    responseType = message.message_enum;
+                    response = message.proto;
+                    continue;
+                }
+                if (txRequest.getRequestType() === Types.RequestType.TXOUTPUT) {
+                    if (!reqDetails.hasRequestIndex())
+                        throw new Error('expected request index');
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const reqIndex = reqDetails.getRequestIndex();
+                    currentMsg = new Types.TransactionType();
+                    if (reqDetails.hasTxHash()) {
+                        currentMsg.setBinOutputsList([currentTx.getBinOutputsList()[reqIndex]]);
+                    }
+                    else {
+                        currentMsg.setOutputsList([currentTx.getOutputsList()[reqIndex]]);
+                        currentMsg.setOutputsCnt(1);
+                    }
+                    txAck = new Messages.TxAck();
+                    txAck.setTx(currentMsg);
+                    const message = await transport.call(Messages.MessageType.MESSAGETYPE_TXACK, txAck, {
+                        msgTimeout: core.LONG_TIMEOUT,
+                        omitLock: true,
+                    }); // 5 Minute timeout
+                    responseType = message.message_enum;
+                    response = message.proto;
+                    continue;
+                }
+                if (txRequest.getRequestType() === Types.RequestType.TXEXTRADATA) {
+                    if (!reqDetails.hasExtraDataOffset() || !reqDetails.hasExtraDataLen())
+                        throw new Error('missing extra data offset and length');
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const offset = reqDetails.getExtraDataOffset();
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const length = reqDetails.getExtraDataLen();
+                    currentMsg = new Types.TransactionType();
+                    currentMsg.setExtraData(currentTx.getExtraData_asU8().slice(offset, offset + length));
+                    txAck = new Messages.TxAck();
+                    txAck.setTx(currentMsg);
+                    const message = await transport.call(Messages.MessageType.MESSAGETYPE_TXACK, txAck, {
+                        msgTimeout: core.LONG_TIMEOUT,
+                        omitLock: true,
+                    }); // 5 Minute timeout
+                    responseType = message.message_enum;
+                    response = message.proto;
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            console.error({ error });
+            throw new Error('Failed to sign BTC transaction');
+        }
+        if (signatures.includes(null)) {
+            throw new Error('Some signatures are missing!');
+        }
+        return {
+            signatures: signatures,
+            serializedTx,
+        };
+    });
+}
+export async function btcSupportsSecureTransfer() {
+    return true;
+}
+export function btcSupportsNativeShapeShift() {
+    return true;
+}
+export async function btcSignMessage(wallet, transport, msg) {
+    await ensureCoinSupport(wallet, msg.coin);
+    const sign = new Messages.SignMessage();
+    sign.setAddressNList(msg.addressNList);
+    sign.setMessage(toUTF8Array(msg.message));
+    sign.setCoinName(msg.coin || 'Bitcoin');
+    sign.setScriptType(translateInputScriptType(msg.scriptType ?? core.BTCInputScriptType.SpendAddress));
+    const event = await transport.call(Messages.MessageType.MESSAGETYPE_SIGNMESSAGE, sign, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const messageSignature = event.proto;
+    const address = messageSignature.getAddress();
+    if (!address)
+        throw new Error('btcSignMessage failed');
+    return {
+        address,
+        signature: core.toHexString(messageSignature.getSignature_asU8()),
+    };
+}
+export async function btcVerifyMessage(wallet, transport, msg) {
+    await ensureCoinSupport(wallet, msg.coin);
+    const verify = new Messages.VerifyMessage();
+    verify.setAddress(msg.address);
+    verify.setSignature(core.arrayify('0x' + msg.signature));
+    verify.setMessage(toUTF8Array(msg.message));
+    verify.setCoinName(msg.coin);
+    let event;
+    try {
+        event = await transport.call(Messages.MessageType.MESSAGETYPE_VERIFYMESSAGE, verify);
+    }
+    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';
+}
+export function btcGetAccountPaths(msg) {
+    const slip44 = core.slip44ByCoin(msg.coin);
+    if (slip44 === undefined)
+        return [];
+    const bip44 = legacyAccount(msg.coin, slip44, msg.accountIdx);
+    const bip49 = segwitAccount(msg.coin, slip44, msg.accountIdx);
+    const bip84 = segwitNativeAccount(msg.coin, slip44, msg.accountIdx);
+    // For BTC Forks
+    const btcLegacy = legacyAccount(msg.coin, core.slip44ByCoin('Bitcoin'), msg.accountIdx);
+    const btcSegwit = segwitAccount(msg.coin, core.slip44ByCoin('Bitcoin'), msg.accountIdx);
+    const btcSegwitNative = segwitNativeAccount(msg.coin, core.slip44ByCoin('Bitcoin'), msg.accountIdx);
+    // For BCH Forks
+    const bchLegacy = legacyAccount(msg.coin, core.slip44ByCoin('BitcoinCash'), msg.accountIdx);
+    let paths = {
+        Bitcoin: [bip44, bip49, bip84],
+        Litecoin: [bip44, bip49, bip84],
+        Dash: [bip44],
+        DigiByte: [bip44, bip49, bip84],
+        Dogecoin: [bip44],
+        Testnet: [bip44, bip49, bip84],
+        BitcoinCash: [bip44, btcLegacy],
+        BitcoinSV: [bip44, bchLegacy, btcLegacy],
+        BitcoinGold: [bip44, bip49, bip84, btcLegacy, btcSegwit, btcSegwitNative],
+    }[msg.coin] ?? [];
+    if (msg.scriptType !== undefined)
+        paths = paths.filter(path => {
+            return path.scriptType === msg.scriptType;
+        });
+    return paths;
+}

package/dist/esm/bnbencoding.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type * as core from '@shapeshiftoss/hdwallet-core';
+export declare function decodeBnbTx(txBytes: Buffer, chainId: string): {
+    signBytes: string;
+    signBytesHash: string;
+    pubKey: Buffer;
+    signature: any;
+};
+export declare function validateBnbTx(txBytes: Buffer, chainId: string): boolean;
+export declare function encodeBnbTx(unsignedTx: core.BinanceTx, publicKey: Buffer, signature: Buffer): Buffer;

package/dist/esm/bnbencoding.js

@@ -0,0 +1,103 @@
+import ecc from '@bitcoinerlab/secp256k1';
+import * as bnbSdk from 'bnb-javascript-sdk-nobroadcast';
+import CryptoJS from 'crypto-js';
+export function decodeBnbTx(txBytes, chainId) {
+    const txDecoded = bnbSdk.amino.decoder.unMarshalBinaryLengthPrefixed(txBytes, {
+        aminoPrefix: 'f0625dee',
+        msgs: [
+            {
+                aminoPrefix: '2a2c87fa',
+                inputs: [{ address: Buffer.alloc(0), coins: [{ denom: '', amount: 0 }] }],
+                outputs: [{ address: Buffer.alloc(0), coins: [{ denom: '', amount: 0 }] }],
+            },
+        ],
+        signatures: [
+            {
+                pubKey: Buffer.alloc(0),
+                signature: Buffer.alloc(0),
+                accountNumber: 0,
+                sequence: 0,
+            },
+        ],
+        memo: '',
+        source: 0,
+        data: Buffer.alloc(0),
+    }).val;
+    if (txDecoded.data !== null)
+        throw new Error('bad data length');
+    if (txDecoded.msgs.length !== 1)
+        throw new Error('bad msgs length');
+    if (txDecoded.signatures.length !== 1)
+        throw new Error('bad signatures length');
+    const signBytes = JSON.stringify({
+        account_number: String(txDecoded.signatures[0].accountNumber),
+        chain_id: chainId,
+        data: null,
+        memo: txDecoded.memo,
+        msgs: [
+            {
+                inputs: txDecoded.msgs[0].inputs.map((x) => ({
+                    address: bnbSdk.crypto.encodeAddress(x.address, 'bnb'),
+                    coins: x.coins.map((y) => ({
+                        amount: Number(y.amount),
+                        denom: y.denom,
+                    })),
+                })),
+                outputs: txDecoded.msgs[0].outputs.map((x) => ({
+                    address: bnbSdk.crypto.encodeAddress(x.address, 'bnb'),
+                    coins: x.coins.map((y) => ({
+                        amount: Number(y.amount),
+                        denom: y.denom,
+                    })),
+                })),
+            },
+        ],
+        sequence: String(txDecoded.signatures[0].sequence),
+        source: String(txDecoded.source),
+    });
+    const signBytesHash = CryptoJS.SHA256(CryptoJS.enc.Utf8.parse(signBytes)).toString();
+    const pubKeyAmino = Buffer.from(txDecoded.signatures[0].pubKey);
+    if (pubKeyAmino.readUInt32BE(0) !== 0xeb5ae987)
+        throw new Error('bad pubkey aminoPrefix');
+    if (pubKeyAmino.readUInt8(4) !== 33)
+        throw new Error('bad pubKey length');
+    const pubKey = pubKeyAmino.slice(5);
+    const signature = txDecoded.signatures[0].signature;
+    return { signBytes, signBytesHash, pubKey, signature };
+}
+export function validateBnbTx(txBytes, chainId) {
+    const { signBytesHash, pubKey, signature } = decodeBnbTx(txBytes, chainId);
+    return ecc.verify(Buffer.from(signBytesHash, 'hex'), pubKey, signature);
+}
+export function encodeBnbTx(unsignedTx, publicKey, signature) {
+    const { account_number, chain_id, sequence, source } = unsignedTx;
+    const msg = unsignedTx.msgs[0];
+    const amountToInt = (x) => Number(x);
+    const msgNormalizer = (x) => ({
+        address: bnbSdk.crypto.decodeAddress(x.address),
+        coins: x.coins.map((y) => ({
+            // In particular, these keys are backwards because we can't have nice things.
+            denom: y.denom,
+            amount: amountToInt(y.amount),
+        })),
+    });
+    const baseMsg = {
+        inputs: msg.inputs.map(msgNormalizer),
+        outputs: msg.outputs.map(msgNormalizer),
+        aminoPrefix: '2A2C87FA',
+    };
+    const tx = new bnbSdk.Transaction(Object.assign({}, unsignedTx, {
+        chainId: chain_id,
+        accountNumber: Number(account_number),
+        source: Number(source ?? 0),
+        sequence: Number(sequence),
+        // A bug in the binance SDK makes this field required, even though it shouldn't be.
+        baseMsg: { getMsg: () => baseMsg, getBaseMsg: () => baseMsg, getSignMsg: () => baseMsg },
+    }));
+    const ecPubKey = bnbSdk.crypto.getPublicKey(Buffer.from(publicKey).toString('hex'));
+    tx.addSignature(ecPubKey, signature);
+    const serializedTx = Buffer.from(tx.serialize(), 'hex');
+    if (!validateBnbTx(serializedTx, chain_id))
+        throw new Error('serialized tx did not validate');
+    return serializedTx;
+}

package/dist/esm/cosmos.d.ts

@@ -0,0 +1,6 @@
+import * as CosmosMessages from '@keepkey/device-protocol/lib/messages-cosmos_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport.js';
+export declare function cosmosGetAccountPaths(msg: core.CosmosGetAccountPaths): core.CosmosAccountPath[];
+export declare function cosmosGetAddress(transport: Transport, msg: CosmosMessages.CosmosGetAddress.AsObject): Promise<string>;
+export declare function cosmosSignTx(transport: Transport, msg: core.CosmosSignTx): Promise<any>;