Update oracles branch

.github/ISSUE_TEMPLATE/feature-or-enhancement-request.md

@@ -6,7 +6,7 @@ labels: discussion
 assignees: ''
 ---
 
-**Summary**
+**Summary or problem description**
 A summary of the problem you want to solve or metric you want to improve
 
 **Do you have any solution you want to propose?**

.gitignore

@@ -255,3 +255,4 @@ paket-files/
 *.sln.iml
 
 PublishProfiles
+/.vscode

neo.UnitTests/IO/Caching/UT_FIFOSet.cs

@@ -144,6 +144,24 @@ public void TestExceptWith()
             };
             set.ExceptWith(new UInt256[] { b, c });
             CollectionAssert.AreEqual(set.ToArray(), new UInt256[] { a });
+
+            set = new FIFOSet<UInt256>(10)
+            {
+                a,
+                b,
+                c
+            };
+            set.ExceptWith(new UInt256[] { a });
+            CollectionAssert.AreEqual(set.ToArray(), new UInt256[] { b, c });
+
+            set = new FIFOSet<UInt256>(10)
+            {
+                a,
+                b,
+                c
+            };
+            set.ExceptWith(new UInt256[] { c });
+            CollectionAssert.AreEqual(set.ToArray(), new UInt256[] { a, b });
         }
     }
 }

neo.UnitTests/IO/UT_ByteArrayComparer.cs

@@ -0,0 +1,27 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.IO;
+
+namespace Neo.UnitTests.IO
+{
+    [TestClass]
+    public class UT_ByteArrayComparer
+    {
+        [TestMethod]
+        public void TestCompare()
+        {
+            ByteArrayComparer comparer = new ByteArrayComparer();
+            byte[] x = new byte[0], y = new byte[0];
+            comparer.Compare(x, y).Should().Be(0);
+
+            x = new byte[] { 1 };
+            comparer.Compare(x, y).Should().Be(1);
+            y = x;
+            comparer.Compare(x, y).Should().Be(0);
+
+            x = new byte[] { 1 };
+            y = new byte[] { 2 };
+            comparer.Compare(x, y).Should().Be(-1);
+        }
+    }
+}

neo.UnitTests/Ledger/UT_Blockchain.cs

@@ -70,13 +70,13 @@ public void TestContainsTransaction()
         [TestMethod]
         public void TestGetCurrentBlockHash()
         {
-            Blockchain.Singleton.CurrentBlockHash.Should().Be(UInt256.Parse("5662a113d8fa9532ea9c52046a463e2e3fcfcdd6192d99cad805b376fb643ceb"));
+            Blockchain.Singleton.CurrentBlockHash.Should().Be(UInt256.Parse("0x0d492ce0f38090a65b2b01af50f7a6d685b6b76fbc41672762e96b05d15d742c"));
         }
 
         [TestMethod]
         public void TestGetCurrentHeaderHash()
         {
-            Blockchain.Singleton.CurrentHeaderHash.Should().Be(UInt256.Parse("5662a113d8fa9532ea9c52046a463e2e3fcfcdd6192d99cad805b376fb643ceb"));
+            Blockchain.Singleton.CurrentHeaderHash.Should().Be(UInt256.Parse("0x0d492ce0f38090a65b2b01af50f7a6d685b6b76fbc41672762e96b05d15d742c"));
         }
 
         [TestMethod]
@@ -88,7 +88,7 @@ public void TestGetBlock()
         [TestMethod]
         public void TestGetBlockHash()
         {
-            Blockchain.Singleton.GetBlockHash(0).Should().Be(UInt256.Parse("5662a113d8fa9532ea9c52046a463e2e3fcfcdd6192d99cad805b376fb643ceb"));
+            Blockchain.Singleton.GetBlockHash(0).Should().Be(UInt256.Parse("0x0d492ce0f38090a65b2b01af50f7a6d685b6b76fbc41672762e96b05d15d742c"));
             Blockchain.Singleton.GetBlockHash(10).Should().BeNull();
         }
 

neo.UnitTests/Ledger/UT_ContractState.cs

@@ -1,4 +1,4 @@
-using FluentAssertions;
+using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.IO;
 using Neo.IO.Json;
@@ -92,7 +92,7 @@ public void TestToJson()
         {
             JObject json = contract.ToJson();
             json["hash"].AsString().Should().Be("0x820944cfdc70976602d71b0091445eedbc661bc5");
-            json["script"].AsString().Should().Be("01");
+            json["script"].AsString().Should().Be("AQ==");
             json["manifest"].AsString().Should().Be(manifest.ToJson().AsString());
         }
     }

