beignet 0.0.48 → 0.0.49

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);