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

package/v1/protocol/BitcoinTaprootProtocol.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,48 +26,85 @@ 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.BitcoinTaprootProtocolImpl = void 0;
-exports.createBitcoinTaprootProtocol = createBitcoinTaprootProtocol;
-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 module_kit_1 = require("@airgap/module-kit");
-const bitcoin = __importStar(require("bitcoinjs-lib"));
-const BitcoinTaprootAddress_1 = require("../data/BitcoinTaprootAddress");
-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 BitcoinSegwitProtocol_1 = require("./BitcoinSegwitProtocol");
-const crypto_1 = require("@airgap/crypto");
-const secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
+exports.createBitcoinTaprootProtocol = exports.BitcoinTaprootProtocolImpl = 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 module_kit_1 = require("@airgap/module-kit");
+var bitcoin = __importStar(require("bitcoinjs-lib"));
+var BitcoinTaprootAddress_1 = require("../data/BitcoinTaprootAddress");
+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 BitcoinSegwitProtocol_1 = require("./BitcoinSegwitProtocol");
+var crypto_1 = require("@airgap/crypto");
+var secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
 // Implementation
-const DUST_AMOUNT = 50;
-class BitcoinTaprootProtocolImpl {
-    constructor(options = {}, bitcoinJS = bitcoin) {
+var DUST_AMOUNT = 50;
+var BitcoinTaprootProtocolImpl = /** @class */ (function () {
+    function BitcoinTaprootProtocolImpl(options, bitcoinJS) {
+        if (options === void 0) { options = {}; }
+        if (bitcoinJS === void 0) { bitcoinJS = bitcoin; }
+        var _a, _b, _c;
         this._isBitcoinProtocol = true;
         this._isBitcoinTaprootProtocol = true;
         this.bip32 = (0, bip32_1.BIP32Factory)(secp256k1_1.default);
@@ -69,82 +117,107 @@ class BitcoinTaprootProtocolImpl {
         };
         this.bitcoinJS.lib.initEccLib(secp256k1_1.default);
         this.segwit = new BitcoinSegwitProtocol_1.BitcoinSegwitProtocolImpl(options);
-        this.metadata = {
-            ...this.segwit.legacy.metadata,
-            identifier: coinlib_core_1.MainProtocolSymbols.BTC_TAPROOT,
-            name: 'Bitcoin (Taproot)',
-            account: {
-                ...(this.segwit.legacy.metadata.account ?? {}),
-                standardDerivationPath: `m/86'/0'/0'`,
-                address: {
-                    ...(this.segwit.legacy.metadata.account?.address ?? {}),
-                    regex: '^(?:[13]{1}[a-km-zA-HJ-NP-Z1-9]{25,34}|bc1[a-z0-9]{39,59})$'
-                }
-            }
-        };
-    }
-    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, 'Unsupported public key type.');
-        }
-    }
-    async prepareTransactionWithNonExtendedPublicKey(publicKey, details, configuration) {
-        throw new Error('Method not implemented.');
-    }
-    async getCryptoConfiguration() {
-        return this.segwit.getCryptoConfiguration();
-    }
-    async getKeyPairFromDerivative(derivative) {
-        return this.segwit.getKeyPairFromDerivative(derivative);
+        this.metadata = __assign(__assign({}, this.segwit.legacy.metadata), { identifier: coinlib_core_1.MainProtocolSymbols.BTC_TAPROOT, name: 'Bitcoin (Taproot)', account: __assign(__assign({}, ((_a = this.segwit.legacy.metadata.account) !== null && _a !== void 0 ? _a : {})), { standardDerivationPath: "m/86'/0'/0'", address: __assign(__assign({}, ((_c = (_b = this.segwit.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 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 signTransactionWithExtendedSecretKey(transaction, secretKey) {
-        const encodedExtendedSecretKey = (0, key_1.convertExtendedSecretKey)(secretKey, { 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.tapBip32Derivation?.forEach((deriv) => {
-                try {
-                    const cutoffFrom = deriv.path.lastIndexOf("'") || deriv.path.lastIndexOf('h');
-                    const childPath = deriv.path.substr(cutoffFrom + 2);
-                    const childNode = bip32.derivePath(childPath);
-                    const tweakedChildNode = childNode.tweak(this.bitcoinJS.lib.crypto.taggedHash('TapTweak', Buffer.from(childNode.publicKey.subarray(1, 33))));
-                    decodedPSBT.signInput(index, {
-                        publicKey: Buffer.from(tweakedChildNode.publicKey),
-                        sign: (hash, lowR) => Buffer.from(tweakedChildNode.sign(hash, lowR)),
-                        signSchnorr: (hash) => Buffer.from(tweakedChildNode.signSchnorr(hash))
-                    });
+    BitcoinTaprootProtocolImpl.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, 'Unsupported public key type.');
                 }
-                catch (e) {
-                    throw new Error(`Error signing index #${index}`);
+                return [2 /*return*/];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.prepareTransactionWithNonExtendedPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Method not implemented.');
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.getCryptoConfiguration()];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.getKeyPairFromDerivative(derivative)];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.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.');
                 }
+                return [2 /*return*/];
             });
         });
-        return (0, module_kit_1.newSignedTransaction)({ psbt: decodedPSBT.toHex() });
-    }
-    async signTransactionWithNonExtendedSecretKey(transaction, secretKey) {
-        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Sign with non extended secret key not supported (Taproot).');
-    }
-    async getMetadata() {
-        return this.metadata;
-    }
-    getAddressFromPublicKey(publicKey) {
+    };
+    BitcoinTaprootProtocolImpl.prototype.signTransactionWithExtendedSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedExtendedSecretKey, bip32, decodedPSBT;
+            var _this = this;
+            return __generator(this, function (_a) {
+                encodedExtendedSecretKey = (0, key_1.convertExtendedSecretKey)(secretKey, { 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.tapBip32Derivation) === null || _a === void 0 ? void 0 : _a.forEach(function (deriv) {
+                        try {
+                            var cutoffFrom = deriv.path.lastIndexOf("'") || deriv.path.lastIndexOf('h');
+                            var childPath = deriv.path.substr(cutoffFrom + 2);
+                            var childNode = bip32.derivePath(childPath);
+                            var tweakedChildNode_1 = childNode.tweak(_this.bitcoinJS.lib.crypto.taggedHash('TapTweak', Buffer.from(childNode.publicKey.subarray(1, 33))));
+                            decodedPSBT.signInput(index, {
+                                publicKey: Buffer.from(tweakedChildNode_1.publicKey),
+                                sign: function (hash, lowR) { return Buffer.from(tweakedChildNode_1.sign(hash, lowR)); },
+                                signSchnorr: function (hash) { return Buffer.from(tweakedChildNode_1.signSchnorr(hash)); }
+                            });
+                        }
+                        catch (e) {
+                            throw new Error("Error signing index #".concat(index));
+                        }
+                    });
+                });
+                return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({ psbt: decodedPSBT.toHex() })];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.signTransactionWithNonExtendedSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Sign with non extended secret key not supported (Taproot).');
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.metadata];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
         switch (publicKey.type) {
             case 'pub':
                 return this.getAddressFromNonExtendedPublicKey(publicKey);
@@ -154,614 +227,853 @@ class BitcoinTaprootProtocolImpl {
                 (0, coinlib_core_1.assertNever)(publicKey);
                 throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Public key type is not supported.');
         }
-    }
-    async getAddressFromExtendedPublicKey(extendedPublicKey) {
-        const encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
-        const payment = this.bitcoinJS.lib.payments.p2tr({
-            internalPubkey: Buffer.from(encodedExtendedPublicKey.value, 'hex').subarray(1, 33),
-            network: this.bitcoinJS.config.network
+    };
+    BitcoinTaprootProtocolImpl.prototype.getAddressFromExtendedPublicKey = function (extendedPublicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedExtendedPublicKey, payment;
+            return __generator(this, function (_a) {
+                encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
+                payment = this.bitcoinJS.lib.payments.p2tr({
+                    internalPubkey: Buffer.from(encodedExtendedPublicKey.value, 'hex').subarray(1, 33),
+                    network: this.bitcoinJS.config.network
+                });
+                return [2 /*return*/, BitcoinTaprootAddress_1.BitcoinTaprootAddress.fromPayment(payment).asString()];
+            });
         });
-        return BitcoinTaprootAddress_1.BitcoinTaprootAddress.fromPayment(payment).asString();
-    }
-    async getDetailsFromTransaction(transaction, _publicKey) {
-        return this.getDetailsFromPSBT(transaction.psbt, _publicKey);
-    }
-    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); // Convert all buffers to hex strings
-        const amount = (() => {
-            if (decodedPSBT.txOutputs.length === 1) {
-                return new bignumber_1.default(decodedPSBT.txOutputs[0].value);
-            }
-            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());
-                }
-            }
-            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) {
-                        useAccumulated = true;
-                        return;
-                    }
-                }
-                const output = decodedPSBT.txOutputs[index];
-                accumulated = accumulated.plus(output.value);
+    };
+    BitcoinTaprootProtocolImpl.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)];
             });
