From 3d0f80ea2fca4593b2ce7a7d0629a4f186974167 Mon Sep 17 00:00:00 2001
From: daniel <4954577+jaensen@users.noreply.github.com>
Date: Tue, 4 Jun 2024 01:43:22 +0200
Subject: [PATCH 1/5] Add subscription support for circles events

---
 Circles.Index.Rpc/Circles.Index.Rpc.csproj    |   1 +
 Circles.Index.Rpc/CirclesRpcModule.cs         |   6 +
 Circles.Index.Rpc/CirclesSubscription.cs      | 103 ++++++++++++++
 .../CirclesSubscriptionParams.cs              |  32 +++++
 Circles.Index.Rpc/ICirclesRpcModule.cs        |  14 +-
 Circles.Index.Rpc/QueryEvents.cs              | 133 ++++++++++++++++++
 Circles.Index/Plugin.cs                       |  23 ++-
 Circles.Index/StateMachine.cs                 |  26 ++++
 Circles.Index/tools/test_ws.html              | 101 +++++++++++++
 docker-compose.gnosis.yml                     |   3 +-
 general-example-requests.md                   |  83 ++++++++++-
 11 files changed, 516 insertions(+), 9 deletions(-)
 create mode 100644 Circles.Index.Rpc/CirclesSubscription.cs
 create mode 100644 Circles.Index.Rpc/CirclesSubscriptionParams.cs
 create mode 100644 Circles.Index.Rpc/QueryEvents.cs
 create mode 100644 Circles.Index/tools/test_ws.html

diff --git a/Circles.Index.Rpc/Circles.Index.Rpc.csproj b/Circles.Index.Rpc/Circles.Index.Rpc.csproj
index 73e7ea9..71884e0 100644
--- a/Circles.Index.Rpc/Circles.Index.Rpc.csproj
+++ b/Circles.Index.Rpc/Circles.Index.Rpc.csproj
@@ -7,6 +7,7 @@
     </PropertyGroup>
 
     <ItemGroup>
+      <PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.2.0" />
       <PackageReference Include="Nethermind.ReferenceAssemblies" Version="1.25.4" />
     </ItemGroup>
 
diff --git a/Circles.Index.Rpc/CirclesRpcModule.cs b/Circles.Index.Rpc/CirclesRpcModule.cs
index 9a1a3cc..01e14cb 100644
--- a/Circles.Index.Rpc/CirclesRpcModule.cs
+++ b/Circles.Index.Rpc/CirclesRpcModule.cs
@@ -183,6 +183,12 @@ public ResultWrapper<DatabaseQueryResult> circles_query(SelectDto query)
         return ResultWrapper<DatabaseQueryResult>.Success(result);
     }
 
+    public ResultWrapper<CirclesEvent[]> circles_events(Address address, long fromBlock, long? toBlock = null)
+    {
+        var queryEvents = new QueryEvents(_indexerContext);
+        return ResultWrapper<CirclesEvent[]>.Success(queryEvents.CirclesEvents(address, fromBlock, toBlock));
+    }
+
     #region private methods
 
     private IEnumerable<Address> TokenAddressesForAccount(Address circlesAccount)
