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

package/v1/protocol/BitcoinSegwitProtocol.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -15,47 +26,84 @@ 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.BitcoinSegwitProtocolImpl = void 0;
-exports.createBitcoinSegwitProtocol = createBitcoinSegwitProtocol;
-const coinlib_core_1 = require("@airgap/coinlib-core");
-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 errors_1 = require("@airgap/coinlib-core/errors");
-const crypto_1 = require("@airgap/crypto");
-const module_kit_1 = require("@airgap/module-kit");
-const bitcoin = __importStar(require("bitcoinjs-lib"));
-const BitcoinSegwitAddress_1 = require("../data/BitcoinSegwitAddress");
-const common_1 = require("../utils/common");
-const key_1 = require("../utils/key");
-const network_1 = require("../utils/network");
-const BitcoinProtocol_1 = require("./BitcoinProtocol");
-const bip32_1 = require("bip32");
-const secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
+exports.createBitcoinSegwitProtocol = exports.BitcoinSegwitProtocolImpl = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+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 errors_1 = require("@airgap/coinlib-core/errors");
+var crypto_1 = require("@airgap/crypto");
+var module_kit_1 = require("@airgap/module-kit");
+var bitcoin = __importStar(require("bitcoinjs-lib"));
+var BitcoinSegwitAddress_1 = require("../data/BitcoinSegwitAddress");
+var common_1 = require("../utils/common");
+var key_1 = require("../utils/key");
+var network_1 = require("../utils/network");
+var BitcoinProtocol_1 = require("./BitcoinProtocol");
+var bip32_1 = require("bip32");
+var secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
 // Implementation
-const DUST_AMOUNT = 50;
-class BitcoinSegwitProtocolImpl {
-    constructor(options = {}, bitcoinJS = bitcoin) {
+var DUST_AMOUNT = 50;
+var BitcoinSegwitProtocolImpl = /** @class */ (function () {
+    function BitcoinSegwitProtocolImpl(options, bitcoinJS) {
+        if (options === void 0) { options = {}; }
+        if (bitcoinJS === void 0) { bitcoinJS = bitcoin; }
+        var _a, _b, _c;
         this._isBitcoinProtocol = true;
         this._isBitcoinSegwitProtocol = true;
         this.bip32 = (0, bip32_1.BIP32Factory)(secp256k1_1.default);
@@ -66,7 +114,7 @@ class BitcoinSegwitProtocolImpl {
                 network: (0, network_1.getBitcoinJSNetwork)(this.options.network, bitcoinJS)
             }
         };
-        const keyConfiguration = {
+        var keyConfiguration = {
             xpriv: {
                 type: 'zprv'
             },
@@ -75,535 +123,741 @@ class BitcoinSegwitProtocolImpl {
             }
         };
         this.legacy = new BitcoinProtocol_1.BitcoinProtocolImpl(options, keyConfiguration);
-        this.metadata = {
-            ...this.legacy.metadata,
-            identifier: coinlib_core_1.MainProtocolSymbols.BTC_SEGWIT,
-            name: 'Bitcoin (Segwit)',
-            account: {
-                ...(this.legacy.metadata.account ?? {}),
-                standardDerivationPath: `m/84'/0'/0'`,
-                address: {
-                    ...(this.legacy.metadata.account?.address ?? {}),
-                    regex: '^(?:[13]{1}[a-km-zA-HJ-NP-Z1-9]{25,34}|bc1[a-z0-9]{39,59})$'
-                }
-            }
-        };
-    }
-    async getMetadata() {
-        return this.metadata;
-    }
-    async getAddressFromPublicKey(publicKey) {
-        switch (publicKey.type) {
-            case 'pub':
-                return this.getAddressFromNonExtendedPublicKey(publicKey);
-            case 'xpub':
-                return this.getAddressFromExtendedPublicKey(publicKey);
-            default:
-                (0, coinlib_core_1.assertNever)(publicKey);
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Public key type is not supported.');
-        }
-    }
-    async getAddressFromNonExtendedPublicKey(publicKey) {
-        const hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
-        const payment = this.bitcoinJS.lib.payments.p2wpkh({ pubkey: Buffer.from(hexPublicKey.value, 'hex') });
-        return BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromPayment(payment).asString();
-    }
-    async getAddressFromExtendedPublicKey(extendedPublicKey) {
-        const encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
-        const bip32 = this.bip32.fromBase58(encodedExtendedPublicKey.value, this.bitcoinJS.config.network);
-        return BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromBip32(bip32).asString();
-    }
-    async deriveFromExtendedPublicKey(publicKey, visibilityIndex, addressIndex) {
-        const encodedPublicKey = (0, key_1.convertExtendedPublicKey)(publicKey, { format: 'encoded', type: 'xpub' });
-        const derivedBip32 = this.bip32
-            .fromBase58(encodedPublicKey.value, this.bitcoinJS.config.network)
-            .derive(visibilityIndex)
-            .derive(addressIndex);
-        return (0, module_kit_1.newPublicKey)(Buffer.from(derivedBip32.publicKey).toString('hex'), 'hex');
-    }
-    async getDetailsFromTransaction(transaction, _publicKey) {
-        return this.getDetailsFromPSBT(transaction.psbt, _publicKey);
+        this.metadata = __assign(__assign({}, this.legacy.metadata), { identifier: coinlib_core_1.MainProtocolSymbols.BTC_SEGWIT, name: 'Bitcoin (Segwit)', account: __assign(__assign({}, ((_a = this.legacy.metadata.account) !== null && _a !== void 0 ? _a : {})), { standardDerivationPath: "m/84'/0'/0'", address: __assign(__assign({}, ((_c = (_b = this.legacy.metadata.account) === null || _b === void 0 ? void 0 : _b.address) !== null && _c !== void 0 ? _c : {})), { regex: '^(?:[13]{1}[a-km-zA-HJ-NP-Z1-9]{25,34}|bc1[a-z0-9]{39,59})$' }) }) });
     }
-    async getDetailsFromPSBT(psbt, publickey) {
-        const decodedPSBT = this.bitcoinJS.lib.Psbt.fromHex(psbt);
-        let fee = new bignumber_1.default(0);
-        for (const txIn of decodedPSBT.data.inputs) {
-            fee = fee.plus(new bignumber_1.default(txIn.witnessUtxo?.value ?? 0));
-        }
-        for (const txOut of decodedPSBT.txOutputs) {
-            fee = fee.minus(new bignumber_1.default(txOut.value));
-        }
-        const alerts = [];
-        const clonedPSBT = decodedPSBT.clone();
-        (0, common_1.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
-                    }
-                }
-            }
-            // 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;
-                    }
-                }
-                const output = decodedPSBT.txOutputs[index];
-                accumulated = accumulated.plus(output.value);
+    BitcoinSegwitProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.metadata];
             });