-            if (useAccumulated) {
-                return accumulated;
-            }
-            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];
-                }
-                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;
-                    }
-                }
-            }
-            else if (obj.tapBip32Derivation) {
-                isChangeAddress = true;
-                const getIndexes = obj.tapBip32Derivation[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];
-                }
-                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;
-                    }
-                }
-            }
-            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;
-                    }
-                }
-            }
-            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,
-                    isOwned,
-                    path: addressIndex === 0 ? '' : `m/86'/0'/0'/1/${addressIndex}`,
-                    amount
+        });
+    };
+    BitcoinTaprootProtocolImpl.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); // Convert all buffers to hex strings
+                        amount = (function () {
+                            if (decodedPSBT.txOutputs.length === 1) {
+                                return new bignumber_1.default(decodedPSBT.txOutputs[0].value);
+                            }
+                            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());
+                                }
+                            }
+                            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) {
+                                        useAccumulated = true;
+                                        return;
+                                    }
+                                }
+                                var output = decodedPSBT.txOutputs[index];
+                                accumulated = accumulated.plus(output.value);
+                            });
+                            if (useAccumulated) {
+                                return accumulated;
+                            }
+                            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, 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*/, 27];
+                                        case 11:
+                                            if (!obj.tapBip32Derivation) return [3 /*break*/, 22];
+                                            isChangeAddress = true;
+                                            getIndexes = obj.tapBip32Derivation[0].path.split('/');
+                                            if (!(publicKey.type === 'xpub')) return [3 /*break*/, 14];
+                                            return [4 /*yield*/, this.deriveFromExtendedPublicKey(publicKey, 1, +getIndexes[getIndexes.length - 1])];
+                                        case 12:
+                                            ourPublickey = _a.sent();
+                                            return [4 /*yield*/, this.getAddressFromPublicKey(ourPublickey)];
+                                        case 13:
+                                            ourGeneratedAddress = _a.sent();
+                                            return [3 /*break*/, 16];
+                                        case 14: return [4 /*yield*/, this.getAddressFromNonExtendedPublicKey(publicKey)];
+                                        case 15:
+                                            ourGeneratedAddress = _a.sent();
+                                            _a.label = 16;
+                                        case 16:
+                                            if (ourGeneratedAddress === address) {
+                                                isOwned = true;
+                                                addressIndex = +getIndexes[getIndexes.length - 1];
+                                            }
+                                            x = 0;
+                                            _a.label = 17;
+                                        case 17:
+                                            if (!(x < 1000)) return [3 /*break*/, 21];
+                                            return [4 /*yield*/, this.deriveFromExtendedPublicKey(publicKey, 1, x)];
+                                        case 18:
+                                            ourPublickey = _a.sent();
+                                            return [4 /*yield*/, this.getAddressFromPublicKey(ourPublickey)];
+                                        case 19:
+                                            ourGeneratedAddress = _a.sent();
+                                            if (ourGeneratedAddress === address) {
+                                                isOwned = true;
+                                                addressIndex = x;
+                                                return [3 /*break*/, 21];
+                                            }
+                                            _a.label = 20;
+                                        case 20:
+                                            x++;
+                                            return [3 /*break*/, 17];
+                                        case 21: return [3 /*break*/, 27];
+                                        case 22:
+                                            if (!obj.unknownKeyVals) return [3 /*break*/, 27];
+                                            x = 0;
+                                            _a.label = 23;
+                                        case 23:
+                                            if (!(x < 1000)) return [3 /*break*/, 27];
+                                            isChangeAddress = true;
+                                            return [4 /*yield*/, this.deriveFromExtendedPublicKey(publicKey, 1, x)];
+                                        case 24:
+                                            ourPublickey = _a.sent();
+                                            return [4 /*yield*/, this.getAddressFromPublicKey(ourPublickey)];
+                                        case 25:
+                                            ourGeneratedAddress = _a.sent();
+                                            if (ourGeneratedAddress === address) {
+                                                isOwned = true;
+                                                addressIndex = x;
+                                                return [3 /*break*/, 27];
+                                            }
+                                            _a.label = 26;
+                                        case 26:
+                                            x++;
+                                            return [3 /*break*/, 23];
+                                        case 27:
+                                            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/86'/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.tapBip32Derivation) === null || _a === void 0 ? void 0 : _a.map(function (el) {
+                                            return _this.bitcoinJS.lib.payments.p2tr({
+                                                internalPubkey: 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: {
+                                        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
+                                    }
+                                }
+                            ]];
                 }
