13177121473

Committed 06 Feb 2025 10:48AM UTC coverage: 71.258% (-0.07%) from 71.328%

Build # 13177121473

Build Type

Pull #923

github

Committed by

web-flow

Commit Message

Merge efb00292f into 0da3a98a5

Pull Request Pull Request #923: update chain types

Run Details

8057 of 13163 branches covered (61.21%)

Branch coverage included in aggregate %.

31 of 32 new or added lines in 9 files covered. (96.88%)

24 existing lines in 5 files now uncovered.

25745 of 34273 relevant lines covered (75.12%)

34490.34 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.03

/lib/wallet/nodeclient.js

/*!
 * nodeclient.js - node client for hsd
 * Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
 * https://github.com/handshake-org/hsd
 */

'use strict';

const assert = require('bsert');
const blacklist = require('bsock/lib/blacklist');
const AsyncEmitter = require('bevent');

/** @typedef {import('@handshake-org/bfilter').BloomFilter} BloomFilter */
/** @typedef {import('../types').Hash} Hash */
/** @typedef {import('../primitives/tx')} TX */
/** @typedef {import('../primitives/claim')} Claim */
/** @typedef {import('../covenants/namestate')} NameState */
/** @typedef {import('../blockchain/chainentry')} ChainEntry */
/** @typedef {import('../node/fullnode')} FullNode */
/** @typedef {import('../node/spvnode')} SPVNode */
/** @typedef {FullNode|SPVNode} Node */

/**
 * Node Client
 * @alias module:node.NodeClient
 */

class NodeClient extends AsyncEmitter {
  /**
   * Create a node client.
   * @constructor
   * @param {Node} node
   */

  constructor(node) {
    super();

    /** @type {Node} */
    this.node = node;
    this.network = node.network;
    this.filter = null;
    this.opened = false;
    this.hooks = new Map();

    this.init();
  }

  /**
   * Initialize the client.
   */

  init() {
    this.node.chain.on('connect', async (entry, block) => {
      if (!this.opened)
        return;

      await this.emitAsync('block connect', entry, block.txs);
    });

    this.node.chain.on('disconnect', async (entry, block) => {
      if (!this.opened)
        return;

      await this.emitAsync('block disconnect', entry);
    });

    this.node.on('tx', (tx) => {
      if (!this.opened)
        return;

      this.emit('tx', tx);
    });

    this.node.on('reset', (tip) => {
      if (!this.opened)
        return;

      this.emit('chain reset', tip);
    });
  }

  /**
   * Open the client.
   * @returns {Promise<void>}
   */

  async open() {
    assert(!this.opened, 'NodeClient is already open.');
    this.opened = true;
    setImmediate(() => this.emit('connect'));
  }

  /**
   * Close the client.
   * @returns {Promise<void>}
   */

  async close() {
    assert(this.opened, 'NodeClient is not open.');
    this.opened = false;
    setImmediate(() => this.emit('disconnect'));
  }

  /**
   * Add a listener.
   * @param {String} type
   * @param {Function} handler
   */

  bind(type, handler) {
    return this.on(type, handler);
  }

  /**
   * Add a hook.
   * @param {String} event
   * @param {Function} handler
   */

  hook(event, handler) {
    assert(typeof event === 'string', 'Event must be a string.');
    assert(typeof handler === 'function', 'Handler must be a function.');
    assert(!this.hooks.has(event), 'Hook already bound.');
    assert(!Object.prototype.hasOwnProperty.call(blacklist, event),
      'Blacklisted event.');
    this.hooks.set(event, handler);
  }

  /**
   * Remove a hook.
   * @param {String} event
   */

  unhook(event) {
    assert(typeof event === 'string', 'Event must be a string.');
    assert(!Object.prototype.hasOwnProperty.call(blacklist, event),
      'Blacklisted event.');
    this.hooks.delete(event);
  }

  /**
   * Call a hook.
   * @param {String} event
   * @param {...Object} args
   * @returns {Promise}
   */

  handleCall(event, ...args) {
    const hook = this.hooks.get(event);

    if (!hook)
      throw new Error('No hook available.');

    return hook(...args);
  }

  /**
   * Get chain tip.
   * @returns {Promise<ChainEntry>}
   */

  async getTip() {
    return this.node.chain.tip;
  }

  /**
   * Get chain entry.
   * @param {Hash} hash
   * @returns {Promise<ChainEntry?>}
   */

  async getEntry(hash) {
    const entry = await this.node.chain.getEntry(hash);

    if (!entry)
      return null;

    if (!await this.node.chain.isMainChain(entry))
      return null;

    return entry;
  }