-            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));
-        })();
-        const changeAddressDatas = await Promise.all(decodedPSBT.data.outputs.map(async (obj, index) => {
-            let isChangeAddress = false;
-            let isOwned = false;
-            let addressIndex = 0;
-            const address = decodedPSBT.txOutputs[index].address;
-            const amount = decodedPSBT.txOutputs[index].value;
-            let ourGeneratedAddress;
-            if (obj.bip32Derivation) {
-                isChangeAddress = true;
-                const getIndexes = obj.bip32Derivation[0].path.split('/');
-                if (publickey.type === 'xpub') {
-                    const ourPublickey = await this.deriveFromExtendedPublicKey(publickey, 1, +getIndexes[getIndexes.length - 1]);
-                    ourGeneratedAddress = await this.getAddressFromPublicKey(ourPublickey);
-                }
-                else {
-                    ourGeneratedAddress = await this.getAddressFromNonExtendedPublicKey(publickey);
-                }
-                if (ourGeneratedAddress === address) {
-                    isOwned = true;
-                    addressIndex = +getIndexes[getIndexes.length - 1];
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (publicKey.type) {
+                    case 'pub':
+                        return [2 /*return*/, this.getAddressFromNonExtendedPublicKey(publicKey)];
+                    case 'xpub':
+                        return [2 /*return*/, this.getAddressFromExtendedPublicKey(publicKey)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(publicKey);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Public key type is not supported.');
                 }
-                for (let x = 0; x < 1000; x++) {
-                    const ourPublickey = await this.deriveFromExtendedPublicKey(publickey, 1, x);
-                    ourGeneratedAddress = await this.getAddressFromPublicKey(ourPublickey);
-                    if (ourGeneratedAddress === address) {
-                        isOwned = true;
-                        addressIndex = x;
-                        break;
-                    }
+                return [2 /*return*/];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getAddressFromNonExtendedPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexPublicKey, payment;
+            return __generator(this, function (_a) {
+                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+                payment = this.bitcoinJS.lib.payments.p2wpkh({ pubkey: Buffer.from(hexPublicKey.value, 'hex') });
+                return [2 /*return*/, BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromPayment(payment).asString()];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getAddressFromExtendedPublicKey = function (extendedPublicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedExtendedPublicKey, bip32;
+            return __generator(this, function (_a) {
+                encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
+                bip32 = this.bip32.fromBase58(encodedExtendedPublicKey.value, this.bitcoinJS.config.network);
+                return [2 /*return*/, BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromBip32(bip32).asString()];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.deriveFromExtendedPublicKey = function (publicKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedPublicKey, derivedBip32;
+            return __generator(this, function (_a) {
+                encodedPublicKey = (0, key_1.convertExtendedPublicKey)(publicKey, { format: 'encoded', type: 'xpub' });
+                derivedBip32 = this.bip32
+                    .fromBase58(encodedPublicKey.value, this.bitcoinJS.config.network)
+                    .derive(visibilityIndex)
+                    .derive(addressIndex);
+                return [2 /*return*/, (0, module_kit_1.newPublicKey)(Buffer.from(derivedBip32.publicKey).toString('hex'), 'hex')];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, _publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getDetailsFromPSBT(transaction.psbt, _publicKey)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getDetailsFromPSBT = function (psbt, publickey) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var decodedPSBT, fee, _i, _c, txIn, _d, _e, txOut, alerts, clonedPSBT, amount, changeAddressDatas, changeAddressInfo;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        decodedPSBT = this.bitcoinJS.lib.Psbt.fromHex(psbt);
+                        fee = new bignumber_1.default(0);
+                        for (_i = 0, _c = decodedPSBT.data.inputs; _i < _c.length; _i++) {
+                            txIn = _c[_i];
+                            fee = fee.plus(new bignumber_1.default((_b = (_a = txIn.witnessUtxo) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 0));
+                        }
+                        for (_d = 0, _e = decodedPSBT.txOutputs; _d < _e.length; _d++) {
+                            txOut = _e[_d];
+                            fee = fee.minus(new bignumber_1.default(txOut.value));
+                        }
+                        alerts = [];
+                        clonedPSBT = decodedPSBT.clone();
+                        (0, common_1.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 [4 /*yield*/, Promise.all(decodedPSBT.data.outputs.map(function (obj, index) { return __awaiter(_this, void 0, void 0, function () {
+                                var isChangeAddress, isOwned, addressIndex, address, amount, ourGeneratedAddress, getIndexes, ourPublickey, x, ourPublickey, x, ourPublickey;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            isChangeAddress = false;
+                                            isOwned = false;
+                                            addressIndex = 0;
+                                            address = decodedPSBT.txOutputs[index].address;
+                                            amount = decodedPSBT.txOutputs[index].value;
+                                            if (!obj.bip32Derivation) return [3 /*break*/, 11];
+                                            isChangeAddress = true;
+                                            getIndexes = obj.bip32Derivation[0].path.split('/');
+                                            if (!(publickey.type === 'xpub')) return [3 /*break*/, 3];
+                                            return [4 /*yield*/, this.deriveFromExtendedPublicKey(publickey, 1, +getIndexes[getIndexes.length - 1])];
+                                        case 1:
+                                            ourPublickey = _a.sent();
+                                            return [4 /*yield*/, this.getAddressFromPublicKey(ourPublickey)];
+                                        case 2:
+                                            ourGeneratedAddress = _a.sent();
+                                            return [3 /*break*/, 5];
+                                        case 3: return [4 /*yield*/, this.getAddressFromNonExtendedPublicKey(publickey)];
+                                        case 4:
+                                            ourGeneratedAddress = _a.sent();
+                                            _a.label = 5;
+                                        case 5:
+                                            if (ourGeneratedAddress === address) {
+                                                isOwned = true;
+                                                addressIndex = +getIndexes[getIndexes.length - 1];
+                                            }
+                                            x = 0;
+                                            _a.label = 6;
+                                        case 6:
+                                            if (!(x < 1000)) return [3 /*break*/, 10];
+                                            return [4 /*yield*/, this.deriveFromExtendedPublicKey(publickey, 1, x)];
+                                        case 7:
+                                            ourPublickey = _a.sent();
+                                            return [4 /*yield*/, this.getAddressFromPublicKey(ourPublickey)];
+                                        case 8:
+                                            ourGeneratedAddress = _a.sent();
+                                            if (ourGeneratedAddress === address) {
+                                                isOwned = true;
+                                                addressIndex = x;
+                                                return [3 /*break*/, 10];
+                                            }
+                                            _a.label = 9;
+                                        case 9:
+                                            x++;
+                                            return [3 /*break*/, 6];
+                                        case 10: return [3 /*break*/, 16];
+                                        case 11:
+                                            if (!obj.unknownKeyVals) return [3 /*break*/, 16];
+                                            x = 0;
+                                            _a.label = 12;
+                                        case 12:
+                                            if (!(x < 1000)) return [3 /*break*/, 16];
+                                            isChangeAddress = true;
+                                            return [4 /*yield*/, this.deriveFromExtendedPublicKey(publickey, 1, x)];
+                                        case 13:
+                                            ourPublickey = _a.sent();
+                                            return [4 /*yield*/, this.getAddressFromPublicKey(ourPublickey)];
+                                        case 14:
+                                            ourGeneratedAddress = _a.sent();
+                                            if (ourGeneratedAddress === address) {
+                                                isOwned = true;
+                                                addressIndex = x;
+                                                return [3 /*break*/, 16];
+                                            }
+                                            _a.label = 15;
+                                        case 15:
+                                            x++;
+                                            return [3 /*break*/, 12];
+                                        case 16:
+                                            if (isChangeAddress && isOwned) {
+                                                alerts.push({
+                                                    type: 'success',
+                                                    title: {
+                                                        type: 'plain',
+                                                        value: ''
+                                                    },
+                                                    description: {
+                                                        type: 'plain',
+                                                        value: 'Note: your change address has been verified'
+                                                    },
+                                                    icon: undefined,
+                                                    actions: undefined
+                                                });
+                                            }
+                                            else if (isChangeAddress && !isOwned) {
+                                                alerts.push({
+                                                    type: 'warning',
+                                                    title: {
+                                                        type: 'plain',
+                                                        value: ''
+                                                    },
+                                                    description: {
+                                                        type: 'plain',
+                                                        value: 'Note: your change address has not been verified'
+                                                    },
+                                                    icon: undefined,
+                                                    actions: undefined
+                                                });
+                                            }
+                                            return [2 /*return*/, [
+                                                    address,
+                                                    {
+                                                        isChangeAddress: isChangeAddress,
+                                                        isOwned: isOwned,
+                                                        path: addressIndex === 0 ? '' : "m/84'/0'/0'/1/".concat(addressIndex),
+                                                        amount: amount
+                                                    }
+                                                ]];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        changeAddressDatas = _f.sent();
+                        changeAddressInfo = {};
+                        changeAddressDatas.forEach(function (changeAddressData) {
+                            changeAddressInfo[changeAddressData[0]] = changeAddressData[1];
+                        });
+                        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 _this.bitcoinJS.lib.payments.p2wpkh({
+                                                pubkey: el.pubkey,
+                                                network: _this.bitcoinJS.lib.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';
+                                    }),
+                                    isInbound: false,
+                                    amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
+                                    fee: (0, module_kit_1.newAmount)(fee, 'blockchain'),
+                                    network: this.options.network,
+                                    changeAddressInfo: changeAddressInfo,
+                                    uiAlerts: alerts,
+                                    json: {
+                                        // This is some unstructured data about the PSBT. This is shown in the UI as a JSON for advanced users.
+                                        inputTx: (0, common_1.eachRecursive)(clonedPSBT.txInputs),
+                                        outputTx: (0, common_1.eachRecursive)(clonedPSBT.txOutputs),
+                                        inputData: clonedPSBT.data.inputs,
+                                        outputData: clonedPSBT.data.outputs,
+                                        PSBTVersion: clonedPSBT.version,
+                                        PSBTLocktime: clonedPSBT.locktime,
+                                        PSBTGlobalMap: clonedPSBT.data.globalMap,
+                                        rawPSBT: psbt
+                                    }
+                                }
+                            ]];
                 }
-            }
-            else if (obj.unknownKeyVals) {
-                for (let x = 0; x < 1000; x++) {
-                    isChangeAddress = true;
-                    const ourPublickey = await this.deriveFromExtendedPublicKey(publickey, 1, x);
-                    ourGeneratedAddress = await this.getAddressFromPublicKey(ourPublickey);
-                    if (ourGeneratedAddress === address) {
-                        isOwned = true;
-                        addressIndex = x;
-                        break;
-                    }
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.verifyMessageWithPublicKey(message, signature, publicKey)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.encryptAsymmetricWithPublicKey(payload, publicKey)];
+            });
+        });
+    };
+    // Offline
+    BitcoinSegwitProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getCryptoConfiguration()];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bip32, privateKeyUint8, privateKey, publicKeyUint8, publicKey;
+            return __generator(this, function (_a) {
+                bip32 = this.derivativeToBip32Node(derivative);
+                privateKeyUint8 = bip32.privateKey;
+                if (privateKeyUint8 === undefined) {
+                    throw new Error('No private key!');
                 }
-            }
-            if (isChangeAddress && isOwned) {
-                alerts.push({
-                    type: 'success',
-                    title: {
-                        type: 'plain',
-                        value: ''
-                    },
-                    description: {
-                        type: 'plain',
-                        value: 'Note: your change address has been verified'
-                    },
-                    icon: undefined,
-                    actions: undefined
-                });
-            }
-            else if (isChangeAddress && !isOwned) {
-                alerts.push({
-                    type: 'warning',
-                    title: {
-                        type: 'plain',
-                        value: ''
-                    },
-                    description: {
-                        type: 'plain',
-                        value: 'Note: your change address has not been verified'
-                    },
-                    icon: undefined,
-                    actions: undefined
-                });
-            }
-            return [
-                address,
-                {
-                    isChangeAddress: isChangeAddress,
-                    isOwned: isOwned,
-                    path: addressIndex === 0 ? '' : `m/84'/0'/0'/1/${addressIndex}`,
-                    amount
+                privateKey = Buffer.from(privateKeyUint8);
+                publicKeyUint8 = bip32.publicKey;
+                publicKey = Buffer.from(publicKeyUint8);
+                return [2 /*return*/, {
+                        secretKey: (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex'),
+                        publicKey: (0, module_kit_1.newPublicKey)(publicKey.toString('hex'), 'hex')
+                    }];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getExtendedKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bip32;
+            return __generator(this, function (_a) {
+                bip32 = this.derivativeToBip32Node(derivative);
+                return [2 /*return*/, {
+                        secretKey: (0, module_kit_1.newExtendedSecretKey)(bip32.toBase58(), 'encoded'),
+                        publicKey: (0, key_1.convertExtendedPublicKey)((0, module_kit_1.newExtendedPublicKey)(bip32.neutered().toBase58(), 'encoded'), {
+                            format: 'encoded',
+                            type: 'zpub'
+                        })
+                    }];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.deriveFromExtendedSecretKey = function (extendedSecretKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedSecretKey, derivedBip32, privateKeyUint8, privateKey;
+            return __generator(this, function (_a) {
+                encodedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
+                derivedBip32 = this.bip32
+                    .fromBase58(encodedSecretKey.value, this.bitcoinJS.config.network)
+                    .derive(visibilityIndex)
+                    .derive(addressIndex);
+                privateKeyUint8 = derivedBip32.privateKey;
+                if (privateKeyUint8 === undefined) {
+                    throw new Error('No private key!');
                 }
-            ];
-        }));
-        const changeAddressInfo = {};
-        changeAddressDatas.forEach((changeAddressData) => {
-            changeAddressInfo[changeAddressData[0]] = changeAddressData[1];
-        });
-        return [
-            {
-                from: decodedPSBT.data.inputs.map((obj) => obj.bip32Derivation
-                    ?.map((el) => this.bitcoinJS.lib.payments.p2wpkh({
-                    pubkey: el.pubkey,
-                    network: this.bitcoinJS.lib.networks.bitcoin
-                }).address)
-                    .join(' ') ?? 'INVALID'),
-                to: decodedPSBT.txOutputs.map((obj) => {
-                    return obj.address || `Script: ${obj.script.toString('hex')}` || 'unknown';
-                }),
-                isInbound: false,
-                amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
-                fee: (0, module_kit_1.newAmount)(fee, 'blockchain'),
-                network: this.options.network,
-                changeAddressInfo,
-                uiAlerts: alerts,
-                json: {
-                    // This is some unstructured data about the PSBT. This is shown in the UI as a JSON for advanced users.
-                    inputTx: (0, common_1.eachRecursive)(clonedPSBT.txInputs),
-                    outputTx: (0, common_1.eachRecursive)(clonedPSBT.txOutputs),
-                    inputData: clonedPSBT.data.inputs,
-                    outputData: clonedPSBT.data.outputs,
-                    PSBTVersion: clonedPSBT.version,
-                    PSBTLocktime: clonedPSBT.locktime,
-                    PSBTGlobalMap: clonedPSBT.data.globalMap,
-                    rawPSBT: psbt
+                privateKey = Buffer.from(privateKeyUint8);
+                return [2 /*return*/, (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex')];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (secretKey.type) {
+                    case 'priv':
+                        return [2 /*return*/, this.signTransactionWithNonExtendedSecretKey(transaction, secretKey)];
+                    case 'xpriv':
+                        return [2 /*return*/, this.signTransactionWithExtendedSecretKey(transaction, secretKey)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(secretKey);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Secret key type not supported.');
                 }
-            }
-        ];
-    }
-    async verifyMessageWithPublicKey(message, signature, publicKey) {
-        return this.legacy.verifyMessageWithPublicKey(message, signature, publicKey);
-    }
-    async encryptAsymmetricWithPublicKey(payload, publicKey) {
-        return this.legacy.encryptAsymmetricWithPublicKey(payload, publicKey);
-    }
-    // Offline
-    async getCryptoConfiguration() {
-        return this.legacy.getCryptoConfiguration();
-    }
-    async getKeyPairFromDerivative(derivative) {
-        const bip32 = this.derivativeToBip32Node(derivative);
-        const privateKeyUint8 = bip32.privateKey;
-        if (privateKeyUint8 === undefined) {
-            throw new Error('No private key!');
-        }
-        const privateKey = Buffer.from(privateKeyUint8);
-        const publicKeyUint8 = bip32.publicKey;
-        const publicKey = Buffer.from(publicKeyUint8);
-        return {
-            secretKey: (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex'),
-            publicKey: (0, module_kit_1.newPublicKey)(publicKey.toString('hex'), 'hex')
-        };
-    }
-    async getExtendedKeyPairFromDerivative(derivative) {
-        const bip32 = this.derivativeToBip32Node(derivative);
-        return {
-            secretKey: (0, module_kit_1.newExtendedSecretKey)(bip32.toBase58(), 'encoded'),
-            publicKey: (0, key_1.convertExtendedPublicKey)((0, module_kit_1.newExtendedPublicKey)(bip32.neutered().toBase58(), 'encoded'), {
-                format: 'encoded',
-                type: 'zpub'
-            })
-        };
-    }
-    async deriveFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex) {
-        const encodedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
-        const derivedBip32 = this.bip32
-            .fromBase58(encodedSecretKey.value, this.bitcoinJS.config.network)
-            .derive(visibilityIndex)
-            .derive(addressIndex);
-        const privateKeyUint8 = derivedBip32.privateKey;
-        if (privateKeyUint8 === undefined) {
-            throw new Error('No private key!');
-        }
-        const privateKey = Buffer.from(privateKeyUint8);
-        return (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex');
-    }
-    async signTransactionWithSecretKey(transaction, secretKey) {
-        switch (secretKey.type) {
-            case 'priv':
-                return this.signTransactionWithNonExtendedSecretKey(transaction, secretKey);
-            case 'xpriv':
-                return this.signTransactionWithExtendedSecretKey(transaction, secretKey);
-            default:
-                (0, coinlib_core_1.assertNever)(secretKey);
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Secret key type not supported.');
-        }
-    }
-    async signTransactionWithNonExtendedSecretKey(transaction, secretKey) {
-        // No reference implementation in v0
-        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Sign with non extended secret key not supported (Segwit).');
-    }
-    async signTransactionWithExtendedSecretKey(transaction, extendedSecretKey) {
-        const encodedExtendedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
-        const bip32 = this.bip32.fromBase58(encodedExtendedSecretKey.value);
-        const decodedPSBT = this.bitcoinJS.lib.Psbt.fromHex(transaction.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 = bip32.derivePath(childPath);
-                    // Wrap publicKey as Buffer to match Signer interface
-                    decodedPSBT.signInput(index, {
-                        publicKey: Buffer.from(childNode.publicKey),
-                        sign: (hash, lowR) => Buffer.from(childNode.sign(hash, lowR))
+                return [2 /*return*/];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.signTransactionWithNonExtendedSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // No reference implementation in v0
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Sign with non extended secret key not supported (Segwit).');
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.signTransactionWithExtendedSecretKey = function (transaction, extendedSecretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedExtendedSecretKey, bip32, decodedPSBT;
+            return __generator(this, function (_a) {
+                encodedExtendedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
+                bip32 = this.bip32.fromBase58(encodedExtendedSecretKey.value);
+                decodedPSBT = this.bitcoinJS.lib.Psbt.fromHex(transaction.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 = bip32.derivePath(childPath);
+                            // Wrap publicKey as Buffer to match Signer interface
+                            decodedPSBT.signInput(index, {
+                                publicKey: Buffer.from(childNode_1.publicKey),
+                                sign: function (hash, lowR) { return Buffer.from(childNode_1.sign(hash, lowR)); }
+                            });
+                        }
+                        catch (e) { }
                     });
-                }
-                catch (e) { }
+                });
+                return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({ psbt: decodedPSBT.toHex() })];
             });
         });
-        return (0, module_kit_1.newSignedTransaction)({ psbt: decodedPSBT.toHex() });
-    }
-    async signMessageWithKeyPair(message, keyPair) {
-        return this.legacy.signMessageWithKeyPair(message, keyPair);
-    }
-    async decryptAsymmetricWithKeyPair(payload, keyPair) {
-        return this.legacy.decryptAsymmetricWithKeyPair(payload, keyPair);
-    }
-    async encryptAESWithSecretKey(payload, secretKey) {
-        return this.legacy.encryptAESWithSecretKey(payload, secretKey);
-    }
-    async decryptAESWithSecretKey(payload, secretKey) {
-        return this.legacy.decryptAESWithSecretKey(payload, secretKey);
-    }
+    };
+    BitcoinSegwitProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.signMessageWithKeyPair(message, keyPair)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.decryptAsymmetricWithKeyPair(payload, keyPair)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.encryptAESWithSecretKey(payload, secretKey)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.decryptAESWithSecretKey(payload, secretKey)];
+            });
+        });
+    };
     // Online
-    async getNetwork() {
-        return this.options.network;
-    }
-    async getTransactionsForPublicKey(publicKey, limit, cursor) {
-        return this.legacy.getTransactionsForPublicKey(publicKey, limit, cursor);
-    }
-    async getTransactionsForAddress(address, limit, cursor) {
-        return this.legacy.getTransactionsForAddress(address, limit, cursor);
-    }
-    async getTransactionsForAddresses(addresses, limit, cursor) {
-        return this.legacy.getTransactionsForAddresses(addresses, limit, cursor);
-    }
-    async getBalanceOfPublicKey(publicKey) {
-        return this.legacy.getBalanceOfPublicKey(publicKey);
-    }
-    async getBalanceOfAddress(address) {
-        return this.legacy.getBalanceOfAddress(address);
-    }
-    async getBalanceOfAddresses(addresses) {
-        return this.legacy.getBalanceOfAddresses(addresses);
-    }
-    async getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
-        return this.legacy.getTransactionMaxAmountWithPublicKey(publicKey, to, configuration);
-    }
-    async getTransactionFeeWithPublicKey(publicKey, details, configuration) {
-        return this.legacy.getTransactionFeeWithPublicKey(publicKey, details, configuration);
-    }
-    async prepareTransactionWithPublicKey(publicKey, details, configuration) {
-        switch (publicKey.type) {
-            case 'pub':
-                return this.prepareTransactionWithNonExtendedPublicKey(publicKey, details, configuration);
-            case 'xpub':
-                return this.prepareTransactionWithExtendedPublicKey(publicKey, details, configuration);
-            default:
-                (0, coinlib_core_1.assertNever)(publicKey);
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Unuspported public key type.');
-        }
-    }
-    async prepareTransactionWithNonExtendedPublicKey(publicKey, details, configuration) {
-        // No reference implementation in v0
-        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Prepare transaction with non extended public key not supported (Segwit).');
-    }
-    async prepareTransactionWithExtendedPublicKey(extendedPublicKey, details, configuration) {
-        if (configuration?.masterFingerprint === undefined) {
-            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.BITCOIN, 'Master fingerprint not set.');
-        }
-        let fee;
-        if (configuration?.fee !== undefined) {
-            fee = configuration.fee;
-        }
-        else {
-            const estimatedFee = await this.getTransactionFeeWithPublicKey(extendedPublicKey, details);
-            fee = estimatedFee.medium;
-        }
-        const wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(this.legacy.units).value);
-        const transaction = (0, module_kit_1.newUnsignedTransaction)({
-            ins: [],
-            outs: []
+    BitcoinSegwitProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network];
+            });
         });
-        const { data: utxos } = await index_1.default.get(`${this.options.network.indexerApi}/api/v2/utxo/${extendedPublicKey.value}?confirmed=true`, {
-            responseType: 'json'
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getTransactionsForPublicKey(publicKey, limit, cursor)];
+            });
         });
-        if (utxos.length <= 0) {
-            throw new errors_1.BalanceError(coinlib_core_1.Domain.BITCOIN, 'Not enough balance.'); // no transactions found on those addresses, probably won't find anything in the next ones
-        }
-        const totalRequiredBalance = details
-            .map(({ amount }) => new bignumber_1.default((0, module_kit_1.newAmount)(amount).blockchain(this.legacy.units).value))
-            .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 derivedPublicKey = await this.deriveFromExtendedPublicKey(extendedPublicKey, indexes[0], indexes[1]);
-            const derivedAddress = await this.getAddressFromPublicKey(derivedPublicKey);
-            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 < details.length; i++) {
-            const value = (0, module_kit_1.newAmount)(details[i].amount).blockchain(this.legacy.units).value;
-            transaction.outs.push({
-                recipient: details[i].to,
-                isChange: false,
-                value
-            });
-            valueAccumulator = valueAccumulator.minus(value);
-        }
-        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 derivedPublicKey = await this.deriveFromExtendedPublicKey(extendedPublicKey, 1, changeAddressIndex);
-            const derivedAddress = await this.getAddressFromPublicKey(derivedPublicKey);
-            transaction.outs.push({
-                recipient: derivedAddress,
-                isChange: true,
-                value: changeValue.toString(10),
-                derivationPath: `1/${changeAddressIndex}`
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getTransactionsForAddress(address, limit, cursor)];
             });
