@ledgerhq/hw-app-btc 10.0.1 → 10.0.2-next.0

package/lib-es/BtcNew.js

@@ -7,33 +7,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { crypto } from "bitcoinjs-lib";
 import { pointCompress } from "tiny-secp256k1";
 import { getXpubComponents, hardenedPathOf, pathArrayToString, pathStringToArray, pubkeyFromXpub, } from "./bip32";
@@ -57,8 +30,8 @@ import { serializeTransaction } from "./serializeTransaction";
  * be developed that exposes PSBT to the outer world, which would render
  * a much cleaner implementation.
  */
-var BtcNew = /** @class */ (function () {
-    function BtcNew(client) {
+export default class BtcNew {
+    constructor(client) {
         this.client = client;
     }
     /**
@@ -91,26 +64,17 @@ var BtcNew = /** @class */ (function () {
      *
      * We opted for adding a new function, which can greatly simplify client code.
      */
-    BtcNew.prototype.getWalletXpub = function (_a) {
-        var path = _a.path, xpubVersion = _a.xpubVersion;
-        return __awaiter(this, void 0, void 0, function () {
-            var pathElements, xpub, xpubComponents;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        pathElements = pathStringToArray(path);
-                        return [4 /*yield*/, this.client.getExtendedPubkey(false, pathElements)];
-                    case 1:
-                        xpub = _b.sent();
-                        xpubComponents = getXpubComponents(xpub);
-                        if (xpubComponents.version != xpubVersion) {
-                            throw new Error("Expected xpub version ".concat(xpubVersion, " doesn't match the xpub version from the device ").concat(xpubComponents.version));
-                        }
-                        return [2 /*return*/, xpub];
-                }
-            });
+    getWalletXpub({ path, xpubVersion, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pathElements = pathStringToArray(path);
+            const xpub = yield this.client.getExtendedPubkey(false, pathElements);
+            const xpubComponents = getXpubComponents(xpub);
+            if (xpubComponents.version != xpubVersion) {
+                throw new Error(`Expected xpub version ${xpubVersion} doesn't match the xpub version from the device ${xpubComponents.version}`);
+            }
+            return xpub;
         });
-    };
+    }
     /**
      * This method returns a public key, a bitcoin address, and and a chaincode
      * for a specific derivation path.
@@ -118,35 +82,25 @@ var BtcNew = /** @class */ (function () {
      * Limitation: If the path is not a leaf node of a standard path, the address
      * will be the empty string "", see this.getWalletAddress() for details.
      */
-    BtcNew.prototype.getWalletPublicKey = function (path, opts) {
+    getWalletPublicKey(path, opts) {
         var _a, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var pathElements, xpub, display, address, components, uncompressedPubkey;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!isPathNormal(path)) {
-                            throw Error("non-standard path: ".concat(path));
-                        }
-                        pathElements = pathStringToArray(path);
-                        return [4 /*yield*/, this.client.getExtendedPubkey(false, pathElements)];
-                    case 1:
-                        xpub = _c.sent();
-                        display = (_a = opts === null || opts === void 0 ? void 0 : opts.verify) !== null && _a !== void 0 ? _a : false;
-                        return [4 /*yield*/, this.getWalletAddress(pathElements, descrTemplFrom((_b = opts === null || opts === void 0 ? void 0 : opts.format) !== null && _b !== void 0 ? _b : "legacy"), display)];
-                    case 2:
-                        address = _c.sent();
-                        components = getXpubComponents(xpub);
-                        uncompressedPubkey = Buffer.from(pointCompress(components.pubkey, false));
-                        return [2 /*return*/, {
-                                publicKey: uncompressedPubkey.toString("hex"),
-                                bitcoinAddress: address,
-                                chainCode: components.chaincode.toString("hex")
-                            }];
-                }
-            });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!isPathNormal(path)) {
+                throw Error(`non-standard path: ${path}`);
+            }
+            const pathElements = pathStringToArray(path);
+            const xpub = yield this.client.getExtendedPubkey(false, pathElements);
+            const display = (_a = opts === null || opts === void 0 ? void 0 : opts.verify) !== null && _a !== void 0 ? _a : false;
+            const address = yield this.getWalletAddress(pathElements, descrTemplFrom((_b = opts === null || opts === void 0 ? void 0 : opts.format) !== null && _b !== void 0 ? _b : "legacy"), display);
+            const components = getXpubComponents(xpub);
+            const uncompressedPubkey = Buffer.from(pointCompress(components.pubkey, false));
+            return {
+                publicKey: uncompressedPubkey.toString("hex"),
+                bitcoinAddress: address,
+                chainCode: components.chaincode.toString("hex"),
+            };
         });
-    };
+    }
     /**
      * Get an address for the specified path.
      *
@@ -162,29 +116,19 @@ var BtcNew = /** @class */ (function () {
      * way to get the address from the device. In this case we have to create it
      * ourselves, but we don't at this time, and instead return an empty ("") address.
      */
-    BtcNew.prototype.getWalletAddress = function (pathElements, descrTempl, display) {
-        return __awaiter(this, void 0, void 0, function () {
-            var accountPath, accountXpub, masterFingerprint, policy, changeAndIndex;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        accountPath = hardenedPathOf(pathElements);
-                        if (accountPath.length + 2 != pathElements.length) {
-                            return [2 /*return*/, ""];
-                        }
-                        return [4 /*yield*/, this.client.getExtendedPubkey(false, accountPath)];
-                    case 1:
-                        accountXpub = _a.sent();
-                        return [4 /*yield*/, this.client.getMasterFingerprint()];
-                    case 2:
-                        masterFingerprint = _a.sent();
-                        policy = new WalletPolicy(descrTempl, createKey(masterFingerprint, accountPath, accountXpub));
-                        changeAndIndex = pathElements.slice(-2, pathElements.length);
-                        return [2 /*return*/, this.client.getWalletAddress(policy, Buffer.alloc(32, 0), changeAndIndex[0], changeAndIndex[1], display)];
-                }
-            });
+    getWalletAddress(pathElements, descrTempl, display) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountPath = hardenedPathOf(pathElements);
+            if (accountPath.length + 2 != pathElements.length) {
+                return "";
+            }
+            const accountXpub = yield this.client.getExtendedPubkey(false, accountPath);
+            const masterFingerprint = yield this.client.getMasterFingerprint();
+            const policy = new WalletPolicy(descrTempl, createKey(masterFingerprint, accountPath, accountXpub));
+            const changeAndIndex = pathElements.slice(-2, pathElements.length);
+            return this.client.getWalletAddress(policy, Buffer.alloc(32, 0), changeAndIndex[0], changeAndIndex[1], display);
         });
