@airgap/bitcoin 0.13.45-beta.3 → 0.13.45-beta.4

package/v0/protocol/BitcoinSegwitProtocol.js

@@ -1,4 +1,19 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -15,40 +30,75 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+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 __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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitcoinSegwitProtocol = void 0;
-const index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
-const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-const index_2 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0/index");
-const bs58check = __importStar(require("@airgap/coinlib-core/dependencies/src/bs58check-2.1.2"));
-const ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
-const bitcoinJS = __importStar(require("bitcoinjs-lib"));
-const BitcoinProtocol_1 = require("./BitcoinProtocol");
-const BitcoinProtocolOptions_1 = require("./BitcoinProtocolOptions");
-const BitcoinSegwitAddress_1 = require("./BitcoinSegwitAddress");
-const bip32_1 = require("bip32");
-const secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
-const DUST_AMOUNT = 50;
+var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var index_2 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0/index");
+var bs58check = __importStar(require("@airgap/coinlib-core/dependencies/src/bs58check-2.1.2"));
+var ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
+var bitcoinJS = __importStar(require("bitcoinjs-lib"));
+var BitcoinProtocol_1 = require("./BitcoinProtocol");
+var BitcoinProtocolOptions_1 = require("./BitcoinProtocolOptions");
+var BitcoinSegwitAddress_1 = require("./BitcoinSegwitAddress");
+var bip32_1 = require("bip32");
+var secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
+var DUST_AMOUNT = 50;
 // This function handles arrays and objects
 function eachRecursive(obj) {
     for (var k in obj) {
@@ -62,352 +112,437 @@ function eachRecursive(obj) {
     return obj;
 }
 // https://github.com/satoshilabs/slips/blob/master/slip-0132.md
-class ExtendedPublicKey {
-    constructor(extendedPublicKey) {
+var ExtendedPublicKey = /** @class */ (function () {
+    function ExtendedPublicKey(extendedPublicKey) {
         this.rawKey = bs58check.decode(extendedPublicKey).slice(4);
     }
-    toXpub() {
+    ExtendedPublicKey.prototype.toXpub = function () {
         return this.addPrefix('0488b21e');
-    }
-    toYPub() {
+    };
+    ExtendedPublicKey.prototype.toYPub = function () {
         return this.addPrefix('049d7cb2');
-    }
-    toZPub() {
+    };
+    ExtendedPublicKey.prototype.toZPub = function () {
         return this.addPrefix('04b24746');
-    }
-    addPrefix(prefix) {
-        const data = Buffer.concat([Buffer.from(prefix, 'hex'), this.rawKey]);
+    };
+    ExtendedPublicKey.prototype.addPrefix = function (prefix) {
+        var data = Buffer.concat([Buffer.from(prefix, 'hex'), this.rawKey]);
         return bs58check.encode(data);
+    };
+    return ExtendedPublicKey;
+}());
+var BitcoinSegwitProtocol = /** @class */ (function (_super) {
+    __extends(BitcoinSegwitProtocol, _super);
+    function BitcoinSegwitProtocol(options) {
+        if (options === void 0) { options = new BitcoinProtocolOptions_1.BitcoinProtocolOptions(); }
+        var _this = _super.call(this, options) || this;
+        _this.name = 'Bitcoin (Segwit)';
+        _this.identifier = ProtocolSymbols_1.MainProtocolSymbols.BTC_SEGWIT;
+        _this.standardDerivationPath = "m/84'/0'/0'";
+        _this.addressPlaceholder = 'bc1...';
+        _this.bip32 = (0, bip32_1.BIP32Factory)(secp256k1_1.default);
+        return _this;
     }
-}
-class BitcoinSegwitProtocol extends BitcoinProtocol_1.BitcoinProtocol {
-    constructor(options = new BitcoinProtocolOptions_1.BitcoinProtocolOptions()) {
-        super(options);
-        this.name = 'Bitcoin (Segwit)';
-        this.identifier = ProtocolSymbols_1.MainProtocolSymbols.BTC_SEGWIT;
-        this.standardDerivationPath = `m/84'/0'/0'`;
-        this.addressPlaceholder = 'bc1...';
-        this.bip32 = (0, bip32_1.BIP32Factory)(secp256k1_1.default);
-    }
-    async getPublicKeyFromHexSecret(secret, derivationPath) {
-        const bitcoinNode = this.bip32.fromSeed(Buffer.from(secret, 'hex'), this.options.network.extras.network);
-        const neutered = bitcoinNode.derivePath(derivationPath).neutered();
-        const zpub = new ExtendedPublicKey(neutered.toBase58()).toZPub();
-        return zpub;
-    }
-    async getPrivateKeyFromHexSecret(secret, derivationPath) {
-        if (!derivationPath) {
-            return this.bip32.fromSeed(Buffer.from(secret, 'hex'), this.options.network.extras.network);
-        }
-        const bitcoinNode = this.bip32.fromSeed(Buffer.from(secret, 'hex'), this.options.network.extras.network);
-        const privateKey = bitcoinNode.derivePath(derivationPath).privateKey;
-        if (!privateKey) {
-            throw new Error('No privatekey!');
-        }
-        return Buffer.from(privateKey).toString('hex');
-    }
-    async getExtendedPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
-        const secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
-        return this.getExtendedPrivateKeyFromHexSecret(secret, derivationPath);
-    }
-    async getExtendedPrivateKeyFromHexSecret(secret, derivationPath) {
-        const bitcoinNode = this.bip32.fromSeed(Buffer.from(secret, 'hex'), this.options.network.extras.network);
-        return bitcoinNode.derivePath(derivationPath).toBase58();
-    }
-    async getAddressFromPublicKey(publicKey, cursor) {
-        // broadcaster knows this (both broadcaster and signer)
-        const address = BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromAddress(this.bip32.fromBase58(publicKey, this.options.network.extras.network).toBase58());
-        return {
-            address: address.asString(),
-            cursor: { hasNext: false }
-        };
-    }
-    async getAddressesFromPublicKey(publicKey, cursor) {
-        return [await this.getAddressFromPublicKey(publicKey, cursor)];
-    }
-    async getAddressFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
-        const xpub = new ExtendedPublicKey(extendedPublicKey).toXpub();
-        // broadcaster knows this (both broadcaster and signer)
-        const keyPair = this.bip32
-            .fromBase58(xpub, this.options.network.extras.network)
-            .derive(visibilityDerivationIndex)
-            .derive(addressDerivationIndex);
-        const obj = bitcoinJS.payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey) });
-        const { address: addressRaw } = obj;
-        if (!addressRaw) {
-            throw new Error('could not generate address');
-        }
-        const address = BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromAddress(addressRaw);
-        return {
-            address: address.asString(),
-            cursor: { hasNext: false }
-        };
-    }
-    getAddressesFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressCount, offset) {
+    BitcoinSegwitProtocol.prototype.getPublicKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bitcoinNode, neutered, zpub;
+            return __generator(this, function (_a) {
+                bitcoinNode = this.bip32.fromSeed(Buffer.from(secret, 'hex'), this.options.network.extras.network);
+                neutered = bitcoinNode.derivePath(derivationPath).neutered();
+                zpub = new ExtendedPublicKey(neutered.toBase58()).toZPub();
+                return [2 /*return*/, zpub];
+            });
+        });
+    };
+    BitcoinSegwitProtocol.prototype.getPrivateKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bitcoinNode, privateKey;
+            return __generator(this, function (_a) {
+                if (!derivationPath) {
+                    return [2 /*return*/, this.bip32.fromSeed(Buffer.from(secret, 'hex'), this.options.network.extras.network)];
+                }
+                bitcoinNode = this.bip32.fromSeed(Buffer.from(secret, 'hex'), this.options.network.extras.network);
+                privateKey = bitcoinNode.derivePath(derivationPath).privateKey;
+                if (!privateKey) {
+                    throw new Error('No privatekey!');
+                }
+                return [2 /*return*/, Buffer.from(privateKey).toString('hex')];
+            });
+        });
+    };
+    BitcoinSegwitProtocol.prototype.getExtendedPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var secret;
+            return __generator(this, function (_a) {
+                secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
+                return [2 /*return*/, this.getExtendedPrivateKeyFromHexSecret(secret, derivationPath)];
+            });
+        });
+    };
+    BitcoinSegwitProtocol.prototype.getExtendedPrivateKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bitcoinNode;
+            return __generator(this, function (_a) {
+                bitcoinNode = this.bip32.fromSeed(Buffer.from(secret, 'hex'), this.options.network.extras.network);
+                return [2 /*return*/, bitcoinNode.derivePath(derivationPath).toBase58()];
+            });
+        });
+    };
+    BitcoinSegwitProtocol.prototype.getAddressFromPublicKey = function (publicKey, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                address = BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromAddress(this.bip32.fromBase58(publicKey, this.options.network.extras.network).toBase58());
+                return [2 /*return*/, {
+                        address: address.asString(),
+                        cursor: { hasNext: false }
+                    }];
+            });
+        });
+    };
+    BitcoinSegwitProtocol.prototype.getAddressesFromPublicKey = function (publicKey, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey, cursor)];
+                    case 1: return [2 /*return*/, [_a.sent()]];
+                }
+            });
+        });
+    };
+    BitcoinSegwitProtocol.prototype.getAddressFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var xpub, keyPair, obj, addressRaw, address;
+            return __generator(this, function (_a) {
+                xpub = new ExtendedPublicKey(extendedPublicKey).toXpub();
+                keyPair = this.bip32
+                    .fromBase58(xpub, this.options.network.extras.network)
+                    .derive(visibilityDerivationIndex)
+                    .derive(addressDerivationIndex);
+                obj = bitcoinJS.payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey) });
+                addressRaw = obj.address;
+                if (!addressRaw) {
+                    throw new Error('could not generate address');
+                }
+                address = BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromAddress(addressRaw);
+                return [2 /*return*/, {
+                        address: address.asString(),
+                        cursor: { hasNext: false }
+                    }];
+            });
+        });
+    };
+    BitcoinSegwitProtocol.prototype.getAddressesFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressCount, offset) {
         // broadcaster knows this (both broadcaster and signer)
-        const node = this.bip32.fromBase58(new ExtendedPublicKey(extendedPublicKey).toXpub(), this.options.network.extras.network);
-        const generatorArray = Array.from(new Array(addressCount), (x, i) => i + offset);
-        return Promise.all(generatorArray.map((x) => {
-            const keyPair = node.derive(visibilityDerivationIndex).derive(x);
-            const { address: addressRaw } = bitcoinJS.payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey) });
+        var node = this.bip32.fromBase58(new ExtendedPublicKey(extendedPublicKey).toXpub(), this.options.network.extras.network);
+        var generatorArray = Array.from(new Array(addressCount), function (x, i) { return i + offset; });
+        return Promise.all(generatorArray.map(function (x) {
+            var keyPair = node.derive(visibilityDerivationIndex).derive(x);
+            var addressRaw = bitcoinJS.payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey) }).address;
             if (!addressRaw) {
                 throw new Error('could not generate address');
             }
-            const address = BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromAddress(addressRaw);
+            var address = BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromAddress(addressRaw);
             return {
                 address: address.asString(),
                 cursor: { hasNext: false }
             };
         }));
