DelayedRenderer<T> & DelayedActionRenderer<T> for stable app-side state transfer

.vscode/settings.json

@@ -19,5 +19,8 @@
     "struct",
     "unrender",
     "unrendered",
+    "unrenderer",
+    "unrendering",
+    "unrenders",
   ]
 }

CHANGES.md

@@ -106,6 +106,7 @@ To be released.
     BoundPeer, TimeSpan?, CancellationToken)` method with
     `Swarm<T>.FindSpecificPeerAsync(Address, int, TimeSpan?, CancellationToken)`.
     [[#981]]
+ -  Added `IActionContext.GetUnconsumedContext()` method.  [[#980]]
 
 ### Backward-incompatible network protocol changes
 
@@ -179,6 +180,8 @@ To be released.
  -  Added `IActionRenderer<T>` interface.  [[#959], [#967], [#970]]
  -  Added `AnonymousRenderer<T>` class.  [[#959], [#963]]
  -  Added `AnonymousActionRenderer<T>` interface.  [[#959], [#967], [#970]]
+ -  Added `DelayedRenderer<T>` class.  [[#980]]
+ -  Added `DelayedActionRenderer<T>` class.  [[#980]]
  -  Added `LoggedRenderer<T>` class.  [[#959], [#963]]
  -  Added `LoggedActionRenderer<T>` interface.  [[#959], [#967], [#970]]
  -  Added `BlockChain<T>.Renderers` property.  [[#945], [#959], [#963]]
@@ -304,6 +307,7 @@ To be released.
 [#967]: https://github.com/planetarium/libplanet/issues/967
 [#970]: https://github.com/planetarium/libplanet/pull/970
 [#972]: https://github.com/planetarium/libplanet/pull/972
+[#980]: https://github.com/planetarium/libplanet/pull/980
 [#981]: https://github.com/planetarium/libplanet/pull/981
 [sleep mode]: https://en.wikipedia.org/wiki/Sleep_mode
 

Libplanet.Tests/Action/ActionContextTest.cs

@@ -101,6 +101,33 @@ public void GuidVersionAndVariant()
             }
         }
 
+        [Fact]
+        public void GetUnconsumedContext()
+        {
+            var random = new System.Random();
+            var original = new ActionContext(
+                signer: random.NextAddress(),
+                miner: random.NextAddress(),
+                blockIndex: 1,
+                previousStates: new DumbAccountStateDelta(),
+                randomSeed: random.Next()
+            );
+
+            // Consume original's random state...
+            int[] values =
+            {
+                original.Random.Next(),
+                original.Random.Next(),
+                original.Random.Next(),
+            };
+
+            IActionContext clone = original.GetUnconsumedContext();
+            Assert.Equal(
+                values,
+                new[] { clone.Random.Next(), clone.Random.Next(), clone.Random.Next() }
+            );
+        }
+
         private class DumbAccountStateDelta : IAccountStateDelta
         {
             public IImmutableSet<Address> UpdatedAddresses =>

Libplanet.Tests/Blockchain/BlockChainTest.cs

@@ -704,30 +704,103 @@ public void UnstageAfterAppendComplete()
             Assert.Empty(_blockChain.GetStagedTransactionIds());
         }
 
+        [Fact]
+        public async Task ActionRenderersHaveDistinctContexts()
+        {
+            var policy = new NullPolicy<DumbAction>();
+            var store = new DefaultStore(null);
+            var generatedRandomValueLogs = new List<int>();
+            IActionRenderer<DumbAction>[] renderers = Enumerable.Range(0, 2).Select(i =>
+                new LoggedActionRenderer<DumbAction>(
+                    new AnonymousActionRenderer<DumbAction>
+                    {
+                        ActionRenderer = (act, context, nextStates) =>
+                            // Consuming the random state through IRandom.Next() should not
+                            // affect contexts passed to other action renderers.
+                            generatedRandomValueLogs.Add(context.Random.Next()),
+                    },
+                    Log.Logger.ForContext("RendererIndex", i)
+                )
+            ).ToArray();
+            BlockChain<DumbAction> blockChain = TestUtils.MakeBlockChain(
+                policy,
+                store,
+                renderers: renderers
+            );
+            var privateKey = new PrivateKey();
+            var action = new DumbAction(default, string.Empty);
+            var actions = new[] { action };
+            blockChain.MakeTransaction(privateKey, actions);
+            Block<DumbAction> block = await blockChain.MineBlock(_fx.Address1, append: false);
+
+            generatedRandomValueLogs.Clear();
+            Assert.Empty(generatedRandomValueLogs);
+            blockChain.Append(block);
+            Assert.Equal(2, generatedRandomValueLogs.Count);
+            Assert.Equal(generatedRandomValueLogs[0], generatedRandomValueLogs[1]);
+        }
+
+        [Fact]
+        public async Task RenderActionsAfterBlockIsRendered()
+        {
+            var policy = new NullPolicy<DumbAction>();
+            var store = new DefaultStore(null);
+            int idx = 0;
+            var blockLogs = new List<(Block<DumbAction> Old, Block<DumbAction> New, int Index)>();
+            var actionLogs = new List<(ActionEvaluation Evaluation, int Index)>();
+            IActionRenderer<DumbAction> renderer = new AnonymousActionRenderer<DumbAction>
+            {
+                BlockRenderer = (oldTip, newTip) =>
+                   blockLogs.Add((oldTip, newTip, idx++)),
+                ActionRenderer = (act, context, nextStates) =>
+                    actionLogs.Add((new ActionEvaluation(act, context, nextStates), idx++)),
+            };
+            renderer = new LoggedActionRenderer<DumbAction>(renderer, Log.Logger);
+            BlockChain<DumbAction> blockChain =
+                TestUtils.MakeBlockChain(policy, store, renderers: new[] { renderer });
+            var privateKey = new PrivateKey();
+
+            var action = new DumbAction(default, string.Empty);
+            var actions = new[] { action };
+            blockChain.MakeTransaction(privateKey, actions);
+            idx = 0;
+            blockLogs.Clear();
+            actionLogs.Clear();
+            Block<DumbAction> prevBlock = blockChain.Tip;
+            Block<DumbAction> block = await blockChain.MineBlock(_fx.Address1);
+
+            Assert.Equal(2, blockChain.Count);
+            Assert.Single(blockLogs);
+            Assert.Single(actionLogs);
+            Assert.Equal((prevBlock, block, 0), blockLogs[0]);
+            Assert.Equal(1, actionLogs[0].Index);
+            Assert.Equal(action, actionLogs[0].Evaluation.Action);
+        }
+
         [Fact]
         public async Task RenderActionsAfterAppendComplete()
         {
-             var policy = new NullPolicy<DumbAction>();
-             var store = new DefaultStore(null);
-             IActionRenderer<DumbAction> renderer = new AnonymousActionRenderer<DumbAction>
-             {
-                 ActionRenderer = (_, __, nextStates) =>
-                     throw new SomeException("thrown by renderer"),
-             };
-             renderer = new LoggedActionRenderer<DumbAction>(renderer, Log.Logger);
-             BlockChain<DumbAction> blockChain =
-                 TestUtils.MakeBlockChain(policy, store, renderers: new[] { renderer });
-             var privateKey = new PrivateKey();
-
-             var action = new DumbAction(default, string.Empty);
-             var actions = new[] { action };
-             blockChain.MakeTransaction(privateKey, actions);
-
-             SomeException e = await Assert.ThrowsAsync<SomeException>(
-                 async () => await blockChain.MineBlock(_fx.Address1)
-             );
-             Assert.Equal("thrown by renderer", e.Message);
-             Assert.Equal(2, blockChain.Count);
+            var policy = new NullPolicy<DumbAction>();
+            var store = new DefaultStore(null);
+            IActionRenderer<DumbAction> renderer = new AnonymousActionRenderer<DumbAction>
+            {
+                ActionRenderer = (_, __, nextStates) =>
+                    throw new SomeException("thrown by renderer"),
+            };
+            renderer = new LoggedActionRenderer<DumbAction>(renderer, Log.Logger);
+            BlockChain<DumbAction> blockChain =
+                TestUtils.MakeBlockChain(policy, store, renderers: new[] { renderer });
+            var privateKey = new PrivateKey();
+
+            var action = new DumbAction(default, string.Empty);
+            var actions = new[] { action };
+            blockChain.MakeTransaction(privateKey, actions);
+
+            SomeException e = await Assert.ThrowsAsync<SomeException>(
+                async () => await blockChain.MineBlock(_fx.Address1)
+            );
+            Assert.Equal("thrown by renderer", e.Message);
+            Assert.Equal(2, blockChain.Count);
         }
 
         [Fact]