11553216230

Committed 28 Oct 2024 11:43AM UTC coverage: 71.275% (+1.2%) from 70.033%

Build # 11553216230

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge ab6292a60 into 1b331eedb

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

Run Details

8053 of 13148 branches covered (61.25%)

Branch coverage included in aggregate %.

824 of 881 new or added lines in 16 files covered. (93.53%)

2062 existing lines in 60 files now uncovered.

25719 of 34235 relevant lines covered (75.12%)

34512.83 hits per line

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

89.66

/lib/blockstore/level.js

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

'use strict';

const assert = require('bsert');
const bdb = require('bdb');
const fs = require('bfile');
const AbstractBlockStore = require('./abstract');
const {AbstractBatch} = require('./abstract');
const layout = require('./layout');
const {types} = require('./common');

/**
 * LevelDB Block Store
 *
 * @alias module:blockstore:LevelBlockStore
 * @abstract
 */

class LevelBlockStore extends AbstractBlockStore {
  /**
   * Create a blockstore that stores blocks in LevelDB.
   * @constructor
   * @param {Object} [options]
   */

  constructor(options) {
    super(options);

    this.location = options.location;

    this.db = bdb.create({
      location: this.location,
      cacheSize: options.cacheSize,
      compression: false,
      memory: options.memory
    });
  }

  /**
   * This method ensures that the storage directory exists
   * before opening.
   * @returns {Promise}
   */

  async ensure() {
    return fs.mkdirp(this.location);
  }

  /**
   * Opens the block storage.
   * @returns {Promise}
   */

  async open() {
    this.logger.info('Opening LevelBlockStore...');

    await this.db.open();
    await this.db.verify(layout.V.encode(), 'levelblockstore', 0);
  }

  /**
   * Closes the block storage.
   */

  async close() {
    this.logger.info('Closing LevelBlockStore...');

    await this.db.close();
  }

  /**
   * This method stores merkle block data in LevelDB.
   * @param {Buffer} hash - The block hash
   * @param {Buffer} data - The block data
   * @returns {Promise}
   */

  async writeMerkle(hash, data) {
    return this.db.put(layout.b.encode(types.MERKLE, hash), data);
  }

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

  async writeUndo(hash, data) {
    return this.db.put(layout.b.encode(types.UNDO, hash), data);
  }

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

  async writeBlock(hash, data) {
    return this.db.put(layout.b.encode(types.BLOCK, hash), data);
  }

  /**
   * This method will retrieve merkle block data.
   * @param {Buffer} hash - The block hash
   * @returns {Promise}
   */

  async readMerkle(hash) {
    return this.db.get(layout.b.encode(types.MERKLE, hash));
  }

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

  async readUndo(hash) {
    return this.db.get(layout.b.encode(types.UNDO, hash));
  }

  /**
   * This method will retrieve block data. Smaller portions of the
   * block (e.g. transactions) can be returned using the offset and
   * length arguments. However, the entire block will be read as the
   * data is stored in a key/value database.
   * @param {Buffer} hash - The block hash
   * @param {Number} offset - The offset within the block
   * @param {Number} length - The number of bytes of the data
   * @returns {Promise}
   */

  async readBlock(hash, offset, length) {
    let raw = await this.db.get(layout.b.encode(types.BLOCK, hash));

    if (offset) {
      if (offset + length > raw.length)
        throw new Error('Out-of-bounds read.');

      raw = raw.slice(offset, offset + length);
    }

    return raw;
  }

  /**
   * This will free resources for storing merkle block data.
   * The block data may not be immediately removed from disk, and will
   * be reclaimed during LevelDB compaction.
   * @param {Buffer} hash - The block hash
   * @returns {Promise}
   */

  async pruneMerkle(hash) {
    if (!await this.hasMerkle(hash))
      return false;

    await this.db.del(layout.b.encode(types.MERKLE, hash));

    return true;
  }

  /**
   * This will free resources for storing the block undo coin data.
   * The block data may not be immediately removed from disk, and will
   * be reclaimed during LevelDB compaction.
   * @param {Buffer} hash - The block hash
   * @returns {Promise}
   */

  async pruneUndo(hash) {
    if (!await this.hasUndo(hash))
      return false;

    await this.db.del(layout.b.encode(types.UNDO, hash));

    return true;
  }

  /**
   * This will free resources for storing the block data. The block
   * data may not be immediately removed from disk, and will be reclaimed
   * during LevelDB compaction.
   * @param {Buffer} hash - The block hash
   * @returns {Promise}
   */

