@shapeshiftoss/hdwallet-keepkey 1.62.39 → 1.62.42

package/dist/cjs/bitcoin.js

@@ -0,0 +1,549 @@
+"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.btcGetAccountPaths = exports.btcVerifyMessage = exports.btcSignMessage = exports.btcSupportsNativeShapeShift = exports.btcSupportsSecureTransfer = exports.btcSignTx = exports.btcGetAddress = exports.btcSupportsScriptType = exports.btcSupportsCoin = void 0;
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const Types = __importStar(require("@keepkey/device-protocol/lib/types_pb"));
+const bitcoinjs = __importStar(require("@shapeshiftoss/bitcoinjs-lib"));
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const assert_1 = __importDefault(require("assert"));
+const icepick_1 = require("icepick");
+const utils_1 = require("./utils");
+// 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((0, utils_1.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((0, utils_1.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);
+            (0, assert_1.default)(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;
+}
+async function btcSupportsCoin(coin) {
+    // FIXME: inspect the CoinTable to determine which coins are actually supported by the device.
+    return supportedCoins.includes(coin);
+}
+exports.btcSupportsCoin = btcSupportsCoin;
+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;
+}
+exports.btcSupportsScriptType = btcSupportsScriptType;
+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((0, utils_1.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());
+}
+exports.btcGetAddress = btcGetAddress;
+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 = (0, icepick_1.thaw)(msgIn);
+        msg.outputs = (0, icepick_1.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,
+        };
+    });
+}
+exports.btcSignTx = btcSignTx;
+async function btcSupportsSecureTransfer() {
+    return true;
+}
+exports.btcSupportsSecureTransfer = btcSupportsSecureTransfer;
+function btcSupportsNativeShapeShift() {
+    return true;
+}
+exports.btcSupportsNativeShapeShift = btcSupportsNativeShapeShift;
+async function btcSignMessage(wallet, transport, msg) {
+    await ensureCoinSupport(wallet, msg.coin);
+    const sign = new Messages.SignMessage();
+    sign.setAddressNList(msg.addressNList);
+    sign.setMessage((0, utils_1.toUTF8Array)(msg.message));
+    sign.setCoinName(msg.coin || 'Bitcoin');
+    sign.setScriptType((0, utils_1.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()),
+    };
+}
+exports.btcSignMessage = btcSignMessage;
+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((0, utils_1.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';
+}
+exports.btcVerifyMessage = btcVerifyMessage;
+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;
+}
+exports.btcGetAccountPaths = btcGetAccountPaths;

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

@@ -1,4 +1,6 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
+/// <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;
@@ -7,4 +9,3 @@ export declare function decodeBnbTx(txBytes: Buffer, chainId: string): {
 };
 export declare function validateBnbTx(txBytes: Buffer, chainId: string): boolean;
 export declare function encodeBnbTx(unsignedTx: core.BinanceTx, publicKey: Buffer, signature: Buffer): Buffer;
-//# sourceMappingURL=bnbencoding.d.ts.map

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

