11144281814

Committed 02 Oct 2024 01:01PM UTC coverage: 71.22% (+1.2%) from 70.033%

Build # 11144281814

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge fc0057022 into 45c6ac1d6

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

Run Details

8028 of 13128 branches covered (61.15%)

Branch coverage included in aggregate %.

817 of 874 new or added lines in 16 files covered. (93.48%)

1925 existing lines in 59 files now uncovered.

25686 of 34210 relevant lines covered (75.08%)

34518.94 hits per line

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

74.29

/lib/blockstore/abstract.js

/*!
 * blockstore/abstract.js - abstract blockstore for hsd
 * Copyright (c) 2019, Braydon Fuller (MIT License).
 * Copyright (c) 2020, Mark Tyneway (MIT License).
 * https://github.com/handshake-org/hsd
 */

'use strict';

const Logger = require('blgr');

/**
 * Abstract Block Store
 *
 * @alias module:blockstore.AbstractBlockStore
 * @abstract
 */

class AbstractBlockStore {
  /**
   * Create an abstract blockstore.
   * @constructor
   * @param {Object} [options]
   */

  constructor(options) {
    this.options = options || {};

    if (this.options.logger != null)
      this.logger = this.options.logger.context('blockstore');
    else
      this.logger = Logger.global.context('blockstore');
  }

  /**
   * This method ensures that resources are available
   * before opening.
   * @returns {Promise}
   */

  async ensure() {
    throw new Error('Abstract method.');
  }

  /**
   * This method opens any necessary resources and
   * initializes the store to be ready to be queried.
   * @returns {Promise}
   */

  async open() {
    throw new Error('Abstract method.');
  }

  /**
   * This method closes resources and prepares
   * the store to be closed.
   * @returns {Promise}
   */

  async close() {
    throw new Error('Abstract method.');
  }

  /**
   * This method stores merkle blocks including
   * all the relevant transactions.
   * @param {Buffer} hash
   * @param {Buffer} data
   * @returns {Promise}
   */

  async writeMerkle(hash, data) {
    throw new Error('Abstract method.');
  }

  /**
   * This method stores block undo coin data.
   * @param {Buffer} hash
   * @param {Buffer} data
   * @returns {Promise}
   */

  async writeUndo(hash, data) {
    throw new Error('Abstract method.');
  }

  /**
   * This method stores block data.
   * @param {Buffer} hash
   * @param {Buffer} data
   * @returns {Promise}
   */

  async writeBlock(hash, data) {
    throw new Error('Abstract method.');
  }

  /**
   * This method reads merkle block data.
   * @param {Buffer} hash
   * @returns {Promise}
   */

