10059963428

Committed 23 Jul 2024 01:33PM UTC coverage: 68.676% (+0.1%) from 68.551%

Build # 10059963428

Build Type

Pull #900

github

Committed by

web-flow

Commit Message

Merge ed01b20bc into 106fbfaac

Pull Request Pull Request #900: Update migrations

Run Details

7559 of 12844 branches covered (58.85%)

Branch coverage included in aggregate %.

313 of 318 new or added lines in 6 files covered. (98.43%)

5 existing lines in 2 files now uncovered.

24146 of 33322 relevant lines covered (72.46%)

33879.95 hits per line

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

94.51

/lib/blockchain/records.js

/*!
 * records.js - chaindb records
 * Copyright (c) 2024 The Handshake Developers (MIT License).
 * https://github.com/handshake-org/hsd
 */

'use strict';

const assert = require('bsert');
const bio = require('bufio');
const {BufferMap} = require('buffer-map');
const consensus = require('../protocol/consensus');
const Network = require('../protocol/network');

/**
 * ChainFlags
 */

class ChainFlags extends bio.Struct {
  /**
   * Create chain flags.
   * @alias module:blockchain.ChainFlags
   * @constructor
   */

  constructor(options) {
    super();

    this.network = Network.primary;
    this.spv = false;
    this.prune = false;
    this.indexTX = false;
    this.indexAddress = false;

    if (options)
      this.fromOptions(options);
  }

  fromOptions(options) {
    this.network = Network.get(options.network);

    if (options.spv != null) {
      assert(typeof options.spv === 'boolean');
      this.spv = options.spv;
    }

    if (options.prune != null) {
      assert(typeof options.prune === 'boolean');
      this.prune = options.prune;
    }

    if (options.indexTX != null) {
      assert(typeof options.indexTX === 'boolean');
      this.indexTX = options.indexTX;
    }

    if (options.indexAddress != null) {
      assert(typeof options.indexAddress === 'boolean');
      this.indexAddress = options.indexAddress;
    }

    return this;
  }

  getSize() {
    return 12;
  }

  write(bw) {
    let flags = 0;

    if (this.spv)
      flags |= 1 << 0;

    if (this.prune)
      flags |= 1 << 1;

    if (this.indexTX)
      flags |= 1 << 2;

    if (this.indexAddress)
      flags |= 1 << 3;

    bw.writeU32(this.network.magic);
    bw.writeU32(flags);
    bw.writeU32(0);

    return bw;
  }

  read(br) {
    this.network = Network.fromMagic(br.readU32());

    const flags = br.readU32();

    this.spv = (flags & 1) !== 0;
    this.prune = (flags & 2) !== 0;
    this.indexTX = (flags & 4) !== 0;
    this.indexAddress = (flags & 8) !== 0;

    return this;
  }
}

/**
 * Chain State
 */

class ChainState extends bio.Struct {
  /**
   * Create chain state.
   * @alias module:blockchain.ChainState
   * @constructor
   */

  constructor() {
    super();
    this.tip = consensus.ZERO_HASH;
    this.tx = 0;
    this.coin = 0;
    this.value = 0;
    this.burned = 0;
    this.committed = false;
  }

  inject(state) {
    this.tip = state.tip;
    this.tx = state.tx;
    this.coin = state.coin;
    this.value = state.value;
    this.burned = state.burned;
    return this;
  }

  connect(block) {
    this.tx += block.txs.length;
  }

  disconnect(block) {
    this.tx -= block.txs.length;
  }

  add(coin) {
    this.coin += 1;
    this.value += coin.value;
  }

  spend(coin) {
    this.coin -= 1;
    this.value -= coin.value;
  }

  burn(coin) {
    this.coin += 1;
    this.burned += coin.value;
  }

  unburn(coin) {
    this.coin -= 1;
    this.burned -= coin.value;
  }

  commit(hash) {
    assert(Buffer.isBuffer(hash));
    this.tip = hash;
    this.committed = true;
    return this.encode();
  }

  getSize() {
    return 64;
  }

  write(bw) {
    bw.writeHash(this.tip);
    bw.writeU64(this.tx);
    bw.writeU64(this.coin);
    bw.writeU64(this.value);
    bw.writeU64(this.burned);
    return bw;
  }

  read(br) {
    this.tip = br.readHash();
    this.tx = br.readU64();
    this.coin = br.readU64();
    this.value = br.readU64();
    this.burned = br.readU64();
    return this;
  }
}

/**
 * State Cache
 */

class StateCache {
  /**
   * Create state cache.
   * @alias module:blockchain.StateCache
   * @constructor
   */

