7337947006

Committed 27 Dec 2023 11:40AM UTC coverage: 69.798% (+1.2%) from 68.626%

Build # 7337947006

Build Type

Pull #883

github

Committed by

web-flow

Commit Message

Merge a32818efe into 5f943173e

Pull Request Pull Request #883: Wallet Sync Updates

Run Details

7683 of 12841 branches covered (0.0%)

Branch coverage included in aggregate %.

36 of 38 new or added lines in 10 files covered. (94.74%)

154 existing lines in 5 files now uncovered.

24468 of 33222 relevant lines covered (73.65%)

34052.9 hits per line

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

90.0

/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');

/**
 * 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 options.
   * @returns {Promise}
   */

  async getOptions() {
    return {
      chain: {
        spv: false,
        chain: false
      }
    };
  }

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

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

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

handshake-org / hsd / 7337947006

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