Oracle policy contract

src/neo/Oracle/OraclePolicyContract.cs

@@ -0,0 +1,186 @@
+using Neo.Cryptography.ECC;
+using Neo.IO;
+using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
+using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
+using Neo.SmartContract.Native;
+using Neo.VM;
+using Neo.VM.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using Array = Neo.VM.Types.Array;
+
+namespace Neo.Oracle
+{
+    public sealed class OraclePolicyContract : NativeContract
+    {
+        public override string ServiceName => "Neo.Native.Oracle.Policy";
+
+        public override int Id => -4;
+
+        private const byte Prefix_Validator = 24;
+        private const byte Prefix_TimeOutMilliSeconds = 25;
+        private const byte Prefix_PerRequestFee = 26;
+
+        public OraclePolicyContract()
+        {
+            Manifest.Features = ContractFeatures.HasStorage;
+        }
+
+        [ContractMethod(0_01000000, ContractParameterType.Boolean, ParameterTypes = new[] { ContractParameterType.Hash160, ContractParameterType.Array }, ParameterNames = new[] { "account", "pubkeys" })]
+        private StackItem DelegateOracleValidator(ApplicationEngine engine, Array args)
+        {
+            UInt160 account = new UInt160(args[0].GetSpan());
+            if (!InteropService.Runtime.CheckWitnessInternal(engine, account)) return false;
+            ECPoint[] pubkeys = ((Array)args[1]).Select(p => p.GetSpan().AsSerializable<ECPoint>()).ToArray();
+            if (pubkeys.Length != 2) return false;
+            StoreView snapshot = engine.Snapshot;
+            StorageKey key = CreateStorageKey(Prefix_Validator, pubkeys[0]);
+            if (snapshot.Storages.TryGet(key) != null)
+            {
+                StorageItem value = snapshot.Storages.GetAndChange(key);
+                value.Value = pubkeys[1].ToArray();
+            }
+            else
+            {
+                snapshot.Storages.Add(key, new StorageItem
+                {
+                    Value = pubkeys[1].ToArray()
+                });
+            }
+            return true;
+        }
+
+        public ECPoint[] GetOracleValidators(StoreView snapshot)
+        {
+            ECPoint[] consensusPublicKey = PolicyContract.NEO.GetValidators(snapshot);
+            IEnumerable<(ECPoint ConsensusPublicKey, ECPoint OraclePublicKey)> hasDelegateOracleValidators = GetDelegateOracleValidators(snapshot).Where(p => consensusPublicKey.Contains(p.ConsensusPublicKey));
+            hasDelegateOracleValidators.ToList().ForEach(p =>
+            {
+                var index = System.Array.IndexOf(consensusPublicKey, p.ConsensusPublicKey);
+                if (index >= 0) consensusPublicKey[index] = p.OraclePublicKey;
+            });
+            return consensusPublicKey;
+        }
+
+        public BigInteger GetOracleValidatorsCount(StoreView snapshot)
+        {
+            return GetOracleValidators(snapshot).Length;
+        }
+
+        internal IEnumerable<(ECPoint ConsensusPublicKey, ECPoint OraclePublicKey)> GetDelegateOracleValidators(StoreView snapshot)
+        {
+            byte[] prefix_key = StorageKey.CreateSearchPrefix(Id, new[] { Prefix_Validator });
+            return snapshot.Storages.Find(prefix_key).Select(p =>
+            (
+                p.Key.Key.AsSerializable<ECPoint>(1),
+                p.Value.Value.AsSerializable<ECPoint>(1)
+            ));
+        }
+
+        [ContractMethod(0_03000000, ContractParameterType.Boolean, ParameterTypes = new[] { ContractParameterType.Integer }, ParameterNames = new[] { "fee" })]
+        private StackItem SetTimeOutMilliSeconds(ApplicationEngine engine, Array args)
+        {
+            StoreView snapshot = engine.Snapshot;
+            Transaction tx = (Transaction)engine.ScriptContainer;
+            Array signatures = new Array(tx.Witnesses.ToList().Select(p => StackItem.FromInterface(p.VerificationScript)));
+            Array pubkeys = new Array(GetOracleValidators(snapshot).ToList().Select(p => StackItem.FromInterface(p)));
+            engine.CurrentContext.EvaluationStack.Push(signatures);
+            engine.CurrentContext.EvaluationStack.Push(pubkeys);
+            engine.CurrentContext.EvaluationStack.Push(StackItem.Null);
+
+            if (BitConverter.ToInt32(args[0].GetSpan()) <= 0) return false;
+            int timeOutMilliSeconds = BitConverter.ToInt32(args[0].GetSpan());
+            if (!InteropService.Crypto.ECDsaCheckMultiSig.Handler.Invoke(engine))
+            {
+                return false;
+            }
+            StorageKey key = CreateStorageKey(Prefix_TimeOutMilliSeconds);
+            if (snapshot.Storages.TryGet(key) != null)
+            {
+                StorageItem value = snapshot.Storages.GetAndChange(key);
+                value.Value = BitConverter.GetBytes(timeOutMilliSeconds);
+                return true;
+            }
+            else
+            {
+                snapshot.Storages.Add(key, new StorageItem
+                {
+                    Value = BitConverter.GetBytes(timeOutMilliSeconds)
+                });
+                return true;
+            }
+        }
+
+        public int GetTimeOutMilliSeconds(StoreView snapshot)
+        {
+            StorageKey key = CreateStorageKey(Prefix_TimeOutMilliSeconds);
+            if (snapshot.Storages.TryGet(key) != null)
+            {
+                return BitConverter.ToInt32(snapshot.Storages.TryGet(key).Value, 0);
+            }
+            else
+            {
+                snapshot.Storages.Add(key, new StorageItem
+                {
+                    Value = BitConverter.GetBytes(1000)
+                });
+                return 1000;
+            }
+        }
+
+        [ContractMethod(0_03000000, ContractParameterType.Boolean, ParameterTypes = new[] { ContractParameterType.Integer }, ParameterNames = new[] { "fee" })]
+        private StackItem SetPerRequestFee(ApplicationEngine engine, Array args)
+        {
+            StoreView snapshot = engine.Snapshot;
+            Transaction tx = (Transaction)engine.ScriptContainer;
+            Array signatures = new Array(tx.Witnesses.ToList().Select(p => StackItem.FromInterface(p.VerificationScript)));
+            Array pubkeys = new Array(GetOracleValidators(snapshot).ToList().Select(p => StackItem.FromInterface(p)));
+            engine.CurrentContext.EvaluationStack.Push(signatures);
+            engine.CurrentContext.EvaluationStack.Push(pubkeys);
+            engine.CurrentContext.EvaluationStack.Push(StackItem.Null);
+            if (BitConverter.ToInt32(args[0].GetSpan()) <= 0) return false;
+            int perRequestFee = BitConverter.ToInt32(args[0].GetSpan());
+            if (!InteropService.Crypto.ECDsaCheckMultiSig.Handler.Invoke(engine))
+            {
+                return false;
+            }
+            StorageKey key = CreateStorageKey(Prefix_PerRequestFee);
+            if (snapshot.Storages.TryGet(key) != null)
+            {
+                StorageItem value = snapshot.Storages.GetAndChange(key);
+                value.Value = BitConverter.GetBytes(perRequestFee);
+                return true;
+            }
+            else
+            {
+                snapshot.Storages.Add(key, new StorageItem
+                {
+                    Value = BitConverter.GetBytes(perRequestFee)
+                });
+                return true;
+            }
+        }
+
+        public int GetPerRequestFee(SnapshotView snapshot)
+        {
+            StorageKey key = CreateStorageKey(Prefix_PerRequestFee);
+            if (snapshot.Storages.TryGet(key) != null)
+            {
+                return BitConverter.ToInt32(snapshot.Storages.TryGet(key).Value, 0);
+            }
+            else
+            {
+                snapshot.Storages.Add(key, new StorageItem
+                {
+                    Value = BitConverter.GetBytes(1000)
+                });
+                return 1000;
+            }
+        }
+    }
+}

