[#43] Client: Set nuget version

Signed-off-by: Pavel Gross <p.gross@yadro.com>

.forgejo/workflows/publish.yml

@@ -0,0 +1,36 @@
+on:
+  push:
+  workflow_dispatch:
+
+jobs:
+  image:
+    name: Publish NuGet packages
+    runs-on: docker
+    container: git.frostfs.info/truecloudlab/env:dotnet-8.0
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Build NuGet packages
+        # `dotnet build` implies and replaces `dotnet pack` thanks to `GeneratePackageOnBuild`
+        run: dotnet build
+
+      - name: Publish NuGet packages
+        run: |-
+          dotnet nuget add source \
+            --name "$NUGET_REGISTRY" \
+            --username "$NUGET_REGISTRY_USER" \
+            --password "$NUGET_REGISTRY_PASSWORD" \
+            --store-password-in-clear-text \
+            "$NUGET_REGISTRY_URL"
+          find -iname '*.nupkg' | grep . | xargs -d'\n' -t -n1 \
+            dotnet nuget push --source "$NUGET_REGISTRY"
+        env:
+          NUGET_REGISTRY: TrueCloudLab
+          NUGET_REGISTRY_URL: https://git.frostfs.info/api/packages/TrueCloudLab/nuget/index.json
+          NUGET_REGISTRY_USER: ${{secrets.NUGET_REGISTRY_USER}}
+          NUGET_REGISTRY_PASSWORD: ${{secrets.NUGET_REGISTRY_PASSWORD}}
+        if: >-
+          startsWith(github.ref, 'refs/tags/v') &&
+          (github.event_name == 'workflow_dispatch' || github.event_name == 'push')

README.md

@@ -47,9 +47,9 @@ var placementPolicy = new FrostFsPlacementPolicy(true, new FrostFsReplica(1));
 var createContainerParam = new PrmContainerCreate(
     new FrostFsContainerInfo(BasicAcl.PublicRW, new FrostFsPlacementPolicy(true, new FrostFsReplica(1))));
 
-var containerId = await client.CreateContainerAsync(createContainerParam);
+var containerId = await client.PutContainerAsync(createContainerParam);
 
-using var fileStream = File.OpenRead(@"C:\Users\Paul\Pictures\cat.jpeg");
+using var fileStream = File.OpenRead(@"cat.jpeg");
 
 var param = new PrmObjectPut
 {

src/FrostFS.SDK.Client/ApeRules/Actions.cs

@@ -0,0 +1,36 @@
+namespace FrostFS.SDK.Client;
+
+public struct Actions(bool inverted, string[] names) : System.IEquatable<Actions>
+{
+    public bool Inverted { get; set; } = inverted;
+
+    public string[] Names { get; set; } = names;
+
+    public override readonly bool Equals(object obj)
+    {
+        if (obj == null || obj is not Actions)
+            return false;
+
+        return Equals((Actions)obj);
+    }
+
+    public override readonly int GetHashCode()
+    {
+        return Inverted.GetHashCode() ^ string.Join(string.Empty, Names).GetHashCode();
+    }
+
+    public static bool operator ==(Actions left, Actions right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(Actions left, Actions right)
+    {
+        return !(left == right);
+    }
+
+    public readonly bool Equals(Actions other)
+    {
+        return this.GetHashCode().Equals(other.GetHashCode());
+    }
+}

src/FrostFS.SDK.Client/ApeRules/Condition.cs

@@ -0,0 +1,43 @@
+namespace FrostFS.SDK.Client;
+
+public struct Condition : System.IEquatable<Condition>
+{
+    public ConditionType Op { get; set; }
+
+    public ConditionKindType Kind { get; set; }
+
+    public string? Key { get; set; }
+
+    public string? Value { get; set; }
+
+    public override bool Equals(object obj)
+    {
+        if (obj == null || obj is not Condition)
+            return false;
+
+        return Equals((Condition)obj);
+    }
+
+    public override readonly int GetHashCode()
+    {
+        return Op.GetHashCode()
+            ^ Kind.GetHashCode()
+            ^ (Key != null ? Key.GetHashCode() : 0)
+            ^ (Value != null ? Value.GetHashCode() : 0);
+    }
+
+    public static bool operator ==(Condition left, Condition right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(Condition left, Condition right)
+    {
+        return !(left == right);
+    }
+
+    public readonly bool Equals(Condition other)
+    {
+        return this.GetHashCode().Equals(other.GetHashCode());
+    }
+}

src/FrostFS.SDK.Client/ApeRules/Enums/ConditionKindType.cs

@@ -0,0 +1,7 @@
+namespace FrostFS.SDK.Client;
+
+public enum ConditionKindType
+{
+    Resource,
+    Request
+}

src/FrostFS.SDK.Client/ApeRules/Enums/ConditionType.cs

@@ -0,0 +1,36 @@
+namespace FrostFS.SDK.Client;
+
+public enum ConditionType
+{
+    CondStringEquals,
+
+    CondStringNotEquals,
+    CondStringEqualsIgnoreCase,
+
+    CondStringNotEqualsIgnoreCase,
+    CondStringLike,
+
+    CondStringNotLike,
+    CondStringLessThan,
+
+    CondStringLessThanEquals,
+    CondStringGreaterThan,
+
+    CondStringGreaterThanEquals,
+
+    // Numeric condition operators.
+    CondNumericEquals,
+
+    CondNumericNotEquals,
+    CondNumericLessThan,
+
+    CondNumericLessThanEquals,
+    CondNumericGreaterThan,
+
+    CondNumericGreaterThanEquals,
+
+    CondSliceContains,
+
+    CondIPAddress,
+    CondNotIPAddress,
+}

src/FrostFS.SDK.Client/ApeRules/Enums/FrostFsTargetType.cs

@@ -2,7 +2,7 @@
 
 public enum FrostFsTargetType
 {
-    Undefined = 0,
+    Undefined,
     Namespace,
     Container,
     User,

src/FrostFS.SDK.Client/ApeRules/Enums/Status.cs

@@ -0,0 +1,9 @@
+namespace FrostFS.SDK.Client;
+
+public enum RuleStatus
+{
+    Allow,
+    NoRuleFound,
+    AccessDenied,
+    QuotaLimitReached
+}

src/FrostFS.SDK.Client/ApeRules/FrostFsChain.cs

@@ -0,0 +1,10 @@
+namespace FrostFS.SDK.Client;
+
+public class FrostFsChain
+{
+    public byte[] ID { get; set; } = [];
+
+    public FrostFsRule[] Rules { get; set; } = [];
+
+    public RuleMatchType MatchType { get; set; }
+}

src/FrostFS.SDK.Client/ApeRules/FrostFsRule.cs

@@ -0,0 +1,18 @@
+namespace FrostFS.SDK.Client;
+
+public class FrostFsRule
+{
+    public RuleStatus Status { get; set; }
+
+    // Actions the operation is applied to.
+    public Actions Actions { get; set; }
+
+    // List of the resources the operation is applied to.
+    public Resources Resources { get; set; }
+
+    // True iff individual conditions must be combined with the logical OR.
+    // By default AND is used, so _each_ condition must pass.
+    public bool Any { get; set; }
+
+    public Condition[]? Conditions { get; set; }
+}

src/FrostFS.SDK.Client/ApeRules/MatchType.cs

@@ -0,0 +1,10 @@
+namespace FrostFS.SDK.Client;
+
+public enum RuleMatchType
+{
+    // DenyPriority rejects the request if any `Deny` is specified. 
+    DenyPriority,
+
+    // FirstMatch returns the first rule action matched to the request.
+    FirstMatch
+}

src/FrostFS.SDK.Client/ApeRules/Resources.cs

@@ -0,0 +1,36 @@
+namespace FrostFS.SDK.Client;
+
+public struct Resources(bool inverted, string[] names) : System.IEquatable<Resources>
+{
+    public bool Inverted { get; set; } = inverted;
+
+    public string[] Names { get; set; } = names;
+
+    public override readonly bool Equals(object obj)
+    {
+        if (obj == null || obj is not Resources)
+            return false;
+
+        return Equals((Resources)obj);
+    }
+
+    public override readonly int GetHashCode()
+    {
+        return Inverted.GetHashCode() ^ string.Join(string.Empty, Names).GetHashCode();
+    }
+
+    public static bool operator ==(Resources left, Resources right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(Resources left, Resources right)
+    {
+        return !(left == right);
+    }
+
+    public readonly bool Equals(Resources other)
+    {
+        return this.GetHashCode().Equals(other.GetHashCode());
+    }
+}

src/FrostFS.SDK.Client/ApeRules/RuleSerializer.cs

@@ -0,0 +1,505 @@
+using System;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("FrostFS.SDK.Tests")]
+
+namespace FrostFS.SDK.Client;
+
+internal static class RuleSerializer
+{
+    const byte Version = 0; // increase if breaking change
+    const int ByteSize = 1;
+    const int UInt8Size = ByteSize;
+    const int BoolSize = ByteSize;
+    const long NullSlice = -1;
+    const int NullSliceSize = 1;
+    const byte ByteTrue = 1;
+    const byte ByteFalse = 0;
+
+    /// <summary>
+    /// maxSliceLen taken from https://github.com/neo-project/neo/blob/38218bbee5bbe8b33cd8f9453465a19381c9a547/src/Neo/IO/Helper.cs#L77 
+    /// </summary>
+    const int MaxSliceLen = 0x1000000;
+
+    const int ChainMarshalVersion = 0;
+
+    internal static byte[] Serialize(FrostFsChain chain)
+    {
+        int s = UInt8Size // Marshaller version
+         + UInt8Size // Chain version
+         + SliceSize(chain.ID, b => ByteSize)
+         + SliceSize(chain.Rules, RuleSize)
+         + UInt8Size; // MatchType
+
+        byte[] buf = new byte[s];
+
+        int offset = UInt8Marshal(buf, 0, Version);
+        offset = UInt8Marshal(buf, offset, ChainMarshalVersion);
+        offset = SliceMarshal(buf, offset, chain.ID, ByteMarshal);
+        offset = SliceMarshal(buf, offset, chain.Rules, MarshalRule);
+        offset = UInt8Marshal(buf, offset, (byte)chain.MatchType);
+
+        VerifyMarshal(buf, offset);
+
+        return buf;
+    }
+
+    internal static FrostFsChain Deserialize(byte[] data)
+    {
+        if (data is null)
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+
+        FrostFsChain chain = new();
+
+        var (offset, version) = UInt8Unmarshal(data, 0);
+
+        if (version != Version)
+        {
+            throw new FrostFsException($"unsupported marshaller version {version}");
+        }
+
+        (offset, byte chainVersion) = UInt8Unmarshal(data, offset);
+
+        if (chainVersion != ChainMarshalVersion)
+        {
+            throw new FrostFsException($"unsupported chain version {chainVersion}");
+        }
+
+        (offset, chain.ID) = SliceUnmarshal(data, offset, UInt8Unmarshal);
+
+        (offset, chain.Rules) = SliceUnmarshal(data, offset, UnmarshalRule);
+
+        (offset, var matchTypeV) = UInt8Unmarshal(data, offset);
+
+        chain.MatchType = (RuleMatchType)matchTypeV;
+
+        VerifyUnmarshal(data, offset);
+
+        return chain;
+    }
+
+    private static int Int64Size(long value)
+    {
+        // https://cs.opensource.google/go/go/+/master:src/encoding/binary/varint.go;l=92;drc=dac9b9ddbd5160c5f4552410f5f8281bd5eed38c
+        // and
+        // https://cs.opensource.google/go/go/+/master:src/encoding/binary/varint.go;l=41;drc=dac9b9ddbd5160c5f4552410f5f8281bd5eed38c
+        ulong ux = (ulong)value << 1;
+        if (value < 0)
+        {
+            ux = ~ux;
+        }
+
+        int size = 0;
+        while (ux >= 0x80)
+        {
+            size++;
+            ux >>= 7;
+        }
+
+        return size + 1;
+    }
+
+    private static int SliceSize<T>(T[] slice, Func<T, int> sizeOf)
+    {
+        if (slice == null)
+        {
+            return NullSliceSize;
+        }
+
+        // Assuming Int64Size is the size of the slice
+        var size = Int64Size(slice.Length);
+        foreach (var v in slice)
+        {
+            size += sizeOf(v);
+        }
+
+        return size;
+    }
+
+    private static int StringSize(string? s)
+    {
+        var len = s != null ? s.Length : 0;
+        return Int64Size(len) + len;
+    }
+
+    private static int ActionsSize(Actions action)
+    {
+        return BoolSize // Inverted
+            + SliceSize(action.Names, StringSize);
+    }
+
+    private static int ResourcesSize(Resources resource)
+    {
+        return BoolSize // Inverted
+            + SliceSize(resource.Names, StringSize);
+    }
+
+    private static int ConditionSize(Condition condition)
+    {
+        return ByteSize // Op
+            + ByteSize // Object
+            + StringSize(condition.Key)
+            + StringSize(condition.Value);
+    }
+
+    private static int RuleSize(FrostFsRule rule)
+    {
+        if (rule is null)
+        {
+            throw new ArgumentNullException(nameof(rule));
+        }
+
+        return ByteSize // Status
+            + ActionsSize(rule.Actions)
+            + ResourcesSize(rule.Resources)
+            + BoolSize // Any
+            + SliceSize(rule.Conditions!, ConditionSize);
+    }
+
+    private static int UInt8Marshal(byte[] buf, int offset, byte value)
+    {
+        if (buf.Length - offset < 1)
+        {
+            throw new FrostFsException("Not enough bytes left to serialize value of type byte");
+        }
+
+        buf[offset] = value;
+
+        return offset + 1;
+    }
+
+    private static int ByteMarshal(byte[] buf, int offset, byte value)
+    {
+        return UInt8Marshal(buf, offset, value);
+    }
+
+    // PutVarint encodes an int64 into buf and returns the number of bytes written.
+    // If the buffer is too small, PutVarint will panic.
+    private static int PutVarint(byte[] buf, int offset, long x)
+    {
+        var ux = (ulong)x << 1;
+
+        if (x < 0)
+        {
+            ux = ~ux;
+        }
+
+        return PutUvarint(buf, offset, ux);
+    }
+
+    private static int PutUvarint(byte[] buf, int offset, ulong x)
+    {
+        while (x >= 0x80)
+        {
+            buf[offset] = (byte)(x | 0x80);
+            x >>= 7;
+            offset++;
+        }
+
+        buf[offset] = (byte)x;
+
+        return offset + 1;
+    }
+
+    private static int Int64Marshal(byte[] buf, int offset, long v)
+    {
+        if (buf.Length - offset < Int64Size(v))
+        {
+            throw new FrostFsException("Not enough bytes left to serialize value of type long");
+        }
+
+        return PutVarint(buf, offset, v);
+    }
+
+    private static int SliceMarshal<T>(byte[] buf, int offset, T[] slice, Func<byte[], int, T, int> marshalT)
+    {
+        if (slice == null)
+        {
+            return Int64Marshal(buf, offset, NullSlice);
+        }
+
+        if (slice.Length > MaxSliceLen)
+        {
+            throw new FrostFsException($"slice size if too big: {slice.Length}");
+        }
+
+        offset = Int64Marshal(buf, offset, slice.Length);
+
+        foreach (var v in slice)
+        {
+            offset = marshalT(buf, offset, v);
+        }
+
+        return offset;
+    }
+
+    private static int BoolMarshal(byte[] buf, int offset, bool value)
+    {
+        return UInt8Marshal(buf, offset, value ? ByteTrue : ByteFalse);
+    }
+
+    private static int StringMarshal(byte[] buf, int offset, string value)
+    {
+        if (value == null)
+        {
+            throw new FrostFsException($"string value is null");
+        }
+
+        if (value.Length > MaxSliceLen)
+        {
+            throw new FrostFsException($"string is too long: {value.Length}");
+        }
+
+        if (buf.Length - offset < Int64Size(value.Length) + value.Length)
+        {
+            throw new FrostFsException($"Not enough bytes left to serialize value of type string with length {value.Length}");
+        }
+
+        offset = Int64Marshal(buf, offset, value.Length);
+
+        if (string.IsNullOrEmpty(value))
+        {
+            return offset;
+        }
+
+        Buffer.BlockCopy(System.Text.Encoding.UTF8.GetBytes(value), 0, buf, offset, value.Length);
+
+        return offset + value.Length;
+    }
+
+    private static int MarshalActions(byte[] buf, int offset, Actions action)
+    {
+        offset = BoolMarshal(buf, offset, action.Inverted);
+
+        return SliceMarshal(buf, offset, action.Names, StringMarshal);
+    }
+
+    private static int MarshalCondition(byte[] buf, int offset, Condition condition)
+    {
+        offset = ByteMarshal(buf, offset, (byte)condition.Op);
+
+        offset = ByteMarshal(buf, offset, (byte)condition.Kind);
+
+        offset = StringMarshal(buf, offset, condition.Key!);
+
+        return StringMarshal(buf, offset, condition.Value!);
+    }
+
+    private static int MarshalRule(byte[] buf, int offset, FrostFsRule rule)
+    {
+        if (rule is null)
+        {
+            throw new ArgumentNullException(nameof(rule));
+        }
+
+        offset = ByteMarshal(buf, offset, (byte)rule.Status);
+
+        offset = MarshalActions(buf, offset, rule.Actions);
+
+        offset = MarshalResources(buf, offset, rule.Resources);
+
+        offset = BoolMarshal(buf, offset, rule.Any);
+
+        return SliceMarshal(buf, offset, rule.Conditions!, MarshalCondition);
+    }
+
+    private static int MarshalResources(byte[] buf, int offset, Resources resources)
+    {
+        offset = BoolMarshal(buf, offset, resources.Inverted);
+
+        return SliceMarshal(buf, offset, resources.Names, StringMarshal);
+    }
+
+    private static void VerifyMarshal(byte[] buf, int lastOffset)
+    {
+        if (buf.Length != lastOffset)
+        {
+            throw new FrostFsException("actual data size differs from expected");
+        }
+    }
+
+    private static (int, bool) BoolUnmarshal(byte[] buf, int offset)
+    {
+        (offset, byte val) = UInt8Unmarshal(buf, offset);
+        return (offset, val == ByteTrue);
+    }
+
+    private static (int, string) StringUnmarshal(byte[] buf, int offset)
+    {
+        (offset, long size) = Int64Unmarshal(buf, offset);
+
+        if (size == 0)
+        {
+            return (offset, string.Empty);
+        }
+
+        if (size > MaxSliceLen)
+        {
+            throw new FrostFsException($"string is too long: '{size}'");
+        }
+        if (size < 0)
+        {
+            throw new FrostFsException($"invalid string size: '{size}'");
+        }
+
+        if (buf.Length - offset < size)
+        {
+            throw new FrostFsException($"not enough bytes left to string value");
+        }
+
+        return (offset + (int)size, System.Text.Encoding.UTF8.GetString(buf, offset, (int)size));
+    }
+
+    private static (int, Actions) UnmarshalActions(byte[] buf, int offset)
+    {
+        Actions action = new();
+        (offset, action.Inverted) = BoolUnmarshal(buf, offset);
+
+        (offset, action.Names) = SliceUnmarshal(buf, offset, StringUnmarshal);
+
+        return (offset, action);
+    }
+
+    private static (int, Resources) UnmarshalResources(byte[] buf, int offset)
+    {
+        Resources res = new();
+
+        (offset, res.Inverted) = BoolUnmarshal(buf, offset);
+        (offset, res.Names) = SliceUnmarshal(buf, offset, StringUnmarshal);
+
+        return (offset, res);
+    }
+
+    private static (int, Condition) UnmarshalCondition(byte[] buf, int offset)
+    {
+        Condition cond = new();
+        (offset, var op) = UInt8Unmarshal(buf, offset);
+
+        cond.Op = (ConditionType)op;
+
+        (offset, var kind) = UInt8Unmarshal(buf, offset);
+
+        cond.Kind = (ConditionKindType)kind;
+
+        (offset, cond.Key) = StringUnmarshal(buf, offset);
+
+        (offset, cond.Value) = StringUnmarshal(buf, offset);
+
+        return (offset, cond);
+    }
+
+    private static (int, FrostFsRule) UnmarshalRule(byte[] buf, int offset)
+    {
+        FrostFsRule rule = new();
+
+        (offset, byte statusV) = UInt8Unmarshal(buf, offset);
+        rule.Status = (RuleStatus)statusV;
+
+        (offset, rule.Actions) = UnmarshalActions(buf, offset);
+
+        (offset, rule.Resources) = UnmarshalResources(buf, offset);
+
+        (offset, rule.Any) = BoolUnmarshal(buf, offset);
+
+        (offset, rule.Conditions) = SliceUnmarshal(buf, offset, UnmarshalCondition);
+
+        return (offset, rule);
+    }
+
+    private static (int, byte) UInt8Unmarshal(byte[] buf, int offset)
+    {
+        if (buf.Length - offset < 1)
+        {
+            throw new FrostFsException($"not enough bytes left to read a value of type 'byte' from offset {offset}");
+        }
+
+        return (offset + 1, buf[offset]);
+    }
+
+    private static (int, long) Int64Unmarshal(byte[] buf, int offset)
+    {
+        if (buf.Length - offset < sizeof(long))
+        {
+            throw new FrostFsException($"not enough bytes left to read a value of type 'long' from offset {offset}");
+        }
+
+        return Varint(buf, offset);
+    }
+
+    private static (int, T[]) SliceUnmarshal<T>(byte[] buf, int offset, Func<byte[], int, (int, T)> unmarshalT)
+    {
+        var (newOffset, size) = Varint(buf, offset);
+
+        if (size == NullSlice)
+        {
+            return (newOffset, []);
+        }
+
+        if (size > MaxSliceLen)
+        {
+            throw new FrostFsException($"slice size is too big: '{size}'");
+        }
+
+        if (size < 0)
+        {
+            throw new FrostFsException($"invalid slice size: '{size}'");
+        }
+
+        var result = new T[size];
+        for (int i = 0; i < result.Length; i++)
+        {
+            (newOffset, result[i]) = unmarshalT(buf, newOffset);
+        }
+
+        return (newOffset, result);
+    }
+
+    private static void VerifyUnmarshal(byte[] buf, int offset)
+    {
+        if (buf.Length != offset)
+        {
+            throw new FrostFsException("unmarshalled bytes left");
+        }
+    }
+
+    private static int MaxVarIntLen64 = 10;
+
+    public static (int, long) Varint(byte[] buf, int offset)
+    {
+        var (ux, n) = Uvarint(buf, offset); // ok to continue in presence of error
+        long x = (long)ux >> 1;
+        if ((ux & 1) != 0)
+        {
+            x = ~x;
+        }
+        return (n, x);
+    }
+
+    public static (ulong, int) Uvarint(byte[] buf, int offset)
+    {
+        ulong x = 0;
+        int s = 0;
+
+        for (int i = offset; i < buf.Length; i++)
+        {
+            byte b = buf[i];
+            if (i == MaxVarIntLen64)
+            {
+                return (0, -(i + 1)); // overflow
+            }
+            if (b < 0x80)
+            {
+                if (i == MaxVarIntLen64 - 1 && b > 1)
+                {
+                    return (0, -(i + 1)); // overflow
+                }
+                return (x | ((ulong)b << s), i + 1);
+            }
+            x |= (ulong)(b & 0x7f) << s;
+            s += 7;
+        }
+        return (0, 0);
+    }
+}

src/FrostFS.SDK.Client/AssemblyInfo.cs

@@ -0,0 +1,8 @@
+using System.Reflection;
+
+[assembly: AssemblyCompany("FrostFS.SDK.Client")]
+[assembly: AssemblyFileVersion("1.0.4.0")]
+[assembly: AssemblyInformationalVersion("1.0.0+d6fe0344538a223303c9295452f0ad73681ca376")]
+[assembly: AssemblyProduct("FrostFS.SDK.Client")]
+[assembly: AssemblyTitle("FrostFS.SDK.Client")]
+[assembly: AssemblyVersion("1.0.4")]

src/FrostFS.SDK.Client/Caches.cs

@@ -6,17 +6,8 @@ internal static class Caches
 {
     private static readonly IMemoryCache _ownersCache = new MemoryCache(new MemoryCacheOptions
     {
-        // TODO: get from options?
         SizeLimit = 256
     });
 
-    private static readonly IMemoryCache _containersCache = new MemoryCache(new MemoryCacheOptions
-    {
-        // TODO: get from options?
-        SizeLimit = 1024
-    });
-
     internal static IMemoryCache Owners => _ownersCache;
-
-    internal static IMemoryCache Containers => _containersCache;
 }

src/FrostFS.SDK.Client/CllientKey.cs

@@ -12,7 +12,7 @@ public class ClientKey(ECDsa key)
 
     internal ByteString PublicKeyProto { get; } = ByteString.CopyFrom(key.PublicKey());
 
-    internal string PublicKey { get; } = key.PublicKey().ToString();
+    internal string PublicKey { get; } = Base58.Encode(key.PublicKey());
 
     internal FrostFsOwner Owner { get; } = new FrostFsOwner(key.PublicKey().PublicKeyToAddress());
 }

src/FrostFS.SDK.Client/Exceptions/FrostFsResponseException.cs

@@ -11,6 +11,7 @@ public class FrostFsResponseException : FrostFsException
     }
 
     public FrostFsResponseException(FrostFsResponseStatus status)
+        : base(status != null ? status.Message != null ? "" : "" : "")
     {
         Status = status;
     }

src/FrostFS.SDK.Client/Extensions/FrostFsExtensions.cs

@@ -1,14 +1,17 @@
 using System;
-
+using System.Security.Cryptography;
 using Google.Protobuf;
 
 namespace FrostFS.SDK.Cryptography;
 
 public static class FrostFsExtensions
 {
-    public static ByteString Sha256(this IMessage data)
+    public static byte[] Sha256(this IMessage data)
     {
-        return ByteString.CopyFrom(data.ToByteArray().Sha256());
+        using var sha256 = SHA256.Create();
+        using HashStream stream = new(sha256);
+        data.WriteTo(stream);
+        return stream.Hash();
     }
 
     public static Guid ToUuid(this ByteString id)
@@ -16,9 +19,18 @@ public static class FrostFsExtensions
         if (id == null)
             throw new ArgumentNullException(nameof(id));
 
-        var orderedBytes = GetGuidBytesDirectOrder(id.Span);
-
-        return new Guid(orderedBytes);
+        return new Guid(
+           (id[0] << 24) + (id[1] << 16) + (id[2] << 8) + id[3],
+           (short)((id[4] << 8) + id[5]),
+           (short)((id[6] << 8) + id[7]),
+           id[8],
+           id[9],
+           id[10],
+           id[11],
+           id[12],
+           id[13],
+           id[14],
+           id[15]);
     }
 
     /// <summary>
@@ -26,37 +38,25 @@ public static class FrostFsExtensions
     /// </summary>
     /// <param name="id"></param>
     /// <returns></returns>
-    public static byte[] ToBytes(this Guid id)
+    public unsafe static void ToBytes(this Guid id, Span<byte> span)
     {
-        var bytes = id.ToByteArray();
+        var pGuid = (byte*)&id;
 
-        var orderedBytes = GetGuidBytesDirectOrder(bytes);
-
-        return orderedBytes;
-    }
-
-    private static byte[] GetGuidBytesDirectOrder(ReadOnlySpan<byte> source)
-    {
-        if (source.Length != 16)
-            throw new ArgumentException("Wrong uuid binary format");
-
-        return [
-            source[3],
-            source[2],
-            source[1],
-            source[0],
-            source[5],
-            source[4],
-            source[7],
-            source[6],
-            source[8],
-            source[9],
-            source[10],
-            source[11],
-            source[12],
-            source[13],
-            source[14],
-            source[15]
-        ];
+        span[0] = pGuid[3];
+        span[1] = pGuid[2];
+        span[2] = pGuid[1];
+        span[3] = pGuid[0];
+        span[4] = pGuid[5];
+        span[5] = pGuid[4];
+        span[6] = pGuid[7];
+        span[7] = pGuid[6];
+        span[8] = pGuid[8];
+        span[9] = pGuid[9];
+        span[10] = pGuid[10];
+        span[11] = pGuid[11];
+        span[12] = pGuid[12];
+        span[13] = pGuid[13];
+        span[14] = pGuid[14];
+        span[15] = pGuid[15];
     }
 }

src/FrostFS.SDK.Client/FrostFS.SDK.Client.csproj

@@ -4,23 +4,34 @@
     <TargetFramework>netstandard2.0</TargetFramework>
     <LangVersion>12.0</LangVersion>
     <Nullable>enable</Nullable>
-	<AnalysisMode>AllEnabledByDefault</AnalysisMode>
+	  <AnalysisMode>AllEnabledByDefault</AnalysisMode>
+    <PackageId>FrostFS.SDK.Client</PackageId>
+    <Version>1.0.4</Version>
+    <Description>
+      C# SDK for FrostFS gRPC native protocol
+    </Description>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
   </PropertyGroup>
 
   <PropertyGroup>
-	<EnableNETAnalyzers>true</EnableNETAnalyzers>
+	  <EnableNETAnalyzers>true</EnableNETAnalyzers>
   </PropertyGroup>
 
   <PropertyGroup>
-	<CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
+	  <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
   </PropertyGroup>
-  
+
   <PropertyGroup>
-	<_SkipUpgradeNetAnalyzersNuGetWarning>true</_SkipUpgradeNetAnalyzersNuGetWarning>
+	  <_SkipUpgradeNetAnalyzersNuGetWarning>true</_SkipUpgradeNetAnalyzersNuGetWarning>
   </PropertyGroup>
-  
+
   <PropertyGroup>
-	<EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+	  <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>

src/FrostFS.SDK.Client/FrostFSClient.cs

@@ -2,8 +2,6 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
-using Frostfs.V2.Ape;
-
 using FrostFS.SDK.Client.Interfaces;
 using FrostFS.SDK.Client.Services;
 using FrostFS.SDK.Cryptography;
@@ -164,25 +162,7 @@ public class FrostFSClient : IFrostFSClient
             Callback = settings.Value.Callback,
             Interceptors = settings.Value.Interceptors
         };
-
-        // TODO: define timeout logic
-        // CheckFrostFsVersionSupport(new Context { Timeout = TimeSpan.FromSeconds(20) });
-    }
-
-    internal FrostFSClient(WrapperPrm prm, SessionCache cache)
-    {
-        ClientCtx = new ClientContext(
-           client: this,
-           key: new ClientKey(prm.Key),
-           owner: FrostFsOwner.FromKey(prm.Key!),
-           channel: prm.GrpcChannelFactory(prm.Address),
-           version: new FrostFsVersion(2, 13))
-        {
-            SessionCache = cache,
-            Interceptors = prm.Interceptors,
-            Callback = prm.Callback
-        };
-    }
+    }   
 
     #region ApeManagerImplementation
     public Task<ReadOnlyMemory<byte>> AddChainAsync(PrmApeChainAdd args, CallContext ctx)
