public class MyServer : JsonRpcServer
{
    readonly SocketListener _listener;
    TaskCompletionSource<int> _tcs = new TaskCompletionSource<int>();

    public MyServer(int port)
    {
        _listener = new SocketListener();
        _listener.Start(new IPEndPoint(IPAddress.Any, port));
        _listener.OnConnection(OnConnection);
    }

    private Task OnConnection(SocketConnection connection)
    {
        IClient client = AttachClient(connection.GetRemoteIp(), connection);
        return _tcs.Task;
    }

    public override void Dispose()
    {
        _tcs.TrySetCanceled();
        _listener?.Stop();
        base.Dispose();
    }
}

const int port = 7733;
using(var server = new MyServer(port))
{
    // Bind to functions on static class
    server.Bind(typeof(Target));    

    // Bind to a delegate
    server.Bind("DelegateMethod", (Action<int,int>)( (a, b)
        => Debug.WriteLine($"DelegateMethod. a={a} b={b}") ));
}

static class Target
{
    public static int TestMethod()
    {
        Debug.WriteLine("TestMethod called");
        return 42;
    }
}

public static class SocketExtensions
{
    static readonly PropertyInfo s_socketProperty;
    static SocketExtensions()
    {
        s_socketProperty = typeof(SocketConnection).GetProperty("Socket",
            BindingFlags.NonPublic | BindingFlags.Instance);
    }

    public static string GetRemoteIp(this SocketConnection conn)
    {
        if (s_socketProperty?.GetValue(conn) is Socket socket)
        {
            var ipEP = socket.RemoteEndPoint as IPEndPoint;
            return ipEP.Address.MapToIPv4().ToString();
        }
        return null;
    }
}

public class MyClient
{
    private readonly SocketConnection _conn;

    public static async Task<JsonRpcClient> ConnectAsync(int port)
    {
        var c = await SocketConnection.ConnectAsync(new IPEndPoint(IPAddress.Loopback, port));
        return new JsonRpcClient(c);
    }
}

const int port = 7733;
using(var client = await MyClient.ConnectAsync(port))
{
    var result = await client.InvokeAsync<int>("TestMethod");
    await client.InvokeAsync("DelegateMethod", 44, 76);

    // Fire-and-forget 
    client.Notify("DelegateMethod", 2, 6);
}