-        }
-        const psbt = new this.bitcoinJS.lib.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(details
-                .reduce((accumulator, next) => {
-                return accumulator.plus((0, module_kit_1.newAmount)(next.amount).blockchain(this.legacy.units).value);
-            }, new bignumber_1.default(0))
-                .toString())
-        });
-        const xpubExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
-        const keyPair = this.bip32.fromBase58(xpubExtendedPublicKey.value);
-        const replaceByFee = configuration?.replaceByFee ? true : false;
-        transaction.ins.forEach((tx) => {
-            const indexes = getPathIndexes(tx.derivationPath);
-            const childNode = keyPair.derivePath(indexes.join('/'));
-            const payment = this.bitcoinJS.lib.payments.p2wpkh({
-                pubkey: Buffer.from(childNode.publicKey),
-                network: this.bitcoinJS.config.network
-            });
-            const p2shOutput = payment.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, 10)
-                },
-                bip32Derivation: [
-                    {
-                        masterFingerprint: Buffer.from(configuration.masterFingerprint.value, 'hex'),
-                        pubkey: Buffer.from(childNode.publicKey),
-                        path: tx.derivationPath
-                    }
-                ]
-            });
-        });
-        transaction.outs.forEach((out, index) => {
-            psbt.addOutput({ address: out.recipient, value: parseInt(out.value, 10) });
-            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')
-                });
-            }
         });