@@ -195,7 +175,7 @@ public class FrostFSClient : IFrostFSClient
         return GetApeManagerService().RemoveChainAsync(args, ctx);
     }
 
-    public Task<Chain[]> ListChainAsync(PrmApeChainList args, CallContext ctx)
+    public Task<FrostFsChain[]> ListChainAsync(PrmApeChainList args, CallContext ctx)
     {
         return GetApeManagerService().ListChainAsync(args, ctx);
     }
@@ -212,9 +192,15 @@ public class FrostFSClient : IFrostFSClient
         return GetContainerService().ListContainersAsync(args, ctx);
     }
 
+    [Obsolete("Use PutContainerAsync method")]
     public Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx)
     {
-        return GetContainerService().CreateContainerAsync(args, ctx);
+        return GetContainerService().PutContainerAsync(args, ctx);
+    }
+
+    public Task<FrostFsContainerId> PutContainerAsync(PrmContainerCreate args, CallContext ctx)
+    {
+        return GetContainerService().PutContainerAsync(args, ctx);
     }
 
     public Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx)
@@ -314,18 +300,6 @@ public class FrostFSClient : IFrostFSClient
     }
     #endregion
 
-    private async void CheckFrostFsVersionSupport(CallContext ctx)
-    {
-        var service = GetNetmapService();
-        var localNodeInfo = await service.GetLocalNodeInfoAsync(ctx).ConfigureAwait(false);
-
-        if (!localNodeInfo.Version.IsSupported(ClientCtx.Version))
-        {
-            var msg = $"FrostFS {localNodeInfo.Version} is not supported.";
-            throw new FrostFsException(msg);
-        }
-    }
-
     private CallInvoker? CreateInvoker()
     {
         CallInvoker? callInvoker = null;
@@ -361,7 +335,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            NetmapServiceClient = NetmapServiceClient ?? (
+            NetmapServiceClient ??= (
                 invoker != null
                 ? new NetmapServiceClient(invoker)
                 : new NetmapServiceClient(ClientCtx.Channel));
@@ -378,7 +352,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            SessionServiceClient = SessionServiceClient ?? (
+            SessionServiceClient ??= (
                 invoker != null
                 ? new SessionServiceClient(invoker)
                 : new SessionServiceClient(ClientCtx.Channel));
@@ -387,7 +361,6 @@ public class FrostFSClient : IFrostFSClient
         }
 
         return SessionServiceProvider;
-
     }
 
     private ApeManagerServiceProvider GetApeManagerService()
@@ -396,7 +369,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            ApeManagerServiceClient = ApeManagerServiceClient ?? (
+            ApeManagerServiceClient ??= (
                 invoker != null
                 ? new APEManagerServiceClient(invoker)
                 : new APEManagerServiceClient(ClientCtx.Channel));
@@ -413,7 +386,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            AccountingServiceClient = AccountingServiceClient ?? (
+            AccountingServiceClient ??= (
                 invoker != null
                 ? new AccountingServiceClient(invoker)
                 : new AccountingServiceClient(ClientCtx.Channel));
@@ -430,7 +403,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            ContainerServiceClient = ContainerServiceClient ?? (
+            ContainerServiceClient ??= (
                 invoker != null
                 ? new ContainerServiceClient(invoker)
                 : new ContainerServiceClient(ClientCtx.Channel));
@@ -447,7 +420,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            ObjectServiceClient = ObjectServiceClient ?? (
+            ObjectServiceClient ??= (
                 invoker != null
                 ? new ObjectServiceClient(invoker)
                 : new ObjectServiceClient(ClientCtx.Channel));
@@ -456,18 +429,5 @@ public class FrostFSClient : IFrostFSClient
         }
 
         return ObjectServiceProvider;
-    }
-
-    public async Task<string?> Dial(CallContext ctx)
-    {
-        var service = GetAccouningService();
-        _ = await service.GetBallance(ctx).ConfigureAwait(false);
-
-        return null;
-    }
-
-    public bool RestartIfUnhealthy(CallContext ctx)
-    {
-        throw new NotImplementedException();
-    }
+    }   
 }

src/FrostFS.SDK.Client/Interfaces/IFrostFSClient.cs

@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
-using Frostfs.V2.Ape;
-
 namespace FrostFS.SDK.Client.Interfaces;
 
 public interface IFrostFSClient
@@ -25,7 +23,7 @@ public interface IFrostFSClient
 
     Task RemoveChainAsync(PrmApeChainRemove args, CallContext ctx);
 
-    Task<Chain[]> ListChainAsync(PrmApeChainList args, CallContext ctx);
+    Task<FrostFsChain[]> ListChainAsync(PrmApeChainList args, CallContext ctx);
     #endregion
 
     #region Container
@@ -33,8 +31,11 @@ public interface IFrostFSClient
 
     IAsyncEnumerable<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll args, CallContext ctx);
 
+    [Obsolete("Use PutContainerAsync method")]
     Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx);
 
+    Task<FrostFsContainerId> PutContainerAsync(PrmContainerCreate args, CallContext ctx);
+
     Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx);
     #endregion
 
@@ -63,6 +64,4 @@ public interface IFrostFSClient
     #region Account
     Task<Accounting.Decimal> GetBalanceAsync(CallContext ctx);
     #endregion
-
-    public Task<string?> Dial(CallContext ctx);
 }

src/FrostFS.SDK.Client/Mappers/ContainerId.cs

@@ -5,16 +5,10 @@ using FrostFS.SDK.Cryptography;
 
 using Google.Protobuf;
 
-using Microsoft.Extensions.Caching.Memory;
-
 namespace FrostFS.SDK.Client.Mappers.GRPC;
 
 public static class ContainerIdMapper
 {
-    private static readonly MemoryCacheEntryOptions _oneHourExpiration = new MemoryCacheEntryOptions()
-       .SetSlidingExpiration(TimeSpan.FromHours(1))
-       .SetSize(1);
-
     public static ContainerID ToMessage(this FrostFsContainerId model)
     {
         if (model is null)
@@ -24,15 +18,11 @@ public static class ContainerIdMapper
 
         var containerId = model.GetValue() ?? throw new ArgumentNullException(nameof(model));
 
-        if (!Caches.Containers.TryGetValue(containerId, out ContainerID? message))
+        var message = new ContainerID
         {
-            message = new ContainerID
-            {
-                Value = ByteString.CopyFrom(Base58.Decode(containerId))
-            };
+            Value = UnsafeByteOperations.UnsafeWrap(Base58.Decode(containerId))
+        };
 
-            Caches.Containers.Set(containerId, message, _oneHourExpiration);
-        }
         return message!;
     }
 

src/FrostFS.SDK.Client/Mappers/Netmap/PlacementPolicy.cs

@@ -16,7 +16,10 @@ public static class PlacementPolicyMapper
 
         return new FrostFsPlacementPolicy(
             placementPolicy.Unique,
-            placementPolicy.Replicas.Select(replica => replica.ToModel()).ToArray()
+            placementPolicy.ContainerBackupFactor,
+            [.. placementPolicy.Selectors.Select(s => s.ToModel())],
+            [.. placementPolicy.Filters.Select(f => f.ToModel())],
+            [.. placementPolicy.Replicas.Select(r => r.ToModel())]
         );
     }
 }

src/FrostFS.SDK.Client/Mappers/Netmap/Replica.cs

@@ -1,10 +1,11 @@
 using System;
+using System.Linq;
 
 using FrostFS.Netmap;
 
 namespace FrostFS.SDK.Client;
 
-public static class ReplicaMapper
+public static class PolicyMapper
 {
     public static Replica ToMessage(this FrostFsReplica replica)
     {
@@ -24,4 +25,76 @@ public static class ReplicaMapper
 
         return new FrostFsReplica((int)replica.Count, replica.Selector);
     }
+
+    public static Selector ToMessage(this FrostFsSelector selector)
+    {
+        if (selector is null)
+        {
+            throw new ArgumentNullException(nameof(selector));
+        }
+
+        return new Selector
+        {
+            Name = selector.Name,
+            Count = selector.Count,
+            Clause = (Clause)selector.Clause,
+            Attribute = selector.Attribute,
+            Filter = selector.Filter
+        };
+    }
+
+    public static FrostFsSelector ToModel(this Selector selector)
+    {
+        if (selector is null)
+        {
+            throw new ArgumentNullException(nameof(selector));
+        }
+
+        var model = new FrostFsSelector(selector.Name)
+        {
+            Count = selector.Count,
+            Clause = (int)selector.Clause,
+            Attribute = selector.Attribute,
+            Filter = selector.Filter
+        };
+
+        return model;
+    }
+
+    public static Filter ToMessage(this FrostFsFilter filter)
+    {
+        if (filter is null)
+        {
+            throw new ArgumentNullException(nameof(filter));
+        }
+
+        var message = new Filter
+        {
+            Name = filter.Name,
+            Key = filter.Key,
+            Op = (Operation)filter.Operation,
+            Value = filter.Value,
+        };
+
+        message.Filters.AddRange(filter.Filters.Select(f => f.ToMessage()));
+
+        return message;
+    }
+
+    public static FrostFsFilter ToModel(this Filter filter)
+    {
+        if (filter is null)
+        {
+            throw new ArgumentNullException(nameof(filter));
+        }
+
+        var model = new FrostFsFilter(
+           filter.Name,
+           filter.Key,
+           (int)filter.Op,
+           filter.Value,
+           [.. filter.Filters.Select(f => f.ToModel())]);
+
+        return model;
+    }
 }

src/FrostFS.SDK.Client/Mappers/Object/ObjectAttributeMapper.cs

@@ -8,11 +8,6 @@ public static class ObjectAttributeMapper
 {
     public static Header.Types.Attribute ToMessage(this FrostFsAttributePair attribute)
     {
-        if (attribute is null)
-        {
-            throw new ArgumentNullException(nameof(attribute));
-        }
-
         return new Header.Types.Attribute
         {
             Key = attribute.Key,

src/FrostFS.SDK.Client/Mappers/Object/ObjectHeaderMapper.cs

@@ -24,25 +24,14 @@ public static class ObjectHeaderMapper
             _ => throw new ArgumentException($"Unknown ObjectType. Value: '{header.ObjectType}'.")
         };
 
-        FrostFsSplit? split = null;
-
-        if (header.Split != null)
-        {
-            var children = header.Split.Children.Count != 0 ? new ReadOnlyCollection<FrostFsObjectId>(
-                    header.Split.Children.Select(x => x.ToModel()).ToList()) : null;
-
-            split = new FrostFsSplit(new SplitId(header.Split.SplitId.ToUuid()),
-                header.Split.Previous?.ToModel(),
-                header.Split.Parent?.ToModel(),
-                header.Split.ParentHeader?.ToModel(),
-                null,
-                children);
-        }
+        FrostFsSplit? split = header!.Split != null
+            ? header.Split.ToModel()
+            : null;
 
         var model = new FrostFsObjectHeader(
             new FrostFsContainerId(Base58.Encode(header.ContainerId.Value.Span)),
             objTypeName,
-            header.Attributes.Select(attribute => attribute.ToModel()).ToArray(),
+            [.. header.Attributes.Select(attribute => attribute.ToModel())],
             split,
             header.OwnerId.ToModel(),
             header.Version.ToModel())
@@ -52,4 +41,18 @@ public static class ObjectHeaderMapper
 
         return model;
     }
+
+    public static FrostFsSplit ToModel(this Header.Types.Split split)
+    {
+        var children = split!.Children.Count != 0
+            ? new ReadOnlyCollection<FrostFsObjectId>([.. split.Children.Select(x => x.ToModel())])
+            : null;
+
+        return new FrostFsSplit(new SplitId(split.SplitId.ToUuid()),
+                        split.Previous?.ToModel(),
+                        split.Parent?.ToModel(),
+                        split.ParentHeader?.ToModel(),
+                        null,
+                        children);
+    }
 }

src/FrostFS.SDK.Client/Mappers/Object/ObjectId.cs

@@ -17,7 +17,7 @@ public static class ObjectIdMapper
 
         return new ObjectID
         {
-            Value = ByteString.CopyFrom(objectId.ToHash())
+            Value = UnsafeByteOperations.UnsafeWrap(objectId.ToHash())
         };
     }
 

src/FrostFS.SDK.Client/Mappers/OwnerId.cs

@@ -26,7 +26,7 @@ public static class OwnerIdMapper
         {
             message = new OwnerID
             {
-                Value = ByteString.CopyFrom(model.ToHash())
+                Value = UnsafeByteOperations.UnsafeWrap(model.ToHash())
             };
 
             Caches.Owners.Set(model, message, _oneHourExpiration);

src/FrostFS.SDK.Client/Mappers/Session/SessionMapper.cs

@@ -1,28 +0,0 @@
-using System;
-
-using Google.Protobuf;
-
-namespace FrostFS.SDK.Client;
-
-public static class SessionMapper
-{
-    public static byte[] Serialize(this Session.SessionToken token)
-    {
-        if (token is null)
-        {
-            throw new ArgumentNullException(nameof(token));
-        }
-
-        byte[] bytes = new byte[token.CalculateSize()];
-        using CodedOutputStream stream = new(bytes);
-        token.WriteTo(stream);
-
-        return bytes;
-    }
-
-    public static Session.SessionToken Deserialize(this Session.SessionToken token, byte[] bytes)
-    {
-        token.MergeFrom(bytes);
-        return token;
-    }
-}

src/FrostFS.SDK.Client/Mappers/SignatureMapper.cs

@@ -23,9 +23,9 @@ public static class SignatureMapper
 
         return new Refs.Signature
         {
-            Key = ByteString.CopyFrom(signature.Key),
+            Key = UnsafeByteOperations.UnsafeWrap(signature.Key),
             Scheme = scheme,
-            Sign = ByteString.CopyFrom(signature.Sign)
+            Sign = UnsafeByteOperations.UnsafeWrap(signature.Sign)
         };
     }
 }

src/FrostFS.SDK.Client/Mappers/Status.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 
 namespace FrostFS.SDK.Client.Mappers.GRPC;
 
@@ -13,6 +14,9 @@ public static class StatusMapper
 
         return codeName is null
             ? throw new ArgumentException($"Unknown StatusCode. Value: '{status.Code}'.")
-            : new FrostFsResponseStatus((FrostFsStatusCode)status.Code, status.Message);
+            : new FrostFsResponseStatus(
+                (FrostFsStatusCode)status.Code,
+                status.Message,
+                string.Join(", ", status.Details.Select(d => System.Text.Encoding.UTF8.GetString([.. d.Value]))));
     }
 }

src/FrostFS.SDK.Client/Models/Chain/FrostFsChain.cs

@@ -1,41 +0,0 @@
-using Google.Protobuf;
-
-namespace FrostFS.SDK.Client;
-
-public struct FrostFsChain(byte[] raw) : System.IEquatable<FrostFsChain>
-{
-    private ByteString? grpcRaw;
-
-    public byte[] Raw { get; } = raw;
-
-    internal ByteString GetRaw()
-    {
-        return grpcRaw ??= ByteString.CopyFrom(Raw);
-    }
-
-    public override readonly bool Equals(object obj)
-    {
-        var chain = (FrostFsChain)obj;
-        return Equals(chain);
-    }
-
-    public override readonly int GetHashCode()
-    {
-        return Raw.GetHashCode();
-    }
-
-    public static bool operator ==(FrostFsChain left, FrostFsChain right)
-    {
-        return left.Equals(right);
-    }
-
-    public static bool operator !=(FrostFsChain left, FrostFsChain right)
-    {
-        return !(left == right);
-    }
-
-    public readonly bool Equals(FrostFsChain other)
-    {
-        return Raw == other.Raw;
-    }
-}

src/FrostFS.SDK.Client/Models/Containers/FrostFsContainerId.cs

@@ -34,21 +34,18 @@ public class FrostFsContainerId
         throw new FrostFsInvalidObjectException();
     }
 
-    internal ContainerID ContainerID
+    public ContainerID GetContainerID()
     {
-        get
+        if (this.containerID != null)
+            return this.containerID;
+
+        if (modelId != null)
         {
-            if (this.containerID != null)
-                return this.containerID;
-
-            if (modelId != null)
-            {
-                this.containerID = this.ToMessage();
-                return this.containerID;
-            }
-
-            throw new FrostFsInvalidObjectException();
+            this.containerID = this.ToMessage();
+            return this.containerID;
         }
+
+        throw new FrostFsInvalidObjectException();
     }
 
     public override string ToString()

src/FrostFS.SDK.Client/Models/Containers/FrostFsContainerInfo.cs