  constructor(network) {
    this.network = network;
    this.bits = [];
    this.updates = [];
    this.init();
  }

  init() {
    for (let i = 0; i < 32; i++)
      this.bits.push(null);

    for (const {bit} of this.network.deploys) {
      assert(!this.bits[bit]);
      this.bits[bit] = new BufferMap();
    }
  }

  set(bit, entry, state) {
    const cache = this.bits[bit];

    assert(cache);

    if (cache.get(entry.hash) !== state) {
      cache.set(entry.hash, state);
      this.updates.push(new CacheUpdate(bit, entry.hash, state));
    }
  }

  get(bit, entry) {
    const cache = this.bits[bit];

    assert(cache);

    const state = cache.get(entry.hash);

    if (state == null)
      return -1;

    return state;
  }

  commit() {
    this.updates.length = 0;
  }

  drop() {
    for (const {bit, hash} of this.updates) {
      const cache = this.bits[bit];
      assert(cache);
      cache.delete(hash);
    }

    this.updates.length = 0;
  }

  insert(bit, hash, state) {
    const cache = this.bits[bit];
    assert(cache);
    cache.set(hash, state);
  }
}

/**
 * Cache Update
 */

class CacheUpdate {
  /**
   * Create cache update.
   * @constructor
   * @ignore
   */

  constructor(bit, hash, state) {
    this.bit = bit;
    this.hash = hash;
    this.state = state;
  }

  encode() {
    const data = Buffer.allocUnsafe(1);
    data[0] = this.state;
    return data;
  }
}

/**
 * Tree related state.
 */

class TreeState extends bio.Struct {
  /**
   * Create tree state.
   * @constructor
   * @ignore
   */

  constructor() {
    super();
    this.treeRoot = consensus.ZERO_HASH;
    this.commitHeight = 0;
    this.compactionRoot = consensus.ZERO_HASH;
    this.compactionHeight = 0;

    this.committed = false;
  }

  inject(state) {
    this.treeRoot = state.treeRoot;
    this.commitHeight = state.treeHeight;
    this.compactionHeight = state.compactionHeight;
    this.compactionRoot = state.compactionRoot;

    return this;
  }

  compact(hash, height) {
    assert(Buffer.isBuffer(hash));
    assert((height >>> 0) === height);

    this.compactionRoot = hash;
    this.compactionHeight = height;
  };

  commit(hash, height) {
    assert(Buffer.isBuffer(hash));
    assert((height >>> 0) === height);

    this.treeRoot = hash;
    this.commitHeight = height;
    this.committed = true;
    return this.encode();
  }

  getSize() {
    return 72;
  }

  write(bw) {
    bw.writeHash(this.treeRoot);
    bw.writeU32(this.commitHeight);
    bw.writeHash(this.compactionRoot);
    bw.writeU32(this.compactionHeight);

    return bw;
  }

  read(br) {
    this.treeRoot = br.readHash();
    this.commitHeight = br.readU32();
    this.compactionRoot = br.readHash();
    this.compactionHeight = br.readU32();

    return this;
  }
}

/*
 * Expose
 */

exports.ChainFlags = ChainFlags;
exports.ChainState = ChainState;
exports.StateCache = StateCache;
exports.TreeState = TreeState;
exports.CacheUpdate = CacheUpdate;

