beignet 0.0.47 → 0.0.49

package/src/wallet/index.ts

@@ -1,7 +1,10 @@
+import * as bip39 from 'bip39';
 import * as bitcoin from 'bitcoinjs-lib';
 import { Network, networks } from 'bitcoinjs-lib';
 import BIP32Factory, { BIP32Interface } from 'bip32';
 import * as ecc from '@bitcoinerlab/secp256k1';
+import cloneDeep from 'lodash.clonedeep';
+
 import {
 	EAddressType,
 	EAvailableNetworks,
@@ -107,9 +110,7 @@ import {
 import { Electrum } from '../electrum';
 import { Transaction } from '../transaction';
 import { GAP_LIMIT, GAP_LIMIT_CHANGE, TRANSACTION_DEFAULTS } from './constants';
-import cloneDeep from 'lodash.clonedeep';
 import { btcToSats } from '../utils/conversion';
-import * as bip39 from 'bip39';
 
 const bip32 = BIP32Factory(ecc);
 
@@ -274,13 +275,34 @@ export class Wallet {
 			if (res.isErr()) return err(res.error.message);
 			wallet.updateFeeEstimates(true);
 			wallet.refreshWallet({});
-			if (wallet._disableMessagesOnCreate) wallet.disableMessages = false;
 			return ok(wallet);
 		} catch (e) {
 			return err(e);
 		}
 	}
 
+	/**
+	 * Stops the wallet. Use this method to prepare the wallet to be de
+	 * @returns {Promise<Result<string>>}
+	 */
+	public async stop(): Promise<Result<string>> {
+		try {
+			// if we are refreshing, we need to wait for it to finish
+			if (this.isRefreshing) {
+				await this.refreshWallet();
+			}
+			// disable onMessage callback
+			this.disableMessages = true;
+			// disable saving to storage
+			this._setData = undefined;
+			// disconnect from Electrum
+			await this.electrum.disconnect();
+			return ok('Wallet stopped.');
+		} catch (e) {
+			return err(e);
+		}
+	}
+
 	public async switchNetwork(
 		network: EAvailableNetworks,
 		servers?: TServer | TServer[]
@@ -351,6 +373,7 @@ export class Wallet {
 			});
 		}
 		this.isRefreshing = true;
+		this.updateFeeEstimates();
 		try {
 			await this.setZeroIndexAddresses();
 			const r1 = await this.updateAddressIndexes();
@@ -379,6 +402,8 @@ export class Wallet {
 			} else {
 				return this._handleRefreshError(e);
 			}
+		} finally {
+			if (this._disableMessagesOnCreate) this.disableMessages = false;
 		}
 	}
 
@@ -1972,7 +1997,6 @@ export class Wallet {
 			[key: string]: number[];
 		} = {};
 		for (const tx of receivedTxs) {
-			this.sendMessage('transactionReceived', tx);
 			// No need to scan an address with a saved UTXO.
 			if (utxoScriptHashes.has(tx.transaction.scriptHash)) continue;
 			for (const addressType in addresses) {
@@ -2009,6 +2033,10 @@ export class Wallet {
 			}
 		}
 
+		for (const tx of receivedTxs) {
+			this.sendMessage('transactionReceived', tx);
+		}
+
 		return ok(notificationTxid);
 	}
 