@@ -91,10 +91,13 @@ public class FrostFsContainerInfo
                 throw new ArgumentNullException("PlacementPolicy is null");
             }
 
+            Span<byte> nonce = stackalloc byte[16];
+            Nonce.ToBytes(nonce);
+
             this.container = new Container.Container()
             {
                 PlacementPolicy = PlacementPolicy.Value.GetPolicy(),
-                Nonce = ByteString.CopyFrom(Nonce.ToBytes()),
+                Nonce = ByteString.CopyFrom(nonce),
                 OwnerId = Owner?.OwnerID,
                 Version = Version?.VersionID
             };

src/FrostFS.SDK.Client/Models/Misc/CheckSum.cs

@@ -11,7 +11,7 @@ public class CheckSum
 
     public static CheckSum CreateCheckSum(byte[] content)
     {
-        return new CheckSum { hash = content.Sha256() };
+        return new CheckSum { hash = DataHasher.Sha256(content.AsSpan()) };
     }
 
     public override string ToString()

src/FrostFS.SDK.Client/Models/Netmap/FrostFsFilter.cs

@@ -0,0 +1,28 @@
+using System.Linq;
+using FrostFS.Netmap;
+
+namespace FrostFS.SDK;
+
+public class FrostFsFilter(string name, string key, int operation, string value, FrostFsFilter[] filters) : IFrostFsFilter
+{
+    public string Name { get; } = name;
+    public string Key { get; } = key;
+    public int Operation { get; } = operation;
+    public string Value { get; } = value;
+    public FrostFsFilter[] Filters { get; } = filters;
+
+    internal Filter GetMessage()
+    {
+        var filter = new Filter()
+        {
+            Name = Name,
+            Key = Key,
+            Op = (Operation)Operation,
+            Value = Value,
+        };
+
+        filter.Filters.AddRange(Filters.Select(f => f.GetMessage()));
+
+        return filter;
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/FrostFsNetmapSnapshot.cs

@@ -1,4 +1,10 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
+
+using FrostFS.SDK.Client;
+using FrostFS.SDK.Client.Models.Netmap.Placement;
+using FrostFS.SDK.Cryptography;
 
 namespace FrostFS.SDK;
 
@@ -7,4 +13,234 @@ public class FrostFsNetmapSnapshot(ulong epoch, IReadOnlyList<FrostFsNodeInfo> n
     public ulong Epoch { get; private set; } = epoch;
 
     public IReadOnlyList<FrostFsNodeInfo> NodeInfoCollection { get; private set; } = nodeInfoCollection;
-}
+
+    internal static INormalizer NewReverseMinNorm(double minV)
+    {
+        return new ReverseMinNorm { min = minV };
+    }
+
+    // newSigmoidNorm returns a normalizer which
+    // normalize values in range of 0.0 to 1.0 to a scaled sigmoid.
+    internal static INormalizer NewSigmoidNorm(double scale)
+    {
+        return new SigmoidNorm(scale);
+    }
+
+    // PlacementVectors sorts container nodes returned by ContainerNodes method
+    // and returns placement vectors for the entity identified by the given pivot.
+    // For example, in order to build node list to store the object, binary-encoded
+    // object identifier can be used as pivot. Result is deterministic for
+    // the fixed NetMap and parameters.
+    public FrostFsNodeInfo[][] PlacementVectors(FrostFsNodeInfo[][] vectors, byte[] pivot)
+    {
+        if (vectors is null)
+        {
+            throw new ArgumentNullException(nameof(vectors));
+        }
+
+        using var murmur3 = new Murmur3(0);
+        var hash = murmur3.GetCheckSum64(pivot);
+
+        var wf = Tools.DefaultWeightFunc(NodeInfoCollection.ToArray());
+
+        var result = new FrostFsNodeInfo[vectors.Length][];
+        var maxSize = vectors.Max(x => x.Length);
+
+        var spanWeigths = new double[maxSize];
+
+        for (int i = 0; i < vectors.Length; i++)
+        {
+            result[i] = new FrostFsNodeInfo[vectors[i].Length];
+
+            for (int j = 0; j < vectors[i].Length; j++)
+            {
+                result[i][j] = vectors[i][j];
+            }
+
+            Tools.AppendWeightsTo(result[i], wf, ref spanWeigths);
+
+            result[i] = Tools.SortHasherSliceByWeightValue(result[i].ToList<FrostFsNodeInfo>(), spanWeigths, hash).ToArray();
+        }
+
+        return result;
+    }
+
+    // SelectFilterNodes returns a two-dimensional list of nodes as a result of applying the
+    // given SelectFilterExpr to the NetMap.
+    // If the SelectFilterExpr contains only filters, the result contains a single row with the
+    // result of the last filter application.
+    // If the SelectFilterExpr contains only selectors, the result contains the selection rows
+    // of the last select application.
+    List<List<FrostFsNodeInfo>> SelectFilterNodes(SelectFilterExpr expr)
+    {
+        var policy = new FrostFsPlacementPolicy(false, expr.Cbf, [expr.Selector], expr.Filters);
+
+        var ctx = new Context(this)
+        {
+            Cbf = expr.Cbf
+        };
+
+        ctx.ProcessFilters(policy);
+        ctx.ProcessSelectors(policy);
+
+        var ret = new List<List<FrostFsNodeInfo>>();
+
+        if (expr.Selector == null)
+        {
+            var lastFilter = expr.Filters.Last();
+
+            var subCollestion = new List<FrostFsNodeInfo>();
+            ret.Add(subCollestion);
+
+            foreach (var nodeInfo in NodeInfoCollection)
+            {
+                if (ctx.Match(ctx.ProcessedFilters[lastFilter.Name], nodeInfo))
+                {
+                    subCollestion.Add(nodeInfo);
+                }
+            }
+        }
+        else if (expr.Selector.Name != null)
+        {
+            var sel = ctx.GetSelection(ctx.ProcessedSelectors[expr.Selector.Name]);
+
+            foreach (var ns in sel)
+            {
+                var subCollestion = new List<FrostFsNodeInfo>();
+                ret.Add(subCollestion);
+                foreach (var n in ns)
+                {
+                    subCollestion.Add(n);
+                }
+            }
+        }
+
+        return ret;
+    }
+
+    internal static Func<FrostFsNodeInfo, double> NewWeightFunc(INormalizer capNorm, INormalizer priceNorm)
+    {
+        return new Func<FrostFsNodeInfo, double>((FrostFsNodeInfo nodeInfo) =>
+        {
+            return capNorm.Normalize(nodeInfo.GetCapacity()) * priceNorm.Normalize(nodeInfo.Price);
+        });
+    }
+
+    private static FrostFsNodeInfo[] FlattenNodes(List<List<FrostFsNodeInfo>> nodes)
+    {
+        int sz = 0;
+        foreach (var ns in nodes)
+        {
+            sz += ns.Count;
+        }
+
+        var result = new FrostFsNodeInfo[sz];
+
+        int i = 0;
+        foreach (var ns in nodes)
+        {
+            foreach (var n in ns)
+            {
+                result[i++] = n;
+            }
+        }
+
+        return result;
+    }
+
+    // ContainerNodes returns two-dimensional list of nodes as a result of applying
+    // given PlacementPolicy to the NetMap. Each line of the list corresponds to a
+    // replica descriptor. Line order corresponds to order of ReplicaDescriptor list
+    // in the policy. Nodes are pre-filtered according to the Filter list from
+    // the policy, and then selected by Selector list. Result is deterministic for
+    // the fixed NetMap and parameters.
+    //
+    // Result can be used in PlacementVectors.
+    public FrostFsNodeInfo[][] ContainerNodes(FrostFsPlacementPolicy p, byte[]? pivot)
+    {
+        var c = new Context(this)
+        {
+            Cbf = p.BackupFactor == 0 ? 3 : p.BackupFactor
+        };
+
+        if (pivot != null && pivot.Length > 0)
+        {
+            c.HrwSeed = pivot;
+
+            using var murmur = new Murmur3(0);
+            c.HrwSeedHash = murmur.GetCheckSum64(pivot);
+        }
+
+        c.ProcessFilters(p);
+        c.ProcessSelectors(p);
+
+        var unique = p.IsUnique();
+
+        var result = new List<List<FrostFsNodeInfo>>(p.Replicas.Length);
+        for (int i = 0; i < p.Replicas.Length; i++)
+        {
+            result.Add([]);
+        }
+
+        // Note that the cached selectors are not used when the policy contains the UNIQUE flag.
+        // This is necessary because each selection vector affects potentially the subsequent vectors
+        // and thus we call getSelection in such case, in order to take into account nodes previously
+        // marked as used by earlier replicas.
+        for (int i = 0; i < p.Replicas.Length; i++)
+        {
+            var sName = p.Replicas[i].Selector;
+
+            if (string.IsNullOrEmpty(sName) && !(p.Replicas.Length == 1 && p.Selectors.Count == 1))
+            {
+                var s = new FrostFsSelector(string.Empty)
+                {
+                    Count = p.Replicas[i].CountNodes(),
+                    Filter = Context.mainFilterName
+                };
+
+                var nodes = c.GetSelection(s);
+                result[i].AddRange(FlattenNodes(nodes));
+
+                if (unique)
+                {
+                    foreach (var n in result[i])
+                    {
+                        c.UsedNodes[n.Hash()] = true;
+                    }
+                }
+
+                continue;
+            }
+
+            if (unique)
+            {
+                if (!c.ProcessedSelectors.TryGetValue(sName, out var s) || s == null)
+                {
+                    throw new FrostFsException($"selector not found: {sName}");
+                }
+
+                var nodes = c.GetSelection(c.ProcessedSelectors[sName]);
+
+                result[i].AddRange(FlattenNodes(nodes));
+
+                foreach (var n in result[i])
+                {
+                    c.UsedNodes[n.Hash()] = true;
+                }
+            }
+            else
+            {
+                var nodes = c.Selections[sName];
+                result[i].AddRange(FlattenNodes(nodes));
+            }
+        }
+
+        var collection = new FrostFsNodeInfo[result.Count][];
+        for (int i = 0; i < result.Count; i++)
+        {
+            collection[i] = [.. result[i]];
+        }
+
+        return collection;
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/FrostFsNodeInfo.cs

@@ -1,5 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+
+using FrostFS.SDK.Client.Models.Netmap.Placement;
+using FrostFS.SDK.Cryptography;
 
 namespace FrostFS.SDK;
 
@@ -8,11 +12,69 @@ public class FrostFsNodeInfo(
     NodeState state,
     IReadOnlyCollection<string> addresses,
     IReadOnlyDictionary<string, string> attributes,
-    ReadOnlyMemory<byte> publicKey)
+    ReadOnlyMemory<byte> publicKey) : IHasher
 {
-    public NodeState State { get; private set; } = state;
-    public FrostFsVersion Version { get; private set; } = version;
-    public IReadOnlyCollection<string> Addresses { get; private set; } = addresses;
-    public IReadOnlyDictionary<string, string> Attributes { get; private set; } = attributes;
-    public ReadOnlyMemory<byte> PublicKey { get; private set; } = publicKey;
-}
+    private ulong _hash;
+
+    // attrPrice is a key to the node attribute that indicates the
+    // price in GAS tokens for storing one GB of data during one Epoch.
+    internal const string AttrPrice = "Price";
+
+    // attrCapacity is a key to the node attribute that indicates the
+    // total available disk space in Gigabytes.
+    internal const string AttrCapacity = "Capacity";
+
+    // attrExternalAddr is a key for the attribute storing node external addresses.
+    internal const string AttrExternalAddr = "ExternalAddr";
+
+    // sepExternalAddr is a separator for multi-value ExternalAddr attribute.
+    internal const string SepExternalAddr = ",";
+
+    private ulong price = ulong.MaxValue;
+
+    public NodeState State { get; } = state;
+
+    public FrostFsVersion Version { get; } = version;
+
+    public IReadOnlyCollection<string> Addresses { get; } = addresses;
+
+    public IReadOnlyDictionary<string, string> Attributes { get; } = attributes;
+
+    public ReadOnlyMemory<byte> PublicKey { get; } = publicKey;
+
+    public ulong Hash()
+    {
+        if (_hash == 0)
+        {
+            using var murmur3 = new Murmur3(0);
+            murmur3.Initialize();
+            _hash = murmur3.GetCheckSum64(PublicKey.ToArray());
+        }
+
+        return _hash;
+    }
+
+    internal ulong GetCapacity()
+    {
+        if (!Attributes.TryGetValue(AttrCapacity, out var val))
+            return 0;
+
+        return ulong.Parse(val, CultureInfo.InvariantCulture);
+    }
+
+    internal ulong Price
+    {
+        get
+        {
+            if (price == ulong.MaxValue)
+            {
+                if (!Attributes.TryGetValue(AttrPrice, out var val))
+                    price = 0;
+                else
+                    price = uint.Parse(val, CultureInfo.InvariantCulture);
+            }
+
+            return price;
+        }
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/FrostFsPlacementPolicy.cs

@@ -1,5 +1,5 @@
-
 using System;
+using System.Collections.ObjectModel;
 using System.Linq;
 
 using FrostFS.Netmap;
@@ -7,18 +7,31 @@ using FrostFS.SDK.Client;
 
 namespace FrostFS.SDK;
 
-public struct FrostFsPlacementPolicy(bool unique, params FrostFsReplica[] replicas)
+public struct FrostFsPlacementPolicy(bool unique,
+    uint backupFactor,
+    Collection<FrostFsSelector> selectors,
+    Collection<FrostFsFilter> filters,
+    params FrostFsReplica[] replicas)
     : IEquatable<FrostFsPlacementPolicy>
 {
-    private PlacementPolicy policy;
+    private PlacementPolicy? policy;
 
-    public FrostFsReplica[] Replicas { get; private set; } = replicas;
-    public bool Unique { get; private set; } = unique;
+    public FrostFsReplica[] Replicas { get; } = replicas;
+
+    public Collection<FrostFsSelector> Selectors { get; } = selectors;
+
+    public Collection<FrostFsFilter> Filters { get; } = filters;
+
+    public bool Unique { get; } = unique;
+
+    public uint BackupFactor { get; } = backupFactor;
 
     public override readonly bool Equals(object obj)
     {
         if (obj is null)
+        {
             return false;
+        }
 
         var other = (FrostFsPlacementPolicy)obj;
 
@@ -34,9 +47,20 @@ public struct FrostFsPlacementPolicy(bool unique, params FrostFsReplica[] replic
                 Filters = { },
                 Selectors = { },
                 Replicas = { },
-                Unique = Unique
+                Unique = Unique,
+                ContainerBackupFactor = BackupFactor
             };
 
+            if (Selectors != null && Selectors.Count > 0)
+            {
+                policy.Selectors.AddRange(Selectors.Select(s => s.GetMessage()));
+            }
+
+            if (Filters != null && Filters.Count > 0)
+            {
+                policy.Filters.AddRange(Filters.Select(s => s.ToMessage()));
+            }
+
             foreach (var replica in Replicas)
             {
                 policy.Replicas.Add(replica.ToMessage());
@@ -46,14 +70,10 @@ public struct FrostFsPlacementPolicy(bool unique, params FrostFsReplica[] replic
         return policy;
     }
 
-    //public static FrostFsPlacementPolicy ToModel(placementPolicy)
-    //{
-    //    return new FrostFsPlacementPolicy(
-    //        placementPolicy.Unique,
-    //        placementPolicy.Replicas.Select(replica => replica.ToModel()).ToArray()
-    //    );
-    //}
-
+    internal readonly bool IsUnique()
+    {
+        return Unique || Replicas.Any(r => r.EcDataCount != 0 || r.EcParityCount != 0);
+    }
 
     public override readonly int GetHashCode()
     {
@@ -86,4 +106,4 @@ public struct FrostFsPlacementPolicy(bool unique, params FrostFsReplica[] replic
 
         return true;
     }
-}
+}

src/FrostFS.SDK.Client/Models/Netmap/FrostFsReplica.cs

@@ -6,6 +6,8 @@ public struct FrostFsReplica : IEquatable<FrostFsReplica>
 {
     public int Count { get; set; }
     public string Selector { get; set; }
+    public uint EcDataCount { get; set; }
+    public uint EcParityCount { get; set; }
 
     public FrostFsReplica(int count, string? selector = null)
     {
@@ -18,16 +20,23 @@ public struct FrostFsReplica : IEquatable<FrostFsReplica>
     public override readonly bool Equals(object obj)
     {
         if (obj is null)
+        {
             return false;
+        }
 
         var other = (FrostFsReplica)obj;
 
         return Count == other.Count && Selector == other.Selector;
     }
 
+    public readonly uint CountNodes()
+    {
+        return Count != 0 ? (uint)Count : EcDataCount + EcParityCount;
+    }
+
     public override readonly int GetHashCode()
     {
-        return Count + Selector.GetHashCode();
+        return (Count + Selector.GetHashCode()) ^ (int)EcDataCount ^ (int)EcParityCount;
     }
 
     public static bool operator ==(FrostFsReplica left, FrostFsReplica right)
@@ -42,6 +51,9 @@ public struct FrostFsReplica : IEquatable<FrostFsReplica>
 
     public readonly bool Equals(FrostFsReplica other)
     {
-        return Count == other.Count && Selector == other.Selector;
+        return Count == other.Count
+            && Selector == other.Selector
+            && EcDataCount == other.EcDataCount
+            && EcParityCount == other.EcParityCount;
     }
-}
+}

src/FrostFS.SDK.Client/Models/Netmap/FrostFsSelector.cs

@@ -0,0 +1,24 @@
+using FrostFS.Netmap;
+
+namespace FrostFS.SDK;
+
+public class FrostFsSelector(string name)
+{
+    public string Name { get; } = name;
+    public uint Count { get; set; }
+    public int Clause { get; set; }
+    public string? Attribute { get; set; }
+    public string? Filter { get; set; }
+
+    internal Selector GetMessage()
+    {
+        return new Selector()
+        {
+            Name = Name,
+            Clause = (Clause)Clause,
+            Count = Count,
+            Filter = Filter ?? string.Empty,
+            Attribute = Attribute ?? string.Empty,
+        };
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/IFrostFsFilter.cs

@@ -0,0 +1,11 @@
+namespace FrostFS.SDK
+{
+    public interface IFrostFsFilter
+    {
+        FrostFsFilter[] Filters { get; }
+        string Key { get; }
+        string Name { get; }
+        int Operation { get; }
+        string Value { get; }
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/NodeAttrPair.cs

@@ -0,0 +1,7 @@
+namespace FrostFS.SDK;
+
+struct NodeAttrPair
+{
+    internal string attr;
+    internal FrostFsNodeInfo[] nodes;
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/Clause.cs

@@ -0,0 +1,8 @@
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+public enum FrostFsClause
+{
+    Unspecified = 0,
+    Same,
+    Distinct
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/Context.cs

@@ -0,0 +1,456 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal struct Context
+{
+    private const string errInvalidFilterName = "filter name is invalid";
+    private const string errInvalidFilterOp = "invalid filter operation";
+    private const string errFilterNotFound = "filter not found";
+    private const string errNonEmptyFilters = "simple filter contains sub-filters";
+    private const string errNotEnoughNodes = "not enough nodes to SELECT from";
+    private const string errUnnamedTopFilter = "unnamed top-level filter";
+
+    internal const string mainFilterName = "*";
+    internal const string likeWildcard = "*";
+
+    // network map to operate on
+    internal FrostFsNetmapSnapshot NetMap { get; }
+
+    // cache of processed filters
+    internal Dictionary<string, FrostFsFilter> ProcessedFilters { get; } = [];
+
+    // cache of processed selectors
+    internal Dictionary<string, FrostFsSelector> ProcessedSelectors { get; } = [];
+
+    // stores results of selector processing
+    internal Dictionary<string, List<List<FrostFsNodeInfo>>> Selections { get; } = [];
+
+    // cache of parsed numeric values
+    internal Dictionary<string, ulong> NumCache { get; } = [];
+
+    internal byte[]? HrwSeed { get; set; }
+
+    // hrw.Hash of hrwSeed
+    internal ulong HrwSeedHash { get; set; }
+
+    // container backup factor
+    internal uint Cbf { get; set; }
+
+    // nodes already used in previous selections, which is needed when the placement
+    // policy uses the UNIQUE flag. Nodes marked as used are not used in subsequent
+    // base selections.
+    internal Dictionary<ulong, bool> UsedNodes { get; } = [];
+
+    // If true, returns an error when netmap does not contain enough nodes for selection.
+    // By default best effort is taken.
+    internal bool Strict { get; set; }
+
+    // weightFunc is a weighting function for determining node priority
+    // which combines low price and high performance
+    private readonly Func<FrostFsNodeInfo, double> weightFunc;
+
+    public Context(FrostFsNetmapSnapshot netMap)
+    {
+        NetMap = netMap;
+        weightFunc = Tools.DefaultWeightFunc(NetMap.NodeInfoCollection);
+    }
+
+    internal void ProcessFilters(FrostFsPlacementPolicy policy)
+    {
+        foreach (var filter in policy.Filters)
+        {
+            ProcessFilter(filter, true);
+        }
+    }
+
+    readonly void ProcessFilter(FrostFsFilter filter, bool top)
+    {
+        var filterName = filter.Name;
+        if (filterName == mainFilterName)
+        {
+            throw new FrostFsException($"{errInvalidFilterName}: '{errInvalidFilterName}' is reserved");
+        }
+
+        if (top && string.IsNullOrEmpty(filterName))
+        {
+            throw new FrostFsException(errUnnamedTopFilter);
+        }
+
+        if (!top && !string.IsNullOrEmpty(filterName) && !ProcessedFilters.ContainsKey(filterName))
+        {
+            throw new FrostFsException(errFilterNotFound);
+        }
+
+        if (filter.Operation == (int)Operation.AND ||
+            filter.Operation == (int)Operation.OR ||
+            filter.Operation == (int)Operation.NOT)
+        {
+            foreach (var f in filter.Filters)
+                ProcessFilter(f, false);
+        }
+        else
+        {
+            if (filter.Filters.Length != 0)
+            {
+                throw new FrostFsException(errNonEmptyFilters);
+            }
+            else if (!top && !string.IsNullOrEmpty(filterName))
+            {
+                // named reference
+                return;
+            }
+
+            switch (filter.Operation)
+            {
+                case (int)Operation.EQ:
+                case (int)Operation.NE:
+                case (int)Operation.LIKE:
+                    break;
+                case (int)Operation.GT:
+                case (int)Operation.GE:
+                case (int)Operation.LT:
+                case (int)Operation.LE:
+                    {
+                        var n = uint.Parse(filter.Value, CultureInfo.InvariantCulture);
+                        NumCache[filter.Value] = n;
+                        break;
+                    }
+                default:
+                    throw new FrostFsException($"{errInvalidFilterOp}: {filter.Operation}");
+            }
+        }
+
+        if (top)
+        {
+            ProcessedFilters[filterName] = filter;
+        }
+    }
+
+    // processSelectors processes selectors and returns error is any of them is invalid.
+    internal void ProcessSelectors(FrostFsPlacementPolicy policy)
+    {
+        foreach (var selector in policy.Selectors)
+        {
+            var filterName = selector.Filter;
+            if (filterName != mainFilterName)
+            {
+                if (selector.Filter == null || !ProcessedFilters.ContainsKey(selector.Filter))
+                {
+                    throw new FrostFsException($"{errFilterNotFound}: SELECT FROM '{filterName}'");
+                }
+            }
+
+            ProcessedSelectors[selector.Name] = selector;
+
+            var selection = GetSelection(selector);
+
+            Selections[selector.Name] = selection;
+        }
+    }
+
+    // calcNodesCount returns number of buckets and minimum number of nodes in every bucket
+    // for the given selector.
+    static (int bucketCount, int nodesInBucket) CalcNodesCount(FrostFsSelector selector)
+    {
+        return selector.Clause == (int)FrostFsClause.Same
+            ? (1, (int)selector.Count)
+            : ((int)selector.Count, 1);
+    }
+
+    // getSelectionBase returns nodes grouped by selector attribute.
+    // It it guaranteed that each pair will contain at least one node.
+    internal NodeAttrPair[] GetSelectionBase(FrostFsSelector selector)
+    {
+        var fName = selector.Filter ?? throw new FrostFsException("Filter name for selector is empty");
+
+        _ = ProcessedFilters.TryGetValue(fName, out var f);
+
+        var isMain = fName == mainFilterName;
+        var result = new List<NodeAttrPair>();
+
+        var nodeMap = new Dictionary<string, List<FrostFsNodeInfo>>();
+        var attr = selector.Attribute;
+
+        foreach (var node in NetMap.NodeInfoCollection)
+        {
+            if (UsedNodes.ContainsKey(node.Hash()))
+            {
+                continue;
+            }
+
+            if (isMain || Match(f, node))
+            {
+                if (attr == null)
+                {
+                    // Default attribute is transparent identifier which is different for every node.
+                    result.Add(new NodeAttrPair { attr = "", nodes = [node] });
+                }
+                else
+                {
+                    var v = node.Attributes[attr];
+                    if (!nodeMap.TryGetValue(v, out var nodes) || nodes == null)
+                    {
+                        nodeMap[v] = [];
+                    }
+
+                    nodeMap[v].Add(node);
+                }
+            }
+        }
+
+        if (!string.IsNullOrEmpty(attr))
+        {
+            foreach (var v in nodeMap)
+            {
+                result.Add(new NodeAttrPair() { attr = v.Key, nodes = [.. v.Value] });
+            }
+        }
+
+        if (HrwSeed != null && HrwSeed.Length != 0)
+        {
+            double[] ws = [];
+
+            var sortedNodes = new NodeAttrPair[result.Count];
+
+            for (int i = 0; i < result.Count; i++)
+            {
+                var res = result[i];
+                Tools.AppendWeightsTo(res.nodes, weightFunc, ref ws);
+                sortedNodes[i].nodes = Tools.SortHasherSliceByWeightValue(res.nodes.ToList(), ws, HrwSeedHash).ToArray();
+                sortedNodes[i].attr = result[i].attr;
+            }
+
+            return sortedNodes;
+        }
+        return [.. result];
+    }
+
+    static double CalcBucketWeight(List<FrostFsNodeInfo> ns, MeanIQRAgg a, Func<FrostFsNodeInfo, double> wf)
+    {
+        foreach (var node in ns)
+        {
+            a.Add(wf(node));
+        }
+
+        return a.Compute();
+    }
+
+    // getSelection returns nodes grouped by s.attribute.
+    // Last argument specifies if more buckets can be used to fulfill CBF.
+    internal List<List<FrostFsNodeInfo>> GetSelection(FrostFsSelector s)
+    {
+        var (bucketCount, nodesInBucket) = CalcNodesCount(s);
+
+        var buckets = GetSelectionBase(s);
+
+        if (Strict && buckets.Length < bucketCount)
+            throw new FrostFsException($"errNotEnoughNodes: '{s.Name}'");
+
+        // We need deterministic output in case there is no pivot.
+        // If pivot is set, buckets are sorted by HRW.
+        // However, because initial order influences HRW order for buckets with equal weights,
+        // we also need to have deterministic input to HRW sorting routine.
+        if (HrwSeed == null || HrwSeed.Length == 0)
+        {
+            buckets = string.IsNullOrEmpty(s.Attribute)
+                ? [.. buckets.OrderBy(b => b.nodes[0].Hash())]
+                : [.. buckets.OrderBy(b => b.attr)];
+        }
+
+        var maxNodesInBucket = nodesInBucket * (int)Cbf;
+
+        var res = new List<List<FrostFsNodeInfo>>(buckets.Length);
+        var fallback = new List<List<FrostFsNodeInfo>>(buckets.Length);
+
+        for (int i = 0; i < buckets.Length; i++)
+        {
+            var ns = buckets[i].nodes;
+            if (ns.Length >= maxNodesInBucket)
+            {
+                res.Add(ns.Take(maxNodesInBucket).ToList());
+            }
+            else if (ns.Length >= nodesInBucket)
+            {
+                fallback.Add(new List<FrostFsNodeInfo>(ns));
+            }
+        }
+
+        if (res.Count < bucketCount)
+        {
+            // Fallback to using minimum allowed backup factor (1).
+            res.AddRange(fallback);
+
+            if (Strict && res.Count < bucketCount)
+            {
+                throw new FrostFsException($"{errNotEnoughNodes}: {s}");
+            }
+        }
+
+        if (HrwSeed != null && HrwSeed.Length != 0)
+        {
+            var weights = new double[res.Count];
+            var a = new MeanIQRAgg();
+
+            for (int i = 0; i < res.Count; i++)
+            {
+                a.Clear();
+                weights[i] = CalcBucketWeight(res[i], a, weightFunc);
+            }
+
+            var hashers = res.Select(r => new HasherList(r)).ToList();
+            hashers = Tools.SortHasherSliceByWeightValue(hashers, weights, HrwSeedHash);
+
+            for (int i = 0; i < res.Count; i++)
+            {
+                res[i] = hashers[i].Nodes;
+            }
+        }
+
+        if (res.Count < bucketCount)
+        {
+            if (Strict && res.Count == 0)
+            {
+                throw new FrostFsException(errNotEnoughNodes);
+            }
+
+            bucketCount = res.Count;
+        }
+
+        if (string.IsNullOrEmpty(s.Attribute))
+        {
+            fallback = res.Skip(bucketCount).ToList();
+            res = res.Take(bucketCount).ToList();
+
+            for (int i = 0; i < fallback.Count; i++)
+            {
+                var index = i % bucketCount;
+                if (res[index].Count >= maxNodesInBucket)
+                {
+                    break;
+                }
+
+                res[index].AddRange(fallback[i]);
+            }
+        }
+
+        return res.Take(bucketCount).ToList();
+    }
+
+    internal bool MatchKeyValue(FrostFsFilter f, FrostFsNodeInfo nodeInfo)
+    {
+        switch (f.Operation)
+        {
+            case (int)Operation.EQ:
+                return nodeInfo.Attributes.TryGetValue(f.Key, out var val) && val == f.Value;
+            case (int)Operation.LIKE:
+                {
+                    var hasPrefix = f.Value.StartsWith(likeWildcard, StringComparison.Ordinal);
+                    var hasSuffix = f.Value.EndsWith(likeWildcard, StringComparison.Ordinal);
+
+                    var start = hasPrefix ? likeWildcard.Length : 0;
+                    var end = hasSuffix ? f.Value.Length - likeWildcard.Length : f.Value.Length;
+                    var str = f.Value.Substring(start, end - start);
+
+                    if (hasPrefix && hasSuffix)
+                        return nodeInfo.Attributes[f.Key].Contains(str);
+
+                    if (hasPrefix && !hasSuffix)
+                        return nodeInfo.Attributes[f.Key].EndsWith(str, StringComparison.Ordinal);
+
+                    if (!hasPrefix && hasSuffix)
+                        return nodeInfo.Attributes[f.Key].StartsWith(str, StringComparison.Ordinal);
+
+
+                    return nodeInfo.Attributes[f.Key] == f.Value;
+                }
+            case (int)Operation.NE:
+                return nodeInfo.Attributes[f.Key] != f.Value;
+            default:
+                {
+                    ulong attr;
+                    switch (f.Key)
+                    {
+                        case FrostFsNodeInfo.AttrPrice:
+                            attr = nodeInfo.Price;
+                            break;
+
+                        case FrostFsNodeInfo.AttrCapacity:
+                            attr = nodeInfo.GetCapacity();
+                            break;
+                        default:
+                            if (!ulong.TryParse(nodeInfo.Attributes[f.Key], NumberStyles.Integer, CultureInfo.InvariantCulture, out attr))
+                                return false;
+                            break;
+                    }
+
+                    switch (f.Operation)
+                    {
+                        case (int)Operation.GT:
+                            return attr > NumCache[f.Value];
+                        case (int)Operation.GE:
+                            return attr >= NumCache[f.Value];
+                        case (int)Operation.LT:
+                            return attr < NumCache[f.Value];
+                        case (int)Operation.LE:
+                            return attr <= NumCache[f.Value];
+                        default:
+                            // do nothing and return false
+                            break;
+                    }
+                }
+                break;
+        }
+
+        // will not happen if context was created from f (maybe panic?)
+        return false;
+    }
+
+    // match matches f against b. It returns no errors because
+    // filter should have been parsed during context creation
+    // and missing node properties are considered as a regular fail.
+    internal bool Match(FrostFsFilter f, FrostFsNodeInfo nodeInfo)
+    {
+        switch (f.Operation)
+        {
+            case (int)Operation.NOT:
+                {
+                    var inner = f.Filters;
+                    var fSub = inner[0];
+
+                    if (!string.IsNullOrEmpty(inner[0].Name))
+                    {
+                        fSub = ProcessedFilters[inner[0].Name];
+                    }
+                    return !Match(fSub, nodeInfo);
+                }
+            case (int)Operation.AND:
+            case (int)Operation.OR:
+                {
+                    for (int i = 0; i < f.Filters.Length; i++)
+                    {
+                        var fSub = f.Filters[i];
+
+                        if (!string.IsNullOrEmpty(f.Filters[i].Name))
+                        {
+                            fSub = ProcessedFilters[f.Filters[i].Name];
+                        }
+
+                        var ok = Match(fSub, nodeInfo);
+
+                        if (ok == (f.Operation == (int)Operation.OR))
+                        {
+                            return ok;
+                        }
+                    }
+
+                    return f.Operation == (int)Operation.AND;
+                }
+            default:
+                return MatchKeyValue(f, nodeInfo);
+        }
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/HasherList.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal sealed class HasherList : IHasher
+{
+    private readonly List<FrostFsNodeInfo> _nodes;
+
+    internal HasherList(List<FrostFsNodeInfo> nodes)
+    {
+        _nodes = nodes;
+    }
+
+    internal List<FrostFsNodeInfo> Nodes
+    {
+        get
+        {
+            return _nodes;
+        }
+    }
+
+    public ulong Hash()
+    {
+        return _nodes.Count > 0 ? _nodes[0].Hash() : 0;
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/IAggregator.cs

@@ -0,0 +1,8 @@
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal interface IAggregator
+{
+    void Add(double d);
+
+    double Compute();
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/IHasher.cs

@@ -0,0 +1,6 @@
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal interface IHasher
+{
+    ulong Hash();
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/INormalizer.cs

@@ -0,0 +1,6 @@
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+interface INormalizer
+{
+    double Normalize(double w);
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/MeanAgg.cs

@@ -0,0 +1,20 @@
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal struct MeanAgg
+{
+    private double mean;
+    private int count;
+
+    internal void Add(double n)
+    {
+        int c = count + 1;
+        mean = mean * count / c + n / c;
+
+        count++;
+    }
+
+    internal readonly double Compute()
+    {
+        return mean;
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/MeanIQRAgg.cs

@@ -0,0 +1,65 @@
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal struct MeanIQRAgg : IAggregator
+{
+    private const int minLn = 4;
+    internal Collection<double> arr = [];
+
+    public MeanIQRAgg()
+    {
+    }
+
+    public readonly void Add(double d)
+    {
+        arr.Add(d);
+    }
+
+    public readonly double Compute()
+    {
+        var length = arr.Count;
+        if (length == 0)
+        {
+            return 0;
+        }
+
+        var sorted = arr.OrderBy(p => p).ToArray();
+
+        double minV, maxV;
+
+        if (arr.Count < minLn)
+        {
+            minV = sorted[0];
+            maxV = sorted[length - 1];
+        }
+        else
+        {
+            var start = length / minLn;
+            var end = length * 3 / minLn - 1;
+
+            minV = sorted[start];
+            maxV = sorted[end];
+        }
+
+        var count = 0;
+        double sum = 0;
+
+        foreach (var e in sorted)
+        {
+            if (e >= minV && e <= maxV)
+            {
+                sum += e;
+                count++;
+            }
+        }
+
+        return sum / count;
+    }
+
+    internal readonly void Clear()
+    {
+        arr.Clear();
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/MinAgg.cs

@@ -0,0 +1,27 @@
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal struct MinAgg
+{
+    private double min;
+    private bool minFound;
+
+    internal void Add(double n)
+    {
+        if (!minFound)
+        {
+            min = n;
+            minFound = true;
+            return;
+        }
+
+        if (n < min)
+        {
+            min = n;
+        }
+    }
+
+    internal readonly double Compute()
+    {
+        return min;
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/Operation.cs

@@ -0,0 +1,16 @@
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+public enum Operation
+{
+    Unspecified = 0,
+    EQ,
+    NE,
+    GT,
+    GE,
+    LT,
+    LE,
+    OR,
+    AND,
+    NOT,
+    LIKE
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/ReverseMinNorm.cs

@@ -0,0 +1,8 @@
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal struct ReverseMinNorm : INormalizer
+{
+    internal double min;
+
+    public readonly double Normalize(double w) => (min + 1) / (w + 1);
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/SelectFilterExpr.cs

@@ -0,0 +1,10 @@
+using System.Collections.ObjectModel;
+
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal struct SelectFilterExpr(uint cbf, FrostFsSelector selector, Collection<FrostFsFilter> filters)
+{
+    internal uint Cbf { get; } = cbf;
+    internal FrostFsSelector Selector { get; } = selector;
+    internal Collection<FrostFsFilter> Filters { get; } = filters;
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/SigmoidNorm.cs

@@ -0,0 +1,23 @@
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+internal readonly struct SigmoidNorm : INormalizer
+{
+    private readonly double _scale;
+
+    internal SigmoidNorm(double scale)
+    {
+        _scale = scale;
+    }
+
+    public readonly double Normalize(double w)
+    {
+        if (_scale == 0)
+        {
+            return 0;
+        }
+
+        var x = w / _scale;
+
+        return x / (1 + x);
+    }
+}

src/FrostFS.SDK.Client/Models/Netmap/Placement/Tools.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using static FrostFS.SDK.FrostFsNetmapSnapshot;
+
+namespace FrostFS.SDK.Client.Models.Netmap.Placement;
+
+public static class Tools
+{
+    internal static ulong Distance(ulong x, ulong y)
+    {
+        var acc = x ^ y;
+        acc ^= acc >> 33;
+        acc *= 0xff51afd7ed558ccd;
+        acc ^= acc >> 33;
+        acc *= 0xc4ceb9fe1a85ec53;
+        acc ^= acc >> 33;
+
+        return acc;
+    }
+
+    internal static double ReverceNormalize(double r, double w)
+    {
+        return (r + 1) / (w + 1);
+    }
+
+    internal static double Normalize(double r, double w)
+    {
+        if (r == 0)
+        {
+            return 0;
+        }
+
+        var x = w / r;
+        return x / (1 + x);
+    }
+
+    internal static void AppendWeightsTo(FrostFsNodeInfo[] nodes, Func<FrostFsNodeInfo, double> wf, ref double[] weights)
+    {
+        if (weights.Length < nodes.Length)
+        {
+            weights = new double[nodes.Length];
+        }
+
+        for (int i = 0; i < nodes.Length; i++)
+        {
+            weights[i] = wf(nodes[i]);
+        }
+    }
+
+    internal static List<T> SortHasherSliceByWeightValue<T>(List<T> nodes, Span<double> weights, ulong hash) where T : IHasher
+    {
+        if (nodes.Count == 0)
+        {
+            return nodes;
+        }
+
+        var allEquals = true;
+
+        if (weights.Length > 1)
+        {
+            for (int i = 1; i < weights.Length; i++)
+            {
+                if (weights[i] != weights[0])
+                {
+                    allEquals = false;
+                    break;
+                }
+            }
+        }
+
+        var dist = new double[nodes.Count];
+
+        if (allEquals)
+        {
+            for (int i = 0; i < dist.Length; i++)
+            {
+                var x = nodes[i].Hash();
+                dist[i] = Distance(x, hash);
+            }
+
+            return SortHasherByDistance(nodes, dist, true);
+        }
+
+        for (int i = 0; i < dist.Length; i++)
+        {
+            var d = Distance(nodes[i].Hash(), hash);
+            dist[i] = (ulong.MaxValue - d) * weights[i];
+        }
+
+        return SortHasherByDistance(nodes, dist, false);
+    }
+
+    internal static List<T> SortHasherByDistance<T, N>(List<T> nodes, N[] dist, bool asc)
+    {
+        IndexedValue<T, N>[] indexes = new IndexedValue<T, N>[nodes.Count];
+        for (int i = 0; i < dist.Length; i++)
+        {
+            indexes[i] = new IndexedValue<T, N>() { nodeInfo = nodes[i], dist = dist[i] };
+        }
+
+        if (asc)
+        {
+            return new List<T>(indexes
+                .OrderBy(x => x.dist)
+                .Select(x => x.nodeInfo).ToArray());
+        }
+        else
+        {
+            return new List<T>(indexes
+                .OrderByDescending(x => x.dist)
+                .Select(x => x.nodeInfo));
+        }
+    }
+
+    internal static Func<FrostFsNodeInfo, double> DefaultWeightFunc(IReadOnlyList<FrostFsNodeInfo> nodes)
+    {
+        MeanAgg mean = new();
+        MinAgg minV = new();
+
+        foreach (var node in nodes)
+        {
+            mean.Add(node.GetCapacity());
+            minV.Add(node.Price);
+        }
+
+        return NewWeightFunc(
+            NewSigmoidNorm(mean.Compute()),
+            NewReverseMinNorm(minV.Compute()));
+    }
+
+    private struct IndexedValue<T, N>
+    {
+        internal T nodeInfo;
+        internal N dist;
+    }
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsAttributePair.cs

@@ -1,8 +1,36 @@
 namespace FrostFS.SDK;
 
-public class FrostFsAttributePair(string key, string value)
+public struct FrostFsAttributePair(string key, string value) : System.IEquatable<FrostFsAttributePair>
 {
     public string Key { get; set; } = key;
 
     public string Value { get; set; } = value;
+
+    public override bool Equals(object obj)
+    {
+        if (obj == null || obj is not FrostFsAttributePair)
+            return false;
+
+        return Equals((FrostFsAttributePair)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return Key.GetHashCode() ^ Value.GetHashCode();
+    }
+
+    public static bool operator ==(FrostFsAttributePair left, FrostFsAttributePair right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(FrostFsAttributePair left, FrostFsAttributePair right)
+    {
+        return !(left == right);
+    }
+
+    public bool Equals(FrostFsAttributePair other)
+    {
+        return GetHashCode().Equals(other.GetHashCode());
+    }
 }

src/FrostFS.SDK.Client/Models/Object/FrostFsObject.cs

@@ -4,8 +4,6 @@ namespace FrostFS.SDK;
 
 public class FrostFsObject
 {
-    private byte[]? bytes;
-
     /// <summary>
     /// Creates new instance from <c>ObjectHeader</c>
     /// </summary>
@@ -45,20 +43,12 @@ public class FrostFsObject
     /// <value>Reader for received data</value>
     public IObjectReader? ObjectReader { get; set; }
 
-    internal byte[] SingleObjectPayload
-    {
-        get { return bytes ?? []; }
-    }
+    public ReadOnlyMemory<byte> SingleObjectPayload { get; set; }
 
     /// <summary>
-    /// The size of payload cannot exceed <c>MaxObjectSize</c> value from <c>NetworkSettings</c>
-    /// Used only for PutSingleObject method
+    /// Provide SHA256 hash of the payload. If null, the hash is calculated by internal logic
     /// </summary>
-    /// <value>Buffer for output data</value>
-    public void SetSingleObjectPayload(byte[] bytes)
-    {
-        this.bytes = bytes;
-    }
+    public byte[]? PayloadHash { get; set; }
 
     /// <summary>
     /// Applied only for the last Object in chain in case of manual multipart uploading

src/FrostFS.SDK.Client/Models/Object/FrostFsSplit.cs

@@ -1,4 +1,7 @@
 using System.Collections.ObjectModel;
+using System.Linq;
+using FrostFS.Object;
+using FrostFS.SDK.Client.Mappers.GRPC;
 
 namespace FrostFS.SDK;
 
@@ -9,6 +12,8 @@ public class FrostFsSplit(SplitId splitId,
     FrostFsSignature? parentSignature = null,
     ReadOnlyCollection<FrostFsObjectId>? children = null)
 {
+    private Header.Types.Split? _split;
+
     public FrostFsSplit() : this(new SplitId())
     {
     }
@@ -24,4 +29,25 @@ public class FrostFsSplit(SplitId splitId,
     public FrostFsObjectHeader? ParentHeader { get; set; } = parentHeader;
 
     public ReadOnlyCollection<FrostFsObjectId>? Children { get; } = children;
+
+    public Header.Types.Split GetSplit()
+    {
+        if (_split == null)
+        {
+            _split = new Header.Types.Split
+            {
+                SplitId = SplitId?.GetSplitId(),
+                Parent = Parent?.ToMessage(),
+                ParentHeader = ParentHeader?.GetHeader(),
+                ParentSignature = ParentSignature?.ToMessage()
+            };
+
+            if (Children != null)
+            {
+                _split.Children.AddRange(Children.Select(x => x.ToMessage()));
+            }
+        }
+
+        return _split;
+    }
 }

src/FrostFS.SDK.Client/Models/Object/FrostFsSplitInfo.cs

@@ -20,7 +20,9 @@ public class FrostFsSplitInfo
 
     public SplitId SplitId => _splitId ??= new SplitId(_splitInfo.SplitId.ToUuid());
 
-    public FrostFsObjectId Link => _link ??= FrostFsObjectId.FromHash(_splitInfo.Link.Value.Span);
+    public FrostFsObjectId? Link => _link ??= _splitInfo.Link == null
+        ? null : FrostFsObjectId.FromHash(_splitInfo.Link.Value.Span);
 
-    public FrostFsObjectId LastPart => _lastPart ??= FrostFsObjectId.FromHash(_splitInfo.LastPart.Value.Span);
+    public FrostFsObjectId? LastPart => _lastPart ??= _splitInfo.LastPart == null
+        ? null : FrostFsObjectId.FromHash(_splitInfo.LastPart.Value.Span);
 }

src/FrostFS.SDK.Client/Models/Object/SplitId.cs

@@ -47,16 +47,11 @@ public class SplitId
         return this.id.ToString();
     }
 
-    public byte[]? ToBinary()
-    {
-        if (this.id == Guid.Empty)
-            return null;
-
-        return this.id.ToBytes();
-    }
-
     public ByteString? GetSplitId()
     {
-        return this.message ??= ByteString.CopyFrom(ToBinary());
+        Span<byte> span = stackalloc byte[16];
+        id.ToBytes(span);
+
+        return this.message ??= ByteString.CopyFrom(span);
     }
 }

src/FrostFS.SDK.Client/Models/Response/FrostFsResponseStatus.cs

@@ -1,14 +1,16 @@
 namespace FrostFS.SDK;
 
-public class FrostFsResponseStatus(FrostFsStatusCode code, string? message = null)
+public class FrostFsResponseStatus(FrostFsStatusCode code, string? message = null, string? details = null)
 {
     public FrostFsStatusCode Code { get; set; } = code;
     public string Message { get; set; } = message ?? string.Empty;
 
+    public string Details { get; set; } = details ?? string.Empty;
+
     public bool IsSuccess => Code == FrostFsStatusCode.Success;
 
     public override string ToString()
     {
-        return $"Response status: {Code}. Message: {Message}.";
+        return $"Response status: {Code}. Message: {Message}. Details: {Details}";
     }
 }

src/FrostFS.SDK.Client/Models/Session/FrostFsSessionToken.cs

@@ -1,5 +1,4 @@
 using System;
-
 using FrostFS.Refs;
 
 using FrostFS.SDK.Client;
@@ -36,7 +35,9 @@ public class FrostFsSessionToken
         get
         {
             if (_id == Guid.Empty)
+            {
                 _id = ProtoId.ToUuid();
+            }
 
             return _id;
         }
@@ -47,7 +48,9 @@ public class FrostFsSessionToken
         get
         {
             if (_sessionKey.IsEmpty)
+            {
                 _sessionKey = ProtoSessionKey.Memory;
+            }
 
             return _sessionKey;
         }
@@ -69,13 +72,16 @@ public class FrostFsSessionToken
         sessionToken.Body.Container = new() { Verb = verb };
 
         if (containerId != null)
+        {
             sessionToken.Body.Container.ContainerId = containerId;
+        }
         else
+        {
             sessionToken.Body.Container.Wildcard = true;
+        }
 
         sessionToken.Body.SessionKey = key.PublicKeyProto;
-
-        sessionToken.Signature = key.ECDsaKey.SignMessagePart(sessionToken.Body);
+        sessionToken.Signature = key.SignMessagePart(sessionToken.Body);
 
         return sessionToken;
     }
@@ -100,7 +106,9 @@ public class FrostFsSessionToken
         ObjectSessionContext.Types.Target target = new() { Container = address.ContainerId };
 
         if (address.ObjectId != null)
+        {
             target.Objects.Add(address.ObjectId);
+        }
 
         sessionToken.Body.Object = new()
         {
@@ -108,9 +116,7 @@ public class FrostFsSessionToken
             Verb = verb
         };
 
-        sessionToken.Body.SessionKey = key.PublicKeyProto;
-
-        sessionToken.Signature = key.ECDsaKey.SignMessagePart(sessionToken.Body);
+        sessionToken.Signature = key.SignMessagePart(sessionToken.Body);
 
         return sessionToken;
     }

src/FrostFS.SDK.Client/ObjectWriter.cs

@@ -32,7 +32,9 @@ namespace FrostFS.SDK.Client
                 }
             };
 
-            chunkRequest.Sign(this.ctx.Key.ECDsaKey);
+            chunkRequest.AddMetaHeader(args.XHeaders);
+
+            chunkRequest.Sign(this.ctx.Key);
 
             await streamer.Write(chunkRequest).ConfigureAwait(false);
         }

src/FrostFS.SDK.Client/Parameters/PrmApeChainRemove.cs

@@ -2,12 +2,12 @@
 
 public readonly struct PrmApeChainRemove(
     FrostFsChainTarget target,
-    FrostFsChain chain,
+    byte[] chainId,
     string[]? xheaders = null) : System.IEquatable<PrmApeChainRemove>
 {
     public FrostFsChainTarget Target { get; } = target;
 
-    public FrostFsChain Chain { get; } = chain;
+    public byte[] ChainId { get; } = chainId;
 
     /// <summary>
     /// FrostFS request X-Headers
@@ -25,13 +25,13 @@ public readonly struct PrmApeChainRemove(
     public readonly bool Equals(PrmApeChainRemove other)
     {
         return Target == other.Target
-            && Chain == other.Chain
+            && ChainId.Equals(other.ChainId)
             && XHeaders == other.XHeaders;
     }
 
     public override readonly int GetHashCode()
     {
-        return Chain.GetHashCode() ^ Target.GetHashCode() ^ XHeaders.GetHashCode();
+        return ChainId.GetHashCode() ^ Target.GetHashCode() ^ XHeaders.GetHashCode();
     }
 
     public static bool operator ==(PrmApeChainRemove left, PrmApeChainRemove right)

src/FrostFS.SDK.Client/Pool/ClientStatusMonitor.cs

@@ -1,163 +0,0 @@
-using System;
-using System.Threading;
-
-using Microsoft.Extensions.Logging;
-
-namespace FrostFS.SDK.Client;
-
-// clientStatusMonitor count error rate and other statistics for connection.
-public class ClientStatusMonitor : IClientStatus
-{
-    private static readonly MethodIndex[] MethodIndexes =
-    [
-        MethodIndex.methodBalanceGet,
-        MethodIndex.methodContainerPut,
-        MethodIndex.methodContainerGet,
-        MethodIndex.methodContainerList,
-        MethodIndex.methodContainerDelete,
-        MethodIndex.methodEndpointInfo,
-        MethodIndex.methodNetworkInfo,
-        MethodIndex.methodNetMapSnapshot,
-        MethodIndex.methodObjectPut,
-        MethodIndex.methodObjectDelete,
-        MethodIndex.methodObjectGet,
-        MethodIndex.methodObjectHead,
-        MethodIndex.methodObjectRange,
-        MethodIndex.methodObjectPatch,
-        MethodIndex.methodSessionCreate,
-        MethodIndex.methodAPEManagerAddChain,
-        MethodIndex.methodAPEManagerRemoveChain,
-        MethodIndex.methodAPEManagerListChains
-    ];
-
-    public static string GetMethodName(MethodIndex index)
-    {
-        return index switch
-        {
-            MethodIndex.methodBalanceGet => "BalanceGet",
-            MethodIndex.methodContainerPut => "ContainerPut",
-            MethodIndex.methodContainerGet => "ContainerGet",
-            MethodIndex.methodContainerList => "ContainerList",
-            MethodIndex.methodContainerDelete => "ContainerDelete",
-            MethodIndex.methodEndpointInfo => "EndpointInfo",
-            MethodIndex.methodNetworkInfo => "NetworkInfo",
-            MethodIndex.methodNetMapSnapshot => "NetMapSnapshot",
-            MethodIndex.methodObjectPut => "ObjectPut",
-            MethodIndex.methodObjectDelete => "ObjectDelete",
-            MethodIndex.methodObjectGet => "ObjectGet",
-            MethodIndex.methodObjectHead => "ObjectHead",
-            MethodIndex.methodObjectRange => "ObjectRange",
-            MethodIndex.methodObjectPatch => "ObjectPatch",
-            MethodIndex.methodSessionCreate => "SessionCreate",
-            MethodIndex.methodAPEManagerAddChain => "APEManagerAddChain",
-            MethodIndex.methodAPEManagerRemoveChain => "APEManagerRemoveChain",
-            MethodIndex.methodAPEManagerListChains => "APEManagerListChains",
-            _ => throw new ArgumentException("Unknown method", nameof(index)),
-        };
-    }
-
-    private readonly object _lock = new();
-
-    private readonly ILogger? logger;
-    private int healthy;
-
-    public ClientStatusMonitor(ILogger? logger, string address)
-    {
-        this.logger = logger;
-        healthy = (int)HealthyStatus.Healthy;
-
-        Address = address;
-        Methods = new MethodStatus[MethodIndexes.Length];
-
-        for (int i = 0; i < MethodIndexes.Length; i++)
-        {
-            Methods[i] = new MethodStatus(GetMethodName(MethodIndexes[i]));
-        }
-    }
-
-    public string Address { get; }
-
-    internal uint ErrorThreshold { get; set; }
-
-    public uint CurrentErrorCount { get; set; }
-
-    public ulong OverallErrorCount { get; set; }
-
-    public MethodStatus[] Methods { get; private set; }
-
-    public bool IsHealthy()
-    {
-        var res = Interlocked.CompareExchange(ref healthy, -1, -1) == (int)HealthyStatus.Healthy;
-        return res;
-    }
-
-    public bool IsDialed()
-    {
-        return Interlocked.CompareExchange(ref healthy, -1, -1) != (int)HealthyStatus.UnhealthyOnDial;
-    }
-
-    public void SetHealthy()
-    {
-        Interlocked.Exchange(ref healthy, (int)HealthyStatus.Healthy);
-    }
-    public void SetUnhealthy()
-    {
-        Interlocked.Exchange(ref healthy, (int)HealthyStatus.UnhealthyOnRequest);
-    }
-
-    public void SetUnhealthyOnDial()
-    {
-        Interlocked.Exchange(ref healthy, (int)HealthyStatus.UnhealthyOnDial);
-    }
-
-    public void IncErrorRate()
-    {
-        bool thresholdReached;
-        lock (_lock)
-        {
-            CurrentErrorCount++;
-            OverallErrorCount++;
-
-            thresholdReached = CurrentErrorCount >= ErrorThreshold;
-
-            if (thresholdReached)
-            {
-                SetUnhealthy();
-                CurrentErrorCount = 0;
-            }
-        }
-
-        if (thresholdReached && logger != null)
-        {
-            FrostFsMessages.ErrorЕhresholdReached(logger, Address, ErrorThreshold);
-        }
-    }
-
-    public uint GetCurrentErrorRate()
-    {
-        lock (_lock)
-        {
-            return CurrentErrorCount;
-        }
-    }
-
-    public ulong GetOverallErrorRate()
-    {
-        lock (_lock)
-        {
-            return OverallErrorCount;
-        }
-    }
-
-    public StatusSnapshot[] MethodsStatus()
-    {
-        var result = new StatusSnapshot[Methods.Length];
-
-        for (int i = 0; i < result.Length; i++)
-        {
-            result[i] = Methods[i].Snapshot!;
-        }
-
-        return result;
-    }
-}

src/FrostFS.SDK.Client/Pool/ClientWrapper.cs

@@ -1,135 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-using Grpc.Core;
-
-namespace FrostFS.SDK.Client;
-
-// clientWrapper is used by default, alternative implementations are intended for testing purposes only.
-public class ClientWrapper : ClientStatusMonitor
-{
-    private readonly object _lock = new();
-    private SessionCache sessionCache;
-
-    internal ClientWrapper(WrapperPrm wrapperPrm, Pool pool) : base(wrapperPrm.Logger, wrapperPrm.Address)
-    {
-        WrapperPrm = wrapperPrm;
-        ErrorThreshold = wrapperPrm.ErrorThreshold;
-
-        sessionCache = pool.SessionCache;
-        Client = new FrostFSClient(WrapperPrm, sessionCache);
-    }
-
-    internal FrostFSClient? Client { get; private set; }
-
-    internal WrapperPrm WrapperPrm { get; }
-
-    internal FrostFSClient? GetClient()
-    {
-        lock (_lock)
-        {
-            if (IsHealthy())
-            {
-                return Client;
-            }
-
-            return null;
-        }
-    }
-
-    // dial establishes a connection to the server from the FrostFS network.
-    // Returns an error describing failure reason. If failed, the client
-    // SHOULD NOT be used.
-    internal async Task Dial(CallContext ctx)
-    {
-        var client = GetClient() ?? throw new FrostFsInvalidObjectException("pool client unhealthy");
-
-        await client.Dial(ctx).ConfigureAwait(false);
-    }
-
-    internal void HandleError(Exception ex)
-    {
-        if (ex is FrostFsResponseException responseException && responseException.Status != null)
-        {
-            switch (responseException.Status.Code)
-            {
-                case FrostFsStatusCode.Internal:
-                case FrostFsStatusCode.WrongMagicNumber:
-                case FrostFsStatusCode.SignatureVerificationFailure:
-                case FrostFsStatusCode.NodeUnderMaintenance:
-                    IncErrorRate();
-                    return;
-            }
-        }
-
-        IncErrorRate();
-    }
-
-    private async Task ScheduleGracefulClose()
-    {
-        if (Client == null)
-            return;
-
-        await Task.Delay((int)WrapperPrm.GracefulCloseOnSwitchTimeout).ConfigureAwait(false);
-    }
-
-    // restartIfUnhealthy checks healthy status of client and recreate it if status is unhealthy.
-    // Indicating if status was changed by this function call and returns error that caused unhealthy status.
-    internal async Task<bool> RestartIfUnhealthy(CallContext ctx)
-    {
-        bool wasHealthy;
-
-        try
-        {
-            var response = await Client!.GetNodeInfoAsync(ctx).ConfigureAwait(false);
-            return false;
-        }
-        catch (RpcException)
-        {
-            wasHealthy = true;
-        }
-
-        // if connection is dialed before, to avoid routine/connection leak,
-        // pool has to close it and then initialize once again.
-        if (IsDialed())
-        {
-            await ScheduleGracefulClose().ConfigureAwait(false);
-        }
-
-        FrostFSClient? client = new(WrapperPrm, sessionCache);
-
-        var error = await client.Dial(ctx).ConfigureAwait(false);
-        if (!string.IsNullOrEmpty(error))
-        {
-            SetUnhealthyOnDial();
-            return wasHealthy;
-        }
-
-        lock (_lock)
-        {
-            Client = client;
-        }
-
-        try
-        {
-            var res = await Client.GetNodeInfoAsync(ctx).ConfigureAwait(false);
-        }
-        catch (FrostFsException)
-        {
-            SetUnhealthy();
-            
-            return wasHealthy;
-        }
-
-        SetHealthy();
-        return !wasHealthy;
-    }
-
-    internal void IncRequests(ulong elapsed, MethodIndex method)
-    {
-        var methodStat = Methods[(int)method];
-
-        methodStat.IncRequests(elapsed);
-    }
-}
-

src/FrostFS.SDK.Client/Pool/HealthyStatus.cs

@@ -1,18 +0,0 @@
-namespace FrostFS.SDK.Client;
-
-// values for healthy status of clientStatusMonitor.
-public enum HealthyStatus
-{
-    // statusUnhealthyOnDial is set when dialing to the endpoint is failed,
-    // so there is no connection to the endpoint, and pool should not close it
-    // before re-establishing connection once again.
-    UnhealthyOnDial,
-
-    // statusUnhealthyOnRequest is set when communication after dialing to the
-    // endpoint is failed due to immediate or accumulated errors, connection is
-    // available and pool should close it before re-establishing connection once again.
-    UnhealthyOnRequest,
-
-    // statusHealthy is set when connection is ready to be used by the pool.
-    Healthy
-}

src/FrostFS.SDK.Client/Pool/IClientStatus.cs

@@ -1,28 +0,0 @@
-namespace FrostFS.SDK.Client;
-
-public interface IClientStatus
-{
-    // isHealthy checks if the connection can handle requests.
-    bool IsHealthy();
-
-    // isDialed checks if the connection was created.
-    bool IsDialed();
-
-    // setUnhealthy marks client as unhealthy.
-    void SetUnhealthy();
-
-    // address return address of endpoint.
-    string Address { get; }
-
-    // currentErrorRate returns current errors rate.
-    // After specific threshold connection is considered as unhealthy.
-    // Pool.startRebalance routine can make this connection healthy again.
-    uint GetCurrentErrorRate();
-
-    // overallErrorRate returns the number of all happened errors.
-    ulong GetOverallErrorRate();
-
-    // methodsStatus returns statistic for all used methods.
-    StatusSnapshot[] MethodsStatus();
-}
-

src/FrostFS.SDK.Client/Pool/InitParameters.cs

@@ -1,45 +0,0 @@
-using System;
-using System.Collections.ObjectModel;
-using System.Security.Cryptography;
-
-using Grpc.Core;
-using Grpc.Core.Interceptors;
-using Grpc.Net.Client;
-
-using Microsoft.Extensions.Logging;
-
-namespace FrostFS.SDK.Client;
-
-// InitParameters contains values used to initialize connection Pool.
-public class InitParameters(Func<string, ChannelBase> grpcChannelFactory)
-{
-    public ECDsa? Key { get; set; }
-
-    public ulong NodeDialTimeout { get; set; }
-
-    public ulong NodeStreamTimeout { get; set; }
-
-    public ulong HealthcheckTimeout { get; set; }
-
-    public ulong ClientRebalanceInterval { get; set; }
-
-    public ulong SessionExpirationDuration { get; set; }
-
-    public uint ErrorThreshold { get; set; }
-
-    public NodeParam[]? NodeParams { get; set; }
-
-    public GrpcChannelOptions[]? DialOptions { get; set; }
-
-    public Func<string, ClientWrapper>? ClientBuilder { get; set; }
-
-    public ulong GracefulCloseOnSwitchTimeout { get; set; }
-
-    public ILogger? Logger { get; set; }
-
-    public Action<CallStatistics>? Callback { get; set; }
-
-    public Collection<Interceptor> Interceptors { get; } = [];
-
-    public Func<string, ChannelBase> GrpcChannelFactory { get; set; } = grpcChannelFactory;
-}

src/FrostFS.SDK.Client/Pool/InnerPool.cs

@@ -1,47 +0,0 @@
-using FrostFS.SDK.Client;
-
-internal sealed class InnerPool
-{
-    private readonly object _lock = new();
-
-    internal InnerPool(Sampler sampler, ClientWrapper[] clients)
-    {
-        Clients = clients;
-        Sampler = sampler;
-    }
-
-    internal Sampler Sampler { get; set; }
-
-    internal ClientWrapper[] Clients { get; }
-
-    internal ClientWrapper? Connection()
-    {
-        lock (_lock)
-        {
-            if (Clients.Length == 1)
-            {
-                var client = Clients[0];
-                if (client.IsHealthy())
-                {
-                    return client;
-                }
-            }
-            else
-            {
-                var attempts = 3 * Clients.Length;
-
-                for (int i = 0; i < attempts; i++)
-                {
-                    int index = Sampler.Next();
-
-                    if (Clients[index].IsHealthy())
-                    {
-                        return Clients[index];
-                    }
-                }
-            }
-
-            return null;
-        }
-    }
-}

src/FrostFS.SDK.Client/Pool/MethodIndex.cs

@@ -1,24 +0,0 @@
-namespace FrostFS.SDK.Client;
-
-public enum MethodIndex
-{
-    methodBalanceGet,
-    methodContainerPut,
-    methodContainerGet,
-    methodContainerList,
-    methodContainerDelete,
-    methodEndpointInfo,
-    methodNetworkInfo,
-    methodNetMapSnapshot,
-    methodObjectPut,
-    methodObjectDelete,
-    methodObjectGet,
-    methodObjectHead,
-    methodObjectRange,
-    methodObjectPatch,
-    methodSessionCreate,
-    methodAPEManagerAddChain,
-    methodAPEManagerRemoveChain,
-    methodAPEManagerListChains,
-    methodLast
-}

src/FrostFS.SDK.Client/Pool/MethodStatus.cs

@@ -1,19 +0,0 @@
-namespace FrostFS.SDK.Client;
-
-public class MethodStatus(string name)
-{
-    private readonly object _lock = new();
-
-    public string Name { get; } = name;
-
-    public StatusSnapshot Snapshot { get; set; } = new StatusSnapshot();
-
-    internal void IncRequests(ulong elapsed)
-    {
-        lock (_lock)
-        {
-            Snapshot.AllTime += elapsed;
-            Snapshot.AllRequests++;
-        }
-    }
-}

src/FrostFS.SDK.Client/Pool/NodeParam.cs

@@ -1,12 +0,0 @@
-namespace FrostFS.SDK.Client;
-
-// NodeParam groups parameters of remote node.
-[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1815:Override equals and operator equals on value types", Justification = "<Pending>")]
-public readonly struct NodeParam(int priority, string address, float weight)
-{
-    public int Priority { get; } = priority;
-
-    public string Address { get; } = address;
-
-    public float Weight { get; } = weight;
-}

src/FrostFS.SDK.Client/Pool/NodeStatistic.cs

@@ -1,12 +0,0 @@
-namespace FrostFS.SDK.Client;
-
-public class NodeStatistic
-{
-    public string? Address { get; internal set; }
-
-    public StatusSnapshot[]? Methods { get; internal set; }
-
-    public ulong OverallErrors { get; internal set; }
-
-    public uint CurrentErrors { get; internal set; }
-}

src/FrostFS.SDK.Client/Pool/NodesParam.cs

@@ -1,12 +0,0 @@
-using System.Collections.ObjectModel;
-
-namespace FrostFS.SDK.Client;
-
-public class NodesParam(int priority)
-{
-    public int Priority { get; } = priority;
-
-    public Collection<string> Addresses { get; } = [];
-
-    public Collection<double> Weights { get; } = [];
-}

src/FrostFS.SDK.Client/Pool/Pool.cs

@@ -1,668 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Security.Cryptography;
-using System.Threading;
-using System.Threading.Tasks;
-
-using Frostfs.V2.Ape;
-
-using FrostFS.Refs;
-using FrostFS.SDK.Client.Interfaces;
-using FrostFS.SDK.Client.Mappers.GRPC;
-using FrostFS.SDK.Cryptography;
-
-using Grpc.Core;
-
-using Microsoft.Extensions.Logging;
-
-
-namespace FrostFS.SDK.Client;
-
-public partial class Pool : IFrostFSClient
-{
-    const int defaultSessionTokenExpirationDuration = 100; // in epochs
-
-    const int defaultErrorThreshold = 100;
-
-    const int defaultGracefulCloseOnSwitchTimeout = 10; //Seconds;
-    const int defaultRebalanceInterval = 15; //Seconds;
-    const int defaultHealthcheckTimeout = 4; //Seconds;
-    const int defaultDialTimeout = 5; //Seconds;
-    const int defaultStreamTimeout = 10; //Seconds;
-
-    private readonly object _lock = new();
-
-    private InnerPool[]? InnerPools { get; set; }
-
-    private ClientKey Key { get; set; }
-
-    private OwnerID? _ownerId;
-
-    private FrostFsOwner? _owner;
-
-    private FrostFsOwner Owner
-    {
-        get
-        {
-            _owner ??= new FrostFsOwner(Key.ECDsaKey.PublicKey().PublicKeyToAddress());
-            return _owner;
-        }
-    }
-
-    private OwnerID OwnerId
-    {
-        get
-        {
-            if (_ownerId == null)
-            {
-                _owner = Key.Owner;
-                _ownerId = _owner.ToMessage();
-            }
-            return _ownerId;
-        }
-    }
-
-    internal CancellationTokenSource CancellationTokenSource { get; } = new CancellationTokenSource();
-
-    internal SessionCache SessionCache { get; set; }
-
-    private ulong SessionTokenDuration { get; set; }
-
-    private RebalanceParameters RebalanceParams { get; set; }
-
-    private Func<string, ClientWrapper> ClientBuilder;
-
-    private bool disposedValue;
-
-    private ILogger? logger { get; set; }
-
-    private ulong MaxObjectSize { get; set; }
-
-    public IClientStatus? ClientStatus { get; }
-
-    // NewPool creates connection pool using parameters.
-    public Pool(InitParameters options)
-    {
-        if (options is null)
-        {
-            throw new ArgumentNullException(nameof(options));
-        }
-
-        if (options.Key == null)
-        {
-            throw new ArgumentException($"Missed required parameter {nameof(options.Key)}");
-        }
-
-        var nodesParams = AdjustNodeParams(options.NodeParams);
-
-        var cache = new SessionCache(options.SessionExpirationDuration);
-
-        FillDefaultInitParams(options, this);
-
-        Key = new ClientKey(options.Key);
-
-        SessionCache = cache;
-        logger = options.Logger;
-        SessionTokenDuration = options.SessionExpirationDuration;
-
-        RebalanceParams = new RebalanceParameters(
-            nodesParams.ToArray(),
-            options.HealthcheckTimeout,
-            options.ClientRebalanceInterval,
-            options.SessionExpirationDuration);
-
-        ClientBuilder = options.ClientBuilder!;
-
-        // ClientContext.PoolErrorHandler = client.HandleError;
-
-    }
-
-    // Dial establishes a connection to the servers from the FrostFS network.
-    // It also starts a routine that checks the health of the nodes and
-    // updates the weights of the nodes for balancing.
-    // Returns an error describing failure reason.
-    //
-    // If failed, the Pool SHOULD NOT be used.
-    //
-    // See also InitParameters.SetClientRebalanceInterval.
-    public async Task<string?> Dial(CallContext ctx)
-    {
-        var inner = new InnerPool[RebalanceParams.NodesParams.Length];
-
-        bool atLeastOneHealthy = false;
-        int i = 0;
-        foreach (var nodeParams in RebalanceParams.NodesParams)
-        {
-            var wrappers = new ClientWrapper[nodeParams.Weights.Count];
-
-            for (int j = 0; j < nodeParams.Addresses.Count; j++)
-            {
-                ClientWrapper? wrapper = null;
-                bool dialed = false;
-                try
-                {
-                    wrapper = wrappers[j] = ClientBuilder(nodeParams.Addresses[j]);
-
-                    await wrapper.Dial(ctx).ConfigureAwait(false);
-                    dialed = true;
-
-                    var token = await InitSessionForDuration(ctx, wrapper, RebalanceParams.SessionExpirationDuration, Key.ECDsaKey, false)
-                        .ConfigureAwait(false);
-
-                    var key = FormCacheKey(nodeParams.Addresses[j], Key.PublicKey);
-                    SessionCache.SetValue(key, token);
-
-                    atLeastOneHealthy = true;
-                }
-                catch (RpcException ex)
-                {
-                    if (!dialed)
-                        wrapper!.SetUnhealthyOnDial();
-                    else
-                        wrapper!.SetUnhealthy();
-
-                    if (logger != null)
-                    {
-                        FrostFsMessages.SessionCreationError(logger, wrapper!.WrapperPrm.Address, ex.Message);
-                    }
-                }
-                catch (FrostFsInvalidObjectException)
-                {
-                    break;
-                }
-            }
-
-            var sampler = new Sampler(nodeParams.Weights.ToArray());
-
-            inner[i] = new InnerPool(sampler, wrappers);
-
-            i++;
-        }
-
-        if (!atLeastOneHealthy)
-            return "At least one node must be healthy";
-
-        InnerPools = inner;
-
-        var res = await GetNetworkSettingsAsync(default).ConfigureAwait(false);
-
-        MaxObjectSize = res.MaxObjectSize;
-
-        StartRebalance(ctx);
-
-        return null;
-    }
-
-    private static IEnumerable<NodesParam> AdjustNodeParams(NodeParam[]? nodeParams)
-    {
-        if (nodeParams == null || nodeParams.Length == 0)
-        {
-            throw new ArgumentException("No FrostFS peers configured");
-        }
-
-        Dictionary<int, NodesParam> nodesParamsDict = new(nodeParams.Length);
-        foreach (var nodeParam in nodeParams)
-        {
-            if (!nodesParamsDict.TryGetValue(nodeParam.Priority, out var nodes))
-            {
-                nodes = new NodesParam(nodeParam.Priority);
-                nodesParamsDict[nodeParam.Priority] = nodes;
-            }
-
-            nodes.Addresses.Add(nodeParam.Address);
-            nodes.Weights.Add(nodeParam.Weight);
-        }
-
-        var nodesParams = new List<NodesParam>(nodesParamsDict.Count);
-
-        foreach (var key in nodesParamsDict.Keys)
-        {
-            var nodes = nodesParamsDict[key];
-            var newWeights = AdjustWeights([.. nodes.Weights]);
-            nodes.Weights.Clear();
-            foreach (var weight in newWeights)
-            {
-                nodes.Weights.Add(weight);
-            }
-
-            nodesParams.Add(nodes);
-        }
-
-        return nodesParams.OrderBy(n => n.Priority);
-    }
-
-    private static double[] AdjustWeights(double[] weights)
-    {
-        var adjusted = new double[weights.Length];
-
-        var sum = weights.Sum();
-
-        if (sum > 0)
-        {
-            for (int i = 0; i < weights.Length; i++)
-            {
-                adjusted[i] = weights[i] / sum;
-            }
-        }
-
-        return adjusted;
-    }
-
-    private static void FillDefaultInitParams(InitParameters parameters, Pool pool)
-    {
-        if (parameters.SessionExpirationDuration == 0)
-            parameters.SessionExpirationDuration = defaultSessionTokenExpirationDuration;
-
-        if (parameters.ErrorThreshold == 0)
-            parameters.ErrorThreshold = defaultErrorThreshold;
-
-        if (parameters.ClientRebalanceInterval <= 0)
-            parameters.ClientRebalanceInterval = defaultRebalanceInterval;
-
-        if (parameters.GracefulCloseOnSwitchTimeout <= 0)
-            parameters.GracefulCloseOnSwitchTimeout = defaultGracefulCloseOnSwitchTimeout;
-
-        if (parameters.HealthcheckTimeout <= 0)
-            parameters.HealthcheckTimeout = defaultHealthcheckTimeout;
-
-        if (parameters.NodeDialTimeout <= 0)
-            parameters.NodeDialTimeout = defaultDialTimeout;
-
-        if (parameters.NodeStreamTimeout <= 0)
-            parameters.NodeStreamTimeout = defaultStreamTimeout;
-
-        if (parameters.SessionExpirationDuration == 0)
-            parameters.SessionExpirationDuration = defaultSessionTokenExpirationDuration;
-
-        parameters.ClientBuilder ??= new Func<string, ClientWrapper>((address) =>
-            {
-                var wrapperPrm = new WrapperPrm()
-                {
-                    Address = address,
-                    Key = parameters.Key!,
-                    Logger = parameters.Logger,
-                    DialTimeout = parameters.NodeDialTimeout,
-                    StreamTimeout = parameters.NodeStreamTimeout,
-                    ErrorThreshold = parameters.ErrorThreshold,
-                    GracefulCloseOnSwitchTimeout = parameters.GracefulCloseOnSwitchTimeout,
-                    Callback = parameters.Callback,
-                    Interceptors = parameters.Interceptors,
-                    GrpcChannelFactory = parameters.GrpcChannelFactory
-
-                };
-
-                return new ClientWrapper(wrapperPrm, pool);
-            }
-        );
-    }
-
-    private ClientWrapper Connection()
-    {
-        foreach (var pool in InnerPools!)
-        {
-            var client = pool.Connection();
-            if (client != null)
-            {
-                return client;
-            }
-        }
-
-        throw new FrostFsException("Cannot find alive client");
-    }
-
-    private static async Task<FrostFsSessionToken> InitSessionForDuration(CallContext ctx, ClientWrapper cw, ulong duration, ECDsa key, bool clientCut)
-    {
-        var client = cw.Client;
-        var networkInfo = await client!.GetNetworkSettingsAsync(ctx).ConfigureAwait(false);
-
-        var epoch = networkInfo.Epoch;
-
-        ulong exp = ulong.MaxValue - epoch < duration
-            ? ulong.MaxValue
-            : epoch + duration;
-
-        var prmSessionCreate = new PrmSessionCreate(exp);
-
-        return await client.CreateSessionAsync(prmSessionCreate, ctx).ConfigureAwait(false);
-    }
-
-    internal static string FormCacheKey(string address, string key)
-    {
-        return $"{address}{key}";
-    }
-
-    public void Close()
-    {
-        CancellationTokenSource.Cancel();
-
-        //if (InnerPools != null)
-        //{
-        //    // close all clients
-        //    foreach (var innerPool in InnerPools)
-        //        foreach (var client in innerPool.Clients)
-        //            if (client.IsDialed())
-        //                client.Client?.Close();
-        //}
-    }
-
-    // startRebalance runs loop to monitor connection healthy status.
-    internal void StartRebalance(CallContext ctx)
-    {
-        var buffers = new double[RebalanceParams.NodesParams.Length][];
-
-        for (int i = 0; i < RebalanceParams.NodesParams.Length; i++)
-        {
-            var parameters = RebalanceParams.NodesParams[i];
-            buffers[i] = new double[parameters.Weights.Count];
-
-            Task.Run(async () =>
-            {
-                await Task.Delay((int)RebalanceParams.ClientRebalanceInterval).ConfigureAwait(false);
-                UpdateNodesHealth(ctx, buffers);
-            });
-        }
-    }
-
-    private void UpdateNodesHealth(CallContext ctx, double[][] buffers)
-    {
-        var tasks = new Task[InnerPools!.Length];
-
-        for (int i = 0; i < InnerPools.Length; i++)
-        {
-            var bufferWeights = buffers[i];
-
-            tasks[i] = Task.Run(() => UpdateInnerNodesHealth(ctx, i, bufferWeights));
-        }
-
-        Task.WaitAll(tasks);
-    }
-
-    private async ValueTask UpdateInnerNodesHealth(CallContext ctx, int poolIndex, double[] bufferWeights)
-    {
-        if (poolIndex > InnerPools!.Length - 1)
-        {
-            return;
-        }
-
-        var pool = InnerPools[poolIndex];
-
-        var options = RebalanceParams;
-
-        int healthyChanged = 0;
-
-        var tasks = new Task[pool.Clients.Length];
-
-        for (int j = 0; j < pool.Clients.Length; j++)
-        {
-            var client = pool.Clients[j];
-            var healthy = false;
-            string? error = null;
-            var changed = false;
-
-            try
-            {
-                // check timeout settings
-                changed = await client!.RestartIfUnhealthy(ctx).ConfigureAwait(false);
-                healthy = true;
-                bufferWeights[j] = options.NodesParams[poolIndex].Weights[j];
-            }
-            // TODO: specify
-            catch (FrostFsException e)
-            {
-                error = e.Message;
-                bufferWeights[j] = 0;
-
-                SessionCache.DeleteByPrefix(client.Address);
-            }
-
-            if (changed)
-            {
-                if (!string.IsNullOrEmpty(error))
-                {
-                    if (logger != null)
-                    {
-                        FrostFsMessages.HealthChanged(logger, client.Address, healthy, error!);
-                    }
-
-                    Interlocked.Exchange(ref healthyChanged, 1);
-                }
-            }
-
-            await Task.WhenAll(tasks).ConfigureAwait(false);
-
-            if (Interlocked.CompareExchange(ref healthyChanged, -1, -1) == 1)
-            {
-                var probabilities = AdjustWeights(bufferWeights);
-
-                lock (_lock)
-                {
-                    pool.Sampler = new Sampler(probabilities);
-                }
-            }
-        }
-    }
-
-
-    // TODO: remove
-    private bool CheckSessionTokenErr(Exception error, string address)
-    {
-        if (error == null)
-        {
-            return false;
-        }
-
-        if (error is SessionNotFoundException || error is SessionExpiredException)
-        {
-            this.SessionCache.DeleteByPrefix(address);
-            return true;
-        }
-
-        return false;
-    }
-
-    public Statistic Statistic()
-    {
-        if (InnerPools == null)
-        {
-            throw new FrostFsInvalidObjectException(nameof(Pool));
-        }
-
-        var statistics = new Statistic();
-
-        foreach (var inner in InnerPools)
-        {
-            int valueIndex = 0;
-            var nodes = new string[inner.Clients.Length];
-
-            lock (_lock)
-            {
-                foreach (var client in inner.Clients)
-                {
-                    if (client.IsHealthy())
-                    {
-                        nodes[valueIndex] = client.Address;
-                    }
-
-                    var node = new NodeStatistic
-                    {
-                        Address = client.Address,
-                        Methods = client.MethodsStatus(),
-                        OverallErrors = client.GetOverallErrorRate(),
-                        CurrentErrors = client.GetCurrentErrorRate()
-                    };
-
-                    statistics.Nodes.Add(node);
-
-                    valueIndex++;
-
-                    statistics.OverallErrors += node.OverallErrors;
-                }
-
-                if (statistics.CurrentNodes == null || statistics.CurrentNodes.Length == 0)
-                {
-                    statistics.CurrentNodes = nodes;
-                }
-            }
-        }
-
-        return statistics;
-    }
-
-    public async Task<FrostFsNetmapSnapshot> GetNetmapSnapshotAsync(CallContext ctx)
-    {
-        var client = Connection();
-
-        return await client.Client!.GetNetmapSnapshotAsync(ctx).ConfigureAwait(false);
-    }
-
-    public async Task<FrostFsNodeInfo> GetNodeInfoAsync(CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.GetNodeInfoAsync(ctx).ConfigureAwait(false);
-    }
-
-    public async Task<NetworkSettings> GetNetworkSettingsAsync(CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.GetNetworkSettingsAsync(ctx).ConfigureAwait(false);
-    }
-
-    public async Task<FrostFsSessionToken> CreateSessionAsync(PrmSessionCreate args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.CreateSessionAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<ReadOnlyMemory<byte>> AddChainAsync(PrmApeChainAdd args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.AddChainAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task RemoveChainAsync(PrmApeChainRemove args, CallContext ctx)
-    {
-        var client = Connection();
-        await client.Client!.RemoveChainAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<Chain[]> ListChainAsync(PrmApeChainList args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.ListChainAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<FrostFsContainerInfo> GetContainerAsync(PrmContainerGet args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.GetContainerAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public IAsyncEnumerable<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll args, CallContext ctx)
-    {
-        var client = Connection();
-        return client.Client!.ListContainersAsync(args, ctx);
-    }
-
-    public async Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.CreateContainerAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx)
-    {
-        var client = Connection();
-        await client.Client!.DeleteContainerAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<FrostFsHeaderResult> GetObjectHeadAsync(PrmObjectHeadGet args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.GetObjectHeadAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<FrostFsObject> GetObjectAsync(PrmObjectGet args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.GetObjectAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<IObjectWriter> PutObjectAsync(PrmObjectPut args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.PutObjectAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<FrostFsObjectId> PutClientCutObjectAsync(PrmObjectClientCutPut args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.PutClientCutObjectAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<FrostFsObjectId> PutSingleObjectAsync(PrmSingleObjectPut args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.PutSingleObjectAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<FrostFsObjectId> PatchObjectAsync(PrmObjectPatch args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.PatchObjectAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<RangeReader> GetRangeAsync(PrmRangeGet args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.GetRangeAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<ReadOnlyMemory<byte>[]> GetRangeHashAsync(PrmRangeHashGet args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.GetRangeHashAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task<FrostFsObjectId> PatchAsync(PrmObjectPatch args, CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.PatchObjectAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public async Task DeleteObjectAsync(PrmObjectDelete args, CallContext ctx)
-    {
-        var client = Connection();
-        await client.Client!.DeleteObjectAsync(args, ctx).ConfigureAwait(false);
-    }
-
-    public IAsyncEnumerable<FrostFsObjectId> SearchObjectsAsync(PrmObjectSearch args, CallContext ctx)
-    {
-        var client = Connection();
-        return client.Client!.SearchObjectsAsync(args, ctx);
-    }
-
-    public async Task<Accounting.Decimal> GetBalanceAsync(CallContext ctx)
-    {
-        var client = Connection();
-        return await client.Client!.GetBalanceAsync(ctx).ConfigureAwait(false);
-    }
-
-    protected virtual void Dispose(bool disposing)
-    {
-        if (!disposedValue)
-        {
-            if (disposing)
-            {
-                Close();
-            }
-
-            disposedValue = true;
-        }
-    }
-
-    public void Dispose()
-    {
-        Dispose(disposing: true);
-    }
-}

src/FrostFS.SDK.Client/Pool/RebalanceParameters.cs

@@ -1,16 +0,0 @@
-namespace FrostFS.SDK.Client;
-
-public class RebalanceParameters(
-    NodesParam[] nodesParams,
-    ulong nodeRequestTimeout,
-    ulong clientRebalanceInterval,
-    ulong sessionExpirationDuration)
-{
-    public NodesParam[] NodesParams { get; set; } = nodesParams;
-
-    public ulong NodeRequestTimeout { get; set; } = nodeRequestTimeout;
-
-    public ulong ClientRebalanceInterval { get; set; } = clientRebalanceInterval;
-
-    public ulong SessionExpirationDuration { get; set; } = sessionExpirationDuration;
-}

src/FrostFS.SDK.Client/Pool/RequestInfo.cs

@@ -1,14 +0,0 @@
-using System;
-
-namespace FrostFS.SDK.Client;
-
-// RequestInfo groups info about pool request.
-struct RequestInfo
-{
-    public string Address { get; set; }
-
-    public MethodIndex MethodIndex { get; set; }
-
-    public TimeSpan Elapsed { get; set; }
-}
-

src/FrostFS.SDK.Client/Pool/Sampler.cs

@@ -1,85 +0,0 @@
-using System;
-
-namespace FrostFS.SDK.Client;
-
-internal sealed class Sampler
-{
-    private readonly object _lock = new();
-
-    private Random random = new();
-
-    internal double[] Probabilities { get; set; }
-    internal int[] Alias { get; set; }
-
-    internal Sampler(double[] probabilities)
-    {
-        var small = new WorkList();
-        var large = new WorkList();
-
-        var n = probabilities.Length;
-
-        //  sampler.randomGenerator = rand.New(source)
-        Probabilities = new double[n];
-        Alias = new int[n];
-
-        // Compute scaled probabilities.
-        var p = new double[n];
-
-        for (int i = 0; i < n; i++)
-        {
-            p[i] = probabilities[i] * n;
-            if (p[i] < 1)
-                small.Add(i);
-            else
-                large.Add(i);
-        }
-
-        while (small.Length > 0 && large.Length > 0)
-        {
-            var l = small.Remove();
-            var g = large.Remove();
-
-            Probabilities[l] = p[l];
-            Alias[l] = g;
-
-            p[g] = p[g] + p[l] - 1;
-
-            if (p[g] < 1)
-                small.Add(g);
-            else
-                large.Add(g);
-        }
-
-        while (large.Length > 0)
-        {
-            var g = large.Remove();
-            Probabilities[g] = 1;
-        }
-
-        while (small.Length > 0)
-        {
-            var l = small.Remove();
-            probabilities[l] = 1;
-        }
-    }
-
-    internal int Next()
-    {
-        var n = Alias.Length;
-
-        int i;
-        double f;
-        lock (_lock)
-        {
-            i = random.Next(0, n - 1);
-            f = random.NextDouble();
-        }
-
-        if (f < Probabilities[i])
-        {
-            return i;
-        }
-
-        return Alias[i];
-    }
-}

src/FrostFS.SDK.Client/Pool/Statistic.cs

@@ -1,12 +0,0 @@
-using System.Collections.ObjectModel;
-
-namespace FrostFS.SDK.Client;
-
-public sealed class Statistic
-{
-    public ulong OverallErrors { get; internal set; }
-
-    public Collection<NodeStatistic> Nodes { get; } = [];
-
-    public string[]? CurrentNodes { get; internal set; }
-}

src/FrostFS.SDK.Client/Pool/StatusSnapshot.cs

@@ -1,8 +0,0 @@
-namespace FrostFS.SDK.Client;
-
-public class StatusSnapshot()
-{
-    public ulong AllTime { get; internal set; }
-
-    public ulong AllRequests { get; internal set; }
-}

src/FrostFS.SDK.Client/Pool/WorkList.cs

@@ -1,26 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-
-namespace FrostFS.SDK.Client;
-
-internal sealed class WorkList
-{
-    private readonly List<int> elements = [];
-
-    internal int Length
-    {
-        get { return elements.Count; }
-    }
-
-    internal void Add(int element)
-    {
-        elements.Add(element);
-    }
-
-    internal int Remove()
-    {
-        int last = elements.LastOrDefault();
-        elements.RemoveAt(elements.Count - 1);
-        return last;
-    }
-}

src/FrostFS.SDK.Client/Pool/WrapperPrm.cs

@@ -1,39 +0,0 @@
-using System;
-using System.Collections.ObjectModel;
-using System.Security.Cryptography;
-
-using Grpc.Core;
-using Grpc.Core.Interceptors;
-
-using Microsoft.Extensions.Logging;
-
-namespace FrostFS.SDK.Client;
-
-[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1815:Override equals and operator equals on value types", Justification = "<Pending>")]
-public struct WrapperPrm
-{
-    internal ILogger? Logger { get; set; }
-
-    internal string Address { get; set; }
-
-    internal ECDsa Key { get; set; }
-
-    internal ulong DialTimeout { get; set; }
-
-    internal ulong StreamTimeout { get; set; }
-
-    internal uint ErrorThreshold { get; set; }
-
-    internal Action ResponseInfoCallback { get; set; }
-
-    internal Action PoolRequestInfoCallback { get; set; }
-
-    internal Func<string, ChannelBase> GrpcChannelFactory { get; set; }
-
-    internal ulong GracefulCloseOnSwitchTimeout { get; set; }
-
-    internal Action<CallStatistics>? Callback { get; set; }
-
-    internal Collection<Interceptor>? Interceptors { get; set; }
-}
-

src/FrostFS.SDK.Client/Services/AccountingServiceProvider.cs

@@ -27,7 +27,7 @@ internal sealed class AccountingServiceProvider : ContextAccessor
         };
 
         request.AddMetaHeader([]);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await _accountingServiceClient!.BalanceAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 

src/FrostFS.SDK.Client/Services/ApeManagerServiceProvider.cs

@@ -1,8 +1,8 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
-
-using Frostfs.V2.Ape;
 using Frostfs.V2.Apemanager;
+using Google.Protobuf;
 
 namespace FrostFS.SDK.Client.Services;
 
@@ -18,17 +18,19 @@ internal sealed class ApeManagerServiceProvider : ContextAccessor
 
     internal async Task<ReadOnlyMemory<byte>> AddChainAsync(PrmApeChainAdd args, CallContext ctx)
     {
+        var binary = RuleSerializer.Serialize(args.Chain);
+
         AddChainRequest request = new()
         {
             Body = new()
             {
-                Chain = new() { Raw = args.Chain.GetRaw() },
+                Chain = new() { Raw = UnsafeByteOperations.UnsafeWrap(binary) },
                 Target = args.Target.GetChainTarget()
             }
         };
 
         request.AddMetaHeader(args.XHeaders);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await _apeManagerServiceClient!.AddChainAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
@@ -43,20 +45,20 @@ internal sealed class ApeManagerServiceProvider : ContextAccessor
         {
             Body = new()
             {
-                ChainId = args.Chain.GetRaw(),
+                ChainId = UnsafeByteOperations.UnsafeWrap(args.ChainId),
                 Target = args.Target.GetChainTarget()
             }
         };
 
         request.AddMetaHeader(args.XHeaders);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await _apeManagerServiceClient!.RemoveChainAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
         Verifier.CheckResponse(response);
     }
 
-    internal async Task<Chain[]> ListChainAsync(PrmApeChainList args, CallContext ctx)
+    internal async Task<FrostFsChain[]> ListChainAsync(PrmApeChainList args, CallContext ctx)
     {
         ListChainsRequest request = new()
         {
@@ -67,12 +69,12 @@ internal sealed class ApeManagerServiceProvider : ContextAccessor
         };
 
         request.AddMetaHeader(args.XHeaders);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await _apeManagerServiceClient!.ListChainsAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
         Verifier.CheckResponse(response);
 
-        return [.. response.Body.Chains];
+        return [.. response.Body.Chains.Select(c => RuleSerializer.Deserialize([.. c.Raw]))];
     }
 }

src/FrostFS.SDK.Client/Services/ContainerServiceProvider.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Security.Cryptography;
 using System.Threading.Tasks;
 
 using FrostFS.Container;
@@ -39,7 +38,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
 
     internal async Task<FrostFsContainerInfo> GetContainerAsync(PrmContainerGet args, CallContext ctx)
     {
-        GetRequest request = GetContainerRequest(args.Container.ContainerID, args.XHeaders, ClientContext.Key.ECDsaKey);
+        GetRequest request = GetContainerRequest(args.Container.GetContainerID(), args.XHeaders, ClientContext.Key);
 
         var response = await service.GetAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
@@ -59,7 +58,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
         };
 
         request.AddMetaHeader(args.XHeaders);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await service.ListAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
@@ -71,7 +70,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
         }
     }
 
-    internal async Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx)
+    internal async Task<FrostFsContainerId> PutContainerAsync(PrmContainerCreate args, CallContext ctx)
     {
         var grpcContainer = args.Container.GetContainer();
 
@@ -83,7 +82,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
             Body = new PutRequest.Types.Body
             {
                 Container = grpcContainer,
-                Signature = ClientContext.Key.ECDsaKey.SignRFC6979(grpcContainer)
+                Signature = ClientContext.Key.SignRFC6979(grpcContainer)
             }
         };
 
@@ -96,7 +95,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
 
         request.AddMetaHeader(args.XHeaders, protoToken);
 
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await service.PutAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
@@ -113,8 +112,8 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
         {
             Body = new DeleteRequest.Types.Body
             {
-                ContainerId = args.ContainerId.ToMessage(),
-                Signature = ClientContext.Key.ECDsaKey.SignRFC6979(args.ContainerId.ToMessage().Value)
+                ContainerId = args.ContainerId.GetContainerID(),
+                Signature = ClientContext.Key.SignRFC6979(args.ContainerId.GetContainerID().Value)
             }
         };
 
@@ -127,7 +126,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
 
         request.AddMetaHeader(args.XHeaders, protoToken);
 
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await service.DeleteAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
@@ -139,7 +138,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
         Verifier.CheckResponse(response);
     }
 
-    private static GetRequest GetContainerRequest(ContainerID id, string[] xHeaders, ECDsa key)
+    private static GetRequest GetContainerRequest(ContainerID id, string[] xHeaders, ClientKey key)
     {
         var request = new GetRequest
         {
@@ -163,7 +162,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
 
     private async Task WaitForContainer(WaitExpects expect, ContainerID id, PrmWait waitParams, CallContext ctx)
     {
-        var request = GetContainerRequest(id, [], ClientContext.Key.ECDsaKey);
+        var request = GetContainerRequest(id, [], ClientContext.Key);
 
         async Task action()
         {

src/FrostFS.SDK.Client/Services/NetmapServiceProvider.cs

@@ -50,7 +50,7 @@ internal sealed class NetmapServiceProvider : ContextAccessor
         };
 
         request.AddMetaHeader([]);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await netmapServiceClient.LocalNodeInfoAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
@@ -64,7 +64,7 @@ internal sealed class NetmapServiceProvider : ContextAccessor
         var request = new NetworkInfoRequest();
 
         request.AddMetaHeader([]);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await netmapServiceClient.NetworkInfoAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken)
             .ConfigureAwait(false);
@@ -79,7 +79,7 @@ internal sealed class NetmapServiceProvider : ContextAccessor
         var request = new NetmapSnapshotRequest();
 
         request.AddMetaHeader([]);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await netmapServiceClient.NetmapSnapshotAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 

src/FrostFS.SDK.Client/Services/ObjectServiceProvider.cs

@@ -10,7 +10,6 @@ using FrostFS.Refs;
 using FrostFS.SDK.Client;
 using FrostFS.SDK.Client.Interfaces;
 using FrostFS.SDK.Client.Mappers.GRPC;
-using FrostFS.SDK.Cryptography;
 using FrostFS.Session;
 
 using Google.Protobuf;
@@ -52,7 +51,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
             {
                 Address = new Address
                 {
-                    ContainerId = args.ContainerId.ContainerID,
+                    ContainerId = args.ContainerId.GetContainerID(),
                     ObjectId = args.ObjectId.ToMessage()
                 },
                 Raw = args.Raw
@@ -68,7 +67,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
 
         request.AddMetaHeader(args.XHeaders, protoToken);
 
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await client!.HeadAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken).ConfigureAwait(false);
 
@@ -97,7 +96,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
             {
                 Address = new Address
                 {
-                    ContainerId = args.ContainerId.ToMessage(),
+                    ContainerId = args.ContainerId.GetContainerID(),
                     ObjectId = args.ObjectId.ToMessage()
                 }
             }
@@ -112,7 +111,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
 
         request.AddMetaHeader(args.XHeaders, protoToken);
 
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         return await GetObject(request, ctx).ConfigureAwait(false);
     }
@@ -125,7 +124,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
             {
                 Address = new Address
                 {
-                    ContainerId = args.ContainerId.ToMessage(),
+                    ContainerId = args.ContainerId.GetContainerID(),
                     ObjectId = args.ObjectId.ToMessage()
                 },
                 Range = new Object.Range
@@ -146,7 +145,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
 
         request.AddMetaHeader(args.XHeaders, protoToken);
 
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var call = client.GetRange(request, null, ctx.GetDeadline(), ctx.CancellationToken);
         return new RangeReader(call);
@@ -160,7 +159,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
             {
                 Address = new Address
                 {
-                    ContainerId = args.ContainerId.ToMessage(),
+                    ContainerId = args.ContainerId.GetContainerID(),
                     ObjectId = args.ObjectId.ToMessage()
                 },
                 Type = ChecksumType.Sha256,
@@ -186,7 +185,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
 
         request.AddMetaHeader(args.XHeaders, protoToken);
 
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await client.GetRangeHashAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
@@ -205,7 +204,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
             {
                 Address = new Address
                 {
-                    ContainerId = args.ContainerId.ToMessage(),
+                    ContainerId = args.ContainerId.GetContainerID(),
                     ObjectId = args.ObjectId.ToMessage()
                 }
             }
@@ -219,7 +218,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
             ClientContext.Key);
 
         request.AddMetaHeader(args.XHeaders, protoToken);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await client.DeleteAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);
 
@@ -232,7 +231,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
         {
             Body = new SearchRequest.Types.Body
             {
-                ContainerId = args.ContainerId.ToMessage(),
+                ContainerId = args.ContainerId.GetContainerID(),
                 Version = 1  // TODO: clarify this param
             }
         };
@@ -248,7 +247,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
 
         request.AddMetaHeader(args.XHeaders, protoToken);
 
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         using var stream = GetSearchReader(request, ctx);
 
@@ -268,7 +267,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
 
     internal async Task<FrostFsObjectId> PutSingleObjectAsync(PrmSingleObjectPut args, CallContext ctx)
     {
-        var grpcObject = ObjectTools.CreateObject(args.FrostFsObject, ClientContext);
+        var grpcObject = ObjectTools.CreateSingleObject(args.FrostFsObject, ClientContext);
 
         var request = new PutSingleRequest
         {
@@ -278,13 +277,13 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
         var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);
 
         var protoToken = sessionToken.CreateObjectTokenContext(
-            new Address { ContainerId = grpcObject.Header.ContainerId, ObjectId = grpcObject.ObjectId },
+            new Address { ContainerId = grpcObject.Header.ContainerId },
             ObjectSessionContext.Types.Verb.Put,
             ClientContext.Key);
 
         request.AddMetaHeader(args.XHeaders, protoToken);
 
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         var response = await client.PutSingleAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken).ConfigureAwait(false);
 
@@ -303,34 +302,17 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
         byte[]? chunkBuffer = null;
         try
         {
-            // common 
             chunkBuffer = ArrayPool<byte>.Shared.Rent(chunkSize);
 
+            bool isFirstChunk = true;
+            ulong currentPos = args.Range.Offset;
+
             var address = new Address
             {
                 ObjectId = args.Address.ObjectId,
                 ContainerId = args.Address.ContainerId
             };
 
-            var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);
-
-            var protoToken = sessionToken.CreateObjectTokenContext(
-                address,
-                ObjectSessionContext.Types.Verb.Patch,
-                ClientContext.Key);
-
-            var request = new PatchRequest()
-            {
-                Body = new()
-                {
-                    Address = address,
-                    ReplaceAttributes = args.ReplaceAttributes,
-                }
-            };
-
-            bool isFirstChunk = true;
-            ulong currentPos = args.Range.Offset;
-
             while (true)
             {
                 var bytesCount = await payload.ReadAsync(chunkBuffer, 0, chunkSize, ctx.CancellationToken).ConfigureAwait(false);
@@ -340,41 +322,62 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
                     break;
                 }
 
-                if (isFirstChunk && args.NewAttributes != null && args.NewAttributes.Length > 0)
+                var request = new PatchRequest()
                 {
-                    foreach (var attr in args.NewAttributes)
+                    Body = new()
                     {
-                        request.Body.NewAttributes.Add(attr.ToMessage());
+                        Address = address,
+                        Patch = new PatchRequest.Types.Body.Types.Patch
+                        {
+                            Chunk = UnsafeByteOperations.UnsafeWrap(chunkBuffer.AsMemory(0, bytesCount)),
+                            SourceRange = new Range { Offset = currentPos, Length = (ulong)bytesCount }
+                        }
                     }
-                }
-
-                request.Body.Patch = new PatchRequest.Types.Body.Types.Patch
-                {
-                    Chunk = ByteString.CopyFrom(chunkBuffer, 0, bytesCount),
-                    SourceRange = new Object.Range { Offset = currentPos, Length = (ulong)bytesCount }
                 };
 
-                currentPos += (ulong)bytesCount;
+                if (isFirstChunk)
+                {
+                    var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);
 
-                request.AddMetaHeader(args.XHeaders, protoToken);
+                    var protoToken = sessionToken.CreateObjectTokenContext(
+                        address,
+                        ObjectSessionContext.Types.Verb.Patch,
+                        ClientContext.Key);
 
-                request.Sign(ClientContext.Key.ECDsaKey);
+                    request.AddMetaHeader(args.XHeaders, protoToken);
+
+                    if (args.NewAttributes != null && args.NewAttributes.Length > 0)
+                    {
+                        foreach (var attr in args.NewAttributes)
+                        {
+                            request.Body.NewAttributes.Add(attr.ToMessage());
+                            request.Body.ReplaceAttributes = args.ReplaceAttributes;
+                        }
+                    }
+
+                    isFirstChunk = false;
+                }
+                else
+                {
+                    request.AddMetaHeader(args.XHeaders);
+                }
+
+                request.Sign(ClientContext.Key);
 
                 await call.RequestStream.WriteAsync(request).ConfigureAwait(false);
 
-                isFirstChunk = false;
+                currentPos += (ulong)bytesCount;
             }
         }
         finally
         {
-            await call.RequestStream.CompleteAsync().ConfigureAwait(false);
-
             if (chunkBuffer != null)
             {
                 ArrayPool<byte>.Shared.Return(chunkBuffer);
             }
         }
 
+        await call.RequestStream.CompleteAsync().ConfigureAwait(false);
         var response = await call.ResponseAsync.ConfigureAwait(false);
 
         Verifier.CheckResponse(response);
@@ -384,83 +387,128 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
 
     internal async Task<FrostFsObjectId> PutClientCutObjectAsync(PrmObjectClientCutPut args, CallContext ctx)
     {
-        var payloadStream = args.Payload!;
+        var stream = args.Payload!;
         var header = args.Header!;
 
         if (header.PayloadLength > 0)
             args.PutObjectContext.FullLength = header.PayloadLength;
-        else if (payloadStream.CanSeek)
-            args.PutObjectContext.FullLength = (ulong)payloadStream.Length;
+        else if (stream.CanSeek)
+            args.PutObjectContext.FullLength = (ulong)stream.Length;
         else
             throw new ArgumentException("The stream does not have a length and payload length is not defined");
 
-        if (args.PutObjectContext.MaxObjectSizeCache == 0)
-        {
-            var networkSettings = await ClientContext.Client.GetNetworkSettingsAsync(ctx)
-                .ConfigureAwait(false);
+        if (args.PutObjectContext.FullLength == 0)
+            throw new ArgumentException("The stream has zero length");
 
-            args.PutObjectContext.MaxObjectSizeCache = (int)networkSettings.MaxObjectSize;
+        var networkSettings = await ClientContext.Client.GetNetworkSettingsAsync(ctx).ConfigureAwait(false);
+        var partSize = (int)networkSettings.MaxObjectSize;
+
+        var restBytes = args.PutObjectContext.FullLength;
+
+        var objectSize = (int)Math.Min((ulong)partSize, restBytes);
+
+        // define collection capacity
+        var objectsCount = (int)(restBytes / (ulong)objectSize) + ((restBytes % (ulong)objectSize) > 0 ? 1 : 0);
+
+        // if the object fits one part, it can be loaded as non-complex object
+        if (objectsCount == 1)
+        {
+            args.PutObjectContext.MaxObjectSizeCache = partSize;
+            var singlePartResult = await PutMultipartStreamObjectAsync(args, default).ConfigureAwait(false);
+            return singlePartResult.ObjectId;
         }
 
-        var restBytes = args.PutObjectContext.FullLength - args.PutObjectContext.CurrentStreamPosition;
-        var objectSize = restBytes > 0 ? (int)Math.Min((ulong)args.PutObjectContext.MaxObjectSizeCache, restBytes) : args.PutObjectContext.MaxObjectSizeCache;
+        List<FrostFsObjectId> parts = new(objectsCount);
 
-        //define collection capacity
-        var restPart = (restBytes % (ulong)objectSize) > 0 ? 1 : 0;
-        var objectsCount = args.PutObjectContext.FullLength > 0 ? (int)(restBytes / (ulong)objectSize) + restPart : 0;
-
-        List<FrostFsObjectId> sentObjectIds = new(objectsCount);
-
-        FrostFsSplit? split = null;
         SplitId splitId = new();
 
         // keep attributes for the large object
-        var attributes = args.Header!.Attributes;
-        args.Header!.Attributes = null;
+        var attributes = args.Header!.Attributes.ToArray();
+        header.Attributes = null;
 
-        // send all parts except the last one as separate Objects
-        while (restBytes > (ulong)args.PutObjectContext.MaxObjectSizeCache)
+        var remain = args.PutObjectContext.FullLength;
+
+        FrostFsObjectHeader? parentHeader = null;
+
+        var lastIndex = objectsCount - 1;
+
+        bool rentBuffer = false;
+        byte[]? buffer = null;
+
+        try
         {
-            split = new FrostFsSplit(splitId, sentObjectIds.LastOrDefault());
-
-            args.Header!.Split = split;
-
-            var result = await PutMultipartStreamObjectAsync(args, default).ConfigureAwait(false);
-
-            sentObjectIds.Add(result.ObjectId);
-
-            restBytes -= (ulong)result.ObjectSize;
-        }
-
-        // send the last part and create linkObject
-        if (sentObjectIds.Count > 0)
-        {
-            var largeObjectHeader = new FrostFsObjectHeader(header.ContainerId, FrostFsObjectType.Regular, [.. attributes])
+            for (int i = 0; i < objectsCount; i++)
             {
-                PayloadLength = args.PutObjectContext.FullLength,
-            };
+                if (args.CustomBuffer != null)
+                {
+                    if (args.CustomBuffer.Length < partSize)
+                    {
+                        throw new ArgumentException($"Buffer size is too small. A buffer with capacity {partSize} is required");
+                    }
 
-            args.Header.Split!.ParentHeader = largeObjectHeader;
+                    buffer = args.CustomBuffer;
+                }
+                else
+                {
+                    buffer = ArrayPool<byte>.Shared.Rent(partSize);
+                    rentBuffer = true;
+                }
 
-            var result = await PutMultipartStreamObjectAsync(args, default).ConfigureAwait(false);
+                var bytesToWrite = Math.Min((ulong)partSize, remain);
 
-            sentObjectIds.Add(result.ObjectId);
+                var size = await stream.ReadAsync(buffer, 0, (int)bytesToWrite).ConfigureAwait(false);
 
-            var linkObject = new FrostFsLinkObject(header.ContainerId, split!.SplitId, largeObjectHeader, sentObjectIds);
+                if (i == lastIndex)
+                {
+                    parentHeader = new FrostFsObjectHeader(header.ContainerId, FrostFsObjectType.Regular, attributes)
+                    {
+                        PayloadLength = args.PutObjectContext.FullLength
+                    };
+                }
 
-            _ = await PutSingleObjectAsync(new PrmSingleObjectPut(linkObject), ctx).ConfigureAwait(false);
+                // Uploading the next part of the object. Note: the request must contain a non-null SplitId parameter
+                var partHeader = new FrostFsObjectHeader(
+                    header.ContainerId,
+                    FrostFsObjectType.Regular,
+                    [],
+                    new FrostFsSplit(splitId, parts.LastOrDefault(),
+                    parentHeader: parentHeader))
+                {
+                    PayloadLength = (ulong)size
+                };
 
-            var parentHeader = args.Header.GetHeader();
+                var obj = new FrostFsObject(partHeader)
+                {
+                    SingleObjectPayload = buffer.AsMemory(0, size)
+                };
 
-            return parentHeader.Split!.Parent.ToModel();
+                var prm = new PrmSingleObjectPut(obj);
+
+                var objId = await PutSingleObjectAsync(prm, ctx).ConfigureAwait(false);
+
+                parts.Add(objId);
+
+                if (i < lastIndex)
+                    continue;
+
+                // Once all parts of the object are uploaded, they must be linked into a single entity
+                var linkObject = new FrostFsLinkObject(header.ContainerId, splitId, parentHeader!, parts);
+
+                _ = await PutSingleObjectAsync(new PrmSingleObjectPut(linkObject), ctx).ConfigureAwait(false);
+
+                // Retrieve the ID of the linked object
+                return partHeader.GetHeader().Split!.Parent.ToModel();
+            }
+
+            throw new FrostFsException("Unexpected error");
+        }
+        finally
+        {
+            if (rentBuffer && buffer != null)
+            {
+                ArrayPool<byte>.Shared.Return(buffer);
+            }
         }
-
-        // We are here if the payload is placed to one Object. It means no cut action, just simple PUT.
-        args.Header!.Attributes = attributes;
-
-        var singlePartResult = await PutMultipartStreamObjectAsync(args, default).ConfigureAwait(false);
-
-        return singlePartResult.ObjectId;
     }
 
     struct PutObjectResult(FrostFsObjectId objectId, int objectSize)
@@ -474,7 +522,6 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
         var payload = args.Payload!;
 
         var chunkSize = args.BufferMaxSize > 0 ? args.BufferMaxSize : Constants.ObjectChunkSize;
-
         var restBytes = args.PutObjectContext.FullLength - args.PutObjectContext.CurrentStreamPosition;
 
         chunkSize = (int)Math.Min(restBytes, (ulong)chunkSize);
@@ -510,7 +557,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
             {
                 // send chunks limited to default or user's settings
                 var bufferSize = objectLimitSize > 0 ?
-                    (int)Math.Min(objectLimitSize - sentBytes, chunkSize)
+                    Math.Min(objectLimitSize - sentBytes, chunkSize)
                     : chunkSize;
 
                 var bytesCount = await payload.ReadAsync(chunkBuffer, 0, bufferSize, ctx.CancellationToken).ConfigureAwait(false);
@@ -524,15 +571,18 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
                 {
                     Body = new PutRequest.Types.Body
                     {
-                        Chunk = ByteString.CopyFrom(chunkBuffer, 0, bytesCount)
+                        Chunk = UnsafeByteOperations.UnsafeWrap(chunkBuffer.AsMemory(0, bytesCount))
                     }
                 };
 
-                chunkRequest.Sign(ClientContext.Key.ECDsaKey);
+                chunkRequest.AddMetaHeader(args.XHeaders);
+                chunkRequest.Sign(ClientContext.Key);
 
                 await stream.Write(chunkRequest).ConfigureAwait(false);
             }
 
+            args.PutObjectContext.CurrentStreamPosition += (ulong)sentBytes;
+
             var response = await stream.Close().ConfigureAwait(false);
             Verifier.CheckResponse(response);
 
@@ -565,32 +615,30 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
 
         if (header.Split != null)
         {
-            ObjectTools.SetSplitValues(grpcHeader, header.Split, ClientContext);
+            ObjectTools.SetSplitValues(grpcHeader, header.Split, ClientContext.Owner, ClientContext.Version, ClientContext.Key);
         }
 
-        var oid = new ObjectID { Value = grpcHeader.Sha256() };
-
         var initRequest = new PutRequest
         {
             Body = new PutRequest.Types.Body
             {
                 Init = new PutRequest.Types.Body.Types.Init
                 {
-                    Header = grpcHeader
+                    Header = grpcHeader,
                 }
             }
         };
 
-        var sessionToken = (args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false));
+        var sessionToken = args.SessionToken ?? await GetDefaultSession(args, ctx).ConfigureAwait(false);
 
         var protoToken = sessionToken.CreateObjectTokenContext(
-            new Address { ContainerId = grpcHeader.ContainerId, ObjectId = oid },
+            new Address { ContainerId = grpcHeader.ContainerId },
             ObjectSessionContext.Types.Verb.Put,
             ClientContext.Key);
 
         initRequest.AddMetaHeader(args.XHeaders, protoToken);
 
-        initRequest.Sign(ClientContext.Key.ECDsaKey);
+        initRequest.Sign(ClientContext.Key);
 
         return await PutObjectInit(initRequest, ctx).ConfigureAwait(false);
     }

src/FrostFS.SDK.Client/Services/SessionServiceProvider.cs

@@ -26,7 +26,7 @@ internal sealed class SessionServiceProvider : ContextAccessor
         };
 
         request.AddMetaHeader(args.XHeaders);
-        request.Sign(ClientContext.Key.ECDsaKey);
+        request.Sign(ClientContext.Key);
 
         return await CreateSession(request, ctx).ConfigureAwait(false);
     }

src/FrostFS.SDK.Client/Services/Shared/SessionCache.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Concurrent;
+using System.Collections.Concurrent;
 
 namespace FrostFS.SDK.Client;
 
@@ -36,15 +35,4 @@ internal sealed class SessionCache(ulong sessionExpirationDuration)
             _cache[key] = value;
         }
     }
-
-    internal void DeleteByPrefix(string prefix)
-    {
-        foreach (var key in _cache.Keys)
-        {
-            if (key.StartsWith(prefix, StringComparison.Ordinal))
-            {
-                _cache.TryRemove(key, out var _);
-            }
-        }
-    }
 }

src/FrostFS.SDK.Client/Tools/ClientContext.cs

@@ -39,7 +39,7 @@ public class ClientContext(FrostFSClient client, ClientKey key, FrostFsOwner own
         {
             if (sessionKey == null && Key != null && Address != null)
             {
-                sessionKey = Pool.FormCacheKey(Address, Key.PublicKey);
+                sessionKey = $"{Address}{Key}";
             }
 
             return sessionKey;

src/FrostFS.SDK.Client/Tools/ObjectTools.cs

@@ -1,5 +1,6 @@
+using System;
 using System.Linq;
-
+using System.Security.Cryptography;
 using FrostFS.Object;
 using FrostFS.Refs;
 using FrostFS.SDK.Client.Mappers.GRPC;
@@ -9,9 +10,48 @@ using Google.Protobuf;
 
 namespace FrostFS.SDK.Client;
 
-internal static class ObjectTools
+public static class ObjectTools
 {
-    internal static Object.Object CreateObject(FrostFsObject @object, ClientContext ctx)
+    public static FrostFsObjectId CalculateObjectId(
+        FrostFsObjectHeader header,
+        ReadOnlyMemory<byte> payloadHash,
+        FrostFsOwner owner,
+        FrostFsVersion version,
+        ClientKey key)
+    {
+        if (header is null)
+        {
+            throw new ArgumentNullException(nameof(header));
+        }
+
+        if (owner is null)
+        {
+            throw new ArgumentNullException(nameof(owner));
+        }
+
+        if (version is null)
+        {
+            throw new ArgumentNullException(nameof(version));
+        }
+
+        if (key is null)
+        {
+            throw new ArgumentNullException(nameof(key));
+        }
+
+        var grpcHeader = CreateHeader(header, payloadHash, owner, version);
+
+        if (header.Split != null)
+            SetSplitValues(grpcHeader, header.Split, owner, version, key);
+
+        using var sha256 = SHA256.Create();
+        using HashStream stream = new(sha256);
+        grpcHeader.WriteTo(stream);
+
+        return new FrostFsObjectId(Base58.Encode(stream.Hash()));
+    }
+
+    internal static Object.Object CreateSingleObject(FrostFsObject @object, ClientContext ctx)
     {
         @object.Header.OwnerId ??= ctx.Owner;
         @object.Header.Version ??= ctx.Version;
@@ -19,19 +59,28 @@ internal static class ObjectTools
         var grpcHeader = @object.Header.GetHeader();
 
         grpcHeader.PayloadLength = (ulong)@object.SingleObjectPayload.Length;
-        grpcHeader.PayloadHash = Sha256Checksum(@object.SingleObjectPayload);
+
+        if (@object.PayloadHash != null)
+        {
+            grpcHeader.PayloadHash = ChecksumFromSha256(@object.PayloadHash);
+        }
+        else
+        {
+            grpcHeader.PayloadHash = Sha256Checksum(@object.SingleObjectPayload);
+        }
 
         var split = @object.Header.Split;
+
         if (split != null)
         {
-            SetSplitValues(grpcHeader, split, ctx);
+            SetSplitValues(grpcHeader, split, ctx.Owner, ctx.Version, ctx.Key);
         }
 
         var obj = new Object.Object
         {
             Header = grpcHeader,
-            ObjectId = new ObjectID { Value = grpcHeader.Sha256() },
-            Payload = ByteString.CopyFrom(@object.SingleObjectPayload)
+            ObjectId = new ObjectID { Value = UnsafeByteOperations.UnsafeWrap(grpcHeader.Sha256()) },
+            Payload = UnsafeByteOperations.UnsafeWrap(@object.SingleObjectPayload)
         };
 
         obj.Signature = new Signature
@@ -43,13 +92,22 @@ internal static class ObjectTools
         return obj;
     }
 
-    internal static void SetSplitValues(Header grpcHeader, FrostFsSplit split, ClientContext ctx)
+    internal static void SetSplitValues(
+        Header grpcHeader,
+        FrostFsSplit split,
+        FrostFsOwner owner,
+        FrostFsVersion version,
+        ClientKey key)
     {
         if (split == null)
+        {
             return;
+        }
 
-        if (ctx.Key == null)
-            throw new FrostFsInvalidObjectException(nameof(ctx.Key));
+        if (key == null)
+        {
+            throw new FrostFsInvalidObjectException(nameof(key));
+        }
 
         grpcHeader.Split = new Header.Types.Split
         {
@@ -57,43 +115,57 @@ internal static class ObjectTools
         };
 
         if (split.Children != null && split.Children.Count != 0)
+        {
             grpcHeader.Split.Children.AddRange(split.Children.Select(id => id.ToMessage()));
+        }
 
         if (split.ParentHeader is not null)
         {
-            var grpcParentHeader = CreateHeader(split.ParentHeader, [], ctx);
+            var grpcParentHeader = CreateHeader(split.ParentHeader, DataHasher.Sha256([]), owner, version);
 
-            grpcHeader.Split.Parent = new ObjectID { Value = grpcParentHeader.Sha256() };
+            grpcHeader.Split.Parent = new ObjectID { Value = UnsafeByteOperations.UnsafeWrap(grpcParentHeader.Sha256()) };
             grpcHeader.Split.ParentHeader = grpcParentHeader;
             grpcHeader.Split.ParentSignature = new Signature
             {
-                Key = ctx.Key.PublicKeyProto,
-                Sign = ctx.Key.ECDsaKey.SignData(grpcHeader.Split.Parent.ToByteArray()),
+                Key = key.PublicKeyProto,
+                Sign = key.ECDsaKey.SignData(grpcHeader.Split.Parent.ToByteArray()),
             };
         }
 
         grpcHeader.Split.Previous = split.Previous?.ToMessage();
     }
 
-    internal static Header CreateHeader(FrostFsObjectHeader header, byte[]? payload, ClientContext ctx)
+    internal static Header CreateHeader(
+        FrostFsObjectHeader header,
+        ReadOnlyMemory<byte> payloadChecksum,
+        FrostFsOwner owner,
+        FrostFsVersion version)
     {
-        header.OwnerId ??= ctx.Owner;
-        header.Version ??= ctx.Version;
+        header.OwnerId ??= owner;
+        header.Version ??= version;
 
         var grpcHeader = header.GetHeader();
 
-        if (payload != null) //  && payload.Length > 0    
-            grpcHeader.PayloadHash = Sha256Checksum(payload);
+        grpcHeader.PayloadHash = ChecksumFromSha256(payloadChecksum);
 
         return grpcHeader;
     }
 
-    internal static Checksum Sha256Checksum(byte[] data)
+    internal static Checksum Sha256Checksum(ReadOnlyMemory<byte> data)
     {
         return new Checksum
         {
             Type = ChecksumType.Sha256,
-            Sum = ByteString.CopyFrom(data.Sha256())
+            Sum = UnsafeByteOperations.UnsafeWrap(DataHasher.Sha256(data))
         };
     }
-}
+
+    internal static Checksum ChecksumFromSha256(ReadOnlyMemory<byte> dataHash)
+    {
+        return new Checksum
+        {
+            Type = ChecksumType.Sha256,
+            Sum = UnsafeByteOperations.UnsafeWrap(dataHash)
+        };
+    }
+}

src/FrostFS.SDK.Client/Tools/Range.cs

@@ -1,248 +0,0 @@
-using System.Runtime.CompilerServices;
-
-namespace System
-{
-    /// <summary>Represent a type can be used to index a collection either from the start or the end.</summary>
-    /// <remarks>
-    /// Index is used by the C# compiler to support the new index syntax
-    /// <code>
-    /// int[] someArray = new int[5] { 1, 2, 3, 4, 5 } ;
-    /// int lastElement = someArray[^1]; // lastElement = 5
-    /// </code>
-    /// </remarks>
-    internal readonly struct Index : IEquatable<Index>
-    {
-        private readonly int _value;
-
-        /// <summary>Construct an Index using a value and indicating if the index is from the start or from the end.</summary>
-        /// <param name="value">The index value. it has to be zero or positive number.</param>
-        /// <param name="fromEnd">Indicating if the index is from the start or from the end.</param>
-        /// <remarks>
-        /// If the Index constructed from the end, index value 1 means pointing at the last element and index value 0 means pointing at beyond last element.
-        /// </remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Index(int value, bool fromEnd = false)
-        {
-            if (value < 0)
-                throw new ArgumentOutOfRangeException(nameof(value), "value must be non-negative");
-
-            if (fromEnd)
-                _value = ~value;
-            else
-                _value = value;
-        }
-
-        // The following private constructors mainly created for perf reason to avoid the checks
-        private Index(int value)
-        {
-            _value = value;
-        }
-
-        /// <summary>Create an Index pointing at first element.</summary>
-        public static Index Start => new(0);
-
-        /// <summary>Create an Index pointing at beyond last element.</summary>
-        public static Index End => new(~0);
-
-        /// <summary>Create an Index from the start at the position indicated by the value.</summary>
-        /// <param name="value">The index value from the start.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Index FromStart(int value)
-        {
-            if (value < 0)
-                throw new ArgumentOutOfRangeException(nameof(value), "value must be non-negative");
-
-            return new Index(value);
-        }
-
-        /// <summary>Create an Index from the end at the position indicated by the value.</summary>
-        /// <param name="value">The index value from the end.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Index FromEnd(int value)
-        {
-            if (value < 0)
-                throw new ArgumentOutOfRangeException(nameof(value), "value must be non-negative");
-
-            return new Index(~value);
-        }
-
-        /// <summary>Returns the index value.</summary>
-        public int Value
-        {
-            get
-            {
-                return _value < 0 ? ~_value : _value;
-            }
-        }
-
-        /// <summary>Indicates whether the index is from the start or the end.</summary>
-        public bool IsFromEnd => _value < 0;
-
-        /// <summary>Calculate the offset from the start using the giving collection length.</summary>
-        /// <param name="length">The length of the collection that the Index will be used with. length has to be a positive value</param>
-        /// <remarks>
-        /// For performance reason, we don't validate the input length parameter and the returned offset value against negative values.
-        /// we don't validate either the returned offset is greater than the input length.
-        /// It is expected Index will be used with collections which always have non negative length/count. If the returned offset is negative and
-        /// then used to index a collection will get out of range exception which will be same affect as the validation.
-        /// </remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int GetOffset(int length)
-        {
-            var offset = _value;
-            if (IsFromEnd)
-            {
-                // offset = length - (~value)
-                // offset = length + (~(~value) + 1)
-                // offset = length + value + 1
-
-                offset += length + 1;
-            }
-            return offset;
-        }
-
-        /// <summary>Indicates whether the current Index object is equal to another object of the same type.</summary>
-        /// <param name="value">An object to compare with this object</param>
-        public override bool Equals(object? value) => value is Index index && _value == index._value;
-
-        /// <summary>Indicates whether the current Index object is equal to another Index object.</summary>
-        /// <param name="other">An object to compare with this object</param>
-        public bool Equals(Index other) => _value == other._value;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        public override int GetHashCode() => _value;
-
-        /// <summary>Converts integer number to an Index.</summary>
-        public static implicit operator Index(int value) => FromStart(value);
-
-        /// <summary>Converts the value of the current Index object to its equivalent string representation.</summary>
-        public override string ToString()
-        {
-            if (IsFromEnd)
-                return $"^{(uint)Value}";
-
-            return $"{(uint)Value}";
-        }
-    }
-
-    /// <summary>Represent a range has start and end indexes.</summary>
-    /// <remarks>
-    /// Range is used by the C# compiler to support the range syntax.
-    /// <code>
-    /// int[] someArray = new int[5] { 1, 2, 3, 4, 5 };
-    /// int[] subArray1 = someArray[0..2]; // { 1, 2 }
-    /// int[] subArray2 = someArray[1..^0]; // { 2, 3, 4, 5 }
-    /// </code>
-    /// </remarks>
-    /// <remarks>Construct a Range object using the start and end indexes.</remarks>
-    /// <param name="start">Represent the inclusive start index of the range.</param>
-    /// <param name="end">Represent the exclusive end index of the range.</param>
-    internal readonly struct Range(Index start, Index end) : IEquatable<Range>
-    {
-        /// <summary>Represent the inclusive start index of the Range.</summary>
-        public Index Start { get; } = start;
-
-        /// <summary>Represent the exclusive end index of the Range.</summary>
-        public Index End { get; } = end;
-
-        /// <summary>Indicates whether the current Range object is equal to another object of the same type.</summary>
-        /// <param name="value">An object to compare with this object</param>
-        public override bool Equals(object? value) =>
-            value is Range r &&
-            r.Start.Equals(Start) &&
-            r.End.Equals(End);
-
-        /// <summary>Indicates whether the current Range object is equal to another Range object.</summary>
-        /// <param name="other">An object to compare with this object</param>
-        public bool Equals(Range other) => other.Start.Equals(Start) && other.End.Equals(End);
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        public override int GetHashCode()
-        {
-            return Start.GetHashCode() * 31 + End.GetHashCode();
-        }
-
-        /// <summary>Converts the value of the current Range object to its equivalent string representation.</summary>
-        public override string ToString()
-        {
-            return Start + ".." + End;
-        }
-
-        /// <summary>Create a Range object starting from start index to the end of the collection.</summary>
-        public static Range StartAt(Index start) => new(start, Index.End);
-
-        /// <summary>Create a Range object starting from first element in the collection to the end Index.</summary>
-        public static Range EndAt(Index end) => new(Index.Start, end);
-
-        /// <summary>Create a Range object starting from first element to the end.</summary>
-        public static Range All => new(Index.Start, Index.End);
-
-        /// <summary>Calculate the start offset and length of range object using a collection length.</summary>
-        /// <param name="length">The length of the collection that the range will be used with. length has to be a positive value.</param>
-        /// <remarks>
-        /// For performance reason, we don't validate the input length parameter against negative values.
-        /// It is expected Range will be used with collections which always have non negative length/count.
-        /// We validate the range is inside the length scope though.
-        /// </remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public (int Offset, int Length) GetOffsetAndLength(int length)
-        {
-            int start;
-            var startIndex = Start;
-
-            if (startIndex.IsFromEnd)
-                start = length - startIndex.Value;
-            else
-                start = startIndex.Value;
-
-            int end;
-            var endIndex = End;
-
-            if (endIndex.IsFromEnd)
-                end = length - endIndex.Value;
-            else
-                end = endIndex.Value;
-
-            if ((uint)end > (uint)length || (uint)start > (uint)end)
-                throw new ArgumentOutOfRangeException(nameof(length));
-
-            return (start, end - start);
-        }
-    }
-}
-
-namespace System.Runtime.CompilerServices
-{
-    internal static class RuntimeHelpers
-    {
-        /// <summary>
-        /// Slices the specified array using the specified range.
-        /// </summary>
-        public static T[] GetSubArray<T>(T[] array, Range range)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-
-            (int offset, int length) = range.GetOffsetAndLength(array.Length);
-
-            if (default(T) != null || typeof(T[]) == array.GetType())
-            {
-                // We know the type of the array to be exactly T[].
-
-                if (length == 0)
-                    return [];
-
-                var dest = new T[length];
-                Array.Copy(array, offset, dest, 0, length);
-                return dest;
-            }
-            else
-            {
-                // The array is actually a U[] where U:T.
-                var dest = (T[])Array.CreateInstance(array.GetType().GetElementType(), length);
-                Array.Copy(array, offset, dest, 0, length);
-                return dest;
-            }
-        }
-    }
-}

src/FrostFS.SDK.Client/Tools/RequestConstructor.cs

@@ -18,7 +18,10 @@ public static class RequestConstructor
         if (request.MetaHeader is not null)
             return;
 
-        request.MetaHeader = MetaHeader.Default().ToMessage();
+        var metaHeader = MetaHeader.Default();
+        metaHeader.Ttl = 2;
+
+        request.MetaHeader = metaHeader.ToMessage();
 
         if (sessionToken != null)
             request.MetaHeader.SessionToken = sessionToken;

src/FrostFS.SDK.Client/Tools/RequestSigner.cs

@@ -13,7 +13,6 @@ using Org.BouncyCastle.Crypto.Digests;
 using Org.BouncyCastle.Crypto.Parameters;
 using Org.BouncyCastle.Crypto.Signers;
 using Org.BouncyCastle.Math;
-
 using Signature = FrostFS.Refs.Signature;
 
 namespace FrostFS.SDK.Client;
@@ -34,6 +33,7 @@ public static class RequestSigner
         var ecParameters = new ECDomainParameters(secp256R1.Curve, secp256R1.G, secp256R1.N);
         var privateKey = new ECPrivateKeyParameters(new BigInteger(1, key.PrivateKey()), ecParameters);
         var signer = new ECDsaSigner(new HMacDsaKCalculator(digest));
+
         var hash = new byte[digest.GetDigestSize()];
 
         digest.BlockUpdate(data, 0, data.Length);
@@ -48,33 +48,32 @@ public static class RequestSigner
         var sbytes = rs[1].ToByteArrayUnsigned();
         var index = RFC6979SignatureSize / 2 - rbytes.Length;
 
-        rbytes.AsSpan().CopyTo(signature[index..]);
+        rbytes.AsSpan().CopyTo(signature.Slice(index));
         index = RFC6979SignatureSize - sbytes.Length;
-        sbytes.AsSpan().CopyTo(signature[index..]);
+        sbytes.AsSpan().CopyTo(signature.Slice(index));
 
         return ByteString.CopyFrom(signature);
     }
 
-
-    internal static SignatureRFC6979 SignRFC6979(this ECDsa key, IMessage message)
+    internal static SignatureRFC6979 SignRFC6979(this ClientKey key, IMessage message)
     {
         return new SignatureRFC6979
         {
-            Key = ByteString.CopyFrom(key.PublicKey()),
-            Sign = key.SignRFC6979(message.ToByteArray()),
+            Key = key.PublicKeyProto,
+            Sign = key.ECDsaKey.SignRFC6979(message.ToByteArray()),
         };
     }
 
-    internal static SignatureRFC6979 SignRFC6979(this ECDsa key, ByteString data)
+    internal static SignatureRFC6979 SignRFC6979(this ClientKey key, ByteString data)
     {
         return new SignatureRFC6979
         {
-            Key = ByteString.CopyFrom(key.PublicKey()),
-            Sign = key.SignRFC6979(data.ToByteArray()),
+            Key = key.PublicKeyProto,
+            Sign = key.ECDsaKey.SignRFC6979(data.ToByteArray()),
         };
     }
 
-    public static ByteString SignData(this ECDsa key, byte[] data)
+    public static ByteString SignData(this ECDsa key, ReadOnlyMemory<byte> data)
     {
         if (key is null)
         {
@@ -84,27 +83,51 @@ public static class RequestSigner
         Span<byte> result = stackalloc byte[65];
         result[0] = 0x04;
 
-        //var hash = new byte[65];
-        //hash[0] = 0x04;
-
-        key.SignHash(data.Sha512()).AsSpan().CopyTo(result[1..]);
+        key.SignHash(DataHasher.Sha512(data)).AsSpan().CopyTo(result.Slice(1));
 
         return ByteString.CopyFrom(result);
     }
 
-    internal static Signature SignMessagePart(this ECDsa key, IMessage? data)
+    public static ByteString SignDataByHash(this ECDsa key, byte[] hash)
     {
-        var data2Sign = data is null ? [] : data.ToByteArray();
+        if (key is null)
+        {
+            throw new ArgumentNullException(nameof(key));
+        }
+
+        Span<byte> result = stackalloc byte[65];
+        result[0] = 0x04;
+
+        key.SignHash(hash).AsSpan().CopyTo(result.Slice(1));
+
+        return ByteString.CopyFrom(result);
+    }
+
+    internal static Signature SignMessagePart(this ClientKey key, IMessage? data)
+    {
+        if (data is null || data.CalculateSize() == 0)
+        {
+            return new Signature
+            {
+                Key = key.PublicKeyProto,
+                Sign = key.ECDsaKey.SignData(ReadOnlyMemory<byte>.Empty),
+            };
+        }
+
+        using var sha512 = SHA512.Create();
+        using HashStream stream = new(sha512);
+        data.WriteTo(stream);
+
         var sig = new Signature
         {
-            Key = ByteString.CopyFrom(key.PublicKey()),
-            Sign = key.SignData(data2Sign),
+            Key = key.PublicKeyProto,
+            Sign = key.ECDsaKey.SignDataByHash(stream.Hash())
         };
 
         return sig;
     }
 
-    internal static void Sign(this IVerifiableMessage message, ECDsa key)
+    internal static void Sign(this IVerifiableMessage message, ClientKey key)
     {
         var meta = message.GetMetaHeader();
         IVerificationHeader verify = message switch

src/FrostFS.SDK.Client/Tools/Verifier.cs

@@ -9,72 +9,32 @@ using FrostFS.Session;
 
 using Google.Protobuf;
 
-using Org.BouncyCastle.Asn1.Sec;
-using Org.BouncyCastle.Crypto.Digests;
-using Org.BouncyCastle.Crypto.Parameters;
-using Org.BouncyCastle.Crypto.Signers;
-using Org.BouncyCastle.Math;
-
 namespace FrostFS.SDK.Client;
 
 public static class Verifier
 {
     public const int RFC6979SignatureSize = 64;
 
-    private static BigInteger[] DecodeSignature(byte[] sig)
-    {
-        if (sig.Length != RFC6979SignatureSize)
-            throw new FormatException($"Wrong signature size, expect={RFC6979SignatureSize}, actual={sig.Length}");
-
-        var rs = new BigInteger[2];
-        rs[0] = new BigInteger(1, sig[..32]);
-        rs[1] = new BigInteger(1, sig[32..]);
-
-        return rs;
-    }
-
-    public static bool VerifyRFC6979(this byte[] publicKey, byte[] data, byte[] sig)
-    {
-        if (publicKey is null || data is null || sig is null)
-            return false;
-
-        var rs = DecodeSignature(sig);
-        var digest = new Sha256Digest();
-        var signer = new ECDsaSigner(new HMacDsaKCalculator(digest));
-        var secp256R1 = SecNamedCurves.GetByName("secp256r1");
-        var ecParameters = new ECDomainParameters(secp256R1.Curve, secp256R1.G, secp256R1.N);
-        var bcPublicKey = new ECPublicKeyParameters(secp256R1.Curve.DecodePoint(publicKey), ecParameters);
-        var hash = new byte[digest.GetDigestSize()];
-
-        digest.BlockUpdate(data, 0, data.Length);
-        digest.DoFinal(hash, 0);
-        signer.Init(false, bcPublicKey);
-
-        return signer.VerifySignature(hash, rs[0], rs[1]);
-    }
-
-    public static bool VerifyRFC6979(this SignatureRFC6979 signature, IMessage message)
-    {
-        if (signature is null)
-        {
-            throw new ArgumentNullException(nameof(signature));
-        }
-
-        return signature.Key.ToByteArray().VerifyRFC6979(message.ToByteArray(), signature.Sign.ToByteArray());
-    }
-
-    public static bool VerifyData(this ECDsa key, byte[] data, byte[] sig)
+    public static bool VerifyData(this ECDsa key, IMessage data, ByteString sig)
     {
         if (key is null)
             throw new ArgumentNullException(nameof(key));
 
-        if (data is null)
-            throw new ArgumentNullException(nameof(data));
-
         if (sig is null)
             throw new ArgumentNullException(nameof(sig));
 
-        return key.VerifyHash(data.Sha512(), sig[1..]);
+        var signature = sig.Span.Slice(1).ToArray();
+        using var sha = SHA512.Create();
+
+        if (data is null)
+        {
+            return key.VerifyHash(DataHasher.Sha512(new Span<byte>([])), signature);
+        }
+
+        using var stream = new HashStream(sha);
+        data.WriteTo(stream);
+
+        return key.VerifyHash(stream.Hash(), signature);
     }
 
     public static bool VerifyMessagePart(this Signature sig, IMessage data)
@@ -83,12 +43,10 @@ public static class Verifier
             return false;
 
         using var key = sig.Key.ToByteArray().LoadPublicKey();
-        var data2Verify = data is null ? [] : data.ToByteArray();
 
-        return key.VerifyData(data2Verify, sig.Sign.ToByteArray());
+        return key.VerifyData(data, sig.Sign);
     }
 
-
     internal static bool VerifyMatryoskaLevel(IMessage body, IMetaHeader meta, IVerificationHeader verification)
     {
         if (!verification.MetaSignature.VerifyMessagePart(meta))
@@ -118,12 +76,19 @@ public static class Verifier
     internal static void CheckResponse(IResponse resp)
     {
         if (!resp.Verify())
+        {
             throw new FormatException($"invalid response, type={resp.GetType()}");
+        }
 
-        var status = resp.MetaHeader.Status.ToModel();
+        if (resp.MetaHeader != null)
+        {
+            var status = resp.MetaHeader.Status.ToModel();
 
-        if (status != null && !status.IsSuccess)
-            throw new FrostFsResponseException(status);
+            if (status != null && !status.IsSuccess)
+            {
+                throw new FrostFsResponseException(status);
+            }
+        }
     }
 
     /// <summary>
@@ -138,6 +103,8 @@ public static class Verifier
         }
 
         if (!request.Verify())
+        {
             throw new FrostFsResponseException($"invalid response, type={request.GetType()}");
+        }
     }
 }

src/FrostFS.SDK.Cryptography/ArrayHelper.cs

@@ -21,4 +21,18 @@ internal static class ArrayHelper
 
         return dst;
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void GetRevertedArray(ReadOnlySpan<byte> source, byte[] data)
+    {
+        if (source.Length != 0)
+        {
+            int i = 0;
+            int j = source.Length - 1;
+            while (i < source.Length)
+            {
+                data[i++] = source[j--];
+            }
+        }
+    }
 }