  async pruneBlock(hash) {
    if (!await this.hasBlock(hash))
      return false;

    await this.db.del(layout.b.encode(types.BLOCK, hash));

    return true;
  }

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

  async hasMerkle(hash) {
    return this.db.has(layout.b.encode(types.MERKLE, hash));
  }

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

  async hasUndo(hash) {
    return this.db.has(layout.b.encode(types.UNDO, hash));
  }

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

  async hasBlock(hash) {
    return this.db.has(layout.b.encode(types.BLOCK, hash));
  }

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

  batch() {
    return new LevelBatch(this.db);
  }
}

/**
 * Batch wrapper for the level blockstore.
 * @alias module:blockstore.LevelBatch
 */

class LevelBatch extends AbstractBatch {
  /**
   * Create LevelBatch
   * @param {bdb.DB} db
   */

  constructor(db) {
    super();

    this.writesBatch = db.batch();
    this.prunesBatch = db.batch();
    this.committedWrites = false;
    this.committedPrunes = false;
  }

  get written() {
    return this.committedPrunes && this.committedWrites;
  }

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

  writeMerkle(hash, data) {
    this.writesBatch.put(layout.b.encode(types.MERKLE, hash), data);
    return this;
  }

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

  writeUndo(hash, data) {
    this.writesBatch.put(layout.b.encode(types.UNDO, hash), data);
    return this;
  }

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

  writeBlock(hash, data) {
    this.writesBatch.put(layout.b.encode(types.BLOCK, hash), data);
    return this;
  }

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

  pruneMerkle(hash) {
    this.prunesBatch.del(layout.b.encode(types.MERKLE, hash));
    return this;
  }

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

  pruneUndo(hash) {
    this.prunesBatch.del(layout.b.encode(types.UNDO, hash));
    return this;
  }

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

  pruneBlock(hash) {
    this.prunesBatch.del(layout.b.encode(types.BLOCK, hash));
    return this;
  }

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

  clear() {
    assert(!this.written, 'Already written all.');
    this.writesBatch.clear();
    this.prunesBatch.clear();
    return this;
  }

  async commitWrites() {
    assert(!this.committedWrites, 'Already written writes.');

    await this.writesBatch.write();

    this.committedWrites = true;
  }

  async commitPrunes() {
    assert(!this.committedPrunes, 'Already written prunes.');

    await this.prunesBatch.write();

    this.committedPrunes = true;
  }

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

  async commit() {
    assert(!this.written, 'Already written all.');

    await this.commitWrites();
    await this.commitPrunes();
  }
}

/*
 * Expose
 */

module.exports = LevelBlockStore;