neo.UnitTests/Ledger/UT_MemoryPool.cs

@@ -13,6 +13,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Numerics;
 
 namespace Neo.UnitTests.Ledger
 {
@@ -73,8 +74,8 @@ private Transaction CreateTransactionWithFee(long fee)
             var randomBytes = new byte[16];
             random.NextBytes(randomBytes);
             Mock<Transaction> mock = new Mock<Transaction>();
-            mock.Setup(p => p.Reverify(It.IsAny<Snapshot>(), It.IsAny<IEnumerable<Transaction>>())).Returns(true);
-            mock.Setup(p => p.Verify(It.IsAny<Snapshot>(), It.IsAny<IEnumerable<Transaction>>())).Returns(true);
+            mock.Setup(p => p.Reverify(It.IsAny<Snapshot>(), It.IsAny<BigInteger>())).Returns(true);
+            mock.Setup(p => p.Verify(It.IsAny<Snapshot>(), It.IsAny<BigInteger>())).Returns(true);
             mock.Object.Script = randomBytes;
             mock.Object.Sender = UInt160.Zero;
             mock.Object.NetworkFee = fee;

neo.UnitTests/Ledger/UT_SendersFeeMonitor.cs

@@ -0,0 +1,56 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
+using System;
+using System.Numerics;
+
+namespace Neo.UnitTests.Ledger
+{
+    [TestClass]
+    public class UT_SendersFeeMonitor
+    {
+        private Transaction CreateTransactionWithFee(long networkFee, long systemFee)
+        {
+            Random random = new Random();
+            var randomBytes = new byte[16];
+            random.NextBytes(randomBytes);
+            Mock<Transaction> mock = new Mock<Transaction>();
+            mock.Setup(p => p.Reverify(It.IsAny<Snapshot>(), It.IsAny<BigInteger>())).Returns(true);
+            mock.Setup(p => p.Verify(It.IsAny<Snapshot>(), It.IsAny<BigInteger>())).Returns(true);
+            mock.Object.Script = randomBytes;
+            mock.Object.Sender = UInt160.Zero;
+            mock.Object.NetworkFee = networkFee;
+            mock.Object.SystemFee = systemFee;
+            mock.Object.Attributes = new TransactionAttribute[0];
+            mock.Object.Cosigners = new Cosigner[0];
+            mock.Object.Witnesses = new[]
+            {
+                new Witness
+                {
+                    InvocationScript = new byte[0],
+                    VerificationScript = new byte[0]
+                }
+            };
+            return mock.Object;
+        }
+
+        [TestMethod]
+        public void TestMemPoolSenderFee()
+        {
+            Transaction transaction = CreateTransactionWithFee(1, 2);
+            SendersFeeMonitor sendersFeeMonitor = new SendersFeeMonitor();
+            sendersFeeMonitor.GetSenderFee(transaction.Sender).Should().Be(0);
+            sendersFeeMonitor.AddSenderFee(transaction);
+            sendersFeeMonitor.GetSenderFee(transaction.Sender).Should().Be(3);
+            sendersFeeMonitor.AddSenderFee(transaction);
+            sendersFeeMonitor.GetSenderFee(transaction.Sender).Should().Be(6);
+            sendersFeeMonitor.RemoveSenderFee(transaction);
+            sendersFeeMonitor.GetSenderFee(transaction.Sender).Should().Be(3);
+            sendersFeeMonitor.RemoveSenderFee(transaction);
+            sendersFeeMonitor.GetSenderFee(transaction.Sender).Should().Be(0);
+        }
+    }
+}

neo.UnitTests/Network/P2P/Payloads/UT_Block.cs

@@ -210,7 +210,7 @@ public void ToJson()
 
             JObject scObj = ((JArray)jObj["witnesses"])[0];
             scObj["invocation"].AsString().Should().Be("");
-            scObj["verification"].AsString().Should().Be("51");
+            scObj["verification"].AsString().Should().Be("UQ==");
 
             jObj["tx"].Should().NotBeNull();
             JArray txObj = (JArray)jObj["tx"];

neo.UnitTests/Network/P2P/Payloads/UT_Transaction.cs

@@ -165,10 +165,9 @@ public void FeeIsMultiSigContract()
                 }
 
                 var sizeGas = tx.Size * NativeContract.Policy.GetFeePerByte(snapshot);
-                Assert.AreEqual(verificationGas, 2000540);
-                Assert.AreEqual(sizeGas, 358000);
-                Assert.AreEqual(verificationGas + sizeGas, 2358540);
-                Assert.AreEqual(tx.NetworkFee, 2358540);
+                Assert.AreEqual(verificationGas, 2000570);
+                Assert.AreEqual(sizeGas, 359000);
+                Assert.AreEqual(tx.NetworkFee, 2359570);
             }
         }
 
