beignet 0.0.1

package/dist/wallet/index.js

@@ -0,0 +1,2113 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wallet = void 0;
+const bitcoin = __importStar(require("bitcoinjs-lib"));
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const bip32_1 = __importDefault(require("bip32"));
+const ecc = __importStar(require("@bitcoinerlab/secp256k1"));
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const shapes_1 = require("../shapes");
+const electrum_1 = require("../electrum");
+const transaction_1 = require("../transaction");
+const constants_1 = require("./constants");
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const conversion_1 = require("../utils/conversion");
+const bip39 = __importStar(require("bip39"));
+const bip32 = (0, bip32_1.default)(ecc);
+class Wallet {
+    constructor({ mnemonic, passphrase, name, network = types_1.EAvailableNetworks.mainnet, addressType = types_1.EAddressType.p2wpkh, storage, electrumOptions, onMessage = () => null, customGetAddress, customGetScriptHash, rbf = false, selectedFeeId = types_1.EFeeId.normal }) {
+        var _a;
+        this._pendingRefreshPromises = [];
+        this.getReceiveAddress = async ({ addressType = this.data.addressType }) => {
+            try {
+                const wallet = this.data;
+                const addressIndex = wallet.addressIndex;
+                const receiveAddress = addressIndex[addressType].address;
+                if (receiveAddress) {
+                    return (0, utils_1.ok)(receiveAddress);
+                }
+                const addresses = wallet === null || wallet === void 0 ? void 0 : wallet.addresses[addressType];
+                if (Object.keys(addresses).length > 0 &&
+                    addressIndex[addressType].index < 0) {
+                    const address = Object.values(addresses).find(({ index }) => index === 0);
+                    if (address) {
+                        return (0, utils_1.ok)(address.address);
+                    }
+                }
+                const generatedAddress = await this.generateNewReceiveAddress({
+                    addressType
+                });
+                if (generatedAddress.isOk()) {
+                    return (0, utils_1.ok)(generatedAddress.value.address);
+                }
+                else {
+                    console.log(generatedAddress.error.message);
+                }
+                return (0, utils_1.err)('No receive address available.');
+            }
+            catch (e) {
+                return (0, utils_1.err)(e);
+            }
+        };
+        this.getBoostedTransactionParents = ({ txid, boostedTransactions }) => {
+            var _a;
+            if (!boostedTransactions) {
+                boostedTransactions = this.getBoostedTransactions();
+            }
+            const boostObj = Object.values(boostedTransactions).find((boostObject) => {
+                return boostObject.childTransaction === txid;
+            });
+            return (_a = boostObj === null || boostObj === void 0 ? void 0 : boostObj.parentTransactions) !== null && _a !== void 0 ? _a : [];
+        };
+        this.getBoostedTransactions = () => {
+            return this.data.boostedTransactions;
+        };
+        this.getBip32Interface = async () => {
+            const network = bitcoinjs_lib_1.networks[this._network];
+            const seed = await bip39.mnemonicToSeed(this._mnemonic, this._passphrase);
+            const root = bip32.fromSeed(seed, network);
+            return (0, utils_1.ok)(root);
+        };
+        if (!mnemonic)
+            throw new Error('No mnemonic specified.');
+        if (!(0, utils_1.validateMnemonic)(mnemonic))
+            throw new Error('Invalid mnemonic.');
+        if (name && name.includes('-'))
+            throw new Error('Wallet name cannot include a hyphen (-).');
+        this._network = network;
+        this._mnemonic = mnemonic;
+        this._passphrase = passphrase !== null && passphrase !== void 0 ? passphrase : '';
+        this._seed = (0, utils_1.getSeed)(this._mnemonic, this._passphrase);
+        this._root = bip32.fromSeed(this._seed, this.getBitcoinNetwork(this._network));
+        this._data = Object.assign(Object.assign({}, (0, utils_1.getDefaultWalletData)()), { addressType });
+        this._getData = (_a = storage === null || storage === void 0 ? void 0 : storage.getData) !== null && _a !== void 0 ? _a : utils_1.getDataFallback;
+        this._setData = storage === null || storage === void 0 ? void 0 : storage.setData;
+        if (customGetAddress)
+            this._customGetAddress = customGetAddress;
+        if (customGetScriptHash)
+            this._customGetScriptHash = customGetScriptHash;
+        this.id = (0, utils_1.generateWalletId)(this._seed);
+        this.name = name !== null && name !== void 0 ? name : this.id;
+        this.exchangeRates = {};
+        this.transaction = new transaction_1.Transaction({
+            wallet: this
+        });
+        this.feeEstimates = (0, lodash_clonedeep_1.default)(shapes_1.defaultFeesShape);
+        this.onMessage = onMessage;
+        this.electrumOptions = electrumOptions;
+        this.electrum = new electrum_1.Electrum({
+            wallet: this,
+            network: this.network,
+            servers: electrumOptions === null || electrumOptions === void 0 ? void 0 : electrumOptions.servers,
+            tls: electrumOptions === null || electrumOptions === void 0 ? void 0 : electrumOptions.tls,
+            net: electrumOptions === null || electrumOptions === void 0 ? void 0 : electrumOptions.net
+        });
+        this.rbf = rbf;
+        this.selectedFeeId = selectedFeeId;
+        this.isRefreshing = false;
+        this.isSwitchingNetworks = false;
+    }
+    get data() {
+        return this._data;
+    }
+    get network() {
+        return this._network;
+    }
+    static async create(params) {
+        try {
+            const wallet = new Wallet(params);
+            const res = await wallet.setWalletData();
+            if (res.isErr())
+                return (0, utils_1.err)(res.error.message);
+            wallet.updateExchangeRates();
+            wallet.updateFeeEstimates();
+            console.log('Syncing Wallet...');
+            await wallet.refreshWallet({});
+            return (0, utils_1.ok)(wallet);
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async switchNetwork(network, servers) {
+        var _a, _b;
+        this.isSwitchingNetworks = true;
+        await this.electrum.disconnect();
+        this._network = network;
+        this._data = (0, utils_1.getDefaultWalletData)();
+        const params = Object.assign(Object.assign({}, this), { mnemonic: this._mnemonic, passphrase: this._passphrase, network, electrumOptions: {
+                servers,
+                tls: (_a = this.electrumOptions) === null || _a === void 0 ? void 0 : _a.tls,
+                net: (_b = this.electrumOptions) === null || _b === void 0 ? void 0 : _b.net
+            }, storage: {
+                getData: this._getData,
+                setData: this._setData
+            }, data: (0, utils_1.getDefaultWalletData)() });
+        const createRes = await Wallet.create(params);
+        if (createRes.isErr())
+            return (0, utils_1.err)(createRes.error.message);
+        Object.assign(this, createRes.value);
+        await this.updateFeeEstimates(true);
+        this.isSwitchingNetworks = false;
+        return (0, utils_1.ok)(`Successfully switched to ${network}.`);
+    }
+    async updateAddressType(addressType) {
+        this._data.addressType = addressType;
+        await this.saveWalletData('addressType', addressType);
+        await this.refreshWallet({});
+    }
+    async refreshWallet({ scanAllAddresses = false, updateAllAddressTypes = true } = {}) {
+        if (this.isRefreshing) {
+            return new Promise((resolve) => {
+                this._pendingRefreshPromises.push(resolve);
+            });
+        }
+        this.isRefreshing = true;
+        try {
+            await this.setZeroIndexAddresses();
+            const addressType = updateAllAddressTypes
+                ? undefined
+                : this.data.addressType;
+            const r1 = await this.updateAddressIndexes({ addressType });
+            if (r1.isErr()) {
+                return this._handleRefreshError(r1.error.message);
+            }
+            const r2 = await this.getUtxos({ scanAllAddresses });
+            if (r2.isErr()) {
+                return this._handleRefreshError(r2.error.message);
+            }
+            const r3 = await this.updateTransactions({ scanAllAddresses });
+            if (r3.isErr()) {
+                return this._handleRefreshError(r3.error.message);
+            }
+            await this.electrum.subscribeToAddresses();
+            this._resolveAllPendingRefreshPromises((0, utils_1.ok)(this.data));
+            return (0, utils_1.ok)(this.data);
+        }
+        catch (e) {
+            return this._handleRefreshError(e);
+        }
+    }
+    _resolveAllPendingRefreshPromises(result) {
+        this.isRefreshing = false;
+        while (this._pendingRefreshPromises.length > 0) {
+            const resolve = this._pendingRefreshPromises.shift();
+            if (resolve) {
+                resolve(result);
+            }
+        }
+    }
+    _handleRefreshError(errorMessage) {
+        this.isRefreshing = false;
+        this._resolveAllPendingRefreshPromises((0, utils_1.err)(errorMessage));
+        return (0, utils_1.err)(errorMessage);
+    }
+    async setWalletData() {
+        try {
+            const storageIdCheckRes = await this.storageIdCheck(this.id);
+            if (storageIdCheckRes.isErr())
+                return (0, utils_1.err)(storageIdCheckRes.error.message);
+            this._data = (0, utils_1.getDefaultWalletData)();
+            const walletDataResponse = await this.getWalletData();
+            if (walletDataResponse.isErr())
+                return (0, utils_1.err)(walletDataResponse.error.message);
+            this._data = walletDataResponse.value;
+            return (0, utils_1.ok)(true);
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async storageIdCheck(id) {
+        const storageKey = this.getWalletDataKey('id');
+        const res = await this._getData(storageKey);
+        if (res.isErr() || !res.value) {
+            this._data.id = id;
+            await this.saveWalletData('id', id);
+            return (0, utils_1.ok)('Saved ID to storage.');
+        }
+        if (res.value !== id) {
+            const msg = 'Mismatched id found in storage. Change the wallet name or delete the old wallet from storage and try again.';
+            console.log(msg);
+            return (0, utils_1.err)(msg);
+        }
+        return (0, utils_1.ok)("ID's match, it's safe to continue.");
+    }
+    getWalletDataKey(key) {
+        return (0, utils_1.getWalletDataStorageKey)(this.name, this._network, key);
+    }
+    async getWalletData() {
+        try {
+            const walletDataKeys = (0, utils_1.getDefaultWalletDataKeys)();
+            const walletData = (0, utils_1.getDefaultWalletData)();
+            for (const key of walletDataKeys) {
+                let dataResult;
+                try {
+                    const walletDataKey = this.getWalletDataKey(key);
+                    const getDataRes = await this._getData(walletDataKey);
+                    if (getDataRes.isErr()) {
+                        return (0, utils_1.err)(dataResult.error.message);
+                    }
+                    dataResult = getDataRes === null || getDataRes === void 0 ? void 0 : getDataRes.value;
+                }
+                catch (e) {
+                    console.log(e);
+                }
+                const data = dataResult !== null && dataResult !== void 0 ? dataResult : walletData[key];
+                switch (key) {
+                    case 'id':
+                        walletData[key] = data;
+                        break;
+                    case 'addressType':
+                        walletData[key] = data;
+                        break;
+                    case 'addresses':
+                    case 'changeAddresses':
+                        walletData[key] = data;
+                        break;
+                    case 'addressIndex':
+                    case 'changeAddressIndex':
+                        walletData[key] = data;
+                        break;
+                    case 'lastUsedAddressIndex':
+                    case 'lastUsedChangeAddressIndex':
+                        walletData[key] = data;
+                        break;
+                    case 'utxos':
+                        walletData[key] = data;
+                        break;
+                    case 'blacklistedUtxos':
+                        walletData[key] = data;
+                        break;
+                    case 'unconfirmedTransactions':
+                    case 'transactions':
+                        walletData[key] = data;
+                        break;
+                    case 'transaction':
+                        walletData[key] = data;
+                        break;
+                    case 'balance':
+                        walletData[key] = data;
+                        break;
+                    case 'header':
+                        walletData[key] = data;
+                        break;
+                    case 'boostedTransactions':
+                        walletData[key] = data;
+                        break;
+                    case 'selectedFeeId':
+                        walletData[key] = data;
+                        break;
+                    case 'exchangeRates':
+                        walletData[key] = data;
+                        break;
+                    case 'feeEstimates':
+                        walletData[key] = data;
+                        break;
+                    default:
+                        return (0, utils_1.err)(`Unhandled key in getWalletData: ${key}`);
+                }
+            }
+            return (0, utils_1.ok)(walletData);
+        }
+        catch (e) {
+            console.log(e);
+            return (0, utils_1.err)(e);
+        }
+    }
+    getBitcoinNetwork(network) {
+        if (!network)
+            network = this._network;
+        return bitcoin.networks[network];
+    }
+    isValid(mnemonic) {
+        return mnemonic === this._mnemonic && (0, utils_1.validateMnemonic)(mnemonic);
+    }
+    async _getAddress(path, addressType) {
+        var _a, _b, _c;
+        if (this._customGetAddress) {
+            const data = {
+                path,
+                type: addressType,
+                selectedNetwork: this.electrum.getElectrumNetwork(this._network)
+            };
+            const res = await this._customGetAddress(data);
+            if (res.isErr()) {
+                return {
+                    address: '',
+                    path,
+                    publicKey: ''
+                };
+            }
+            return res.value;
+        }
+        const keyPair = this._root.derivePath(path);
+        let address;
+        switch (addressType) {
+            case types_1.EAddressType.p2wpkh:
+                address =
+                    (_a = bitcoin.payments.p2wpkh({
+                        pubkey: keyPair.publicKey,
+                        network: this.getBitcoinNetwork()
+                    }).address) !== null && _a !== void 0 ? _a : '';
+                break;
+            case types_1.EAddressType.p2sh:
+                address =
+                    (_b = bitcoin.payments.p2sh({
+                        redeem: bitcoin.payments.p2wpkh({
+                            pubkey: keyPair.publicKey,
+                            network: this.getBitcoinNetwork()
+                        }),
+                        network: this.getBitcoinNetwork()
+                    }).address) !== null && _b !== void 0 ? _b : '';
+                break;
+            case types_1.EAddressType.p2pkh:
+                address =
+                    (_c = bitcoin.payments.p2pkh({
+                        pubkey: keyPair.publicKey,
+                        network: this.getBitcoinNetwork()
+                    }).address) !== null && _c !== void 0 ? _c : '';
+                break;
+        }
+        return {
+            address,
+            path,
+            publicKey: keyPair.publicKey.toString('hex')
+        };
+    }
+    async getAddress({ index, changeAddress = false, addressType = this.data.addressType } = {}) {
+        try {
+            if (index === undefined) {
+                const addressIndex = this.data.addressIndex[addressType];
+                index = addressIndex.index >= 0 ? String(addressIndex.index) : '0';
+            }
+            const pathRes = (0, utils_1.getKeyDerivationPathString)({
+                addressType,
+                changeAddress,
+                index,
+                network: this._network
+            });
+            if (pathRes.isErr()) {
+                return '';
+            }
+            const path = pathRes.value;
+            const res = await this._getAddress(path, addressType);
+            if (!(res === null || res === void 0 ? void 0 : res.address))
+                return '';
+            return res.address;
+        }
+        catch (_a) {
+            return '';
+        }
+    }
+    async getAddressByPath({ path, addressType }) {
+        if (!path) {
+            return (0, utils_1.err)('No path specified');
+        }
+        if (!addressType) {
+            const res = (0, utils_1.getAddressTypeFromPath)(path);
+            if (res.isErr())
+                return (0, utils_1.err)(res.error.message);
+            addressType = res.value;
+        }
+        try {
+            const getAddressRes = await this._getAddress(path, addressType);
+            if (!(getAddressRes === null || getAddressRes === void 0 ? void 0 : getAddressRes.address))
+                return (0, utils_1.err)('Unable to get address.');
+            return (0, utils_1.ok)(getAddressRes);
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async connectToElectrum(servers) {
+        var _a;
+        const res = await this.electrum.connectToElectrum({
+            network: this._network,
+            servers: servers !== null && servers !== void 0 ? servers : (_a = this.electrumOptions) === null || _a === void 0 ? void 0 : _a.servers
+        });
+        let msg = 'Unable to connect to Electrum server.';
+        if (res.isErr()) {
+            console.log(msg);
+            return (0, utils_1.err)(msg);
+        }
+        msg = 'Connected to Electrum server.';
+        return (0, utils_1.ok)(msg);
+    }
+    async getAddressBalance(address) {
+        const scriptHash = await this.getScriptHash({
+            address,
+            network: this._network
+        });
+        const res = await this.electrum.getAddressBalance(scriptHash);
+        if (res.error)
+            return (0, utils_1.err)('Unable to get address balance at this time.');
+        return (0, utils_1.ok)({ unconfirmed: res.unconfirmed, confirmed: res.confirmed });
+    }
+    async getAddressesBalance(addresses = []) {
+        try {
+            const network = this._network;
+            const scriptHashes = await Promise.all(addresses.map(async (address) => {
+                return await this.getScriptHash({ address, network });
+            }));
+            const res = await this.electrum.getAddressScriptHashBalances(scriptHashes);
+            if (res.error) {
+                return (0, utils_1.err)(res.data);
+            }
+            return (0, utils_1.ok)(res.data.reduce((acc, cur) => {
+                var _a, _b, _c, _d;
+                return (acc +
+                    Number((_b = (_a = cur.result) === null || _a === void 0 ? void 0 : _a.confirmed) !== null && _b !== void 0 ? _b : 0) +
+                    Number((_d = (_c = cur.result) === null || _c === void 0 ? void 0 : _c.unconfirmed) !== null && _d !== void 0 ? _d : 0));
+            }, 0) || 0);
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async getScriptHash({ address, network }) {
+        if (this._customGetScriptHash) {
+            const selectedNetwork = this.electrum.getElectrumNetwork(network);
+            return await this._customGetScriptHash({ address, selectedNetwork });
+        }
+        return (0, utils_1.getScriptHash)({ address, network });
+    }
+    getPrivateKey(path) {
+        const keyPair = this._root.derivePath(path);
+        return keyPair.toWIF();
+    }
+    async getScriptHashBalance(scriptHash) {
+        const res = await this.electrum.getAddressBalance(scriptHash);
+        if (res.error)
+            return (0, utils_1.err)('Unable to get address balance at this time.');
+        return (0, utils_1.ok)({ unconfirmed: res.unconfirmed, confirmed: res.confirmed });
+    }
+    getBalance() {
+        var _a, _b;
+        return (_b = (_a = this === null || this === void 0 ? void 0 : this.data) === null || _a === void 0 ? void 0 : _a.balance) !== null && _b !== void 0 ? _b : 0;
+    }
+    async generateAddresses({ addressAmount = 10, changeAddressAmount = 10, addressIndex = 0, changeAddressIndex = 0, keyDerivationPath, addressType = this.data.addressType }) {
+        const network = this._network;
+        try {
+            if (!keyDerivationPath) {
+                const keyDerivationPathResponse = (0, utils_1.getKeyDerivationPath)({
+                    network,
+                    addressType
+                });
+                if (keyDerivationPathResponse.isErr())
+                    return (0, utils_1.err)(keyDerivationPathResponse.error.message);
+                keyDerivationPath = keyDerivationPathResponse.value;
+            }
+            const addresses = {};
+            const changeAddresses = {};
+            const addressArray = new Array(addressAmount).fill(null);
+            const changeAddressArray = new Array(changeAddressAmount).fill(null);
+            await Promise.all(addressArray.map(async (_item, i) => {
+                const index = i + addressIndex;
+                const path = Object.assign({}, keyDerivationPath);
+                path.index = `${index}`;
+                const addressPath = (0, utils_1.formatKeyDerivationPath)({
+                    path,
+                    network,
+                    changeAddress: false,
+                    index: `${index}`
+                });
+                if (addressPath.isErr()) {
+                    throw addressPath.error;
+                }
+                const address = await this.getAddressByPath({
+                    path: addressPath.value.pathString
+                });
+                if (address.isErr()) {
+                    throw address.error;
+                }
+                const scriptHash = await this.getScriptHash({
+                    address: address.value.address,
+                    network
+                });
+                if (!scriptHash) {
+                    throw new Error('Unable to get script hash.');
+                }
+                addresses[scriptHash] = Object.assign(Object.assign({}, address.value), { index,
+                    scriptHash });
+            }));
+            await Promise.all(changeAddressArray.map(async (_item, i) => {
+                const index = i + changeAddressIndex;
+                const path = Object.assign({}, keyDerivationPath);
+                path.index = `${index}`;
+                const changeAddressPath = (0, utils_1.formatKeyDerivationPath)({
+                    path,
+                    network,
+                    changeAddress: true,
+                    index: `${index}`
+                });
+                if (changeAddressPath.isErr()) {
+                    throw changeAddressPath.error;
+                }
+                const address = await this.getAddressByPath({
+                    path: changeAddressPath.value.pathString
+                });
+                if (address.isErr()) {
+                    throw address.error;
+                }
+                const scriptHash = await this.getScriptHash({
+                    address: address.value.address,
+                    network
+                });
+                if (!scriptHash) {
+                    throw new Error('Unable to get script hash.');
+                }
+                changeAddresses[scriptHash] = Object.assign(Object.assign({}, address.value), { index,
+                    scriptHash });
+            }));
+            return (0, utils_1.ok)({ addresses, changeAddresses });
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async checkElectrumConnection() {
+        const isConnected = this.electrum.connectedToElectrum;
+        if (!isConnected) {
+            return await this.connectToElectrum();
+        }
+        const pingRes = await this.electrum.isConnected();
+        if (pingRes)
+            return (0, utils_1.ok)('Is connected to Electrum.Z');
+        return (0, utils_1.err)('Failed Electrum connection check.');
+    }
+    async getNextAvailableAddress(addressType) {
+        const checkRes = await this.checkElectrumConnection();
+        if (checkRes.isErr())
+            return (0, utils_1.err)(checkRes.error.message);
+        try {
+            const network = this._network;
+            addressType = addressType !== null && addressType !== void 0 ? addressType : this.data.addressType;
+            const currentWallet = this.data;
+            const { path } = shapes_1.addressTypes[addressType];
+            const result = (0, utils_1.formatKeyDerivationPath)({ path, network });
+            if (result.isErr()) {
+                return (0, utils_1.err)(result.error.message);
+            }
+            const { pathObject: keyDerivationPath } = result.value;
+            let addressIndex = currentWallet.addressIndex[addressType];
+            let lastUsedAddressIndex = currentWallet.lastUsedAddressIndex[addressType];
+            let changeAddressIndex = currentWallet.changeAddressIndex[addressType];
+            let lastUsedChangeAddressIndex = currentWallet.lastUsedChangeAddressIndex[addressType];
+            if ((addressIndex === null || addressIndex === void 0 ? void 0 : addressIndex.index) < 0 || !(addressIndex === null || addressIndex === void 0 ? void 0 : addressIndex.address)) {
+                const generatedAddresses = await this.generateAddresses({
+                    addressAmount: constants_1.GENERATE_ADDRESS_AMOUNT,
+                    addressIndex: 0,
+                    changeAddressAmount: 0,
+                    keyDerivationPath,
+                    addressType
+                });
+                if (generatedAddresses.isErr()) {
+                    return (0, utils_1.err)(generatedAddresses.error);
+                }
+                const addresses = generatedAddresses.value.addresses;
+                const sorted = Object.values(addresses).sort((a, b) => a.index - b.index);
+                addressIndex = sorted[0];
+            }
+            if ((changeAddressIndex === null || changeAddressIndex === void 0 ? void 0 : changeAddressIndex.index) < 0 || !(changeAddressIndex === null || changeAddressIndex === void 0 ? void 0 : changeAddressIndex.address)) {
+                const generatedAddresses = await this.generateAddresses({
+                    addressAmount: 0,
+                    changeAddressAmount: constants_1.GENERATE_ADDRESS_AMOUNT,
+                    changeAddressIndex: 0,
+                    keyDerivationPath,
+                    addressType
+                });
+                if (generatedAddresses.isErr()) {
+                    return (0, utils_1.err)(generatedAddresses.error);
+                }
+                const addresses = generatedAddresses.value.changeAddresses;
+                const sorted = Object.values(addresses).sort((a, b) => a.index - b.index);
+                changeAddressIndex = sorted[0];
+            }
+            let addresses = currentWallet.addresses[addressType];
+            let changeAddresses = currentWallet.changeAddresses[addressType];
+            const addressCount = Object.values(addresses).length;
+            const changeAddressCount = Object.values(changeAddresses).length;
+            if (addressCount < constants_1.GENERATE_ADDRESS_AMOUNT ||
+                addressIndex.index === addressCount) {
+                const newAddresses = await this.addAddresses({
+                    addressAmount: constants_1.GENERATE_ADDRESS_AMOUNT,
+                    changeAddressAmount: 0,
+                    addressIndex: addressIndex.index,
+                    changeAddressIndex: 0,
+                    keyDerivationPath,
+                    addressType
+                });
+                if (newAddresses.isOk()) {
+                    addresses = newAddresses.value.addresses;
+                }
+            }
+            if (changeAddressCount < constants_1.GENERATE_ADDRESS_AMOUNT ||
+                changeAddressIndex.index === changeAddressCount) {
+                const newChangeAddresses = await this.addAddresses({
+                    addressAmount: 0,
+                    changeAddressAmount: constants_1.GENERATE_ADDRESS_AMOUNT,
+                    addressIndex: 0,
+                    changeAddressIndex: changeAddressIndex.index,
+                    keyDerivationPath,
+                    addressType
+                });
+                if (newChangeAddresses.isOk()) {
+                    changeAddresses = newChangeAddresses.value.changeAddresses;
+                }
+            }
+            let allAddresses = Object.values(addresses).filter(({ index }) => index >= addressIndex.index);
+            let addressesToScan = allAddresses;
+            let allChangeAddresses = Object.values(changeAddresses).filter(({ index }) => index >= changeAddressIndex.index);
+            let changeAddressesToScan = allChangeAddresses;
+            let combinedAddressesToScan = [
+                ...addressesToScan,
+                ...changeAddressesToScan
+            ];
+            let foundLastUsedAddress = false;
+            let foundLastUsedChangeAddress = false;
+            let addressHasBeenUsed = false;
+            let changeAddressHasBeenUsed = false;
+            const lastKnownIndexes = (0, utils_1.ok)({
+                addressIndex,
+                lastUsedAddressIndex,
+                changeAddressIndex,
+                lastUsedChangeAddressIndex
+            });
+            while (!foundLastUsedAddress || !foundLastUsedChangeAddress) {
+                const addressHistory = await this.electrum.getAddressHistory({
+                    scriptHashes: combinedAddressesToScan
+                });
+                if (addressHistory.isErr()) {
+                    console.log(addressHistory.error.message);
+                    return lastKnownIndexes;
+                }
+                const txHashes = addressHistory.value;
+                const highestUsedIndex = (0, utils_1.getHighestUsedIndexFromTxHashes)({
+                    txHashes,
+                    addresses,
+                    changeAddresses,
+                    addressIndex,
+                    changeAddressIndex
+                });
+                if (highestUsedIndex.isErr()) {
+                    console.log(highestUsedIndex.error.message);
+                    return lastKnownIndexes;
+                }
+                addressIndex = highestUsedIndex.value.addressIndex;
+                changeAddressIndex = highestUsedIndex.value.changeAddressIndex;
+                if (highestUsedIndex.value.foundAddressIndex) {
+                    addressHasBeenUsed = true;
+                }
+                if (highestUsedIndex.value.foundChangeAddressIndex) {
+                    changeAddressHasBeenUsed = true;
+                }
+                const highestStoredIndex = this.getHighestStoredAddressIndex({
+                    addressType
+                });
+                if (highestStoredIndex.isErr()) {
+                    console.log(highestStoredIndex.error.message);
+                    return lastKnownIndexes;
+                }
+                const { addressIndex: highestUsedAddressIndex, changeAddressIndex: highestUsedChangeAddressIndex } = highestUsedIndex.value;
+                const { addressIndex: highestStoredAddressIndex, changeAddressIndex: highestStoredChangeAddressIndex } = highestStoredIndex.value;
+                if (highestUsedAddressIndex.index < highestStoredAddressIndex.index) {
+                    foundLastUsedAddress = true;
+                }
+                if (highestUsedChangeAddressIndex.index <
+                    highestStoredChangeAddressIndex.index) {
+                    foundLastUsedChangeAddress = true;
+                }
+                if (foundLastUsedAddress && foundLastUsedChangeAddress) {
+                    let newAddressIndex = addressIndex.index;
+                    if (highestUsedAddressIndex.index > addressIndex.index ||
+                        addressHasBeenUsed) {
+                        const index = highestUsedAddressIndex.index;
+                        if (highestUsedAddressIndex && index >= 0) {
+                            lastUsedAddressIndex = highestUsedAddressIndex;
+                        }
+                        newAddressIndex = index >= 0 ? index + 1 : index;
+                    }
+                    let newChangeAddressIndex = changeAddressIndex.index;
+                    if (highestUsedChangeAddressIndex.index > changeAddressIndex.index ||
+                        changeAddressHasBeenUsed) {
+                        const index = highestUsedChangeAddressIndex.index;
+                        if (highestUsedChangeAddressIndex && index >= 0) {
+                            lastUsedChangeAddressIndex = highestUsedChangeAddressIndex;
+                        }
+                        newChangeAddressIndex = index >= 0 ? index + 1 : index;
+                    }
+                    const nextAvailableAddress = Object.values(allAddresses).find(({ index }) => index === newAddressIndex);
+                    const nextAvailableChangeAddress = Object.values(allChangeAddresses).find(({ index }) => index === newChangeAddressIndex);
+                    if (!nextAvailableAddress || !nextAvailableChangeAddress) {
+                        return lastKnownIndexes;
+                    }
+                    return (0, utils_1.ok)({
+                        addressIndex: nextAvailableAddress,
+                        lastUsedAddressIndex,
+                        changeAddressIndex: nextAvailableChangeAddress,
+                        lastUsedChangeAddressIndex
+                    });
+                }
+                if (!foundLastUsedAddress) {
+                    const newAddresses = await this.addAddresses({
+                        addressAmount: constants_1.GENERATE_ADDRESS_AMOUNT,
+                        changeAddressAmount: 0,
+                        addressIndex: highestStoredIndex.value.addressIndex.index,
+                        changeAddressIndex: 0,
+                        keyDerivationPath,
+                        addressType
+                    });
+                    if (newAddresses.isOk()) {
+                        addresses = newAddresses.value.addresses || {};
+                    }
+                }
+                if (!foundLastUsedChangeAddress) {
+                    const newChangeAddresses = await this.addAddresses({
+                        addressAmount: 0,
+                        changeAddressAmount: constants_1.GENERATE_ADDRESS_AMOUNT,
+                        addressIndex: 0,
+                        changeAddressIndex: highestStoredIndex.value.changeAddressIndex.index,
+                        keyDerivationPath,
+                        addressType
+                    });
+                    if (newChangeAddresses.isOk()) {
+                        changeAddresses = newChangeAddresses.value.changeAddresses || {};
+                    }
+                }
+                addressesToScan = Object.values(addresses);
+                changeAddressesToScan = Object.values(changeAddresses);
+                combinedAddressesToScan = [
+                    ...addressesToScan,
+                    ...changeAddressesToScan
+                ];
+                allAddresses = [...allAddresses, ...addressesToScan];
+                allChangeAddresses = [...allChangeAddresses, ...changeAddressesToScan];
+            }
+            return lastKnownIndexes;
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    getHighestStoredAddressIndex({ addressType }) {
+        try {
+            const currentWallet = this.data;
+            const addresses = currentWallet.addresses[addressType];
+            const changeAddresses = currentWallet.changeAddresses[addressType];
+            const addressIndex = Object.values(addresses).reduce((prev, current) => {
+                return prev.index > current.index ? prev : current;
+            });
+            const changeAddressIndex = Object.values(changeAddresses).reduce((prev, current) => (prev.index > current.index ? prev : current));
+            return (0, utils_1.ok)({ addressIndex, changeAddressIndex });
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async addAddresses({ addressAmount = 5, changeAddressAmount = 5, addressIndex = 0, changeAddressIndex = 0, addressType, keyDerivationPath }) {
+        if (!addressType) {
+            addressType = this.data.addressType;
+        }
+        const network = this._network;
+        const { path, type } = shapes_1.addressTypes[addressType];
+        if (!keyDerivationPath) {
+            const keyDerivationPathResponse = (0, utils_1.getKeyDerivationPathObject)({
+                path,
+                network
+            });
+            if (keyDerivationPathResponse.isErr()) {
+                return (0, utils_1.err)(keyDerivationPathResponse.error.message);
+            }
+            keyDerivationPath = keyDerivationPathResponse.value;
+        }
+        const generatedAddresses = await this.generateAddresses({
+            addressAmount,
+            changeAddressAmount,
+            addressIndex,
+            changeAddressIndex,
+            keyDerivationPath,
+            addressType: type
+        });
+        if (generatedAddresses.isErr()) {
+            return (0, utils_1.err)(generatedAddresses.error);
+        }
+        const removeDuplicateResponse = await this.removeDuplicateAddresses({
+            addresses: generatedAddresses.value.addresses,
+            changeAddresses: generatedAddresses.value.changeAddresses
+        });
+        if (removeDuplicateResponse.isErr()) {
+            return (0, utils_1.err)(removeDuplicateResponse.error.message);
+        }
+        const addresses = removeDuplicateResponse.value.addresses;
+        const changeAddresses = removeDuplicateResponse.value.changeAddresses;
+        if (Object.keys(addresses).length) {
+            this._data.addresses[addressType] = Object.assign(Object.assign({}, this.data.addresses[addressType]), addresses);
+            await this.saveWalletData('addresses', this._data.addresses);
+        }
+        if (Object.keys(changeAddresses).length) {
+            this._data.changeAddresses[addressType] = Object.assign(Object.assign({}, this.data.changeAddresses[addressType]), changeAddresses);
+            await this.saveWalletData('changeAddresses', this._data.changeAddresses);
+        }
+        return (0, utils_1.ok)(Object.assign(Object.assign({}, generatedAddresses.value), { addressType: type }));
+    }
+    async removeDuplicateAddresses({ addresses = {}, changeAddresses = {} }) {
+        try {
+            const currentWallet = this.data;
+            const currentAddressTypeContent = currentWallet.addresses;
+            const currentChangeAddressTypeContent = currentWallet.changeAddresses;
+            await Promise.all([
+                (0, utils_1.objectKeys)(currentAddressTypeContent).map(async (addressType) => {
+                    await Promise.all((0, utils_1.objectKeys)(addresses).map((scriptHash) => {
+                        if (scriptHash in currentAddressTypeContent[addressType]) {
+                            delete addresses[scriptHash];
+                        }
+                    }));
+                }),
+                (0, utils_1.objectKeys)(currentChangeAddressTypeContent).map(async (addressType) => {
+                    await Promise.all((0, utils_1.objectKeys)(changeAddresses).map((scriptHash) => {
+                        if (scriptHash in currentChangeAddressTypeContent[addressType]) {
+                            delete changeAddresses[scriptHash];
+                        }
+                    }));
+                })
+            ]);
+            return (0, utils_1.ok)({ addresses, changeAddresses });
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async updateAddressIndexes({ addressType } = {}) {
+        const checkRes = await this.checkElectrumConnection();
+        if (checkRes.isErr())
+            return (0, utils_1.err)(checkRes.error.message);
+        const currentWallet = this.data;
+        let addressTypeKeys = Object.values(types_1.EAddressType);
+        if (addressType) {
+            addressTypeKeys = [addressType];
+        }
+        let updated = false;
+        const promises = addressTypeKeys.map(async (addressTypeKey) => {
+            const response = await this.getNextAvailableAddress(addressTypeKey);
+            if (response.isErr()) {
+                throw response.error;
+            }
+            const result = response.value;
+            let addressIndex = currentWallet.addressIndex[addressTypeKey];
+            let changeAddressIndex = currentWallet.changeAddressIndex[addressTypeKey];
+            let lastUsedAddressIndex = currentWallet.lastUsedAddressIndex[addressTypeKey];
+            let lastUsedChangeAddressIndex = currentWallet.lastUsedChangeAddressIndex[addressTypeKey];
+            if (addressIndex.index < 0 ||
+                changeAddressIndex.index < 0 ||
+                result.addressIndex.index > addressIndex.index ||
+                result.changeAddressIndex.index > changeAddressIndex.index ||
+                result.lastUsedAddressIndex.index > lastUsedAddressIndex.index ||
+                result.lastUsedChangeAddressIndex.index >
+                    (lastUsedChangeAddressIndex === null || lastUsedChangeAddressIndex === void 0 ? void 0 : lastUsedChangeAddressIndex.index)) {
+                if (result.addressIndex) {
+                    addressIndex = result.addressIndex;
+                }
+                if (result.changeAddressIndex) {
+                    changeAddressIndex = result.changeAddressIndex;
+                }
+                if (result.lastUsedAddressIndex) {
+                    lastUsedAddressIndex = result.lastUsedAddressIndex;
+                }
+                if (result.lastUsedChangeAddressIndex) {
+                    lastUsedChangeAddressIndex = result.lastUsedChangeAddressIndex;
+                }
+                const lastUsedIndex = lastUsedAddressIndex.index > 0 ? lastUsedAddressIndex.index : 0;
+                const currentGap = Math.abs(addressIndex.index - lastUsedIndex);
+                if (currentGap > constants_1.GAP_LIMIT) {
+                    const excessAmount = currentGap - constants_1.GAP_LIMIT;
+                    const newIndex = addressIndex.index - excessAmount;
+                    const _addressIndex = await this.generateAddresses({
+                        addressType: addressTypeKey,
+                        addressAmount: 1,
+                        changeAddressAmount: 0,
+                        addressIndex: newIndex
+                    });
+                    if (_addressIndex.isErr()) {
+                        return (0, utils_1.err)(_addressIndex.error.message);
+                    }
+                    addressIndex = Object.values(_addressIndex.value.addresses)[0];
+                }
+                const lastUsedChangeIndex = lastUsedChangeAddressIndex.index > 0
+                    ? lastUsedChangeAddressIndex.index
+                    : 0;
+                const currentChangeAddressGap = Math.abs(changeAddressIndex.index - lastUsedChangeIndex);
+                if (currentChangeAddressGap > constants_1.GAP_LIMIT) {
+                    const excessAmount = currentGap - constants_1.GAP_LIMIT;
+                    const newIndex = addressIndex.index - excessAmount;
+                    const _changeAddressIndex = await this.generateAddresses({
+                        addressType: addressTypeKey,
+                        addressAmount: 0,
+                        changeAddressAmount: 1,
+                        changeAddressIndex: newIndex
+                    });
+                    if (_changeAddressIndex.isErr()) {
+                        return (0, utils_1.err)(_changeAddressIndex.error.message);
+                    }
+                    changeAddressIndex = Object.values(_changeAddressIndex.value.changeAddresses)[0];
+                }
+                this._data.addressIndex[addressTypeKey] = addressIndex;
+                this._data.changeAddressIndex[addressTypeKey] = changeAddressIndex;
+                this._data.lastUsedAddressIndex[addressTypeKey] = lastUsedAddressIndex;
+                this._data.lastUsedChangeAddressIndex[addressTypeKey] =
+                    lastUsedChangeAddressIndex;
+                await Promise.all([
+                    this.saveWalletData('addressIndex', this._data.addressIndex),
+                    this.saveWalletData('changeAddressIndex', this._data.changeAddressIndex),
+                    this.saveWalletData('lastUsedAddressIndex', this._data.lastUsedAddressIndex),
+                    this.saveWalletData('lastUsedChangeAddressIndex', this._data.lastUsedChangeAddressIndex)
+                ]);
+                updated = true;
+            }
+        });
+        try {
+            await Promise.all(promises);
+            return (0, utils_1.ok)(updated ? 'Successfully updated indexes.' : 'No update needed.');
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async resetAddressIndexes() {
+        const defaultWalletShape = (0, utils_1.getDefaultWalletData)();
+        this._data.addressIndex = defaultWalletShape.addressIndex;
+        this._data.changeAddressIndex = defaultWalletShape.changeAddressIndex;
+        this._data.lastUsedAddressIndex = defaultWalletShape.lastUsedAddressIndex;
+        this._data.lastUsedChangeAddressIndex =
+            defaultWalletShape.lastUsedChangeAddressIndex;
+        await Promise.all([
+            this.saveWalletData('addressIndex', this._data.addressIndex),
+            this.saveWalletData('changeAddressIndex', this._data.changeAddressIndex),
+            this.saveWalletData('lastUsedAddressIndex', this._data.lastUsedAddressIndex),
+            this.saveWalletData('lastUsedChangeAddressIndex', this._data.lastUsedChangeAddressIndex)
+        ]);
+    }
+    async generateNewReceiveAddress({ addressType = this.data.addressType, keyDerivationPath }) {
+        try {
+            const network = this._network;
+            const currentWallet = this.data;
+            const getGapLimitResponse = this.getGapLimit({
+                addressType
+            });
+            if (getGapLimitResponse.isErr()) {
+                return (0, utils_1.err)(getGapLimitResponse.error.message);
+            }
+            const { addressDelta } = getGapLimitResponse.value;
+            if (addressDelta >= constants_1.GAP_LIMIT) {
+                const addressIndex = currentWallet.addressIndex;
+                const receiveAddress = addressIndex[addressType];
+                return (0, utils_1.ok)(receiveAddress);
+            }
+            const { path } = shapes_1.addressTypes[addressType];
+            if (!keyDerivationPath) {
+                const keyDerivationPathResponse = (0, utils_1.getKeyDerivationPathObject)({
+                    network,
+                    path
+                });
+                if (keyDerivationPathResponse.isErr()) {
+                    return (0, utils_1.err)(keyDerivationPathResponse.error.message);
+                }
+                keyDerivationPath = keyDerivationPathResponse.value;
+            }
+            const addresses = currentWallet.addresses[addressType];
+            const currentAddressIndex = currentWallet.addressIndex[addressType].index;
+            const nextAddressIndex = Object.values(addresses).find((address) => {
+                return address.index === currentAddressIndex + 1;
+            });
+            if (nextAddressIndex) {
+                this._data.addressIndex[addressType] = nextAddressIndex;
+                await Promise.all([
+                    this.saveWalletData('addressIndex', this._data.addressIndex)
+                ]);
+                return (0, utils_1.ok)(nextAddressIndex);
+            }
+            const addAddressesRes = await this.addAddresses({
+                addressAmount: 1,
+                changeAddressAmount: 0,
+                addressIndex: currentAddressIndex + 1,
+                changeAddressIndex: 0,
+                keyDerivationPath,
+                addressType
+            });
+            if (addAddressesRes.isErr()) {
+                return (0, utils_1.err)(addAddressesRes.error.message);
+            }
+            const addressKeys = Object.keys(addAddressesRes.value.addresses);
+            if (!addressKeys.length) {
+                return (0, utils_1.err)('Unable to generate addresses at this time.');
+            }
+            const newAddressIndex = addAddressesRes.value.addresses[addressKeys[0]];
+            this._data.addressIndex[addressType] = newAddressIndex;
+            await this.saveWalletData('addressIndex', this._data.addressIndex);
+            return (0, utils_1.ok)(newAddressIndex);
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    getGapLimit({ addressType }) {
+        try {
+            if (!addressType) {
+                addressType = this.data.addressType;
+            }
+            const currentWallet = this.data;
+            const addressIndex = currentWallet.addressIndex[addressType].index;
+            const lastUsedAddressIndex = currentWallet.lastUsedAddressIndex[addressType].index;
+            const changeAddressIndex = currentWallet.changeAddressIndex[addressType].index;
+            const lastUsedChangeAddressIndex = currentWallet.lastUsedChangeAddressIndex[addressType].index;
+            const addressDelta = Math.abs(addressIndex - (lastUsedAddressIndex > 0 ? lastUsedAddressIndex : 0));
+            const changeAddressDelta = Math.abs(changeAddressIndex -
+                (lastUsedChangeAddressIndex > 0 ? lastUsedChangeAddressIndex : 0));
+            return (0, utils_1.ok)({ addressDelta, changeAddressDelta });
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async getUtxos({ scanAllAddresses = false }) {
+        var _a, _b, _c, _d;
+        const checkRes = await this.checkElectrumConnection();
+        if (checkRes.isErr())
+            return (0, utils_1.err)(checkRes.error.message);
+        const getUtxosRes = await this.electrum.getUtxos({ scanAllAddresses });
+        if (getUtxosRes.isErr()) {
+            return (0, utils_1.err)(getUtxosRes.error.message);
+        }
+        const utxos = (_b = (_a = getUtxosRes.value) === null || _a === void 0 ? void 0 : _a.utxos) !== null && _b !== void 0 ? _b : [];
+        const balance = (_d = (_c = getUtxosRes.value) === null || _c === void 0 ? void 0 : _c.balance) !== null && _d !== void 0 ? _d : 0;
+        this._data.utxos = utxos;
+        this._data.balance = balance;
+        await Promise.all([
+            this.saveWalletData('utxos', this._data.utxos),
+            this.saveWalletData('balance', this._data.balance)
+        ]);
+        return (0, utils_1.ok)({ utxos, balance });
+    }
+    listUtxos() {
+        return this.data.utxos;
+    }
+    async saveWalletData(key, data) {
+        if (!this._setData)
+            return;
+        const walletDataKey = this.getWalletDataKey(key);
+        await this._setData(walletDataKey, data);
+    }
+    async updateAndSaveWalletData(key, data, addressType) {
+        if (addressType) {
+            this.data[key][addressType] = data;
+            await this.saveWalletData(key, this._data[key]);
+        }
+        else {
+            this.data[key] = data;
+            await this.saveWalletData(key, this._data[key]);
+        }
+    }
+    async updateTransactions({ scanAllAddresses = false, replaceStoredTransactions = false }) {
+        await this.checkUnconfirmedTransactions();
+        const history = await this.electrum.getAddressHistory({
+            scanAllAddresses: scanAllAddresses || replaceStoredTransactions
+        });
+        if (history.isErr()) {
+            return (0, utils_1.err)(history.error.message);
+        }
+        if (!history.value.length) {
+            return (0, utils_1.ok)(undefined);
+        }
+        const getTransactionsResponse = await this.electrum.getTransactions({
+            txHashes: history.value
+        });
+        if (getTransactionsResponse.isErr()) {
+            return (0, utils_1.err)(getTransactionsResponse.error.message);
+        }
+        const formatTransactionsResponse = await this.formatTransactions({
+            transactions: getTransactionsResponse.value.data
+        });
+        if (formatTransactionsResponse.isErr()) {
+            return (0, utils_1.err)(formatTransactionsResponse.error.message);
+        }
+        const transactions = formatTransactionsResponse.value;
+        this.addUnconfirmedTransactions({
+            transactions
+        });
+        if (replaceStoredTransactions) {
+            this._data.transactions = transactions;
+            await this.saveWalletData('transactions', this._data.transactions);
+            return (0, utils_1.ok)(undefined);
+        }
+        const formattedTransactions = {};
+        let notificationTxid;
+        const storedTransactions = this.data.transactions;
+        const confirmedTxs = [];
+        const receivedTxs = [];
+        const sentTxs = [];
+        Object.keys(transactions).forEach((txid) => {
+            var _a, _b, _c, _d, _e;
+            if (!storedTransactions[txid] ||
+                storedTransactions[txid].height !== transactions[txid].height) {
+                formattedTransactions[txid] = Object.assign(Object.assign({}, transactions[txid]), { timestamp: (_d = (_b = (_a = storedTransactions[txid]) === null || _a === void 0 ? void 0 : _a.timestamp) !== null && _b !== void 0 ? _b : (_c = transactions[txid]) === null || _c === void 0 ? void 0 : _c.timestamp) !== null && _d !== void 0 ? _d : Date.now() });
+                if (this.onMessage && ((_e = formattedTransactions[txid]) === null || _e === void 0 ? void 0 : _e.height) > 0)
+                    confirmedTxs.push({ transaction: formattedTransactions[txid] });
+            }
+            if (!(txid in storedTransactions)) {
+                if (this.onMessage) {
+                    if (transactions[txid].type === types_1.EPaymentType.received) {
+                        receivedTxs.push({ transaction: transactions[txid] });
+                    }
+                    else if (transactions[txid].type === types_1.EPaymentType.sent) {
+                        sentTxs.push({ transaction: transactions[txid] });
+                    }
+                }
+                notificationTxid = txid;
+            }
+        });
+        if (!Object.keys(formattedTransactions).length) {
+            return (0, utils_1.ok)(undefined);
+        }
+        this._data.transactions = Object.assign(Object.assign({}, this._data.transactions), formattedTransactions);
+        await this.saveWalletData('transactions', this._data.transactions);
+        if (this.onMessage) {
+            confirmedTxs.forEach((tx) => {
+                this.onMessage('transactionConfirmed', tx);
+            });
+            sentTxs.forEach((tx) => {
+                this.onMessage('transactionSent', tx);
+            });
+            receivedTxs.forEach((tx) => {
+                this.onMessage('transactionReceived', tx);
+            });
+        }
+        return (0, utils_1.ok)(notificationTxid);
+    }
+    async checkUnconfirmedTransactions() {
+        try {
+            const processRes = await this.processUnconfirmedTransactions();
+            if (processRes.isErr()) {
+                return (0, utils_1.err)(processRes.error.message);
+            }
+            const { unconfirmedTxs, outdatedTxs, ghostTxs } = processRes.value;
+            if (outdatedTxs.length > 0) {
+                if (this.onMessage)
+                    this.onMessage('reorg', outdatedTxs);
+                await this.updateTransactionHeights(outdatedTxs);
+            }
+            if (ghostTxs.length > 0) {
+                if (this.onMessage)
+                    this.onMessage('rbf', ghostTxs);
+                await this.updateGhostTransactions({
+                    txIds: ghostTxs
+                });
+            }
+            else {
+                this._data.unconfirmedTransactions = unconfirmedTxs;
+                await Promise.all([
+                    this.saveWalletData('unconfirmedTransactions', this._data.unconfirmedTransactions)
+                ]);
+            }
+            return (0, utils_1.ok)('Successfully updated unconfirmed transactions.');
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async processUnconfirmedTransactions() {
+        try {
+            const oldUnconfirmedTxs = this.getUnconfirmedTransactions();
+            const tx_hashes = Object.values(oldUnconfirmedTxs).map((transaction) => {
+                return { tx_hash: transaction.txid };
+            });
+            const txs = await this.electrum.getTransactions({
+                txHashes: tx_hashes
+            });
+            if (txs.isErr()) {
+                return (0, utils_1.err)(txs.error);
+            }
+            const unconfirmedTxs = {};
+            const outdatedTxs = [];
+            const ghostTxs = [];
+            txs.value.data.forEach((txData) => {
+                var _a, _b, _c, _d, _e, _f;
+                if (!this.electrum.transactionExists(txData)) {
+                    ghostTxs.push(txData.data.tx_hash);
+                    return;
+                }
+                const newHeight = this.confirmationsToBlockHeight({
+                    confirmations: (_b = (_a = txData.result) === null || _a === void 0 ? void 0 : _a.confirmations) !== null && _b !== void 0 ? _b : 0
+                });
+                if (!((_c = txData.result) === null || _c === void 0 ? void 0 : _c.confirmations)) {
+                    const oldHeight = (_e = (_d = oldUnconfirmedTxs[txData.data.tx_hash]) === null || _d === void 0 ? void 0 : _d.height) !== null && _e !== void 0 ? _e : 0;
+                    if (oldHeight > newHeight) {
+                        outdatedTxs.push(txData.data);
+                    }
+                    unconfirmedTxs[txData.data.tx_hash] = Object.assign(Object.assign({}, oldUnconfirmedTxs[txData.data.tx_hash]), { height: newHeight });
+                    return;
+                }
+                if (((_f = txData.result) === null || _f === void 0 ? void 0 : _f.confirmations) < 6) {
+                    unconfirmedTxs[txData.data.tx_hash] = Object.assign(Object.assign({}, oldUnconfirmedTxs[txData.data.tx_hash]), { height: newHeight });
+                }
+            });
+            return (0, utils_1.ok)({
+                unconfirmedTxs,
+                outdatedTxs,
+                ghostTxs
+            });
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    getUnconfirmedTransactions() {
+        var _a;
+        const currentWallet = this.data;
+        return (_a = currentWallet === null || currentWallet === void 0 ? void 0 : currentWallet.unconfirmedTransactions) !== null && _a !== void 0 ? _a : {};
+    }
+    confirmationsToBlockHeight({ confirmations, currentHeight }) {
+        if (!currentHeight) {
+            const header = this.data.header;
+            currentHeight = header.height;
+        }
+        if (confirmations > currentHeight) {
+            return 0;
+        }
+        return currentHeight - confirmations;
+    }
+    async updateHeader(headerData) {
+        this._data.header = headerData;
+        await this.saveWalletData('header', headerData);
+    }
+    async updateGhostTransactions({ txIds }) {
+        try {
+            const transactions = this.data.transactions;
+            const unconfirmedTransactions = this.data.unconfirmedTransactions;
+            txIds.forEach((txId) => {
+                if (txId in transactions) {
+                    transactions[txId]['exists'] = false;
+                }
+                if (txId in unconfirmedTransactions) {
+                    delete unconfirmedTransactions[txId];
+                }
+            });
+            this._data.transactions = transactions;
+            await this.saveWalletData('transactions', transactions);
+            this._data.unconfirmedTransactions = unconfirmedTransactions;
+            await this.saveWalletData('unconfirmedTransactions', unconfirmedTransactions);
+            await this.rescanAddresses({
+                shouldClearAddresses: false
+            });
+            return (0, utils_1.ok)('Successfully deleted transactions.');
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async rescanAddresses({ shouldClearAddresses = true, shouldClearTransactions = false }) {
+        if (shouldClearAddresses) {
+            await this.clearAddresses();
+        }
+        if (shouldClearTransactions) {
+            await this.clearTransactions();
+        }
+        await this.clearUtxos();
+        await this.resetAddressIndexes();
+        await this.setZeroIndexAddresses();
+        return await this.refreshWallet({
+            scanAllAddresses: true
+        });
+    }
+    async clearUtxos() {
+        this._data.balance = 0;
+        this._data.utxos = [];
+        await Promise.all([
+            this.saveWalletData('balance', this._data.balance),
+            this.saveWalletData('utxos', this._data.utxos)
+        ]);
+        return "Successfully cleared UTXO's.";
+    }
+    async clearTransactions() {
+        this._data.transactions = (0, utils_1.getDefaultWalletData)().transactions;
+        await this.saveWalletData('transactions', this._data.transactions);
+        return 'Successfully reset transactions.';
+    }
+    async clearAddresses() {
+        this._data.addresses = (0, shapes_1.getAddressTypeContent)({});
+        this._data.changeAddresses = (0, shapes_1.getAddressTypeContent)({});
+        await Promise.all([
+            this.saveWalletData('addresses', this._data.addresses),
+            this.saveWalletData('changeAddresses', this._data.changeAddresses)
+        ]);
+        return 'Successfully reset transactions.';
+    }
+    async updateTransactionHeights(txs) {
+        let needsSave = false;
+        const transactions = this.data.transactions;
+        txs.forEach((tx) => {
+            const txId = tx.tx_hash;
+            if (txId in transactions) {
+                transactions[txId].confirmTimestamp = 0;
+                needsSave = true;
+            }
+        });
+        if (needsSave) {
+            await this.saveWalletData('transactions', transactions);
+        }
+        return 'Successfully updated reorg transactions.';
+    }
+    async addUnconfirmedTransactions({ transactions }) {
+        try {
+            const unconfirmedTransactions = {};
+            Object.keys(transactions).forEach((key) => {
+                const confirmations = this.blockHeightToConfirmations({
+                    blockHeight: transactions[key].height
+                });
+                if (confirmations < 6) {
+                    unconfirmedTransactions[key] = transactions[key];
+                }
+            });
+            if (!Object.keys(unconfirmedTransactions).length) {
+                return (0, utils_1.ok)('No unconfirmed transactions found.');
+            }
+            this._data.unconfirmedTransactions = Object.assign(Object.assign({}, this.data.unconfirmedTransactions), unconfirmedTransactions);
+            await this.saveWalletData('unconfirmedTransactions', this._data.unconfirmedTransactions);
+            return (0, utils_1.ok)('Successfully updated unconfirmed transactions.');
+        }
+        catch (e) {
+            console.log(e);
+            return (0, utils_1.err)(e);
+        }
+    }
+    blockHeightToConfirmations({ blockHeight, currentHeight }) {
+        if (!blockHeight) {
+            return 0;
+        }
+        if (!currentHeight) {
+            const header = this.electrum.getBlockHeader();
+            currentHeight = header.height;
+        }
+        if (currentHeight < blockHeight) {
+            return 0;
+        }
+        return currentHeight - blockHeight + 1;
+    }
+    async formatTransactions({ transactions }) {
+        if (transactions.length < 1) {
+            return (0, utils_1.ok)({});
+        }
+        const currentWallet = this.data;
+        const inputs = [];
+        transactions.forEach(({ result }) => {
+            if (result === null || result === void 0 ? void 0 : result.vin) {
+                result.vin.forEach((v) => inputs.push({ tx_hash: v.txid, vout: v.vout }));
+            }
+        });
+        const inputDataResponse = await this.getInputData({
+            inputs
+        });
+        if (inputDataResponse.isErr()) {
+            return (0, utils_1.err)(inputDataResponse.error.message);
+        }
+        const addressTypeKeys = Object.values(types_1.EAddressType);
+        const inputData = inputDataResponse.value;
+        const currentAddresses = currentWallet.addresses;
+        const currentChangeAddresses = currentWallet.changeAddresses;
+        let addresses = {};
+        let changeAddresses = {};
+        let rbf = false;
+        addressTypeKeys.map((addressType) => {
+            var _a, _b;
+            if (((_a = Object.keys(currentAddresses[addressType])) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                addresses = Object.assign(Object.assign({}, addresses), currentAddresses[addressType]);
+            }
+            if (((_b = Object.keys(currentChangeAddresses[addressType])) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                changeAddresses = Object.assign(Object.assign({}, changeAddresses), currentChangeAddresses[addressType]);
+            }
+        });
+        const combinedAddressObj = {};
+        [...Object.values(addresses), ...Object.values(changeAddresses)].map((data) => {
+            combinedAddressObj[data.address] = data;
+        });
+        const formattedTransactions = {};
+        transactions.map(async ({ data, result }) => {
+            if (!result.txid) {
+                return;
+            }
+            let totalInputValue = 0;
+            let matchedInputValue = 0;
+            let totalOutputValue = 0;
+            let matchedOutputValue = 0;
+            let messages = [];
+            result.vin.map(({ txid, scriptSig, vout, sequence }) => {
+                try {
+                    const asm = scriptSig.asm;
+                    if (asm !== '' && asm.includes('OP_RETURN')) {
+                        const OpReturnMessages = (0, utils_1.decodeOpReturnMessage)(asm);
+                        messages = messages.concat(OpReturnMessages);
+                    }
+                }
+                catch (_a) { }
+                try {
+                    if (sequence < 0xffffffff - 1)
+                        rbf = true;
+                }
+                catch (_b) { }
+                const { addresses: _addresses, value } = inputData[`${txid}${vout}`];
+                totalInputValue = totalInputValue + value;
+                _addresses.map((address) => {
+                    if (address in combinedAddressObj) {
+                        matchedInputValue = matchedInputValue + value;
+                    }
+                });
+            });
+            result.vout.map(({ scriptPubKey, value }) => {
+                const _addresses = scriptPubKey.addresses
+                    ? scriptPubKey.addresses
+                    : scriptPubKey.address
+                        ? [scriptPubKey.address]
+                        : [];
+                totalOutputValue = totalOutputValue + value;
+                _addresses.map((address) => {
+                    if (address in combinedAddressObj) {
+                        matchedOutputValue = matchedOutputValue + value;
+                    }
+                });
+            });
+            const txid = result.txid;
+            const type = matchedInputValue > matchedOutputValue
+                ? types_1.EPaymentType.sent
+                : types_1.EPaymentType.received;
+            const totalMatchedValue = matchedOutputValue - matchedInputValue;
+            const value = Number(totalMatchedValue.toFixed(8));
+            const totalValue = totalInputValue - totalOutputValue;
+            const fee = Number(Math.abs(totalValue).toFixed(8));
+            const vsize = result.vsize;
+            const satsPerByte = Math.round((0, conversion_1.btcToSats)(fee) / vsize);
+            const { address, height, scriptHash } = data;
+            let timestamp = Date.now();
+            let confirmTimestamp;
+            if (height > 0 && result.blocktime) {
+                confirmTimestamp = result.blocktime * 1000;
+                if (confirmTimestamp < timestamp) {
+                    timestamp = confirmTimestamp;
+                }
+            }
+            formattedTransactions[txid] = {
+                address,
+                height,
+                scriptHash,
+                totalInputValue,
+                matchedInputValue,
+                totalOutputValue,
+                matchedOutputValue,
+                fee,
+                satsPerByte,
+                type,
+                value,
+                txid,
+                messages,
+                timestamp,
+                confirmTimestamp,
+                vin: result.vin,
+                rbf,
+                exists: true,
+                vsize
+            };
+        });
+        return (0, utils_1.ok)(formattedTransactions);
+    }
+    async getInputData({ inputs }) {
+        try {
+            const inputData = {};
+            for (let i = 0; i < inputs.length; i += constants_1.CHUNK_LIMIT) {
+                const chunk = inputs.slice(i, i + constants_1.CHUNK_LIMIT);
+                const getTransactionsResponse = await this.electrum.getTransactionsFromInputs({
+                    txHashes: chunk
+                });
+                if (getTransactionsResponse.isErr()) {
+                    return (0, utils_1.err)(getTransactionsResponse.error.message);
+                }
+                getTransactionsResponse.value.data.map(({ data, result }) => {
+                    const vout = result.vout[data.vout];
+                    const addresses = vout.scriptPubKey.addresses
+                        ? vout.scriptPubKey.addresses
+                        : vout.scriptPubKey.address
+                            ? [vout.scriptPubKey.address]
+                            : [];
+                    const value = vout.value;
+                    const key = `${data.tx_hash}${vout.n}`;
+                    inputData[key] = { addresses, value };
+                });
+            }
+            return (0, utils_1.ok)(inputData);
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    getExchangeRate(currency = 'EUR') {
+        var _a, _b;
+        try {
+            if (currency in this.exchangeRates) {
+                return (_b = (_a = this.exchangeRates[currency]) === null || _a === void 0 ? void 0 : _a.rate) !== null && _b !== void 0 ? _b : 0;
+            }
+            return 0;
+        }
+        catch (_c) {
+            return 0;
+        }
+    }
+    validateAddress(address) {
+        return (0, utils_1.validateAddress)({ address, network: this._network }).isValid;
+    }
+    async getChangeAddress(addressType = this.data.addressType) {
+        const currentWallet = this.data;
+        const changeAddressIndexContent = currentWallet.changeAddressIndex[addressType];
+        if ((changeAddressIndexContent === null || changeAddressIndexContent === void 0 ? void 0 : changeAddressIndexContent.address) &&
+            changeAddressIndexContent.index >= 0) {
+            return (0, utils_1.ok)(changeAddressIndexContent);
+        }
+        const generateAddressResponse = await this.generateAddresses({
+            addressAmount: 0,
+            changeAddressAmount: 1,
+            addressType
+        });
+        if (generateAddressResponse.isErr()) {
+            console.log(generateAddressResponse.error.message);
+            return (0, utils_1.err)('Unable to successfully generate a change address.');
+        }
+        return (0, utils_1.ok)(generateAddressResponse.value.changeAddresses[0]);
+    }
+    async getFeeEstimates(network = this._network) {
+        try {
+            if (network === types_1.EAvailableNetworks.bitcoinRegtest) {
+                return {
+                    fast: 60,
+                    normal: 50,
+                    slow: 40,
+                    minimum: 30,
+                    timestamp: Date.now()
+                };
+            }
+            const urlModifier = network === 'bitcoin' ? '' : 'testnet/';
+            const response = await fetch(`https://mempool.space/${urlModifier}api/v1/fees/recommended`);
+            const res = await response.json();
+            return {
+                fast: res.fastestFee,
+                normal: res.halfHourFee,
+                slow: res.hourFee,
+                minimum: res.minimumFee,
+                timestamp: Date.now()
+            };
+        }
+        catch (_a) {
+            return shapes_1.defaultFeesShape;
+        }
+    }
+    async setupTransaction(params = {}) {
+        return await this.transaction.setupTransaction(params);
+    }
+    getFeeInfo({ satsPerByte = this.feeEstimates.normal, message = '', transaction, fundingLightning = false } = {}) {
+        return this.transaction.getTotalFeeObj({
+            satsPerByte,
+            message,
+            transaction,
+            fundingLightning
+        });
+    }
+    async sendMany({ txs = [], satsPerByte = this.feeEstimates.normal, rbf, broadcast = true, shuffleOutputs = true }) {
+        const setupTransactionRes = await this.transaction.setupTransaction({
+            rbf
+        });
+        if (setupTransactionRes.isErr()) {
+            return (0, utils_1.err)(setupTransactionRes.error.message);
+        }
+        if (!Array.isArray(txs))
+            txs = [txs];
+        const shuffledTxs = shuffleOutputs ? (0, utils_1.shuffleArray)(txs) : txs;
+        let index = 0;
+        for (const tx of shuffledTxs) {
+            const updateSendTransactionRes = this.transaction.updateSendTransaction({
+                transaction: {
+                    label: tx.message,
+                    outputs: [{ address: tx.address, value: tx.amount, index }]
+                }
+            });
+            if (updateSendTransactionRes.isErr())
+                (0, utils_1.err)(updateSendTransactionRes.error.message);
+            index++;
+        }
+        const updateFeeRes = this.transaction.updateFee({ satsPerByte });
+        if (updateFeeRes.isErr()) {
+            if (updateFeeRes.error.message.includes('Unable to increase the fee')) {
+                const feeInfo = this.getFeeInfo({ satsPerByte: 1 });
+                if (feeInfo.isOk()) {
+                    return (0, utils_1.err)(`Fee is too high. The maximum fee for this transaction is ${feeInfo.value.maxSatPerByte}`);
+                }
+            }
+            else {
+                return (0, utils_1.err)(updateFeeRes.error.message);
+            }
+        }
+        const createRes = await this.transaction.createTransaction({
+            shuffleOutputs
+        });
+        if (createRes.isErr())
+            return (0, utils_1.err)(createRes.error.message);
+        const { hex } = createRes.value;
+        if (!broadcast) {
+            return (0, utils_1.ok)(hex);
+        }
+        const broadcastRes = await this.electrum.broadcastTransaction({
+            rawTx: hex
+        });
+        if (broadcastRes.isErr())
+            return (0, utils_1.err)(broadcastRes.error.message);
+        return (0, utils_1.ok)(broadcastRes.value);
+    }
+    async send({ address, amount, message = '', satsPerByte = this.feeEstimates.normal, rbf, broadcast = true, shuffleOutputs = true }) {
+        return await this.sendMany({
+            txs: [{ address, amount, message }],
+            satsPerByte,
+            rbf,
+            broadcast,
+            shuffleOutputs
+        });
+    }
+    getAddressFromScriptHash(scriptHash) {
+        const addresses = this.data.addresses;
+        const changeAddresses = this.data.changeAddresses;
+        const combinedAddresses = [
+            ...Object.values(addresses),
+            ...Object.values(changeAddresses)
+        ].flatMap((addressGroup) => Object.values(addressGroup));
+        return combinedAddresses.find((addressObj) => addressObj.scriptHash === scriptHash);
+    }
+    async setZeroIndexAddresses() {
+        const types = Object.values(types_1.EAddressType);
+        const currentWallet = this.data;
+        let saveAddressIndexes = false;
+        let saveChangeAddressIndexes = false;
+        for (const addressType of types) {
+            const addressIndex = currentWallet.addressIndex[addressType];
+            const changeAddressIndex = currentWallet.changeAddressIndex[addressType];
+            if ((addressIndex === null || addressIndex === void 0 ? void 0 : addressIndex.index) < 0) {
+                await this.updateAddressIndex(addressType, false);
+                saveAddressIndexes = true;
+            }
+            if ((changeAddressIndex === null || changeAddressIndex === void 0 ? void 0 : changeAddressIndex.index) < 0) {
+                await this.updateAddressIndex(addressType, true);
+                saveChangeAddressIndexes = true;
+            }
+        }
+        if (saveAddressIndexes) {
+            await this.saveWalletData('addressIndex', this._data.addressIndex);
+        }
+        if (saveChangeAddressIndexes) {
+            await this.saveWalletData('changeAddressIndex', this._data.changeAddressIndex);
+        }
+        return (0, utils_1.ok)('Set Zero Index Addresses.');
+    }
+    async updateAddressIndex(addressType, isChangeAddress, index = 0) {
+        const address = await this.generateAddresses({
+            addressAmount: isChangeAddress ? 0 : 1,
+            addressIndex: index,
+            changeAddressAmount: isChangeAddress ? 1 : 0,
+            changeAddressIndex: index,
+            addressType
+        });
+        const indexToUpdate = isChangeAddress
+            ? 'changeAddressIndex'
+            : 'addressIndex';
+        if (address.isOk()) {
+            const key = isChangeAddress ? 'changeAddresses' : 'addresses';
+            this._data[indexToUpdate][addressType] =
+                address.value[key][Object.keys(address.value[key])[0]];
+        }
+        let addresses = {};
+        if (indexToUpdate === 'addressIndex') {
+            addresses = this.data.addresses[addressType];
+        }
+        else {
+            addresses = this.data.changeAddresses[addressType];
+        }
+        if (!Object.keys(addresses).length) {
+            await this.addAddresses({
+                addressAmount: indexToUpdate === 'addressIndex' ? constants_1.GENERATE_ADDRESS_AMOUNT : 0,
+                addressIndex: index,
+                changeAddressAmount: indexToUpdate === 'changeAddressIndex' ? constants_1.GENERATE_ADDRESS_AMOUNT : 0,
+                changeAddressIndex: index,
+                addressType
+            });
+        }
+    }
+    getAddressIndexInfo() {
+        const addressType = this.data.addressType;
+        const currentWallet = this.data;
+        const addressIndex = currentWallet.addressIndex[addressType];
+        const changeAddressIndex = currentWallet.addressIndex[addressType];
+        const lastUsedAddressIndex = currentWallet.lastUsedAddressIndex[addressType];
+        const lastUsedChangeAddressIndex = currentWallet.lastUsedChangeAddressIndex[addressType];
+        return {
+            addressIndex,
+            changeAddressIndex,
+            lastUsedAddressIndex,
+            lastUsedChangeAddressIndex
+        };
+    }
+    async getRbfData({ txHash }) {
+        var _a, _b, _c, _d, _e;
+        const txResponse = await this.electrum.getTransactions({
+            txHashes: [txHash]
+        });
+        if (txResponse.isErr()) {
+            return (0, utils_1.err)(txResponse.error.message);
+        }
+        const txData = txResponse.value.data;
+        const wallet = this.data;
+        const addressTypeKeys = (0, utils_1.objectKeys)(types_1.EAddressType);
+        const addresses = wallet.addresses;
+        const changeAddresses = wallet.changeAddresses;
+        let allAddresses = {};
+        let allChangeAddresses = {};
+        await Promise.all(addressTypeKeys.map((addressType) => {
+            allAddresses = Object.assign(Object.assign(Object.assign({}, allAddresses), addresses[addressType]), changeAddresses[addressType]);
+            allChangeAddresses = Object.assign(Object.assign({}, allChangeAddresses), changeAddresses[addressType]);
+        }));
+        let changeAddressData = {
+            address: '',
+            value: 0,
+            index: 0
+        };
+        const inputs = [];
+        let address = '';
+        let scriptHash = '';
+        let path = '';
+        let value = 0;
+        const addressType = types_1.EAddressType.p2wpkh;
+        const outputs = [];
+        let message = '';
+        let inputTotal = 0;
+        let outputTotal = 0;
+        let fee = 0;
+        const insAndOuts = await Promise.all(txData.map(({ result }) => {
+            var _a, _b;
+            const vin = (_a = result.vin) !== null && _a !== void 0 ? _a : [];
+            const vout = (_b = result.vout) !== null && _b !== void 0 ? _b : [];
+            return { vins: vin, vouts: vout };
+        }));
+        const { vins, vouts } = insAndOuts[0];
+        for (let i = 0; i < vins.length; i++) {
+            try {
+                const input = vins[i];
+                const txId = input.txid;
+                const tx = await this.electrum.getTransactions({
+                    txHashes: [{ tx_hash: txId }]
+                });
+                if (tx.isErr()) {
+                    return (0, utils_1.err)(tx.error.message);
+                }
+                if (tx.value.data[0].data.height > 0) {
+                    return (0, utils_1.err)('Transaction is already confirmed. Unable to RBF.');
+                }
+                const txVout = tx.value.data[0].result.vout[input.vout];
+                if ((_a = txVout.scriptPubKey) === null || _a === void 0 ? void 0 : _a.address) {
+                    address = txVout.scriptPubKey.address;
+                }
+                else if (((_b = txVout.scriptPubKey) === null || _b === void 0 ? void 0 : _b.addresses) &&
+                    txVout.scriptPubKey.addresses.length) {
+                    address = txVout.scriptPubKey.addresses[0];
+                }
+                if (!address) {
+                    continue;
+                }
+                scriptHash = (0, utils_1.getScriptHash)({ address, network: this._network });
+                if (!(scriptHash in allAddresses)) {
+                    continue;
+                }
+                path = allAddresses[scriptHash].path;
+                value = (0, conversion_1.btcToSats)(txVout.value);
+                inputs.push({
+                    tx_hash: input.txid,
+                    index: input.vout,
+                    tx_pos: input.vout,
+                    height: 0,
+                    address,
+                    scriptHash,
+                    path,
+                    value
+                });
+                if (value) {
+                    inputTotal = inputTotal + value;
+                }
+            }
+            catch (e) {
+                console.log(e);
+            }
+        }
+        for (let i = 0; i < vouts.length; i++) {
+            const vout = vouts[i];
+            const voutValue = (0, conversion_1.btcToSats)(vout.value);
+            if ((_c = vout.scriptPubKey) === null || _c === void 0 ? void 0 : _c.addresses) {
+                address = vout.scriptPubKey.addresses[0];
+            }
+            else if ((_d = vout.scriptPubKey) === null || _d === void 0 ? void 0 : _d.address) {
+                address = vout.scriptPubKey.address;
+            }
+            else {
+                try {
+                    if (vout.scriptPubKey.asm.includes('OP_RETURN')) {
+                        message = (0, utils_1.decodeOpReturnMessage)(vout.scriptPubKey.asm)[0] || '';
+                    }
+                }
+                catch (_f) { }
+            }
+            if (!address) {
+                continue;
+            }
+            const changeAddressScriptHash = await (0, utils_1.getScriptHash)({
+                address,
+                network: this._network
+            });
+            if (Object.keys(allAddresses).includes(changeAddressScriptHash)) {
+                changeAddressData = {
+                    address,
+                    value: voutValue,
+                    index: i
+                };
+            }
+            const index = (_e = outputs === null || outputs === void 0 ? void 0 : outputs.length) !== null && _e !== void 0 ? _e : 0;
+            outputs.push({
+                address,
+                value: voutValue,
+                index
+            });
+            outputTotal = outputTotal + voutValue;
+        }
+        if (!(changeAddressData === null || changeAddressData === void 0 ? void 0 : changeAddressData.address) && outputs.length >= 2) {
+            return (0, utils_1.err)('cpfp');
+        }
+        if (outputTotal > inputTotal) {
+            return (0, utils_1.err)('Outputs should not be greater than the inputs.');
+        }
+        fee = Math.abs(Number(inputTotal - outputTotal));
+        return (0, utils_1.ok)({
+            changeAddress: changeAddressData.address,
+            inputs,
+            balance: inputTotal,
+            outputs,
+            fee,
+            message,
+            addressType,
+            rbf: true
+        });
+    }
+    async deleteOnChainTransactionById({ txid }) {
+        const transactions = this.data.transactions;
+        if (txid in transactions) {
+            delete transactions[txid];
+        }
+        await this.saveWalletData('transactions', transactions);
+    }
+    async addGhostTransaction({ txid }) {
+        if (txid in this._data.transactions) {
+            this._data.transactions[txid].exists = false;
+        }
+        await this.saveWalletData('transactions', this._data.transactions);
+    }
+    async addBoostedTransaction({ newTxId, oldTxId, type = types_1.EBoostType.cpfp, fee }) {
+        try {
+            const boostedTransactions = this.data.boostedTransactions;
+            const parentTransactions = this.getBoostedTransactionParents({
+                txid: oldTxId,
+                boostedTransactions
+            });
+            parentTransactions.push(oldTxId);
+            const boostedTx = {
+                parentTransactions: parentTransactions,
+                childTransaction: newTxId,
+                type,
+                fee
+            };
+            const boostedTransaction = {
+                [oldTxId]: boostedTx
+            };
+            this._data.boostedTransactions = Object.assign(Object.assign({}, this.data.boostedTransactions), boostedTransaction);
+            await this.saveWalletData('boostedTransactions', this._data.boostedTransactions);
+            return (0, utils_1.ok)(boostedTx);
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async resetSendTransaction() {
+        return await this.transaction.resetSendTransaction();
+    }
+    getBoostableTransactions() {
+        const cpfp = [];
+        const rbf = [];
+        Object.values(this.data.unconfirmedTransactions).map((tx) => {
+            if (tx.rbf)
+                rbf.push(tx);
+            cpfp.push(tx);
+        });
+        return { cpfp, rbf };
+    }
+    addTxInput({ input }) {
+        var _a;
+        try {
+            const txData = this.transaction.data;
+            const inputs = (_a = txData === null || txData === void 0 ? void 0 : txData.inputs) !== null && _a !== void 0 ? _a : [];
+            const newInputs = [...inputs, input];
+            this.transaction.updateSendTransaction({
+                transaction: {
+                    inputs: newInputs
+                }
+            });
+            return (0, utils_1.ok)(newInputs);
+        }
+        catch (e) {
+            console.log(e);
+            return (0, utils_1.err)(e);
+        }
+    }
+    removeTxInput({ input }) {
+        var _a;
+        try {
+            const txData = this.transaction.data;
+            const txInputs = (_a = txData === null || txData === void 0 ? void 0 : txData.inputs) !== null && _a !== void 0 ? _a : [];
+            const newInputs = txInputs.filter((txInput) => {
+                if (!(0, utils_1.objectsMatch)(input, txInput)) {
+                    return txInput;
+                }
+            });
+            this.transaction.updateSendTransaction({
+                transaction: {
+                    inputs: newInputs
+                }
+            });
+            return (0, utils_1.ok)(newInputs);
+        }
+        catch (e) {
+            console.log(e);
+            return (0, utils_1.err)(e);
+        }
+    }
+    addTxTag({ tag }) {
+        try {
+            const txData = this.transaction.data;
+            let tags = [...txData.tags, tag];
+            tags = [...new Set(tags)];
+            this.transaction.updateSendTransaction({
+                transaction: Object.assign(Object.assign({}, txData), { tags })
+            });
+            return (0, utils_1.ok)('Tag successfully added');
+        }
+        catch (e) {
+            console.log(e);
+            return (0, utils_1.err)(e);
+        }
+    }
+    removeTxTag({ tag }) {
+        try {
+            const txData = this.transaction.data;
+            const tags = txData.tags;
+            const newTags = tags.filter((t) => t !== tag);
+            this.transaction.updateSendTransaction({
+                transaction: Object.assign(Object.assign({}, txData), { tags: newTags })
+            });
+            return (0, utils_1.ok)('Tag successfully added');
+        }
+        catch (e) {
+            console.log(e);
+            return (0, utils_1.err)(e);
+        }
+    }
+    setupFeeForOnChainTransaction({ satsPerByte, selectedFeeId }) {
+        var _a;
+        try {
+            const transactionData = this.transaction.data;
+            if (!satsPerByte) {
+                satsPerByte = (_a = transactionData === null || transactionData === void 0 ? void 0 : transactionData.satsPerByte) !== null && _a !== void 0 ? _a : 1;
+                satsPerByte =
+                    this.selectedFeeId === types_1.EFeeId.none
+                        ? satsPerByte
+                        : this.feeEstimates[this.selectedFeeId];
+            }
+            const res = this.transaction.updateFee({
+                satsPerByte: satsPerByte !== null && satsPerByte !== void 0 ? satsPerByte : 1,
+                selectedFeeId
+            });
+            if (res.isErr()) {
+                console.log(res.error.message);
+                return (0, utils_1.err)(res.error.message);
+            }
+            return (0, utils_1.ok)('Fee has been changed successfully');
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    updateWalletBalance({ balance }) {
+        try {
+            this._data.balance = balance;
+            this.saveWalletData('balance', balance);
+            return (0, utils_1.ok)('Successfully updated balance.');
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async updateExchangeRates() {
+        const exchangeRates = await (0, utils_1.getExchangeRates)();
+        if (exchangeRates.isErr())
+            return (0, utils_1.err)(exchangeRates.error.message);
+        this.exchangeRates = exchangeRates.value;
+        await this.saveWalletData('exchangeRates', this.exchangeRates);
+        return (0, utils_1.ok)(this.exchangeRates);
+    }
+    async updateFeeEstimates(forceUpdate = false) {
+        const timestamp = this.feeEstimates.timestamp;
+        const difference = Math.floor((Date.now() - timestamp) / 1000);
+        if (!forceUpdate && difference < 1800) {
+            return (0, utils_1.ok)(this.feeEstimates);
+        }
+        const feeEstimates = await this.getFeeEstimates();
+        if (!feeEstimates) {
+            return (0, utils_1.err)('Unable to retrieve fee estimates.');
+        }
+        this.feeEstimates = feeEstimates;
+        await this.saveWalletData('feeEstimates', feeEstimates);
+        return (0, utils_1.ok)(feeEstimates);
+    }
+}
+exports.Wallet = Wallet;
+//# sourceMappingURL=index.js.map