8438742178

Committed 26 Mar 2024 03:36PM UTC coverage: 68.991% (+0.4%) from 68.632%

Build # 8438742178

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge d56955923 into 0a4f24bdb

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

Run Details

7676 of 12970 branches covered (59.18%)

Branch coverage included in aggregate %.

436 of 467 new or added lines in 11 files covered. (93.36%)

5 existing lines in 4 files now uncovered.

24471 of 33626 relevant lines covered (72.77%)

33880.95 hits per line

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

13.11

/lib/wallet/client.js

/*!
 * client.js - http client for wallets
 * Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
 * https://github.com/handshake-org/hsd
 */

'use strict';

const assert = require('bsert');
const NodeClient = require('../client/node');
const TX = require('../primitives/tx');
const Coin = require('../primitives/coin');
const NameState = require('../covenants/namestate');
const {encoding} = require('bufio');

const parsers = {
  'block connect': (entry, txs) => parseBlock(entry, txs),
  'block disconnect': entry => [parseEntry(entry)],
  'block rescan': (entry, txs) => parseBlock(entry, txs),
  'chain reset': entry => [parseEntry(entry)],
  'tx': tx => [TX.decode(tx)]
};

class WalletClient extends NodeClient {
  constructor(options) {
    super(options);
  }

  bind(event, handler) {
    const parser = parsers[event];

    if (!parser) {
      super.bind(event, handler);
      return;
    }

    super.bind(event, (...args) => {
      return handler(...parser(...args));
    });
  }

  hook(event, handler) {
    const parser = parsers[event];

    if (!parser) {
      super.hook(event, handler);
      return;
    }

    super.hook(event, (...args) => {
      return handler(...parser(...args));
    });
  }

  async getTip() {
    return parseEntry(await super.getTip());
  }

  async getEntry(block) {
    if (Buffer.isBuffer(block))
      block = block.toString('hex');

    return parseEntry(await super.getEntry(block));
  }

  /**
   * Get entries.
   * @param {Number} [start=-1]
   * @param {Number} [end=-1]
   * @returns {Promise<Object[]>}
   */

  async getEntries(start, end) {
    const entries = await super.getEntries(start, end);
    return entries.map(parseEntry);
  }

  async send(tx) {
    return super.send(tx.encode());
  }

  async sendClaim(claim) {
    return super.sendClaim(claim.encode());
  }

  async setFilter(filter) {
    return super.setFilter(filter.encode());
  }

  async rescan(start) {
    return super.rescan(start);
  }

  async getNameStatus(nameHash) {
    const json = await super.getNameStatus(nameHash);
    return NameState.fromJSON(json);
  }

  async getCoin(hash, index) {
    const json = super.getCoin(hash, index);
    return Coin.fromJSON(json);
  }
}

/*
 * Helpers
 */

function parseEntry(data) {
  if (!data)
    return null;

  // 32  hash
  // 4   height
  // 4   nonce
  // 8   time
  // 32  prev
  // 32  tree
  // 24  extranonce
  // 32  reserved
  // 32  witness
  // 32  merkle
  // 4   version
  // 4   bits
  // 32  mask
  // 32  chainwork
  // 304 TOTAL

  assert(Buffer.isBuffer(data));
  // Just enough to read the three data below
  assert(data.length >= 48);

  const hash = data.slice(0, 32);
  const height = encoding.readU32(data, 32);
  // skip nonce 4.
  const time = encoding.readU64(data, 40);

  return {
    hash,
    height,
    time
  };
}

function parseBlock(entry, txs) {
  const block = parseEntry(entry);
  const out = [];

  for (const tx of txs)
    out.push(TX.decode(tx));

  return [block, out];
}

/*
 * Expose
 */

module.exports = WalletClient;