@@ -214,7 +213,7 @@ public void FeeIsSignatureContractDetailed()
                 Assert.IsNull(tx.Witnesses);
 
                 // check pre-computed network fee (already guessing signature sizes)
-                tx.NetworkFee.Should().Be(1257240);
+                tx.NetworkFee.Should().Be(1258270);
 
                 // ----
                 // Sign
@@ -251,12 +250,12 @@ public void FeeIsSignatureContractDetailed()
                         verificationGas += engine.GasConsumed;
                     }
                 }
-                Assert.AreEqual(verificationGas, 1000240);
+                Assert.AreEqual(verificationGas, 1000270);
 
                 // ------------------
                 // check tx_size cost
                 // ------------------
-                Assert.AreEqual(tx.Size, 257);
+                Assert.AreEqual(tx.Size, 258);
 
                 // will verify tx size, step by step
 
@@ -272,16 +271,16 @@ public void FeeIsSignatureContractDetailed()
                 // Part III
                 Assert.AreEqual(tx.Script.GetVarSize(), 82);
                 // Part IV
-                Assert.AreEqual(tx.Witnesses.GetVarSize(), 107);
+                Assert.AreEqual(tx.Witnesses.GetVarSize(), 108);
                 // I + II + III + IV
-                Assert.AreEqual(tx.Size, 45 + 23 + 82 + 107);
+                Assert.AreEqual(tx.Size, 45 + 23 + 82 + 108);
 
                 Assert.AreEqual(NativeContract.Policy.GetFeePerByte(snapshot), 1000);
                 var sizeGas = tx.Size * NativeContract.Policy.GetFeePerByte(snapshot);
-                Assert.AreEqual(sizeGas, 257000);
+                Assert.AreEqual(sizeGas, 258000);
 
                 // final check on sum: verification_cost + tx_size
-                Assert.AreEqual(verificationGas + sizeGas, 1257240);
+                Assert.AreEqual(verificationGas + sizeGas, 1258270);
                 // final assert
                 Assert.AreEqual(tx.NetworkFee, verificationGas + sizeGas);
             }
@@ -372,7 +371,7 @@ public void FeeIsSignatureContract_TestScope_Global()
                 // get sizeGas
                 var sizeGas = tx.Size * NativeContract.Policy.GetFeePerByte(snapshot);
                 // final check on sum: verification_cost + tx_size
-                Assert.AreEqual(verificationGas + sizeGas, 1257240);
+                Assert.AreEqual(verificationGas + sizeGas, 1258270);
                 // final assert
                 Assert.AreEqual(tx.NetworkFee, verificationGas + sizeGas);
             }
@@ -464,7 +463,7 @@ public void FeeIsSignatureContract_TestScope_CurrentHash_GAS()
                 // get sizeGas
                 var sizeGas = tx.Size * NativeContract.Policy.GetFeePerByte(snapshot);
                 // final check on sum: verification_cost + tx_size
-                Assert.AreEqual(verificationGas + sizeGas, 1278240);
+                Assert.AreEqual(verificationGas + sizeGas, 1279270);
                 // final assert
                 Assert.AreEqual(tx.NetworkFee, verificationGas + sizeGas);
             }
@@ -559,7 +558,7 @@ public void FeeIsSignatureContract_TestScope_CalledByEntry_Plus_GAS()
                 // get sizeGas
                 var sizeGas = tx.Size * NativeContract.Policy.GetFeePerByte(snapshot);
                 // final check on sum: verification_cost + tx_size
-                Assert.AreEqual(verificationGas + sizeGas, 1278240);
+                Assert.AreEqual(verificationGas + sizeGas, 1279270);
                 // final assert
                 Assert.AreEqual(tx.NetworkFee, verificationGas + sizeGas);
             }
@@ -714,7 +713,7 @@ public void FeeIsSignatureContract_TestScope_CurrentHash_NEO_GAS()
                 // get sizeGas
                 var sizeGas = tx.Size * NativeContract.Policy.GetFeePerByte(snapshot);
                 // final check on sum: verification_cost + tx_size
-                Assert.AreEqual(verificationGas + sizeGas, 1298240);
+                Assert.AreEqual(verificationGas + sizeGas, 1299270);
                 // final assert
                 Assert.AreEqual(tx.NetworkFee, verificationGas + sizeGas);
             }
