@shapeshiftoss/hdwallet-keepkey 1.55.4-alpha.1 → 1.55.4

package/dist/bitcoin.js

@@ -1,10 +1,57 @@
-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";
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.btcSupportsCoin = btcSupportsCoin;
+exports.btcSupportsScriptType = btcSupportsScriptType;
+exports.btcGetAddress = btcGetAddress;
+exports.btcSignTx = btcSignTx;
+exports.btcSupportsSecureTransfer = btcSupportsSecureTransfer;
+exports.btcSupportsNativeShapeShift = btcSupportsNativeShapeShift;
+exports.btcSignMessage = btcSignMessage;
+exports.btcVerifyMessage = btcVerifyMessage;
+exports.btcGetAccountPaths = btcGetAccountPaths;
+exports.btcIsSameAccount = btcIsSameAccount;
+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:
@@ -51,7 +98,7 @@ function prepareSignTx(coin, inputs, outputs) {
         utxo.setPrevIndex(input.vout);
         if (input.sequence !== undefined)
             utxo.setSequence(input.sequence);
-        utxo.setScriptType(translateInputScriptType(input.scriptType));
+        utxo.setScriptType((0, utils_1.translateInputScriptType)(input.scriptType));
         utxo.setAddressNList(input.addressNList);
         utxo.setAmount(Number(input.amount));
         unsignedTx.addInputs(utxo, i);
@@ -68,7 +115,7 @@ function prepareSignTx(coin, inputs, outputs) {
         }
         if (output.isChange || output.addressType === core.BTCOutputAddressType.Transfer) {
             // BTCSignTxOutputTranfer ||  BTCSignTxOutputChange
-            newOutput.setScriptType(translateOutputScriptType(output.scriptType));
+            newOutput.setScriptType((0, utils_1.translateOutputScriptType)(output.scriptType));
             newOutput.setAddressNList(output.addressNList);
             newOutput.setAddressType(output.isChange ? Types.OutputAddressType.CHANGE : Types.OutputAddressType.TRANSFER);
         }
@@ -81,7 +128,7 @@ function prepareSignTx(coin, inputs, outputs) {
         else {
             // BTCSignTxOutputSpend
             newOutput.setScriptType(Types.OutputScriptType.PAYTOADDRESS);
-            assert(output.address !== undefined, "Output must have a valid BTC address.");
+            (0, assert_1.default)(output.address !== undefined, "Output must have a valid BTC address.");
             newOutput.setAddress(output.address);
             newOutput.setAddressType(Types.OutputAddressType.SPEND);
         }
@@ -168,11 +215,13 @@ function prepareSignTx(coin, inputs, outputs) {
     });
     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 ensureCoinSupport(wallet, coin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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:
@@ -191,6 +240,7 @@ function validateVoutOrdering(msg) {
        - count vouts > 4
        - count vouts with coins (value) > 2
     */
+    var _a;
     // Check that vout:0 contains the vault address
     if (msg.outputs[0].address != msg.vaultAddress) {
         return false;
@@ -200,277 +250,293 @@ function validateVoutOrdering(msg) {
         return false;
     }
     // Check and make sure vout:2 has OP_RETURN data
-    if (!(msg.outputs[2] && msg.outputs[2]?.opReturnData)) {
+    if (!(msg.outputs[2] && ((_a = msg.outputs[2]) === null || _a === void 0 ? void 0 : _a.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;
+function btcSupportsCoin(coin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // FIXME: inspect the CoinTable to determine which coins are actually supported by the device.
+        return supportedCoins.includes(coin);
+    });
 }
-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,
+function btcSupportsScriptType(coin, scriptType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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;
     });
-    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, {
+function btcGetAddress(wallet, transport, msg) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield 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 = yield transport.call(Messages.MessageType.MESSAGETYPE_GETADDRESS, addr, {
             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());
+        });
+        if (response.message_type === core.Events.CANCEL)
+            throw response;
+        const btcAddress = response.proto;
+        return core.mustBeDefined(btcAddress.getAddress());
+    });
+}
+function btcSignTx(wallet, transport, msgIn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return transport.lockDuring(() => __awaiter(this, void 0, void 0, function* () {
+            // 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);
+            yield ensureCoinSupport(wallet, msg.coin);
+            if (msg.opReturnData) {
+                if (msg.opReturnData.length > 80) {
+                    throw new Error("OP_RETURN output character count is too damn high.");
                 }
-                // 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`);
+                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 } = yield 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
-                    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();
+                    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 (currentTx.hasVersion())
-                        currentMsg.setVersion(currentTx.getVersion());
+                    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
-                    if (currentTx.hasLockTime())
-                        currentMsg.setLockTime(currentTx.getLockTime());
+                    const reqDetails = txRequest.getDetails();
                     // 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);
+                    if (!reqDetails.hasTxHash()) {
+                        currentTx = txmap["unsigned"];
                     }
                     else {
-                        currentMsg.setOutputsCnt(currentTx.getOutputsList().length);
+                        currentTx = txmap[core.toHexString(reqDetails.getTxHash_asU8())];
                     }
-                    if (currentTx.hasExtraData()) {
-                        currentMsg.setExtraDataLen(currentTx.getExtraData_asU8().length);
+                    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 = yield transport.call(Messages.MessageType.MESSAGETYPE_TXACK, txAck, {
+                            msgTimeout: core.LONG_TIMEOUT,
+                            omitLock: true,
+                        }); // 5 Minute timeout
+                        responseType = message.message_enum;
+                        response = message.proto;
+                        continue;
                     }
-                    else {
-                        currentMsg.setExtraDataLen(0);
+                    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 = yield transport.call(Messages.MessageType.MESSAGETYPE_TXACK, txAck, {
+                            msgTimeout: core.LONG_TIMEOUT,
+                            omitLock: true,
+                        }); // 5 Minute timeout
+                        responseType = message.message_enum;
+                        response = message.proto;
+                        continue;
                     }
-                    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]]);
+                    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 = yield transport.call(Messages.MessageType.MESSAGETYPE_TXACK, txAck, {
+                            msgTimeout: core.LONG_TIMEOUT,
+                            omitLock: true,
+                        }); // 5 Minute timeout
+                        responseType = message.message_enum;
+                        response = message.proto;
+                        continue;
                     }
-                    else {
-                        currentMsg.setOutputsList([currentTx.getOutputsList()[reqIndex]]);
-                        currentMsg.setOutputsCnt(1);
+                    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 = yield transport.call(Messages.MessageType.MESSAGETYPE_TXACK, txAck, {
+                            msgTimeout: core.LONG_TIMEOUT,
+                            omitLock: true,
+                        }); // 5 Minute timeout
+                        responseType = message.message_enum;
+                        response = message.proto;
+                        continue;
                     }
-                    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: serializedTx,
-        };
+            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: serializedTx,
+            };
+        }));
     });
 }
