Ensure that view interops can't be changed outside

src/Neo.VM/Debugger.cs

@@ -63,7 +63,7 @@ private void ExecuteAndCheckBreakPoints()
             engine.ExecuteNext();
             if (engine.State == VMState.NONE && engine.InvocationStack.Count > 0 && break_points.Count > 0)
             {
-                if (break_points.TryGetValue(engine.CurrentContext!.Script, out HashSet<uint>? hashset) && hashset.Contains((uint)engine.CurrentContext.InstructionPointer))
+                if (break_points.TryGetValue(engine.CurrentContext!.Script, out var hashset) && hashset.Contains((uint)engine.CurrentContext.InstructionPointer))
                     engine.State = VMState.BREAK;
             }
         }
@@ -79,7 +79,7 @@ private void ExecuteAndCheckBreakPoints()
         /// </returns>
         public bool RemoveBreakPoint(Script script, uint position)
         {
-            if (!break_points.TryGetValue(script, out HashSet<uint>? hashset)) return false;
+            if (!break_points.TryGetValue(script, out var hashset)) return false;
             if (!hashset.Remove(position)) return false;
             if (hashset.Count == 0) break_points.Remove(script);
             return true;

src/Neo/SmartContract/BinarySerializer.cs

@@ -83,10 +83,10 @@ public static StackItem Deserialize(ref MemoryReader reader, ExecutionEngineLimi
         public static StackItem Deserialize(ref MemoryReader reader, uint maxSize, uint maxItems, IReferenceCounter referenceCounter = null)
         {
             Stack<StackItem> deserialized = new();
-            int undeserialized = 1;
+            var undeserialized = 1;
             while (undeserialized-- > 0)
             {
-                StackItemType type = (StackItemType)reader.ReadByte();
+                var type = (StackItemType)reader.ReadByte();
                 switch (type)
                 {
                     case StackItemType.Any:
@@ -102,7 +102,7 @@ public static StackItem Deserialize(ref MemoryReader reader, uint maxSize, uint
                         deserialized.Push(reader.ReadVarMemory((int)maxSize));
                         break;
                     case StackItemType.Buffer:
-                        ReadOnlyMemory<byte> memory = reader.ReadVarMemory((int)maxSize);
+                        var memory = reader.ReadVarMemory((int)maxSize);
                         deserialized.Push(new Buffer(memory.Span));
                         break;
                     case StackItemType.Array:

src/Neo/SmartContract/Native/ContractManagement.cs

@@ -214,7 +214,7 @@ public bool HasMethod(IReadOnlyStore snapshot, UInt160 hash, string method, int
         public IEnumerable<ContractState> ListContracts(IReadOnlyStore snapshot)
         {
             var listContractsPrefix = CreateStorageKey(Prefix_Contract);
-            return snapshot.Find(listContractsPrefix).Select(kvp => kvp.Value.GetInteroperable<ContractState>(false));
+            return snapshot.Find(listContractsPrefix).Select(kvp => kvp.Value.GetInteroperableClone<ContractState>(false));
         }
 
         [ContractMethod(RequiredCallFlags = CallFlags.All)]

src/Neo/SmartContract/Native/NeoToken.cs

@@ -538,7 +538,7 @@ public ECPoint[] GetCommittee(IReadOnlyStore snapshot)
         public NeoAccountState GetAccountState(IReadOnlyStore snapshot, UInt160 account)
         {
             var key = CreateStorageKey(Prefix_Account, account);
-            return snapshot.TryGet(key, out var item) ? item.GetInteroperable<NeoAccountState>() : null;
+            return snapshot.TryGet(key, out var item) ? item.GetInteroperableClone<NeoAccountState>() : null;
         }
 
         /// <summary>

src/Neo/SmartContract/Native/OracleContract.cs

@@ -104,7 +104,7 @@ private UInt256 GetOriginalTxid(ApplicationEngine engine)
         public OracleRequest GetRequest(IReadOnlyStore snapshot, ulong id)
         {
             var key = CreateStorageKey(Prefix_Request, id);
-            return snapshot.TryGet(key, out var item) ? item.GetInteroperable<OracleRequest>() : null;
+            return snapshot.TryGet(key, out var item) ? item.GetInteroperableClone<OracleRequest>() : null;
         }
 
         /// <summary>
@@ -116,7 +116,7 @@ public OracleRequest GetRequest(IReadOnlyStore snapshot, ulong id)
         {
             var key = CreateStorageKey(Prefix_Request);
             return snapshot.Find(key)
-                .Select(p => (BinaryPrimitives.ReadUInt64BigEndian(p.Key.Key.Span[1..]), p.Value.GetInteroperable<OracleRequest>()));
+                .Select(p => (BinaryPrimitives.ReadUInt64BigEndian(p.Key.Key.Span[1..]), p.Value.GetInteroperableClone<OracleRequest>()));
         }
 
         /// <summary>
@@ -133,7 +133,7 @@ public OracleRequest GetRequest(IReadOnlyStore snapshot, ulong id)
             foreach (ulong id in list)
             {
                 var key = CreateStorageKey(Prefix_Request, id);
-                yield return (id, snapshot[key].GetInteroperable<OracleRequest>());
+                yield return (id, snapshot[key].GetInteroperableClone<OracleRequest>());
             }
         }
 

src/Neo/SmartContract/StorageItem.cs

@@ -95,7 +95,7 @@ public StorageItem(IInteroperable interoperable)
         }
 
         /// <summary>
-        /// Create a new instance from an sealed <see cref="IInteroperable"/> class. 
+        /// Create a new instance from an sealed <see cref="IInteroperable"/> class.
         /// </summary>
         /// <param name="interoperable">The <see cref="IInteroperable"/> value of the <see cref="StorageItem"/>.</param>
         /// <returns><see cref="StorageItem"/> class</returns>
@@ -187,32 +187,60 @@ public void FromReplica(StorageItem replica)
         /// <returns>The <see cref="IInteroperable"/> in the storage.</returns>
         public T GetInteroperable<T>() where T : IInteroperable, new()
         {
-            if (_cache is null)
-            {
-                var interoperable = new T();
-                interoperable.FromStackItem(BinarySerializer.Deserialize(_value, ExecutionEngineLimits.Default));
-                _cache = interoperable;
-            }
+            _cache ??= GetInteroperableClone<T>();
             _value = null;
             return (T)_cache;
         }
 
         /// <summary>
-        /// Gets an <see cref="IInteroperable"/> from the storage.
+        /// Gets an <see cref="IInteroperableVerifiable"/> from the storage.
         /// </summary>
         /// <param name="verify">Verify deserialization</param>
+        /// <typeparam name="T">The type of the <see cref="IInteroperableVerifiable"/>.</typeparam>
+        /// <returns>The <see cref="IInteroperableVerifiable"/> in the storage.</returns>
+        public T GetInteroperable<T>(bool verify = true) where T : IInteroperableVerifiable, new()
+        {
+            _cache ??= GetInteroperableClone<T>(verify);
+            _value = null;
+            return (T)_cache;
+        }
+
+        /// <summary>
+        /// Gets an <see cref="IInteroperable"/> from the storage not related to this <see cref="StorageItem"/>.
+        /// </summary>
         /// <typeparam name="T">The type of the <see cref="IInteroperable"/>.</typeparam>
         /// <returns>The <see cref="IInteroperable"/> in the storage.</returns>
-        public T GetInteroperable<T>(bool verify = true) where T : IInteroperableVerifiable, new()
+        public T GetInteroperableClone<T>() where T : IInteroperable, new()
         {
-            if (_cache is null)
+            // If it's interoperable and not sealed
+            if (_value.IsEmpty && _cache is T interoperable)
             {
-                var interoperable = new T();
-                interoperable.FromStackItem(BinarySerializer.Deserialize(_value, ExecutionEngineLimits.Default), verify);
-                _cache = interoperable;
+                // Refresh data without change _value
+                return (T)interoperable.Clone();
             }
-            _value = null;
-            return (T)_cache;
+
+            interoperable = new T();
+            interoperable.FromStackItem(BinarySerializer.Deserialize(_value, ExecutionEngineLimits.Default));
+            return interoperable;
+        }
+
+        /// <summary>
+        /// Gets an <see cref="IInteroperableVerifiable"/> from the storage not related to this <see cref="StorageItem"/>.
+        /// </summary>
+        /// <param name="verify">Verify deserialization</param>
+        /// <typeparam name="T">The type of the <see cref="IInteroperableVerifiable"/>.</typeparam>
+        /// <returns>The <see cref="IInteroperableVerifiable"/> in the storage.</returns>
+        public T GetInteroperableClone<T>(bool verify = true) where T : IInteroperableVerifiable, new()
+        {
+            // If it's interoperable and not sealed
+            if (_value.IsEmpty && _cache is T interoperable)
+            {
+                return (T)interoperable.Clone();
+            }
+
+            interoperable = new T();
+            interoperable.FromStackItem(BinarySerializer.Deserialize(_value, ExecutionEngineLimits.Default), verify);
+            return interoperable;
         }
 
         /// <summary>

tests/Neo.UnitTests/Extensions/UT_ContractStateExtensions.cs

@@ -54,6 +54,11 @@ public void TestGetStorage()
 
             Assert.IsNotNull(item);
             Assert.AreEqual(100_000_000, item.GetInteroperable<AccountState>().Balance);
+
+            // Ensure GetInteroperableClone don't change nothing
+
+            item.GetInteroperableClone<AccountState>().Balance = 123;
+            Assert.AreEqual(100_000_000, item.GetInteroperable<AccountState>().Balance);
         }
     }
 }

tests/Neo.UnitTests/Network/P2P/Payloads/UT_Conflicts.cs

@@ -83,24 +83,31 @@ public void Verify()
             var key = UT_MemoryPool.CreateStorageKey(NativeContract.Ledger.Id, Prefix_Transaction, _u.ToArray());
 
             // Conflicting transaction is in the Conflicts attribute of some other on-chain transaction.
+            var tx = new Transaction()
+            {
+                Script = new byte[] { (byte)OpCode.RET },
+                Witnesses = [Witness.Empty],
+                Signers = [new Signer() { Account = UInt160.Zero }],
+                Attributes = []
+            };
             var conflict = new TransactionState();
             snapshotCache.Add(key, new StorageItem(conflict));
-            Assert.IsTrue(test.Verify(snapshotCache, new Transaction()));
+            Assert.IsTrue(test.Verify(snapshotCache, tx));
 
             // Conflicting transaction is on-chain.
             snapshotCache.Delete(key);
             conflict = new TransactionState
             {
                 BlockIndex = 123,
-                Transaction = new Transaction(),
+                Transaction = tx,
                 State = VMState.NONE
             };
             snapshotCache.Add(key, new StorageItem(conflict));
-            Assert.IsFalse(test.Verify(snapshotCache, new Transaction()));
+            Assert.IsFalse(test.Verify(snapshotCache, tx));
 
             // There's no conflicting transaction at all.
             snapshotCache.Delete(key);
-            Assert.IsTrue(test.Verify(snapshotCache, new Transaction()));
+            Assert.IsTrue(test.Verify(snapshotCache, tx));
         }
     }
 }