-            ];
-        }));
-        const changeAddressInfo = {};
-        changeAddressDatas.forEach((changeAddressData) => {
-            changeAddressInfo[changeAddressData[0]] = changeAddressData[1];
-        });
-        return [
-            {
-                from: decodedPSBT.data.inputs.map((obj) => obj.tapBip32Derivation
-                    ?.map((el) => this.bitcoinJS.lib.payments.p2tr({
-                    internalPubkey: 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: {
-                    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
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (publicKey.type) {
+                    case 'pub':
+                        return [2 /*return*/, this.getTransactionsForNonExtendedPublicKey(publicKey, limit, cursor)];
+                    case 'xpub':
+                        return [2 /*return*/, this.getTransactionsForExtendedPublicKey(publicKey, limit, cursor)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(publicKey);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Public key type not supported');
                 }
-            }
-        ];
-    }
-    async getNetwork() {
-        return this.options.network;
-    }
-    async getTransactionsForPublicKey(publicKey, limit, cursor) {
-        switch (publicKey.type) {
-            case 'pub':
-                return this.getTransactionsForNonExtendedPublicKey(publicKey, limit, cursor);
-            case 'xpub':
-                return this.getTransactionsForExtendedPublicKey(publicKey, limit, cursor);
-            default:
-                (0, coinlib_core_1.assertNever)(publicKey);
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Public key type not supported');
-        }
-    }
-    async getTransactionsForNonExtendedPublicKey(publicKey, limit, cursor) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getTransactionsForAddresses([address], limit, cursor);
-    }
-    async getTransactionsForExtendedPublicKey(extendedPublicKey, limit, cursor) {
-        const encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
-        const page = cursor?.page ?? 1;
-        const url = `${this.options.network.indexerApi}/api/v2/xpub/tr(${encodedExtendedPublicKey.value})?details=txs&tokens=used&pageSize=${limit}&page=${page}`;
-        const { data } = await index_1.default.get(url, {
-            responseType: 'json'
-        });
-        const ourAddresses = (data.tokens || []).filter((token) => token.type === 'XPUBAddress').map((token) => token.name);
-        const airGapTransactions = [];
-        if (data.page === page) {
-            for (const transaction of data.transactions || []) {
-                const tempAirGapTransactionFrom = [];
-                const tempAirGapTransactionTo = [];
-                let tempAirGapTransactionIsInbound = true;
-                let amountNotAdded = true;
-                let amount = new bignumber_1.default(0);
-                for (const vin of transaction.vin) {
-                    if ((0, common_1.containsSome)(vin.addresses, ourAddresses)) {
-                        tempAirGapTransactionIsInbound = false;
-                    }
-                    tempAirGapTransactionFrom.push(...vin.addresses);
+                return [2 /*return*/];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getTransactionsForNonExtendedPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getTransactionsForAddresses([address], limit, cursor)];
                 }
-                for (const vout of transaction.vout) {
-                    if (vout.addresses) {
-                        tempAirGapTransactionTo.push(...vout.addresses);
-                    }
-                    if ((0, common_1.containsSome)(vout.addresses, ourAddresses) && transaction.vout.length > 2) {
-                        amount = amount.plus(vout.value);
-                        amountNotAdded = false;
-                    }
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getTransactionsForExtendedPublicKey = function (extendedPublicKey, limit, cursor) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedExtendedPublicKey, page, url, data, ourAddresses, airGapTransactions, _i, _b, transaction, tempAirGapTransactionFrom, tempAirGapTransactionTo, tempAirGapTransactionIsInbound, amountNotAdded, amount, _c, _d, vin, _e, _f, vout, airGapTransaction, hasNext;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
+                        page = (_a = cursor === null || cursor === void 0 ? void 0 : cursor.page) !== null && _a !== void 0 ? _a : 1;
+                        url = "".concat(this.options.network.indexerApi, "/api/v2/xpub/tr(").concat(encodedExtendedPublicKey.value, ")?details=txs&tokens=used&pageSize=").concat(limit, "&page=").concat(page);
+                        return [4 /*yield*/, index_1.default.get(url, {
+                                responseType: 'json'
+                            })];
+                    case 1:
+                        data = (_g.sent()).data;
+                        ourAddresses = (data.tokens || []).filter(function (token) { return token.type === 'XPUBAddress'; }).map(function (token) { return token.name; });
+                        airGapTransactions = [];
+                        if (data.page === page) {
+                            for (_i = 0, _b = data.transactions || []; _i < _b.length; _i++) {
+                                transaction = _b[_i];
+                                tempAirGapTransactionFrom = [];
+                                tempAirGapTransactionTo = [];
+                                tempAirGapTransactionIsInbound = true;
+                                amountNotAdded = true;
+                                amount = new bignumber_1.default(0);
+                                for (_c = 0, _d = transaction.vin; _c < _d.length; _c++) {
+                                    vin = _d[_c];
+                                    if ((0, common_1.containsSome)(vin.addresses, ourAddresses)) {
+                                        tempAirGapTransactionIsInbound = false;
+                                    }
+                                    tempAirGapTransactionFrom.push.apply(tempAirGapTransactionFrom, vin.addresses);
+                                }
+                                for (_e = 0, _f = transaction.vout; _e < _f.length; _e++) {
+                                    vout = _f[_e];
+                                    if (vout.addresses) {
+                                        tempAirGapTransactionTo.push.apply(tempAirGapTransactionTo, vout.addresses);
+                                    }
+                                    if ((0, common_1.containsSome)(vout.addresses, ourAddresses) && transaction.vout.length > 2) {
+                                        amount = amount.plus(vout.value);
+                                        amountNotAdded = false;
+                                    }
+                                }
+                                // deduct fee from amount
+                                //amount = amount.minus(transaction.fees)
+                                if (amountNotAdded) {
+                                    amount = amount.plus(transaction.vout[0].value);
+                                }
+                                airGapTransaction = {
+                                    from: tempAirGapTransactionFrom,
+                                    to: tempAirGapTransactionTo,
+                                    isInbound: tempAirGapTransactionIsInbound,
+                                    amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
+                                    fee: (0, module_kit_1.newAmount)(transaction.fees, 'blockchain'),
+                                    status: {
+                                        type: 'applied',
+                                        hash: transaction.txid,
+                                        block: transaction.blockHeight.toString()
+                                    },
+                                    network: this.options.network,
+                                    timestamp: transaction.blockTime
+                                };
+                                airGapTransactions.push(airGapTransaction);
+                            }
+                        }
+                        hasNext = page < data.totalPages;
+                        return [2 /*return*/, {
+                                transactions: airGapTransactions,
+                                cursor: {
+                                    hasNext: hasNext,
+                                    page: hasNext ? page + 1 : undefined
+                                }
+                            }];
                 }
-                // deduct fee from amount
-                //amount = amount.minus(transaction.fees)
-                if (amountNotAdded) {
-                    amount = amount.plus(transaction.vout[0].value);
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getTransactionsForAddresses([address], limit, cursor)];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getTransactionsForAddresses = function (addresses, limit, cursor) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var airGapTransactions, page, url, data, _i, _b, transaction, tempAirGapTransactionFrom, tempAirGapTransactionTo, tempAirGapTransactionIsInbound, amount, _c, _d, vin, _e, _f, vout, airGapTransaction, hasNext;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        airGapTransactions = [];
+                        page = (_a = cursor === null || cursor === void 0 ? void 0 : cursor.page) !== null && _a !== void 0 ? _a : 1;
+                        url = "".concat(this.options.network.indexerApi, "/api/v2/address/").concat(addresses[0], "?page=").concat(page, "&pageSize=").concat(limit, "&details=txs");
+                        return [4 /*yield*/, index_1.default.get(url, {
+                                responseType: 'json'
+                            })];
+                    case 1:
+                        data = (_g.sent()).data;
+                        if (data.page == page) {
+                            for (_i = 0, _b = data.transactions || []; _i < _b.length; _i++) {
+                                transaction = _b[_i];
+                                tempAirGapTransactionFrom = [];
+                                tempAirGapTransactionTo = [];
+                                tempAirGapTransactionIsInbound = true;
+                                amount = new bignumber_1.default(0);
+                                for (_c = 0, _d = transaction.vin; _c < _d.length; _c++) {
+                                    vin = _d[_c];
+                                    if (vin.addresses && (0, common_1.containsSome)(vin.addresses, addresses)) {
+                                        tempAirGapTransactionIsInbound = false;
+                                    }
+                                    tempAirGapTransactionFrom.push.apply(tempAirGapTransactionFrom, vin.addresses);
+                                    amount = vin.value ? amount.plus(vin.value) : amount;
+                                }
+                                for (_e = 0, _f = transaction.vout; _e < _f.length; _e++) {
+                                    vout = _f[_e];
+                                    if (vout.addresses) {
+                                        tempAirGapTransactionTo.push.apply(tempAirGapTransactionTo, vout.addresses);
+                                        // If receiving address is our address, and transaction is outbound => our change
+                                        if ((0, common_1.containsSome)(vout.addresses, addresses) && !tempAirGapTransactionIsInbound) {
+                                            // remove only if related to this address
+                                            amount = amount.minus(new bignumber_1.default(vout.value));
+                                        }
+                                        // If receiving address is not ours, and transaction isbound => senders change
+                                        if (!(0, common_1.containsSome)(vout.addresses, addresses) && tempAirGapTransactionIsInbound) {
+                                            amount = amount.minus(new bignumber_1.default(vout.value));
+                                        }
+                                    }
+                                }
+                                // deduct fee from amount
+                                amount = amount.minus(new bignumber_1.default(transaction.fees));
+                                airGapTransaction = {
+                                    from: tempAirGapTransactionFrom,
+                                    to: tempAirGapTransactionTo,
+                                    isInbound: tempAirGapTransactionIsInbound,
+                                    amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
+                                    fee: (0, module_kit_1.newAmount)(transaction.fees, 'blockchain'),
+                                    status: {
+                                        type: 'applied',
+                                        hash: transaction.txid,
+                                        block: transaction.blockHeight.toString()
+                                    },
+                                    network: this.options.network,
+                                    timestamp: transaction.blockTime
+                                };
+                                airGapTransactions.push(airGapTransaction);
+                            }
+                        }
+                        hasNext = page < data.totalPages;
+                        return [2 /*return*/, {
+                                transactions: airGapTransactions,
+                                cursor: {
+                                    hasNext: hasNext,
+                                    page: hasNext ? page + 1 : undefined
+                                }
+                            }];
                 }
-                const airGapTransaction = {
-                    from: tempAirGapTransactionFrom,
-                    to: tempAirGapTransactionTo,
-                    isInbound: tempAirGapTransactionIsInbound,
-                    amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
-                    fee: (0, module_kit_1.newAmount)(transaction.fees, 'blockchain'),
-                    status: {
-                        type: 'applied',
-                        hash: transaction.txid,
-                        block: transaction.blockHeight.toString()
-                    },
-                    network: this.options.network,
-                    timestamp: transaction.blockTime
-                };
-                airGapTransactions.push(airGapTransaction);
-            }
-        }
-        const hasNext = page < data.totalPages;
-        return {
-            transactions: airGapTransactions,
-            cursor: {
-                hasNext,
-                page: hasNext ? page + 1 : undefined
-            }
-        };
-    }
-    async getTransactionsForAddress(address, limit, cursor) {
-        return this.getTransactionsForAddresses([address], limit, cursor);
-    }
-    async getTransactionsForAddresses(addresses, limit, cursor) {
-        const airGapTransactions = [];
-        const page = cursor?.page ?? 1;
-        const url = `${this.options.network.indexerApi}/api/v2/address/${addresses[0]}?page=${page}&pageSize=${limit}&details=txs`;
-        const { data } = await index_1.default.get(url, {
-            responseType: 'json'
-        });
-        if (data.page == page) {
-            for (const transaction of data.transactions || []) {
-                const tempAirGapTransactionFrom = [];
-                const tempAirGapTransactionTo = [];
-                let tempAirGapTransactionIsInbound = true;
-                let amount = new bignumber_1.default(0);
-                for (const vin of transaction.vin) {
-                    if (vin.addresses && (0, common_1.containsSome)(vin.addresses, addresses)) {
-                        tempAirGapTransactionIsInbound = false;
-                    }
-                    tempAirGapTransactionFrom.push(...vin.addresses);
-                    amount = vin.value ? amount.plus(vin.value) : amount;
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (publicKey.type) {
+                    case 'pub':
+                        return [2 /*return*/, this.getBalanceOfNonExtendedPublicKey(publicKey)];
+                    case 'xpub':
+                        return [2 /*return*/, this.getBalanceOfExtendedPublicKey(publicKey)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(publicKey);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Unsupported public key type.');
                 }
-                for (const vout of transaction.vout) {
-                    if (vout.addresses) {
-                        tempAirGapTransactionTo.push(...vout.addresses);
-                        // If receiving address is our address, and transaction is outbound => our change
-                        if ((0, common_1.containsSome)(vout.addresses, addresses) && !tempAirGapTransactionIsInbound) {
-                            // remove only if related to this address
-                            amount = amount.minus(new bignumber_1.default(vout.value));
-                        }
-                        // If receiving address is not ours, and transaction isbound => senders change
-                        if (!(0, common_1.containsSome)(vout.addresses, addresses) && tempAirGapTransactionIsInbound) {
-                            amount = amount.minus(new bignumber_1.default(vout.value));
-                        }
-                    }
+                return [2 /*return*/];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getBalanceOfNonExtendedPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getBalanceOfAddresses([address])];
                 }
-                // deduct fee from amount
-                amount = amount.minus(new bignumber_1.default(transaction.fees));
-                const airGapTransaction = {
-                    from: tempAirGapTransactionFrom,
-                    to: tempAirGapTransactionTo,
-                    isInbound: tempAirGapTransactionIsInbound,
-                    amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
-                    fee: (0, module_kit_1.newAmount)(transaction.fees, 'blockchain'),
-                    status: {
-                        type: 'applied',
-                        hash: transaction.txid,
-                        block: transaction.blockHeight.toString()
-                    },
-                    network: this.options.network,
-                    timestamp: transaction.blockTime
-                };
-                airGapTransactions.push(airGapTransaction);
-            }
-        }
-        const hasNext = page < data.totalPages;
-        return {
-            transactions: airGapTransactions,
-            cursor: {
-                hasNext,
-                page: hasNext ? page + 1 : undefined
-            }
-        };
-    }
-    async getBalanceOfPublicKey(publicKey) {
-        switch (publicKey.type) {
-            case 'pub':
-                return this.getBalanceOfNonExtendedPublicKey(publicKey);
-            case 'xpub':
-                return this.getBalanceOfExtendedPublicKey(publicKey);
-            default:
-                (0, coinlib_core_1.assertNever)(publicKey);
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Unsupported public key type.');
-        }
-    }
-    async getBalanceOfNonExtendedPublicKey(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getBalanceOfAddresses([address]);
-    }
-    async getBalanceOfExtendedPublicKey(extendedPublicKey) {
-        const encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
-        const { data } = await index_1.default.get(`${this.options.network.indexerApi}/api/v2/xpub/tr(${encodedExtendedPublicKey.value})?pageSize=1`, {
-            responseType: 'json'
+            });
         });
-        return {
-            total: (0, module_kit_1.newAmount)(data.balance, 'blockchain')
-        };
-    }
-    async getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
-        return this.segwit.getTransactionMaxAmountWithPublicKey(publicKey, to, configuration);
-    }
-    async getTransactionFeeWithPublicKey(publicKey, details, configuration) {
-        return this.segwit.getTransactionFeeWithPublicKey(publicKey, details, configuration);
-    }
-    async broadcastTransaction(transaction) {
-        const psbt = this.bitcoinJS.lib.Psbt.fromHex(transaction.psbt);
-        // Verify and finalize each Taproot input
-        psbt.data.inputs.forEach((input, index) => {
-            if (input.tapInternalKey) {
-                try {
-                    const finalized = psbt.finalizeTaprootInput(index);
-                    if (!finalized) {
-                        throw new Error(`Failed to finalize Taproot input #${index}`);
-                    }
+    };
+    BitcoinTaprootProtocolImpl.prototype.getBalanceOfExtendedPublicKey = function (extendedPublicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedExtendedPublicKey, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.indexerApi, "/api/v2/xpub/tr(").concat(encodedExtendedPublicKey.value, ")?pageSize=1"), {
+                                responseType: 'json'
+                            })];
+                    case 1:
+                        data = (_a.sent()).data;
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)(data.balance, 'blockchain')
+                            }];
                 }
