Add ITraceDebugPlugin infrastructure

src/neo/Ledger/Blockchain.cs

@@ -427,10 +427,18 @@ private void Persist(Block block)
                     clonedSnapshot.Transactions.Add(tx.Hash, state);
                     clonedSnapshot.Transactions.Commit();
 
-                    using (ApplicationEngine engine = new ApplicationEngine(TriggerType.Application, tx, clonedSnapshot, tx.SystemFee))
+                    // For now, only support a first trace debug plugin that returns true to ShouldTrace
+                    var traceDebugPlugin = Plugin.TraceDebugPlugins
+                        .Where(p => p.ShouldTrace(block.Header, tx))
+                        .FirstOrDefault();
+
+                    using var traceDebugSink = traceDebugPlugin?.GetSink(block.Header, tx);
+
+                    using (ApplicationEngine engine = new ApplicationEngine(TriggerType.Application, tx, clonedSnapshot, tx.SystemFee, traceDebugSink: traceDebugSink))
                     {
                         engine.LoadScript(tx.Script);
                         state.VMState = engine.Execute();
+                        traceDebugSink?.Results(state.VMState, engine.GasConsumed, engine.ResultStack);
                         if (state.VMState == VMState.HALT)
                         {
                             clonedSnapshot.Commit();

src/neo/Plugins/ITraceDebugPlugin.cs

@@ -0,0 +1,10 @@
+using Neo.Network.P2P.Payloads;
+
+namespace Neo.Plugins
+{
+    public interface ITraceDebugPlugin
+    {
+        bool ShouldTrace(Header header, Transaction tx);
+        ITraceDebugSink GetSink(Header header, Transaction tx);
+    }
+}

src/neo/Plugins/ITraceDebugSink.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using Neo.Ledger;
+using Neo.SmartContract;
+using Neo.VM;
+
+namespace Neo.Plugins
+{
+    public interface ITraceDebugSink : IDisposable
+    {
+        void Trace(VMState vmState, IReadOnlyCollection<ExecutionContext> stackFrames,
+            IEnumerable<(UInt160 scriptHash, byte[] key, StorageItem item)> storages);
+        void Log(LogEventArgs args);
+        void Notify(NotifyEventArgs args);
+        void Results(VMState vmState, long gasConsumed, IReadOnlyCollection<Neo.VM.Types.StackItem> results);
+    }
+}

src/neo/Plugins/Plugin.cs

@@ -17,6 +17,7 @@ public abstract class Plugin : IDisposable
         internal static readonly List<IPersistencePlugin> PersistencePlugins = new List<IPersistencePlugin>();
         internal static readonly List<IP2PPlugin> P2PPlugins = new List<IP2PPlugin>();
         internal static readonly List<IMemoryPoolTxObserverPlugin> TxObserverPlugins = new List<IMemoryPoolTxObserverPlugin>();
+        internal static readonly List<ITraceDebugPlugin> TraceDebugPlugins = new List<ITraceDebugPlugin>();
 
         public static readonly string PluginsDirectory = Combine(GetDirectoryName(Assembly.GetEntryAssembly().Location), "Plugins");
         private static readonly FileSystemWatcher configWatcher;
@@ -54,6 +55,7 @@ protected Plugin()
             if (this is IP2PPlugin p2p) P2PPlugins.Add(p2p);
             if (this is IPersistencePlugin persistence) PersistencePlugins.Add(persistence);
             if (this is IMemoryPoolTxObserverPlugin txObserver) TxObserverPlugins.Add(txObserver);
+            if (this is ITraceDebugPlugin traceDebug) TraceDebugPlugins.Add(traceDebug);
 
             Configure();
         }

src/neo/SmartContract/ApplicationEngine.Runtime.cs

@@ -143,7 +143,12 @@ internal void RuntimeLog(byte[] state)
         {
             if (state.Length > MaxNotificationSize) throw new ArgumentException();
             string message = Utility.StrictUTF8.GetString(state);
-            Log?.Invoke(this, new LogEventArgs(ScriptContainer, CurrentScriptHash, message));
+            if (Log != null || traceDebugSink != null)
+            {
+                var args = new LogEventArgs(ScriptContainer, CurrentScriptHash, message);
+                Log?.Invoke(this, args);
+                traceDebugSink?.Log(args);
+            }
         }
 
         internal void RuntimeNotify(byte[] eventName, Array state)
@@ -157,6 +162,7 @@ internal void SendNotification(UInt160 hash, string eventName, Array state)
         {
             NotifyEventArgs notification = new NotifyEventArgs(ScriptContainer, hash, eventName, (Array)state.DeepCopy());
             Notify?.Invoke(this, notification);
+            traceDebugSink?.Notify(notification);
             notifications ??= new List<NotifyEventArgs>();
             notifications.Add(notification);
         }

src/neo/SmartContract/ApplicationEngine.cs

@@ -2,6 +2,7 @@
 using Neo.Ledger;
 using Neo.Network.P2P.Payloads;
 using Neo.Persistence;
+using Neo.Plugins;
 using Neo.VM;
 using Neo.VM.Types;
 using System;
@@ -29,10 +30,12 @@ private class InvocationState
         private static Dictionary<uint, InteropDescriptor> services;
         private readonly long gas_amount;
         private readonly bool testMode;
+        private bool preExecTrace = true;
         private List<NotifyEventArgs> notifications;
         private List<IDisposable> disposables;
         private readonly Dictionary<UInt160, int> invocationCounter = new Dictionary<UInt160, int>();
         private readonly Dictionary<ExecutionContext, InvocationState> invocationStates = new Dictionary<ExecutionContext, InvocationState>();
+        private readonly ITraceDebugSink traceDebugSink;
 
         public static IReadOnlyDictionary<uint, InteropDescriptor> Services => services;
         public TriggerType Trigger { get; }
@@ -45,13 +48,14 @@ private class InvocationState
         public UInt160 EntryScriptHash => EntryContext?.GetState<ExecutionContextState>().ScriptHash;
         public IReadOnlyList<NotifyEventArgs> Notifications => notifications ?? (IReadOnlyList<NotifyEventArgs>)Array.Empty<NotifyEventArgs>();
 
-        public ApplicationEngine(TriggerType trigger, IVerifiable container, StoreView snapshot, long gas, bool testMode = false)
+        public ApplicationEngine(TriggerType trigger, IVerifiable container, StoreView snapshot, long gas, bool testMode = false, ITraceDebugSink traceDebugSink = null)
         {
             this.Trigger = trigger;
             this.ScriptContainer = container;
             this.Snapshot = snapshot;
             this.gas_amount = gas;
             this.testMode = testMode;
+            this.traceDebugSink = traceDebugSink;
         }
 
         internal void AddGas(long gas)
@@ -222,12 +226,49 @@ protected override void OnSysCall(uint method)
                 Push(Convert(returnValue));
         }
 