-    };
+    }
     /**
      * Build and sign a transaction. See Btc.createPaymentTransaction for
      * details on how to use this method.
@@ -193,111 +137,97 @@ var BtcNew = /** @class */ (function () {
      * a psbt which is finally signed and finalized, and the extracted fully signed
      * transaction is returned.
      */
-    BtcNew.prototype.createPaymentTransaction = function (arg) {
-        return __awaiter(this, void 0, void 0, function () {
-            var inputCount, psbt, masterFp, accountType, notifyCount, progress, accountXpub, accountPath, i, pathElems, outputsConcat, outputsBufferReader, outputCount, changeData, changeFound, i, amount, outputScript, isChange, changePath, pubkey, key, p, firstSigned, progressCallback, serializedTx;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        inputCount = arg.inputs.length;
-                        if (inputCount == 0) {
-                            throw Error("No inputs");
-                        }
-                        psbt = new PsbtV2();
-                        return [4 /*yield*/, this.client.getMasterFingerprint()];
-                    case 1:
-                        masterFp = _a.sent();
-                        accountType = accountTypeFromArg(arg, psbt, masterFp);
-                        if (arg.lockTime != undefined) {
-                            // The signer will assume locktime 0 if unset
-                            psbt.setGlobalFallbackLocktime(arg.lockTime);
-                        }
-                        psbt.setGlobalInputCount(inputCount);
-                        psbt.setGlobalPsbtVersion(2);
-                        psbt.setGlobalTxVersion(2);
-                        notifyCount = 0;
-                        progress = function () {
-                            if (!arg.onDeviceStreaming)
-                                return;
-                            arg.onDeviceStreaming({
-                                total: 2 * inputCount,
-                                index: notifyCount,
-                                progress: ++notifyCount / (2 * inputCount)
-                            });
-                        };
-                        accountXpub = "";
-                        accountPath = [];
-                        i = 0;
-                        _a.label = 2;
-                    case 2:
-                        if (!(i < inputCount)) return [3 /*break*/, 7];
-                        progress();
-                        pathElems = pathStringToArray(arg.associatedKeysets[i]);
-                        if (!(accountXpub == "")) return [3 /*break*/, 4];
-                        // We assume all inputs belong to the same account so we set
-                        // the account xpub and path based on the first input.
-                        accountPath = pathElems.slice(0, -2);
-                        return [4 /*yield*/, this.client.getExtendedPubkey(false, accountPath)];
-                    case 3:
-                        accountXpub = _a.sent();
-                        _a.label = 4;
-                    case 4: return [4 /*yield*/, this.setInput(psbt, i, arg.inputs[i], pathElems, accountType, masterFp, arg.sigHashType)];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6:
-                        i++;
-                        return [3 /*break*/, 2];
-                    case 7:
-                        outputsConcat = Buffer.from(arg.outputScriptHex, "hex");
-                        outputsBufferReader = new BufferReader(outputsConcat);
-                        outputCount = outputsBufferReader.readVarInt();
-                        psbt.setGlobalOutputCount(outputCount);
-                        return [4 /*yield*/, this.outputScriptAt(accountPath, accountType, arg.changePath)];
-                    case 8:
-                        changeData = _a.sent();
-                        changeFound = !changeData;
-                        for (i = 0; i < outputCount; i++) {
-                            amount = Number(outputsBufferReader.readUInt64());
-                            outputScript = outputsBufferReader.readVarSlice();
-                            psbt.setOutputAmount(i, amount);
-                            psbt.setOutputScript(i, outputScript);
-                            isChange = changeData && outputScript.equals(changeData === null || changeData === void 0 ? void 0 : changeData.cond.scriptPubKey);
-                            if (isChange) {
-                                changeFound = true;
-                                changePath = pathStringToArray(arg.changePath);
-                                pubkey = changeData.pubkey;
-                                accountType.setOwnOutput(i, changeData.cond, [pubkey], [changePath]);
-                            }
-                        }
-                        if (!changeFound) {
-                            throw new Error("Change script not found among outputs! " +
-                                (changeData === null || changeData === void 0 ? void 0 : changeData.cond.scriptPubKey.toString("hex")));
-                        }
-                        key = createKey(masterFp, accountPath, accountXpub);
-                        p = new WalletPolicy(accountType.getDescriptorTemplate(), key);
-                        // This is cheating, because it's not actually requested on the
-                        // device yet, but it will be, soonish.
-                        if (arg.onDeviceSignatureRequested)
-                            arg.onDeviceSignatureRequested();
-                        firstSigned = false;
-                        progressCallback = function () {
-                            if (!firstSigned) {
-                                firstSigned = true;
-                                arg.onDeviceSignatureGranted && arg.onDeviceSignatureGranted();
-                            }
-                            progress();
-                        };
-                        return [4 /*yield*/, this.signPsbt(psbt, p, progressCallback)];
-                    case 9:
-                        _a.sent();
-                        finalize(psbt);
-                        serializedTx = extract(psbt);
-                        return [2 /*return*/, serializedTx.toString("hex")];
+    createPaymentTransaction(arg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inputCount = arg.inputs.length;
+            if (inputCount == 0) {
+                throw Error("No inputs");
+            }
+            const psbt = new PsbtV2();
+            // The master fingerprint is needed when adding BIP32 derivation paths on
+            // the psbt.
+            const masterFp = yield this.client.getMasterFingerprint();
+            const accountType = accountTypeFromArg(arg, psbt, masterFp);
+            if (arg.lockTime != undefined) {
+                // The signer will assume locktime 0 if unset
+                psbt.setGlobalFallbackLocktime(arg.lockTime);
+            }
+            psbt.setGlobalInputCount(inputCount);
+            psbt.setGlobalPsbtVersion(2);
+            psbt.setGlobalTxVersion(2);
+            let notifyCount = 0;
+            const progress = () => {
+                if (!arg.onDeviceStreaming)
+                    return;
+                arg.onDeviceStreaming({
+                    total: 2 * inputCount,
+                    index: notifyCount,
+                    progress: ++notifyCount / (2 * inputCount),
+                });
+            };
+            let accountXpub = "";
+            let accountPath = [];
+            for (let i = 0; i < inputCount; i++) {
+                progress();
+                const pathElems = pathStringToArray(arg.associatedKeysets[i]);
+                if (accountXpub == "") {
+                    // We assume all inputs belong to the same account so we set
+                    // the account xpub and path based on the first input.
+                    accountPath = pathElems.slice(0, -2);
+                    accountXpub = yield this.client.getExtendedPubkey(false, accountPath);
                 }
-            });
+                yield this.setInput(psbt, i, arg.inputs[i], pathElems, accountType, masterFp, arg.sigHashType);
+            }
+            const outputsConcat = Buffer.from(arg.outputScriptHex, "hex");
+            const outputsBufferReader = new BufferReader(outputsConcat);
+            const outputCount = outputsBufferReader.readVarInt();
+            psbt.setGlobalOutputCount(outputCount);
+            const changeData = yield this.outputScriptAt(accountPath, accountType, arg.changePath);
+            // If the caller supplied a changePath, we must make sure there actually is
+            // a change output. If no change output found, we'll throw an error.
+            let changeFound = !changeData;
+            for (let i = 0; i < outputCount; i++) {
+                const amount = Number(outputsBufferReader.readUInt64());
+                const outputScript = outputsBufferReader.readVarSlice();
+                psbt.setOutputAmount(i, amount);
+                psbt.setOutputScript(i, outputScript);
+                // We won't know if we're paying to ourselves, because there's no
+                // information in arg to support multiple "change paths". One exception is
+                // if there are multiple outputs to the change address.
+                const isChange = changeData && outputScript.equals(changeData === null || changeData === void 0 ? void 0 : changeData.cond.scriptPubKey);
+                if (isChange) {
+                    changeFound = true;
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const changePath = pathStringToArray(arg.changePath);
+                    const pubkey = changeData.pubkey;
+                    accountType.setOwnOutput(i, changeData.cond, [pubkey], [changePath]);
+                }
+            }
+            if (!changeFound) {
+                throw new Error("Change script not found among outputs! " +
+                    (changeData === null || changeData === void 0 ? void 0 : changeData.cond.scriptPubKey.toString("hex")));
+            }
+            const key = createKey(masterFp, accountPath, accountXpub);
+            const p = new WalletPolicy(accountType.getDescriptorTemplate(), key);
+            // This is cheating, because it's not actually requested on the
+            // device yet, but it will be, soonish.
+            if (arg.onDeviceSignatureRequested)
+                arg.onDeviceSignatureRequested();
+            let firstSigned = false;
+            // This callback will be called once for each signature yielded.
+            const progressCallback = () => {
+                if (!firstSigned) {
+                    firstSigned = true;
+                    arg.onDeviceSignatureGranted && arg.onDeviceSignatureGranted();
+                }
+                progress();
+            };
+            yield this.signPsbt(psbt, p, progressCallback);
+            finalize(psbt);
+            const serializedTx = extract(psbt);
+            return serializedTx.toString("hex");
         });
-    };
+    }
     /**
      * Calculates an output script along with public key and possible redeemScript
      * from a path and accountType. The accountPath must be a prefix of path.
@@ -306,75 +236,60 @@ var BtcNew = /** @class */ (function () {
      * wrapped p2wpkh), and pubkey at provided path. The values of these three
      * properties depend on the accountType used.
      */
-    BtcNew.prototype.outputScriptAt = function (accountPath, accountType, path) {
-        return __awaiter(this, void 0, void 0, function () {
-            var pathElems, i, xpub, pubkey, cond;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!path)
-                            return [2 /*return*/, undefined];
-                        pathElems = pathStringToArray(path);
-                        // Make sure path is in our account, otherwise something fishy is probably
-                        // going on.
-                        for (i = 0; i < accountPath.length; i++) {
-                            if (accountPath[i] != pathElems[i]) {
-                                throw new Error("Path ".concat(path, " not in account ").concat(pathArrayToString(accountPath)));
-                            }
-                        }
-                        return [4 /*yield*/, this.client.getExtendedPubkey(false, pathElems)];
-                    case 1:
-                        xpub = _a.sent();
-                        pubkey = pubkeyFromXpub(xpub);
-                        cond = accountType.spendingCondition([pubkey]);
-                        return [2 /*return*/, { cond: cond, pubkey: pubkey }];
+    outputScriptAt(accountPath, accountType, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!path)
+                return undefined;
+            const pathElems = pathStringToArray(path);
+            // Make sure path is in our account, otherwise something fishy is probably
+            // going on.
+            for (let i = 0; i < accountPath.length; i++) {
+                if (accountPath[i] != pathElems[i]) {
+                    throw new Error(`Path ${path} not in account ${pathArrayToString(accountPath)}`);
                 }
-            });
+            }
+            const xpub = yield this.client.getExtendedPubkey(false, pathElems);
+            const pubkey = pubkeyFromXpub(xpub);
+            const cond = accountType.spendingCondition([pubkey]);
+            return { cond, pubkey };
         });
