test: monotonic time reorg, incomplete

lib/wallet/walletdb.js

@@ -2110,8 +2110,6 @@ class WalletDB extends EventEmitter {
   async _removeBlock(entry) {
     const tip = BlockMeta.fromEntry(entry);
 
-    // TODO remove monotonic block times or mark as unconfirmed
-
     if (tip.height === 0)
       throw new Error('WDB: Bad disconnection (genesis block).');
 

test/util/regtest.js

@@ -102,22 +102,52 @@ async function generateBlocks(count, nclient, coinbase) {
 }
 
 async function generateReorg(depth, nclient, wclient, coinbase) {
-  let hashes = [];
+  const blockInterval = 600;
+
+  let invalidated = [];
+  let lastTime = null;
 
+  // Invalidate blocks to the depth.
   for (let i = 0; i < depth; i++) {
     const hash = await nclient.execute('getbestblockhash');
-    hashes.push(hash);
+    invalidated.push(hash);
+
+    // Get the time for the block before it's removed.
+    const lastBlock = await nclient.execute('getblock', [hash]);
+    lastTime = lastBlock.time;
+
     await nclient.execute('invalidateblock', [hash]);
   }
 
+  // Increase time so that blocks do not have
+  // the same time stamp as before.
+  lastTime += 10000;
+
+  // Create a new transaction so that the transactions
+  // order is different after the reorg.
   const addr = await wclient.execute('getnewaddress', ['blue']);
   const txid = await wclient.execute('sendtoaddress', [addr, 0.11111111]);
 
-  const blocks = await generateBlocks(depth, nclient, coinbase);
+  let validated = [];
+
+  // Add new blocks back to the same height plus one
+  // so that it becomes the chain with the most work.
+  for (let c = 0; c < depth + 1; c++) {
+    let blocktime = lastTime + c * blockInterval;
+    await nclient.execute('setmocktime', [blocktime]);
+
+    const blockhashes = await generateBlocks(1, nclient, coinbase);
+    const block = await nclient.execute('getblock', [blockhashes[0]]);
+
+    validated.push(block.hash);
+
+    assert(block.time <= blocktime + 1);
+    assert(block.time >= blocktime);
+  }
 
   return {
-    invalidated: hashes,
-    validated: blocks
+    invalidated,
+    validated
   }
 }
 

test/wallet-time-test.js

@@ -53,6 +53,17 @@ async function testMonotonicTime(wclient) {
   assert(monotonic, 'Expected to be monotonic');
 }
 
+async function testReorg(wclient, previous, depth) {
+  const current = await wclient.execute('getblocksbytime', [genesisTime, 1000]);
+  assert.strictEqual(current.length, previous.length + 1);
+
+  const l = current.length;
+
+  for (let i = 1; i < depth + 1; i++) {
+    assert.notStrictEqual(previous[l - i].block, current[l - i].block);
+  }
+}
+
 describe('Wallet Monotonic Time', function() {
   this.timeout(10000);
 
@@ -64,8 +75,8 @@ describe('Wallet Monotonic Time', function() {
     await rimraf(testPrefix);
     await rimraf(spvTestPrefix);
 
-    node = await initFullNode({ports, prefix: testPrefix});
-    spvnode = await initSPVNode({ports, prefix: spvTestPrefix});
+    node = await initFullNode({ports, prefix: testPrefix, logLevel: 'none'});
+    spvnode = await initSPVNode({ports, prefix: spvTestPrefix, logLevel: 'none'});
 
     nclient = await initNodeClient({ports: ports.full});
     wclient = await initWalletClient({ports: ports.full});
@@ -106,18 +117,26 @@ describe('Wallet Monotonic Time', function() {
     await testMonotonicTime(spvwclient);
   });
 
-  describe('chain reorganizations', function() {
+  describe.skip('chain reorganizations', function() {
+    const depth = 3;
+    let previous = null;
+
     before(async () => {
-      const result = await generateReorg(1, nclient, wclient, coinbase);
+      previous = await wclient.execute('getblocksbytime', [genesisTime, 1000]);
+
+      const result = await generateReorg(depth, nclient, wclient, coinbase);
       assert.notStrictEqual(result.invalidated[0], result.validated[0]);
+
+      // TODO remove this
+      await sleep(5000);
     });
 
     it('should reorganize monotonic time for a full node', async() => {
-      // TODO
+      await testReorg(wclient, previous, depth);
     });
 
     it('should reorganize monotonic time for a spv node', async() => {
-      // TODO
+      await testReorg(spvwclient, previous, depth);
     });
   });
 });