9316161786

Committed 31 May 2024 09:38AM UTC coverage: 68.545% (+0.01%) from 68.532%

Build # 9316161786

Build Type

Pull #882

github

Committed by

web-flow

Commit Message

Merge 501f52950 into 1daebd8ab

Pull Request Pull Request #882: Update wallet and node clients

Run Details

7537 of 12828 branches covered (58.75%)

Branch coverage included in aggregate %.

4 of 5 new or added lines in 2 files covered. (80.0%)

2 existing lines in 1 file now uncovered.

24011 of 33197 relevant lines covered (72.33%)

34019.46 hits per line

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

46.84

/lib/client/node.js

/*!
 * client.js - http client for wallets
 * Copyright (c) 2017, Christopher Jeffrey (MIT License).
 * https://github.com/bcoin-org/bcoin
 */

'use strict';

// NOTE: This is part of generated `hs-client`.
// Don't introduce any unnecessary dependencies to this.

const assert = require('bsert');
const {Client} = require('bcurl');

/**
 * Node Client
 * @alias module:client.NodeClient
 * @extends {bcurl.Client}
 */

class NodeClient extends Client {
  /**
   * Creat a node client.
   * @param {Object?} options
   */

  constructor(options) {
    super(options);
  }

  /**
   * Auth with server.
   * @returns {Promise}
   */

  async auth() {
    await this.call('auth', this.password);
    await this.watchChain();
    await this.watchMempool();
  }

  /**
   * Make an RPC call.
   * @returns {Promise}
   */

  execute(name, params) {
    return super.execute('/', name, params);
  }

  /**
   * Get a mempool snapshot.
   * @returns {Promise}
   */

  getMempool() {
    return this.get('/mempool');
  }

  /**
   * Get a mempool rejection filter.
   * @param {Object} options
   * @returns {Promise}
   */

  getMempoolRejectionFilter(options) {
    return this.get('/mempool/invalid', options);
  }

  /**
   * Check against mempool rejection filter.
   * @param {Hash} hash - transaction hash
   * @returns {Promise}
   */

  checkMempoolRejectionFilter(hash) {
    return this.get(`/mempool/invalid/${hash}`);
  }

  /**
   * Get some info about the server (network and version).
   * @returns {Promise}
   */

  getInfo() {
    return this.get('/');
  }

  /**
   * Get coins that pertain to an address from the mempool or chain database.
   * Takes into account spent coins in the mempool.
   * @param {String} address
   * @returns {Promise}
   */

  getCoinsByAddress(address) {
    assert(typeof address === 'string');
    return this.get(`/coin/address/${address}`);
  }

  /**
   * Get coins that pertain to addresses from the mempool or chain database.
   * Takes into account spent coins in the mempool.
   * @param {String[]} addresses
   * @returns {Promise}
   */

  getCoinsByAddresses(addresses) {
    assert(Array.isArray(addresses));
    return this.post('/coin/address', { addresses });
  }

  /**
   * Retrieve a coin from the mempool or chain database.
   * Takes into account spent coins in the mempool.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Promise}
   */

  getCoin(hash, index) {
    assert(typeof hash === 'string');
    assert((index >>> 0) === index);
    return this.get(`/coin/${hash}/${index}`);
  }

  /**
   * Retrieve transactions pertaining to an
   * address from the mempool or chain database.
   * @param {String} address
   * @returns {Promise}
   */

  getTXByAddress(address) {
    assert(typeof address === 'string');
    return this.get(`/tx/address/${address}`);
  }

  /**
   * Retrieve transactions pertaining to
   * addresses from the mempool or chain database.
   * @param {String[]} addresses
   * @returns {Promise}
   */

  getTXByAddresses(addresses) {
    assert(Array.isArray(addresses));
    return this.post('/tx/address', { addresses });
  }

  /**
   * Retrieve a transaction from the mempool or chain database.
   * @param {Hash} hash
   * @returns {Promise}
   */

  getTX(hash) {
    assert(typeof hash === 'string');
    return this.get(`/tx/${hash}`);
  }

  /**
   * Retrieve a block from the chain database.
   * @param {Hash|Number} block
   * @returns {Promise}
   */

  getBlock(block) {
    assert(typeof block === 'string' || typeof block === 'number');
    return this.get(`/block/${block}`);
  }

  /**
   * Retrieve a block header.
   * @param {Hash|Number} block
   * @returns {Promise}
   */