-                catch (error) {
-                    throw new Error(`Error finalizing Taproot input #${index}: ${error}`);
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.getTransactionMaxAmountWithPublicKey(publicKey, to, configuration)];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.getTransactionFeeWithPublicKey(publicKey, details, configuration)];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var psbt, hexTransaction, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        psbt = this.bitcoinJS.lib.Psbt.fromHex(transaction.psbt);
+                        // Verify and finalize each Taproot input
+                        psbt.data.inputs.forEach(function (input, index) {
+                            if (input.tapInternalKey) {
+                                try {
+                                    var finalized = psbt.finalizeTaprootInput(index);
+                                    if (!finalized) {
+                                        throw new Error("Failed to finalize Taproot input #".concat(index));
+                                    }
+                                }
+                                catch (error) {
+                                    throw new Error("Error finalizing Taproot input #".concat(index, ": ").concat(error));
+                                }
+                            }
+                        });
+                        hexTransaction = psbt.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
+                            // return ''
+                        ];
                 }
-            }
+            });
         });
-        // Extract and broadcast the finalized transaction
-        const hexTransaction = psbt.extractTransaction().toHex();
-        const { data } = await index_1.default.post(`${this.options.network.indexerApi}/api/v2/sendtx/`, hexTransaction);
-        return data.result;
-        // return ''
-    }
-    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: 'xpub'
-            })
-        };
-    }
-    derivativeToBip32Node(derivative) {
-        const extendedSecretKey = this.convertCryptoDerivative(derivative);
-        return this.bip32.fromBase58(extendedSecretKey.value, this.bitcoinJS.config.network);
-    }
-    convertCryptoDerivative(derivative) {
-        const hexNode = (0, crypto_1.encodeDerivative)('hex', {
-            ...derivative,
-            secretKey: `00${derivative.secretKey}`
+    };
+    BitcoinTaprootProtocolImpl.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: 'xpub'
+                        })
+                    }];
+            });
         });