@@ -2759,13 +2787,25 @@ export class Wallet {
 	public async getFeeEstimates(network = this._network): Promise<IOnchainFees> {
 		try {
 			if (network === EAvailableNetworks.bitcoinRegtest) {
-				return defaultFeesShape;
+				return { ...defaultFeesShape, timestamp: Date.now() };
 			}
 			const urlModifier = network === 'bitcoin' ? '' : 'testnet/';
 			const response = await fetch(
 				`https://mempool.space/${urlModifier}api/v1/fees/recommended`
 			);
 			const res: IGetFeeEstimatesResponse = await response.json();
+			// check the response for the expected properties
+			if (
+				!(
+					res.fastestFee > 0 &&
+					res.halfHourFee > 0 &&
+					res.hourFee > 0 &&
+					res.minimumFee > 0
+				)
+			) {
+				throw new Error('Unexpected response from mempool.space');
+			}
+
 			return {
 				fast: res.fastestFee,
 				normal: res.halfHourFee,
@@ -2791,9 +2831,19 @@ export class Wallet {
 			if (network !== EAvailableNetworks.bitcoinMainnet) {
 				return defaultFeesShape;
 			}
-			const url = 'https://blocktank.synonym.to/api/v2/info';
+			const url = 'https://api1.blocktank.to/api/info';
 			const response = await fetch(url);
 			const res: IBtInfo = await response.json();
+			// check the response for the expected properties
+			if (
+				!(
+					res?.onchain?.feeRates?.fast > 0 &&
+					res?.onchain?.feeRates?.mid > 0 &&
+					res?.onchain?.feeRates?.slow > 0
+				)
+			) {
+				throw new Error('Unexpected response from blocktank');
+			}
 			const { fast, mid, slow } = res.onchain.feeRates;
 			return {
 				fast,
@@ -2804,7 +2854,7 @@ export class Wallet {
 			};
 		} catch (e) {
 			console.log('Unable to fetch fee estimates.', e);
-			return defaultFeesShape;
+			return this.feeEstimates;
 		}
 	}
 
@@ -3698,7 +3748,7 @@ export class Wallet {
 	 * Updates the fee estimates for the current network.
 	 * @public
 	 * @async
-	 * @param {true} [forceUpdate] Ignores the timestamp if set true and forces the update
+	 * @param {boolean} [forceUpdate] Ignores the timestamp if set true and forces the update
 	 * @returns {Promise<Result<IOnchainFees>>}
 	 */
 	public async updateFeeEstimates(
@@ -3706,13 +3756,10 @@ export class Wallet {
 	): Promise<Result<IOnchainFees>> {
 		const timestamp = this.feeEstimates.timestamp;
 		const difference = Math.floor((Date.now() - timestamp) / 1000);
-		if (!forceUpdate && difference < 1800) {
+		if (!forceUpdate && difference < 60) {
 			return ok(this.feeEstimates);
 		}
 		const feeEstimates = await this.getFeeEstimates();
-		if (!feeEstimates) {
-			return err('Unable to retrieve fee estimates.');
-		}
 		this.feeEstimates = feeEstimates;
 		await this.saveWalletData('feeEstimates', feeEstimates);
 		return ok(feeEstimates);

package/tests/boost.test.ts

@@ -10,7 +10,7 @@ import {
 	EProtocol,
 	generateMnemonic,
 	Wallet
-} from '../src';
+} from '../';
 import {
 	bitcoinURL,
 	electrumHost,
@@ -25,62 +25,66 @@ let waitForElectrum: TWaitForElectrum;
 const rpc = new BitcoinJsonRpc(bitcoinURL);
 const failure = { canBoost: false, rbf: false, cpfp: false };
 
-beforeEach(async function () {
+describe('Boost', async function () {
 	this.timeout(testTimeout);
 
-	let balance = await rpc.getBalance();
-	const address = await rpc.getNewAddress();
-	await rpc.generateToAddress(1, address);
+	beforeEach(async function () {
+		this.timeout(testTimeout);
+
+		let balance = await rpc.getBalance();
+		const address = await rpc.getNewAddress();
+		await rpc.generateToAddress(1, address);
 
-	while (balance < 10) {
-		await rpc.generateToAddress(10, address);
-		balance = await rpc.getBalance();
-	}
+		while (balance < 10) {
+			await rpc.generateToAddress(10, address);
+			balance = await rpc.getBalance();
+		}
 
-	waitForElectrum = await initWaitForElectrumToSync(
-		{ host: electrumHost, port: electrumPort },
-		bitcoinURL
-	);
+		waitForElectrum = await initWaitForElectrumToSync(
+			{ host: electrumHost, port: electrumPort },
+			bitcoinURL
+		);
 
-	await waitForElectrum();
+		await waitForElectrum();
 
-	const mnemonic = generateMnemonic();
+		const mnemonic = generateMnemonic();
 
-	const res = await Wallet.create({
-		rbf: true,
-		mnemonic,
-		// mnemonic: 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
-		network: EAvailableNetworks.regtest,
-		addressType: EAddressType.p2wpkh,
-		electrumOptions: {
-			servers: [
-				{
-					host: '127.0.0.1',
-					ssl: 60002,
-					tcp: 60001,
-					protocol: EProtocol.tcp
-				}
-			],
-			net,
-			tls
-		},
-		// reduce gap limit to speed up tests
-		gapLimitOptions: {
-			lookAhead: 2,
-			lookBehind: 2,
-			lookAheadChange: 2,
-			lookBehindChange: 2
+		const res = await Wallet.create({
+			rbf: true,
+			mnemonic,
+			// mnemonic: 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
+			network: EAvailableNetworks.regtest,
+			addressType: EAddressType.p2wpkh,
+			electrumOptions: {
+				servers: [
+					{
+						host: '127.0.0.1',
+						ssl: 60002,
+						tcp: 60001,
+						protocol: EProtocol.tcp
+					}
+				],
+				net,
+				tls
+			},
+			// reduce gap limit to speed up tests
+			gapLimitOptions: {
+				lookAhead: 2,
+				lookBehind: 2,
+				lookAheadChange: 2,
+				lookBehindChange: 2
+			}
+		});
+		if (res.isErr()) {
+			throw res.error;
 		}
+		wallet = res.value;
+		await wallet.refreshWallet({});
 	});
-	if (res.isErr()) {
-		throw res.error;
-	}
-	wallet = res.value;
-	await wallet.refreshWallet({});
-});
 
-describe('Boost', async function () {
-	this.timeout(testTimeout);
+	afterEach(async function () {
+		await wallet?.electrum?.disconnect();
+	});
 
 	it('Should fail in some cases.', async () => {
 		// tx not found
@@ -89,9 +93,7 @@ describe('Boost', async function () {
 
 		// balance is 0
 		const r = await wallet.getNextAvailableAddress();
-		if (r.isErr()) {
-			throw r.error;
-		}
+		if (r.isErr()) throw r.error;
 		const a1 = r.value.addressIndex.address;
 		await rpc.sendToAddress(a1, '1');
 		await rpc.generateToAddress(1, await rpc.getNewAddress());
@@ -103,9 +105,7 @@ describe('Boost', async function () {
 			amount: 99999743,
 			satsPerByte: 1
 		});
-		if (s1.isErr()) {
-			throw s1.error;
-		}
+		if (s1.isErr()) throw s1.error;
 		await wallet.refreshWallet({});
 		expect(wallet.data.balance).to.be.below(256);
 		const b2 = wallet.canBoost(s1.value);
@@ -120,9 +120,7 @@ describe('Boost', async function () {
 			address: 'bcrt1q6rz28mcfaxtmd6v789l9rrlrusdprr9pz3cppk',
 			amount: 10000000
 		});
-		if (s2.isErr()) {
-			throw s2.error;
-		}
+		if (s2.isErr()) throw s2.error;
 		await rpc.generateToAddress(1, await rpc.getNewAddress()); // confirm tx
 		await wallet.refreshWallet({});
 		const b3 = wallet.canBoost(s2.value);
@@ -131,9 +129,7 @@ describe('Boost', async function () {
 
 	it('Should generate CPFP for send transaction', async () => {
 		const r = await wallet.getNextAvailableAddress();
-		if (r.isErr()) {
-			throw r.error;
-		}
+		if (r.isErr()) throw r.error;
 		const a1 = r.value.addressIndex.address;
 		await rpc.sendToAddress(a1, '1');
 		await rpc.generateToAddress(1, await rpc.getNewAddress());
@@ -148,18 +144,14 @@ describe('Boost', async function () {
 			satsPerByte: 1,
 			rbf: false
 		});
-		if (s1.isErr()) {
-			throw s1.error;
-		}
+		if (s1.isErr()) throw s1.error;
 		const oldTxId = s1.value;
 		await wallet.refreshWallet({});
 		const b1 = wallet.canBoost(oldTxId);
 		expect(b1).to.deep.equal({ canBoost: true, rbf: false, cpfp: true });
 
 		const setup = await wallet.transaction.setupCpfp({ txid: oldTxId });
-		if (setup.isErr()) {
-			throw setup.error;
-		}
+		if (setup.isErr()) throw setup.error;
 		expect(setup.value.inputs.length).to.equal(1);
 		expect(setup.value.outputs.length).to.equal(1);
 		expect(setup.value.boostType).to.equal(EBoostType.cpfp);
@@ -169,9 +161,7 @@ describe('Boost', async function () {
 		expect(setup.value.satsPerByte).to.be.above(6);
 
 		const createRes = await wallet.transaction.createTransaction();
-		if (createRes.isErr()) {
-			throw createRes.error;
-		}
+		if (createRes.isErr()) throw createRes.error;
 		const newTxId = createRes.value.id;
 		wallet.electrum.broadcastTransaction({ rawTx: createRes.value.hex });
 
@@ -181,9 +171,7 @@ describe('Boost', async function () {
 			type: EBoostType.cpfp,
 			fee: setup.value.fee
 		});
-		if (addBoost.isErr()) {
-			throw addBoost.error;
-		}
+		if (addBoost.isErr()) throw addBoost.error;
 		const boosted = wallet.getBoostedTransactions();
 		expect(boosted).to.deep.equal({
 			[oldTxId]: {
@@ -205,18 +193,14 @@ describe('Boost', async function () {
 
 	it('Should generate RBF for send transaction', async () => {
 		const r = await wallet.getNextAvailableAddress();
-		if (r.isErr()) {
-			throw r.error;
-		}
+		if (r.isErr()) throw r.error;
 		const a1 = r.value.addressIndex.address;
 		await rpc.sendToAddress(a1, '0.0001'); // 10000 sats
 		await rpc.generateToAddress(1, await rpc.getNewAddress());
 
 		await waitForElectrum();
 		const r1 = await wallet.refreshWallet({});
-		if (r1.isErr()) {
-			throw r1.error;
-		}
+		if (r1.isErr()) throw r1.error;
 		expect(wallet.data.balance).to.equal(10000);
 
 		// create and send original transaction
@@ -226,35 +210,25 @@ describe('Boost', async function () {
 			satsPerByte: 1,
 			rbf: true
 		});
-		if (s1.isErr()) {
-			throw s1.error;
-		}
+		if (s1.isErr()) throw s1.error;
 		const oldTxId = s1.value;
 		const r2 = await wallet.refreshWallet({});
-		if (r2.isErr()) {
-			throw r2.error;
-		}
+		if (r2.isErr()) throw r2.error;
 		const b1 = wallet.canBoost(oldTxId);
 		expect(b1).to.deep.equal({ canBoost: true, rbf: true, cpfp: true });
 
 		// replace original transaction using RBF
 		const setup = await wallet.transaction.setupRbf({ txid: oldTxId });
-		if (setup.isErr()) {
-			throw setup.error;
-		}
+		if (setup.isErr()) throw setup.error;
 		expect(setup.value.boostType).to.equal(EBoostType.rbf);
 		expect(setup.value.minFee).to.be.above(1);
 		const createRes = await wallet.transaction.createTransaction();
-		if (createRes.isErr()) {
-			throw createRes.error;
-		}
+		if (createRes.isErr()) throw createRes.error;
 		const newTxId = createRes.value.id;
 		const broadcastResp = await wallet.electrum.broadcastTransaction({
 			rawTx: createRes.value.hex
 		});
-		if (broadcastResp.isErr()) {
-			throw broadcastResp.error;
-		}
+		if (broadcastResp.isErr()) throw broadcastResp.error;
 
 		const addBoost = await wallet.addBoostedTransaction({
 			oldTxId,
@@ -262,9 +236,7 @@ describe('Boost', async function () {
 			type: EBoostType.rbf,
 			fee: setup.value.fee
 		});
-		if (addBoost.isErr()) {
-			throw addBoost.error;
-		}
+		if (addBoost.isErr()) throw addBoost.error;
 		const boosted = wallet.getBoostedTransactions();
 		expect(boosted).to.deep.equal({
 			[oldTxId]: {
@@ -276,9 +248,7 @@ describe('Boost', async function () {
 		});
 
 		const r3 = await wallet.refreshWallet({});
-		if (r3.isErr()) {
-			throw r3.error;
-		}
+		if (r3.isErr()) throw r3.error;
 
 		expect(Object.keys(wallet.transactions).length).to.equal(2);
 		expect(wallet.transactions).not.to.have.property(oldTxId);

package/tests/derivation.test.ts

@@ -1,4 +1,4 @@
-import * as chai from 'chai';
+import { expect } from 'chai';
 import {
 	EAddressType,
 	EAvailableNetworks,
@@ -8,16 +8,13 @@ import {
 	getKeyDerivationPathString
 } from '../src';
 
-const expect = chai.expect;
-
 describe('Derivation Methods', () => {
 	it('Should return default derivation path object for p2wpkh', () => {
 		const pathRes = getKeyDerivationPath({
 			addressType: EAddressType.p2wpkh,
 			network: EAvailableNetworks.mainnet
 		});
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value.purpose).to.equal('84');
 		expect(pathRes.value.coinType).to.equal('0');
 		expect(pathRes.value.account).to.equal('0');
@@ -29,8 +26,7 @@ describe('Derivation Methods', () => {
 			addressType: EAddressType.p2sh,
 			network: EAvailableNetworks.mainnet
 		});
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value.purpose).to.equal('49');
 		expect(pathRes.value.coinType).to.equal('0');
 		expect(pathRes.value.account).to.equal('0');
@@ -42,8 +38,7 @@ describe('Derivation Methods', () => {
 			addressType: EAddressType.p2pkh,
 			network: EAvailableNetworks.mainnet
 		});
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value.purpose).to.equal('44');
 		expect(pathRes.value.coinType).to.equal('0');
 		expect(pathRes.value.account).to.equal('0');
@@ -58,8 +53,7 @@ describe('Derivation Methods', () => {
 			index: 0,
 			network: EAvailableNetworks.mainnet
 		});
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value).to.equal("m/84'/0'/0'/1/0");
 	});
 	it('Should return a valid testnet p2sh derivation string at index 40', () => {
@@ -69,8 +63,7 @@ describe('Derivation Methods', () => {
 			index: '40',
 			network: EAvailableNetworks.testnet
 		});
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value).to.equal("m/49'/1'/0'/0/40");
 	});
 	it('Should return a valid mainnet p2pkh derivation string at index 8', () => {
@@ -80,8 +73,7 @@ describe('Derivation Methods', () => {
 			index: 8,
 			network: EAvailableNetworks.mainnet
 		});
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value).to.equal("m/44'/0'/0'/0/8");
 	});
 
@@ -90,8 +82,7 @@ describe('Derivation Methods', () => {
 			path: "m/84'/0'/0'/1/0",
 			network: EAvailableNetworks.mainnet
 		});
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value.purpose).to.equal('84');
 		expect(pathRes.value.coinType).to.equal('0');
 		expect(pathRes.value.account).to.equal('0');
@@ -103,8 +94,7 @@ describe('Derivation Methods', () => {
 			path: "m/49'/1'/0'/0/40",
 			network: EAvailableNetworks.testnet
 		});
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value.purpose).to.equal('49');
 		expect(pathRes.value.coinType).to.equal('1');
 		expect(pathRes.value.account).to.equal('0');
@@ -116,8 +106,7 @@ describe('Derivation Methods', () => {
 			path: "m/44'/0'/0'/0/8",
 			network: EAvailableNetworks.mainnet
 		});
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value.purpose).to.equal('44');
 		expect(pathRes.value.coinType).to.equal('0');
 		expect(pathRes.value.account).to.equal('0');
@@ -127,20 +116,17 @@ describe('Derivation Methods', () => {
 
 	it('Should return a valid address type from p2wpkh path', () => {
 		const pathRes = getAddressTypeFromPath("m/84'/0'/0'/0/0");
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value).to.equal(EAddressType.p2wpkh);
 	});
 	it('Should return a valid address type from p2sh path', () => {
 		const pathRes = getAddressTypeFromPath("m/49'/0'/0'/0/0");
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value).to.equal(EAddressType.p2sh);
 	});
 	it('Should return a valid address type from p2pkh path', () => {
 		const pathRes = getAddressTypeFromPath("m/44'/0'/0'/0/0");
-		expect(pathRes.isErr()).to.equal(false);
-		if (pathRes.isErr()) return;
+		if (pathRes.isErr()) throw pathRes.error;
 		expect(pathRes.value).to.equal(EAddressType.p2pkh);
 	});
 });

package/tests/electrum.test.ts

@@ -1,47 +1,49 @@
-import * as chai from 'chai';
+import { expect } from 'chai';
 import net from 'net';
 import tls from 'tls';
 
 import { Wallet } from '../';
-import { EAvailableNetworks, EAddressType, IGetUtxosResponse } from '../src';
-import { TEST_MNEMONIC } from './constants';
-import { Result } from '../src';
 import { servers } from '../example/helpers';
+import {
+	EAddressType,
+	EAvailableNetworks,
+	IGetUtxosResponse,
+	Result
+} from '../src';
+import { TEST_MNEMONIC } from './constants';
 import { EXPECTED_SHARED_RESULTS } from './expected-results';
 
-const expect = chai.expect;
-
 const testTimeout = 60000;
 
 let wallet: Wallet;
 
-before(async function () {
+describe('Electrum Methods', async function (): Promise<void> {
 	this.timeout(testTimeout);
-	const res = await Wallet.create({
-		mnemonic: TEST_MNEMONIC,
-		network: EAvailableNetworks.testnet,
-		addressType: EAddressType.p2wpkh,
-		electrumOptions: {
-			servers: servers[EAvailableNetworks.testnet],
-			net,
-			tls
-		}
+
+	before(async function () {
+		this.timeout(testTimeout);
+		const res = await Wallet.create({
+			mnemonic: TEST_MNEMONIC,
+			network: EAvailableNetworks.testnet,
+			addressType: EAddressType.p2wpkh,
+			electrumOptions: {
+				servers: servers[EAvailableNetworks.testnet],
+				net,
+				tls
+			}
+		});
+		if (res.isErr()) throw res.error;
+		wallet = res.value;
+		await wallet.refreshWallet({});
+	});
+
+	after(async function () {
+		await wallet?.electrum?.disconnect();
 	});
-	if (res.isErr()) {
-		console.log('error: ', res.error.message);
-		//throw new Error(res.error.message);
-		return;
-	}
-	wallet = res.value;
-	await wallet.refreshWallet({});
-});
 
-describe('Electrum Methods', async function (): Promise<void> {
-	this.timeout(testTimeout);
 	it('connectToElectrum: Should connect to a random Electrum server', async () => {
 		const connectResponse = await wallet.connectToElectrum();
-		expect(connectResponse.isErr()).to.equal(false);
-		if (connectResponse.isErr()) return;
+		if (connectResponse.isErr()) throw connectResponse.error;
 		expect(connectResponse.value).to.equal('Connected to Electrum server.');
 	});
 
@@ -54,15 +56,13 @@ describe('Electrum Methods', async function (): Promise<void> {
 		const addressBalance = await wallet.getAddressBalance(
 			'tb1qyvc8r7338383xjshqsz38mfn2eql879nhrf8y0'
 		);
-		expect(addressBalance.isErr()).to.equal(false);
-		if (addressBalance.isErr()) return;
+		if (addressBalance.isErr()) throw addressBalance.error;
 		expect(addressBalance.value.confirmed).to.equal(20000);
 	});
 
 	it('getNextAvailableAddress: Should return the next available address/change index and the last used address/change index', async () => {
 		const r = await wallet.getNextAvailableAddress();
-		expect(r.isErr()).to.equal(false);
-		if (r.isErr()) return;
+		if (r.isErr()) throw r.error;
 		expect(r.value).to.deep.equal(
 			EXPECTED_SHARED_RESULTS.getNextAvailableAddress
 		);
@@ -70,8 +70,7 @@ describe('Electrum Methods', async function (): Promise<void> {
 
 	it("Should return available UTXO's", async () => {
 		const getUtxosRes: Result<IGetUtxosResponse> = await wallet.getUtxos({});
-		expect(getUtxosRes.isErr()).to.equal(false);
-		if (getUtxosRes.isErr()) return;
+		if (getUtxosRes.isErr()) throw getUtxosRes.error;
 		expect(Array.isArray(getUtxosRes.value.utxos)).to.equal(true);
 		expect(getUtxosRes.value.utxos.length).to.equal(3);
 		expect(getUtxosRes.value.balance).to.equal(5855);