-    };
+    }
     /**
      * Adds relevant data about an input to the psbt. This includes sequence,
      * previous txid, output index, spent UTXO, redeem script for wrapped p2wpkh,
      * public key and its derivation path.
      */
-    BtcNew.prototype.setInput = function (psbt, i, input, pathElements, accountType, masterFP, sigHashType) {
-        return __awaiter(this, void 0, void 0, function () {
-            var inputTx, spentOutputIndex, redeemScript, sequence, inputTxBuffer, inputTxid, xpubBase58, pubkey, spentTxOutput, spendCondition, spentOutput;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        inputTx = input[0];
-                        spentOutputIndex = input[1];
-                        redeemScript = input[2] ? Buffer.from(input[2], "hex") : undefined;
-                        sequence = input[3];
-                        if (sequence != undefined) {
-                            psbt.setInputSequence(i, sequence);
-                        }
-                        if (sigHashType != undefined) {
-                            psbt.setInputSighashType(i, sigHashType);
-                        }
-                        inputTxBuffer = serializeTransaction(inputTx, true);
-                        inputTxid = crypto.hash256(inputTxBuffer);
-                        return [4 /*yield*/, this.client.getExtendedPubkey(false, pathElements)];
-                    case 1:
-                        xpubBase58 = _a.sent();
-                        pubkey = pubkeyFromXpub(xpubBase58);
-                        if (!inputTx.outputs)
-                            throw Error("Missing outputs array in transaction to sign");
-                        spentTxOutput = inputTx.outputs[spentOutputIndex];
-                        spendCondition = {
-                            scriptPubKey: spentTxOutput.script,
-                            redeemScript: redeemScript
-                        };
-                        spentOutput = { cond: spendCondition, amount: spentTxOutput.amount };
-                        accountType.setInput(i, inputTxBuffer, spentOutput, [pubkey], [pathElements]);
-                        psbt.setInputPreviousTxId(i, inputTxid);
-                        psbt.setInputOutputIndex(i, spentOutputIndex);
-                        return [2 /*return*/];
-                }
-            });
+    setInput(psbt, i, input, pathElements, accountType, masterFP, sigHashType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inputTx = input[0];
+            const spentOutputIndex = input[1];
+            // redeemScript will be null for wrapped p2wpkh, we need to create it
+            // ourselves. But if set, it should be used.
+            const redeemScript = input[2] ? Buffer.from(input[2], "hex") : undefined;
+            const sequence = input[3];
+            if (sequence != undefined) {
+                psbt.setInputSequence(i, sequence);
+            }
+            if (sigHashType != undefined) {
+                psbt.setInputSighashType(i, sigHashType);
+            }
+            const inputTxBuffer = serializeTransaction(inputTx, true);
+            const inputTxid = crypto.hash256(inputTxBuffer);
+            const xpubBase58 = yield this.client.getExtendedPubkey(false, pathElements);
+            const pubkey = pubkeyFromXpub(xpubBase58);
+            if (!inputTx.outputs)
+                throw Error("Missing outputs array in transaction to sign");
+            const spentTxOutput = inputTx.outputs[spentOutputIndex];
+            const spendCondition = {
+                scriptPubKey: spentTxOutput.script,
+                redeemScript: redeemScript,
+            };
+            const spentOutput = { cond: spendCondition, amount: spentTxOutput.amount };
+            accountType.setInput(i, inputTxBuffer, spentOutput, [pubkey], [pathElements]);
+            psbt.setInputPreviousTxId(i, inputTxid);
+            psbt.setInputOutputIndex(i, spentOutputIndex);
         });