-        const extendedSecretKey = {
+    };
+    BitcoinTaprootProtocolImpl.prototype.derivativeToBip32Node = function (derivative) {
+        var extendedSecretKey = this.convertCryptoDerivative(derivative);
+        return this.bip32.fromBase58(extendedSecretKey.value, this.bitcoinJS.config.network);
+    };
+    BitcoinTaprootProtocolImpl.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' });
-    }
-    async deriveFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex) {
-        return this.segwit.deriveFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex);
-    }
-    async deriveFromExtendedPublicKey(extendedPublicKey, visibilityIndex, addressIndex) {
-        const encodedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { 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 signMessageWithKeyPair(message, keyPair) {
-        return this.segwit.signMessageWithKeyPair(message, keyPair);
-    }
-    async verifyMessageWithPublicKey(message, signature, publicKey) {
-        return this.segwit.verifyMessageWithPublicKey(message, signature, publicKey);
-    }
-    async decryptAsymmetricWithKeyPair(payload, keyPair) {
-        return this.segwit.decryptAsymmetricWithKeyPair(payload, keyPair);
-    }
-    async encryptAsymmetricWithPublicKey(payload, publicKey) {
-        return this.segwit.encryptAsymmetricWithPublicKey(payload, publicKey);
-    }
-    async encryptAESWithSecretKey(payload, secretKey) {
-        return this.segwit.encryptAESWithSecretKey(payload, secretKey);
-    }
-    decryptAESWithSecretKey(payload, secretKey) {
-        return this.segwit.decryptAESWithSecretKey(payload, secretKey);
-    }
-    async getBalanceOfAddress(address, configuration) {
-        return this.segwit.getBalanceOfAddress(address);
-    }
-    async getBalanceOfAddresses(addresses, configuration) {
-        return this.segwit.getBalanceOfAddresses(addresses);
-    }
-    // Common methods similar to Segwit implementation
-    // ... [Include all the common methods from Segwit implementation but modify for Taproot]
-    async getAddressFromNonExtendedPublicKey(publicKey) {
-        const hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
-        const payment = this.bitcoinJS.lib.payments.p2tr({
-            internalPubkey: Buffer.from(hexPublicKey.value, 'hex').subarray(1, 33),
-            network: this.bitcoinJS.config.network
+    };
+    BitcoinTaprootProtocolImpl.prototype.deriveFromExtendedSecretKey = function (extendedSecretKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.deriveFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex)];
+            });
         });