  getBlockHeader(block) {
    assert(typeof block === 'string' || typeof block === 'number');
    return this.get(`/header/${block}`);
  }

  /**
   * Add a transaction to the mempool and broadcast it.
   * @param {TX} tx
   * @returns {Promise}
   */

  broadcast(tx) {
    assert(typeof tx === 'string');
    return this.post('/broadcast', { tx });
  }

  /**
   * Add a claim to the mempool and broadcast it.
   * @param {Claim} claim
   * @returns {Promise}
   */

  broadcastClaim(claim) {
    assert(typeof claim === 'string');
    return this.post('/claim', { claim });
  }

  /**
   * Estimate smart fee. Same as estimateFee, but
   * an HTTP call instead of websocket call.
   * @param {Number} blocks
   * @returns {Promise}
   */

  getSmartFee(blocks) {
    return this.get('/fee', { blocks });
  }

  /**
   * Reset the chain.
   * @param {Number} height
   * @returns {Promise}
   */

  reset(height) {
    return this.post('/reset', { height });
  }

  /**
   * Watch the blockchain.
   * @private
   * @returns {Promise}
   */

  watchChain() {
    return this.call('watch chain');
  }

  /**
   * Watch the blockchain.
   * @private
   * @returns {Promise}
   */

  watchMempool() {
    return this.call('watch mempool');
  }

  /**
   * Get chain tip.
   * @returns {Promise}
   */

  getTip() {
    return this.call('get tip');
  }

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

  getEntry(block) {
    return this.call('get entry', block);
  }

  /**
   * Get hashes.
   * @param {Number} [start=-1]
   * @param {Number} [end=-1]
   * @returns {Promise}
   */

  getHashes(start, end) {
    return this.call('get hashes', start, end);
  }

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

  send(tx) {
    assert(Buffer.isBuffer(tx));
    return this.call('send', tx);
  }

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

  sendClaim(claim) {
    assert(Buffer.isBuffer(claim));
    return this.call('send claim', claim);
  }

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

  getNameStatus(nameHash) {
    assert(Buffer.isBuffer(nameHash));
    return this.call('get name', nameHash);
  }

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

  setFilter(filter) {
    assert(Buffer.isBuffer(filter));
    return this.call('set filter', filter);
  }

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

  addFilter(chunks) {
    if (!Array.isArray(chunks))
      chunks = [chunks];

    return this.call('add filter', chunks);
  }

  /**
   * Reset filter.
   * @returns {Promise}
   */

  resetFilter() {
    return this.call('reset filter');
  }

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

  estimateFee(blocks) {
    assert(blocks == null || typeof blocks === 'number');
    return this.call('estimate fee', blocks);
  }

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

  rescan(start) {
    if (start == null)
      start = 0;

    assert(typeof start === 'number' || Buffer.isBuffer(start));

    return this.call('rescan', start);
  }

  /**
   * Rescan for any missed transactions. (Interactive)
   * @param {Number|Hash} start - Start block.
   * @param {BloomFilter} [filter]
   * @returns {Promise}
   */

  rescanInteractive(start, filter = null) {
    if (start == null)
      start = 0;

    assert(typeof start === 'number' || Buffer.isBuffer(start));

    return this.call('rescan interactive', start, filter);
  }
}

/*
 * Expose
 */

module.exports = NodeClient;