-    };
+    }
     /**
      * This implements the "Signer" role of the BIP370 transaction signing
      * process.
@@ -384,40 +299,30 @@ var BtcNew = /** @class */ (function () {
      * comment in-line. The signatures returned from the hardware device is added
      * to the appropriate input fields of the PSBT.
      */
-    BtcNew.prototype.signPsbt = function (psbt, walletPolicy, progressCallback) {
-        return __awaiter(this, void 0, void 0, function () {
-            var sigs;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.client.signPsbt(psbt, walletPolicy, Buffer.alloc(32, 0), progressCallback)];
-                    case 1:
-                        sigs = _a.sent();
-                        sigs.forEach(function (v, k) {
-                            // Note: Looking at BIP32 derivation does not work in the generic case,
-                            // since some inputs might not have a BIP32-derived pubkey.
-                            var pubkeys = psbt.getInputKeyDatas(k, psbtIn.BIP32_DERIVATION);
-                            var pubkey;
-                            if (pubkeys.length != 1) {
-                                // No legacy BIP32_DERIVATION, assume we're using taproot.
-                                pubkey = psbt.getInputKeyDatas(k, psbtIn.TAP_BIP32_DERIVATION);
-                                if (pubkey.length == 0) {
-                                    throw Error("Missing pubkey derivation for input ".concat(k));
-                                }
-                                psbt.setInputTapKeySig(k, v);
-                            }
-                            else {
-                                pubkey = pubkeys[0];
-                                psbt.setInputPartialSig(k, pubkey, v);
-                            }
-                        });
-                        return [2 /*return*/];
+    signPsbt(psbt, walletPolicy, progressCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sigs = yield this.client.signPsbt(psbt, walletPolicy, Buffer.alloc(32, 0), progressCallback);
+            sigs.forEach((v, k) => {
+                // Note: Looking at BIP32 derivation does not work in the generic case,
+                // since some inputs might not have a BIP32-derived pubkey.
+                const pubkeys = psbt.getInputKeyDatas(k, psbtIn.BIP32_DERIVATION);
+                let pubkey;
+                if (pubkeys.length != 1) {
+                    // No legacy BIP32_DERIVATION, assume we're using taproot.
+                    pubkey = psbt.getInputKeyDatas(k, psbtIn.TAP_BIP32_DERIVATION);
+                    if (pubkey.length == 0) {
+                        throw Error(`Missing pubkey derivation for input ${k}`);
+                    }
+                    psbt.setInputTapKeySig(k, v);
+                }
+                else {
+                    pubkey = pubkeys[0];
+                    psbt.setInputPartialSig(k, pubkey, v);
                 }
             });
         });
-    };
-    return BtcNew;
-}());
-export default BtcNew;
+    }
+}
 function descrTemplFrom(addressFormat) {
     if (addressFormat == "legacy")
         return "pkh(@0)";
@@ -459,17 +364,15 @@ function accountTypeFromArg(arg, psbt, masterFp) {
 */
 function isPathNormal(path) {
     //path is not deepest hardened node of a standard path or deeper, use BtcOld
-    var h = 0x80000000; //HARDENED from bip32
-    var pathElems = pathStringToArray(path);
-    var hard = function (n) { return n >= h; };
-    var soft = function (n) { return n === undefined || n < h; };
-    var change = function (n) {
-        return n === undefined || n === 0 || n === 1;
-    };
+    const h = 0x80000000; //HARDENED from bip32
+    const pathElems = pathStringToArray(path);
+    const hard = (n) => n >= h;
+    const soft = (n) => n === undefined || n < h;
+    const change = (n) => n === undefined || n === 0 || n === 1;
     if (pathElems.length >= 3 &&
         pathElems.length <= 5 &&
-        [44 + h, 49 + h, 84 + h, 86 + h].some(function (v) { return v == pathElems[0]; }) &&
-        [0 + h, 1 + h].some(function (v) { return v == pathElems[1]; }) &&
+        [44 + h, 49 + h, 84 + h, 86 + h].some((v) => v == pathElems[0]) &&
+        [0 + h, 1 + h].some((v) => v == pathElems[1]) &&
         hard(pathElems[2]) &&
         change(pathElems[3]) &&
         soft(pathElems[4])) {
@@ -478,7 +381,7 @@ function isPathNormal(path) {
     if (pathElems.length >= 4 &&
         pathElems.length <= 6 &&
         48 + h == pathElems[0] &&
-        [0 + h, 1 + h].some(function (v) { return v == pathElems[1]; }) &&
+        [0 + h, 1 + h].some((v) => v == pathElems[1]) &&
         hard(pathElems[2]) &&
         hard(pathElems[3]) &&
         change(pathElems[4]) &&