diff --git a/Circles.Index.Rpc/CirclesSubscription.cs b/Circles.Index.Rpc/CirclesSubscription.cs
new file mode 100644
index 0000000..45efe6a
--- /dev/null
+++ b/Circles.Index.Rpc/CirclesSubscription.cs
@@ -0,0 +1,103 @@
+using Circles.Index.Common;
+using Nethermind.JsonRpc;
+using Nethermind.JsonRpc.Modules.Subscribe;
+
+namespace Circles.Index.Rpc;
+
+public class NotifyEventArgs(CirclesEvent[] events) : EventArgs
+{
+    public CirclesEvent[] Events { get; } = events;
+}
+
+public class CirclesSubscription : Subscription
+{
+    public override string Type => "circles";
+
+    private readonly CirclesSubscriptionParams _param;
+
+    public static long SubscriberCount => _subscriberCount;
+    private static long _subscriberCount;
+
+    public CirclesSubscription(IJsonRpcDuplexClient jsonRpcDuplexClient, CirclesSubscriptionParams param) : base(
+        jsonRpcDuplexClient)
+    {
+        Notification += OnNotification;
+        _param = param;
+
+        Interlocked.Increment(ref _subscriberCount);
+    }
+
+    public static event EventHandler<NotifyEventArgs>? Notification;
+
+    public static void Notify(Context context, Range<long> importedRange)
+    {
+        if (_subscriberCount == 0)
+        {
+            return;
+        }
+
+        var queryEvents = new QueryEvents(context);
+        var events = queryEvents.CirclesEvents(null, importedRange.Min, importedRange.Max);
+
+        Notification?.Invoke(null, new NotifyEventArgs(events));
+    }
+
+    private void OnNotification(object? sender, NotifyEventArgs e)
+    {
+        ScheduleAction(async () =>
+        {
+            CirclesEvent[] events;
+
+            if (_param.Address != null)
+            {
+                var filterAddress = _param.Address!.ToString(true, false);
+                events = FilterForAffectedAddress(e, filterAddress);
+            }
+            else
+            {
+                events = e.Events;
+            }
+
+            JsonRpcResult result = CreateSubscriptionMessage(events);
+            await JsonRpcDuplexClient.SendJsonRpcResult(result);
+        });
+    }
+
+    private CirclesEvent[] FilterForAffectedAddress(NotifyEventArgs e, string filterAddress)
+    {
+        var filteredForAddress = new List<CirclesEvent>();
+        var addressesInEvent = new HashSet<string>();
+
+        foreach (var circlesEvent in e.Events)
+        {
+            addressesInEvent.Clear();
+
+            foreach (var circlesEventValue in circlesEvent.Values)
+            {
+                if (!QueryEvents.AddressColumns.Contains(circlesEventValue.Key))
+                {
+                    continue;
+                }
+
+                if (circlesEventValue.Value is string address)
+                {
+                    addressesInEvent.Add(address);
+                }
+            }
+
+            if (addressesInEvent.Contains(filterAddress))
+            {
+                filteredForAddress.Add(circlesEvent);
+            }
+        }
+
+        return filteredForAddress.ToArray();
+    }
+
+    public override void Dispose()
+    {
+        base.Dispose();
+
+        Interlocked.Decrement(ref _subscriberCount);
+    }
+}
\ No newline at end of file
diff --git a/Circles.Index.Rpc/CirclesSubscriptionParams.cs b/Circles.Index.Rpc/CirclesSubscriptionParams.cs
new file mode 100644
index 0000000..e4e9ed3
--- /dev/null
+++ b/Circles.Index.Rpc/CirclesSubscriptionParams.cs
@@ -0,0 +1,32 @@
+using System.Text.Json;
+using Nethermind.Core;
+using Nethermind.JsonRpc;
+
+namespace Circles.Index.Rpc;
+
+public class CirclesSubscriptionParams : IJsonRpcParam
+{
+    public Address? Address { get; private set; }
+
+    public void ReadJson(JsonElement element, JsonSerializerOptions options)
+    {
+        JsonDocument? doc = null;
+        try
+        {
+            if (element.ValueKind == JsonValueKind.String)
+            {
+                doc = JsonDocument.Parse(element.GetString() ?? "{}");
+                element = doc.RootElement;
+            }
+
+            if (element.TryGetProperty("address", out JsonElement addressElement))
+            {
+                Address = Address.TryParse(addressElement.GetString(), out Address? address) ? address : null;
+            }
+        }
+        finally
+        {
+            doc?.Dispose();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Circles.Index.Rpc/ICirclesRpcModule.cs b/Circles.Index.Rpc/ICirclesRpcModule.cs
index 58a2917..13ec046 100644
--- a/Circles.Index.Rpc/ICirclesRpcModule.cs
+++ b/Circles.Index.Rpc/ICirclesRpcModule.cs
@@ -10,12 +10,15 @@ namespace Circles.Index.Rpc;
 #region DTOs
 
 public record CirclesTokenBalance(Address Token, string Balance, string TokenOwner);
+
 public record CirclesTokenBalanceV2(UInt256 TokenId, string Balance, string TokenOwner);
 
 public record CirclesTrustRelation(Address User, int limit);
 
 public record CirclesTrustRelations(Address User, CirclesTrustRelation[] Trusts, CirclesTrustRelation[] TrustedBy);
 
+public record CirclesEvent(string Event, IDictionary<string, object?> Values);
+
 #endregion
 
 [RpcModule("Circles")]
@@ -31,15 +34,20 @@ public interface ICirclesRpcModule : IRpcModule
     [JsonRpcMethod(Description = "Gets the balance of each V1 Circles token the specified address holds",
         IsImplemented = true)]
     Task<ResultWrapper<CirclesTokenBalance[]>> circles_getTokenBalances(Address address, bool asTimeCircles = false);
-    
+
     [JsonRpcMethod(Description = "Gets the V2 Circles balance of the specified address", IsImplemented = true)]
     Task<ResultWrapper<string>> circlesV2_getTotalBalance(Address address, bool asTimeCircles = false);
-    
+
     [JsonRpcMethod(Description = "Gets the balance of each V2 Circles token the specified address holds",
         IsImplemented = true)]
-    Task<ResultWrapper<CirclesTokenBalanceV2[]>> circlesV2_getTokenBalances(Address address, bool asTimeCircles = false);
+    Task<ResultWrapper<CirclesTokenBalanceV2[]>>
+        circlesV2_getTokenBalances(Address address, bool asTimeCircles = false);
 
     [JsonRpcMethod(Description = "Queries the data of one Circles index table",
         IsImplemented = true)]
     ResultWrapper<DatabaseQueryResult> circles_query(SelectDto query);
+
+    [JsonRpcMethod(Description = "Returns all events affecting the specified account since block N",
+        IsImplemented = true)]
+    ResultWrapper<CirclesEvent[]> circles_events(Address address, long fromBlock, long? toBlock = null);
 }
\ No newline at end of file
diff --git a/Circles.Index.Rpc/QueryEvents.cs b/Circles.Index.Rpc/QueryEvents.cs
new file mode 100644
index 0000000..33dade1
--- /dev/null
+++ b/Circles.Index.Rpc/QueryEvents.cs
@@ -0,0 +1,133 @@
+using System.Collections.Concurrent;
+using System.Collections.Immutable;
+using Circles.Index.Common;
+using Circles.Index.Query;
+using Nethermind.Core;
+
+namespace Circles.Index.Rpc;
+
+public class QueryEvents(Context context)
+{
+    public static readonly ImmutableHashSet<string> AddressColumns = new HashSet<string>
+    {
+        "user", "avatar", "organization", "from", "to", "canSendTo", "account", "group", "human", "invited",
+        "inviter", "truster", "trustee"
+    }.ToImmutableHashSet();
+
+    public CirclesEvent[] CirclesEvents(Address? address, long fromBlock, long? toBlock = null)
+    {
+        long currentHead = context.NethermindApi.BlockTree?.Head?.Number
+                           ?? throw new Exception("BlockTree or Head is null");
+
+        string? addressString = address?.ToString(true, false);
+
+        ValidateInputs(addressString, fromBlock, toBlock, currentHead);
+
+        var queries = BuildQueries(addressString, fromBlock, toBlock);
+
+        var events = ExecuteQueries(queries);
+
+        var sortedEvents = SortEvents(events);
+
+        return sortedEvents;
+    }
+
+    private void ValidateInputs(string? address, long fromBlock, long? toBlock, long currentHead)
+    {
+        if (address == "0x0000000000000000000000000000000000000000")
+            throw new Exception("The zero address cannot be queried.");
+
+        if (fromBlock < 0)
+            throw new Exception("The fromBlock parameter must be greater than or equal to 0.");
+
+        if (toBlock.HasValue && toBlock.Value < fromBlock)
+            throw new Exception("The toBlock parameter must be greater than or equal to fromBlock.");
+
+        if (toBlock.HasValue && toBlock.Value > currentHead)
+            throw new Exception(
+                "The toBlock parameter must be less than or equal to the current head. Leave it empty to query all blocks until the current head.");
+    }
+
+    private List<Select> BuildQueries(string? address, long fromBlock, long? toBlock)
+    {
+        var queries = new List<Select>();
+
+        foreach (var table in context.Database.Schema.Tables)
+        {
+            if (table.Key.Namespace.StartsWith("V_") || table.Key.Namespace == "System")
+                continue;
+
+            var addressColumnFilters = address == null
+                ? []
+                : table.Value.Columns
+                    .Where(column => AddressColumns.Contains(column.Column))
+                    .Select(column => new FilterPredicate(column.Column, FilterType.Equals, address))
+                    .Cast<IFilterPredicate>()
+                    .ToList();
+
+            if (addressColumnFilters.Count == 0)
+                continue;
+
+            var filters = new List<IFilterPredicate>
+            {
+                new FilterPredicate("blockNumber", FilterType.GreaterThanOrEquals, fromBlock),
+                new Conjunction(ConjunctionType.Or, addressColumnFilters.ToArray())
+            };
+
+            if (toBlock.HasValue)
+            {
+                filters.Add(new FilterPredicate("blockNumber", FilterType.LessThanOrEquals, toBlock.Value));
+            }
+
+            queries.Add(new Select(table.Key.Namespace, table.Key.Table, Array.Empty<string>(),
+                new[] { new Conjunction(ConjunctionType.And, filters.ToArray()) },
+                new[]
+                {
+                    new OrderBy("blockNumber", "ASC"), new OrderBy("transactionIndex", "ASC"),
+                    new OrderBy("logIndex", "ASC")
+                },
+                null, true, int.MaxValue));
+        }
+
+        return queries;
+    }
+
+    private ConcurrentDictionary<(long BlockNo, long TransactionIndex, long LogIndex), CirclesEvent> ExecuteQueries(
+        List<Select> queries)
+    {
+        var events = new ConcurrentDictionary<(long BlockNo, long TransactionIndex, long LogIndex), CirclesEvent>();
+        var tasks = queries.Select(query => Task.Run(() =>
+        {
+            var sql = query.ToSql(context.Database);
+            var result = context.Database.Select(sql);
+
+            foreach (var row in result.Rows)
+            {
+                var eventName = $"{query.Namespace}_{query.Table}";
+                var values = result.Columns.Select((col, i) => new { col, value = row[i] })
+                    .ToDictionary(x => x.col, x => x.value);
+
+                var key = ((long)(row[0] ?? new Exception("Block number is null")),
+                    (long)(row[2] ?? throw new Exception("Transaction index is null")),
+                    (long)(row[3] ?? throw new Exception("Log index is null")));
+
+                events.TryAdd(key, new CirclesEvent(eventName, values));
+            }
+        })).ToArray();
+
+        Task.WaitAll(tasks);
+
+        return events;
+    }
+
+    private CirclesEvent[] SortEvents(
+        ConcurrentDictionary<(long BlockNo, long TransactionIndex, long LogIndex), CirclesEvent> events)
+    {
+        return events
+            .OrderBy(o => o.Key.BlockNo)
+            .ThenBy(o => o.Key.TransactionIndex)
+            .ThenBy(o => o.Key.LogIndex)
+            .Select(o => o.Value)
+            .ToArray();
+    }
+}
\ No newline at end of file
diff --git a/Circles.Index/Plugin.cs b/Circles.Index/Plugin.cs
index 63718c1..8d0b6c6 100644
--- a/Circles.Index/Plugin.cs
+++ b/Circles.Index/Plugin.cs
@@ -6,7 +6,10 @@
 using Nethermind.Api.Extensions;
 using Nethermind.Core;
 using Nethermind.Core.Extensions;
+using Nethermind.JsonRpc;
 using Nethermind.JsonRpc.Modules;
+using Nethermind.JsonRpc.Modules.Eth;
+using Nethermind.JsonRpc.Modules.Subscribe;
 using Nethermind.Logging;
 using Npgsql;
 
@@ -29,8 +32,15 @@ public class Plugin : INethermindPlugin
     private int _newItemsArrived;
     private long _latestHeadToIndex = -1;
 
+    private bool _enableWebsockets;
+
     public async Task Init(INethermindApi nethermindApi)
     {
+        var (getFromAPi, _) = nethermindApi.ForInit;
+        IInitConfig initConfig = getFromAPi.Config<IInitConfig>();
+
+        _enableWebsockets = initConfig.WebSocketsEnabled;
+
         IDatabaseSchema common = new Common.DatabaseSchema();
         IDatabaseSchema v1 = new CirclesV1.DatabaseSchema();
         IDatabaseSchema v2 = new CirclesV2.DatabaseSchema();
@@ -184,9 +194,20 @@ public async Task InitRpcModules()
             throw new Exception("_indexerContext.NethermindApi.RpcModuleProvider is not set");
         }
 
+        var (getFromAPi, _) = _indexerContext.NethermindApi.ForRpc;
+
         CirclesRpcModule circlesRpcModule = new(_indexerContext);
-        _indexerContext.NethermindApi.ForRpc.GetFromApi.RpcModuleProvider?.Register(
+        getFromAPi.RpcModuleProvider?.Register(
             new SingletonModulePool<ICirclesRpcModule>(circlesRpcModule));
+
+        if (getFromAPi.SubscriptionFactory == null)
+        {
+            throw new Exception("getFromAPi.SubscriptionFactory is not set");
+        }
+
+        getFromAPi.SubscriptionFactory.RegisterSubscriptionType<CirclesSubscriptionParams>(
+            "circles",
+            (client, param) => new CirclesSubscription(client, param));
     }
 
     public ValueTask DisposeAsync()
diff --git a/Circles.Index/StateMachine.cs b/Circles.Index/StateMachine.cs
index 5b4915c..d196a2c 100644
--- a/Circles.Index/StateMachine.cs
+++ b/Circles.Index/StateMachine.cs
@@ -1,4 +1,5 @@
 using Circles.Index.Common;
+using Circles.Index.Rpc;
 using Nethermind.Blockchain;
 using Nethermind.Blockchain.Receipts;
 
@@ -19,6 +20,7 @@ public enum State
         New,
         Initial,
         Syncing,
+        NotifySubscribers,
         Reorg,
         WaitForNewBlock,
         Error,
@@ -99,6 +101,30 @@ public async Task HandleEvent(IEvent e)
                                                 $"to {importedBlockRange.Max}");
                             Errors.Clear();
 
+                            await TransitionTo(State.NotifySubscribers, importedBlockRange);
+                            return;
+                    }
+
+                    break;
+
+                case State.NotifySubscribers:
+                    switch (e)
+                    {
+                        case EnterState<Range<long>> importedBlockRange:
+                            context.Logger.Info(
+                                $"Notifying {CirclesSubscription.SubscriberCount} subscribers about new blocks: " +
+                                $"{importedBlockRange.Arg.Min} - {importedBlockRange.Arg.Max}");
+
+                            if (importedBlockRange.Arg.Max - importedBlockRange.Arg.Min > 1000)
+                            {
+                                context.Logger.Warn(
+                                    $"Too many blocks to notify: {importedBlockRange.Arg.Max - importedBlockRange.Arg.Min}");
+                            }
+                            else
+                            {
+                                CirclesSubscription.Notify(context, importedBlockRange.Arg);
+                            }
+
                             await TransitionTo(State.WaitForNewBlock);
                             return;
                     }