  async readMerkle(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * This method will retrieve block undo coin data.
   * @param {Buffer} hash
   * @returns {Promise}
   */

  async readUndo(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * This method will retrieve block data. Smaller portions of
   * the block can be read by using the offset and size arguments.
   * @param {Buffer} hash
   * @param {Number} offset
   * @param {Number} size
   * @returns {Promise}
   */

  async readBlock(hash, offset, size) {
    throw new Error('Abstract method.');
  }

  /**
   * This will free resources for storing the merkle block data.
   * @param {Buffer} hash
   * @returns {Promise}
   */

  async pruneMerkle(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * This will free resources for storing the block undo coin data.
   * @param {Buffer} hash
   * @returns {Promise}
   */

  async pruneUndo(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * This will free resources for storing the block data.
   * @param {Buffer} hash
   * @returns {Promise}
   */

  async pruneBlock(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * This will check if merkle block data has been stored
   * and is available.
   * @param {Buffer} hash
   * @returns {Promise}
   */

  async hasMerkle(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * This will check if a block undo coin data has been stored
   * and is available.
   * @param {Buffer} hash
   * @returns {Promise}
   */

  async hasUndo(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * This will check if a block has been stored and is available.
   * @param {Buffer} hash
   * @returns {Promise}
   */

  async hasBlock(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * Create batch.
   * @returns {AbstractBatch}
   */

  batch() {
    throw new Error('Abstract method.');
  }
}

/**
 * This class is just interface for file and level batches.
 * @alias module:blockstore.AbstractBatch
 * @abstract
 */

class AbstractBatch {
  /**
   * Create AbstractBatch.
   * @constructor
   */

  constructor() {
  }

  /**
   * Write merkle block data to the batch.
   * @param {Buffer} hash
   * @param {Buffer} data
   * @returns {this}
   */

  writeMerkle(hash, data) {
    throw new Error('Abstract method.');
  }

  /**
   * Write undo coin data to the batch.
   * @param {Buffer} hash
   * @param {Buffer} data
   * @returns {this}
   */

  writeUndo(hash, data) {
    throw new Error('Abstract method.');
  }

  /**
   * Write block data to the batch.
   * @param {Buffer} hash
   * @param {Buffer} data
   * @returns {this}
   */

  writeBlock(hash, data) {
    throw new Error('Abstract method.');
  }

  /**
   * Remove merkle block data from the batch.
   * @param {Buffer} hash
   * @returns {this}
   */

  pruneMerkle(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * Remove undo data from the batch.
   * @param {Buffer} hash
   * @returns {this}
   */

  pruneUndo(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * Prune block data from the batch.
   * @param {Buffer} hash
   * @returns {this}
   */

  pruneBlock(hash) {
    throw new Error('Abstract method.');
  }

  /**
   * Clear the batch.
   * @returns {this}
   */

  clear() {
    throw new Error('Abstract method.');
  }

  /**
   * Write change to the store.
   * @returns {Promise}
   */

  commit() {
    throw new Error('Abstract method.');
  }
}

/*
 * Expose
 */

AbstractBlockStore.AbstractBatch = AbstractBatch;
module.exports = AbstractBlockStore;

1	/*!
2	* blockstore/abstract.js - abstract blockstore for hsd
3	* Copyright (c) 2019, Braydon Fuller (MIT License).
4	* Copyright (c) 2020, Mark Tyneway (MIT License).
5	* https://github.com/handshake-org/hsd
6	*/
7
8	'use strict';
9
10	const Logger = require('blgr');	1✔
11
12	/**
13	* Abstract Block Store
14	*
15	* @alias module:blockstore.AbstractBlockStore
16	* @abstract
17	*/
18
19	class AbstractBlockStore {
20	/**
21	* Create an abstract blockstore.
22	* @constructor
23	* @param {Object} [options]
24	*/
25
26	constructor(options) {
27	this.options = options \|\| {};	311✔
28
29	if (this.options.logger != null)	311✔
30	this.logger = this.options.logger.context('blockstore');	174✔
31	else
32	this.logger = Logger.global.context('blockstore');	137✔
33	}
34
35	/**
36	* This method ensures that resources are available
37	* before opening.
38	* @returns {Promise}
39	*/
40
41	async ensure() {
42	throw new Error('Abstract method.');	1✔
43	}
44
45	/**
46	* This method opens any necessary resources and
47	* initializes the store to be ready to be queried.
48	* @returns {Promise}
49	*/
50
51	async open() {
52	throw new Error('Abstract method.');	1✔
53	}
54
55	/**
56	* This method closes resources and prepares
57	* the store to be closed.
58	* @returns {Promise}
59	*/
60
61	async close() {
62	throw new Error('Abstract method.');	1✔
63	}
64
65	/**
66	* This method stores merkle blocks including
67	* all the relevant transactions.
68	* @param {Buffer} hash
69	* @param {Buffer} data
70	* @returns {Promise}
71	*/
72
73	async writeMerkle(hash, data) {
74	throw new Error('Abstract method.');	1✔
75	}
76
77	/**
78	* This method stores block undo coin data.
79	* @param {Buffer} hash
80	* @param {Buffer} data
81	* @returns {Promise}
82	*/
83
84	async writeUndo(hash, data) {
85	throw new Error('Abstract method.');	1✔
86	}
87
88	/**
89	* This method stores block data.
90	* @param {Buffer} hash
91	* @param {Buffer} data
92	* @returns {Promise}
93	*/
94
95	async writeBlock(hash, data) {
96	throw new Error('Abstract method.');	1✔
97	}
98
99	/**
100	* This method reads merkle block data.
101	* @param {Buffer} hash
102	* @returns {Promise}
103	*/
104
105	async readMerkle(hash) {
106	throw new Error('Abstract method.');	1✔
107	}
108
109	/**
110	* This method will retrieve block undo coin data.
111	* @param {Buffer} hash
112	* @returns {Promise}
113	*/
114
115	async readUndo(hash) {
116	throw new Error('Abstract method.');	1✔
117	}
118
119	/**
120	* This method will retrieve block data. Smaller portions of
121	* the block can be read by using the offset and size arguments.
122	* @param {Buffer} hash
123	* @param {Number} offset
124	* @param {Number} size
125	* @returns {Promise}
126	*/
127
128	async readBlock(hash, offset, size) {
129	throw new Error('Abstract method.');	1✔
130	}
131
132	/**
133	* This will free resources for storing the merkle block data.
134	* @param {Buffer} hash
135	* @returns {Promise}
136	*/
137
138	async pruneMerkle(hash) {
139	throw new Error('Abstract method.');	1✔
140	}
141
142	/**
143	* This will free resources for storing the block undo coin data.
144	* @param {Buffer} hash
145	* @returns {Promise}
146	*/
147
148	async pruneUndo(hash) {
149	throw new Error('Abstract method.');	1✔
150	}
151
152	/**
153	* This will free resources for storing the block data.
154	* @param {Buffer} hash
155	* @returns {Promise}
156	*/
157
158	async pruneBlock(hash) {
159	throw new Error('Abstract method.');	1✔
160	}
161
162	/**
163	* This will check if merkle block data has been stored
164	* and is available.
165	* @param {Buffer} hash
166	* @returns {Promise}
167	*/
168
169	async hasMerkle(hash) {
170	throw new Error('Abstract method.');	1✔
171	}
172
173	/**
174	* This will check if a block undo coin data has been stored
175	* and is available.
176	* @param {Buffer} hash
177	* @returns {Promise}
178	*/
179
180	async hasUndo(hash) {
181	throw new Error('Abstract method.');	1✔
182	}
183
184	/**
185	* This will check if a block has been stored and is available.
186	* @param {Buffer} hash
187	* @returns {Promise}
188	*/
189
190	async hasBlock(hash) {
191	throw new Error('Abstract method.');	1✔
192	}
193
194	/**
195	* Create batch.
196	* @returns {AbstractBatch}
197	*/
198
199	batch() {
UNCOV 200	throw new Error('Abstract method.');	×
201	}
202	}
203
204	/**
205	* This class is just interface for file and level batches.
206	* @alias module:blockstore.AbstractBatch
207	* @abstract
208	*/
209
210	class AbstractBatch {
211	/**
212	* Create AbstractBatch.
213	* @constructor
214	*/
215
216	constructor() {
217	}
218
219	/**
220	* Write merkle block data to the batch.
221	* @param {Buffer} hash
222	* @param {Buffer} data
223	* @returns {this}
224	*/
225
226	writeMerkle(hash, data) {
227	throw new Error('Abstract method.');	×
228	}
229
230	/**
231	* Write undo coin data to the batch.
232	* @param {Buffer} hash
233	* @param {Buffer} data
234	* @returns {this}
235	*/
236
237	writeUndo(hash, data) {
238	throw new Error('Abstract method.');	×
239	}
240
241	/**
242	* Write block data to the batch.
243	* @param {Buffer} hash
244	* @param {Buffer} data
245	* @returns {this}
246	*/
247
248	writeBlock(hash, data) {
249	throw new Error('Abstract method.');	×
250	}
251
252	/**
253	* Remove merkle block data from the batch.
254	* @param {Buffer} hash
255	* @returns {this}
256	*/
257
258	pruneMerkle(hash) {
259	throw new Error('Abstract method.');	×
260	}
261
262	/**
263	* Remove undo data from the batch.
264	* @param {Buffer} hash
265	* @returns {this}
266	*/
267
268	pruneUndo(hash) {
269	throw new Error('Abstract method.');	×
270	}
271
272	/**
273	* Prune block data from the batch.
274	* @param {Buffer} hash
275	* @returns {this}
276	*/
277
278	pruneBlock(hash) {
279	throw new Error('Abstract method.');	×
280	}
281
282	/**
283	* Clear the batch.
284	* @returns {this}
285	*/
286
287	clear() {
288	throw new Error('Abstract method.');	×
289	}
290
291	/**
292	* Write change to the store.
293	* @returns {Promise}
294	*/
295
296	commit() {
297	throw new Error('Abstract method.');	×
298	}
299	}
300
301	/*
302	* Expose
303	*/
304
305	AbstractBlockStore.AbstractBatch = AbstractBatch;	1✔
306	module.exports = AbstractBlockStore;	1✔

handshake-org / hsd / 11144281814

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