Integrate NeoFS into oracle module

src/OracleService/OracleService.cs

@@ -43,10 +43,7 @@ public class OracleService : Plugin, IPersistencePlugin
         private int counter;
         private NeoSystem System;
 
-        private static readonly IReadOnlyDictionary<string, IOracleProtocol> protocols = new Dictionary<string, IOracleProtocol>
-        {
-            ["https"] = new OracleHttpsProtocol()
-        };
+        private readonly Dictionary<string, IOracleProtocol> protocols = new Dictionary<string, IOracleProtocol>();
 
         public override string Description => "Built-in oracle plugin";
 
@@ -112,6 +109,8 @@ public void Start(Wallet wallet)
             if (!CheckOracleAccount(wallet, oracles)) throw new ArgumentException("There is no oracle account in wallet");
 
             this.wallet = wallet;
+            protocols["https"] = new OracleHttpsProtocol();
+            protocols["neofs"] = new OracleNeoFSProtocol(wallet, oracles);
             started = true;
             timer = new Timer(OnTimer, null, RefreshInterval, Timeout.Infinite);
 

src/OracleService/OracleService.csproj

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

src/OracleService/OracleService/config.json

@@ -8,6 +8,10 @@
     "Https": {
       "Timeout": 5000
     },
+    "NeoFS": {
+      "EndPoint": "127.0.0.1:8080",
+      "Timeout": 15000
+    },
     "AutoStart": false
   }
 }

src/OracleService/Protocols/OracleNeoFSProtocol.cs