diff --git a/Circles.Index/tools/test_ws.html b/Circles.Index/tools/test_ws.html
new file mode 100644
index 0000000..1a436ef
--- /dev/null
+++ b/Circles.Index/tools/test_ws.html
@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>WebSocket Circles Event Subscription</title>
+</head>
+<body>
+<h1>WebSocket Circles Event Subscription</h1>
+<div id="log"></div>
+
+<script>
+    class WebsocketConnection {
+        constructor(url) {
+            this.url = url;
+            this.websocket = null;
+            this.messageId = 0;
+            this.pendingResponses = {};
+            this.subscriptionListeners = {};
+        }
+
+        connect() {
+            return new Promise((resolve, reject) => {
+                this.websocket = new WebSocket(this.url);
+                this.websocket.onopen = () => {
+                    console.log('Connected');
+                    resolve();
+                };
+                this.websocket.onmessage = (event) => {
+                    const message = JSON.parse(event.data);
+                    const {id, method, params} = message;
+                    if (id !== undefined && this.pendingResponses[id]) {
+                        this.pendingResponses[id].resolve(message);
+                        delete this.pendingResponses[id];
+                    }
+                    if (method === 'eth_subscription' && params) {
+                        const {subscription, result} = params;
+                        if (this.subscriptionListeners[subscription]) {
+                            this.subscriptionListeners[subscription].forEach(listener => listener(result));
+                        }
+                    }
+                };
+                this.websocket.onclose = () => console.log('Disconnected');
+                this.websocket.onerror = (error) => {
+                    console.error('WebSocket error:', error);
+                    reject(error);
+                };
+            });
+        }
+
+        sendMessage(method, params, timeout = 5000) {
+            if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN) {
+                return Promise.reject('WebSocket is not connected');
+            }
+            const id = this.messageId++;
+            const message = {jsonrpc: "2.0", method, params, id};
+            return new Promise((resolve, reject) => {
+                this.pendingResponses[id] = {resolve, reject};
+                this.websocket.send(JSON.stringify(message));
+                setTimeout(() => {
+                    if (this.pendingResponses[id]) {
+                        this.pendingResponses[id].reject('Request timed out');
+                        delete this.pendingResponses[id];
+                    }
+                }, timeout);
+            });
+        }
+
+        async subscribe(method, params, listener) {
+            const response = await this.sendMessage('eth_subscribe', [method, params]);
+            const subscriptionId = response.result;
+            if (!this.subscriptionListeners[subscriptionId]) {
+                this.subscriptionListeners[subscriptionId] = [];
+            }
+            this.subscriptionListeners[subscriptionId].push(listener);
+            return subscriptionId;
+        }
+    }
+
+    const wsConnection = new WebsocketConnection('ws://localhost:8545');
+    const logElement = document.getElementById('log');
+
+    function log(message) {
+        const messageElement = document.createElement('div');
+        messageElement.textContent = message;
+        logElement.appendChild(messageElement);
+    }
+
+    (async () => {
+        try {
+            await wsConnection.connect();
+            log('Connected to websocket...');
+            const subscriptionId = await wsConnection.subscribe('circles', JSON.stringify({"address": "0x0000000000000000000000000000000000000000"}), (event) => {
+                log(`Circles event: ${JSON.stringify(event)}`);
+            });
+            log(`Subscribed with ID: ${subscriptionId}`);
+        } catch (error) {
+        }
+    })();
+</script>
+</body>
+</html>
diff --git a/docker-compose.gnosis.yml b/docker-compose.gnosis.yml
index 054a428..b252908 100644
--- a/docker-compose.gnosis.yml
+++ b/docker-compose.gnosis.yml
@@ -2,7 +2,7 @@ services:
   nethermind-gnosis:
     build:
       context: .
