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

package/v1/protocol/BitcoinLegacyProtocol.js

@@ -1,15 +1,4 @@
 "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);
@@ -26,83 +15,47 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBitcoinLegacyProtocol = exports.BitcoinLegacyProtocolImpl = void 0;
-var coinlib_core_1 = require("@airgap/coinlib-core");
-var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
-var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-var errors_1 = require("@airgap/coinlib-core/errors");
-var crypto_1 = require("@airgap/crypto");
-var module_kit_1 = require("@airgap/module-kit");
-var bitcoin = __importStar(require("bitcoinjs-lib"));
-var common_1 = require("../utils/common");
-var key_1 = require("../utils/key");
-var network_1 = require("../utils/network");
-var bip32_1 = require("bip32");
-var secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
-var BitcoinProtocol_1 = require("./BitcoinProtocol");
-var BitcoinLegacyAddress_1 = require("../data/BitcoinLegacyAddress");
+exports.BitcoinLegacyProtocolImpl = void 0;
+exports.createBitcoinLegacyProtocol = createBitcoinLegacyProtocol;
+const coinlib_core_1 = require("@airgap/coinlib-core");
+const index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
+const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+const errors_1 = require("@airgap/coinlib-core/errors");
+const crypto_1 = require("@airgap/crypto");
+const module_kit_1 = require("@airgap/module-kit");
+const bitcoin = __importStar(require("bitcoinjs-lib"));
+const common_1 = require("../utils/common");
+const key_1 = require("../utils/key");
+const network_1 = require("../utils/network");
+const bip32_1 = require("bip32");
+const secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
+const BitcoinProtocol_1 = require("./BitcoinProtocol");
+const BitcoinLegacyAddress_1 = require("../data/BitcoinLegacyAddress");
 // Implementation
