8490300487

Committed 30 Mar 2024 11:04AM UTC coverage: 69.088% (+0.5%) from 68.632%

Build # 8490300487

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge 957501383 into 0a4f24bdb

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

Run Details

7685 of 12976 branches covered (59.22%)

Branch coverage included in aggregate %.

485 of 516 new or added lines in 13 files covered. (93.99%)

7 existing lines in 6 files now uncovered.

24530 of 33653 relevant lines covered (72.89%)

34281.57 hits per line

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

81.08

/lib/wallet/nullclient.js

/*!
 * nullclient.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 EventEmitter = require('events');
const NameState = require('../covenants/namestate');
const Block = require('../primitives/block');
const util = require('../utils/util');

/**
 * Null Client
 * Sort of a fake local client for separation of concerns.
 * @alias module:node.NullClient
 */

class NullClient extends EventEmitter {
  /**
   * Create a client.
   * @constructor
   */

  constructor(wdb) {
    super();

    this.wdb = wdb;
    this.network = wdb.network;
    this.opened = false;
  }

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

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

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

  async close() {
    assert(this.opened, 'NullClient 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() {
    const {hash, height, time} = this.network.genesis;
    return { hash, height, time };
  }

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

  async getEntry(hash) {
    return { hash, height: 0, time: 0 };
  }

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

  async getMedianTime(blockhash) {
    return util.now();
  }

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

  async send(tx) {
    this.wdb.emit('send', tx);
  }

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

  async sendClaim(claim) {
    this.wdb.emit('send claim', claim);
  }

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

  async setFilter(filter) {
    this.wdb.emit('set filter', filter);
  }

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

  async addFilter(data) {
    this.wdb.emit('add filter', data);
  }

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

  async resetFilter() {
    this.wdb.emit('reset filter');
  }

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

  async estimateFee(blocks) {
    return this.network.feeRate;
  }

  /**
   * Get hash range.
   * @param {Number} start
   * @param {Number} end
   * @returns {Promise}
   */

  async getHashes(start = -1, end = -1) {
    return [this.network.genesis.hash];
  }

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

  async getEntries(start = -1, end = -1) {
    const genesisBlock = Block.decode(this.network.genesisBlock);
    const entry = {
      hash: genesisBlock.hash(),
      height: 0,
      time: genesisBlock.time
    };
    return [entry];
  }

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

  async rescan(start) {
    ;
  }

  /**
   * Get opening bid height.
   * @param {Buffer} nameHash
   * @returns {Object}
   */

  async getNameStatus(nameHash) {
    return new NameState();
  }
}

/*
 * Expose
 */

module.exports = NullClient;

1	/*!
2	* nullclient.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 EventEmitter = require('events');	1✔
11	const NameState = require('../covenants/namestate');	1✔
12	const Block = require('../primitives/block');	1✔
13	const util = require('../utils/util');	1✔
14
15	/**
16	* Null Client
17	* Sort of a fake local client for separation of concerns.
18	* @alias module:node.NullClient
19	*/
20
21	class NullClient extends EventEmitter {
22	/**
23	* Create a client.
24	* @constructor
25	*/
26
27	constructor(wdb) {
28	super();	77✔
29
30	this.wdb = wdb;	77✔
31	this.network = wdb.network;	77✔
32	this.opened = false;	77✔
33	}
34
35	/**
36	* Open the client.
37	* @returns {Promise}
38	*/
39
40	async open(options) {
41	assert(!this.opened, 'NullClient is already open.');	3✔
42	this.opened = true;	3✔
43	setImmediate(() => this.emit('connect'));	3✔
44	}
45
46	/**
47	* Close the client.
48	* @returns {Promise}
49	*/
50
51	async close() {
52	assert(this.opened, 'NullClient is not open.');	3✔
53	this.opened = false;	3✔
54	setImmediate(() => this.emit('disconnect'));	3✔
55	}
56
57	/**
58	* Add a listener.
59	* @param {String} type
60	* @param {Function} handler
61	*/
62
63	bind(type, handler) {
64	return this.on(type, handler);	308✔
65	}
66
67	/**
68	* Add a listener.
69	* @param {String} type
70	* @param {Function} handler
71	*/
72
73	hook(type, handler) {
74	return this.on(type, handler);	77✔
75	}
76
77	/**
78	* Get chain tip.
79	* @returns {Promise}
80	*/
81
82	async getTip() {
83	const {hash, height, time} = this.network.genesis;	×
84	return { hash, height, time };	×
85	}
86
87	/**
88	* Get chain entry.
89	* @param {Hash} hash
90	* @returns {Promise}
91	*/
92
93	async getEntry(hash) {
94	return { hash, height: 0, time: 0 };	3✔
95	}
96
97	/**
98	* Get median time past.
99	* @param {Hash} blockhash
100	* @returns {Promise<Number>}
101	*/
102
103	async getMedianTime(blockhash) {
NEW 104	return util.now();	×
105	}
106
107	/**
108	* Send a transaction. Do not wait for promise.
109	* @param {TX} tx
110	* @returns {Promise}
111	*/
112
113	async send(tx) {
114	this.wdb.emit('send', tx);	69✔
115	}
116
117	/**
118	* Send a claim. Do not wait for promise.
119	* @param {Claim} claim
120	* @returns {Promise}
121	*/
122
123	async sendClaim(claim) {
124	this.wdb.emit('send claim', claim);	1✔
125	}
126
127	/**
128	* Set bloom filter.
129	* @param {Bloom} filter
130	* @returns {Promise}
131	*/
132
133	async setFilter(filter) {
134	this.wdb.emit('set filter', filter);	3✔
135	}
136
137	/**
138	* Add data to filter.
139	* @param {Buffer} data
140	* @returns {Promise}
141	*/
142
143	async addFilter(data) {
144	this.wdb.emit('add filter', data);	7,890✔
145	}
146
147	/**
148	* Reset filter.
149	* @returns {Promise}
150	*/
151
152	async resetFilter() {
153	this.wdb.emit('reset filter');	×
154	}
155
156	/**
157	* Esimate smart fee.
158	* @param {Number?} blocks
159	* @returns {Promise}
160	*/
161
162	async estimateFee(blocks) {
163	return this.network.feeRate;	163✔
164	}
165
166	/**
167	* Get hash range.
168	* @param {Number} start
169	* @param {Number} end
170	* @returns {Promise}
171	*/
172
173	async getHashes(start = -1, end = -1) {	×
UNCOV 174	return [this.network.genesis.hash];	×
175	}
176
177	/**
178	* Get entries.
179	* @param {Number} [start=-1]
180	* @param {Number} [end=-1]
181	* @returns {Promise}
182	*/
183
184	async getEntries(start = -1, end = -1) {	6✔
185	const genesisBlock = Block.decode(this.network.genesisBlock);	3✔
186	const entry = {	3✔
187	hash: genesisBlock.hash(),
188	height: 0,
189	time: genesisBlock.time
190	};
191	return [entry];	3✔
192	}
193
194	/**
195	* Rescan for any missed transactions.
196	* @param {Number\|Hash} start - Start block.
197	* @param {Bloom} filter
198	* @param {Function} iter - Iterator.
199	* @returns {Promise}
200	*/
201
202	async rescan(start) {
203	;
204	}
205
206	/**
207	* Get opening bid height.
208	* @param {Buffer} nameHash
209	* @returns {Object}
210	*/
211
212	async getNameStatus(nameHash) {
213	return new NameState();	5✔
214	}
215	}
216
217	/*
218	* Expose
219	*/
220
221	module.exports = NullClient;	1✔

handshake-org / hsd / 8490300487

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