Relocate transaction verification

src/neo/Ledger/MemoryPool.cs

@@ -271,7 +271,7 @@ internal VerifyResult TryAdd(Transaction tx, StoreView snapshot)
             _txRwLock.EnterWriteLock();
             try
             {
-                VerifyResult result = tx.Verify(snapshot, VerificationContext);
+                VerifyResult result = tx.VerifyStateDependent(snapshot, VerificationContext);
                 if (result != VerifyResult.Succeed) return result;
 
                 _unsortedTransactions.Add(tx.Hash, poolItem);
@@ -425,7 +425,7 @@ private int ReverifyTransactions(SortedSet<PoolItem> verifiedSortedTxPool,
                 // Since unverifiedSortedTxPool is ordered in an ascending manner, we take from the end.
                 foreach (PoolItem item in unverifiedSortedTxPool.Reverse().Take(count))
                 {
-                    if (item.Tx.VerifyForEachBlock(snapshot, VerificationContext) == VerifyResult.Succeed)
+                    if (item.Tx.VerifyStateDependent(snapshot, VerificationContext) == VerifyResult.Succeed)
                     {
                         reverifiedItems.Add(item);
                         VerificationContext.AddTransaction(item.Tx);

src/neo/Network/P2P/Payloads/Transaction.cs

@@ -281,7 +281,7 @@ bool IInventory.Verify(StoreView snapshot)
             return Verify(snapshot, null) == VerifyResult.Succeed;
         }
 
-        public virtual VerifyResult VerifyForEachBlock(StoreView snapshot, TransactionVerificationContext context)
+        public virtual VerifyResult VerifyStateDependent(StoreView snapshot, TransactionVerificationContext context)
         {
             if (ValidUntilBlock <= snapshot.Height || ValidUntilBlock > snapshot.Height + MaxValidUntilBlockIncrement)
                 return VerifyResult.Expired;
@@ -294,24 +294,27 @@ public virtual VerifyResult VerifyForEachBlock(StoreView snapshot, TransactionVe
             foreach (TransactionAttribute attribute in Attributes)
                 if (!attribute.Verify(snapshot, this))
                     return VerifyResult.Invalid;
-            if (hashes.Length != Witnesses.Length) return VerifyResult.Invalid;
-            for (int i = 0; i < hashes.Length; i++)
-            {
-                if (Witnesses[i].VerificationScript.Length > 0) continue;
-                if (snapshot.Contracts.TryGet(hashes[i]) is null) return VerifyResult.Invalid;
-            }
+            long net_fee = NetworkFee - Size * NativeContract.Policy.GetFeePerByte(snapshot);
+            if (!this.VerifyWitnesses(snapshot, net_fee, WitnessFlag.StateDependent))
+                return VerifyResult.Invalid;
+            return VerifyResult.Succeed;
+        }
+
+        public virtual VerifyResult VerifyStateIndependent()
+        {
+            if (Size > MaxTransactionSize)
+                return VerifyResult.Invalid;
+            if (!this.VerifyWitnesses(null, NetworkFee, WitnessFlag.StateIndependent))
+                return VerifyResult.Invalid;
             return VerifyResult.Succeed;
         }
 
         public virtual VerifyResult Verify(StoreView snapshot, TransactionVerificationContext context)
         {
-            VerifyResult result = VerifyForEachBlock(snapshot, context);
+            VerifyResult result = VerifyStateIndependent();
             if (result != VerifyResult.Succeed) return result;
-            if (Size > MaxTransactionSize) return VerifyResult.Invalid;
-            long net_fee = NetworkFee - Size * NativeContract.Policy.GetFeePerByte(snapshot);
-            if (net_fee < 0) return VerifyResult.InsufficientFunds;
-            if (!this.VerifyWitnesses(snapshot, net_fee)) return VerifyResult.Invalid;
-            return VerifyResult.Succeed;
+            result = VerifyStateDependent(snapshot, context);
+            return result;
         }
 
         public StackItem ToStackItem(ReferenceCounter referenceCounter)

src/neo/Network/P2P/Payloads/Witness.cs

@@ -11,6 +11,10 @@ public class Witness : ISerializable
         public byte[] InvocationScript;
         public byte[] VerificationScript;
 
+        public WitnessFlag Flag => VerificationScript.Length == 0 ? WitnessFlag.StateDependent : WitnessFlag.StateIndependent;
+
+        internal long GasConsumed { get; set; }
+
         private UInt160 _scriptHash;
         public virtual UInt160 ScriptHash
         {

src/neo/Network/P2P/Payloads/WitnessFlag.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace Neo.SmartContract
+{
+    [Flags]
+    public enum WitnessFlag : byte
+    {
+        None = 0,
+
+        StateIndependent = 0b00000001,
+        StateDependent = 0b00000010,
+
+        All = StateIndependent | StateDependent
+    }
+}

src/neo/Network/P2P/RemoteNode.ProtocolHandler.cs

@@ -12,11 +12,40 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Net;
+using System.Threading.Tasks;
 
 namespace Neo.Network.P2P
 {
     partial class RemoteNode
     {
+        private class TransactionRouter : UntypedActor
+        {
+            private readonly NeoSystem system;
+
+            public TransactionRouter(NeoSystem system)
+            {
+                this.system = system;
+            }
+
+            protected override void OnReceive(object message)
+            {
+                switch (message)
+                {
+                    case Transaction tx:
+                        if (tx.VerifyStateIndependent() == VerifyResult.Succeed)
+                            OnTransactionReceived(tx);
+                        break;
+                }
+            }
+
+            private void OnTransactionReceived(Transaction tx)
+            {
+                system.TaskManager.Tell(tx);
+                system.Consensus?.Tell(tx);
+                system.Blockchain.Tell(tx, ActorRefs.NoSender);
+            }
+        }
+
         private class Timer { }
         private class PendingKnownHashesCollection : KeyedCollection<UInt256, (UInt256, DateTime)>
         {
@@ -31,6 +60,7 @@ protected override UInt256 GetKeyForItem((UInt256, DateTime) item)
         private readonly HashSetCache<UInt256> sentHashes = new HashSetCache<UInt256>(Blockchain.Singleton.MemPool.Capacity * 2 / 5);
         private bool verack = false;
         private BloomFilter bloom_filter;
+        private IActorRef transactionRouter;
 
         private static readonly TimeSpan TimerInterval = TimeSpan.FromSeconds(30);
         private static readonly TimeSpan PendingTimeout = TimeSpan.FromMinutes(1);
@@ -62,10 +92,17 @@ private void OnMessage(Message msg)
                     OnAddrMessageReceived((AddrPayload)msg.Payload);
                     break;
                 case MessageCommand.Block:
-                    OnInventoryReceived((Block)msg.Payload);
+                    Block block = (Block)msg.Payload;
+                    system.TaskManager.Tell(block);
+                    system.Blockchain.Tell(block, ActorRefs.NoSender);
+                    UpdateLastBlockIndex(block.Index, false);
+                    RenewKnownHashes(block.Hash);
                     break;
                 case MessageCommand.Consensus:
-                    OnInventoryReceived((ConsensusPayload)msg.Payload);
+                    ConsensusPayload consensusPayload = (ConsensusPayload)msg.Payload;
+                    system.TaskManager.Tell(consensusPayload);
+                    system.Blockchain.Tell(consensusPayload, ActorRefs.NoSender);
+                    RenewKnownHashes(consensusPayload.Hash);
                     break;
                 case MessageCommand.FilterAdd:
                     OnFilterAddMessageReceived((FilterAddPayload)msg.Payload);
@@ -104,8 +141,12 @@ private void OnMessage(Message msg)
                     OnPongMessageReceived((PingPayload)msg.Payload);
                     break;
                 case MessageCommand.Transaction:
+                    Transaction tx = (Transaction)msg.Payload;
+                    RenewKnownHashes(tx.Hash);
                     if (msg.Payload.Size <= Transaction.MaxTransactionSize)
-                        OnInventoryReceived((Transaction)msg.Payload);
+                    {
+                        transactionRouter.Tell(tx);
+                    }
                     break;
                 case MessageCommand.Verack:
                 case MessageCommand.Version:
@@ -284,15 +325,10 @@ private void OnGetHeadersMessageReceived(GetBlockByIndexPayload payload)
             EnqueueMessage(Message.Create(MessageCommand.Headers, HeadersPayload.Create(headers.ToArray())));
         }
 
-        private void OnInventoryReceived(IInventory inventory)
+        private void RenewKnownHashes(UInt256 hash)
         {
-            system.TaskManager.Tell(inventory);
-            if (inventory is Transaction transaction)
-                system.Consensus?.Tell(transaction);
-            system.Blockchain.Tell(inventory, ActorRefs.NoSender);
-            pendingKnownHashes.Remove(inventory.Hash);
-            knownHashes.Add(inventory.Hash);
-            if (inventory is Block b) UpdateLastBlockIndex(b.Index, false);
+            pendingKnownHashes.Remove(hash);
+            knownHashes.Add(hash);
         }
 
         private void OnInvMessageReceived(InvPayload payload)

src/neo/Network/P2P/RemoteNode.cs

@@ -1,6 +1,7 @@
 using Akka.Actor;
 using Akka.Configuration;
 using Akka.IO;
+using Akka.Routing;
 using Neo.Cryptography;
 using Neo.IO;
 using Neo.IO.Actors;
@@ -36,6 +37,7 @@ public RemoteNode(NeoSystem system, object connection, IPEndPoint remote, IPEndP
         {
             this.system = system;
             LocalNode.Singleton.RemoteNodes.TryAdd(Self, this);
+            transactionRouter = Context.ActorOf(Akka.Actor.Props.Create(() => new TransactionRouter(system)).WithMailbox("remote-node-mailbox").WithRouter(new SmallestMailboxPool(20)));
         }
 
         /// <summary>

src/neo/SmartContract/Helper.cs

@@ -129,7 +129,7 @@ public static UInt160 ToScriptHash(this ReadOnlySpan<byte> script)
             return new UInt160(Crypto.Hash160(script));
         }
 
-        internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snapshot, long gas)
+        internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snapshot, long gas, WitnessFlag filter = WitnessFlag.All)
         {
             if (gas < 0) return false;
             if (gas > MaxVerificationGas) gas = MaxVerificationGas;
@@ -146,6 +146,13 @@ internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snap
             if (hashes.Length != verifiable.Witnesses.Length) return false;
             for (int i = 0; i < hashes.Length; i++)
             {
+                if (filter != WitnessFlag.All && !filter.HasFlag(verifiable.Witnesses[i].Flag))
+                {
+                    gas -= verifiable.Witnesses[i].GasConsumed;
+                    if (gas < 0) return false;
+                    continue;
+                }
+
                 int offset;
                 ContractMethodDescriptor init = null;
                 byte[] verification = verifiable.Witnesses[i].VerificationScript;
@@ -164,14 +171,15 @@ internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snap
                     if (hashes[i] != verifiable.Witnesses[i].ScriptHash) return false;
                     offset = 0;
                 }
-                using (ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Verification, verifiable, snapshot.Clone(), gas))
+                using (ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Verification, verifiable, snapshot != null ? snapshot.Clone() : snapshot, gas))
                 {
                     ExecutionContext context = engine.LoadScript(verification, CallFlags.None, offset);
                     if (init != null) engine.LoadContext(context.Clone(init.Offset), false);
                     engine.LoadScript(verifiable.Witnesses[i].InvocationScript, CallFlags.None);
                     if (engine.Execute() == VMState.FAULT) return false;
                     if (engine.ResultStack.Count != 1 || !engine.ResultStack.Pop().GetBoolean()) return false;
                     gas -= engine.GasConsumed;
+                    verifiable.Witnesses[i].GasConsumed = engine.GasConsumed;
                 }
             }
             return true;

tests/neo.UnitTests/Ledger/UT_MemoryPool.cs

@@ -9,6 +9,7 @@
 using Neo.Plugins;
 using Neo.SmartContract;
 using Neo.SmartContract.Native;
+using Neo.SmartContract.Native.Tokens;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -31,6 +32,7 @@ public class UT_MemoryPool
 
         private const byte Prefix_MaxTransactionsPerBlock = 23;
         private const byte Prefix_FeePerByte = 10;
+        private readonly UInt160 senderAccount = UInt160.Zero;
         private MemoryPool _unit;
         private MemoryPool _unit2;
         private TestIMemoryPoolTxObserverPlugin plugin;
@@ -82,12 +84,13 @@ private Transaction CreateTransactionWithFee(long fee)
             var randomBytes = new byte[16];
             random.NextBytes(randomBytes);
             Mock<Transaction> mock = new Mock<Transaction>();
-            mock.Setup(p => p.VerifyForEachBlock(It.IsAny<StoreView>(), It.IsAny<TransactionVerificationContext>())).Returns(VerifyResult.Succeed);
             mock.Setup(p => p.Verify(It.IsAny<StoreView>(), It.IsAny<TransactionVerificationContext>())).Returns(VerifyResult.Succeed);
+            mock.Setup(p => p.VerifyStateDependent(It.IsAny<StoreView>(), It.IsAny<TransactionVerificationContext>())).Returns(VerifyResult.Succeed);
+            mock.Setup(p => p.VerifyStateIndependent()).Returns(VerifyResult.Succeed);
             mock.Object.Script = randomBytes;
             mock.Object.NetworkFee = fee;
             mock.Object.Attributes = Array.Empty<TransactionAttribute>();
-            mock.Object.Signers = new Signer[] { new Signer() { Account = UInt160.Zero, Scopes = WitnessScope.None } };
+            mock.Object.Signers = new Signer[] { new Signer() { Account = senderAccount, Scopes = WitnessScope.None } };
             mock.Object.Witnesses = new[]
             {
                 new Witness
@@ -105,12 +108,14 @@ private Transaction CreateTransactionWithFeeAndBalanceVerify(long fee)
             var randomBytes = new byte[16];
             random.NextBytes(randomBytes);
             Mock<Transaction> mock = new Mock<Transaction>();
-            mock.Setup(p => p.VerifyForEachBlock(It.IsAny<StoreView>(), It.IsAny<TransactionVerificationContext>())).Returns((StoreView snapshot, TransactionVerificationContext context) => context.CheckTransaction(mock.Object, snapshot) ? VerifyResult.Succeed : VerifyResult.InsufficientFunds);
+            UInt160 sender = senderAccount;
             mock.Setup(p => p.Verify(It.IsAny<StoreView>(), It.IsAny<TransactionVerificationContext>())).Returns(VerifyResult.Succeed);
+            mock.Setup(p => p.VerifyStateDependent(It.IsAny<StoreView>(), It.IsAny<TransactionVerificationContext>())).Returns((StoreView snapshot, TransactionVerificationContext context) => context.CheckTransaction(mock.Object, snapshot) ? VerifyResult.Succeed : VerifyResult.InsufficientFunds);
+            mock.Setup(p => p.VerifyStateIndependent()).Returns(VerifyResult.Succeed);
             mock.Object.Script = randomBytes;
             mock.Object.NetworkFee = fee;
             mock.Object.Attributes = Array.Empty<TransactionAttribute>();
-            mock.Object.Signers = new Signer[] { new Signer() { Account = UInt160.Zero, Scopes = WitnessScope.None } };
+            mock.Object.Signers = new Signer[] { new Signer() { Account = senderAccount, Scopes = WitnessScope.None } };
             mock.Object.Witnesses = new[]
             {
                 new Witness
@@ -147,9 +152,8 @@ private void AddTransaction(Transaction txToAdd)
             _unit.TryAdd(txToAdd, snapshot);
         }
 
-        private void AddTransactionsWithBalanceVerify(int count, long fee)
+        private void AddTransactionsWithBalanceVerify(int count, long fee, SnapshotView snapshot)
         {
-            var snapshot = Blockchain.Singleton.GetSnapshot();
             for (int i = 0; i < count; i++)
             {
                 var txToAdd = CreateTransactionWithFeeAndBalanceVerify(fee);
@@ -218,8 +222,14 @@ public void BlockPersistMovesTxToUnverifiedAndReverification()
         [TestMethod]
         public void BlockPersistAndReverificationWillAbandonTxAsBalanceTransfered()
         {
+            SnapshotView snapshot = Blockchain.Singleton.GetSnapshot();
+            BigInteger balance = NativeContract.GAS.BalanceOf(snapshot, senderAccount);
+            ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot, long.MaxValue);
+            NativeContract.GAS.Burn(engine, UInt160.Zero, balance);
+            NativeContract.GAS.Mint(engine, UInt160.Zero, 70);
+
             long txFee = 1;
-            AddTransactionsWithBalanceVerify(70, txFee);
+            AddTransactionsWithBalanceVerify(70, txFee, snapshot);
 
             _unit.SortedTxCount.Should().Be(70);
 
@@ -230,11 +240,9 @@ public void BlockPersistAndReverificationWillAbandonTxAsBalanceTransfered()
 
             // Simulate the transfer process in tx by burning the balance
             UInt160 sender = block.Transactions[0].Sender;
-            SnapshotView snapshot = Blockchain.Singleton.GetSnapshot();
-            BigInteger balance = NativeContract.GAS.BalanceOf(snapshot, sender);
 
             ApplicationEngine applicationEngine = ApplicationEngine.Create(TriggerType.All, block, snapshot, (long)balance);
-            NativeContract.GAS.Burn(applicationEngine, sender, balance);
+            NativeContract.GAS.Burn(applicationEngine, sender, NativeContract.GAS.BalanceOf(snapshot, sender));
             NativeContract.GAS.Mint(applicationEngine, sender, txFee * 30); // Set the balance to meet 30 txs only
 
             // Persist block and reverify all the txs in mempool, but half of the txs will be discarded

tests/neo.UnitTests/Ledger/UT_TransactionVerificationContext.cs

@@ -28,8 +28,9 @@ private Transaction CreateTransactionWithFee(long networkFee, long systemFee)
             var randomBytes = new byte[16];
             random.NextBytes(randomBytes);
             Mock<Transaction> mock = new Mock<Transaction>();
-            mock.Setup(p => p.VerifyForEachBlock(It.IsAny<StoreView>(), It.IsAny<TransactionVerificationContext>())).Returns(VerifyResult.Succeed);
             mock.Setup(p => p.Verify(It.IsAny<StoreView>(), It.IsAny<TransactionVerificationContext>())).Returns(VerifyResult.Succeed);
+            mock.Setup(p => p.VerifyStateDependent(It.IsAny<StoreView>(), It.IsAny<TransactionVerificationContext>())).Returns(VerifyResult.Succeed);
+            mock.Setup(p => p.VerifyStateIndependent()).Returns(VerifyResult.Succeed);
             mock.Object.Script = randomBytes;
             mock.Object.NetworkFee = networkFee;
             mock.Object.SystemFee = systemFee;