Store notification merkleRoot in TransactionState

src/Neo/Ledger/Blockchain.cs

@@ -11,6 +11,7 @@
 using Akka.Actor;
 using Akka.Configuration;
 using Akka.IO;
+using Neo.Cryptography;
 using Neo.IO.Actors;
 using Neo.Network.P2P;
 using Neo.Network.P2P.Payloads;
@@ -422,6 +423,9 @@ private void Persist(Block block)
                     using ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Application, tx, clonedSnapshot, block, system.Settings, tx.SystemFee);
                     engine.LoadScript(tx.Script);
                     transactionState.State = engine.Execute();
+                    ApplicationExecuted application_executed = new(engine);
+                    transactionState.NotificationMerkleRoot =
+                            MerkleTree.ComputeRoot(application_executed.Notifications.Select(p => p.GetNotificationHash()).ToArray());
                     if (transactionState.State == VMState.HALT)
                     {
                         clonedSnapshot.Commit();
@@ -430,7 +434,6 @@ private void Persist(Block block)
                     {
                         clonedSnapshot = snapshot.CreateSnapshot();
                     }
-                    ApplicationExecuted application_executed = new(engine);
                     Context.System.EventStream.Publish(application_executed);
                     all_application_executed.Add(application_executed);
                 }

src/Neo/SmartContract/Native/LedgerContract.cs

@@ -41,7 +41,8 @@ internal override ContractTask OnPersist(ApplicationEngine engine)
             {
                 BlockIndex = engine.PersistingBlock.Index,
                 Transaction = p,
-                State = VMState.NONE
+                State = VMState.NONE,
+                NotificationMerkleRoot = UInt256.Zero
             }).ToArray();
             engine.Snapshot.Add(CreateStorageKey(Prefix_BlockHash).AddBigEndian(engine.PersistingBlock.Index), new StorageItem(engine.PersistingBlock.Hash.ToArray()));
             engine.Snapshot.Add(CreateStorageKey(Prefix_Block).Add(engine.PersistingBlock.Hash), new StorageItem(Trim(engine.PersistingBlock).ToArray()));

src/Neo/SmartContract/Native/TransactionState.cs

@@ -39,6 +39,11 @@ public class TransactionState : IInteroperable
         /// </summary>
         public VMState State;
 
+        /// <summary>
+        /// The merkle root of the notifications.
+        /// </summary>
+        public UInt256 NotificationMerkleRoot;
+
         private ReadOnlyMemory<byte> _rawTransaction;
 
         IInteroperable IInteroperable.Clone()
@@ -49,6 +54,7 @@ IInteroperable IInteroperable.Clone()
                 Transaction = Transaction,
                 ConflictingSigners = ConflictingSigners,
                 State = State,
+                NotificationMerkleRoot = NotificationMerkleRoot,
                 _rawTransaction = _rawTransaction
             };
         }
@@ -60,6 +66,7 @@ void IInteroperable.FromReplica(IInteroperable replica)
             Transaction = from.Transaction;
             ConflictingSigners = from.ConflictingSigners;
             State = from.State;
+            NotificationMerkleRoot = from.NotificationMerkleRoot;
             if (_rawTransaction.IsEmpty)
                 _rawTransaction = from._rawTransaction;
         }
@@ -76,14 +83,15 @@ void IInteroperable.FromStackItem(StackItem stackItem)
             _rawTransaction = ((ByteString)@struct[1]).Memory;
             Transaction = _rawTransaction.AsSerializable<Transaction>();
             State = (VMState)(byte)@struct[2].GetInteger();