1	/*!
2	* client.js - http client for wallets
3	* Copyright (c) 2017, Christopher Jeffrey (MIT License).
4	* https://github.com/bcoin-org/bcoin
5	*/
6
7	'use strict';
8
9	// NOTE: This is part of generated `hs-client`.
10	// Don't introduce any unnecessary dependencies to this.
11
12	const assert = require('bsert');	1✔
13	const {Client} = require('bcurl');	1✔
14
15	/**
16	* Node Client
17	* @alias module:client.NodeClient
18	* @extends {bcurl.Client}
19	*/
20
21	class NodeClient extends Client {
22	/**
23	* Creat a node client.
24	* @param {Object?} options
25	*/
26
27	constructor(options) {
28	super(options);	76✔
29	}
30
31	/**
32	* Auth with server.
33	* @returns {Promise}
34	*/
35
36	async auth() {
37	await this.call('auth', this.password);	73✔
38	await this.watchChain();	54✔
39	await this.watchMempool();	53✔
40	}
41
42	/**
43	* Make an RPC call.
44	* @returns {Promise}
45	*/
46
47	execute(name, params) {
48	return super.execute('/', name, params);	381✔
49	}
50
51	/**
52	* Get a mempool snapshot.
53	* @returns {Promise}
54	*/
55
56	getMempool() {
57	return this.get('/mempool');	4✔
58	}
59
60	/**
61	* Get a mempool rejection filter.
62	* @param {Object} options
63	* @returns {Promise}
64	*/
65
66	getMempoolRejectionFilter(options) {
67	return this.get('/mempool/invalid', options);	2✔
68	}
69
70	/**
71	* Check against mempool rejection filter.
72	* @param {Hash} hash - transaction hash
73	* @returns {Promise}
74	*/
75
76	checkMempoolRejectionFilter(hash) {
77	return this.get(`/mempool/invalid/${hash}`);	1✔
78	}
79
80	/**
81	* Get some info about the server (network and version).
82	* @returns {Promise}
83	*/
84
85	getInfo() {
86	return this.get('/');	33✔
87	}
88
89	/**
90	* Get coins that pertain to an address from the mempool or chain database.
91	* Takes into account spent coins in the mempool.
92	* @param {String} address
93	* @returns {Promise}
94	*/
95
96	getCoinsByAddress(address) {
97	assert(typeof address === 'string');	×
98	return this.get(`/coin/address/${address}`);	×
99	}
100
101	/**
102	* Get coins that pertain to addresses from the mempool or chain database.
103	* Takes into account spent coins in the mempool.
104	* @param {String[]} addresses
105	* @returns {Promise}
106	*/
107
108	getCoinsByAddresses(addresses) {
109	assert(Array.isArray(addresses));	1✔
110	return this.post('/coin/address', { addresses });	1✔
111	}
112
113	/**
114	* Retrieve a coin from the mempool or chain database.
115	* Takes into account spent coins in the mempool.
116	* @param {Hash} hash
117	* @param {Number} index
118	* @returns {Promise}
119	*/
120
121	getCoin(hash, index) {
122	assert(typeof hash === 'string');	1✔
123	assert((index >>> 0) === index);	1✔
124	return this.get(`/coin/${hash}/${index}`);	1✔
125	}
126
127	/**
128	* Retrieve transactions pertaining to an
129	* address from the mempool or chain database.
130	* @param {String} address
131	* @returns {Promise}
132	*/
133
134	getTXByAddress(address) {
135	assert(typeof address === 'string');	×
136	return this.get(`/tx/address/${address}`);	×
137	}
138
139	/**
140	* Retrieve transactions pertaining to
141	* addresses from the mempool or chain database.
142	* @param {String[]} addresses
143	* @returns {Promise}
144	*/
145
146	getTXByAddresses(addresses) {
147	assert(Array.isArray(addresses));	×
148	return this.post('/tx/address', { addresses });	×
149	}
150
151	/**
152	* Retrieve a transaction from the mempool or chain database.
153	* @param {Hash} hash
154	* @returns {Promise}
155	*/
156
157	getTX(hash) {
158	assert(typeof hash === 'string');	×
159	return this.get(`/tx/${hash}`);	×
160	}
161
162	/**
163	* Retrieve a block from the chain database.
164	* @param {Hash\|Number} block
165	* @returns {Promise}
166	*/
167
168	getBlock(block) {
169	assert(typeof block === 'string' \|\| typeof block === 'number');	1✔
170	return this.get(`/block/${block}`);	1✔
171	}
172
173	/**
174	* Retrieve a block header.
175	* @param {Hash\|Number} block
176	* @returns {Promise}
177	*/
178
179	getBlockHeader(block) {
180	assert(typeof block === 'string' \|\| typeof block === 'number');	14✔
181	return this.get(`/header/${block}`);	14✔
182	}
183
184	/**
185	* Add a transaction to the mempool and broadcast it.
186	* @param {TX} tx
187	* @returns {Promise}
188	*/
189
190	broadcast(tx) {
191	assert(typeof tx === 'string');	1✔
192	return this.post('/broadcast', { tx });	1✔
193	}
194
195	/**
196	* Add a claim to the mempool and broadcast it.
197	* @param {Claim} claim
198	* @returns {Promise}
199	*/
200
201	broadcastClaim(claim) {
202	assert(typeof claim === 'string');	×
203	return this.post('/claim', { claim });	×
204	}
205
206	/**
207	* Estimate smart fee. Same as estimateFee, but
208	* an HTTP call instead of websocket call.
209	* @param {Number} blocks
210	* @returns {Promise}
211	*/
212
213	getSmartFee(blocks) {
NEW 214	return this.get('/fee', { blocks });	×
215	}
216
217	/**
218	* Reset the chain.
219	* @param {Number} height
220	* @returns {Promise}
221	*/
222
223	reset(height) {
224	return this.post('/reset', { height });	×
225	}
226
227	/**
228	* Watch the blockchain.
229	* @private
230	* @returns {Promise}
231	*/
232
233	watchChain() {
234	return this.call('watch chain');	54✔
235	}
236
237	/**
238	* Watch the blockchain.
239	* @private
240	* @returns {Promise}
241	*/
242
243	watchMempool() {
244	return this.call('watch mempool');	53✔
245	}
246
247	/**
248	* Get chain tip.
249	* @returns {Promise}
250	*/
251
252	getTip() {
253	return this.call('get tip');	×
254	}
255
256	/**
257	* Get chain entry.
258	* @param {Hash} hash
259	* @returns {Promise}
260	*/
261
262	getEntry(block) {
263	return this.call('get entry', block);	×
264	}
265
266	/**
267	* Get hashes.
268	* @param {Number} [start=-1]
269	* @param {Number} [end=-1]
270	* @returns {Promise}
271	*/
272
273	getHashes(start, end) {
274	return this.call('get hashes', start, end);	×
275	}
276
277	/**
278	* Send a transaction. Do not wait for promise.
279	* @param {TX} tx
280	* @returns {Promise}
281	*/
282
283	send(tx) {
284	assert(Buffer.isBuffer(tx));	×
285	return this.call('send', tx);	×
286	}
287
288	/**
289	* Send a claim. Do not wait for promise.
290	* @param {Claim} claim
291	* @returns {Promise}
292	*/
293
294	sendClaim(claim) {
295	assert(Buffer.isBuffer(claim));	×
296	return this.call('send claim', claim);	×
297	}
298
299	/**
300	* Get name state.
301	* @param {Buffer} nameHash
302	* @returns {Promise}
303	*/
304
305	getNameStatus(nameHash) {
306	assert(Buffer.isBuffer(nameHash));	×
307	return this.call('get name', nameHash);	×
308	}
309
310	/**
311	* Set bloom filter.
312	* @param {Bloom} filter
313	* @returns {Promise}
314	*/
315
316	setFilter(filter) {
317	assert(Buffer.isBuffer(filter));	13✔
318	return this.call('set filter', filter);	13✔
319	}
320
321	/**
322	* Add data to filter.
323	* @param {Buffer} data
324	* @returns {Promise}
325	*/
326
327	addFilter(chunks) {
328	if (!Array.isArray(chunks))	×
329	chunks = [chunks];	×
330
331	return this.call('add filter', chunks);	×
332	}
333
334	/**
335	* Reset filter.
336	* @returns {Promise}
337	*/
338
339	resetFilter() {
340	return this.call('reset filter');	×
341	}
342
343	/**
344	* Esimate smart fee.
345	* @param {Number?} blocks
346	* @returns {Promise}
347	*/
348
349	estimateFee(blocks) {
350	assert(blocks == null \|\| typeof blocks === 'number');	×
351	return this.call('estimate fee', blocks);	×
352	}
353
354	/**
355	* Rescan for any missed transactions.
356	* @param {Number\|Hash} start - Start block.
357	* @returns {Promise}
358	*/
359
360	rescan(start) {
361	if (start == null)	×
362	start = 0;	×
363
364	assert(typeof start === 'number' \|\| Buffer.isBuffer(start));	×
365
366	return this.call('rescan', start);	×
367	}
368
369	/**
370	* Rescan for any missed transactions. (Interactive)
371	* @param {Number\|Hash} start - Start block.
372	* @param {BloomFilter} [filter]
373	* @returns {Promise}
374	*/
375
376	rescanInteractive(start, filter = null) {	16✔
377	if (start == null)	38!
378	start = 0;	×
379
380	assert(typeof start === 'number' \|\| Buffer.isBuffer(start));	38!
381
382	return this.call('rescan interactive', start, filter);	38✔
383	}
384	}
385
386	/*
387	* Expose
388	*/
389
390	module.exports = NodeClient;	1✔

handshake-org / hsd / 9316161786

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