Relocate transaction verification (neo-project#1507)

src/neo/Ledger/Blockchain.cs

@@ -26,6 +26,7 @@ public class Import { public IEnumerable<Block> Blocks; public bool Verify = tru
         public class ImportCompleted { }
         public class FillMemoryPool { public IEnumerable<Transaction> Transactions; }
         public class FillCompleted { }
+        internal class PreverifyCompleted { public Transaction Transaction; public VerifyResult Result; public bool Relay; }
         public class RelayResult { public IInventory Inventory; public VerifyResult Result; }
 
         public static readonly uint MillisecondsPerBlock = ProtocolSettings.Default.MillisecondsPerBlock;
@@ -58,6 +59,7 @@ public class RelayResult { public IInventory Inventory; public VerifyResult Resu
         private const int MaxTxToReverifyPerIdle = 10;
         private static readonly object lockObj = new object();
         private readonly NeoSystem system;
+        private readonly IActorRef txrouter;
         private readonly List<UInt256> header_index = new List<UInt256>();
         private uint stored_header_count = 0;
         private readonly Dictionary<UInt256, Block> block_cache = new Dictionary<UInt256, Block>();
@@ -103,6 +105,7 @@ static Blockchain()
         public Blockchain(NeoSystem system, IStore store)
         {
             this.system = system;
+            this.txrouter = Context.ActorOf(TransactionRouter.Props(system));
             this.MemPool = new MemoryPool(system, ProtocolSettings.Default.MemoryPoolMaxTransactions);
             this.Store = store;
             this.View = new ReadOnlyView(store);
@@ -302,20 +305,15 @@ private void OnFillMemoryPool(IEnumerable<Transaction> transactions)
 
         private void OnInventory(IInventory inventory, bool relay = true)
         {
-            RelayResult rr = new RelayResult
+            VerifyResult result = inventory switch
             {
-                Inventory = inventory,
-                Result = inventory switch
-                {
-                    Block block => OnNewBlock(block),
-                    Transaction transaction => OnNewTransaction(transaction),
-                    _ => OnNewInventory(inventory)
-                }
+                Block block => OnNewBlock(block),
+                Transaction transaction => OnNewTransaction(transaction),
+                _ => OnNewInventory(inventory)
             };
-            if (relay && rr.Result == VerifyResult.Succeed)
+            if (relay && result == VerifyResult.Succeed)
                 system.LocalNode.Tell(new LocalNode.RelayDirectly { Inventory = inventory });
-            Sender.Tell(rr);
-            Context.System.EventStream.Publish(rr);
+            SendRelayResult(inventory, result);
         }
 
         private VerifyResult OnNewBlock(Block block)
@@ -360,6 +358,14 @@ private VerifyResult OnNewTransaction(Transaction transaction)
             return MemPool.TryAdd(transaction, currentSnapshot);
         }
 
+        private void OnPreverifyCompleted(PreverifyCompleted task)
+        {
+            if (task.Result == VerifyResult.Succeed)
+                OnInventory(task.Transaction, task.Relay);
+            else
+                SendRelayResult(task.Transaction, task.Result);
+        }
+
         protected override void OnReceive(object message)
         {
             switch (message)
@@ -373,22 +379,34 @@ protected override void OnReceive(object message)
                 case Block block:
                     OnInventory(block, false);
                     break;
+                case Transaction tx:
+                    OnTransaction(tx, true);
+                    break;
                 case Transaction[] transactions:
-                    {
-                        // This message comes from a mempool's revalidation, already relayed
-                        foreach (var tx in transactions) OnInventory(tx, false);
-                        break;
-                    }
+                    // This message comes from a mempool's revalidation, already relayed
+                    foreach (var tx in transactions) OnTransaction(tx, false);
+                    break;
                 case IInventory inventory:
                     OnInventory(inventory);
                     break;
+                case PreverifyCompleted task:
+                    OnPreverifyCompleted(task);
+                    break;
                 case Idle _:
                     if (MemPool.ReVerifyTopUnverifiedTransactionsIfNeeded(MaxTxToReverifyPerIdle, currentSnapshot))
                         Self.Tell(Idle.Instance, ActorRefs.NoSender);
                     break;
             }
         }
 
+        private void OnTransaction(Transaction tx, bool relay)
+        {
+            if (ContainsTransaction(tx.Hash))
+                SendRelayResult(tx, VerifyResult.AlreadyExists);
+            else
+                txrouter.Tell(new TransactionRouter.Task { Transaction = tx, Relay = relay }, Sender);
+        }
+
         private void Persist(Block block)
         {
             using (SnapshotView snapshot = GetSnapshot())
@@ -507,6 +525,17 @@ private void SaveHeaderHashList(SnapshotView snapshot = null)
             }
         }
 
+        private void SendRelayResult(IInventory inventory, VerifyResult result)
+        {
+            RelayResult rr = new RelayResult
+            {
+                Inventory = inventory,
+                Result = result
+            };
+            Sender.Tell(rr);
+            Context.System.EventStream.Publish(rr);
+        }
+
         private void UpdateCurrentSnapshot()
         {
             Interlocked.Exchange(ref currentSnapshot, GetSnapshot())?.Dispose();

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/Ledger/TransactionRouter.cs

@@ -0,0 +1,35 @@
+using Akka.Actor;
+using Akka.Routing;
+using Neo.Network.P2P.Payloads;
+using System;
+
+namespace Neo.Ledger
+{
+    internal class TransactionRouter : UntypedActor
+    {
+        public class Task { public Transaction Transaction; public bool Relay; }
+
+        private readonly IActorRef blockchain;
+
+        public TransactionRouter(NeoSystem system)
+        {
+            this.blockchain = system.Blockchain;
+        }
+
+        protected override void OnReceive(object message)
+        {
+            if (!(message is Task task)) return;
+            blockchain.Tell(new Blockchain.PreverifyCompleted
+            {
+                Transaction = task.Transaction,
+                Result = task.Transaction.VerifyStateIndependent(),
+                Relay = task.Relay
+            }, Sender);
+        }
+
+        internal static Props Props(NeoSystem system)
+        {
+            return Akka.Actor.Props.Create(() => new TransactionRouter(system)).WithRouter(new SmallestMailboxPool(Environment.ProcessorCount));
+        }
+    }
+}

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,8 @@ public class Witness : ISerializable
         public byte[] InvocationScript;
         public byte[] VerificationScript;
 
+        internal long GasConsumed { get; set; }
+
         private UInt160 _scriptHash;
         public virtual UInt160 ScriptHash
         {
@@ -24,6 +26,8 @@ public virtual UInt160 ScriptHash
             }
         }
 
+        public bool StateDependent => VerificationScript.Length == 0;
+
         public int Size => InvocationScript.GetVarSize() + VerificationScript.GetVarSize();
 
         void ISerializable.Deserialize(BinaryReader reader)

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

@@ -286,13 +286,19 @@ private void OnGetHeadersMessageReceived(GetBlockByIndexPayload payload)
 
         private void OnInventoryReceived(IInventory inventory)
         {
-            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);
+            system.TaskManager.Tell(inventory);
+            system.Blockchain.Tell(inventory, ActorRefs.NoSender);
+            switch (inventory)
+            {
+                case Transaction transaction:
+                    system.Consensus?.Tell(transaction);
+                    break;
+                case Block block:
+                    UpdateLastBlockIndex(block.Index, false);
+                    break;
+            }
         }
 
         private void OnInvMessageReceived(InvPayload payload)

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,14 @@ 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++)
             {
+                WitnessFlag flag = verifiable.Witnesses[i].StateDependent ? WitnessFlag.StateDependent : WitnessFlag.StateIndependent;
+                if (!filter.HasFlag(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 +172,16 @@ 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?.Clone(), gas))
                 {
-                    ExecutionContext context = engine.LoadScript(verification, CallFlags.None, offset);
+                    CallFlags callFlags = verifiable.Witnesses[i].StateDependent ? CallFlags.AllowStates : CallFlags.None;
+                    ExecutionContext context = engine.LoadScript(verification, callFlags, 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;

src/neo/SmartContract/WitnessFlag.cs

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