Asynchronous Oracle

src/neo/Network/P2P/Payloads/OracleResponse.cs

@@ -0,0 +1,48 @@
+using Neo.IO;
+using Neo.IO.Json;
+using System;
+using System.IO;
+
+namespace Neo.Network.P2P.Payloads
+{
+    public class OracleResponse : TransactionAttribute
+    {
+        private const int MaxResultSize = 1024;
+
+        public ulong Id;
+        public bool Success;
+        public byte[] Result;
+
+        public override TransactionAttributeType Type => TransactionAttributeType.OracleResponse;
+        public override bool AllowMultiple => false;
+
+        public override int Size => base.Size +
+            sizeof(ulong) +         //Id
+            sizeof(bool) +          //Success
+            Result.GetVarSize();    //Result
+
+        protected override void DeserializeWithoutType(BinaryReader reader)
+        {
+            Id = reader.ReadUInt64();
+            Success = reader.ReadBoolean();
+            Result = reader.ReadVarBytes(MaxResultSize);
+            if (!Success && Result.Length > 0) throw new FormatException();
+        }
+
+        protected override void SerializeWithoutType(BinaryWriter writer)
+        {
+            writer.Write(Id);
+            writer.Write(Success);
+            writer.WriteVarBytes(Result);
+        }
+
+        public override JObject ToJson()
+        {
+            JObject json = base.ToJson();
+            json["id"] = Id;
+            json["success"] = Success;
+            json["result"] = Convert.ToBase64String(Result);
+            return json;
+        }
+    }
+}

src/neo/Network/P2P/Payloads/Transaction.cs

@@ -5,6 +5,7 @@
 using Neo.Persistence;
 using Neo.SmartContract;
 using Neo.SmartContract.Native;
+using Neo.SmartContract.Native.Oracle;
 using Neo.VM;
 using Neo.VM.Types;
 using Neo.Wallets;
@@ -26,6 +27,8 @@ public class Transaction : IEquatable<Transaction>, IInventory, IInteroperable
         /// </summary>
         public const int MaxTransactionAttributes = 16;
 
+        private static readonly byte[] oracleResponseScript;
+
         private byte version;
         private uint nonce;
         private UInt160 sender;
@@ -53,6 +56,8 @@ public TransactionAttribute[] Attributes
         private Dictionary<UInt160, Cosigner> _cosigners;
         public IReadOnlyDictionary<UInt160, Cosigner> Cosigners => _cosigners ??= attributes.OfType<Cosigner>().ToDictionary(p => p.Account);
 
+        public bool IsOracleResponse => Attributes.Any(p => p is OracleResponse);
+
         /// <summary>
         /// The <c>NetworkFee</c> for the transaction divided by its <c>Size</c>.
         /// <para>Note that this property must be used with care. Getting the value of this property multiple times will return the same result. The value of this property can only be obtained after the transaction has been completely built (no longer modified).</para>
@@ -144,6 +149,22 @@ public Witness[] Witnesses
             set { witnesses = value; _size = 0; }
         }
 
+        static Transaction()
+        {
+            using ScriptBuilder sb = new ScriptBuilder();
+            sb.EmitAppCall(NativeContract.Oracle.Hash, "finish");
+            oracleResponseScript = sb.ToArray();
+        }
+
+        private bool CheckOracleResponse(StoreView snapshot)
+        {
+            OracleResponse response = Attributes.OfType<OracleResponse>().FirstOrDefault();
+            if (response is null) return true;
+            OracleRequest request = NativeContract.Oracle.GetRequest(snapshot, response.Id);
+            Transaction request_tx = snapshot.GetTransaction(request.Txid);
+            return Sender.Equals(request_tx.Sender);
+        }
+
         void ISerializable.Deserialize(BinaryReader reader)
         {
             int startPosition = -1;
@@ -191,6 +212,12 @@ public void DeserializeUnsigned(BinaryReader reader)
             }
             Script = reader.ReadVarBytes(ushort.MaxValue);
             if (Script.Length == 0) throw new FormatException();