-      dockerfile: x64.Dockerfile
+      dockerfile: x64.debug.Dockerfile
     restart: unless-stopped
     networks:
       - circles-gnosis
@@ -36,6 +36,7 @@ services:
     environment:
       - V1_HUB_ADDRESS=0x29b9a7fBb8995b2423a71cC17cf9810798F6C543
       - V2_HUB_ADDRESS=0xFFfbD3E62203B888bb8E09c1fcAcE58242674964
+      - V2_NAME_REGISTRY_ADDRESS=0x466D13BF31a19cF4d42C6D396905AC82653dAFC4
       - START_BLOCK=0
       - POSTGRES_CONNECTION_STRING=Server=postgres-gnosis;Port=5432;Database=postgres;User Id=${POSTGRES_USER};Password=${POSTGRES_PASSWORD};
 
diff --git a/general-example-requests.md b/general-example-requests.md
index 46acc18..bfc445b 100644
--- a/general-example-requests.md
+++ b/general-example-requests.md
@@ -2,9 +2,81 @@
 
 The examples in this file are general Circles RPC methods that can be used to query Circles V1 and V2 data.
 
-1. [circles_query](#circles_query)      
-1.1. [Get a list of Circles avatars](#get-a-list-of-circles-users)  
-1.2. [Get the trust relations between avatars](#get-the-trust-relations-between-avatars)  
+1. [circles subscription](#circles-subscription)
+2. [circles_events](#circles_events)
+3. [circles_query](#circles_query)      
+   3.1. [Get a list of Circles avatars](#get-a-list-of-circles-users)  
+   3.2. [Get the trust relations between avatars](#get-the-trust-relations-between-avatars)
+
+### circles subscription
+
+#### Example
+
+```js
+```
+
+### circles_events
+
+Queries all events that involve a specific address. This is especially useful to update a client once it's address is
+involved in an event (see [circles subscription](#circles-subscription))
+or can be used to populate a history view for a specific address.
+
+**Signature**: `circles_events(address: string, fromBlock: number, toBlock?: number)`.
+
+The `fromBlock` and `toBlock` parameters can be used to filter the events by block number.
+The `toBlock` parameter can be set to `null` to query all events from `fromBlock` to the latest block.
+
+#### Example
+
+```shell
+curl -X POST --data '{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "circles_events",
+  "params": [
+    "0xde374ece6fa50e781e81aac78e811b33d16912c7",
+    30282299,
+    null
+  ]
+}' -H "Content-Type: application/json" http://localhost:8545/
+```
+
+#### Response
+
+The response generally contains the following fields:
+
+* `event` - The name of the event.
+    * `CrcV1_...`
+        * `HubTransfer`
+        * `OrganizationSignup`
+        * `Signup`
+        * `Transfer`
+        * `Trust`
+    * `CrcV2_...`
+        * `ApprovalForAll`
+        * `DiscountCost`
+        * `InviteHuman`
+        * `PersonalMint`
+        * `RegisterGroup`
+        * `RegisterHuman`
+        * `RegisterOrganization`
+        * `RegisterShortName`
+        * `Stopped`
+        * `TransferBatch`
+        * `TransferSingle`
+        * `Trust`
+        * `UpdateMetadataDigest`
+        * `URI`
+        * `CidV0` (predecessor of `URI` and `UpdateMetadataDigest`)
+* `values` - The values of the event.
+
+The values contain at least the following fields:
+
+* `blockNumber` - The block number the event was emitted in.
+* `timestamp` - The unix timestamp of the event.
+* `transactionIndex` - The index of the transaction in the block.
+* `logIndex` - The index of the log in the transaction.
+* `transactionHash` - The hash of the transaction.
 
 ### circles_query
 
@@ -82,9 +154,10 @@ curl -X POST --data '{
 
 ##### Get a list of Circles avatars
 
-This query returns v1 as well as v2 Circles users. The version of the user can be determined by the `version` column.  
+This query returns v1 as well as v2 Circles users. The version of the user can be determined by the `version` column.
 
 The following columns are only valid for v2 users:
+
 * `invitedBy` - The address of the user who invited the user.
 * `name` - The name of the group or organization.
 * `cidV0Digest` - The token metadata CID of the avatar.
@@ -194,9 +267,11 @@ curl -X POST --data '{
 This query returns the trust relations between avatars.
 
 The following columns are only valid for v1 trust relations:
+
 * `limit` - The trust limit (0 is no trust, 100 full trust).
 
 The following columns are only valid for v2 trust relations:
+
 * `expiryTime` - The expiry time of the trust relation.
 
 ```shell

From 5ee2531abb6cc76c914323033c6531a5ed7d2b95 Mon Sep 17 00:00:00 2001
From: daniel <4954577+jaensen@users.noreply.github.com>
Date: Tue, 4 Jun 2024 02:26:33 +0200
Subject: [PATCH 2/5] fix problem when no address is supplied

---
 Circles.Index.Rpc/CirclesSubscription.cs | 29 +++++++++++++++++++++++-
 Circles.Index.Rpc/QueryEvents.cs         | 20 ++++++++++++----
 Circles.Index/Plugin.cs                  |  2 +-
 Circles.Index/tools/test_ws.html         |  2 +-
 4 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/Circles.Index.Rpc/CirclesSubscription.cs b/Circles.Index.Rpc/CirclesSubscription.cs
index 45efe6a..b90759a 100644
--- a/Circles.Index.Rpc/CirclesSubscription.cs
+++ b/Circles.Index.Rpc/CirclesSubscription.cs
@@ -1,4 +1,6 @@
 using Circles.Index.Common;
+using Circles.Index.Query;
+using Nethermind.Core;
 using Nethermind.JsonRpc;
 using Nethermind.JsonRpc.Modules.Subscribe;
 
@@ -18,12 +20,32 @@ public class CirclesSubscription : Subscription
     public static long SubscriberCount => _subscriberCount;
     private static long _subscriberCount;
 
-    public CirclesSubscription(IJsonRpcDuplexClient jsonRpcDuplexClient, CirclesSubscriptionParams param) : base(
+    public CirclesSubscription(IJsonRpcDuplexClient jsonRpcDuplexClient, Context context,
+        CirclesSubscriptionParams param) : base(
         jsonRpcDuplexClient)
     {
         Notification += OnNotification;
         _param = param;
 
+        if (param.Address == Address.Zero)
+        {
+            throw new Exception("The zero address cannot be subscribed to.");
+        }
+
+        if (param.Address != null)
+        {
+            var select = new Select("V_Crc", "Avatars", ["avatar"], [
+                new FilterPredicate("avatar", FilterType.Equals, param.Address?.ToString(true, false))
+            ], [], 1);
+
+            var parameterizedSql = select.ToSql(context.Database);
+            var avatarInfo = context.Database.Select(parameterizedSql);
+            if (!avatarInfo.Rows.Any())
+            {
+                throw new Exception($"The address {param.Address} is not a circles avatar.");
+            }
+        }
+
         Interlocked.Increment(ref _subscriberCount);
     }
 
@@ -39,6 +61,11 @@ public static void Notify(Context context, Range<long> importedRange)
         var queryEvents = new QueryEvents(context);
         var events = queryEvents.CirclesEvents(null, importedRange.Min, importedRange.Max);
 
+        if (events.Length == 0)
+        {
+            return;
+        }
+
         Notification?.Invoke(null, new NotifyEventArgs(events));
     }
 
diff --git a/Circles.Index.Rpc/QueryEvents.cs b/Circles.Index.Rpc/QueryEvents.cs
index 33dade1..0ffcae7 100644
--- a/Circles.Index.Rpc/QueryEvents.cs
+++ b/Circles.Index.Rpc/QueryEvents.cs
@@ -65,22 +65,32 @@ private List<Select> BuildQueries(string? address, long fromBlock, long? toBlock
                     .Cast<IFilterPredicate>()
                     .ToList();
 
-            if (addressColumnFilters.Count == 0)
-                continue;
-
             var filters = new List<IFilterPredicate>
             {
                 new FilterPredicate("blockNumber", FilterType.GreaterThanOrEquals, fromBlock),
-                new Conjunction(ConjunctionType.Or, addressColumnFilters.ToArray())
             };
 
+            if (addressColumnFilters.Count > 0)
+            {
+                if (addressColumnFilters.Count == 1)
+                {
+                    filters.Add(addressColumnFilters[0]);
+                }
+                else
+                {
+                    addressColumnFilters.Add(new Conjunction(ConjunctionType.Or, addressColumnFilters.ToArray()));
+                }
+            }
+
             if (toBlock.HasValue)
             {
                 filters.Add(new FilterPredicate("blockNumber", FilterType.LessThanOrEquals, toBlock.Value));
             }
 
             queries.Add(new Select(table.Key.Namespace, table.Key.Table, Array.Empty<string>(),
-                new[] { new Conjunction(ConjunctionType.And, filters.ToArray()) },
+                filters.Count > 1
+                    ? new[] { new Conjunction(ConjunctionType.And, filters.ToArray()) }
+                    : filters,
                 new[]
                 {
                     new OrderBy("blockNumber", "ASC"), new OrderBy("transactionIndex", "ASC"),
diff --git a/Circles.Index/Plugin.cs b/Circles.Index/Plugin.cs
index 8d0b6c6..0550da4 100644
--- a/Circles.Index/Plugin.cs
+++ b/Circles.Index/Plugin.cs
@@ -207,7 +207,7 @@ public async Task InitRpcModules()
 
         getFromAPi.SubscriptionFactory.RegisterSubscriptionType<CirclesSubscriptionParams>(
             "circles",
-            (client, param) => new CirclesSubscription(client, param));
+            (client, param) => new CirclesSubscription(client, _indexerContext, param));
     }
 
     public ValueTask DisposeAsync()
diff --git a/Circles.Index/tools/test_ws.html b/Circles.Index/tools/test_ws.html
index 1a436ef..9d76348 100644
--- a/Circles.Index/tools/test_ws.html
+++ b/Circles.Index/tools/test_ws.html
@@ -89,7 +89,7 @@ <h1>WebSocket Circles Event Subscription</h1>
         try {
             await wsConnection.connect();
             log('Connected to websocket...');
-            const subscriptionId = await wsConnection.subscribe('circles', JSON.stringify({"address": "0x0000000000000000000000000000000000000000"}), (event) => {
+            const subscriptionId = await wsConnection.subscribe('circles', JSON.stringify({}), (event) => {
                 log(`Circles event: ${JSON.stringify(event)}`);
             });
             log(`Subscribed with ID: ${subscriptionId}`);

From 55752d32431a84f90b48b6492d8aa8c4f5686f72 Mon Sep 17 00:00:00 2001
From: daniel <4954577+jaensen@users.noreply.github.com>
Date: Tue, 4 Jun 2024 04:10:41 +0200
Subject: [PATCH 3/5] fix addressColumnFilters in QueryEvents.cs

---
 Circles.Index.Rpc/QueryEvents.cs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/Circles.Index.Rpc/QueryEvents.cs b/Circles.Index.Rpc/QueryEvents.cs
index 0ffcae7..0a933f6 100644
--- a/Circles.Index.Rpc/QueryEvents.cs
+++ b/Circles.Index.Rpc/QueryEvents.cs
@@ -72,14 +72,9 @@ private List<Select> BuildQueries(string? address, long fromBlock, long? toBlock
 
             if (addressColumnFilters.Count > 0)
             {
-                if (addressColumnFilters.Count == 1)
-                {
-                    filters.Add(addressColumnFilters[0]);
-                }
-                else
-                {
-                    addressColumnFilters.Add(new Conjunction(ConjunctionType.Or, addressColumnFilters.ToArray()));
-                }
+                filters.Add(addressColumnFilters.Count == 1
+                    ? addressColumnFilters[0]
+                    : new Conjunction(ConjunctionType.Or, addressColumnFilters.ToArray()));
             }
 
             if (toBlock.HasValue)

From 8921230e6b30b9aea862630988aa7d6a04569c13 Mon Sep 17 00:00:00 2001
From: daniel <4954577+jaensen@users.noreply.github.com>
Date: Tue, 4 Jun 2024 04:11:20 +0200
Subject: [PATCH 4/5] updated readme

---
 Readme.md | 310 ++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 300 insertions(+), 10 deletions(-)

diff --git a/Readme.md b/Readme.md
index 9f30ebe..0835799 100644
--- a/Readme.md
+++ b/Readme.md
@@ -3,9 +3,31 @@
 A [Nethermind](https://www.nethermind.io/nethermind-client) plugin to index and
 query [Circles](https://www.aboutcircles.com/) protocol events.
 
+* [Quickstart](#quickstart)
+    * [Query a node](#query-a-node)
+    * [Run a node](#run-a-node)
+        * [Clone the repository](#1-clone-the-repository)
+        * [Create a jwtsecret](#2-create-a-jwtsecret)
+        * [Set up the .env file](#3-set-up-the-env-file)
+        * [Run node](#4-run-node)
+            * [Ports](#ports)
+            * [Volumes](#volumes)
+    * [Run a spaceneth node](#run-a-spaceneth-node)
+        * [Deploying the Circles contracts](#deploying-the-circles-contracts)
+        * [Blockscout](#blockscout)
+        * [Get a funded account](#get-a-funded-account)
+        * [Manipulate time](#manipulate-time)
+        * [Reset the spaceneth node](#reset-the-spaceneth-node)
+* [Circles RPC methods](#circles-rpc-methods)
+    * [circles_getTotalBalance / circlesV2_getTotalBalance](#circles_gettotalbalance--circlesv2_gettotalbalance)
+    * [circles_getTokenBalance / circlesV2_getTokenBalances](#circles_gettokenbalance--circlesv2_gettokenbalances)
+    * [circles_query](#circles_query)
+    * [circles_events](#circles_events)
+    * [eth_subscribe("circles")](#eth_subscribecircles)
+
 ## Quickstart
 
-**Query a node**
+### Query a node
 
 If you're just looking for a way to query Circles events, you can check out the query examples:
 
@@ -15,7 +37,7 @@ If you're just looking for a way to query Circles events, you can check out the
 
 For a detailed description of the available RPC methods, see the [Circles RPC methods](#circles-rpc-methods) section.
 
-**Run a node**
+### Run a node
 
 The repository contains a docker-compose file to start a Nethermind node with the Circles plugin installed. There are
 configurations for Gnosis Chain, Chiado and Spaceneth (a local testnet).
@@ -23,14 +45,14 @@ configurations for Gnosis Chain, Chiado and Spaceneth (a local testnet).
 The quickstart configurations use [lighthouse](https://github.com/sigp/lighthouse) as consensus engine and spin up a
 postgres database to store the indexed data. The spaceneth configuration comes with a local blockscout instance.
 
-### 1. Clone the repository
+#### 1. Clone the repository
 
 ```bash
 git clone https://github.com/CirclesUBI/circles-nethermind-plugin.git
 cd circles-nethermind-plugin
 ```
 
-### 2. Create a jwtsecret
+#### 2. Create a jwtsecret
 
 For the use with Gnosis Chain and Chiado, a shared secret is required to authenticate requests between the execution and
 consensus engine.
@@ -47,7 +69,7 @@ mkdir -p ./.state/jwtsecret-chiado
 openssl rand -hex 32 > ./.state/jwtsecret-chiado/jwt.hex
 ```
 
-### 3. Set up the .env file
+#### 3. Set up the .env file
 
 Copy the `.env.example` file to `.env` and adjust the values to your needs.
 
@@ -55,7 +77,7 @@ Copy the `.env.example` file to `.env` and adjust the values to your needs.
 cp .env.example .env
 ```
 
-### 4. Run node
+#### 4. Run node
 
 Choose if your want to run your node on Gnosis Chain or Chiado.
 
@@ -73,7 +95,7 @@ That's it! The node must be fully synced before you can start querying the Circl
 Once synced you can use the node like any other RPC node, but with the added benefit of querying Circles events directly
 at the same RPC endpoint.
 
-#### Ports:
+##### Ports:
 
 * `30303/tcp` (nethermind p2p)
 * `30303/udp` (nethermind p2p)
@@ -83,7 +105,7 @@ at the same RPC endpoint.
 * `9000/udp` (consensus p2p)
 * `5054/tcp` (consensus metrics)
 
-#### Volumes
+##### Volumes
 
 * `./.state` - Directory containing all host mapped docker volumes
     * `./.state/consensus-chiado|consensus-chiado` - Lighthouse consensus engine data
@@ -91,7 +113,7 @@ at the same RPC endpoint.
     * `./.state/postgres-chiado|postgres-gnosis` - Postgres data
     * `./.state/jwtsecret-chiado|jwtsecret-gnosis` - Shared secret between execution and consensus engine
 
-### Spaceneth
+### Run a spaceneth node
 
 The process of setting up a local only node is a bit more involved. However, by using this approach, you gain
 the possibility to manipulate the node's time and don't need any xDai, which is useful for testing purposes.
@@ -228,10 +250,66 @@ and [v2-example-requests.md](v2-example-requests.md) files.
 
 These methods allow you to query the total Circles (v1/v2) holdings of an address.
 
+**Signature**:
+
+* `circles_getTotalBalance(address: string, asTimeCircles: bool = false)`.
+* `circlesV2_getTotalBalance(address: string, asTimeCircles: bool = false)`.
+
+#### Example
+
+```shell
+curl -X POST --data '{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "circles_getTotalBalance",
+  "params": [
+    "0xde374ece6fa50e781e81aac78e811b33d16912c7",
+    true
+  ]
+}' -H "Content-Type: application/json" http://localhost:8545/
+```
+
+#### Response
+
+This method returns a string formatted BigInteger value. The value is the sum of all Circles holdings of the address.
+
+If `asTimeCircles` is set to `true`, the value is formatted
+as [TimeCircles](https://github.com/CirclesUBI/timecircles) floating point number instead of the raw BigInteger value.
+
 ### circles_getTokenBalance / circlesV2_getTokenBalances
 
 These methods allow you to query all individual Circles (v1/v2) holdings of an address.
 
+**Signature**:
+
+* `circles_getTokenBalances(address: string, asTimeCircles: bool = false)`.
+* `circlesV2_getTokenBalances(address: string, asTimeCircles: bool = false)`.
+
+#### Example
+
+```shell
+curl -X POST --data '{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "circles_getTokenBalances",
+  "params": [
+    "0xde374ece6fa50e781e81aac78e811b33d16912c7",
+    true
+  ]
+}' -H "Content-Type: application/json" http://localhost:8545/
+```
+
+#### Response
+
+This method returns an array of objects with the following properties:
+
+* `tokenId` - The address of the token.
+* `balance` - The balance of the token.
+* `tokenOwner` - The address of the token owner.
+
+If `asTimeCircles` is set to `true`, the value is formatted
+as [TimeCircles](https://github.com/CirclesUBI/timecircles) floating point number instead of the raw BigInteger value.
+
 ### circles_query
 
 This method allows you to query Circles events. The method takes a single parameter, which is a JSON object with the
@@ -247,6 +325,46 @@ following properties:
 
 _NOTE: There is no default order, so make sure to always add sensible order columns._
 
+#### Example
+
+```shell
+curl -X POST --data '{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "circles_query",
+  "params": [
+    {
+      "Namespace": "V_Crc",
+      "Table": "Avatars",
+      "Limit": 100,
+      "Columns": [],
+      "Filter": [],
+      "Order": [
+        {
+          "Column": "blockNumber",
+          "SortOrder": "DESC"
+        },
+        {
+          "Column": "transactionIndex",
+          "SortOrder": "DESC"
+        },
+        {
+          "Column": "logIndex",
+          "SortOrder": "DESC"
+        }
+      ]
+    }
+  ]
+}' -H "Content-Type: application/json" http://localhost:8545/
+```
+
+#### Response
+
+The result is a JSON object that resembles a table with rows and columns:
+
+* `Columns` - An array of column names.
+* `Rows` - An array of rows, where each row is an array of values.
+
 #### Available namespaces, tables and columns
 
 Every table has at least the following columns:
@@ -312,4 +430,176 @@ Namespaces and tables:
 #### Pagination
 
 You can use the combination of `blockNumber`, `transactionIndex` and `logIndex`
-(+ `batchIndex` in the case of batch events) together with a `limit` to paginate through the results.
\ No newline at end of file
+(+ `batchIndex` in the case of batch events) together with a `limit` and order to paginate through the results.
+
+### circles_events
+
+Queries all events that involve a specific address. Can be used to e.g. easily populate a user's transaction history.
+
+**Signature**: `circles_events(address: string, fromBlock: number, toBlock?: number)`.
+
+The `fromBlock` and `toBlock` parameters can be used to filter the events by block number.
+The `toBlock` parameter can be set to `null` to query all events from `fromBlock` to the latest block.
+
+#### Example
+
+```shell
+curl -X POST --data '{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "circles_events",
+  "params": [
+    "0xde374ece6fa50e781e81aac78e811b33d16912c7",
+    30282299,
+    null
+  ]
+}' -H "Content-Type: application/json" http://localhost:8545/
+```
+
+#### Response
+
+The response generally contains the following fields:
+
+* `event` - The name of the event (See
+  [Available namespaces, tables and columns](#available-namespaces-tables-and-columns) for available event types).
+* `values` - The values of the event.
+
+The values contain at least the following fields:
+
+* `blockNumber` - The block number the event was emitted in.
+* `timestamp` - The unix timestamp of the event.
+* `transactionIndex` - The index of the transaction in the block.
+* `logIndex` - The index of the log in the transaction.
+* `transactionHash` - The hash of the transaction.
+
+### eth_subscribe("circles")
+
+Subscribes to all Circles events. The subscription is a stream of events that are emitted as soon as they've been
+indexed. Can be filtered to just a specific address.
+
+**Signature**: `eth_subscribe("circles", { address?: string })`.
+
+#### Example
+
+Copy the following code into an HTML file and open it in a browser to subscribe to Circles events.
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>WebSocket Circles Event Subscription</title>
+</head>
+<body>
+<h1>WebSocket Circles Event Subscription</h1>
+<div id="log"></div>
+
+<script>
+    class WebsocketConnection {
+        constructor(url) {
+            this.url = url;
+            this.websocket = null;
+            this.messageId = 0;
+            this.pendingResponses = {};
+            this.subscriptionListeners = {};
+        }
+
+        connect() {
+            return new Promise((resolve, reject) => {
+                this.websocket = new WebSocket(this.url);
+                this.websocket.onopen = () => {
+                    console.log('Connected');
+                    resolve();
+                };
+                this.websocket.onmessage = (event) => {
+                    const message = JSON.parse(event.data);
+                    const {id, method, params} = message;
+                    if (id !== undefined && this.pendingResponses[id]) {
+                        this.pendingResponses[id].resolve(message);
+                        delete this.pendingResponses[id];
+                    }
+                    if (method === 'eth_subscription' && params) {
+                        const {subscription, result} = params;
+                        if (this.subscriptionListeners[subscription]) {
+                            this.subscriptionListeners[subscription].forEach(listener => listener(result));
+                        }
+                    }
+                };
+                this.websocket.onclose = () => console.log('Disconnected');
+                this.websocket.onerror = (error) => {
+                    console.error('WebSocket error:', error);
+                    reject(error);
+                };
+            });
+        }
+
+        sendMessage(method, params, timeout = 5000) {
+            if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN) {
+                return Promise.reject('WebSocket is not connected');
+            }
+            const id = this.messageId++;
+            const message = {jsonrpc: "2.0", method, params, id};
+            return new Promise((resolve, reject) => {
+                this.pendingResponses[id] = {resolve, reject};
+                this.websocket.send(JSON.stringify(message));
+                setTimeout(() => {
+                    if (this.pendingResponses[id]) {
+                        this.pendingResponses[id].reject('Request timed out');
+                        delete this.pendingResponses[id];
+                    }
+                }, timeout);
+            });
+        }
+
+        async subscribe(method, params, listener) {
+            const response = await this.sendMessage('eth_subscribe', [method, params]);
+            const subscriptionId = response.result;
+            if (!this.subscriptionListeners[subscriptionId]) {
+                this.subscriptionListeners[subscriptionId] = [];
+            }
+            this.subscriptionListeners[subscriptionId].push(listener);
+            return subscriptionId;
+        }
+    }
+
+    const wsConnection = new WebsocketConnection('ws://localhost:8545');
+    const logElement = document.getElementById('log');
+
+    function log(message) {
+        const messageElement = document.createElement('div');
+        messageElement.textContent = message;
+        logElement.appendChild(messageElement);
+    }
+
+    (async () => {
+        try {
+            await wsConnection.connect();
+            log('Connected to websocket...');
+
+            // Subscribe to all Circles events:
+            const subscriptionArgs = JSON.stringify({});
+
+            // Subscribe to events for a specific address:
+            // const subscriptionArgs = JSON.stringify({"address": "0xde374ece6fa50e781e81aac78e811b33d16912c7"});
+
+            const subscriptionId = await wsConnection.subscribe('circles', subscriptionArgs), (
+            event
+        ) =>
+            {
+                log(`Circles event: ${JSON.stringify(event)}`);
+            }
+        )
+            ;
+            log(`Subscribed with ID: ${subscriptionId}`);
+        } catch (error) {
+        }
+    })();
+</script>
+</body>
+</html>
+```
+
+#### Response
+
+The emitted events are the same as the objects returned by the `circles_events` ([circles_events Response](#response-1))
+method.
\ No newline at end of file

From ce1170abbe652d56cb20ab90758a772586db76fd Mon Sep 17 00:00:00 2001
From: daniel <4954577+jaensen@users.noreply.github.com>
Date: Tue, 4 Jun 2024 04:11:49 +0200
Subject: [PATCH 5/5] bump assembly version to 1.2

---
 Circles.Index/Circles.Index.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Circles.Index/Circles.Index.csproj b/Circles.Index/Circles.Index.csproj
index 87692ac..10157a4 100644
--- a/Circles.Index/Circles.Index.csproj
+++ b/Circles.Index/Circles.Index.csproj
@@ -8,8 +8,8 @@
         <Authors>Daniel Janz (Gnosis Service GmbH)</Authors>
         <Copyright>Gnosis Service GmbH</Copyright>
         <Product>Circles</Product>
-        <AssemblyVersion>1.1</AssemblyVersion>
-        <FileVersion>1.1</FileVersion>
+        <AssemblyVersion>1.2</AssemblyVersion>
+        <FileVersion>1.2</FileVersion>
     </PropertyGroup>