src/neo/SmartContract/Native/NativeContract.cs

@@ -2,6 +2,7 @@
 
 using Neo.IO;
 using Neo.Ledger;
+using Neo.Oracle;
 using Neo.SmartContract.Manifest;
 using Neo.SmartContract.Native.Tokens;
 using Neo.VM;
@@ -23,6 +24,7 @@ public abstract class NativeContract
         public static NeoToken NEO { get; } = new NeoToken();
         public static GasToken GAS { get; } = new GasToken();
         public static PolicyContract Policy { get; } = new PolicyContract();
+        public static OraclePolicyContract OraclePolicy { get; } = new OraclePolicyContract();
 
         public abstract string ServiceName { get; }
         public uint ServiceHash { get; }

src/neo/neo.csproj

@@ -30,4 +30,8 @@
     <PackageReference Include="Neo.VM" Version="3.0.0-CI00201" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Oracle\" />
+  </ItemGroup>
+
 </Project>

tests/neo.UnitTests/Oracle/UT_OraclePolicy.cs

@@ -0,0 +1,116 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Cryptography.ECC;
+using Neo.IO;
+using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
+using Neo.Oracle;
+using Neo.Persistence;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using Neo.UnitTests.Extensions;
+using Neo.VM;
+using Neo.VM.Types;
+using Neo.Wallets;
+using System.Linq;
+using System.Numerics;
+
+namespace Neo.UnitTests.Oracle
+{
+    [TestClass]
+    public class UT_OraclePolicy
+    {
+        [TestInitialize]
+        public void TestSetup()
+        {
+            TestBlockchain.InitializeMockNeoSystem();
+        }
+
+        [TestMethod]
+        public void Check_GetPerRequestFee()
+        {
+            var snapshot = Blockchain.Singleton.GetSnapshot();
+            // Fake blockchain
+            OraclePolicyContract contract = NativeContract.OraclePolicy;
+            Assert.AreEqual(contract.GetPerRequestFee(snapshot), 1000);
+        }
+
+        [TestMethod]
+        public void Check_GetTimeOutMilliSeconds()
+        {
+            var snapshot = Blockchain.Singleton.GetSnapshot();
+            // Fake blockchain
+            OraclePolicyContract contract = NativeContract.OraclePolicy;
+            Assert.AreEqual(contract.GetPerRequestFee(snapshot), 1000);
+        }
+
+        [TestMethod]
+        public void Check_GetOracleValidators()
+        {
+            var snapshot = Blockchain.Singleton.GetSnapshot();
+            // Fake blockchain
+            OraclePolicyContract contract = NativeContract.OraclePolicy;
+            ECPoint[] obj = contract.GetOracleValidators(snapshot);
+            Assert.AreEqual(obj.Length, 7);
+        }
+
+        [TestMethod]
+        public void Test_DelegateOracleValidator()
+        {
+            var snapshot = Blockchain.Singleton.GetSnapshot();
+            // Fake blockchain
+            OraclePolicyContract contract = NativeContract.OraclePolicy;
+            ECPoint[] obj = contract.GetOracleValidators(snapshot);
+            Assert.AreEqual(obj.Length, 7);
+
+            // Without signature
+            byte[] privateKey1 = { 0x01,0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
+            KeyPair keyPair1 = new KeyPair(privateKey1);
+            ECPoint pubkey1 = keyPair1.PublicKey;
+
+            byte[] privateKey2 = { 0x01,0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
+            KeyPair keyPair2 = new KeyPair(privateKey2);
+            ECPoint pubkey2 = keyPair2.PublicKey;
+
+            Array array = new Array();
+            array.Add(StackItem.FromInterface(privateKey1));
+            array.Add(StackItem.FromInterface(privateKey2));
+
+            /*            var ret = NativeContract.OraclePolicy.Call(snapshot, new Nep5NativeContractExtensions.ManualWitness(),
+                            "DelegateOracleValidator", new ContractParameter(ContractParameterType.Hash160) { Value = 1 }, new ContractParameter(ContractParameterType.Array) { Value = array });
+                        ret.Should().BeOfType<VM.Types.Boolean>();
+                        ret.ToBoolean().Should().BeFalse();*/
+        }
+        internal static (bool State, bool Result) Check_DelegateOracleValidator(StoreView snapshot, byte[] account, byte[][] pubkeys, bool signAccount)
+        {
+            var engine = new ApplicationEngine(TriggerType.Application,
+    new Nep5NativeContractExtensions.ManualWitness(signAccount ? new UInt160(account) : UInt160.Zero), snapshot, 0, true);
+
+            engine.LoadScript(NativeContract.OraclePolicy.Script);
+
+            var script = new ScriptBuilder();
+
+            foreach (var ec in pubkeys) script.EmitPush(ec);
+            script.EmitPush(pubkeys.Length);
+            script.Emit(OpCode.PACK);
+
+            script.EmitPush(account.ToArray());
+            script.EmitPush(2);
+            script.Emit(OpCode.PACK);
+            script.EmitPush("DelegateOracleValidator");
+            engine.LoadScript(script.ToArray());
+
+            if (engine.Execute() == VMState.FAULT)
+            {
+                return (false, false);
+            }
+
+            var result = engine.ResultStack.Pop();
+            result.Should().BeOfType(typeof(VM.Types.Boolean));
+
+            return (true, result.ToBoolean());
+        }
+    }
+}

tests/neo.UnitTests/neo.UnitTests.csproj

@@ -31,4 +31,8 @@
   <ItemGroup>
     <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
   </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Oracle\" />
+  </ItemGroup>
 </Project>