From a90abe468b8dc3ffed34515797885dedcb4e0723 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 7 Sep 2023 21:02:34 +0900
Subject: [PATCH 01/72] Prepare 3.3.1

---
 CHANGES.md                 | 6 ++++++
 Libplanet/Libplanet.csproj | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index 1a151f51d26..8b4b00c25d6 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,12 @@
 Libplanet changelog
 ===================
 
+Version 3.3.1
+-------------
+
+To be released.
+
+
 Version 3.3.0
 -------------
 
diff --git a/Libplanet/Libplanet.csproj b/Libplanet/Libplanet.csproj
index 07772199473..5674140f862 100644
--- a/Libplanet/Libplanet.csproj
+++ b/Libplanet/Libplanet.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <PackageId>Libplanet</PackageId>
     <Title>Libplanet</Title>
-    <VersionPrefix>3.3.0</VersionPrefix>
+    <VersionPrefix>3.3.1</VersionPrefix>
     <!-- Note: don't be confused by the word "prefix" here.  It's merely a
     version without suffix like "-dev.123".  See the following examples:
       Version: 1.2.3-dev.456

From fb249addd5bf730d12457b9932565a19cd969872 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 8 Sep 2023 11:58:50 +0900
Subject: [PATCH 02/72] Added test

---
 Libplanet.Tests/Store/Trie/MerkleTrieTest.cs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/Libplanet.Tests/Store/Trie/MerkleTrieTest.cs b/Libplanet.Tests/Store/Trie/MerkleTrieTest.cs
index 4f309fb9a04..e22c25f7b91 100644
--- a/Libplanet.Tests/Store/Trie/MerkleTrieTest.cs
+++ b/Libplanet.Tests/Store/Trie/MerkleTrieTest.cs
@@ -288,6 +288,22 @@ public void GetNode()
             Assert.IsType<HashNode>(trie.GetNode(Nibbles.FromHex("0010")));
         }
 
+        [Fact]
+        public void ResolveToValueAtTheEndOfShortNode()
+        {
+            IStateStore stateStore = new TrieStateStore(new MemoryKeyValueStore());
+            ITrie trie = stateStore.GetStateRoot(null);
+
+            KeyBytes key00 = new KeyBytes(new byte[] { 0x00 });
+            IValue value00 = new Text("00");
+            KeyBytes key0000 = new KeyBytes(new byte[] { 0x00, 0x00 });
+
+            trie = trie.Set(key00, value00);
+            trie = stateStore.Commit(trie);
+
+            Assert.Null(trie.Get(key0000));
+        }
+
         [Fact]
         public void SetValueToExtendedKey()
         {

From 2a04941effecf12c48f366119f30f78c1838c8b9 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 8 Sep 2023 11:55:25 +0900
Subject: [PATCH 03/72] Bug fix for trie value resolution

---
 Libplanet.Store/Trie/MerkleTrie.Path.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Libplanet.Store/Trie/MerkleTrie.Path.cs b/Libplanet.Store/Trie/MerkleTrie.Path.cs
index e9331377f27..1ef133c199f 100644
--- a/Libplanet.Store/Trie/MerkleTrie.Path.cs
+++ b/Libplanet.Store/Trie/MerkleTrie.Path.cs
@@ -9,7 +9,9 @@ public partial class MerkleTrie
             node switch
             {
                 null => null,
-                ValueNode valueNode => valueNode.Value,
+                ValueNode valueNode => !cursor.RemainingAnyNibbles
+                    ? valueNode.Value
+                    : null,
                 ShortNode shortNode => cursor.RemainingNibblesStartWith(shortNode.Key)
                     ? ResolveToValue(shortNode.Value, cursor.Next(shortNode.Key.Length))
                     : null,

From 7e552b6ae2fc2610b8b4c9e5048b283641346e5f Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 8 Sep 2023 12:04:22 +0900
Subject: [PATCH 04/72] Changelog

---
 CHANGES.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 8b4b00c25d6..0938540c48e 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -6,6 +6,11 @@ Version 3.3.1
 
 To be released.
 
+-  (Libplanet.Store) Fixed a bug where `ITrie.Get()` could wrongly retrieve
+   an `IValue` from a non-existent path.  [[#3420]]
+
+[#3420]: https://github.com/planetarium/libplanet/pull/3420
+
 
 Version 3.3.0
 -------------

From 1236953b4d868d2d6b730090f3e57d866724f075 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 8 Sep 2023 12:23:09 +0900
Subject: [PATCH 05/72] Release 3.3.1

---
 CHANGES.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index 0938540c48e..f06ae9b5bc9 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -4,7 +4,7 @@ Libplanet changelog
 Version 3.3.1
 -------------
 
-To be released.
+Released on September 8, 2023.
 
 -  (Libplanet.Store) Fixed a bug where `ITrie.Get()` could wrongly retrieve
    an `IValue` from a non-existent path.  [[#3420]]

From 7ced969e48fee56a6402ce06c54b0eb58149b5ac Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Mon, 18 Sep 2023 14:00:07 +0900
Subject: [PATCH 06/72] Added new GetAccountState() interface method

---
 Libplanet.Action/State/IBlockChainStates.cs   | 17 +++++++++++
 .../Queries/StateQueryTest.cs                 |  4 +++
 Libplanet/Blockchain/BlockChain.cs            |  7 ++++-
 Libplanet/Blockchain/BlockChainStates.cs      | 30 +++++++++++--------
 Libplanet/Blockchain/NullChainStates.cs       |  5 ++++
 5 files changed, 50 insertions(+), 13 deletions(-)

diff --git a/Libplanet.Action/State/IBlockChainStates.cs b/Libplanet.Action/State/IBlockChainStates.cs
index 3e2fa0b344d..a33f010fa1a 100644
--- a/Libplanet.Action/State/IBlockChainStates.cs
+++ b/Libplanet.Action/State/IBlockChainStates.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Security.Cryptography;
 using Bencodex.Types;
+using Libplanet.Common;
 using Libplanet.Crypto;
 using Libplanet.Store;
 using Libplanet.Store.Trie;
@@ -150,5 +152,20 @@ FungibleAssetValue GetTotalSupply(
         /// </exception>
         /// <seealso cref="IAccountState"/>
         IAccountState GetAccountState(BlockHash? offset);
+
+        /// <summary>
+        /// Returns the <see cref="IAccountState"/> in the <see cref="BlockChain"/>'s state storage
+        /// with <paramref name="hash"/>.
+        /// </summary>
+        /// <param name="hash">The state root hash for which to create
+        /// an <see cref="IAccountState"/>.</param>
+        /// <returns>
+        /// The <see cref="IAccountState"/> with <paramref name="hash"/> as its state root hash.
+        /// </returns>
+        /// <exception cref="ArgumentException">Thrown when no <see cref="ITrie"/> with
+        /// <paramref name="hash"/> as its state root hash is found.
+        /// </exception>
+        /// <seealso cref="IAccountState"/>
+        IAccountState GetAccountState(HashDigest<SHA256>? hash);
     }
 }
diff --git a/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs b/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
index 7319e5ed934..037f78fb1e0 100644
--- a/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
+++ b/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
@@ -17,6 +17,8 @@
 using Libplanet.Store.Trie;
 using Xunit;
 using static Libplanet.Explorer.Tests.GraphQLTestUtils;
+using Libplanet.Common;
+using System.Security.Cryptography;
 
 namespace Libplanet.Explorer.Tests.Queries;
 
@@ -194,6 +196,8 @@ public ValidatorSet GetValidatorSet(BlockHash? offset) =>
 
         public IAccountState GetAccountState(BlockHash? offset) => new MockAccount(offset);
 
+        public IAccountState GetAccountState(HashDigest<SHA256>? offset) => new MockAccount(null);
+
         public ITrie GetTrie(BlockHash? offset)
         {
             throw new System.NotImplementedException();
diff --git a/Libplanet/Blockchain/BlockChain.cs b/Libplanet/Blockchain/BlockChain.cs
index bef8f501cc2..2b48c883a2a 100644
--- a/Libplanet/Blockchain/BlockChain.cs
+++ b/Libplanet/Blockchain/BlockChain.cs
@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
+using System.Security.Cryptography;
 using System.Threading;
 using Bencodex.Types;
 using Libplanet.Action;
@@ -560,10 +561,14 @@ public FungibleAssetValue GetTotalSupply(Currency currency, BlockHash? offset) =
         public ValidatorSet GetValidatorSet(BlockHash? offset) =>
             _blockChainStates.GetValidatorSet(offset);
 
-        /// <inheritdoc cref="IBlockChainStates.GetAccountState" />
+        /// <inheritdoc cref="IBlockChainStates.GetAccountState(BlockHash?)" />
         public IAccountState GetAccountState(BlockHash? offset) =>
             _blockChainStates.GetAccountState(offset);
 
+        /// <inheritdoc cref="IBlockChainStates.GetAccountState(HashDigest{SHA256}?)" />
+        public IAccountState GetAccountState(HashDigest<SHA256>? hash) =>
+            _blockChainStates.GetAccountState(hash);
+
         /// <summary>
         /// Queries the recorded <see cref="TxExecution"/> for a successful or failed
         /// <see cref="Transaction"/> within a <see cref="Block"/>.
diff --git a/Libplanet/Blockchain/BlockChainStates.cs b/Libplanet/Blockchain/BlockChainStates.cs
index 6eb46aa30a1..69e2b05dbc5 100644
--- a/Libplanet/Blockchain/BlockChainStates.cs
+++ b/Libplanet/Blockchain/BlockChainStates.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action.State;
+using Libplanet.Common;
 using Libplanet.Crypto;
 using Libplanet.Store;
 using Libplanet.Store.Trie;
@@ -48,10 +50,14 @@ public FungibleAssetValue GetTotalSupply(Currency currency, BlockHash? offset) =
         public ValidatorSet GetValidatorSet(BlockHash? offset) =>
             GetAccountState(offset).GetValidatorSet();
 
-        /// <inheritdoc cref="IBlockChainStates.GetAccountState"/>
+        /// <inheritdoc cref="IBlockChainStates.GetAccountState(BlockHash?)"/>
         public IAccountState GetAccountState(BlockHash? offset) =>
             new AccountState(GetTrie(offset));
 
+        /// <inheritdoc cref="IBlockChainStates.GetAccountState(HashDigest{SHA256}?)"/>
+        public IAccountState GetAccountState(HashDigest<SHA256>? hash) =>
+            new AccountState(GetTrie(hash));
+
         /// <summary>
         /// Returns the state root associated with <see cref="BlockHash"/>
         /// <paramref name="offset"/>.
@@ -84,17 +90,7 @@ private ITrie GetTrie(BlockHash? offset)
             }
             else if (_store.GetStateRootHash(hash) is { } stateRootHash)
             {
-                if (_stateStore.ContainsStateRoot(stateRootHash))
-                {
-                    return _stateStore.GetStateRoot(stateRootHash);
-                }
-                else
-                {
-                    throw new ArgumentException(
-                        $"Could not find state root {stateRootHash} associated with " +
-                        $"block hash {offset} in {nameof(IStateStore)}.",
-                        nameof(offset));
-                }
+                return GetTrie(stateRootHash);
             }
             else
             {
@@ -103,5 +99,15 @@ private ITrie GetTrie(BlockHash? offset)
                     nameof(offset));
             }
         }
+
+        private ITrie GetTrie(HashDigest<SHA256>? hash)
+        {
+            ITrie trie = _stateStore.GetStateRoot(hash);
+            return trie.Recorded
+                ? trie
+                : throw new ArgumentException(
+                    $"Could not find state root {hash} in {nameof(IStateStore)}.",
+                    nameof(hash));
+        }
     }
 }
diff --git a/Libplanet/Blockchain/NullChainStates.cs b/Libplanet/Blockchain/NullChainStates.cs
index 6e9a2e72b8d..903fbeb2006 100644
--- a/Libplanet/Blockchain/NullChainStates.cs
+++ b/Libplanet/Blockchain/NullChainStates.cs
@@ -1,6 +1,8 @@
 using System.Collections.Generic;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action.State;
+using Libplanet.Common;
 using Libplanet.Crypto;
 using Libplanet.Store.Trie;
 using Libplanet.Types.Assets;
@@ -38,5 +40,8 @@ public ValidatorSet GetValidatorSet(BlockHash? offset) =>
 
         public IAccountState GetAccountState(BlockHash? offset) =>
             new AccountState(new MerkleTrie(_keyValueStore));
+
+        public IAccountState GetAccountState(HashDigest<SHA256>? hash) =>
+            new AccountState(new MerkleTrie(_keyValueStore));
     }
 }

From 636e8b74c40d5882914f9a84f165e979dfc2bf4e Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Mon, 18 Sep 2023 14:02:28 +0900
Subject: [PATCH 07/72] Changelog

---
 CHANGES.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 2e9f1cfdcff..d9784b55f4d 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -10,6 +10,9 @@ To be released.
 
 ### Backward-incompatible API changes
 
+ -  Added `IBlockChainStates.GetAccountState(HashDigest<SHA256>?)`
+    interface method.  [[#3425]]
+
 ### Backward-incompatible network protocol changes
 
 ### Backward-incompatible storage format changes
@@ -24,6 +27,8 @@ To be released.
 
 ### CLI tools
 
+[#3425]: https://github.com/planetarium/libplanet/pull/3425
+
 
 Version 3.3.1
 -------------

From e813b55e66c57a523b0a5266f79f5f7032da105b Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Mon, 18 Sep 2023 10:30:15 +0900
Subject: [PATCH 08/72] Introduce IActionRenderContext

---
 Libplanet.Action/ActionRenderContext.cs  | 82 ++++++++++++++++++++++
 Libplanet.Action/IActionRenderContext.cs | 86 ++++++++++++++++++++++++
 2 files changed, 168 insertions(+)
 create mode 100644 Libplanet.Action/ActionRenderContext.cs
 create mode 100644 Libplanet.Action/IActionRenderContext.cs

diff --git a/Libplanet.Action/ActionRenderContext.cs b/Libplanet.Action/ActionRenderContext.cs
new file mode 100644
index 00000000000..83a1ad374c8
--- /dev/null
+++ b/Libplanet.Action/ActionRenderContext.cs
@@ -0,0 +1,82 @@
+using System.Diagnostics.Contracts;
+using System.Security.Cryptography;
+using Libplanet.Common;
+using Libplanet.Crypto;
+using Libplanet.Types.Tx;
+
+namespace Libplanet.Action
+{
+    public class ActionRenderContext : IActionRenderContext
+    {
+        public ActionRenderContext(IActionContext context)
+            : this(
+                signer: context.Signer,
+                txId: context.TxId,
+                miner: context.Miner,
+                blockIndex: context.BlockIndex,
+                blockProtocolVersion: context.BlockProtocolVersion,
+                rehearsal: context.Rehearsal,
+                previousState: context.PreviousState.Trie.Hash,
+                random: context.GetUnconsumedContext().Random,
+                blockAction: context.BlockAction)
+        {
+        }
+
+        public ActionRenderContext(
+            Address signer,
+            TxId? txId,
+            Address miner,
+            long blockIndex,
+            int blockProtocolVersion,
+            bool rehearsal,
+            HashDigest<SHA256> previousState,
+            IRandom random,
+            bool blockAction)
+        {
+            Signer = signer;
+            TxId = txId;
+            Miner = miner;
+            BlockIndex = blockIndex;
+            BlockProtocolVersion = blockProtocolVersion;
+            Rehearsal = rehearsal;
+            PreviousState = previousState;
+            Random = random;
+            BlockAction = blockAction;
+        }
+
+        /// <inheritdoc cref="IActionRenderContext.Signer"/>
+        [Pure]
+        public Address Signer { get; }
+
+        /// <inheritdoc cref="IActionRenderContext.TxId"/>
+        [Pure]
+        public TxId? TxId { get; }
+
+        /// <inheritdoc cref="IActionRenderContext.Miner"/>
+        [Pure]
+        public Address Miner { get; }
+
+        /// <inheritdoc cref="IActionRenderContext.BlockIndex"/>
+        [Pure]
+        public long BlockIndex { get; }
+
+        /// <inheritdoc cref="IActionRenderContext.BlockProtocolVersion"/>
+        [Pure]
+        public int BlockProtocolVersion { get; }
+
+        /// <inheritdoc cref="IActionRenderContext.Rehearsal"/>
+        [Pure]
+        public bool Rehearsal { get; }
+
+        /// <inheritdoc cref="IActionRenderContext.PreviousState"/>
+        [Pure]
+        public HashDigest<SHA256> PreviousState { get; }
+
+        /// <inheritdoc cref="IActionRenderContext.Random"/>
+        public IRandom Random { get; }
+
+        /// <inheritdoc cref="IActionRenderContext.BlockAction"/>
+        [Pure]
+        public bool BlockAction { get; }
+    }
+}
diff --git a/Libplanet.Action/IActionRenderContext.cs b/Libplanet.Action/IActionRenderContext.cs
new file mode 100644
index 00000000000..42a32aaf1c0
--- /dev/null
+++ b/Libplanet.Action/IActionRenderContext.cs
@@ -0,0 +1,86 @@
+using System.Diagnostics.Contracts;
+using System.Security.Cryptography;
+using Libplanet.Common;
+using Libplanet.Crypto;
+using Libplanet.Types.Blocks;
+using Libplanet.Types.Tx;
+
+namespace Libplanet.Action
+{
+    /// <summary>
+    /// Contextual data determined by a transaction and a block for rendering.
+    /// </summary>
+    public interface IActionRenderContext
+    {
+        /// <summary>
+        /// The <see cref="Transaction.Signer"/> of the <see cref="Transaction"/> that contains
+        /// the <see cref="IAction"/> to be executed.  If the <see cref="IAction"/> is
+        /// not part of a <see cref="Transaction"/>, e.g. <see cref="IBlockPolicy.BlockAction"/>,
+        /// this is set to <see cref="Block.Miner"/> instead.
+        /// </summary>
+        [Pure]
+        Address Signer { get; }
+
+        /// <summary>
+        /// The <see cref="Transaction.Id"/> of the <see cref="Transaction"/> that contains
+        /// the <see cref="IAction"/>.  If the <see cref="IAction"/> is not part of
+        /// a <see cref="Transaction"/>, e.g. <see cref="IBlockPolicy.BlockAction"/>,
+        /// this is set to <see langword="null"/>.
+        /// </summary>
+        [Pure]
+        TxId? TxId { get; }
+
+        /// <summary>
+        /// The <see cref="Block.Miner"/> of the <see cref="Block"/> that contains
+        /// the <see cref="IAction"/>.
+        /// </summary>
+        [Pure]
+        Address Miner { get; }
+
+        /// <summary>
+        /// The <see cref="Block.Index"/> of the <see cref="Block"/> that contains
+        /// the <see cref="IAction"/>.
+        /// </summary>
+        [Pure]
+        long BlockIndex { get; }
+
+        /// <summary>
+        /// The <see cref="Block.ProtocolVersion"/> of the <see cref="Block"/> that contains
+        /// the <see cref="IAction"/>.
+        /// </summary>
+        [Pure]
+        int BlockProtocolVersion { get; }
+
+        /// <summary>
+        /// Whether an <see cref="IAction"/> is being executed during
+        /// &#x201c;rehearsal mode&#x201d;, that there is nothing
+        /// in <see cref="PreviousState"/>.
+        /// </summary>
+        [Pure]
+        bool Rehearsal { get; }
+
+        /// <summary>
+        /// The state root hash of the previous state.
+        /// </summary>
+        [Pure]
+        HashDigest<SHA256> PreviousState { get; }
+
+        /// <summary>
+        /// An initialized pseudorandom number generator.  Its seed (state)
+        /// is determined by a block and a transaction, which is
+        /// deterministic so that every node can replay the same action and
+        /// then reproduce the same result, while neither a single block miner
+        /// nor a single transaction signer can predict the result and cheat.
+        /// </summary>
+        /// <returns>A random object that shares interface mostly equivalent
+        /// to <see cref="System.Random"/>.</returns>
+        IRandom Random { get; }
+
+        /// <summary>
+        /// Whether this action is executed as a block action.
+        /// <see langword="false"/> if it belongs to a transaction.
+        /// </summary>
+        [Pure]
+        bool BlockAction { get; }
+    }
+}

From faa366128bfb991d472a7bcabb95fd326cd2df2c Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Mon, 18 Sep 2023 10:47:47 +0900
Subject: [PATCH 09/72] Use IActionRenderContext

---
 Libplanet.Action/ActionRenderContext.cs       |  2 +-
 .../Renderers/AnonymousActionRendererTest.cs  | 10 ++++-----
 .../Renderers/LoggedActionRendererTest.cs     | 11 +++++-----
 Libplanet/Blockchain/BlockChain.Swap.cs       |  4 ++--
 .../Renderers/AnonymousActionRenderer.cs      | 21 +++++++++++--------
 .../Renderers/AtomicActionRenderer.cs         | 19 +++++++++--------
 .../Debug/RecordingActionRenderer.cs          |  4 ++--
 .../Renderers/Debug/RenderRecord.cs           |  8 +++----
 .../Debug/ValidatingActionRenderer.cs         | 10 ++++-----
 .../Blockchain/Renderers/IActionRenderer.cs   | 13 ++++++------
 .../Renderers/LoggedActionRenderer.cs         | 12 +++++------
 11 files changed, 56 insertions(+), 58 deletions(-)

diff --git a/Libplanet.Action/ActionRenderContext.cs b/Libplanet.Action/ActionRenderContext.cs
index 83a1ad374c8..8857356f2c1 100644
--- a/Libplanet.Action/ActionRenderContext.cs
+++ b/Libplanet.Action/ActionRenderContext.cs
@@ -17,7 +17,7 @@ public ActionRenderContext(IActionContext context)
                 blockProtocolVersion: context.BlockProtocolVersion,
                 rehearsal: context.Rehearsal,
                 previousState: context.PreviousState.Trie.Hash,
-                random: context.GetUnconsumedContext().Random,
+                random: context.Random,
                 blockAction: context.BlockAction)
         {
         }
diff --git a/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs b/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs
index 4dc584e9ce5..22beb546cd9 100644
--- a/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs
+++ b/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs
@@ -16,8 +16,8 @@ public class AnonymousActionRendererTest
 
         private static IAccount _account = new Account(MockAccountState.Empty);
 
-        private static IActionContext _actionContext =
-            new ActionContext(
+        private static IActionRenderContext _actionContext =
+            new ActionRenderContext(new ActionContext(
                 default,
                 default,
                 default,
@@ -25,7 +25,7 @@ public class AnonymousActionRendererTest
                 default,
                 _account,
                 default,
-                0);
+                0));
 
         private static Exception _exception = new Exception();
 
@@ -41,7 +41,7 @@ public class AnonymousActionRendererTest
         [Fact]
         public void ActionRenderer()
         {
-            (IValue, IActionContext, IAccount)? record = null;
+            (IValue, IActionRenderContext, IAccount)? record = null;
             var renderer = new AnonymousActionRenderer
             {
                 ActionRenderer = (action, context, nextStates) =>
@@ -63,7 +63,7 @@ record = (action, context, nextStates),
         [Fact]
         public void ActionErrorRenderer()
         {
-            (IValue, IActionContext, Exception)? record = null;
+            (IValue, IActionRenderContext, Exception)? record = null;
             var renderer = new AnonymousActionRenderer
             {
                 ActionErrorRenderer = (action, context, exception) =>
diff --git a/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs b/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs
index a6a20d8fa03..1c9d4e66db2 100644
--- a/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs
+++ b/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs
@@ -68,8 +68,8 @@ public void ActionRenderings(bool error, bool rehearsal, bool exception)
         {
             bool called = false;
             LogEvent firstLog = null;
-            IActionContext actionContext =
-                new ActionContext(
+            IActionRenderContext actionContext =
+                new ActionRenderContext(new ActionContext(
                     default,
                     default,
                     default,
@@ -78,13 +78,12 @@ public void ActionRenderings(bool error, bool rehearsal, bool exception)
                     _account,
                     default,
                     0,
-                    rehearsal
-                );
+                    rehearsal));
             Exception actionError = new Exception();
             IActionRenderer actionRenderer;
             if (error)
             {
-                Action<IValue, IActionContext, Exception> render = (action, cxt, e) =>
+                Action<IValue, IActionRenderContext, Exception> render = (action, cxt, e) =>
                 {
                     LogEvent[] logs = LogEvents.ToArray();
                     Assert.Single(logs);
@@ -105,7 +104,7 @@ public void ActionRenderings(bool error, bool rehearsal, bool exception)
             }
             else
             {
-                Action<IValue, IActionContext, IAccount> render = (action, cxt, next) =>
+                Action<IValue, IActionRenderContext, IAccount> render = (action, cxt, next) =>
                 {
                     LogEvent[] logs = LogEvents.ToArray();
                     Assert.Single(logs);
diff --git a/Libplanet/Blockchain/BlockChain.Swap.cs b/Libplanet/Blockchain/BlockChain.Swap.cs
index fbfc30203b1..7525fc1d81e 100644
--- a/Libplanet/Blockchain/BlockChain.Swap.cs
+++ b/Libplanet/Blockchain/BlockChain.Swap.cs
@@ -232,14 +232,14 @@ internal long RenderActions(
                     {
                         renderer.RenderAction(
                             evaluation.Action,
-                            evaluation.InputContext.GetUnconsumedContext(),
+                            new ActionRenderContext(evaluation.InputContext.GetUnconsumedContext()),
                             evaluation.OutputState);
                     }
                     else
                     {
                         renderer.RenderActionError(
                             evaluation.Action,
-                            evaluation.InputContext.GetUnconsumedContext(),
+                            new ActionRenderContext(evaluation.InputContext.GetUnconsumedContext()),
                             evaluation.Exception);
                     }
 
diff --git a/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs b/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs
index 12cdad41dfc..366b26fc35d 100644
--- a/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs
@@ -29,15 +29,15 @@ public sealed class AnonymousActionRenderer : AnonymousRenderer, IActionRenderer
     {
         /// <summary>
         /// A callback function to be invoked together with
-        /// <see cref="RenderAction(IValue, IActionContext, IAccount)"/>.
+        /// <see cref="RenderAction(IValue, IActionRenderContext, IAccount)"/>.
         /// </summary>
-        public Action<IValue, IActionContext, IAccount>? ActionRenderer { get; set; }
+        public Action<IValue, IActionRenderContext, IAccount>? ActionRenderer { get; set; }
 
         /// <summary>
         /// A callback function to be invoked together with
-        /// <see cref="RenderActionError(IValue, IActionContext, Exception)"/>.
+        /// <see cref="RenderActionError(IValue, IActionRenderContext, Exception)"/>.
         /// </summary>
-        public Action<IValue, IActionContext, Exception>? ActionErrorRenderer { get; set; }
+        public Action<IValue, IActionRenderContext, Exception>? ActionErrorRenderer { get; set; }
 
         /// <summary>
         /// A callback function to be invoked together with
@@ -46,18 +46,21 @@ public sealed class AnonymousActionRenderer : AnonymousRenderer, IActionRenderer
         public Action<Block, Block>? BlockEndRenderer { get; set; }
 
         /// <inheritdoc
-        /// cref="IActionRenderer.RenderAction(IValue, IActionContext, IAccount)"/>
+        /// cref="IActionRenderer.RenderAction(IValue, IActionRenderContext, IAccount)"/>
         public void RenderAction(
             IValue action,
-            IActionContext context,
+            IActionRenderContext context,
             IAccount nextStates
         ) =>
             ActionRenderer?.Invoke(action, context, nextStates);
 
         /// <inheritdoc
-        /// cref="IActionRenderer.RenderActionError(IValue, IActionContext, Exception)"/>
-        public void RenderActionError(IValue action, IActionContext context, Exception exception)
-            => ActionErrorRenderer?.Invoke(action, context, exception);
+        /// cref="IActionRenderer.RenderActionError(IValue, IActionRenderContext, Exception)"/>
+        public void RenderActionError(
+            IValue action,
+            IActionRenderContext context,
+            Exception exception) =>
+                ActionErrorRenderer?.Invoke(action, context, exception);
 
         /// <inheritdoc cref="IActionRenderer.RenderBlockEnd(Block, Block)"/>
         public void RenderBlockEnd(Block oldTip, Block newTip) =>
diff --git a/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs b/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs
index 1073452edec..0532abb0b5d 100644
--- a/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs
@@ -20,7 +20,7 @@ namespace Libplanet.Blockchain.Renderers
     /// </remarks>
     public sealed class AtomicActionRenderer : IActionRenderer
     {
-        private readonly List<(IValue, IActionContext, IAccount)> _eventBuffer;
+        private readonly List<(IValue, IActionRenderContext, IAccount)> _eventBuffer;
         private TxId? _lastTxId;
         private bool _errored;
 
@@ -35,7 +35,7 @@ public AtomicActionRenderer(IActionRenderer actionRenderer)
         {
             ActionRenderer = actionRenderer;
             _lastTxId = null;
-            _eventBuffer = new List<(IValue, IActionContext, IAccount)>();
+            _eventBuffer = new List<(IValue, IActionRenderContext, IAccount)>();
             _errored = false;
         }
 
@@ -58,11 +58,10 @@ public void RenderBlockEnd(Block oldTip, Block newTip)
             ActionRenderer.RenderBlockEnd(oldTip, newTip);
         }
 
-        /// <inheritdoc
-        /// cref="IActionRenderer.RenderAction(IValue, IActionContext, IAccount)"/>
+        /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public void RenderAction(
             IValue action,
-            IActionContext context,
+            IActionRenderContext context,
             IAccount nextStates
         )
         {
@@ -81,9 +80,11 @@ IAccount nextStates
             }
         }
 
-        /// <inheritdoc
-        /// cref="IActionRenderer.RenderActionError(IValue, IActionContext, Exception)"/>
-        public void RenderActionError(IValue action, IActionContext context, Exception exception)
+        /// <inheritdoc cref="IActionRenderer.RenderActionError"/>
+        public void RenderActionError(
+            IValue action,
+            IActionRenderContext context,
+            Exception exception)
         {
             if (!context.TxId.Equals(_lastTxId))
             {
@@ -102,7 +103,7 @@ public void RenderActionError(IValue action, IActionContext context, Exception e
 
         private void FlushBuffer(
             TxId? newTxId,
-            Action<IValue, IActionContext, IAccount> render
+            Action<IValue, IActionRenderContext, IAccount> render
         )
         {
             if (!_errored)
diff --git a/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs b/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs
index bdf29a86930..805a524030a 100644
--- a/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs
@@ -59,7 +59,7 @@ public void ResetRecords()
         /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public virtual void RenderAction(
             IValue action,
-            IActionContext context,
+            IActionRenderContext context,
             IAccount nextStates
         )
         {
@@ -79,7 +79,7 @@ IAccount nextStates
         /// <inheritdoc cref="IActionRenderer.RenderActionError"/>
         public virtual void RenderActionError(
             IValue action,
-            IActionContext context,
+            IActionRenderContext context,
             Exception exception
         ) =>
             _records.Add(
diff --git a/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs b/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs
index 4b7ba015ea0..56e702723a8 100644
--- a/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs
+++ b/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs
@@ -39,7 +39,7 @@ protected ActionBase(
                 long index,
                 string stackTrace,
                 IValue action,
-                IActionContext context,
+                IActionRenderContext context,
                 bool unrender = false
             )
                 : base(index, stackTrace)
@@ -57,7 +57,7 @@ protected ActionBase(
             /// <summary>
             /// The action evaluation context.
             /// </summary>
-            public IActionContext Context { get; }
+            public IActionRenderContext Context { get; }
 
             /// <summary>
             /// Whether it is not an unrender event, but a render event.
@@ -93,7 +93,7 @@ public ActionSuccess(
                 long index,
                 string stackTrace,
                 IValue action,
-                IActionContext context,
+                IActionRenderContext context,
                 IAccount nextStates,
                 bool unrender = false
             )
@@ -129,7 +129,7 @@ public ActionError(
                 long index,
                 string stackTrace,
                 IValue action,
-                IActionContext context,
+                IActionRenderContext context,
                 Exception exception,
                 bool unrender = false
             )
diff --git a/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs b/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs
index 36f7f864319..81177bebf90 100644
--- a/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs
@@ -40,11 +40,10 @@ public override void RenderBlock(Block oldTip, Block newTip)
             Validate();
         }
 
-        /// <inheritdoc
-        /// cref="IActionRenderer.RenderAction(IValue, IActionContext, IAccount)"/>
+        /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public override void RenderAction(
             IValue action,
-            IActionContext context,
+            IActionRenderContext context,
             IAccount nextStates
         )
         {
@@ -52,11 +51,10 @@ IAccount nextStates
             Validate();
         }
 
-        /// <inheritdoc
-        /// cref="IActionRenderer.RenderActionError(IValue, IActionContext, Exception)"/>
+        /// <inheritdoc cref="IActionRenderer.RenderActionError"/>
         public override void RenderActionError(
             IValue action,
-            IActionContext context,
+            IActionRenderContext context,
             Exception exception
         )
         {
diff --git a/Libplanet/Blockchain/Renderers/IActionRenderer.cs b/Libplanet/Blockchain/Renderers/IActionRenderer.cs
index 50d527865d8..08a3a71ea98 100644
--- a/Libplanet/Blockchain/Renderers/IActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/IActionRenderer.cs
@@ -17,8 +17,8 @@ namespace Libplanet.Blockchain.Renderers
     /// <list type="number">
     /// <item><description><see cref="IRenderer.RenderBlock(Block, Block)"/> (one time)
     /// </description></item>
-    /// <item><description><see cref="RenderAction(IValue, IActionContext, IAccount)"/>
-    /// &amp; <see cref="RenderActionError(IValue, IActionContext, Exception)"/> (zero or more
+    /// <item><description><see cref="RenderAction"/>
+    /// &amp; <see cref="RenderActionError"/> (zero or more
     /// times)</description>
     /// </item>
     /// <item><description><see cref="RenderBlockEnd(Block, Block)"/> (one time)</description>
@@ -56,18 +56,17 @@ public interface IActionRenderer : IRenderer
         /// It is guaranteed to be called only once for an <paramref name="action"/>,
         /// and only after applied to the blockchain, unless an exception is thrown during executing
         /// the <paramref name="action"/> (in that case <see
-        /// cref="RenderActionError(IValue, IActionContext, Exception)"/> is called instead) or
+        /// cref="RenderActionError"/> is called instead) or
         /// once the <paramref name="action"/> has been unrendered.
         /// <para>Also note that this method is invoked after <see
         /// cref="IRenderer.RenderBlock(Block, Block)"/> method is called
         /// (where its second parameter <c>newTip</c> contains a transaction the <paramref
         /// name="action"/> belongs to).</para>
         /// </remarks>
-        void RenderAction(IValue action, IActionContext context, IAccount nextStates);
+        void RenderAction(IValue action, IActionRenderContext context, IAccount nextStates);
 
         /// <summary>
-        /// Does the similar things to <see cref=
-        /// "RenderAction(IValue, IActionContext, IAccount)"/>, except that this method
+        /// Does the similar things to <see cref="RenderAction"/>, except that this method
         /// is invoked when <paramref name="action"/> has terminated with an exception.
         /// </summary>
         /// <param name="action">An action which threw an exception during execution.</param>
@@ -83,7 +82,7 @@ public interface IActionRenderer : IRenderer
         /// (where its second parameter <c>newTip</c> contains a transaction the <paramref
         /// name="action"/> belongs to).
         /// </remarks>
-        void RenderActionError(IValue action, IActionContext context, Exception exception);
+        void RenderActionError(IValue action, IActionRenderContext context, Exception exception);
 
         /// <summary>
         /// Does things that should be done right all actions in a new <see cref="Block"/> are
diff --git a/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs b/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs
index 45a0d776350..14097746632 100644
--- a/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs
@@ -67,11 +67,10 @@ Block newTip
                 ActionRenderer.RenderBlockEnd
             );
 
-        /// <inheritdoc
-        /// cref="IActionRenderer.RenderAction(IValue, IActionContext, IAccount)"/>
+        /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public void RenderAction(
             IValue action,
-            IActionContext context,
+            IActionRenderContext context,
             IAccount nextStates
         ) =>
             LogActionRendering(
@@ -81,11 +80,10 @@ IAccount nextStates
                 () => ActionRenderer.RenderAction(action, context, nextStates)
             );
 
-        /// <inheritdoc
-        /// cref="IActionRenderer.RenderActionError(IValue, IActionContext, Exception)"/>
+        /// <inheritdoc cref="IActionRenderer.RenderActionError"/>
         public void RenderActionError(
             IValue action,
-            IActionContext context,
+            IActionRenderContext context,
             Exception exception
         ) =>
             LogActionRendering(
@@ -98,7 +96,7 @@ Exception exception
         private void LogActionRendering(
             string methodName,
             IValue action,
-            IActionContext context,
+            IActionRenderContext context,
             System.Action callback
         )
         {

From 725b16713a69fa7314c07512433182062637dd3a Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Mon, 18 Sep 2023 13:27:19 +0900
Subject: [PATCH 10/72] Render with StateRootHash

---
 .../Queries/StateQueryTest.cs                 |  2 +-
 .../Blockchain/BlockChainTest.Append.cs       | 15 ++++++---
 Libplanet/Blockchain/BlockChain.Swap.cs       | 32 +++++++++++++++++--
 3 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs b/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
index 037f78fb1e0..e97f28ed96b 100644
--- a/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
+++ b/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
@@ -196,7 +196,7 @@ public ValidatorSet GetValidatorSet(BlockHash? offset) =>
 
         public IAccountState GetAccountState(BlockHash? offset) => new MockAccount(offset);
 
-        public IAccountState GetAccountState(HashDigest<SHA256>? offset) => new MockAccount(null);
+        public IAccountState GetAccountState(HashDigest<SHA256>? hash) => new MockAccount(null);
 
         public ITrie GetTrie(BlockHash? offset)
         {
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
index 7bf98ff7fa8..57dabf652f1 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
@@ -80,7 +80,8 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
             Assert.Equal(2, renders[0].Context.BlockIndex);
             Assert.Equal(
                 new IValue[] { null, null, null, null, (Integer)1 },
-                addresses.Select(renders[0].Context.PreviousState.GetState)
+                addresses.Select(
+                    _blockChain.GetAccountState(renders[0].Context.PreviousState).GetState)
             );
             Assert.Equal(
                 new IValue[] { (Text)"foo", null, null, null, (Integer)1 },
@@ -90,7 +91,8 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
             Assert.Equal(2, renders[1].Context.BlockIndex);
             Assert.Equal(
                 addresses.Select(renders[0].NextStates.GetState),
-                addresses.Select(renders[1].Context.PreviousState.GetState)
+                addresses.Select(
+                    _blockChain.GetAccountState(renders[1].Context.PreviousState).GetState)
             );
             Assert.Equal(
                 new IValue[] { (Text)"foo", (Text)"bar", null, null, (Integer)1 },
@@ -100,7 +102,8 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
             Assert.Equal(2, renders[2].Context.BlockIndex);
             Assert.Equal(
                 addresses.Select(renders[1].NextStates.GetState),
-                addresses.Select(renders[2].Context.PreviousState.GetState)
+                addresses.Select(
+                    _blockChain.GetAccountState(renders[2].Context.PreviousState).GetState)
             );
             Assert.Equal(
                 new IValue[] { (Text)"foo", (Text)"bar", (Text)"baz", null, (Integer)1 },
@@ -110,7 +113,8 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
             Assert.Equal(2, renders[3].Context.BlockIndex);
             Assert.Equal(
                 addresses.Select(renders[2].NextStates.GetState),
-                addresses.Select(renders[3].Context.PreviousState.GetState)
+                addresses.Select(
+                    _blockChain.GetAccountState(renders[3].Context.PreviousState).GetState)
             );
             Assert.Equal(
                 new IValue[]
@@ -137,7 +141,8 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
             );
             Assert.Equal(
                 (Integer)1,
-                (Integer)blockRenders[1].Context.PreviousState.GetState(minerAddress)
+                (Integer)_blockChain.GetAccountState(blockRenders[1].Context.PreviousState)
+                    .GetState(minerAddress)
             );
             Assert.Equal(
                 (Integer)2,
diff --git a/Libplanet/Blockchain/BlockChain.Swap.cs b/Libplanet/Blockchain/BlockChain.Swap.cs
index 7525fc1d81e..7ecc48dddb6 100644
--- a/Libplanet/Blockchain/BlockChain.Swap.cs
+++ b/Libplanet/Blockchain/BlockChain.Swap.cs
@@ -5,8 +5,10 @@
 using System.Diagnostics;
 using System.Linq;
 using Libplanet.Action;
+using Libplanet.Action.State;
 using Libplanet.Blockchain.Renderers;
 using Libplanet.Store;
+using Libplanet.Store.Trie;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
 
@@ -219,6 +221,7 @@ internal long RenderActions(
             }
 
             long count = 0;
+            ITrie trie = GetAccountState(block.PreviousHash).Trie;
             foreach (var evaluation in evaluations)
             {
                 if (evaluation.InputContext.BlockAction && Policy.BlockAction is null)
@@ -232,17 +235,42 @@ internal long RenderActions(
                     {
                         renderer.RenderAction(
                             evaluation.Action,
-                            new ActionRenderContext(evaluation.InputContext.GetUnconsumedContext()),
+                            new ActionRenderContext(
+                                signer: evaluation.InputContext.Signer,
+                                txId: evaluation.InputContext.TxId,
+                                miner: evaluation.InputContext.Miner,
+                                blockIndex: evaluation.InputContext.BlockIndex,
+                                blockProtocolVersion: evaluation.InputContext.BlockProtocolVersion,
+                                rehearsal: evaluation.InputContext.Rehearsal,
+                                previousState: trie.Hash,
+                                random: evaluation.InputContext.GetUnconsumedContext().Random,
+                                blockAction: evaluation.InputContext.BlockAction),
                             evaluation.OutputState);
                     }
                     else
                     {
                         renderer.RenderActionError(
                             evaluation.Action,
-                            new ActionRenderContext(evaluation.InputContext.GetUnconsumedContext()),
+                            new ActionRenderContext(
+                                signer: evaluation.InputContext.Signer,
+                                txId: evaluation.InputContext.TxId,
+                                miner: evaluation.InputContext.Miner,
+                                blockIndex: evaluation.InputContext.BlockIndex,
+                                blockProtocolVersion: evaluation.InputContext.BlockProtocolVersion,
+                                rehearsal: evaluation.InputContext.Rehearsal,
+                                previousState: trie.Hash,
+                                random: evaluation.InputContext.GetUnconsumedContext().Random,
+                                blockAction: evaluation.InputContext.BlockAction),
                             evaluation.Exception);
                     }
 
+                    foreach (var kv in evaluation.OutputState.Delta.ToRawDelta())
+                    {
+                        trie = trie.Set(kv.Key, kv.Value);
+                    }
+
+                    trie = StateStore.Commit(trie);
+
                     count++;
                 }
             }

From 22278b2f685b047b90c1d0e7d91c565e35236b59 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Tue, 19 Sep 2023 09:40:37 +0900
Subject: [PATCH 11/72] Use HashDigest instead of IAccount

---
 Libplanet.Action.Tests/Sys/InitializeTest.cs  |  6 ++--
 Libplanet.Tests/Action/ActionEvaluatorTest.cs |  4 +--
 .../Blockchain/BlockChainTest.Append.cs       | 20 ++++++-----
 Libplanet.Tests/Blockchain/BlockChainTest.cs  |  4 +--
 .../Renderers/AnonymousActionRendererTest.cs  | 16 +++++----
 .../Renderers/LoggedActionRendererTest.cs     | 33 ++++++++++---------
 Libplanet.Tests/Store/TrieStateStoreTest.cs   |  4 +--
 Libplanet/Blockchain/BlockChain.Swap.cs       | 18 +++++-----
 .../Renderers/AnonymousActionRenderer.cs      | 17 +++++-----
 .../Renderers/AtomicActionRenderer.cs         | 15 +++++----
 .../Debug/RecordingActionRenderer.cs          |  7 ++--
 .../Renderers/Debug/RenderRecord.cs           | 11 ++++---
 .../Debug/ValidatingActionRenderer.cs         |  7 ++--
 .../Blockchain/Renderers/IActionRenderer.cs   | 12 ++++---
 .../Renderers/LoggedActionRenderer.cs         |  7 ++--
 15 files changed, 99 insertions(+), 82 deletions(-)

diff --git a/Libplanet.Action.Tests/Sys/InitializeTest.cs b/Libplanet.Action.Tests/Sys/InitializeTest.cs
index ff4243e9336..5c6bea6328c 100644
--- a/Libplanet.Action.Tests/Sys/InitializeTest.cs
+++ b/Libplanet.Action.Tests/Sys/InitializeTest.cs
@@ -59,10 +59,10 @@ public void Execute()
                 validatorSet: _validatorSet
             );
 
-            var nextStates = initialize.Execute(context);
+            var nextState = initialize.Execute(context);
 
-            Assert.Equal(_validatorSet, nextStates.GetValidatorSet());
-            Assert.Equal(_states[default], nextStates.GetState(default));
+            Assert.Equal(_validatorSet, nextState.GetValidatorSet());
+            Assert.Equal(_states[default], nextState.GetState(default));
         }
 
         [Fact]
diff --git a/Libplanet.Tests/Action/ActionEvaluatorTest.cs b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
index 57432ae30ec..45eb15af07b 100644
--- a/Libplanet.Tests/Action/ActionEvaluatorTest.cs
+++ b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
@@ -638,12 +638,12 @@ public void EvaluateTxResultThrowingException()
                     lastCommit: CreateBlockCommit(hash, 122, 0)),
                 transactions: txs).Propose();
             IAccount previousState = actionEvaluator.PrepareInitialDelta(block);
-            var nextStates = actionEvaluator.EvaluateTx(
+            var nextState = actionEvaluator.EvaluateTx(
                 blockHeader: block,
                 tx: tx,
                 previousState: previousState).Last().OutputState;
 
-            Assert.Empty(nextStates.GetUpdatedStates());
+            Assert.Empty(nextState.GetUpdatedStates());
         }
 
         [Fact]
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
index 57dabf652f1..30ffcf280df 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
@@ -85,34 +85,34 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
             );
             Assert.Equal(
                 new IValue[] { (Text)"foo", null, null, null, (Integer)1 },
-                addresses.Select(renders[0].NextStates.GetState)
+                addresses.Select(_blockChain.GetAccountState(renders[0].NextState).GetState)
             );
             Assert.Equal("bar", actions[1].Item);
             Assert.Equal(2, renders[1].Context.BlockIndex);
             Assert.Equal(
-                addresses.Select(renders[0].NextStates.GetState),
+                addresses.Select(_blockChain.GetAccountState(renders[0].NextState).GetState),
                 addresses.Select(
                     _blockChain.GetAccountState(renders[1].Context.PreviousState).GetState)
             );
             Assert.Equal(
                 new IValue[] { (Text)"foo", (Text)"bar", null, null, (Integer)1 },
-                addresses.Select(renders[1].NextStates.GetState)
+                addresses.Select(_blockChain.GetAccountState(renders[1].NextState).GetState)
             );
             Assert.Equal("baz", actions[2].Item);
             Assert.Equal(2, renders[2].Context.BlockIndex);
             Assert.Equal(
-                addresses.Select(renders[1].NextStates.GetState),
+                addresses.Select(_blockChain.GetAccountState(renders[1].NextState).GetState),
                 addresses.Select(
                     _blockChain.GetAccountState(renders[2].Context.PreviousState).GetState)
             );
             Assert.Equal(
                 new IValue[] { (Text)"foo", (Text)"bar", (Text)"baz", null, (Integer)1 },
-                addresses.Select(renders[2].NextStates.GetState)
+                addresses.Select(_blockChain.GetAccountState(renders[2].NextState).GetState)
             );
             Assert.Equal("qux", actions[3].Item);
             Assert.Equal(2, renders[3].Context.BlockIndex);
             Assert.Equal(
-                addresses.Select(renders[2].NextStates.GetState),
+                addresses.Select(_blockChain.GetAccountState(renders[2].NextState).GetState),
                 addresses.Select(
                     _blockChain.GetAccountState(renders[3].Context.PreviousState).GetState)
             );
@@ -121,7 +121,7 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
                 {
                     (Text)"foo", (Text)"bar", (Text)"baz", (Text)"qux", (Integer)1,
                 },
-                renders[3].NextStates.GetStates(addresses)
+                _blockChain.GetAccountState(renders[3].NextState).GetStates(addresses)
             );
 
             Address minerAddress = addresses[4];
@@ -137,7 +137,8 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
 
             Assert.Equal(
                 (Integer)1,
-                (Integer)blockRenders[0].NextStates.GetState(minerAddress)
+                (Integer)_blockChain.GetAccountState(
+                    blockRenders[0].NextState).GetState(minerAddress)
             );
             Assert.Equal(
                 (Integer)1,
@@ -146,7 +147,8 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
             );
             Assert.Equal(
                 (Integer)2,
-                (Integer)blockRenders[1].NextStates.GetState(minerAddress)
+                (Integer)_blockChain.GetAccountState(
+                    blockRenders[1].NextState).GetState(minerAddress)
             );
 
             foreach (Transaction tx in txs)
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.cs b/Libplanet.Tests/Blockchain/BlockChainTest.cs
index e5b833820f8..b05da227ad1 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.cs
@@ -311,7 +311,7 @@ public void ActionRenderersHaveDistinctContexts()
                 new LoggedActionRenderer(
                     new AnonymousActionRenderer
                     {
-                        ActionRenderer = (act, context, nextStates) =>
+                        ActionRenderer = (act, context, nextState) =>
                             // Consuming the random state through IRandom.Next() should not
                             // affect contexts passed to other action renderers.
                             generatedRandomValueLogs.Add(context.Random.Next()),
@@ -382,7 +382,7 @@ public void RenderActionsAfterAppendComplete()
 
             IActionRenderer renderer = new AnonymousActionRenderer
             {
-                ActionRenderer = (a, __, nextStates) =>
+                ActionRenderer = (a, __, nextState) =>
                 {
                     if (!(a is Dictionary dictionary &&
                           dictionary.TryGetValue((Text)"type_id", out IValue typeId) &&
diff --git a/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs b/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs
index 22beb546cd9..a6b818fb7a0 100644
--- a/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs
+++ b/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs
@@ -1,10 +1,12 @@
 using System;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
 using Libplanet.Action.State;
 using Libplanet.Action.Tests.Common;
 using Libplanet.Action.Tests.Mocks;
 using Libplanet.Blockchain.Renderers;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 using Xunit;
 
@@ -41,11 +43,11 @@ public class AnonymousActionRendererTest
         [Fact]
         public void ActionRenderer()
         {
-            (IValue, IActionRenderContext, IAccount)? record = null;
+            (IValue, IActionRenderContext, HashDigest<SHA256>)? record = null;
             var renderer = new AnonymousActionRenderer
             {
-                ActionRenderer = (action, context, nextStates) =>
-                    record = (action, context, nextStates),
+                ActionRenderer = (action, context, nextState) =>
+                    record = (action, context, nextState),
             };
 
             renderer.RenderActionError(_action, _actionContext, _exception);
@@ -53,11 +55,11 @@ record = (action, context, nextStates),
             renderer.RenderBlock(_genesis, _blockA);
             Assert.Null(record);
 
-            renderer.RenderAction(_action, _actionContext, _account);
+            renderer.RenderAction(_action, _actionContext, _account.Trie.Hash);
             Assert.NotNull(record);
             Assert.Same(_action, record?.Item1);
             Assert.Same(_actionContext, record?.Item2);
-            Assert.Same(_account, record?.Item3);
+            Assert.Equal(_account.Trie.Hash, record?.Item3);
         }
 
         [Fact]
@@ -70,7 +72,7 @@ public void ActionErrorRenderer()
                     record = (action, context, exception),
             };
 
-            renderer.RenderAction(_action, _actionContext, _account);
+            renderer.RenderAction(_action, _actionContext, _account.Trie.Hash);
             Assert.Null(record);
             renderer.RenderBlock(_genesis, _blockA);
             Assert.Null(record);
@@ -91,7 +93,7 @@ public void BlockRenderer()
                 BlockRenderer = (oldTip, newTip) => record = (oldTip, newTip),
             };
 
-            renderer.RenderAction(_action, _actionContext, _account);
+            renderer.RenderAction(_action, _actionContext, _account.Trie.Hash);
             Assert.Null(record);
             renderer.RenderActionError(_action, _actionContext, _exception);
             Assert.Null(record);
diff --git a/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs b/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs
index 1c9d4e66db2..593351f5006 100644
--- a/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs
+++ b/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs
@@ -2,12 +2,14 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
 using Libplanet.Action.State;
 using Libplanet.Action.Tests.Common;
 using Libplanet.Action.Tests.Mocks;
 using Libplanet.Blockchain.Renderers;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 using Serilog;
 using Serilog.Events;
@@ -23,8 +25,6 @@ public class LoggedActionRendererTest : IDisposable
 
         private static IAccount _account = new Account(MockAccountState.Empty);
 
-        private static Exception _exception = new Exception();
-
         private static Block _genesis =
             TestUtils.ProposeGenesisBlock(TestUtils.GenesisProposer);
 
@@ -104,20 +104,21 @@ public void ActionRenderings(bool error, bool rehearsal, bool exception)
             }
             else
             {
-                Action<IValue, IActionRenderContext, IAccount> render = (action, cxt, next) =>
-                {
-                    LogEvent[] logs = LogEvents.ToArray();
-                    Assert.Single(logs);
-                    firstLog = logs[0];
-                    Assert.Same(_action, action);
-                    Assert.Same(actionContext, cxt);
-                    Assert.Same(_account, next);
-                    called = true;
-                    if (exception)
+                Action<IValue, IActionRenderContext, HashDigest<SHA256>> render =
+                    (action, cxt, next) =>
                     {
-                        throw new ThrowException.SomeException(string.Empty);
-                    }
-                };
+                        LogEvent[] logs = LogEvents.ToArray();
+                        Assert.Single(logs);
+                        firstLog = logs[0];
+                        Assert.Same(_action, action);
+                        Assert.Same(actionContext, cxt);
+                        Assert.Equal(_account.Trie.Hash, next);
+                        called = true;
+                        if (exception)
+                        {
+                            throw new ThrowException.SomeException(string.Empty);
+                        }
+                    };
                 actionRenderer = new AnonymousActionRenderer
                 {
                     ActionRenderer = render,
@@ -146,7 +147,7 @@ public void ActionRenderings(bool error, bool rehearsal, bool exception)
                 }
                 else
                 {
-                    actionRenderer.RenderAction(_action, actionContext, _account);
+                    actionRenderer.RenderAction(_action, actionContext, _account.Trie.Hash);
                 }
             }
             catch (ThrowException.SomeException e)
diff --git a/Libplanet.Tests/Store/TrieStateStoreTest.cs b/Libplanet.Tests/Store/TrieStateStoreTest.cs
index 5bfd9b65ae6..b99ee445ffc 100644
--- a/Libplanet.Tests/Store/TrieStateStoreTest.cs
+++ b/Libplanet.Tests/Store/TrieStateStoreTest.cs
@@ -80,9 +80,9 @@ public void PruneStates()
             ITrie first = stateStore.Commit(null, values);
 
             int prevStatesCount = _stateKeyValueStore.ListKeys().Count();
-            ImmutableDictionary<KeyBytes, IValue> nextStates =
+            ImmutableDictionary<KeyBytes, IValue> nextState =
                 values.SetItem(new KeyBytes("foo"), (Binary)GetRandomBytes(4096));
-            ITrie second = stateStore.Commit(first.Hash, nextStates);
+            ITrie second = stateStore.Commit(first.Hash, nextState);
 
             // foo = 0x666f6f
             // updated branch node (0x6, aka root) + updated branch node (0x66) +
diff --git a/Libplanet/Blockchain/BlockChain.Swap.cs b/Libplanet/Blockchain/BlockChain.Swap.cs
index 7ecc48dddb6..33f87ede385 100644
--- a/Libplanet/Blockchain/BlockChain.Swap.cs
+++ b/Libplanet/Blockchain/BlockChain.Swap.cs
@@ -229,6 +229,14 @@ internal long RenderActions(
                     continue;
                 }
 
+                ITrie nextTrie = trie;
+                foreach (var kv in evaluation.OutputState.Delta.ToRawDelta())
+                {
+                    nextTrie = nextTrie.Set(kv.Key, kv.Value);
+                }
+
+                nextTrie = StateStore.Commit(nextTrie);
+
                 foreach (IActionRenderer renderer in ActionRenderers)
                 {
                     if (evaluation.Exception is null)
@@ -245,7 +253,7 @@ internal long RenderActions(
                                 previousState: trie.Hash,
                                 random: evaluation.InputContext.GetUnconsumedContext().Random,
                                 blockAction: evaluation.InputContext.BlockAction),
-                            evaluation.OutputState);
+                            nextTrie.Hash);
                     }
                     else
                     {
@@ -264,13 +272,7 @@ internal long RenderActions(
                             evaluation.Exception);
                     }
 
-                    foreach (var kv in evaluation.OutputState.Delta.ToRawDelta())
-                    {
-                        trie = trie.Set(kv.Key, kv.Value);
-                    }
-
-                    trie = StateStore.Commit(trie);
-
+                    trie = nextTrie;
                     count++;
                 }
             }
diff --git a/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs b/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs
index 366b26fc35d..9b95cac7fa4 100644
--- a/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs
@@ -1,7 +1,8 @@
 using System;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
-using Libplanet.Action.State;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 
 namespace Libplanet.Blockchain.Renderers
@@ -18,7 +19,7 @@ namespace Libplanet.Blockchain.Renderers
     /// <code><![CDATA[
     /// var actionRenderer = new AnonymousActionRenderer
     /// {
-    ///     ActionRenderer = (action, context, nextStates) =>
+    ///     ActionRenderer = (action, context, nextState) =>
     ///     {
     ///         // Implement RenderAction() here.
     ///     };
@@ -29,9 +30,10 @@ public sealed class AnonymousActionRenderer : AnonymousRenderer, IActionRenderer
     {
         /// <summary>
         /// A callback function to be invoked together with
-        /// <see cref="RenderAction(IValue, IActionRenderContext, IAccount)"/>.
+        /// <see cref="RenderAction(IValue, IActionRenderContext, HashDigest{SHA256})"/>.
         /// </summary>
-        public Action<IValue, IActionRenderContext, IAccount>? ActionRenderer { get; set; }
+        public Action<IValue, IActionRenderContext, HashDigest<SHA256>>? ActionRenderer
+            { get; set; }
 
         /// <summary>
         /// A callback function to be invoked together with
@@ -45,14 +47,13 @@ public sealed class AnonymousActionRenderer : AnonymousRenderer, IActionRenderer
         /// </summary>
         public Action<Block, Block>? BlockEndRenderer { get; set; }
 
-        /// <inheritdoc
-        /// cref="IActionRenderer.RenderAction(IValue, IActionRenderContext, IAccount)"/>
+        /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public void RenderAction(
             IValue action,
             IActionRenderContext context,
-            IAccount nextStates
+            HashDigest<SHA256> nextState
         ) =>
-            ActionRenderer?.Invoke(action, context, nextStates);
+            ActionRenderer?.Invoke(action, context, nextState);
 
         /// <inheritdoc
         /// cref="IActionRenderer.RenderActionError(IValue, IActionRenderContext, Exception)"/>
diff --git a/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs b/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs
index 0532abb0b5d..646bf8f001f 100644
--- a/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs
@@ -1,8 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
-using Libplanet.Action.State;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
 
@@ -20,7 +21,7 @@ namespace Libplanet.Blockchain.Renderers
     /// </remarks>
     public sealed class AtomicActionRenderer : IActionRenderer
     {
-        private readonly List<(IValue, IActionRenderContext, IAccount)> _eventBuffer;
+        private readonly List<(IValue, IActionRenderContext, HashDigest<SHA256>)> _eventBuffer;
         private TxId? _lastTxId;
         private bool _errored;
 
@@ -35,7 +36,7 @@ public AtomicActionRenderer(IActionRenderer actionRenderer)
         {
             ActionRenderer = actionRenderer;
             _lastTxId = null;
-            _eventBuffer = new List<(IValue, IActionRenderContext, IAccount)>();
+            _eventBuffer = new List<(IValue, IActionRenderContext, HashDigest<SHA256>)>();
             _errored = false;
         }
 
@@ -62,7 +63,7 @@ public void RenderBlockEnd(Block oldTip, Block newTip)
         public void RenderAction(
             IValue action,
             IActionRenderContext context,
-            IAccount nextStates
+            HashDigest<SHA256> nextState
         )
         {
             if (!context.TxId.Equals(_lastTxId))
@@ -72,11 +73,11 @@ IAccount nextStates
 
             if (context.TxId is null)
             {
-                ActionRenderer.RenderAction(action, context, nextStates);
+                ActionRenderer.RenderAction(action, context, nextState);
             }
             else if (!_errored)
             {
-                _eventBuffer.Add((action, context, nextStates));
+                _eventBuffer.Add((action, context, nextState));
             }
         }
 
@@ -103,7 +104,7 @@ public void RenderActionError(
 
         private void FlushBuffer(
             TxId? newTxId,
-            Action<IValue, IActionRenderContext, IAccount> render
+            Action<IValue, IActionRenderContext, HashDigest<SHA256>> render
         )
         {
             if (!_errored)
diff --git a/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs b/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs
index 805a524030a..e04ace87f64 100644
--- a/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs
@@ -2,9 +2,10 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
-using Libplanet.Action.State;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 using Serilog;
 
@@ -60,7 +61,7 @@ public void ResetRecords()
         public virtual void RenderAction(
             IValue action,
             IActionRenderContext context,
-            IAccount nextStates
+            HashDigest<SHA256> nextState
         )
         {
             _records.Add(
@@ -69,7 +70,7 @@ IAccount nextStates
                     stackTrace: RemoveFirstLine(Environment.StackTrace).TrimEnd(),
                     action: action,
                     context: context,
-                    nextStates: nextStates
+                    nextState: nextState
                 )
             );
 
diff --git a/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs b/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs
index 56e702723a8..78d12a04e39 100644
--- a/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs
+++ b/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs
@@ -1,7 +1,8 @@
 using System;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
-using Libplanet.Action.State;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 
 namespace Libplanet.Blockchain.Renderers.Debug
@@ -87,25 +88,25 @@ public class ActionSuccess : ActionBase
             /// <param name="stackTrace">The stack trace of the render event.</param>
             /// <param name="action">The rendered action.</param>
             /// <param name="context">The action evaluation context.</param>
-            /// <param name="nextStates">The resulting states after the action is evaluated.</param>
+            /// <param name="nextState">The resulting state after the action is evaluated.</param>
             /// <param name="unrender">Whether it is an unrender event.</param>
             public ActionSuccess(
                 long index,
                 string stackTrace,
                 IValue action,
                 IActionRenderContext context,
-                IAccount nextStates,
+                HashDigest<SHA256> nextState,
                 bool unrender = false
             )
                 : base(index, stackTrace, action, context, unrender: unrender)
             {
-                NextStates = nextStates;
+                NextState = nextState;
             }
 
             /// <summary>
             /// The resulting states after the action is evaluated.
             /// </summary>
-            public IAccount NextStates { get; }
+            public HashDigest<SHA256> NextState { get; }
 
             /// <inheritdoc cref="RenderRecord.ToString()"/>
             public override string ToString() => $"{base.ToString()} [success]";
diff --git a/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs b/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs
index 81177bebf90..f8be6ab7f24 100644
--- a/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs
@@ -1,8 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
-using Libplanet.Action.State;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 
 namespace Libplanet.Blockchain.Renderers.Debug
@@ -44,10 +45,10 @@ public override void RenderBlock(Block oldTip, Block newTip)
         public override void RenderAction(
             IValue action,
             IActionRenderContext context,
-            IAccount nextStates
+            HashDigest<SHA256> nextState
         )
         {
-            base.RenderAction(action, context, nextStates);
+            base.RenderAction(action, context, nextState);
             Validate();
         }
 
diff --git a/Libplanet/Blockchain/Renderers/IActionRenderer.cs b/Libplanet/Blockchain/Renderers/IActionRenderer.cs
index 08a3a71ea98..dce1073cabe 100644
--- a/Libplanet/Blockchain/Renderers/IActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/IActionRenderer.cs
@@ -1,7 +1,8 @@
 using System;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
-using Libplanet.Action.State;
+using Libplanet.Common;
 using Libplanet.Store;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
@@ -48,8 +49,8 @@ public interface IActionRenderer : IRenderer
         /// the <paramref name="action"/>'s <see cref="IAction.Execute(IActionContext)"/> method.
         /// That means <see cref="IActionContext.PreviousState"/> are the states right
         /// <em>before</em> this action executed.  For the states after this action executed,
-        /// use the <paramref name="nextStates"/> argument instead.</param>
-        /// <param name="nextStates">The states right <em>after</em> this action executed,
+        /// use the <paramref name="nextState"/> argument instead.</param>
+        /// <param name="nextState">The state root hash right <em>after</em> this action executed,
         /// which means it is equivalent to the states <paramref name="action"/>'s
         /// <see cref="IAction.Execute(IActionContext)"/> method returned.</param>
         /// <remarks>
@@ -63,7 +64,10 @@ public interface IActionRenderer : IRenderer
         /// (where its second parameter <c>newTip</c> contains a transaction the <paramref
         /// name="action"/> belongs to).</para>
         /// </remarks>
-        void RenderAction(IValue action, IActionRenderContext context, IAccount nextStates);
+        void RenderAction(
+            IValue action,
+            IActionRenderContext context,
+            HashDigest<SHA256> nextState);
 
         /// <summary>
         /// Does the similar things to <see cref="RenderAction"/>, except that this method
diff --git a/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs b/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs
index 14097746632..b0c715bbe43 100644
--- a/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs
@@ -1,7 +1,8 @@
 using System;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
-using Libplanet.Action.State;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 using Serilog;
 using Serilog.Events;
@@ -71,13 +72,13 @@ Block newTip
         public void RenderAction(
             IValue action,
             IActionRenderContext context,
-            IAccount nextStates
+            HashDigest<SHA256> nextState
         ) =>
             LogActionRendering(
                 nameof(RenderAction),
                 action,
                 context,
-                () => ActionRenderer.RenderAction(action, context, nextStates)
+                () => ActionRenderer.RenderAction(action, context, nextState)
             );
 
         /// <inheritdoc cref="IActionRenderer.RenderActionError"/>

From 0fd63b707195acad0f115782cea32403441527ef Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Tue, 19 Sep 2023 10:36:30 +0900
Subject: [PATCH 12/72] Changelog

---
 CHANGES.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index d9784b55f4d..8b9e5a89637 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -12,6 +12,12 @@ To be released.
 
  -  Added `IBlockChainStates.GetAccountState(HashDigest<SHA256>?)`
     interface method.  [[#3425]]
+ -  Changed `IActionRenderer.RenderAction(IValue, IActionContext, IAccount)`
+    to `IActionRenderer.RenderAction(IValue, IActionRenderContext,
+    HashDigest<SHA256>)`.  [[#3427]]
+ -  Changed `IActionRenderer.RenderActionError(IValue, IActionContext,
+    Exception)` to `IActionRenderer.RenderActionError(IValue,
+    IActionRenderContext, Exception)`.  [[#3427]]
 
 ### Backward-incompatible network protocol changes
 
@@ -19,6 +25,8 @@ To be released.
 
 ### Added APIs
 
+ -  Added `IActionRenderContext` interface.  [[#3427]]
+
 ### Behavioral changes
 
 ### Bug fixes
@@ -28,6 +36,7 @@ To be released.
 ### CLI tools
 
 [#3425]: https://github.com/planetarium/libplanet/pull/3425
+[#3427]: https://github.com/planetarium/libplanet/pull/3427
 
 
 Version 3.3.1

From c9dae8452e7996b024d29a26340e33514c72a569 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 14 Sep 2023 10:36:30 +0900
Subject: [PATCH 13/72] Initial implementation of AccountDiff

---
 Libplanet.Action/State/AccountDiff.cs | 303 ++++++++++++++++++++++++++
 1 file changed, 303 insertions(+)
 create mode 100644 Libplanet.Action/State/AccountDiff.cs

diff --git a/Libplanet.Action/State/AccountDiff.cs b/Libplanet.Action/State/AccountDiff.cs
new file mode 100644
index 00000000000..66fa45822d2
--- /dev/null
+++ b/Libplanet.Action/State/AccountDiff.cs
@@ -0,0 +1,303 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Security.Cryptography;
+using Bencodex.Types;
+using Libplanet.Common;
+using Libplanet.Crypto;
+using Libplanet.Store.Trie;
+using Libplanet.Types.Assets;
+using Libplanet.Types.Consensus;
+
+namespace Libplanet.Action.State
+{
+    public class AccountDiff
+    {
+        private static readonly int _addressKeyLength = Address.Size * 2;
+
+        private static readonly int _currencyKeyLength = HashDigest<SHA1>.Size * 2;
+
+        private static readonly int _stateKeyLength = _addressKeyLength;
+
+        private static readonly int _fungibleAssetKeyLength =
+            _addressKeyLength + _currencyKeyLength + 2;
+
+        private static readonly int _totalSupplyKeyLength = _currencyKeyLength + 2;
+
+        private static readonly int _validatorSetKeyLength = 3;
+
+        private static readonly ImmutableDictionary<int, byte> _reverseConversionTable =
+            new Dictionary<int, byte>()
+            {
+                [48] = 0,   // '0'
+                [49] = 1,   // '1'
+                [50] = 2,   // '2'
+                [51] = 3,   // '3'
+                [52] = 4,   // '4'
+                [53] = 5,   // '5'
+                [54] = 6,   // '6'
+                [55] = 7,   // '7'
+                [56] = 8,   // '8'
+                [57] = 9,   // '9'
+                [97] = 10,  // 'a'
+                [98] = 11,  // 'b'
+                [99] = 12,  // 'c'
+                [100] = 13, // 'd'
+                [101] = 14, // 'e'
+                [102] = 15, // 'f'
+            }.ToImmutableDictionary();
+
+        private AccountDiff(
+            ImmutableDictionary<Address, (IValue?, IValue)> stateDiff,
+            ImmutableDictionary<(Address, Currency), (FungibleAssetValue, FungibleAssetValue)>
+                fungibleAssetValueDiff,
+            ImmutableDictionary<Currency, (FungibleAssetValue, FungibleAssetValue)>
+                totalSupplyDiff,
+            (ValidatorSet, ValidatorSet)? validatorSetDiff)
+        {
+            StateDiffs = stateDiff;
+            FungibleAssetValueDiffs = fungibleAssetValueDiff;
+            TotalSupplyDiffs = totalSupplyDiff;
+            ValidatorSetDiff = validatorSetDiff;
+        }
+
+        public ImmutableDictionary<Address, (IValue?, IValue)> StateDiffs { get; }
+
+        public ImmutableDictionary<(Address, Currency), (FungibleAssetValue, FungibleAssetValue)>
+            FungibleAssetValueDiffs { get; }
+
+        public ImmutableDictionary<Currency, (FungibleAssetValue, FungibleAssetValue)>
+            TotalSupplyDiffs { get; }
+
+        public (ValidatorSet, ValidatorSet)? ValidatorSetDiff { get; }
+
+        public static AccountDiff Create(IAccountState source, IAccountState target)
+            => Create(source.Trie, target.Trie);
+
+        // NOTE: interpret not actual.
+        public static AccountDiff Create(ITrie source, ITrie target)
+        {
+            var rawDiffs = source.Diff(target).ToList();
+
+            Dictionary<Address, (IValue?, IValue)> stateDiffs =
+                new Dictionary<Address, (IValue?, IValue)>();
+            Dictionary<(Address, Currency), (FungibleAssetValue, FungibleAssetValue)> favDiffs =
+                new Dictionary<(Address, Currency), (FungibleAssetValue, FungibleAssetValue)>();
+            Dictionary<Currency, (FungibleAssetValue, FungibleAssetValue)> totalSupplyDiffs =
+                new Dictionary<Currency, (FungibleAssetValue, FungibleAssetValue)>();
+            (ValidatorSet, ValidatorSet)? validatorSetDiff = null;
+
+            foreach (var diff in rawDiffs)
+            {
+                // NOTE: Cannot use switch as some lengths cannot be derived as const.
+                if (diff.Path.Length == _stateKeyLength)
+                {
+                    var sd = ToStateDiff(diff);
+                    stateDiffs[sd.Address] = (sd.TargetValue, sd.SourceValue);
+                }
+                else if (diff.Path.Length == _fungibleAssetKeyLength)
+                {
+                    var favd = ToFAVDiff(diff);
+
+                    // NOTE: Only add when different.  Actual stored data may be different
+                    // as 0 value can also be represented as null.
+                    if (!favd.SourceValue.Equals(favd.TargetValue))
+                    {
+                        favDiffs[(favd.Address, favd.Currency)] =
+                            (favd.TargetValue, favd.SourceValue);
+                    }
+                }
+                else if (diff.Path.Length == _totalSupplyKeyLength)
+                {
+                    var tsd = ToTotalSupplyDiff(diff);
+
+                    // NOTE: Only add when different.  Actual stored data may be different
+                    // as 0 value can also be represented as null.
+                    if (!tsd.SourceValue.Equals(tsd.TargetValue))
+                    {
+                        totalSupplyDiffs[tsd.Currency] = (tsd.TargetValue, tsd.SourceValue);
+                    }
+                }
+                else if (diff.Path.Length == _validatorSetKeyLength)
+                {
+                    var vsd = ToValidatorSetDiff(diff);
+
+                    // NOTE: Only set when different.  Actual stored data may be different
+                    // as empty validator set can also be represented as null.
+                    if (!vsd.SourceValue.Equals(vsd.TargetValue))
+                    {
+                        validatorSetDiff = (vsd.TargetValue, vsd.SourceValue);
+                    }
+                }
+                else
+                {
+                    throw new ArgumentException(
+                        $"Encountered different values at an invalid location: {diff.Path}");
+                }
+            }
+
+            return new AccountDiff(
+                stateDiffs.ToImmutableDictionary(),
+                favDiffs.ToImmutableDictionary(),
+                totalSupplyDiffs.ToImmutableDictionary(),
+                validatorSetDiff);
+        }
+
+        internal static (Address Address, IValue? TargetValue, IValue SourceValue)
+            ToStateDiff((KeyBytes Path, IValue? TargetValue, IValue SourceValue) encoded)
+        {
+            return (
+                ToAddress(encoded.Path.ToByteArray()),
+                encoded.TargetValue,
+                encoded.SourceValue);
+        }
+
+        internal static (
+            Address Address,
+            Currency Currency,
+            FungibleAssetValue TargetValue,
+            FungibleAssetValue SourceValue) ToFAVDiff(
+                (KeyBytes Path, IValue? TargetValue, IValue SourceValue) encoded)
+        {
+            Address address =
+                ToAddress(
+                    encoded.Path.ByteArray.Skip(1).Take(_addressKeyLength).ToArray());
+            HashDigest<SHA1> currencyHash =
+                ToCurrencyHash(
+                    encoded.Path.ByteArray
+                        .Skip(_addressKeyLength + 2)
+                        .Take(_currencyKeyLength)
+                        .ToArray());
+            FungibleAssetValue sourceFAV = new FungibleAssetValue(encoded.SourceValue);
+            Currency currency = sourceFAV.Currency;
+            FungibleAssetValue targetFAV = encoded.TargetValue is { } value
+                ? new FungibleAssetValue(value)
+                : FungibleAssetValue.FromRawValue(sourceFAV.Currency, 0);
+
+            if (!currency.Hash.Equals(currencyHash))
+            {
+                throw new ArgumentException(
+                    $"The internal trie path {currencyHash} for a stored FAV does not match " +
+                    $"the hash {currency.Hash} of the FAV {currency.Ticker}");
+            }
+            else if (!currency.Equals(targetFAV.Currency))
+            {
+                throw new ArgumentException(
+                    $"The currency of the FAV stored in target {targetFAV.Currency} " +
+                    $"does match the currency of the FAV stored in source {sourceFAV.Currency}");
+            }
+
+            return (address, currency, targetFAV, sourceFAV);
+        }
+
+        internal static (
+            Currency Currency,
+            FungibleAssetValue TargetValue,
+            FungibleAssetValue SourceValue) ToTotalSupplyDiff(
+                (KeyBytes Path, IValue? TargetValue, IValue SourceValue) encoded)
+        {
+            HashDigest<SHA1> currencyHash =
+                ToCurrencyHash(
+                    encoded.Path.ByteArray
+                        .Skip(_addressKeyLength + 2)
+                        .Take(_currencyKeyLength)
+                        .ToArray());
+            FungibleAssetValue sourceFAV = new FungibleAssetValue(encoded.SourceValue);
+            Currency currency = sourceFAV.Currency;
+            FungibleAssetValue targetFAV = encoded.TargetValue is { } value
+                ? new FungibleAssetValue(value)
+                : FungibleAssetValue.FromRawValue(sourceFAV.Currency, 0);
+
+            if (!currency.Hash.Equals(currencyHash))
+            {
+                throw new ArgumentException(
+                    $"The internal trie path {currencyHash} for a stored FAV does not match " +
+                    $"the hash {currency.Hash} of the FAV {currency.Ticker}");
+            }
+            else if (!currency.Equals(targetFAV.Currency))
+            {
+                throw new ArgumentException(
+                    $"The currency of the FAV stored in target {targetFAV.Currency} " +
+                    $"does match the currency of the FAV stored in source {sourceFAV.Currency}");
+            }
+
+            return (currency, targetFAV, sourceFAV);
+        }
+
+        internal static (ValidatorSet TargetValue, ValidatorSet SourceValue)
+            ToValidatorSetDiff(
+                (KeyBytes Path, IValue? TargetValue, IValue SourceValue) encoded)
+        {
+            if (encoded.Path.Equals(KeyConverters.ValidatorSetKey))
+            {
+                ValidatorSet sourceVS = new ValidatorSet(encoded.SourceValue);
+                ValidatorSet targetVS = encoded.TargetValue is { } value
+                    ? new ValidatorSet(value)
+                    : new ValidatorSet();
+                return (targetVS, sourceVS);
+            }
+            else
+            {
+                throw new ArgumentException(
+                    $"Encountered different values at an invalid location: {encoded.Path}");
+            }
+        }
+
+        internal static Address FromStateKey(KeyBytes key)
+        {
+            if (key.Length != _stateKeyLength)
+            {
+                throw new ArgumentException(
+                    $"Given {nameof(key)} must be of length {_stateKeyLength}: {key.Length}");
+            }
+
+            byte[] buffer = new byte[Address.Size];
+            for (int i = 0; i < buffer.Length; i++)
+            {
+                buffer[i] = Pack(key.ByteArray[i * 2], key.ByteArray[i * 2 + 1]);
+            }
+
+            return new Address(buffer);
+        }
+
+        internal static Address ToAddress(byte[] bytes)
+        {
+            if (bytes.Length != _stateKeyLength)
+            {
+                throw new ArgumentException(
+                    $"Given {nameof(bytes)} must be of length {_stateKeyLength}: {bytes.Length}");
+            }
+
+            byte[] buffer = new byte[Address.Size];
+            for (int i = 0; i < buffer.Length; i++)
+            {
+                buffer[i] = Pack(bytes[i * 2], bytes[i * 2 + 1]);
+            }
+
+            return new Address(buffer);
+        }
+
+        internal static HashDigest<SHA1> ToCurrencyHash(byte[] bytes)
+        {
+            var expectedLength = HashDigest<SHA1>.Size * 2;
+            if (bytes.Length != expectedLength)
+            {
+                throw new ArgumentException(
+                    $"Given {nameof(bytes)} must be of length {_stateKeyLength}: {bytes.Length}");
+            }
+
+            byte[] buffer = new byte[HashDigest<SHA1>.Size];
+            for (int i = 0; i < buffer.Length; i++)
+            {
+                buffer[i] = Pack(bytes[i * 2], bytes[i * 2 + 1]);
+            }
+
+            return new HashDigest<SHA1>(buffer);
+        }
+
+        // FIXME: Assumes both x and y are less than 16.
+        private static byte Pack(byte x, byte y) =>
+            (byte)((_reverseConversionTable[x] << 4) + _reverseConversionTable[y]);
+    }
+}

From 85e54d2e434ec43cbbc94c7abe3ba8834e8c04be Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 14 Sep 2023 14:01:24 +0900
Subject: [PATCH 14/72] Docs

---
 Libplanet.Action/State/AccountDiff.cs | 57 +++++++++++++++++++++++++--
 1 file changed, 54 insertions(+), 3 deletions(-)

diff --git a/Libplanet.Action/State/AccountDiff.cs b/Libplanet.Action/State/AccountDiff.cs
index 66fa45822d2..1d48f61ee12 100644
--- a/Libplanet.Action/State/AccountDiff.cs
+++ b/Libplanet.Action/State/AccountDiff.cs
@@ -12,6 +12,36 @@
 
 namespace Libplanet.Action.State
 {
+    /// <summary>
+    /// Represents a difference between two <see cref="IAccountState"/>s.
+    /// This is an interpretation of a raw difference obtained by <see cref="ITrie.Diff"/>
+    /// from <see cref="IAccountState"/>'s perspective.  Keep in mind of the following properties:
+    /// <list type="bullet">
+    ///     <item><description>
+    ///         Any <see lagnword="null"/> value, which is equivalent to non-existant value in
+    ///         the underlying storage, in the source is <em>ignored</em>.  That is, even if
+    ///         the value in the target and the value in the source are different while
+    ///         the value in the source is <see langword="null"/>, this will not be
+    ///         part of the resulting <see cref="AccountDiff"/>.
+    ///     </description></item>
+    ///     <item><description>
+    ///         Any <see langword="null"/> value, again, which is equivalent to non-existant value
+    ///         in the underlying storage, in the target for <see cref="FungibleAssetValue"/>
+    ///         and <see cref="ValidatorSet"/> is interpreted accordingly.  That is,
+    ///         0 amount of <see cref="FungibleAssetValue"/> and empty <see cref="ValidatorSet"/>
+    ///         are used.  This is in accordance with how <see cref="IAccountState.GetBalance"/>
+    ///         and <see cref="IAccountState.GetValidatorSet"/> would behave.
+    ///     </description></item>
+    ///     <item><description>
+    ///         Due to the reason mentioned directly above, the size of <see cref="AccountDiff"/>
+    ///         derived from <see cref="ITrie.Diff"/> may not be the same.  Moreover,
+    ///         an <see cref="AccountDiff"/> being empty <em>does not guarantee</em>
+    ///         that the data are the same as <see cref="IAccountState"/> is not capable of
+    ///         distinguishing between <see langword="null"/> and 0 <see cref="FungibleAssetValue"/>
+    ///         and so on and so forth.
+    ///     </description></item>
+    /// </list>
+    /// </summary>
     public class AccountDiff
     {
         private static readonly int _addressKeyLength = Address.Size * 2;
@@ -72,11 +102,32 @@ private AccountDiff(
 
         public (ValidatorSet, ValidatorSet)? ValidatorSetDiff { get; }
 
-        public static AccountDiff Create(IAccountState source, IAccountState target)
+        /// <summary>
+        /// Creates an <see cref="AccountDiff"/> instance from given parameters.
+        /// </summary>
+        /// <param name="target">The <see cref="IAccountState"/> to use as the target.</param>
+        /// <param name="source">The <see cref="IAccountState"/> to use as the source.</param>
+        /// <returns>An <see cref="AccountDiff"/> created from given parameters.</returns>
+        /// <remarks>Note that the ordering of the parameters are flipped compared to
+        /// <see cref="ITrie.Diff"/> for syntactical reasons.</remarks>
+        /// <seealso cref="ITrie.Diff"/>
+        /// <seealso cref="Create(ITrie, ITrie)"/>
+        public static AccountDiff Create(IAccountState target, IAccountState source)
             => Create(source.Trie, target.Trie);
 
-        // NOTE: interpret not actual.
-        public static AccountDiff Create(ITrie source, ITrie target)
+        /// <summary>
+        /// Creates an <see cref="AccountDiff"/> instance from given parameters.
+        /// </summary>
+        /// <param name="target">The <see cref="ITrie"/> to use as the target.</param>
+        /// <param name="source">The <see cref="ITrie"/> to use as the source.</param>
+        /// <returns>An <see cref="AccountDiff"/> created from given parameters.</returns>
+        /// <exception cref="ArgumentException">Thrown when the diff internally obtained from
+        /// <see cref="ITrie.Diff"/> cannot be properly interpreted.</exception>
+        /// <remarks>Note that the ordering of the parameters are flipped compared to
+        /// <see cref="ITrie.Diff"/> for syntactical reasons.</remarks>
+        /// <seealso cref="ITrie.Diff"/>
+        /// <seealso cref="Create(IAccountState, IAccountState)"/>
+        public static AccountDiff Create(ITrie target, ITrie source)
         {
             var rawDiffs = source.Diff(target).ToList();
 

From 09dad05f94fc1bd476947b8f869c1a521ee15e71 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 15 Sep 2023 17:38:32 +0900
Subject: [PATCH 15/72] Change FAVs to HashDigest<SHA1> and Integer

---
 Libplanet.Action/State/AccountDiff.cs | 115 +++++++++++++-------------
 1 file changed, 56 insertions(+), 59 deletions(-)

diff --git a/Libplanet.Action/State/AccountDiff.cs b/Libplanet.Action/State/AccountDiff.cs
index 1d48f61ee12..00a228ce5e7 100644
--- a/Libplanet.Action/State/AccountDiff.cs
+++ b/Libplanet.Action/State/AccountDiff.cs
@@ -14,7 +14,7 @@ namespace Libplanet.Action.State
 {
     /// <summary>
     /// Represents a difference between two <see cref="IAccountState"/>s.
-    /// This is an interpretation of a raw difference obtained by <see cref="ITrie.Diff"/>
+    /// This is a partial interpretation of a raw difference obtained by <see cref="ITrie.Diff"/>
     /// from <see cref="IAccountState"/>'s perspective.  Keep in mind of the following properties:
     /// <list type="bullet">
     ///     <item><description>
@@ -40,6 +40,13 @@ namespace Libplanet.Action.State
     ///         distinguishing between <see langword="null"/> and 0 <see cref="FungibleAssetValue"/>
     ///         and so on and so forth.
     ///     </description></item>
+    ///     <item><description>
+    ///         As <see cref="Currency"/> information is in the domain of an application using
+    ///         this library, only the hash of a <see cref="Currency"/> is directly stored in
+    ///         the underlying storage.  As such, each <see cref="Currency"/> and
+    ///         <see cref="FungibleAssetValue"/> are handled as raw values, that is, as hash and
+    ///         <see cref="Integer"/>, for an <see cref="AccountDiff"/>.
+    ///     </description></item>
     /// </list>
     /// </summary>
     public class AccountDiff
@@ -80,9 +87,9 @@ public class AccountDiff
 
         private AccountDiff(
             ImmutableDictionary<Address, (IValue?, IValue)> stateDiff,
-            ImmutableDictionary<(Address, Currency), (FungibleAssetValue, FungibleAssetValue)>
+            ImmutableDictionary<(Address, HashDigest<SHA1>), (Integer, Integer)>
                 fungibleAssetValueDiff,
-            ImmutableDictionary<Currency, (FungibleAssetValue, FungibleAssetValue)>
+            ImmutableDictionary<HashDigest<SHA1>, (Integer, Integer)>
                 totalSupplyDiff,
             (ValidatorSet, ValidatorSet)? validatorSetDiff)
         {
@@ -94,10 +101,10 @@ private AccountDiff(
 
         public ImmutableDictionary<Address, (IValue?, IValue)> StateDiffs { get; }
 
-        public ImmutableDictionary<(Address, Currency), (FungibleAssetValue, FungibleAssetValue)>
+        public ImmutableDictionary<(Address, HashDigest<SHA1>), (Integer, Integer)>
             FungibleAssetValueDiffs { get; }
 
-        public ImmutableDictionary<Currency, (FungibleAssetValue, FungibleAssetValue)>
+        public ImmutableDictionary<HashDigest<SHA1>, (Integer, Integer)>
             TotalSupplyDiffs { get; }
 
         public (ValidatorSet, ValidatorSet)? ValidatorSetDiff { get; }
@@ -113,7 +120,7 @@ private AccountDiff(
         /// <seealso cref="ITrie.Diff"/>
         /// <seealso cref="Create(ITrie, ITrie)"/>
         public static AccountDiff Create(IAccountState target, IAccountState source)
-            => Create(source.Trie, target.Trie);
+            => Create(target.Trie, source.Trie);
 
         /// <summary>
         /// Creates an <see cref="AccountDiff"/> instance from given parameters.
@@ -133,10 +140,10 @@ public static AccountDiff Create(ITrie target, ITrie source)
 
             Dictionary<Address, (IValue?, IValue)> stateDiffs =
                 new Dictionary<Address, (IValue?, IValue)>();
-            Dictionary<(Address, Currency), (FungibleAssetValue, FungibleAssetValue)> favDiffs =
-                new Dictionary<(Address, Currency), (FungibleAssetValue, FungibleAssetValue)>();
-            Dictionary<Currency, (FungibleAssetValue, FungibleAssetValue)> totalSupplyDiffs =
-                new Dictionary<Currency, (FungibleAssetValue, FungibleAssetValue)>();
+            Dictionary<(Address, HashDigest<SHA1>), (Integer, Integer)> favDiffs =
+                new Dictionary<(Address, HashDigest<SHA1>), (Integer, Integer)>();
+            Dictionary<HashDigest<SHA1>, (Integer, Integer)> totalSupplyDiffs =
+                new Dictionary<HashDigest<SHA1>, (Integer, Integer)>();
             (ValidatorSet, ValidatorSet)? validatorSetDiff = null;
 
             foreach (var diff in rawDiffs)
@@ -206,9 +213,9 @@ internal static (Address Address, IValue? TargetValue, IValue SourceValue)
 
         internal static (
             Address Address,
-            Currency Currency,
-            FungibleAssetValue TargetValue,
-            FungibleAssetValue SourceValue) ToFAVDiff(
+            HashDigest<SHA1> Currency,
+            Integer TargetValue,
+            Integer SourceValue) ToFAVDiff(
                 (KeyBytes Path, IValue? TargetValue, IValue SourceValue) encoded)
         {
             Address address =
@@ -220,60 +227,48 @@ internal static (
                         .Skip(_addressKeyLength + 2)
                         .Take(_currencyKeyLength)
                         .ToArray());
-            FungibleAssetValue sourceFAV = new FungibleAssetValue(encoded.SourceValue);
-            Currency currency = sourceFAV.Currency;
-            FungibleAssetValue targetFAV = encoded.TargetValue is { } value
-                ? new FungibleAssetValue(value)
-                : FungibleAssetValue.FromRawValue(sourceFAV.Currency, 0);
-
-            if (!currency.Hash.Equals(currencyHash))
-            {
-                throw new ArgumentException(
-                    $"The internal trie path {currencyHash} for a stored FAV does not match " +
-                    $"the hash {currency.Hash} of the FAV {currency.Ticker}");
-            }
-            else if (!currency.Equals(targetFAV.Currency))
-            {
-                throw new ArgumentException(
-                    $"The currency of the FAV stored in target {targetFAV.Currency} " +
-                    $"does match the currency of the FAV stored in source {sourceFAV.Currency}");
-            }
-
-            return (address, currency, targetFAV, sourceFAV);
+            Integer sourceValue = encoded.SourceValue is Integer sourceInteger
+                ? sourceInteger
+                : throw new ArgumentException(
+                    $"Expected an {nameof(Integer)} but encountered an invalid value " +
+                    $"{encoded.SourceValue} at {encoded.Path}");
+            Integer targetValue = encoded.TargetValue is { } value
+                ? value is Integer targetInteger
+                    ? targetInteger
+                    : throw new ArgumentException(
+                        $"Expected an {nameof(Integer)} but encountered " +
+                        $"an invalid value {encoded.TargetValue} at {encoded.Path}")
+                : new Integer(0);
+
+            return (address, currencyHash, targetValue, sourceValue);
         }
 
         internal static (
-            Currency Currency,
-            FungibleAssetValue TargetValue,
-            FungibleAssetValue SourceValue) ToTotalSupplyDiff(
+            HashDigest<SHA1> Currency,
+            Integer TargetValue,
+            Integer SourceValue) ToTotalSupplyDiff(
                 (KeyBytes Path, IValue? TargetValue, IValue SourceValue) encoded)
         {
             HashDigest<SHA1> currencyHash =
                 ToCurrencyHash(
                     encoded.Path.ByteArray
-                        .Skip(_addressKeyLength + 2)
+                        .Skip(2)
                         .Take(_currencyKeyLength)
                         .ToArray());
-            FungibleAssetValue sourceFAV = new FungibleAssetValue(encoded.SourceValue);
-            Currency currency = sourceFAV.Currency;
-            FungibleAssetValue targetFAV = encoded.TargetValue is { } value
-                ? new FungibleAssetValue(value)
-                : FungibleAssetValue.FromRawValue(sourceFAV.Currency, 0);
-
-            if (!currency.Hash.Equals(currencyHash))
-            {
-                throw new ArgumentException(
-                    $"The internal trie path {currencyHash} for a stored FAV does not match " +
-                    $"the hash {currency.Hash} of the FAV {currency.Ticker}");
-            }
-            else if (!currency.Equals(targetFAV.Currency))
-            {
-                throw new ArgumentException(
-                    $"The currency of the FAV stored in target {targetFAV.Currency} " +
-                    $"does match the currency of the FAV stored in source {sourceFAV.Currency}");
-            }
-
-            return (currency, targetFAV, sourceFAV);
+            Integer sourceValue = encoded.SourceValue is Integer sourceInteger
+                ? sourceInteger
+                : throw new ArgumentException(
+                    $"Expected an {nameof(Integer)} but encountered an invalid value " +
+                    $"{encoded.SourceValue} at {encoded.Path}");
+            Integer targetValue = encoded.TargetValue is { } value
+                ? value is Integer targetInteger
+                    ? targetInteger
+                    : throw new ArgumentException(
+                        $"Expected an {nameof(Integer)} but encountered " +
+                        $"an invalid value {encoded.TargetValue} at {encoded.Path}")
+                : new Integer(0);
+
+            return (currencyHash, targetValue, sourceValue);
         }
 
         internal static (ValidatorSet TargetValue, ValidatorSet SourceValue)
@@ -329,13 +324,15 @@ internal static Address ToAddress(byte[] bytes)
             return new Address(buffer);
         }
 
+        // FIXME: This assumes to know that hash algorithm used by Currency is SHA1.
         internal static HashDigest<SHA1> ToCurrencyHash(byte[] bytes)
         {
-            var expectedLength = HashDigest<SHA1>.Size * 2;
+            var expectedLength = _currencyKeyLength;
             if (bytes.Length != expectedLength)
             {
                 throw new ArgumentException(
-                    $"Given {nameof(bytes)} must be of length {_stateKeyLength}: {bytes.Length}");
+                    $"Given {nameof(bytes)} must be of length {_currencyKeyLength}: " +
+                    $"{bytes.Length}");
             }
 
             byte[] buffer = new byte[HashDigest<SHA1>.Size];

From 71f5a6b340c67476d95edb5e831f950eeb68721a Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 15 Sep 2023 17:43:48 +0900
Subject: [PATCH 16/72] Added test

---
 Libplanet.Tests/Action/AccountDiffTest.cs | 172 ++++++++++++++++++++++
 1 file changed, 172 insertions(+)
 create mode 100644 Libplanet.Tests/Action/AccountDiffTest.cs

diff --git a/Libplanet.Tests/Action/AccountDiffTest.cs b/Libplanet.Tests/Action/AccountDiffTest.cs
new file mode 100644
index 00000000000..16c902ad210
--- /dev/null
+++ b/Libplanet.Tests/Action/AccountDiffTest.cs
@@ -0,0 +1,172 @@
+using System.Collections.Generic;
+using Bencodex.Types;
+using Libplanet.Action;
+using Libplanet.Action.State;
+using Libplanet.Crypto;
+using Libplanet.Store;
+using Libplanet.Store.Trie;
+using Libplanet.Types.Assets;
+using Libplanet.Types.Blocks;
+using Libplanet.Types.Consensus;
+using Xunit;
+
+namespace Libplanet.Tests.Action
+{
+    public class AccountDiffTest
+    {
+        public AccountDiffTest()
+        {
+            USD = Currency.Uncapped("USD", 2, null);
+            KRW = Currency.Uncapped("KRW", 0, null);
+            JPY = Currency.Uncapped("JPY", 0, null);
+        }
+
+        public Currency USD { get; }
+
+        public Currency KRW { get; }
+
+        public Currency JPY { get; }
+
+        [Fact]
+        public void EmptyAccountStateSource()
+        {
+            IStateStore stateStore = new TrieStateStore(new MemoryKeyValueStore());
+            ITrie targetTrie = stateStore.GetStateRoot(null);
+            ITrie sourceTrie = stateStore.GetStateRoot(null);
+
+            AccountDiff diff = AccountDiff.Create(targetTrie, sourceTrie);
+            Assert.Empty(diff.StateDiffs);
+            Assert.Empty(diff.FungibleAssetValueDiffs);
+            Assert.Empty(diff.TotalSupplyDiffs);
+            Assert.Null(diff.ValidatorSetDiff);
+
+            IAccount targetAccount = new Account(new AccountState(targetTrie));
+            PrivateKey signer = new PrivateKey();
+            IActionContext context = CreateActionContext(signer.ToAddress(), targetTrie);
+            targetAccount = targetAccount.MintAsset(
+                context, signer.ToAddress(), new FungibleAssetValue(USD, 123, 45));
+            targetAccount = targetAccount.SetState(signer.ToAddress(), new Text("Foo"));
+
+            targetTrie = Commit(stateStore, targetTrie, targetAccount.Delta);
+
+            diff = AccountDiff.Create(targetTrie, sourceTrie);
+            Assert.Empty(diff.StateDiffs);
+            Assert.Empty(diff.FungibleAssetValueDiffs);
+            Assert.Empty(diff.TotalSupplyDiffs);
+            Assert.Null(diff.ValidatorSetDiff);
+        }
+
+        [Fact]
+        public void Diff()
+        {
+            IStateStore stateStore = new TrieStateStore(new MemoryKeyValueStore());
+            ITrie targetTrie = stateStore.GetStateRoot(null);
+            ITrie sourceTrie = stateStore.GetStateRoot(null);
+
+            Address addr1 = new Address(TestUtils.GetRandomBytes(Address.Size));
+            Address addr2 = new Address(TestUtils.GetRandomBytes(Address.Size));
+            Address addr3 = new Address(TestUtils.GetRandomBytes(Address.Size));
+
+            AccountDiff diff = AccountDiff.Create(targetTrie, sourceTrie);
+            Assert.Empty(diff.StateDiffs);
+            Assert.Empty(diff.FungibleAssetValueDiffs);
+            Assert.Empty(diff.TotalSupplyDiffs);
+            Assert.Null(diff.ValidatorSetDiff);
+
+            IAccount targetAccount = new Account(new AccountState(targetTrie));
+            PrivateKey signer = new PrivateKey();
+            IActionContext context = CreateActionContext(signer.ToAddress(), targetTrie);
+            targetAccount = targetAccount.SetState(addr1, new Text("One"));
+            targetAccount = targetAccount.SetState(addr2, new Text("Two"));
+            targetAccount = targetAccount.MintAsset(
+                context, signer.ToAddress(), new FungibleAssetValue(USD, 123, 45));
+
+            targetTrie = Commit(stateStore, targetTrie, targetAccount.Delta);
+            sourceTrie = targetTrie;
+
+            IAccount sourceAccount = new Account(new AccountState(sourceTrie));
+            sourceAccount = sourceAccount.SetState(addr2, new Text("Two_"));
+            sourceAccount = sourceAccount.SetState(addr3, new Text("Three"));
+            sourceAccount = sourceAccount.MintAsset(
+                context, signer.ToAddress(), new FungibleAssetValue(USD, 456, 78));
+            sourceAccount = sourceAccount.MintAsset(
+                context, signer.ToAddress(), new FungibleAssetValue(KRW, 10, 0));
+            sourceAccount = sourceAccount.BurnAsset(
+                context, signer.ToAddress(), new FungibleAssetValue(KRW, 10, 0));
+            sourceAccount = sourceAccount.MintAsset(
+                context, signer.ToAddress(), new FungibleAssetValue(JPY, 321, 0));
+            sourceAccount = sourceAccount.SetValidator(new Validator(signer.PublicKey, 1));
+
+            sourceTrie = Commit(stateStore, sourceTrie, sourceAccount.Delta);
+
+            diff = AccountDiff.Create(targetTrie, sourceTrie);
+            Assert.Equal(2, diff.StateDiffs.Count);
+            Assert.Equal((new Text("Two"), new Text("Two_")), diff.StateDiffs[addr2]);
+            Assert.Equal((null, new Text("Three")), diff.StateDiffs[addr3]);
+
+            Assert.Equal(2, diff.FungibleAssetValueDiffs.Count);    // KRW is treated as unchanged
+            Assert.Equal(
+                (new Integer(12345), new Integer(12345 + 45678)),
+                diff.FungibleAssetValueDiffs[(signer.ToAddress(), USD.Hash)]);
+            Assert.Equal(
+                (new Integer(0), new Integer(321)),
+                diff.FungibleAssetValueDiffs[(signer.ToAddress(), JPY.Hash)]);
+
+            Assert.Equal(2, diff.TotalSupplyDiffs.Count);           // KRW is treated as unchanged
+            Assert.Equal(
+                (new Integer(12345), new Integer(12345 + 45678)),
+                diff.TotalSupplyDiffs[USD.Hash]);
+            Assert.Equal(
+                (new Integer(0), new Integer(321)),
+                diff.TotalSupplyDiffs[JPY.Hash]);
+
+            Assert.Equal(
+                (
+                    new ValidatorSet(),
+                    new ValidatorSet(new List<Validator>() { new Validator(signer.PublicKey, 1) })
+                ),
+                diff.ValidatorSetDiff);
+
+            diff = AccountDiff.Create(sourceTrie, targetTrie);
+            Assert.Single(diff.StateDiffs);                 // Note addr3 is not tracked
+            Assert.Equal((new Text("Two_"), new Text("Two")), diff.StateDiffs[addr2]);
+            Assert.Single(diff.FungibleAssetValueDiffs);    // Only USD is tracked
+            Assert.Equal(
+                (new Integer(12345 + 45678), new Integer(12345)),
+                diff.FungibleAssetValueDiffs[(signer.ToAddress(), USD.Hash)]);
+            Assert.Single(diff.TotalSupplyDiffs);           // Only USD is tracked
+            Assert.Equal(
+                (new Integer(12345 + 45678), new Integer(12345)),
+                diff.TotalSupplyDiffs[USD.Hash]);
+            Assert.Null(diff.ValidatorSetDiff);             // Note ValidatorSet is not tracked
+        }
+
+        public IActionContext CreateActionContext(Address signer, ITrie trie) =>
+            new ActionContext(
+                signer,
+                null,
+                signer,
+                0,
+                Block.CurrentProtocolVersion,
+                new Account(new AccountState(trie)),
+                0,
+                0,
+                false);
+
+        public ITrie Commit(
+            IStateStore stateStore,
+            ITrie baseTrie,
+            IAccountDelta accountDelta)
+        {
+            var trie = baseTrie;
+            var rawDelta = accountDelta.ToRawDelta();
+
+            foreach (var kv in rawDelta)
+            {
+                trie = trie.Set(kv.Key, kv.Value);
+            }
+
+            return stateStore.Commit(trie);
+        }
+    }
+}

From d19fdac843f77e2bf0593612ab26bd7ba6f50e51 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 15 Sep 2023 17:45:16 +0900
Subject: [PATCH 17/72] Typo fix

---
 Libplanet.Action/State/AccountDiff.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Libplanet.Action/State/AccountDiff.cs b/Libplanet.Action/State/AccountDiff.cs
index 00a228ce5e7..dc414d63ed2 100644
--- a/Libplanet.Action/State/AccountDiff.cs
+++ b/Libplanet.Action/State/AccountDiff.cs
@@ -18,14 +18,14 @@ namespace Libplanet.Action.State
     /// from <see cref="IAccountState"/>'s perspective.  Keep in mind of the following properties:
     /// <list type="bullet">
     ///     <item><description>
-    ///         Any <see lagnword="null"/> value, which is equivalent to non-existant value in
+    ///         Any <see lagnword="null"/> value, which is equivalent to non-existent value in
     ///         the underlying storage, in the source is <em>ignored</em>.  That is, even if
     ///         the value in the target and the value in the source are different while
     ///         the value in the source is <see langword="null"/>, this will not be
     ///         part of the resulting <see cref="AccountDiff"/>.
     ///     </description></item>
     ///     <item><description>
-    ///         Any <see langword="null"/> value, again, which is equivalent to non-existant value
+    ///         Any <see langword="null"/> value, again, which is equivalent to non-existent value
     ///         in the underlying storage, in the target for <see cref="FungibleAssetValue"/>
     ///         and <see cref="ValidatorSet"/> is interpreted accordingly.  That is,
     ///         0 amount of <see cref="FungibleAssetValue"/> and empty <see cref="ValidatorSet"/>

From 8ab83ad6344629d006d1065cd659b33a862d19f6 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Tue, 19 Sep 2023 10:52:59 +0900
Subject: [PATCH 18/72] Changelog

---
 CHANGES.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 8b9e5a89637..9c893e102ed 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -25,6 +25,7 @@ To be released.
 
 ### Added APIs
 
+ -  Added `AccountDiff` class.  [[#3424]]
  -  Added `IActionRenderContext` interface.  [[#3427]]
 
 ### Behavioral changes
@@ -35,6 +36,7 @@ To be released.
 
 ### CLI tools
 
+[#3424]: https://github.com/planetarium/libplanet/pull/3424
 [#3425]: https://github.com/planetarium/libplanet/pull/3425
 [#3427]: https://github.com/planetarium/libplanet/pull/3427
 

From cf1d2d6f6b28ddb4ac12c0daaba97d62c26c2528 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 07:39:29 +0900
Subject: [PATCH 19/72] Removed unnecessary ISerializable implementation

---
 Libplanet.Tests/Tx/TxFailureTest.cs | 18 -------
 Libplanet.Tests/Tx/TxSuccessTest.cs | 18 -------
 Libplanet.Types/Tx/TxExecution.cs   | 20 +-------
 Libplanet.Types/Tx/TxFailure.cs     | 19 --------
 Libplanet.Types/Tx/TxSuccess.cs     | 75 +----------------------------
 5 files changed, 2 insertions(+), 148 deletions(-)

diff --git a/Libplanet.Tests/Tx/TxFailureTest.cs b/Libplanet.Tests/Tx/TxFailureTest.cs
index 0caebf920e5..f628e8054a6 100644
--- a/Libplanet.Tests/Tx/TxFailureTest.cs
+++ b/Libplanet.Tests/Tx/TxFailureTest.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Runtime.Serialization.Formatters.Binary;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
 using Xunit;
@@ -54,21 +52,5 @@ public void Constructor()
             Assert.Equal(nameof(ArgumentNullException), f.ExceptionName);
             Assert.Null(f.ExceptionMetadata);
         }
-
-        [Fact]
-        public void Serialization()
-        {
-            var formatter = new BinaryFormatter();
-            var stream = new MemoryStream();
-            formatter.Serialize(stream, _fx);
-            stream.Seek(0, SeekOrigin.Begin);
-            object deserialized = formatter.Deserialize(stream);
-            Assert.IsType<TxFailure>(deserialized);
-            var f = (TxFailure)deserialized;
-            Assert.Equal(_blockHash, f.BlockHash);
-            Assert.Equal(_txid, f.TxId);
-            Assert.Equal(_fx.ExceptionName, f.ExceptionName);
-            Assert.Equal(_fx.ExceptionMetadata, f.ExceptionMetadata);
-        }
     }
 }
diff --git a/Libplanet.Tests/Tx/TxSuccessTest.cs b/Libplanet.Tests/Tx/TxSuccessTest.cs
index 6418da8edbe..fecce72eece 100644
--- a/Libplanet.Tests/Tx/TxSuccessTest.cs
+++ b/Libplanet.Tests/Tx/TxSuccessTest.cs
@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Immutable;
-using System.IO;
 using System.Linq;
-using System.Runtime.Serialization.Formatters.Binary;
 using Bencodex.Types;
 using Libplanet.Crypto;
 using Libplanet.Types.Assets;
@@ -71,21 +69,5 @@ public void ConstructorBuilder()
             Assert.Equal(_updatedStates, _fx.UpdatedStates);
             Assert.Equal(_updatedFungibleAssets, _fx.UpdatedFungibleAssets);
         }
-
-        [Fact]
-        public void Serialization()
-        {
-            var formatter = new BinaryFormatter();
-            var stream = new MemoryStream();
-            formatter.Serialize(stream, _fx);
-            stream.Seek(0, SeekOrigin.Begin);
-            object deserialized = formatter.Deserialize(stream);
-            Assert.IsType<TxSuccess>(deserialized);
-            var s = (TxSuccess)deserialized;
-            Assert.Equal(_blockHash, s.BlockHash);
-            Assert.Equal(_txid, s.TxId);
-            Assert.Equal(_fx.UpdatedStates, s.UpdatedStates);
-            Assert.Equal(_fx.UpdatedFungibleAssets, s.UpdatedFungibleAssets);
-        }
     }
 }
diff --git a/Libplanet.Types/Tx/TxExecution.cs b/Libplanet.Types/Tx/TxExecution.cs
index c7ed50ba23b..c534c63b307 100644
--- a/Libplanet.Types/Tx/TxExecution.cs
+++ b/Libplanet.Types/Tx/TxExecution.cs
@@ -1,8 +1,5 @@
-using System;
 using System.Diagnostics.Contracts;
-using System.Runtime.Serialization;
 using Bencodex;
-using Libplanet.Common.Serialization;
 using Libplanet.Types.Blocks;
 
 namespace Libplanet.Types.Tx
@@ -15,18 +12,10 @@ namespace Libplanet.Types.Tx
     /// </summary>
     /// <seealso cref="TxSuccess"/>
     /// <seealso cref="TxFailure"/>
-    [Serializable]
-    public abstract class TxExecution : ISerializable
+    public abstract class TxExecution
     {
         protected static readonly Codec _codec = new Codec();
 
-        protected TxExecution(SerializationInfo info, StreamingContext context)
-            : this(
-                info.GetValue<BlockHash>(nameof(BlockHash)),
-                info.GetValue<TxId>(nameof(TxId)))
-        {
-        }
-
         private protected TxExecution(BlockHash blockHash, TxId txId)
         {
             BlockHash = blockHash;
@@ -45,12 +34,5 @@ private protected TxExecution(BlockHash blockHash, TxId txId)
         /// </summary>
         [Pure]
         public TxId TxId { get; }
-
-        /// <inheritdoc cref="ISerializable.GetObjectData(SerializationInfo, StreamingContext)"/>
-        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            info.AddValue(nameof(BlockHash), BlockHash);
-            info.AddValue(nameof(TxId), TxId);
-        }
     }
 }
diff --git a/Libplanet.Types/Tx/TxFailure.cs b/Libplanet.Types/Tx/TxFailure.cs
index f15e4c744e1..707aa88c992 100644
--- a/Libplanet.Types/Tx/TxFailure.cs
+++ b/Libplanet.Types/Tx/TxFailure.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Diagnostics.Contracts;
-using System.Runtime.Serialization;
 using Bencodex.Types;
 using Libplanet.Types.Blocks;
 
@@ -10,7 +9,6 @@ namespace Libplanet.Types.Tx
     /// Summarizes an execution result of a <see cref="Transaction"/> with any exception-throwing
     /// actions.
     /// </summary>
-    [Serializable]
     public sealed class TxFailure : TxExecution
     {
         /// <summary>
@@ -54,12 +52,6 @@ public TxFailure(
         {
         }
 
-        private TxFailure(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-        {
-            ExceptionName = info.GetString(nameof(ExceptionName)) ?? string.Empty;
-        }
-
         /// <summary>
         /// The name of the exception type, e.g., <c>System.ArgumentException</c>.
         /// </summary>
@@ -71,16 +63,5 @@ private TxFailure(SerializationInfo info, StreamingContext context)
         /// </summary>
         [Pure]
         public IValue? ExceptionMetadata => null;
-
-        /// <inheritdoc cref="ISerializable.GetObjectData(SerializationInfo, StreamingContext)"/>
-        public override void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            base.GetObjectData(info, context);
-            info.AddValue(nameof(ExceptionName), ExceptionName);
-            info.AddValue(
-                nameof(ExceptionMetadata),
-                ExceptionMetadata is { } m ? _codec.Encode(m) : null
-            );
-        }
     }
 }
diff --git a/Libplanet.Types/Tx/TxSuccess.cs b/Libplanet.Types/Tx/TxSuccess.cs
index e35bd0c1382..25aed81870e 100644
--- a/Libplanet.Types/Tx/TxSuccess.cs
+++ b/Libplanet.Types/Tx/TxSuccess.cs
@@ -1,12 +1,6 @@
-using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.Contracts;
-using System.Linq;
-using System.Numerics;
-using System.Runtime.Serialization;
 using Bencodex.Types;
-using Libplanet.Common.Serialization;
 using Libplanet.Crypto;
 using Libplanet.Types.Assets;
 using Libplanet.Types.Blocks;
@@ -17,8 +11,7 @@ namespace Libplanet.Types.Tx
     /// <summary>
     /// Summarizes an execution result of a successful <see cref="Transaction"/>.
     /// </summary>
-    [Serializable]
-    public sealed class TxSuccess : TxExecution, ISerializable
+    public sealed class TxSuccess : TxExecution
     {
         /// <summary>
         /// Creates a <see cref="TxSuccess"/> instance.
@@ -50,20 +43,6 @@ public TxSuccess(
             UpdatedFungibleAssets = updatedFungibleAssets;
         }
 
-        private TxSuccess(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-        {
-            var updatedStates =
-                (Dictionary)_codec.Decode(info.GetValue<byte[]>(nameof(UpdatedStates)));
-            UpdatedStates = updatedStates.ToImmutableDictionary(
-                kv => new Address(kv.Key),
-                kv => kv.Value
-            );
-            UpdatedFungibleAssets = DecodeFungibleAssetGroups(
-                info.GetValue<byte[]>(nameof(UpdatedFungibleAssets))
-            );
-        }
-
         /// <summary>
         /// The states delta made by the actions in the transaction within the block.
         /// </summary>
@@ -87,57 +66,5 @@ public IImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>
         [Pure]
         public IImmutableSet<Address> UpdatedAddresses =>
             UpdatedStates.Keys.ToImmutableHashSet().Union(UpdatedFungibleAssets.Keys);
-
-        /// <inheritdoc cref="ISerializable.GetObjectData(SerializationInfo, StreamingContext)"/>
-        public override void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            base.GetObjectData(info, context);
-            info.AddValue(
-                nameof(UpdatedStates),
-                _codec.Encode(
-                    new Dictionary(
-                        UpdatedStates.Select(kv =>
-                            new KeyValuePair<IKey, IValue>(
-                                new Binary(kv.Key.ToByteArray()),
-                                kv.Value))))
-            );
-            info.AddValue(
-                nameof(UpdatedFungibleAssets),
-                EncodeFungibleAssetGroups(UpdatedFungibleAssets)
-            );
-        }
-
-        private static byte[] EncodeFungibleAssetGroups(
-            IImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>> g
-        ) =>
-            _codec.Encode(
-                new Dictionary(
-                    g.Select(kv =>
-                        new KeyValuePair<Binary, List>(
-                            kv.Key.ByteArray,
-                            new List(
-                                kv.Value.Select(fav =>
-                                    List.Empty
-                                        .Add(fav.Key.Serialize())
-                                        .Add(fav.Value.RawValue)
-                                )
-                            )
-                        )
-                    )
-                )
-            );
-
-        private static IImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>
-        DecodeFungibleAssetGroups(byte[] encoded) =>
-            ((Dictionary)_codec.Decode(encoded)).ToImmutableDictionary(
-                kv => new Address(kv.Key),
-                kv => (IImmutableDictionary<Currency, FAV>)((List)kv.Value)
-                    .Cast<List>()
-                    .Select(pair => (new Currency(pair[0]), (Bencodex.Types.Integer)pair[1]))
-                    .ToImmutableDictionary(
-                        pair => pair.Item1,
-                        pair => FungibleAssetValue.FromRawValue(pair.Item1, (BigInteger)pair.Item2)
-                    )
-            );
     }
 }

From 0da3bbe10a2c284aa7382f86b28d22db1694f779 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 07:42:48 +0900
Subject: [PATCH 20/72] Remove unused ExceptionMetadata from TxFailure

---
 Libplanet.Store/BaseStore.cs                           | 2 +-
 Libplanet.Tests/Blockchain/BlockChainTest.Append.cs    | 1 -
 Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs | 1 -
 Libplanet.Tests/Store/StoreTest.cs                     | 1 -
 Libplanet.Tests/Tx/TxFailureTest.cs                    | 2 --
 Libplanet.Types/Tx/TxFailure.cs                        | 7 -------
 6 files changed, 1 insertion(+), 13 deletions(-)

diff --git a/Libplanet.Store/BaseStore.cs b/Libplanet.Store/BaseStore.cs
index c2b7146154a..d6ac2b1873e 100644
--- a/Libplanet.Store/BaseStore.cs
+++ b/Libplanet.Store/BaseStore.cs
@@ -203,7 +203,7 @@ protected static IValue SerializeTxExecution(TxFailure txFailure)
                 .Add("fail", true)
                 .Add("exc", txFailure.ExceptionName);
 
-            return txFailure.ExceptionMetadata is { } v ? d.Add("excMeta", v) : d;
+            return d;
         }
 
         protected static TxExecution DeserializeTxExecution(
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
index 30ffcf280df..c157f939948 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
@@ -240,7 +240,6 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
                 $"{nameof(System)}.{nameof(ArgumentOutOfRangeException)}",
                 txFailure.ExceptionName
             );
-            Assert.Null(txFailure.ExceptionMetadata);
             var txExecution3 = getTxExecution(block3.Hash, tx3Transfer.Id);
             _logger.Verbose(nameof(txExecution3) + " = {@TxExecution}", txExecution3);
             Assert.IsType<TxSuccess>(txExecution3);
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs
index c4b96ce5638..edc36f6275a 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs
@@ -161,7 +161,6 @@ void AssertTxFailuresEqual(TxFailure expected, TxExecution actual)
                 Assert.Equal(expected.TxId, failure.TxId);
                 Assert.Equal(expected.BlockHash, failure.BlockHash);
                 Assert.Equal(expected.ExceptionName, failure.ExceptionName);
-                Assert.Equal(expected.ExceptionMetadata, failure.ExceptionMetadata);
             }
 
             Func<BlockHash, TxId, TxExecution> getTxExecution
diff --git a/Libplanet.Tests/Store/StoreTest.cs b/Libplanet.Tests/Store/StoreTest.cs
index 38a4dab3f64..8c464c83c74 100644
--- a/Libplanet.Tests/Store/StoreTest.cs
+++ b/Libplanet.Tests/Store/StoreTest.cs
@@ -410,7 +410,6 @@ void AssertTxFailuresEqual(TxFailure expected, TxExecution actual)
                 Assert.Equal(expected.TxId, failure.TxId);
                 Assert.Equal(expected.BlockHash, failure.BlockHash);
                 Assert.Equal(expected.ExceptionName, failure.ExceptionName);
-                Assert.Equal(expected.ExceptionMetadata, failure.ExceptionMetadata);
             }
 
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId1));
diff --git a/Libplanet.Tests/Tx/TxFailureTest.cs b/Libplanet.Tests/Tx/TxFailureTest.cs
index f628e8054a6..6897580aa97 100644
--- a/Libplanet.Tests/Tx/TxFailureTest.cs
+++ b/Libplanet.Tests/Tx/TxFailureTest.cs
@@ -36,7 +36,6 @@ public void ConstructorWithExceptionObject()
             Assert.Equal(
                 $"{nameof(System)}.{nameof(ArgumentNullException)}",
                 _fx.ExceptionName);
-            Assert.Null(_fx.ExceptionMetadata);
         }
 
         [Fact]
@@ -50,7 +49,6 @@ public void Constructor()
             Assert.Equal(_blockHash, f.BlockHash);
             Assert.Equal(_txid, f.TxId);
             Assert.Equal(nameof(ArgumentNullException), f.ExceptionName);
-            Assert.Null(f.ExceptionMetadata);
         }
     }
 }
diff --git a/Libplanet.Types/Tx/TxFailure.cs b/Libplanet.Types/Tx/TxFailure.cs
index 707aa88c992..43ed9646293 100644
--- a/Libplanet.Types/Tx/TxFailure.cs
+++ b/Libplanet.Types/Tx/TxFailure.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Diagnostics.Contracts;
-using Bencodex.Types;
 using Libplanet.Types.Blocks;
 
 namespace Libplanet.Types.Tx
@@ -57,11 +56,5 @@ public TxFailure(
         /// </summary>
         [Pure]
         public string ExceptionName { get; }
-
-        /// <summary>
-        /// Optional metadata about the exception.
-        /// </summary>
-        [Pure]
-        public IValue? ExceptionMetadata => null;
     }
 }

From fa6bb26a52386a8c69a3f80449580bd8923592d6 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 09:31:37 +0900
Subject: [PATCH 21/72] Changelog

---
 CHANGES.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 9c893e102ed..710a446002a 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -18,6 +18,9 @@ To be released.
  -  Changed `IActionRenderer.RenderActionError(IValue, IActionContext,
     Exception)` to `IActionRenderer.RenderActionError(IValue,
     IActionRenderContext, Exception)`.  [[#3427]]
+ -  Removed `TxFailure.ExceptionMetadata` property.  [[#3428]]
+ -  Removed `ISerializable` interface from `TxExecution`, `TxSuccess`,
+    and `TxFailure`.  [[#3428]]
 
 ### Backward-incompatible network protocol changes
 
@@ -39,6 +42,7 @@ To be released.
 [#3424]: https://github.com/planetarium/libplanet/pull/3424
 [#3425]: https://github.com/planetarium/libplanet/pull/3425
 [#3427]: https://github.com/planetarium/libplanet/pull/3427
+[#3428]: https://github.com/planetarium/libplanet/pull/3428
 
 
 Version 3.3.1

From 6b4ce880208ead54b052b11187b435ccdc64e3a0 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 05:17:01 +0900
Subject: [PATCH 22/72] Initial MakeTxExecutions overhaul

---
 .../Blockchain/BlockChain.TxExecution.cs      | 106 ++++++++++++------
 1 file changed, 73 insertions(+), 33 deletions(-)

diff --git a/Libplanet/Blockchain/BlockChain.TxExecution.cs b/Libplanet/Blockchain/BlockChain.TxExecution.cs
index 8b85b895eaa..9004bb98698 100644
--- a/Libplanet/Blockchain/BlockChain.TxExecution.cs
+++ b/Libplanet/Blockchain/BlockChain.TxExecution.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
@@ -5,6 +6,7 @@
 using System.Linq;
 using Libplanet.Action;
 using Libplanet.Action.State;
+using Libplanet.Store.Trie;
 using Libplanet.Types.Assets;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
@@ -28,44 +30,83 @@ IReadOnlyList<IActionEvaluation> evaluations
                 .Where(e => e.InputContext.TxId is { })
                 .GroupBy(e => e.InputContext.TxId!.Value);
             int count = 0;
-            foreach (IGrouping<TxId, IActionEvaluation> txEvals in evaluationsPerTxs)
+
+            List<(TxId?, List<IActionEvaluation>)> groupedEvals =
+                new List<(TxId?, List<IActionEvaluation>)>();
+            foreach (IActionEvaluation eval in evaluations)
             {
-                TxId txid = txEvals.Key;
-                IAccount prevStates = txEvals.First().InputContext.PreviousState;
-                IActionEvaluation evalSum = txEvals.Last();
-                TxExecution txExecution;
-                if (evalSum.Exception is { } e)
+                if (groupedEvals.Count == 0)
                 {
-                    txExecution = new TxFailure(
-                        block.Hash,
-                        txid,
-                        e.InnerException ?? e);
+                    groupedEvals.Add(
+                        (eval.InputContext.TxId, new List<IActionEvaluation>() { eval }));
                 }
                 else
                 {
-                    IAccount outputStates = evalSum.OutputState;
-                    txExecution = new TxSuccess(
-                        block.Hash,
-                        txid,
-                        outputStates.GetUpdatedStates(),
-                        outputStates.Delta.UpdatedFungibleAssets
-                            .Select(pair =>
-                                (
-                                    pair.Item1,
-                                    pair.Item2,
-                                    outputStates.GetBalance(pair.Item1, pair.Item2)
-                                ))
-                            .GroupBy(triple => triple.Item1)
-                            .ToImmutableDictionary(
-                                group => group.Key,
-                                group => (IImmutableDictionary<Currency, FungibleAssetValue>)group
-                                    .ToImmutableDictionary(
-                                        triple => triple.Item2,
-                                        triple => triple.Item3)));
+                    if (groupedEvals.Last().Item1.Equals(eval.InputContext.TxId))
+                    {
+                        groupedEvals.Last().Item2.Add(eval);
+                    }
+                    else
+                    {
+                        groupedEvals.Add(
+                            (eval.InputContext.TxId, new List<IActionEvaluation>() { eval }));
+                    }
                 }
+            }
 
-                yield return txExecution;
-                count++;
+            ITrie trie = GetAccountState(block.PreviousHash).Trie;
+
+            foreach (var group in groupedEvals)
+            {
+                if (group.Item1 is { } txId)
+                {
+                    // make tx execution
+                    ITrie nextTrie = trie;
+                    foreach (var eval in group.Item2)
+                    {
+                        foreach (var kv in eval.OutputState.Delta.ToRawDelta())
+                        {
+                            nextTrie = nextTrie.Set(kv.Key, kv.Value);
+                        }
+                    }
+
+                    nextTrie = StateStore.Commit(nextTrie);
+
+                    List<Exception?> exceptions = group.Item2
+                        .Select(eval => eval.Exception)
+                        .ToList();
+
+                    yield return exceptions.Any(exception => exception is { })
+                        ? new TxFailure(
+                            block.Hash,
+                            txId,
+                            trie.Hash,
+                            nextTrie.Hash,
+                            exceptions)
+                        : new TxSuccess(
+                            block.Hash,
+                            txId,
+                            trie.Hash,
+                            nextTrie.Hash,
+                            exceptions);
+                    count++;
+                    trie = nextTrie;
+                }
+                else
+                {
+                    // move forward
+                    ITrie nextTrie = trie;
+                    foreach (var eval in group.Item2)
+                    {
+                        foreach (var kv in eval.OutputState.Delta.ToRawDelta())
+                        {
+                            nextTrie = nextTrie.Set(kv.Key, kv.Value);
+                        }
+                    }
+
+                    nextTrie = StateStore.Commit(nextTrie);
+                    trie = nextTrie;
+                }
             }
 
             _logger.Verbose(
@@ -73,8 +114,7 @@ IReadOnlyList<IActionEvaluation> evaluations
                 "s for {Txs} transactions within the block #{BlockIndex} {BlockHash}",
                 count,
                 block.Index,
-                block.Hash
-            );
+                block.Hash);
         }
 
         internal void UpdateTxExecutions(IEnumerable<TxExecution> txExecutions)

From 3b1ba6b27ab52888093b248770b1e2c3513cf6c9 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 11:42:38 +0900
Subject: [PATCH 23/72] Reimplement TxSuccess and TxFailure

---
 Libplanet.Types/Tx/TxFailure.cs               | 55 +++++++------
 Libplanet.Types/Tx/TxSuccess.cs               | 82 +++++++++----------
 .../Blockchain/BlockChain.TxExecution.cs      | 24 +++---
 3 files changed, 81 insertions(+), 80 deletions(-)

diff --git a/Libplanet.Types/Tx/TxFailure.cs b/Libplanet.Types/Tx/TxFailure.cs
index 43ed9646293..8427980b99a 100644
--- a/Libplanet.Types/Tx/TxFailure.cs
+++ b/Libplanet.Types/Tx/TxFailure.cs
@@ -1,5 +1,8 @@
 using System;
-using System.Diagnostics.Contracts;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 
 namespace Libplanet.Types.Tx
@@ -17,44 +20,48 @@ public sealed class TxFailure : TxExecution
         /// that the <see cref="Transaction"/> is executed within.</param>
         /// <param name="txId">The executed <see cref="Transaction"/>'s <see
         /// cref="Transaction.Id"/>.</param>
-        /// <param name="exceptionName">The name of the exception type,
-        /// e.g., <c>System.ArgumentException</c>.</param>
-        /// <param name="exceptionMetadata">Optional metadata about the exception.</param>
+        /// <param name="inputState">The state root hash of the state before the
+        /// execution of a <see cref="Transaction"/>.</param>
+        /// <param name="outputState">The state root hash of the state after the
+        /// execution of a <see cref="Transaction"/>.</param>
+        /// <param name="exceptionNames">The list of excetions thrown while
+        /// executing the actions.</param>
         public TxFailure(
             BlockHash blockHash,
             TxId txId,
-            string exceptionName
-        )
+            HashDigest<SHA256> inputState,
+            HashDigest<SHA256> outputState,
+            List<string> exceptionNames)
             : base(blockHash, txId)
         {
-            ExceptionName = exceptionName;
+            InputState = inputState;
+            OutputState = outputState;
+            ExceptionNames = exceptionNames;
         }
 
-        /// <summary>
-        /// Creates a <see cref="TxFailure"/> instance.
-        /// </summary>
-        /// <param name="blockHash">The <see cref="Block.Hash"/> of the <see cref="Block"/>
-        /// that the <see cref="Transaction"/> is executed within.</param>
-        /// <param name="txId">The executed <see cref="Transaction"/>'s <see
-        /// cref="Transaction.Id"/>.</param>
-        /// <param name="exception">The uncaught exception thrown by an action in the transaction.
-        /// </param>
         public TxFailure(
             BlockHash blockHash,
             TxId txId,
-            Exception exception)
+            HashDigest<SHA256> inputState,
+            HashDigest<SHA256> outputState,
+            List<Exception?> exceptions)
             : this(
                 blockHash,
                 txId,
-                exception.GetType().FullName ?? string.Empty
-            )
+                inputState,
+                outputState,
+                exceptions
+                    .Select(exception => exception is { } e
+                        ? e.GetType().FullName
+                        : string.Empty)
+                    .ToList())
         {
         }
 
-        /// <summary>
-        /// The name of the exception type, e.g., <c>System.ArgumentException</c>.
-        /// </summary>
-        [Pure]
-        public string ExceptionName { get; }
+        public HashDigest<SHA256> InputState { get; }
+
+        public HashDigest<SHA256> OutputState { get; }
+
+        public List<string> ExceptionNames { get; }
     }
 }
diff --git a/Libplanet.Types/Tx/TxSuccess.cs b/Libplanet.Types/Tx/TxSuccess.cs
index 25aed81870e..a41e6fc034b 100644
--- a/Libplanet.Types/Tx/TxSuccess.cs
+++ b/Libplanet.Types/Tx/TxSuccess.cs
@@ -1,10 +1,9 @@
-using System.Collections.Immutable;
-using System.Diagnostics.Contracts;
-using Bencodex.Types;
-using Libplanet.Crypto;
-using Libplanet.Types.Assets;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
-using FAV = Libplanet.Types.Assets.FungibleAssetValue;
 
 namespace Libplanet.Types.Tx
 {
@@ -20,51 +19,48 @@ public sealed class TxSuccess : TxExecution
         /// that the <see cref="Transaction"/> is executed within.</param>
         /// <param name="txId">The executed <see cref="Transaction"/>'s <see
         /// cref="Transaction.Id"/>.</param>
-        /// <param name="updatedStates">The states delta made by the actions in
-        /// the transaction within the block.</param>
-        /// <param name="fungibleAssetsDelta"><see cref="Address"/>es and sets of
-        /// <see cref="Currency"/> whose fungible assets have been updated by the actions in
-        /// the transaction within the block.  Included <see cref="FungibleAssetValue"/>s are
-        /// the delta values (plus or minus) that the transaction makes.</param>
-        /// <param name="updatedFungibleAssets"><see cref="Address"/>es and sets of
-        /// <see cref="Currency"/> whose fungible assets have been updated by the actions in
-        /// the transaction within the block.  Included <see cref="FungibleAssetValue"/>s are
-        /// the final balances right after the transaction is executed.</param>
+        /// <param name="inputState">The state root hash of the state before the
+        /// execution of a <see cref="Transaction"/>.</param>
+        /// <param name="outputState">The state root hash of the state after the
+        /// execution of a <see cref="Transaction"/>.</param>
+        /// <param name="exceptionNames">The list of excetions thrown while
+        /// executing the actions.</param>
         public TxSuccess(
             BlockHash blockHash,
             TxId txId,
-            IImmutableDictionary<Address, IValue> updatedStates,
-            IImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>
-                updatedFungibleAssets
-        )
+            HashDigest<SHA256> inputState,
+            HashDigest<SHA256> outputState,
+            List<string> exceptionNames)
             : base(blockHash, txId)
         {
-            UpdatedStates = updatedStates;
-            UpdatedFungibleAssets = updatedFungibleAssets;
+            InputState = inputState;
+            OutputState = outputState;
+            ExceptionNames = exceptionNames;
         }
 
-        /// <summary>
-        /// The states delta made by the actions in the transaction within the block.
-        /// </summary>
-        [Pure]
-        public IImmutableDictionary<Address, IValue> UpdatedStates { get; }
+        public TxSuccess(
+            BlockHash blockHash,
+            TxId txId,
+            HashDigest<SHA256> inputState,
+            HashDigest<SHA256> outputState,
+            List<Exception?> exceptions)
+            : this(
+                blockHash,
+                txId,
+                inputState,
+                outputState,
+                exceptions
+                    .Select(exception => exception is { } e
+                        ? e.GetType().FullName
+                        : string.Empty)
+                    .ToList())
+        {
+        }
 
-        /// <summary>
-        /// <see cref="Address"/>es and sets of <see cref="Currency"/> whose fungible assets have
-        /// been updated by the actions in the transaction within the block.  Included
-        /// <see cref="FungibleAssetValue"/>s are the final balances right after the transaction is
-        /// executed.
-        /// </summary>
-        [Pure]
-        public IImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>
-            UpdatedFungibleAssets { get; }
+        public HashDigest<SHA256> InputState { get; }
 
-        /// <summary>
-        /// All <seealso cref="Address"/>es of the accounts that have been updated by the actions
-        /// in the transaction within the block.
-        /// </summary>
-        [Pure]
-        public IImmutableSet<Address> UpdatedAddresses =>
-            UpdatedStates.Keys.ToImmutableHashSet().Union(UpdatedFungibleAssets.Keys);
+        public HashDigest<SHA256> OutputState { get; }
+
+        public List<string> ExceptionNames { get; }
     }
 }
diff --git a/Libplanet/Blockchain/BlockChain.TxExecution.cs b/Libplanet/Blockchain/BlockChain.TxExecution.cs
index 9004bb98698..e0a8b72c061 100644
--- a/Libplanet/Blockchain/BlockChain.TxExecution.cs
+++ b/Libplanet/Blockchain/BlockChain.TxExecution.cs
@@ -1,13 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
 using Libplanet.Action;
 using Libplanet.Action.State;
 using Libplanet.Store.Trie;
-using Libplanet.Types.Assets;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
 
@@ -26,11 +24,6 @@ internal IEnumerable<TxExecution> MakeTxExecutions(
             IReadOnlyList<IActionEvaluation> evaluations
         )
         {
-            IEnumerable<IGrouping<TxId, IActionEvaluation>> evaluationsPerTxs = evaluations
-                .Where(e => e.InputContext.TxId is { })
-                .GroupBy(e => e.InputContext.TxId!.Value);
-            int count = 0;
-
             List<(TxId?, List<IActionEvaluation>)> groupedEvals =
                 new List<(TxId?, List<IActionEvaluation>)>();
             foreach (IActionEvaluation eval in evaluations)
@@ -56,11 +49,11 @@ IReadOnlyList<IActionEvaluation> evaluations
 
             ITrie trie = GetAccountState(block.PreviousHash).Trie;
 
+            int count = 0;
             foreach (var group in groupedEvals)
             {
                 if (group.Item1 is { } txId)
                 {
-                    // make tx execution
                     ITrie nextTrie = trie;
                     foreach (var eval in group.Item2)
                     {
@@ -76,25 +69,30 @@ IReadOnlyList<IActionEvaluation> evaluations
                         .Select(eval => eval.Exception)
                         .ToList();
 
-                    yield return exceptions.Any(exception => exception is { })
-                        ? new TxFailure(
+                    if (exceptions.Any(exception => exception is { }))
+                    {
+                        yield return new TxFailure(
                             block.Hash,
                             txId,
                             trie.Hash,
                             nextTrie.Hash,
-                            exceptions)
-                        : new TxSuccess(
+                            exceptions);
+                    }
+                    else
+                    {
+                        yield return new TxSuccess(
                             block.Hash,
                             txId,
                             trie.Hash,
                             nextTrie.Hash,
                             exceptions);
+                    }
+
                     count++;
                     trie = nextTrie;
                 }
                 else
                 {
-                    // move forward
                     ITrie nextTrie = trie;
                     foreach (var eval in group.Item2)
                     {

From 83df0c7c4539b0a67b7a25e17dba170a9dc926b7 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 17:47:25 +0900
Subject: [PATCH 24/72] Combine TxSuccess and TxFailure

---
 Libplanet.Types/Tx/TxExecution.cs | 150 ++++++++++++++++++++++++++++--
 Libplanet.Types/Tx/TxFailure.cs   |  67 -------------
 Libplanet.Types/Tx/TxSuccess.cs   |  66 -------------
 3 files changed, 144 insertions(+), 139 deletions(-)
 delete mode 100644 Libplanet.Types/Tx/TxFailure.cs
 delete mode 100644 Libplanet.Types/Tx/TxSuccess.cs

diff --git a/Libplanet.Types/Tx/TxExecution.cs b/Libplanet.Types/Tx/TxExecution.cs
index c534c63b307..4fb13998c70 100644
--- a/Libplanet.Types/Tx/TxExecution.cs
+++ b/Libplanet.Types/Tx/TxExecution.cs
@@ -1,5 +1,10 @@
+using System;
+using System.Collections.Generic;
 using System.Diagnostics.Contracts;
-using Bencodex;
+using System.Linq;
+using System.Security.Cryptography;
+using Bencodex.Types;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 
 namespace Libplanet.Types.Tx
@@ -10,16 +15,116 @@ namespace Libplanet.Types.Tx
     /// a <see cref="Block"/>, and even if it's the same <see cref="Transaction"/> its
     /// result can vary depending on <see cref="Block"/> that it is executed within.</para>
     /// </summary>
-    /// <seealso cref="TxSuccess"/>
-    /// <seealso cref="TxFailure"/>
-    public abstract class TxExecution
+    public sealed class TxExecution
     {
-        protected static readonly Codec _codec = new Codec();
+        internal static readonly Text FailKey = new Text("fail");
 
-        private protected TxExecution(BlockHash blockHash, TxId txId)
+        internal static readonly Text InputStateKey = new Text("i");
+
+        internal static readonly Text OutputStateKey = new Text("o");
+
+        internal static readonly Text ExceptionNamesKey = new Text("e");
+
+        public TxExecution(
+            BlockHash blockHash,
+            TxId txId,
+            bool fail,
+            HashDigest<SHA256> inputState,
+            HashDigest<SHA256> outputState,
+            List<Exception?> exceptions)
+            : this(
+                blockHash,
+                txId,
+                fail,
+                inputState,
+                outputState,
+                exceptions
+                    .Select(exception => exception is { } e
+                        ? e.GetType().FullName
+                        : string.Empty)
+                    .ToList())
+        {
+        }
+
+        public TxExecution(
+            BlockHash blockHash,
+            TxId txId,
+            bool fail,
+            HashDigest<SHA256> inputState,
+            HashDigest<SHA256> outputState,
+            List<string> exceptionNames)
         {
             BlockHash = blockHash;
             TxId = txId;
+            Fail = fail;
+            InputState = inputState;
+            OutputState = outputState;
+            ExceptionNames = exceptionNames;
+        }
+
+#pragma warning disable SA1118 // The parameter spans multiple lines.
+        public TxExecution(
+            BlockHash blockHash,
+            TxId txId,
+            IValue encoded)
+            : this(
+                blockHash,
+                txId,
+                encoded is Dictionary dict
+                    ? dict
+                    : throw new ArgumentException())
+#pragma warning restore SA1118
+        {
+        }
+
+        private TxExecution(
+            BlockHash blockHash,
+            TxId txId,
+            Dictionary encoded)
+        {
+            BlockHash = blockHash;
+            TxId = txId;
+
+            if (!encoded.TryGetValue(FailKey, out IValue fail) ||
+                !(fail is Bencodex.Types.Boolean failBoolean) ||
+                (failBoolean.Value == false))
+            {
+                throw new ArgumentException($"Invalid fail key value: {fail}");
+            }
+
+            if (encoded.TryGetValue(InputStateKey, out IValue input) &&
+                input is Binary inputBinary)
+            {
+                InputState = HashDigest<SHA256>.DeriveFrom(inputBinary.ByteArray);
+            }
+            else
+            {
+                InputState = null;
+            }
+
+            if (encoded.TryGetValue(OutputStateKey, out IValue output) &&
+                input is Binary outputBinary)
+            {
+                InputState = HashDigest<SHA256>.DeriveFrom(outputBinary.ByteArray);
+            }
+            else
+            {
+                OutputState = null;
+            }
+
+            if (encoded.TryGetValue(ExceptionNamesKey, out IValue exceptions) &&
+                exceptions is List exceptionsList)
+            {
+                ExceptionNames = exceptionsList
+                    .Select(value => value is Text t
+                        ? t.Value
+                        : throw new ArgumentException())
+                    .ToList();
+            }
+            else
+            {
+                ExceptionNames = null;
+            }
         }
 
         /// <summary>
@@ -34,5 +139,38 @@ private protected TxExecution(BlockHash blockHash, TxId txId)
         /// </summary>
         [Pure]
         public TxId TxId { get; }
+
+        public bool Fail { get; }
+
+        public HashDigest<SHA256>? InputState { get; }
+
+        public HashDigest<SHA256>? OutputState { get; }
+
+        public List<string>? ExceptionNames { get; }
+
+        public IValue ToBencodex()
+        {
+            Dictionary dict = Dictionary.Empty
+                .Add(FailKey, Fail);
+
+            if (InputState is { } inputState)
+            {
+                dict = dict.Add(InputStateKey, inputState.ByteArray);
+            }
+
+            if (OutputState is { } outputState)
+            {
+                dict = dict.Add(OutputStateKey, outputState.ByteArray);
+            }
+
+            if (ExceptionNames is { } exceptionNames)
+            {
+                dict = dict.Add(
+                    ExceptionNamesKey,
+                    new List(exceptionNames.Select(exceptionName => new Text(exceptionName))));
+            }
+
+            return dict;
+        }
     }
 }
diff --git a/Libplanet.Types/Tx/TxFailure.cs b/Libplanet.Types/Tx/TxFailure.cs
deleted file mode 100644
index 8427980b99a..00000000000
--- a/Libplanet.Types/Tx/TxFailure.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Security.Cryptography;
-using Libplanet.Common;
-using Libplanet.Types.Blocks;
-
-namespace Libplanet.Types.Tx
-{
-    /// <summary>
-    /// Summarizes an execution result of a <see cref="Transaction"/> with any exception-throwing
-    /// actions.
-    /// </summary>
-    public sealed class TxFailure : TxExecution
-    {
-        /// <summary>
-        /// Creates a <see cref="TxFailure"/> instance.
-        /// </summary>
-        /// <param name="blockHash">The <see cref="Block.Hash"/> of the <see cref="Block"/>
-        /// that the <see cref="Transaction"/> is executed within.</param>
-        /// <param name="txId">The executed <see cref="Transaction"/>'s <see
-        /// cref="Transaction.Id"/>.</param>
-        /// <param name="inputState">The state root hash of the state before the
-        /// execution of a <see cref="Transaction"/>.</param>
-        /// <param name="outputState">The state root hash of the state after the
-        /// execution of a <see cref="Transaction"/>.</param>
-        /// <param name="exceptionNames">The list of excetions thrown while
-        /// executing the actions.</param>
-        public TxFailure(
-            BlockHash blockHash,
-            TxId txId,
-            HashDigest<SHA256> inputState,
-            HashDigest<SHA256> outputState,
-            List<string> exceptionNames)
-            : base(blockHash, txId)
-        {
-            InputState = inputState;
-            OutputState = outputState;
-            ExceptionNames = exceptionNames;
-        }
-
-        public TxFailure(
-            BlockHash blockHash,
-            TxId txId,
-            HashDigest<SHA256> inputState,
-            HashDigest<SHA256> outputState,
-            List<Exception?> exceptions)
-            : this(
-                blockHash,
-                txId,
-                inputState,
-                outputState,
-                exceptions
-                    .Select(exception => exception is { } e
-                        ? e.GetType().FullName
-                        : string.Empty)
-                    .ToList())
-        {
-        }
-
-        public HashDigest<SHA256> InputState { get; }
-
-        public HashDigest<SHA256> OutputState { get; }
-
-        public List<string> ExceptionNames { get; }
-    }
-}
diff --git a/Libplanet.Types/Tx/TxSuccess.cs b/Libplanet.Types/Tx/TxSuccess.cs
deleted file mode 100644
index a41e6fc034b..00000000000
--- a/Libplanet.Types/Tx/TxSuccess.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Security.Cryptography;
-using Libplanet.Common;
-using Libplanet.Types.Blocks;
-
-namespace Libplanet.Types.Tx
-{
-    /// <summary>
-    /// Summarizes an execution result of a successful <see cref="Transaction"/>.
-    /// </summary>
-    public sealed class TxSuccess : TxExecution
-    {
-        /// <summary>
-        /// Creates a <see cref="TxSuccess"/> instance.
-        /// </summary>
-        /// <param name="blockHash">The <see cref="Block.Hash"/> of the <see cref="Block"/>
-        /// that the <see cref="Transaction"/> is executed within.</param>
-        /// <param name="txId">The executed <see cref="Transaction"/>'s <see
-        /// cref="Transaction.Id"/>.</param>
-        /// <param name="inputState">The state root hash of the state before the
-        /// execution of a <see cref="Transaction"/>.</param>
-        /// <param name="outputState">The state root hash of the state after the
-        /// execution of a <see cref="Transaction"/>.</param>
-        /// <param name="exceptionNames">The list of excetions thrown while
-        /// executing the actions.</param>
-        public TxSuccess(
-            BlockHash blockHash,
-            TxId txId,
-            HashDigest<SHA256> inputState,
-            HashDigest<SHA256> outputState,
-            List<string> exceptionNames)
-            : base(blockHash, txId)
-        {
-            InputState = inputState;
-            OutputState = outputState;
-            ExceptionNames = exceptionNames;
-        }
-
-        public TxSuccess(
-            BlockHash blockHash,
-            TxId txId,
-            HashDigest<SHA256> inputState,
-            HashDigest<SHA256> outputState,
-            List<Exception?> exceptions)
-            : this(
-                blockHash,
-                txId,
-                inputState,
-                outputState,
-                exceptions
-                    .Select(exception => exception is { } e
-                        ? e.GetType().FullName
-                        : string.Empty)
-                    .ToList())
-        {
-        }
-
-        public HashDigest<SHA256> InputState { get; }
-
-        public HashDigest<SHA256> OutputState { get; }
-
-        public List<string> ExceptionNames { get; }
-    }
-}

From b58f95efd2820c146eb4dce495afa657a52a059d Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 18:15:58 +0900
Subject: [PATCH 25/72] Update IStore interface and its implementations

---
 Libplanet.Explorer/Store/LiteDBRichStore.cs | 10 ++--
 Libplanet.Explorer/Store/MySQLRichStore.cs  | 10 ++--
 Libplanet.RocksDBStore/RocksDBStore.cs      | 15 ++----
 Libplanet.Store/BaseStore.cs                | 55 ++-------------------
 Libplanet.Store/DefaultStore.cs             | 19 ++-----
 Libplanet.Store/IStore.cs                   | 21 ++------
 Libplanet.Store/MemoryStore.cs              |  7 +--
 Libplanet.Tests/Store/ProxyStore.cs         | 10 ++--
 Libplanet.Tests/Store/StoreTracker.cs       | 12 ++---
 9 files changed, 29 insertions(+), 130 deletions(-)

diff --git a/Libplanet.Explorer/Store/LiteDBRichStore.cs b/Libplanet.Explorer/Store/LiteDBRichStore.cs
index 9e666f7e795..f2001263837 100644
--- a/Libplanet.Explorer/Store/LiteDBRichStore.cs
+++ b/Libplanet.Explorer/Store/LiteDBRichStore.cs
@@ -90,13 +90,9 @@ public LiteDBRichStore(
             return _store.GetBlockIndex(blockHash);
         }
 
-        /// <inheritdoc cref="IStore.PutTxExecution(TxSuccess)"/>
-        public void PutTxExecution(TxSuccess txSuccess) =>
-            _store.PutTxExecution(txSuccess);
-
-        /// <inheritdoc cref="IStore.PutTxExecution(TxFailure)"/>
-        public void PutTxExecution(TxFailure txFailure) =>
-            _store.PutTxExecution(txFailure);
+        /// <inheritdoc cref="IStore.PutTxExecution"/>
+        public void PutTxExecution(TxExecution txExecution) =>
+            _store.PutTxExecution(txExecution);
 
         /// <inheritdoc cref="IStore.GetTxExecution(BlockHash, TxId)"/>
         public TxExecution GetTxExecution(BlockHash blockHash, TxId txid) =>
diff --git a/Libplanet.Explorer/Store/MySQLRichStore.cs b/Libplanet.Explorer/Store/MySQLRichStore.cs
index a78d4c3eb87..e51cdf18555 100644
--- a/Libplanet.Explorer/Store/MySQLRichStore.cs
+++ b/Libplanet.Explorer/Store/MySQLRichStore.cs
@@ -53,13 +53,9 @@ public MySQLRichStore(IStore store, MySQLRichStoreOptions options)
         public long? GetBlockIndex(BlockHash blockHash) =>
             _store.GetBlockIndex(blockHash);
 
-        /// <inheritdoc cref="IStore.PutTxExecution(TxSuccess)"/>
-        public void PutTxExecution(TxSuccess txSuccess) =>
-            _store.PutTxExecution(txSuccess);
-
-        /// <inheritdoc cref="IStore.PutTxExecution(TxFailure)"/>
-        public void PutTxExecution(TxFailure txFailure) =>
-            _store.PutTxExecution(txFailure);
+        /// <inheritdoc cref="IStore.PutTxExecution"/>
+        public void PutTxExecution(TxExecution txExecution) =>
+            _store.PutTxExecution(txExecution);
 
         /// <inheritdoc cref="IStore.GetTxExecution(BlockHash, TxId)"/>
         public TxExecution GetTxExecution(BlockHash blockHash, TxId txid) =>
diff --git a/Libplanet.RocksDBStore/RocksDBStore.cs b/Libplanet.RocksDBStore/RocksDBStore.cs
index 533c15cee99..484fbade7dd 100644
--- a/Libplanet.RocksDBStore/RocksDBStore.cs
+++ b/Libplanet.RocksDBStore/RocksDBStore.cs
@@ -986,18 +986,11 @@ public override IEnumerable<BlockHash> IterateTxIdBlockHashIndex(TxId txId)
             }
         }
 
-        /// <inheritdoc cref="BaseStore.PutTxExecution(TxSuccess)"/>
-        public override void PutTxExecution(TxSuccess txSuccess) =>
+        /// <inheritdoc cref="BaseStore.PutTxExecution"/>
+        public override void PutTxExecution(TxExecution txExecution) =>
             _txExecutionDb.Put(
-                TxExecutionKey(txSuccess),
-                Codec.Encode(SerializeTxExecution(txSuccess))
-            );
-
-        /// <inheritdoc cref="BaseStore.PutTxExecution(TxFailure)"/>
-        public override void PutTxExecution(TxFailure txFailure) =>
-            _txExecutionDb.Put(
-                TxExecutionKey(txFailure),
-                Codec.Encode(SerializeTxExecution(txFailure))
+                TxExecutionKey(txExecution),
+                Codec.Encode(SerializeTxExecution(txExecution))
             );
 
         /// <inheritdoc cref="BaseStore.GetTxExecution(BlockHash, TxId)"/>
diff --git a/Libplanet.Store/BaseStore.cs b/Libplanet.Store/BaseStore.cs
index d6ac2b1873e..6faca3dca3e 100644
--- a/Libplanet.Store/BaseStore.cs
+++ b/Libplanet.Store/BaseStore.cs
@@ -99,10 +99,7 @@ public Block GetBlock(BlockHash blockHash)
         public abstract bool ContainsBlock(BlockHash blockHash);
 
         /// <inheritdoc/>
-        public abstract void PutTxExecution(TxSuccess txSuccess);
-
-        /// <inheritdoc/>
-        public abstract void PutTxExecution(TxFailure txFailure);
+        public abstract void PutTxExecution(TxExecution txExecution);
 
         /// <inheritdoc/>
         public abstract TxExecution GetTxExecution(BlockHash blockHash, TxId txid);
@@ -178,32 +175,9 @@ public virtual long CountBlocks()
         /// <inheritdoc/>
         public abstract IEnumerable<BlockHash> GetBlockCommitHashes();
 
-        protected static IValue SerializeTxExecution(TxSuccess txSuccess)
-        {
-            var sDelta = new Dictionary(
-                txSuccess.UpdatedStates.Select(kv =>
-                    new KeyValuePair<IKey, IValue>(
-                        new Binary(kv.Key.ByteArray),
-                        kv.Value is { } v ? List.Empty.Add(v) : List.Empty
-                    )
-                )
-            );
-            var updatedFAVs = SerializeGroupedFAVs(txSuccess.UpdatedFungibleAssets);
-            var serialized = Dictionary.Empty
-                .Add("fail", false)
-                .Add("sDelta", sDelta)
-                .Add("updatedFAVs", new Dictionary(updatedFAVs));
-
-            return serialized;
-        }
-
-        protected static IValue SerializeTxExecution(TxFailure txFailure)
+        protected static IValue SerializeTxExecution(TxExecution txExecution)
         {
-            Dictionary d = Dictionary.Empty
-                .Add("fail", true)
-                .Add("exc", txFailure.ExceptionName);
-
-            return d;
+            return txExecution.ToBencodex();
         }
 
         protected static TxExecution DeserializeTxExecution(
@@ -223,28 +197,7 @@ ILogger logger
 
             try
             {
-                bool fail = d.GetValue<Bencodex.Types.Boolean>("fail");
-
-                if (fail)
-                {
-                    string excName = d.GetValue<Text>("exc");
-                    return new TxFailure(blockHash, txid, excName);
-                }
-
-                ImmutableDictionary<Address, IValue> sDelta = d.GetValue<Dictionary>("sDelta")
-                    .ToImmutableDictionary(
-                        kv => new Address((IValue)kv.Key),
-                        kv => kv.Value is List l && l.Any() ? l[0] : null
-                    );
-                IImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>
-                    updatedFAVs = DeserializeGroupedFAVs(d.GetValue<Dictionary>("updatedFAVs"));
-
-                return new TxSuccess(
-                    blockHash,
-                    txid,
-                    sDelta,
-                    updatedFAVs
-                );
+                return new TxExecution(blockHash, txid, d);
             }
             catch (Exception e)
             {
diff --git a/Libplanet.Store/DefaultStore.cs b/Libplanet.Store/DefaultStore.cs
index f7b8c37846b..8a83a5002af 100644
--- a/Libplanet.Store/DefaultStore.cs
+++ b/Libplanet.Store/DefaultStore.cs
@@ -489,26 +489,15 @@ public override bool ContainsBlock(BlockHash blockHash)
             return _blocks.FileExists(blockPath);
         }
 
-        /// <inheritdoc cref="BaseStore.PutTxExecution(TxSuccess)"/>
-        public override void PutTxExecution(TxSuccess txSuccess)
+        /// <inheritdoc cref="BaseStore.PutTxExecution"/>
+        public override void PutTxExecution(TxExecution txExecution)
         {
-            UPath path = TxExecutionPath(txSuccess);
+            UPath path = TxExecutionPath(txExecution);
             UPath dirPath = path.GetDirectory();
             CreateDirectoryRecursively(_txExecutions, dirPath);
             using Stream f =
                 _txExecutions.OpenFile(path, System.IO.FileMode.Create, FileAccess.Write);
-            Codec.Encode(SerializeTxExecution(txSuccess), f);
-        }
-
-        /// <inheritdoc cref="BaseStore.PutTxExecution(TxFailure)"/>
-        public override void PutTxExecution(TxFailure txFailure)
-        {
-            UPath path = TxExecutionPath(txFailure);
-            UPath dirPath = path.GetDirectory();
-            CreateDirectoryRecursively(_txExecutions, dirPath);
-            using Stream f =
-                _txExecutions.OpenFile(path, System.IO.FileMode.Create, FileAccess.Write);
-            Codec.Encode(SerializeTxExecution(txFailure), f);
+            Codec.Encode(SerializeTxExecution(txExecution), f);
         }
 
         /// <inheritdoc cref="BaseStore.GetTxExecution(BlockHash, TxId)"/>
diff --git a/Libplanet.Store/IStore.cs b/Libplanet.Store/IStore.cs
index d84e802ca7f..a2d39af0f22 100644
--- a/Libplanet.Store/IStore.cs
+++ b/Libplanet.Store/IStore.cs
@@ -166,26 +166,12 @@ public interface IStore : IDisposable
         /// </summary>
         /// <remarks>If there is already the record for the same <see cref="TxExecution.BlockHash"/>
         /// and <see cref="TxExecution.TxId"/>, the record is silently overwritten.</remarks>
-        /// <param name="txSuccess">The successful transaction execution summary to record.
+        /// <param name="txExecution">The transaction execution summary to record.
         /// Must not be <see langword="null"/>.</param>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="txSuccess"/> is
         /// <see langword="null"/>.</exception>
-        /// <seealso cref="PutTxExecution(TxFailure)"/>
         /// <seealso cref="GetTxExecution(BlockHash, TxId)"/>
-        void PutTxExecution(TxSuccess txSuccess);
-
-        /// <summary>
-        /// Records the given <paramref name="txFailure"/>.
-        /// </summary>
-        /// <remarks>If there is already the record for the same <see cref="TxExecution.BlockHash"/>
-        /// and <see cref="TxExecution.TxId"/>, the record is silently overwritten.</remarks>
-        /// <param name="txFailure">The failed transaction execution summary to record.
-        /// Must not be <see langword="null"/>.</param>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="txFailure"/> is
-        /// <see langword="null"/>.</exception>
-        /// <seealso cref="PutTxExecution(TxSuccess)"/>
-        /// <seealso cref="GetTxExecution(BlockHash, TxId)"/>
-        void PutTxExecution(TxFailure txFailure);
+        void PutTxExecution(TxExecution txExecution);
 
         /// <summary>
         /// Retrieves the recorded transaction execution summary.
@@ -196,8 +182,7 @@ public interface IStore : IDisposable
         /// execution to retrieve.</param>
         /// <returns>The recorded transaction execution summary.  If it has been never recorded
         /// <see langword="null"/> is returned instead.</returns>
-        /// <seealso cref="PutTxExecution(TxFailure)"/>
-        /// <seealso cref="PutTxExecution(TxSuccess)"/>
+        /// <seealso cref="PutTxExecution"/>
         TxExecution GetTxExecution(BlockHash blockHash, TxId txid);
 
         /// <summary>
diff --git a/Libplanet.Store/MemoryStore.cs b/Libplanet.Store/MemoryStore.cs
index 091747b3977..755f5c4733b 100644
--- a/Libplanet.Store/MemoryStore.cs
+++ b/Libplanet.Store/MemoryStore.cs
@@ -186,11 +186,8 @@ bool IStore.DeleteBlock(BlockHash blockHash) =>
         bool IStore.ContainsBlock(BlockHash blockHash) =>
             _blocks.ContainsKey(blockHash);
 
-        void IStore.PutTxExecution(TxSuccess txSuccess) =>
-            _txExecutions[(txSuccess.BlockHash, txSuccess.TxId)] = txSuccess;
-
-        void IStore.PutTxExecution(TxFailure txFailure) =>
-            _txExecutions[(txFailure.BlockHash, txFailure.TxId)] = txFailure;
+        void IStore.PutTxExecution(TxExecution txExecution) =>
+            _txExecutions[(txExecution.BlockHash, txExecution.TxId)] = txExecution;
 
         TxExecution IStore.GetTxExecution(BlockHash blockHash, TxId txid) =>
             _txExecutions.TryGetValue((blockHash, txid), out TxExecution e) ? e : null;
diff --git a/Libplanet.Tests/Store/ProxyStore.cs b/Libplanet.Tests/Store/ProxyStore.cs
index 6325b207b02..dde51f23d54 100644
--- a/Libplanet.Tests/Store/ProxyStore.cs
+++ b/Libplanet.Tests/Store/ProxyStore.cs
@@ -114,13 +114,9 @@ public virtual bool DeleteBlock(BlockHash blockHash) =>
         public virtual bool ContainsBlock(BlockHash blockHash) =>
             Store.ContainsBlock(blockHash);
 
-        /// <inheritdoc cref="IStore.PutTxExecution(TxSuccess)"/>
-        public virtual void PutTxExecution(TxSuccess txSuccess) =>
-            Store.PutTxExecution(txSuccess);
-
-        /// <inheritdoc cref="IStore.PutTxExecution(TxFailure)"/>
-        public virtual void PutTxExecution(TxFailure txFailure) =>
-            Store.PutTxExecution(txFailure);
+        /// <inheritdoc cref="IStore.PutTxExecution"/>
+        public virtual void PutTxExecution(TxExecution txExecution) =>
+            Store.PutTxExecution(txExecution);
 
         /// <inheritdoc cref="IStore.GetTxExecution(BlockHash, TxId)"/>
         public virtual TxExecution GetTxExecution(BlockHash blockHash, TxId txid) =>
diff --git a/Libplanet.Tests/Store/StoreTracker.cs b/Libplanet.Tests/Store/StoreTracker.cs
index 241a801b8d5..c2faff600b1 100644
--- a/Libplanet.Tests/Store/StoreTracker.cs
+++ b/Libplanet.Tests/Store/StoreTracker.cs
@@ -47,16 +47,10 @@ public bool ContainsBlock(BlockHash blockHash)
             return _store.ContainsBlock(blockHash);
         }
 
-        public void PutTxExecution(TxSuccess txSuccess)
+        public void PutTxExecution(TxExecution txExecution)
         {
-            Log(nameof(PutTxExecution), txSuccess);
-            _store.PutTxExecution(txSuccess);
-        }
-
-        public void PutTxExecution(TxFailure txFailure)
-        {
-            Log(nameof(PutTxExecution), txFailure);
-            _store.PutTxExecution(txFailure);
+            Log(nameof(PutTxExecution), txExecution);
+            _store.PutTxExecution(txExecution);
         }
 
         public TxExecution GetTxExecution(BlockHash blockHash, TxId txid)

From e3439ca82aafb7845a1055a1f621b527fd6426e0 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 18:26:54 +0900
Subject: [PATCH 26/72] Update TxExecution creation from BlockChain

---
 .../Blockchain/BlockChain.TxExecution.cs      | 68 ++++---------------
 1 file changed, 13 insertions(+), 55 deletions(-)

diff --git a/Libplanet/Blockchain/BlockChain.TxExecution.cs b/Libplanet/Blockchain/BlockChain.TxExecution.cs
index e0a8b72c061..34eda701b2b 100644
--- a/Libplanet/Blockchain/BlockChain.TxExecution.cs
+++ b/Libplanet/Blockchain/BlockChain.TxExecution.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
 using System.Linq;
 using Libplanet.Action;
 using Libplanet.Action.State;
@@ -69,24 +67,13 @@ IReadOnlyList<IActionEvaluation> evaluations
                         .Select(eval => eval.Exception)
                         .ToList();
 
-                    if (exceptions.Any(exception => exception is { }))
-                    {
-                        yield return new TxFailure(
-                            block.Hash,
-                            txId,
-                            trie.Hash,
-                            nextTrie.Hash,
-                            exceptions);
-                    }
-                    else
-                    {
-                        yield return new TxSuccess(
-                            block.Hash,
-                            txId,
-                            trie.Hash,
-                            nextTrie.Hash,
-                            exceptions);
-                    }
+                    yield return new TxExecution(
+                        block.Hash,
+                        txId,
+                        exceptions.Any(exception => exception is { }),
+                        trie.Hash,
+                        nextTrie.Hash,
+                        exceptions);
 
                     count++;
                     trie = nextTrie;
@@ -120,42 +107,13 @@ internal void UpdateTxExecutions(IEnumerable<TxExecution> txExecutions)
             int count = 0;
             foreach (TxExecution txExecution in txExecutions)
             {
-                // Note that there are two overloaded methods of the same name PutTxExecution()
-                // in IStore.  As those two have different signatures, run-time polymorphism
-                // does not work.  Instead, we need the following hard-coded branch:
-                switch (txExecution)
-                {
-                    case TxSuccess s:
-                        Store.PutTxExecution(s);  // IStore.PutTxExecution(TxSuccess)
-                        _logger.Verbose(
-                            "Updated " + nameof(TxSuccess) +
-                            " for tx {TxId} within block {BlockHash}",
-                            s.TxId,
-                            s.BlockHash
-                        );
-                        break;
-                    case TxFailure f:
-                        Store.PutTxExecution(f);  // IStore.PutTxExecution(TxFailure)
-                        _logger.Verbose(
-                            "Updated " + nameof(TxFailure) +
-                            " for tx {TxId} within block {BlockHash}",
-                            f.TxId,
-                            f.BlockHash
-                        );
-                        break;
-                    default:
-                        // In theory, this case must not happen.  The following case is for just in
-                        // case.  (For example, we might add a new subtype for TxExecution.)
-                        const string msg = "Unexpected subtype of " + nameof(TxExecution) + ": {0}";
-                        _logger.Fatal(msg, txExecution);
-                        Trace.Assert(
-                            false,
-                            string.Format(CultureInfo.InvariantCulture, msg, txExecution)
-                        );
-                        break;
-                }
-
+                Store.PutTxExecution(txExecution);
                 count++;
+
+                _logger.Verbose(
+                    "Updated " + nameof(TxExecution) + " for tx {TxId} within block {BlockHash}",
+                    txExecution.TxId,
+                    txExecution.BlockHash);
             }
 
             _logger.Verbose(

From c44e0f066cb8d31acb5bab2b3c6558b67abd796b Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 18:29:21 +0900
Subject: [PATCH 27/72] Updated TransactionQuery for TxResult

---
 .../Queries/TransactionQuery.cs               | 31 +++++--------------
 1 file changed, 7 insertions(+), 24 deletions(-)

diff --git a/Libplanet.Explorer/Queries/TransactionQuery.cs b/Libplanet.Explorer/Queries/TransactionQuery.cs
index 88342431640..fa7f2f4b990 100644
--- a/Libplanet.Explorer/Queries/TransactionQuery.cs
+++ b/Libplanet.Explorer/Queries/TransactionQuery.cs
@@ -268,30 +268,13 @@ index is null
                         );
                         var txExecutedBlock = blockChain[txExecutedBlockHashValue];
 
-                        return execution switch
-                        {
-                            TxSuccess txSuccess => new TxResult(
-                                TxStatus.SUCCESS,
-                                txExecutedBlock.Index,
-                                txExecutedBlock.Hash.ToString(),
-                                null,
-                                txSuccess.UpdatedStates,
-                                txSuccess.UpdatedFungibleAssets
-                            ),
-                            TxFailure txFailure => new TxResult(
-                                TxStatus.FAILURE,
-                                txExecutedBlock.Index,
-                                txExecutedBlock.Hash.ToString(),
-                                txFailure.ExceptionName,
-                                null,
-                                null
-                            ),
-                            _ => throw new NotSupportedException(
-                                #pragma warning disable format
-                                $"{nameof(execution)} is not expected concrete class."
-                                #pragma warning restore format
-                            ),
-                        };
+                        return new TxResult(
+                            execution.Fail ? TxStatus.FAILURE : TxStatus.SUCCESS,
+                            txExecutedBlock.Index,
+                            txExecutedBlock.Hash.ToString(),
+                            null,
+                            null,
+                            null);
                     }
                     catch (Exception)
                     {

From e09838f6d3274416eb16b343d748594c509688fd Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 20 Sep 2023 21:00:25 +0900
Subject: [PATCH 28/72] Fix tests

---
 .../Blockchain/BlockChainTest.Append.cs       | 108 +++++++------
 .../Blockchain/BlockChainTest.Internals.cs    |  68 ++++-----
 .../Blockchain/BlockChainTest.ProposeBlock.cs |   2 +-
 Libplanet.Tests/Store/StoreTest.cs            |  74 ++++-----
 Libplanet.Tests/Tx/TxExecutionTest.cs         | 144 ++++++++++++++++++
 Libplanet.Tests/Tx/TxFailureTest.cs           |  54 -------
 Libplanet.Tests/Tx/TxSuccessTest.cs           |  73 ---------
 Libplanet.Types/Tx/TxExecution.cs             |  13 +-
 .../Blockchain/BlockChain.TxExecution.cs      |   5 +-
 9 files changed, 265 insertions(+), 276 deletions(-)
 create mode 100644 Libplanet.Tests/Tx/TxExecutionTest.cs
 delete mode 100644 Libplanet.Tests/Tx/TxFailureTest.cs
 delete mode 100644 Libplanet.Tests/Tx/TxSuccessTest.cs

diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
index c157f939948..f9aa4c2a87c 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
@@ -6,6 +6,7 @@
 using Bencodex.Types;
 using Libplanet.Action;
 using Libplanet.Action.Loader;
+using Libplanet.Action.State;
 using Libplanet.Action.Tests.Common;
 using Libplanet.Blockchain;
 using Libplanet.Blockchain.Policies;
@@ -15,7 +16,6 @@
 using Libplanet.Store;
 using Libplanet.Store.Trie;
 using Libplanet.Tests.Store;
-using Libplanet.Types.Assets;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
 using Xunit;
@@ -157,11 +157,15 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
                 Assert.Null(getTxExecution(block1.Hash, tx.Id));
 
                 TxExecution e = getTxExecution(block2.Hash, tx.Id);
-                Assert.IsType<TxSuccess>(e);
-                var s = (TxSuccess)e;
-                Assert.Equal(block2.Hash, s.BlockHash);
-                Assert.Equal(tx.Id, s.TxId);
-                Assert.Empty(s.UpdatedFungibleAssets);
+                Assert.False(e.Fail);
+                Assert.Equal(block2.Hash, e.BlockHash);
+                Assert.Equal(tx.Id, e.TxId);
+                var inputAccount =
+                    _blockChain.GetAccountState(Assert.IsType<HashDigest<SHA256>>(e.InputState));
+                var outputAccount =
+                    _blockChain.GetAccountState(Assert.IsType<HashDigest<SHA256>>(e.OutputState));
+                var accountDiff = AccountDiff.Create(inputAccount, outputAccount);
+                Assert.Empty(accountDiff.FungibleAssetValueDiffs);
             }
 
             var pk = new PrivateKey();
@@ -199,65 +203,57 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
             _blockChain.Append(block3, TestUtils.CreateBlockCommit(block3));
             var txExecution1 = getTxExecution(block3.Hash, tx1Transfer.Id);
             _logger.Verbose(nameof(txExecution1) + " = {@TxExecution}", txExecution1);
-            Assert.IsType<TxSuccess>(txExecution1);
-            var txSuccess1 = (TxSuccess)txExecution1;
+            Assert.False(txExecution1.Fail);
+            var inputAccount1 = _blockChain.GetAccountState(
+                Assert.IsType<HashDigest<SHA256>>(txExecution1.InputState));
+            var outputAccount1 = _blockChain.GetAccountState(
+                Assert.IsType<HashDigest<SHA256>>(txExecution1.OutputState));
+            var accountDiff1 = AccountDiff.Create(inputAccount1, outputAccount1);
+
             Assert.Equal(
-                addresses.Take(3).Append(pk.ToAddress()).ToImmutableHashSet(),
-                txSuccess1.UpdatedAddresses
-            );
+                (new Address[] { addresses[0], pk.ToAddress() }).ToImmutableHashSet(),
+                accountDiff1.StateDiffs.Select(kv => kv.Key).ToImmutableHashSet());
             Assert.Equal(
-                ImmutableDictionary<Address, IValue>.Empty
-                    .Add(pk.ToAddress(), (Text)"foo")
-                    .Add(addresses[0], (Text)"foo,bar"),
-                txSuccess1.UpdatedStates
-            );
+                (new Address[] { addresses[1], addresses[2], pk.ToAddress() })
+                    .ToImmutableHashSet(),
+                accountDiff1.FungibleAssetValueDiffs.Select(kv => kv.Key.Item1)
+                    .ToImmutableHashSet());
             Assert.Equal(
-                ImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>.Empty
-                    .Add(
-                        pk.ToAddress(),
-                        ImmutableDictionary<Currency, FAV>.Empty
-                            .Add(DumbAction.DumbCurrency, DumbAction.DumbCurrency * -30)
-                    )
-                    .Add(
-                        addresses[1],
-                        ImmutableDictionary<Currency, FAV>.Empty
-                            .Add(DumbAction.DumbCurrency, DumbAction.DumbCurrency * 10)
-                    )
-                    .Add(
-                        addresses[2],
-                        ImmutableDictionary<Currency, FAV>.Empty
-                            .Add(DumbAction.DumbCurrency, DumbAction.DumbCurrency * 20)
-                    ),
-                txSuccess1.UpdatedFungibleAssets
-            );
+                new Text("foo"),
+                outputAccount1.GetState(pk.ToAddress()));
+            Assert.Equal(
+                new Text("foo,bar"),
+                outputAccount1.GetState(addresses[0]));
+            Assert.Equal(
+                DumbAction.DumbCurrency * -30,
+                outputAccount1.GetBalance(pk.ToAddress(), DumbAction.DumbCurrency));
+            Assert.Equal(
+                DumbAction.DumbCurrency * 10,
+                outputAccount1.GetBalance(addresses[1], DumbAction.DumbCurrency));
+            Assert.Equal(
+                DumbAction.DumbCurrency * 20,
+                outputAccount1.GetBalance(addresses[2], DumbAction.DumbCurrency));
+
             var txExecution2 = getTxExecution(block3.Hash, tx2Error.Id);
             _logger.Verbose(nameof(txExecution2) + " = {@TxExecution}", txExecution2);
-            Assert.IsType<TxFailure>(txExecution2);
-            var txFailure = (TxFailure)txExecution2;
-            Assert.Equal(block3.Hash, txFailure.BlockHash);
-            Assert.Equal(tx2Error.Id, txFailure.TxId);
-            Assert.Equal(
+            Assert.True(txExecution2.Fail);
+            Assert.Equal(block3.Hash, txExecution2.BlockHash);
+            Assert.Equal(tx2Error.Id, txExecution2.TxId);
+            Assert.Contains(
                 $"{nameof(System)}.{nameof(ArgumentOutOfRangeException)}",
-                txFailure.ExceptionName
-            );
+                txExecution2.ExceptionNames);
+
             var txExecution3 = getTxExecution(block3.Hash, tx3Transfer.Id);
             _logger.Verbose(nameof(txExecution3) + " = {@TxExecution}", txExecution3);
-            Assert.IsType<TxSuccess>(txExecution3);
-            var txSuccess3 = (TxSuccess)txExecution3;
+            Assert.False(txExecution3.Fail);
+            var outputAccount3 = _blockChain.GetAccountState(
+                Assert.IsType<HashDigest<SHA256>>(txExecution3.OutputState));
             Assert.Equal(
-                ImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>.Empty
-                    .Add(
-                        pk.ToAddress(),
-                        ImmutableDictionary<Currency, FAV>.Empty
-                            .Add(DumbAction.DumbCurrency, DumbAction.DumbCurrency * -35)
-                    )
-                    .Add(
-                        addresses[1],
-                        ImmutableDictionary<Currency, FAV>.Empty
-                            .Add(DumbAction.DumbCurrency, DumbAction.DumbCurrency * 15)
-                    ),
-                txSuccess3.UpdatedFungibleAssets
-            );
+                DumbAction.DumbCurrency * -35,
+                outputAccount3.GetBalance(pk.ToAddress(), DumbAction.DumbCurrency));
+            Assert.Equal(
+                DumbAction.DumbCurrency * 15,
+                outputAccount3.GetBalance(addresses[1], DumbAction.DumbCurrency));
         }
 
         [SkippableFact]
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs
index edc36f6275a..0264b51de79 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs
@@ -2,18 +2,18 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Security.Cryptography;
 using Bencodex.Types;
 using Libplanet.Action;
 using Libplanet.Action.Tests.Common;
+using Libplanet.Common;
 using Libplanet.Crypto;
 using Libplanet.Store;
-using Libplanet.Types.Assets;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
 using Xunit;
 using static Libplanet.Action.State.KeyConverters;
 using static Libplanet.Tests.TestUtils;
-using FAV = Libplanet.Types.Assets.FungibleAssetValue;
 
 namespace Libplanet.Tests.Blockchain
 {
@@ -144,23 +144,14 @@ public void ExecuteActions()
         [InlineData(false)]
         public void UpdateTxExecutions(bool getTxExecutionViaStore)
         {
-            void AssertTxSuccessesEqual(TxSuccess expected, TxExecution actual)
+            void AssertTxExecutionEqual(TxExecution expected, TxExecution actual)
             {
-                Assert.IsType<TxSuccess>(actual);
-                var success = (TxSuccess)actual;
-                Assert.Equal(expected.TxId, success.TxId);
-                Assert.Equal(expected.BlockHash, success.BlockHash);
-                Assert.Equal(expected.UpdatedStates, success.UpdatedStates);
-                Assert.Equal(expected.UpdatedFungibleAssets, success.UpdatedFungibleAssets);
-            }
-
-            void AssertTxFailuresEqual(TxFailure expected, TxExecution actual)
-            {
-                Assert.IsType<TxFailure>(actual);
-                var failure = (TxFailure)actual;
-                Assert.Equal(expected.TxId, failure.TxId);
-                Assert.Equal(expected.BlockHash, failure.BlockHash);
-                Assert.Equal(expected.ExceptionName, failure.ExceptionName);
+                Assert.Equal(expected.Fail, actual.Fail);
+                Assert.Equal(expected.TxId, actual.TxId);
+                Assert.Equal(expected.BlockHash, actual.BlockHash);
+                Assert.Equal(expected.InputState, actual.InputState);
+                Assert.Equal(expected.OutputState, actual.OutputState);
+                Assert.Equal(expected.ExceptionNames, actual.ExceptionNames);
             }
 
             Func<BlockHash, TxId, TxExecution> getTxExecution
@@ -174,37 +165,32 @@ Func<BlockHash, TxId, TxExecution> getTxExecution
             Assert.Null(getTxExecution(_fx.Hash2, _fx.TxId2));
 
             var random = new System.Random();
-            var inputA = new TxSuccess(
+            var inputA = new TxExecution(
                 _fx.Hash1,
                 _fx.TxId1,
-                ImmutableDictionary<Address, IValue>.Empty.Add(
-                    random.NextAddress(),
-                    (Text)"state value"
-                ),
-                ImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>.Empty
-                    .Add(
-                        random.NextAddress(),
-                        ImmutableDictionary<Currency, FAV>.Empty.Add(
-                            DumbAction.DumbCurrency,
-                            DumbAction.DumbCurrency * 10
-                        )
-                    )
-            );
-            var inputB = new TxFailure(
+                false,
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new List<string>() { string.Empty });
+            var inputB = new TxExecution(
                 _fx.Hash1,
                 _fx.TxId2,
-                "AnExceptionName"
-            );
-            var inputC = new TxFailure(
+                true,
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new List<string>() { "AnExceptionName" });
+            var inputC = new TxExecution(
                 _fx.Hash2,
                 _fx.TxId1,
-                "AnotherExceptionName"
-            );
+                true,
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new List<string>() { "AnotherExceptionName", "YetAnotherExceptionName" });
             _blockChain.UpdateTxExecutions(new TxExecution[] { inputA, inputB, inputC });
 
-            AssertTxSuccessesEqual(inputA, getTxExecution(_fx.Hash1, _fx.TxId1));
-            AssertTxFailuresEqual(inputB, getTxExecution(_fx.Hash1, _fx.TxId2));
-            AssertTxFailuresEqual(inputC, getTxExecution(_fx.Hash2, _fx.TxId1));
+            AssertTxExecutionEqual(inputA, getTxExecution(_fx.Hash1, _fx.TxId1));
+            AssertTxExecutionEqual(inputB, getTxExecution(_fx.Hash1, _fx.TxId2));
+            AssertTxExecutionEqual(inputC, getTxExecution(_fx.Hash2, _fx.TxId1));
             Assert.Null(getTxExecution(_fx.Hash2, _fx.TxId2));
         }
     }
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.ProposeBlock.cs b/Libplanet.Tests/Blockchain/BlockChainTest.ProposeBlock.cs
index 2d7ac97d3be..4ebffe3706b 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.ProposeBlock.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.ProposeBlock.cs
@@ -314,7 +314,7 @@ public void ProposeBlockWithPendingTxs()
                     tx.Id,
                     txx
                 );
-                Assert.IsType<TxSuccess>(txx);
+                Assert.False(txx.Fail);
                 Assert.Equal(block.Hash, txx.BlockHash);
                 Assert.Equal(tx.Id, txx.TxId);
                 Assert.Null(_blockChain.GetTxExecution(_blockChain.Genesis.Hash, tx.Id));
diff --git a/Libplanet.Tests/Store/StoreTest.cs b/Libplanet.Tests/Store/StoreTest.cs
index 8c464c83c74..f343ff3ab57 100644
--- a/Libplanet.Tests/Store/StoreTest.cs
+++ b/Libplanet.Tests/Store/StoreTest.cs
@@ -11,9 +11,9 @@
 using Libplanet.Action.Tests.Common;
 using Libplanet.Blockchain;
 using Libplanet.Blockchain.Policies;
+using Libplanet.Common;
 using Libplanet.Crypto;
 using Libplanet.Store;
-using Libplanet.Types.Assets;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Consensus;
 using Libplanet.Types.Tx;
@@ -21,7 +21,6 @@
 using Xunit;
 using Xunit.Abstractions;
 using static Libplanet.Tests.TestUtils;
-using FAV = Libplanet.Types.Assets.FungibleAssetValue;
 
 namespace Libplanet.Tests.Store
 {
@@ -393,23 +392,14 @@ public void StoreBlock()
         [SkippableFact]
         public void TxExecution()
         {
-            void AssertTxSuccessesEqual(TxSuccess expected, TxExecution actual)
+            void AssertTxExecutionEqual(TxExecution expected, TxExecution actual)
             {
-                Assert.IsType<TxSuccess>(actual);
-                var success = (TxSuccess)actual;
-                Assert.Equal(expected.TxId, success.TxId);
-                Assert.Equal(expected.BlockHash, success.BlockHash);
-                Assert.Equal(expected.UpdatedStates, success.UpdatedStates);
-                Assert.Equal(expected.UpdatedFungibleAssets, success.UpdatedFungibleAssets);
-            }
-
-            void AssertTxFailuresEqual(TxFailure expected, TxExecution actual)
-            {
-                Assert.IsType<TxFailure>(actual);
-                var failure = (TxFailure)actual;
-                Assert.Equal(expected.TxId, failure.TxId);
-                Assert.Equal(expected.BlockHash, failure.BlockHash);
-                Assert.Equal(expected.ExceptionName, failure.ExceptionName);
+                Assert.Equal(expected.Fail, actual.Fail);
+                Assert.Equal(expected.TxId, actual.TxId);
+                Assert.Equal(expected.BlockHash, actual.BlockHash);
+                Assert.Equal(expected.InputState, actual.InputState);
+                Assert.Equal(expected.OutputState, actual.OutputState);
+                Assert.Equal(expected.ExceptionNames, actual.ExceptionNames);
             }
 
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId1));
@@ -417,52 +407,46 @@ void AssertTxFailuresEqual(TxFailure expected, TxExecution actual)
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash2, Fx.TxId1));
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash2, Fx.TxId2));
 
-            var random = new System.Random();
-            var inputA = new TxSuccess(
+            var inputA = new TxExecution(
                 Fx.Hash1,
                 Fx.TxId1,
-                ImmutableDictionary<Address, IValue>.Empty.Add(
-                    random.NextAddress(),
-                    (Text)"state value"
-                ),
-                ImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>.Empty
-                    .Add(
-                        random.NextAddress(),
-                        ImmutableDictionary<Currency, FAV>.Empty.Add(
-                            DumbAction.DumbCurrency,
-                            DumbAction.DumbCurrency * 10
-                        )
-                    )
-            );
+                false,
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new List<string>() { string.Empty });
             Fx.Store.PutTxExecution(inputA);
 
-            AssertTxSuccessesEqual(inputA, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId1));
+            AssertTxExecutionEqual(inputA, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId1));
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId2));
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash2, Fx.TxId1));
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash2, Fx.TxId2));
 
-            var inputB = new TxFailure(
+            var inputB = new TxExecution(
                 Fx.Hash1,
                 Fx.TxId2,
-                "AnExceptionName"
-            );
+                true,
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new List<string>() { "AnExceptionName" });
             Fx.Store.PutTxExecution(inputB);
 
-            AssertTxSuccessesEqual(inputA, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId1));
-            AssertTxFailuresEqual(inputB, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId2));
+            AssertTxExecutionEqual(inputA, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId1));
+            AssertTxExecutionEqual(inputB, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId2));
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash2, Fx.TxId1));
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash2, Fx.TxId2));
 
-            var inputC = new TxFailure(
+            var inputC = new TxExecution(
                 Fx.Hash2,
                 Fx.TxId1,
-                "AnotherExceptionName"
-            );
+                true,
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new HashDigest<SHA256>(TestUtils.GetRandomBytes(HashDigest<SHA256>.Size)),
+                new List<string>() { "AnotherExceptionName", "YetAnotherExceptionName" });
             Fx.Store.PutTxExecution(inputC);
 
-            AssertTxSuccessesEqual(inputA, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId1));
-            AssertTxFailuresEqual(inputB, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId2));
-            AssertTxFailuresEqual(inputC, Fx.Store.GetTxExecution(Fx.Hash2, Fx.TxId1));
+            AssertTxExecutionEqual(inputA, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId1));
+            AssertTxExecutionEqual(inputB, Fx.Store.GetTxExecution(Fx.Hash1, Fx.TxId2));
+            AssertTxExecutionEqual(inputC, Fx.Store.GetTxExecution(Fx.Hash2, Fx.TxId1));
             Assert.Null(Fx.Store.GetTxExecution(Fx.Hash2, Fx.TxId2));
         }
 
diff --git a/Libplanet.Tests/Tx/TxExecutionTest.cs b/Libplanet.Tests/Tx/TxExecutionTest.cs
new file mode 100644
index 00000000000..aa1c40841b8
--- /dev/null
+++ b/Libplanet.Tests/Tx/TxExecutionTest.cs
@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using Bencodex.Types;
+using Libplanet.Types.Assets;
+using Libplanet.Types.Tx;
+using Xunit;
+
+namespace Libplanet.Tests.Tx
+{
+    public class TxExecutionTest
+    {
+        [Theory]
+        [InlineData(false, "")]
+        [InlineData(true, "SomeException")]
+        public void Constructor(bool fail, string exceptionName)
+        {
+            var random = new Random();
+            var blockHash = random.NextBlockHash();
+            var txId = random.NextTxId();
+            var inputState = random.NextHashDigest<SHA256>();
+            var outputState = random.NextHashDigest<SHA256>();
+            var exceptionNames = new List<string>() { exceptionName };
+            var execution = new TxExecution(
+                blockHash,
+                txId,
+                fail,
+                inputState,
+                outputState,
+                exceptionNames);
+            Assert.Equal(blockHash, execution.BlockHash);
+            Assert.Equal(txId, execution.TxId);
+            Assert.Equal(fail, execution.Fail);
+            Assert.Equal(inputState, execution.InputState);
+            Assert.Equal(outputState, execution.OutputState);
+            Assert.Equal(exceptionNames, execution.ExceptionNames);
+        }
+
+        [Fact]
+        public void EncodeDecode()
+        {
+            var random = new Random();
+            var execution = new TxExecution(
+                random.NextBlockHash(),
+                random.NextTxId(),
+                true,
+                random.NextHashDigest<SHA256>(),
+                random.NextHashDigest<SHA256>(),
+                new List<string>() { string.Empty, "SomeException", "AnotherException" });
+            var encoded = execution.ToBencodex();
+            var decoded = new TxExecution(
+                execution.BlockHash,
+                execution.TxId,
+                encoded);
+            Assert.Equal(execution.BlockHash, decoded.BlockHash);
+            Assert.Equal(execution.TxId, decoded.TxId);
+            Assert.Equal(execution.Fail, decoded.Fail);
+            Assert.Equal(execution.InputState, decoded.InputState);
+            Assert.Equal(execution.OutputState, decoded.OutputState);
+            Assert.Equal(execution.ExceptionNames, decoded.ExceptionNames);
+        }
+
+        [Fact]
+        public void ConstructorWithExceptions()
+        {
+            var random = new Random();
+            var blockHash = random.NextBlockHash();
+            var txId = random.NextTxId();
+            var inputState = random.NextHashDigest<SHA256>();
+            var outputState = random.NextHashDigest<SHA256>();
+            var exceptions = new List<Exception>() { null, new ArgumentException("Message") };
+            var execution = new TxExecution(
+                blockHash,
+                txId,
+                true,
+                inputState,
+                outputState,
+                exceptions);
+            Assert.Equal(blockHash, execution.BlockHash);
+            Assert.Equal(txId, execution.TxId);
+            Assert.True(execution.Fail);
+            Assert.Equal(inputState, execution.InputState);
+            Assert.Equal(outputState, execution.OutputState);
+            Assert.Equal(
+                exceptions
+                    .Select(exception => exception is Exception e
+                        ? e.GetType().FullName
+                        : string.Empty),
+                execution.ExceptionNames);
+        }
+
+        [Fact]
+        public void DecodeFailLegacy()
+        {
+            var random = new Random();
+            var blockHash = random.NextBlockHash();
+            var txId = random.NextTxId();
+
+            Dictionary legacyEncoded = Dictionary.Empty
+                .Add("fail", true)
+                .Add("exc", "SomeException");
+            var failExecution = new TxExecution(
+                blockHash,
+                txId,
+                legacyEncoded);
+            Assert.Equal(blockHash, failExecution.BlockHash);
+            Assert.Equal(txId, failExecution.TxId);
+            Assert.True(failExecution.Fail);
+            Assert.Null(failExecution.InputState);
+            Assert.Null(failExecution.OutputState);
+            Assert.Null(failExecution.ExceptionNames);
+        }
+
+        [Fact]
+        public void DecodeSuccessLegacy()
+        {
+            var random = new Random();
+            var blockHash = random.NextBlockHash();
+            var txId = random.NextTxId();
+
+            // Note: Actual format for sDelta and updatedFAVs doesn't really matter,
+            // it is important decoding doesn't throw an exception.
+            var currency = Currency.Uncapped("FOO", 0, null);
+            Dictionary legacyEncoded = Dictionary.Empty
+                .Add("fail", false)
+                .Add("sDelta", Dictionary.Empty
+                    .Add(random.NextAddress().ByteArray, random.NextAddress().ByteArray))
+                .Add("updatedFAVs", List.Empty
+                    .Add(currency.Serialize())
+                    .Add(123));
+            var successExecution = new TxExecution(
+                blockHash,
+                txId,
+                legacyEncoded);
+            Assert.Equal(blockHash, successExecution.BlockHash);
+            Assert.Equal(txId, successExecution.TxId);
+            Assert.False(successExecution.Fail);
+            Assert.Null(successExecution.InputState);
+            Assert.Null(successExecution.OutputState);
+            Assert.Null(successExecution.ExceptionNames);
+        }
+    }
+}
diff --git a/Libplanet.Tests/Tx/TxFailureTest.cs b/Libplanet.Tests/Tx/TxFailureTest.cs
deleted file mode 100644
index 6897580aa97..00000000000
--- a/Libplanet.Tests/Tx/TxFailureTest.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using Libplanet.Types.Blocks;
-using Libplanet.Types.Tx;
-using Xunit;
-
-namespace Libplanet.Tests.Tx
-{
-    public class TxFailureTest
-    {
-        private readonly BlockHash _blockHash;
-        private readonly TxId _txid;
-        private readonly TxFailure _fx;
-
-        [SuppressMessage(
-            "Major Code Smell",
-            "S3928",
-            Justification = "The ArgumentNullException instance made here is a just example."
-        )]
-        public TxFailureTest()
-        {
-            var random = new Random();
-            _blockHash = random.NextBlockHash();
-            _txid = random.NextTxId();
-            _fx = new TxFailure(
-                _blockHash,
-                _txid,
-                new ArgumentNullException("foo"));
-        }
-
-        [Fact]
-        public void ConstructorWithExceptionObject()
-        {
-            Assert.Equal(_blockHash, _fx.BlockHash);
-            Assert.Equal(_txid, _fx.TxId);
-            Assert.Equal(
-                $"{nameof(System)}.{nameof(ArgumentNullException)}",
-                _fx.ExceptionName);
-        }
-
-        [Fact]
-        public void Constructor()
-        {
-            var f = new TxFailure(
-                _blockHash,
-                _txid,
-                nameof(ArgumentNullException)
-            );
-            Assert.Equal(_blockHash, f.BlockHash);
-            Assert.Equal(_txid, f.TxId);
-            Assert.Equal(nameof(ArgumentNullException), f.ExceptionName);
-        }
-    }
-}
diff --git a/Libplanet.Tests/Tx/TxSuccessTest.cs b/Libplanet.Tests/Tx/TxSuccessTest.cs
deleted file mode 100644
index fecce72eece..00000000000
--- a/Libplanet.Tests/Tx/TxSuccessTest.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-using System;
-using System.Collections.Immutable;
-using System.Linq;
-using Bencodex.Types;
-using Libplanet.Crypto;
-using Libplanet.Types.Assets;
-using Libplanet.Types.Blocks;
-using Libplanet.Types.Tx;
-using Xunit;
-using FAV = Libplanet.Types.Assets.FungibleAssetValue;
-
-namespace Libplanet.Tests.Tx
-{
-    public class TxSuccessTest
-    {
-        private static readonly Currency[] Currencies = new[] { "FOO", "BAR", "BAZ", "QUX" }
-            .Select(ticker => Currency.Uncapped(ticker, 0, null))
-            .ToArray();
-
-        private readonly BlockHash _blockHash;
-        private readonly TxId _txid;
-        private readonly ImmutableDictionary<Address, IValue> _updatedStates;
-
-        private readonly ImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>
-            _updatedFungibleAssets;
-
-        private readonly TxSuccess _fx;
-
-        public TxSuccessTest()
-        {
-            var random = new Random();
-            _blockHash = random.NextBlockHash();
-            _txid = random.NextTxId();
-            _updatedStates = Enumerable.Repeat(random, 5).ToImmutableDictionary(
-                RandomExtensions.NextAddress,
-                _ => (IValue)new Bencodex.Types.Integer(random.Next())
-            );
-            var currencies = Currencies.ToList();
-            _updatedFungibleAssets = Enumerable.Repeat(random, 5).ToImmutableDictionary(
-                RandomExtensions.NextAddress,
-                _ => (IImmutableDictionary<Currency, FAV>)Enumerable.Repeat(
-                        0,
-                        random.Next(currencies.Count))
-                    .Select(__ =>
-                    {
-                        int i = random.Next(currencies.Count);
-                        Currency c = currencies[i];
-                        currencies.RemoveAt(i);
-                        return c;
-                    })
-                    .ToImmutableDictionary(
-                        c => c,
-                        c => c * random.Next()
-                    )
-            );
-            _fx = new TxSuccess(
-                _blockHash,
-                _txid,
-                _updatedStates,
-                _updatedFungibleAssets
-            );
-        }
-
-        [Fact]
-        public void ConstructorBuilder()
-        {
-            Assert.Equal(_blockHash, _fx.BlockHash);
-            Assert.Equal(_txid, _fx.TxId);
-            Assert.Equal(_updatedStates, _fx.UpdatedStates);
-            Assert.Equal(_updatedFungibleAssets, _fx.UpdatedFungibleAssets);
-        }
-    }
-}
diff --git a/Libplanet.Types/Tx/TxExecution.cs b/Libplanet.Types/Tx/TxExecution.cs
index 4fb13998c70..99bdeb3bcb7 100644
--- a/Libplanet.Types/Tx/TxExecution.cs
+++ b/Libplanet.Types/Tx/TxExecution.cs
@@ -86,16 +86,19 @@ private TxExecution(
             TxId = txId;
 
             if (!encoded.TryGetValue(FailKey, out IValue fail) ||
-                !(fail is Bencodex.Types.Boolean failBoolean) ||
-                (failBoolean.Value == false))
+                !(fail is Bencodex.Types.Boolean failBoolean))
             {
                 throw new ArgumentException($"Invalid fail key value: {fail}");
             }
+            else
+            {
+                Fail = failBoolean.Value;
+            }
 
             if (encoded.TryGetValue(InputStateKey, out IValue input) &&
                 input is Binary inputBinary)
             {
-                InputState = HashDigest<SHA256>.DeriveFrom(inputBinary.ByteArray);
+                InputState = new HashDigest<SHA256>(inputBinary.ByteArray);
             }
             else
             {
@@ -103,9 +106,9 @@ private TxExecution(
             }
 
             if (encoded.TryGetValue(OutputStateKey, out IValue output) &&
-                input is Binary outputBinary)
+                output is Binary outputBinary)
             {
-                InputState = HashDigest<SHA256>.DeriveFrom(outputBinary.ByteArray);
+                OutputState = new HashDigest<SHA256>(outputBinary.ByteArray);
             }
             else
             {
diff --git a/Libplanet/Blockchain/BlockChain.TxExecution.cs b/Libplanet/Blockchain/BlockChain.TxExecution.cs
index 34eda701b2b..c4d7f19bded 100644
--- a/Libplanet/Blockchain/BlockChain.TxExecution.cs
+++ b/Libplanet/Blockchain/BlockChain.TxExecution.cs
@@ -65,6 +65,9 @@ IReadOnlyList<IActionEvaluation> evaluations
 
                     List<Exception?> exceptions = group.Item2
                         .Select(eval => eval.Exception)
+                        .Select(exception => exception is { } e && e.InnerException is { } i
+                            ? i
+                            : exception)
                         .ToList();
 
                     yield return new TxExecution(
@@ -73,7 +76,7 @@ IReadOnlyList<IActionEvaluation> evaluations
                         exceptions.Any(exception => exception is { }),
                         trie.Hash,
                         nextTrie.Hash,
-                        exceptions);
+                        exceptions.ToList());
 
                     count++;
                     trie = nextTrie;

From 978b7684b3d8aad7ba2e6cf8b42c6aec5173e9a6 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 21 Sep 2023 10:00:59 +0900
Subject: [PATCH 29/72] Refactor TxResult to partially accommodate TxExecution
 changes

---
 .../GraphTypes/TxResultTypeTest.cs            | 46 +++++--------------
 .../Queries/TransactionQueryGeneratedTest.cs  | 18 ++++----
 Libplanet.Explorer/GraphTypes/TxResult.cs     |  7 +--
 Libplanet.Explorer/GraphTypes/TxResultType.cs |  6 +--
 .../Queries/TransactionQuery.cs               |  2 +-
 5 files changed, 29 insertions(+), 50 deletions(-)

diff --git a/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs b/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs
index 0781e99d71f..7b849e5be4e 100644
--- a/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs
+++ b/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs
@@ -21,7 +21,7 @@ public async void Query(TxResult txResult, IDictionary<string, object> expected)
                     txStatus
                     blockIndex
                     blockHash
-                    exceptionName
+                    exceptionNames
                     updatedStates {
                         address
                         state
@@ -60,17 +60,17 @@ public static IEnumerable<object[]> TestCases() {
                         TxStatus.SUCCESS,
                         0,
                         "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
+                        new List<string>() { "" },
                         null,
-                        ImmutableDictionary<Address, Bencodex.Types.IValue>.Empty,
-                        ImmutableDictionary<Address, IImmutableDictionary<Currency, FungibleAssetValue>>.Empty
+                        null
                     ),
                     new Dictionary<string, object> {
                         ["txStatus"] = "SUCCESS",
                         ["blockIndex"] = 0L,
                         ["blockHash"] = "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
-                        ["exceptionName"] = null,
-                        ["updatedStates"] = new object[0],
-                        ["updatedFungibleAssets"] = new object[0],
+                        ["exceptionNames"] = new string[] { "" },
+                        ["updatedStates"] = null,
+                        ["updatedFungibleAssets"] = null,
                     }
                 },
                 new object[] {
@@ -78,41 +78,17 @@ public static IEnumerable<object[]> TestCases() {
                         TxStatus.SUCCESS,
                         0,
                         "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
+                        new List<string>() { "" },
                         null,
-                        ImmutableDictionary<Address, Bencodex.Types.IValue>.Empty
-                            .Add(address, Bencodex.Types.Null.Value),
-                        ImmutableDictionary<Address, IImmutableDictionary<Currency, FungibleAssetValue>>.Empty
-                            .Add(
-                                address,
-                                ImmutableDictionary<Currency, FungibleAssetValue>.Empty
-                                    .Add(KRW, KRW * 20000)
-                            )
+                        null
                     ),
                     new Dictionary<string, object> {
                         ["txStatus"] = "SUCCESS",
                         ["blockIndex"] = 0L,
                         ["blockHash"] = "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
-                        ["exceptionName"] = null,
-                        ["updatedStates"] = new object[] {
-                            new Dictionary<string, object> {
-                                ["address"] = address.ToString(),
-                                ["state"] = new byte[] { 110, },
-                            },
-                        },
-                        ["updatedFungibleAssets"] = new object[] {
-                            new Dictionary<string, object> {
-                                ["address"] = address.ToString(),
-                                ["fungibleAssetValues"] = new object[] {
-                                    new Dictionary<string, object> {
-                                        ["currency"] = new Dictionary<string, object> {
-                                            ["ticker"] = KRW.Ticker,
-                                            ["decimalPlaces"] = KRW.DecimalPlaces,
-                                        },
-                                        ["quantity"] = "20000",
-                                    },
-                                },
-                            },
-                        },
+                        ["exceptionNames"] = new string[] { "" },
+                        ["updatedStates"] = null,
+                        ["updatedFungibleAssets"] = null,
                     }
                 }
             };
diff --git a/Libplanet.Explorer.Tests/Queries/TransactionQueryGeneratedTest.cs b/Libplanet.Explorer.Tests/Queries/TransactionQueryGeneratedTest.cs
index db2021cce63..bbfa248715f 100644
--- a/Libplanet.Explorer.Tests/Queries/TransactionQueryGeneratedTest.cs
+++ b/Libplanet.Explorer.Tests/Queries/TransactionQueryGeneratedTest.cs
@@ -64,24 +64,24 @@ public async Task TransactionResult()
         Assert.Equal("SUCCESS", queryResult.TxStatus);
         Assert.Equal(successBlock.Index, queryResult.BlockIndex);
         Assert.Equal(successBlock.Hash.ToString(), queryResult.BlockHash);
-        Assert.Null(queryResult.ExceptionName);
+        Assert.Equal(new string[] { "" }, queryResult.ExceptionNames);
         queryResult = await ExecuteTransactionResultQueryAsync(failTx.Id);
         Assert.Equal("FAILURE", queryResult.TxStatus);
         Assert.Equal(failBlock.Index, queryResult.BlockIndex);
         Assert.Equal(failBlock.Hash.ToString(), queryResult.BlockHash);
         Assert.Equal(
-            "Libplanet.Action.State.CurrencyPermissionException",
-            queryResult.ExceptionName);
+            new string[] { "Libplanet.Action.State.CurrencyPermissionException" },
+            queryResult.ExceptionNames);
         queryResult = await ExecuteTransactionResultQueryAsync(new TxId());
         Assert.Equal("INVALID", queryResult.TxStatus);
         Assert.Null(queryResult.BlockIndex);
         Assert.Null(queryResult.BlockHash);
-        Assert.Null(queryResult.ExceptionName);
+        Assert.Null(queryResult.ExceptionNames);
         queryResult = await ExecuteTransactionResultQueryAsync(stagingTx.Id);
         Assert.Equal("STAGING", queryResult.TxStatus);
         Assert.Null(queryResult.BlockIndex);
         Assert.Null(queryResult.BlockHash);
-        Assert.Null(queryResult.ExceptionName);
+        Assert.Null(queryResult.ExceptionNames);
     }
 
     [Fact]
@@ -300,7 +300,7 @@ await Source.Index.GetContainedBlockHashByTxIdAsync(expected[i].Id)
     }
 
     private async Task<
-            (string TxStatus, long? BlockIndex, string? BlockHash, string? ExceptionName)>
+            (string TxStatus, long? BlockIndex, string? BlockHash, string[]? ExceptionNames)>
         ExecuteTransactionResultQueryAsync(TxId txId)
     {
         ExecutionResult result = await ExecuteQueryAsync(@$"
@@ -310,7 +310,7 @@ private async Task<
                 txStatus
                 blockIndex
                 blockHash
-                exceptionName
+                exceptionNames
             }}
          }}
         ", QueryGraph, source: Source);
@@ -319,10 +319,12 @@ private async Task<
         IDictionary<string, object> resultDict =
             (IDictionary<string, object>)Assert.IsAssignableFrom<IDictionary<string, object>>(
                 resultData.ToValue())["transactionResult"];
+        var exceptionNames = ((object[]?)resultDict["exceptionNames"])?.Select(
+            name => Assert.IsType<string>(name)).ToArray();
         return (
             (string)resultDict["txStatus"],
             (long?)resultDict["blockIndex"],
             (string?)resultDict["blockHash"],
-            (string?)resultDict["exceptionName"]);
+            (string[]?)exceptionNames);
     }
 }
diff --git a/Libplanet.Explorer/GraphTypes/TxResult.cs b/Libplanet.Explorer/GraphTypes/TxResult.cs
index eb9a518762a..f45d842ae07 100644
--- a/Libplanet.Explorer/GraphTypes/TxResult.cs
+++ b/Libplanet.Explorer/GraphTypes/TxResult.cs
@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using Bencodex.Types;
 using Libplanet.Crypto;
@@ -12,7 +13,7 @@ public TxResult(
             TxStatus status,
             long? blockIndex,
             string? blockHash,
-            string? exceptionName,
+            List<string>? exceptionNames,
             IImmutableDictionary<Address, IValue>? updatedStates,
             IImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>?
                 updatedFungibleAssets
@@ -21,7 +22,7 @@ public TxResult(
             TxStatus = status;
             BlockIndex = blockIndex;
             BlockHash = blockHash;
-            ExceptionName = exceptionName;
+            ExceptionNames = exceptionNames;
             UpdatedStates = updatedStates;
             UpdatedFungibleAssets = updatedFungibleAssets;
         }
@@ -32,7 +33,7 @@ public TxResult(
 
         public string? BlockHash { get; private set; }
 
-        public string? ExceptionName { get; private set; }
+        public List<string>? ExceptionNames { get; private set; }
 
         public IImmutableDictionary<Address, IValue>? UpdatedStates { get; }
 
diff --git a/Libplanet.Explorer/GraphTypes/TxResultType.cs b/Libplanet.Explorer/GraphTypes/TxResultType.cs
index 70a1a16022d..953efa54e05 100644
--- a/Libplanet.Explorer/GraphTypes/TxResultType.cs
+++ b/Libplanet.Explorer/GraphTypes/TxResultType.cs
@@ -28,10 +28,10 @@ public TxResultType()
                 resolve: context => context.Source.BlockHash
             );
 
-            Field<StringGraphType>(
-                nameof(TxResult.ExceptionName),
+            Field<ListGraphType<StringGraphType>>(
+                nameof(TxResult.ExceptionNames),
                 description: "The name of exception. (when only failed)",
-                resolve: context => context.Source.ExceptionName
+                resolve: context => context.Source.ExceptionNames
             );
 
             Field<ListGraphType<NonNullGraphType<UpdatedStateType>>>(
diff --git a/Libplanet.Explorer/Queries/TransactionQuery.cs b/Libplanet.Explorer/Queries/TransactionQuery.cs
index fa7f2f4b990..da64a3b359c 100644
--- a/Libplanet.Explorer/Queries/TransactionQuery.cs
+++ b/Libplanet.Explorer/Queries/TransactionQuery.cs
@@ -272,7 +272,7 @@ index is null
                             execution.Fail ? TxStatus.FAILURE : TxStatus.SUCCESS,
                             txExecutedBlock.Index,
                             txExecutedBlock.Hash.ToString(),
-                            null,
+                            execution.ExceptionNames,
                             null,
                             null);
                     }

From 5c3dcdbca56d8ea0849555229c722e40f7191971 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 21 Sep 2023 10:30:51 +0900
Subject: [PATCH 30/72] Clean up TxResult API

---
 .../GraphTypes/TxResultTypeTest.cs            | 28 +----------
 Libplanet.Explorer/GraphTypes/TxResult.cs     | 18 +------
 Libplanet.Explorer/GraphTypes/TxResultType.cs | 48 -------------------
 .../Queries/TransactionQuery.cs               | 13 +----
 4 files changed, 5 insertions(+), 102 deletions(-)

diff --git a/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs b/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs
index 7b849e5be4e..7fa38783b7e 100644
--- a/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs
+++ b/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs
@@ -22,20 +22,6 @@ public async void Query(TxResult txResult, IDictionary<string, object> expected)
                     blockIndex
                     blockHash
                     exceptionNames
-                    updatedStates {
-                        address
-                        state
-                    }
-                    updatedFungibleAssets {
-                        address
-                        fungibleAssetValues {
-                            currency {
-                                ticker
-                                decimalPlaces
-                            }
-                            quantity
-                        }
-                    }
                 }";
 
             var txResultType = new TxResultType();
@@ -52,25 +38,19 @@ public async void Query(TxResult txResult, IDictionary<string, object> expected)
         }
 
         public static IEnumerable<object[]> TestCases() {
-            Currency KRW = Currency.Uncapped("KRW", 18, null);
-            Address address = new Address("76ca86fa821c8241f9422c22b1386021047faf0d");
             return new object[][] {
                 new object[] {
                     new TxResult(
                         TxStatus.SUCCESS,
                         0,
                         "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
-                        new List<string>() { "" },
-                        null,
-                        null
+                        new List<string>() { "" }
                     ),
                     new Dictionary<string, object> {
                         ["txStatus"] = "SUCCESS",
                         ["blockIndex"] = 0L,
                         ["blockHash"] = "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
                         ["exceptionNames"] = new string[] { "" },
-                        ["updatedStates"] = null,
-                        ["updatedFungibleAssets"] = null,
                     }
                 },
                 new object[] {
@@ -78,17 +58,13 @@ public static IEnumerable<object[]> TestCases() {
                         TxStatus.SUCCESS,
                         0,
                         "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
-                        new List<string>() { "" },
-                        null,
-                        null
+                        new List<string>() { "" }
                     ),
                     new Dictionary<string, object> {
                         ["txStatus"] = "SUCCESS",
                         ["blockIndex"] = 0L,
                         ["blockHash"] = "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
                         ["exceptionNames"] = new string[] { "" },
-                        ["updatedStates"] = null,
-                        ["updatedFungibleAssets"] = null,
                     }
                 }
             };
diff --git a/Libplanet.Explorer/GraphTypes/TxResult.cs b/Libplanet.Explorer/GraphTypes/TxResult.cs
index f45d842ae07..754df551866 100644
--- a/Libplanet.Explorer/GraphTypes/TxResult.cs
+++ b/Libplanet.Explorer/GraphTypes/TxResult.cs
@@ -1,9 +1,4 @@
 using System.Collections.Generic;
-using System.Collections.Immutable;
-using Bencodex.Types;
-using Libplanet.Crypto;
-using Libplanet.Types.Assets;
-using FAV = Libplanet.Types.Assets.FungibleAssetValue;
 
 namespace Libplanet.Explorer.GraphTypes
 {
@@ -13,18 +8,12 @@ public TxResult(
             TxStatus status,
             long? blockIndex,
             string? blockHash,
-            List<string>? exceptionNames,
-            IImmutableDictionary<Address, IValue>? updatedStates,
-            IImmutableDictionary<Address, IImmutableDictionary<Currency, FAV>>?
-                updatedFungibleAssets
-        )
+            List<string>? exceptionNames)
         {
             TxStatus = status;
             BlockIndex = blockIndex;
             BlockHash = blockHash;
             ExceptionNames = exceptionNames;
-            UpdatedStates = updatedStates;
-            UpdatedFungibleAssets = updatedFungibleAssets;
         }
 
         public TxStatus TxStatus { get; private set; }
@@ -34,10 +23,5 @@ public TxResult(
         public string? BlockHash { get; private set; }
 
         public List<string>? ExceptionNames { get; private set; }
-
-        public IImmutableDictionary<Address, IValue>? UpdatedStates { get; }
-
-        public IImmutableDictionary<Address, IImmutableDictionary<Currency, FungibleAssetValue>>?
-            UpdatedFungibleAssets { get; }
     }
 }
diff --git a/Libplanet.Explorer/GraphTypes/TxResultType.cs b/Libplanet.Explorer/GraphTypes/TxResultType.cs
index 953efa54e05..0cd5ab45a89 100644
--- a/Libplanet.Explorer/GraphTypes/TxResultType.cs
+++ b/Libplanet.Explorer/GraphTypes/TxResultType.cs
@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Linq;
 using GraphQL.Types;
 using Libplanet.Crypto;
 using Libplanet.Types.Assets;
@@ -33,53 +32,6 @@ public TxResultType()
                 description: "The name of exception. (when only failed)",
                 resolve: context => context.Source.ExceptionNames
             );
-
-            Field<ListGraphType<NonNullGraphType<UpdatedStateType>>>(
-                nameof(TxResult.UpdatedStates),
-                resolve: context => context.Source.UpdatedStates?
-                    .Select(pair => new UpdatedState(pair.Key, pair.Value))
-            );
-
-            Field<ListGraphType<NonNullGraphType<FungibleAssetBalancesType>>>(
-                nameof(TxResult.UpdatedFungibleAssets),
-                resolve: context => context.Source.UpdatedFungibleAssets?
-                    .Select(pair => new FungibleAssetBalances(pair.Key, pair.Value.Values))
-            );
-        }
-
-        public record UpdatedState(Address Address, Bencodex.Types.IValue? State);
-
-        public class UpdatedStateType : ObjectGraphType<UpdatedState>
-        {
-            public UpdatedStateType()
-            {
-                Field<NonNullGraphType<AddressType>>(
-                    nameof(UpdatedState.Address),
-                    resolve: context => context.Source.Address
-                );
-                Field<BencodexValueType>(
-                    nameof(UpdatedState.State),
-                    resolve: context => context.Source.State
-                );
-            }
-        }
-
-        public record FungibleAssetBalances(
-            Address Address, IEnumerable<FungibleAssetValue> FungibleAssetValues);
-
-        public class FungibleAssetBalancesType : ObjectGraphType<FungibleAssetBalances>
-        {
-            public FungibleAssetBalancesType()
-            {
-                Field<NonNullGraphType<AddressType>>(
-                    nameof(FungibleAssetBalances.Address),
-                    resolve: context => context.Source.Address
-                );
-                Field<NonNullGraphType<ListGraphType<NonNullGraphType<FungibleAssetValueType>>>>(
-                    nameof(FungibleAssetBalances.FungibleAssetValues),
-                    resolve: context => context.Source.FungibleAssetValues
-                );
-            }
         }
     }
 }
diff --git a/Libplanet.Explorer/Queries/TransactionQuery.cs b/Libplanet.Explorer/Queries/TransactionQuery.cs
index da64a3b359c..667528f0242 100644
--- a/Libplanet.Explorer/Queries/TransactionQuery.cs
+++ b/Libplanet.Explorer/Queries/TransactionQuery.cs
@@ -248,15 +248,11 @@ index is null
                                 TxStatus.STAGING,
                                 null,
                                 null,
-                                null,
-                                null,
                                 null)
                             : new TxResult(
                                 TxStatus.INVALID,
                                 null,
                                 null,
-                                null,
-                                null,
                                 null);
                     }
 
@@ -272,9 +268,7 @@ index is null
                             execution.Fail ? TxStatus.FAILURE : TxStatus.SUCCESS,
                             txExecutedBlock.Index,
                             txExecutedBlock.Hash.ToString(),
-                            execution.ExceptionNames,
-                            null,
-                            null);
+                            execution.ExceptionNames);
                     }
                     catch (Exception)
                     {
@@ -282,10 +276,7 @@ index is null
                             TxStatus.INVALID,
                             null,
                             null,
-                            null,
-                            null,
-                            null
-                        );
+                            null);
                     }
                 }
             );

From 00f4bead6e7e3b720cef4f918c604b3bc18bb9dc Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 21 Sep 2023 11:27:02 +0900
Subject: [PATCH 31/72] Changed individual elements of ExceptionNames to be
 nullable

---
 .../Queries/TransactionQueryGeneratedTest.cs  |  8 +--
 Libplanet.Tests/Tx/TxExecutionTest.cs         |  4 +-
 Libplanet.Types/Tx/TxExecution.cs             | 49 +++++++++++++------
 3 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/Libplanet.Explorer.Tests/Queries/TransactionQueryGeneratedTest.cs b/Libplanet.Explorer.Tests/Queries/TransactionQueryGeneratedTest.cs
index bbfa248715f..fda7e5b6f05 100644
--- a/Libplanet.Explorer.Tests/Queries/TransactionQueryGeneratedTest.cs
+++ b/Libplanet.Explorer.Tests/Queries/TransactionQueryGeneratedTest.cs
@@ -64,7 +64,7 @@ public async Task TransactionResult()
         Assert.Equal("SUCCESS", queryResult.TxStatus);
         Assert.Equal(successBlock.Index, queryResult.BlockIndex);
         Assert.Equal(successBlock.Hash.ToString(), queryResult.BlockHash);
-        Assert.Equal(new string[] { "" }, queryResult.ExceptionNames);
+        Assert.Equal(new string?[] { null }, queryResult.ExceptionNames);
         queryResult = await ExecuteTransactionResultQueryAsync(failTx.Id);
         Assert.Equal("FAILURE", queryResult.TxStatus);
         Assert.Equal(failBlock.Index, queryResult.BlockIndex);
@@ -300,7 +300,7 @@ await Source.Index.GetContainedBlockHashByTxIdAsync(expected[i].Id)
     }
 
     private async Task<
-            (string TxStatus, long? BlockIndex, string? BlockHash, string[]? ExceptionNames)>
+            (string TxStatus, long? BlockIndex, string? BlockHash, string?[]? ExceptionNames)>
         ExecuteTransactionResultQueryAsync(TxId txId)
     {
         ExecutionResult result = await ExecuteQueryAsync(@$"
@@ -320,11 +320,11 @@ private async Task<
             (IDictionary<string, object>)Assert.IsAssignableFrom<IDictionary<string, object>>(
                 resultData.ToValue())["transactionResult"];
         var exceptionNames = ((object[]?)resultDict["exceptionNames"])?.Select(
-            name => Assert.IsType<string>(name)).ToArray();
+            name => name is { } n ? Assert.IsType<string>(n) : null).ToArray();
         return (
             (string)resultDict["txStatus"],
             (long?)resultDict["blockIndex"],
             (string?)resultDict["blockHash"],
-            (string[]?)exceptionNames);
+            (string?[]?)exceptionNames);
     }
 }
diff --git a/Libplanet.Tests/Tx/TxExecutionTest.cs b/Libplanet.Tests/Tx/TxExecutionTest.cs
index aa1c40841b8..d85f45b19e5 100644
--- a/Libplanet.Tests/Tx/TxExecutionTest.cs
+++ b/Libplanet.Tests/Tx/TxExecutionTest.cs
@@ -47,7 +47,7 @@ public void EncodeDecode()
                 true,
                 random.NextHashDigest<SHA256>(),
                 random.NextHashDigest<SHA256>(),
-                new List<string>() { string.Empty, "SomeException", "AnotherException" });
+                new List<string>() { null, "SomeException", "AnotherException" });
             var encoded = execution.ToBencodex();
             var decoded = new TxExecution(
                 execution.BlockHash,
@@ -86,7 +86,7 @@ public void ConstructorWithExceptions()
                 exceptions
                     .Select(exception => exception is Exception e
                         ? e.GetType().FullName
-                        : string.Empty),
+                        : null),
                 execution.ExceptionNames);
         }
 
diff --git a/Libplanet.Types/Tx/TxExecution.cs b/Libplanet.Types/Tx/TxExecution.cs
index 99bdeb3bcb7..abcc20d5c78 100644
--- a/Libplanet.Types/Tx/TxExecution.cs
+++ b/Libplanet.Types/Tx/TxExecution.cs
@@ -41,7 +41,7 @@ public TxExecution(
                 exceptions
                     .Select(exception => exception is { } e
                         ? e.GetType().FullName
-                        : string.Empty)
+                        : null)
                     .ToList())
         {
         }
@@ -52,7 +52,7 @@ public TxExecution(
             bool fail,
             HashDigest<SHA256> inputState,
             HashDigest<SHA256> outputState,
-            List<string> exceptionNames)
+            List<string?> exceptionNames)
         {
             BlockHash = blockHash;
             TxId = txId;
@@ -66,13 +66,16 @@ public TxExecution(
         public TxExecution(
             BlockHash blockHash,
             TxId txId,
-            IValue encoded)
+            IValue bencoded)
             : this(
                 blockHash,
                 txId,
-                encoded is Dictionary dict
+                bencoded is Dictionary dict
                     ? dict
-                    : throw new ArgumentException())
+                    : throw new ArgumentException(
+                        $"Given {nameof(bencoded)} must be of type " +
+                        $"{typeof(Bencodex.Types.Dictionary)}: {bencoded.GetType()}",
+                        nameof(bencoded)))
 #pragma warning restore SA1118
         {
         }
@@ -80,22 +83,29 @@ encoded is Dictionary dict
         private TxExecution(
             BlockHash blockHash,
             TxId txId,
-            Dictionary encoded)
+            Dictionary bencoded)
         {
             BlockHash = blockHash;
             TxId = txId;
 
-            if (!encoded.TryGetValue(FailKey, out IValue fail) ||
-                !(fail is Bencodex.Types.Boolean failBoolean))
+            if (!bencoded.TryGetValue(FailKey, out IValue fail))
             {
-                throw new ArgumentException($"Invalid fail key value: {fail}");
+                throw new ArgumentException(
+                    $"Given {nameof(bencoded)} is missing fail value",
+                    nameof(bencoded));
+            }
+            else if (!(fail is Bencodex.Types.Boolean failBoolean))
+            {
+                throw new ArgumentException(
+                    $"Given {nameof(bencoded)} has an invalid fail value: {fail}",
+                    nameof(bencoded));
             }
             else
             {
                 Fail = failBoolean.Value;
             }
 
-            if (encoded.TryGetValue(InputStateKey, out IValue input) &&
+            if (bencoded.TryGetValue(InputStateKey, out IValue input) &&
                 input is Binary inputBinary)
             {
                 InputState = new HashDigest<SHA256>(inputBinary.ByteArray);
@@ -105,7 +115,7 @@ private TxExecution(
                 InputState = null;
             }
 
-            if (encoded.TryGetValue(OutputStateKey, out IValue output) &&
+            if (bencoded.TryGetValue(OutputStateKey, out IValue output) &&
                 output is Binary outputBinary)
             {
                 OutputState = new HashDigest<SHA256>(outputBinary.ByteArray);
@@ -115,13 +125,17 @@ private TxExecution(
                 OutputState = null;
             }
 
-            if (encoded.TryGetValue(ExceptionNamesKey, out IValue exceptions) &&
+            if (bencoded.TryGetValue(ExceptionNamesKey, out IValue exceptions) &&
                 exceptions is List exceptionsList)
             {
                 ExceptionNames = exceptionsList
                     .Select(value => value is Text t
-                        ? t.Value
-                        : throw new ArgumentException())
+                        ? (string?)t.Value
+                        : value is Null
+                            ? (string?)null
+                            : throw new ArgumentException(
+                                $"Expected either {nameof(Text)} or {nameof(Null)} " +
+                                $"but got {value.GetType()}"))
                     .ToList();
             }
             else
@@ -149,7 +163,7 @@ private TxExecution(
 
         public HashDigest<SHA256>? OutputState { get; }
 
-        public List<string>? ExceptionNames { get; }
+        public List<string?>? ExceptionNames { get; }
 
         public IValue ToBencodex()
         {
@@ -170,7 +184,10 @@ public IValue ToBencodex()
             {
                 dict = dict.Add(
                     ExceptionNamesKey,
-                    new List(exceptionNames.Select(exceptionName => new Text(exceptionName))));
+                    new List(exceptionNames
+                        .Select(exceptionName => exceptionName is { } name
+                            ? (IValue)new Text(exceptionName)
+                            : (IValue)Null.Value)));
             }
 
             return dict;

From 45812cabb49a1b8e0a1b7f1901400dada729df4e Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 21 Sep 2023 11:33:06 +0900
Subject: [PATCH 32/72] Docs

---
 Libplanet.Explorer/GraphTypes/TxResult.cs     |  4 +--
 Libplanet.Explorer/GraphTypes/TxResultType.cs |  3 ---
 Libplanet.Types/Tx/TxExecution.cs             | 25 +++++++++++++++++++
 3 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/Libplanet.Explorer/GraphTypes/TxResult.cs b/Libplanet.Explorer/GraphTypes/TxResult.cs
index 754df551866..00f3c3a3b24 100644
--- a/Libplanet.Explorer/GraphTypes/TxResult.cs
+++ b/Libplanet.Explorer/GraphTypes/TxResult.cs
@@ -8,7 +8,7 @@ public TxResult(
             TxStatus status,
             long? blockIndex,
             string? blockHash,
-            List<string>? exceptionNames)
+            List<string?>? exceptionNames)
         {
             TxStatus = status;
             BlockIndex = blockIndex;
@@ -22,6 +22,6 @@ public TxResult(
 
         public string? BlockHash { get; private set; }
 
-        public List<string>? ExceptionNames { get; private set; }
+        public List<string?>? ExceptionNames { get; private set; }
     }
 }
diff --git a/Libplanet.Explorer/GraphTypes/TxResultType.cs b/Libplanet.Explorer/GraphTypes/TxResultType.cs
index 0cd5ab45a89..539865e7676 100644
--- a/Libplanet.Explorer/GraphTypes/TxResultType.cs
+++ b/Libplanet.Explorer/GraphTypes/TxResultType.cs
@@ -1,7 +1,4 @@
-using System.Collections.Generic;
 using GraphQL.Types;
-using Libplanet.Crypto;
-using Libplanet.Types.Assets;
 
 namespace Libplanet.Explorer.GraphTypes
 {
diff --git a/Libplanet.Types/Tx/TxExecution.cs b/Libplanet.Types/Tx/TxExecution.cs
index abcc20d5c78..5d98cc0b35b 100644
--- a/Libplanet.Types/Tx/TxExecution.cs
+++ b/Libplanet.Types/Tx/TxExecution.cs
@@ -157,12 +157,37 @@ private TxExecution(
         [Pure]
         public TxId TxId { get; }
 
+        /// <summary>
+        /// Whether <em>every</em> action in the <see cref="Transaction"/> was
+        /// executed without throwing and <see cref="Exception"/>.
+        /// </summary>
         public bool Fail { get; }
 
+        /// <summary>
+        /// The state before the execution of the <see cref="Transaction"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is marked <see langword="null"/>-able for backward compatibility.
+        /// </remarks>
         public HashDigest<SHA256>? InputState { get; }
 
+        /// <summary>
+        /// The state after the execution of the <see cref="Transaction"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is marked <see langword="null"/>-able for backward compatibility.
+        /// </remarks>
         public HashDigest<SHA256>? OutputState { get; }
 
+        /// <summary>
+        /// The list of <see cref="Exception"/> names thrown by actions
+        /// in the <see cref="Transaction"/>.  A value of <see langword="null"/>
+        /// as an element represents no <see cref="Exception"/> being thrown for
+        /// the action of the same index.
+        /// </summary>
+        /// <remarks>
+        /// This is marked <see langword="null"/>-able for backward compatibility.
+        /// </remarks>
         public List<string?>? ExceptionNames { get; }
 
         public IValue ToBencodex()

From 9453c71ae5549a178e176912b25ed15e62ee32f4 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 21 Sep 2023 14:04:14 +0900
Subject: [PATCH 33/72] Changelog

---
 CHANGES.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 710a446002a..aca7e306747 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -21,6 +21,17 @@ To be released.
  -  Removed `TxFailure.ExceptionMetadata` property.  [[#3428]]
  -  Removed `ISerializable` interface from `TxExecution`, `TxSuccess`,
     and `TxFailure`.  [[#3428]]
+ -  Removed `TxSuccess` and `TxFailure` class.  [[#3429]]
+ -  Changed `TxExecution` class as `sealed` from `abstract.`  [[#3429]]
+ -  All properties of `TxExecution` except `BlockHash` and `TxId` were
+    overhauled.  [[#3429]]
+ -  (Libplanet.Store) Removed `IStore.PutTxExecution(TxSuccess)` and
+    `IStore.PutTxExecution(TxFailure)`;
+    added `IStore.PutTxExecution(TxExecution)`.  [[#3429]]
+ -  (Libplanet.Explorer) Removed `TxResult.ExceptionName` of type `string?`
+    and added `TxResult.ExceptionNames` of type `List<string?>?`.  [[#3429]]
+ -  (Libplanet.Explorer) Removed `TxResult.UpdatedStates` and
+    `TxResult.UpdatedFungibleAssets`.  [[#3429]]
 
 ### Backward-incompatible network protocol changes
 
@@ -43,6 +54,7 @@ To be released.
 [#3425]: https://github.com/planetarium/libplanet/pull/3425
 [#3427]: https://github.com/planetarium/libplanet/pull/3427
 [#3428]: https://github.com/planetarium/libplanet/pull/3428
+[#3429]: https://github.com/planetarium/libplanet/pull/3429
 
 
 Version 3.3.1

From 78a827619806b8941cbc96d3f51f5e4d9257911f Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 21 Sep 2023 17:42:14 +0900
Subject: [PATCH 34/72] Remove clutter

---
 Libplanet/Blockchain/BlockChain.Swap.cs | 21 +++++----------------
 1 file changed, 5 insertions(+), 16 deletions(-)

diff --git a/Libplanet/Blockchain/BlockChain.Swap.cs b/Libplanet/Blockchain/BlockChain.Swap.cs
index 33f87ede385..5ee46a00c25 100644
--- a/Libplanet/Blockchain/BlockChain.Swap.cs
+++ b/Libplanet/Blockchain/BlockChain.Swap.cs
@@ -124,7 +124,6 @@ HashSet<TxId> GetTxIdsWithRange(
                     oldTip: oldTip,
                     newTip: newTip,
                     branchpoint: branchpoint,
-                    rewindPath: rewindPath,
                     fastForwardPath: fastForwardPath);
             }
             finally
@@ -140,7 +139,6 @@ internal void RenderSwap(
             Block oldTip,
             Block newTip,
             Block branchpoint,
-            IReadOnlyList<BlockHash> rewindPath,
             IReadOnlyList<BlockHash> fastForwardPath)
         {
             if (render)
@@ -172,23 +170,21 @@ internal void RenderFastForward(
             {
                 _logger.Debug("Rendering actions in new chain");
 
-                long count = 0;
                 foreach (BlockHash hash in fastForwardPath)
                 {
                     Block block = Store.GetBlock(hash);
                     ImmutableList<IActionEvaluation> evaluations =
                         ActionEvaluator.Evaluate(block).ToImmutableList();
 
-                    count += RenderActions(
+                    RenderActions(
                         evaluations: evaluations,
-                        block: block
-                    );
+                        block: block);
                 }
 
                 _logger.Debug(
-                    "{MethodName}() completed rendering {Count} actions",
+                    "{MethodName}() completed rendering actions in {Count} blocks",
                     nameof(Swap),
-                    count);
+                    fastForwardPath.Count);
 
                 foreach (IActionRenderer renderer in ActionRenderers)
                 {
@@ -203,8 +199,7 @@ internal void RenderFastForward(
         /// <param name="evaluations"><see cref="IActionEvaluation"/>s of the block.  If it is
         /// <see langword="null"/>, evaluate actions of the <paramref name="block"/> again.</param>
         /// <param name="block"><see cref="Block"/> to render actions.</param>
-        /// <returns>The number of actions rendered.</returns>
-        internal long RenderActions(
+        internal void RenderActions(
             IReadOnlyList<IActionEvaluation> evaluations,
             Block block)
         {
@@ -224,11 +219,6 @@ internal long RenderActions(
             ITrie trie = GetAccountState(block.PreviousHash).Trie;
             foreach (var evaluation in evaluations)
             {
-                if (evaluation.InputContext.BlockAction && Policy.BlockAction is null)
-                {
-                    continue;
-                }
-
                 ITrie nextTrie = trie;
                 foreach (var kv in evaluation.OutputState.Delta.ToRawDelta())
                 {
@@ -287,7 +277,6 @@ internal long RenderActions(
                     block.Index,
                     block.Hash,
                     stopwatch.ElapsedMilliseconds);
-            return count;
         }
 
         /// <summary>

From e620c2576650aec49421bd8407cedc6e01ab41b9 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 22 Sep 2023 12:27:27 +0900
Subject: [PATCH 35/72] Renamed for better consistency; added
 ICommittedActionEvaluation

---
 ...erContext.cs => CommittedActionContext.cs} | 24 ++++----
 Libplanet.Action/CommittedActionEvaluation.cs | 60 +++++++++++++++++++
 ...rContext.cs => ICommittedActionContext.cs} |  2 +-
 .../ICommittedActionEvaluation.cs             | 35 +++++++++++
 .../Renderers/AnonymousActionRendererTest.cs  |  8 +--
 .../Renderers/LoggedActionRendererTest.cs     |  8 +--
 Libplanet/Blockchain/BlockChain.Swap.cs       |  4 +-
 .../Renderers/AnonymousActionRenderer.cs      | 14 ++---
 .../Renderers/AtomicActionRenderer.cs         | 10 ++--
 .../Debug/RecordingActionRenderer.cs          |  4 +-
 .../Renderers/Debug/RenderRecord.cs           |  8 +--
 .../Debug/ValidatingActionRenderer.cs         |  4 +-
 .../Blockchain/Renderers/IActionRenderer.cs   |  4 +-
 .../Renderers/LoggedActionRenderer.cs         |  6 +-
 14 files changed, 143 insertions(+), 48 deletions(-)
 rename Libplanet.Action/{ActionRenderContext.cs => CommittedActionContext.cs} (69%)
 create mode 100644 Libplanet.Action/CommittedActionEvaluation.cs
 rename Libplanet.Action/{IActionRenderContext.cs => ICommittedActionContext.cs} (98%)
 create mode 100644 Libplanet.Action/ICommittedActionEvaluation.cs

diff --git a/Libplanet.Action/ActionRenderContext.cs b/Libplanet.Action/CommittedActionContext.cs
similarity index 69%
rename from Libplanet.Action/ActionRenderContext.cs
rename to Libplanet.Action/CommittedActionContext.cs
index 8857356f2c1..0979257f950 100644
--- a/Libplanet.Action/ActionRenderContext.cs
+++ b/Libplanet.Action/CommittedActionContext.cs
@@ -6,9 +6,9 @@
 
 namespace Libplanet.Action
 {
-    public class ActionRenderContext : IActionRenderContext
+    public class CommittedActionContext : ICommittedActionContext
     {
-        public ActionRenderContext(IActionContext context)
+        public CommittedActionContext(IActionContext context)
             : this(
                 signer: context.Signer,
                 txId: context.TxId,
@@ -22,7 +22,7 @@ public ActionRenderContext(IActionContext context)
         {
         }
 
-        public ActionRenderContext(
+        public CommittedActionContext(
             Address signer,
             TxId? txId,
             Address miner,
@@ -44,38 +44,38 @@ public ActionRenderContext(
             BlockAction = blockAction;
         }
 
-        /// <inheritdoc cref="IActionRenderContext.Signer"/>
+        /// <inheritdoc cref="ICommittedActionContext.Signer"/>
         [Pure]
         public Address Signer { get; }
 
-        /// <inheritdoc cref="IActionRenderContext.TxId"/>
+        /// <inheritdoc cref="ICommittedActionContext.TxId"/>
         [Pure]
         public TxId? TxId { get; }
 
-        /// <inheritdoc cref="IActionRenderContext.Miner"/>
+        /// <inheritdoc cref="ICommittedActionContext.Miner"/>
         [Pure]
         public Address Miner { get; }
 
-        /// <inheritdoc cref="IActionRenderContext.BlockIndex"/>
+        /// <inheritdoc cref="ICommittedActionContext.BlockIndex"/>
         [Pure]
         public long BlockIndex { get; }
 
-        /// <inheritdoc cref="IActionRenderContext.BlockProtocolVersion"/>
+        /// <inheritdoc cref="ICommittedActionContext.BlockProtocolVersion"/>
         [Pure]
         public int BlockProtocolVersion { get; }
 
-        /// <inheritdoc cref="IActionRenderContext.Rehearsal"/>
+        /// <inheritdoc cref="ICommittedActionContext.Rehearsal"/>
         [Pure]
         public bool Rehearsal { get; }
 
-        /// <inheritdoc cref="IActionRenderContext.PreviousState"/>
+        /// <inheritdoc cref="ICommittedActionContext.PreviousState"/>
         [Pure]
         public HashDigest<SHA256> PreviousState { get; }
 
-        /// <inheritdoc cref="IActionRenderContext.Random"/>
+        /// <inheritdoc cref="ICommittedActionContext.Random"/>
         public IRandom Random { get; }
 
-        /// <inheritdoc cref="IActionRenderContext.BlockAction"/>
+        /// <inheritdoc cref="ICommittedActionContext.BlockAction"/>
         [Pure]
         public bool BlockAction { get; }
     }
diff --git a/Libplanet.Action/CommittedActionEvaluation.cs b/Libplanet.Action/CommittedActionEvaluation.cs
new file mode 100644
index 00000000000..6f7e04ff10d
--- /dev/null
+++ b/Libplanet.Action/CommittedActionEvaluation.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Security.Cryptography;
+using Bencodex.Types;
+using Libplanet.Common;
+
+namespace Libplanet.Action
+{
+    /// <summary>
+    /// A record type to represent an evaluation plan and result of
+    /// a single action.
+    /// </summary>
+    public class CommittedActionEvaluation : ICommittedActionEvaluation
+    {
+        /// <summary>
+        /// Creates an <see cref="CommittedActionEvaluation"/> instance
+        /// with filling properties.
+        /// </summary>
+        /// <param name="action">An action to evaluate.</param>
+        /// <param name="inputContext">An input <see cref="IActionContext"/> to
+        /// evaluate <paramref name="action"/>.</param>
+        /// <param name="outputState">The result states that
+        /// <paramref name="action"/> makes.</param>
+        /// <param name="exception">An exception that has risen during evaluating a given
+        /// <paramref name="action"/>.</param>
+        public CommittedActionEvaluation(
+            IValue action,
+            ICommittedActionContext inputContext,
+            HashDigest<SHA256> outputState,
+            Exception? exception = null)
+        {
+            Action = action;
+            InputContext = inputContext;
+            OutputState = outputState;
+            Exception = exception;
+        }
+
+        /// <summary>
+        /// An action to evaluate.
+        /// </summary>
+        public IValue Action { get; }
+
+        /// <summary>
+        /// An input <see cref="ICommittedActionContext"/> to evaluate
+        /// <see cref="Action"/>.
+        /// </summary>
+        /// <remarks>Its <see cref="ICommittedActionContext.Random"/> property
+        /// is not consumed yet.</remarks>
+        public ICommittedActionContext InputContext { get; }
+
+        /// <summary>
+        /// The result states that <see cref="Action"/> makes.
+        /// </summary>
+        public HashDigest<SHA256> OutputState { get; }
+
+        /// <summary>
+        /// An exception that had risen during evaluation.
+        /// </summary>
+        public Exception? Exception { get; }
+    }
+}
diff --git a/Libplanet.Action/IActionRenderContext.cs b/Libplanet.Action/ICommittedActionContext.cs
similarity index 98%
rename from Libplanet.Action/IActionRenderContext.cs
rename to Libplanet.Action/ICommittedActionContext.cs
index 42a32aaf1c0..6ec79df4bf7 100644
--- a/Libplanet.Action/IActionRenderContext.cs
+++ b/Libplanet.Action/ICommittedActionContext.cs
@@ -10,7 +10,7 @@ namespace Libplanet.Action
     /// <summary>
     /// Contextual data determined by a transaction and a block for rendering.
     /// </summary>
-    public interface IActionRenderContext
+    public interface ICommittedActionContext
     {
         /// <summary>
         /// The <see cref="Transaction.Signer"/> of the <see cref="Transaction"/> that contains
diff --git a/Libplanet.Action/ICommittedActionEvaluation.cs b/Libplanet.Action/ICommittedActionEvaluation.cs
new file mode 100644
index 00000000000..3fea4f8d9d8
--- /dev/null
+++ b/Libplanet.Action/ICommittedActionEvaluation.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Security.Cryptography;
+using Bencodex.Types;
+using Libplanet.Common;
+
+namespace Libplanet.Action
+{
+    public interface ICommittedActionEvaluation
+    {
+        /// <summary>
+        /// An action data to evaluate. When the
+        /// <see cref="InputContext"/>.<see cref="IActionContext.BlockAction"/> is true,
+        /// use <see cref="IBlockPolicy.BlockAction"/> instead of trying deserialization.
+        /// </summary>
+        public IValue Action { get; }
+
+        /// <summary>
+        /// An input <see cref="IActionContext"/> to evaluate
+        /// <see cref="Action"/>.
+        /// </summary>
+        /// <remarks>Its <see cref="IActionContext.Random"/> property
+        /// is not consumed yet.</remarks>
+        public ICommittedActionContext InputContext { get; }
+
+        /// <summary>
+        /// The result states that <see cref="Action"/> makes.
+        /// </summary>
+        public HashDigest<SHA256> OutputState { get; }
+
+        /// <summary>
+        /// An exception that had risen during evaluation.
+        /// </summary>
+        public Exception? Exception { get; }
+    }
+}
diff --git a/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs b/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs
index a6b818fb7a0..1966eb0cf09 100644
--- a/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs
+++ b/Libplanet.Tests/Blockchain/Renderers/AnonymousActionRendererTest.cs
@@ -18,8 +18,8 @@ public class AnonymousActionRendererTest
 
         private static IAccount _account = new Account(MockAccountState.Empty);
 
-        private static IActionRenderContext _actionContext =
-            new ActionRenderContext(new ActionContext(
+        private static ICommittedActionContext _actionContext =
+            new CommittedActionContext(new ActionContext(
                 default,
                 default,
                 default,
@@ -43,7 +43,7 @@ public class AnonymousActionRendererTest
         [Fact]
         public void ActionRenderer()
         {
-            (IValue, IActionRenderContext, HashDigest<SHA256>)? record = null;
+            (IValue, ICommittedActionContext, HashDigest<SHA256>)? record = null;
             var renderer = new AnonymousActionRenderer
             {
                 ActionRenderer = (action, context, nextState) =>
@@ -65,7 +65,7 @@ record = (action, context, nextState),
         [Fact]
         public void ActionErrorRenderer()
         {
-            (IValue, IActionRenderContext, Exception)? record = null;
+            (IValue, ICommittedActionContext, Exception)? record = null;
             var renderer = new AnonymousActionRenderer
             {
                 ActionErrorRenderer = (action, context, exception) =>
diff --git a/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs b/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs
index 593351f5006..4c8220d8616 100644
--- a/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs
+++ b/Libplanet.Tests/Blockchain/Renderers/LoggedActionRendererTest.cs
@@ -68,8 +68,8 @@ public void ActionRenderings(bool error, bool rehearsal, bool exception)
         {
             bool called = false;
             LogEvent firstLog = null;
-            IActionRenderContext actionContext =
-                new ActionRenderContext(new ActionContext(
+            ICommittedActionContext actionContext =
+                new CommittedActionContext(new ActionContext(
                     default,
                     default,
                     default,
@@ -83,7 +83,7 @@ public void ActionRenderings(bool error, bool rehearsal, bool exception)
             IActionRenderer actionRenderer;
             if (error)
             {
-                Action<IValue, IActionRenderContext, Exception> render = (action, cxt, e) =>
+                Action<IValue, ICommittedActionContext, Exception> render = (action, cxt, e) =>
                 {
                     LogEvent[] logs = LogEvents.ToArray();
                     Assert.Single(logs);
@@ -104,7 +104,7 @@ public void ActionRenderings(bool error, bool rehearsal, bool exception)
             }
             else
             {
-                Action<IValue, IActionRenderContext, HashDigest<SHA256>> render =
+                Action<IValue, ICommittedActionContext, HashDigest<SHA256>> render =
                     (action, cxt, next) =>
                     {
                         LogEvent[] logs = LogEvents.ToArray();
diff --git a/Libplanet/Blockchain/BlockChain.Swap.cs b/Libplanet/Blockchain/BlockChain.Swap.cs
index 5ee46a00c25..9008bebe9ad 100644
--- a/Libplanet/Blockchain/BlockChain.Swap.cs
+++ b/Libplanet/Blockchain/BlockChain.Swap.cs
@@ -233,7 +233,7 @@ internal void RenderActions(
                     {
                         renderer.RenderAction(
                             evaluation.Action,
-                            new ActionRenderContext(
+                            new CommittedActionContext(
                                 signer: evaluation.InputContext.Signer,
                                 txId: evaluation.InputContext.TxId,
                                 miner: evaluation.InputContext.Miner,
@@ -249,7 +249,7 @@ internal void RenderActions(
                     {
                         renderer.RenderActionError(
                             evaluation.Action,
-                            new ActionRenderContext(
+                            new CommittedActionContext(
                                 signer: evaluation.InputContext.Signer,
                                 txId: evaluation.InputContext.TxId,
                                 miner: evaluation.InputContext.Miner,
diff --git a/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs b/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs
index 9b95cac7fa4..42fd7be8aa0 100644
--- a/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/AnonymousActionRenderer.cs
@@ -30,16 +30,16 @@ public sealed class AnonymousActionRenderer : AnonymousRenderer, IActionRenderer
     {
         /// <summary>
         /// A callback function to be invoked together with
-        /// <see cref="RenderAction(IValue, IActionRenderContext, HashDigest{SHA256})"/>.
+        /// <see cref="RenderAction(IValue, ICommittedActionContext, HashDigest{SHA256})"/>.
         /// </summary>
-        public Action<IValue, IActionRenderContext, HashDigest<SHA256>>? ActionRenderer
+        public Action<IValue, ICommittedActionContext, HashDigest<SHA256>>? ActionRenderer
             { get; set; }
 
         /// <summary>
         /// A callback function to be invoked together with
-        /// <see cref="RenderActionError(IValue, IActionRenderContext, Exception)"/>.
+        /// <see cref="RenderActionError(IValue, ICommittedActionContext, Exception)"/>.
         /// </summary>
-        public Action<IValue, IActionRenderContext, Exception>? ActionErrorRenderer { get; set; }
+        public Action<IValue, ICommittedActionContext, Exception>? ActionErrorRenderer { get; set; }
 
         /// <summary>
         /// A callback function to be invoked together with
@@ -50,16 +50,16 @@ public Action<IValue, IActionRenderContext, HashDigest<SHA256>>? ActionRenderer
         /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public void RenderAction(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             HashDigest<SHA256> nextState
         ) =>
             ActionRenderer?.Invoke(action, context, nextState);
 
         /// <inheritdoc
-        /// cref="IActionRenderer.RenderActionError(IValue, IActionRenderContext, Exception)"/>
+        /// cref="IActionRenderer.RenderActionError(IValue, ICommittedActionContext, Exception)"/>
         public void RenderActionError(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             Exception exception) =>
                 ActionErrorRenderer?.Invoke(action, context, exception);
 
diff --git a/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs b/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs
index 646bf8f001f..7b4b7608dcd 100644
--- a/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/AtomicActionRenderer.cs
@@ -21,7 +21,7 @@ namespace Libplanet.Blockchain.Renderers
     /// </remarks>
     public sealed class AtomicActionRenderer : IActionRenderer
     {
-        private readonly List<(IValue, IActionRenderContext, HashDigest<SHA256>)> _eventBuffer;
+        private readonly List<(IValue, ICommittedActionContext, HashDigest<SHA256>)> _eventBuffer;
         private TxId? _lastTxId;
         private bool _errored;
 
@@ -36,7 +36,7 @@ public AtomicActionRenderer(IActionRenderer actionRenderer)
         {
             ActionRenderer = actionRenderer;
             _lastTxId = null;
-            _eventBuffer = new List<(IValue, IActionRenderContext, HashDigest<SHA256>)>();
+            _eventBuffer = new List<(IValue, ICommittedActionContext, HashDigest<SHA256>)>();
             _errored = false;
         }
 
@@ -62,7 +62,7 @@ public void RenderBlockEnd(Block oldTip, Block newTip)
         /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public void RenderAction(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             HashDigest<SHA256> nextState
         )
         {
@@ -84,7 +84,7 @@ HashDigest<SHA256> nextState
         /// <inheritdoc cref="IActionRenderer.RenderActionError"/>
         public void RenderActionError(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             Exception exception)
         {
             if (!context.TxId.Equals(_lastTxId))
@@ -104,7 +104,7 @@ public void RenderActionError(
 
         private void FlushBuffer(
             TxId? newTxId,
-            Action<IValue, IActionRenderContext, HashDigest<SHA256>> render
+            Action<IValue, ICommittedActionContext, HashDigest<SHA256>> render
         )
         {
             if (!_errored)
diff --git a/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs b/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs
index e04ace87f64..731860a599f 100644
--- a/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/Debug/RecordingActionRenderer.cs
@@ -60,7 +60,7 @@ public void ResetRecords()
         /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public virtual void RenderAction(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             HashDigest<SHA256> nextState
         )
         {
@@ -80,7 +80,7 @@ HashDigest<SHA256> nextState
         /// <inheritdoc cref="IActionRenderer.RenderActionError"/>
         public virtual void RenderActionError(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             Exception exception
         ) =>
             _records.Add(
diff --git a/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs b/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs
index 78d12a04e39..3c269daa5b2 100644
--- a/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs
+++ b/Libplanet/Blockchain/Renderers/Debug/RenderRecord.cs
@@ -40,7 +40,7 @@ protected ActionBase(
                 long index,
                 string stackTrace,
                 IValue action,
-                IActionRenderContext context,
+                ICommittedActionContext context,
                 bool unrender = false
             )
                 : base(index, stackTrace)
@@ -58,7 +58,7 @@ protected ActionBase(
             /// <summary>
             /// The action evaluation context.
             /// </summary>
-            public IActionRenderContext Context { get; }
+            public ICommittedActionContext Context { get; }
 
             /// <summary>
             /// Whether it is not an unrender event, but a render event.
@@ -94,7 +94,7 @@ public ActionSuccess(
                 long index,
                 string stackTrace,
                 IValue action,
-                IActionRenderContext context,
+                ICommittedActionContext context,
                 HashDigest<SHA256> nextState,
                 bool unrender = false
             )
@@ -130,7 +130,7 @@ public ActionError(
                 long index,
                 string stackTrace,
                 IValue action,
-                IActionRenderContext context,
+                ICommittedActionContext context,
                 Exception exception,
                 bool unrender = false
             )
diff --git a/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs b/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs
index f8be6ab7f24..11a4c32a35e 100644
--- a/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/Debug/ValidatingActionRenderer.cs
@@ -44,7 +44,7 @@ public override void RenderBlock(Block oldTip, Block newTip)
         /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public override void RenderAction(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             HashDigest<SHA256> nextState
         )
         {
@@ -55,7 +55,7 @@ HashDigest<SHA256> nextState
         /// <inheritdoc cref="IActionRenderer.RenderActionError"/>
         public override void RenderActionError(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             Exception exception
         )
         {
diff --git a/Libplanet/Blockchain/Renderers/IActionRenderer.cs b/Libplanet/Blockchain/Renderers/IActionRenderer.cs
index dce1073cabe..90c9c8c2ab2 100644
--- a/Libplanet/Blockchain/Renderers/IActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/IActionRenderer.cs
@@ -66,7 +66,7 @@ public interface IActionRenderer : IRenderer
         /// </remarks>
         void RenderAction(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             HashDigest<SHA256> nextState);
 
         /// <summary>
@@ -86,7 +86,7 @@ void RenderAction(
         /// (where its second parameter <c>newTip</c> contains a transaction the <paramref
         /// name="action"/> belongs to).
         /// </remarks>
-        void RenderActionError(IValue action, IActionRenderContext context, Exception exception);
+        void RenderActionError(IValue action, ICommittedActionContext context, Exception exception);
 
         /// <summary>
         /// Does things that should be done right all actions in a new <see cref="Block"/> are
diff --git a/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs b/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs
index b0c715bbe43..be0220f80aa 100644
--- a/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs
+++ b/Libplanet/Blockchain/Renderers/LoggedActionRenderer.cs
@@ -71,7 +71,7 @@ Block newTip
         /// <inheritdoc cref="IActionRenderer.RenderAction"/>
         public void RenderAction(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             HashDigest<SHA256> nextState
         ) =>
             LogActionRendering(
@@ -84,7 +84,7 @@ HashDigest<SHA256> nextState
         /// <inheritdoc cref="IActionRenderer.RenderActionError"/>
         public void RenderActionError(
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             Exception exception
         ) =>
             LogActionRendering(
@@ -97,7 +97,7 @@ Exception exception
         private void LogActionRendering(
             string methodName,
             IValue action,
-            IActionRenderContext context,
+            ICommittedActionContext context,
             System.Action callback
         )
         {

From 7d8a429dd1603b6613f5c079c27d5d4f1d16cc5b Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 22 Sep 2023 14:25:10 +0900
Subject: [PATCH 36/72] Combined triple commit into one

---
 Libplanet.Action/ActionContext.cs             |  1 +
 Libplanet.Action/CommittedActionContext.cs    | 14 +++
 Libplanet.Action/ICommittedActionContext.cs   |  2 +
 Libplanet.Action/Random.cs                    |  3 -
 Libplanet.Net/Consensus/Context.cs            | 15 +--
 .../Blockchain/BlockChainTest.Append.cs       |  3 +-
 Libplanet/Blockchain/BlockChain.Evaluate.cs   | 95 +++++++++++++------
 Libplanet/Blockchain/BlockChain.Swap.cs       | 51 +++-------
 .../Blockchain/BlockChain.TxExecution.cs      | 46 +++------
 Libplanet/Blockchain/BlockChain.Validate.cs   |  2 +-
 Libplanet/Blockchain/BlockChain.cs            |  2 +-
 11 files changed, 121 insertions(+), 113 deletions(-)

diff --git a/Libplanet.Action/ActionContext.cs b/Libplanet.Action/ActionContext.cs
index 4c0b3bfce21..00ef9fe365b 100644
--- a/Libplanet.Action/ActionContext.cs
+++ b/Libplanet.Action/ActionContext.cs
@@ -69,6 +69,7 @@ public ActionContext(
         /// <inheritdoc cref="IActionContext.UseGas(long)"/>
         public void UseGas(long gas) => GetGasMeter.Value?.UseGas(gas);
 
+        /// <inheritdoc cref="IActionContext.GetUnconsumedContext"/>
         [Pure]
         public IActionContext GetUnconsumedContext() =>
             new ActionContext(
diff --git a/Libplanet.Action/CommittedActionContext.cs b/Libplanet.Action/CommittedActionContext.cs
index 0979257f950..70a6e23aa1f 100644
--- a/Libplanet.Action/CommittedActionContext.cs
+++ b/Libplanet.Action/CommittedActionContext.cs
@@ -78,5 +78,19 @@ public CommittedActionContext(
         /// <inheritdoc cref="ICommittedActionContext.BlockAction"/>
         [Pure]
         public bool BlockAction { get; }
+
+        /// <inheritdoc cref="ICommittedActionContext.Copy"/>
+        [Pure]
+        public ICommittedActionContext Copy() =>
+            new CommittedActionContext(
+                Signer,
+                TxId,
+                Miner,
+                BlockIndex,
+                BlockProtocolVersion,
+                Rehearsal,
+                PreviousState,
+                new Random(Random.Seed),
+                BlockAction);
     }
 }
diff --git a/Libplanet.Action/ICommittedActionContext.cs b/Libplanet.Action/ICommittedActionContext.cs
index 6ec79df4bf7..3d24518ebc8 100644
--- a/Libplanet.Action/ICommittedActionContext.cs
+++ b/Libplanet.Action/ICommittedActionContext.cs
@@ -82,5 +82,7 @@ public interface ICommittedActionContext
         /// </summary>
         [Pure]
         bool BlockAction { get; }
+
+        ICommittedActionContext Copy();
     }
 }
diff --git a/Libplanet.Action/Random.cs b/Libplanet.Action/Random.cs
index 294611db661..a5f974322b7 100644
--- a/Libplanet.Action/Random.cs
+++ b/Libplanet.Action/Random.cs
@@ -1,6 +1,3 @@
-#nullable disable
-using System;
-
 namespace Libplanet.Action
 {
     internal class Random : System.Random, IRandom
diff --git a/Libplanet.Net/Consensus/Context.cs b/Libplanet.Net/Consensus/Context.cs
index a6492264786..e9177de1ca2 100644
--- a/Libplanet.Net/Consensus/Context.cs
+++ b/Libplanet.Net/Consensus/Context.cs
@@ -96,7 +96,9 @@ public partial class Context : IDisposable
 
         private readonly ILogger _logger;
         private readonly
-            LRUCache<BlockHash, (bool IsValid, IReadOnlyList<IActionEvaluation> EvaluatedActions)>
+            LRUCache<
+                BlockHash,
+                (bool IsValid, IReadOnlyList<ICommittedActionEvaluation> EvaluatedActions)>
             _blockValidationCache;
 
         private Block? _lockedValue;
@@ -191,7 +193,7 @@ private Context(
             _validatorSet = validators;
             _cancellationTokenSource = new CancellationTokenSource();
             _blockValidationCache =
-                new LRUCache<BlockHash, (bool, IReadOnlyList<IActionEvaluation>)>(
+                new LRUCache<BlockHash, (bool, IReadOnlyList<ICommittedActionEvaluation>)>(
                     cacheSize, Math.Max(cacheSize / 64, 8));
 
             _contextTimeoutOption = contextTimeoutOptions ?? new ContextTimeoutOption();
@@ -454,7 +456,8 @@ private void PublishMessage(ConsensusMsg message)
         /// </param>
         /// <returns><see langword="true"/> if block is valid, otherwise <see langword="false"/>.
         /// </returns>
-        private bool IsValid(Block block, out IReadOnlyList<IActionEvaluation> evaluatedActions)
+        private bool IsValid(
+            Block block, out IReadOnlyList<ICommittedActionEvaluation> evaluatedActions)
         {
             if (_blockValidationCache.TryGet(block.Hash, out var cached))
             {
@@ -466,11 +469,11 @@ private bool IsValid(Block block, out IReadOnlyList<IActionEvaluation> evaluated
                 // Need to get txs from store, lock?
                 // TODO: Remove ChainId, enhancing lock management.
                 _blockChain._rwlock.EnterUpgradeableReadLock();
-                IReadOnlyList<IActionEvaluation> actionEvaluations;
+                IReadOnlyList<ICommittedActionEvaluation> actionEvaluations;
 
                 if (block.Index != Height)
                 {
-                    evaluatedActions = ImmutableArray<IActionEvaluation>.Empty;
+                    evaluatedActions = ImmutableArray<ICommittedActionEvaluation>.Empty;
                     _blockValidationCache.AddReplace(block.Hash, (false, evaluatedActions));
                     return false;
                 }
@@ -515,7 +518,7 @@ e is InvalidTxException ||
                         "Block #{Index} {Hash} is invalid",
                         block.Index,
                         block.Hash);
-                    evaluatedActions = ImmutableArray<IActionEvaluation>.Empty;
+                    evaluatedActions = ImmutableArray<ICommittedActionEvaluation>.Empty;
                     _blockValidationCache.AddReplace(block.Hash, (false, evaluatedActions));
                     return false;
                 }
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
index f9aa4c2a87c..ef4f31e9d37 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
@@ -610,7 +610,8 @@ public void CachedActionEvaluationWrittenOnAppend()
             _blockChain.StageTransaction(txA0);
             _blockChain.StageTransaction(txA1);
             Block block = _blockChain.ProposeBlock(miner);
-            IReadOnlyList<IActionEvaluation> actionEvaluations = _blockChain.EvaluateBlock(block);
+            (IReadOnlyList<ICommittedActionEvaluation> actionEvaluations, _) =
+                _blockChain.ToCommittedEvaluation(block, _blockChain.EvaluateBlock(block));
             Assert.Equal(0L, _blockChain.Tip.Index);
             _blockChain.Append(
                 block,
diff --git a/Libplanet/Blockchain/BlockChain.Evaluate.cs b/Libplanet/Blockchain/BlockChain.Evaluate.cs
index 5efc9112965..e8bc389fc07 100644
--- a/Libplanet/Blockchain/BlockChain.Evaluate.cs
+++ b/Libplanet/Blockchain/BlockChain.Evaluate.cs
@@ -7,6 +7,7 @@
 using Bencodex.Types;
 using Libplanet.Action;
 using Libplanet.Action.Loader;
+using Libplanet.Action.State;
 using Libplanet.Common;
 using Libplanet.Crypto;
 using Libplanet.Store;
@@ -97,44 +98,27 @@ public static IReadOnlyList<IActionEvaluation> EvaluateGenesis(
         /// <seealso cref="EvaluateBlock"/>
         /// <seealso cref="ValidateBlockStateRootHash"/>
         public HashDigest<SHA256> DetermineBlockStateRootHash(
-            IPreEvaluationBlock block, out IReadOnlyList<IActionEvaluation> evaluations)
+            IPreEvaluationBlock block, out IReadOnlyList<ICommittedActionEvaluation> evaluations)
         {
             _rwlock.EnterWriteLock();
             try
             {
                 Stopwatch stopwatch = new Stopwatch();
                 stopwatch.Start();
-                evaluations = EvaluateBlock(block);
-                var totalDelta = evaluations.GetRawTotalDelta();
+                var rawEvaluations = EvaluateBlock(block);
+
                 _logger.Debug(
-                    "Took {DurationMs} ms to summarize the states delta with {KeyCount} key " +
-                    "changes made by block #{BlockIndex} pre-evaluation hash {PreEvaluationHash}",
+                    "Took {DurationMs} ms to evaluate block #{BlockIndex} " +
+                    "pre-evaluation hash {PreEvaluationHash} with {Count} action evaluations",
                     stopwatch.ElapsedMilliseconds,
-                    totalDelta.Count,
                     block.Index,
-                    block.PreEvaluationHash);
-
-                ITrie trie = GetAccountState(block.PreviousHash).Trie;
-                foreach (var kv in totalDelta)
-                {
-                    trie = trie.Set(kv.Key, kv.Value);
-                }
+                    block.PreEvaluationHash,
+                    rawEvaluations.Count);
 
-                trie = StateStore.Commit(trie);
-                HashDigest<SHA256> rootHash = trie.Hash;
-                _logger
-                    .ForContext("Tag", "Metric")
-                    .ForContext("Subtag", "StateUpdateDuration")
-                    .Information(
-                        "Took {DurationMs} ms to update the states with {KeyCount} key changes " +
-                        "and resulting in state root hash {StateRootHash} for " +
-                        "block #{BlockIndex} pre-evaluation hash {PreEvaluationHash}",
-                        stopwatch.ElapsedMilliseconds,
-                        totalDelta.Count,
-                        rootHash,
-                        block.Index,
-                        block.PreEvaluationHash);
+                (var committedEvaluations, var rootHash) =
+                    ToCommittedEvaluation(block, rawEvaluations);
 
+                evaluations = committedEvaluations;
                 return rootHash;
             }
             finally
@@ -183,5 +167,62 @@ internal Block EvaluateAndSign(
                 : throw new ArgumentException(
                     $"Given {nameof(preEvaluationBlock)} must have protocol version " +
                     $"2 or greater: {preEvaluationBlock.ProtocolVersion}");
+
+        internal (IReadOnlyList<ICommittedActionEvaluation>, HashDigest<SHA256>)
+            ToCommittedEvaluation(
+                IPreEvaluationBlock block,
+                IReadOnlyList<IActionEvaluation> evaluations)
+        {
+            Stopwatch stopwatch = new Stopwatch();
+            stopwatch.Start();
+
+            ITrie trie = GetAccountState(block.PreviousHash).Trie;
+            var committedEvaluations = new List<CommittedActionEvaluation>();
+
+            int setCount = 0;
+            foreach (var evaluation in evaluations)
+            {
+                ITrie nextTrie = trie;
+                foreach (var kv in evaluation.OutputState.Delta.ToRawDelta())
+                {
+                    nextTrie = nextTrie.Set(kv.Key, kv.Value);
+                    setCount++;
+                }
+
+                nextTrie = StateStore.Commit(nextTrie);
+                var committedEvaluation = new CommittedActionEvaluation(
+                    action: evaluation.Action,
+                    inputContext: new CommittedActionContext(
+                        signer: evaluation.InputContext.Signer,
+                        txId: evaluation.InputContext.TxId,
+                        miner: evaluation.InputContext.Miner,
+                        blockIndex: evaluation.InputContext.BlockIndex,
+                        blockProtocolVersion: evaluation.InputContext.BlockProtocolVersion,
+                        rehearsal: evaluation.InputContext.Rehearsal,
+                        previousState: trie.Hash,
+                        random: evaluation.InputContext.GetUnconsumedContext().Random,
+                        blockAction: evaluation.InputContext.BlockAction),
+                    outputState: nextTrie.Hash,
+                    exception: evaluation.Exception);
+                committedEvaluations.Add(committedEvaluation);
+
+                trie = nextTrie;
+            }
+
+            _logger
+                .ForContext("Tag", "Metric")
+                .ForContext("Subtag", "StateUpdateDuration")
+                .Information(
+                    "Took {DurationMs} ms to update the states with {Count} key changes " +
+                    "and resulting in state root hash {StateRootHash} for " +
+                    "block #{BlockIndex} pre-evaluation hash {PreEvaluationHash}",
+                    stopwatch.ElapsedMilliseconds,
+                    setCount,
+                    trie.Hash,
+                    block.Index,
+                    block.PreEvaluationHash);
+
+            return (committedEvaluations, trie.Hash);
+        }
     }
 }
diff --git a/Libplanet/Blockchain/BlockChain.Swap.cs b/Libplanet/Blockchain/BlockChain.Swap.cs
index 9008bebe9ad..b9330f1cb4b 100644
--- a/Libplanet/Blockchain/BlockChain.Swap.cs
+++ b/Libplanet/Blockchain/BlockChain.Swap.cs
@@ -5,10 +5,8 @@
 using System.Diagnostics;
 using System.Linq;
 using Libplanet.Action;
-using Libplanet.Action.State;
 using Libplanet.Blockchain.Renderers;
 using Libplanet.Store;
-using Libplanet.Store.Trie;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
 
@@ -175,9 +173,10 @@ internal void RenderFastForward(
                     Block block = Store.GetBlock(hash);
                     ImmutableList<IActionEvaluation> evaluations =
                         ActionEvaluator.Evaluate(block).ToImmutableList();
+                    (var committedEvaluations, _) = ToCommittedEvaluation(block, evaluations);
 
                     RenderActions(
-                        evaluations: evaluations,
+                        evaluations: committedEvaluations,
                         block: block);
                 }
 
@@ -200,9 +199,14 @@ internal void RenderFastForward(
         /// <see langword="null"/>, evaluate actions of the <paramref name="block"/> again.</param>
         /// <param name="block"><see cref="Block"/> to render actions.</param>
         internal void RenderActions(
-            IReadOnlyList<IActionEvaluation> evaluations,
+            IReadOnlyList<ICommittedActionEvaluation> evaluations,
             Block block)
         {
+            if (evaluations is null)
+            {
+                throw new NullReferenceException(nameof(evaluations));
+            }
+
             Stopwatch stopwatch = new Stopwatch();
             stopwatch.Start();
             _logger.Debug(
@@ -210,59 +214,26 @@ internal void RenderActions(
                 block.Index,
                 block.Hash);
 
-            if (evaluations is null)
-            {
-                evaluations = ActionEvaluator.Evaluate(block);
-            }
-
             long count = 0;
-            ITrie trie = GetAccountState(block.PreviousHash).Trie;
             foreach (var evaluation in evaluations)
             {
-                ITrie nextTrie = trie;
-                foreach (var kv in evaluation.OutputState.Delta.ToRawDelta())
-                {
-                    nextTrie = nextTrie.Set(kv.Key, kv.Value);
-                }
-
-                nextTrie = StateStore.Commit(nextTrie);
-
                 foreach (IActionRenderer renderer in ActionRenderers)
                 {
                     if (evaluation.Exception is null)
                     {
                         renderer.RenderAction(
                             evaluation.Action,
-                            new CommittedActionContext(
-                                signer: evaluation.InputContext.Signer,
-                                txId: evaluation.InputContext.TxId,
-                                miner: evaluation.InputContext.Miner,
-                                blockIndex: evaluation.InputContext.BlockIndex,
-                                blockProtocolVersion: evaluation.InputContext.BlockProtocolVersion,
-                                rehearsal: evaluation.InputContext.Rehearsal,
-                                previousState: trie.Hash,
-                                random: evaluation.InputContext.GetUnconsumedContext().Random,
-                                blockAction: evaluation.InputContext.BlockAction),
-                            nextTrie.Hash);
+                            evaluation.InputContext.Copy(),
+                            evaluation.OutputState);
                     }
                     else
                     {
                         renderer.RenderActionError(
                             evaluation.Action,
-                            new CommittedActionContext(
-                                signer: evaluation.InputContext.Signer,
-                                txId: evaluation.InputContext.TxId,
-                                miner: evaluation.InputContext.Miner,
-                                blockIndex: evaluation.InputContext.BlockIndex,
-                                blockProtocolVersion: evaluation.InputContext.BlockProtocolVersion,
-                                rehearsal: evaluation.InputContext.Rehearsal,
-                                previousState: trie.Hash,
-                                random: evaluation.InputContext.GetUnconsumedContext().Random,
-                                blockAction: evaluation.InputContext.BlockAction),
+                            evaluation.InputContext.Copy(),
                             evaluation.Exception);
                     }
 
-                    trie = nextTrie;
                     count++;
                 }
             }
diff --git a/Libplanet/Blockchain/BlockChain.TxExecution.cs b/Libplanet/Blockchain/BlockChain.TxExecution.cs
index c4d7f19bded..7f381cbc0a9 100644
--- a/Libplanet/Blockchain/BlockChain.TxExecution.cs
+++ b/Libplanet/Blockchain/BlockChain.TxExecution.cs
@@ -19,17 +19,17 @@ public partial class BlockChain
         /// <returns>The corresponding <see cref="TxExecution"/>s.</returns>
         internal IEnumerable<TxExecution> MakeTxExecutions(
             Block block,
-            IReadOnlyList<IActionEvaluation> evaluations
+            IReadOnlyList<ICommittedActionEvaluation> evaluations
         )
         {
-            List<(TxId?, List<IActionEvaluation>)> groupedEvals =
-                new List<(TxId?, List<IActionEvaluation>)>();
-            foreach (IActionEvaluation eval in evaluations)
+            List<(TxId?, List<ICommittedActionEvaluation>)> groupedEvals =
+                new List<(TxId?, List<ICommittedActionEvaluation>)>();
+            foreach (ICommittedActionEvaluation eval in evaluations)
             {
                 if (groupedEvals.Count == 0)
                 {
                     groupedEvals.Add(
-                        (eval.InputContext.TxId, new List<IActionEvaluation>() { eval }));
+                        (eval.InputContext.TxId, new List<ICommittedActionEvaluation>() { eval }));
                 }
                 else
                 {
@@ -40,7 +40,10 @@ IReadOnlyList<IActionEvaluation> evaluations
                     else
                     {
                         groupedEvals.Add(
-                            (eval.InputContext.TxId, new List<IActionEvaluation>() { eval }));
+                            (
+                                eval.InputContext.TxId,
+                                new List<ICommittedActionEvaluation>() { eval }
+                            ));
                     }
                 }
             }
@@ -52,17 +55,7 @@ IReadOnlyList<IActionEvaluation> evaluations
             {
                 if (group.Item1 is { } txId)
                 {
-                    ITrie nextTrie = trie;
-                    foreach (var eval in group.Item2)
-                    {
-                        foreach (var kv in eval.OutputState.Delta.ToRawDelta())
-                        {
-                            nextTrie = nextTrie.Set(kv.Key, kv.Value);
-                        }
-                    }
-
-                    nextTrie = StateStore.Commit(nextTrie);
-
+                    // If txId is not null, group has at least one element.
                     List<Exception?> exceptions = group.Item2
                         .Select(eval => eval.Exception)
                         .Select(exception => exception is { } e && e.InnerException is { } i
@@ -74,26 +67,11 @@ IReadOnlyList<IActionEvaluation> evaluations
                         block.Hash,
                         txId,
                         exceptions.Any(exception => exception is { }),
-                        trie.Hash,
-                        nextTrie.Hash,
+                        group.Item2.First().InputContext.PreviousState,
+                        group.Item2.Last().OutputState,
                         exceptions.ToList());
 
                     count++;
-                    trie = nextTrie;
-                }
-                else
-                {
-                    ITrie nextTrie = trie;
-                    foreach (var eval in group.Item2)
-                    {
-                        foreach (var kv in eval.OutputState.Delta.ToRawDelta())
-                        {
-                            nextTrie = nextTrie.Set(kv.Key, kv.Value);
-                        }
-                    }
-
-                    nextTrie = StateStore.Commit(nextTrie);
-                    trie = nextTrie;
                 }
             }
 
diff --git a/Libplanet/Blockchain/BlockChain.Validate.cs b/Libplanet/Blockchain/BlockChain.Validate.cs
index 4242a8f5a43..3e008b8ad71 100644
--- a/Libplanet/Blockchain/BlockChain.Validate.cs
+++ b/Libplanet/Blockchain/BlockChain.Validate.cs
@@ -318,7 +318,7 @@ internal void ValidateBlock(Block block)
         /// <seealso cref="EvaluateBlock"/>
         /// <seealso cref="DetermineBlockStateRootHash"/>
         internal void ValidateBlockStateRootHash(
-            Block block, out IReadOnlyList<IActionEvaluation> evaluations)
+            Block block, out IReadOnlyList<ICommittedActionEvaluation> evaluations)
         {
             var rootHash = DetermineBlockStateRootHash(block, out evaluations);
             if (!rootHash.Equals(block.StateRootHash))
diff --git a/Libplanet/Blockchain/BlockChain.cs b/Libplanet/Blockchain/BlockChain.cs
index 2b48c883a2a..76591f08835 100644
--- a/Libplanet/Blockchain/BlockChain.cs
+++ b/Libplanet/Blockchain/BlockChain.cs
@@ -964,7 +964,7 @@ internal void Append(
             Block block,
             BlockCommit blockCommit,
             bool render,
-            IReadOnlyList<IActionEvaluation> actionEvaluations = null
+            IReadOnlyList<ICommittedActionEvaluation> actionEvaluations = null
         )
         {
             if (Count == 0)

From fde8c9524151e1a5467f2edf2ec72f80fc852502 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 22 Sep 2023 17:24:04 +0900
Subject: [PATCH 37/72] Changelog

---
 CHANGES.md | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index aca7e306747..b6a029b6280 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -12,12 +12,6 @@ To be released.
 
  -  Added `IBlockChainStates.GetAccountState(HashDigest<SHA256>?)`
     interface method.  [[#3425]]
- -  Changed `IActionRenderer.RenderAction(IValue, IActionContext, IAccount)`
-    to `IActionRenderer.RenderAction(IValue, IActionRenderContext,
-    HashDigest<SHA256>)`.  [[#3427]]
- -  Changed `IActionRenderer.RenderActionError(IValue, IActionContext,
-    Exception)` to `IActionRenderer.RenderActionError(IValue,
-    IActionRenderContext, Exception)`.  [[#3427]]
  -  Removed `TxFailure.ExceptionMetadata` property.  [[#3428]]
  -  Removed `ISerializable` interface from `TxExecution`, `TxSuccess`,
     and `TxFailure`.  [[#3428]]
@@ -32,6 +26,12 @@ To be released.
     and added `TxResult.ExceptionNames` of type `List<string?>?`.  [[#3429]]
  -  (Libplanet.Explorer) Removed `TxResult.UpdatedStates` and
     `TxResult.UpdatedFungibleAssets`.  [[#3429]]
+ -  Changed `IActionRenderer.RenderAction(IValue, IActionContext, IAccount)`
+    to `IActionRenderer.RenderAction(IValue, ICommittedActionContext,
+    HashDigest<SHA256>)`.  [[#3431]]
+ -  Changed `IActionRenderer.RenderActionError(IValue, IActionContext,
+    Exception)` to `IActionRenderer.RenderActionError(IValue,
+    ICommittedActionContext, Exception)`.  [[#3431]]
 
 ### Backward-incompatible network protocol changes
 
@@ -40,7 +40,8 @@ To be released.
 ### Added APIs
 
  -  Added `AccountDiff` class.  [[#3424]]
- -  Added `IActionRenderContext` interface.  [[#3427]]
+ -  Added `ICommittedActionContext` interface.  [[#3431]]
+ -  Added `ICommittedActionEvaluation` interface.  [[#3431]]
 
 ### Behavioral changes
 
@@ -52,9 +53,9 @@ To be released.
 
 [#3424]: https://github.com/planetarium/libplanet/pull/3424
 [#3425]: https://github.com/planetarium/libplanet/pull/3425
-[#3427]: https://github.com/planetarium/libplanet/pull/3427
 [#3428]: https://github.com/planetarium/libplanet/pull/3428
 [#3429]: https://github.com/planetarium/libplanet/pull/3429
+[#3431]: https://github.com/planetarium/libplanet/pull/3431
 
 
 Version 3.3.1

From ec42f31dd8115c2489dbc734b4c3c34f0b416a2f Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Mon, 25 Sep 2023 16:39:17 +0900
Subject: [PATCH 38/72] Docs fix

---
 Libplanet.Store/IStore.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Libplanet.Store/IStore.cs b/Libplanet.Store/IStore.cs
index a2d39af0f22..bbcbde2fd7e 100644
--- a/Libplanet.Store/IStore.cs
+++ b/Libplanet.Store/IStore.cs
@@ -162,13 +162,13 @@ public interface IStore : IDisposable
         bool ContainsBlock(BlockHash blockHash);
 
         /// <summary>
-        /// Records the given <paramref name="txSuccess"/>.
+        /// Records the given <paramref name="txExecution"/>.
         /// </summary>
         /// <remarks>If there is already the record for the same <see cref="TxExecution.BlockHash"/>
         /// and <see cref="TxExecution.TxId"/>, the record is silently overwritten.</remarks>
         /// <param name="txExecution">The transaction execution summary to record.
         /// Must not be <see langword="null"/>.</param>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="txSuccess"/> is
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="txExecution"/> is
         /// <see langword="null"/>.</exception>
         /// <seealso cref="GetTxExecution(BlockHash, TxId)"/>
         void PutTxExecution(TxExecution txExecution);

From 8e4b006558fdac842074ff6ab4d581ac3656284f Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Mon, 25 Sep 2023 17:21:47 +0900
Subject: [PATCH 39/72] Libplanet 3.4.0

---
 CHANGES.md | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index b6a029b6280..be2aab315f7 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -4,9 +4,7 @@ Libplanet changelog
 Version 3.4.0
 -------------
 
-To be released.
-
-### Deprecated APIs
+Released on September 25, 2023.
 
 ### Backward-incompatible API changes
 
@@ -33,24 +31,12 @@ To be released.
     Exception)` to `IActionRenderer.RenderActionError(IValue,
     ICommittedActionContext, Exception)`.  [[#3431]]
 
-### Backward-incompatible network protocol changes
-
-### Backward-incompatible storage format changes
-
 ### Added APIs
 
  -  Added `AccountDiff` class.  [[#3424]]
  -  Added `ICommittedActionContext` interface.  [[#3431]]
  -  Added `ICommittedActionEvaluation` interface.  [[#3431]]
 
-### Behavioral changes
-
-### Bug fixes
-
-### Dependencies
-
-### CLI tools
-
 [#3424]: https://github.com/planetarium/libplanet/pull/3424
 [#3425]: https://github.com/planetarium/libplanet/pull/3425
 [#3428]: https://github.com/planetarium/libplanet/pull/3428

From 9e2337db7082191af93ca9d37398767723023f8a Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Mon, 25 Sep 2023 17:56:05 +0900
Subject: [PATCH 40/72] Prepare 3.5.0

---
 CHANGES.md                 | 24 ++++++++++++++++++++++++
 Libplanet/Libplanet.csproj |  2 +-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index be2aab315f7..5ae494ab71d 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,30 @@
 Libplanet changelog
 ===================
 
+Version 3.5.0
+-------------
+
+To be released.
+
+### Deprecated APIs
+
+### Backward-incompatible API changes
+
+### Backward-incompatible network protocol changes
+
+### Backward-incompatible storage format changes
+
+### Added APIs
+
+### Behavioral changes
+
+### Bug fixes
+
+### Dependencies
+
+### CLI tools
+
+
 Version 3.4.0
 -------------
 
diff --git a/Libplanet/Libplanet.csproj b/Libplanet/Libplanet.csproj
index d972c96dd32..6a510f89531 100644
--- a/Libplanet/Libplanet.csproj
+++ b/Libplanet/Libplanet.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <PackageId>Libplanet</PackageId>
     <Title>Libplanet</Title>
-    <VersionPrefix>3.4.0</VersionPrefix>
+    <VersionPrefix>3.5.0</VersionPrefix>
     <!-- Note: don't be confused by the word "prefix" here.  It's merely a
     version without suffix like "-dev.123".  See the following examples:
       Version: 1.2.3-dev.456

From 7bf2c388ba70a11d17572bfdd72946fdf4e0ec39 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Tue, 26 Sep 2023 18:04:10 +0900
Subject: [PATCH 41/72] Replace Random with Seed for IActionContext

---
 Libplanet.Action.Tests/ActionContextTest.cs   | 23 +++++++++++--------
 Libplanet.Action.Tests/Common/DumbAction.cs   |  2 +-
 Libplanet.Action.Tests/Common/RandomAction.cs |  2 +-
 Libplanet.Action/ActionContext.cs             | 13 ++++++-----
 Libplanet.Action/ActionEvaluator.cs           |  4 ++--
 Libplanet.Action/CommittedActionContext.cs    | 16 ++++++++-----
 Libplanet.Action/IActionContext.cs            | 19 +++++++++++----
 Libplanet.Action/ICommittedActionContext.cs   | 19 +++++++++++----
 .../ActionAnalyzerTest.cs                     |  2 +-
 Libplanet.Analyzers/ActionAnalyzer.cs         |  2 +-
 Libplanet.Tests/Action/ActionEvaluatorTest.cs |  8 +++----
 Libplanet.Tests/Blockchain/BlockChainTest.cs  |  2 +-
 Libplanet/Blockchain/BlockChain.Evaluate.cs   |  2 +-
 13 files changed, 71 insertions(+), 43 deletions(-)

diff --git a/Libplanet.Action.Tests/ActionContextTest.cs b/Libplanet.Action.Tests/ActionContextTest.cs
index 493d31c470a..939c5aa6bda 100644
--- a/Libplanet.Action.Tests/ActionContextTest.cs
+++ b/Libplanet.Action.Tests/ActionContextTest.cs
@@ -40,7 +40,7 @@ public void RandomShouldBeDeterministic()
                     randomSeed: seed,
                     gasLimit: 0
                 );
-                IRandom random = context.Random;
+                IRandom random = context.GetRandom();
                 Assert.Equal(expected, random.Next());
             }
         }
@@ -93,11 +93,14 @@ public void GuidShouldBeDeterministic()
                 ),
             };
 
+            var rand1 = context1.GetRandom();
+            var rand2 = context2.GetRandom();
+            var rand3 = context3.GetRandom();
             foreach (var (expected, diff) in testCases)
             {
-                Assert.Equal(expected, context1.Random.GenerateRandomGuid());
-                Assert.Equal(expected, context2.Random.GenerateRandomGuid());
-                Assert.Equal(diff, context3.Random.GenerateRandomGuid());
+                Assert.Equal(expected, rand1.GenerateRandomGuid());
+                Assert.Equal(expected, rand2.GenerateRandomGuid());
+                Assert.Equal(diff, rand3.GenerateRandomGuid());
             }
         }
 
@@ -116,7 +119,7 @@ public void GuidVersionAndVariant()
                     randomSeed: i,
                     gasLimit: 0
                 );
-                var guid = context.Random.GenerateRandomGuid().ToString();
+                var guid = context.GetRandom().GenerateRandomGuid().ToString();
 
                 Assert.Equal('4', guid[14]);
                 Assert.True(guid[19] >= '8' && guid[19] <= 'b');
@@ -137,17 +140,19 @@ public void GetUnconsumedContext()
                 gasLimit: 0);
 
             // Consume original's random state...
+            var originalRandom = original.GetRandom();
             int[] values =
             {
-                original.Random.Next(),
-                original.Random.Next(),
-                original.Random.Next(),
+                originalRandom.Next(),
+                originalRandom.Next(),
+                originalRandom.Next(),
             };
 
             IActionContext clone = original.GetUnconsumedContext();
+            var clonedRandom = clone.GetRandom();
             Assert.Equal(
                 values,
-                new[] { clone.Random.Next(), clone.Random.Next(), clone.Random.Next() }
+                new[] { clonedRandom.Next(), clonedRandom.Next(), clonedRandom.Next() }
             );
         }
     }
diff --git a/Libplanet.Action.Tests/Common/DumbAction.cs b/Libplanet.Action.Tests/Common/DumbAction.cs
index 066ce6fbc67..cb2f6a1c439 100644
--- a/Libplanet.Action.Tests/Common/DumbAction.cs
+++ b/Libplanet.Action.Tests/Common/DumbAction.cs
@@ -178,7 +178,7 @@ public IAccount Execute(IActionContext context)
             {
                 states = states.SetState(
                     RandomRecordsAddress,
-                    (Integer)context.Random.Next()
+                    (Integer)context.GetRandom().Next()
                 );
             }
 
diff --git a/Libplanet.Action.Tests/Common/RandomAction.cs b/Libplanet.Action.Tests/Common/RandomAction.cs
index e5f7439a92b..6c71de6b1e2 100644
--- a/Libplanet.Action.Tests/Common/RandomAction.cs
+++ b/Libplanet.Action.Tests/Common/RandomAction.cs
@@ -36,7 +36,7 @@ public IAccount Execute(IActionContext context)
                 return states.SetState(Address, Null.Value);
             }
 
-            return states.SetState(Address, (Integer)context.Random.Next());
+            return states.SetState(Address, (Integer)context.GetRandom().Next());
         }
     }
 }
diff --git a/Libplanet.Action/ActionContext.cs b/Libplanet.Action/ActionContext.cs
index 00ef9fe365b..9758bce9606 100644
--- a/Libplanet.Action/ActionContext.cs
+++ b/Libplanet.Action/ActionContext.cs
@@ -11,7 +11,6 @@ internal class ActionContext : IActionContext
     {
         public static readonly AsyncLocal<GasMeter> GetGasMeter = new AsyncLocal<GasMeter>();
 
-        private readonly int _randomSeed;
         private readonly long _gasLimit;
 
         public ActionContext(
@@ -32,8 +31,7 @@ public ActionContext(
             BlockProtocolVersion = blockProtocolVersion;
             Rehearsal = rehearsal;
             PreviousState = previousState;
-            Random = new Random(randomSeed);
-            _randomSeed = randomSeed;
+            RandomSeed = randomSeed;
             _gasLimit = gasLimit;
 
             GetGasMeter.Value = new GasMeter(_gasLimit);
@@ -60,8 +58,8 @@ public ActionContext(
         /// <inheritdoc cref="IActionContext.PreviousState"/>
         public IAccount PreviousState { get; }
 
-        /// <inheritdoc cref="IActionContext.Random"/>
-        public IRandom Random { get; }
+        /// <inheritdoc cref="IActionContext.RandomSeed"/>
+        public int RandomSeed { get; }
 
         /// <inheritdoc cref="IActionContext.BlockAction"/>
         public bool BlockAction => TxId is null;
@@ -79,10 +77,13 @@ public IActionContext GetUnconsumedContext() =>
                 BlockIndex,
                 BlockProtocolVersion,
                 PreviousState,
-                _randomSeed,
+                RandomSeed,
                 _gasLimit,
                 Rehearsal);
 
+        /// <inheritdoc cref="IActionContext.GetRandom"/>
+        public IRandom GetRandom() => new Random(RandomSeed);
+
         /// <summary>
         /// Returns the elapsed gas of the current action.
         /// </summary>
diff --git a/Libplanet.Action/ActionEvaluator.cs b/Libplanet.Action/ActionEvaluator.cs
index 094fda3a82a..5f643b7546f 100644
--- a/Libplanet.Action/ActionEvaluator.cs
+++ b/Libplanet.Action/ActionEvaluator.cs
@@ -188,7 +188,7 @@ IActionContext CreateActionContext(
 
             long gasLimit = tx?.GasLimit ?? long.MaxValue;
 
-            byte[] signature = tx?.Signature ?? new byte[0];
+            byte[] signature = tx?.Signature ?? Array.Empty<byte>();
             byte[] hashedSignature;
             using (var hasher = SHA1.Create())
             {
@@ -243,7 +243,7 @@ IActionContext CreateActionContext(IAccount newPrevState)
                     blockIndex: inputContext.BlockIndex,
                     blockProtocolVersion: inputContext.BlockProtocolVersion,
                     previousState: newPrevState,
-                    randomSeed: inputContext.Random.Seed,
+                    randomSeed: inputContext.RandomSeed,
                     gasLimit: inputContext.GasLimit());
             }
 
diff --git a/Libplanet.Action/CommittedActionContext.cs b/Libplanet.Action/CommittedActionContext.cs
index 70a6e23aa1f..b1f3337cd83 100644
--- a/Libplanet.Action/CommittedActionContext.cs
+++ b/Libplanet.Action/CommittedActionContext.cs
@@ -17,7 +17,7 @@ public CommittedActionContext(IActionContext context)
                 blockProtocolVersion: context.BlockProtocolVersion,
                 rehearsal: context.Rehearsal,
                 previousState: context.PreviousState.Trie.Hash,
-                random: context.Random,
+                randomSeed: context.RandomSeed,
                 blockAction: context.BlockAction)
         {
         }
@@ -30,7 +30,7 @@ public CommittedActionContext(
             int blockProtocolVersion,
             bool rehearsal,
             HashDigest<SHA256> previousState,
-            IRandom random,
+            int randomSeed,
             bool blockAction)
         {
             Signer = signer;
@@ -40,7 +40,7 @@ public CommittedActionContext(
             BlockProtocolVersion = blockProtocolVersion;
             Rehearsal = rehearsal;
             PreviousState = previousState;
-            Random = random;
+            RandomSeed = randomSeed;
             BlockAction = blockAction;
         }
 
@@ -72,13 +72,17 @@ public CommittedActionContext(
         [Pure]
         public HashDigest<SHA256> PreviousState { get; }
 
-        /// <inheritdoc cref="ICommittedActionContext.Random"/>
-        public IRandom Random { get; }
+        /// <inheritdoc cref="ICommittedActionContext.RandomSeed"/>
+        public int RandomSeed { get; }
 
         /// <inheritdoc cref="ICommittedActionContext.BlockAction"/>
         [Pure]
         public bool BlockAction { get; }
 
+        /// <inheritdoc cref="ICommittedActionContext.GetRandom"/>
+        [Pure]
+        public IRandom GetRandom() => new Random(RandomSeed);
+
         /// <inheritdoc cref="ICommittedActionContext.Copy"/>
         [Pure]
         public ICommittedActionContext Copy() =>
@@ -90,7 +94,7 @@ public ICommittedActionContext Copy() =>
                 BlockProtocolVersion,
                 Rehearsal,
                 PreviousState,
-                new Random(Random.Seed),
+                RandomSeed,
                 BlockAction);
     }
 }
diff --git a/Libplanet.Action/IActionContext.cs b/Libplanet.Action/IActionContext.cs
index f3996bc678c..fe1c03fb238 100644
--- a/Libplanet.Action/IActionContext.cs
+++ b/Libplanet.Action/IActionContext.cs
@@ -73,15 +73,15 @@ public interface IActionContext
         IAccount PreviousState { get; }
 
         /// <summary>
-        /// An initialized pseudorandom number generator.  Its seed (state)
-        /// is determined by a block and a transaction, which is
+        /// The random seed to use for pseudorandom number generator.  This value
+        /// is determined by various block properties, the signature of the transaction
+        /// containing the action to execute, and index of the action to execute, which is
         /// deterministic so that every node can replay the same action and
         /// then reproduce the same result, while neither a single block miner
         /// nor a single transaction signer can predict the result and cheat.
         /// </summary>
-        /// <returns>A random object that shares interface mostly equivalent
-        /// to <see cref="System.Random"/>.</returns>
-        IRandom Random { get; }
+        /// <seealso cref="GetRandom"/>
+        int RandomSeed { get; }
 
         /// <summary>
         /// Whether this action is executed as a block action.
@@ -109,6 +109,15 @@ public interface IActionContext
         [Pure]
         IActionContext GetUnconsumedContext();
 
+        /// <summary>
+        /// Returns a newly intialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
+        /// as its seed value.
+        /// </summary>
+        /// <returns>A newly intialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
+        /// as its seed value.</returns>
+        [Pure]
+        IRandom GetRandom();
+
         /// <summary>
         /// Returns the total gas used by the current action.
         /// </summary>
diff --git a/Libplanet.Action/ICommittedActionContext.cs b/Libplanet.Action/ICommittedActionContext.cs
index 3d24518ebc8..16e35bfc8b0 100644
--- a/Libplanet.Action/ICommittedActionContext.cs
+++ b/Libplanet.Action/ICommittedActionContext.cs
@@ -66,15 +66,15 @@ public interface ICommittedActionContext
         HashDigest<SHA256> PreviousState { get; }
 
         /// <summary>
-        /// An initialized pseudorandom number generator.  Its seed (state)
-        /// is determined by a block and a transaction, which is
+        /// The random seed to use for pseudorandom number generator.  This value
+        /// is determined by various block properties, the signature of the transaction
+        /// containing the action to execute, and index of the action to execute, which is
         /// deterministic so that every node can replay the same action and
         /// then reproduce the same result, while neither a single block miner
         /// nor a single transaction signer can predict the result and cheat.
         /// </summary>
-        /// <returns>A random object that shares interface mostly equivalent
-        /// to <see cref="System.Random"/>.</returns>
-        IRandom Random { get; }
+        /// <seealso cref="GetRandom"/>
+        int RandomSeed { get; }
 
         /// <summary>
         /// Whether this action is executed as a block action.
@@ -83,6 +83,15 @@ public interface ICommittedActionContext
         [Pure]
         bool BlockAction { get; }
 
+        /// <summary>
+        /// Returns a newly intialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
+        /// as its seed value.
+        /// </summary>
+        /// <returns>A newly intialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
+        /// as its seed value.</returns>
+        [Pure]
+        IRandom GetRandom();
+
         ICommittedActionContext Copy();
     }
 }
diff --git a/Libplanet.Analyzers.Tests/ActionAnalyzerTest.cs b/Libplanet.Analyzers.Tests/ActionAnalyzerTest.cs
index 734e08d059b..52eb38179d9 100644
--- a/Libplanet.Analyzers.Tests/ActionAnalyzerTest.cs
+++ b/Libplanet.Analyzers.Tests/ActionAnalyzerTest.cs
@@ -43,7 +43,7 @@ public static void Main() {}
             {
                 Id = "LAA1001",
                 Message = "The System.Random makes an IAction indeterministic; " +
-                    "use IActionContext.Random property instead.",
+                    "use IActionContext.GetRandom method instead.",
                 Severity = DiagnosticSeverity.Warning,
                 Locations = new[] { new DiagnosticResultLocation(12, 29) },
             };
diff --git a/Libplanet.Analyzers/ActionAnalyzer.cs b/Libplanet.Analyzers/ActionAnalyzer.cs
index 192a7578660..b3c83e09e4a 100644
--- a/Libplanet.Analyzers/ActionAnalyzer.cs
+++ b/Libplanet.Analyzers/ActionAnalyzer.cs
@@ -37,7 +37,7 @@ public class ActionAnalyzer : DiagnosticAnalyzer
                 title: "SystemRandomBreaksActionDeterminism",
                 messageFormat:
                     $"The {{0}} makes an {nameof(IAction)} indeterministic; use " +
-                    $"{nameof(IActionContext)}.{nameof(IActionContext.Random)} property instead.",
+                    $"{nameof(IActionContext)}.{nameof(IActionContext.GetRandom)} method instead.",
                 category: "Determinism",
                 defaultSeverity: DiagnosticSeverity.Warning,
                 isEnabledByDefault: true,
diff --git a/Libplanet.Tests/Action/ActionEvaluatorTest.cs b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
index 45eb15af07b..15f4e678d7a 100644
--- a/Libplanet.Tests/Action/ActionEvaluatorTest.cs
+++ b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
@@ -332,7 +332,7 @@ DumbAction MakeAction(Address address, char identifier, Address? transferTo = nu
                 Assert.Equal(expect.Signer, eval.InputContext.Signer);
                 Assert.Equal(GenesisProposer.ToAddress(), eval.InputContext.Miner);
                 Assert.Equal(block1.Index, eval.InputContext.BlockIndex);
-                randomValue = eval.InputContext.Random.Next();
+                randomValue = eval.InputContext.GetRandom().Next();
                 Assert.Equal(
                     (Integer)eval.OutputState.GetState(
                         DumbAction.RandomRecordsAddress),
@@ -456,7 +456,7 @@ DumbAction MakeAction(Address address, char identifier, Address? transferTo = nu
                 Assert.Equal(block2.Index, eval.InputContext.BlockIndex);
                 Assert.False(eval.InputContext.Rehearsal);
                 Assert.Null(eval.Exception);
-                randomValue = eval.InputContext.Random.Next();
+                randomValue = eval.InputContext.GetRandom().Next();
                 Assert.Equal(
                     eval.OutputState.GetState(
                         DumbAction.RandomRecordsAddress),
@@ -564,7 +564,7 @@ public void EvaluateTx()
                 Assert.Equal(
                     (Integer)eval.OutputState.GetState(
                         DumbAction.RandomRecordsAddress),
-                    (Integer)eval.InputContext.Random.Next());
+                    (Integer)eval.InputContext.GetRandom().Next());
                 IActionEvaluation prevEval = i > 0 ? evaluations[i - 1] : null;
                 Assert.Equal(
                     prevEval is null
@@ -1295,7 +1295,7 @@ private void CheckRandomSeedInAction()
             {
                 IActionEvaluation eval = evalsA[i];
                 IActionContext context = eval.InputContext;
-                Assert.Equal(initialRandomSeed + i, context.Random.Seed);
+                Assert.Equal(initialRandomSeed + i, context.RandomSeed);
             }
         }
 
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.cs b/Libplanet.Tests/Blockchain/BlockChainTest.cs
index b05da227ad1..0b3abfb2688 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.cs
@@ -314,7 +314,7 @@ public void ActionRenderersHaveDistinctContexts()
                         ActionRenderer = (act, context, nextState) =>
                             // Consuming the random state through IRandom.Next() should not
                             // affect contexts passed to other action renderers.
-                            generatedRandomValueLogs.Add(context.Random.Next()),
+                            generatedRandomValueLogs.Add(context.GetRandom().Next()),
                     },
                     Log.Logger.ForContext("RendererIndex", i)
                 )
diff --git a/Libplanet/Blockchain/BlockChain.Evaluate.cs b/Libplanet/Blockchain/BlockChain.Evaluate.cs
index e8bc389fc07..627b2a70bbd 100644
--- a/Libplanet/Blockchain/BlockChain.Evaluate.cs
+++ b/Libplanet/Blockchain/BlockChain.Evaluate.cs
@@ -200,7 +200,7 @@ internal Block EvaluateAndSign(
                         blockProtocolVersion: evaluation.InputContext.BlockProtocolVersion,
                         rehearsal: evaluation.InputContext.Rehearsal,
                         previousState: trie.Hash,
-                        random: evaluation.InputContext.GetUnconsumedContext().Random,
+                        randomSeed: evaluation.InputContext.RandomSeed,
                         blockAction: evaluation.InputContext.BlockAction),
                     outputState: nextTrie.Hash,
                     exception: evaluation.Exception);

From 1e1e0e68367e7006a93ab97437129933f338c9f5 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 27 Sep 2023 09:58:56 +0900
Subject: [PATCH 42/72] Remove unnecessary copy methods

---
 Libplanet.Action.Tests/ActionContextTest.cs | 30 ---------------------
 Libplanet.Action/ActionContext.cs           | 14 ----------
 Libplanet.Action/ActionEvaluator.cs         |  3 +--
 Libplanet.Action/CommittedActionContext.cs  | 14 ----------
 Libplanet.Action/IActionContext.cs          | 11 --------
 Libplanet.Action/ICommittedActionContext.cs |  2 --
 Libplanet/Blockchain/BlockChain.Swap.cs     |  4 +--
 7 files changed, 3 insertions(+), 75 deletions(-)

diff --git a/Libplanet.Action.Tests/ActionContextTest.cs b/Libplanet.Action.Tests/ActionContextTest.cs
index 939c5aa6bda..4044de57780 100644
--- a/Libplanet.Action.Tests/ActionContextTest.cs
+++ b/Libplanet.Action.Tests/ActionContextTest.cs
@@ -125,35 +125,5 @@ public void GuidVersionAndVariant()
                 Assert.True(guid[19] >= '8' && guid[19] <= 'b');
             }
         }
-
-        [Fact]
-        public void GetUnconsumedContext()
-        {
-            var original = new ActionContext(
-                signer: _address,
-                txid: _txid,
-                miner: _address,
-                blockIndex: 1,
-                blockProtocolVersion: Block.CurrentProtocolVersion,
-                previousState: new Account(MockAccountState.Empty),
-                randomSeed: _random.Next(),
-                gasLimit: 0);
-
-            // Consume original's random state...
-            var originalRandom = original.GetRandom();
-            int[] values =
-            {
-                originalRandom.Next(),
-                originalRandom.Next(),
-                originalRandom.Next(),
-            };
-
-            IActionContext clone = original.GetUnconsumedContext();
-            var clonedRandom = clone.GetRandom();
-            Assert.Equal(
-                values,
-                new[] { clonedRandom.Next(), clonedRandom.Next(), clonedRandom.Next() }
-            );
-        }
     }
 }
diff --git a/Libplanet.Action/ActionContext.cs b/Libplanet.Action/ActionContext.cs
index 9758bce9606..179c42bcf30 100644
--- a/Libplanet.Action/ActionContext.cs
+++ b/Libplanet.Action/ActionContext.cs
@@ -67,20 +67,6 @@ public ActionContext(
         /// <inheritdoc cref="IActionContext.UseGas(long)"/>
         public void UseGas(long gas) => GetGasMeter.Value?.UseGas(gas);
 
-        /// <inheritdoc cref="IActionContext.GetUnconsumedContext"/>
-        [Pure]
-        public IActionContext GetUnconsumedContext() =>
-            new ActionContext(
-                Signer,
-                TxId,
-                Miner,
-                BlockIndex,
-                BlockProtocolVersion,
-                PreviousState,
-                RandomSeed,
-                _gasLimit,
-                Rehearsal);
-
         /// <inheritdoc cref="IActionContext.GetRandom"/>
         public IRandom GetRandom() => new Random(RandomSeed);
 
diff --git a/Libplanet.Action/ActionEvaluator.cs b/Libplanet.Action/ActionEvaluator.cs
index 5f643b7546f..6754fe994dc 100644
--- a/Libplanet.Action/ActionEvaluator.cs
+++ b/Libplanet.Action/ActionEvaluator.cs
@@ -228,8 +228,7 @@ internal static (ActionEvaluation Evaluation, long NextGasLimit) EvaluateAction(
             IAction action,
             ILogger? logger = null)
         {
-            // Make a copy since ActionContext is stateful.
-            IActionContext inputContext = context.GetUnconsumedContext();
+            IActionContext inputContext = context;
             IAccount state = inputContext.PreviousState;
             Exception? exc = null;
             IFeeCollector feeCollector = new FeeCollector(context, tx?.MaxGasPrice);
diff --git a/Libplanet.Action/CommittedActionContext.cs b/Libplanet.Action/CommittedActionContext.cs
index b1f3337cd83..ea819d0790e 100644
--- a/Libplanet.Action/CommittedActionContext.cs
+++ b/Libplanet.Action/CommittedActionContext.cs
@@ -82,19 +82,5 @@ public CommittedActionContext(
         /// <inheritdoc cref="ICommittedActionContext.GetRandom"/>
         [Pure]
         public IRandom GetRandom() => new Random(RandomSeed);
-
-        /// <inheritdoc cref="ICommittedActionContext.Copy"/>
-        [Pure]
-        public ICommittedActionContext Copy() =>
-            new CommittedActionContext(
-                Signer,
-                TxId,
-                Miner,
-                BlockIndex,
-                BlockProtocolVersion,
-                Rehearsal,
-                PreviousState,
-                RandomSeed,
-                BlockAction);
     }
 }
diff --git a/Libplanet.Action/IActionContext.cs b/Libplanet.Action/IActionContext.cs
index fe1c03fb238..e6830d6192b 100644
--- a/Libplanet.Action/IActionContext.cs
+++ b/Libplanet.Action/IActionContext.cs
@@ -98,17 +98,6 @@ public interface IActionContext
         /// </param>
         void UseGas(long gas);
 
-        /// <summary>
-        /// Returns a clone of this context, except that its <see cref="Random"/> has the unconsumed
-        /// state (with the same seed).  The clone and its original are a distinct instance
-        /// each other, in other words, one's state transfer must not affect the other one
-        /// (i.e., consuming <see cref="Random"/> source should be local to a context instance).
-        /// </summary>
-        /// <returns>A clone instance, which is distinct from its original.  Its internal state
-        /// is entirely equivalent to the original's unconsumed initial state.</returns>
-        [Pure]
-        IActionContext GetUnconsumedContext();
-
         /// <summary>
         /// Returns a newly intialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
         /// as its seed value.
diff --git a/Libplanet.Action/ICommittedActionContext.cs b/Libplanet.Action/ICommittedActionContext.cs
index 16e35bfc8b0..be35b45bccd 100644
--- a/Libplanet.Action/ICommittedActionContext.cs
+++ b/Libplanet.Action/ICommittedActionContext.cs
@@ -91,7 +91,5 @@ public interface ICommittedActionContext
         /// as its seed value.</returns>
         [Pure]
         IRandom GetRandom();
-
-        ICommittedActionContext Copy();
     }
 }
diff --git a/Libplanet/Blockchain/BlockChain.Swap.cs b/Libplanet/Blockchain/BlockChain.Swap.cs
index b9330f1cb4b..4bb3e4f7145 100644
--- a/Libplanet/Blockchain/BlockChain.Swap.cs
+++ b/Libplanet/Blockchain/BlockChain.Swap.cs
@@ -223,14 +223,14 @@ internal void RenderActions(
                     {
                         renderer.RenderAction(
                             evaluation.Action,
-                            evaluation.InputContext.Copy(),
+                            evaluation.InputContext,
                             evaluation.OutputState);
                     }
                     else
                     {
                         renderer.RenderActionError(
                             evaluation.Action,
-                            evaluation.InputContext.Copy(),
+                            evaluation.InputContext,
                             evaluation.Exception);
                     }
 

From abf7c5492ca733759a8198b465c823d6c60ffee2 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 4 Oct 2023 01:21:13 +0900
Subject: [PATCH 43/72] Changelog

---
 CHANGES.md                                  | 7 +++++++
 Libplanet.Action/IActionContext.cs          | 4 ++--
 Libplanet.Action/ICommittedActionContext.cs | 4 ++--
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 5ae494ab71d..5ddf52404a9 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -10,6 +10,11 @@ To be released.
 
 ### Backward-incompatible API changes
 
+ -  Removed `IActionContext.Random` property.  Use `IActionContext.GetRandom()`
+    instead.  [[#3437]]
+ -  Added `IActionContext.RandomSeed` property.  [[#3437]]
+ -  Added `IActionContext.GetRandom()` method.  [[#3437]]
+
 ### Backward-incompatible network protocol changes
 
 ### Backward-incompatible storage format changes
@@ -24,6 +29,8 @@ To be released.
 
 ### CLI tools
 
+[#3437]: https://github.com/planetarium/libplanet/pull/3437
+
 
 Version 3.4.0
 -------------
diff --git a/Libplanet.Action/IActionContext.cs b/Libplanet.Action/IActionContext.cs
index e6830d6192b..793ea3c2d78 100644
--- a/Libplanet.Action/IActionContext.cs
+++ b/Libplanet.Action/IActionContext.cs
@@ -99,10 +99,10 @@ public interface IActionContext
         void UseGas(long gas);
 
         /// <summary>
-        /// Returns a newly intialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
+        /// Returns a newly initialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
         /// as its seed value.
         /// </summary>
-        /// <returns>A newly intialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
+        /// <returns>A newly initialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
         /// as its seed value.</returns>
         [Pure]
         IRandom GetRandom();
diff --git a/Libplanet.Action/ICommittedActionContext.cs b/Libplanet.Action/ICommittedActionContext.cs
index be35b45bccd..d4e2440c92d 100644
--- a/Libplanet.Action/ICommittedActionContext.cs
+++ b/Libplanet.Action/ICommittedActionContext.cs
@@ -84,10 +84,10 @@ public interface ICommittedActionContext
         bool BlockAction { get; }
 
         /// <summary>
-        /// Returns a newly intialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
+        /// Returns a newly initialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
         /// as its seed value.
         /// </summary>
-        /// <returns>A newly intialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
+        /// <returns>A newly initialized <see cref="IRandom"/> using <see cref="RandomSeed"/>
         /// as its seed value.</returns>
         [Pure]
         IRandom GetRandom();

From 250e4a8e03fcdb06cb573e4e3b48f0e1adec3685 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 4 Oct 2023 10:09:17 +0900
Subject: [PATCH 44/72] Changed Evaluate to require base state root hash

---
 Libplanet.Action/ActionEvaluator.cs           | 18 +++-----
 Libplanet.Action/IActionEvaluator.cs          |  8 +++-
 Libplanet.Tests/Action/ActionEvaluatorTest.cs | 42 +++++++++++--------
 Libplanet.Tests/Blockchain/BlockChainTest.cs  |  2 +-
 Libplanet/Blockchain/BlockChain.Evaluate.cs   |  4 +-
 Libplanet/Blockchain/BlockChain.Swap.cs       |  6 ++-
 6 files changed, 46 insertions(+), 34 deletions(-)

diff --git a/Libplanet.Action/ActionEvaluator.cs b/Libplanet.Action/ActionEvaluator.cs
index 6754fe994dc..f50f2121c9d 100644
--- a/Libplanet.Action/ActionEvaluator.cs
+++ b/Libplanet.Action/ActionEvaluator.cs
@@ -76,7 +76,9 @@ public static int GenerateRandomSeed(
 
         /// <inheritdoc cref="IActionEvaluator.Evaluate"/>
         [Pure]
-        public IReadOnlyList<IActionEvaluation> Evaluate(IPreEvaluationBlock block)
+        public IReadOnlyList<IActionEvaluation> Evaluate(
+            IPreEvaluationBlock block,
+            HashDigest<SHA256>? baseStateRootHash)
         {
             _logger.Information(
                 "Evaluating actions in the block #{BlockIndex} " +
@@ -88,7 +90,7 @@ public IReadOnlyList<IActionEvaluation> Evaluate(IPreEvaluationBlock block)
             stopwatch.Start();
             try
             {
-                IAccount previousState = PrepareInitialDelta(block);
+                IAccount previousState = PrepareInitialDelta(baseStateRootHash);
                 ImmutableList<ActionEvaluation> evaluations =
                     EvaluateBlock(block, previousState).ToImmutableList();
 
@@ -472,17 +474,9 @@ internal ActionEvaluation EvaluatePolicyBlockAction(
                 actions: new[] { policyBlockAction }.ToImmutableList()).Single();
         }
 
-        /// <summary>
-        /// Prepares the initial <see cref="IAccount"/> to for evaluating
-        /// <paramref name="block"/>.
-        /// </summary>
-        /// <param name="block">The <see cref="Block"/> to evaluate..</param>
-        /// <returns>The initial <see cref="IAccount"/> to be used
-        /// for evaluating <paramref name="block"/>.
-        /// </returns>
-        internal IAccount PrepareInitialDelta(IPreEvaluationBlock block)
+        internal IAccount PrepareInitialDelta(HashDigest<SHA256>? stateRootHash)
         {
-            return new Account(_blockChainStates.GetAccountState(block.PreviousHash));
+            return new Account(_blockChainStates.GetAccountState(stateRootHash));
         }
 
         [Pure]
diff --git a/Libplanet.Action/IActionEvaluator.cs b/Libplanet.Action/IActionEvaluator.cs
index d72d0e7864f..69be793465b 100644
--- a/Libplanet.Action/IActionEvaluator.cs
+++ b/Libplanet.Action/IActionEvaluator.cs
@@ -1,6 +1,8 @@
 using System.Collections.Generic;
 using System.Diagnostics.Contracts;
+using System.Security.Cryptography;
 using Libplanet.Action.Loader;
+using Libplanet.Common;
 using Libplanet.Types.Blocks;
 
 namespace Libplanet.Action
@@ -18,6 +20,8 @@ public interface IActionEvaluator
         /// The main entry point for evaluating a <see cref="IPreEvaluationBlock"/>.
         /// </summary>
         /// <param name="block">The block to evaluate.</param>
+        /// <param name="baseStateRootHash">The base state to use when evaluating
+        /// <paramref name="block"/>.</param>
         /// <returns> The result of evaluating every <see cref="IAction"/> related to
         /// <paramref name="block"/> as an <see cref="IReadOnlyList{T}"/> of
         /// <see cref="IActionEvaluation"/>s.</returns>
@@ -29,6 +33,8 @@ public interface IActionEvaluator
         /// the end.</para>
         /// </remarks>
         [Pure]
-        IReadOnlyList<IActionEvaluation> Evaluate(IPreEvaluationBlock block);
+        IReadOnlyList<IActionEvaluation> Evaluate(
+            IPreEvaluationBlock block,
+            HashDigest<SHA256>? baseStateRootHash);
     }
 }
diff --git a/Libplanet.Tests/Action/ActionEvaluatorTest.cs b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
index 15f4e678d7a..f55ff597bcf 100644
--- a/Libplanet.Tests/Action/ActionEvaluatorTest.cs
+++ b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
@@ -101,10 +101,10 @@ public void Idempotent()
 
             for (int i = 0; i < repeatCount; ++i)
             {
-                var actionEvaluations = actionEvaluator.Evaluate(noStateRootBlock);
+                var actionEvaluations = actionEvaluator.Evaluate(noStateRootBlock, null);
                 generatedRandomNumbers.Add(
                     (Integer)actionEvaluations[0].OutputState.GetState(txAddress));
-                actionEvaluations = actionEvaluator.Evaluate(stateRootBlock);
+                actionEvaluations = actionEvaluator.Evaluate(stateRootBlock, null);
                 generatedRandomNumbers.Add(
                     (Integer)actionEvaluations[0].OutputState.GetState(txAddress));
             }
@@ -146,7 +146,8 @@ public void Evaluate()
             Block block = chain.ProposeBlock(miner);
             chain.Append(block, CreateBlockCommit(block));
 
-            var evaluations = chain.ActionEvaluator.Evaluate(chain.Tip);
+            var evaluations = chain.ActionEvaluator.Evaluate(
+                chain.Tip, chain.Store.GetStateRootHash(chain.Tip.PreviousHash));
 
             Assert.False(evaluations[0].InputContext.BlockAction);
             Assert.Single(evaluations);
@@ -180,7 +181,8 @@ public void EvaluateWithException()
             chain.StageTransaction(tx);
             Block block = chain.ProposeBlock(new PrivateKey());
             chain.Append(block, CreateBlockCommit(block));
-            var evaluations = chain.ActionEvaluator.Evaluate(chain.Tip);
+            var evaluations = chain.ActionEvaluator.Evaluate(
+                chain.Tip, chain.Store.GetStateRootHash(chain.Tip.PreviousHash));
 
             Assert.False(evaluations[0].InputContext.BlockAction);
             Assert.Single(evaluations);
@@ -229,7 +231,7 @@ public void EvaluateWithCriticalException()
                     txHash: BlockContent.DeriveTxHash(txs),
                     lastCommit: null),
                 transactions: txs).Propose();
-            IAccount previousState = actionEvaluator.PrepareInitialDelta(block);
+            IAccount previousState = actionEvaluator.PrepareInitialDelta(genesis.StateRootHash);
 
             Assert.Throws<OutOfMemoryException>(
                 () => actionEvaluator.EvaluateTx(
@@ -237,7 +239,8 @@ public void EvaluateWithCriticalException()
                     tx: tx,
                     previousState: previousState).ToList());
             Assert.Throws<OutOfMemoryException>(
-                () => chain.ActionEvaluator.Evaluate(block).ToList());
+                () => chain.ActionEvaluator.Evaluate(
+                    block, chain.Store.GetStateRootHash(block.PreviousHash)).ToList());
         }
 
         [Fact]
@@ -309,7 +312,7 @@ DumbAction MakeAction(Address address, char identifier, Address? transferTo = nu
                 genesis,
                 GenesisProposer,
                 block1Txs);
-            IAccount previousState = actionEvaluator.PrepareInitialDelta(block1);
+            IAccount previousState = actionEvaluator.PrepareInitialDelta(genesis.StateRootHash);
             var evals = actionEvaluator.EvaluateBlock(
                 block1,
                 previousState).ToImmutableArray();
@@ -343,7 +346,7 @@ DumbAction MakeAction(Address address, char identifier, Address? transferTo = nu
                         .Select(x => x is Text t ? t.Value : null));
             }
 
-            previousState = actionEvaluator.PrepareInitialDelta(block1);
+            previousState = actionEvaluator.PrepareInitialDelta(genesis.StateRootHash);
             ActionEvaluation[] evals1 =
                 actionEvaluator.EvaluateBlock(block1, previousState).ToArray();
             IImmutableDictionary<Address, IValue> dirty1 = evals1.GetDirtyStates();
@@ -528,7 +531,7 @@ public void EvaluateTx()
 
             DumbAction.RehearsalRecords.Value =
                 ImmutableList<(Address, string)>.Empty;
-            IAccount previousState = actionEvaluator.PrepareInitialDelta(block);
+            IAccount previousState = actionEvaluator.PrepareInitialDelta(null);
             var evaluations = actionEvaluator.EvaluateTx(
                 blockHeader: block,
                 tx: tx,
@@ -594,7 +597,7 @@ prevEval is null
 
             DumbAction.RehearsalRecords.Value =
                 ImmutableList<(Address, string)>.Empty;
-            previousState = actionEvaluator.PrepareInitialDelta(block);
+            previousState = actionEvaluator.PrepareInitialDelta(null);
             IAccount delta = actionEvaluator.EvaluateTx(
                 blockHeader: block,
                 tx: tx,
@@ -637,7 +640,7 @@ public void EvaluateTxResultThrowingException()
                     txHash: BlockContent.DeriveTxHash(txs),
                     lastCommit: CreateBlockCommit(hash, 122, 0)),
                 transactions: txs).Propose();
-            IAccount previousState = actionEvaluator.PrepareInitialDelta(block);
+            IAccount previousState = actionEvaluator.PrepareInitialDelta(null);
             var nextState = actionEvaluator.EvaluateTx(
                 blockHeader: block,
                 tx: tx,
@@ -768,7 +771,7 @@ public void EvaluatePolicyBlockAction()
             var block = chain.ProposeBlock(
                 GenesisProposer, txs.ToImmutableList(), CreateBlockCommit(chain.Tip));
 
-            IAccount previousState = actionEvaluator.PrepareInitialDelta(genesis);
+            IAccount previousState = actionEvaluator.PrepareInitialDelta(null);
             var evaluation = actionEvaluator.EvaluatePolicyBlockAction(genesis, previousState);
 
             Assert.Equal(chain.Policy.BlockAction, evaluation.Action);
@@ -787,7 +790,7 @@ public void EvaluatePolicyBlockAction()
             Assert.True(evaluation.InputContext.BlockAction);
 
             chain.Append(block, CreateBlockCommit(block), render: true);
-            previousState = actionEvaluator.PrepareInitialDelta(block);
+            previousState = actionEvaluator.PrepareInitialDelta(genesis.StateRootHash);
             var txEvaluations = actionEvaluator.EvaluateBlock(
                 block,
                 previousState).ToList();
@@ -980,7 +983,8 @@ public void EvaluateActionAndCollectFee()
             var miner = new PrivateKey();
             Block block = chain.ProposeBlock(miner);
 
-            var evaluations = chain.ActionEvaluator.Evaluate(block);
+            var evaluations = chain.ActionEvaluator.Evaluate(
+                block, chain.Store.GetStateRootHash(block.PreviousHash));
 
             Assert.False(evaluations[0].InputContext.BlockAction);
             Assert.Single(evaluations);
@@ -1043,7 +1047,9 @@ public void EvaluateThrowingExceedGasLimit()
             var miner = new PrivateKey();
             Block block = chain.ProposeBlock(miner);
 
-            var evaluations = chain.ActionEvaluator.Evaluate(block);
+            var evaluations = chain.ActionEvaluator.Evaluate(
+                block,
+                chain.Store.GetStateRootHash(block.PreviousHash));
 
             Assert.False(evaluations[0].InputContext.BlockAction);
             Assert.Single(evaluations);
@@ -1110,7 +1116,8 @@ public void EvaluateThrowingInsufficientBalanceForGasFee()
             var miner = new PrivateKey();
             Block block = chain.ProposeBlock(miner);
 
-            var evaluations = chain.ActionEvaluator.Evaluate(block);
+            var evaluations = chain.ActionEvaluator.Evaluate(
+                block, chain.Store.GetStateRootHash(block.PreviousHash));
 
             Assert.False(evaluations[0].InputContext.BlockAction);
             Assert.Single(evaluations);
@@ -1171,7 +1178,8 @@ public void EvaluateMinusGasFee()
             var miner = new PrivateKey();
             Block block = chain.ProposeBlock(miner);
 
-            var evaluations = chain.ActionEvaluator.Evaluate(block);
+            var evaluations = chain.ActionEvaluator.Evaluate(
+                block, chain.Store.GetStateRootHash(block.PreviousHash));
 
             Assert.False(evaluations[0].InputContext.BlockAction);
             Assert.Single(evaluations);
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.cs b/Libplanet.Tests/Blockchain/BlockChainTest.cs
index 0b3abfb2688..54c87d71390 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.cs
@@ -1707,7 +1707,7 @@ void BuildIndex(Guid id, Block block)
 
             // Build a store with incomplete states
             Block b = chain.Genesis;
-            IAccount previousState = actionEvaluator.PrepareInitialDelta(b);
+            IAccount previousState = actionEvaluator.PrepareInitialDelta(null);
             ActionEvaluation[] evals =
                 actionEvaluator.EvaluateBlock(b, previousState).ToArray();
             IImmutableDictionary<Address, IValue> dirty = evals.GetDirtyStates();
diff --git a/Libplanet/Blockchain/BlockChain.Evaluate.cs b/Libplanet/Blockchain/BlockChain.Evaluate.cs
index 627b2a70bbd..648e490b7f5 100644
--- a/Libplanet/Blockchain/BlockChain.Evaluate.cs
+++ b/Libplanet/Blockchain/BlockChain.Evaluate.cs
@@ -72,7 +72,7 @@ public static IReadOnlyList<IActionEvaluation> EvaluateGenesis(
                     nameof(preEvaluationBlock));
             }
 
-            return actionEvaluator.Evaluate(preEvaluationBlock);
+            return actionEvaluator.Evaluate(preEvaluationBlock, null);
         }
 
         /// <summary>
@@ -138,7 +138,7 @@ public HashDigest<SHA256> DetermineBlockStateRootHash(
         /// <seealso cref="ValidateBlockStateRootHash"/>
         [Pure]
         public IReadOnlyList<IActionEvaluation> EvaluateBlock(IPreEvaluationBlock block) =>
-            ActionEvaluator.Evaluate(block);
+            ActionEvaluator.Evaluate(block, Store.GetStateRootHash(block.PreviousHash));
 
         /// <summary>
         /// Evaluates all actions in the <see cref="PreEvaluationBlock.Transactions"/> and
diff --git a/Libplanet/Blockchain/BlockChain.Swap.cs b/Libplanet/Blockchain/BlockChain.Swap.cs
index 4bb3e4f7145..e6bf06c0866 100644
--- a/Libplanet/Blockchain/BlockChain.Swap.cs
+++ b/Libplanet/Blockchain/BlockChain.Swap.cs
@@ -4,8 +4,10 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using System.Security.Cryptography;
 using Libplanet.Action;
 using Libplanet.Blockchain.Renderers;
+using Libplanet.Common;
 using Libplanet.Store;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
@@ -171,8 +173,10 @@ internal void RenderFastForward(
                 foreach (BlockHash hash in fastForwardPath)
                 {
                     Block block = Store.GetBlock(hash);
+                    HashDigest<SHA256>? baseStateRootHash =
+                        Store.GetStateRootHash(block.PreviousHash);
                     ImmutableList<IActionEvaluation> evaluations =
-                        ActionEvaluator.Evaluate(block).ToImmutableList();
+                        ActionEvaluator.Evaluate(block, baseStateRootHash).ToImmutableList();
                     (var committedEvaluations, _) = ToCommittedEvaluation(block, evaluations);
 
                     RenderActions(

From 3e390e89dc614b57de77d1470d1f94ccc3786631 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 4 Oct 2023 12:59:56 +0900
Subject: [PATCH 45/72] Changelog

---
 CHANGES.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 5ddf52404a9..5471cc20407 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -14,6 +14,9 @@ To be released.
     instead.  [[#3437]]
  -  Added `IActionContext.RandomSeed` property.  [[#3437]]
  -  Added `IActionContext.GetRandom()` method.  [[#3437]]
+ -  Changed `IActionEvaluator.Evaluate(IPreEvaluationBlock)` to
+    `IActionEvaluator.Evaluate(IPreEvaluationBlock, HashDigest<SHA256>)`.
+    [[#3438]]
 
 ### Backward-incompatible network protocol changes
 
@@ -30,6 +33,7 @@ To be released.
 ### CLI tools
 
 [#3437]: https://github.com/planetarium/libplanet/pull/3437
+[#3438]: https://github.com/planetarium/libplanet/pull/3438
 
 
 Version 3.4.0

From 65ac4b33dbca621fadb77515a233cfe2a24a4b39 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 4 Oct 2023 13:59:32 +0900
Subject: [PATCH 46/72] Remove IBlockChainStates dependency; replaced with
 IStateStore

---
 Libplanet.Action/ActionEvaluator.cs           | 11 +++---
 Libplanet.Benchmarks/AppendBlock.cs           |  2 +-
 Libplanet.Benchmarks/BlockChain.cs            |  2 +-
 Libplanet.Benchmarks/ProposeBlock.cs          |  2 +-
 Libplanet.Explorer.Executable/Program.cs      |  2 +-
 .../GeneratedBlockChainFixture.cs             |  2 +-
 .../Commands/BlockCommand.cs                  |  3 +-
 .../Consensus/ConsensusReactorTest.cs         |  2 +-
 Libplanet.Net.Tests/SwarmTest.Broadcast.cs    |  2 +-
 .../RocksDBStoreTest.cs                       |  2 +-
 Libplanet.Tests/Action/ActionEvaluatorTest.cs | 16 ++++-----
 .../Blockchain/BlockChainTest.Append.cs       | 12 +++----
 .../Blockchain/BlockChainTest.ProposeBlock.cs |  8 ++---
 .../BlockChainTest.ValidateNextBlock.cs       |  4 +--
 Libplanet.Tests/Blockchain/BlockChainTest.cs  | 35 +++++++++----------
 .../Blockchain/Policies/BlockPolicyTest.cs    |  2 +-
 .../Blockchain/Policies/StagePolicyTest.cs    |  2 +-
 .../Blocks/PreEvaluationBlockTest.cs          |  4 +--
 Libplanet.Tests/Fixtures/IntegerSet.cs        |  2 +-
 Libplanet.Tests/Store/StoreFixture.cs         |  2 +-
 Libplanet.Tests/Store/StoreTest.cs            |  2 +-
 Libplanet.Tests/TestUtils.cs                  |  2 +-
 22 files changed, 59 insertions(+), 62 deletions(-)

diff --git a/Libplanet.Action/ActionEvaluator.cs b/Libplanet.Action/ActionEvaluator.cs
index f50f2121c9d..0a8a56beb1e 100644
--- a/Libplanet.Action/ActionEvaluator.cs
+++ b/Libplanet.Action/ActionEvaluator.cs
@@ -11,6 +11,7 @@
 using Libplanet.Action.State;
 using Libplanet.Common;
 using Libplanet.Crypto;
+using Libplanet.Store;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
 using Serilog;
@@ -24,7 +25,7 @@ public class ActionEvaluator : IActionEvaluator
     {
         private readonly ILogger _logger;
         private readonly PolicyBlockActionGetter _policyBlockActionGetter;
-        private readonly IBlockChainStates _blockChainStates;
+        private readonly IStateStore _stateStore;
         private readonly IActionLoader _actionLoader;
 
         /// <summary>
@@ -32,19 +33,19 @@ public class ActionEvaluator : IActionEvaluator
         /// </summary>
         /// <param name="policyBlockActionGetter">A delegator to get policy block action to evaluate
         /// at the end for each <see cref="IPreEvaluationBlock"/> that gets evaluated.</param>
-        /// <param name="blockChainStates">The <see cref="IBlockChainStates"/> to use to retrieve
+        /// <param name="stateStore">The <see cref="IBlockChainStates"/> to use to retrieve
         /// the states for a provided <see cref="Address"/>.</param>
         /// <param name="actionTypeLoader"> A <see cref="IActionLoader"/> implementation using
         /// action type lookup.</param>
         public ActionEvaluator(
             PolicyBlockActionGetter policyBlockActionGetter,
-            IBlockChainStates blockChainStates,
+            IStateStore stateStore,
             IActionLoader actionTypeLoader)
         {
             _logger = Log.ForContext<ActionEvaluator>()
                 .ForContext("Source", nameof(ActionEvaluator));
             _policyBlockActionGetter = policyBlockActionGetter;
-            _blockChainStates = blockChainStates;
+            _stateStore = stateStore;
             _actionLoader = actionTypeLoader;
         }
 
@@ -476,7 +477,7 @@ internal ActionEvaluation EvaluatePolicyBlockAction(
 
         internal IAccount PrepareInitialDelta(HashDigest<SHA256>? stateRootHash)
         {
-            return new Account(_blockChainStates.GetAccountState(stateRootHash));
+            return new Account(new AccountState(_stateStore.GetStateRoot(stateRootHash)));
         }
 
         [Pure]
diff --git a/Libplanet.Benchmarks/AppendBlock.cs b/Libplanet.Benchmarks/AppendBlock.cs
index e3ceddc40b8..d028c3f67ff 100644
--- a/Libplanet.Benchmarks/AppendBlock.cs
+++ b/Libplanet.Benchmarks/AppendBlock.cs
@@ -30,7 +30,7 @@ public AppendBlock()
                 fx.GenesisBlock,
                 new ActionEvaluator(
                     policyBlockActionGetter: _ => null,
-                    blockChainStates: new BlockChainStates(fx.Store, fx.StateStore),
+                    stateStore: fx.StateStore,
                     actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
             _privateKey = new PrivateKey();
         }
diff --git a/Libplanet.Benchmarks/BlockChain.cs b/Libplanet.Benchmarks/BlockChain.cs
index 0de92be08c2..7f78615a258 100644
--- a/Libplanet.Benchmarks/BlockChain.cs
+++ b/Libplanet.Benchmarks/BlockChain.cs
@@ -36,7 +36,7 @@ public void SetupChain()
                 _fx.GenesisBlock,
                 new ActionEvaluator(
                     policyBlockActionGetter: _ => null,
-                    blockChainStates: new BlockChainStates(_fx.Store, _fx.StateStore),
+                    stateStore: _fx.StateStore,
                     actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
             var key = new PrivateKey();
             for (var i = 0; i < 500; i++)
diff --git a/Libplanet.Benchmarks/ProposeBlock.cs b/Libplanet.Benchmarks/ProposeBlock.cs
index 9522527b9f4..ab29b8214c2 100644
--- a/Libplanet.Benchmarks/ProposeBlock.cs
+++ b/Libplanet.Benchmarks/ProposeBlock.cs
@@ -29,7 +29,7 @@ public ProposeBlock()
                 fx.GenesisBlock,
                 new ActionEvaluator(
                     policyBlockActionGetter: _ => null,
-                    blockChainStates: new BlockChainStates(fx.Store, fx.StateStore),
+                    stateStore: fx.StateStore,
                     actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
             _privateKey = new PrivateKey();
         }
diff --git a/Libplanet.Explorer.Executable/Program.cs b/Libplanet.Explorer.Executable/Program.cs
index dbc4aa3c5bf..45e7367bfb8 100644
--- a/Libplanet.Explorer.Executable/Program.cs
+++ b/Libplanet.Explorer.Executable/Program.cs
@@ -227,7 +227,7 @@ If omitted (default) explorer only the local blockchain store.")]
                         blockChainStates,
                         new ActionEvaluator(
                             _ => policy.BlockAction,
-                            blockChainStates,
+                            stateStore,
                             new SingleActionLoader(typeof(NullAction))));
                 Startup.PreloadedSingleton = false;
                 Startup.BlockChainSingleton = blockChain;
diff --git a/Libplanet.Explorer.Tests/GeneratedBlockChainFixture.cs b/Libplanet.Explorer.Tests/GeneratedBlockChainFixture.cs
index efb64174f74..8f35c9797cd 100644
--- a/Libplanet.Explorer.Tests/GeneratedBlockChainFixture.cs
+++ b/Libplanet.Explorer.Tests/GeneratedBlockChainFixture.cs
@@ -85,7 +85,7 @@ public GeneratedBlockChainFixture(
         IStore store = new MemoryStore();
         var actionEvaluator = new ActionEvaluator(
             _ => policy.BlockAction,
-            new BlockChainStates(store, stateStore),
+            stateStore,
             TypedActionLoader.Create(typeof(SimpleAction).Assembly, typeof(SimpleAction)));
         Block genesisBlock = BlockChain.ProposeGenesisBlock(
             actionEvaluator,
diff --git a/Libplanet.Extensions.Cocona/Commands/BlockCommand.cs b/Libplanet.Extensions.Cocona/Commands/BlockCommand.cs
index 6a42f1fff81..882c869fb6e 100644
--- a/Libplanet.Extensions.Cocona/Commands/BlockCommand.cs
+++ b/Libplanet.Extensions.Cocona/Commands/BlockCommand.cs
@@ -157,8 +157,7 @@ public void GenerateGenesis(
         var blockAction = blockPolicyParams.GetBlockAction();
         var actionEvaluator = new ActionEvaluator(
             _ => blockAction,
-            new BlockChainStates(
-                new MemoryStore(), new TrieStateStore(new DefaultKeyValueStore(null))),
+            new TrieStateStore(new DefaultKeyValueStore(null)),
             new SingleActionLoader(typeof(NullAction)));
         Block genesis = BlockChain.ProposeGenesisBlock(
             actionEvaluator, privateKey: key, transactions: txs);
diff --git a/Libplanet.Net.Tests/Consensus/ConsensusReactorTest.cs b/Libplanet.Net.Tests/Consensus/ConsensusReactorTest.cs
index ed870e36fb8..4b4318f2338 100644
--- a/Libplanet.Net.Tests/Consensus/ConsensusReactorTest.cs
+++ b/Libplanet.Net.Tests/Consensus/ConsensusReactorTest.cs
@@ -67,7 +67,7 @@ public async void StartAsync()
                     fx.GenesisBlock,
                     new ActionEvaluator(
                         policyBlockActionGetter: _ => TestUtils.Policy.BlockAction,
-                        blockChainStates: new BlockChainStates(stores[i], stateStore),
+                        stateStore: stateStore,
                         actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
             }
 
diff --git a/Libplanet.Net.Tests/SwarmTest.Broadcast.cs b/Libplanet.Net.Tests/SwarmTest.Broadcast.cs
index 0cb4a03d958..e866975e125 100644
--- a/Libplanet.Net.Tests/SwarmTest.Broadcast.cs
+++ b/Libplanet.Net.Tests/SwarmTest.Broadcast.cs
@@ -465,7 +465,7 @@ public async Task BroadcastTxAsyncMany()
                     fxs[i].GenesisBlock,
                     new ActionEvaluator(
                         policyBlockActionGetter: _ => policy.BlockAction,
-                        blockChainStates: new BlockChainStates(fxs[i].Store, fxs[i].StateStore),
+                        stateStore: fxs[i].StateStore,
                         actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
                 swarms[i] = await CreateSwarm(blockChains[i]).ConfigureAwait(false);
             }
diff --git a/Libplanet.RocksDBStore.Tests/RocksDBStoreTest.cs b/Libplanet.RocksDBStore.Tests/RocksDBStoreTest.cs
index 05c51dedff6..d11c0f37b6d 100644
--- a/Libplanet.RocksDBStore.Tests/RocksDBStoreTest.cs
+++ b/Libplanet.RocksDBStore.Tests/RocksDBStoreTest.cs
@@ -87,7 +87,7 @@ public void ReopenStoreAfterDispose()
                     Fx.GenesisBlock,
                     new ActionEvaluator(
                         policyBlockActionGetter: _ => null,
-                        blockChainStates: new BlockChainStates(store, stateStore),
+                        stateStore: stateStore,
                         actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
                 store.Dispose();
 
diff --git a/Libplanet.Tests/Action/ActionEvaluatorTest.cs b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
index f55ff597bcf..a4b1dec6a5f 100644
--- a/Libplanet.Tests/Action/ActionEvaluatorTest.cs
+++ b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
@@ -86,7 +86,7 @@ public void Idempotent()
                 transactions: txs).Propose();
             var actionEvaluator = new ActionEvaluator(
                 _ => null,
-                NullChainStates.Instance,
+                new TrieStateStore(new MemoryKeyValueStore()),
                 new SingleActionLoader(typeof(RandomAction)));
             Block stateRootBlock = noStateRootBlock.Sign(
                 GenesisProposer,
@@ -270,7 +270,7 @@ DumbAction MakeAction(Address address, char identifier, Address? transferTo = nu
             Block genesis = ProposeGenesisBlock(TestUtils.GenesisProposer);
             var actionEvaluator = new ActionEvaluator(
                 policyBlockActionGetter: _ => null,
-                blockChainStates: NullChainStates.Instance,
+                stateStore: new TrieStateStore(new MemoryKeyValueStore()),
                 actionTypeLoader: new SingleActionLoader(typeof(DumbAction)));
 
             Transaction[] block1Txs =
@@ -303,7 +303,7 @@ DumbAction MakeAction(Address address, char identifier, Address? transferTo = nu
                     timestamp: DateTimeOffset.MinValue.AddSeconds(7)),
             };
             foreach ((var tx, var i) in block1Txs.Zip(
-                Enumerable.Range(0, block1Txs.Count()), (x, y) => (x, y)))
+                Enumerable.Range(0, block1Txs.Length), (x, y) => (x, y)))
             {
                 _logger.Debug("{0}[{1}] = {2}", nameof(block1Txs), i, tx.Id);
             }
@@ -312,7 +312,7 @@ DumbAction MakeAction(Address address, char identifier, Address? transferTo = nu
                 genesis,
                 GenesisProposer,
                 block1Txs);
-            IAccount previousState = actionEvaluator.PrepareInitialDelta(genesis.StateRootHash);
+            IAccount previousState = actionEvaluator.PrepareInitialDelta(null);
             var evals = actionEvaluator.EvaluateBlock(
                 block1,
                 previousState).ToImmutableArray();
@@ -346,7 +346,7 @@ DumbAction MakeAction(Address address, char identifier, Address? transferTo = nu
                         .Select(x => x is Text t ? t.Value : null));
             }
 
-            previousState = actionEvaluator.PrepareInitialDelta(genesis.StateRootHash);
+            previousState = actionEvaluator.PrepareInitialDelta(null);
             ActionEvaluation[] evals1 =
                 actionEvaluator.EvaluateBlock(block1, previousState).ToArray();
             IImmutableDictionary<Address, IValue> dirty1 = evals1.GetDirtyStates();
@@ -415,7 +415,7 @@ DumbAction MakeAction(Address address, char identifier, Address? transferTo = nu
                     timestamp: DateTimeOffset.MinValue.AddSeconds(4)),
             };
             foreach ((var tx, var i) in block2Txs.Zip(
-                Enumerable.Range(0, block2Txs.Count()), (x, y) => (x, y)))
+                Enumerable.Range(0, block2Txs.Length), (x, y) => (x, y)))
             {
                 _logger.Debug("{0}[{1}] = {2}", nameof(block2Txs), i, tx.Id);
             }
@@ -526,7 +526,7 @@ public void EvaluateTx()
                 transactions: txs).Propose();
             var actionEvaluator = new ActionEvaluator(
                 policyBlockActionGetter: _ => null,
-                blockChainStates: NullChainStates.Instance,
+                stateStore: new TrieStateStore(new MemoryKeyValueStore()),
                 actionTypeLoader: new SingleActionLoader(typeof(DumbAction)));
 
             DumbAction.RehearsalRecords.Value =
@@ -628,7 +628,7 @@ public void EvaluateTxResultThrowingException()
             var hash = new BlockHash(GetRandomBytes(BlockHash.Size));
             var actionEvaluator = new ActionEvaluator(
                 policyBlockActionGetter: _ => null,
-                blockChainStates: NullChainStates.Instance,
+                stateStore: new TrieStateStore(new MemoryKeyValueStore()),
                 actionTypeLoader: new SingleActionLoader(typeof(ThrowException))
             );
             var block = new BlockContent(
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
index ef4f31e9d37..a43b61c48d3 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
@@ -314,7 +314,7 @@ public void AppendFailDueToInvalidTxCount()
                 miner,
                 manyTxs.ToImmutableList(),
                 TestUtils.CreateBlockCommit(_blockChain.Tip));
-            Assert.Equal(manyTxs.Count, block.Transactions.Count());
+            Assert.Equal(manyTxs.Count, block.Transactions.Count);
 
             var e = Assert.Throws<InvalidBlockTxCountException>(() =>
                 _blockChain.Append(block, TestUtils.CreateBlockCommit(block))
@@ -376,11 +376,11 @@ TxPolicyViolationException IsSignerValid(
                     fx.GenesisBlock,
                     new ActionEvaluator(
                         _ => policy.BlockAction,
-                        blockChainStates: new BlockChainStates(fx.Store, fx.StateStore),
+                        stateStore: fx.StateStore,
                         actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
 
-                var validTx = blockChain.MakeTransaction(validKey, new DumbAction[] { });
-                var invalidTx = blockChain.MakeTransaction(invalidKey, new DumbAction[] { });
+                var validTx = blockChain.MakeTransaction(validKey, Array.Empty<DumbAction>());
+                var invalidTx = blockChain.MakeTransaction(invalidKey, Array.Empty<DumbAction>());
 
                 var miner = new PrivateKey();
 
@@ -405,7 +405,6 @@ public void UnstageAfterAppendComplete()
             PrivateKey privateKey = new PrivateKey();
             (Address[] addresses, Transaction[] txs) =
                 MakeFixturesForAppendTests(privateKey, epoch: DateTimeOffset.UtcNow);
-            var genesis = _blockChain.Genesis;
             Assert.Empty(_blockChain.GetStagedTransactionIds());
 
             // Mining with empty staged.
@@ -452,7 +451,6 @@ public void DoesNotUnstageOnAppendForForkedChain()
             PrivateKey privateKey = new PrivateKey();
             (_, Transaction[] txs) =
                 MakeFixturesForAppendTests(privateKey, epoch: DateTimeOffset.UtcNow);
-            var genesis = _blockChain.Genesis;
             Assert.Empty(_blockChain.GetStagedTransactionIds());
             var workspace = _blockChain.Fork(_blockChain.Genesis.Hash);
             Assert.Empty(_blockChain.ListStagedTransactions());
@@ -508,7 +506,7 @@ public void AppendValidatesBlock()
                 blockChainStates,
                 new ActionEvaluator(
                     _ => policy.BlockAction,
-                    blockChainStates,
+                    _fx.StateStore,
                     new SingleActionLoader(typeof(DumbAction))));
             Assert.Throws<BlockPolicyViolationException>(
                 () => blockChain.Append(_fx.Block1, TestUtils.CreateBlockCommit(_fx.Block1)));
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.ProposeBlock.cs b/Libplanet.Tests/Blockchain/BlockChainTest.ProposeBlock.cs
index 4ebffe3706b..8c892a46f3f 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.ProposeBlock.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.ProposeBlock.cs
@@ -125,7 +125,7 @@ public void CanProposeInvalidGenesisBlock()
                 var policy = new BlockPolicy();
                 var actionEvaluator = new ActionEvaluator(
                     _ => policy.BlockAction,
-                    new BlockChainStates(fx.Store, fx.StateStore),
+                    fx.StateStore,
                     new SingleActionLoader(typeof(DumbAction)));
                 var genesis = BlockChain.ProposeGenesisBlock(
                     actionEvaluator,
@@ -165,7 +165,7 @@ public void CanProposeInvalidBlock()
                     fx.GenesisBlock,
                     new ActionEvaluator(
                         _ => policy.BlockAction,
-                        blockChainStates: new BlockChainStates(fx.Store, fx.StateStore),
+                        stateStore: fx.StateStore,
                         actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
                 var txs = new[]
                 {
@@ -347,7 +347,7 @@ TxPolicyViolationException IsSignerValid(
                     fx.GenesisBlock,
                     new ActionEvaluator(
                         _ => policy.BlockAction,
-                        blockChainStates: new BlockChainStates(fx.Store, fx.StateStore),
+                        stateStore: fx.StateStore,
                         actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
 
                 var validTx = blockChain.MakeTransaction(validKey, new DumbAction[] { });
@@ -459,7 +459,7 @@ public void ProposeBlockWithBlockAction()
                 blockChainStates,
                 new ActionEvaluator(
                     _ => policy.BlockAction,
-                    blockChainStates,
+                    _fx.StateStore,
                     new SingleActionLoader(typeof(DumbAction))));
 
             blockChain.MakeTransaction(privateKey2, new[] { new DumbAction(address2, "baz") });
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.ValidateNextBlock.cs b/Libplanet.Tests/Blockchain/BlockChainTest.ValidateNextBlock.cs
index 86a1f4dc992..ce70e70b331 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.ValidateNextBlock.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.ValidateNextBlock.cs
@@ -182,7 +182,7 @@ public void ValidateNextBlockInvalidStateRootHash()
             IStore store = new MemoryStore();
             var actionEvaluator = new ActionEvaluator(
                 _ => policy.BlockAction,
-                new BlockChainStates(store, stateStore),
+                stateStore,
                 new SingleActionLoader(typeof(DumbAction)));
             var genesisBlock = TestUtils.ProposeGenesisBlock(
                 actionEvaluator,
@@ -226,7 +226,7 @@ public void ValidateNextBlockInvalidStateRootHash()
                 blockChainStates,
                 new ActionEvaluator(
                     _ => policyWithBlockAction.BlockAction,
-                    blockChainStates,
+                    stateStore,
                     new SingleActionLoader(typeof(DumbAction))));
             Assert.Throws<InvalidBlockStateRootHashException>(() =>
                 chain2.Append(block1, TestUtils.CreateBlockCommit(block1)));
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.cs b/Libplanet.Tests/Blockchain/BlockChainTest.cs
index 54c87d71390..fa2355a049d 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.cs
@@ -65,7 +65,7 @@ public BlockChainTest(ITestOutputHelper output)
                 _fx.GenesisBlock,
                 new ActionEvaluator(
                     _ => _policy.BlockAction,
-                    blockChainStates: new BlockChainStates(_fx.Store, _fx.StateStore),
+                    stateStore: _fx.StateStore,
                     actionTypeLoader: new SingleActionLoader(typeof(DumbAction))),
                 renderers: new[] { new LoggedActionRenderer(_renderer, Log.Logger) }
             );
@@ -98,7 +98,6 @@ public void ValidatorSet()
                 "GenesisBlock is {Hash}, Transactions: {Txs}",
                 _blockChain.Genesis,
                 _blockChain.Genesis.Transactions);
-            var transactions = _blockChain.Genesis.Transactions.ToList();
             Assert.Equal(TestUtils.ValidatorSet.TotalCount, validatorSet.TotalCount);
         }
 
@@ -139,7 +138,7 @@ public void CanonicalId()
                 blockChainStates,
                 new ActionEvaluator(
                     _ => policy.BlockAction,
-                    blockChainStates,
+                    _fx.StateStore,
                     new SingleActionLoader(typeof(DumbAction))));
 
             Assert.Equal(chain1.Id, z.Id);
@@ -185,7 +184,7 @@ public void ProcessActions()
                 typeof(BaseAction).Assembly, typeof(BaseAction));
             var actionEvaluator = new ActionEvaluator(
                 _ => policy.BlockAction,
-                blockChainStates,
+                stateStore,
                 actionLoader);
             var nonce = 0;
             var txs = TestUtils.ValidatorSet.Validators
@@ -596,7 +595,7 @@ public void ForkShouldSkipExecuteAndRenderGenesis()
             {
                 var actionEvaluator = new ActionEvaluator(
                     _ => _policy.BlockAction,
-                    new BlockChainStates(store, stateStore),
+                    stateStore,
                     new SingleActionLoader(typeof(DumbAction)));
                 var genesis = ProposeGenesisBlock(
                     actionEvaluator,
@@ -627,7 +626,7 @@ public void ForkShouldSkipExecuteAndRenderGenesis()
                     genesis,
                     new ActionEvaluator(
                         _ => _policy.BlockAction,
-                        blockChainStates: new BlockChainStates(store, stateStore),
+                        stateStore: stateStore,
                         actionTypeLoader: new SingleActionLoader(typeof(DumbAction))),
                     renderers: new[] { renderer }
                 );
@@ -1017,7 +1016,7 @@ public void ReorgIsUnableToHeterogenousChain(bool render)
             {
                 var actionEvaluator = new ActionEvaluator(
                     _ => _policy.BlockAction,
-                    blockChainStates: new BlockChainStates(fx2.Store, fx2.StateStore),
+                    stateStore: fx2.StateStore,
                     actionTypeLoader: new SingleActionLoader(typeof(DumbAction)));
                 Block genesis2 = ProposeGenesisBlock(
                     actionEvaluator,
@@ -1074,7 +1073,7 @@ public void GetStatesOnCreatingBlockChain()
             var stateStore = new TrieStateStore(new MemoryKeyValueStore());
             var actionEvaluator = new ActionEvaluator(
                 _ => policy.BlockAction,
-                new BlockChainStates(store, stateStore),
+                stateStore,
                 new SingleActionLoader(typeof(DumbAction)));
             Block genesisWithTx = ProposeGenesisBlock(
                 actionEvaluator,
@@ -1117,7 +1116,7 @@ public void GetStateOnlyDrillsDownUntilRequestedAddressesAreFound()
                 blockChainStates,
                 new ActionEvaluator(
                     _ => policy.BlockAction,
-                    blockChainStates,
+                    _fx.StateStore,
                     new SingleActionLoader(typeof(DumbAction))));
 
             Block b = chain.Genesis;
@@ -1171,7 +1170,7 @@ public void GetStateReturnsEarlyForNonexistentAccount()
                 blockChainStates,
                 new ActionEvaluator(
                     _ => policy.BlockAction,
-                    blockChainStates,
+                    _fx.StateStore,
                     new SingleActionLoader(typeof(DumbAction))));
 
             Block b = chain.Genesis;
@@ -1246,7 +1245,7 @@ public void GetStateReturnsLatestStatesWhenMultipleAddresses()
                 blockChainStates,
                 new ActionEvaluator(
                     _ => policy.BlockAction,
-                    blockChainStates,
+                    _fx.StateStore,
                     new SingleActionLoader(typeof(DumbAction))));
 
             Assert.All(chain.GetStates(addresses), Assert.Null);
@@ -1318,7 +1317,7 @@ public void FindBranchPoint()
                     emptyFx.GenesisBlock,
                     new ActionEvaluator(
                         _ => _blockChain.Policy.BlockAction,
-                        blockChainStates: new BlockChainStates(emptyFx.Store, emptyFx.StateStore),
+                        stateStore: emptyFx.StateStore,
                         actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
                 var fork = BlockChain.Create(
                     _blockChain.Policy,
@@ -1328,7 +1327,7 @@ public void FindBranchPoint()
                     forkFx.GenesisBlock,
                     new ActionEvaluator(
                         _ => _blockChain.Policy.BlockAction,
-                        blockChainStates: new BlockChainStates(forkFx.Store, forkFx.StateStore),
+                        stateStore: forkFx.StateStore,
                         actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
                 fork.Append(b1, CreateBlockCommit(b1));
                 fork.Append(b2, CreateBlockCommit(b2));
@@ -1677,7 +1676,7 @@ internal static (Address, Address[] Addresses, BlockChain Chain)
             var chainStates = new BlockChainStates(store, stateStore);
             var actionEvaluator = new ActionEvaluator(
                 _ => blockPolicy.BlockAction,
-                blockChainStates: chainStates,
+                stateStore: stateStore,
                 actionTypeLoader: new SingleActionLoader(typeof(DumbAction)));
             Block genesisBlock = ProposeGenesisBlock(
                 actionEvaluator,
@@ -1901,7 +1900,7 @@ private void CreateWithGenesisBlock()
                 storeFixture.Store, storeFixture.StateStore);
             var actionEvaluator = new ActionEvaluator(
                 _ => policy.BlockAction,
-                blockChainStates,
+                storeFixture.StateStore,
                 new SingleActionLoader(typeof(DumbAction)));
             BlockChain blockChain = BlockChain.Create(
                 policy,
@@ -1941,7 +1940,7 @@ private void ConstructWithUnexpectedGenesisBlock()
             var blockChainStates = new BlockChainStates(store, stateStore);
             var actionEvaluator = new ActionEvaluator(
                 _ => policy.BlockAction,
-                blockChainStates,
+                stateStore,
                 new SingleActionLoader(typeof(DumbAction)));
             var genesisBlockA = BlockChain.ProposeGenesisBlock(actionEvaluator);
             var genesisBlockB = BlockChain.ProposeGenesisBlock(actionEvaluator);
@@ -2020,7 +2019,7 @@ private void CheckIfTxPolicyExceptionHasInnerException()
                 List.Empty);
             var actionEvaluator = new ActionEvaluator(
                 _ => policy.BlockAction,
-                new BlockChainStates(store, stateStore),
+                stateStore,
                 new SingleActionLoader(typeof(DumbAction)));
             var genesisWithTx = ProposeGenesisBlock(
                 actionEvaluator,
@@ -2083,7 +2082,7 @@ private void ValidateNextBlockCommitOnValidatorSetChange()
 
             var actionEvaluator = new ActionEvaluator(
                 _ => policy.BlockAction,
-                new BlockChainStates(storeFixture.Store, storeFixture.StateStore),
+                storeFixture.StateStore,
                 new SingleActionLoader(typeof(SetValidator)));
             Block genesis = BlockChain.ProposeGenesisBlock(
                 actionEvaluator,
diff --git a/Libplanet.Tests/Blockchain/Policies/BlockPolicyTest.cs b/Libplanet.Tests/Blockchain/Policies/BlockPolicyTest.cs
index 82fa140c973..947c0bf12d5 100644
--- a/Libplanet.Tests/Blockchain/Policies/BlockPolicyTest.cs
+++ b/Libplanet.Tests/Blockchain/Policies/BlockPolicyTest.cs
@@ -43,7 +43,7 @@ public BlockPolicyTest(ITestOutputHelper output)
                 _fx.GenesisBlock,
                 new ActionEvaluator(
                     _ => _policy.BlockAction,
-                    blockChainStates: new BlockChainStates(_fx.Store, _fx.StateStore),
+                    stateStore: _fx.StateStore,
                     actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
         }
 
diff --git a/Libplanet.Tests/Blockchain/Policies/StagePolicyTest.cs b/Libplanet.Tests/Blockchain/Policies/StagePolicyTest.cs
index 6ce4f8c7d47..421547e65f5 100644
--- a/Libplanet.Tests/Blockchain/Policies/StagePolicyTest.cs
+++ b/Libplanet.Tests/Blockchain/Policies/StagePolicyTest.cs
@@ -32,7 +32,7 @@ protected StagePolicyTest()
                 _fx.GenesisBlock,
                 new ActionEvaluator(
                     _ => _policy.BlockAction,
-                    blockChainStates: new BlockChainStates(_fx.Store, _fx.StateStore),
+                    stateStore: _fx.StateStore,
                     actionTypeLoader: new SingleActionLoader(typeof(DumbAction))));
             _key = new PrivateKey();
             _txs = Enumerable.Range(0, 5).Select(i =>
diff --git a/Libplanet.Tests/Blocks/PreEvaluationBlockTest.cs b/Libplanet.Tests/Blocks/PreEvaluationBlockTest.cs
index f4a3ab9d9a8..63dbef5ebdb 100644
--- a/Libplanet.Tests/Blocks/PreEvaluationBlockTest.cs
+++ b/Libplanet.Tests/Blocks/PreEvaluationBlockTest.cs
@@ -43,7 +43,7 @@ public void Evaluate()
             {
                 var actionEvaluator = new ActionEvaluator(
                     _ => policy.BlockAction,
-                    new BlockChainStates(fx.Store, fx.StateStore),
+                    fx.StateStore,
                     new SingleActionLoader(typeof(Arithmetic)));
                 Block genesis = preEvalGenesis.Sign(
                     _contents.GenesisKey,
@@ -106,7 +106,7 @@ public void DetermineStateRootHash()
             {
                 var actionEvaluator = new ActionEvaluator(
                     _ => policy.BlockAction,
-                    blockChainStates: new BlockChainStates(fx.Store, fx.StateStore),
+                    stateStore: fx.StateStore,
                     actionTypeLoader: new SingleActionLoader(typeof(Arithmetic)));
                 HashDigest<SHA256> genesisStateRootHash =
                     BlockChain.DetermineGenesisStateRootHash(
diff --git a/Libplanet.Tests/Fixtures/IntegerSet.cs b/Libplanet.Tests/Fixtures/IntegerSet.cs
index 60404bed62e..89bdc2592e1 100644
--- a/Libplanet.Tests/Fixtures/IntegerSet.cs
+++ b/Libplanet.Tests/Fixtures/IntegerSet.cs
@@ -76,7 +76,7 @@ public IntegerSet(
             StateStore = new TrieStateStore(KVStore);
             var actionEvaluator = new ActionEvaluator(
                 _ => policy.BlockAction,
-                new BlockChainStates(Store, StateStore),
+                StateStore,
                 new SingleActionLoader(typeof(Arithmetic)));
             Genesis = TestUtils.ProposeGenesisBlock(
                 actionEvaluator,
diff --git a/Libplanet.Tests/Store/StoreFixture.cs b/Libplanet.Tests/Store/StoreFixture.cs
index 5592cc2e9ab..ea5cfc1b51b 100644
--- a/Libplanet.Tests/Store/StoreFixture.cs
+++ b/Libplanet.Tests/Store/StoreFixture.cs
@@ -105,7 +105,7 @@ protected StoreFixture(IAction blockAction = null)
                 validatorSet: TestUtils.ValidatorSet);
             var actionEvaluator = new ActionEvaluator(
                 _ => blockAction,
-                new BlockChainStates(new MemoryStore(), stateStore),
+                stateStore,
                 new SingleActionLoader(typeof(DumbAction)));
             GenesisBlock = preEval.Sign(
                 Proposer,
diff --git a/Libplanet.Tests/Store/StoreTest.cs b/Libplanet.Tests/Store/StoreTest.cs
index f343ff3ab57..380b207ec1e 100644
--- a/Libplanet.Tests/Store/StoreTest.cs
+++ b/Libplanet.Tests/Store/StoreTest.cs
@@ -1010,7 +1010,7 @@ public void Copy()
                 var preEval = ProposeGenesis(proposer: GenesisProposer.PublicKey);
                 var actionEvaluator = new ActionEvaluator(
                     _ => policy.BlockAction,
-                    new BlockChainStates(s1, fx.StateStore),
+                    fx.StateStore,
                     new SingleActionLoader(typeof(DumbAction)));
                 var genesis = preEval.Sign(
                     GenesisProposer,
diff --git a/Libplanet.Tests/TestUtils.cs b/Libplanet.Tests/TestUtils.cs
index 93f5687f106..3c03fc7e686 100644
--- a/Libplanet.Tests/TestUtils.cs
+++ b/Libplanet.Tests/TestUtils.cs
@@ -609,7 +609,7 @@ public static (BlockChain BlockChain, ActionEvaluator ActionEvaluator)
             var blockChainStates = new BlockChainStates(store, stateStore);
             var actionEvaluator = new ActionEvaluator(
                     _ => policy.BlockAction,
-                    blockChainStates: blockChainStates,
+                    stateStore: stateStore,
                     actionTypeLoader: new SingleActionLoader(typeof(T)));
 
             if (genesisBlock is null)

From 978d8c2b02110f143e1483bea965f84bc13bcc73 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 4 Oct 2023 14:48:27 +0900
Subject: [PATCH 47/72] Changelog

---
 CHANGES.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 5471cc20407..c5576fa8a06 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -17,6 +17,8 @@ To be released.
  -  Changed `IActionEvaluator.Evaluate(IPreEvaluationBlock)` to
     `IActionEvaluator.Evaluate(IPreEvaluationBlock, HashDigest<SHA256>)`.
     [[#3438]]
+ -  Changed `ActionEvaluator` to accept `IStateStore` instead of
+    `IBlockChainStates`  [[#3439]]
 
 ### Backward-incompatible network protocol changes
 
@@ -34,6 +36,7 @@ To be released.
 
 [#3437]: https://github.com/planetarium/libplanet/pull/3437
 [#3438]: https://github.com/planetarium/libplanet/pull/3438
+[#3439]: https://github.com/planetarium/libplanet/pull/3439
 
 
 Version 3.4.0

From 0682020db0c086540269ddfe496fd259490e9dbf Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 4 Oct 2023 14:49:54 +0900
Subject: [PATCH 48/72] Remove unused code

---
 Libplanet.Action/ActionEvaluator.cs     |  5 ++-
 Libplanet/Blockchain/NullChainStates.cs | 47 -------------------------
 2 files changed, 2 insertions(+), 50 deletions(-)
 delete mode 100644 Libplanet/Blockchain/NullChainStates.cs

diff --git a/Libplanet.Action/ActionEvaluator.cs b/Libplanet.Action/ActionEvaluator.cs
index 0a8a56beb1e..9c3b602d0a2 100644
--- a/Libplanet.Action/ActionEvaluator.cs
+++ b/Libplanet.Action/ActionEvaluator.cs
@@ -10,7 +10,6 @@
 using Libplanet.Action.Loader;
 using Libplanet.Action.State;
 using Libplanet.Common;
-using Libplanet.Crypto;
 using Libplanet.Store;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
@@ -33,8 +32,8 @@ public class ActionEvaluator : IActionEvaluator
         /// </summary>
         /// <param name="policyBlockActionGetter">A delegator to get policy block action to evaluate
         /// at the end for each <see cref="IPreEvaluationBlock"/> that gets evaluated.</param>
-        /// <param name="stateStore">The <see cref="IBlockChainStates"/> to use to retrieve
-        /// the states for a provided <see cref="Address"/>.</param>
+        /// <param name="stateStore">The <see cref="IStateStore"/> to use to retrieve
+        /// the states for a provided <see cref="HashDigest{SHA256}"/>.</param>
         /// <param name="actionTypeLoader"> A <see cref="IActionLoader"/> implementation using
         /// action type lookup.</param>
         public ActionEvaluator(
diff --git a/Libplanet/Blockchain/NullChainStates.cs b/Libplanet/Blockchain/NullChainStates.cs
deleted file mode 100644
index 903fbeb2006..00000000000
--- a/Libplanet/Blockchain/NullChainStates.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using System.Collections.Generic;
-using System.Security.Cryptography;
-using Bencodex.Types;
-using Libplanet.Action.State;
-using Libplanet.Common;
-using Libplanet.Crypto;
-using Libplanet.Store.Trie;
-using Libplanet.Types.Assets;
-using Libplanet.Types.Blocks;
-using Libplanet.Types.Consensus;
-
-namespace Libplanet.Blockchain
-{
-    internal class NullChainStates : IBlockChainStates
-    {
-        public static readonly NullChainStates Instance = new NullChainStates();
-        private static readonly IKeyValueStore _keyValueStore = new MemoryKeyValueStore();
-
-        private NullChainStates()
-        {
-        }
-
-        public IValue? GetState(
-            Address address, BlockHash? offset) =>
-            GetAccountState(offset).GetState(address);
-
-        public IReadOnlyList<IValue?> GetStates(
-            IReadOnlyList<Address> addresses, BlockHash? offset) =>
-            GetAccountState(offset).GetStates(addresses);
-
-        public FungibleAssetValue GetBalance(
-            Address address, Currency currency, BlockHash? offset) =>
-            GetAccountState(offset).GetBalance(address, currency);
-
-        public FungibleAssetValue GetTotalSupply(Currency currency, BlockHash? offset) =>
-            GetAccountState(offset).GetTotalSupply(currency);
-
-        public ValidatorSet GetValidatorSet(BlockHash? offset) =>
-            GetAccountState(offset).GetValidatorSet();
-
-        public IAccountState GetAccountState(BlockHash? offset) =>
-            new AccountState(new MerkleTrie(_keyValueStore));
-
-        public IAccountState GetAccountState(HashDigest<SHA256>? hash) =>
-            new AccountState(new MerkleTrie(_keyValueStore));
-    }
-}

From e141590210a6e5f95fa8f369d3ffea84eb95acf4 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 4 Oct 2023 15:29:44 +0900
Subject: [PATCH 49/72] Release 3.5.0

---
 CHANGES.md | 18 +-----------------
 1 file changed, 1 insertion(+), 17 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index c5576fa8a06..96c5e08954a 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -4,9 +4,7 @@ Libplanet changelog
 Version 3.5.0
 -------------
 
-To be released.
-
-### Deprecated APIs
+Released on October 4, 2023.
 
 ### Backward-incompatible API changes
 
@@ -20,20 +18,6 @@ To be released.
  -  Changed `ActionEvaluator` to accept `IStateStore` instead of
     `IBlockChainStates`  [[#3439]]
 
-### Backward-incompatible network protocol changes
-
-### Backward-incompatible storage format changes
-
-### Added APIs
-
-### Behavioral changes
-
-### Bug fixes
-
-### Dependencies
-
-### CLI tools
-
 [#3437]: https://github.com/planetarium/libplanet/pull/3437
 [#3438]: https://github.com/planetarium/libplanet/pull/3438
 [#3439]: https://github.com/planetarium/libplanet/pull/3439

From ddb46aab2a6afdaf5181941dd8192fab84f991c3 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 4 Oct 2023 20:34:43 +0900
Subject: [PATCH 50/72] Prepare 3.6.0

---
 CHANGES.md                 | 24 ++++++++++++++++++++++++
 Libplanet/Libplanet.csproj |  2 +-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index 96c5e08954a..aa14b8efcdd 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,30 @@
 Libplanet changelog
 ===================
 
+Version 3.6.0
+-------------
+
+To be released.
+
+### Deprecated APIs
+
+### Backward-incompatible API changes
+
+### Backward-incompatible network protocol changes
+
+### Backward-incompatible storage format changes
+
+### Added APIs
+
+### Behavioral changes
+
+### Bug fixes
+
+### Dependencies
+
+### CLI tools
+
+
 Version 3.5.0
 -------------
 
diff --git a/Libplanet/Libplanet.csproj b/Libplanet/Libplanet.csproj
index 6a510f89531..9de444533bb 100644
--- a/Libplanet/Libplanet.csproj
+++ b/Libplanet/Libplanet.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <PackageId>Libplanet</PackageId>
     <Title>Libplanet</Title>
-    <VersionPrefix>3.5.0</VersionPrefix>
+    <VersionPrefix>3.6.0</VersionPrefix>
     <!-- Note: don't be confused by the word "prefix" here.  It's merely a
     version without suffix like "-dev.123".  See the following examples:
       Version: 1.2.3-dev.456

From 05c2c39fe30914364fe018354c17b52f89e4ddb5 Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 10:59:10 +0900
Subject: [PATCH 51/72] feat: add field on `TxResult`

---
 Libplanet.Explorer/GraphTypes/TxResult.cs     | 10 ++++++++++
 Libplanet.Explorer/GraphTypes/TxResultType.cs | 14 ++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/Libplanet.Explorer/GraphTypes/TxResult.cs b/Libplanet.Explorer/GraphTypes/TxResult.cs
index 00f3c3a3b24..958f2a2d9ba 100644
--- a/Libplanet.Explorer/GraphTypes/TxResult.cs
+++ b/Libplanet.Explorer/GraphTypes/TxResult.cs
@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.Security.Cryptography;
+using Libplanet.Common;
 
 namespace Libplanet.Explorer.GraphTypes
 {
@@ -8,11 +10,15 @@ public TxResult(
             TxStatus status,
             long? blockIndex,
             string? blockHash,
+            HashDigest<SHA256>? inputState,
+            HashDigest<SHA256>? outputState,
             List<string?>? exceptionNames)
         {
             TxStatus = status;
             BlockIndex = blockIndex;
             BlockHash = blockHash;
+            InputState = inputState;
+            OutputState = outputState;
             ExceptionNames = exceptionNames;
         }
 
@@ -22,6 +28,10 @@ public TxResult(
 
         public string? BlockHash { get; private set; }
 
+        public HashDigest<SHA256>? InputState { get; private set; }
+
+        public HashDigest<SHA256>? OutputState { get; private set; }
+
         public List<string?>? ExceptionNames { get; private set; }
     }
 }
diff --git a/Libplanet.Explorer/GraphTypes/TxResultType.cs b/Libplanet.Explorer/GraphTypes/TxResultType.cs
index 539865e7676..679c061d2dc 100644
--- a/Libplanet.Explorer/GraphTypes/TxResultType.cs
+++ b/Libplanet.Explorer/GraphTypes/TxResultType.cs
@@ -24,6 +24,20 @@ public TxResultType()
                 resolve: context => context.Source.BlockHash
             );
 
+            Field<HashDigestSHA256Type>(
+                nameof(TxResult.InputState),
+                description: "The input state's root hash " +
+                "which the target transaction executed.",
+                resolve: context => context.Source.InputState
+            );
+
+            Field<HashDigestSHA256Type>(
+                nameof(TxResult.OutputState),
+                description: "The output state's root hash " +
+                "which the target transaction executed.",
+                resolve: context => context.Source.OutputState
+            );
+
             Field<ListGraphType<StringGraphType>>(
                 nameof(TxResult.ExceptionNames),
                 description: "The name of exception. (when only failed)",

From 7c37ca181c701a4e56a0ff7ee483c73a6e53ef22 Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 10:59:47 +0900
Subject: [PATCH 52/72] introduce: HashDigestSHA256Type.cs

---
 .../GraphTypes/HashDigestSHA256Type.cs        | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 Libplanet.Explorer/GraphTypes/HashDigestSHA256Type.cs

diff --git a/Libplanet.Explorer/GraphTypes/HashDigestSHA256Type.cs b/Libplanet.Explorer/GraphTypes/HashDigestSHA256Type.cs
new file mode 100644
index 00000000000..45d8f0ccf48
--- /dev/null
+++ b/Libplanet.Explorer/GraphTypes/HashDigestSHA256Type.cs
@@ -0,0 +1,44 @@
+#nullable disable
+using System;
+using System.Security.Cryptography;
+using GraphQL.Language.AST;
+using GraphQL.Types;
+using Libplanet.Common;
+
+namespace Libplanet.Explorer.GraphTypes
+{
+    public class HashDigestSHA256Type : StringGraphType
+    {
+        public HashDigestSHA256Type()
+        {
+            Name = "HashDigest_SHA256";
+        }
+
+        public override object Serialize(object value)
+        {
+            if (value is HashDigest<SHA256> hash)
+            {
+                return hash.ToString();
+            }
+
+            return value;
+        }
+
+        public override object ParseValue(object value) =>
+            value switch
+            {
+                null => null,
+                string hex => HashDigest<SHA256>.FromString(hex),
+                _ => throw new ArgumentException(
+                    $"Expected a hexadecimal string but {value}", nameof(value)),
+            };
+
+        public override object ParseLiteral(IValue value) =>
+            value switch
+            {
+                StringValue str => ParseValue(str.Value),
+                _ => throw new ArgumentException(
+                    $"Expected a hexadecimal string but {value}", nameof(value)),
+            };
+    }
+}

From b94d632e2703680b85952ac35a040ff14768ab2b Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 11:00:28 +0900
Subject: [PATCH 53/72] refactor: adjust field changes on `TransactionQuery`

---
 Libplanet.Explorer/Queries/TransactionQuery.cs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/Libplanet.Explorer/Queries/TransactionQuery.cs b/Libplanet.Explorer/Queries/TransactionQuery.cs
index 667528f0242..5b8c5198db6 100644
--- a/Libplanet.Explorer/Queries/TransactionQuery.cs
+++ b/Libplanet.Explorer/Queries/TransactionQuery.cs
@@ -248,11 +248,15 @@ index is null
                                 TxStatus.STAGING,
                                 null,
                                 null,
+                                null,
+                                null,
                                 null)
                             : new TxResult(
                                 TxStatus.INVALID,
                                 null,
                                 null,
+                                null,
+                                null,
                                 null);
                     }
 
@@ -268,6 +272,8 @@ index is null
                             execution.Fail ? TxStatus.FAILURE : TxStatus.SUCCESS,
                             txExecutedBlock.Index,
                             txExecutedBlock.Hash.ToString(),
+                            execution.InputState,
+                            execution.OutputState,
                             execution.ExceptionNames);
                     }
                     catch (Exception)
@@ -276,6 +282,8 @@ index is null
                             TxStatus.INVALID,
                             null,
                             null,
+                            null,
+                            null,
                             null);
                     }
                 }

From b11cfeadeab92be77ed0ab43911007cef2d0ee7c Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 11:01:17 +0900
Subject: [PATCH 54/72] test: add more fixture for `TxResult`

---
 .../GraphTypes/TxResultTypeTest.cs            | 63 +++++++++++++++++--
 1 file changed, 58 insertions(+), 5 deletions(-)

diff --git a/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs b/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs
index 7fa38783b7e..a97d1325598 100644
--- a/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs
+++ b/Libplanet.Explorer.Tests/GraphTypes/TxResultTypeTest.cs
@@ -1,9 +1,8 @@
 using System.Collections.Generic;
-using System.Collections.Immutable;
+using System.Security.Cryptography;
 using GraphQL;
 using GraphQL.Execution;
-using Libplanet.Crypto;
-using Libplanet.Types.Assets;
+using Libplanet.Common;
 using Libplanet.Explorer.GraphTypes;
 using Xunit;
 using static Libplanet.Explorer.Tests.GraphQLTestUtils;
@@ -21,6 +20,8 @@ public async void Query(TxResult txResult, IDictionary<string, object> expected)
                     txStatus
                     blockIndex
                     blockHash
+                    inputState
+                    outputState
                     exceptionNames
                 }";
 
@@ -44,28 +45,80 @@ public static IEnumerable<object[]> TestCases() {
                         TxStatus.SUCCESS,
                         0,
                         "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
+                        HashDigest<SHA256>.FromString(
+                            "7146ddfb3594089795f6992a668a3ce7fde089aacdda68075e1bc37b14ebb06f"),
+                        HashDigest<SHA256>.FromString(
+                            "72bb2e17da644cbca9045f5e689fae0323b6af56a0acab9fd828d2243b50df1c"),
                         new List<string>() { "" }
                     ),
                     new Dictionary<string, object> {
                         ["txStatus"] = "SUCCESS",
                         ["blockIndex"] = 0L,
                         ["blockHash"] = "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
+                        ["inputState"] = 
+                            "7146ddfb3594089795f6992a668a3ce7fde089aacdda68075e1bc37b14ebb06f",
+                        ["outputState"] = 
+                            "72bb2e17da644cbca9045f5e689fae0323b6af56a0acab9fd828d2243b50df1c",
                         ["exceptionNames"] = new string[] { "" },
                     }
                 },
                 new object[] {
                     new TxResult(
-                        TxStatus.SUCCESS,
+                        TxStatus.FAILURE,
                         0,
                         "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
+                        HashDigest<SHA256>.FromString(
+                            "7146ddfb3594089795f6992a668a3ce7fde089aacdda68075e1bc37b14ebb06f"),
+                        HashDigest<SHA256>.FromString(
+                            "7146ddfb3594089795f6992a668a3ce7fde089aacdda68075e1bc37b14ebb06f"),
                         new List<string>() { "" }
                     ),
                     new Dictionary<string, object> {
-                        ["txStatus"] = "SUCCESS",
+                        ["txStatus"] = "FAILURE",
                         ["blockIndex"] = 0L,
+                        ["inputState"] = 
+                            "7146ddfb3594089795f6992a668a3ce7fde089aacdda68075e1bc37b14ebb06f",
+                        ["outputState"] = 
+                            "7146ddfb3594089795f6992a668a3ce7fde089aacdda68075e1bc37b14ebb06f",
                         ["blockHash"] = "45bcaa4c0b00f4f31eb61577e595ea58fb69c7df3ee612aa6eea945bbb0ce39d",
                         ["exceptionNames"] = new string[] { "" },
                     }
+                },
+                new object[] {
+                    new TxResult(
+                        TxStatus.INVALID,
+                        null,
+                        null,
+                        null,
+                        null,
+                        new List<string>() { "" }
+                    ),
+                    new Dictionary<string, object> {
+                        ["txStatus"] = "INVALID",
+                        ["blockIndex"] = null,
+                        ["blockHash"] = null,
+                        ["inputState"] = null,
+                        ["outputState"] = null,
+                        ["exceptionNames"] = new string[] { "" },
+                    }
+                },
+                new object[] {
+                    new TxResult(
+                        TxStatus.STAGING,
+                        null,
+                        null,
+                        null,
+                        null,
+                        new List<string>() { "" }
+                    ),
+                    new Dictionary<string, object> {
+                        ["txStatus"] = "STAGING",
+                        ["blockIndex"] = null,
+                        ["blockHash"] = null,
+                        ["inputState"] = null,
+                        ["outputState"] = null,
+                        ["exceptionNames"] = new string[] { "" },
+                    }
                 }
             };
         }

From b811d2d8e571c5bf12bf5820fa468fee24b10571 Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 11:07:09 +0900
Subject: [PATCH 55/72] docs: CHANGES.md

---
 CHANGES.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index aa14b8efcdd..f9f1ff02a1f 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -16,6 +16,11 @@ To be released.
 
 ### Added APIs
 
+ -  (Libplanet.Explorer) Added `TxResult.InputState` of type 
+    `HashDigest<SHA256>?`.  [[#3446], [#3447]]
+ -  (Libplanet.Explorer) Added `TxResult.OutputState` of type 
+    `HashDigest<SHA256>?`.  [[#3446], [#3447]]
+
 ### Behavioral changes
 
 ### Bug fixes
@@ -24,6 +29,8 @@ To be released.
 
 ### CLI tools
 
+[#3446]: https://github.com/planetarium/libplanet/issues/3446
+[#3447]: https://github.com/planetarium/libplanet/pull/3447
 
 Version 3.5.0
 -------------

From 41bb8b169c6e0503b526f674f6699e4bef384bcb Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Wed, 4 Oct 2023 22:36:38 +0900
Subject: [PATCH 56/72] Update IActionEvaluator interface

---
 Libplanet.Action/IActionEvaluator.cs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/Libplanet.Action/IActionEvaluator.cs b/Libplanet.Action/IActionEvaluator.cs
index 69be793465b..edaa0d9fa95 100644
--- a/Libplanet.Action/IActionEvaluator.cs
+++ b/Libplanet.Action/IActionEvaluator.cs
@@ -24,16 +24,15 @@ public interface IActionEvaluator
         /// <paramref name="block"/>.</param>
         /// <returns> The result of evaluating every <see cref="IAction"/> related to
         /// <paramref name="block"/> as an <see cref="IReadOnlyList{T}"/> of
-        /// <see cref="IActionEvaluation"/>s.</returns>
+        /// <see cref="ICommittedActionEvaluation"/>s.</returns>
         /// <remarks>
-        /// <para>Publicly exposed for benchmarking.</para>
-        /// <para>First evaluates all <see cref="IAction"/>s in
+        /// First evaluates all <see cref="IAction"/>s in
         /// <see cref="IBlockContent.Transactions"/> of <paramref name="block"/> and appends the
         /// evaluation of the <see cref="IBlockPolicy.BlockAction"/> held by the instance at
-        /// the end.</para>
+        /// the end.
         /// </remarks>
         [Pure]
-        IReadOnlyList<IActionEvaluation> Evaluate(
+        IReadOnlyList<ICommittedActionEvaluation> Evaluate(
             IPreEvaluationBlock block,
             HashDigest<SHA256>? baseStateRootHash);
     }

From b4c73acb5d9b7dd2659eb3cf91cbd074788fa4a7 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 5 Oct 2023 00:22:26 +0900
Subject: [PATCH 57/72] Update ActionEvaluator and BlockChain

---
 Libplanet.Action/ActionEvaluator.cs         | 73 ++++++++++++++++++---
 Libplanet/Blockchain/BlockChain.Evaluate.cs | 34 +++++-----
 Libplanet/Blockchain/BlockChain.Swap.cs     |  8 +--
 Libplanet/Blockchain/BlockChain.cs          |  5 +-
 4 files changed, 83 insertions(+), 37 deletions(-)

diff --git a/Libplanet.Action/ActionEvaluator.cs b/Libplanet.Action/ActionEvaluator.cs
index 9c3b602d0a2..ffdfbae2e91 100644
--- a/Libplanet.Action/ActionEvaluator.cs
+++ b/Libplanet.Action/ActionEvaluator.cs
@@ -11,6 +11,7 @@
 using Libplanet.Action.State;
 using Libplanet.Common;
 using Libplanet.Store;
+using Libplanet.Store.Trie;
 using Libplanet.Types.Blocks;
 using Libplanet.Types.Tx;
 using Serilog;
@@ -76,7 +77,7 @@ public static int GenerateRandomSeed(
 
         /// <inheritdoc cref="IActionEvaluator.Evaluate"/>
         [Pure]
-        public IReadOnlyList<IActionEvaluation> Evaluate(
+        public IReadOnlyList<ICommittedActionEvaluation> Evaluate(
             IPreEvaluationBlock block,
             HashDigest<SHA256>? baseStateRootHash)
         {
@@ -95,19 +96,15 @@ public IReadOnlyList<IActionEvaluation> Evaluate(
                     EvaluateBlock(block, previousState).ToImmutableList();
 
                 var policyBlockAction = _policyBlockActionGetter(block);
-                if (policyBlockAction is null)
-                {
-                    return evaluations;
-                }
-                else
+                if (policyBlockAction is { } blockAction)
                 {
                     previousState = evaluations.Count > 0
                         ? evaluations.Last().OutputState
                         : previousState;
-                    return evaluations.Add(
-                        EvaluatePolicyBlockAction(block, previousState)
-                    );
+                    evaluations = evaluations.Add(EvaluatePolicyBlockAction(block, previousState));
                 }
+
+                return ToCommittedEvaluation(block, evaluations, baseStateRootHash);
             }
             finally
             {
@@ -479,6 +476,64 @@ internal IAccount PrepareInitialDelta(HashDigest<SHA256>? stateRootHash)
             return new Account(new AccountState(_stateStore.GetStateRoot(stateRootHash)));
         }
 
+        internal IReadOnlyList<ICommittedActionEvaluation>
+            ToCommittedEvaluation(
+                IPreEvaluationBlock block,
+                IReadOnlyList<IActionEvaluation> evaluations,
+                HashDigest<SHA256>? baseStateRootHash)
+        {
+            Stopwatch stopwatch = new Stopwatch();
+            stopwatch.Start();
+
+            ITrie trie = _stateStore.GetStateRoot(baseStateRootHash);
+            var committedEvaluations = new List<CommittedActionEvaluation>();
+
+            int setCount = 0;
+            foreach (var evaluation in evaluations)
+            {
+                ITrie nextTrie = trie;
+                foreach (var kv in evaluation.OutputState.Delta.ToRawDelta())
+                {
+                    nextTrie = nextTrie.Set(kv.Key, kv.Value);
+                    setCount++;
+                }
+
+                nextTrie = _stateStore.Commit(nextTrie);
+                var committedEvaluation = new CommittedActionEvaluation(
+                    action: evaluation.Action,
+                    inputContext: new CommittedActionContext(
+                        signer: evaluation.InputContext.Signer,
+                        txId: evaluation.InputContext.TxId,
+                        miner: evaluation.InputContext.Miner,
+                        blockIndex: evaluation.InputContext.BlockIndex,
+                        blockProtocolVersion: evaluation.InputContext.BlockProtocolVersion,
+                        rehearsal: evaluation.InputContext.Rehearsal,
+                        previousState: trie.Hash,
+                        randomSeed: evaluation.InputContext.RandomSeed,
+                        blockAction: evaluation.InputContext.BlockAction),
+                    outputState: nextTrie.Hash,
+                    exception: evaluation.Exception);
+                committedEvaluations.Add(committedEvaluation);
+
+                trie = nextTrie;
+            }
+
+            _logger
+                .ForContext("Tag", "Metric")
+                .ForContext("Subtag", "StateUpdateDuration")
+                .Information(
+                    "Took {DurationMs} ms to update the states with {Count} key changes " +
+                    "and resulting in state root hash {StateRootHash} for " +
+                    "block #{BlockIndex} pre-evaluation hash {PreEvaluationHash}",
+                    stopwatch.ElapsedMilliseconds,
+                    setCount,
+                    trie.Hash,
+                    block.Index,
+                    block.PreEvaluationHash);
+
+            return committedEvaluations;
+        }
+
         [Pure]
         private static IEnumerable<ITransaction> OrderTxsForEvaluationV0(
             IEnumerable<ITransaction> txs,
diff --git a/Libplanet/Blockchain/BlockChain.Evaluate.cs b/Libplanet/Blockchain/BlockChain.Evaluate.cs
index 648e490b7f5..ca421119af0 100644
--- a/Libplanet/Blockchain/BlockChain.Evaluate.cs
+++ b/Libplanet/Blockchain/BlockChain.Evaluate.cs
@@ -1,10 +1,9 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
+using System.Linq;
 using System.Security.Cryptography;
-using Bencodex.Types;
 using Libplanet.Action;
 using Libplanet.Action.Loader;
 using Libplanet.Action.State;
@@ -39,13 +38,12 @@ public partial class BlockChain
         public static HashDigest<SHA256> DetermineGenesisStateRootHash(
             IActionEvaluator actionEvaluator,
             IPreEvaluationBlock preEvaluationBlock,
-            out IReadOnlyList<IActionEvaluation> evaluations)
+            out IReadOnlyList<ICommittedActionEvaluation> evaluations)
         {
             evaluations = EvaluateGenesis(actionEvaluator, preEvaluationBlock);
-            IImmutableDictionary<KeyBytes, IValue> delta = evaluations.GetRawTotalDelta();
-            IStateStore stateStore = new TrieStateStore(new DefaultKeyValueStore(null));
-            ITrie trie = stateStore.Commit(stateStore.GetStateRoot(null).Hash, delta);
-            return trie.Hash;
+            return evaluations.Count > 0
+                ? evaluations.Last().OutputState
+                : new TrieStateStore(new DefaultKeyValueStore(null)).GetStateRoot(null).Hash;
         }
 
         /// <summary>
@@ -55,13 +53,13 @@ public static HashDigest<SHA256> DetermineGenesisStateRootHash(
         /// evaluate the proposed <see cref="Block"/>.</param>
         /// <param name="preEvaluationBlock">The <see cref="IPreEvaluationBlock"/> to
         /// evaluate.</param>
-        /// <returns>An <see cref="IReadOnlyList{T}"/> of <see cref="IActionEvaluation"/>s
+        /// <returns>An <see cref="IReadOnlyList{T}"/> of <see cref="ICommittedActionEvaluation"/>s
         /// resulting from evaluating <paramref name="preEvaluationBlock"/> using
         /// <paramref name="actionEvaluator"/>.</returns>
         /// <exception cref="ArgumentException">Thrown if <paramref name="preEvaluationBlock"/>s
         /// <see cref="IBlockMetadata.Index"/> is not zero.</exception>
         [Pure]
-        public static IReadOnlyList<IActionEvaluation> EvaluateGenesis(
+        public static IReadOnlyList<ICommittedActionEvaluation> EvaluateGenesis(
             IActionEvaluator actionEvaluator,
             IPreEvaluationBlock preEvaluationBlock)
         {
@@ -105,7 +103,7 @@ public HashDigest<SHA256> DetermineBlockStateRootHash(
             {
                 Stopwatch stopwatch = new Stopwatch();
                 stopwatch.Start();
-                var rawEvaluations = EvaluateBlock(block);
+                evaluations = EvaluateBlock(block);
 
                 _logger.Debug(
                     "Took {DurationMs} ms to evaluate block #{BlockIndex} " +
@@ -113,13 +111,11 @@ public HashDigest<SHA256> DetermineBlockStateRootHash(
                     stopwatch.ElapsedMilliseconds,
                     block.Index,
                     block.PreEvaluationHash,
-                    rawEvaluations.Count);
+                    evaluations.Count);
 
-                (var committedEvaluations, var rootHash) =
-                    ToCommittedEvaluation(block, rawEvaluations);
-
-                evaluations = committedEvaluations;
-                return rootHash;
+                return evaluations.Count > 0
+                    ? evaluations.Last().OutputState
+                    : GetAccountState(block.PreviousHash).Trie.Hash;
             }
             finally
             {
@@ -131,13 +127,13 @@ public HashDigest<SHA256> DetermineBlockStateRootHash(
         /// Evaluates the <see cref="IAction"/>s in given <paramref name="block"/>.
         /// </summary>
         /// <param name="block">The <see cref="IPreEvaluationBlock"/> to execute.</param>
-        /// <returns>An <see cref="IReadOnlyList{T}"/> of <ses cref="IActionEvaluation"/>s for
-        /// given <paramref name="block"/>.</returns>
+        /// <returns>An <see cref="IReadOnlyList{T}"/> of <ses cref="ICommittedActionEvaluation"/>s
+        /// for given <paramref name="block"/>.</returns>
         /// <exception cref="InvalidActionException">Thrown when given <paramref name="block"/>
         /// contains an action that cannot be loaded with <see cref="IActionLoader"/>.</exception>
         /// <seealso cref="ValidateBlockStateRootHash"/>
         [Pure]
-        public IReadOnlyList<IActionEvaluation> EvaluateBlock(IPreEvaluationBlock block) =>
+        public IReadOnlyList<ICommittedActionEvaluation> EvaluateBlock(IPreEvaluationBlock block) =>
             ActionEvaluator.Evaluate(block, Store.GetStateRootHash(block.PreviousHash));
 
         /// <summary>
diff --git a/Libplanet/Blockchain/BlockChain.Swap.cs b/Libplanet/Blockchain/BlockChain.Swap.cs
index e6bf06c0866..1e543ac4050 100644
--- a/Libplanet/Blockchain/BlockChain.Swap.cs
+++ b/Libplanet/Blockchain/BlockChain.Swap.cs
@@ -1,7 +1,6 @@
 #nullable disable
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
 using System.Security.Cryptography;
@@ -175,12 +174,11 @@ internal void RenderFastForward(
                     Block block = Store.GetBlock(hash);
                     HashDigest<SHA256>? baseStateRootHash =
                         Store.GetStateRootHash(block.PreviousHash);
-                    ImmutableList<IActionEvaluation> evaluations =
-                        ActionEvaluator.Evaluate(block, baseStateRootHash).ToImmutableList();
-                    (var committedEvaluations, _) = ToCommittedEvaluation(block, evaluations);
+                    IReadOnlyList<ICommittedActionEvaluation> evaluations =
+                        ActionEvaluator.Evaluate(block, baseStateRootHash);
 
                     RenderActions(
-                        evaluations: committedEvaluations,
+                        evaluations: evaluations,
                         block: block);
                 }
 
diff --git a/Libplanet/Blockchain/BlockChain.cs b/Libplanet/Blockchain/BlockChain.cs
index 76591f08835..1989564468c 100644
--- a/Libplanet/Blockchain/BlockChain.cs
+++ b/Libplanet/Blockchain/BlockChain.cs
@@ -384,7 +384,7 @@ public static BlockChain Create(
             var computedStateRootHash = DetermineGenesisStateRootHash(
                 actionEvaluator,
                 preEval,
-                out IReadOnlyList<IActionEvaluation> evals);
+                out var _);
             if (!genesisBlock.StateRootHash.Equals(computedStateRootHash))
             {
                 throw new InvalidBlockStateRootHashException(
@@ -414,9 +414,6 @@ public static BlockChain Create(
 
             store.SetCanonicalChainId(id);
 
-            var delta = evals.GetRawTotalDelta();
-            stateStore.Commit(null, delta);
-
             blockChainStates ??= new BlockChainStates(store, stateStore);
 
             return new BlockChain(

From a7626bc32f344f155765850342ac446bb3a3b714 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 5 Oct 2023 11:55:18 +0900
Subject: [PATCH 58/72] Fix tests

---
 Libplanet.Tests/Action/ActionEvaluatorTest.cs | 31 ++++++++++++-------
 .../Blockchain/BlockChainTest.Append.cs       |  4 +--
 .../Blocks/PreEvaluationBlockTest.cs          |  2 +-
 Libplanet.Tests/Store/StoreFixture.cs         |  3 +-
 4 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/Libplanet.Tests/Action/ActionEvaluatorTest.cs b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
index a4b1dec6a5f..ca5f9d2eb08 100644
--- a/Libplanet.Tests/Action/ActionEvaluatorTest.cs
+++ b/Libplanet.Tests/Action/ActionEvaluatorTest.cs
@@ -86,15 +86,14 @@ public void Idempotent()
                 transactions: txs).Propose();
             var actionEvaluator = new ActionEvaluator(
                 _ => null,
-                new TrieStateStore(new MemoryKeyValueStore()),
+                stateStore,
                 new SingleActionLoader(typeof(RandomAction)));
             Block stateRootBlock = noStateRootBlock.Sign(
                 GenesisProposer,
                 BlockChain.DetermineGenesisStateRootHash(
                     actionEvaluator,
                     noStateRootBlock,
-                    out IReadOnlyList<IActionEvaluation> evals));
-            stateStore.Commit(null, evals.GetRawTotalDelta());
+                    out IReadOnlyList<ICommittedActionEvaluation> evals));
             var generatedRandomNumbers = new List<int>();
 
             AssertPreEvaluationBlocksEqual(stateRootBlock, noStateRootBlock);
@@ -103,10 +102,14 @@ public void Idempotent()
             {
                 var actionEvaluations = actionEvaluator.Evaluate(noStateRootBlock, null);
                 generatedRandomNumbers.Add(
-                    (Integer)actionEvaluations[0].OutputState.GetState(txAddress));
+                    (Integer)new AccountState(
+                        stateStore.GetStateRoot(actionEvaluations[0].OutputState))
+                            .GetState(txAddress));
                 actionEvaluations = actionEvaluator.Evaluate(stateRootBlock, null);
                 generatedRandomNumbers.Add(
-                    (Integer)actionEvaluations[0].OutputState.GetState(txAddress));
+                    (Integer)new AccountState(
+                        stateStore.GetStateRoot(actionEvaluations[0].OutputState))
+                            .GetState(txAddress));
             }
 
             for (int i = 1; i < generatedRandomNumbers.Count; ++i)
@@ -921,10 +924,12 @@ public void TotalUpdatedFungibleAssets()
             var block = chain.ProposeBlock(
                 GenesisProposer, txs.ToImmutableList(), CreateBlockCommit(chain.Tip));
 
-            var evals = chain.EvaluateBlock(block);
+            var evals = actionEvaluator.EvaluateBlock(
+                block,
+                new Account(chain.GetAccountState(block.PreviousHash)));
 
-            // Includes policy block action
-            Assert.Equal(4, evals.Count);
+            // Does not include policy block action
+            Assert.Equal(3, evals.Count());
             var latest = evals.Last().OutputState;
 
             // Only addresses[0] and addresses[1] succeeded in minting
@@ -991,10 +996,11 @@ public void EvaluateActionAndCollectFee()
             Assert.Null(evaluations.Single().Exception);
             Assert.Equal(
                 FungibleAssetValue.FromRawValue(foo, 9),
-                evaluations.Single().OutputState.GetBalance(address, foo));
+                chain.GetAccountState(evaluations.Single().OutputState).GetBalance(address, foo));
             Assert.Equal(
                 FungibleAssetValue.FromRawValue(foo, 1),
-                evaluations.Single().OutputState.GetBalance(miner.ToAddress(), foo));
+                chain.GetAccountState(
+                    evaluations.Single().OutputState).GetBalance(miner.ToAddress(), foo));
         }
 
         [Fact]
@@ -1060,10 +1066,11 @@ public void EvaluateThrowingExceedGasLimit()
                 evaluations.Single().Exception?.InnerException?.GetType());
             Assert.Equal(
                 FungibleAssetValue.FromRawValue(foo, 5),
-                evaluations.Single().OutputState.GetBalance(address, foo));
+                chain.GetAccountState(evaluations.Single().OutputState).GetBalance(address, foo));
             Assert.Equal(
                 FungibleAssetValue.FromRawValue(foo, 5),
-                evaluations.Single().OutputState.GetBalance(miner.ToAddress(), foo));
+                chain.GetAccountState(
+                    evaluations.Single().OutputState).GetBalance(miner.ToAddress(), foo));
         }
 
         [Fact]
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
index a43b61c48d3..4ff7204fe4a 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Append.cs
@@ -608,8 +608,8 @@ public void CachedActionEvaluationWrittenOnAppend()
             _blockChain.StageTransaction(txA0);
             _blockChain.StageTransaction(txA1);
             Block block = _blockChain.ProposeBlock(miner);
-            (IReadOnlyList<ICommittedActionEvaluation> actionEvaluations, _) =
-                _blockChain.ToCommittedEvaluation(block, _blockChain.EvaluateBlock(block));
+            IReadOnlyList<ICommittedActionEvaluation> actionEvaluations =
+                _blockChain.EvaluateBlock(block);
             Assert.Equal(0L, _blockChain.Tip.Index);
             _blockChain.Append(
                 block,
diff --git a/Libplanet.Tests/Blocks/PreEvaluationBlockTest.cs b/Libplanet.Tests/Blocks/PreEvaluationBlockTest.cs
index 63dbef5ebdb..ccde686aa6f 100644
--- a/Libplanet.Tests/Blocks/PreEvaluationBlockTest.cs
+++ b/Libplanet.Tests/Blocks/PreEvaluationBlockTest.cs
@@ -110,7 +110,7 @@ public void DetermineStateRootHash()
                     actionTypeLoader: new SingleActionLoader(typeof(Arithmetic)));
                 HashDigest<SHA256> genesisStateRootHash =
                     BlockChain.DetermineGenesisStateRootHash(
-                        actionEvaluator, preEvalGenesis, out _);
+                        actionEvaluator, preEvalGenesis, out var _);
                 _output.WriteLine("#0 StateRootHash: {0}", genesisStateRootHash);
                 Block genesis =
                     preEvalGenesis.Sign(_contents.GenesisKey, genesisStateRootHash);
diff --git a/Libplanet.Tests/Store/StoreFixture.cs b/Libplanet.Tests/Store/StoreFixture.cs
index ea5cfc1b51b..6661eb2b7ca 100644
--- a/Libplanet.Tests/Store/StoreFixture.cs
+++ b/Libplanet.Tests/Store/StoreFixture.cs
@@ -112,8 +112,7 @@ protected StoreFixture(IAction blockAction = null)
                 BlockChain.DetermineGenesisStateRootHash(
                     actionEvaluator,
                     preEval,
-                    out IReadOnlyList<IActionEvaluation> evals));
-            stateStore.Commit(null, evals.GetRawTotalDelta());
+                    out IReadOnlyList<ICommittedActionEvaluation> evals));
             stateRootHashes[GenesisBlock.Hash] = GenesisBlock.StateRootHash;
             Block1 = TestUtils.ProposeNextBlock(
                 GenesisBlock,

From c839a9aacff98476929f78749fa30eb47e71b55f Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 5 Oct 2023 11:56:09 +0900
Subject: [PATCH 59/72] Cleanup

---
 Libplanet/Blockchain/BlockChain.Evaluate.cs | 58 ---------------------
 1 file changed, 58 deletions(-)

diff --git a/Libplanet/Blockchain/BlockChain.Evaluate.cs b/Libplanet/Blockchain/BlockChain.Evaluate.cs
index ca421119af0..12c857ef779 100644
--- a/Libplanet/Blockchain/BlockChain.Evaluate.cs
+++ b/Libplanet/Blockchain/BlockChain.Evaluate.cs
@@ -6,7 +6,6 @@
 using System.Security.Cryptography;
 using Libplanet.Action;
 using Libplanet.Action.Loader;
-using Libplanet.Action.State;
 using Libplanet.Common;
 using Libplanet.Crypto;
 using Libplanet.Store;
@@ -163,62 +162,5 @@ internal Block EvaluateAndSign(
                 : throw new ArgumentException(
                     $"Given {nameof(preEvaluationBlock)} must have protocol version " +
                     $"2 or greater: {preEvaluationBlock.ProtocolVersion}");
-
-        internal (IReadOnlyList<ICommittedActionEvaluation>, HashDigest<SHA256>)
-            ToCommittedEvaluation(
-                IPreEvaluationBlock block,
-                IReadOnlyList<IActionEvaluation> evaluations)
-        {
-            Stopwatch stopwatch = new Stopwatch();
-            stopwatch.Start();
-
-            ITrie trie = GetAccountState(block.PreviousHash).Trie;
-            var committedEvaluations = new List<CommittedActionEvaluation>();
-
-            int setCount = 0;
-            foreach (var evaluation in evaluations)
-            {
-                ITrie nextTrie = trie;
-                foreach (var kv in evaluation.OutputState.Delta.ToRawDelta())
-                {
-                    nextTrie = nextTrie.Set(kv.Key, kv.Value);
-                    setCount++;
-                }
-
-                nextTrie = StateStore.Commit(nextTrie);
-                var committedEvaluation = new CommittedActionEvaluation(
-                    action: evaluation.Action,
-                    inputContext: new CommittedActionContext(
-                        signer: evaluation.InputContext.Signer,
-                        txId: evaluation.InputContext.TxId,
-                        miner: evaluation.InputContext.Miner,
-                        blockIndex: evaluation.InputContext.BlockIndex,
-                        blockProtocolVersion: evaluation.InputContext.BlockProtocolVersion,
-                        rehearsal: evaluation.InputContext.Rehearsal,
-                        previousState: trie.Hash,
-                        randomSeed: evaluation.InputContext.RandomSeed,
-                        blockAction: evaluation.InputContext.BlockAction),
-                    outputState: nextTrie.Hash,
-                    exception: evaluation.Exception);
-                committedEvaluations.Add(committedEvaluation);
-
-                trie = nextTrie;
-            }
-
-            _logger
-                .ForContext("Tag", "Metric")
-                .ForContext("Subtag", "StateUpdateDuration")
-                .Information(
-                    "Took {DurationMs} ms to update the states with {Count} key changes " +
-                    "and resulting in state root hash {StateRootHash} for " +
-                    "block #{BlockIndex} pre-evaluation hash {PreEvaluationHash}",
-                    stopwatch.ElapsedMilliseconds,
-                    setCount,
-                    trie.Hash,
-                    block.Index,
-                    block.PreEvaluationHash);
-
-            return (committedEvaluations, trie.Hash);
-        }
     }
 }

From 3ac7d04530d1794de71c66e6ea3d3331507c7e6a Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 5 Oct 2023 13:15:38 +0900
Subject: [PATCH 60/72] Changelog

---
 CHANGES.md | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index f9f1ff02a1f..2d3e0fceb25 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -10,28 +10,49 @@ To be released.
 
 ### Backward-incompatible API changes
 
+ -  Changed `IActionEvaluator.Evaluate()`'s return type to
+    `IReadOnlyList<ICommittedActionEvaluation>` from
+    `IReadOnlyList<IActionEvaluation>`.  [[#3445]]
+ -  Changed `BlockChain.DetermineStateRootHash(IActionEvaluator,
+    IPreEvaluationBlock, out IReadOnlyList<IActionEvaluation>)` to
+    `BlockChain.DetermineStateRootHash(IActionEvaluator,
+    IPreEvaluationBlock, out IReadOnlyList<ICommittedActionEvaluation>)`.
+    [[#3445]]
+ -  Changed `BlockChain.EvaluateGenesis()`'s return type to
+    `IReadOnlyList<ICommittedActionEvaluation>` from
+    `IReadOnlyList<IActionEvaluation>`.  [[#3445]]
+ -  Changed `BlockChain.EvaluateBlock()`'s return type to
+    `IReadOnlyList<ICommittedActionEvaluation>` from
+    `IReadOnlyList<IActionEvaluation>`.  [[#3445]]
+
 ### Backward-incompatible network protocol changes
 
 ### Backward-incompatible storage format changes
 
 ### Added APIs
 
- -  (Libplanet.Explorer) Added `TxResult.InputState` of type 
+ -  (Libplanet.Explorer) Added `TxResult.InputState` of type
     `HashDigest<SHA256>?`.  [[#3446], [#3447]]
- -  (Libplanet.Explorer) Added `TxResult.OutputState` of type 
+ -  (Libplanet.Explorer) Added `TxResult.OutputState` of type
     `HashDigest<SHA256>?`.  [[#3446], [#3447]]
 
 ### Behavioral changes
 
+ -  `IActionEvaluator.Evaluate()`, `BlockChain.EvaluateGenesis()`,
+    and `BlockChain.EvaluateBlock()` have a side-effect of storing
+    data to `IStateStore` when called.  [[#3445]]
+
 ### Bug fixes
 
 ### Dependencies
 
 ### CLI tools
 
+[#3445]: https://github.com/planetarium/libplanet/pull/3445
 [#3446]: https://github.com/planetarium/libplanet/issues/3446
 [#3447]: https://github.com/planetarium/libplanet/pull/3447
 
+
 Version 3.5.0
 -------------
 

From 3de6e31314fc57744bd20d0aafd1c7347c813f1e Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 6 Oct 2023 11:24:02 +0900
Subject: [PATCH 61/72] Updated side-effect warning

---
 Libplanet.Action/IActionEvaluator.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Libplanet.Action/IActionEvaluator.cs b/Libplanet.Action/IActionEvaluator.cs
index edaa0d9fa95..39c802e78a5 100644
--- a/Libplanet.Action/IActionEvaluator.cs
+++ b/Libplanet.Action/IActionEvaluator.cs
@@ -3,6 +3,7 @@
 using System.Security.Cryptography;
 using Libplanet.Action.Loader;
 using Libplanet.Common;
+using Libplanet.Store;
 using Libplanet.Types.Blocks;
 
 namespace Libplanet.Action
@@ -26,10 +27,15 @@ public interface IActionEvaluator
         /// <paramref name="block"/> as an <see cref="IReadOnlyList{T}"/> of
         /// <see cref="ICommittedActionEvaluation"/>s.</returns>
         /// <remarks>
+        /// <para>
+        /// This has a side-effect of writing data to internally held <see cref="IStateStore"/>.
+        /// </para>
+        /// <para>
         /// First evaluates all <see cref="IAction"/>s in
         /// <see cref="IBlockContent.Transactions"/> of <paramref name="block"/> and appends the
         /// evaluation of the <see cref="IBlockPolicy.BlockAction"/> held by the instance at
         /// the end.
+        /// </para>
         /// </remarks>
         [Pure]
         IReadOnlyList<ICommittedActionEvaluation> Evaluate(

From 696d8b7b6554142aa07f2a9a8eb0088e5a5375b2 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 6 Oct 2023 12:52:09 +0900
Subject: [PATCH 62/72] Remove unnecessary code

---
 Libplanet.Store/StateStoreExtensions.cs       | 79 -----------------
 .../Blockchain/BlockChainTest.Internals.cs    |  7 +-
 .../Store/StateStoreExtensionsTest.cs         | 87 -------------------
 .../Store/TrieStateStoreCommitTest.cs         |  8 +-
 Libplanet.Tests/Store/TrieStateStoreTest.cs   | 21 ++++-
 5 files changed, 24 insertions(+), 178 deletions(-)
 delete mode 100644 Libplanet.Store/StateStoreExtensions.cs
 delete mode 100644 Libplanet.Tests/Store/StateStoreExtensionsTest.cs

diff --git a/Libplanet.Store/StateStoreExtensions.cs b/Libplanet.Store/StateStoreExtensions.cs
deleted file mode 100644
index 3a5b6a2585c..00000000000
--- a/Libplanet.Store/StateStoreExtensions.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Security.Cryptography;
-using Bencodex.Types;
-using Libplanet.Common;
-using Libplanet.Store.Trie;
-
-namespace Libplanet.Store
-{
-    /// <summary>
-    /// Convenient extension methods for <see cref="IStateStore"/>.
-    /// </summary>
-    public static class StateStoreExtensions
-    {
-        /// <summary>
-        /// Records <paramref name="rawStatesDelta"/> which is based on the previous state
-        /// root, and returns the new state root.
-        /// </summary>
-        /// <param name="stateStore">The <see cref="IStateStore"/> to records
-        /// the <paramref name="rawStatesDelta"/>.</param>
-        /// <param name="previousStateRootHash">The state root hash on which
-        /// the <paramref name="rawStatesDelta"/> is based.</param>
-        /// <param name="rawStatesDelta">The raw states delta to be recorded.</param>
-        /// <returns>The new state root.</returns>
-        public static ITrie Commit(
-            this IStateStore stateStore,
-            HashDigest<SHA256>? previousStateRootHash,
-            IImmutableDictionary<KeyBytes, IValue> rawStatesDelta
-        )
-        {
-            ITrie trie = stateStore.GetStateRoot(previousStateRootHash);
-            foreach (KeyValuePair<KeyBytes, IValue> pair in rawStatesDelta)
-            {
-                trie = trie.Set(pair.Key, pair.Value);
-            }
-
-            ITrie stage = stateStore.Commit(trie);
-            return stateStore.GetStateRoot(stage.Hash);
-        }
-
-        /// <summary>
-        /// Gets multiple states at once.
-        /// </summary>
-        /// <param name="stateStore">The <see cref="IStateStore"/> to get states.</param>
-        /// <param name="stateRootHash">The root hash of the state trie to look up states from.
-        /// </param>
-        /// <param name="rawStateKeys">State keys to get.</param>
-        /// <returns>The state values associated to the specified <paramref name="rawStateKeys"/>.
-        /// The associated values are ordered in the same way to the corresponding
-        /// <paramref name="rawStateKeys"/>.  Absent values are represented as
-        /// <see langword="null"/>.</returns>
-        public static IReadOnlyList<IValue?> GetStates(
-            this IStateStore stateStore,
-            HashDigest<SHA256>? stateRootHash,
-            IReadOnlyList<KeyBytes> rawStateKeys
-        )
-        {
-            ITrie trie = stateStore.GetStateRoot(stateRootHash);
-            KeyBytes[] keys = rawStateKeys.ToArray();
-            return trie.Get(keys);
-        }
-
-        /// <summary>
-        /// Checks if the state root is recorded in the <paramref name="stateStore"/>.
-        /// </summary>
-        /// <param name="stateStore">The <see cref="IStateStore"/> to check if the state root is
-        /// recorded in it.</param>
-        /// <param name="stateRootHash">The hash of the state root to check if it is recorded.
-        /// </param>
-        /// <returns><see langword="true"/> if the state root exists in the
-        /// <paramref name="stateStore"/>; otherwise, <see langword="false"/>.</returns>
-        public static bool ContainsStateRoot(
-            this IStateStore stateStore,
-            HashDigest<SHA256> stateRootHash
-        ) =>
-            stateStore.GetStateRoot(stateRootHash).Recorded;
-    }
-}
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs b/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs
index 0264b51de79..4a560f1c5f0 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.Internals.cs
@@ -131,10 +131,9 @@ public void ExecuteActions()
             {
                 AssertBencodexEqual(
                     pair.Value,
-                    _fx.StateStore.GetStates(
-                        block1.StateRootHash,
-                        new[] { ToStateKey(pair.Key) }
-                    )[0]
+                    _fx.StateStore
+                        .GetStateRoot(block1.StateRootHash)
+                        .Get(new[] { ToStateKey(pair.Key) })[0]
                 );
             }
         }
diff --git a/Libplanet.Tests/Store/StateStoreExtensionsTest.cs b/Libplanet.Tests/Store/StateStoreExtensionsTest.cs
deleted file mode 100644
index 9af7cbb9002..00000000000
--- a/Libplanet.Tests/Store/StateStoreExtensionsTest.cs
+++ /dev/null
@@ -1,87 +0,0 @@
-using System.Collections.Immutable;
-using System.Diagnostics.CodeAnalysis;
-using Bencodex.Types;
-using Libplanet.Store;
-using Libplanet.Store.Trie;
-using Xunit;
-using static Libplanet.Tests.TestUtils;
-
-namespace Libplanet.Tests.Store
-{
-    [SuppressMessage(
-        "Usage",
-        "xUnit1026",
-        Justification = "Labels purpose to distinguish " + nameof(IStateStore) + " impls.")]
-    public class StateStoreExtensionsTest
-    {
-        public static IImmutableDictionary<KeyBytes, IValue> ZeroDelta =>
-            ImmutableDictionary<KeyBytes, IValue>.Empty;
-
-        public static KeyBytes KeyFoo => new KeyBytes("foo");
-
-        public static KeyBytes KeyBar => new KeyBytes("bar");
-
-        public static KeyBytes KeyBaz => new KeyBytes("baz");
-
-        public static IImmutableDictionary<KeyBytes, IValue> DeltaA => ZeroDelta
-            .Add(KeyFoo, (Text)"abc")
-            .Add(KeyBar, (Text)"def");
-
-        public static IImmutableDictionary<KeyBytes, IValue> DeltaB => ZeroDelta
-            .Add(KeyFoo, (Text)"ABC")
-            .Add(KeyBaz, (Text)"ghi");
-
-        [Fact]
-        public void Commit()
-        {
-            IStateStore stateStore = new TrieStateStore(new DefaultKeyValueStore(null));
-            ITrie a = stateStore.Commit(null, DeltaA);
-            Assert.True(a.Recorded);
-            AssertBencodexEqual((Text)"abc", a.Get(new[] { KeyFoo })[0]);
-            AssertBencodexEqual((Text)"def", a.Get(new[] { KeyBar })[0]);
-            Assert.Null(a.Get(new[] { KeyBaz })[0]);
-
-            ITrie recordA = stateStore.GetStateRoot(a.Hash);
-            AssertBytesEqual(a.Hash, recordA.Hash);
-            AssertBencodexEqual((Text)"abc", recordA.Get(new[] { KeyFoo })[0]);
-            AssertBencodexEqual((Text)"def", recordA.Get(new[] { KeyBar })[0]);
-            Assert.Null(recordA.Get(new[] { KeyBaz })[0]);
-
-            ITrie b = stateStore.Commit(a.Hash, DeltaB);
-            Assert.True(b.Recorded);
-            AssertBencodexEqual((Text)"ABC", b.Get(new[] { KeyFoo })[0]);
-            AssertBencodexEqual((Text)"def", b.Get(new[] { KeyBar })[0]);
-            AssertBencodexEqual((Text)"ghi", b.Get(new[] { KeyBaz })[0]);
-        }
-
-        [Fact]
-        public void GetState()
-        {
-            IStateStore stateStore = new TrieStateStore(new DefaultKeyValueStore(null));
-            ITrie a = stateStore.Commit(null, DeltaA);
-            ITrie b = stateStore.Commit(a.Hash, DeltaB);
-
-            AssertBencodexEqual(
-                (Text)"abc", stateStore.GetStates(a.Hash, new[] { new KeyBytes("foo") })[0]);
-            AssertBencodexEqual(
-                (Text)"def", stateStore.GetStates(a.Hash, new[] { new KeyBytes("bar") })[0]);
-            AssertBencodexEqual(
-                null, stateStore.GetStates(a.Hash, new[] { new KeyBytes("baz") })[0]);
-
-            AssertBencodexEqual(
-                (Text)"ABC", stateStore.GetStates(b.Hash, new[] { new KeyBytes("foo") })[0]);
-            AssertBencodexEqual(
-                (Text)"def", stateStore.GetStates(b.Hash, new[] { new KeyBytes("bar") })[0]);
-            AssertBencodexEqual(
-                (Text)"ghi", stateStore.GetStates(b.Hash, new[] { new KeyBytes("baz") })[0]);
-        }
-
-        [Fact]
-        public void ContainsStateRoot()
-        {
-            IStateStore stateStore = new TrieStateStore(new DefaultKeyValueStore(null));
-            ITrie a = stateStore.Commit(null, DeltaA);
-            Assert.True(stateStore.ContainsStateRoot(a.Hash));
-        }
-    }
-}
diff --git a/Libplanet.Tests/Store/TrieStateStoreCommitTest.cs b/Libplanet.Tests/Store/TrieStateStoreCommitTest.cs
index 4d7381821e8..2ba0aa13cf3 100644
--- a/Libplanet.Tests/Store/TrieStateStoreCommitTest.cs
+++ b/Libplanet.Tests/Store/TrieStateStoreCommitTest.cs
@@ -19,13 +19,13 @@ public void CommitEmptyDoesNotWrite()
             HashDigest<SHA256> emptyRootHash = emptyTrie.Hash;
 
             Assert.Null(emptyTrie.Root);
-            Assert.True(stateStore.ContainsStateRoot(emptyRootHash));
+            Assert.True(stateStore.GetStateRoot(emptyRootHash).Recorded);
             Assert.False(keyValueStore.Exists(new KeyBytes(emptyRootHash.ByteArray)));
 
             emptyTrie = stateStore.Commit(emptyTrie);
             Assert.Null(emptyTrie.Root);
             Assert.Equal(emptyRootHash, emptyTrie.Hash);
-            Assert.True(stateStore.ContainsStateRoot(emptyRootHash));
+            Assert.True(stateStore.GetStateRoot(emptyRootHash).Recorded);
             Assert.False(keyValueStore.Exists(new KeyBytes(emptyRootHash.ByteArray)));
         }
 
@@ -47,8 +47,8 @@ public void Commit()
 
             Assert.NotEqual(hashBeforeCommit, hashAfterCommitOnce);
             Assert.Equal(hashAfterCommitOnce, hashAfterCommitTwice);
-            Assert.False(stateStore.ContainsStateRoot(hashBeforeCommit));
-            Assert.True(stateStore.ContainsStateRoot(hashAfterCommitOnce));
+            Assert.False(stateStore.GetStateRoot(hashBeforeCommit).Recorded);
+            Assert.True(stateStore.GetStateRoot(hashAfterCommitOnce).Recorded);
             Assert.False(keyValueStore.Exists(new KeyBytes(hashBeforeCommit.ByteArray)));
             Assert.True(keyValueStore.Exists(new KeyBytes(hashAfterCommitOnce.ByteArray)));
 
diff --git a/Libplanet.Tests/Store/TrieStateStoreTest.cs b/Libplanet.Tests/Store/TrieStateStoreTest.cs
index b99ee445ffc..4c38a56662c 100644
--- a/Libplanet.Tests/Store/TrieStateStoreTest.cs
+++ b/Libplanet.Tests/Store/TrieStateStoreTest.cs
@@ -50,7 +50,11 @@ public void GetStateRoot()
                 .Add(barKey, (Text)ByteUtil.Hex(GetRandomBytes(32)))
                 .Add(bazKey, (Bencodex.Types.Boolean)false)
                 .Add(quxKey, Bencodex.Types.Dictionary.Empty);
-            HashDigest<SHA256> hash = stateStore.Commit(null, values).Hash;
+            ITrie trie = stateStore.Commit(
+                values.Aggregate(
+                    stateStore.GetStateRoot(null),
+                    (prev, kv) => prev.Set(kv.Key, kv.Value)));
+            HashDigest<SHA256> hash = trie.Hash;
             ITrie found = stateStore.GetStateRoot(hash);
             Assert.True(found.Recorded);
             AssertBencodexEqual(values[fooKey], found.Get(new[] { KeyFoo })[0]);
@@ -77,12 +81,18 @@ public void PruneStates()
                         .Add("text", ByteUtil.Hex(GetRandomBytes(2048))));
 
             var stateStore = new TrieStateStore(_stateKeyValueStore);
-            ITrie first = stateStore.Commit(null, values);
+            ITrie first = stateStore.Commit(
+                values.Aggregate(
+                    stateStore.GetStateRoot(null),
+                    (prev, kv) => prev.Set(kv.Key, kv.Value)));
 
             int prevStatesCount = _stateKeyValueStore.ListKeys().Count();
             ImmutableDictionary<KeyBytes, IValue> nextState =
                 values.SetItem(new KeyBytes("foo"), (Binary)GetRandomBytes(4096));
-            ITrie second = stateStore.Commit(first.Hash, nextState);
+            ITrie second = stateStore.Commit(
+                nextState.Aggregate(
+                    first,
+                    (prev, kv) => prev.Set(kv.Key, kv.Value)));
 
             // foo = 0x666f6f
             // updated branch node (0x6, aka root) + updated branch node (0x66) +
@@ -115,7 +125,10 @@ public void CopyStates()
 
             IKeyValueStore targetStateKeyValueStore = new MemoryKeyValueStore();
             var targetStateStore = new TrieStateStore(targetStateKeyValueStore);
-            ITrie trie = stateStore.Commit(null, values);
+            ITrie trie = stateStore.Commit(
+                values.Aggregate(
+                    stateStore.GetStateRoot(null),
+                    (prev, kv) => prev.Set(kv.Key, kv.Value)));
             int prevStatesCount = _stateKeyValueStore.ListKeys().Count();
 
             _stateKeyValueStore.Set(

From 4bc58cedb91aad1cea3054870db6ea9944b1bc9a Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 6 Oct 2023 15:42:32 +0900
Subject: [PATCH 63/72] Changelog

---
 CHANGES.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 2d3e0fceb25..c156a74731a 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -24,6 +24,7 @@ To be released.
  -  Changed `BlockChain.EvaluateBlock()`'s return type to
     `IReadOnlyList<ICommittedActionEvaluation>` from
     `IReadOnlyList<IActionEvaluation>`.  [[#3445]]
+ -  Removed `StateStoreExtensions` class.  [[#3323], [#3450]]
 
 ### Backward-incompatible network protocol changes
 
@@ -48,9 +49,11 @@ To be released.
 
 ### CLI tools
 
+[#3323]: https://github.com/planetarium/libplanet/issues/3323
 [#3445]: https://github.com/planetarium/libplanet/pull/3445
 [#3446]: https://github.com/planetarium/libplanet/issues/3446
 [#3447]: https://github.com/planetarium/libplanet/pull/3447
+[#3450]: https://github.com/planetarium/libplanet/pull/3450
 
 
 Version 3.5.0

From ee141fb9677a1f4f6702e0e2c902c814243daada Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 15:24:09 +0900
Subject: [PATCH 64/72] feat: add field for query state by `StateRootHash`

---
 Libplanet.Explorer/Queries/StateQuery.cs | 221 ++++++++++++++++-------
 1 file changed, 155 insertions(+), 66 deletions(-)

diff --git a/Libplanet.Explorer/Queries/StateQuery.cs b/Libplanet.Explorer/Queries/StateQuery.cs
index 2895ae0c30a..d026122c79c 100644
--- a/Libplanet.Explorer/Queries/StateQuery.cs
+++ b/Libplanet.Explorer/Queries/StateQuery.cs
@@ -1,8 +1,10 @@
 using System;
+using System.Security.Cryptography;
 using GraphQL;
 using GraphQL.Types;
 using Libplanet.Action.State;
 using Libplanet.Blockchain.Policies;
+using Libplanet.Common;
 using Libplanet.Crypto;
 using Libplanet.Explorer.GraphTypes;
 using Libplanet.Types.Assets;
@@ -21,7 +23,8 @@ public StateQuery()
             arguments: new QueryArguments(
                 new QueryArgument<NonNullGraphType<ListGraphType<NonNullGraphType<AddressType>>>>
                     { Name = "addresses" },
-                new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "offsetBlockHash" }
+                new QueryArgument<IdGraphType> { Name = "offsetBlockHash" },
+                new QueryArgument<HashDigestSHA256Type> { Name = "offsetStateRootHash" }
             ),
             resolve: ResolveStates
         );
@@ -30,7 +33,8 @@ public StateQuery()
             arguments: new QueryArguments(
                 new QueryArgument<NonNullGraphType<AddressType>> { Name = "owner" },
                 new QueryArgument<NonNullGraphType<CurrencyInputType>> { Name = "currency" },
-                new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "offsetBlockHash" }
+                new QueryArgument<IdGraphType> { Name = "offsetBlockHash" },
+                new QueryArgument<HashDigestSHA256Type> { Name = "offsetStateRootHash" }
             ),
             resolve: ResolveBalance
         );
@@ -38,14 +42,16 @@ public StateQuery()
             "totalSupply",
             arguments: new QueryArguments(
                 new QueryArgument<NonNullGraphType<CurrencyInputType>> { Name = "currency" },
-                new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "offsetBlockHash" }
+                new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "offsetBlockHash" },
+                new QueryArgument<HashDigestSHA256Type> { Name = "offsetStateRootHash" }
             ),
             resolve: ResolveTotalSupply
         );
         Field<ListGraphType<NonNullGraphType<ValidatorType>>>(
             "validators",
             arguments: new QueryArguments(
-                new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "offsetBlockHash" }
+                new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "offsetBlockHash" },
+                new QueryArgument<HashDigestSHA256Type> { Name = "offsetStateRootHash" }
             ),
             resolve: ResolveValidatorSet
         );
@@ -55,25 +61,45 @@ private static object ResolveStates(
         IResolveFieldContext<(IBlockChainStates ChainStates, IBlockPolicy Policy)> context)
     {
         Address[] addresses = context.GetArgument<Address[]>("addresses");
-        string offsetBlockHash = context.GetArgument<string>("offsetBlockHash");
+        string? offsetBlockHash = context.GetArgument<string?>("offsetBlockHash");
+        HashDigest<SHA256>? offsetStateRootHash = context
+            .GetArgument<HashDigest<SHA256>?>("offsetStateRootHash");
 
-        BlockHash offset;
-        try
+        switch (blockhash: offsetBlockHash, srh: offsetStateRootHash)
         {
-            offset = BlockHash.FromString(offsetBlockHash);
-        }
-        catch (Exception e)
-        {
-            throw new ExecutionError(
-                "offsetBlockHash must consist of hexadecimal digits.\n" + e.Message,
-                e
-            );
-        }
+            case (blockhash: not null, srh: not null):
+                throw new ExecutionError(
+                    "offsetBlockHash and offsetStateRootHash cannot be specified at the same time."
+                );
+            case (blockhash: null, srh: null):
+                throw new ExecutionError(
+                    "Either offsetBlockHash or offsetStateRootHash must be specified."
+                );
+            case (blockhash: not null, _):
+            {
+                BlockHash offset;
+                try
+                {
+                    offset = BlockHash.FromString(offsetBlockHash);
+                }
+                catch (Exception e)
+                {
+                    throw new ExecutionError(
+                        "offsetBlockHash must consist of hexadecimal digits.\n" + e.Message,
+                        e
+                    );
+                }
 
-        return context.Source.ChainStates.GetStates(
-            addresses,
-            offset
-        );
+                return context.Source.ChainStates.GetAccountState(
+                    offset
+                ).GetStates(addresses);
+            }
+
+            case (_, srh: not null):
+                return context.Source.ChainStates.GetAccountState(
+                    offsetStateRootHash
+                ).GetStates(addresses);
+        }
     }
 
     private static object ResolveBalance(
@@ -81,33 +107,54 @@ private static object ResolveBalance(
     {
         Address owner = context.GetArgument<Address>("owner");
         Currency currency = context.GetArgument<Currency>("currency");
-        string offsetBlockHash = context.GetArgument<string>("offsetBlockHash");
+        string? offsetBlockHash = context.GetArgument<string?>("offsetBlockHash");
+        HashDigest<SHA256>? offsetStateRootHash = context
+            .GetArgument<HashDigest<SHA256>?>("offsetStateRootHash");
 
-        BlockHash offset;
-        try
+        switch (blockhash: offsetBlockHash, srh: offsetStateRootHash)
         {
-            offset = BlockHash.FromString(offsetBlockHash);
-        }
-        catch (Exception e)
-        {
-            throw new ExecutionError(
-                "offsetBlockHash must consist of hexadecimal digits.\n" + e.Message,
-                e
-            );
-        }
+            case (blockhash: not null, srh: not null):
+                throw new ExecutionError(
+                    "offsetBlockHash and offsetStateRootHash cannot be specified at the same time."
+                );
+            case (blockhash: null, srh: null):
+                throw new ExecutionError(
+                    "Either offsetBlockHash or offsetStateRootHash must be specified."
+                );
+            case (blockhash: not null, _):
+            {
+                BlockHash offset;
+                try
+                {
+                    offset = BlockHash.FromString(offsetBlockHash);
+                }
+                catch (Exception e)
+                {
+                    throw new ExecutionError(
+                        "offsetBlockHash must consist of hexadecimal digits.\n" + e.Message,
+                        e
+                    );
+                }
 
-        return context.Source.ChainStates.GetBalance(
-            owner,
-            currency,
-            offset
-        );
+                return context.Source.ChainStates.GetAccountState(
+                    offset
+                ).GetBalance(owner, currency);
+            }
+
+            case (_, srh: not null):
+                return context.Source.ChainStates.GetAccountState(
+                    offsetStateRootHash
+                ).GetBalance(owner, currency);
+        }
     }
 
     private static object? ResolveTotalSupply(
         IResolveFieldContext<(IBlockChainStates ChainStates, IBlockPolicy Policy)> context)
     {
         Currency currency = context.GetArgument<Currency>("currency");
-        string offsetBlockHash = context.GetArgument<string>("offsetBlockHash");
+        string? offsetBlockHash = context.GetArgument<string?>("offsetBlockHash");
+        HashDigest<SHA256>? offsetStateRootHash = context
+            .GetArgument<HashDigest<SHA256>?>("offsetStateRootHash");
 
         if (!currency.TotalSupplyTrackable)
         {
@@ -118,42 +165,84 @@ private static object ResolveBalance(
             throw new ExecutionError(msg);
         }
 
-        BlockHash offset;
-        try
+        switch (blockhash: offsetBlockHash, srh: offsetStateRootHash)
         {
-            offset = BlockHash.FromString(offsetBlockHash);
-        }
-        catch (Exception e)
-        {
-            throw new ExecutionError(
-                "offsetBlockHash must consist of hexadecimal digits.\n" + e.Message,
-                e
-            );
-        }
+            case (blockhash: not null, srh: not null):
+                throw new ExecutionError(
+                    "offsetBlockHash and offsetStateRootHash cannot be specified at the same time."
+                );
+            case (blockhash: null, srh: null):
+                throw new ExecutionError(
+                    "Either offsetBlockHash or offsetStateRootHash must be specified."
+                );
+            case (blockhash: not null, _):
+            {
+                BlockHash offset;
+                try
+                {
+                    offset = BlockHash.FromString(offsetBlockHash);
+                }
+                catch (Exception e)
+                {
+                    throw new ExecutionError(
+                        "offsetBlockHash must consist of hexadecimal digits.\n" + e.Message,
+                        e
+                    );
+                }
 
-        return context.Source.ChainStates.GetTotalSupply(
-            currency,
-            offset
-        );
+                return context.Source.ChainStates.GetAccountState(
+                    offset
+                ).GetTotalSupply(currency);
+            }
+
+            case (_, srh: not null):
+                return context.Source.ChainStates.GetAccountState(
+                    offsetStateRootHash
+                ).GetTotalSupply(currency);
+        }
     }
 
     private static object? ResolveValidatorSet(
         IResolveFieldContext<(IBlockChainStates ChainStates, IBlockPolicy Policy)> context)
     {
-        string offsetBlockHash = context.GetArgument<string>("offsetBlockHash");
-        BlockHash offset;
-        try
-        {
-            offset = BlockHash.FromString(offsetBlockHash);
-        }
-        catch (Exception e)
+        string? offsetBlockHash = context.GetArgument<string?>("offsetBlockHash");
+        HashDigest<SHA256>? offsetStateRootHash = context
+            .GetArgument<HashDigest<SHA256>?>("offsetStateRootHash");
+
+        switch (blockhash: offsetBlockHash, srh: offsetStateRootHash)
         {
-            throw new ExecutionError(
-                "offsetBlockHash must consist of hexadecimal digits.\n" + e.Message,
-                e
-            );
-        }
+            case (blockhash: not null, srh: not null):
+                throw new ExecutionError(
+                    "offsetBlockHash and offsetStateRootHash cannot be specified at the same time."
+                );
+            case (blockhash: null, srh: null):
+                throw new ExecutionError(
+                    "Either offsetBlockHash or offsetStateRootHash must be specified."
+                );
+            case (blockhash: not null, _):
+            {
+                BlockHash offset;
+                try
+                {
+                    offset = BlockHash.FromString(offsetBlockHash);
+                }
+                catch (Exception e)
+                {
+                    throw new ExecutionError(
+                        "offsetBlockHash must consist of hexadecimal digits.\n" + e.Message,
+                        e
+                    );
+                }
+
+                return context.Source.ChainStates.GetAccountState(
+                    offset
+                ).GetValidatorSet().Validators;
+            }
 
-        return context.Source.ChainStates.GetValidatorSet(offset).Validators;
+            case (_, srh: not null):
+                return context.Source.ChainStates.GetAccountState(
+                    offsetStateRootHash
+                ).GetValidatorSet().Validators;
+        }
     }
 }

From 9d7b970e7cd5fa4a599d465f42a7c839124b9a68 Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 15:24:38 +0900
Subject: [PATCH 65/72] test: throw exception when violate mutual exclusive

---
 .../Queries/StateQueryTest.cs                 | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs b/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
index e97f28ed96b..bd8d5b94c82 100644
--- a/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
+++ b/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
@@ -174,6 +174,26 @@ public async Task Validators()
         Assert.Equal("032038e153d344773986c039ba5dbff12ae70cfdf6ea8beb7c5ea9b361a72a9233", validatorDict["publicKey"]);
         Assert.Equal(new BigInteger(1), validatorDict["power"]);
     }
+    
+    [Fact]
+    public async Task ThrowExecutionErrorIfViolateMutualExclusive()
+    {
+        (IBlockChainStates, IBlockPolicy) source = (
+            new MockChainStates(), new BlockPolicy()
+        );
+        ExecutionResult result = await ExecuteQueryAsync<StateQuery>(@"
+        {
+            states(
+                 addresses: [""0x5003712B63baAB98094aD678EA2B24BcE445D076"", ""0x0000000000000000000000000000000000000000""],
+                 offsetBlockHash:
+                     ""01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b"",
+                 offsetStateRootHash:
+                     ""c33b27773104f75ac9df5b0533854108bd498fab31e5236b6f1e1f6404d5ef64""
+            )
+        }
+        ", source: source);
+        Assert.IsType<ExecutionErrors>(result.Errors);
+    }
 
     private class MockChainStates : IBlockChainStates
     {

From ffbad63c814f8274b783cad8d3ebe6619117d778 Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 15:28:35 +0900
Subject: [PATCH 66/72] docs: CHANGES.md

---
 CHANGES.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index c156a74731a..a8952cfe4dd 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -36,6 +36,18 @@ To be released.
     `HashDigest<SHA256>?`.  [[#3446], [#3447]]
  -  (Libplanet.Explorer) Added `TxResult.OutputState` of type
     `HashDigest<SHA256>?`.  [[#3446], [#3447]]
+ -  (Libplanet.Explorer) Added `offsetStateRootHash` of type
+    `HashDigest<SHA256>?` argument for `StateQuery.states` field.
+    [[#3448], [#3449]]
+ -  (Libplanet.Explorer) Added `offsetStateRootHash` of type
+    `HashDigest<SHA256>?` argument for `StateQuery.balance` field.
+    [[#3448], [#3449]]
+ -  (Libplanet.Explorer) Added `offsetStateRootHash` of type
+    `HashDigest<SHA256>?` argument for `StateQuery.totalSupply` field.
+    [[#3448], [#3449]]
+ -  (Libplanet.Explorer) Added `offsetStateRootHash` of type
+    `HashDigest<SHA256>?` argument for `StateQuery.validators` field.
+    [[#3448], [#3449]]
 
 ### Behavioral changes
 
@@ -53,6 +65,8 @@ To be released.
 [#3445]: https://github.com/planetarium/libplanet/pull/3445
 [#3446]: https://github.com/planetarium/libplanet/issues/3446
 [#3447]: https://github.com/planetarium/libplanet/pull/3447
+[#3448]: https://github.com/planetarium/libplanet/issues/3448
+[#3449]: https://github.com/planetarium/libplanet/pull/3449
 [#3450]: https://github.com/planetarium/libplanet/pull/3450
 
 

From 8a686aef28dc62834791d4ab5c505ac7287bc621 Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 16:55:35 +0900
Subject: [PATCH 67/72] test: add test case with `StateRootHash`

---
 .../Queries/StateQueryTest.cs                 | 181 ++++++++++++++++--
 1 file changed, 168 insertions(+), 13 deletions(-)

diff --git a/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs b/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
index bd8d5b94c82..2a8d24bd448 100644
--- a/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
+++ b/Libplanet.Explorer.Tests/Queries/StateQueryTest.cs
@@ -194,6 +194,158 @@ public async Task ThrowExecutionErrorIfViolateMutualExclusive()
         ", source: source);
         Assert.IsType<ExecutionErrors>(result.Errors);
     }
+    
+    [Fact]
+    public async Task StatesBySrh()
+    {
+        var currency = Currency.Uncapped("ABC", 2, minters: null);
+        (IBlockChainStates, IBlockPolicy) source = (
+            new MockChainStates(), new BlockPolicy()
+        );
+        ExecutionResult result = await ExecuteQueryAsync<StateQuery>(@"
+        {
+            states(
+                 addresses: [""0x5003712B63baAB98094aD678EA2B24BcE445D076"", ""0x0000000000000000000000000000000000000000""],
+                 offsetStateRootHash:
+                     ""c33b27773104f75ac9df5b0533854108bd498fab31e5236b6f1e1f6404d5ef64""
+            )
+        }
+        ", source: source);
+        Assert.Null(result.Errors);
+        ExecutionNode resultData = Assert.IsAssignableFrom<ExecutionNode>(result.Data);
+        IDictionary<string, object> resultDict =
+            Assert.IsAssignableFrom<IDictionary<string, object>>(resultData!.ToValue());
+        object[] states =
+            Assert.IsAssignableFrom<object[]>(resultDict["states"]);
+        Assert.Equal(new[] { new byte[] { 110, }, null }, states);
+    }
+
+    [Fact]
+    public async Task BalanceBySrh()
+    {
+        (IBlockChainStates, IBlockPolicy) source = (
+            new MockChainStates(),
+            new BlockPolicy()
+        );
+        ExecutionResult result = await ExecuteQueryAsync<StateQuery>(@"
+        {
+            balance(
+                 owner: ""0x5003712B63baAB98094aD678EA2B24BcE445D076"",
+                 currency: { ticker: ""ABC"", decimalPlaces: 2, totalSupplyTrackable: true },
+                 offsetStateRootHash:
+                     ""c33b27773104f75ac9df5b0533854108bd498fab31e5236b6f1e1f6404d5ef64""
+            ) {
+                currency { ticker, hash }
+                sign
+                majorUnit
+                minorUnit
+                quantity
+                string
+            }
+        }
+        ", source: source);
+        Assert.Null(result.Errors);
+        ExecutionNode resultData = Assert.IsAssignableFrom<ExecutionNode>(result.Data);
+        IDictionary<string, object> resultDict =
+            Assert.IsAssignableFrom<IDictionary<string, object>>(resultData!.ToValue());
+        IDictionary<string, object> balanceDict =
+            Assert.IsAssignableFrom<IDictionary<string, object>>(resultDict["balance"]);
+        IDictionary<string, object> currencyDict =
+            Assert.IsAssignableFrom<IDictionary<string, object>>(balanceDict["currency"]);
+        Assert.Equal("ABC", currencyDict["ticker"]);
+        Assert.Equal("84ba810ca5ac342c122eb7ef455939a8a05d1d40", currencyDict["hash"]);
+        Assert.Equal(1, Assert.IsAssignableFrom<int>(balanceDict["sign"]));
+        Assert.Equal(123, Assert.IsAssignableFrom<BigInteger>(balanceDict["majorUnit"]));
+        Assert.Equal(0, Assert.IsAssignableFrom<BigInteger>(balanceDict["minorUnit"]));
+        Assert.Equal("123", balanceDict["quantity"]);
+        Assert.Equal("123 ABC", balanceDict["string"]);
+    }
+
+    [Fact]
+    public async Task TotalSupplyBySrh()
+    {
+         var currency = Currency.Uncapped("ABC", 2, minters: null);
+#pragma warning disable CS0618  // Legacy, which is obsolete, is the only way to test this:
+         var legacyToken = Currency.Legacy("LEG", 0, null);
+#pragma warning restore CS0618
+         (IBlockChainStates, IBlockPolicy) source = (
+            new MockChainStates(), new BlockPolicy());
+        ExecutionResult result = await ExecuteQueryAsync<StateQuery>(@"
+        {
+            totalSupply(
+                 currency: { ticker: ""ABC"", decimalPlaces: 2, totalSupplyTrackable: true },
+                 offsetStateRootHash:
+                     ""c33b27773104f75ac9df5b0533854108bd498fab31e5236b6f1e1f6404d5ef64""
+            ) {
+                currency { ticker, hash }
+                sign
+                majorUnit
+                minorUnit
+                quantity
+                string
+            }
+        }
+        ", source: source);
+        Assert.Null(result.Errors);
+        ExecutionNode resultData = Assert.IsAssignableFrom<ExecutionNode>(result.Data);
+        IDictionary<string, object> resultDict =
+            Assert.IsAssignableFrom<IDictionary<string, object>>(resultData!.ToValue());
+        IDictionary<string, object> totalSupplyDict =
+            Assert.IsAssignableFrom<IDictionary<string, object>>(resultDict["totalSupply"]);
+        IDictionary<string, object> currencyDict =
+            Assert.IsAssignableFrom<IDictionary<string, object>>(totalSupplyDict["currency"]);
+        Assert.Equal("ABC", currencyDict["ticker"]);
+        Assert.Equal("84ba810ca5ac342c122eb7ef455939a8a05d1d40", currencyDict["hash"]);
+        Assert.Equal(1, Assert.IsAssignableFrom<int>(totalSupplyDict["sign"]));
+        Assert.Equal(10000, Assert.IsAssignableFrom<BigInteger>(totalSupplyDict["majorUnit"]));
+        Assert.Equal(0, Assert.IsAssignableFrom<BigInteger>(totalSupplyDict["minorUnit"]));
+        Assert.Equal("10000", totalSupplyDict["quantity"]);
+        Assert.Equal("10000 ABC", totalSupplyDict["string"]);
+
+        result = await ExecuteQueryAsync<StateQuery>(@"
+        {
+            totalSupply(
+                 currency: { ticker: ""LEG"", decimalPlaces: 0, totalSupplyTrackable: false },
+                 offsetBlockHash:
+                     ""01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b""
+            ) {
+                quantity
+            }
+        }
+        ", source: source);
+        Assert.Single(result.Errors);
+        Assert.Contains("not trackable", result.Errors[0].Message);
+    }
+
+    [Fact]
+    public async Task ValidatorsBySrh()
+    {
+         (IBlockChainStates, IBlockPolicy) source = (
+            new MockChainStates(),
+            new BlockPolicy()
+        );
+        ExecutionResult result = await ExecuteQueryAsync<StateQuery>(@"
+        {
+            validators(
+                 offsetStateRootHash:
+                     ""c33b27773104f75ac9df5b0533854108bd498fab31e5236b6f1e1f6404d5ef64""
+            ) {
+                publicKey
+                power
+            }
+        }
+        ", source: source);
+        Assert.Null(result.Errors);
+        ExecutionNode resultData = Assert.IsAssignableFrom<ExecutionNode>(result.Data);
+        IDictionary<string, object> resultDict =
+            Assert.IsAssignableFrom<IDictionary<string, object>>(resultData!.ToValue());
+        object[] validators = Assert.IsAssignableFrom<object[]>(resultDict["validators"]);
+        IDictionary<string, object> validatorDict =
+            Assert.IsAssignableFrom<IDictionary<string, object>>(validators[0]);
+        Assert.Equal("032038e153d344773986c039ba5dbff12ae70cfdf6ea8beb7c5ea9b361a72a9233", validatorDict["publicKey"]);
+        Assert.Equal(new BigInteger(1), validatorDict["power"]);
+    }
+    
 
     private class MockChainStates : IBlockChainStates
     {
@@ -214,9 +366,11 @@ public FungibleAssetValue GetTotalSupply(Currency currency, BlockHash? offset) =
         public ValidatorSet GetValidatorSet(BlockHash? offset) =>
             GetAccountState(offset).GetValidatorSet();
 
-        public IAccountState GetAccountState(BlockHash? offset) => new MockAccount(offset);
+        public IAccountState GetAccountState(BlockHash? offset) => 
+            new MockAccount(offset, null);
 
-        public IAccountState GetAccountState(HashDigest<SHA256>? hash) => new MockAccount(null);
+        public IAccountState GetAccountState(HashDigest<SHA256>? hash) =>
+            new MockAccount(null, hash);
 
         public ITrie GetTrie(BlockHash? offset)
         {
@@ -226,9 +380,10 @@ public ITrie GetTrie(BlockHash? offset)
 
     private class MockAccount : IAccount
     {
-        public MockAccount(BlockHash? blockHash)
+        public MockAccount(BlockHash? blockHash, HashDigest<SHA256>? stateRootHash)
         {
             BlockHash = blockHash ?? default;
+            StateRootHash = stateRootHash ?? default;
         }
 
         public ITrie Trie { get; }
@@ -237,6 +392,8 @@ public MockAccount(BlockHash? blockHash)
 
         public BlockHash BlockHash { get; }
 
+        public HashDigest<SHA256> StateRootHash { get; }
+
         public IImmutableSet<(Address, Currency)> TotalUpdatedFungibleAssets { get; }
         public IAccount SetState(Address address, IValue state)
         {
@@ -268,26 +425,24 @@ public IAccount SetValidator(Validator validator)
         public IValue GetState(Address address) => GetStates(new[] { address }).First();
 
         public IReadOnlyList<IValue> GetStates(IReadOnlyList<Address> addresses) =>
-            BlockHash is { } _
-                ? addresses.Select(address => address.ToString() switch
-                {
-                    "0x5003712B63baAB98094aD678EA2B24BcE445D076" => (IValue)Null.Value,
-                    _ => null,
-                }).ToImmutableList()
-                : addresses.Select(address => (IValue)null).ToList();
+            addresses.Select(address => address.ToString() switch
+            {
+                "0x5003712B63baAB98094aD678EA2B24BcE445D076" => (IValue)Null.Value,
+                _ => null,
+            }).ToImmutableList();
 
         public FungibleAssetValue GetBalance(Address address, Currency currency) =>
-            BlockHash is { } _
+            BlockHash is { } && StateRootHash is { }
                 ? currency * 123
                 : currency * 0;
 
         public FungibleAssetValue GetTotalSupply(Currency currency) =>
-            BlockHash is { } _
+            BlockHash is { } && StateRootHash is { }
                 ? currency * 10000
                 : currency * 0;
 
         public ValidatorSet GetValidatorSet() =>
-            BlockHash is { } _
+            BlockHash is { } && StateRootHash is { }
                 ? new ValidatorSet(new List<Validator>
                 {
                     new(

From 47620844bed0f1b5df32e612e3155849b7e989ee Mon Sep 17 00:00:00 2001
From: Suho Lee <iam@suho.io>
Date: Fri, 6 Oct 2023 16:56:02 +0900
Subject: [PATCH 68/72] fix: remove `NonNull` argument from `TotalSupply` and
 `Validators`

---
 Libplanet.Explorer/Queries/StateQuery.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Libplanet.Explorer/Queries/StateQuery.cs b/Libplanet.Explorer/Queries/StateQuery.cs
index d026122c79c..4b2e9ce4e52 100644
--- a/Libplanet.Explorer/Queries/StateQuery.cs
+++ b/Libplanet.Explorer/Queries/StateQuery.cs
@@ -42,7 +42,7 @@ public StateQuery()
             "totalSupply",
             arguments: new QueryArguments(
                 new QueryArgument<NonNullGraphType<CurrencyInputType>> { Name = "currency" },
-                new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "offsetBlockHash" },
+                new QueryArgument<IdGraphType> { Name = "offsetBlockHash" },
                 new QueryArgument<HashDigestSHA256Type> { Name = "offsetStateRootHash" }
             ),
             resolve: ResolveTotalSupply
@@ -50,7 +50,7 @@ public StateQuery()
         Field<ListGraphType<NonNullGraphType<ValidatorType>>>(
             "validators",
             arguments: new QueryArguments(
-                new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "offsetBlockHash" },
+                new QueryArgument<IdGraphType> { Name = "offsetBlockHash" },
                 new QueryArgument<HashDigestSHA256Type> { Name = "offsetStateRootHash" }
             ),
             resolve: ResolveValidatorSet

From 99e4103018faeb05ec1a274bc5b19c300bdd8bd1 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 6 Oct 2023 18:08:29 +0900
Subject: [PATCH 69/72] Release 3.6.0

---
 CHANGES.md | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index a8952cfe4dd..b87d98cf5bb 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -4,9 +4,7 @@ Libplanet changelog
 Version 3.6.0
 -------------
 
-To be released.
-
-### Deprecated APIs
+Released on October 6, 2023.
 
 ### Backward-incompatible API changes
 
@@ -26,10 +24,6 @@ To be released.
     `IReadOnlyList<IActionEvaluation>`.  [[#3445]]
  -  Removed `StateStoreExtensions` class.  [[#3323], [#3450]]
 
-### Backward-incompatible network protocol changes
-
-### Backward-incompatible storage format changes
-
 ### Added APIs
 
  -  (Libplanet.Explorer) Added `TxResult.InputState` of type
@@ -55,12 +49,6 @@ To be released.
     and `BlockChain.EvaluateBlock()` have a side-effect of storing
     data to `IStateStore` when called.  [[#3445]]
 
-### Bug fixes
-
-### Dependencies
-
-### CLI tools
-
 [#3323]: https://github.com/planetarium/libplanet/issues/3323
 [#3445]: https://github.com/planetarium/libplanet/pull/3445
 [#3446]: https://github.com/planetarium/libplanet/issues/3446

From 1722d4fb254d6e1366b926fc53cabd07dbede07e Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Fri, 6 Oct 2023 21:54:42 +0900
Subject: [PATCH 70/72] Prepare 3.7.0

---
 CHANGES.md                 | 24 ++++++++++++++++++++++++
 Libplanet/Libplanet.csproj |  2 +-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index b87d98cf5bb..d58105403b8 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,30 @@
 Libplanet changelog
 ===================
 
+Version 3.7.0
+-------------
+
+To be released.
+
+### Deprecated APIs
+
+### Backward-incompatible API changes
+
+### Backward-incompatible network protocol changes
+
+### Backward-incompatible storage format changes
+
+### Added APIs
+
+### Behavioral changes
+
+### Bug fixes
+
+### Dependencies
+
+### CLI tools
+
+
 Version 3.6.0
 -------------
 
diff --git a/Libplanet/Libplanet.csproj b/Libplanet/Libplanet.csproj
index 9de444533bb..5f002332417 100644
--- a/Libplanet/Libplanet.csproj
+++ b/Libplanet/Libplanet.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <PackageId>Libplanet</PackageId>
     <Title>Libplanet</Title>
-    <VersionPrefix>3.6.0</VersionPrefix>
+    <VersionPrefix>3.7.0</VersionPrefix>
     <!-- Note: don't be confused by the word "prefix" here.  It's merely a
     version without suffix like "-dev.123".  See the following examples:
       Version: 1.2.3-dev.456

From 0e8cb7af9ee23d25f1d64e74dfeba9781e0e54e7 Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 12 Oct 2023 21:52:00 +0900
Subject: [PATCH 71/72] Optimized BlockMarshaler

---
 Libplanet.Types/Blocks/BlockMarshaler.cs | 94 +++++++++++++++---------
 1 file changed, 61 insertions(+), 33 deletions(-)

diff --git a/Libplanet.Types/Blocks/BlockMarshaler.cs b/Libplanet.Types/Blocks/BlockMarshaler.cs
index a6b41708d0f..f731804df38 100644
--- a/Libplanet.Types/Blocks/BlockMarshaler.cs
+++ b/Libplanet.Types/Blocks/BlockMarshaler.cs
@@ -17,27 +17,56 @@ namespace Libplanet.Types.Blocks
     public static class BlockMarshaler
     {
         // Block fields:
-        internal static readonly byte[] HeaderKey = { 0x48 }; // 'H'
-        internal static readonly byte[] TransactionsKey = { 0x54 }; // 'T'
+        internal static readonly Binary HeaderKey = new Binary(new byte[] { 0x48 }); // 'H'
+        internal static readonly Binary TransactionsKey = new Binary(new byte[] { 0x54 }); // 'T'
 
         private const string TimestampFormat = "yyyy-MM-ddTHH:mm:ss.ffffffZ";
 
         // Header fields:
-        private static readonly byte[] ProtocolVersionKey = { 0x00 };
-        private static readonly byte[] IndexKey = { 0x69 }; // 'i'
-        private static readonly byte[] TimestampKey = { 0x74 }; // 't'
-        private static readonly byte[] DifficultyKey = { 0x64 }; // 'd'; Legacy, unused.
-        private static readonly byte[] TotalDifficultyKey = { 0x54 }; // 'T'; Legacy, unused.
-        private static readonly byte[] NonceKey = { 0x6e }; // 'n'; Legacy, unused.
-        private static readonly byte[] MinerKey = { 0x6d }; // 'm'
-        private static readonly byte[] PublicKeyKey = { 0x50 }; // 'P'
-        private static readonly byte[] PreviousHashKey = { 0x70 }; // 'p'
-        private static readonly byte[] TxHashKey = { 0x78 }; // 'x'
-        private static readonly byte[] HashKey = { 0x68 }; // 'h'
-        private static readonly byte[] StateRootHashKey = { 0x73 }; // 's'
-        private static readonly byte[] SignatureKey = { 0x53 }; // 'S'
-        private static readonly byte[] PreEvaluationHashKey = { 0x63 }; // 'c'
-        private static readonly byte[] LastCommitKey = { 0x43 }; // 'C'
+        private static readonly Binary ProtocolVersionKey =
+            new Binary(new byte[] { 0x00 });
+
+        private static readonly Binary IndexKey =
+            new Binary(new byte[] { 0x69 }); // 'i'
+
+        private static readonly Binary TimestampKey =
+            new Binary(new byte[] { 0x74 }); // 't'
+
+        private static readonly Binary DifficultyKey =
+            new Binary(new byte[] { 0x64 }); // 'd'; Legacy, unused.
+
+        private static readonly Binary TotalDifficultyKey =
+            new Binary(new byte[] { 0x54 }); // 'T'; Legacy, unused.
+
+        private static readonly Binary NonceKey =
+            new Binary(new byte[] { 0x6e }); // 'n'; Legacy, unused.
+
+        private static readonly Binary MinerKey =
+            new Binary(new byte[] { 0x6d }); // 'm'
+
+        private static readonly Binary PublicKeyKey =
+            new Binary(new byte[] { 0x50 }); // 'P'
+
+        private static readonly Binary PreviousHashKey =
+            new Binary(new byte[] { 0x70 }); // 'p'
+
+        private static readonly Binary TxHashKey =
+            new Binary(new byte[] { 0x78 }); // 'x'
+
+        private static readonly Binary HashKey =
+            new Binary(new byte[] { 0x68 }); // 'h'
+
+        private static readonly Binary StateRootHashKey =
+            new Binary(new byte[] { 0x73 }); // 's'
+
+        private static readonly Binary SignatureKey =
+            new Binary(new byte[] { 0x53 }); // 'S'
+
+        private static readonly Binary PreEvaluationHashKey =
+            new Binary(new byte[] { 0x63 }); // 'c'
+
+        private static readonly Binary LastCommitKey =
+            new Binary(new byte[] { 0x43 }); // 'C'
 
         public static Dictionary MarshalBlockMetadata(IBlockMetadata metadata)
         {
@@ -150,7 +179,7 @@ public static Dictionary MarshalBlock(this Block block) =>
                 MarshalTransactions(block.Transactions));
 
         public static long UnmarshalBlockMetadataIndex(Dictionary marshaledMetadata) =>
-            marshaledMetadata.GetValue<Integer>(IndexKey);
+            (Integer)marshaledMetadata[IndexKey];
 
         public static BlockMetadata UnmarshalBlockMetadata(Dictionary marshaled)
         {
@@ -158,40 +187,40 @@ public static BlockMetadata UnmarshalBlockMetadata(Dictionary marshaled)
             PublicKey? publicKey = null;
             if (marshaled.ContainsKey(PublicKeyKey))
             {
-                publicKey = new PublicKey(marshaled.GetValue<Binary>(PublicKeyKey).ByteArray);
+                publicKey = new PublicKey(((Binary)marshaled[PublicKeyKey]).ByteArray);
                 miner = publicKey.ToAddress();
             }
             else
             {
-                miner = new Address(marshaled.GetValue<Binary>(MinerKey).ByteArray);
+                miner = new Address(marshaled[MinerKey]);
             }
 
 #pragma warning disable SA1118 // The parameter spans multiple lines
             return new BlockMetadata(
                 protocolVersion: marshaled.ContainsKey(ProtocolVersionKey)
-                    ? (int)marshaled.GetValue<Integer>(ProtocolVersionKey)
+                    ? (int)(Integer)marshaled[ProtocolVersionKey]
                     : 0,
                 index: UnmarshalBlockMetadataIndex(marshaled),
                 timestamp: DateTimeOffset.ParseExact(
-                    marshaled.GetValue<Text>(TimestampKey),
+                    (Text)marshaled[TimestampKey],
                     TimestampFormat,
                     CultureInfo.InvariantCulture),
                 miner: miner,
                 publicKey: publicKey,
                 previousHash: marshaled.ContainsKey(PreviousHashKey)
-                    ? new BlockHash(marshaled.GetValue<IValue>(PreviousHashKey))
+                    ? new BlockHash(marshaled[PreviousHashKey])
                     : (BlockHash?)null,
                 txHash: marshaled.ContainsKey(TxHashKey)
-                    ? new HashDigest<SHA256>(marshaled.GetValue<Binary>(TxHashKey).ByteArray)
+                    ? new HashDigest<SHA256>(((Binary)marshaled[TxHashKey]).ByteArray)
                     : (HashDigest<SHA256>?)null,
                 lastCommit: marshaled.ContainsKey(LastCommitKey)
-                    ? new BlockCommit(marshaled.GetValue<IValue>(LastCommitKey))
+                    ? new BlockCommit(marshaled[LastCommitKey])
                     : (BlockCommit?)null);
 #pragma warning restore SA1118
         }
 
         public static HashDigest<SHA256> UnmarshalPreEvaluationHash(Dictionary marshaled) =>
-            new HashDigest<SHA256>(marshaled.GetValue<Binary>(PreEvaluationHashKey).ByteArray);
+            new HashDigest<SHA256>(((Binary)marshaled[PreEvaluationHashKey]).ByteArray);
 
         public static PreEvaluationBlockHeader UnmarshalPreEvaluationBlockHeader(
             Dictionary marshaled)
@@ -203,25 +232,24 @@ public static PreEvaluationBlockHeader UnmarshalPreEvaluationBlockHeader(
 
         public static BlockHash UnmarshalBlockHash(Dictionary marshaledBlock)
         {
-            Dictionary blockHeader = marshaledBlock.GetValue<Dictionary>(HeaderKey);
+            Dictionary blockHeader = (Dictionary)marshaledBlock[HeaderKey];
             return UnmarshalBlockHeaderHash(blockHeader);
         }
 
         public static BlockHash UnmarshalBlockHeaderHash(Dictionary marshaledBlockHeader) =>
-            new BlockHash(marshaledBlockHeader.GetValue<IValue>(HashKey));
+            new BlockHash(marshaledBlockHeader[HashKey]);
 
         public static HashDigest<SHA256> UnmarshalBlockHeaderStateRootHash(
             Dictionary marshaledBlockHeader
         ) =>
             new HashDigest<SHA256>(
-                marshaledBlockHeader.GetValue<Binary>(StateRootHashKey).ByteArray
-            );
+                ((Binary)marshaledBlockHeader[StateRootHashKey]).ByteArray);
 
         public static ImmutableArray<byte>? UnmarshalBlockHeaderSignature(
             Dictionary marshaledBlockHeader
         ) =>
             marshaledBlockHeader.ContainsKey(SignatureKey)
-                ? marshaledBlockHeader.GetValue<Binary>(SignatureKey).ByteArray
+                ? ((Binary)marshaledBlockHeader[SignatureKey]).ByteArray
                 : (ImmutableArray<byte>?)null;
 
         public static BlockHeader UnmarshalBlockHeader(Dictionary marshaled)
@@ -241,12 +269,12 @@ public static IReadOnlyList<Transaction> UnmarshalTransactions(List marshaled) =
         public static IReadOnlyList<Transaction> UnmarshalBlockTransactions(
             Dictionary marshaledBlock) =>
             marshaledBlock.ContainsKey(TransactionsKey)
-                ? UnmarshalTransactions(marshaledBlock.GetValue<List>(TransactionsKey))
+                ? UnmarshalTransactions((List)marshaledBlock[TransactionsKey])
                 : ImmutableArray<Transaction>.Empty;
 
         public static Block UnmarshalBlock(Dictionary marshaled)
         {
-            BlockHeader header = UnmarshalBlockHeader(marshaled.GetValue<Dictionary>(HeaderKey));
+            BlockHeader header = UnmarshalBlockHeader((Dictionary)marshaled[HeaderKey]);
             IReadOnlyList<Transaction> txs = UnmarshalBlockTransactions(marshaled);
             return new Block(header, txs);
         }

From bd218520742c2b0877fe99d9d21a5d385373ca4f Mon Sep 17 00:00:00 2001
From: Say Cheong <greymistcube@gmail.com>
Date: Thu, 12 Oct 2023 22:08:45 +0900
Subject: [PATCH 72/72] Changelog

---
 CHANGES.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index d58105403b8..ec4fd2caaeb 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -18,12 +18,16 @@ To be released.
 
 ### Behavioral changes
 
+ -  Slightly optimized `BlockMarshaler`.  [[#3454]]
+
 ### Bug fixes
 
 ### Dependencies
 
 ### CLI tools
 
+[#3454]: https://github.com/planetarium/libplanet/pull/3454
+
 
 Version 3.6.0
 -------------