+            if (IsOracleResponse)
+            {
+                if (Cosigners.Count > 0) throw new FormatException();
+                if (!Script.AsSpan().SequenceEqual(oracleResponseScript))
+                    throw new FormatException();
+            }
         }
 
         public bool Equals(Transaction other)
@@ -217,7 +244,12 @@ public override int GetHashCode()
 
         public UInt160[] GetScriptHashesForVerifying(StoreView snapshot)
         {
-            var hashes = new HashSet<UInt160>(Cosigners.Keys) { Sender };
+            var hashes = new HashSet<UInt160>(Cosigners.Keys)
+            {
+                IsOracleResponse
+                ? Blockchain.GetConsensusAddress(NativeContract.Oracle.GetOracleNodes(snapshot))
+                : Sender
+            };
             return hashes.OrderBy(p => p).ToArray();
         }
 
@@ -286,9 +318,9 @@ public virtual VerifyResult Verify(StoreView snapshot, BigInteger totalSenderFee
         {
             VerifyResult result = VerifyForEachBlock(snapshot, totalSenderFeeFromPool);
             if (result != VerifyResult.Succeed) return result;
-            int size = Size;
-            if (size > MaxTransactionSize) return VerifyResult.Invalid;
-            long net_fee = NetworkFee - size * NativeContract.Policy.GetFeePerByte(snapshot);
+            if (!CheckOracleResponse(snapshot)) return VerifyResult.Invalid;
+            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;

src/neo/Network/P2P/Payloads/TransactionAttributeType.cs

@@ -5,6 +5,8 @@ namespace Neo.Network.P2P.Payloads
     public enum TransactionAttributeType : byte
     {
         [ReflectionCache(typeof(Cosigner))]
-        Cosigner = 0x01
+        Cosigner = 0x01,
+        [ReflectionCache(typeof(OracleResponse))]
+        OracleResponse = 0x11
     }
 }

src/neo/SmartContract/ApplicationEngine.Runtime.cs

@@ -1,6 +1,8 @@
 using Neo.Cryptography.ECC;
 using Neo.IO;
 using Neo.Network.P2P.Payloads;
+using Neo.SmartContract.Native;
+using Neo.SmartContract.Native.Oracle;
 using Neo.VM.Types;
 using System;
 using System.Collections.Generic;
@@ -104,7 +106,19 @@ internal bool CheckWitnessInternal(UInt160 hash)
         {
             if (ScriptContainer is Transaction tx)
             {
-                if (!tx.Cosigners.TryGetValue(hash, out Cosigner cosigner)) return false;
+                IReadOnlyDictionary<UInt160, Cosigner> cosigners;
+                OracleResponse response = tx.Attributes.OfType<OracleResponse>().FirstOrDefault();
+                if (response is null)
+                {
+                    cosigners = tx.Cosigners;
+                }
+                else
+                {
+                    OracleRequest request = NativeContract.Oracle.GetRequest(Snapshot, response.Id);
+                    Transaction request_tx = Snapshot.GetTransaction(request.Txid);
+                    cosigners = request_tx.Cosigners;
+                }
+                if (!cosigners.TryGetValue(hash, out Cosigner cosigner)) return false;
                 if (cosigner.Scopes == WitnessScope.Global) return true;
                 if (cosigner.Scopes.HasFlag(WitnessScope.CalledByEntry))
                 {

src/neo/SmartContract/Native/NativeContract.cs

@@ -1,6 +1,7 @@
 using Neo.IO;
 using Neo.Ledger;
 using Neo.SmartContract.Manifest;
+using Neo.SmartContract.Native.Oracle;
 using Neo.SmartContract.Native.Tokens;
 using Neo.VM;
 using Neo.VM.Types;
@@ -24,6 +25,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 OracleContract Oracle { get; } = new OracleContract();
 
         [ContractMethod(0, CallFlags.None)]
         public abstract string Name { get; }
@@ -79,6 +81,12 @@ protected NativeContract()
             contractsHashDictionary.Add(Hash, this);
         }
 
+        protected bool CheckCommittees(ApplicationEngine engine)
+        {
+            UInt160 committeeMultiSigAddr = NEO.GetCommitteeAddress(engine.Snapshot);
+            return engine.CheckWitnessInternal(committeeMultiSigAddr);
+        }
+
         protected StorageKey CreateStorageKey(byte prefix, byte[] key = null)
         {
             StorageKey storageKey = new StorageKey

src/neo/SmartContract/Native/Oracle/OracleContract.Lists.cs

@@ -0,0 +1,43 @@
+using Neo.Cryptography.ECC;
+using Neo.IO;
+using Neo.VM;
+using Neo.VM.Types;
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.Linq;
+using Array = Neo.VM.Types.Array;
+
+namespace Neo.SmartContract.Native.Oracle
+{
+    partial class OracleContract
+    {
+        private class IdList : List<ulong>, IInteroperable
+        {
+            public void FromStackItem(StackItem stackItem)
+            {
+                foreach (StackItem item in (Array)stackItem)
+                    Add(BinaryPrimitives.ReadUInt64LittleEndian(item.GetSpan()));
+            }
+
+            public StackItem ToStackItem(ReferenceCounter referenceCounter)
+            {
+                return new Array(referenceCounter, this.Select(p => (StackItem)BitConverter.GetBytes(p)));
+            }
+        }
+
+        private class NodeList : List<ECPoint>, IInteroperable
+        {
+            public void FromStackItem(StackItem stackItem)
+            {
+                foreach (StackItem item in (Array)stackItem)
+                    Add(ECPoint.DecodePoint(item.GetSpan(), ECCurve.Secp256r1));
+            }
+
+            public StackItem ToStackItem(ReferenceCounter referenceCounter)
+            {
+                return new Array(referenceCounter, this.Select(p => (StackItem)p.ToArray()));
+            }
+        }
+    }
+}

src/neo/SmartContract/Native/Oracle/OracleContract.cs

@@ -0,0 +1,135 @@
+#pragma warning disable IDE0051
+
+using Neo.Cryptography;
+using Neo.Cryptography.ECC;
+using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
+using Neo.SmartContract.Manifest;
+using Neo.VM.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+
+namespace Neo.SmartContract.Native.Oracle
+{
+    public sealed partial class OracleContract : NativeContract
+    {
+        private const int MaxUrlLength = 256;
+        private const int MaxFilterLength = 128;
+        private const int MaxCallbackLength = 32;
+        private const int MaxUserDataLength = 512;
+
+        private const byte Prefix_NodeList = 8;
+        private const byte Prefix_RequestId = 9;
+        private const byte Prefix_Request = 7;
+        private const byte Prefix_IdList = 6;
+
+        private const long OracleRequestPrice = 0_50000000;
+
+        public override int Id => -4;
+        public override string Name => "Oracle";
+
+        internal OracleContract()
+        {
+            Manifest.Features = ContractFeatures.HasStorage | ContractFeatures.Payable;
+        }
+
+        [ContractMethod(0, CallFlags.AllowModifyStates)]
+        private void Finish(ApplicationEngine engine)
+        {
+            Transaction tx = (Transaction)engine.ScriptContainer;
+            OracleResponse response = tx.Attributes.OfType<OracleResponse>().First();
+            StorageKey key = CreateStorageKey(Prefix_Request, BitConverter.GetBytes(response.Id));
+            OracleRequest request = engine.Snapshot.Storages[key].GetInteroperable<OracleRequest>();
+            engine.Snapshot.Storages.Delete(key);
+            key = CreateStorageKey(Prefix_IdList, GetUrlHash(request.Url));
+            IdList list = engine.Snapshot.Storages.GetAndChange(key).GetInteroperable<IdList>();
+            if (!list.Remove(response.Id)) throw new InvalidOperationException();
+            if (list.Count == 0) engine.Snapshot.Storages.Delete(key);
+            GAS.Mint(engine, Hash, OracleRequestPrice);
+            StackItem userData = BinarySerializer.Deserialize(request.UserData, engine.MaxStackSize, engine.MaxItemSize, engine.ReferenceCounter);
+            engine.CallFromNativeContract(null, request.CallbackContract, request.CallbackMethod, request.Url, userData, response.Success, response.Result);
+        }
+
+        [ContractMethod(0_01000000, CallFlags.AllowStates)]
+        public ECPoint[] GetOracleNodes(StoreView snapshot)
+        {
+            return snapshot.Storages[CreateStorageKey(Prefix_NodeList)].GetInteroperable<NodeList>().ToArray();
+        }
+
+        public OracleRequest GetRequest(StoreView snapshot, ulong id)
+        {
+            return snapshot.Storages.TryGet(CreateStorageKey(Prefix_Request, BitConverter.GetBytes(id)))?.GetInteroperable<OracleRequest>();
+        }
+
+        public IEnumerable<OracleRequest> GetRequests(StoreView snapshot)
+        {
+            return snapshot.Storages.Find(new byte[] { Prefix_Request }).Select(p => p.Value.GetInteroperable<OracleRequest>());
+        }
+
+        public IEnumerable<OracleRequest> GetRequestsByUrl(StoreView snapshot, string url)
+        {
+            IdList list = snapshot.Storages.TryGet(CreateStorageKey(Prefix_IdList, GetUrlHash(url)))?.GetInteroperable<IdList>();
+            if (list is null) yield break;
+            foreach (ulong id in list)
+                yield return snapshot.Storages[CreateStorageKey(Prefix_Request, BitConverter.GetBytes(id))].GetInteroperable<OracleRequest>();
+        }
+
+        private static byte[] GetUrlHash(string url)
+        {
+            return Crypto.Hash160(Utility.StrictUTF8.GetBytes(url));
+        }
+
+        [ContractMethod(1_00000000, CallFlags.AllowModifyStates)]
+        private void Incentivize(ApplicationEngine engine)
+        {
+            ECPoint[] nodes = GetOracleNodes(engine.Snapshot);
+            BigInteger gas = GAS.BalanceOf(engine.Snapshot, Hash) / nodes.Length;
+            if (gas.IsZero) return;
+            foreach (ECPoint node in nodes)
+            {
+                UInt160 to = Contract.CreateSignatureRedeemScript(node).ToScriptHash();
+                GAS.TransferInternal(engine, Hash, to, gas);
+            }
+        }
+
+        internal override void Initialize(ApplicationEngine engine)
+        {
+            engine.Snapshot.Storages.Add(CreateStorageKey(Prefix_NodeList), new StorageItem(new NodeList()));
+            engine.Snapshot.Storages.Add(CreateStorageKey(Prefix_RequestId), new StorageItem(BitConverter.GetBytes(0ul)));
+        }
+
+        [ContractMethod(OracleRequestPrice, CallFlags.AllowModifyStates)]
+        private void Request(ApplicationEngine engine, string url, string filter, string callback, StackItem userData)
+        {
+            if (Utility.StrictUTF8.GetByteCount(url) > MaxUrlLength
+                || (filter != null && Utility.StrictUTF8.GetByteCount(filter) > MaxFilterLength)
+                || Utility.StrictUTF8.GetByteCount(callback) > MaxCallbackLength)
+                throw new ArgumentException();
+            StorageItem item_id = engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_RequestId));
+            ulong id = BitConverter.ToUInt64(item_id.Value) + 1;
+            item_id.Value = BitConverter.GetBytes(id);
+            engine.Snapshot.Storages.Add(CreateStorageKey(Prefix_Request, item_id.Value), new StorageItem(new OracleRequest
+            {
+                Txid = ((Transaction)engine.ScriptContainer).Hash,
+                Url = url,
+                Filter = filter,
+                CallbackContract = engine.CallingScriptHash,
+                CallbackMethod = callback,
+                UserData = BinarySerializer.Serialize(userData, MaxUserDataLength)
+            }));
+            engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_IdList, GetUrlHash(url)), () => new StorageItem(new IdList())).GetInteroperable<IdList>().Add(id);
+        }
+
+        [ContractMethod(0, CallFlags.AllowModifyStates)]
+        private void SetOracleNodes(ApplicationEngine engine, ECPoint[] nodes)
+        {
+            if (!CheckCommittees(engine)) throw new InvalidOperationException();
+            NodeList list = engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_NodeList)).GetInteroperable<NodeList>();
+            list.Clear();
+            list.AddRange(nodes);
+        }
+    }
+}