  /**
   * Send a transaction. Do not wait for promise.
   * @param {TX} tx
   * @returns {Promise<void>}
   */

  async send(tx) {
    this.node.relay(tx);
  }

  /**
   * Send a claim. Do not wait for promise.
   * @param {Claim} claim
   * @returns {Promise<void>}
   */

  async sendClaim(claim) {
    this.node.relayClaim(claim);
  }

  /**
   * Set bloom filter.
   * @param {BloomFilter} filter
   * @returns {Promise<void>}
   */

  async setFilter(filter) {
    this.filter = filter;
    this.node.pool.setFilter(filter);
  }

  /**
   * Add data to filter.
   * @param {Buffer} data
   * @returns {Promise<void>}
   */

  async addFilter(data) {
    // `data` is ignored because pool.spvFilter === walletDB.filter
    // and therefore is already updated.
    // Argument is kept here to be consistent with API in
    // wallet/client.js (client/node.js) and wallet/nullclient.js
    this.node.pool.queueFilterLoad();
  }

  /**
   * Reset filter.
   * @returns {Promise<void>}
   */

  async resetFilter() {
    this.node.pool.queueFilterLoad();
  }

  /**
   * Esimate smart fee.
   * @param {Number?} blocks
   * @returns {Promise<Number>}
   */

  async estimateFee(blocks) {
    if (!this.node.fees)
      return this.network.feeRate;

    return this.node.fees.estimateFee(blocks);
  }

  /**
   * Get hash range.
   * @param {Number} start
   * @param {Number} end
   * @returns {Promise<Hash[]>}
   */

  async getHashes(start = -1, end = -1) {
    return this.node.chain.getHashes(start, end);
  }

  /**
   * Get entries range.
   * @param {Number} start
   * @param {Number} end
   * @returns {Promise<ChainEntry[]>}
   */

  async getEntries(start = -1, end = -1) {
    return this.node.chain.getEntries(start, end);
  }

  /**
   * Rescan for any missed transactions.
   * @param {Number|Hash} start - Start block.
   * @returns {Promise<void>}
   */

  async rescan(start) {
    if (this.node.spv)
      return this.node.chain.reset(start);

    return this.node.chain.scan(start, this.filter, (entry, txs) => {
      return this.handleCall('block rescan', entry, txs);
    });
  }

  /**
   * Rescan interactive for any missed transactions.
   * @param {Number|Hash} start - Start block.
   * @param {Boolean} [fullLock=false]
   * @returns {Promise<void>}
   */

  async rescanInteractive(start, fullLock = true) {
    if (this.node.spv)
      return this.node.chain.reset(start);

    const iter = async (entry, txs) => {
      return await this.handleCall('block rescan interactive', entry, txs);
    };

    try {
      return await this.node.scanInteractive(
        start,
        this.filter,
        iter,
        fullLock
      );
    } catch (e) {
      await this.handleCall('block rescan interactive abort', e.message);
      throw e;
    }
  }

  /**
   * Get name state.
   * @param {Buffer} nameHash
   * @returns {Promise<NameState>}
   */

  async getNameStatus(nameHash) {
    return this.node.getNameStatus(nameHash);
  }

  /**
   * Get UTXO.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Object}
   */

  async getCoin(hash, index) {
    return this.node.getCoin(hash, index);
  }

  /**
   * Get block header.
   * @param {Hash|Number} block
   * @returns {Promise<ChainEntry>}
   */

  async getBlockHeader(block) {
    if (typeof block === 'string')
      block = Buffer.from(block, 'hex');

    const entry = await this.node.chain.getEntry(block);

    if (!entry)
      return null;

    return entry.toJSON();
  }
}

/*
 * Expose
 */

module.exports = NodeClient;

