[3.0.8.0] Fast Rewind

src/Stratis.Bitcoin.Features.Consensus.Tests/CoinViews/CoinViewStackTest.cs

@@ -126,7 +126,7 @@ public NonBackedCoinView()
                 throw new NotImplementedException();
             }
 
-            public uint256 Rewind()
+            public uint256 Rewind(int targetHeight)
             {
                 throw new NotImplementedException();
             }
@@ -166,7 +166,7 @@ public BackedCoinView1(BackedCoinView2 inner, int outputCount = 0)
                 throw new NotImplementedException();
             }
 
-            public uint256 Rewind()
+            public uint256 Rewind(int targetHeight)
             {
                 throw new NotImplementedException();
             }
@@ -206,7 +206,7 @@ public BackedCoinView2(NonBackedCoinView inner, int outputCount = 0)
                 throw new NotImplementedException();
             }
 
-            public uint256 Rewind()
+            public uint256 Rewind(int targetHeight)
             {
                 throw new NotImplementedException();
             }

src/Stratis.Bitcoin.Features.Consensus.Tests/CoinViews/CoinviewTests.cs

@@ -120,9 +120,13 @@ public async Task TestRewindAsync()
 
             await this.ValidateCoinviewIntegrityAsync(outPoints);
 
-            for (int i = 0; i < addChangesTimes; i++)
+            var random = new Random();
+
+            while (currentHeight > 1)
             {
-                this.cachedCoinView.Rewind();
+                currentHeight = random.Next(currentHeight - 1) + 1;
+
+                this.cachedCoinView.Rewind(currentHeight);
 
                 uint256 currentTip = this.cachedCoinView.GetTipHash();
 

src/Stratis.Bitcoin.Features.Consensus.Tests/Rules/TestRulesContext.cs

@@ -120,7 +120,7 @@ public override uint256 GetBlockHash()
             throw new NotImplementedException();
         }
 
-        public override Task<RewindState> RewindAsync()
+        public override Task<RewindState> RewindAsync(int targetHeight)
         {
             throw new NotImplementedException();
         }

src/Stratis.Bitcoin.Features.Consensus/CoinViews/CachedCoinView.cs