-var DUST_AMOUNT = 50;
-var BitcoinLegacyProtocolImpl = /** @class */ (function () {
-    function BitcoinLegacyProtocolImpl(options, bitcoinJS) {
-        if (options === void 0) { options = {}; }
-        if (bitcoinJS === void 0) { bitcoinJS = bitcoin; }
+const DUST_AMOUNT = 50;
+class BitcoinLegacyProtocolImpl {
+    constructor(options = {}, bitcoinJS = bitcoin) {
         this._isBitcoinProtocol = true;
         this.bip32 = (0, bip32_1.BIP32Factory)(secp256k1_1.default);
         this.options = (0, BitcoinProtocol_1.createBitcoinProtocolOptions)(options.network);
@@ -116,743 +69,514 @@ var BitcoinLegacyProtocolImpl = /** @class */ (function () {
         this.legacy = new BitcoinProtocol_1.BitcoinProtocolImpl(options);
         this.metadata = this.legacy.metadata;
     }
-    BitcoinLegacyProtocolImpl.prototype.getMetadata = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.metadata];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (publicKey.type) {
-                    case 'pub':
-                        return [2 /*return*/, this.getAddressFromNonExtendedPublicKey(publicKey)];
-                    case 'xpub':
-                        return [2 /*return*/, this.getAddressFromExtendedPublicKey(publicKey)];
-                    default:
-                        (0, coinlib_core_1.assertNever)(publicKey);
-                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Public key type is not supported.');
+    async getMetadata() {
+        return this.metadata;
+    }
+    async getAddressFromPublicKey(publicKey) {
+        switch (publicKey.type) {
+            case 'pub':
+                return this.getAddressFromNonExtendedPublicKey(publicKey);
+            case 'xpub':
+                return this.getAddressFromExtendedPublicKey(publicKey);
+            default:
+                (0, coinlib_core_1.assertNever)(publicKey);
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Public key type is not supported.');
+        }
+    }
+    async getAddressFromNonExtendedPublicKey(publicKey) {
+        const hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+        const payment = this.bitcoinJS.lib.payments.p2pkh({ pubkey: Buffer.from(hexPublicKey.value, 'hex') });
+        return BitcoinLegacyAddress_1.BitcoinLegacyAddress.fromPayment(payment).asString();
+    }
+    async getAddressFromExtendedPublicKey(extendedPublicKey) {
+        const encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
+        const bip32 = this.bip32.fromBase58(encodedExtendedPublicKey.value, this.bitcoinJS.config.network);
+        return BitcoinLegacyAddress_1.BitcoinLegacyAddress.fromBip32(bip32).asString();
+    }
+    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 getDetailsFromTransaction(transaction, _publicKey) {
+        return this.getDetailsFromPSBT(transaction.psbt, _publicKey);
+    }
+    async getDetailsFromPSBT(psbt, publickey) {
+        const decodedPSBT = this.bitcoinJS.lib.Psbt.fromHex(psbt);
+        let inTotal = new bignumber_1.default(0);
+        for (let i = 0; i < decodedPSBT.data.inputs.length; i++) {
+            const input = decodedPSBT.data.inputs[i];
+            if (input.witnessUtxo) {
+                inTotal = inTotal.plus(input.witnessUtxo.value);
+            }
+            else if (input.nonWitnessUtxo) {
+                // bitcoinjs-lib v6: prevout index comes from the underlying unsigned tx
+                const prevIndex = decodedPSBT.txInputs[i].index;
+                const prevTx = this.bitcoinJS.lib.Transaction.fromBuffer(input.nonWitnessUtxo);
+                inTotal = inTotal.plus(prevTx.outs[prevIndex].value);
+            }
+            else {
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'PSBT input missing UTXO data.');
+            }
+        }
+        let fee = inTotal;
+        for (const o of decodedPSBT.txOutputs) {
+            fee = fee.minus(o.value);
+        }
+        const alerts = [];
+        const clonedPSBT = decodedPSBT.clone();
+        (0, common_1.eachRecursive)(clonedPSBT);
+        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());
+                    }
                 }
-                return [2 /*return*/];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.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.p2pkh({ pubkey: Buffer.from(hexPublicKey.value, 'hex') });
-                return [2 /*return*/, BitcoinLegacyAddress_1.BitcoinLegacyAddress.fromPayment(payment).asString()];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getAddressFromExtendedPublicKey = function (extendedPublicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var encodedExtendedPublicKey, bip32;
-            return __generator(this, function (_a) {
-                encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
-                bip32 = this.bip32.fromBase58(encodedExtendedPublicKey.value, this.bitcoinJS.config.network);
-                return [2 /*return*/, BitcoinLegacyAddress_1.BitcoinLegacyAddress.fromBip32(bip32).asString()];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.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')];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.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)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getDetailsFromPSBT = function (psbt, publickey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var decodedPSBT, inTotal, i, input, prevIndex, prevTx, fee, _i, _a, o, alerts, clonedPSBT, amount, changeAddressDatas, changeAddressInfo;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        decodedPSBT = this.bitcoinJS.lib.Psbt.fromHex(psbt);
-                        inTotal = new bignumber_1.default(0);
-                        for (i = 0; i < decodedPSBT.data.inputs.length; i++) {
-                            input = decodedPSBT.data.inputs[i];
-                            if (input.witnessUtxo) {
-                                inTotal = inTotal.plus(input.witnessUtxo.value);
-                            }
-                            else if (input.nonWitnessUtxo) {
-                                prevIndex = decodedPSBT.txInputs[i].index;
-                                prevTx = this.bitcoinJS.lib.Transaction.fromBuffer(input.nonWitnessUtxo);
-                                inTotal = inTotal.plus(prevTx.outs[prevIndex].value);
-                            }
-                            else {
-                                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'PSBT input missing UTXO data.');
-                            }
-                        }
-                        fee = inTotal;
-                        for (_i = 0, _a = decodedPSBT.txOutputs; _i < _a.length; _i++) {
-                            o = _a[_i];
-                            fee = fee.minus(o.value);
-                        }
-                        alerts = [];
-                        clonedPSBT = decodedPSBT.clone();
-                        (0, common_1.eachRecursive)(clonedPSBT);
-                        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, x, ourPublickey;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            isChangeAddress = false;
-                                            isOwned = false;
-                                            addressIndex = 0;
-                                            address = decodedPSBT.txOutputs[index].address;
-                                            amount = decodedPSBT.txOutputs[index].value;
-                                            if (!obj.bip32Derivation) return [3 /*break*/, 11];
-                                            isChangeAddress = true;
-                                            getIndexes = obj.bip32Derivation[0].path.split('/');
-                                            if (!(publickey.type === 'xpub')) return [3 /*break*/, 3];
-                                            return [4 /*yield*/, this.deriveFromExtendedPublicKey(publickey, 1, +getIndexes[getIndexes.length - 1])];
-                                        case 1:
-                                            ourPublickey = _a.sent();
-                                            return [4 /*yield*/, this.getAddressFromPublicKey(ourPublickey)];
-                                        case 2:
-                                            ourGeneratedAddress = _a.sent();
-                                            return [3 /*break*/, 5];
-                                        case 3: return [4 /*yield*/, this.getAddressFromNonExtendedPublicKey(publickey)];
-                                        case 4:
-                                            ourGeneratedAddress = _a.sent();
-                                            _a.label = 5;
-                                        case 5:
-                                            if (ourGeneratedAddress === address) {
-                                                isOwned = true;
-                                                addressIndex = +getIndexes[getIndexes.length - 1];
-                                            }
-                                            x = 0;
-                                            _a.label = 6;
-                                        case 6:
-                                            if (!(x < 1000)) return [3 /*break*/, 10];
-                                            return [4 /*yield*/, this.deriveFromExtendedPublicKey(publickey, 1, x)];
-                                        case 7:
-                                            ourPublickey = _a.sent();
-                                            return [4 /*yield*/, this.getAddressFromPublicKey(ourPublickey)];
-                                        case 8:
-                                            ourGeneratedAddress = _a.sent();
-                                            if (ourGeneratedAddress === address) {
-                                                isOwned = true;
-                                                addressIndex = x;
-                                                return [3 /*break*/, 10];
-                                            }
-                                            _a.label = 9;
-                                        case 9:
-                                            x++;
-                                            return [3 /*break*/, 6];
-                                        case 10: return [3 /*break*/, 16];
-                                        case 11:
-                                            if (!obj.unknownKeyVals) return [3 /*break*/, 16];
-                                            x = 0;
-                                            _a.label = 12;
-                                        case 12:
-                                            if (!(x < 1000)) return [3 /*break*/, 16];
-                                            isChangeAddress = true;
-                                            return [4 /*yield*/, this.deriveFromExtendedPublicKey(publickey, 1, x)];
-                                        case 13:
-                                            ourPublickey = _a.sent();
-                                            return [4 /*yield*/, this.getAddressFromPublicKey(ourPublickey)];
-                                        case 14:
-                                            ourGeneratedAddress = _a.sent();
-                                            if (ourGeneratedAddress === address) {
-                                                isOwned = true;
-                                                addressIndex = x;
-                                                return [3 /*break*/, 16];
-                                            }
-                                            _a.label = 15;
-                                        case 15:
-                                            x++;
-                                            return [3 /*break*/, 12];
-                                        case 16:
-                                            if (isChangeAddress && isOwned) {
-                                                alerts.push({
-                                                    type: 'success',
-                                                    title: {
-                                                        type: 'plain',
-                                                        value: ''
-                                                    },
-                                                    description: {
-                                                        type: 'plain',
-                                                        value: 'Note: your change address has been verified'
-                                                    },
-                                                    icon: undefined,
-                                                    actions: undefined
-                                                });
-                                            }
-                                            else if (isChangeAddress && !isOwned) {
-                                                alerts.push({
-                                                    type: 'warning',
-                                                    title: {
-                                                        type: 'plain',
-                                                        value: ''
-                                                    },
-                                                    description: {
-                                                        type: 'plain',
-                                                        value: 'Note: your change address has not been verified'
-                                                    },
-                                                    icon: undefined,
-                                                    actions: undefined
-                                                });
-                                            }
-                                            return [2 /*return*/, [
-                                                    address,
-                                                    {
-                                                        isChangeAddress: isChangeAddress,
-                                                        isOwned: isOwned,
-                                                        path: addressIndex === 0 ? '' : "m/44'/0'/0'/1/".concat(addressIndex),
-                                                        amount: amount
-                                                    }
-                                                ]];
-                                    }
-                                });
-                            }); }))];
-                    case 1:
-                        changeAddressDatas = _b.sent();
-                        changeAddressInfo = {};
-                        changeAddressDatas.forEach(function (changeAddressData) {
-                            changeAddressInfo[changeAddressData[0]] = changeAddressData[1];
-                        });
-                        return [2 /*return*/, [
-                                {
-                                    from: decodedPSBT.data.inputs.map(function (obj) {
-                                        var _a, _b;
-                                        return (_b = (_a = obj.bip32Derivation) === null || _a === void 0 ? void 0 : _a.map(function (el) {
-                                            return _this.bitcoinJS.lib.payments.p2pkh({
-                                                pubkey: el.pubkey,
-                                                network: _this.bitcoinJS.lib.networks.bitcoin
-                                            }).address;
-                                        }).join(' ')) !== null && _b !== void 0 ? _b : 'INVALID';
-                                    }),
-                                    to: decodedPSBT.txOutputs.map(function (obj) {
-                                        return obj.address || "Script: ".concat(obj.script.toString('hex')) || 'unknown';
-                                    }),
-                                    isInbound: false,
-                                    amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
-                                    fee: (0, module_kit_1.newAmount)(fee, 'blockchain'),
-                                    network: this.options.network,
-                                    changeAddressInfo: changeAddressInfo,
-                                    uiAlerts: alerts,
-                                    json: {
-                                        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
-                                    }
-                                }
-                            ]];
+            }
+            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);
             });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.verifyMessageWithPublicKey(message, signature, publicKey)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.encryptAsymmetricWithPublicKey(payload, publicKey)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getCryptoConfiguration = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.getCryptoConfiguration()];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
