10562004069

Committed 26 Aug 2024 02:49PM UTC coverage: 69.891% (+0.09%) from 69.802%

Build # 10562004069

Build Type

Pull #900

github

Committed by

web-flow

Commit Message

Merge 15bedd8d2 into 9ddb69e2b

Pull Request Pull Request #900: Update migrations

Run Details

7734 of 12889 branches covered (60.0%)

Branch coverage included in aggregate %.

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

15 existing lines in 6 files now uncovered.

24622 of 33406 relevant lines covered (73.71%)

34119.56 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();	373✔
28
29	this.network = Network.primary;	373✔
30	this.spv = false;	373✔
31	this.prune = false;	373✔
32	this.indexTX = false;	373✔
33	this.indexAddress = false;	373✔
34
35	if (options)	373!
NEW 36	this.fromOptions(options);	×
37	}
38
39	fromOptions(options) {
40	this.network = Network.get(options.network);	210✔
41
42	if (options.spv != null) {	210!
43	assert(typeof options.spv === 'boolean');	210✔
44	this.spv = options.spv;	210✔
45	}
46
47	if (options.prune != null) {	210!
48	assert(typeof options.prune === 'boolean');	210✔
49	this.prune = options.prune;	210✔
50	}
51
52	if (options.indexTX != null) {	210!
53	assert(typeof options.indexTX === 'boolean');	210✔
54	this.indexTX = options.indexTX;	210✔
55	}
56
57	if (options.indexAddress != null) {	210!
58	assert(typeof options.indexAddress === 'boolean');	210✔
59	this.indexAddress = options.indexAddress;	210✔
60	}
61
62	return this;	210✔
63	}
64
65	getSize() {
66	return 12;	210✔
67	}
68
69	write(bw) {
70	let flags = 0;	210✔
71
72	if (this.spv)	210✔
73	flags \|= 1 << 0;	12✔
74
75	if (this.prune)	210✔
76	flags \|= 1 << 1;	8✔
77
78	if (this.indexTX)	210✔
79	flags \|= 1 << 2;	3✔
80
81	if (this.indexAddress)	210✔
82	flags \|= 1 << 3;	2✔
83
84	bw.writeU32(this.network.magic);	210✔
85	bw.writeU32(flags);	210✔
86	bw.writeU32(0);	210✔
87
88	return bw;	210✔
89	}
90
91	read(br) {
92	this.network = Network.fromMagic(br.readU32());	163✔
93
94	const flags = br.readU32();	163✔
95
96	this.spv = (flags & 1) !== 0;	163✔
97	this.prune = (flags & 2) !== 0;	163✔
98	this.indexTX = (flags & 4) !== 0;	163✔
99	this.indexAddress = (flags & 8) !== 0;	163✔
100
101	return this;	163✔
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();	25,341✔
118	this.tip = consensus.ZERO_HASH;	25,341✔
119	this.tx = 0;	25,341✔
120	this.coin = 0;	25,341✔
121	this.value = 0;	25,341✔
122	this.burned = 0;	25,341✔
123	this.committed = false;	25,341✔
124	}
125
126	inject(state) {
127	this.tip = state.tip;	25,003✔
128	this.tx = state.tx;	25,003✔
129	this.coin = state.coin;	25,003✔
130	this.value = state.value;	25,003✔
131	this.burned = state.burned;	25,003✔
132	return this;	25,003✔
133	}
134
135	connect(block) {
136	this.tx += block.txs.length;	19,155✔
137	}
138
139	disconnect(block) {
140	this.tx -= block.txs.length;	2,819✔
141	}
142
143	add(coin) {
144	this.coin += 1;	67,310✔
145	this.value += coin.value;	67,310✔
146	}
147
148	spend(coin) {
149	this.coin -= 1;	46,584✔
150	this.value -= coin.value;	46,584✔
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));	22,796✔
165	this.tip = hash;	22,796✔
166	this.committed = true;	22,796✔
167	return this.encode();	22,796✔
168	}
169
170	getSize() {
171	return 64;	22,796✔
172	}
173
174	write(bw) {
175	bw.writeHash(this.tip);	22,796✔
176	bw.writeU64(this.tx);	22,796✔
177	bw.writeU64(this.coin);	22,796✔
178	bw.writeU64(this.value);	22,796✔
179	bw.writeU64(this.burned);	22,796✔
180	return bw;	22,796✔
181	}
182
183	read(br) {
184	this.tip = br.readHash();	70✔
185	this.tx = br.readU64();	70✔
186	this.coin = br.readU64();	70✔
187	this.value = br.readU64();	70✔
188	this.burned = br.readU64();	70✔
189	return this;	70✔
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;	338✔
206	this.bits = [];	338✔
207	this.updates = [];	338✔
208	this.init();	338✔
209	}
210
211	init() {
212	for (let i = 0; i < 32; i++)	338✔
213	this.bits.push(null);	10,816✔
214
215	for (const {bit} of this.network.deploys) {	338✔
216	assert(!this.bits[bit]);	1,014✔
217	this.bits[bit] = new BufferMap();	1,014✔
218	}
219	}
220
221	set(bit, entry, state) {
222	const cache = this.bits[bit];	264✔
223
224	assert(cache);	264✔
225
226	if (cache.get(entry.hash) !== state) {	264!
227	cache.set(entry.hash, state);	264✔
228	this.updates.push(new CacheUpdate(bit, entry.hash, state));	264✔
229	}
230	}
231
232	get(bit, entry) {
233	const cache = this.bits[bit];	74,135✔
234
235	assert(cache);	74,135✔
236
237	const state = cache.get(entry.hash);	74,135✔
238
239	if (state == null)	74,135✔
240	return -1;	264✔
241
242	return state;	73,871✔
243	}
244
245	commit() {
246	this.updates.length = 0;	24,992✔
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;	264✔
279	this.hash = hash;	264✔
280	this.state = state;	264✔
281	}
282
283	encode() {
284	const data = Buffer.allocUnsafe(1);	262✔
285	data[0] = this.state;	262✔
286	return data;	262✔
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();	25,648✔
303	this.treeRoot = consensus.ZERO_HASH;	25,648✔
304	this.commitHeight = 0;	25,648✔
305	this.compactionRoot = consensus.ZERO_HASH;	25,648✔
306	this.compactionHeight = 0;	25,648✔
307
308	this.committed = false;	25,648✔
309	}
310
311	inject(state) {
312	this.treeRoot = state.treeRoot;	24,999✔
313	this.commitHeight = state.treeHeight;	24,999✔
314	this.compactionHeight = state.compactionHeight;	24,999✔
315	this.compactionRoot = state.compactionRoot;	24,999✔
316
317	return this;	24,999✔
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,882✔
330	assert((height >>> 0) === height);	4,882✔
331
332	this.treeRoot = hash;	4,882✔
333	this.commitHeight = height;	4,882✔
334	this.committed = true;	4,882✔
335	return this.encode();	4,882✔
336	}
337
338	getSize() {
339	return 72;	4,884✔
340	}
341
342	write(bw) {
343	bw.writeHash(this.treeRoot);	4,884✔
344	bw.writeU32(this.commitHeight);	4,884✔
345	bw.writeHash(this.compactionRoot);	4,884✔
346	bw.writeU32(this.compactionHeight);	4,884✔
347
348	return bw;	4,884✔
349	}
350
351	read(br) {
352	this.treeRoot = br.readHash();	381✔
353	this.commitHeight = br.readU32();	381✔
354	this.compactionRoot = br.readHash();	381✔
355	this.compactionHeight = br.readU32();	381✔
356
357	return this;	381✔
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 / 10562004069

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