1	/*!
2	* records.js - chaindb records
3	* Copyright (c) 2024 The Handshake Developers (MIT License).
4	* https://github.com/handshake-org/hsd
5	*/
6
7	'use strict';
8
9	const assert = require('bsert');	1✔
10	const bio = require('bufio');	1✔
11	const {BufferMap} = require('buffer-map');	1✔
12	const consensus = require('../protocol/consensus');	1✔
13	const Network = require('../protocol/network');	1✔
14
15	/**
16	* ChainFlags
17	*/
18
19	class ChainFlags extends bio.Struct {
20	/**
21	* Create chain flags.
22	* @alias module:blockchain.ChainFlags
23	* @constructor
24	*/
25
26	constructor(options) {
27	super();	304✔
28
29	this.network = Network.primary;	304✔
30	this.spv = false;	304✔
31	this.prune = false;	304✔
32	this.indexTX = false;	304✔
33	this.indexAddress = false;	304✔
34
35	if (options)	304!
NEW 36	this.fromOptions(options);	×
37	}
38
39	fromOptions(options) {
40	this.network = Network.get(options.network);	195✔
41
42	if (options.spv != null) {	195!
43	assert(typeof options.spv === 'boolean');	195✔
44	this.spv = options.spv;	195✔
45	}
46
47	if (options.prune != null) {	195!
48	assert(typeof options.prune === 'boolean');	195✔
49	this.prune = options.prune;	195✔
50	}
51
52	if (options.indexTX != null) {	195!
53	assert(typeof options.indexTX === 'boolean');	195✔
54	this.indexTX = options.indexTX;	195✔
55	}
56
57	if (options.indexAddress != null) {	195!
58	assert(typeof options.indexAddress === 'boolean');	195✔
59	this.indexAddress = options.indexAddress;	195✔
60	}
61
62	return this;	195✔
63	}
64
65	getSize() {
66	return 12;	195✔
67	}
68
69	write(bw) {
70	let flags = 0;	195✔
71
72	if (this.spv)	195✔
73	flags \|= 1 << 0;	11✔
74
75	if (this.prune)	195✔
76	flags \|= 1 << 1;	8✔
77
78	if (this.indexTX)	195✔
79	flags \|= 1 << 2;	3✔
80
81	if (this.indexAddress)	195✔
82	flags \|= 1 << 3;	2✔
83
84	bw.writeU32(this.network.magic);	195✔
85	bw.writeU32(flags);	195✔
86	bw.writeU32(0);	195✔
87
88	return bw;	195✔
89	}
90
91	read(br) {
92	this.network = Network.fromMagic(br.readU32());	109✔
93
94	const flags = br.readU32();	109✔
95
96	this.spv = (flags & 1) !== 0;	109✔
97	this.prune = (flags & 2) !== 0;	109✔
98	this.indexTX = (flags & 4) !== 0;	109✔
99	this.indexAddress = (flags & 8) !== 0;	109✔
100
101	return this;	109✔
102	}
103	}
104
105	/**
106	* Chain State
107	*/
108
109	class ChainState extends bio.Struct {
110	/**
111	* Create chain state.
112	* @alias module:blockchain.ChainState
113	* @constructor
114	*/
115
116	constructor() {
117	super();	24,045✔
118	this.tip = consensus.ZERO_HASH;	24,045✔
119	this.tx = 0;	24,045✔
120	this.coin = 0;	24,045✔
121	this.value = 0;	24,045✔
122	this.burned = 0;	24,045✔
123	this.committed = false;	24,045✔
124	}
125
126	inject(state) {
127	this.tip = state.tip;	23,776✔
128	this.tx = state.tx;	23,776✔
129	this.coin = state.coin;	23,776✔
130	this.value = state.value;	23,776✔
131	this.burned = state.burned;	23,776✔
132	return this;	23,776✔
133	}
134
135	connect(block) {
136	this.tx += block.txs.length;	18,263✔
137	}
138
139	disconnect(block) {
140	this.tx -= block.txs.length;	2,694✔
141	}
142
143	add(coin) {
144	this.coin += 1;	66,163✔
145	this.value += coin.value;	66,163✔
146	}
147
148	spend(coin) {
149	this.coin -= 1;	46,344✔
150	this.value -= coin.value;	46,344✔
151	}
152
153	burn(coin) {
154	this.coin += 1;	1,649✔
155	this.burned += coin.value;	1,649✔
156	}
157
158	unburn(coin) {
159	this.coin -= 1;	1✔
160	this.burned -= coin.value;	1✔
161	}
162
163	commit(hash) {
164	assert(Buffer.isBuffer(hash));	21,714✔
165	this.tip = hash;	21,714✔
166	this.committed = true;	21,714✔
167	return this.encode();	21,714✔
168	}
169
170	getSize() {
171	return 64;	21,714✔
172	}
173
174	write(bw) {
175	bw.writeHash(this.tip);	21,714✔
176	bw.writeU64(this.tx);	21,714✔
177	bw.writeU64(this.coin);	21,714✔
178	bw.writeU64(this.value);	21,714✔
179	bw.writeU64(this.burned);	21,714✔
180	return bw;	21,714✔
181	}
182
183	read(br) {
184	this.tip = br.readHash();	43✔
185	this.tx = br.readU64();	43✔
186	this.coin = br.readU64();	43✔
187	this.value = br.readU64();	43✔
188	this.burned = br.readU64();	43✔
189	return this;	43✔
190	}
191	}
192
193	/**
194	* State Cache
195	*/
196
197	class StateCache {
198	/**
199	* Create state cache.
200	* @alias module:blockchain.StateCache
201	* @constructor
202	*/
203
204	constructor(network) {
205	this.network = network;	269✔
206	this.bits = [];	269✔
207	this.updates = [];	269✔
208	this.init();	269✔
209	}
210
211	init() {
212	for (let i = 0; i < 32; i++)	269✔
213	this.bits.push(null);	8,608✔
214
215	for (const {bit} of this.network.deploys) {	269✔
216	assert(!this.bits[bit]);	807✔
217	this.bits[bit] = new BufferMap();	807✔
218	}
219	}
220
221	set(bit, entry, state) {
222	const cache = this.bits[bit];	258✔
223
224	assert(cache);	258✔
225
226	if (cache.get(entry.hash) !== state) {	258!
227	cache.set(entry.hash, state);	258✔
228	this.updates.push(new CacheUpdate(bit, entry.hash, state));	258✔
229	}
230	}
231
232	get(bit, entry) {
233	const cache = this.bits[bit];	74,095✔
234
235	assert(cache);	74,095✔
236
237	const state = cache.get(entry.hash);	74,095✔
238
239	if (state == null)	74,095✔
240	return -1;	258✔
241
242	return state;	73,837✔
243	}
244
245	commit() {
246	this.updates.length = 0;	23,765✔
247	}
248
249	drop() {
250	for (const {bit, hash} of this.updates) {	3✔
NEW 251	const cache = this.bits[bit];	×
NEW 252	assert(cache);	×
NEW 253	cache.delete(hash);	×
254	}
255
256	this.updates.length = 0;	3✔
257	}
258
259	insert(bit, hash, state) {
260	const cache = this.bits[bit];	30✔
261	assert(cache);	30✔
262	cache.set(hash, state);	30✔
263	}
264	}
265
266	/**
267	* Cache Update
268	*/
269
270	class CacheUpdate {
271	/**
272	* Create cache update.
273	* @constructor
274	* @ignore
275	*/
276
277	constructor(bit, hash, state) {
278	this.bit = bit;	258✔
279	this.hash = hash;	258✔
280	this.state = state;	258✔
281	}
282
283	encode() {
284	const data = Buffer.allocUnsafe(1);	256✔
285	data[0] = this.state;	256✔
286	return data;	256✔
287	}
288	}
289
290	/**
291	* Tree related state.
292	*/
293
294	class TreeState extends bio.Struct {
295	/**
296	* Create tree state.
297	* @constructor
298	* @ignore
299	*/
300
301	constructor() {
302	super();	24,321✔
303	this.treeRoot = consensus.ZERO_HASH;	24,321✔
304	this.commitHeight = 0;	24,321✔
305	this.compactionRoot = consensus.ZERO_HASH;	24,321✔
306	this.compactionHeight = 0;	24,321✔
307
308	this.committed = false;	24,321✔
309	}
310
311	inject(state) {
312	this.treeRoot = state.treeRoot;	23,772✔
313	this.commitHeight = state.treeHeight;	23,772✔
314	this.compactionHeight = state.compactionHeight;	23,772✔
315	this.compactionRoot = state.compactionRoot;	23,772✔
316
317	return this;	23,772✔
318	}
319
320	compact(hash, height) {
321	assert(Buffer.isBuffer(hash));	25✔
322	assert((height >>> 0) === height);	25✔
323
324	this.compactionRoot = hash;	25✔
325	this.compactionHeight = height;	25✔
326	};
327
328	commit(hash, height) {
329	assert(Buffer.isBuffer(hash));	4,673✔
330	assert((height >>> 0) === height);	4,673✔
331
332	this.treeRoot = hash;	4,673✔
333	this.commitHeight = height;	4,673✔
334	this.committed = true;	4,673✔
335	return this.encode();	4,673✔
336	}
337
338	getSize() {
339	return 72;	4,675✔
340	}
341
342	write(bw) {
343	bw.writeHash(this.treeRoot);	4,675✔
344	bw.writeU32(this.commitHeight);	4,675✔
345	bw.writeHash(this.compactionRoot);	4,675✔
346	bw.writeU32(this.compactionHeight);	4,675✔
347
348	return bw;	4,675✔
349	}
350
351	read(br) {
352	this.treeRoot = br.readHash();	323✔
353	this.commitHeight = br.readU32();	323✔
354	this.compactionRoot = br.readHash();	323✔
355	this.compactionHeight = br.readU32();	323✔
356
357	return this;	323✔
358	}
359	}
360
361	/*
362	* Expose
363	*/
364
365	exports.ChainFlags = ChainFlags;	1✔
366	exports.ChainState = ChainState;	1✔
367	exports.StateCache = StateCache;	1✔
368	exports.TreeState = TreeState;	1✔
369	exports.CacheUpdate = CacheUpdate;	1✔

handshake-org / hsd / 10059963428

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