@@ -0,0 +1,128 @@
+using Google.Protobuf;
+using Neo.Cryptography.ECC;
+using Neo.Network.P2P.Payloads;
+using Neo.Wallets;
+using NeoFS.API.v2.Client;
+using NeoFS.API.v2.Client.ObjectParams;
+using NeoFS.API.v2.Cryptography;
+using NeoFS.API.v2.Refs;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using Object = NeoFS.API.v2.Object.Object;
+using Range = NeoFS.API.v2.Object.Range;
+
+namespace Neo.Plugins
+{
+    class OracleNeoFSProtocol : IOracleProtocol
+    {
+        private readonly System.Security.Cryptography.ECDsa privateKey;
+
+        public OracleNeoFSProtocol(Wallet wallet, ECPoint[] oracles)
+        {
+            byte[] key = oracles.Select(p => wallet.GetAccount(p)).Where(p => p is not null && p.HasKey && !p.Lock).FirstOrDefault().GetKey().PrivateKey;
+            privateKey = key.LoadPrivateKey();
+        }
+
+        public void Configure()
+        {
+        }
+
+        public void Dispose()
+        {
+            privateKey.Dispose();
+        }
+
+        public async Task<(OracleResponseCode, string)> ProcessAsync(Uri uri, CancellationToken cancellation)
+        {
+            Utility.Log(nameof(OracleNeoFSProtocol), LogLevel.Debug, $"Request: {uri.AbsoluteUri}");
+
+            if (!Settings.Default.AllowPrivateHost)
+            {
+                IPHostEntry entry = await Dns.GetHostEntryAsync(uri.Host);
+                if (entry.IsInternal())
+                    return (OracleResponseCode.Forbidden, null);
+            }
+            try
+            {
+                byte[] res = await GetAsync(uri, Settings.Default.NeoFS.EndPoint, cancellation);
+                Utility.Log(nameof(OracleNeoFSProtocol), LogLevel.Debug, $"NeoFS result: {res.ToHexString()}");
+                return (OracleResponseCode.Success, Convert.ToBase64String(res));
+            }
+            catch (Exception e)
+            {
+                Utility.Log(nameof(OracleNeoFSProtocol), LogLevel.Debug, $"NeoFS result: error,{e.Message}");
+                return (OracleResponseCode.Error, null);
+            }
+        }
+
+        private async Task<byte[]> GetAsync(Uri uri, string host, CancellationToken cancellation)
+        {
+            string[] ps = uri.AbsolutePath.Split("/");
+            if (ps.Length < 2) throw new FormatException("Invalid neofs url");
+            ContainerID containerID = ContainerID.FromBase58String(ps[0]);
+            ObjectID objectID = ObjectID.FromBase58String(ps[1]);
+            Address objectAddr = new()
+            {
+                ContainerId = containerID,
+                ObjectId = objectID
+            };
+            Client client = new(privateKey, host, 120000);
+            var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellation);
+            tokenSource.CancelAfter(Settings.Default.NeoFS.Timeout);
+            if (ps.Length == 2)
+                return await GetPayloadAsync(client, objectAddr, tokenSource.Token);
+            return ps[2] switch
+            {
+                "range" => await GetRangeAsync(client, objectAddr, ps.Skip(3).ToArray(), tokenSource.Token),
+                "header" => GetHeader(client, objectAddr, tokenSource.Token),
+                "hash" => GetHash(client, objectAddr, ps.Skip(3).ToArray(), tokenSource.Token),
+                _ => throw new Exception("invalid command")
+            };
+        }
+
+        private static async Task<byte[]> GetPayloadAsync(Client client, Address addr, CancellationToken cancellation)
+        {
+            Object obj = await client.GetObject(cancellation, new GetObjectParams() { Address = addr }, new CallOptions { Ttl = 2 });
+            return obj.Payload.ToByteArray();
+        }
+
+        private static Task<byte[]> GetRangeAsync(Client client, Address addr, string[] ps, CancellationToken cancellation)
+        {
+            if (ps.Length == 0) throw new Exception("object range is invalid (expected 'Offset|Length'");
+            Range range = ParseRange(ps[0]);
+            return client.GetObjectPayloadRangeData(cancellation, new RangeDataParams() { Address = addr, Range = range }, new CallOptions { Ttl = 2 });
+        }
+
+        private static byte[] GetHeader(Client client, Address addr, CancellationToken cancellation)
+        {
+            var obj = client.GetObjectHeader(cancellation, new ObjectHeaderParams() { Address = addr }, new CallOptions { Ttl = 2 });
+            return obj.ToByteArray();
+        }
+
+        private static byte[] GetHash(Client client, Address addr, string[] ps, CancellationToken cancellation)
+        {
+            if (ps.Length == 0 || ps[0] == "")
+            {
+                Object obj = client.GetObjectHeader(cancellation, new ObjectHeaderParams() { Address = addr }, new CallOptions { Ttl = 2 });
+                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 } }, new CallOptions { Ttl = 2 });
+            if (hashes.Count == 0) throw new Exception(string.Format("{0}: empty response", "object range is invalid (expected 'Offset|Length'"));
+            return hashes[0];
+        }
+
+        private static Range ParseRange(string s)
+        {
+            int sepIndex = s.IndexOf("|");
+            if (sepIndex < 0) throw new Exception("object range is invalid (expected 'Offset|Length'");
+            ulong offset = ulong.Parse(s[..sepIndex]);
+            ulong length = ulong.Parse(s[sepIndex..]);
+            return new Range() { Offset = offset, Length = length };
+        }
+    }
+}

src/OracleService/Settings.cs

@@ -14,6 +14,18 @@ public HttpsSettings(IConfigurationSection section)
         }
     }
 
+    class NeoFSSettings
+    {
+        public string EndPoint { get; }
+        public TimeSpan Timeout { get; }
+
+        public NeoFSSettings(IConfigurationSection section)
+        {
+            EndPoint = section.GetValue("EndPoint", "127.0.0.1:8080");
+            Timeout = TimeSpan.FromMilliseconds(section.GetValue("Timeout", 15000));
+        }
+    }
+
     class Settings
     {
         public uint Network { get; }
@@ -22,6 +34,7 @@ class Settings
         public bool AllowPrivateHost { get; }
         public string[] AllowedContentTypes { get; }
         public HttpsSettings Https { get; }
+        public NeoFSSettings NeoFS { get; }
         public bool AutoStart { get; }
 
         public static Settings Default { get; private set; }
@@ -34,6 +47,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"));
+            NeoFS = new NeoFSSettings(section.GetSection("NeoFS"));
             AutoStart = section.GetValue("AutoStart", false);
         }