1	/*!
2	* blockstore/level.js - leveldb blockstore for hsd
3	* Copyright (c) 2019, Braydon Fuller (MIT License).
4	* https://github.com/handshake-org/hsd
5	*/
6
7	'use strict';
8
9	const assert = require('bsert');	1✔
10	const bdb = require('bdb');	1✔
11	const fs = require('bfile');	1✔
12	const AbstractBlockStore = require('./abstract');	1✔
13	const {AbstractBatch} = require('./abstract');	1✔
14	const layout = require('./layout');	1✔
15	const {types} = require('./common');	1✔
16
17	/**
18	* LevelDB Block Store
19	*
20	* @alias module:blockstore:LevelBlockStore
21	* @abstract
22	*/
23
24	class LevelBlockStore extends AbstractBlockStore {
25	/**
26	* Create a blockstore that stores blocks in LevelDB.
27	* @constructor
28	* @param {Object} [options]
29	*/
30
31	constructor(options) {
32	super(options);	207✔
33
34	this.location = options.location;	207✔
35
36	this.db = bdb.create({	207✔
37	location: this.location,
38	cacheSize: options.cacheSize,
39	compression: false,
40	memory: options.memory
41	});
42	}
43
44	/**
45	* This method ensures that the storage directory exists
46	* before opening.
47	* @returns {Promise}
48	*/
49
50	async ensure() {
51	return fs.mkdirp(this.location);	23✔
52	}
53
54	/**
55	* Opens the block storage.
56	* @returns {Promise}
57	*/
58
59	async open() {
60	this.logger.info('Opening LevelBlockStore...');	231✔
61
62	await this.db.open();	231✔
63	await this.db.verify(layout.V.encode(), 'levelblockstore', 0);	231✔
64	}
65
66	/**
67	* Closes the block storage.
68	*/
69
70	async close() {
71	this.logger.info('Closing LevelBlockStore...');	231✔
72
73	await this.db.close();	231✔
74	}
75
76	/**
77	* This method stores merkle block data in LevelDB.
78	* @param {Buffer} hash - The block hash
79	* @param {Buffer} data - The block data
80	* @returns {Promise}
81	*/
82
83	async writeMerkle(hash, data) {
84	return this.db.put(layout.b.encode(types.MERKLE, hash), data);	1✔
85	}
86
87	/**
88	* This method stores block undo coin data in LevelDB.
89	* @param {Buffer} hash - The block hash
90	* @param {Buffer} data - The block data
91	* @returns {Promise}
92	*/
93
94	async writeUndo(hash, data) {
95	return this.db.put(layout.b.encode(types.UNDO, hash), data);	14✔
96	}
97
98	/**
99	* This method stores block data in LevelDB.
100	* @param {Buffer} hash - The block hash
101	* @param {Buffer} data - The block data
102	* @returns {Promise}
103	*/
104
105	async writeBlock(hash, data) {
106	return this.db.put(layout.b.encode(types.BLOCK, hash), data);	122✔
107	}
108
109	/**
110	* This method will retrieve merkle block data.
111	* @param {Buffer} hash - The block hash
112	* @returns {Promise}
113	*/
114
115	async readMerkle(hash) {
116	return this.db.get(layout.b.encode(types.MERKLE, hash));	5✔
117	}
118
119	/**
120	* This method will retrieve block undo coin data.
121	* @param {Buffer} hash - The block hash
122	* @returns {Promise}
123	*/
124
125	async readUndo(hash) {
126	return this.db.get(layout.b.encode(types.UNDO, hash));	2,757✔
127	}
128
129	/**
130	* This method will retrieve block data. Smaller portions of the
131	* block (e.g. transactions) can be returned using the offset and
132	* length arguments. However, the entire block will be read as the
133	* data is stored in a key/value database.
134	* @param {Buffer} hash - The block hash
135	* @param {Number} offset - The offset within the block
136	* @param {Number} length - The number of bytes of the data
137	* @returns {Promise}
138	*/
139
140	async readBlock(hash, offset, length) {
141	let raw = await this.db.get(layout.b.encode(types.BLOCK, hash));	13,435✔
142
143	if (offset) {	13,435✔
144	if (offset + length > raw.length)	2✔
145	throw new Error('Out-of-bounds read.');	1✔
146
147	raw = raw.slice(offset, offset + length);	1✔
148	}
149
150	return raw;	13,434✔
151	}
152
153	/**
154	* This will free resources for storing merkle block data.
155	* The block data may not be immediately removed from disk, and will
156	* be reclaimed during LevelDB compaction.
157	* @param {Buffer} hash - The block hash
158	* @returns {Promise}
159	*/
160
161	async pruneMerkle(hash) {
UNCOV 162	if (!await this.hasMerkle(hash))	×
163	return false;	×
164
165	await this.db.del(layout.b.encode(types.MERKLE, hash));	×
166
UNCOV 167	return true;	×
168	}
169
170	/**
171	* This will free resources for storing the block undo coin data.
172	* The block data may not be immediately removed from disk, and will
173	* be reclaimed during LevelDB compaction.
174	* @param {Buffer} hash - The block hash
175	* @returns {Promise}
176	*/
177
178	async pruneUndo(hash) {
179	if (!await this.hasUndo(hash))	2✔
180	return false;	1✔
181
182	await this.db.del(layout.b.encode(types.UNDO, hash));	1✔
183
184	return true;	1✔
185	}
186
187	/**
188	* This will free resources for storing the block data. The block
189	* data may not be immediately removed from disk, and will be reclaimed
190	* during LevelDB compaction.
191	* @param {Buffer} hash - The block hash
192	* @returns {Promise}
193	*/
194
195	async pruneBlock(hash) {
196	if (!await this.hasBlock(hash))	2✔
197	return false;	1✔
198
199	await this.db.del(layout.b.encode(types.BLOCK, hash));	1✔
200
201	return true;	1✔
202	}
203
204	/**
205	* This will check if a merkle block data has been stored
206	* and is available.
207	* @param {Buffer} hash - The block hash
208	* @returns {Promise}
209	*/
210
211	async hasMerkle(hash) {
212	return this.db.has(layout.b.encode(types.MERKLE, hash));	64✔
213	}
214
215	/**
216	* This will check if a block undo coin data has been stored
217	* and is available.
218	* @param {Buffer} hash - The block hash
219	* @returns {Promise}
220	*/
221
222	async hasUndo(hash) {
223	return this.db.has(layout.b.encode(types.UNDO, hash));	68✔
224	}
225
226	/**
227	* This will check if a block has been stored and is available.
228	* @param {Buffer} hash - The block hash
229	* @returns {Promise}
230	*/
231
232	async hasBlock(hash) {
233	return this.db.has(layout.b.encode(types.BLOCK, hash));	190✔
234	}
235
236	/**
237	* Create batch.
238	* @returns {LevelBatch}
239	*/
240
241	batch() {
242	return new LevelBatch(this.db);	19,327✔
243	}
244	}
245
246	/**
247	* Batch wrapper for the level blockstore.
248	* @alias module:blockstore.LevelBatch
249	*/
250
251	class LevelBatch extends AbstractBatch {
252	/**
253	* Create LevelBatch
254	* @param {bdb.DB} db
255	*/
256
257	constructor(db) {
258	super();	19,327✔
259
260	this.writesBatch = db.batch();	19,327✔
261	this.prunesBatch = db.batch();	19,327✔
262	this.committedWrites = false;	19,327✔
263	this.committedPrunes = false;	19,327✔
264	}
265
266	get written() {
267	return this.committedPrunes && this.committedWrites;	29✔
268	}
269
270	/**
271	* Write merkle block data to the batch.
272	* @param {Buffer} hash
273	* @param {Buffer} data
274	* @returns {this}
275	*/
276
277	writeMerkle(hash, data) {
278	this.writesBatch.put(layout.b.encode(types.MERKLE, hash), data);	34✔
279	return this;	34✔
280	}
281
282	/**
283	* Write undo coin data to the batch.
284	* @param {Buffer} hash
285	* @param {Buffer} data
286	* @returns {this}
287	*/
288
289	writeUndo(hash, data) {
290	this.writesBatch.put(layout.b.encode(types.UNDO, hash), data);	1,648✔
291	return this;	1,648✔
292	}
293
294	/**
295	* Write block data to the batch.
296	* @param {Buffer} hash
297	* @param {Buffer} data
298	* @returns {this}
299	*/
300
301	writeBlock(hash, data) {
302	this.writesBatch.put(layout.b.encode(types.BLOCK, hash), data);	16,293✔
303	return this;	16,293✔
304	}
305
306	/**
307	* Remove merkle block data from the batch.
308	* @param {Buffer} hash
309	* @returns {this}
310	*/
311
312	pruneMerkle(hash) {
313	this.prunesBatch.del(layout.b.encode(types.MERKLE, hash));	32✔
314	return this;	32✔
315	}
316
317	/**
318	* Remove undo data from the batch.
319	* @param {Buffer} hash
320	* @returns {this}
321	*/
322
323	pruneUndo(hash) {
324	this.prunesBatch.del(layout.b.encode(types.UNDO, hash));	2,788✔
325	return this;	2,788✔
326	}
327
328	/**
329	* Prune block data from the batch.
330	* @param {Buffer} hash
331	* @returns {this}
332	*/
333
334	pruneBlock(hash) {
335	this.prunesBatch.del(layout.b.encode(types.BLOCK, hash));	2,425✔
336	return this;	2,425✔
337	}
338
339	/**
340	* Clear the batch.
341	* @returns {this}
342	*/
343
344	clear() {
345	assert(!this.written, 'Already written all.');	2✔
UNCOV 346	this.writesBatch.clear();	×
UNCOV 347	this.prunesBatch.clear();	×
UNCOV 348	return this;	×
349	}
350
351	async commitWrites() {
352	assert(!this.committedWrites, 'Already written writes.');	19,325✔
353
354	await this.writesBatch.write();	19,325✔
355
356	this.committedWrites = true;	19,325✔
357	}
358
359	async commitPrunes() {
360	assert(!this.committedPrunes, 'Already written prunes.');	19,323✔
361
362	await this.prunesBatch.write();	19,323✔
363
364	this.committedPrunes = true;	19,323✔
365	}
366
367	/**
368	* Write change to the store.
369	* @returns {Promise}
370	*/
371
372	async commit() {
373	assert(!this.written, 'Already written all.');	27✔
374
375	await this.commitWrites();	25✔
376	await this.commitPrunes();	25✔
377	}
378	}
379
380	/*
381	* Expose
382	*/
383
384	module.exports = LevelBlockStore;	1✔

handshake-org / hsd / 11553216230

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