12790057089

Committed 15 Jan 2025 02:08PM UTC coverage: 71.235% (-0.005%) from 71.24%

Build # 12790057089

Build Type

Pull #918

github

Committed by

web-flow

Commit Message

Merge ebf0ec0c0 into 343525aad

Pull Request Pull Request #918: wdb: clean up types

Run Details

8053 of 13158 branches covered (61.2%)

Branch coverage included in aggregate %.

91 of 94 new or added lines in 6 files covered. (96.81%)

12 existing lines in 7 files now uncovered.

25729 of 34265 relevant lines covered (75.09%)

34485.24 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('../node/node')} Node */

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

class NodeClient extends AsyncEmitter {
  /** @type {Node} */
  node;

  /**
   * Create a node client.
   * @constructor
   * @param {Node} node
   */

  constructor(node) {
    super();

    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}
   */

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

  /**
   * Close the client.
   * @returns {Promise}
   */

  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}
   */

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

  /**
   * Get chain entry.
   * @param {Hash} hash
   * @returns {Promise}
   */

  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}
   */

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

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

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

  /**
   * Set bloom filter.
   * @param {Bloom} filter
   * @returns {Promise}
   */

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

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

  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}
   */

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

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

  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}
   */

  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}
   */

  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}
   */

  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 {Object}
   */

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

handshake-org / hsd / 12790057089

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