1	/*!
2	* nodeclient.js - node client for hsd
3	* Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
4	* https://github.com/handshake-org/hsd
5	*/
6
7	'use strict';
8
9	const assert = require('bsert');	1✔
10	const blacklist = require('bsock/lib/blacklist');	1✔
11	const AsyncEmitter = require('bevent');	1✔
12
13	/** @typedef {import('@handshake-org/bfilter').BloomFilter} BloomFilter */
14	/** @typedef {import('../types').Hash} Hash */
15	/** @typedef {import('../primitives/tx')} TX */
16	/** @typedef {import('../primitives/claim')} Claim */
17	/** @typedef {import('../covenants/namestate')} NameState */
18	/** @typedef {import('../blockchain/chainentry')} ChainEntry */
19	/** @typedef {import('../node/fullnode')} FullNode */
20	/** @typedef {import('../node/spvnode')} SPVNode */
21	/** @typedef {FullNode\|SPVNode} Node */
22
23	/**
24	* Node Client
25	* @alias module:node.NodeClient
26	*/
27
28	class NodeClient extends AsyncEmitter {
29	/**
30	* Create a node client.
31	* @constructor
32	* @param {Node} node
33	*/
34
35	constructor(node) {
36	super();	90✔
37
38	/** @type {Node} */
39	this.node = node;	90✔
40	this.network = node.network;	90✔
41	this.filter = null;	90✔
42	this.opened = false;	90✔
43	this.hooks = new Map();	90✔
44
45	this.init();	90✔
46	}
47
48	/**
49	* Initialize the client.
50	*/
51
52	init() {
53	this.node.chain.on('connect', async (entry, block) => {	90✔
54	if (!this.opened)	7,019✔
55	return;	1✔
56
57	await this.emitAsync('block connect', entry, block.txs);	7,018✔
58	});
59
60	this.node.chain.on('disconnect', async (entry, block) => {	90✔
61	if (!this.opened)	107!
62	return;	×
63
64	await this.emitAsync('block disconnect', entry);	107✔
65	});
66
67	this.node.on('tx', (tx) => {	90✔
68	if (!this.opened)	1,916!
UNCOV 69	return;	×
70
71	this.emit('tx', tx);	1,916✔
72	});
73
74	this.node.on('reset', (tip) => {	90✔
75	if (!this.opened)	7!
76	return;	×
77
78	this.emit('chain reset', tip);	7✔
79	});
80	}
81
82	/**
83	* Open the client.
84	* @returns {Promise<void>}
85	*/
86
87	async open() {
88	assert(!this.opened, 'NodeClient is already open.');	91✔
89	this.opened = true;	91✔
90	setImmediate(() => this.emit('connect'));	91✔
91	}
92
93	/**
94	* Close the client.
95	* @returns {Promise<void>}
96	*/
97
98	async close() {
99	assert(this.opened, 'NodeClient is not open.');	91✔
100	this.opened = false;	91✔
101	setImmediate(() => this.emit('disconnect'));	91✔
102	}
103
104	/**
105	* Add a listener.
106	* @param {String} type
107	* @param {Function} handler
108	*/
109
110	bind(type, handler) {
111	return this.on(type, handler);	360✔
112	}
113
114	/**
115	* Add a hook.
116	* @param {String} event
117	* @param {Function} handler
118	*/
119
120	hook(event, handler) {
121	assert(typeof event === 'string', 'Event must be a string.');	270✔
122	assert(typeof handler === 'function', 'Handler must be a function.');	270✔
123	assert(!this.hooks.has(event), 'Hook already bound.');	270✔
124	assert(!Object.prototype.hasOwnProperty.call(blacklist, event),	270✔
125	'Blacklisted event.');
126	this.hooks.set(event, handler);	270✔
127	}
128
129	/**
130	* Remove a hook.
131	* @param {String} event
132	*/
133
134	unhook(event) {
135	assert(typeof event === 'string', 'Event must be a string.');	×
136	assert(!Object.prototype.hasOwnProperty.call(blacklist, event),	×
137	'Blacklisted event.');
138	this.hooks.delete(event);	×
139	}
140
141	/**
142	* Call a hook.
143	* @param {String} event
144	* @param {...Object} args
145	* @returns {Promise}
146	*/
147
148	handleCall(event, ...args) {
149	const hook = this.hooks.get(event);	2,015✔
150
151	if (!hook)	2,015!
152	throw new Error('No hook available.');	×
153
154	return hook(...args);	2,015✔
155	}
156
157	/**
158	* Get chain tip.
159	* @returns {Promise<ChainEntry>}
160	*/
161
162	async getTip() {
163	return this.node.chain.tip;	×
164	}
165
166	/**
167	* Get chain entry.
168	* @param {Hash} hash
169	* @returns {Promise<ChainEntry?>}
170	*/
171
172	async getEntry(hash) {
173	const entry = await this.node.chain.getEntry(hash);	92✔
174
175	if (!entry)	92✔
176	return null;	1✔
177
178	if (!await this.node.chain.isMainChain(entry))	91✔
179	return null;	1✔
180
181	return entry;	90✔
182	}
183
184	/**
185	* Send a transaction. Do not wait for promise.
186	* @param {TX} tx
187	* @returns {Promise<void>}
188	*/
189
190	async send(tx) {
191	this.node.relay(tx);	1,800✔
192	}
193
194	/**
195	* Send a claim. Do not wait for promise.
196	* @param {Claim} claim
197	* @returns {Promise<void>}
198	*/
199
200	async sendClaim(claim) {
201	this.node.relayClaim(claim);	8✔
202	}
203
204	/**
205	* Set bloom filter.
206	* @param {BloomFilter} filter
207	* @returns {Promise<void>}
208	*/
209
210	async setFilter(filter) {
211	this.filter = filter;	91✔
212	this.node.pool.setFilter(filter);	91✔
213	}
214
215	/**
216	* Add data to filter.
217	* @param {Buffer} data
218	* @returns {Promise<void>}
219	*/
220
221	async addFilter(data) {
222	// `data` is ignored because pool.spvFilter === walletDB.filter
223	// and therefore is already updated.
224	// Argument is kept here to be consistent with API in
225	// wallet/client.js (client/node.js) and wallet/nullclient.js
226	this.node.pool.queueFilterLoad();	152,646✔
227	}
228
229	/**
230	* Reset filter.
231	* @returns {Promise<void>}
232	*/
233
234	async resetFilter() {
235	this.node.pool.queueFilterLoad();	×
236	}
237
238	/**
239	* Esimate smart fee.
240	* @param {Number?} blocks
241	* @returns {Promise<Number>}
242	*/
243
244	async estimateFee(blocks) {
245	if (!this.node.fees)	1,951!
246	return this.network.feeRate;	×
247
248	return this.node.fees.estimateFee(blocks);	1,951✔
249	}
250
251	/**
252	* Get hash range.
253	* @param {Number} start
254	* @param {Number} end
255	* @returns {Promise<Hash[]>}
256	*/
257
258	async getHashes(start = -1, end = -1) {	×
259	return this.node.chain.getHashes(start, end);	×
260	}
261
262	/**
263	* Get entries range.
264	* @param {Number} start
265	* @param {Number} end
266	* @returns {Promise<ChainEntry[]>}
267	*/
268
269	async getEntries(start = -1, end = -1) {	160✔
270	return this.node.chain.getEntries(start, end);	80✔
271	}
272
273	/**
274	* Rescan for any missed transactions.
275	* @param {Number\|Hash} start - Start block.
276	* @returns {Promise<void>}
277	*/
278
279	async rescan(start) {
280	if (this.node.spv)	×
281	return this.node.chain.reset(start);	×
282
283	return this.node.chain.scan(start, this.filter, (entry, txs) => {	×
284	return this.handleCall('block rescan', entry, txs);	×
285	});
286	}
287
288	/**
289	* Rescan interactive for any missed transactions.
290	* @param {Number\|Hash} start - Start block.
291	* @param {Boolean} [fullLock=false]
292	* @returns {Promise<void>}
293	*/
294
295	async rescanInteractive(start, fullLock = true) {	×
296	if (this.node.spv)	325✔
297	return this.node.chain.reset(start);	6✔
298
299	const iter = async (entry, txs) => {	319✔
300	return await this.handleCall('block rescan interactive', entry, txs);	2,014✔
301	};
302
303	try {	319✔
304	return await this.node.scanInteractive(	319✔
305	start,
306	this.filter,
307	iter,
308	fullLock
309	);
310	} catch (e) {
311	await this.handleCall('block rescan interactive abort', e.message);	1✔
312	throw e;	1✔
313	}
314	}
315
316	/**
317	* Get name state.
318	* @param {Buffer} nameHash
319	* @returns {Promise<NameState>}
320	*/
321
322	async getNameStatus(nameHash) {
323	return this.node.getNameStatus(nameHash);	413✔
324	}
325
326	/**
327	* Get UTXO.
328	* @param {Hash} hash
329	* @param {Number} index
330	* @returns {Object}
331	*/
332
333	async getCoin(hash, index) {
334	return this.node.getCoin(hash, index);	3✔
335	}
336
337	/**
338	* Get block header.
339	* @param {Hash\|Number} block
340	* @returns {Promise<ChainEntry>}
341	*/
342
343	async getBlockHeader(block) {
344	if (typeof block === 'string')	×
345	block = Buffer.from(block, 'hex');	×
346
347	const entry = await this.node.chain.getEntry(block);	×
348
349	if (!entry)	×
350	return null;	×
351
352	return entry.toJSON();	×
353	}
354	}
355
356	/*
357	* Expose
358	*/
359
360	module.exports = NodeClient;	1✔

handshake-org / hsd / 13177121473

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous