@dashevo/dash-spv 1.1.8 → 2.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.mocharc.yml +3 -0
- package/.ultra.cache.json +1 -0
- package/config/config.js +14 -7
- package/index.js +4 -0
- package/lib/blockstore.js +0 -1
- package/lib/consensus.js +36 -33
- package/lib/errors/SPVError.js +8 -0
- package/lib/merkleproofs.js +2 -2
- package/lib/spvchain.js +253 -205
- package/lib/test/.eslintrc +9 -0
- package/lib/test/bootstrap.js +15 -0
- package/lib/x11.js +27 -0
- package/package.json +12 -8
- package/test/data/headers.js +1 -1
- package/test/index.js +60 -56
- package/test/spvchain.js +79 -0
package/.mocharc.yml
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"files":{".eslintignore":"5772aab4a649e8c99c5b74bd685792cd6a69f9ac",".eslintrc.json":"41aa1d3c1477f203b588dcb5c0015454edd94481",".gitignore":"095d365a56f423d4fab2345c95c137e7c6ea45c0",".mocharc.yml":"f6d924f143da5bc22530e55dcec6922aff69d8e1","LICENSE":"95bf3c7cb642fb61c1bbbb319fd3c83e47a5af96","README.md":"3659fd1bfb44b5e6916679ae586ccbff18683e59","config/config.js":"267c3536b5fe54c88080a56241c34d7393a54ac2","index.js":"4413accedb71ffb73ea7ce4ad45a2035c2ce92ca","lib/blockstore.js":"1ed82a8c1cfb4bc3aa96f0669a27c94d2e76b164","lib/consensus.js":"73201c7fec9c62f5f87dba7b2d0d54c08fa4fa6f","lib/errors/SPVError.js":"08b7af972c146bcdf29ffaa06eb90ca2c5660914","lib/merkleproofs.js":"dca09952c352109795af64f9490209a96e483e2f","lib/spvchain.js":"4ada79dda7b544debbfc023c1ce5ad058bb0c034","lib/test/.eslintrc":"4c2b11fe8177c0c2fd0667acb599fc44c4c9741a","lib/test/bootstrap.js":"e2b2b2b17a9bf0ebff7721d8cb1e5cb75efb0f0f","lib/utils.js":"c2119b88a67698053e783f09c038a04ae208f232","lib/x11.js":"d85e555bad579a8b3e2e92447331933ce9b0c4b1","package.json":"7eaf8ec7ae8bff681e2ab55442e0cc784058ea7c","test/data/headers.js":"eb9cae85ee11027338fbf1f69e373d22388286d6","test/data/merkleproofs.js":"49ea4c29fb1f0cf6378ed7ee46b0a1db3bb555c1","test/data/rawHeaders.js":"03fed6ca2f8c2d1b63cfa13743431a2d551c7ad9","test/index.js":"4b67c838fadf0baac0207b13ddd99b0bc8d228c0","test/spvchain.js":"58a7716c91830e0a23bd27ab857cbba70b8bee93"},"deps":{}}
|
package/config/config.js
CHANGED
|
@@ -30,9 +30,9 @@ module.exports = {
|
|
|
30
30
|
version: 1,
|
|
31
31
|
previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
|
|
32
32
|
merkleroot: 'e0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7',
|
|
33
|
-
time:
|
|
34
|
-
bits: '
|
|
35
|
-
nonce:
|
|
33
|
+
time: 1417713337,
|
|
34
|
+
bits: '207fffff',
|
|
35
|
+
nonce: 1096447,
|
|
36
36
|
});
|
|
37
37
|
},
|
|
38
38
|
getRegtestGenesis() {
|
|
@@ -40,12 +40,19 @@ module.exports = {
|
|
|
40
40
|
version: 1,
|
|
41
41
|
previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
|
|
42
42
|
merkleroot: 'e0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7',
|
|
43
|
-
time:
|
|
44
|
-
bits: '
|
|
45
|
-
nonce:
|
|
43
|
+
time: 1417713337,
|
|
44
|
+
bits: '207fffff',
|
|
45
|
+
nonce: 1096447,
|
|
46
46
|
});
|
|
47
47
|
},
|
|
48
48
|
getLivenetGenesis() {
|
|
49
|
-
|
|
49
|
+
return utils.normalizeHeader({
|
|
50
|
+
version: 1,
|
|
51
|
+
previousblockhash: '0000000000000000000000000000000000000000000000000000000000000000',
|
|
52
|
+
merkleroot: 'e0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7',
|
|
53
|
+
time: 1390095618,
|
|
54
|
+
bits: '1e0ffff0',
|
|
55
|
+
nonce: 28917698,
|
|
56
|
+
});
|
|
50
57
|
},
|
|
51
58
|
};
|
package/index.js
CHANGED
|
@@ -1,7 +1,11 @@
|
|
|
1
1
|
const spvChain = require('./lib/spvchain');
|
|
2
2
|
const merkleProof = require('./lib/merkleproofs');
|
|
3
|
+
const genesis = require('./config/config');
|
|
4
|
+
const SPVError = require('./lib/errors/SPVError');
|
|
3
5
|
|
|
4
6
|
module.exports = {
|
|
5
7
|
SpvChain: spvChain,
|
|
6
8
|
MerkleProof: merkleProof,
|
|
9
|
+
genesis,
|
|
10
|
+
SPVError,
|
|
7
11
|
};
|
package/lib/blockstore.js
CHANGED
package/lib/consensus.js
CHANGED
|
@@ -1,43 +1,46 @@
|
|
|
1
|
-
const { hasValidTarget } = require('@dashevo/dark-gravity-wave');
|
|
1
|
+
// const { hasValidTarget } = require('@dashevo/dark-gravity-wave');
|
|
2
2
|
const merkleProofs = require('./merkleproofs');
|
|
3
|
-
const utils = require('./utils');
|
|
3
|
+
// const utils = require('./utils');
|
|
4
4
|
|
|
5
|
-
const MIN_TIMESTAMP_HEADERS = 11;
|
|
6
|
-
const MIN_DGW_HEADERS = 24;
|
|
5
|
+
// const MIN_TIMESTAMP_HEADERS = 11;
|
|
6
|
+
// const MIN_DGW_HEADERS = 24;
|
|
7
7
|
|
|
8
|
-
function getMedianTimestamp(headers) {
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
}
|
|
8
|
+
// function getMedianTimestamp(headers) {
|
|
9
|
+
// const timestamps = headers.map((h) => h.time);
|
|
10
|
+
// const median = (arr) => {
|
|
11
|
+
// const mid = Math.floor(arr.length / 2);
|
|
12
|
+
// const nums = [...arr].sort((a, b) => a - b);
|
|
13
|
+
// return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
|
|
14
|
+
// };
|
|
15
|
+
// return median(timestamps);
|
|
16
|
+
// }
|
|
17
17
|
|
|
18
18
|
// Must be strictly greater than the median time of the previous 11 blocks.
|
|
19
19
|
// https://dash-docs.github.io/en/developer-reference#block-headers
|
|
20
|
-
function hasGreaterThanMedianTimestamp(newHeader, previousHeaders) {
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
}
|
|
20
|
+
// function hasGreaterThanMedianTimestamp(newHeader, previousHeaders) {
|
|
21
|
+
// if (previousHeaders.length < MIN_TIMESTAMP_HEADERS) return true;
|
|
22
|
+
// const headerNormalised = utils.normalizeHeader(newHeader);
|
|
23
|
+
// const normalizedLatestHeaders = previousHeaders.slice(
|
|
24
|
+
// Math.max(previousHeaders.length - MIN_TIMESTAMP_HEADERS, 0),
|
|
25
|
+
// ).map((h) => utils.normalizeHeader(h));
|
|
26
|
+
// return getMedianTimestamp(normalizedLatestHeaders) < headerNormalised.time;
|
|
27
|
+
// }
|
|
28
28
|
|
|
29
|
-
function isValidBlockHeader(newHeader, previousHeaders, network = 'mainnet') {
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
29
|
+
function isValidBlockHeader(/* newHeader, previousHeaders, network = 'mainnet' */) {
|
|
30
|
+
// TODO: implement consensus checks properly for all networks
|
|
31
|
+
return true;
|
|
32
|
+
// if (previousHeaders.length > MIN_DGW_HEADERS) {
|
|
33
|
+
// return newHeader.validProofOfWork()
|
|
34
|
+
// && newHeader.validTimestamp()
|
|
35
|
+
// && hasGreaterThanMedianTimestamp(newHeader, previousHeaders)
|
|
36
|
+
// && hasValidTarget(
|
|
37
|
+
// utils.getDgwBlock(newHeader), previousHeaders.map((h) => utils.getDgwBlock(h)), network,
|
|
38
|
+
// );
|
|
39
|
+
// }
|
|
40
|
+
// // TODO: eventually this check start failing in dashmate
|
|
41
|
+
// return newHeader.validProofOfWork()
|
|
42
|
+
// && newHeader.validTimestamp()
|
|
43
|
+
// && hasGreaterThanMedianTimestamp(newHeader, previousHeaders);
|
|
41
44
|
}
|
|
42
45
|
|
|
43
46
|
/**
|
package/lib/merkleproofs.js
CHANGED
|
@@ -11,10 +11,10 @@ const merkleproofs = {
|
|
|
11
11
|
validateTxProofs: (merkleBlock, transactions) => {
|
|
12
12
|
let txToFilter = transactions.slice();
|
|
13
13
|
if (typeof transactions[0] === 'string') {
|
|
14
|
-
txToFilter = txToFilter.map(tx => DashUtil.toHash(tx).toString('hex'));
|
|
14
|
+
txToFilter = txToFilter.map((tx) => DashUtil.toHash(tx).toString('hex'));
|
|
15
15
|
}
|
|
16
16
|
return merkleBlock.validMerkleTree
|
|
17
|
-
&& txToFilter.filter(tx => merkleBlock.hasTransaction(tx)).length === transactions.length;
|
|
17
|
+
&& txToFilter.filter((tx) => merkleBlock.hasTransaction(tx)).length === transactions.length;
|
|
18
18
|
},
|
|
19
19
|
};
|
|
20
20
|
|
package/lib/spvchain.js
CHANGED
|
@@ -1,124 +1,181 @@
|
|
|
1
|
-
const
|
|
1
|
+
const X11 = require('./x11');
|
|
2
|
+
|
|
2
3
|
const config = require('../config/config');
|
|
3
4
|
const Consensus = require('./consensus');
|
|
4
|
-
const utils = require('
|
|
5
|
+
const utils = require('./utils');
|
|
6
|
+
const SPVError = require('./errors/SPVError');
|
|
7
|
+
|
|
8
|
+
const CHAIN_TYPE_NETWORKS = {
|
|
9
|
+
testnet: 'testnet',
|
|
10
|
+
devnet: 'devnet',
|
|
11
|
+
local: 'regtest',
|
|
12
|
+
regtest: 'regtest',
|
|
13
|
+
lowdiff: 'regtest',
|
|
14
|
+
livenet: 'mainnet',
|
|
15
|
+
mainnet: 'mainnet',
|
|
16
|
+
};
|
|
17
|
+
|
|
18
|
+
const createGenesis = (chainType) => {
|
|
19
|
+
switch (chainType) {
|
|
20
|
+
case 'testnet': return config.getTestnetGenesis();
|
|
21
|
+
case 'devnet': return config.getDevnetGenesis();
|
|
22
|
+
case 'local':
|
|
23
|
+
case 'regtest': return config.getRegtestGenesis();
|
|
24
|
+
case 'livenet':
|
|
25
|
+
case 'mainnet': return config.getLivenetGenesis();
|
|
26
|
+
case 'lowdiff': return config.getLowDiffGenesis();
|
|
27
|
+
default: throw new SPVError(`Unsupported chain type ${chainType}`);
|
|
28
|
+
}
|
|
29
|
+
};
|
|
5
30
|
|
|
6
31
|
const SpvChain = class {
|
|
7
|
-
constructor(chainType, confirms = 100
|
|
8
|
-
this.root = null;
|
|
9
|
-
this.allBranches = [];
|
|
10
|
-
this.orphanBlocks = [];
|
|
11
|
-
this.orphanChunks = [];
|
|
32
|
+
constructor(chainType, confirms = 100) {
|
|
12
33
|
this.confirmsBeforeFinal = confirms;
|
|
13
|
-
this.
|
|
14
|
-
this.
|
|
34
|
+
this.network = CHAIN_TYPE_NETWORKS[chainType];
|
|
35
|
+
if (!this.network) {
|
|
36
|
+
throw new SPVError(`Unsupported chain type "${chainType}"`);
|
|
37
|
+
}
|
|
38
|
+
this.genesis = createGenesis(chainType);
|
|
39
|
+
|
|
40
|
+
this.reset();
|
|
15
41
|
}
|
|
16
42
|
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
this.root = config.getLowDiffGenesis();
|
|
66
|
-
break;
|
|
67
|
-
default:
|
|
68
|
-
if (startBlock) {
|
|
69
|
-
this.root = startBlock;
|
|
70
|
-
this.network = 'mainnet';
|
|
71
|
-
} else {
|
|
72
|
-
throw new Error('Unhandled chaintype or startBlock not provided');
|
|
73
|
-
}
|
|
74
|
-
break;
|
|
43
|
+
static async wasmX11Ready() {
|
|
44
|
+
return X11.load();
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
reset() {
|
|
48
|
+
this.allBranches = [[]];
|
|
49
|
+
this.orphanChunks = [];
|
|
50
|
+
this.prunedHeaders = [];
|
|
51
|
+
|
|
52
|
+
this.hashesByHeight = new Map();
|
|
53
|
+
this.heightByHash = new Map();
|
|
54
|
+
this.orphansHashes = new Set();
|
|
55
|
+
// Height of the first header in the chain.
|
|
56
|
+
// 0 - if we are synchronizing from genesis
|
|
57
|
+
// > 0 if part of the chain is pruned and we are synchronizing from checkpoint where
|
|
58
|
+
this.startBlockHeight = null;
|
|
59
|
+
|
|
60
|
+
// Head of pending first header.
|
|
61
|
+
// Used in situations where we don't know root in advance
|
|
62
|
+
this.pendingStartBlockHeight = null;
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
/**
|
|
66
|
+
* Initializes chain with a start block and height
|
|
67
|
+
* - When no arguments provided, chain is initialized from genesis block
|
|
68
|
+
* - If startBlock is provided, height must be provided as well
|
|
69
|
+
* @param {BlockHeader} [startBlock]
|
|
70
|
+
* @param {number} [height]
|
|
71
|
+
*/
|
|
72
|
+
initialize(startBlock, height) {
|
|
73
|
+
if (!X11.ready()) {
|
|
74
|
+
throw new SPVError('X11 wasm not ready, call wasmX11Ready() first');
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
if (this.startBlockHeight !== null) {
|
|
78
|
+
throw new SPVError('Chain already initialized');
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
if (startBlock && typeof height === 'number') {
|
|
82
|
+
// eslint-disable-next-line
|
|
83
|
+
startBlock = utils.normalizeHeader(startBlock);
|
|
84
|
+
} else if (!startBlock && typeof height !== 'number') {
|
|
85
|
+
// eslint-disable-next-line
|
|
86
|
+
startBlock = this.genesis;
|
|
87
|
+
// eslint-disable-next-line
|
|
88
|
+
height = 0;
|
|
89
|
+
} else {
|
|
90
|
+
throw new SPVError('Initialization error, please provide both startBlock and height');
|
|
75
91
|
}
|
|
76
|
-
|
|
77
|
-
this.
|
|
92
|
+
|
|
93
|
+
this.startBlockHeight = height;
|
|
94
|
+
this.hashesByHeight = new Map([[height, startBlock.hash]]);
|
|
95
|
+
this.heightByHash = new Map([[startBlock.hash, height]]);
|
|
96
|
+
this.setAllBranches(startBlock);
|
|
78
97
|
}
|
|
79
98
|
|
|
80
|
-
|
|
81
|
-
|
|
99
|
+
initialized() {
|
|
100
|
+
return this.startBlockHeight !== null || this.pendingStartBlockHeight !== null;
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
validate() {
|
|
82
104
|
const longestChain = this.getLongestChain();
|
|
105
|
+
if (!longestChain.length) {
|
|
106
|
+
throw new SPVError('Empty SPV chain');
|
|
107
|
+
}
|
|
108
|
+
const head = longestChain[longestChain.length - 1];
|
|
109
|
+
const tail = this.prunedHeaders[0] || longestChain[0];
|
|
110
|
+
|
|
111
|
+
const headHeight = this.heightByHash.get(head.hash);
|
|
112
|
+
const tailHeight = this.heightByHash.get(tail.hash);
|
|
113
|
+
|
|
114
|
+
if (this.orphanChunks.length) {
|
|
115
|
+
throw new SPVError('Chain contains orphan chunks');
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
if (typeof headHeight !== 'number') {
|
|
119
|
+
throw new SPVError(`Head header '${head.hash}' height is invalid ${headHeight}`);
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
if (typeof tailHeight !== 'number') {
|
|
123
|
+
throw new SPVError(`Tail header '${tail.hash}' height is invalid ${tailHeight}`);
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
if (this.hashesByHeight.get(headHeight) !== head.hash) {
|
|
127
|
+
throw new SPVError(`Head header '${head.hash}' height mismatch`);
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
if (this.hashesByHeight.get(tailHeight) !== tail.hash) {
|
|
131
|
+
throw new SPVError(`Tail header '${tail.hash}' height mismatch`);
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
const expectedChainLength = headHeight - tailHeight + 1;
|
|
135
|
+
const actualChainLength = longestChain.length + this.prunedHeaders.length;
|
|
83
136
|
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
// Children discarded as stale branches
|
|
87
|
-
delete pruneBlock.orphan;
|
|
88
|
-
this.store.put(pruneBlock);
|
|
137
|
+
if (expectedChainLength !== actualChainLength) {
|
|
138
|
+
throw new SPVError(`Chain length mismatch: expected ${expectedChainLength}, actual ${actualChainLength}`);
|
|
89
139
|
}
|
|
90
140
|
}
|
|
91
141
|
|
|
92
142
|
/** @private */
|
|
93
|
-
|
|
94
|
-
const
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
}
|
|
102
|
-
return null;
|
|
143
|
+
checkPruneBlocks() {
|
|
144
|
+
const longestChain = this.getLongestChain();
|
|
145
|
+
|
|
146
|
+
longestChain
|
|
147
|
+
.splice(0, longestChain.length - this.confirmsBeforeFinal)
|
|
148
|
+
.forEach((header) => {
|
|
149
|
+
this.prunedHeaders.push(header);
|
|
150
|
+
});
|
|
103
151
|
}
|
|
104
152
|
|
|
105
153
|
/** @private */
|
|
106
|
-
setAllBranches(node
|
|
154
|
+
setAllBranches(node, branch = []) {
|
|
155
|
+
if (!node) {
|
|
156
|
+
throw new SPVError('Root node for a branch is not defined');
|
|
157
|
+
}
|
|
158
|
+
|
|
107
159
|
this.allBranches = [];
|
|
108
160
|
branch.push(node);
|
|
109
161
|
|
|
110
|
-
|
|
111
|
-
this.setAllBranches(c, Array.from(branch));
|
|
112
|
-
});
|
|
113
|
-
|
|
114
|
-
if (node.children.length === 0) {
|
|
115
|
-
this.allBranches.push(branch);
|
|
116
|
-
}
|
|
162
|
+
this.allBranches.push(branch);
|
|
117
163
|
}
|
|
118
164
|
|
|
119
165
|
/** @private */
|
|
120
166
|
appendHeadersToLongestChain(headers) {
|
|
121
|
-
const
|
|
167
|
+
const longestChain = this.getLongestChain();
|
|
168
|
+
const lastHeight = this.startBlockHeight
|
|
169
|
+
+ longestChain.length + this.prunedHeaders.length;
|
|
170
|
+
|
|
171
|
+
headers.forEach((header, i) => {
|
|
172
|
+
const height = lastHeight + i;
|
|
173
|
+
this.hashesByHeight.set(height, header.hash);
|
|
174
|
+
this.heightByHash.set(header.hash, height);
|
|
175
|
+
});
|
|
176
|
+
|
|
177
|
+
const newLongestChain = longestChain.concat(headers);
|
|
178
|
+
|
|
122
179
|
this.allBranches = [];
|
|
123
180
|
this.allBranches.push(newLongestChain);
|
|
124
181
|
}
|
|
@@ -129,37 +186,30 @@ const SpvChain = class {
|
|
|
129
186
|
}
|
|
130
187
|
|
|
131
188
|
/** @private */
|
|
132
|
-
isDuplicate(
|
|
133
|
-
return this.
|
|
134
|
-
.concat(this.orphanBlocks.map(orphan => orphan.hash))
|
|
135
|
-
.filter(hash => hash === compareHash).length > 0;
|
|
136
|
-
}
|
|
137
|
-
|
|
138
|
-
/** @private */
|
|
139
|
-
orphanReconnect() {
|
|
140
|
-
for (let i = 0; i < this.orphanBlocks.length; i += 1) {
|
|
141
|
-
const connectionTip = this.findConnection(this.orphanBlocks[i]);
|
|
142
|
-
if (connectionTip) {
|
|
143
|
-
connectionTip.children.push(this.orphanBlocks[i]);
|
|
144
|
-
this.orphanBlocks.splice(i, 1);
|
|
145
|
-
}
|
|
146
|
-
}
|
|
189
|
+
isDuplicate(hash) {
|
|
190
|
+
return this.heightByHash.has(hash) || this.orphansHashes.has(hash);
|
|
147
191
|
}
|
|
148
192
|
|
|
149
193
|
/** @private */
|
|
150
194
|
orphanChunksReconnect() {
|
|
195
|
+
// TODO: consider optimizing with map of { [chunkHeadHash]: chunkIndex }
|
|
196
|
+
// to get rid of sorting and make the whole function of O(n) complexity
|
|
151
197
|
this.orphanChunks.sort((a, b) => a[0].timestamp - b[0].timestamp);
|
|
152
|
-
|
|
153
|
-
|
|
198
|
+
|
|
199
|
+
for (let i = 0; i < this.orphanChunks.length; i += 1) {
|
|
200
|
+
const chunk = this.orphanChunks[i];
|
|
201
|
+
const tipHash = this.getTipHash();
|
|
202
|
+
const chunkPrevHash = utils.getCorrectedHash(chunk[0].prevHash);
|
|
203
|
+
|
|
204
|
+
if (tipHash === chunkPrevHash) {
|
|
154
205
|
this.appendHeadersToLongestChain(chunk);
|
|
155
|
-
|
|
206
|
+
chunk.forEach((header) => {
|
|
207
|
+
this.orphansHashes.delete(header.hash);
|
|
208
|
+
});
|
|
209
|
+
this.orphanChunks.splice(i, 1);
|
|
210
|
+
i -= 1;
|
|
156
211
|
}
|
|
157
|
-
}
|
|
158
|
-
}
|
|
159
|
-
|
|
160
|
-
/** @private */
|
|
161
|
-
getOrphans() {
|
|
162
|
-
return this.orphanBlocks;
|
|
212
|
+
}
|
|
163
213
|
}
|
|
164
214
|
|
|
165
215
|
/** @private */
|
|
@@ -167,17 +217,6 @@ const SpvChain = class {
|
|
|
167
217
|
return this.orphanChunks;
|
|
168
218
|
}
|
|
169
219
|
|
|
170
|
-
/** @private */
|
|
171
|
-
processValidHeader(header) {
|
|
172
|
-
const connection = this.findConnection(header);
|
|
173
|
-
if (connection) {
|
|
174
|
-
connection.children.push(header);
|
|
175
|
-
this.orphanReconnect();
|
|
176
|
-
} else {
|
|
177
|
-
this.orphanBlocks.push(header);
|
|
178
|
-
}
|
|
179
|
-
}
|
|
180
|
-
|
|
181
220
|
/** @private
|
|
182
221
|
* validates a dashcore.BlockHeader object
|
|
183
222
|
*
|
|
@@ -186,8 +225,9 @@ const SpvChain = class {
|
|
|
186
225
|
* @return {boolean}
|
|
187
226
|
*/
|
|
188
227
|
isValid(header, previousHeaders) {
|
|
189
|
-
|
|
190
|
-
|
|
228
|
+
const validBlockHeader = Consensus.isValidBlockHeader(header, previousHeaders, this.network);
|
|
229
|
+
const duplicate = this.isDuplicate(header.hash);
|
|
230
|
+
return !!validBlockHeader && !duplicate;
|
|
191
231
|
}
|
|
192
232
|
|
|
193
233
|
/* eslint-disable no-param-reassign */
|
|
@@ -203,24 +243,23 @@ const SpvChain = class {
|
|
|
203
243
|
if (utils.getCorrectedHash(header.prevHash) !== previousHeader.hash) {
|
|
204
244
|
return false;
|
|
205
245
|
}
|
|
206
|
-
|
|
207
|
-
header.children = [];
|
|
208
|
-
}
|
|
209
|
-
if (!previousHeader.children) {
|
|
210
|
-
previousHeader.children = [];
|
|
211
|
-
}
|
|
212
|
-
previousHeader.children.push(header);
|
|
246
|
+
|
|
213
247
|
return true;
|
|
214
248
|
}
|
|
215
|
-
/* eslint-enable no-param-reassign */
|
|
216
249
|
|
|
217
250
|
/**
|
|
218
|
-
*
|
|
219
|
-
*
|
|
220
|
-
* @
|
|
251
|
+
* Returns the longest chain of headers
|
|
252
|
+
* @param options
|
|
253
|
+
* @returns {*}
|
|
221
254
|
*/
|
|
222
|
-
getLongestChain() {
|
|
223
|
-
|
|
255
|
+
getLongestChain(options = { withPruned: false }) {
|
|
256
|
+
let longestChain = this.allBranches.sort((b1, b2) => b1 < b2)[0];
|
|
257
|
+
|
|
258
|
+
if (options.withPruned) {
|
|
259
|
+
longestChain = this.prunedHeaders.concat(longestChain);
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
return longestChain;
|
|
224
263
|
}
|
|
225
264
|
|
|
226
265
|
/**
|
|
@@ -229,7 +268,8 @@ const SpvChain = class {
|
|
|
229
268
|
* @return {string} hash
|
|
230
269
|
*/
|
|
231
270
|
getTipHash() {
|
|
232
|
-
|
|
271
|
+
const tip = this.getTipHeader();
|
|
272
|
+
return tip && tip.hash;
|
|
233
273
|
}
|
|
234
274
|
|
|
235
275
|
/**
|
|
@@ -248,35 +288,8 @@ const SpvChain = class {
|
|
|
248
288
|
* @return {Object} header
|
|
249
289
|
*/
|
|
250
290
|
getHeader(hash) {
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
if (blockInDB) {
|
|
254
|
-
return blockInDB;
|
|
255
|
-
}
|
|
256
|
-
|
|
257
|
-
return this.getLongestChain().filter(h => h.hash === hash)[0];
|
|
258
|
-
});
|
|
259
|
-
}
|
|
260
|
-
|
|
261
|
-
/**
|
|
262
|
-
* adds a valid header to the tip of the longest spv chain.
|
|
263
|
-
* If it cannot be connected to the tip it gets temporarily
|
|
264
|
-
* added to an orphan array for possible later reconnection
|
|
265
|
-
*
|
|
266
|
-
* @param {Object[]|string[]|buffer[]} header
|
|
267
|
-
* @return {boolean}
|
|
268
|
-
*/
|
|
269
|
-
addHeader(header) {
|
|
270
|
-
const headerNormalised = utils.normalizeHeader(header);
|
|
271
|
-
|
|
272
|
-
if (this.isValid(headerNormalised, this.getLongestChain())) {
|
|
273
|
-
headerNormalised.children = [];
|
|
274
|
-
this.processValidHeader(headerNormalised);
|
|
275
|
-
this.setAllBranches();
|
|
276
|
-
this.checkPruneBlocks();
|
|
277
|
-
return true;
|
|
278
|
-
}
|
|
279
|
-
return false;
|
|
291
|
+
// TODO: perform lookup in pruned headers?
|
|
292
|
+
return this.getLongestChain().filter((h) => h.hash === hash)[0];
|
|
280
293
|
}
|
|
281
294
|
|
|
282
295
|
/**
|
|
@@ -285,45 +298,80 @@ const SpvChain = class {
|
|
|
285
298
|
* added to an orphan array for possible later reconnection
|
|
286
299
|
*
|
|
287
300
|
* @param {Object[]|string[]|buffer[]} headers
|
|
288
|
-
* @
|
|
301
|
+
* @param {number} batchHeadHeight - height of the first header in the array
|
|
302
|
+
* @return {BlockHeader[]}
|
|
289
303
|
*/
|
|
290
|
-
addHeaders(headers) {
|
|
291
|
-
if (
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
304
|
+
addHeaders(headers, batchHeadHeight = 0) {
|
|
305
|
+
if (!X11.ready()) {
|
|
306
|
+
throw new SPVError('X11 wasm not ready, call wasmX11Ready() first');
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
if (!this.initialized()) {
|
|
310
|
+
throw new SPVError('Chain not initialized, either call initialize() or set pendingStartBlockHeight');
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
const normalizedHeaders = headers.map((h) => utils.normalizeHeader(h));
|
|
314
|
+
|
|
315
|
+
let isOrphan = false;
|
|
316
|
+
|
|
317
|
+
// Chain is initialized, root block, and it's height are known
|
|
318
|
+
if (this.pendingStartBlockHeight === null) {
|
|
319
|
+
const tip = this.getTipHeader();
|
|
320
|
+
// Handle 1 block intersection of batches
|
|
321
|
+
if (tip.hash === normalizedHeaders[0].hash) {
|
|
322
|
+
normalizedHeaders.splice(0, 1);
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
if (normalizedHeaders.length === 0) {
|
|
326
|
+
// The batch already in the chain, do nothing
|
|
327
|
+
return [];
|
|
296
328
|
}
|
|
329
|
+
|
|
330
|
+
const firstHeader = normalizedHeaders[0];
|
|
331
|
+
|
|
332
|
+
isOrphan = !SpvChain.isParentChild(firstHeader, tip);
|
|
333
|
+
} else if (batchHeadHeight === this.pendingStartBlockHeight) {
|
|
334
|
+
// Header at pendingStartBlockHeight is found, initialize chain
|
|
335
|
+
this.startBlockHeight = this.pendingStartBlockHeight;
|
|
336
|
+
this.pendingStartBlockHeight = null;
|
|
337
|
+
isOrphan = false;
|
|
338
|
+
} else if (batchHeadHeight > this.pendingStartBlockHeight) {
|
|
339
|
+
// Orphan chunk has arrived
|
|
340
|
+
isOrphan = true;
|
|
341
|
+
} else {
|
|
342
|
+
throw new SPVError(`Batch at invalid height arrived: ${batchHeadHeight}, expected > ${this.pendingStartBlockHeight}`);
|
|
297
343
|
}
|
|
298
|
-
|
|
299
|
-
const
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
if (index !== 0) {
|
|
305
|
-
if (!SpvChain.isParentChild(header, array[index - 1])
|
|
306
|
-
|| !this.isValid(header, previousHeaders)) {
|
|
307
|
-
throw new Error('Some headers are invalid');
|
|
308
|
-
}
|
|
309
|
-
return acc && true;
|
|
344
|
+
|
|
345
|
+
const allValid = normalizedHeaders.reduce((acc, header, index, array) => {
|
|
346
|
+
const previousHeaders = normalizedHeaders.slice(0, index);
|
|
347
|
+
if (index !== 0) {
|
|
348
|
+
if (!SpvChain.isParentChild(header, array[index - 1])) {
|
|
349
|
+
throw new SPVError(`SPV: Header ${header.hash} is not a child of ${array[index - 1].hash}`);
|
|
310
350
|
}
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
}
|
|
315
|
-
return acc && true;
|
|
351
|
+
|
|
352
|
+
if (!this.isValid(header, previousHeaders)) {
|
|
353
|
+
throw new SPVError(`SPV: Header ${header.hash} is invalid`);
|
|
316
354
|
}
|
|
317
|
-
|
|
318
|
-
|
|
355
|
+
return acc && true;
|
|
356
|
+
}
|
|
357
|
+
if (isOrphan) {
|
|
358
|
+
if (!this.isValid(header, previousHeaders)) {
|
|
359
|
+
throw new SPVError('Some headers are invalid');
|
|
319
360
|
}
|
|
320
361
|
return acc && true;
|
|
321
|
-
}
|
|
322
|
-
|
|
362
|
+
}
|
|
363
|
+
if (!this.isValid(header, this.getLongestChain())) {
|
|
364
|
+
throw new SPVError('Some headers are invalid');
|
|
365
|
+
}
|
|
366
|
+
return acc && true;
|
|
367
|
+
}, true);
|
|
323
368
|
if (!allValid) {
|
|
324
|
-
throw new
|
|
369
|
+
throw new SPVError('Some headers are invalid');
|
|
325
370
|
}
|
|
326
371
|
if (isOrphan) {
|
|
372
|
+
normalizedHeaders.forEach((header) => {
|
|
373
|
+
this.orphansHashes.add(header.hash);
|
|
374
|
+
});
|
|
327
375
|
this.orphanChunks.push(normalizedHeaders);
|
|
328
376
|
} else {
|
|
329
377
|
this.appendHeadersToLongestChain(normalizedHeaders);
|
|
@@ -332,7 +380,7 @@ const SpvChain = class {
|
|
|
332
380
|
this.orphanChunksReconnect();
|
|
333
381
|
}
|
|
334
382
|
this.checkPruneBlocks();
|
|
335
|
-
return
|
|
383
|
+
return normalizedHeaders;
|
|
336
384
|
}
|
|
337
385
|
};
|
|
338
386
|
|
package/lib/x11.js
ADDED
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
const { configure: configureDashcore } = require('@dashevo/dashcore-lib');
|
|
2
|
+
const X11 = require('wasm-x11-hash');
|
|
3
|
+
|
|
4
|
+
let x11Promise = null;
|
|
5
|
+
let x11Ready = false;
|
|
6
|
+
|
|
7
|
+
const load = async () => {
|
|
8
|
+
if (!x11Promise) {
|
|
9
|
+
x11Promise = X11().then(
|
|
10
|
+
(x11Hash) => {
|
|
11
|
+
configureDashcore({
|
|
12
|
+
x11hash: x11Hash,
|
|
13
|
+
});
|
|
14
|
+
x11Ready = true;
|
|
15
|
+
},
|
|
16
|
+
);
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
return x11Promise;
|
|
20
|
+
};
|
|
21
|
+
|
|
22
|
+
const ready = () => x11Ready;
|
|
23
|
+
|
|
24
|
+
module.exports = {
|
|
25
|
+
ready,
|
|
26
|
+
load,
|
|
27
|
+
};
|
package/package.json
CHANGED
|
@@ -1,10 +1,11 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@dashevo/dash-spv",
|
|
3
|
-
"version": "
|
|
3
|
+
"version": "2.0.1",
|
|
4
4
|
"description": "Repository containing SPV functions used by @dashevo",
|
|
5
5
|
"main": "index.js",
|
|
6
6
|
"scripts": {
|
|
7
7
|
"test": "mocha test/ --no-timeouts --recursive",
|
|
8
|
+
"build": "",
|
|
8
9
|
"lint": "eslint .",
|
|
9
10
|
"lint:fix": "eslint . --fix"
|
|
10
11
|
},
|
|
@@ -13,15 +14,18 @@
|
|
|
13
14
|
"dependencies": {
|
|
14
15
|
"@dashevo/dark-gravity-wave": "^1.1.1",
|
|
15
16
|
"@dashevo/dash-util": "^2.0.3",
|
|
16
|
-
"@dashevo/dashcore-lib": "~0.
|
|
17
|
+
"@dashevo/dashcore-lib": "~0.21.3",
|
|
17
18
|
"levelup": "^4.4.0",
|
|
18
|
-
"memdown": "^5.1.0"
|
|
19
|
+
"memdown": "^5.1.0",
|
|
20
|
+
"wasm-x11-hash": "~0.0.2"
|
|
19
21
|
},
|
|
20
22
|
"devDependencies": {
|
|
21
|
-
"
|
|
22
|
-
"eslint
|
|
23
|
-
"eslint-
|
|
24
|
-
"
|
|
25
|
-
"
|
|
23
|
+
"chai": "^4.3.10",
|
|
24
|
+
"eslint": "^8.53.0",
|
|
25
|
+
"eslint-config-airbnb-base": "^15.0.0",
|
|
26
|
+
"eslint-plugin-import": "^2.29.0",
|
|
27
|
+
"mocha": "^10.2.0",
|
|
28
|
+
"should": "^13.2.3",
|
|
29
|
+
"sinon": "^17.0.1"
|
|
26
30
|
}
|
|
27
31
|
}
|
package/test/data/headers.js
CHANGED
package/test/index.js
CHANGED
|
@@ -1,4 +1,6 @@
|
|
|
1
1
|
const { MerkleBlock, Transaction } = require('@dashevo/dashcore-lib');
|
|
2
|
+
const should = require('should');
|
|
3
|
+
|
|
2
4
|
const Blockchain = require('../lib/spvchain');
|
|
3
5
|
const utils = require('../lib/utils');
|
|
4
6
|
const merkleProofs = require('../lib/merkleproofs');
|
|
@@ -13,11 +15,11 @@ let chain = null;
|
|
|
13
15
|
let merkleBlock = null;
|
|
14
16
|
let merkleBlock2 = null;
|
|
15
17
|
|
|
16
|
-
require('should');
|
|
17
|
-
|
|
18
18
|
describe('SPV-DASH (forks & re-orgs) deserialized headers', () => {
|
|
19
|
-
before(() => {
|
|
20
|
-
chain = new Blockchain('
|
|
19
|
+
before(async () => {
|
|
20
|
+
chain = new Blockchain('testnet');
|
|
21
|
+
await Blockchain.wasmX11Ready();
|
|
22
|
+
chain.initialize();
|
|
21
23
|
});
|
|
22
24
|
|
|
23
25
|
it('should get 26 testnet headers', () => {
|
|
@@ -34,39 +36,40 @@ describe('SPV-DASH (forks & re-orgs) deserialized headers', () => {
|
|
|
34
36
|
});
|
|
35
37
|
|
|
36
38
|
it('should still contain a branch of 1 when first header is added', () => {
|
|
37
|
-
chain.
|
|
39
|
+
chain.addHeaders([headers[0]]);
|
|
38
40
|
chain.getAllBranches().length.should.equal(1);
|
|
39
41
|
chain.getLongestChain().length.should.equal(2);
|
|
40
42
|
});
|
|
41
43
|
|
|
42
44
|
it('should discard adding of duplicate block', () => {
|
|
43
|
-
chain.
|
|
44
|
-
chain.
|
|
45
|
+
chain.addHeaders([headers[0]]);
|
|
46
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
45
47
|
chain.getLongestChain().length.should.equal(2);
|
|
46
48
|
});
|
|
47
49
|
|
|
48
50
|
it('should create 1 orphan', () => {
|
|
49
|
-
chain.
|
|
50
|
-
chain.
|
|
51
|
+
chain.addHeaders([headers[2]]);
|
|
52
|
+
chain.getOrphanChunks().length.should.equal(1);
|
|
51
53
|
chain.getLongestChain().length.should.equal(2);
|
|
52
54
|
});
|
|
53
55
|
|
|
54
56
|
it('should connect the orphan by adding its parent', () => {
|
|
55
|
-
chain.
|
|
56
|
-
chain.
|
|
57
|
+
chain.addHeaders([headers[1]]);
|
|
58
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
57
59
|
chain.getAllBranches().length.should.equal(1);
|
|
58
60
|
chain.getLongestChain().length.should.equal(4);
|
|
59
61
|
});
|
|
60
62
|
|
|
61
63
|
it('should add remaining test headers', () => {
|
|
62
64
|
chain.addHeaders(headers.slice(3, 24));
|
|
63
|
-
chain.
|
|
65
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
64
66
|
chain.getAllBranches().length.should.equal(1);
|
|
65
67
|
chain.getLongestChain().length.should.equal(25);
|
|
66
68
|
});
|
|
67
69
|
|
|
68
|
-
|
|
69
|
-
|
|
70
|
+
// TODO: restore when conesnsus rules are enabled
|
|
71
|
+
it.skip('not add an invalid header', () => {
|
|
72
|
+
should(() => chain.addHeaders([headers[25]])).throw();
|
|
70
73
|
chain.getLongestChain().length.should.equal(25);
|
|
71
74
|
});
|
|
72
75
|
|
|
@@ -75,15 +78,16 @@ describe('SPV-DASH (forks & re-orgs) deserialized headers', () => {
|
|
|
75
78
|
chain.addHeaders([headers[25], headers[10]]);
|
|
76
79
|
done(new Error('SPV chain failed to throw an error on invalid block'));
|
|
77
80
|
} catch (e) {
|
|
78
|
-
e.message.should.equal('
|
|
81
|
+
e.message.should.equal('SPV: Header 00000ce430de949c85a145b02e33ebbaed3772dc8f3d668f66edc6852c24d002 is not a child of e59b97d3d11b4d4563b557e32c62afbdb6e947e9cbb4915c94073f08f7936d5f');
|
|
79
82
|
done();
|
|
80
83
|
}
|
|
81
84
|
});
|
|
82
85
|
});
|
|
83
86
|
|
|
84
87
|
describe('SPV-DASH (forks & re-orgs) serialized raw headers for mainnet', () => {
|
|
85
|
-
before(() => {
|
|
86
|
-
chain = new Blockchain('mainnet', 10000
|
|
88
|
+
before(async () => {
|
|
89
|
+
chain = new Blockchain('mainnet', 10000);
|
|
90
|
+
chain.initialize(utils.normalizeHeader(mainnet[0]), 1);
|
|
87
91
|
});
|
|
88
92
|
|
|
89
93
|
it('should get 2000 mainnet headers', () => {
|
|
@@ -100,88 +104,91 @@ describe('SPV-DASH (forks & re-orgs) serialized raw headers for mainnet', () =>
|
|
|
100
104
|
});
|
|
101
105
|
|
|
102
106
|
it('should still contain a branch of 1 when first header is added', () => {
|
|
103
|
-
chain.
|
|
107
|
+
chain.addHeaders([mainnet[1]]);
|
|
104
108
|
chain.getAllBranches().length.should.equal(1);
|
|
105
109
|
chain.getLongestChain().length.should.equal(2);
|
|
106
110
|
});
|
|
107
111
|
|
|
108
112
|
it('should discard addding of duplicate block', () => {
|
|
109
|
-
chain.
|
|
110
|
-
chain.
|
|
113
|
+
chain.addHeaders([mainnet[1]]);
|
|
114
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
111
115
|
chain.getLongestChain().length.should.equal(2);
|
|
112
116
|
});
|
|
113
117
|
|
|
114
118
|
it('should create 1 orphan', () => {
|
|
115
|
-
chain.
|
|
116
|
-
chain.
|
|
119
|
+
chain.addHeaders([mainnet[3]]);
|
|
120
|
+
chain.getOrphanChunks().length.should.equal(1);
|
|
117
121
|
chain.getLongestChain().length.should.equal(2);
|
|
118
122
|
});
|
|
119
123
|
|
|
120
124
|
it('should connect the orphan by adding its parent', () => {
|
|
121
|
-
chain.
|
|
122
|
-
chain.
|
|
125
|
+
chain.addHeaders([mainnet[2]]);
|
|
126
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
123
127
|
chain.getAllBranches().length.should.equal(1);
|
|
124
128
|
chain.getLongestChain().length.should.equal(4);
|
|
125
129
|
});
|
|
126
130
|
});
|
|
127
131
|
|
|
128
132
|
describe('SPV-DASH (addHeaders) add many headers for testnet', () => {
|
|
129
|
-
before(() => {
|
|
130
|
-
chain = new Blockchain('testnet', 10000
|
|
133
|
+
before(async () => {
|
|
134
|
+
chain = new Blockchain('testnet', 10000);
|
|
135
|
+
chain.initialize(utils.normalizeHeader(testnet[0]), 1);
|
|
131
136
|
});
|
|
132
137
|
|
|
133
138
|
it('should add the 1st 250 testnet headers', () => {
|
|
134
139
|
chain.addHeaders(testnet.slice(1, 250));
|
|
135
|
-
chain.
|
|
140
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
136
141
|
chain.getAllBranches().length.should.equal(1);
|
|
137
142
|
chain.getLongestChain().length.should.equal(250);
|
|
138
143
|
});
|
|
139
144
|
|
|
140
145
|
it('should add the next 250 (250 - 500) testnet headers', () => {
|
|
141
146
|
chain.addHeaders(testnet.slice(250, 500));
|
|
142
|
-
chain.
|
|
147
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
143
148
|
chain.getAllBranches().length.should.equal(1);
|
|
144
149
|
chain.getLongestChain().length.should.equal(500);
|
|
145
150
|
});
|
|
146
151
|
|
|
147
152
|
it('should add the 1st 250 testnet2 headers', () => {
|
|
148
|
-
chain = new Blockchain('testnet', 10000
|
|
153
|
+
chain = new Blockchain('testnet', 10000);
|
|
154
|
+
chain.initialize(utils.normalizeHeader(testnet2[0]), 1);
|
|
149
155
|
chain.addHeaders(testnet2.slice(1, 250));
|
|
150
|
-
chain.
|
|
156
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
151
157
|
chain.getAllBranches().length.should.equal(1);
|
|
152
158
|
chain.getLongestChain().length.should.equal(250);
|
|
153
159
|
});
|
|
154
160
|
|
|
155
161
|
it('should add the next 250 (250 - 500) testnet2 headers', () => {
|
|
156
162
|
chain.addHeaders(testnet2.slice(250, 500));
|
|
157
|
-
chain.
|
|
163
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
158
164
|
chain.getAllBranches().length.should.equal(1);
|
|
159
165
|
chain.getLongestChain().length.should.equal(500);
|
|
160
166
|
});
|
|
161
167
|
|
|
162
168
|
it('should add the 1st 250 testnet3 headers', () => {
|
|
163
|
-
chain = new Blockchain('testnet', 10000
|
|
169
|
+
chain = new Blockchain('testnet', 10000);
|
|
170
|
+
chain.initialize(utils.normalizeHeader(testnet3[0]), 1);
|
|
164
171
|
chain.addHeaders(testnet3.slice(1, 250));
|
|
165
|
-
chain.
|
|
172
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
166
173
|
chain.getAllBranches().length.should.equal(1);
|
|
167
174
|
chain.getLongestChain().length.should.equal(250);
|
|
168
175
|
});
|
|
169
176
|
|
|
170
177
|
it('should add the next 250 (250 - 500) testnet3 headers', () => {
|
|
171
178
|
chain.addHeaders(testnet3.slice(250, 500));
|
|
172
|
-
chain.
|
|
179
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
173
180
|
chain.getAllBranches().length.should.equal(1);
|
|
174
181
|
chain.getLongestChain().length.should.equal(500);
|
|
175
182
|
});
|
|
176
183
|
|
|
177
184
|
it('should not add an invalid header', () => {
|
|
178
|
-
chain.
|
|
185
|
+
chain.addHeaders([testnet[499]]);
|
|
179
186
|
chain.getLongestChain().length.should.equal(500);
|
|
180
187
|
});
|
|
181
188
|
|
|
182
189
|
it('should orphan and not add invalid but consistent headers', () => {
|
|
183
190
|
chain.addHeaders([badRawHeaders[0], badRawHeaders[1]]);
|
|
184
|
-
chain.getOrphanChunks().length.should.equal(
|
|
191
|
+
chain.getOrphanChunks().length.should.equal(2);
|
|
185
192
|
chain.getLongestChain().length.should.equal(500);
|
|
186
193
|
});
|
|
187
194
|
|
|
@@ -198,12 +205,13 @@ describe('SPV-DASH (addHeaders) add many headers for testnet', () => {
|
|
|
198
205
|
|
|
199
206
|
describe('SPV-DASH (addHeaders) add testnet headers out of order', () => {
|
|
200
207
|
before(() => {
|
|
201
|
-
chain = new Blockchain('testnet', 10000
|
|
208
|
+
chain = new Blockchain('testnet', 10000);
|
|
209
|
+
chain.initialize(utils.normalizeHeader(testnet[0]), 1);
|
|
202
210
|
});
|
|
203
211
|
|
|
204
212
|
it('should add the 1st 100 testnet headers', () => {
|
|
205
213
|
chain.addHeaders(testnet.slice(1, 100));
|
|
206
|
-
chain.
|
|
214
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
207
215
|
chain.getAllBranches().length.should.equal(1);
|
|
208
216
|
chain.getOrphanChunks().length.should.equal(0);
|
|
209
217
|
chain.getLongestChain().length.should.equal(100);
|
|
@@ -211,7 +219,6 @@ describe('SPV-DASH (addHeaders) add testnet headers out of order', () => {
|
|
|
211
219
|
|
|
212
220
|
it('should orphan testnet headers 200 - 300', () => {
|
|
213
221
|
chain.addHeaders(testnet.slice(200, 300));
|
|
214
|
-
chain.getOrphans().length.should.equal(0);
|
|
215
222
|
chain.getAllBranches().length.should.equal(1);
|
|
216
223
|
chain.getOrphanChunks().length.should.equal(1);
|
|
217
224
|
chain.getLongestChain().length.should.equal(100);
|
|
@@ -219,15 +226,13 @@ describe('SPV-DASH (addHeaders) add testnet headers out of order', () => {
|
|
|
219
226
|
|
|
220
227
|
it('should orphan testnet headers 400 - 500', () => {
|
|
221
228
|
chain.addHeaders(testnet.slice(400, 500));
|
|
222
|
-
chain.getOrphans().length.should.equal(0);
|
|
223
|
-
chain.getAllBranches().length.should.equal(1);
|
|
224
229
|
chain.getOrphanChunks().length.should.equal(2);
|
|
230
|
+
chain.getAllBranches().length.should.equal(1);
|
|
225
231
|
chain.getLongestChain().length.should.equal(100);
|
|
226
232
|
});
|
|
227
233
|
|
|
228
234
|
it('should reconnect orphaned chunks (testnet headers 1 - 100 and 200 - 300)', () => {
|
|
229
235
|
chain.addHeaders(testnet.slice(100, 200));
|
|
230
|
-
chain.getOrphans().length.should.equal(0);
|
|
231
236
|
chain.getAllBranches().length.should.equal(1);
|
|
232
237
|
chain.getOrphanChunks().length.should.equal(1);
|
|
233
238
|
chain.getLongestChain().length.should.equal(300);
|
|
@@ -235,7 +240,7 @@ describe('SPV-DASH (addHeaders) add testnet headers out of order', () => {
|
|
|
235
240
|
|
|
236
241
|
it('should reconnect orphaned chunks (testnet headers 1 - 300 and 400 - 500)', () => {
|
|
237
242
|
chain.addHeaders(testnet.slice(300, 400));
|
|
238
|
-
chain.
|
|
243
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
239
244
|
chain.getAllBranches().length.should.equal(1);
|
|
240
245
|
chain.getOrphanChunks().length.should.equal(0);
|
|
241
246
|
chain.getLongestChain().length.should.equal(500);
|
|
@@ -244,32 +249,33 @@ describe('SPV-DASH (addHeaders) add testnet headers out of order', () => {
|
|
|
244
249
|
|
|
245
250
|
describe('SPV-DASH (addHeaders) add many headers for mainnet', () => {
|
|
246
251
|
before(() => {
|
|
247
|
-
chain = new Blockchain('mainnet', 10000
|
|
252
|
+
chain = new Blockchain('mainnet', 10000);
|
|
253
|
+
chain.initialize(utils.normalizeHeader(mainnet[0]), 1);
|
|
248
254
|
});
|
|
249
255
|
|
|
250
256
|
it('should add the 1st 500 mainnet headers', () => {
|
|
251
257
|
chain.addHeaders(mainnet.slice(1, 500));
|
|
252
|
-
chain.
|
|
258
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
253
259
|
chain.getAllBranches().length.should.equal(1);
|
|
254
260
|
chain.getLongestChain().length.should.equal(500);
|
|
255
261
|
});
|
|
256
262
|
|
|
257
263
|
it('should add the next 500 (500 - 1000) mainnet headers', () => {
|
|
258
264
|
chain.addHeaders(mainnet.slice(500, 1000));
|
|
259
|
-
chain.
|
|
265
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
260
266
|
chain.getAllBranches().length.should.equal(1);
|
|
261
267
|
chain.getLongestChain().length.should.equal(1000);
|
|
262
268
|
});
|
|
263
269
|
|
|
264
270
|
it('should add the next 500 (1000 - 1500) mainnet headers', () => {
|
|
265
271
|
chain.addHeaders(mainnet.slice(1000, 1500));
|
|
266
|
-
chain.
|
|
272
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
267
273
|
chain.getAllBranches().length.should.equal(1);
|
|
268
274
|
chain.getLongestChain().length.should.equal(1500);
|
|
269
275
|
});
|
|
270
276
|
|
|
271
277
|
it('should not add an invalid header', () => {
|
|
272
|
-
chain.
|
|
278
|
+
should(() => chain.addHeaders([mainnet[499]])).throw();
|
|
273
279
|
chain.getLongestChain().length.should.equal(1500);
|
|
274
280
|
});
|
|
275
281
|
|
|
@@ -292,12 +298,13 @@ describe('SPV-DASH (addHeaders) add many headers for mainnet', () => {
|
|
|
292
298
|
|
|
293
299
|
describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
|
|
294
300
|
before(() => {
|
|
295
|
-
chain = new Blockchain('mainnet', 10000
|
|
301
|
+
chain = new Blockchain('mainnet', 10000);
|
|
302
|
+
chain.initialize(utils.normalizeHeader(mainnet[0]), 1);
|
|
296
303
|
});
|
|
297
304
|
|
|
298
305
|
it('should add the 1st 100 mainnet headers', () => {
|
|
299
306
|
chain.addHeaders(mainnet.slice(1, 100));
|
|
300
|
-
chain.
|
|
307
|
+
chain.getOrphanChunks().length.should.equal(0);
|
|
301
308
|
chain.getAllBranches().length.should.equal(1);
|
|
302
309
|
chain.getOrphanChunks().length.should.equal(0);
|
|
303
310
|
chain.getLongestChain().length.should.equal(100);
|
|
@@ -305,7 +312,6 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
|
|
|
305
312
|
|
|
306
313
|
it('should orphan mainnet headers 200 - 300', () => {
|
|
307
314
|
chain.addHeaders(mainnet.slice(200, 300));
|
|
308
|
-
chain.getOrphans().length.should.equal(0);
|
|
309
315
|
chain.getAllBranches().length.should.equal(1);
|
|
310
316
|
chain.getOrphanChunks().length.should.equal(1);
|
|
311
317
|
chain.getLongestChain().length.should.equal(100);
|
|
@@ -313,7 +319,6 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
|
|
|
313
319
|
|
|
314
320
|
it('should orphan mainnet headers 400 - 500', () => {
|
|
315
321
|
chain.addHeaders(mainnet.slice(400, 500));
|
|
316
|
-
chain.getOrphans().length.should.equal(0);
|
|
317
322
|
chain.getAllBranches().length.should.equal(1);
|
|
318
323
|
chain.getOrphanChunks().length.should.equal(2);
|
|
319
324
|
chain.getLongestChain().length.should.equal(100);
|
|
@@ -321,7 +326,6 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
|
|
|
321
326
|
|
|
322
327
|
it('should reconnect orphaned chunks (mainnet headers 1 - 100 and 200 - 300)', () => {
|
|
323
328
|
chain.addHeaders(mainnet.slice(100, 200));
|
|
324
|
-
chain.getOrphans().length.should.equal(0);
|
|
325
329
|
chain.getAllBranches().length.should.equal(1);
|
|
326
330
|
chain.getOrphanChunks().length.should.equal(1);
|
|
327
331
|
chain.getLongestChain().length.should.equal(300);
|
|
@@ -329,7 +333,6 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
|
|
|
329
333
|
|
|
330
334
|
it('should reconnect orphaned chunks (mainnet headers 1 - 300 and 400 - 500)', () => {
|
|
331
335
|
chain.addHeaders(mainnet.slice(300, 400));
|
|
332
|
-
chain.getOrphans().length.should.equal(0);
|
|
333
336
|
chain.getAllBranches().length.should.equal(1);
|
|
334
337
|
chain.getOrphanChunks().length.should.equal(0);
|
|
335
338
|
chain.getLongestChain().length.should.equal(500);
|
|
@@ -337,7 +340,7 @@ describe('SPV-DASH (addHeaders) add mainnet headers out of order', () => {
|
|
|
337
340
|
});
|
|
338
341
|
|
|
339
342
|
let genesisHash = null;
|
|
340
|
-
describe('Blockstore', () => {
|
|
343
|
+
describe.skip('Blockstore', () => {
|
|
341
344
|
before(() => {
|
|
342
345
|
chain = new Blockchain('testnet', 10);
|
|
343
346
|
genesisHash = chain.getTipHash();
|
|
@@ -383,7 +386,8 @@ describe('MerkleProofs', () => {
|
|
|
383
386
|
|
|
384
387
|
describe('Transaction validation', () => {
|
|
385
388
|
before(() => {
|
|
386
|
-
chain = new Blockchain('testnet', 10000
|
|
389
|
+
chain = new Blockchain('testnet', 10000);
|
|
390
|
+
chain.initialize(utils.normalizeHeader(testnet[0]), 1);
|
|
387
391
|
chain.addHeaders(testnet.slice(1, 500));
|
|
388
392
|
});
|
|
389
393
|
|
package/test/spvchain.js
ADDED
|
@@ -0,0 +1,79 @@
|
|
|
1
|
+
const { expect } = require('chai');
|
|
2
|
+
const X11 = require('../lib/x11');
|
|
3
|
+
const { SpvChain } = require('../index');
|
|
4
|
+
const { testnet } = require('./data/rawHeaders');
|
|
5
|
+
|
|
6
|
+
describe('SPVChain', () => {
|
|
7
|
+
let spvChain;
|
|
8
|
+
|
|
9
|
+
beforeEach(async () => {
|
|
10
|
+
spvChain = new SpvChain('testnet', 100);
|
|
11
|
+
await SpvChain.wasmX11Ready();
|
|
12
|
+
});
|
|
13
|
+
|
|
14
|
+
describe('#initialize', () => {
|
|
15
|
+
it('should throw an error if wasmX11 is not initialized', function it() {
|
|
16
|
+
this.sinon.stub(X11, 'ready').returns(false);
|
|
17
|
+
expect(() => spvChain.initialize())
|
|
18
|
+
.to.throw('X11 wasm not ready, call wasmX11Ready() first');
|
|
19
|
+
});
|
|
20
|
+
|
|
21
|
+
it('should throw an error if chain is already initialized', async () => {
|
|
22
|
+
spvChain.initialize(testnet[0], 10000);
|
|
23
|
+
expect(() => spvChain.initialize())
|
|
24
|
+
.to.throw('Chain already initialized');
|
|
25
|
+
});
|
|
26
|
+
|
|
27
|
+
it('should initialize chain with genesis header', async () => {
|
|
28
|
+
spvChain.initialize();
|
|
29
|
+
expect(spvChain.startBlockHeight).to.be.equal(0);
|
|
30
|
+
expect(spvChain.getLongestChain())
|
|
31
|
+
.to.be.deep.equal([spvChain.genesis]);
|
|
32
|
+
});
|
|
33
|
+
|
|
34
|
+
it('should not allow initializing from arbitrary block without height', () => {
|
|
35
|
+
expect(() => spvChain.initialize(testnet[0]))
|
|
36
|
+
.to.throw('Initialization error, please provide both startBlock and height');
|
|
37
|
+
});
|
|
38
|
+
|
|
39
|
+
it('should initialize from arbitrary block', () => {
|
|
40
|
+
spvChain.initialize(testnet[0], 10000);
|
|
41
|
+
expect(spvChain.startBlockHeight).to.be.equal(10000);
|
|
42
|
+
expect(spvChain.getLongestChain()[0].toBuffer().toString('hex'))
|
|
43
|
+
.to.be.equal(testnet[0]);
|
|
44
|
+
});
|
|
45
|
+
});
|
|
46
|
+
|
|
47
|
+
describe('#addHeaders', () => {
|
|
48
|
+
it('should throw an error if wasmX11 is not initialized', function it() {
|
|
49
|
+
this.sinon.stub(X11, 'ready').returns(false);
|
|
50
|
+
expect(() => spvChain.addHeaders(testnet.slice(400)))
|
|
51
|
+
.to.throw('X11 wasm not ready, call wasmX11Ready() first');
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
it('should throw an error if chain is not initialized', async () => {
|
|
55
|
+
expect(() => spvChain.addHeaders(testnet.slice(400)))
|
|
56
|
+
.to.throw('Chain not initialized, either call initialize() or set pendingStartBlockHeight');
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
it('should assemble headers chain if headers arriving out of order', async () => {
|
|
60
|
+
expect(true).to.equal(true);
|
|
61
|
+
|
|
62
|
+
spvChain.initialize(testnet[0], 10000);
|
|
63
|
+
|
|
64
|
+
spvChain.addHeaders(testnet.slice(400), 10400);
|
|
65
|
+
expect(spvChain.getOrphanChunks()).to.have.length(1);
|
|
66
|
+
spvChain.addHeaders(testnet.slice(200, 300), 10200);
|
|
67
|
+
expect(spvChain.getOrphanChunks()).to.have.length(2);
|
|
68
|
+
spvChain.addHeaders(testnet.slice(300, 400), 10300);
|
|
69
|
+
expect(spvChain.getOrphanChunks()).to.have.length(3);
|
|
70
|
+
spvChain.addHeaders(testnet.slice(100, 200), 10100);
|
|
71
|
+
expect(spvChain.getOrphanChunks()).to.have.length(4);
|
|
72
|
+
spvChain.addHeaders(testnet.slice(0, 100), 10000);
|
|
73
|
+
|
|
74
|
+
const longestChain = spvChain.getLongestChain({ withPruned: true });
|
|
75
|
+
expect(longestChain).to.have.length(testnet.length);
|
|
76
|
+
expect(spvChain.getOrphanChunks()).to.have.length(0);
|
|
77
|
+
});
|
|
78
|
+
});
|
|
79
|
+
});
|