Integrate NeoFS into oracle module

src/OracleService/OracleService.cs

@@ -43,7 +43,8 @@ public class OracleService : Plugin, IPersistencePlugin
 
         private static readonly IReadOnlyDictionary<string, IOracleProtocol> protocols = new Dictionary<string, IOracleProtocol>
         {
-            ["https"] = new OracleHttpsProtocol()
+            ["https"] = new OracleHttpsProtocol(),
+            ["neofs"] = new OracleFsProtocol()
         };
 
         public override string Description => "Built-in oracle plugin";
@@ -86,6 +87,8 @@ private void OnStart()
             {
                 if (!CheckOracleAvaiblable(snapshot, out ECPoint[] oracles)) throw new ArgumentException("The oracle service is unavailable");
                 if (!CheckOracleAccount(wallet, oracles)) throw new ArgumentException("There is no oracle account in wallet");
+                foreach (var (_, p) in protocols)
+                    p.AttachWallet(wallet, oracles);
             }
 
             started = true;

src/OracleService/OracleService.csproj

@@ -6,6 +6,7 @@
 
   <ItemGroup>
     <PackageReference Include="Neo.ConsoleService" Version="1.0.0" />
+    <PackageReference Include="NeoFS.API" Version="0.0.18" />
   </ItemGroup>
 
   <ItemGroup>

src/OracleService/OracleService/config.json

@@ -6,6 +6,9 @@
     "AllowedContentTypes": [ "application/json" ],
     "Https": {
       "Timeout": 5000
+    },
+    "Fs": {
+      "FsNodes": [],
     }
   }
 }

src/OracleService/Protocols/IOracleProtocol.cs

@@ -1,4 +1,6 @@
+using Neo.Cryptography.ECC;
 using Neo.Network.P2P.Payloads;
+using Neo.Wallets;
 using System;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,5 +11,6 @@ interface IOracleProtocol : IDisposable
     {
         void Configure();
         Task<(OracleResponseCode, string)> ProcessAsync(Uri uri, CancellationToken cancellation);
+        void AttachWallet(Wallet wallet, ECPoint[] oracles);
     }
 }

src/OracleService/Protocols/OracleFsProtocol.cs

