8361633863

Committed 20 Mar 2024 03:32PM UTC coverage: 68.773% (+0.1%) from 68.632%

Build # 8361633863

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge 31468188f into 0a4f24bdb

Pull Request Pull Request #888: Wallet TX Count and time indexing

Run Details

7584 of 12884 branches covered (58.86%)

Branch coverage included in aggregate %.

249 of 277 new or added lines in 11 files covered. (89.89%)

4 existing lines in 3 files now uncovered.

24273 of 33438 relevant lines covered (72.59%)

33850.88 hits per line

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

69.88

/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 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.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 listener.
   * @param {String} type
   * @param {Function} handler
   */

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

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

  /**
   * Get median time past.
   * @param {Hash} blockhash
   * @returns {Promise<Number>}
   */

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

    if (!entry)
      return null;

    return this.node.chain.getMedianTime(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.
   * @param {Bloom} filter
   * @param {Function} iter - Iterator.
   * @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.emitAsync('block rescan', entry, txs);
    });
  }

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

/*
 * 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 AsyncEmitter = require('bevent');	1✔
11
12	/** @typedef {import('../node/node')} Node */
13
14	/**
15	* Node Client
16	* @alias module:node.NodeClient
17	*/
18
19	class NodeClient extends AsyncEmitter {
20	/** @type {Node} */
21	node;
22
23	/**
24	* Create a node client.
25	* @constructor
26	* @param {Node} node
27	*/
28
29	constructor(node) {
30	super();	63✔
31
32	this.node = node;	63✔
33	this.network = node.network;	63✔
34	this.filter = null;	63✔
35	this.opened = false;	63✔
36
37	this.init();	63✔
38	}
39
40	/**
41	* Initialize the client.
42	*/
43
44	init() {
45	this.node.chain.on('connect', async (entry, block) => {	63✔
46	if (!this.opened)	6,638!
47	return;	×
48
49	await this.emitAsync('block connect', entry, block.txs);	6,638✔
50	});
51
52	this.node.chain.on('disconnect', async (entry, block) => {	63✔
53	if (!this.opened)	74!
54	return;	×
55
56	await this.emitAsync('block disconnect', entry);	74✔
57	});
58
59	this.node.on('tx', (tx) => {	63✔
60	if (!this.opened)	1,013!
61	return;	×
62
63	this.emit('tx', tx);	1,013✔
64	});
65
66	this.node.on('reset', (tip) => {	63✔
67	if (!this.opened)	3!
68	return;	×
69
70	this.emit('chain reset', tip);	3✔
71	});
72	}
73
74	/**
75	* Open the client.
76	* @returns {Promise}
77	*/
78
79	async open(options) {
80	assert(!this.opened, 'NodeClient is already open.');	64✔
81	this.opened = true;	64✔
82	setImmediate(() => this.emit('connect'));	64✔
83	}
84
85	/**
86	* Close the client.
87	* @returns {Promise}
88	*/
89
90	async close() {
91	assert(this.opened, 'NodeClient is not open.');	64✔
92	this.opened = false;	64✔
93	setImmediate(() => this.emit('disconnect'));	64✔
94	}
95
96	/**
97	* Add a listener.
98	* @param {String} type
99	* @param {Function} handler
100	*/
101
102	bind(type, handler) {
103	return this.on(type, handler);	252✔
104	}
105
106	/**
107	* Add a listener.
108	* @param {String} type
109	* @param {Function} handler
110	*/
111
112	hook(type, handler) {
113	return this.on(type, handler);	63✔
114	}
115
116	/**
117	* Get chain tip.
118	* @returns {Promise}
119	*/
120
121	async getTip() {
122	return this.node.chain.tip;	×
123	}
124
125	/**
126	* Get chain entry.
127	* @param {Hash} hash
128	* @returns {Promise}
129	*/
130
131	async getEntry(hash) {
132	const entry = await this.node.chain.getEntry(hash);	63✔
133
134	if (!entry)	63!
135	return null;	×
136
137	if (!await this.node.chain.isMainChain(entry))	63!
138	return null;	×
139
140	return entry;	63✔
141	}
142
143	/**
144	* Get median time past.
145	* @param {Hash} blockhash
146	* @returns {Promise<Number>}
147	*/
148
149	async getMedianTime(blockhash) {
NEW 150	const entry = await this.node.chain.getEntry(blockhash);	×
151
NEW 152	if (!entry)	×
NEW 153	return null;	×
154
NEW 155	return this.node.chain.getMedianTime(entry);	×
156	}
157
158	/**
159	* Send a transaction. Do not wait for promise.
160	* @param {TX} tx
161	* @returns {Promise}
162	*/
163
164	async send(tx) {
165	this.node.relay(tx);	921✔
166	}
167
168	/**
169	* Send a claim. Do not wait for promise.
170	* @param {Claim} claim
171	* @returns {Promise}
172	*/
173
174	async sendClaim(claim) {
175	this.node.relayClaim(claim);	8✔
176	}
177
178	/**
179	* Set bloom filter.
180	* @param {Bloom} filter
181	* @returns {Promise}
182	*/
183
184	async setFilter(filter) {
185	this.filter = filter;	64✔
186	this.node.pool.setFilter(filter);	64✔
187	}
188
189	/**
190	* Add data to filter.
191	* @param {Buffer} data
192	* @returns {Promise}
193	*/
194
195	async addFilter(data) {
196	// `data` is ignored because pool.spvFilter === walletDB.filter
197	// and therefore is already updated.
198	// Argument is kept here to be consistent with API in
199	// wallet/client.js (client/node.js) and wallet/nullclient.js
200	this.node.pool.queueFilterLoad();	145,387✔
201	}
202
203	/**
204	* Reset filter.
205	* @returns {Promise}
206	*/
207
208	async resetFilter() {
209	this.node.pool.queueFilterLoad();	×
210	}
211
212	/**
213	* Esimate smart fee.
214	* @param {Number?} blocks
215	* @returns {Promise}
216	*/
217
218	async estimateFee(blocks) {
219	if (!this.node.fees)	1,078!
220	return this.network.feeRate;	×
221
222	return this.node.fees.estimateFee(blocks);	1,078✔
223	}
224
225	/**
226	* Get hash range.
227	* @param {Number} start
228	* @param {Number} end
229	* @returns {Promise}
230	*/
231
232	async getHashes(start = -1, end = -1) {	×
UNCOV 233	return this.node.chain.getHashes(start, end);	×
234	}
235
236	/**
237	* Get entries range.
238	* @param {Number} start
239	* @param {Number} end
240	* @returns {Promise<ChainEntry[]>}
241	*/
242
243	async getEntries(start = -1, end = -1) {	126✔
244	return this.node.chain.getEntries(start, end);	63✔
245	}
246
247	/**
248	* Rescan for any missed transactions.
249	* @param {Number\|Hash} start - Start block.
250	* @param {Bloom} filter
251	* @param {Function} iter - Iterator.
252	* @returns {Promise}
253	*/
254
255	async rescan(start) {
256	if (this.node.spv)	293✔
257	return this.node.chain.reset(start);	2✔
258
259	return this.node.chain.scan(start, this.filter, (entry, txs) => {	291✔
260	return this.emitAsync('block rescan', entry, txs);	1,670✔
261	});
262	}
263
264	/**
265	* Get name state.
266	* @param {Buffer} nameHash
267	* @returns {Object}
268	*/
269
270	async getNameStatus(nameHash) {
271	return this.node.getNameStatus(nameHash);	413✔
272	}
273
274	/**
275	* Get UTXO.
276	* @param {Hash} hash
277	* @param {Number} index
278	* @returns {Object}
279	*/
280
281	async getCoin(hash, index) {
282	return this.node.getCoin(hash, index);	3✔
283	}
284	}
285
286	/*
287	* Expose
288	*/
289
290	module.exports = NodeClient;	1✔

handshake-org / hsd / 8361633863

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