-        return (0, module_kit_1.newUnsignedTransaction)({ psbt: psbt.toHex() });
-    }
-    async broadcastTransaction(transaction) {
-        const hexTransaction = this.bitcoinJS.lib.Psbt.fromHex(transaction.psbt).finalizeAllInputs().extractTransaction().toHex();
-        const { data } = await index_1.default.post(`${this.options.network.indexerApi}/api/v2/sendtx/`, hexTransaction);
-        return data.result;
-    }
-    // Custom
-    convertCryptoDerivative(derivative) {
-        const hexNode = (0, crypto_1.encodeDerivative)('hex', {
-            ...derivative,
-            secretKey: `00${derivative.secretKey}`
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionsForAddresses = function (addresses, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getTransactionsForAddresses(addresses, limit, cursor)];
+            });
         });
-        const extendedSecretKey = {
+    };
+    BitcoinSegwitProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getBalanceOfPublicKey(publicKey)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getBalanceOfAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getBalanceOfAddress(address)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getBalanceOfAddresses(addresses)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getTransactionMaxAmountWithPublicKey(publicKey, to, configuration)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getTransactionFeeWithPublicKey(publicKey, details, configuration)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (publicKey.type) {
+                    case 'pub':
+                        return [2 /*return*/, this.prepareTransactionWithNonExtendedPublicKey(publicKey, details, configuration)];
+                    case 'xpub':
+                        return [2 /*return*/, this.prepareTransactionWithExtendedPublicKey(publicKey, details, configuration)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(publicKey);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Unuspported public key type.');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.prepareTransactionWithNonExtendedPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // No reference implementation in v0
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Prepare transaction with non extended public key not supported (Segwit).');
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.prepareTransactionWithExtendedPublicKey = function (extendedPublicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fee, estimatedFee, wrappedFee, transaction, utxos, totalRequiredBalance, valueAccumulator, getPathIndexes, _i, utxos_1, utxo, indexes, derivedPublicKey, derivedAddress, i, value, lastUsedInternalAddress, changeValue, changeAddressIndex, derivedPublicKey, derivedAddress, psbt, xpubExtendedPublicKey, keyPair, replaceByFee;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if ((configuration === null || configuration === void 0 ? void 0 : configuration.masterFingerprint) === undefined) {
+                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.BITCOIN, 'Master fingerprint not set.');
+                        }
+                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 1];
+                        fee = configuration.fee;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.getTransactionFeeWithPublicKey(extendedPublicKey, details)];
+                    case 2:
+                        estimatedFee = _a.sent();
+                        fee = estimatedFee.medium;
+                        _a.label = 3;
+                    case 3:
+                        wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(this.legacy.units).value);
+                        transaction = (0, module_kit_1.newUnsignedTransaction)({
+                            ins: [],
+                            outs: []
+                        });
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.indexerApi, "/api/v2/utxo/").concat(extendedPublicKey.value, "?confirmed=true"), {
+                                responseType: 'json'
+                            })];
+                    case 4:
+                        utxos = (_a.sent()).data;
+                        if (utxos.length <= 0) {
+                            throw new errors_1.BalanceError(coinlib_core_1.Domain.BITCOIN, 'Not enough balance.'); // no transactions found on those addresses, probably won't find anything in the next ones
+                        }
+                        totalRequiredBalance = details
+                            .map(function (_a) {
+                            var amount = _a.amount;
+                            return new bignumber_1.default((0, module_kit_1.newAmount)(amount).blockchain(_this.legacy.units).value);
+                        })
+                            .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 = 5;
+                    case 5:
+                        if (!(_i < utxos_1.length)) return [3 /*break*/, 9];
+                        utxo = utxos_1[_i];
+                        valueAccumulator = valueAccumulator.plus(utxo.value);
+                        indexes = getPathIndexes(utxo.path);
+                        return [4 /*yield*/, this.deriveFromExtendedPublicKey(extendedPublicKey, indexes[0], indexes[1])];
+                    case 6:
+                        derivedPublicKey = _a.sent();
+                        return [4 /*yield*/, this.getAddressFromPublicKey(derivedPublicKey)];
+                    case 7:
+                        derivedAddress = _a.sent();
+                        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*/, 9];
+                        }
+                        _a.label = 8;
+                    case 8:
+                        _i++;
+                        return [3 /*break*/, 5];
+                    case 9:
+                        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
+                            throw new Error('not enough balance 2');
+                        }
+                        for (i = 0; i < details.length; i++) {
+                            value = (0, module_kit_1.newAmount)(details[i].amount).blockchain(this.legacy.units).value;
+                            transaction.outs.push({
+                                recipient: details[i].to,
+                                isChange: false,
+                                value: value
+                            });
+                            valueAccumulator = valueAccumulator.minus(value);
+                        }
+                        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*/, 12];
+                        changeAddressIndex = lastUsedInternalAddress + 1;
+                        return [4 /*yield*/, this.deriveFromExtendedPublicKey(extendedPublicKey, 1, changeAddressIndex)];
+                    case 10:
+                        derivedPublicKey = _a.sent();
+                        return [4 /*yield*/, this.getAddressFromPublicKey(derivedPublicKey)];
+                    case 11:
+                        derivedAddress = _a.sent();
+                        transaction.outs.push({
+                            recipient: derivedAddress,
+                            isChange: true,
+                            value: changeValue.toString(10),
+                            derivationPath: "1/".concat(changeAddressIndex)
+                        });
+                        _a.label = 12;
+                    case 12:
+                        psbt = new this.bitcoinJS.lib.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(details
+                                .reduce(function (accumulator, next) {
+                                return accumulator.plus((0, module_kit_1.newAmount)(next.amount).blockchain(_this.legacy.units).value);
+                            }, new bignumber_1.default(0))
+                                .toString())
+                        });
+                        xpubExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
+                        keyPair = this.bip32.fromBase58(xpubExtendedPublicKey.value);
+                        replaceByFee = (configuration === null || configuration === void 0 ? void 0 : configuration.replaceByFee) ? true : false;
+                        transaction.ins.forEach(function (tx) {
+                            var indexes = getPathIndexes(tx.derivationPath);
+                            var childNode = keyPair.derivePath(indexes.join('/'));
+                            var payment = _this.bitcoinJS.lib.payments.p2wpkh({
+                                pubkey: Buffer.from(childNode.publicKey),
+                                network: _this.bitcoinJS.config.network
+                            });
+                            var p2shOutput = payment.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, 10)
+                                },
+                                bip32Derivation: [
+                                    {
+                                        masterFingerprint: Buffer.from(configuration.masterFingerprint.value, 'hex'),
+                                        pubkey: Buffer.from(childNode.publicKey),
+                                        path: tx.derivationPath
+                                    }
+                                ]
+                            });
+                        });
+                        transaction.outs.forEach(function (out, index) {
+                            psbt.addOutput({ address: out.recipient, value: parseInt(out.value, 10) });
+                            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')
+                                });
+                            }
+                        });
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({ psbt: psbt.toHex() })];
+                }
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexTransaction, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        hexTransaction = this.bitcoinJS.lib.Psbt.fromHex(transaction.psbt).finalizeAllInputs().extractTransaction().toHex();
+                        return [4 /*yield*/, index_1.default.post("".concat(this.options.network.indexerApi, "/api/v2/sendtx/"), hexTransaction)];
+                    case 1:
+                        data = (_a.sent()).data;
+                        return [2 /*return*/, data.result];
+                }
+            });
+        });
+    };
+    // Custom
+    BitcoinSegwitProtocolImpl.prototype.convertCryptoDerivative = function (derivative) {
+        var hexNode = (0, crypto_1.encodeDerivative)('hex', __assign(__assign({}, derivative), { secretKey: "00".concat(derivative.secretKey) }));
+        var extendedSecretKey = {
             type: 'xpriv',
             format: 'hex',
             value: hexNode.secretKey
         };
         return (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
-    }
-    derivativeToBip32Node(derivative) {
-        const extendedSecretKey = this.convertCryptoDerivative(derivative);
+    };
+    BitcoinSegwitProtocolImpl.prototype.derivativeToBip32Node = function (derivative) {
+        var extendedSecretKey = this.convertCryptoDerivative(derivative);
         return this.bip32.fromBase58(extendedSecretKey.value, this.bitcoinJS.config.network);
-    }
-}
+    };
+    return BitcoinSegwitProtocolImpl;
+}());
 exports.BitcoinSegwitProtocolImpl = BitcoinSegwitProtocolImpl;
 // Factory
-function createBitcoinSegwitProtocol(options = {}) {
+function createBitcoinSegwitProtocol(options) {
+    if (options === void 0) { options = {}; }
     return new BitcoinSegwitProtocolImpl(options);
 }
+exports.createBitcoinSegwitProtocol = createBitcoinSegwitProtocol;
 //# sourceMappingURL=BitcoinSegwitProtocol.js.map