@@ -798,7 +797,7 @@ public void Transaction_Reverify_Hashes_Length_Unequal_To_Witnesses_Length()
             };
             UInt160[] hashes = txSimple.GetScriptHashesForVerifying(snapshot);
             Assert.AreEqual(2, hashes.Length);
-            Assert.IsFalse(txSimple.Reverify(snapshot, new Transaction[0]));
+            Assert.IsFalse(txSimple.Reverify(snapshot, BigInteger.Zero));
         }
 
         [TestMethod]
@@ -1062,7 +1061,7 @@ public void FeeIsSignatureContract_TestScope_Global_Default()
                 // get sizeGas
                 var sizeGas = tx.Size * NativeContract.Policy.GetFeePerByte(snapshot);
                 // final check on sum: verification_cost + tx_size
-                Assert.AreEqual(verificationGas + sizeGas, 1257240);
+                Assert.AreEqual(verificationGas + sizeGas, 1258270);
                 // final assert
                 Assert.AreEqual(tx.NetworkFee, verificationGas + sizeGas);
             }
@@ -1093,7 +1092,7 @@ public void ToJson()
             ((JArray)jObj["attributes"]).Count.Should().Be(0);
             ((JArray)jObj["cosigners"]).Count.Should().Be(0);
             jObj["net_fee"].AsString().Should().Be("0");
-            jObj["script"].AsString().Should().Be("4220202020202020202020202020202020202020202020202020202020202020");
+            jObj["script"].AsString().Should().Be("QiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA=");
             jObj["sys_fee"].AsString().Should().Be("4200000000");
         }
     }

neo.UnitTests/Network/P2P/Payloads/UT_Witness.cs

@@ -82,9 +82,9 @@ public void MaxSize_OK()
 
             // Check max size
 
-            witness.Size.Should().Be(1003);
+            witness.Size.Should().Be(1004);
             witness.InvocationScript.GetVarSize().Should().Be(653);
-            witness.VerificationScript.GetVarSize().Should().Be(350);
+            witness.VerificationScript.GetVarSize().Should().Be(351);
 
             Assert.IsTrue(witness.Size <= 1024);
 
@@ -146,8 +146,8 @@ public void ToJson()
             JObject json = uut.ToJson();
             Assert.IsTrue(json.ContainsProperty("invocation"));
             Assert.IsTrue(json.ContainsProperty("verification"));
-            Assert.AreEqual(json["invocation"].AsString(), "2020");
-            Assert.AreEqual(json["verification"].AsString(), "202020");
+            Assert.AreEqual(json["invocation"].AsString(), "ICA=");
+            Assert.AreEqual(json["verification"].AsString(), "ICAg");
         }
     }
 }

neo.UnitTests/Network/P2P/UT_ProtocolHandlerMailbox.cs

@@ -136,10 +136,6 @@ public void ProtocolHandlerMailbox_Test_ShallDrop()
             msg = Message.Create(MessageCommand.Inv, s);
             uut.ShallDrop(msg, emptyQueue).Should().Be(false);
             uut.ShallDrop(msg, new object[] { msg }).Should().Be(false);
-            // GetData (drop)
-            msg = Message.Create(MessageCommand.GetData, s);
-            uut.ShallDrop(msg, emptyQueue).Should().Be(false);
-            uut.ShallDrop(msg, new object[] { msg }).Should().Be(true);
             // NotFound (no drop)
             msg = Message.Create(MessageCommand.NotFound, s);
             uut.ShallDrop(msg, emptyQueue).Should().Be(false);

neo.UnitTests/Network/RPC/Models/UT_RpcBlock.cs

@@ -0,0 +1,29 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Network.P2P.Payloads;
+using Neo.Network.RPC.Models;
+using System;
+
+namespace Neo.UnitTests.Network.RPC.Models
+{
+    [TestClass]
+    public class UT_RpcBlock
+    {
+        [TestMethod]
+        public void TestToJson()
+        {
+            var rpcBlock = new RpcBlock();
+            var block = new Block();
+            TestUtils.SetupBlockWithValues(block, UInt256.Zero, out UInt256 _, out UInt160 _, out ulong _, out uint _, out Witness _, out Transaction[] _, 1);
+            rpcBlock.Block = block;
+            var json = rpcBlock.ToJson();
+            json["previousblockhash"].AsString().Should().Be("0x0000000000000000000000000000000000000000000000000000000000000000");
+            json.Should().NotBeNull();
+
+            rpcBlock.Confirmations = 1;
+            rpcBlock.NextBlockHash = UInt256.Zero;
+            json = rpcBlock.ToJson();
+            json["confirmations"].AsNumber().Should().Be(1);
+        }
+    }
+}