-        return __awaiter(this, void 0, void 0, function () {
-            var bip32, privateKeyUint8, privateKey, publicKeyUint8, publicKey;
-            return __generator(this, function (_a) {
-                bip32 = this.derivativeToBip32Node(derivative);
-                privateKeyUint8 = bip32.privateKey;
-                if (privateKeyUint8 === undefined) {
-                    throw new Error('No private key!');
+            if (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);
                 }
-                privateKey = Buffer.from(privateKeyUint8);
-                publicKeyUint8 = bip32.publicKey;
-                publicKey = Buffer.from(publicKeyUint8);
-                return [2 /*return*/, {
-                        secretKey: (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex'),
-                        publicKey: (0, module_kit_1.newPublicKey)(publicKey.toString('hex'), 'hex')
-                    }];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.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'
-                        })
-                    }];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.deriveFromExtendedSecretKey = function (extendedSecretKey, visibilityIndex, addressIndex) {
-        return __awaiter(this, void 0, void 0, function () {
-            var encodedSecretKey, derivedBip32, privateKeyUint8, privateKey;
-            return __generator(this, function (_a) {
-                encodedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
-                derivedBip32 = this.bip32
-                    .fromBase58(encodedSecretKey.value, this.bitcoinJS.config.network)
-                    .derive(visibilityIndex)
-                    .derive(addressIndex);
-                privateKeyUint8 = derivedBip32.privateKey;
-                if (privateKeyUint8 === undefined) {
-                    throw new Error('No private key!');
+                else {
+                    ourGeneratedAddress = await this.getAddressFromNonExtendedPublicKey(publickey);
                 }
-                privateKey = Buffer.from(privateKeyUint8);
-                return [2 /*return*/, (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex')];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.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.');
+                if (ourGeneratedAddress === address) {
+                    isOwned = true;
+                    addressIndex = +getIndexes[getIndexes.length - 1];
                 }
-                return [2 /*return*/];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.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');
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.signTransactionWithExtendedSecretKey = function (transaction, extendedSecretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var encodedExtendedSecretKey, bip32, decodedPSBT;
-            return __generator(this, function (_a) {
-                encodedExtendedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
-                bip32 = this.bip32.fromBase58(encodedExtendedSecretKey.value);
-                decodedPSBT = this.bitcoinJS.lib.Psbt.fromHex(transaction.psbt);
-                decodedPSBT.data.inputs.forEach(function (input, index) {
-                    var _a;
-                    (_a = input.bip32Derivation) === null || _a === void 0 ? void 0 : _a.forEach(function (deriv) {
-                        try {
-                            // This uses the same logic to find child key as the "findWalletByFingerprintDerivationPathAndProtocolIdentifier" method in the Vault
-                            var cutoffFrom = deriv.path.lastIndexOf("'") || deriv.path.lastIndexOf('h');
-                            var childPath = deriv.path.substr(cutoffFrom + 2);
-                            var childNode_1 = bip32.derivePath(childPath);
-                            // Wrap publicKey as Buffer to match Signer interface
-                            decodedPSBT.signInput(index, {
-                                publicKey: Buffer.from(childNode_1.publicKey),
-                                sign: function (hash, lowR) { return Buffer.from(childNode_1.sign(hash, lowR)); }
-                            });
-                        }
-                        catch (e) { }
-                    });
+                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
                 });
-                return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({ psbt: decodedPSBT.toHex() })];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.signMessageWithKeyPair(message, keyPair)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.decryptAsymmetricWithKeyPair(payload, keyPair)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.encryptAESWithSecretKey(payload, secretKey)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.decryptAESWithSecretKey(payload, secretKey)];
+            }
+            else if (isChangeAddress && !isOwned) {
+                alerts.push({
+                    type: 'warning',
+                    title: {
+                        type: 'plain',
+                        value: ''
+                    },
+                    description: {
+                        type: 'plain',
+                        value: 'Note: your change address has not been verified'
+                    },
+                    icon: undefined,
+                    actions: undefined
+                });
+            }
+            return [
+                address,
+                {
+                    isChangeAddress: isChangeAddress,
+                    isOwned: isOwned,
+                    path: addressIndex === 0 ? '' : `m/44'/0'/0'/1/${addressIndex}`,
+                    amount
+                }
+            ];
+        }));
+        const changeAddressInfo = {};
+        changeAddressDatas.forEach((changeAddressData) => {
+            changeAddressInfo[changeAddressData[0]] = changeAddressData[1];
+        });
+        return [
+            {
+                from: decodedPSBT.data.inputs.map((obj) => obj.bip32Derivation
+                    ?.map((el) => this.bitcoinJS.lib.payments.p2pkh({
+                    pubkey: el.pubkey,
+                    network: this.bitcoinJS.lib.networks.bitcoin
+                }).address)
+                    .join(' ') ?? 'INVALID'),
+                to: decodedPSBT.txOutputs.map((obj) => {
+                    return obj.address || `Script: ${obj.script.toString('hex')}` || 'unknown';
+                }),
+                isInbound: false,
+                amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
+                fee: (0, module_kit_1.newAmount)(fee, 'blockchain'),
+                network: this.options.network,
+                changeAddressInfo,
+                uiAlerts: alerts,
+                json: {
+                    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
+                }
+            }
+        ];
+    }
+    async verifyMessageWithPublicKey(message, signature, publicKey) {
+        return this.legacy.verifyMessageWithPublicKey(message, signature, publicKey);
+    }
+    async encryptAsymmetricWithPublicKey(payload, publicKey) {
+        return this.legacy.encryptAsymmetricWithPublicKey(payload, publicKey);
+    }
+    async getCryptoConfiguration() {
+        return this.legacy.getCryptoConfiguration();
+    }
+    async getKeyPairFromDerivative(derivative) {
+        const bip32 = this.derivativeToBip32Node(derivative);
+        const privateKeyUint8 = bip32.privateKey;
+        if (privateKeyUint8 === undefined) {
+            throw new Error('No private key!');
+        }
+        const privateKey = Buffer.from(privateKeyUint8);
+        const publicKeyUint8 = bip32.publicKey;
+        const publicKey = Buffer.from(publicKeyUint8);
+        return {
+            secretKey: (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex'),
+            publicKey: (0, module_kit_1.newPublicKey)(publicKey.toString('hex'), 'hex')
+        };
+    }
+    async getExtendedKeyPairFromDerivative(derivative) {
+        const bip32 = this.derivativeToBip32Node(derivative);
+        return {
+            secretKey: (0, module_kit_1.newExtendedSecretKey)(bip32.toBase58(), 'encoded'),
+            publicKey: (0, key_1.convertExtendedPublicKey)((0, module_kit_1.newExtendedPublicKey)(bip32.neutered().toBase58(), 'encoded'), {
+                format: 'encoded',
+                type: 'xpub'
+            })
+        };
+    }
+    async deriveFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex) {
+        const encodedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
+        const derivedBip32 = this.bip32
+            .fromBase58(encodedSecretKey.value, this.bitcoinJS.config.network)
+            .derive(visibilityIndex)
+            .derive(addressIndex);
+        const privateKeyUint8 = derivedBip32.privateKey;
+        if (privateKeyUint8 === undefined) {
+            throw new Error('No private key!');
+        }
+        const privateKey = Buffer.from(privateKeyUint8);
+        return (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex');
+    }
+    async signTransactionWithSecretKey(transaction, secretKey) {
+        switch (secretKey.type) {
+            case 'priv':
+                return this.signTransactionWithNonExtendedSecretKey(transaction, secretKey);
+            case 'xpriv':
+                return this.signTransactionWithExtendedSecretKey(transaction, secretKey);
+            default:
+                (0, coinlib_core_1.assertNever)(secretKey);
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Secret key type not supported.');
+        }
+    }
+    async signTransactionWithNonExtendedSecretKey(transaction, secretKey) {
+        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Sign with non extended secret key not supported');
+    }
+    async signTransactionWithExtendedSecretKey(transaction, extendedSecretKey) {
+        const encodedExtendedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
+        const bip32 = this.bip32.fromBase58(encodedExtendedSecretKey.value);
+        const decodedPSBT = this.bitcoinJS.lib.Psbt.fromHex(transaction.psbt);
+        decodedPSBT.data.inputs.forEach((input, index) => {
+            input.bip32Derivation?.forEach((deriv) => {
+                try {
+                    // This uses the same logic to find child key as the "findWalletByFingerprintDerivationPathAndProtocolIdentifier" method in the Vault
+                    const cutoffFrom = deriv.path.lastIndexOf("'") || deriv.path.lastIndexOf('h');
+                    const childPath = deriv.path.substr(cutoffFrom + 2);
+                    const childNode = bip32.derivePath(childPath);
+                    // Wrap publicKey as Buffer to match Signer interface
+                    decodedPSBT.signInput(index, {
+                        publicKey: Buffer.from(childNode.publicKey),
+                        sign: (hash, lowR) => Buffer.from(childNode.sign(hash, lowR))
+                    });
+                }
+                catch (e) { }
             });
         });
-    };
+        return (0, module_kit_1.newSignedTransaction)({ psbt: decodedPSBT.toHex() });
+    }
+    async signMessageWithKeyPair(message, keyPair) {
+        return this.legacy.signMessageWithKeyPair(message, keyPair);
+    }
+    async decryptAsymmetricWithKeyPair(payload, keyPair) {
+        return this.legacy.decryptAsymmetricWithKeyPair(payload, keyPair);
+    }
+    async encryptAESWithSecretKey(payload, secretKey) {
+        return this.legacy.encryptAESWithSecretKey(payload, secretKey);
+    }
+    async decryptAESWithSecretKey(payload, secretKey) {
+        return this.legacy.decryptAESWithSecretKey(payload, secretKey);
+    }
     // Online
-    BitcoinLegacyProtocolImpl.prototype.getNetwork = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.network];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.getTransactionsForPublicKey(publicKey, limit, cursor)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.getTransactionsForAddress(address, limit, cursor)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getTransactionsForAddresses = function (addresses, limit, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.getTransactionsForAddresses(addresses, limit, cursor)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.getBalanceOfPublicKey(publicKey)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getBalanceOfAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.getBalanceOfAddress(address)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getBalanceOfAddresses = function (addresses) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.getBalanceOfAddresses(addresses)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.getTransactionMaxAmountWithPublicKey(publicKey, to, configuration)];
-            });
-        });
-    };
-    BitcoinLegacyProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (_publicKey, _details, _configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.legacy.getTransactionFeeWithPublicKey(_publicKey, _details, _configuration)];
-            });
+    async getNetwork() {
+        return this.options.network;
+    }
+    async getTransactionsForPublicKey(publicKey, limit, cursor) {
+        return this.legacy.getTransactionsForPublicKey(publicKey, limit, cursor);
+    }
+    async getTransactionsForAddress(address, limit, cursor) {
+        return this.legacy.getTransactionsForAddress(address, limit, cursor);
+    }
+    async getTransactionsForAddresses(addresses, limit, cursor) {
+        return this.legacy.getTransactionsForAddresses(addresses, limit, cursor);
+    }
+    async getBalanceOfPublicKey(publicKey) {
+        return this.legacy.getBalanceOfPublicKey(publicKey);
+    }
+    async getBalanceOfAddress(address) {
+        return this.legacy.getBalanceOfAddress(address);
+    }
+    async getBalanceOfAddresses(addresses) {
+        return this.legacy.getBalanceOfAddresses(addresses);
+    }
+    async getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
+        return this.legacy.getTransactionMaxAmountWithPublicKey(publicKey, to, configuration);
+    }
+    async getTransactionFeeWithPublicKey(_publicKey, _details, _configuration) {
+        return this.legacy.getTransactionFeeWithPublicKey(_publicKey, _details, _configuration);
+    }
+    async prepareTransactionWithPublicKey(publicKey, details, configuration) {
+        switch (publicKey.type) {
+            case 'pub':
+                return this.prepareTransactionWithNonExtendedPublicKey(publicKey, details, configuration);
+            case 'xpub':
+                return this.prepareTransactionWithExtendedPublicKey(publicKey, details, configuration);
+            default:
+                (0, coinlib_core_1.assertNever)(publicKey);
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Unuspported public key type.');
+        }
+    }
+    async prepareTransactionWithNonExtendedPublicKey(publicKey, details, configuration) {
+        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Prepare transaction with non extended public key not supported');
+    }
+    async prepareTransactionWithExtendedPublicKey(extendedPublicKey, details, configuration) {
+        if (configuration?.masterFingerprint === undefined) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.BITCOIN, 'Master fingerprint not set.');
+        }
+        let fee;
+        if (configuration?.fee !== undefined) {
+            fee = configuration.fee;
+        }
+        else {
+            const estimatedFee = await this.getTransactionFeeWithPublicKey(extendedPublicKey, details);
+            fee = estimatedFee.medium;
+        }
+        const wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(this.legacy.units).value);
+        const transaction = (0, module_kit_1.newUnsignedTransaction)({
+            ins: [],
+            outs: []
         });