@@ -469,7 +469,7 @@ public void SaveChanges(IList<UnspentOutputs> unspentOutputs, IEnumerable<TxOut[
         }
 
         /// <inheritdoc />
-        public uint256 Rewind()
+        public uint256 Rewind(int targetHeight)
         {
             if (this.innerBlockHash == null)
             {
@@ -481,7 +481,7 @@ public uint256 Rewind()
 
             lock (this.lockobj)
             {
-                uint256 hash = this.inner.Rewind();
+                uint256 hash = this.inner.Rewind(targetHeight);
 
                 foreach (KeyValuePair<uint256, CacheItem> cachedUtxoItem in this.cachedUtxoItems)
                 {
@@ -497,7 +497,7 @@ public uint256 Rewind()
 
                 this.innerBlockHash = hash;
                 this.blockHash = hash;
-                this.blockHeight -= 1;
+                this.blockHeight = targetHeight;
 
                 if (this.rewindDataIndexCache != null)
                     this.rewindDataIndexCache.Initialize(this.blockHeight, this);

src/Stratis.Bitcoin.Features.Consensus/CoinViews/CoinView.cs

@@ -57,8 +57,9 @@ public interface ICoinView
         /// and restoring recently spent outputs as UTXOs.
         /// </para>
         /// </summary>
+        /// <param name="targetHeight">The target height.</param>
         /// <returns>Hash of the block header which is now the tip of the rewound coinview.</returns>
-        uint256 Rewind();
+        uint256 Rewind(int targetHeight);
 
         /// <summary>
         /// Gets the rewind data by block height.

src/Stratis.Bitcoin.Features.Consensus/CoinViews/DBreezeCoinView.cs

@@ -6,6 +6,7 @@
 using System.Threading;
 using DBreeze;
 using DBreeze.DataTypes;
+using DBreeze.Utils;
 using Microsoft.Extensions.Logging;
 using NBitcoin;
 using NBitcoin.BitcoinCore;
@@ -237,6 +238,7 @@ public void SaveChanges(IList<UnspentOutputs> unspentOutputs, IEnumerable<TxOut[
                     if (rewindDataList != null)
                     {
                         int nextRewindIndex = this.GetRewindIndex(transaction) + 1;
+
                         foreach (RewindData rewindData in rewindDataList)
                         {
                             this.logger.LogDebug("Rewind state #{0} created.", nextRewindIndex);
@@ -292,43 +294,72 @@ public RewindData GetRewindData(int height)
         }
 
         /// <inheritdoc />
-        public uint256 Rewind()
+        public uint256 Rewind(int targetHeight)
         {
             uint256 res = null;
             using (DBreeze.Transactions.Transaction transaction = this.CreateTransaction())
             {
+                int currentHeight = this.GetRewindIndex(transaction);
+
+                Guard.Assert(targetHeight >= 0 && targetHeight < currentHeight);
+
                 transaction.SynchronizeTables("BlockHash", "Coins", "Rewind");
-                if (this.GetRewindIndex(transaction) == 0)
+
+                if (targetHeight == 0)
                 {
                     transaction.RemoveAllKeys("Coins", true);
-                    this.SetBlockHash(transaction, this.network.GenesisHash);
+                    transaction.RemoveAllKeys("Rewind", true);
 
                     res = this.network.GenesisHash;
                 }
                 else
                 {
                     transaction.ValuesLazyLoadingIsOn = false;
 
-                    Row<int, byte[]> firstRow = transaction.SelectBackward<int, byte[]>("Rewind").FirstOrDefault();
-                    transaction.RemoveKey("Rewind", firstRow.Key);
-                    var rewindData = this.dBreezeSerializer.Deserialize<RewindData>(firstRow.Value);
-                    this.SetBlockHash(transaction, rewindData.PreviousBlockHash);
+                    var keysToRemove = new List<int>();
+                    var changes = new Dictionary<uint256, Coins>();
 
-                    foreach (uint256 txId in rewindData.TransactionsToRemove)
+                    // Determine rewind data to remove up to but excluding the target height.
+                    for (;  currentHeight > targetHeight; currentHeight--)
                     {
-                        this.logger.LogDebug("Outputs of transaction ID '{0}' will be removed.", txId);
-                        transaction.RemoveKey("Coins", txId.ToBytes(false));
-                    }
+                        Row<int, byte[]> firstRow = transaction.Select<int, byte[]>("Rewind", currentHeight);
+                        var rewindData = this.dBreezeSerializer.Deserialize<RewindData>(firstRow.Value);
+                        keysToRemove.Add(firstRow.Key);
 
-                    foreach (UnspentOutputs coin in rewindData.OutputsToRestore)
-                    {
-                        this.logger.LogDebug("Outputs of transaction ID '{0}' will be restored.", coin.TransactionId);
-                        transaction.Insert("Coins", coin.TransactionId.ToBytes(false), this.dBreezeSerializer.Serialize(coin.ToCoins()));
+                        foreach (uint256 txId in rewindData.TransactionsToRemove)
+                        {
+                            this.logger.LogTrace("Outputs of transaction ID '{0}' will be removed.", txId);
+                            changes[txId] = null;
+                        }
+
+                        foreach (UnspentOutputs coin in rewindData.OutputsToRestore)
+                        {
+                            this.logger.LogTrace("Outputs of transaction ID '{0}' will be restored.", coin.TransactionId);
+                            changes[coin.TransactionId] = coin.ToCoins();
+                        }
+
+                        res = rewindData.PreviousBlockHash;
                     }
 
-                    res = rewindData.PreviousBlockHash;
+                    var byteListComparer = new ByteListComparer();
+
+                    // Remove the rewind data key.
+                    foreach (int key in keysToRemove.OrderBy(k => k))
+                        transaction.RemoveKey("Rewind", key);
+
+                    // Remove coins where changes have null.
+                    foreach (uint256 txId in changes.Where(x => x.Value == null).Select(x => x.Key).OrderBy(t => t.ToBytes(false), byteListComparer))
+                        transaction.RemoveKey("Coins", txId.ToBytes(false));
+
+                    // Add coins where changes contain the coins to add.
+                    foreach (KeyValuePair<uint256, Coins> kv in changes.Where(x => x.Value != null).OrderBy(c => c.Key.ToBytes(false), byteListComparer))
+                        transaction.Insert("Coins", kv.Key.ToBytes(false), this.dBreezeSerializer.Serialize(kv.Value));
                 }
 
+                // Set to hash of new tip.
+                this.SetBlockHash(transaction, res);
+
+                // Commit the changes.
                 transaction.Commit();
             }
 

src/Stratis.Bitcoin.Features.Consensus/CoinViews/InMemoryCoinView.cs

@@ -91,7 +91,7 @@ public void SaveChanges(IList<UnspentOutputs> unspentOutputs, IEnumerable<TxOut[
         }
 
         /// <inheritdoc />
-        public uint256 Rewind()
+        public uint256 Rewind(int targetHeight)
         {
             throw new NotImplementedException();
         }

src/Stratis.Bitcoin.Features.Consensus/Rules/PowConsensusRuleEngine.cs

@@ -51,11 +51,11 @@ public override uint256 GetBlockHash()
         }
 
         /// <inheritdoc />
-        public override Task<RewindState> RewindAsync()
+        public override Task<RewindState> RewindAsync(int targetHeight)
         {
             var state = new RewindState()
             {
-                BlockHash = this.UtxoSet.Rewind()
+                BlockHash = this.UtxoSet.Rewind(targetHeight)
             };
 
             return Task.FromResult(state);
@@ -82,7 +82,7 @@ public override void Initialize(ChainedHeader chainTip)
                 this.logger.LogInformation("Rewinding coin db from {0}", consensusTipHash);
                 // In case block store initialized behind, rewind until or before the block store tip.
                 // The node will complete loading before connecting to peers so the chain will never know if a reorg happened.
-                consensusTipHash = breezeCoinView.Rewind();
+                consensusTipHash = breezeCoinView.Rewind(chainTip.Height);
             }
         }
 

src/Stratis.Bitcoin.Features.Consensus/StakeChainStore.cs

@@ -53,7 +53,7 @@ public void Load()
 
             while (currentHeader == null)
             {
-                hash = this.dBreezeCoinView.Rewind();
+                hash = this.dBreezeCoinView.Rewind(this.chainIndexer.Height);
                 currentHeader = this.chainIndexer.GetHeader(hash);
             }
 

src/Stratis.Bitcoin.Features.MemoryPool/MemPoolCoinView.cs

@@ -73,7 +73,7 @@ public void SaveChanges(IList<UnspentOutputs> unspentOutputs, IEnumerable<TxOut[
         }
 
         /// <inheritdoc />
-        public uint256 Rewind()
+        public uint256 Rewind(int targetHeight)
         {
             throw new NotImplementedException();
         }

src/Stratis.Bitcoin.IntegrationTests/CoinViewTester.cs

@@ -75,8 +75,7 @@ public uint256 NewBlock()
 
         public uint256 Rewind()
         {
-            this.hash = this.coinView.Rewind();
-            this.blockHeight--;
+            this.hash = this.coinView.Rewind(--this.blockHeight);
             return this.hash;
         }
     }

src/Stratis.Bitcoin.Tests/Consensus/TestInMemoryCoinView.cs

@@ -97,7 +97,7 @@ public void SaveChanges(IList<UnspentOutputs> unspentOutputs, IEnumerable<TxOut[
         }
 
         /// <inheritdoc />
-        public uint256 Rewind()
+        public uint256 Rewind(int targetHeight)
         {
             throw new NotImplementedException();
         }

src/Stratis.Bitcoin/Consensus/ConsensusManager.cs

@@ -245,7 +245,7 @@ public async Task InitializeAsync(ChainedHeader chainTip)
 
                 // In case block store initialized behind, rewind until or before the block store tip.
                 // The node will complete loading before connecting to peers so the chain will never know if a reorg happened.
-                RewindState transitionState = await this.ConsensusRules.RewindAsync().ConfigureAwait(false);
+                RewindState transitionState = await this.ConsensusRules.RewindAsync(this.chainState.BlockStoreTip.Height).ConfigureAwait(false);
                 consensusTipHash = transitionState.BlockHash;
             }
 
@@ -724,7 +724,7 @@ private async Task<List<ChainedHeaderBlock>> RewindToForkPointAsync(ChainedHeade
                     }
                 }
 
-                await this.ConsensusRules.RewindAsync().ConfigureAwait(false);
+                await this.ConsensusRules.RewindAsync(current.Previous.Height).ConfigureAwait(false);
 
                 lock (this.peerLock)
                 {

src/Stratis.Bitcoin/Consensus/ConsensusRuleEngine.cs

@@ -288,7 +288,7 @@ private void ExecuteRules(IEnumerable<SyncConsensusRule> rules, RuleContext rule
         public abstract uint256 GetBlockHash();
 
         /// <inheritdoc />
-        public abstract Task<RewindState> RewindAsync();
+        public abstract Task<RewindState> RewindAsync(int targetHeight);
 
         [NoTrace]
         public T GetRule<T>() where T : ConsensusRuleBase

src/Stratis.Bitcoin/Consensus/IConsensusRuleEngine.cs

@@ -51,8 +51,9 @@ public interface IConsensusRuleEngine : IDisposable
         /// and restoring the chain to an earlier state.
         /// </para>
         /// </summary>
+        /// <param name="targetHeight">The target height.</param>
         /// <returns>Hash of the block header which is now the tip of the chain.</returns>
-        Task<RewindState> RewindAsync();
+        Task<RewindState> RewindAsync(int targetHeight);
 
         /// <summary>Execute header validation rules.</summary>
         /// <param name="header">The chained header that is going to be validated.</param>