@airgap/bitcoin 0.13.11-beta.1 → 0.13.11-beta.3

package/v1/protocol/BitcoinSegwitProtocol.js

@@ -0,0 +1,720 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBitcoinSegwitProtocol = exports.BitcoinSegwitProtocolImpl = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var errors_1 = require("@airgap/coinlib-core/errors");
+var crypto_1 = require("@airgap/crypto");
+var module_kit_1 = require("@airgap/module-kit");
+var bitcoin = __importStar(require("bitcoinjs-lib"));
+var BitcoinSegwitAddress_1 = require("../data/BitcoinSegwitAddress");
+var common_1 = require("../utils/common");
+var key_1 = require("../utils/key");
+var network_1 = require("../utils/network");
+var BitcoinProtocol_1 = require("./BitcoinProtocol");
+// Implementation
+var DUST_AMOUNT = 50;
+var BitcoinSegwitProtocolImpl = /** @class */ (function () {
+    function BitcoinSegwitProtocolImpl(options, bitcoinJS) {
+        if (options === void 0) { options = {}; }
+        if (bitcoinJS === void 0) { bitcoinJS = bitcoin; }
+        var _a, _b, _c;
+        this.legacy = new BitcoinProtocol_1.BitcoinProtocolImpl(options);
+        this.options = (0, BitcoinProtocol_1.createBitcoinProtocolOptions)(options.network);
+        this.bitcoinJS = {
+            lib: bitcoinJS,
+            config: {
+                network: (0, network_1.getBitcoinJSNetwork)(this.options.network, bitcoinJS)
+            }
+        };
+        this.metadata = __assign(__assign({}, this.legacy.metadata), { identifier: coinlib_core_1.MainProtocolSymbols.BTC_SEGWIT, name: 'Bitcoin (Segwit)', account: __assign(__assign({}, ((_a = this.legacy.metadata.account) !== null && _a !== void 0 ? _a : {})), { standardDerivationPath: "m/84'/0'/0'", address: __assign(__assign({}, ((_c = (_b = this.legacy.metadata.account) === null || _b === void 0 ? void 0 : _b.address) !== null && _c !== void 0 ? _c : {})), { regex: 'bc1...' }) }) });
+    }
+    BitcoinSegwitProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.metadata];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (publicKey.type) {
+                    case 'pub':
+                        return [2 /*return*/, this.getAddressFromNonExtendedPublicKey(publicKey)];
+                    case 'xpub':
+                        return [2 /*return*/, this.getAddressFromExtendedPublicKey(publicKey)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(publicKey);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Public key type is not supported.');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getAddressFromNonExtendedPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexPublicKey, payment;
+            return __generator(this, function (_a) {
+                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+                payment = this.bitcoinJS.lib.payments.p2wpkh({ pubkey: Buffer.from(hexPublicKey.value, 'hex') });
+                return [2 /*return*/, BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromPayment(payment).asString()];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getAddressFromExtendedPublicKey = function (extendedPublicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedExtendedPublicKey, bip32;
+            return __generator(this, function (_a) {
+                encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
+                bip32 = this.bitcoinJS.lib.bip32.fromBase58(encodedExtendedPublicKey.value, this.bitcoinJS.config.network);
+                return [2 /*return*/, BitcoinSegwitAddress_1.BitcoinSegwitAddress.fromBip32(bip32).asString()];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.deriveFromExtendedPublicKey = function (publicKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedPublicKey, derivedBip32;
+            return __generator(this, function (_a) {
+                encodedPublicKey = (0, key_1.convertExtendedPublicKey)(publicKey, { format: 'encoded', type: 'xpub' });
+                derivedBip32 = this.bitcoinJS.lib.bip32
+                    .fromBase58(encodedPublicKey.value, this.bitcoinJS.config.network)
+                    .derive(visibilityIndex)
+                    .derive(addressIndex);
+                return [2 /*return*/, (0, module_kit_1.newPublicKey)(derivedBip32.publicKey.toString('hex'), 'hex')];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, _publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getDetailsFromPSBT(transaction.psbt)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getDetailsFromPSBT = function (psbt) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var decodedPSBT, fee, _i, _c, txIn, _d, _e, txOut, alerts, clonedPSBT, amount;
+            var _this = this;
+            return __generator(this, function (_f) {
+                decodedPSBT = this.bitcoinJS.lib.Psbt.fromHex(psbt);
+                fee = new bignumber_1.default(0);
+                for (_i = 0, _c = decodedPSBT.data.inputs; _i < _c.length; _i++) {
+                    txIn = _c[_i];
+                    fee = fee.plus(new bignumber_1.default((_b = (_a = txIn.witnessUtxo) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 0));
+                }
+                for (_d = 0, _e = decodedPSBT.txOutputs; _d < _e.length; _d++) {
+                    txOut = _e[_d];
+                    fee = fee.minus(new bignumber_1.default(txOut.value));
+                }
+                alerts = [];
+                clonedPSBT = decodedPSBT.clone();
+                (0, common_1.eachRecursive)(clonedPSBT); // All buffers to hex string
+                amount = (function () {
+                    // If tx has only one output, this is the amount
+                    if (decodedPSBT.txOutputs.length === 1) {
+                        return new bignumber_1.default(decodedPSBT.txOutputs[0].value);
+                    }
+                    // If we can match one output to an exact amount that we add to the PSBT, this is our amount.
+                    {
+                        var unknownKeyVals = decodedPSBT.data.globalMap.unknownKeyVals;
+                        if (unknownKeyVals) {
+                            var amountArray = unknownKeyVals.filter(function (kv) { return kv.key.equals(Buffer.from('amount')); });
+                            if (amountArray.length > 0) {
+                                return new bignumber_1.default(amountArray[0].value.toString()); // Buffer to number
+                            }
+                        }
+                    }
+                    // If tx has an output and we added a derivation path in the PSBT (in the wallet, prepareTransaction), we know that it is a change address and we ignore it.
+                    var accumulated = new bignumber_1.default(0);
+                    var useAccumulated = false;
+                    decodedPSBT.data.outputs.forEach(function (outputKeyValues, index) {
+                        if (outputKeyValues.unknownKeyVals) {
+                            var derivationPaths = outputKeyValues.unknownKeyVals
+                                .filter(function (kv) { return kv.key.equals(Buffer.from('dp')); })
+                                .map(function (kv) { return kv.value.toString(); });
+                            if (derivationPaths.length > 0) {
+                                // If one of the outputs has the derivation in the custom key/value map, we can use this to determine the amount.
+                                useAccumulated = true;
+                                return;
+                            }
+                        }
+                        var output = decodedPSBT.txOutputs[index];
+                        accumulated = accumulated.plus(output.value);
+                    });
+                    if (useAccumulated) {
+                        return accumulated;
+                    }
+                    // If we cannot match anything above, we need to assume that the whole amount is being sent and the user has to check the outputs.
+                    return decodedPSBT.txOutputs
+                        .map(function (obj) { return new bignumber_1.default(obj.value); })
+                        .reduce(function (accumulator, currentValue) { return accumulator.plus(currentValue); });
+                })();
+                return [2 /*return*/, [
+                        {
+                            from: decodedPSBT.data.inputs.map(function (obj) {
+                                var _a, _b;
+                                return (_b = (_a = obj.bip32Derivation) === null || _a === void 0 ? void 0 : _a.map(function (el) {
+                                    return _this.bitcoinJS.lib.payments.p2wpkh({
+                                        pubkey: el.pubkey,
+                                        network: _this.bitcoinJS.lib.networks.bitcoin
+                                    }).address;
+                                }).join(' ')) !== null && _b !== void 0 ? _b : 'INVALID';
+                            }),
+                            to: decodedPSBT.txOutputs.map(function (obj) {
+                                return obj.address || "Script: ".concat(obj.script.toString('hex')) || 'unknown';
+                            }),
+                            isInbound: false,
+                            amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
+                            fee: (0, module_kit_1.newAmount)(fee, 'blockchain'),
+                            network: this.options.network,
+                            uiAlerts: alerts,
+                            json: {
+                                // This is some unstructured data about the PSBT. This is shown in the UI as a JSON for advanced users.
+                                inputTx: (0, common_1.eachRecursive)(clonedPSBT.txInputs),
+                                outputTx: (0, common_1.eachRecursive)(clonedPSBT.txOutputs),
+                                inputData: clonedPSBT.data.inputs,
+                                outputData: clonedPSBT.data.outputs,
+                                PSBTVersion: clonedPSBT.version,
+                                PSBTLocktime: clonedPSBT.locktime,
+                                PSBTGlobalMap: clonedPSBT.data.globalMap,
+                                rawPSBT: psbt
+                            }
+                        }
+                    ]];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.verifyMessageWithPublicKey(message, signature, publicKey)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.encryptAsymmetricWithPublicKey(payload, publicKey)];
+            });
+        });
+    };
+    // Offline
+    BitcoinSegwitProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getCryptoConfiguration()];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bip32, privateKey, publicKey;
+            return __generator(this, function (_a) {
+                bip32 = this.derivativeToBip32Node(derivative);
+                privateKey = bip32.privateKey;
+                if (privateKey === undefined) {
+                    throw new Error('No private key!');
+                }
+                publicKey = bip32.publicKey;
+                return [2 /*return*/, {
+                        secretKey: (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex'),
+                        publicKey: (0, module_kit_1.newPublicKey)(publicKey.toString('hex'), 'hex')
+                    }];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getExtendedKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bip32;
+            return __generator(this, function (_a) {
+                bip32 = this.derivativeToBip32Node(derivative);
+                return [2 /*return*/, {
+                        secretKey: (0, module_kit_1.newExtendedSecretKey)(bip32.toBase58(), 'encoded'),
+                        publicKey: (0, key_1.convertExtendedPublicKey)((0, module_kit_1.newExtendedPublicKey)(bip32.neutered().toBase58(), 'encoded'), {
+                            format: 'encoded',
+                            type: 'zpub'
+                        })
+                    }];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.deriveFromExtendedSecretKey = function (extendedSecretKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedSecretKey, derivedBip32, privateKey;
+            return __generator(this, function (_a) {
+                encodedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
+                derivedBip32 = this.bitcoinJS.lib.bip32
+                    .fromBase58(encodedSecretKey.value, this.bitcoinJS.config.network)
+                    .derive(visibilityIndex)
+                    .derive(addressIndex);
+                privateKey = derivedBip32.privateKey;
+                if (privateKey === undefined) {
+                    throw new Error('No private key!');
+                }
+                return [2 /*return*/, (0, module_kit_1.newSecretKey)(privateKey.toString('hex'), 'hex')];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (secretKey.type) {
+                    case 'priv':
+                        return [2 /*return*/, this.signTransactionWithNonExtendedSecretKey(transaction, secretKey)];
+                    case 'xpriv':
+                        return [2 /*return*/, this.signTransactionWithExtendedSecretKey(transaction, secretKey)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(secretKey);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Secret key type not supported.');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.signTransactionWithNonExtendedSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // No reference implementation in v0
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Sign with non extended secret key not supported (Segwit).');
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.signTransactionWithExtendedSecretKey = function (transaction, extendedSecretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedExtendedSecretKey, bip32, decodedPSBT;
+            return __generator(this, function (_a) {
+                encodedExtendedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
+                bip32 = this.bitcoinJS.lib.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);
+                            decodedPSBT.signInput(index, bip32.derivePath(childPath));
+                            console.log("Signed input ".concat(index, " with path ").concat(deriv.path));
+                        }
+                        catch (e) {
+                            console.log("Error signing input ".concat(index), e);
+                        }
+                    });
+                });
+                return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({ psbt: decodedPSBT.toHex() })];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.signMessageWithKeyPair(message, keyPair)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.decryptAsymmetricWithKeyPair(payload, keyPair)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.encryptAESWithSecretKey(payload, secretKey)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.decryptAESWithSecretKey(payload, secretKey)];
+            });
+        });
+    };
+    // Online
+    BitcoinSegwitProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getTransactionsForPublicKey(publicKey, limit, cursor)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getTransactionsForAddress(address, limit, cursor)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionsForAddresses = function (addresses, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getTransactionsForAddresses(addresses, limit, cursor)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getBalanceOfPublicKey(publicKey)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getBalanceOfAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getBalanceOfAddress(address)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getBalanceOfAddresses(addresses)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.legacy.getTransactionMaxAmountWithPublicKey(publicKey, to, configuration)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getTransactionFeeWithPublicKey(publicKey, details)];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (publicKey.type) {
+                    case 'pub':
+                        return [2 /*return*/, this.prepareTransactionWithNonExtendedPublicKey(publicKey, details, configuration)];
+                    case 'xpub':
+                        return [2 /*return*/, this.prepareTransactionWithExtendedPublicKey(publicKey, details, configuration)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(publicKey);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Unuspported public key type.');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.prepareTransactionWithNonExtendedPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // No reference implementation in v0
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.BITCOIN, 'Prepare transaction with non extended public key not supported (Segwit).');
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.prepareTransactionWithExtendedPublicKey = function (extendedPublicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fee, estimatedFee, wrappedFee, transaction, utxos, totalRequiredBalance, valueAccumulator, getPathIndexes, _i, utxos_1, utxo, indexes, derivedPublicKey, derivedAddress, i, value, lastUsedInternalAddress, changeValue, changeAddressIndex, derivedPublicKey, derivedAddress, psbt, xpubExtendedPublicKey, keyPair, replaceByFee;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if ((configuration === null || configuration === void 0 ? void 0 : configuration.masterFingerprint) === undefined) {
+                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.BITCOIN, 'Master fingerprint not set.');
+                        }
+                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 1];
+                        fee = configuration.fee;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.getTransactionFeeWithPublicKey(extendedPublicKey, details)];
+                    case 2:
+                        estimatedFee = _a.sent();
+                        fee = estimatedFee.medium;
+                        _a.label = 3;
+                    case 3:
+                        wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(this.legacy.units).value);
+                        transaction = (0, module_kit_1.newUnsignedTransaction)({
+                            ins: [],
+                            outs: []
+                        });
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.indexerApi, "/api/v2/utxo/").concat(extendedPublicKey.value, "?confirmed=true"), {
+                                responseType: 'json'
+                            })];
+                    case 4:
+                        utxos = (_a.sent()).data;
+                        if (utxos.length <= 0) {
+                            throw new errors_1.BalanceError(coinlib_core_1.Domain.BITCOIN, 'Not enough balance.'); // no transactions found on those addresses, probably won't find anything in the next ones
+                        }
+                        totalRequiredBalance = details
+                            .map(function (_a) {
+                            var amount = _a.amount;
+                            return new bignumber_1.default((0, module_kit_1.newAmount)(amount).blockchain(_this.legacy.units).value);
+                        })
+                            .reduce(function (accumulator, currentValue) { return accumulator.plus(currentValue); })
+                            .plus(wrappedFee);
+                        valueAccumulator = new bignumber_1.default(0);
+                        getPathIndexes = function (path) {
+                            var result = path
+                                .split('/')
+                                .slice(-2)
+                                .map(function (item) { return parseInt(item); })
+                                .filter(function (item) { return !isNaN(item); });
+                            if (result.length !== 2) {
+                                throw new Error('Unexpected path format');
+                            }
+                            return [result[0], result[1]];
+                        };
+                        _i = 0, utxos_1 = utxos;
+                        _a.label = 5;
+                    case 5:
+                        if (!(_i < utxos_1.length)) return [3 /*break*/, 9];
+                        utxo = utxos_1[_i];
+                        valueAccumulator = valueAccumulator.plus(utxo.value);
+                        indexes = getPathIndexes(utxo.path);
+                        return [4 /*yield*/, this.deriveFromExtendedPublicKey(extendedPublicKey, indexes[0], indexes[1])];
+                    case 6:
+                        derivedPublicKey = _a.sent();
+                        return [4 /*yield*/, this.getAddressFromPublicKey(derivedPublicKey)];
+                    case 7:
+                        derivedAddress = _a.sent();
+                        if (derivedAddress === utxo.address) {
+                            transaction.ins.push({
+                                txId: utxo.txid,
+                                value: new bignumber_1.default(utxo.value).toString(10),
+                                vout: utxo.vout,
+                                address: utxo.address,
+                                derivationPath: utxo.path
+                            });
+                        }
+                        else {
+                            throw new Error('Invalid address returned from API');
+                        }
+                        if (valueAccumulator.isGreaterThanOrEqualTo(totalRequiredBalance)) {
+                            return [3 /*break*/, 9];
+                        }
+                        _a.label = 8;
+                    case 8:
+                        _i++;
+                        return [3 /*break*/, 5];
+                    case 9:
+                        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
+                            throw new Error('not enough balance 2');
+                        }
+                        for (i = 0; i < details.length; i++) {
+                            value = (0, module_kit_1.newAmount)(details[i].amount).blockchain(this.legacy.units).value;
+                            transaction.outs.push({
+                                recipient: details[i].to,
+                                isChange: false,
+                                value: value
+                            });
+                            valueAccumulator = valueAccumulator.minus(value);
+                        }
+                        lastUsedInternalAddress = Math.max.apply(Math, __spreadArray([-1], utxos
+                            .map(function (utxo) { return getPathIndexes(utxo.path); })
+                            .filter(function (indexes) { return indexes[0] === 1; })
+                            .map(function (indexes) { return indexes[1]; }), false));
+                        changeValue = valueAccumulator.minus(wrappedFee);
+                        if (!changeValue.isGreaterThan(new bignumber_1.default(DUST_AMOUNT))) return [3 /*break*/, 12];
+                        changeAddressIndex = lastUsedInternalAddress + 1;
+                        return [4 /*yield*/, this.deriveFromExtendedPublicKey(extendedPublicKey, 1, changeAddressIndex)];
+                    case 10:
+                        derivedPublicKey = _a.sent();
+                        return [4 /*yield*/, this.getAddressFromPublicKey(derivedPublicKey)];
+                    case 11:
+                        derivedAddress = _a.sent();
+                        transaction.outs.push({
+                            recipient: derivedAddress,
+                            isChange: true,
+                            value: changeValue.toString(10),
+                            derivationPath: "1/".concat(changeAddressIndex)
+                        });
+                        _a.label = 12;
+                    case 12:
+                        psbt = new this.bitcoinJS.lib.Psbt();
+                        // We add the total amount of the transaction to the global map. This can be used to show the info in the "from-to" component after the transaction was signed.
+                        psbt.addUnknownKeyValToGlobal({
+                            key: Buffer.from('amount'),
+                            value: Buffer.from(details
+                                .reduce(function (accumulator, next) {
+                                return accumulator.plus((0, module_kit_1.newAmount)(next.amount).blockchain(_this.legacy.units).value);
+                            }, new bignumber_1.default(0))
+                                .toString())
+                        });
+                        xpubExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, { format: 'encoded', type: 'xpub' });
+                        keyPair = this.bitcoinJS.lib.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 p2wpkh = _this.bitcoinJS.lib.payments.p2wpkh({
+                                pubkey: childNode.publicKey,
+                                network: _this.bitcoinJS.config.network
+                            });
+                            var p2shOutput = p2wpkh.output;
+                            if (!p2shOutput) {
+                                throw new Error('no p2shOutput');
+                            }
+                            psbt.addInput({
+                                hash: tx.txId,
+                                index: tx.vout,
+                                sequence: replaceByFee ? 0xfffffffd : undefined,
+                                witnessUtxo: {
+                                    script: p2shOutput,
+                                    value: parseInt(tx.value, 10)
+                                },
+                                bip32Derivation: [
+                                    {
+                                        masterFingerprint: Buffer.from(configuration.masterFingerprint.value, 'hex'),
+                                        pubkey: childNode.publicKey,
+                                        path: tx.derivationPath
+                                    }
+                                ]
+                            });
+                        });
+                        transaction.outs.forEach(function (out, index) {
+                            psbt.addOutput({ address: out.recipient, value: parseInt(out.value, 10) });
+                            if (out.derivationPath) {
+                                // We add the derivation path of our change address to the key value map of the PSBT. This will allow us to later "filter" out this address when displaying the transaction info.
+                                psbt.addUnknownKeyValToOutput(index, {
+                                    key: Buffer.from('dp'),
+                                    value: Buffer.from(out.derivationPath, 'utf8')
+                                });
+                            }
+                        });
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({ psbt: psbt.toHex() })];
+                }
+            });
+        });
+    };
+    BitcoinSegwitProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexTransaction, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        hexTransaction = this.bitcoinJS.lib.Psbt.fromHex(transaction.psbt).finalizeAllInputs().extractTransaction().toHex();
+                        return [4 /*yield*/, index_1.default.post("".concat(this.options.network.indexerApi, "/api/v2/sendtx/"), hexTransaction)];
+                    case 1:
+                        data = (_a.sent()).data;
+                        return [2 /*return*/, data.result];
+                }
+            });
+        });
+    };
+    // Custom
+    BitcoinSegwitProtocolImpl.prototype.convertCryptoDerivative = function (derivative) {
+        var hexNode = (0, crypto_1.encodeDerivative)('hex', __assign(__assign({}, derivative), { secretKey: "00".concat(derivative.secretKey) }));
+        var extendedSecretKey = {
+            type: 'xpriv',
+            format: 'hex',
+            value: hexNode.secretKey
+        };
+        return (0, key_1.convertExtendedSecretKey)(extendedSecretKey, { format: 'encoded', type: 'xprv' });
+    };
+    BitcoinSegwitProtocolImpl.prototype.derivativeToBip32Node = function (derivative) {
+        var extendedSecretKey = this.convertCryptoDerivative(derivative);
+        return this.bitcoinJS.lib.bip32.fromBase58(extendedSecretKey.value, this.bitcoinJS.config.network);
+    };
+    return BitcoinSegwitProtocolImpl;
+}());
+exports.BitcoinSegwitProtocolImpl = BitcoinSegwitProtocolImpl;
+// Factory
+function createBitcoinSegwitProtocol(options) {
+    if (options === void 0) { options = {}; }
+    return new BitcoinSegwitProtocolImpl(options);
+}
+exports.createBitcoinSegwitProtocol = createBitcoinSegwitProtocol;
+//# sourceMappingURL=BitcoinSegwitProtocol.js.map