beignet 0.0.48 → 0.0.49

package/tests/receive.test.ts

@@ -0,0 +1,216 @@
+import BitcoinJsonRpc from 'bitcoin-json-rpc';
+import { expect } from 'chai';
+import net from 'net';
+import tls from 'tls';
+
+import {
+	EAddressType,
+	EAvailableNetworks,
+	EProtocol,
+	generateMnemonic,
+	sleep,
+	Wallet
+} from '../';
+import {
+	bitcoinURL,
+	electrumHost,
+	electrumPort,
+	initWaitForElectrumToSync,
+	MessageListener,
+	TWaitForElectrum
+} from './utils';
+
+const testTimeout = 60000;
+let wallet: Wallet;
+let waitForElectrum: TWaitForElectrum;
+const rpc = new BitcoinJsonRpc(bitcoinURL);
+const ml = new MessageListener();
+
+describe('Receive', async function () {
+	this.timeout(testTimeout);
+
+	beforeEach(async function () {
+		this.timeout(testTimeout);
+		ml.clear();
+
+		// Ensure sufficient balance in regtest
+		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();
+		}
+
+		waitForElectrum = await initWaitForElectrumToSync(
+			{ host: electrumHost, port: electrumPort },
+			bitcoinURL
+		);
+
+		await waitForElectrum();
+
+		const mnemonic = generateMnemonic();
+
+		const res = await Wallet.create({
+			mnemonic,
+			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
+			},
+			addressTypesToMonitor: [EAddressType.p2wpkh],
+			onMessage: ml.onMessage
+		});
+		if (res.isErr()) throw res.error;
+		wallet = res.value;
+		await wallet.refreshWallet({});
+	});
+
+	afterEach(async function () {
+		await wallet?.electrum?.disconnect();
+	});
+
+	it('Should generate new receiving address', async () => {
+		const r = await wallet.getNextAvailableAddress();
+		if (r.isErr()) throw r.error;
+		const address = r.value.addressIndex.address;
+		expect(address).to.be.a('string');
+		expect(address).to.match(/^bcrt1/); // Regtest bech32 prefix
+	});
+
+	it('Should receive funds and update balance', async () => {
+		expect(wallet.data.balance).to.equal(0);
+
+		const r = await wallet.getNextAvailableAddress();
+		if (r.isErr()) throw r.error;
+		const address = r.value.addressIndex.address;
+		expect(address).to.be.a('string');
+		expect(address).to.match(/^bcrt1/); // Regtest bech32 prefix
+
+		const amount = 0.1;
+		const amountSats = amount * 10e7;
+		await rpc.sendToAddress(address, amount.toString());
+
+		await rpc.generateToAddress(1, await rpc.getNewAddress());
+		await waitForElectrum();
+
+		await wallet.refreshWallet({});
+		expect(wallet.getBalance()).to.equal(amountSats);
+		expect(wallet.balance).to.equal(amountSats);
+		expect(wallet.utxos.length).to.equal(1);
+	});
+
+	it('Should track multiple receiving addresses', async () => {
+		const r1 = await wallet.getNextAvailableAddress();
+		if (r1.isErr()) throw r1.error;
+		const address1 = r1.value.addressIndex.address;
+		const r2 = await wallet.getNextAvailableAddress();
+		if (r2.isErr()) throw r2.error;
+		const address2 = r2.value.addressIndex.address;
+
+		// Without any transactions addresses should match
+		expect(address1).to.equal(address2);
+
+		// Send funds, get new address
+		await rpc.sendToAddress(address1, '0.1');
+		await rpc.generateToAddress(1, await rpc.getNewAddress());
+		await waitForElectrum();
+		const r3 = await wallet.getNextAvailableAddress();
+		if (r3.isErr()) throw r3.error;
+		const address3 = r3.value.addressIndex.address;
+
+		// After a transaction, addresses should differ
+		expect(address1).to.not.equal(address3);
+
+		// Second transaction
+		const receivePromise = ml.waitFor('transactionReceived');
+		await rpc.sendToAddress(address3, '0.2');
+		await receivePromise;
+
+		// unfortinately it is possible that Electrum server still does not
+		// have second transaction parsed so we need to wait a bit
+		while (wallet.data.utxos.length === 1) {
+			await sleep(100);
+			await wallet.refreshWallet();
+		}
+
+		// Check balances
+		expect(wallet.balance).to.equal(0.3 * 10e7); // 0.3 BTC in sats
+
+		// Test getAddressBalance
+		const balance1 = await wallet.getAddressBalance(address1);
+		if (balance1.isErr()) throw balance1.error;
+		expect(balance1.value.confirmed).to.equal(0.1 * 10e7);
+		const balance3 = await wallet.getAddressBalance(address3);
+		if (balance3.isErr()) throw balance3.error;
+		expect(balance3.value.unconfirmed).to.equal(0.2 * 10e7);
+
+		// Test getAddressesBalance
+		const combinedBalance = await wallet.getAddressesBalance([
+			address1,
+			address3
+		]);
+		if (combinedBalance.isErr()) throw combinedBalance.error;
+		expect(combinedBalance.value).to.equal(0.3 * 10e7);
+	});
+
+	it('Should handle unconfirmed transactions', async () => {
+		const r = await wallet.getNextAvailableAddress();
+		if (r.isErr()) throw r.error;
+		const address = r.value.addressIndex.address;
+
+		await rpc.sendToAddress(address, '0.1');
+		await waitForElectrum();
+
+		// Refresh wallet and check unconfirmed transactions
+		await wallet.refreshWallet({});
+		expect(Object.keys(wallet.data.unconfirmedTransactions)).to.have.length(1);
+		expect(Object.keys(wallet.data.transactions)).to.have.length(1);
+
+		// Generate blocks to confirm transaction
+		await rpc.generateToAddress(10, await rpc.getNewAddress());
+		await waitForElectrum();
+
+		// Refresh and check confirmed status
+		await wallet.refreshWallet({});
+		expect(Object.keys(wallet.data.unconfirmedTransactions)).to.have.length(0);
+		expect(Object.keys(wallet.data.transactions)).to.have.length(1);
+	});
+
+	it('Should receive transaction and emit correct messages', async () => {
+		const r = await wallet.getNextAvailableAddress();
+		if (r.isErr()) throw r.error;
+		const address = r.value.addressIndex.address;
+
+		// test transactionReceived message
+		const receivePromise = ml.waitFor('transactionReceived');
+		const amount = 0.1;
+		await rpc.sendToAddress(address, amount.toString());
+		const txReceivedMessage = await receivePromise;
+		expect(txReceivedMessage.transaction.value).to.equal(0.1);
+
+		// test transactionConfirmed message
+		const confirmedPromise = ml.waitFor('transactionConfirmed');
+		await rpc.generateToAddress(1, await rpc.getNewAddress());
+		await waitForElectrum();
+		const txConfirmedMessage = await confirmedPromise;
+		expect(txConfirmedMessage.transaction.height).to.be.greaterThan(0);
+	});
+});