@@ -0,0 +1,153 @@
+using Google.Protobuf;
+using Neo.Network.P2P.Payloads;
+using NeoFS.API.v2.Client;
+using NeoFS.API.v2.Client.ObjectParams;
+using NeoFS.API.v2.Refs;
+using NeoFS.API.v2.Cryptography;
+using System;
+using System.Linq;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using Range = NeoFS.API.v2.Object.Range;
+using System.Collections.Generic;
+using Object = NeoFS.API.v2.Object.Object;
+using Neo.Wallets;
+using Neo.Cryptography.ECC;
+
+namespace Neo.Plugins
+{
+    class OracleFsProtocol : IOracleProtocol
+    {
+        private byte[] privateKey;
+        private const string URIScheme = "neofs";
+        private const string ErrInvalidScheme = "invalid URI scheme";
+        private const string ErrMissingObject = "object ID is missing from URI";
+        private const string ErrInvalidContainer = "container ID is invalid";
+        private const string ErrInvalidObject = "object ID is invalid";
+        private const string ErrInvalidRange = "object range is invalid (expected 'Offset|Length'";
+        private const string ErrInvalidCommand = "invalid command";
+
+        private const string RangeSep = "|";
+        private const string RangeCmd = "range";
+        private const string HeaderCmd = "header";
+        private const string HashCmd = "hash";
+
+        public void Configure()
+        {
+        }
+
+        public void Dispose()
+        {
+        }
+
+        public void AttachWallet(Wallet wallet, ECPoint[] oracles)
+        {
+            privateKey = oracles.Select(p => wallet.GetAccount(p)).Where(p => p is not null && p.HasKey && !p.Lock).FirstOrDefault(null)?.GetKey().PrivateKey;
+        }
+
+        public async Task<(OracleResponseCode, string)> ProcessAsync(Uri uri, CancellationToken cancellation)
+        {
+            Utility.Log(nameof(OracleFsProtocol), LogLevel.Debug, $"Request: {uri.AbsoluteUri}");
+
+            if (!Settings.Default.AllowPrivateHost)
+            {
+                IPHostEntry entry = await Dns.GetHostEntryAsync(uri.Host);
+                if (entry.IsInternal())
+                    return (OracleResponseCode.Forbidden, null);
+            }
+            int index = uri.LocalPath.GetHashCode() % Settings.Default.Fs.FSNodes.Length;
+            try
+            {
+                byte[] res = Get(cancellation, privateKey, uri, Settings.Default.Fs.FSNodes[index]);
+                Utility.Log(nameof(OracleFsProtocol), LogLevel.Debug, $"NeoFS result: {res.ToHexString()}");
+                return (OracleResponseCode.Success, res.ToHexString());
+            }
+            catch (Exception e)
+            {
+                Utility.Log(nameof(OracleFsProtocol), LogLevel.Debug, $"NeoFS result: error,{e.Message}");
+                return (OracleResponseCode.Error, null);
+            }
+        }
+
+        private byte[] Get(CancellationToken cancellation, byte[] privateKey, Uri uri, string host)
+        {
+            if (uri.Scheme != URIScheme) throw new Exception(ErrInvalidScheme);
+            string[] ps = uri.OriginalString.Substring((uri.Scheme + "://").Length).Split("/");
+            if (ps.Length == 0) throw new Exception(ErrMissingObject);
+            byte[] rawCID = Cryptography.Base58.Decode(uri.Host);
+            if (rawCID.Length != 32) throw new Exception(ErrInvalidContainer);
+            byte[] rawOID = Cryptography.Base58.Decode(ps[0]);
+            if (rawOID.Length != 32) throw new Exception(ErrInvalidObject);
+            ContainerID containerID = ContainerID.FromByteArray(rawCID);
+            ObjectID objectID = ObjectID.FromByteArray(rawOID);
+            Address objectAddr = new Address()
+            {
+                ContainerId = containerID,
+                ObjectId = objectID
+            };
+            Client client = new Client(host, privateKey.LoadPrivateKey());
+            if (ps.Length == 1)
+            {
+                return GetPayload(cancellation, client, objectAddr);
+            }
+            else if (ps[1] == RangeCmd)
+            {
+                return GetPayload(cancellation, client, objectAddr);
+            }
+            else if (ps[1] == HeaderCmd)
+            {
+                return GetPayload(cancellation, client, objectAddr);
+            }
+            else if (ps[1] == HashCmd)
+            {
+                return GetHash(cancellation, client, objectAddr, ps.Skip(2).ToArray());
+            }
+            else
+            {
+                throw new Exception(ErrInvalidCommand);
+            }
+        }
+
+        private byte[] GetPayload(CancellationToken cancellation, Client client, Address addr)
+        {
+            Object obj = client.GetObject(cancellation, new GetObjectParams() { Address = addr }).Result;
+            return obj.Payload.ToByteArray();
+        }
+
+        private byte[] GetRange(CancellationToken cancellation, Client client, Address addr, params string[] ps)
+        {
+            if (ps.Length == 0) throw new Exception(ErrInvalidRange);
+            Range range = ParseRange(ps[0]);
+            return client.GetObjectPayloadRangeData(cancellation, new RangeDataParams() { Address = addr, Range = range }).Result;
+        }
+
+        private byte[] GetHeader(CancellationToken cancellation, Client client, Address addr)
+        {
+            var obj = client.GetObjectHeader(cancellation, new ObjectHeaderParams() { Address = addr });
+            return obj.ToByteArray();
+        }
+
+        private byte[] GetHash(CancellationToken cancellation, Client client, Address addr, params string[] ps)
+        {
+            if (ps.Length == 0 || ps[0] == "")
+            {
+                Object obj = client.GetObjectHeader(cancellation, new ObjectHeaderParams() { Address = addr });
+                return obj.Header.PayloadHash.Sum.ToByteArray();
+            }
+            Range range = ParseRange(ps[0]);
+            List<byte[]> hashes = client.GetObjectPayloadRangeHash(cancellation, new RangeChecksumParams() { Address = addr, Ranges = new List<Range>() { range } });
+            if (hashes.Count == 0) throw new Exception(string.Format("{0}: empty response", ErrInvalidRange));
+            return hashes[0];
+        }
+
+        private Range ParseRange(string s)
+        {
+            int sepIndex = s.IndexOf(RangeSep);
+            if (sepIndex < 0) throw new Exception(ErrInvalidRange);
+            ulong offset = ulong.Parse(s.Substring(0, sepIndex));
+            ulong length = ulong.Parse(s.Substring(sepIndex));
+            return new Range() { Offset = offset, Length = length };
+        }
+    }
+}

src/OracleService/Protocols/OracleHttpsProtocol.cs

@@ -1,4 +1,6 @@
+using Neo.Cryptography.ECC;
 using Neo.Network.P2P.Payloads;
+using Neo.Wallets;
 using System;
 using System.Linq;
 using System.Net;
@@ -12,6 +14,10 @@ class OracleHttpsProtocol : IOracleProtocol
     {
         private readonly HttpClient client = new HttpClient();
 
+        public void AttachWallet(Wallet wallet, ECPoint[] oracles)
+        {
+        }
+
         public void Configure()
         {
             client.DefaultRequestHeaders.Accept.Clear();

src/OracleService/Settings.cs

@@ -14,13 +14,24 @@ public HttpsSettings(IConfigurationSection section)
         }
     }
 
+    class FsSettings
+    {
+        public string[] FSNodes { get; }
+
+        public FsSettings(IConfigurationSection section)
+        {
+            FSNodes = section.GetSection("FsNodes").GetChildren().Select(p => p.Get<string>()).ToArray();
+        }
+    }
+
     class Settings
     {
         public Uri[] Nodes { get; }
         public TimeSpan MaxTaskTimeout { get; }
         public bool AllowPrivateHost { get; }
         public string[] AllowedContentTypes { get; }
         public HttpsSettings Https { get; }
+        public FsSettings Fs { get; }
 
         public static Settings Default { get; private set; }
 
@@ -31,6 +42,7 @@ private Settings(IConfigurationSection section)
             AllowPrivateHost = section.GetValue("AllowPrivateHost", false);
             AllowedContentTypes = section.GetSection("AllowedContentTypes").GetChildren().Select(p => p.Get<string>()).ToArray();
             Https = new HttpsSettings(section.GetSection("Https"));
+            Fs = new FsSettings(section.GetSection("Fs"));
         }
 
         public static void Load(IConfigurationSection section)