+        internal void Trace()
+        {
+            if (traceDebugSink != null)
+            {
+                var storages = InvocationStack
+                    .Select(ec => ec.GetScriptHash())
+                    .Distinct()
+                    .SelectMany(scriptHash =>
+                    {
+                        var contractState = Snapshot.Contracts.TryGet(scriptHash);
+                        return contractState != null
+                            ? Snapshot.Storages
+                                .Find(StorageKey.CreateSearchPrefix(contractState.Id, default))
+                                .Select(t => (scriptHash, t.Key.Key, t.Value))
+                            : Enumerable.Empty<(UInt160, byte[], StorageItem)>();
+                    });
+
+                traceDebugSink.Trace(State, InvocationStack, storages);
+            }
+        }
+
         protected override void PreExecuteInstruction()
         {
+            if (preExecTrace)
+            {
+                Trace();
+                preExecTrace = false;
+            }
+
             if (CurrentContext.InstructionPointer < CurrentContext.Script.Length)
                 AddGas(OpCodePrices[CurrentContext.CurrentInstruction.OpCode]);
         }
 
+        protected override void PostExecuteInstruction(Instruction instruction)
+        {
+            Trace();
+        }
+
+        protected override void OnStateChanged()
+        {
+            Trace();
+        }
+
         private static Block CreateDummyBlock(StoreView snapshot)
         {
             var currentBlock = snapshot.Blocks[snapshot.CurrentBlockHash];