package/tests/storage.test.ts

@@ -1,55 +1,58 @@
-import * as chai from 'chai';
 import { validateMnemonic } from 'bip39';
+import { expect } from 'chai';
 import net from 'net';
 import tls from 'tls';
+import sinon from 'sinon';
 
 import { Wallet } from '../';
+import { deleteDirectory, getData, servers, setData } from '../example/helpers';
 import {
 	EAddressType,
 	EAvailableNetworks,
+	generateMnemonic,
 	IGetUtxosResponse,
-	Result,
-	generateMnemonic
+	Result
 } from '../src';
 import { TEST_MNEMONIC } from './constants';
-import { deleteDirectory, getData, servers, setData } from '../example/helpers';
 import { EXPECTED_SHARED_RESULTS } from './expected-results';
 
-const expect = chai.expect;
-
 const testTimeout = 60000;
 
 let wallet: Wallet;
 const WALLET_NAME = 'storagetestwallet0';
 
-before(async function () {
-	this.timeout(testTimeout);
-	await deleteDirectory('example/walletData'); // Start test with clean slate.
-	const res = await Wallet.create({
-		mnemonic: TEST_MNEMONIC,
-		network: EAvailableNetworks.testnet,
-		name: WALLET_NAME,
-		addressType: EAddressType.p2wpkh,
-		storage: {
-			getData,
-			setData
-		},
-		electrumOptions: {
-			servers: servers[EAvailableNetworks.testnet],
-			net,
-			tls
-		}
-	});
-	if (res.isErr()) {
-		console.log('error: ', res.error.message);
-		//throw new Error(res.error.message);
-		return;
-	}
-	wallet = res.value;
-});
+const storage = { getData, setData };
+const storageSpy = sinon.spy(storage, 'setData');
+const messageSpy = sinon.spy();
 
 describe('Storage Test', async function (): Promise<void> {
 	this.timeout(testTimeout);
+
+	before(async function () {
+		this.timeout(testTimeout);
+		await deleteDirectory('example/walletData'); // Start test with clean slate.
+		const res = await Wallet.create({
+			mnemonic: TEST_MNEMONIC,
+			network: EAvailableNetworks.testnet,
+			name: WALLET_NAME,
+			addressType: EAddressType.p2wpkh,
+			storage,
+			onMessage: messageSpy,
+			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();
+	});
+
 	it('Should successfully create a wallet.', () => {
 		expect(wallet).not.to.be.null;
 	});
@@ -100,8 +103,7 @@ describe('Storage Test', async function (): Promise<void> {
 
 	it('Should generate a bech32 receiving address at index 0 via its path', async () => {
 		const address = await wallet.getAddressByPath({ path: "m/84'/1'/0'/0/0" });
-		expect(address.isErr()).to.equal(false);
-		if (address.isErr()) return;
+		if (address.isErr()) throw address.error;
 		expect(address.value.address).to.equal(
 			'tb1qmja98kkd540qtesjqdanfg0ywags845vehfg66'
 		);
@@ -109,8 +111,7 @@ describe('Storage Test', async function (): Promise<void> {
 
 	it('Should generate a segwit change address at index 1 via its path', async () => {
 		const address = await wallet.getAddressByPath({ path: "m/49'/1'/0'/1/1" });
-		expect(address.isErr()).to.equal(false);
-		if (address.isErr()) return;
+		if (address.isErr()) throw address.error;
 		expect(address.value.address).to.equal(
 			'2NDRG1ZGhWMGGNW7Mp58BKcyBs4Hyat8Law'
 		);
@@ -118,8 +119,7 @@ describe('Storage Test', async function (): Promise<void> {
 
 	it('Should generate a testnet legacy receiving address at index 5 via its path', async () => {
 		const address = await wallet.getAddressByPath({ path: "m/44'/1'/0'/0/5" });
-		expect(address.isErr()).to.equal(false);
-		if (address.isErr()) return;
+		if (address.isErr()) throw address.error;
 		expect(address.value.address).to.equal(
 			'mohdq3fadTtT4uSH4oNr4F1Dp3YM4pR3VF'
 		);
@@ -127,8 +127,7 @@ describe('Storage Test', async function (): Promise<void> {
 
 	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
 		);
@@ -136,8 +135,7 @@ describe('Storage Test', 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);
@@ -152,6 +150,21 @@ describe('Storage Test', async function (): Promise<void> {
 		);
 	});
 
+	it('Should successfully stop the wallet', async () => {
+		wallet.refreshWallet(); // start wallet refresh in the background
+		const r = await wallet.stop();
+		if (r.isErr()) throw r.error;
+		storageSpy.resetHistory();
+		messageSpy.resetHistory();
+		// try to force the wallet to update it's data
+		wallet.feeEstimates.timestamp = 0;
+		await wallet.updateFeeEstimates(true);
+		await wallet.refreshWallet();
+		// make sure that the wallet did not call setData or onMessage
+		expect(storageSpy.called).to.equal(false);
+		expect(messageSpy.called).to.equal(false);
+	});
+
 	// it('Attempts to create a new wallet using the same name of an existing wallet in storage.', async () => {
 	// 	const createRes = await Wallet.create({
 	// 		mnemonic: generateMnemonic(),

package/tests/transaction.test.ts

@@ -1,4 +1,4 @@
-import * as chai from 'chai';
+import { expect } from 'chai';
 import net from 'net';
 import tls from 'tls';
 
@@ -8,38 +8,37 @@ import {
 	ISweepPrivateKeyRes,
 	Wallet
 } from '../';
+import { servers } from '../example/helpers';
 import { EAvailableNetworks, Result } from '../src';
 import { TRANSACTION_TEST_MNEMONIC } from './constants';
-import { servers } from '../example/helpers';
 import { EXPECTED_TRANSACTION_RESULTS } from './expected-results';
 
-const expect = chai.expect;
-
 const testTimeout = 60000;
 
 let wallet: Wallet;
 
-before(async function () {
+describe('Transaction Test', async function (): Promise<void> {
 	this.timeout(testTimeout);
-	const res = await Wallet.create({
-		mnemonic: TRANSACTION_TEST_MNEMONIC,
-		network: EAvailableNetworks.testnet,
-		electrumOptions: {
-			servers: servers[EAvailableNetworks.testnet],
-			net,
-			tls
-		}
+
+	before(async function () {
+		this.timeout(testTimeout);
+		const res = await Wallet.create({
+			mnemonic: TRANSACTION_TEST_MNEMONIC,
+			network: EAvailableNetworks.testnet,
+			electrumOptions: {
+				servers: servers[EAvailableNetworks.testnet],
+				net,
+				tls
+			}
+		});
+		if (res.isErr()) throw res.error;
+		wallet = res.value;
+		await wallet.refreshWallet({});
 	});
-	if (res.isErr()) {
-		console.log('error: ', res.error.message);
-		return;
-	}
-	wallet = res.value;
-	await wallet.refreshWallet({});
-});
 
-describe('Transaction Test', async function (): Promise<void> {
-	this.timeout(testTimeout);
+	after(async function () {
+		await wallet?.electrum?.disconnect();
+	});
 
 	it('Should successfully create a wallet.', (): void => {
 		expect(wallet).not.to.be.null;
@@ -53,9 +52,7 @@ describe('Transaction Test', async function (): Promise<void> {
 
 	it('Should successfully return fee information.', (): void => {
 		const feeInfo = wallet.getFeeInfo({ satsPerByte: 5 });
-		expect(feeInfo.isErr()).to.equal(false);
-		if (feeInfo.isErr()) return;
-		expect(feeInfo).not.to.be.null;
+		if (feeInfo.isErr()) throw feeInfo.error;
 		expect(feeInfo.value.satsPerByte).to.equal(5);
 		expect(feeInfo.value.totalFee).to.equal(830);
 		expect(feeInfo.value.transactionByteCount).to.equal(166);
@@ -72,15 +69,13 @@ describe('Transaction Test', async function (): Promise<void> {
 			shuffleOutputs: false,
 			rbf: true
 		});
-		expect(sendRes.isErr()).to.equal(false);
-		if (sendRes.isErr()) return;
+		if (sendRes.isErr()) throw sendRes.error;
 		expect(sendRes.value).to.equal(
 			'020000000001014b44d379e48a8100d1c26f7220b8bbf7a4894ff015d5bc4064a28d08d25d808d0000000000000000000288130000000000001600143f1a7a1802e377d01602acf1cad403368ed3bb89ba21010000000000160014a6bd95db4dd6979189cad389daad006e236f4ba802483045022100dd709b656c271c7e2ab4c83e0245b9b8d9096a1c7a33eddc9a32113f436851d9022033f8e5cb016ae4c440badfa34e438ada7bea2cdd36e782c136e516350b502bca012102e86b90924963237c59e5389aab1cc5350c114549d1c5e7186a56ef33aea24ff900000000'
 		);
 
 		const decodeRes = decodeRawTransaction(sendRes.value, wallet.network);
-		expect(decodeRes.isErr()).to.equal(false);
-		if (decodeRes.isErr()) return;
+		if (decodeRes.isErr()) throw decodeRes.error;
 		expect(decodeRes.value).to.deep.equal(
 			EXPECTED_TRANSACTION_RESULTS.decodeRawTransaction
 		);
@@ -104,15 +99,13 @@ describe('Transaction Test', async function (): Promise<void> {
 			satsPerByte: 5,
 			rbf: true
 		});
-		expect(sendManyRes.isErr()).to.equal(false);
-		if (sendManyRes.isErr()) return;
+		if (sendManyRes.isErr()) throw sendManyRes.error;
 		expect(sendManyRes.value).to.equal(
 			'020000000001014b44d379e48a8100d1c26f7220b8bbf7a4894ff015d5bc4064a28d08d25d808d000000000000000000038813000000000000160014a6b760eaa96a9ba91bae9465dfc4eabe711e1d6770170000000000001600146bcf920595e09b5d8f7b8d03b3694ad3057572892c0a010000000000160014a6bd95db4dd6979189cad389daad006e236f4ba80247304402207e7b5de41cb9bf33e434c2136390bf40d6b6552b69234a62f6bf48b89f0d44ac022056121c9a9d79d9d84896c9896a6fddb358b48667021ff2832b5c5871d90b701a012102e86b90924963237c59e5389aab1cc5350c114549d1c5e7186a56ef33aea24ff900000000'
 		);
 
 		const decodeRes = decodeRawTransaction(sendManyRes.value, wallet.network);
-		expect(decodeRes.isErr()).to.equal(false);
-		if (decodeRes.isErr()) return;
+		if (decodeRes.isErr()) throw decodeRes.error;
 		expect(decodeRes.value).to.deep.equal(
 			EXPECTED_TRANSACTION_RESULTS.decodeRawSendManyTransaction
 		);
@@ -126,7 +119,7 @@ describe('Transaction Test', async function (): Promise<void> {
 				satsPerByte: 5,
 				broadcast: false
 			});
-		if (sweepPrivateKey.isErr()) return;
+		if (sweepPrivateKey.isErr()) throw sweepPrivateKey.error;
 		expect(sweepPrivateKey.value.id).to.equal(
 			'7fbef762e16676715bc94693a495923273259aa1190a5bf97bf18ab676393af5'
 		);
@@ -145,7 +138,7 @@ describe('Transaction Test', async function (): Promise<void> {
 				broadcast: false,
 				combineWithWalletUtxos: true
 			});
-		if (sweepPrivateKey.isErr()) return;
+		if (sweepPrivateKey.isErr()) throw sweepPrivateKey.error;
 		expect(sweepPrivateKey.value.id).to.equal(
 			'ea6677d40bbf44dbc2d19d3765fd440aa2344f928d724dc021884fc5984e91ff'
 		);
@@ -166,14 +159,13 @@ describe('Transaction Test', async function (): Promise<void> {
 				}
 			]
 		});
-		expect(setupResponse.isErr()).to.equal(false);
-		if (setupResponse.isErr()) return;
+		if (setupResponse.isErr()) throw setupResponse.error;
+
 		const privateKeyInfo: Result<IPrivateKeyInfo> =
 			await wallet.getPrivateKeyInfo(
 				'cUVwTLfHYrF7KGdTVU4AcP4yjtRTH3Y2BbTKHJbp2tsHDfpE8Zq5'
 			);
-		expect(privateKeyInfo.isErr()).to.equal(false);
-		if (privateKeyInfo.isErr()) return;
+		if (privateKeyInfo.isErr()) throw privateKeyInfo.error;
 		const utxos = privateKeyInfo.value.utxos;
 		const keyPair = privateKeyInfo.value.keyPair;
 		expect(Array.isArray(utxos)).to.equal(true);
@@ -185,13 +177,11 @@ describe('Transaction Test', async function (): Promise<void> {
 			inputs: utxos,
 			keyPair
 		});
-		expect(addExternRes.isErr()).to.equal(false);
-		if (addExternRes.isErr()) return;
+		if (addExternRes.isErr()) throw addExternRes.error;
 		const createTransaction = await wallet.transaction.createTransaction({
 			shuffleOutputs: false
 		});
-		expect(createTransaction.isErr()).to.equal(false);
-		if (createTransaction.isErr()) return;
+		if (createTransaction.isErr()) throw createTransaction.error;
 		expect(createTransaction.value.id).to.equal(
 			'c0b4a54d9b4f88a32c7d7349f03c71c84a16b99b5c82159474768e734afecd81'
 		);

package/tests/utils.ts

@@ -1,7 +1,13 @@
 import net from 'net';
 import BitcoinJsonRpc from 'bitcoin-json-rpc';
 import ElectrumClient from 'bw-electrum-client';
-import { EProtocol, sleep } from '../src';
+import {
+	EProtocol,
+	sleep,
+	TMessageDataMap,
+	TMessageKeys,
+	TOnMessage
+} from '../src';
 
 export const bitcoinURL = 'http://polaruser:polarpass@127.0.0.1:43782';
 export const electrumHost = '127.0.0.1';
@@ -44,7 +50,7 @@ export const initWaitForElectrumToSync = async (
 
 	const waitForElectrum = (): Promise<void> => {
 		return new Promise(async (resolve, reject) => {
-			let count;
+			let count: number;
 			let running = true;
 
 			const timer = setTimeout(async () => {
@@ -82,3 +88,55 @@ export const initWaitForElectrumToSync = async (
 
 	return waitForElectrum;
 };
+
+type TMessage = {
+	key: TMessageKeys;
+	data: TMessageDataMap[keyof TMessageDataMap];
+	timestamp: number;
+};
+
+export class MessageListener {
+	public messages: TMessage[] = [];
+	private resolvers: ((message: TMessage) => void)[] = [];
+
+	onMessage: TOnMessage = (key, data) => {
+		const message: TMessage = {
+			key,
+			data,
+			timestamp: Date.now()
+		};
+		this.messages.push(message);
+		this.resolvers.forEach((resolve) => resolve(message));
+	};
+
+	waitFor<K extends TMessageKeys>(
+		messageKey: K,
+		timeout = 20000
+	): Promise<TMessageDataMap[K]> {
+		// Check if message already received
+		const existingMessage = this.messages.find((msg) => msg.key === messageKey);
+		if (existingMessage) {
+			return Promise.resolve(existingMessage.data as TMessageDataMap[K]);
+		}
+
+		// Wait for new message
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				reject(new Error('Timeout waiting for message'));
+			}, timeout);
+
+			const resolver = (msg: TMessage): void => {
+				if (msg.key === messageKey) {
+					clearTimeout(timer);
+					resolve(msg.data as TMessageDataMap[K]);
+				}
+			};
+			this.resolvers.push(resolver);
+		});
+	}
+
+	clear(): void {
+		this.messages = [];
+		this.resolvers = [];
+	}
+}