@@ -26,20 +26,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeBnbTx = decodeBnbTx;
-exports.validateBnbTx = validateBnbTx;
-exports.encodeBnbTx = encodeBnbTx;
+exports.encodeBnbTx = exports.validateBnbTx = exports.decodeBnbTx = void 0;
 const secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
 const bnbSdk = __importStar(require("bnb-javascript-sdk-nobroadcast"));
 const crypto_js_1 = __importDefault(require("crypto-js"));
 function decodeBnbTx(txBytes, chainId) {
     const txDecoded = bnbSdk.amino.decoder.unMarshalBinaryLengthPrefixed(txBytes, {
-        aminoPrefix: "f0625dee",
+        aminoPrefix: 'f0625dee',
         msgs: [
             {
-                aminoPrefix: "2a2c87fa",
-                inputs: [{ address: Buffer.alloc(0), coins: [{ denom: "", amount: 0 }] }],
-                outputs: [{ address: Buffer.alloc(0), coins: [{ denom: "", amount: 0 }] }],
+                aminoPrefix: '2a2c87fa',
+                inputs: [{ address: Buffer.alloc(0), coins: [{ denom: '', amount: 0 }] }],
+                outputs: [{ address: Buffer.alloc(0), coins: [{ denom: '', amount: 0 }] }],
             },
         ],
         signatures: [
@@ -50,16 +48,16 @@ function decodeBnbTx(txBytes, chainId) {
                 sequence: 0,
             },
         ],
-        memo: "",
+        memo: '',
         source: 0,
         data: Buffer.alloc(0),
     }).val;
     if (txDecoded.data !== null)
-        throw new Error("bad data length");
+        throw new Error('bad data length');
     if (txDecoded.msgs.length !== 1)
-        throw new Error("bad msgs length");
+        throw new Error('bad msgs length');
     if (txDecoded.signatures.length !== 1)
-        throw new Error("bad signatures length");
+        throw new Error('bad signatures length');
     const signBytes = JSON.stringify({
         account_number: String(txDecoded.signatures[0].accountNumber),
         chain_id: chainId,
@@ -68,14 +66,14 @@ function decodeBnbTx(txBytes, chainId) {
         msgs: [
             {
                 inputs: txDecoded.msgs[0].inputs.map((x) => ({
-                    address: bnbSdk.crypto.encodeAddress(x.address, "bnb"),
+                    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"),
+                    address: bnbSdk.crypto.encodeAddress(x.address, 'bnb'),
                     coins: x.coins.map((y) => ({
                         amount: Number(y.amount),
                         denom: y.denom,
@@ -89,17 +87,19 @@ function decodeBnbTx(txBytes, chainId) {
     const signBytesHash = crypto_js_1.default.SHA256(crypto_js_1.default.enc.Utf8.parse(signBytes)).toString();
     const pubKeyAmino = Buffer.from(txDecoded.signatures[0].pubKey);
     if (pubKeyAmino.readUInt32BE(0) !== 0xeb5ae987)
-        throw new Error("bad pubkey aminoPrefix");
+        throw new Error('bad pubkey aminoPrefix');
     if (pubKeyAmino.readUInt8(4) !== 33)
-        throw new Error("bad pubKey length");
+        throw new Error('bad pubKey length');
     const pubKey = pubKeyAmino.slice(5);
     const signature = txDecoded.signatures[0].signature;
     return { signBytes, signBytesHash, pubKey, signature };
 }
+exports.decodeBnbTx = decodeBnbTx;
 function validateBnbTx(txBytes, chainId) {
     const { signBytesHash, pubKey, signature } = decodeBnbTx(txBytes, chainId);
-    return secp256k1_1.default.verify(Buffer.from(signBytesHash, "hex"), pubKey, signature);
+    return secp256k1_1.default.verify(Buffer.from(signBytesHash, 'hex'), pubKey, signature);
 }
+exports.validateBnbTx = validateBnbTx;
 function encodeBnbTx(unsignedTx, publicKey, signature) {
     const { account_number, chain_id, sequence, source } = unsignedTx;
     const msg = unsignedTx.msgs[0];
@@ -115,21 +115,21 @@ function encodeBnbTx(unsignedTx, publicKey, signature) {
     const baseMsg = {
         inputs: msg.inputs.map(msgNormalizer),
         outputs: msg.outputs.map(msgNormalizer),
-        aminoPrefix: "2A2C87FA",
+        aminoPrefix: '2A2C87FA',
     };
     const tx = new bnbSdk.Transaction(Object.assign({}, unsignedTx, {
         chainId: chain_id,
         accountNumber: Number(account_number),
-        source: Number(source !== null && source !== void 0 ? source : 0),
+        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"));
+    const ecPubKey = bnbSdk.crypto.getPublicKey(Buffer.from(publicKey).toString('hex'));
     tx.addSignature(ecPubKey, signature);
-    const serializedTx = Buffer.from(tx.serialize(), "hex");
+    const serializedTx = Buffer.from(tx.serialize(), 'hex');
     if (!validateBnbTx(serializedTx, chain_id))
-        throw new Error("serialized tx did not validate");
+        throw new Error('serialized tx did not validate');
     return serializedTx;
 }
-//# sourceMappingURL=bnbencoding.js.map
+exports.encodeBnbTx = encodeBnbTx;