-        return BitcoinTaprootAddress_1.BitcoinTaprootAddress.fromPayment(payment).asString();
-    }
-    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.segwit.legacy.units).value);
-        const transaction = (0, module_kit_1.newUnsignedTransaction)({
-            ins: [],
-            outs: []
+    };
+    BitcoinTaprootProtocolImpl.prototype.deriveFromExtendedPublicKey = function (extendedPublicKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedPublicKey, derivedBip32;
+            return __generator(this, function (_a) {
+                encodedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { 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')];
+            });
         });
-        const { data: utxos } = await index_1.default.get(`${this.options.network.indexerApi}/api/v2/utxo/tr(${extendedPublicKey.value})?confirmed=true`, {
-            responseType: 'json'
+    };
+    BitcoinTaprootProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.signMessageWithKeyPair(message, keyPair)];
+            });
         });
-        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.segwit.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
+    };
+    BitcoinTaprootProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.verifyMessageWithPublicKey(message, signature, publicKey)];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.decryptAsymmetricWithKeyPair(payload, keyPair)];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.encryptAsymmetricWithPublicKey(payload, publicKey)];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.encryptAESWithSecretKey(payload, secretKey)];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return this.segwit.decryptAESWithSecretKey(payload, secretKey);
+    };
+    BitcoinTaprootProtocolImpl.prototype.getBalanceOfAddress = function (address, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.getBalanceOfAddress(address)];
+            });
+        });
+    };
+    BitcoinTaprootProtocolImpl.prototype.getBalanceOfAddresses = function (addresses, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.segwit.getBalanceOfAddresses(addresses)];
+            });
+        });
+    };
+    // Common methods similar to Segwit implementation
+    // ... [Include all the common methods from Segwit implementation but modify for Taproot]
+    BitcoinTaprootProtocolImpl.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.p2tr({
+                    internalPubkey: Buffer.from(hexPublicKey.value, 'hex').subarray(1, 33),
+                    network: this.bitcoinJS.config.network
                 });
