Introduce Swarm<T>.Reorged event

CHANGES.md

@@ -103,6 +103,8 @@ To be released.
      -  Added `StateCompleterSet<T>` struct.
      -  Added `StateCompleters<T>` static class.
      -  Added `FungibleAssetStateCompleters<T>` static class.
+ -  Added `Reorged` event on `BlockChain<T>`.  [[#945]]
+ -  Added `ReorgedEventArgs` class.  [[#945]]
 
 ### Behavioral changes
 
@@ -192,6 +194,7 @@ To be released.
 [#936]: https://github.com/planetarium/libplanet/pull/936
 [#940]: https://github.com/planetarium/libplanet/pull/940
 [#941]: https://github.com/planetarium/libplanet/pull/941
+[#945]: https://github.com/planetarium/libplanet/pull/945
 [sleep mode]: https://en.wikipedia.org/wiki/Sleep_mode
 
 

Libplanet.Tests/Blockchain/BlockChainTest.cs

@@ -2173,6 +2173,43 @@ void TipChangedHandler(object target, BlockChain<DumbAction>.TipChangedEventArgs
             // TODO: Add test cases for swap
         }
 
+        [Fact]
+        private async void Reorged()
+        {
+            Block<DumbAction> actualOldTip = null;
+            Block<DumbAction> actualNewTip = null;
+            Block<DumbAction> actualBranchpoint = null;
+            int callCount = 0;
+
+            _blockChain.Reorged += (target, args) =>
+            {
+                actualOldTip = args.OldTip;
+                actualNewTip = args.NewTip;
+                actualBranchpoint = args.Branchpoint;
+                callCount += 1;
+            };
+            var branchpoint = _blockChain.Tip;
+            var fork = _blockChain.Fork(_blockChain.Tip.Hash);
+            await fork.MineBlock(_fx.Address1);
+            await fork.MineBlock(_fx.Address2);
+            await _blockChain.MineBlock(_fx.Address3);
+
+            var oldTip = _blockChain.Tip;
+            var newTip = fork.Tip;
+
+            Assert.Null(actualOldTip);
+            Assert.Null(actualNewTip);
+            Assert.Null(actualBranchpoint);
+            Assert.Equal(0, callCount);
+
+            _blockChain.Swap(fork, false);
+
+            Assert.Equal(oldTip.Hash, actualOldTip.Hash);
+            Assert.Equal(newTip.Hash, actualNewTip.Hash);
+            Assert.Equal(branchpoint.Hash, actualBranchpoint.Hash);
+            Assert.Equal(1, callCount);
+        }
+
         [Fact]
         private async void AbortMining()
         {

Libplanet/Blockchain/BlockChain.cs

@@ -176,6 +176,11 @@ bool render
         /// </summary>
         public event EventHandler<TipChangedEventArgs> TipChanged;
 
+        /// <summary>
+        /// An event which is invoked when the chain is reorged.
+        /// </summary>
+        public event EventHandler<ReorgedEventArgs> Reorged;
+
         public IBlockPolicy<T> Policy { get; }
 
         /// <summary>
@@ -1344,11 +1349,20 @@ IEnumerable<TxId> GetTxIdsWithRange(BlockChain<T> chain, Block<T> start, Block<T
                     Hash = other.Tip.Hash,
                     Index = other.Tip.Index,
                 };
+
+                var reorgedEventArgs = new ReorgedEventArgs
+                {
+                    OldTip = Tip,
+                    NewTip = other.Tip,
+                    Branchpoint = topmostCommon,
+                };
+
                 Guid obsoleteId = Id;
                 Id = other.Id;
                 Store.SetCanonicalChainId(Id);
                 _blocks = new BlockSet<T>(Store);
                 TipChanged?.Invoke(this, tipChangedEventArgs);
+                Reorged?.Invoke(this, reorgedEventArgs);
                 _transactions = new TransactionSet<T>(Store);
                 Store.DeleteChainId(obsoleteId);
             }
@@ -1624,5 +1638,26 @@ public class TipChangedEventArgs : EventArgs
             /// </summary>
             public HashDigest<SHA256> Hash { get; set; }
         }
+
+        /// <summary>
+        /// Provides data for the <see cref="BlockChain{T}.Reorged"/> event.
+        /// </summary>
+        public class ReorgedEventArgs : EventArgs
+        {
+            /// <summary>
+            /// The <see cref="BlockChain{T}.Tip"/> before the chain is reorged.
+            /// </summary>
+            public Block<T> OldTip { get; set; }
+
+            /// <summary>
+            /// The <see cref="BlockChain{T}.Tip"/> after the chain is reorged.
+            /// </summary>
+            public Block<T> NewTip { get; set; }
+
+            /// <summary>
+            /// The <see cref="Block{T}"/> point of the chain branches off.
+            /// </summary>
+            public Block<T> Branchpoint { get; set; }
+        }
     }
 }