-    }
-    async getTransactionDetails(unsignedTx) {
-        // out of public information (both broadcaster and signer)
-        const transaction = unsignedTx.transaction;
-        const decodedPSBT = bitcoinJS.Psbt.fromHex(transaction.psbt);
-        let feeCalculator = new bignumber_1.default(0);
-        for (const txIn of decodedPSBT.data.inputs) {
-            feeCalculator = feeCalculator.plus(new bignumber_1.default(txIn.witnessUtxo?.value ?? 0));
-        }
-        for (const txOut of decodedPSBT.txOutputs) {
-            feeCalculator = feeCalculator.minus(new bignumber_1.default(txOut.value));
-        }
-        const warnings = [];
-        const clonedPSBT = decodedPSBT.clone();
-        eachRecursive(clonedPSBT); // All buffers to hex string
-        // Amount is tricky for BTC. Full amount of inputs is always transferred, but usually a (big) part of the amount is sent back to the sender via change address. So it's not easy to determine what the amount is that the user intended to send.
-        const amount = (() => {
-            // If tx has only one output, this is the amount
-            if (decodedPSBT.txOutputs.length === 1) {
-                return new bignumber_1.default(decodedPSBT.txOutputs[0].value);
-            }
-            // If we can match one output to an exact amount that we add to the PSBT, this is our amount.
-            {
-                const unknownKeyVals = decodedPSBT.data.globalMap.unknownKeyVals;
-                if (unknownKeyVals) {
-                    const amountArray = unknownKeyVals.filter((kv) => kv.key.equals(Buffer.from('amount')));
-                    if (amountArray.length > 0) {
-                        return new bignumber_1.default(amountArray[0].value.toString()); // Buffer to number
-                    }
+    };
+    BitcoinSegwitProtocol.prototype.getTransactionDetails = function (unsignedTx) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var transaction, decodedPSBT, feeCalculator, _i, _c, txIn, _d, _e, txOut, warnings, clonedPSBT, amount;
+            return __generator(this, function (_f) {
+                transaction = unsignedTx.transaction;
+                decodedPSBT = bitcoinJS.Psbt.fromHex(transaction.psbt);
+                feeCalculator = new bignumber_1.default(0);
+                for (_i = 0, _c = decodedPSBT.data.inputs; _i < _c.length; _i++) {
+                    txIn = _c[_i];
+                    feeCalculator = feeCalculator.plus(new bignumber_1.default((_b = (_a = txIn.witnessUtxo) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 0));
                 }
-            }
-            // If tx has an output and we added a derivation path in the PSBT (in the wallet, prepareTransaction), we know that it is a change address and we ignore it.
-            let accumulated = new bignumber_1.default(0);
-            let useAccumulated = false;
-            decodedPSBT.data.outputs.forEach((outputKeyValues, index) => {
-                if (outputKeyValues.unknownKeyVals) {
-                    const derivationPaths = outputKeyValues.unknownKeyVals
-                        .filter((kv) => kv.key.equals(Buffer.from('dp')))
-                        .map((kv) => kv.value.toString());
-                    if (derivationPaths.length > 0) {
-                        // If one of the outputs has the derivation in the custom key/value map, we can use this to determine the amount.
-                        useAccumulated = true;
-                        return;
-                    }
+                for (_d = 0, _e = decodedPSBT.txOutputs; _d < _e.length; _d++) {
+                    txOut = _e[_d];
+                    feeCalculator = feeCalculator.minus(new bignumber_1.default(txOut.value));
                 }
-                const output = decodedPSBT.txOutputs[index];
-                accumulated = accumulated.plus(output.value);
+                warnings = [];
+                clonedPSBT = decodedPSBT.clone();
+                eachRecursive(clonedPSBT); // All buffers to hex string
+                amount = (function () {
+                    // If tx has only one output, this is the amount
+                    if (decodedPSBT.txOutputs.length === 1) {
+                        return new bignumber_1.default(decodedPSBT.txOutputs[0].value);
+                    }
+                    // If we can match one output to an exact amount that we add to the PSBT, this is our amount.
+                    {
+                        var unknownKeyVals = decodedPSBT.data.globalMap.unknownKeyVals;
+                        if (unknownKeyVals) {
+                            var amountArray = unknownKeyVals.filter(function (kv) { return kv.key.equals(Buffer.from('amount')); });
+                            if (amountArray.length > 0) {
+                                return new bignumber_1.default(amountArray[0].value.toString()); // Buffer to number
+                            }
+                        }
+                    }
+                    // If tx has an output and we added a derivation path in the PSBT (in the wallet, prepareTransaction), we know that it is a change address and we ignore it.
+                    var accumulated = new bignumber_1.default(0);
+                    var useAccumulated = false;
+                    decodedPSBT.data.outputs.forEach(function (outputKeyValues, index) {
+                        if (outputKeyValues.unknownKeyVals) {
+                            var derivationPaths = outputKeyValues.unknownKeyVals
+                                .filter(function (kv) { return kv.key.equals(Buffer.from('dp')); })
+                                .map(function (kv) { return kv.value.toString(); });
+                            if (derivationPaths.length > 0) {
+                                // If one of the outputs has the derivation in the custom key/value map, we can use this to determine the amount.
+                                useAccumulated = true;
+                                return;
+                            }
+                        }
+                        var output = decodedPSBT.txOutputs[index];
+                        accumulated = accumulated.plus(output.value);
+                    });
+                    if (useAccumulated) {
+                        return accumulated;
+                    }
+                    // If we cannot match anything above, we need to assume that the whole amount is being sent and the user has to check the outputs.
+                    return decodedPSBT.txOutputs
+                        .map(function (obj) { return new bignumber_1.default(obj.value); })
+                        .reduce(function (accumulator, currentValue) { return accumulator.plus(currentValue); });
+                })();
+                return [2 /*return*/, [
+                        {
+                            from: decodedPSBT.data.inputs.map(function (obj) {
+                                var _a, _b;
+                                return (_b = (_a = obj.bip32Derivation) === null || _a === void 0 ? void 0 : _a.map(function (el) {
+                                    return bitcoinJS.payments.p2wpkh({
+                                        pubkey: el.pubkey,
+                                        network: bitcoinJS.networks.bitcoin
+                                    }).address;
+                                }).join(' ')) !== null && _b !== void 0 ? _b : 'INVALID';
+                            }),
+                            to: decodedPSBT.txOutputs.map(function (obj) {
+                                return obj.address || "Script: ".concat(obj.script.toString('hex')) || 'unknown';
+                            }),
+                            amount: amount.toString(10),
+                            fee: feeCalculator.toString(10),
+                            protocolIdentifier: this.identifier,
+                            network: this.options.network,
+                            isInbound: false,
+                            transactionDetails: {
+                                // This is some unstructured data about the PSBT. This is shown in the UI as a JSON for advanced users.
+                                inputTx: eachRecursive(clonedPSBT.txInputs),
+                                outputTx: eachRecursive(clonedPSBT.txOutputs),
+                                inputData: clonedPSBT.data.inputs,
+                                outputData: clonedPSBT.data.outputs,
+                                PSBTVersion: clonedPSBT.version,
+                                PSBTLocktime: clonedPSBT.locktime,
+                                PSBTGlobalMap: clonedPSBT.data.globalMap,
+                                rawPSBT: unsignedTx.transaction
+                            },
+                            warnings: warnings
+                        }
+                    ]];
             });
-            if (useAccumulated) {
-                return accumulated;
-            }
-            // If we cannot match anything above, we need to assume that the whole amount is being sent and the user has to check the outputs.
-            return decodedPSBT.txOutputs
-                .map((obj) => new bignumber_1.default(obj.value))
-                .reduce((accumulator, currentValue) => accumulator.plus(currentValue));
-        })();
-        return [
-            {
-                from: decodedPSBT.data.inputs.map((obj) => obj.bip32Derivation
-                    ?.map((el) => bitcoinJS.payments.p2wpkh({
-                    pubkey: el.pubkey,
-                    network: bitcoinJS.networks.bitcoin
-                }).address)
-                    .join(' ') ?? 'INVALID'),
-                to: decodedPSBT.txOutputs.map((obj) => {
-                    return obj.address || `Script: ${obj.script.toString('hex')}` || 'unknown';
-                }),
-                amount: amount.toString(10),
-                fee: feeCalculator.toString(10),
-                protocolIdentifier: this.identifier,
-                network: this.options.network,
-                isInbound: false,
-                transactionDetails: {
-                    // This is some unstructured data about the PSBT. This is shown in the UI as a JSON for advanced users.
-                    inputTx: eachRecursive(clonedPSBT.txInputs),
-                    outputTx: eachRecursive(clonedPSBT.txOutputs),
-                    inputData: clonedPSBT.data.inputs,
-                    outputData: clonedPSBT.data.outputs,
-                    PSBTVersion: clonedPSBT.version,
-                    PSBTLocktime: clonedPSBT.locktime,
-                    PSBTGlobalMap: clonedPSBT.data.globalMap,
-                    rawPSBT: unsignedTx.transaction
-                },
-                warnings
-            }
-        ];
-    }
-    async getTransactionDetailsFromSigned(signedTx) {
-        return this.getTransactionDetails({ publicKey: '', transaction: { psbt: signedTx.transaction } });
-    }
-    async prepareTransactionFromExtendedPublicKey(extendedPublicKey, offset, recipients, values, fee, extras) {
-        if (!extras.masterFingerprint) {
-            throw new Error('MasterFingerprint not set!');
-        }
-        const wrappedValues = values.map((value) => new bignumber_1.default(value));
-        const wrappedFee = new bignumber_1.default(fee);
-        const transaction = {
-            ins: [],
-            outs: []
-        };
-        if (recipients.length !== wrappedValues.length) {
-            throw new Error('recipients do not match values');
-        }
-        const { data: utxos } = await index_1.default.get(`${this.options.network.extras.indexerApi}/api/v2/utxo/${extendedPublicKey}?confirmed=true`, {
-            responseType: 'json'
         });
-        if (utxos.length <= 0) {
-            throw new Error('not enough balance'); // no transactions found on those addresses, probably won't find anything in the next ones
-        }
-        const totalRequiredBalance = wrappedValues
-            .reduce((accumulator, currentValue) => accumulator.plus(currentValue))
-            .plus(wrappedFee);
-        let valueAccumulator = new bignumber_1.default(0);
-        const getPathIndexes = (path) => {
-            const result = path
-                .split('/')
-                .slice(-2)
-                .map((item) => parseInt(item))
-                .filter((item) => !isNaN(item));
-            if (result.length !== 2) {
-                throw new Error('Unexpected path format');
-            }
-            return [result[0], result[1]];
-        };
-        for (const utxo of utxos) {
-            valueAccumulator = valueAccumulator.plus(utxo.value);
-            const indexes = getPathIndexes(utxo.path);
-            const derivedAddress = (await this.getAddressFromExtendedPublicKey(extendedPublicKey, indexes[0], indexes[1])).address;
-            if (derivedAddress === utxo.address) {
-                transaction.ins.push({
-                    txId: utxo.txid,
-                    value: new bignumber_1.default(utxo.value).toString(10),
-                    vout: utxo.vout,
-                    address: utxo.address,
-                    derivationPath: utxo.path
-                });
-            }
-            else {
-                throw new Error('Invalid address returned from API');
-            }
-            if (valueAccumulator.isGreaterThanOrEqualTo(totalRequiredBalance)) {
-                break;
-            }
-        }
-        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
-            throw new Error('not enough balance 2');
-        }
-        for (let i = 0; i < recipients.length; i++) {
-            transaction.outs.push({
-                recipient: recipients[i],
-                isChange: false,
-                value: wrappedValues[i].toString(10)
-            });
-            valueAccumulator = valueAccumulator.minus(wrappedValues[i]);
-        }
-        const lastUsedInternalAddress = Math.max(-1, ...utxos
-            .map((utxo) => getPathIndexes(utxo.path))
-            .filter((indexes) => indexes[0] === 1)
-            .map((indexes) => indexes[1]));
-        // If the change is considered dust, the transaction will fail.
-        // Dust is a variable value around 300-600 satoshis, depending on the configuration.
-        // We set a low fee here to not block any transactions, but it might still fail due to "dust".
-        const changeValue = valueAccumulator.minus(wrappedFee);
-        if (changeValue.isGreaterThan(new bignumber_1.default(DUST_AMOUNT))) {
-            const changeAddressIndex = lastUsedInternalAddress + 1;
-            const derivedAddress = (await this.getAddressFromExtendedPublicKey(extendedPublicKey, 1, changeAddressIndex)).address;
-            transaction.outs.push({
-                recipient: derivedAddress,
-                isChange: true,
-                value: changeValue.toString(10),
-                derivationPath: `1/${changeAddressIndex}`
+    };
+    BitcoinSegwitProtocol.prototype.getTransactionDetailsFromSigned = function (signedTx) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getTransactionDetails({ publicKey: '', transaction: { psbt: signedTx.transaction } })];
             });
-        }
-        const psbt = new bitcoinJS.Psbt();
-        // We add the total amount of the transaction to the global map. This can be used to show the info in the "from-to" component after the transaction was signed.
-        psbt.addUnknownKeyValToGlobal({
-            key: Buffer.from('amount'),
-            value: Buffer.from(wrappedValues.reduce((accumulator, currentValue) => accumulator.plus(currentValue)).toString())
         });
-        const keyPair = this.bip32.fromBase58(new ExtendedPublicKey(extendedPublicKey).toXpub());
-        const replaceByFee = extras.replaceByFee ? true : false;
-        transaction.ins.forEach((tx) => {
-            const indexes = getPathIndexes(tx.derivationPath);
-            const childNode = keyPair.derivePath(indexes.join('/'));
-            const p2wpkh = bitcoinJS.payments.p2wpkh({ pubkey: Buffer.from(childNode.publicKey), network: this.options.network.extras.network });
-            const p2shOutput = p2wpkh.output;
-            if (!p2shOutput) {
-                throw new Error('no p2shOutput');
-            }
-            psbt.addInput({
-                hash: tx.txId,
-                index: tx.vout,
-                sequence: replaceByFee ? 0xfffffffd : undefined, // Needs to be at least 2 below max int value to be RBF
-                witnessUtxo: {
-                    script: p2shOutput,
-                    value: parseInt(tx.value)
-                },
-                bip32Derivation: [
-                    {
-                        masterFingerprint: Buffer.from(extras.masterFingerprint, 'hex'),
-                        pubkey: Buffer.from(childNode.publicKey),
-                        path: tx.derivationPath
-                    }
-                ]
+    };
+    BitcoinSegwitProtocol.prototype.prepareTransactionFromExtendedPublicKey = function (extendedPublicKey, offset, recipients, values, fee, extras) {
+        return __awaiter(this, void 0, void 0, function () {
+            var wrappedValues, wrappedFee, transaction, utxos, totalRequiredBalance, valueAccumulator, getPathIndexes, _i, utxos_1, utxo, indexes, derivedAddress, i, lastUsedInternalAddress, changeValue, changeAddressIndex, derivedAddress, psbt, keyPair, replaceByFee, tx;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!extras.masterFingerprint) {
+                            throw new Error('MasterFingerprint not set!');
+                        }
+                        wrappedValues = values.map(function (value) { return new bignumber_1.default(value); });
+                        wrappedFee = new bignumber_1.default(fee);
+                        transaction = {
+                            ins: [],
+                            outs: []
+                        };
+                        if (recipients.length !== wrappedValues.length) {
+                            throw new Error('recipients do not match values');
+                        }
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.extras.indexerApi, "/api/v2/utxo/").concat(extendedPublicKey, "?confirmed=true"), {
+                                responseType: 'json'
+                            })];
+                    case 1:
+                        utxos = (_a.sent()).data;
+                        if (utxos.length <= 0) {
+                            throw new Error('not enough balance'); // no transactions found on those addresses, probably won't find anything in the next ones
+                        }
+                        totalRequiredBalance = wrappedValues
+                            .reduce(function (accumulator, currentValue) { return accumulator.plus(currentValue); })
+                            .plus(wrappedFee);
+                        valueAccumulator = new bignumber_1.default(0);
+                        getPathIndexes = function (path) {
+                            var result = path
+                                .split('/')
+                                .slice(-2)
+                                .map(function (item) { return parseInt(item); })
+                                .filter(function (item) { return !isNaN(item); });
+                            if (result.length !== 2) {
+                                throw new Error('Unexpected path format');
+                            }
+                            return [result[0], result[1]];
+                        };
+                        _i = 0, utxos_1 = utxos;
+                        _a.label = 2;
+                    case 2:
+                        if (!(_i < utxos_1.length)) return [3 /*break*/, 5];
+                        utxo = utxos_1[_i];
+                        valueAccumulator = valueAccumulator.plus(utxo.value);
+                        indexes = getPathIndexes(utxo.path);
+                        return [4 /*yield*/, this.getAddressFromExtendedPublicKey(extendedPublicKey, indexes[0], indexes[1])];
+                    case 3:
+                        derivedAddress = (_a.sent()).address;
+                        if (derivedAddress === utxo.address) {
+                            transaction.ins.push({
+                                txId: utxo.txid,
+                                value: new bignumber_1.default(utxo.value).toString(10),
+                                vout: utxo.vout,
+                                address: utxo.address,
+                                derivationPath: utxo.path
+                            });
+                        }
+                        else {
+                            throw new Error('Invalid address returned from API');
+                        }
+                        if (valueAccumulator.isGreaterThanOrEqualTo(totalRequiredBalance)) {
+                            return [3 /*break*/, 5];
+                        }
+                        _a.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
+                            throw new Error('not enough balance 2');
+                        }
+                        for (i = 0; i < recipients.length; i++) {
+                            transaction.outs.push({
+                                recipient: recipients[i],
+                                isChange: false,
+                                value: wrappedValues[i].toString(10)
+                            });
+                            valueAccumulator = valueAccumulator.minus(wrappedValues[i]);
+                        }
+                        lastUsedInternalAddress = Math.max.apply(Math, __spreadArray([-1], utxos
+                            .map(function (utxo) { return getPathIndexes(utxo.path); })
+                            .filter(function (indexes) { return indexes[0] === 1; })
+                            .map(function (indexes) { return indexes[1]; }), false));
+                        changeValue = valueAccumulator.minus(wrappedFee);
+                        if (!changeValue.isGreaterThan(new bignumber_1.default(DUST_AMOUNT))) return [3 /*break*/, 7];
+                        changeAddressIndex = lastUsedInternalAddress + 1;
+                        return [4 /*yield*/, this.getAddressFromExtendedPublicKey(extendedPublicKey, 1, changeAddressIndex)];
+                    case 6:
+                        derivedAddress = (_a.sent()).address;
+                        transaction.outs.push({
+                            recipient: derivedAddress,
+                            isChange: true,
+                            value: changeValue.toString(10),
+                            derivationPath: "1/".concat(changeAddressIndex)
+                        });
+                        _a.label = 7;
+                    case 7:
+                        psbt = new bitcoinJS.Psbt();
+                        // We add the total amount of the transaction to the global map. This can be used to show the info in the "from-to" component after the transaction was signed.
+                        psbt.addUnknownKeyValToGlobal({
+                            key: Buffer.from('amount'),
+                            value: Buffer.from(wrappedValues.reduce(function (accumulator, currentValue) { return accumulator.plus(currentValue); }).toString())
+                        });
+                        keyPair = this.bip32.fromBase58(new ExtendedPublicKey(extendedPublicKey).toXpub());
+                        replaceByFee = extras.replaceByFee ? true : false;
+                        transaction.ins.forEach(function (tx) {
+                            var indexes = getPathIndexes(tx.derivationPath);
+                            var childNode = keyPair.derivePath(indexes.join('/'));
+                            var p2wpkh = bitcoinJS.payments.p2wpkh({ pubkey: Buffer.from(childNode.publicKey), network: _this.options.network.extras.network });
+                            var p2shOutput = p2wpkh.output;
+                            if (!p2shOutput) {
+                                throw new Error('no p2shOutput');
+                            }
+                            psbt.addInput({
+                                hash: tx.txId,
+                                index: tx.vout,
+                                sequence: replaceByFee ? 0xfffffffd : undefined,
+                                witnessUtxo: {
+                                    script: p2shOutput,
+                                    value: parseInt(tx.value)
+                                },
+                                bip32Derivation: [
+                                    {
+                                        masterFingerprint: Buffer.from(extras.masterFingerprint, 'hex'),
+                                        pubkey: Buffer.from(childNode.publicKey),
+                                        path: tx.derivationPath
+                                    }
+                                ]
+                            });
+                        });
+                        transaction.outs.forEach(function (out, index) {
+                            psbt.addOutput({ address: out.recipient, value: parseInt(out.value) });
+                            if (out.derivationPath) {
+                                // We add the derivation path of our change address to the key value map of the PSBT. This will allow us to later "filter" out this address when displaying the transaction info.
+                                psbt.addUnknownKeyValToOutput(index, {
+                                    key: Buffer.from('dp'),
+                                    value: Buffer.from(out.derivationPath, 'utf8')
+                                });
+                            }
+                        });
+                        tx = {
+                            psbt: psbt.toHex()
+                        };
+                        return [2 /*return*/, tx];
+                }
             });
         });