-            }
-            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.segwit.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}`
+                return [2 /*return*/, BitcoinTaprootAddress_1.BitcoinTaprootAddress.fromPayment(payment).asString()];
             });
-        }
-        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.segwit.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 xOnlyPubkey = childNode.publicKey.length === 33 ? childNode.publicKey.slice(1, 33) : childNode.publicKey;
-            const payment = this.bitcoinJS.lib.payments.p2tr({
-                internalPubkey: Buffer.from(xOnlyPubkey),
-                network: this.bitcoinJS.config.network
-            });
-            const inputCommon = {
-                hash: tx.txId,
-                index: tx.vout,
-                sequence: replaceByFee ? 0xfffffffd : undefined,
-                witnessUtxo: {
-                    script: payment.output,
-                    value: parseInt(tx.value, 10)
+        });
+    };
+    BitcoinTaprootProtocolImpl.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.segwit.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/tr(").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.segwit.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.segwit.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.segwit.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 xOnlyPubkey = childNode.publicKey.length === 33 ? childNode.publicKey.slice(1, 33) : childNode.publicKey;
+                            var payment = _this.bitcoinJS.lib.payments.p2tr({
+                                internalPubkey: Buffer.from(xOnlyPubkey),
+                                network: _this.bitcoinJS.config.network
+                            });
+                            var inputCommon = {
+                                hash: tx.txId,
+                                index: tx.vout,
+                                sequence: replaceByFee ? 0xfffffffd : undefined,
+                                witnessUtxo: {
+                                    script: payment.output,
+                                    value: parseInt(tx.value, 10)
+                                }
+                            };
+                            var p2shOutput = payment.output;
+                            if (!p2shOutput) {
+                                throw new Error('no p2shOutput');
+                            }
+                            var fingerprintBuffer = Buffer.from(configuration.masterFingerprint.value, 'hex');
+                            psbt.addInput(__assign(__assign({}, inputCommon), { tapInternalKey: Buffer.from(xOnlyPubkey), tapBip32Derivation: [
+                                    {
+                                        leafHashes: [],
+                                        path: tx.derivationPath,
+                                        pubkey: Buffer.from(xOnlyPubkey),
+                                        masterFingerprint: fingerprintBuffer
+                                    }
+                                ] }));
+                        });
+                        transaction.outs.forEach(function (out, index) {
+                            psbt.addOutput({ address: out.recipient, value: parseInt(out.value, 10) });
+                            if (out.derivationPath) {
+                                psbt.addUnknownKeyValToOutput(index, {
+                                    key: Buffer.from('dp'),
+                                    value: Buffer.from(out.derivationPath, 'utf8')
+                                });
+                            }
+                        });
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({ psbt: psbt.toHex() })];
                 }
-            };
-            const p2shOutput = payment.output;
-            if (!p2shOutput) {
-                throw new Error('no p2shOutput');
-            }
-            const fingerprintBuffer = Buffer.from(configuration.masterFingerprint.value, 'hex');
-            psbt.addInput({
-                ...inputCommon,
-                tapInternalKey: Buffer.from(xOnlyPubkey),
-                tapBip32Derivation: [
-                    {
-                        leafHashes: [],
-                        path: tx.derivationPath,
-                        pubkey: Buffer.from(xOnlyPubkey),
-                        masterFingerprint: fingerprintBuffer
-                    }
-                ]
-            });
-        });
-        transaction.outs.forEach((out, index) => {
-            psbt.addOutput({ address: out.recipient, value: parseInt(out.value, 10) });
-            if (out.derivationPath) {
-                psbt.addUnknownKeyValToOutput(index, {
-                    key: Buffer.from('dp'),
-                    value: Buffer.from(out.derivationPath, 'utf8')
-                });
-            }
+            });
         });
-        return (0, module_kit_1.newUnsignedTransaction)({ psbt: psbt.toHex() });
-    }
-}
+    };
+    return BitcoinTaprootProtocolImpl;
+}());
 exports.BitcoinTaprootProtocolImpl = BitcoinTaprootProtocolImpl;
 // Factory
-function createBitcoinTaprootProtocol(options = {}) {
+function createBitcoinTaprootProtocol(options) {
+    if (options === void 0) { options = {}; }
     return new BitcoinTaprootProtocolImpl(options);
 }
+exports.createBitcoinTaprootProtocol = createBitcoinTaprootProtocol;
 //# sourceMappingURL=BitcoinTaprootProtocol.js.map