+            NotificationMerkleRoot = new UInt256(@struct[3].GetSpan());
         }
 
         StackItem IInteroperable.ToStackItem(ReferenceCounter referenceCounter)
         {
             if (Transaction is null) return new Struct(referenceCounter) { new VM.Types.Array(referenceCounter, ConflictingSigners.Select(u => new ByteString(u.ToArray())).ToArray()) };
             if (_rawTransaction.IsEmpty)
                 _rawTransaction = Transaction.ToArray();
-            return new Struct(referenceCounter) { BlockIndex, _rawTransaction, (byte)State };
+            return new Struct(referenceCounter) { BlockIndex, _rawTransaction, (byte)State, NotificationMerkleRoot.ToArray() };
         }
     }
 }

src/Neo/SmartContract/NotifyEventArgs.cs

@@ -8,11 +8,13 @@
 // Redistribution and use in source and binary forms with or without
 // modifications are permitted.
 
+using Neo.Cryptography;
 using Neo.IO;
 using Neo.Network.P2P.Payloads;
 using Neo.VM;
 using Neo.VM.Types;
 using System;
+using System.IO;
 using Array = Neo.VM.Types.Array;
 
 namespace Neo.SmartContract
@@ -57,6 +59,31 @@ public NotifyEventArgs(IVerifiable container, UInt160 script_hash, string eventN
             this.State = state;
         }
 
+        /// <summary>
+        /// Get notification Hash, or UInt256.Zero if something is wrong
+        /// </summary>
+        public UInt256 GetNotificationHash()
+        {
+            using MemoryStream ms = new();
+            using BinaryWriter writer = new(ms, Utility.StrictUTF8, true);
+            writer.Write(ScriptHash);
+
+            try
+            {
+                writer.Write(EventName);
+                writer.Write(BinarySerializer.Serialize(State, 32));
+            }
+            catch
+            {
+                // It might have more state entries than expected or an unsupported event name encoding.
+
+                return UInt256.Zero;
+            }
+
+            writer.Flush();
+            return new UInt256(ms.ToArray().Sha256());
+        }
+
         public void FromStackItem(StackItem stackItem)
         {
             throw new NotSupportedException();

tests/Neo.UnitTests/Ledger/UT_TransactionState.cs

@@ -32,15 +32,17 @@ public void Initialize()
                         InvocationScript=Array.Empty<byte>(),
                         VerificationScript=Array.Empty<byte>()
                     } }
-                }
+                },
+                NotificationMerkleRoot = UInt256.Zero
             };
             originTrimmed = new TransactionState
             {
+                NotificationMerkleRoot = UInt256.Zero,
                 ConflictingSigners = new UInt160[]
-            {
-                new UInt160(Crypto.Hash160(new byte[] { 1, 2, 3 })),
-                new UInt160(Crypto.Hash160(new byte[] { 4, 5, 6 }))
-            }
+                {
+                    new UInt160(Crypto.Hash160(new byte[] { 1, 2, 3 })),
+                    new UInt160(Crypto.Hash160(new byte[] { 4, 5, 6 }))
+                }
             };
         }
 
@@ -50,7 +52,10 @@ public void TestDeserialize()
             var data = BinarySerializer.Serialize(((IInteroperable)origin).ToStackItem(null), 1024);
             var reader = new MemoryReader(data);
 
-            TransactionState dest = new();
+            TransactionState dest = new()
+            {
+                NotificationMerkleRoot = UInt256.Zero
+            };
             ((IInteroperable)dest).FromStackItem(BinarySerializer.Deserialize(ref reader, ExecutionEngineLimits.Default, null));
 
             dest.BlockIndex.Should().Be(origin.BlockIndex);
@@ -64,7 +69,10 @@ public void TestDeserializeTrimmed()
             var data = BinarySerializer.Serialize(((IInteroperable)originTrimmed).ToStackItem(null), 1024);
             var reader = new MemoryReader(data);
 
-            TransactionState dest = new();
+            TransactionState dest = new()
+            {
+                NotificationMerkleRoot = UInt256.Zero
+            };
             ((IInteroperable)dest).FromStackItem(BinarySerializer.Deserialize(ref reader, ExecutionEngineLimits.Default, null));
 
             dest.BlockIndex.Should().Be(0);