Convert InteropInterface<IEnumerator> to Array for RpcClient to digest

src/RpcServer/RpcServer.SmartContract.cs

@@ -2,17 +2,18 @@
 #pragma warning disable IDE0060
 
 using Neo.IO.Json;
+using Neo.Ledger;
 using Neo.Network.P2P.Payloads;
 using Neo.Persistence;
 using Neo.SmartContract;
+using Neo.SmartContract.Native;
 using Neo.VM;
+using Neo.VM.Types;
+using Neo.Wallets;
 using System;
 using System.IO;
 using System.Linq;
-using Neo.IO;
-using Neo.Ledger;
-using Neo.SmartContract.Native;
-using Neo.Wallets;
+using Array = Neo.VM.Types.Array;
 
 namespace Neo.Plugins
 {
@@ -64,7 +65,9 @@ private JObject GetInvokeResult(byte[] script, IVerifiable checkWitnessHashes =
             json["gas_consumed"] = engine.GasConsumed.ToString();
             try
             {
-                json["stack"] = new JArray(engine.ResultStack.Select(p => p.ToParameter().ToJson()));
+                var stackItems = engine.ResultStack.ToArray();
+                ConvertIEnumeratorToArray(stackItems); // convert InteropInterface<IEnumerator> to Array for RpcClient to digest
+                json["stack"] = new JArray(stackItems.Select(p => p.ToJson()));
             }
             catch (InvalidOperationException)
             {
@@ -74,6 +77,43 @@ private JObject GetInvokeResult(byte[] script, IVerifiable checkWitnessHashes =
             return json;
         }
 
+        public static void ConvertIEnumeratorToArray(StackItem[] stackItems)
+        {
+            for (int i = 0; i < stackItems.Length; i++)
+            {
+                if (stackItems[i] is InteropInterface interopInterface)
+                {
+                    if (interopInterface.TryGetInterface(out System.Collections.IEnumerator sysEnum))
+                    {
+                        Array array = new Array();
+                        while (sysEnum.MoveNext())
+                        {
+                            var current = sysEnum.Current;
+                            if (!(current is StackItem))
+                            {
+                                if (current is IInteroperable interoperable)
+                                    current = interoperable.ToStackItem(null);
+                                else
+                                    current = new InteropInterface(current);
+                            }
+                            array.Add((StackItem)current);
+                        }
+                        stackItems[i] = array;
+                        continue;
+                    }
+                    if (interopInterface.TryGetInterface(out Neo.SmartContract.Enumerators.IEnumerator neoEnum))
+                    {
+                        Array array = new Array();
+                        while (neoEnum.Next())
+                        {
+                            array.Add(neoEnum.Value());
+                        }
+                        stackItems[i] = array;
+                    }
+                }
+            }
+        }
+
         [RpcMethod]
         private JObject InvokeFunction(JArray _params)
         {

tests/Neo.Network.RPC.Tests/Neo.Network.RPC.Tests.csproj

@@ -17,6 +17,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\RpcClient\RpcClient.csproj" />
+    <ProjectReference Include="..\..\src\RpcServer\RpcServer.csproj" />
   </ItemGroup>
 
   <ItemGroup>

tests/Neo.Network.RPC.Tests/UT_RpcServer.cs

@@ -0,0 +1,78 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.IO;
+using Neo.Plugins;
+using Neo.SmartContract.Iterators;
+using Neo.SmartContract.Native.Tokens;
+using Neo.VM.Types;
+using Neo.Wallets;
+using System;
+using System.Collections.Generic;
+
+namespace Neo.Network.RPC.Tests
+{
+    [TestClass]
+    public class UT_RpcServer
+    {
+        [TestMethod]
+        public void Test_ConvertIEnumeratorToArray()
+        {
+            IReadOnlyList<byte[]> values = new byte[1][] { "NeHNBbeLNtiCEeaFQ6tLLpXkr5Xw6esKnV".ToScriptHash().ToArray() };
+            IIterator iterator = new TestIterator(values);
+
+            StackItem[] stackItems = new StackItem[]
+            {
+                12345,
+                "hello",
+                new InteropInterface(new int[] { 1, 2, 3 }.GetEnumerator()),
+                new InteropInterface(new AccountState[] {new AccountState()}.GetEnumerator()),
+                new InteropInterface(iterator)
+            };
+
+            Assert.AreEqual(stackItems[3].Type, StackItemType.InteropInterface);
+            Assert.AreEqual(stackItems[4].Type, StackItemType.InteropInterface);
+
+            RpcServer.ConvertIEnumeratorToArray(stackItems);
+
+            Assert.AreEqual(stackItems[3].Type, StackItemType.Array);
+            Assert.AreEqual(stackItems[4].Type, StackItemType.Array);
+        }
+    }
+
+    internal class TestIterator : IIterator
+    {
+        private readonly IReadOnlyList<byte[]> values;
+        private int index = -1;
+
+        public TestIterator(IReadOnlyList<byte[]> vs)
+        {
+            this.values = vs;
+        }
+
+        public PrimitiveType Key()
+        {
+            if (index < 0)
+                throw new InvalidOperationException();
+            return index;
+        }
+
+        public bool Next()
+        {
+            int next = index + 1;
+            if (next >= values.Count)
+                return false;
+            index = next;
+            return true;
+        }
+
+        public StackItem Value()
+        {
+            if (index < 0)
+                throw new InvalidOperationException();
+            return values[index];
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+}

tests/Neo.Network.RPC.Tests/UT_TransactionManager.cs

@@ -122,6 +122,7 @@ public void TestSign()
             Assert.IsTrue(Crypto.VerifySignature(tx.GetHashData(), signature, keyPair1.PublicKey));
             // verify network fee and system fee
             long networkFee = tx.Size * (long)1000 + ApplicationEngine.OpCodePrices[OpCode.PUSHDATA1] + ApplicationEngine.OpCodePrices[OpCode.PUSHDATA1] + ApplicationEngine.OpCodePrices[OpCode.PUSHNULL] + ApplicationEngine.ECDsaVerifyPrice * 1;
+
             Assert.AreEqual(networkFee, tx.NetworkFee);
             Assert.AreEqual(100, tx.SystemFee);