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

package/v0/protocol/BitcoinProtocol.js

@@ -15,77 +15,41 @@ 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.BitcoinProtocol = void 0;
-var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
-var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-var index_2 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0/index");
-var bitcoinJSMessage = __importStar(require("@airgap/coinlib-core/dependencies/src/bitcoinjs-message-2.1.1/index"));
-var errors_1 = require("@airgap/coinlib-core/errors");
-var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
-var ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
-var BitcoinAddress_1 = require("./BitcoinAddress");
-var BitcoinCryptoClient_1 = require("./BitcoinCryptoClient");
-var BitcoinProtocolOptions_1 = require("./BitcoinProtocolOptions");
-var DUST_AMOUNT = 50;
-var BitcoinProtocol = /** @class */ (function () {
-    function BitcoinProtocol(options) {
-        if (options === void 0) { options = new BitcoinProtocolOptions_1.BitcoinProtocolOptions(); }
+const index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
+const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+const index_2 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0/index");
+const bitcoinJSMessage = __importStar(require("@airgap/coinlib-core/dependencies/src/bitcoinjs-message-2.1.1/index"));
+const errors_1 = require("@airgap/coinlib-core/errors");
+const coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+const ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
+const BitcoinAddress_1 = require("./BitcoinAddress");
+const BitcoinCryptoClient_1 = require("./BitcoinCryptoClient");
+const BitcoinProtocolOptions_1 = require("./BitcoinProtocolOptions");
+const DUST_AMOUNT = 50;
+class BitcoinProtocol {
+    constructor(options = new BitcoinProtocolOptions_1.BitcoinProtocolOptions()) {
         this.options = options;
         this.symbol = 'BTC';
         this.name = 'Bitcoin (Legacy)';
@@ -114,957 +78,596 @@ var BitcoinProtocol = /** @class */ (function () {
             }
         ];
         this.supportsHD = true;
-        this.standardDerivationPath = "m/44'/0'/0'";
+        this.standardDerivationPath = `m/44'/0'/0'`;
         this.addressIsCaseSensitive = true;
         this.addressValidationPattern = '^(?:[13]{1}[a-km-zA-HJ-NP-Z1-9]{25,34}|bc1[a-z0-9]{39,59})$';
         this.addressPlaceholder = '1ABC...';
         this.cryptoClient = new BitcoinCryptoClient_1.BitcoinCryptoClient(this, bitcoinJSMessage);
     }
-    BitcoinProtocol.prototype.getSymbol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.symbol];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getName = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.name];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getMarketSymbol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.marketSymbol];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getAssetSymbol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, undefined];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getFeeSymbol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.feeSymbol];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getFeeDefaults = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.feeDefaults];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getDecimals = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.decimals];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getFeeDecimals = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.feeDecimals];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getIdentifier = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.identifier];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getUnits = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.units];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getSupportsHD = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.supportsHD];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getStandardDerivationPath = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.standardDerivationPath];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getAddressIsCaseSensitive = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.addressIsCaseSensitive];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getAddressValidationPattern = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.addressValidationPattern];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getAddressPlaceholder = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.addressPlaceholder];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getOptions = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getBlockExplorerLinkForAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.network.blockExplorer.getAddressLink(address)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getBlockExplorerLinkForTxId = function (txId) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.network.blockExplorer.getTransactionLink(txId)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getPublicKeyFromMnemonic = function (mnemonic, derivationPath, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var secret;
-            return __generator(this, function (_a) {
-                secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
-                return [2 /*return*/, this.getPublicKeyFromHexSecret(secret, derivationPath)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var secret;
-            return __generator(this, function (_a) {
-                secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
-                return [2 /*return*/, this.getPrivateKeyFromHexSecret(secret, derivationPath)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getExtendedPublicKeyFromMnemonic = function (mnemonic, derivationPath, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var secret;
-            return __generator(this, function (_a) {
-                secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
-                return [2 /*return*/, this.getExtendedPublicKeyFromHexSecret(secret, derivationPath)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getExtendedPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var secret;
-            return __generator(this, function (_a) {
-                secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
-                return [2 /*return*/, this.getExtendedPrivateKeyFromHexSecret(secret, derivationPath)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getPublicKeyFromHexSecret = function (secret, derivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var bitcoinNode;
-            return __generator(this, function (_a) {
-                bitcoinNode = this.options.config.bitcoinJSLib.HDNode.fromSeedHex(secret, this.options.network.extras.network);
-                return [2 /*return*/, bitcoinNode.derivePath(derivationPath).neutered().toBase58()];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getPrivateKeyFromHexSecret = function (secret, derivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var bitcoinNode;
-            return __generator(this, function (_a) {
-                bitcoinNode = this.options.config.bitcoinJSLib.HDNode.fromSeedHex(secret, this.options.network.extras.network);
-                return [2 /*return*/, bitcoinNode.derivePath(derivationPath).keyPair.d.toBuffer(32).toString('hex')];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getExtendedPublicKeyFromHexSecret = function (secret, derivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getPublicKeyFromHexSecret(secret, derivationPath)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getExtendedPrivateKeyFromHexSecret = function (secret, derivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var bitcoinNode;
-            return __generator(this, function (_a) {
-                bitcoinNode = this.options.config.bitcoinJSLib.HDNode.fromSeedHex(secret, this.options.network.extras.network);
-                return [2 /*return*/, bitcoinNode.derivePath(derivationPath).toBase58()];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getAddressFromPublicKey = function (publicKey, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            var node, address;
-            return __generator(this, function (_a) {
-                node = this.options.config.bitcoinJSLib.HDNode.fromBase58(publicKey, this.options.network.extras.network);
-                address = BitcoinAddress_1.BitcoinAddress.from(node);
-                return [2 /*return*/, {
-                        address: address.asString(),
-                        cursor: { hasNext: false }
-                    }];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getAddressesFromPublicKey = function (publicKey, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey, cursor)];
-                    case 1: return [2 /*return*/, [_a.sent()]];
+    async getSymbol() {
+        return this.symbol;
+    }
+    async getName() {
+        return this.name;
+    }
+    async getMarketSymbol() {
+        return this.marketSymbol;
+    }
+    async getAssetSymbol() {
+        return undefined;
+    }
+    async getFeeSymbol() {
+        return this.feeSymbol;
+    }
+    async getFeeDefaults() {
+        return this.feeDefaults;
+    }
+    async getDecimals() {
+        return this.decimals;
+    }
+    async getFeeDecimals() {
+        return this.feeDecimals;
+    }
+    async getIdentifier() {
+        return this.identifier;
+    }
+    async getUnits() {
+        return this.units;
+    }
+    async getSupportsHD() {
+        return this.supportsHD;
+    }
+    async getStandardDerivationPath() {
+        return this.standardDerivationPath;
+    }
+    async getAddressIsCaseSensitive() {
+        return this.addressIsCaseSensitive;
+    }
+    async getAddressValidationPattern() {
+        return this.addressValidationPattern;
+    }
+    async getAddressPlaceholder() {
+        return this.addressPlaceholder;
+    }
+    async getOptions() {
+        return this.options;
+    }
+    async getBlockExplorerLinkForAddress(address) {
+        return this.options.network.blockExplorer.getAddressLink(address);
+    }
+    async getBlockExplorerLinkForTxId(txId) {
+        return this.options.network.blockExplorer.getTransactionLink(txId);
+    }
+    async getPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
+        const secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
+        return this.getPublicKeyFromHexSecret(secret, derivationPath);
+    }
+    async getPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
+        const secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
+        return this.getPrivateKeyFromHexSecret(secret, derivationPath);
+    }
+    async getExtendedPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
+        const secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
+        return this.getExtendedPublicKeyFromHexSecret(secret, derivationPath);
+    }
+    async getExtendedPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
+        const secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
+        return this.getExtendedPrivateKeyFromHexSecret(secret, derivationPath);
+    }
+    async getPublicKeyFromHexSecret(secret, derivationPath) {
+        const bitcoinNode = this.options.config.bitcoinJSLib.HDNode.fromSeedHex(secret, this.options.network.extras.network);
+        return bitcoinNode.derivePath(derivationPath).neutered().toBase58();
+    }
+    async getPrivateKeyFromHexSecret(secret, derivationPath) {
+        const bitcoinNode = this.options.config.bitcoinJSLib.HDNode.fromSeedHex(secret, this.options.network.extras.network);
+        return bitcoinNode.derivePath(derivationPath).keyPair.d.toBuffer(32).toString('hex');
+    }
+    async getExtendedPublicKeyFromHexSecret(secret, derivationPath) {
+        return this.getPublicKeyFromHexSecret(secret, derivationPath);
+    }
+    async getExtendedPrivateKeyFromHexSecret(secret, derivationPath) {
+        const bitcoinNode = this.options.config.bitcoinJSLib.HDNode.fromSeedHex(secret, this.options.network.extras.network);
+        return bitcoinNode.derivePath(derivationPath).toBase58();
+    }
+    async getAddressFromPublicKey(publicKey, cursor) {
+        // broadcaster knows this (both broadcaster and signer)
+        const node = this.options.config.bitcoinJSLib.HDNode.fromBase58(publicKey, this.options.network.extras.network);
+        const address = BitcoinAddress_1.BitcoinAddress.from(node);
+        return {
+            address: address.asString(),
+            cursor: { hasNext: false }
+        };
+    }
+    async getAddressesFromPublicKey(publicKey, cursor) {
+        return [await this.getAddressFromPublicKey(publicKey, cursor)];
+    }
+    async getAddressFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
+        // broadcaster knows this (both broadcaster and signer)
+        const node = this.options.config.bitcoinJSLib.HDNode.fromBase58(extendedPublicKey, this.options.network.extras.network);
+        const address = BitcoinAddress_1.BitcoinAddress.from(node, visibilityDerivationIndex, addressDerivationIndex);
+        return {
+            address: address.asString(),
+            cursor: { hasNext: false }
+        };
+    }
+    async getAddressesFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressCount, offset) {
+        // broadcaster knows this (both broadcaster and signer)
+        const node = this.options.config.bitcoinJSLib.HDNode.fromBase58(extendedPublicKey, this.options.network.extras.network);
+        const generatorArray = Array.from(new Array(addressCount), (_, i) => i + offset);
+        return Promise.all(generatorArray.map((x) => {
+            const address = BitcoinAddress_1.BitcoinAddress.from(node, visibilityDerivationIndex, x);
+            return {
+                address: address.asString(),
+                cursor: { hasNext: false }
+            };
+        }));
+    }
+    async signWithPrivateKey(privateKey, transaction) {
+        const transactionBuilder = new this.options.config.bitcoinJSLib.TransactionBuilder(this.options.network.extras.network);
+        for (const input of transaction.ins) {
+            transactionBuilder.addInput(input.txId, input.vout);
+        }
+        for (const output of transaction.outs) {
+            if (output.isChange) {
+                // 1. `getAddressFromPublicKey` expects a base58 encoded key
+                const generatedChangeAddress = (await this.getAddressFromPublicKey(privateKey)).address;
+                if (generatedChangeAddress !== output.recipient) {
+                    throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.BITCOIN, 'Change address could not be verified.');
                 }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getAddressFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
-        return __awaiter(this, void 0, void 0, function () {
-            var node, address;
-            return __generator(this, function (_a) {
-                node = this.options.config.bitcoinJSLib.HDNode.fromBase58(extendedPublicKey, this.options.network.extras.network);
-                address = BitcoinAddress_1.BitcoinAddress.from(node, visibilityDerivationIndex, addressDerivationIndex);
-                return [2 /*return*/, {
-                        address: address.asString(),
-                        cursor: { hasNext: false }
-                    }];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getAddressesFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressCount, offset) {
-        return __awaiter(this, void 0, void 0, function () {
-            var node, generatorArray;
-            return __generator(this, function (_a) {
-                node = this.options.config.bitcoinJSLib.HDNode.fromBase58(extendedPublicKey, this.options.network.extras.network);
-                generatorArray = Array.from(new Array(addressCount), function (_, i) { return i + offset; });
-                return [2 /*return*/, Promise.all(generatorArray.map(function (x) {
-                        var address = BitcoinAddress_1.BitcoinAddress.from(node, visibilityDerivationIndex, x);
-                        return {
-                            address: address.asString(),
-                            cursor: { hasNext: false }
-                        };
-                    }))];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.signWithPrivateKey = function (privateKey, transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var transactionBuilder, _i, _a, input, _b, _c, output, generatedChangeAddress, i;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        transactionBuilder = new this.options.config.bitcoinJSLib.TransactionBuilder(this.options.network.extras.network);
-                        for (_i = 0, _a = transaction.ins; _i < _a.length; _i++) {
-                            input = _a[_i];
-                            transactionBuilder.addInput(input.txId, input.vout);
-                        }
-                        _b = 0, _c = transaction.outs;
-                        _d.label = 1;
-                    case 1:
-                        if (!(_b < _c.length)) return [3 /*break*/, 5];
-                        output = _c[_b];
-                        if (!output.isChange) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.getAddressFromPublicKey(privateKey)];
-                    case 2:
-                        generatedChangeAddress = (_d.sent()).address;
-                        if (generatedChangeAddress !== output.recipient) {
-                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.BITCOIN, 'Change address could not be verified.');
-                        }
-                        _d.label = 3;
-                    case 3:
-                        transactionBuilder.addOutput(output.recipient, new bignumber_1.default(output.value).toNumber());
-                        _d.label = 4;
-                    case 4:
-                        _b++;
-                        return [3 /*break*/, 1];
-                    case 5:
-                        for (i = 0; i < transaction.ins.length; i++) {
-                            // 2. `privateKey` is used as a hex string
-                            transactionBuilder.sign(i, Buffer.from(privateKey, 'hex'));
-                        }
-                        // TODO: given 1 & 2, check if it works
-                        return [2 /*return*/, transactionBuilder.build().toHex()];
+            }
+            transactionBuilder.addOutput(output.recipient, new bignumber_1.default(output.value).toNumber());
+        }
+        for (let i = 0; i < transaction.ins.length; i++) {
+            // 2. `privateKey` is used as a hex string
+            transactionBuilder.sign(i, Buffer.from(privateKey, 'hex'));
+        }
+        // TODO: given 1 & 2, check if it works
+        return transactionBuilder.build().toHex();
+    }
+    async signWithExtendedPrivateKey(extendedPrivateKey, transaction) {
+        const transactionBuilder = new this.options.config.bitcoinJSLib.TransactionBuilder(this.options.network.extras.network);
+        const node = this.options.config.bitcoinJSLib.HDNode.fromBase58(extendedPrivateKey, this.options.network.extras.network);
+        for (const input of transaction.ins) {
+            transactionBuilder.addInput(input.txId, input.vout);
+        }
+        const changeAddressBatchSize = 10;
+        const changeAddressMaxAddresses = 500;
+        for (const output of transaction.outs) {
+            let changeAddressIsValid = false;
+            if (output.isChange) {
+                if (output.derivationPath) {
+                    const generatedChangeAddress = (await this.getAddressesFromExtendedPublicKey(extendedPrivateKey, 1, 1, parseInt(output.derivationPath, 10))).map((address) => address.address);
+                    changeAddressIsValid = generatedChangeAddress.includes(output.recipient);
                 }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.signWithExtendedPrivateKey = function (extendedPrivateKey, transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var transactionBuilder, node, _i, _a, input, changeAddressBatchSize, changeAddressMaxAddresses, _b, _c, output, changeAddressIsValid, generatedChangeAddress, x, addresses, i;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        transactionBuilder = new this.options.config.bitcoinJSLib.TransactionBuilder(this.options.network.extras.network);
-                        node = this.options.config.bitcoinJSLib.HDNode.fromBase58(extendedPrivateKey, this.options.network.extras.network);
-                        for (_i = 0, _a = transaction.ins; _i < _a.length; _i++) {
-                            input = _a[_i];
-                            transactionBuilder.addInput(input.txId, input.vout);
-                        }
-                        changeAddressBatchSize = 10;
-                        changeAddressMaxAddresses = 500;
-                        _b = 0, _c = transaction.outs;
-                        _d.label = 1;
-                    case 1:
-                        if (!(_b < _c.length)) return [3 /*break*/, 10];
-                        output = _c[_b];
-                        changeAddressIsValid = false;
-                        if (!output.isChange) return [3 /*break*/, 8];
-                        if (!output.derivationPath) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.getAddressesFromExtendedPublicKey(extendedPrivateKey, 1, 1, parseInt(output.derivationPath, 10))];
-                    case 2:
-                        generatedChangeAddress = (_d.sent()).map(function (address) { return address.address; });
-                        changeAddressIsValid = generatedChangeAddress.includes(output.recipient);
-                        return [3 /*break*/, 7];
-                    case 3:
-                        x = 0;
-                        _d.label = 4;
-                    case 4:
-                        if (!(x < changeAddressMaxAddresses)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.getAddressesFromExtendedPublicKey(extendedPrivateKey, 1, changeAddressBatchSize, x)];
-                    case 5:
-                        addresses = (_d.sent()).map(function (address) { return address.address; });
+                else {
+                    for (let x = 0; x < changeAddressMaxAddresses; x += changeAddressBatchSize) {
+                        const addresses = (await this.getAddressesFromExtendedPublicKey(extendedPrivateKey, 1, changeAddressBatchSize, x)).map((address) => address.address);
                         if (addresses.indexOf(output.recipient) >= 0) {
                             changeAddressIsValid = true;
                             x = changeAddressMaxAddresses;
                         }
-                        _d.label = 6;
-                    case 6:
-                        x += changeAddressBatchSize;
-                        return [3 /*break*/, 4];
-                    case 7:
-                        if (!changeAddressIsValid) {
-                            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.BITCOIN, 'Change address could not be verified.');
-                        }
-                        _d.label = 8;
-                    case 8:
-                        transactionBuilder.addOutput(output.recipient, new bignumber_1.default(output.value).toNumber());
-                        _d.label = 9;
-                    case 9:
-                        _b++;
-                        return [3 /*break*/, 1];
-                    case 10:
-                        for (i = 0; i < transaction.ins.length; i++) {
-                            transactionBuilder.sign(i, node.derivePath(transaction.ins[i].derivationPath));
-                        }
-                        return [2 /*return*/, transactionBuilder.build().toHex()];
-                }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getTransactionDetails = function (unsignedTx) {
-        return __awaiter(this, void 0, void 0, function () {
-            var transaction, feeCalculator, _i, _a, txIn, _b, _c, txOut, warnings;
-            return __generator(this, function (_d) {
-                transaction = unsignedTx.transaction;
-                feeCalculator = new bignumber_1.default(0);
-                for (_i = 0, _a = transaction.ins; _i < _a.length; _i++) {
-                    txIn = _a[_i];
-                    feeCalculator = feeCalculator.plus(new bignumber_1.default(txIn.value));
-                }
-                for (_b = 0, _c = transaction.outs; _b < _c.length; _b++) {
-                    txOut = _c[_b];
-                    feeCalculator = feeCalculator.minus(new bignumber_1.default(txOut.value));
-                }
-                warnings = [];
-                return [2 /*return*/, [
-                        {
-                            from: transaction.ins.map(function (obj) { return obj.address; }),
-                            to: transaction.outs.filter(function (obj) { return !obj.isChange; }).map(function (obj) { return obj.recipient; }),
-                            amount: transaction.outs
-                                .filter(function (obj) { return !obj.isChange; })
-                                .map(function (obj) { return new bignumber_1.default(obj.value); })
-                                .reduce(function (accumulator, currentValue) { return accumulator.plus(currentValue); })
-                                .toString(10),
-                            fee: feeCalculator.toString(10),
-                            protocolIdentifier: this.identifier,
-                            network: this.options.network,
-                            isInbound: false,
-                            transactionDetails: unsignedTx.transaction,
-                            warnings: warnings
-                        }
-                    ]];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getTransactionDetailsFromSigned = function (signedTx) {
-        return __awaiter(this, void 0, void 0, function () {
-            var tx, bitcoinTx;
-            var _this = this;
-            return __generator(this, function (_a) {
-                tx = {
-                    to: [],
-                    from: signedTx.from,
-                    amount: signedTx.amount,
-                    fee: signedTx.fee,
-                    protocolIdentifier: this.identifier,
-                    network: this.options.network,
-                    isInbound: false,
-                    transactionDetails: signedTx.transaction
-                };
-                bitcoinTx = this.options.config.bitcoinJSLib.Transaction.fromHex(signedTx.transaction);
-                bitcoinTx.outs.forEach(function (output) {
-                    var address = _this.options.config.bitcoinJSLib.address.fromOutputScript(output.script, _this.options.network.extras.network);
-                    // only works if one output is target and rest is change, but this way we can filter out change addresses
-                    if (new bignumber_1.default(output.value).isEqualTo(signedTx.amount)) {
-                        tx.to.push(address);
                     }
-                });
-                return [2 /*return*/, [tx]];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getBalanceOfAddresses = function (addresses) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valueAccumulator, _i, addresses_1, address, data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        valueAccumulator = new bignumber_1.default(0);
-                        _i = 0, addresses_1 = addresses;
-                        _a.label = 1;
-                    case 1:
-                        if (!(_i < addresses_1.length)) return [3 /*break*/, 4];
-                        address = addresses_1[_i];
-                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.extras.indexerApi, "/api/v2/address/").concat(address, "?details=basic"), {
-                                responseType: 'json'
-                            })];
-                    case 2:
-                        data = (_a.sent()).data;
-                        valueAccumulator = valueAccumulator.plus(new bignumber_1.default(data.balance));
-                        _a.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, valueAccumulator.toString(10)];
                 }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getBalanceOfPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _a.sent();
-                        return [2 /*return*/, this.getBalanceOfAddresses([address.address])];
-                }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getBalanceOfExtendedPublicKey = function (extendedPublicKey, offset) {
-        if (offset === void 0) { offset = 0; }
-        return __awaiter(this, void 0, void 0, function () {
-            var data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.extras.indexerApi, "/api/v2/xpub/").concat(extendedPublicKey, "?pageSize=1"), {
-                            responseType: 'json'
-                        })];
-                    case 1:
-                        data = (_a.sent()).data;
-                        return [2 /*return*/, data.balance];
+                if (!changeAddressIsValid) {
+                    throw new errors_1.InvalidValueError(coinlib_error_1.Domain.BITCOIN, 'Change address could not be verified.');
                 }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getBalanceOfPublicKeyForSubProtocols = function (publicKey, subProtocols) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                throw Promise.reject('get balance of sub protocols not supported');
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getAvailableBalanceOfAddresses = function (addresses) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getBalanceOfAddresses(addresses)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.estimateMaxTransactionValueFromExtendedPublicKey = function (extendedPublicKey, recipients, fee) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getBalanceOfExtendedPublicKey(extendedPublicKey)];
-            });
+            }
+            transactionBuilder.addOutput(output.recipient, new bignumber_1.default(output.value).toNumber());
+        }
+        for (let i = 0; i < transaction.ins.length; i++) {
+            transactionBuilder.sign(i, node.derivePath(transaction.ins[i].derivationPath));
+        }
+        return transactionBuilder.build().toHex();
+    }
+    async getTransactionDetails(unsignedTx) {
+        // out of public information (both broadcaster and signer)
+        const transaction = unsignedTx.transaction;
+        let feeCalculator = new bignumber_1.default(0);
+        for (const txIn of transaction.ins) {
+            feeCalculator = feeCalculator.plus(new bignumber_1.default(txIn.value));
+        }
+        for (const txOut of transaction.outs) {
+            feeCalculator = feeCalculator.minus(new bignumber_1.default(txOut.value));
+        }
+        const warnings = [];
+        return [
+            {
+                from: transaction.ins.map((obj) => obj.address),
+                to: transaction.outs.filter((obj) => !obj.isChange).map((obj) => obj.recipient),
+                amount: transaction.outs
+                    .filter((obj) => !obj.isChange)
+                    .map((obj) => new bignumber_1.default(obj.value))
+                    .reduce((accumulator, currentValue) => accumulator.plus(currentValue))
+                    .toString(10),
+                fee: feeCalculator.toString(10),
+                protocolIdentifier: this.identifier,
+                network: this.options.network,
+                isInbound: false,
+                transactionDetails: unsignedTx.transaction,
+                warnings
+            }
+        ];
+    }
+    async getTransactionDetailsFromSigned(signedTx) {
+        const tx = {
+            to: [],
+            from: signedTx.from,
+            amount: signedTx.amount,
+            fee: signedTx.fee,
+            protocolIdentifier: this.identifier,
+            network: this.options.network,
+            isInbound: false,
+            transactionDetails: signedTx.transaction
+        };
+        const bitcoinTx = this.options.config.bitcoinJSLib.Transaction.fromHex(signedTx.transaction);
+        bitcoinTx.outs.forEach((output) => {
+            const address = this.options.config.bitcoinJSLib.address.fromOutputScript(output.script, this.options.network.extras.network);
+            // only works if one output is target and rest is change, but this way we can filter out change addresses
+            if (new bignumber_1.default(output.value).isEqualTo(signedTx.amount)) {
+                tx.to.push(address);
+            }
         });
-    };
-    BitcoinProtocol.prototype.estimateMaxTransactionValueFromPublicKey = function (publicKey, recipients, fee) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getBalanceOfPublicKey(publicKey)];
-            });
+        return [tx];
+    }
+    async getBalanceOfAddresses(addresses) {
+        let valueAccumulator = new bignumber_1.default(0);
+        // The API doesn't support batch checking of balances, so we have to do it manually
+        for (const address of addresses) {
+            const { data } = await index_1.default.get(`${this.options.network.extras.indexerApi}/api/v2/address/${address}?details=basic`, {
+                responseType: 'json'
+            });
+            valueAccumulator = valueAccumulator.plus(new bignumber_1.default(data.balance));
+        }
+        return valueAccumulator.toString(10);
+    }
+    async getBalanceOfPublicKey(publicKey) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getBalanceOfAddresses([address.address]);
+    }
+    async getBalanceOfExtendedPublicKey(extendedPublicKey, offset = 0) {
+        const { data } = await index_1.default.get(`${this.options.network.extras.indexerApi}/api/v2/xpub/${extendedPublicKey}?pageSize=1`, {
+            responseType: 'json'
         });
-    };
-    BitcoinProtocol.prototype.estimateFeeDefaultsFromExtendedPublicKey = function (publicKey, recipients, values, data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result, estimatedFee, feeStepFactor, mediumFee, lowFee, highFee;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.extras.indexerApi, "/api/v2/estimatefee/5"))];
-                    case 1:
-                        result = (_a.sent()).data.result;
-                        estimatedFee = new bignumber_1.default(result).shiftedBy(this.feeDecimals);
-                        if (estimatedFee.isZero()) {
-                            return [2 /*return*/, this.feeDefaults];
-                        }
-                        feeStepFactor = new bignumber_1.default(0.5);
-                        mediumFee = estimatedFee;
-                        lowFee = mediumFee.minus(mediumFee.times(feeStepFactor)).integerValue(bignumber_1.default.ROUND_FLOOR);
-                        highFee = mediumFee.plus(mediumFee.times(feeStepFactor)).integerValue(bignumber_1.default.ROUND_FLOOR);
-                        return [2 /*return*/, {
-                                low: lowFee.shiftedBy(-this.feeDecimals).toFixed(),
-                                medium: mediumFee.shiftedBy(-this.feeDecimals).toFixed(),
-                                high: highFee.shiftedBy(-this.feeDecimals).toFixed()
-                            }];
-                }
+        return data.balance;
+    }
+    async getBalanceOfPublicKeyForSubProtocols(publicKey, subProtocols) {
+        throw Promise.reject('get balance of sub protocols not supported');
+    }
+    async getAvailableBalanceOfAddresses(addresses) {
+        return this.getBalanceOfAddresses(addresses);
+    }
+    async estimateMaxTransactionValueFromExtendedPublicKey(extendedPublicKey, recipients, fee) {
+        return this.getBalanceOfExtendedPublicKey(extendedPublicKey);
+    }
+    async estimateMaxTransactionValueFromPublicKey(publicKey, recipients, fee) {
+        return this.getBalanceOfPublicKey(publicKey);
+    }
+    async estimateFeeDefaultsFromExtendedPublicKey(publicKey, recipients, values, data) {
+        const result = (await index_1.default.get(`${this.options.network.extras.indexerApi}/api/v2/estimatefee/5`)).data.result;
+        const estimatedFee = new bignumber_1.default(result).shiftedBy(this.feeDecimals);
+        if (estimatedFee.isZero()) {
+            return this.feeDefaults;
+        }
+        const feeStepFactor = new bignumber_1.default(0.5);
+        const mediumFee = estimatedFee;
+        const lowFee = mediumFee.minus(mediumFee.times(feeStepFactor)).integerValue(bignumber_1.default.ROUND_FLOOR);
+        const highFee = mediumFee.plus(mediumFee.times(feeStepFactor)).integerValue(bignumber_1.default.ROUND_FLOOR);
+        return {
+            low: lowFee.shiftedBy(-this.feeDecimals).toFixed(),
+            medium: mediumFee.shiftedBy(-this.feeDecimals).toFixed(),
+            high: highFee.shiftedBy(-this.feeDecimals).toFixed()
+        };
+    }
+    async estimateFeeDefaultsFromPublicKey(publicKey, recipients, values, data) {
+        return Promise.reject('estimating fee defaults using non extended public key not implemented');
+    }
+    async prepareTransactionFromExtendedPublicKey(extendedPublicKey, offset, recipients, values, fee, extras) {
+        const wrappedValues = values.map((value) => new bignumber_1.default(value));
+        const wrappedFee = new bignumber_1.default(fee);
+        const transaction = {
+            ins: [],
+            outs: []
+        };
+        if (recipients.length !== wrappedValues.length) {
+            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.BITCOIN, 'recipients do not match values');
+        }
+        const { data: utxos } = await index_1.default
+            .get(`${this.options.network.extras.indexerApi}/api/v2/utxo/${extendedPublicKey}?confirmed=true`, {
+            responseType: 'json'
+        })
+            .catch((error) => {
+            throw new errors_1.NetworkError(coinlib_error_1.Domain.BITCOIN, error);
+        });
+        if (utxos.length <= 0) {
+            throw new errors_1.BalanceError(coinlib_error_1.Domain.BITCOIN, 'not enough balance'); // no transactions found on those addresses, probably won't find anything in the next ones
+        }
+        const totalRequiredBalance = wrappedValues
+            .reduce((accumulator, currentValue) => accumulator.plus(currentValue))
+            .plus(wrappedFee);
+        let valueAccumulator = new bignumber_1.default(0);
+        const getPathIndexes = (path) => {
+            const result = path
+                .split('/')
+                .slice(-2)
+                .map((item) => parseInt(item, 10))
+                .filter((item) => !isNaN(item));
+            if (result.length !== 2) {
+                throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.BITCOIN, 'Unexpected path format');
+            }
+            return [result[0], result[1]];
+        };
+        for (const utxo of utxos) {
+            valueAccumulator = valueAccumulator.plus(utxo.value);
+            const indexes = getPathIndexes(utxo.path);
+            const derivedAddress = await this.getAddressFromExtendedPublicKey(extendedPublicKey, indexes[0], indexes[1]);
+            if (derivedAddress.address === utxo.address) {
+                transaction.ins.push({
+                    txId: utxo.txid,
+                    value: new bignumber_1.default(utxo.value).toString(10),
+                    vout: utxo.vout,
+                    address: utxo.address,
+                    derivationPath: indexes.join('/')
+                });
+            }
+            else {
+                throw new errors_1.InvalidValueError(coinlib_error_1.Domain.BITCOIN, `Invalid address ${JSON.stringify(utxo.address)} returned from API`);
+            }
+            if (valueAccumulator.isGreaterThanOrEqualTo(totalRequiredBalance)) {
+                break;
+            }
+        }
+        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
+            throw new errors_1.BalanceError(coinlib_error_1.Domain.BITCOIN, 'not enough balance');
+        }
+        for (let i = 0; i < recipients.length; i++) {
+            transaction.outs.push({
+                recipient: recipients[i],
+                isChange: false,
+                value: wrappedValues[i].toString(10),
+                derivationPath: '' // TODO: Remove this as soon as our serializer supports optional properties
+            });
+            valueAccumulator = valueAccumulator.minus(wrappedValues[i]);
+        }
+        const lastUsedInternalAddress = Math.max(-1, ...utxos
+            .map((utxo) => getPathIndexes(utxo.path))
+            .filter((indexes) => indexes[0] === 1)
+            .map((indexes) => indexes[1]));
+        // If the change is considered dust, the transaction will fail.
+        // Dust is a variable value around 300-600 satoshis, depending on the configuration.
+        // We set a low fee here to not block any transactions, but it might still fail due to "dust".
+        const changeValue = valueAccumulator.minus(wrappedFee);
+        if (changeValue.isGreaterThan(new bignumber_1.default(DUST_AMOUNT))) {
+            const changeAddressIndex = lastUsedInternalAddress + 1;
+            const derivedAddress = await this.getAddressFromExtendedPublicKey(extendedPublicKey, 1, changeAddressIndex);
+            transaction.outs.push({
+                recipient: derivedAddress.address,
+                isChange: true,
+                value: changeValue.toString(10),
+                derivationPath: changeAddressIndex.toString()
             });
-        });
-    };
-    BitcoinProtocol.prototype.estimateFeeDefaultsFromPublicKey = function (publicKey, recipients, values, data) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, Promise.reject('estimating fee defaults using non extended public key not implemented')];
+        }
+        return transaction;
+    }
+    async prepareTransactionFromPublicKey(publicKey, recipients, values, fee) {
+        const wrappedValues = values.map((value) => new bignumber_1.default(value));
+        const wrappedFee = new bignumber_1.default(fee);
+        const transaction = {
+            ins: [],
+            outs: []
+        };
+        if (recipients.length !== wrappedValues.length) {
+            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.BITCOIN, 'Recipient and value length does not match.');
+        }
+        const address = (await this.getAddressFromPublicKey(publicKey)).address;
+        const { data: utxos } = await index_1.default.get(`${this.options.network.extras.indexerApi}/api/v2/utxo/${address}`, {
+            responseType: 'json'
+        });
+        const totalRequiredBalance = wrappedValues
+            .reduce((accumulator, currentValue) => accumulator.plus(currentValue))
+            .plus(wrappedFee);
+        let valueAccumulator = new bignumber_1.default(0);
+        for (const utxo of utxos) {
+            valueAccumulator = valueAccumulator.plus(new bignumber_1.default(utxo.value));
+            transaction.ins.push({
+                txId: utxo.txid,
+                value: new bignumber_1.default(utxo.value).toString(10),
+                vout: utxo.vout,
+                address
+            });
+            if (valueAccumulator.isGreaterThanOrEqualTo(totalRequiredBalance)) {
+                break;
+            }
+        }
+        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
+            throw new errors_1.BalanceError(coinlib_error_1.Domain.BITCOIN, `not enough balance, having ${valueAccumulator.toFixed()} of ${totalRequiredBalance.toFixed()}`);
+        }
+        // tx.addInput(utxo.txid, utxo.vout)
+        for (let i = 0; i < recipients.length; i++) {
+            transaction.outs.push({
+                recipient: recipients[i],
+                isChange: false,
+                value: wrappedValues[i].toString(10)
+            });
+            valueAccumulator = valueAccumulator.minus(wrappedValues[i]);
+            // tx.addOutput(recipients[i], values[i])
+        }
+        // If the change is considered dust, the transaction will fail.
+        // Dust is a variable value around 300-600 satoshis, depending on the configuration.
+        // We set a low fee here to not block any transactions, but it might still fail due to "dust".
+        const changeValue = valueAccumulator.minus(wrappedFee);
+        if (changeValue.isGreaterThan(new bignumber_1.default(DUST_AMOUNT))) {
+            transaction.outs.push({
+                recipient: address,
+                isChange: true,
+                value: changeValue.toString(10)
             });
-        });
-    };
-    BitcoinProtocol.prototype.prepareTransactionFromExtendedPublicKey = function (extendedPublicKey, offset, recipients, values, fee, extras) {
-        return __awaiter(this, void 0, void 0, function () {
-            var wrappedValues, wrappedFee, transaction, utxos, totalRequiredBalance, valueAccumulator, getPathIndexes, _i, utxos_1, utxo, indexes, derivedAddress, i, lastUsedInternalAddress, changeValue, changeAddressIndex, derivedAddress;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        wrappedValues = values.map(function (value) { return new bignumber_1.default(value); });
-                        wrappedFee = new bignumber_1.default(fee);
-                        transaction = {
-                            ins: [],
-                            outs: []
-                        };
-                        if (recipients.length !== wrappedValues.length) {
-                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.BITCOIN, 'recipients do not match values');
-                        }
-                        return [4 /*yield*/, index_1.default
-                                .get("".concat(this.options.network.extras.indexerApi, "/api/v2/utxo/").concat(extendedPublicKey, "?confirmed=true"), {
-                                responseType: 'json'
-                            })
-                                .catch(function (error) {
-                                throw new errors_1.NetworkError(coinlib_error_1.Domain.BITCOIN, error);
-                            })];
-                    case 1:
-                        utxos = (_a.sent()).data;
-                        if (utxos.length <= 0) {
-                            throw new errors_1.BalanceError(coinlib_error_1.Domain.BITCOIN, 'not enough balance'); // no transactions found on those addresses, probably won't find anything in the next ones
-                        }
-                        totalRequiredBalance = wrappedValues
-                            .reduce(function (accumulator, currentValue) { return accumulator.plus(currentValue); })
-                            .plus(wrappedFee);
-                        valueAccumulator = new bignumber_1.default(0);
-                        getPathIndexes = function (path) {
-                            var result = path
-                                .split('/')
-                                .slice(-2)
-                                .map(function (item) { return parseInt(item, 10); })
-                                .filter(function (item) { return !isNaN(item); });
-                            if (result.length !== 2) {
-                                throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.BITCOIN, 'Unexpected path format');
-                            }
-                            return [result[0], result[1]];
-                        };
-                        _i = 0, utxos_1 = utxos;
-                        _a.label = 2;
-                    case 2:
-                        if (!(_i < utxos_1.length)) return [3 /*break*/, 5];
-                        utxo = utxos_1[_i];
-                        valueAccumulator = valueAccumulator.plus(utxo.value);
-                        indexes = getPathIndexes(utxo.path);
-                        return [4 /*yield*/, this.getAddressFromExtendedPublicKey(extendedPublicKey, indexes[0], indexes[1])];
-                    case 3:
-                        derivedAddress = _a.sent();
-                        if (derivedAddress.address === utxo.address) {
-                            transaction.ins.push({
-                                txId: utxo.txid,
-                                value: new bignumber_1.default(utxo.value).toString(10),
-                                vout: utxo.vout,
-                                address: utxo.address,
-                                derivationPath: indexes.join('/')
-                            });
-                        }
-                        else {
-                            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.BITCOIN, "Invalid address ".concat(JSON.stringify(utxo.address), " returned from API"));
-                        }
-                        if (valueAccumulator.isGreaterThanOrEqualTo(totalRequiredBalance)) {
-                            return [3 /*break*/, 5];
-                        }
-                        _a.label = 4;
-                    case 4:
-                        _i++;
-                        return [3 /*break*/, 2];
-                    case 5:
-                        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
-                            throw new errors_1.BalanceError(coinlib_error_1.Domain.BITCOIN, 'not enough balance');
-                        }
-                        for (i = 0; i < recipients.length; i++) {
-                            transaction.outs.push({
-                                recipient: recipients[i],
-                                isChange: false,
-                                value: wrappedValues[i].toString(10),
-                                derivationPath: '' // TODO: Remove this as soon as our serializer supports optional properties
-                            });
-                            valueAccumulator = valueAccumulator.minus(wrappedValues[i]);
-                        }
-                        lastUsedInternalAddress = Math.max.apply(Math, __spreadArray([-1], utxos
-                            .map(function (utxo) { return getPathIndexes(utxo.path); })
-                            .filter(function (indexes) { return indexes[0] === 1; })
-                            .map(function (indexes) { return indexes[1]; }), false));
-                        changeValue = valueAccumulator.minus(wrappedFee);
-                        if (!changeValue.isGreaterThan(new bignumber_1.default(DUST_AMOUNT))) return [3 /*break*/, 7];
-                        changeAddressIndex = lastUsedInternalAddress + 1;
-                        return [4 /*yield*/, this.getAddressFromExtendedPublicKey(extendedPublicKey, 1, changeAddressIndex)];
-                    case 6:
-                        derivedAddress = _a.sent();
-                        transaction.outs.push({
-                            recipient: derivedAddress.address,
-                            isChange: true,
-                            value: changeValue.toString(10),
-                            derivationPath: changeAddressIndex.toString()
-                        });
-                        _a.label = 7;
-                    case 7: return [2 /*return*/, transaction];
+        }
+        return transaction;
+    }
+    async broadcastTransaction(rawTransaction) {
+        const { data } = await index_1.default.post(this.options.network.extras.indexerApi + '/api/v2/sendtx/', rawTransaction);
+        return data.result;
+    }
+    async getTransactionsFromExtendedPublicKey(extendedPublicKey, limit, cursor, addressOffset = 0) {
+        const page = cursor?.page ?? 1;
+        const { data } = await index_1.default.get(this.options.network.extras.indexerApi +
+            '/api/v2/xpub/' +
+            extendedPublicKey +
+            `?details=txs&tokens=used&pageSize=${limit}&page=${page}`, {
+            responseType: 'json'
+        });
+        const ourAddresses = (data.tokens || []).filter((token) => token.type === 'XPUBAddress').map((token) => token.name);
+        const airGapTransactions = [];
+        if (data.page == page) {
+            for (const transaction of data.transactions || []) {
+                const tempAirGapTransactionFrom = [];
+                const tempAirGapTransactionTo = [];
+                let tempAirGapTransactionIsInbound = true;
+                let amount = new bignumber_1.default(0);
+                for (const vin of transaction.vin) {
+                    if (this.containsSome(vin.addresses, ourAddresses)) {
+                        tempAirGapTransactionIsInbound = false;
+                    }
+                    tempAirGapTransactionFrom.push(...vin.addresses);
+                    amount = amount.plus(vin.value);
                 }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.prepareTransactionFromPublicKey = function (publicKey, recipients, values, fee) {
-        return __awaiter(this, void 0, void 0, function () {
-            var wrappedValues, wrappedFee, transaction, address, utxos, totalRequiredBalance, valueAccumulator, _i, utxos_2, utxo, i, changeValue;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        wrappedValues = values.map(function (value) { return new bignumber_1.default(value); });
-                        wrappedFee = new bignumber_1.default(fee);
-                        transaction = {
-                            ins: [],
-                            outs: []
-                        };
-                        if (recipients.length !== wrappedValues.length) {
-                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.BITCOIN, 'Recipient and value length does not match.');
+                for (const vout of transaction.vout) {
+                    if (vout.addresses) {
+                        tempAirGapTransactionTo.push(...vout.addresses);
+                        // If receiving address is our address, and transaction is outbound => our change
+                        if (this.containsSome(vout.addresses, ourAddresses) && !tempAirGapTransactionIsInbound) {
+                            // remove only if related to this address
+                            amount = amount.minus(vout.value);
                         }
-                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = (_a.sent()).address;
-                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.extras.indexerApi, "/api/v2/utxo/").concat(address), {
-                                responseType: 'json'
-                            })];
-                    case 2:
-                        utxos = (_a.sent()).data;
-                        totalRequiredBalance = wrappedValues
-                            .reduce(function (accumulator, currentValue) { return accumulator.plus(currentValue); })
-                            .plus(wrappedFee);
-                        valueAccumulator = new bignumber_1.default(0);
-                        for (_i = 0, utxos_2 = utxos; _i < utxos_2.length; _i++) {
-                            utxo = utxos_2[_i];
-                            valueAccumulator = valueAccumulator.plus(new bignumber_1.default(utxo.value));
-                            transaction.ins.push({
-                                txId: utxo.txid,
-                                value: new bignumber_1.default(utxo.value).toString(10),
-                                vout: utxo.vout,
-                                address: address
-                            });
-                            if (valueAccumulator.isGreaterThanOrEqualTo(totalRequiredBalance)) {
-                                break;
-                            }
+                        // If receiving address is not ours, and transaction isbound => senders change
+                        if (!this.containsSome(vout.addresses, ourAddresses) && tempAirGapTransactionIsInbound) {
+                            amount = amount.minus(vout.value);
                         }
-                        if (valueAccumulator.isLessThan(totalRequiredBalance)) {
-                            throw new errors_1.BalanceError(coinlib_error_1.Domain.BITCOIN, "not enough balance, having ".concat(valueAccumulator.toFixed(), " of ").concat(totalRequiredBalance.toFixed()));
-                        }
-                        // tx.addInput(utxo.txid, utxo.vout)
-                        for (i = 0; i < recipients.length; i++) {
-                            transaction.outs.push({
-                                recipient: recipients[i],
-                                isChange: false,
-                                value: wrappedValues[i].toString(10)
-                            });
-                            valueAccumulator = valueAccumulator.minus(wrappedValues[i]);
-                            // tx.addOutput(recipients[i], values[i])
-                        }
-                        changeValue = valueAccumulator.minus(wrappedFee);
-                        if (changeValue.isGreaterThan(new bignumber_1.default(DUST_AMOUNT))) {
-                            transaction.outs.push({
-                                recipient: address,
-                                isChange: true,
-                                value: changeValue.toString(10)
-                            });
-                        }
-                        return [2 /*return*/, transaction];
+                    }
                 }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.broadcastTransaction = function (rawTransaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.post(this.options.network.extras.indexerApi + '/api/v2/sendtx/', rawTransaction)];
-                    case 1:
-                        data = (_a.sent()).data;
-                        return [2 /*return*/, data.result];
+                // deduct fee from amount
+                amount = amount.minus(transaction.fees);
+                const airGapTransaction = {
+                    hash: transaction.txid,
+                    from: tempAirGapTransactionFrom,
+                    to: tempAirGapTransactionTo,
+                    isInbound: tempAirGapTransactionIsInbound,
+                    amount: amount.toString(10),
+                    fee: new bignumber_1.default(transaction.fees).toString(10),
+                    blockHeight: transaction.blockHeight.toString(),
+                    protocolIdentifier: this.identifier,
+                    network: this.options.network,
+                    timestamp: transaction.blockTime
+                };
+                airGapTransactions.push(airGapTransaction);
+            }
+        }
+        return {
+            transactions: airGapTransactions,
+            cursor: {
+                page: cursor ? cursor.page + 1 : 2
+            }
+        };
+    }
+    async getTransactionsFromPublicKey(publicKey, limit, cursor) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getTransactionsFromAddresses([address.address], limit, cursor);
+    }
+    async getTransactionsFromAddresses(addresses, limit, cursor) {
+        const airGapTransactions = [];
+        const page = cursor?.page ?? 1;
+        const url = `${this.options.network.extras.indexerApi}/api/v2/address/${addresses[0]}?page=${page}&pageSize=${limit}&details=txs`;
+        const { data } = await index_1.default.get(url, {
+            responseType: 'json'
+        });
+        if (data.page == page) {
+            for (const transaction of data.transactions || []) {
+                const tempAirGapTransactionFrom = [];
+                const tempAirGapTransactionTo = [];
+                let tempAirGapTransactionIsInbound = true;
+                let amount = new bignumber_1.default(0);
+                for (const vin of transaction.vin) {
+                    if (vin.addresses && this.containsSome(vin.addresses, addresses)) {
+                        tempAirGapTransactionIsInbound = false;
+                    }
+                    tempAirGapTransactionFrom.push(...vin.addresses);
+                    amount = vin.value ? amount.plus(vin.value) : amount;
                 }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getTransactionsFromExtendedPublicKey = function (extendedPublicKey, limit, cursor, addressOffset) {
-        var _a;
-        if (addressOffset === void 0) { addressOffset = 0; }
-        return __awaiter(this, void 0, void 0, function () {
-            var page, data, ourAddresses, airGapTransactions, _i, _b, transaction, tempAirGapTransactionFrom, tempAirGapTransactionTo, tempAirGapTransactionIsInbound, amount, _c, _d, vin, _e, _f, vout, airGapTransaction;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0:
-                        page = (_a = cursor === null || cursor === void 0 ? void 0 : cursor.page) !== null && _a !== void 0 ? _a : 1;
-                        return [4 /*yield*/, index_1.default.get(this.options.network.extras.indexerApi +
-                                '/api/v2/xpub/' +
-                                extendedPublicKey +
-                                "?details=txs&tokens=used&pageSize=".concat(limit, "&page=").concat(page), {
-                                responseType: 'json'
-                            })];
-                    case 1:
-                        data = (_g.sent()).data;
-                        ourAddresses = (data.tokens || []).filter(function (token) { return token.type === 'XPUBAddress'; }).map(function (token) { return token.name; });
-                        airGapTransactions = [];
-                        if (data.page == page) {
-                            for (_i = 0, _b = data.transactions || []; _i < _b.length; _i++) {
-                                transaction = _b[_i];
-                                tempAirGapTransactionFrom = [];
-                                tempAirGapTransactionTo = [];
-                                tempAirGapTransactionIsInbound = true;
-                                amount = new bignumber_1.default(0);
-                                for (_c = 0, _d = transaction.vin; _c < _d.length; _c++) {
-                                    vin = _d[_c];
-                                    if (this.containsSome(vin.addresses, ourAddresses)) {
-                                        tempAirGapTransactionIsInbound = false;
-                                    }
-                                    tempAirGapTransactionFrom.push.apply(tempAirGapTransactionFrom, vin.addresses);
-                                    amount = amount.plus(vin.value);
-                                }
-                                for (_e = 0, _f = transaction.vout; _e < _f.length; _e++) {
-                                    vout = _f[_e];
-                                    if (vout.addresses) {
-                                        tempAirGapTransactionTo.push.apply(tempAirGapTransactionTo, vout.addresses);
-                                        // If receiving address is our address, and transaction is outbound => our change
-                                        if (this.containsSome(vout.addresses, ourAddresses) && !tempAirGapTransactionIsInbound) {
-                                            // remove only if related to this address
-                                            amount = amount.minus(vout.value);
-                                        }
-                                        // If receiving address is not ours, and transaction isbound => senders change
-                                        if (!this.containsSome(vout.addresses, ourAddresses) && tempAirGapTransactionIsInbound) {
-                                            amount = amount.minus(vout.value);
-                                        }
-                                    }
-                                }
-                                // deduct fee from amount
-                                amount = amount.minus(transaction.fees);
-                                airGapTransaction = {
-                                    hash: transaction.txid,
-                                    from: tempAirGapTransactionFrom,
-                                    to: tempAirGapTransactionTo,
-                                    isInbound: tempAirGapTransactionIsInbound,
-                                    amount: amount.toString(10),
-                                    fee: new bignumber_1.default(transaction.fees).toString(10),
-                                    blockHeight: transaction.blockHeight.toString(),
-                                    protocolIdentifier: this.identifier,
-                                    network: this.options.network,
-                                    timestamp: transaction.blockTime
-                                };
-                                airGapTransactions.push(airGapTransaction);
-                            }
+                for (const vout of transaction.vout) {
+                    if (vout.addresses) {
+                        tempAirGapTransactionTo.push(...vout.addresses);
+                        // If receiving address is our address, and transaction is outbound => our change
+                        if (this.containsSome(vout.addresses, addresses) && !tempAirGapTransactionIsInbound) {
+                            // remove only if related to this address
+                            amount = amount.minus(new bignumber_1.default(vout.value));
                         }
-                        return [2 /*return*/, {
-                                transactions: airGapTransactions,
-                                cursor: {
-                                    page: cursor ? cursor.page + 1 : 2
-                                }
-                            }];
-                }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getTransactionsFromPublicKey = function (publicKey, limit, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _a.sent();
-                        return [2 /*return*/, this.getTransactionsFromAddresses([address.address], limit, cursor)];
-                }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getTransactionsFromAddresses = function (addresses, limit, cursor) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var airGapTransactions, page, url, data, _i, _b, transaction, tempAirGapTransactionFrom, tempAirGapTransactionTo, tempAirGapTransactionIsInbound, amount, _c, _d, vin, _e, _f, vout, airGapTransaction;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0:
-                        airGapTransactions = [];
-                        page = (_a = cursor === null || cursor === void 0 ? void 0 : cursor.page) !== null && _a !== void 0 ? _a : 1;
-                        url = "".concat(this.options.network.extras.indexerApi, "/api/v2/address/").concat(addresses[0], "?page=").concat(page, "&pageSize=").concat(limit, "&details=txs");
-                        return [4 /*yield*/, index_1.default.get(url, {
-                                responseType: 'json'
-                            })];
-                    case 1:
-                        data = (_g.sent()).data;
-                        if (data.page == page) {
-                            for (_i = 0, _b = data.transactions || []; _i < _b.length; _i++) {
-                                transaction = _b[_i];
-                                tempAirGapTransactionFrom = [];
-                                tempAirGapTransactionTo = [];
-                                tempAirGapTransactionIsInbound = true;
-                                amount = new bignumber_1.default(0);
-                                for (_c = 0, _d = transaction.vin; _c < _d.length; _c++) {
-                                    vin = _d[_c];
-                                    if (vin.addresses && this.containsSome(vin.addresses, addresses)) {
-                                        tempAirGapTransactionIsInbound = false;
-                                    }
-                                    tempAirGapTransactionFrom.push.apply(tempAirGapTransactionFrom, vin.addresses);
-                                    amount = vin.value ? amount.plus(vin.value) : amount;
-                                }
-                                for (_e = 0, _f = transaction.vout; _e < _f.length; _e++) {
-                                    vout = _f[_e];
-                                    if (vout.addresses) {
-                                        tempAirGapTransactionTo.push.apply(tempAirGapTransactionTo, vout.addresses);
-                                        // If receiving address is our address, and transaction is outbound => our change
-                                        if (this.containsSome(vout.addresses, addresses) && !tempAirGapTransactionIsInbound) {
-                                            // remove only if related to this address
-                                            amount = amount.minus(new bignumber_1.default(vout.value));
-                                        }
-                                        // If receiving address is not ours, and transaction isbound => senders change
-                                        if (!this.containsSome(vout.addresses, addresses) && tempAirGapTransactionIsInbound) {
-                                            amount = amount.minus(new bignumber_1.default(vout.value));
-                                        }
-                                    }
-                                }
-                                // deduct fee from amount
-                                amount = amount.minus(new bignumber_1.default(transaction.fees));
-                                airGapTransaction = {
-                                    hash: transaction.txid,
-                                    from: tempAirGapTransactionFrom,
-                                    to: tempAirGapTransactionTo,
-                                    isInbound: tempAirGapTransactionIsInbound,
-                                    amount: amount.toString(10),
-                                    fee: new bignumber_1.default(transaction.fees).toString(10),
-                                    blockHeight: transaction.blockHeight.toString(),
-                                    protocolIdentifier: this.identifier,
-                                    network: this.options.network,
-                                    timestamp: transaction.blockTime
-                                };
-                                airGapTransactions.push(airGapTransaction);
-                            }
+                        // If receiving address is not ours, and transaction isbound => senders change
+                        if (!this.containsSome(vout.addresses, addresses) && tempAirGapTransactionIsInbound) {
+                            amount = amount.minus(new bignumber_1.default(vout.value));
                         }
-                        return [2 /*return*/, {
-                                transactions: airGapTransactions,
-                                cursor: {
-                                    page: cursor ? cursor.page + 1 : 2
-                                }
-                            }];
+                    }
                 }
-            });
-        });
-    };
-    BitcoinProtocol.prototype.containsSome = function (needles, haystack) {
-        for (var _i = 0, needles_1 = needles; _i < needles_1.length; _i++) {
-            var needle = needles_1[_i];
+                // deduct fee from amount
+                amount = amount.minus(new bignumber_1.default(transaction.fees));
+                const airGapTransaction = {
+                    hash: transaction.txid,
+                    from: tempAirGapTransactionFrom,
+                    to: tempAirGapTransactionTo,
+                    isInbound: tempAirGapTransactionIsInbound,
+                    amount: amount.toString(10),
+                    fee: new bignumber_1.default(transaction.fees).toString(10),
+                    blockHeight: transaction.blockHeight.toString(),
+                    protocolIdentifier: this.identifier,
+                    network: this.options.network,
+                    timestamp: transaction.blockTime
+                };
+                airGapTransactions.push(airGapTransaction);
+            }
+        }
+        return {
+            transactions: airGapTransactions,
+            cursor: {
+                page: cursor ? cursor.page + 1 : 2
+            }
+        };
+    }
+    containsSome(needles, haystack) {
+        for (const needle of needles) {
             if (haystack.indexOf(needle) > -1) {
                 return true;
             }
         }
         return false;
-    };
-    BitcoinProtocol.prototype.signMessage = function (message, keypair) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.signMessage(message, keypair)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.verifyMessage = function (message, signature, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.verifyMessage(message, signature, publicKey)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.encryptAsymmetric = function (message, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var childPublicKey;
-            return __generator(this, function (_a) {
-                childPublicKey = this.options.config.bitcoinJSLib.HDNode.fromBase58(publicKey, this.options.network.extras.network)
-                    .derive(0)
-                    .derive(0)
-                    .getPublicKeyBuffer();
-                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(message, childPublicKey)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.decryptAsymmetric = function (message, keypair) {
-        return __awaiter(this, void 0, void 0, function () {
-            var childPrivateKey;
-            return __generator(this, function (_a) {
-                childPrivateKey = this.options.config.bitcoinJSLib.HDNode.fromBase58(keypair.privateKey, this.options.network.extras.network)
-                    .derive(0)
-                    .derive(0)
-                    .keyPair.d.toBuffer(32);
-                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(message, { publicKey: '', privateKey: childPrivateKey.toString('hex') })];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.encryptAES = function (message, privateKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.encryptAES(message, privateKey)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.decryptAES = function (message, privateKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.decryptAES(message, privateKey)];
-            });
-        });
-    };
-    BitcoinProtocol.prototype.getTransactionStatuses = function (transactionHashes) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, Promise.reject('Transaction status not implemented')];
-            });
-        });
-    };
-    return BitcoinProtocol;
-}());
+    }
+    async signMessage(message, keypair) {
+        return this.cryptoClient.signMessage(message, keypair);
+    }
+    async verifyMessage(message, signature, publicKey) {
+        return this.cryptoClient.verifyMessage(message, signature, publicKey);
+    }
+    async encryptAsymmetric(message, publicKey) {
+        const childPublicKey = this.options.config.bitcoinJSLib.HDNode.fromBase58(publicKey, this.options.network.extras.network)
+            .derive(0)
+            .derive(0)
+            .getPublicKeyBuffer();
+        return this.cryptoClient.encryptAsymmetric(message, childPublicKey);
+    }
+    async decryptAsymmetric(message, keypair) {
+        const childPrivateKey = this.options.config.bitcoinJSLib.HDNode.fromBase58(keypair.privateKey, this.options.network.extras.network)
+            .derive(0)
+            .derive(0)
+            .keyPair.d.toBuffer(32);
+        return this.cryptoClient.decryptAsymmetric(message, { publicKey: '', privateKey: childPrivateKey.toString('hex') });
+    }
+    async encryptAES(message, privateKey) {
+        return this.cryptoClient.encryptAES(message, privateKey);
+    }
+    async decryptAES(message, privateKey) {
+        return this.cryptoClient.decryptAES(message, privateKey);
+    }
+    async getTransactionStatuses(transactionHashes) {
+        return Promise.reject('Transaction status not implemented');
+    }
+}
 exports.BitcoinProtocol = BitcoinProtocol;
 //# sourceMappingURL=BitcoinProtocol.js.map