-    };
-    BitcoinLegacyProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (publicKey.type) {
-                    case 'pub':
-                        return [2 /*return*/, this.prepareTransactionWithNonExtendedPublicKey(publicKey, details, configuration)];
-                    case 'xpub':
-                        return [2 /*return*/, this.prepareTransactionWithExtendedPublicKey(publicKey, details, configuration)];
-                    default:
-                        (0, coinlib_core_1.assertNever)(publicKey);
-                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Unuspported public key type.');
-                }
-                return [2 /*return*/];
-            });
+        const { data: utxos } = await index_1.default.get(`${this.options.network.indexerApi}/api/v2/utxo/${extendedPublicKey.value}?confirmed=true`, {
+            responseType: 'json'
         });
-    };
-    BitcoinLegacyProtocolImpl.prototype.prepareTransactionWithNonExtendedPublicKey = function (publicKey, details, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Prepare transaction with non extended public key not supported');
+        if (utxos.length <= 0) {
+            throw new errors_1.BalanceError(coinlib_core_1.Domain.BITCOIN, 'Not enough balance.');
+        }
+        const totalRequiredBalance = details
+            .map(({ amount }) => new bignumber_1.default((0, module_kit_1.newAmount)(amount).blockchain(this.legacy.units).value))
+            .reduce((accumulator, currentValue) => accumulator.plus(currentValue))
+            .plus(wrappedFee);
+        let valueAccumulator = new bignumber_1.default(0);
+        const getPathIndexes = (path) => {
+            const result = path
+                .split('/')
+                .slice(-2)
+                .map((item) => parseInt(item))
+                .filter((item) => !isNaN(item));
+            if (result.length !== 2) {
+                throw new Error('Unexpected path format');
+            }
+            return [result[0], result[1]];
+        };
+        for (const utxo of utxos) {
+            valueAccumulator = valueAccumulator.plus(utxo.value);
+            const indexes = getPathIndexes(utxo.path);
+            const derivedPublicKey = await this.deriveFromExtendedPublicKey(extendedPublicKey, indexes[0], indexes[1]);
+            const derivedAddress = await this.getAddressFromPublicKey(derivedPublicKey);
+            if (derivedAddress === utxo.address) {
+                transaction.ins.push({
+                    txId: utxo.txid,
+                    value: new bignumber_1.default(utxo.value).toString(10),
+                    vout: utxo.vout,
+                    address: utxo.address,
+                    derivationPath: utxo.path
+                });
+            }
+            else {
+                throw new Error('Invalid address returned from API');
+            }
+            if (valueAccumulator.isGreaterThanOrEqualTo(totalRequiredBalance)) {
+                break;
+            }
+        }
+        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
+            throw new Error('not enough balance 2');
+        }
+        for (let i = 0; i < details.length; i++) {
+            const value = (0, module_kit_1.newAmount)(details[i].amount).blockchain(this.legacy.units).value;
+            transaction.outs.push({
+                recipient: details[i].to,
+                isChange: false,
+                value
+            });
+            valueAccumulator = valueAccumulator.minus(value);
+        }
+        const lastUsedInternalAddress = Math.max(-1, ...utxos
+            .map((utxo) => getPathIndexes(utxo.path))
+            .filter((indexes) => indexes[0] === 1)
+            .map((indexes) => indexes[1]));
+        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}`
             });
-        });
-    };
-    BitcoinLegacyProtocolImpl.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, _a, _b, tx, indexes, childNode, data, prevTxHex;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.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 = _c.sent();
-                        fee = estimatedFee.medium;
-                        _c.label = 3;
-                    case 3:
-                        wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(this.legacy.units).value);
-                        transaction = (0, module_kit_1.newUnsignedTransaction)({
-                            ins: [],
-                            outs: []
-                        });
-                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.indexerApi, "/api/v2/utxo/").concat(extendedPublicKey.value, "?confirmed=true"), {
-                                responseType: 'json'
-                            })];
-                    case 4:
-                        utxos = (_c.sent()).data;
-                        if (utxos.length <= 0) {
-                            throw new errors_1.BalanceError(coinlib_core_1.Domain.BITCOIN, 'Not enough balance.');
-                        }
-                        totalRequiredBalance = details
-                            .map(function (_a) {
-                            var amount = _a.amount;
-                            return new bignumber_1.default((0, module_kit_1.newAmount)(amount).blockchain(_this.legacy.units).value);
-                        })
-                            .reduce(function (accumulator, currentValue) { return accumulator.plus(currentValue); })
-                            .plus(wrappedFee);
-                        valueAccumulator = new bignumber_1.default(0);
-                        getPathIndexes = function (path) {
-                            var result = path
-                                .split('/')
-                                .slice(-2)
-                                .map(function (item) { return parseInt(item); })
-                                .filter(function (item) { return !isNaN(item); });
-                            if (result.length !== 2) {
-                                throw new Error('Unexpected path format');
-                            }
-                            return [result[0], result[1]];
-                        };
-                        _i = 0, utxos_1 = utxos;
-                        _c.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 = _c.sent();
-                        return [4 /*yield*/, this.getAddressFromPublicKey(derivedPublicKey)];
-                    case 7:
-                        derivedAddress = _c.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];
-                        }
-                        _c.label = 8;
-                    case 8:
-                        _i++;
-                        return [3 /*break*/, 5];
-                    case 9:
-                        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
-                            throw new Error('not enough balance 2');
-                        }
-                        for (i = 0; i < details.length; i++) {
-                            value = (0, module_kit_1.newAmount)(details[i].amount).blockchain(this.legacy.units).value;
-                            transaction.outs.push({
-                                recipient: details[i].to,
-                                isChange: false,
-                                value: value
-                            });
-                            valueAccumulator = valueAccumulator.minus(value);
-                        }
-                        lastUsedInternalAddress = Math.max.apply(Math, __spreadArray([-1], utxos
-                            .map(function (utxo) { return getPathIndexes(utxo.path); })
-                            .filter(function (indexes) { return indexes[0] === 1; })
-                            .map(function (indexes) { return indexes[1]; }), false));
-                        changeValue = valueAccumulator.minus(wrappedFee);
-                        if (!changeValue.isGreaterThan(new bignumber_1.default(DUST_AMOUNT))) return [3 /*break*/, 12];
-                        changeAddressIndex = lastUsedInternalAddress + 1;
-                        return [4 /*yield*/, this.deriveFromExtendedPublicKey(extendedPublicKey, 1, changeAddressIndex)];
-                    case 10:
-                        derivedPublicKey = _c.sent();
-                        return [4 /*yield*/, this.getAddressFromPublicKey(derivedPublicKey)];
-                    case 11:
-                        derivedAddress = _c.sent();
-                        transaction.outs.push({
-                            recipient: derivedAddress,
-                            isChange: true,
-                            value: changeValue.toString(10),
-                            derivationPath: "1/".concat(changeAddressIndex)
-                        });
-                        _c.label = 12;
-                    case 12:
-                        psbt = new this.bitcoinJS.lib.Psbt();
-                        psbt.addUnknownKeyValToGlobal({
-                            key: Buffer.from('amount'),
-                            value: Buffer.from(details
-                                .reduce(function (accumulator, next) {
-                                return accumulator.plus((0, module_kit_1.newAmount)(next.amount).blockchain(_this.legacy.units).value);
-                            }, new bignumber_1.default(0))
-                                .toString())
-                        });
-                        xpubExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
-                        keyPair = this.bip32.fromBase58(xpubExtendedPublicKey.value);
-                        replaceByFee = (configuration === null || configuration === void 0 ? void 0 : configuration.replaceByFee) ? true : false;
-                        _a = 0, _b = transaction.ins;
-                        _c.label = 13;
-                    case 13:
-                        if (!(_a < _b.length)) return [3 /*break*/, 16];
-                        tx = _b[_a];
-                        indexes = getPathIndexes(tx.derivationPath);
-                        childNode = keyPair.derivePath(indexes.join('/'));
-                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.indexerApi, "/api/v2/tx/").concat(tx.txId), {
-                                responseType: 'json'
-                            })];
-                    case 14:
-                        data = (_c.sent()).data;
-                        prevTxHex = data.hex;
-                        if (!prevTxHex) {
-                            throw new Error("Missing prev tx hex for ".concat(tx.txId));
-                        }
-                        psbt.addInput({
-                            hash: tx.txId,
-                            index: tx.vout,
-                            sequence: replaceByFee ? 0xfffffffd : undefined,
-                            nonWitnessUtxo: Buffer.from(prevTxHex, 'hex'),
-                            bip32Derivation: [
-                                {
-                                    masterFingerprint: Buffer.from(configuration.masterFingerprint.value, 'hex'),
-                                    pubkey: Buffer.from(childNode.publicKey),
-                                    path: tx.derivationPath
-                                }
-                            ]
-                        });
-                        _c.label = 15;
-                    case 15:
-                        _a++;
-                        return [3 /*break*/, 13];
-                    case 16:
-                        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 psbt = new this.bitcoinJS.lib.Psbt();
+        psbt.addUnknownKeyValToGlobal({
+            key: Buffer.from('amount'),
+            value: Buffer.from(details
+                .reduce((accumulator, next) => {
+                return accumulator.plus((0, module_kit_1.newAmount)(next.amount).blockchain(this.legacy.units).value);
+            }, new bignumber_1.default(0))
+                .toString())
+        });
+        const xpubExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
+        const keyPair = this.bip32.fromBase58(xpubExtendedPublicKey.value);
+        const replaceByFee = configuration?.replaceByFee ? true : false;
+        for (const tx of transaction.ins) {
+            const indexes = getPathIndexes(tx.derivationPath);
+            const childNode = keyPair.derivePath(indexes.join('/'));
+            const { data } = await index_1.default.get(`${this.options.network.indexerApi}/api/v2/tx/${tx.txId}`, {
+                responseType: 'json'
+            });
+            const prevTxHex = data.hex;
+            if (!prevTxHex) {
+                throw new Error(`Missing prev tx hex for ${tx.txId}`);
+            }
+            psbt.addInput({
+                hash: tx.txId,
+                index: tx.vout,
+                sequence: replaceByFee ? 0xfffffffd : undefined,
+                nonWitnessUtxo: Buffer.from(prevTxHex, 'hex'),
+                bip32Derivation: [
+                    {
+                        masterFingerprint: Buffer.from(configuration.masterFingerprint.value, 'hex'),
+                        pubkey: Buffer.from(childNode.publicKey),
+                        path: tx.derivationPath
+                    }
+                ]
             });
+        }
+        transaction.outs.forEach((out, index) => {
+            psbt.addOutput({ address: out.recipient, value: parseInt(out.value, 10) });
+            if (out.derivationPath) {
+                psbt.addUnknownKeyValToOutput(index, {
+                    key: Buffer.from('dp'),
+                    value: Buffer.from(out.derivationPath, 'utf8')
+                });
+            }
         });
-    };
-    BitcoinLegacyProtocolImpl.prototype.broadcastTransaction = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexTransaction, data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        hexTransaction = this.bitcoinJS.lib.Psbt.fromHex(transaction.psbt).finalizeAllInputs().extractTransaction().toHex();
-                        return [4 /*yield*/, index_1.default.post("".concat(this.options.network.indexerApi, "/api/v2/sendtx/"), hexTransaction)];
-                    case 1:
-                        data = (_a.sent()).data;
-                        return [2 /*return*/, data.result];
-                }
-            });
+        return (0, module_kit_1.newUnsignedTransaction)({ psbt: psbt.toHex() });
+    }
+    async broadcastTransaction(transaction) {
+        const hexTransaction = this.bitcoinJS.lib.Psbt.fromHex(transaction.psbt).finalizeAllInputs().extractTransaction().toHex();
+        const { data } = await index_1.default.post(`${this.options.network.indexerApi}/api/v2/sendtx/`, hexTransaction);
+        return data.result;
+    }
+    convertCryptoDerivative(derivative) {
+        const hexNode = (0, crypto_1.encodeDerivative)('hex', {
+            ...derivative,
+            secretKey: `00${derivative.secretKey}`
         });
-    };
-    BitcoinLegacyProtocolImpl.prototype.convertCryptoDerivative = function (derivative) {
-        var hexNode = (0, crypto_1.encodeDerivative)('hex', __assign(__assign({}, derivative), { secretKey: "00".concat(derivative.secretKey) }));
-        var extendedSecretKey = {
+        const extendedSecretKey = {
             type: 'xpriv',
             format: 'hex',
             value: hexNode.secretKey
         };
         return (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
-    };
-    BitcoinLegacyProtocolImpl.prototype.derivativeToBip32Node = function (derivative) {
-        var extendedSecretKey = this.convertCryptoDerivative(derivative);
+    }
+    derivativeToBip32Node(derivative) {
+        const extendedSecretKey = this.convertCryptoDerivative(derivative);
         return this.bip32.fromBase58(extendedSecretKey.value, this.bitcoinJS.config.network);
-    };
-    return BitcoinLegacyProtocolImpl;
-}());
+    }
+}
 exports.BitcoinLegacyProtocolImpl = BitcoinLegacyProtocolImpl;
 // Factory
-function createBitcoinLegacyProtocol(options) {
-    if (options === void 0) { options = {}; }
+function createBitcoinLegacyProtocol(options = {}) {
     return new BitcoinLegacyProtocolImpl(options);
 }
-exports.createBitcoinLegacyProtocol = createBitcoinLegacyProtocol;
 //# sourceMappingURL=BitcoinLegacyProtocol.js.map