1	/*!
2	* client.js - http client for wallets
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 NodeClient = require('../client/node');	1✔
11	const TX = require('../primitives/tx');	1✔
12	const Coin = require('../primitives/coin');	1✔
13	const NameState = require('../covenants/namestate');	1✔
14	const {encoding} = require('bufio');	1✔
15
16	const parsers = {	1✔
17	'block connect': (entry, txs) => parseBlock(entry, txs),	×
18	'block disconnect': entry => [parseEntry(entry)],	×
19	'block rescan': (entry, txs) => parseBlock(entry, txs),	×
20	'chain reset': entry => [parseEntry(entry)],	×
21	'tx': tx => [TX.decode(tx)]	×
22	};
23
24	class WalletClient extends NodeClient {
25	constructor(options) {
26	super(options);	×
27	}
28
29	bind(event, handler) {
30	const parser = parsers[event];	×
31
32	if (!parser) {	×
33	super.bind(event, handler);	×
34	return;	×
35	}
36
37	super.bind(event, (...args) => {	×
38	return handler(...parser(...args));	×
39	});
40	}
41
42	hook(event, handler) {
43	const parser = parsers[event];	×
44
45	if (!parser) {	×
46	super.hook(event, handler);	×
47	return;	×
48	}
49
50	super.hook(event, (...args) => {	×
51	return handler(...parser(...args));	×
52	});
53	}
54
55	async getTip() {
56	return parseEntry(await super.getTip());	×
57	}
58
59	async getEntry(block) {
60	if (Buffer.isBuffer(block))	×
61	block = block.toString('hex');	×
62
63	return parseEntry(await super.getEntry(block));	×
64	}
65
66	/**
67	* Get entries.
68	* @param {Number} [start=-1]
69	* @param {Number} [end=-1]
70	* @returns {Promise<Object[]>}
71	*/
72
73	async getEntries(start, end) {
NEW 74	const entries = await super.getEntries(start, end);	×
NEW 75	return entries.map(parseEntry);	×
76	}
77
78	async send(tx) {
79	return super.send(tx.encode());	×
80	}
81
82	async sendClaim(claim) {
83	return super.sendClaim(claim.encode());	×
84	}
85
86	async setFilter(filter) {
87	return super.setFilter(filter.encode());	×
88	}
89
90	async rescan(start) {
91	return super.rescan(start);	×
92	}
93
94	async getNameStatus(nameHash) {
95	const json = await super.getNameStatus(nameHash);	×
96	return NameState.fromJSON(json);	×
97	}
98
99	async getCoin(hash, index) {
100	const json = super.getCoin(hash, index);	×
101	return Coin.fromJSON(json);	×
102	}
103	}
104
105	/*
106	* Helpers
107	*/
108
109	function parseEntry(data) {
NEW 110	if (!data)	×
NEW 111	return null;	×
112
113	// 32 hash
114	// 4 height
115	// 4 nonce
116	// 8 time
117	// 32 prev
118	// 32 tree
119	// 24 extranonce
120	// 32 reserved
121	// 32 witness
122	// 32 merkle
123	// 4 version
124	// 4 bits
125	// 32 mask
126	// 32 chainwork
127	// 304 TOTAL
128
129	assert(Buffer.isBuffer(data));	×
130	// Just enough to read the three data below
NEW 131	assert(data.length >= 48);	×
132
NEW 133	const hash = data.slice(0, 32);	×
NEW 134	const height = encoding.readU32(data, 32);	×
135	// skip nonce 4.
NEW 136	const time = encoding.readU64(data, 40);	×
137
138	return {	×
139	hash,
140	height,
141	time
142	};
143	}
144
145	function parseBlock(entry, txs) {
146	const block = parseEntry(entry);	×
147	const out = [];	×
148
149	for (const tx of txs)	×
150	out.push(TX.decode(tx));	×
151
152	return [block, out];	×
153	}
154
155	/*
156	* Expose
157	*/
158
159	module.exports = WalletClient;	1✔

handshake-org / hsd / 8438742178

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