tests/Neo.UnitTests/SmartContract/UT_InteropPrices.cs

@@ -78,7 +78,7 @@ public void ApplicationEngineRegularPut()
             snapshot.Add(skey, sItem);
             snapshot.AddContract(script.ToScriptHash(), contractState);
 
-            using ApplicationEngine ae = ApplicationEngine.Create(TriggerType.Application, null, snapshot);
+            using var ae = ApplicationEngine.Create(TriggerType.Application, null, snapshot);
             Debugger debugger = new(ae);
             ae.LoadScript(script);
             debugger.StepInto();

tests/Neo.UnitTests/SmartContract/UT_SmartContractHelper.cs

@@ -125,7 +125,7 @@ public void TestIsStandardContract()
         public void TestVerifyWitnesses()
         {
             var snapshotCache1 = TestBlockchain.GetTestSnapshotCache().CloneCache();
-            UInt256 index1 = UInt256.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff01");
+            var index1 = UInt256.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff01");
             TestUtils.BlocksAdd(snapshotCache1, index1, new TrimmedBlock()
             {
                 Header = new Header
@@ -142,7 +142,7 @@ public void TestVerifyWitnesses()
             Assert.IsFalse(Helper.VerifyWitnesses(new Header() { PrevHash = index1 }, TestProtocolSettings.Default, snapshotCache1, 100));
 
             var snapshotCache2 = TestBlockchain.GetTestSnapshotCache();
-            UInt256 index2 = UInt256.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff01");
+            var index2 = UInt256.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff01");
             TrimmedBlock block2 = new()
             {
                 Header = new Header
@@ -163,7 +163,7 @@ public void TestVerifyWitnesses()
             Assert.IsFalse(Helper.VerifyWitnesses(header2, TestProtocolSettings.Default, snapshotCache2, 100));
 
             var snapshotCache3 = TestBlockchain.GetTestSnapshotCache();
-            UInt256 index3 = UInt256.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff01");
+            var index3 = UInt256.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff01");
             TrimmedBlock block3 = new()
             {
                 Header = new Header
@@ -180,6 +180,8 @@ public void TestVerifyWitnesses()
             Header header3 = new()
             {
                 PrevHash = index3,
+                MerkleRoot = UInt256.Zero,
+                NextConsensus = UInt160.Zero,
                 Witness = Witness.Empty
             };
             snapshotCache3.AddContract(UInt160.Zero, new ContractState()