-export async function btcSupportsSecureTransfer() {
-    return true;
+function btcSupportsSecureTransfer() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return true;
+    });
 }
-export function btcSupportsNativeShapeShift() {
+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,
+function btcSignMessage(wallet, transport, msg) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        yield 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)((_a = msg.scriptType) !== null && _a !== void 0 ? _a : core.BTCInputScriptType.SpendAddress));
+        const event = yield 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()),
+        };
     });
-    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;
+function btcVerifyMessage(wallet, transport, msg) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield 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 = yield transport.call(Messages.MessageType.MESSAGETYPE_VERIFYMESSAGE, verify);
         }
-        throw e;
-    }
-    const success = event.proto;
-    return success.getMessage() === "Message verified";
+        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) {
+function btcGetAccountPaths(msg) {
+    var _a;
     const slip44 = core.slip44ByCoin(msg.coin);
     if (slip44 === undefined)
         return [];
@@ -483,7 +549,7 @@ export function btcGetAccountPaths(msg) {
     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 = {
+    let paths = (_a = {
         Bitcoin: [bip44, bip49, bip84],
         Litecoin: [bip44, bip49, bip84],
         Dash: [bip44],
@@ -493,14 +559,14 @@ export function btcGetAccountPaths(msg) {
         BitcoinCash: [bip44, btcLegacy],
         BitcoinSV: [bip44, bchLegacy, btcLegacy],
         BitcoinGold: [bip44, bip49, bip84, btcLegacy, btcSegwit, btcSegwitNative],
-    }[msg.coin] ?? [];
+    }[msg.coin]) !== null && _a !== void 0 ? _a : [];
     if (msg.scriptType !== undefined)
         paths = paths.filter((path) => {
             return path.scriptType === msg.scriptType;
         });
     return paths;
 }
-export function btcIsSameAccount(msg) {
+function btcIsSameAccount(msg) {
     if (msg.length < 1)
         return false;
     if (msg.length > 3)