-        transaction.outs.forEach((out, index) => {
-            psbt.addOutput({ address: out.recipient, value: parseInt(out.value) });
-            if (out.derivationPath) {
-                // We add the derivation path of our change address to the key value map of the PSBT. This will allow us to later "filter" out this address when displaying the transaction info.
-                psbt.addUnknownKeyValToOutput(index, {
-                    key: Buffer.from('dp'),
-                    value: Buffer.from(out.derivationPath, 'utf8')
+    };
+    BitcoinSegwitProtocol.prototype.signWithExtendedPrivateKey = function (extendedPrivateKey, transaction /* RawBitcoinSegwitTransaction */) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rawBitcoinSegwitTx, bip32PK, decodedPSBT;
+            return __generator(this, function (_a) {
+                rawBitcoinSegwitTx = transaction;
+                bip32PK = this.bip32.fromBase58(extendedPrivateKey);
+                decodedPSBT = bitcoinJS.Psbt.fromHex(rawBitcoinSegwitTx.psbt);
+                decodedPSBT.data.inputs.forEach(function (input, index) {
+                    var _a;
+                    (_a = input.bip32Derivation) === null || _a === void 0 ? void 0 : _a.forEach(function (deriv) {
+                        try {
+                            // This uses the same logic to find child key as the "findWalletByFingerprintDerivationPathAndProtocolIdentifier" method in the Vault
+                            var cutoffFrom = deriv.path.lastIndexOf("'") || deriv.path.lastIndexOf('h');
+                            var childPath = deriv.path.substr(cutoffFrom + 2);
+                            var childNode_1 = bip32PK.derivePath(childPath);
+                            decodedPSBT.signInput(index, {
+                                publicKey: Buffer.from(childNode_1.publicKey),
+                                sign: function (hash, lowR) { return Buffer.from(childNode_1.sign(hash, lowR)); }
+                            });
+                            console.log("Signed input ".concat(index, " with path ").concat(deriv.path));
+                        }
+                        catch (e) {
+                            console.log("Error signing input ".concat(index), e);
+                        }
+                    });
                 });
-            }
+                return [2 /*return*/, decodedPSBT.toHex()];
+            });
         });
-        const tx = {
-            psbt: psbt.toHex()
-        };
-        return tx;
-    }
-    async signWithExtendedPrivateKey(extendedPrivateKey, transaction /* RawBitcoinSegwitTransaction */) {
-        const rawBitcoinSegwitTx = transaction;
-        const bip32PK = this.bip32.fromBase58(extendedPrivateKey);
-        const decodedPSBT = bitcoinJS.Psbt.fromHex(rawBitcoinSegwitTx.psbt);
-        decodedPSBT.data.inputs.forEach((input, index) => {
-            input.bip32Derivation?.forEach((deriv) => {
-                try {
-                    // This uses the same logic to find child key as the "findWalletByFingerprintDerivationPathAndProtocolIdentifier" method in the Vault
-                    const cutoffFrom = deriv.path.lastIndexOf("'") || deriv.path.lastIndexOf('h');
-                    const childPath = deriv.path.substr(cutoffFrom + 2);
-                    const childNode = bip32PK.derivePath(childPath);
-                    decodedPSBT.signInput(index, {
-                        publicKey: Buffer.from(childNode.publicKey),
-                        sign: (hash, lowR) => Buffer.from(childNode.sign(hash, lowR))
-                    });
-                    console.log(`Signed input ${index} with path ${deriv.path}`);
-                }
-                catch (e) {
-                    console.log(`Error signing input ${index}`, e);
-                }
+    };
+    BitcoinSegwitProtocol.prototype.broadcastTransaction = function (rawTransaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexTransaction;
+            return __generator(this, function (_a) {
+                hexTransaction = bitcoinJS.Psbt.fromHex(rawTransaction).finalizeAllInputs().extractTransaction().toHex();
+                return [2 /*return*/, _super.prototype.broadcastTransaction.call(this, hexTransaction)];
             });
         });
-        return decodedPSBT.toHex();
-    }
-    async broadcastTransaction(rawTransaction) {
-        const hexTransaction = bitcoinJS.Psbt.fromHex(rawTransaction).finalizeAllInputs().extractTransaction().toHex();
-        return super.broadcastTransaction(hexTransaction);
-    }
-}
+    };
+    return BitcoinSegwitProtocol;
+}(BitcoinProtocol_1.BitcoinProtocol));
 exports.BitcoinSegwitProtocol = BitcoinSegwitProtocol;
 //# sourceMappingURL=BitcoinSegwitProtocol.js.map