From 2c7557ba0746edeaffb4542bbbf68a0a1f3521ce Mon Sep 17 00:00:00 2001
From: Milad Raeisi <6504337+miladsoft@users.noreply.github.com>
Date: Thu, 19 May 2022 00:40:00 +0430
Subject: [PATCH 01/11] change background-image in index.html (#145)

* change background-image in index.html

* Delete settings.json
---
 src/Blockcore.Indexer/wwwroot/css/Style.css   |   4 +-
 .../wwwroot/img/background.png                | Bin 7589 -> 4235 bytes
 src/Blockcore.Indexer/wwwroot/index.html      |  40 +++++++++---------
 3 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/Blockcore.Indexer/wwwroot/css/Style.css b/src/Blockcore.Indexer/wwwroot/css/Style.css
index 3b84fa2f..79871943 100644
--- a/src/Blockcore.Indexer/wwwroot/css/Style.css
+++ b/src/Blockcore.Indexer/wwwroot/css/Style.css
@@ -5,8 +5,8 @@ body {
    padding-right: 15%;
    padding-top: 40px;
    padding-bottom: 40px;
-   background-image: url(/img/background.png);
-   background-repeat: repeat;
+   background-image: url("/img/background.png");
+   background-repeat: repeat-x;
 }
 .flex-container {
    display: flex;
diff --git a/src/Blockcore.Indexer/wwwroot/img/background.png b/src/Blockcore.Indexer/wwwroot/img/background.png
index ec18a962b5c2dde73182ba06edf6a7a87af546a5..739b52c9f3d86fc92e9ad94f9a4dbe8395bcb103 100644
GIT binary patch
literal 4235
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

literal 7589
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
TD#lW`Uuo_dnCMsDdV=^L{Z;sl

diff --git a/src/Blockcore.Indexer/wwwroot/index.html b/src/Blockcore.Indexer/wwwroot/index.html
index 07109f8f..0765d6ac 100644
--- a/src/Blockcore.Indexer/wwwroot/index.html
+++ b/src/Blockcore.Indexer/wwwroot/index.html
@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html lang="en">
+
 <head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
@@ -8,27 +9,26 @@
    <link rel="icon" type="image/x-icon" href="/img/favicon.ico">
    <link rel="stylesheet" href="css/Style.css">
 </head>
+
 <body>
-   <div class="container">
-      <div class="flex-container">
-         <div class="card indexer-card">
-            <h3>Sync Progress</h3>
-            <p>
-            <div id="network">Please wait...</div>
-            <div id="progress"></div>
-            </p>
-            <a href="/" class="button"><span>refresh </span></a>
-         </div>
-         <div class="card indexer-card">
-            <h3>See details</h3>
-            <p>Click the link below for more details on blockchain and network</p>
-            <a href="/api/stats" target="_blank" class="button"><span>See details </span> </a>
-         </div>
-         <div class="card indexer-card">
-            <h3>API Documentation</h3>
-            <p>Click the link below to view the Indexer API Documentation</p>
-            <a href="/docs" target="_blank" class="button"><span>API Documentation </span></a>
-         </div>
+   <div class="flex-container">
+      <div class="card indexer-card">
+         <h3>Sync Progress</h3>
+         <p>
+         <div id="network">Please wait...</div>
+         <div id="progress"></div>
+         </p>
+         <a href="/" class="button"><span>refresh </span></a>
+      </div>
+      <div class="card indexer-card">
+         <h3>See details</h3>
+         <p>Click the link below for more details on blockchain and network</p>
+         <a href="/api/stats" target="_blank" class="button"><span>See details </span> </a>
+      </div>
+      <div class="card indexer-card">
+         <h3>API Documentation</h3>
+         <p>Click the link below to view the Indexer API Documentation</p>
+         <a href="/docs" target="_blank" class="button"><span>API Documentation </span></a>
       </div>
    </div>
    <script>

From 501bee213cd716b652d0fbbe3d26368a182fbe3d Mon Sep 17 00:00:00 2001
From: TheDude <davidgershony@gmail.com>
Date: Sat, 28 May 2022 21:24:09 +0100
Subject: [PATCH 02/11] Fixed typo to fit the Cirrus on release 1.1.44 (#146)

Co-authored-by: TheDude <david@vsodir.onmicrosoft.com>
---
 .../NonFungibleToken/NonFungibleTokenSmartContractBuilder.cs    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/NonFungibleTokenSmartContractBuilder.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/NonFungibleTokenSmartContractBuilder.cs
index a68ab242..f85cbf6b 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/NonFungibleTokenSmartContractBuilder.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/NonFungibleTokenSmartContractBuilder.cs
@@ -22,7 +22,7 @@ public NonFungibleTokenComputedTable BuildSmartContract(CirrusContractTable crea
          ContractCreateTransactionId = createContractTransaction.TransactionId,
          LastProcessedBlockHeight = createContractTransaction.BlockIndex,
          Name = (string)logs.Data["nftName"],
-         Symbol = (string)logs.Data["nftSymbole"],
+         Symbol =  (string)logs.Data["nftSymbol"],
          Owner = (string)logs.Data["nftOwner"],
          OwnerOnlyMinting = (bool)logs.Data["nftOwnerOnlyMinting"],
          Tokens = new List<Token>()

From 83f67f3dfb9ed0a70c50ff41d105d53e781ba832 Mon Sep 17 00:00:00 2001
From: TheDude <david@vsodir.onmicrosoft.com>
Date: Sat, 28 May 2022 21:30:25 +0100
Subject: [PATCH 03/11] Updated change log

---
 CHANGELOG.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe04f981..56bf17b9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,12 @@
-## <small>0.2.33 (2022-05-10)</small>
+## <small>0.2.34 (2022-05-28)</small>
+
+* change background-image in index.html (#145) ([2c7557b](https://github.com/block-core/blockcore-indexer/commit/2c7557b)), closes [#145](https://github.com/block-core/blockcore-indexer/issues/145)
+* Fixed typo to fit the Cirrus on release 1.1.44 (#146) ([501bee2](https://github.com/block-core/blockcore-indexer/commit/501bee2)), closes [#146](https://github.com/block-core/blockcore-indexer/issues/146)
+* Update version and changelog ([4c4a597](https://github.com/block-core/blockcore-indexer/commit/4c4a597))
+
+
+
+## <small>0.2.33 (2022-05-04)</small>
 
 * Add trx index to trx api (#139) ([f906d1e](https://github.com/block-core/blockcore-indexer/commit/f906d1e)), closes [#139](https://github.com/block-core/blockcore-indexer/issues/139)
 * Added NFT and asstets enpoints (#142) ([37601f8](https://github.com/block-core/blockcore-indexer/commit/37601f8)), closes [#142](https://github.com/block-core/blockcore-indexer/issues/142)

From 82f56606c23429f25123b9b5e34c0e95cfa0323f Mon Sep 17 00:00:00 2001
From: Dan Gershony <dan.gershony@gmail.com>
Date: Sun, 5 Jun 2022 22:09:26 +0100
Subject: [PATCH 04/11] Return confirmation count on block header (#148)

* Return confirmation count on block header

* fix possible null bug
---
 .../Storage/Mongo/MongoData.cs                 | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/Blockcore.Indexer.Core/Storage/Mongo/MongoData.cs b/src/Blockcore.Indexer.Core/Storage/Mongo/MongoData.cs
index 22a23488..84175a37 100644
--- a/src/Blockcore.Indexer.Core/Storage/Mongo/MongoData.cs
+++ b/src/Blockcore.Indexer.Core/Storage/Mongo/MongoData.cs
@@ -219,14 +219,28 @@ public SyncBlockInfo BlockByIndex(long blockIndex)
       {
          FilterDefinition<BlockTable> filter = Builders<BlockTable>.Filter.Eq(info => info.BlockIndex, blockIndex);
 
-         return mongoDb.BlockTable.Find(filter).ToList().Select(mongoBlockToStorageBlock.Map).FirstOrDefault();
+         SyncBlockInfo block = mongoDb.BlockTable.Find(filter).ToList().Select(mongoBlockToStorageBlock.Map).FirstOrDefault();
+
+         SyncBlockInfo tip = globalState.StoreTip;
+
+         if (tip != null && block != null)
+            block.Confirmations = tip.BlockIndex + 1 - block.BlockIndex;
+
+         return block;
       }
 
       public SyncBlockInfo BlockByHash(string blockHash)
       {
          FilterDefinition<BlockTable> filter = Builders<BlockTable>.Filter.Eq(info => info.BlockHash, blockHash);
 
-         return mongoDb.BlockTable.Find(filter).ToList().Select(mongoBlockToStorageBlock.Map).FirstOrDefault();
+         SyncBlockInfo block = mongoDb.BlockTable.Find(filter).ToList().Select(mongoBlockToStorageBlock.Map).FirstOrDefault();
+
+         SyncBlockInfo tip = globalState.StoreTip;
+
+         if (tip != null && block != null)
+            block.Confirmations = tip.BlockIndex + 1 - block.BlockIndex;
+
+         return block;
       }
 
       public QueryResult<QueryOrphanBlock> OrphanBlocks(int? offset, int limit)

From 719f891402bc1c04a12df7032cb57bcd0120a6f9 Mon Sep 17 00:00:00 2001
From: TheDude <davidgershony@gmail.com>
Date: Fri, 10 Jun 2022 10:25:51 +0100
Subject: [PATCH 05/11] Added caching for stats endpoint (#150)

* Added caching to mem cache of the stats response

* Use the block hash as indicator of changed state of the blockchain - this includes reorgs

* Changed the key to be a string

* Fixed hard coded key

Co-authored-by: TheDude <david@vsodir.onmicrosoft.com>
---
 .../Handlers/StatsHandler.cs                  | 34 +++++++++++--------
 .../Models/Statistics.cs                      |  2 ++
 2 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/src/Blockcore.Indexer.Core/Handlers/StatsHandler.cs b/src/Blockcore.Indexer.Core/Handlers/StatsHandler.cs
index 08d93d96..138eb9cf 100644
--- a/src/Blockcore.Indexer.Core/Handlers/StatsHandler.cs
+++ b/src/Blockcore.Indexer.Core/Handlers/StatsHandler.cs
@@ -14,6 +14,7 @@
 using Blockcore.Indexer.Core.Storage;
 using Blockcore.Indexer.Core.Storage.Types;
 using Blockcore.Networks;
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Options;
 
 namespace Blockcore.Indexer.Core.Handlers
@@ -36,6 +37,9 @@ public class StatsHandler
       readonly ICryptoClientFactory clientFactory;
       readonly GlobalState globalState;
 
+      readonly IMemoryCache cache;
+      const string Key = "Statistics";
+
       /// <summary>
       /// Initializes a new instance of the <see cref="StatsHandler"/> class.
       /// </summary>
@@ -46,11 +50,13 @@ public StatsHandler(
          IOptions<IndexerSettings> configuration,
          IOptions<ChainSettings> chainConfiguration,
          ICryptoClientFactory clientFactory,
-         GlobalState globalState)
+         GlobalState globalState,
+         IMemoryCache cache)
       {
          this.storage = storage;
          this.clientFactory = clientFactory;
          this.globalState = globalState;
+         this.cache = cache;
          syncConnection = connection;
          this.configuration = configuration.Value;
          this.chainConfiguration = chainConfiguration.Value;
@@ -130,6 +136,15 @@ public async Task<CoinInfo> CoinInformation()
 
       public async Task<Statistics> Statistics()
       {
+         var cachedStats = cache.Get<Statistics>(Key);
+
+         if (cachedStats != null &&
+             cachedStats.Blockchain.BestBlockHash == globalState.StoreTip.BlockHash)
+         {
+            return cachedStats;
+         }
+
+
          SyncConnection connection = syncConnection;
          var client = clientFactory.Create(connection);
          var stats = new Statistics { Symbol = syncConnection.Symbol };
@@ -168,19 +183,6 @@ public async Task<Statistics> Statistics()
                long totalSize = syncConnection.RecentItems.Sum(s => s.Size);
                stats.AvgBlockSizeKb = Math.Round((double)totalSize / syncConnection.RecentItems.Count, 0);
 
-               //var groupedByMin = syncConnection.RecentItems
-               //   //.GroupBy(g => g.Inserted.Hour + g.Inserted.Minute)
-               //   .OrderByDescending(o => o.Inserted)
-               //   .GroupBy(g => g.Inserted.Minute)
-               //   .Take(10)
-               //   .ToDictionary(s => s.Key,
-               //      s => s.ToList().Count);
-
-               //int totalBlocks = groupedByMin.Skip(1).Take(5).Sum(s => s.Value);
-               //int totalSecondsPerBlok = groupedByMin.Skip(1).Take(5).Count();
-
-               //stats.BlocksPerMinute = (int)Math.Round((double)totalBlocks / totalSecondsPerBlok);
-
                stats.BlocksPerMinute = syncConnection.RecentItems.Count(w => w.Inserted > DateTime.UtcNow.AddMinutes(-1));
             }
          }
@@ -189,6 +191,10 @@ public async Task<Statistics> Statistics()
             stats.Progress = ex.Message;
          }
 
+         stats.IsInIBDMode = globalState.IbdMode();
+
+         cache.Set(Key,stats);
+
          return stats;
       }
 
diff --git a/src/Blockcore.Indexer.Core/Models/Statistics.cs b/src/Blockcore.Indexer.Core/Models/Statistics.cs
index c7da9862..6ed9c01e 100644
--- a/src/Blockcore.Indexer.Core/Models/Statistics.cs
+++ b/src/Blockcore.Indexer.Core/Models/Statistics.cs
@@ -131,5 +131,7 @@ public class Statistics
 
       public string Error { get; set; }
 
+      public bool IsInIBDMode { get; set; }
+
    }
 }

From 7e65edf727a725ff4dca5c7b0e6695d43f3b4f25 Mon Sep 17 00:00:00 2001
From: Milad Raeisi <6504337+miladsoft@users.noreply.github.com>
Date: Fri, 24 Jun 2022 13:15:28 +0430
Subject: [PATCH 06/11] Update Swashbuckle package (#152)

---
 src/Blockcore.Indexer.Core/Blockcore.Indexer.Core.csproj | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Blockcore.Indexer.Core/Blockcore.Indexer.Core.csproj b/src/Blockcore.Indexer.Core/Blockcore.Indexer.Core.csproj
index e6429db7..c7605401 100644
--- a/src/Blockcore.Indexer.Core/Blockcore.Indexer.Core.csproj
+++ b/src/Blockcore.Indexer.Core/Blockcore.Indexer.Core.csproj
@@ -6,10 +6,10 @@
       <PackageReference Include="Microsoft.Extensions.PlatformAbstractions" Version="1.1.0" />
       <PackageReference Include="MongoDB.Driver" Version="2.14.1" />
       <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-      <PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
-      <PackageReference Include="Swashbuckle.AspNetCore.Annotations" Version="6.2.3" />
-      <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" Version="6.2.3" />
-      <PackageReference Include="Swashbuckle.AspNetCore.Swagger" Version="6.2.3" />
+      <PackageReference Include="Swashbuckle.AspNetCore" Version="6.3.1" />
+      <PackageReference Include="Swashbuckle.AspNetCore.Annotations" Version="6.3.1" />
+      <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" Version="6.3.1" />
+      <PackageReference Include="Swashbuckle.AspNetCore.Swagger" Version="6.3.1" />
    </ItemGroup>
    <ItemGroup>
      <PackageReference Update="Microsoft.SourceLink.GitHub" Version="1.1.1" />

From f62dc875798b532315384ede90436069b977c21f Mon Sep 17 00:00:00 2001
From: TheDude <david@vsodir.onmicrosoft.com>
Date: Fri, 24 Jun 2022 10:17:02 +0100
Subject: [PATCH 07/11] Updated version

---
 CHANGELOG.md              | 9 +++++++++
 package.json              | 2 +-
 src/Directory.Build.props | 2 +-
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 56bf17b9..c1fdb770 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,17 @@
+## <small>0.2.35 (2022-06-24)</small>
+
+* Added caching for stats endpoint (#150) ([719f891](https://github.com/block-core/blockcore-indexer/commit/719f891)), closes [#150](https://github.com/block-core/blockcore-indexer/issues/150)
+* Return confirmation count on block header (#148) ([82f5660](https://github.com/block-core/blockcore-indexer/commit/82f5660)), closes [#148](https://github.com/block-core/blockcore-indexer/issues/148)
+* Update Swashbuckle package (#152) ([7e65edf](https://github.com/block-core/blockcore-indexer/commit/7e65edf)), closes [#152](https://github.com/block-core/blockcore-indexer/issues/152)
+
+
+
 ## <small>0.2.34 (2022-05-28)</small>
 
 * change background-image in index.html (#145) ([2c7557b](https://github.com/block-core/blockcore-indexer/commit/2c7557b)), closes [#145](https://github.com/block-core/blockcore-indexer/issues/145)
 * Fixed typo to fit the Cirrus on release 1.1.44 (#146) ([501bee2](https://github.com/block-core/blockcore-indexer/commit/501bee2)), closes [#146](https://github.com/block-core/blockcore-indexer/issues/146)
 * Update version and changelog ([4c4a597](https://github.com/block-core/blockcore-indexer/commit/4c4a597))
+* Updated change log ([83f67f3](https://github.com/block-core/blockcore-indexer/commit/83f67f3))
 
 
 
diff --git a/package.json b/package.json
index 1adf143c..49c3b9c1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "blockcoreindexer",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "license": "MIT",
   "author": {
     "name": "Blockcore",
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index 368a7f29..e7e01eaa 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
    <PropertyGroup>
-      <Version>0.2.34</Version>
+      <Version>0.2.35</Version>
       <TargetFramework>net6.0</TargetFramework>
       <Authors>Blockcore</Authors>
       <PackageLicenseExpression>MIT</PackageLicenseExpression>

From 312c206a85ce08164ea766725d9e48b9eb7504fa Mon Sep 17 00:00:00 2001
From: TheDude <davidgershony@gmail.com>
Date: Mon, 4 Jul 2022 10:33:28 +0100
Subject: [PATCH 08/11] Changed smart contracts to be seperate token and
 contract (#153)

* Fixed login on generic service to support NFT as well.

* Deleted explicit code for NFT token (all is in the generic service now)

* First step of changing smart contract saving of tokens to another document

* Changed tokens to another table and fixing of debug issues - not complete

* Fixed issued with the auction events

* Fixed the OnSale event updating

* Changed the assets endpoint to get data from the tokens table

* Fixed token filter by id endpoint

* Fixed the Dao smart contract to work with split tables

* Fixed standard contract to work with split tables

* Moved all smart contracts to one table

* Deleted commented code

* Fixed the logic in the runner to update smart contracts periodically

* Fixed error message and added delay time

* Fixed issue with lookup

* Fixed API endpoints

* Added rewind logic for smart contracts

* Fix for change in the NFT store smart contract

* Renamed methods

* Added endpoint that lists tokens for an owner address

* Minor changes after PR

Co-authored-by: TheDude <david@vsodir.onmicrosoft.com>
---
 .../Storage/Mongo/CirrusMongoDbMock.cs        |  10 +-
 .../Mongo/ComputeSmartContractServiceTests.cs |  13 +-
 src/Blockcore.Indexer.Cirrus/CirrusStartup.cs |  36 ++-
 .../Client/Types/ContractReceiptResponse.cs   |   2 +
 .../Controllers/CirrusQueryController.cs      |  35 +-
 .../Models/QueryDAOContract.cs                |  16 +
 .../Models/QueryNonFungibleTokenContract.cs   |  15 +
 .../Models/QueryStandardToken.cs              |  12 +
 .../Models/QueryStandardTokenContract.cs      |  18 ++
 .../Storage/ICirrusStorage.cs                 |  11 +-
 .../Mongo/CirrusBlockRewindOperation.cs       |  39 +++
 .../Storage/Mongo/CirrusMongoBuilder.cs       |  23 +-
 .../Storage/Mongo/CirrusMongoData.cs          | 305 +++++++++++++++---
 .../Storage/Mongo/CirrusMongoDb.cs            |  46 ++-
 .../Storage/Mongo/ICirrusMongoDb.cs           |  13 +-
 ...SmartContractServiceWithSplitDocuments.cs} | 135 ++++----
 .../Dao/AddToWhiteListLogReader.cs            |  11 +-
 .../Dao/BlacklistAddressesLogReader.cs        |   9 +-
 .../Dao/CreateProposalLogReader.cs            |  22 +-
 .../Dao/DaoSmartContractBuilder.cs            |   4 +-
 .../SmartContracts/Dao/DepositLogReader.cs    |  19 +-
 .../Dao/ExecuteProposalLogReader.cs           |  23 +-
 .../Dao/GetOrPropertyCallsLogReader.cs        |  11 +-
 .../Dao/UpdateMaxVotingDurationLogReader.cs   |  13 +-
 .../Dao/UpdateMinVotingDurationLogReader.cs   |  12 +-
 .../Mongo/SmartContracts/Dao/VoteLogReader.cs |  52 ++-
 .../IComputeSmartContractService.cs           |   4 +-
 .../SmartContracts/IContractDataReader.cs     |  25 ++
 .../Mongo/SmartContracts/ILogReader.cs        |   6 +-
 .../SmartContracts/ISmartContractBuilder.cs   |   2 +-
 .../ISmartContractHandlersFactory.cs          |   6 +-
 .../ISmartContractTransactionsLookup.cs       |  11 +
 .../SmartContracts/NFTComputedService.cs      | 140 --------
 .../NonFungibleToken/BurnLogReader.cs         |  16 +-
 .../ClaimOwnershipLogReader.cs                |   8 +-
 .../NonFungibleToken/MintLogReader.cs         |  16 +-
 .../NonFungibleTokenSmartContractBuilder.cs   |   5 +-
 .../NonFungibleToken/PendingOwnerLogReader.cs |   9 +-
 .../NonFungibleToken/SafeMintLogReader.cs     |  16 +-
 .../SafeTransferFromLogReader.cs              |  16 +-
 .../NonFungibleToken/SalesEventReader.cs      |  18 +-
 .../NonFungibleToken/TransferLogReader.cs     |  20 +-
 .../AuctionEndLogReader.cs                    |  68 +++-
 .../NonFungibleTokenAuction/BidLogReader.cs   |  47 ++-
 ...bleTokenSmartContractTransactionsLookup.cs |  30 ++
 .../NonFungibleTokenStore/BuyLogReader.cs     |  52 ++-
 .../CancelSaleLogReader.cs                    |  36 ++-
 .../SmartContractHandlersFactory.cs           |  11 +-
 .../SmartContractTransactionsLookup.cs        |  26 ++
 .../StandardToken/GetOrPropertyLogReader.cs   |   9 +-
 .../StandardTokenSmartContractBuilder.cs      |  23 +-
 .../StandardToken/TransferFromLogReader.cs    |  32 --
 .../TransferToAndFromLogReader.cs             |  76 +++++
 .../StandardToken/TransferToLogReader.cs      |  55 ----
 .../Mongo/Types/CirrusContractCodeTable.cs    |   4 +-
 .../Storage/Mongo/Types/DaoContractDeposit.cs |   1 +
 ...roposal.cs => DaoContractProposalTable.cs} |   3 +-
 ...ctComputedTable.cs => DaoContractTable.cs} |   7 +-
 ...le.cs => NonFungibleTokenContractTable.cs} |   7 +-
 .../{Token.cs => NonFungibleTokenTable.cs}    |   4 +-
 .../Storage/Mongo/Types/Sale.cs               |   1 +
 .../Storage/Mongo/Types/SmartContractData.cs  |   9 +
 ...tComputedBase.cs => SmartContractTable.cs} |   5 +-
 .../Mongo/Types/SmartContractTokenId.cs       |   7 +
 .../Mongo/Types/StandardTokenAmountChange.cs  |   8 +
 .../Mongo/Types/StandardTokenComputedTable.cs |  19 --
 .../Mongo/Types/StandardTokenContractTable.cs |  14 +
 .../Mongo/Types/StandardTokenHolder.cs        |   7 -
 .../Mongo/Types/StandardTokenHolderTable.cs   |   9 +
 .../Sync/SyncTasks/SmartContractSyncRunner.cs |  95 ++++++
 src/Blockcore.Indexer.Core/Startup.cs         |   2 +
 .../Storage/Mongo/BlockRewindOperation.cs     |  13 +-
 .../Storage/Mongo/IBlockRewindOperation.cs    |   8 +
 .../Storage/Mongo/MongoData.cs                |   7 +-
 .../Mongo/MongoStorageOperationsTests.cs      |   6 +-
 75 files changed, 1286 insertions(+), 638 deletions(-)
 create mode 100644 src/Blockcore.Indexer.Cirrus/Models/QueryDAOContract.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Models/QueryNonFungibleTokenContract.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Models/QueryStandardToken.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Models/QueryStandardTokenContract.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusBlockRewindOperation.cs
 rename src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/{ComputeSmartContractService.cs => ComputeSmartContractServiceWithSplitDocuments.cs} (56%)
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/IContractDataReader.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractTransactionsLookup.cs
 delete mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NFTComputedService.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenSmartContractTransactionsLookup.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/SmartContractTransactionsLookup.cs
 delete mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferFromLogReader.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferToAndFromLogReader.cs
 delete mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferToLogReader.cs
 rename src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/{DaoContractProposal.cs => DaoContractProposalTable.cs} (88%)
 rename src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/{DaoContractComputedTable.cs => DaoContractTable.cs} (67%)
 rename src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/{NonFungibleTokenComputedTable.cs => NonFungibleTokenContractTable.cs} (65%)
 rename src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/{Token.cs => NonFungibleTokenTable.cs} (85%)
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractData.cs
 rename src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/{SmartContractComputedBase.cs => SmartContractTable.cs} (71%)
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractTokenId.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenAmountChange.cs
 delete mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenComputedTable.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenContractTable.cs
 delete mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenHolder.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenHolderTable.cs
 create mode 100644 src/Blockcore.Indexer.Cirrus/Sync/SyncTasks/SmartContractSyncRunner.cs
 create mode 100644 src/Blockcore.Indexer.Core/Storage/Mongo/IBlockRewindOperation.cs

diff --git a/src/Blockcore.Indexer.Cirrus.Tests/Storage/Mongo/CirrusMongoDbMock.cs b/src/Blockcore.Indexer.Cirrus.Tests/Storage/Mongo/CirrusMongoDbMock.cs
index b023af03..638cd8ca 100644
--- a/src/Blockcore.Indexer.Cirrus.Tests/Storage/Mongo/CirrusMongoDbMock.cs
+++ b/src/Blockcore.Indexer.Cirrus.Tests/Storage/Mongo/CirrusMongoDbMock.cs
@@ -14,8 +14,8 @@ public class CirrusMongoDbMock : MongodbMock
    public Mock<IMongoQueryable<CirrusContractTable>> CirrusContractTableQuariable;
    public Mock<IMongoCollection<CirrusContractCodeTable>> CirrusContractCodeTableCollection;
    public Mock<IMongoQueryable<CirrusContractCodeTable>> CirrusContractCodeTableQuariable;
-   public Mock<IMongoCollection<DaoContractComputedTable>> DaoContractComputedTableCollection;
-   public Mock<IMongoQueryable<DaoContractComputedTable>> DaoContractComputedTableQuariable;
+   public Mock<IMongoCollection<DaoContractTable>> DaoContractComputedTableCollection;
+   public Mock<IMongoQueryable<DaoContractTable>> DaoContractComputedTableQuariable;
 
    private Mock<ICirrusMongoDb> cirrusDb;
 
@@ -25,15 +25,15 @@ public CirrusMongoDbMock()
       CirrusContractTableCollection = new Mock<IMongoCollection<CirrusContractTable>>();
       CirrusContractTableQuariable = new Mock<IMongoQueryable<CirrusContractTable>>();
       CirrusContractCodeTableCollection = new Mock<IMongoCollection<CirrusContractCodeTable>>();
-      DaoContractComputedTableCollection = new Mock<IMongoCollection<DaoContractComputedTable>>();
+      DaoContractComputedTableCollection = new Mock<IMongoCollection<DaoContractTable>>();
 
       cirrusDb = new Mock<ICirrusMongoDb>();
 
       cirrusDb.Setup(_ => _.CirrusContractTable).Returns(CirrusContractTableCollection.Object);
       cirrusDb.Setup(_ => _.CirrusContractCodeTable).Returns(CirrusContractCodeTableCollection.Object);
-      cirrusDb.Setup(_ => _.DaoContractComputedTable).Returns(DaoContractComputedTableCollection.Object);
+      cirrusDb.Setup(_ => _.DaoContractTable).Returns(DaoContractComputedTableCollection.Object);
 
-      cirrusDb.Setup(_ => _.DaoContractComputedTable.Database)
+      cirrusDb.Setup(_ => _.DaoContractTable.Database)
         .Returns(MongoDatabaseObject);
       
      DaoContractComputedTableCollection.Setup(_ => _.Settings)
diff --git a/src/Blockcore.Indexer.Cirrus.Tests/Storage/Mongo/ComputeSmartContractServiceTests.cs b/src/Blockcore.Indexer.Cirrus.Tests/Storage/Mongo/ComputeSmartContractServiceTests.cs
index b62c589c..914d9179 100644
--- a/src/Blockcore.Indexer.Cirrus.Tests/Storage/Mongo/ComputeSmartContractServiceTests.cs
+++ b/src/Blockcore.Indexer.Cirrus.Tests/Storage/Mongo/ComputeSmartContractServiceTests.cs
@@ -17,7 +17,7 @@ namespace Blockcore.Indexer.Cirrus.Tests.Storage.Mongo;
 
 public class ComputeSmartContractServiceTests
 {
-   ComputeSmartContractService<DaoContractComputedTable> sut;
+   ComputeSmartContractServiceWithSplitDocuments<DaoContractTable,DaoContractProposalTable> sut;
 
    CirrusMongoDbMock mongoDbMock;
 
@@ -60,17 +60,14 @@ public ComputeSmartContractServiceTests()
          chainSetting.Object, networkSettings.Object);
 
 
-      sut = new ComputeSmartContractService<DaoContractComputedTable>(null, mongoDbMock.CirrusMongoDbObject,
-         new Mock<ISmartContractHandlersFactory<DaoContractComputedTable>>().Object, new Mock<ICryptoClientFactory>().Object, syncConnection,
-         Mock.Of<IMongoDatabase>());
+      sut = new ComputeSmartContractServiceWithSplitDocuments<DaoContractTable, DaoContractProposalTable>(null, mongoDbMock.CirrusMongoDbObject,
+         new Mock<ISmartContractHandlersFactory<DaoContractTable,DaoContractProposalTable>>().Object, new Mock<ICryptoClientFactory>().Object, syncConnection,
+         Mock.Of<IMongoDatabase>(), new Mock<ISmartContractTransactionsLookup<DaoContractTable>>().Object);
    }
 
    //[Fact]
    public async Task WhenTheContractIsNotFountAnTheTrandactionIsNotFoundReturnsNull()
    {
-      var result = await sut.ComputeSmartContractForAddressAsync(Guid.NewGuid().ToString());
-
-
-      Assert.Null(result);
+       await sut.ComputeSmartContractForAddressAsync(Guid.NewGuid().ToString());
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/CirrusStartup.cs b/src/Blockcore.Indexer.Cirrus/CirrusStartup.cs
index 04222107..7f5ccc2e 100644
--- a/src/Blockcore.Indexer.Cirrus/CirrusStartup.cs
+++ b/src/Blockcore.Indexer.Cirrus/CirrusStartup.cs
@@ -9,6 +9,7 @@
 using Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using Blockcore.Indexer.Cirrus.Sync.SyncTasks;
 using Blockcore.Indexer.Core;
 using Blockcore.Indexer.Core.Client;
 using Blockcore.Indexer.Core.Crypto;
@@ -63,25 +64,36 @@ public void ConfigureServices(IServiceCollection services)
             .AddApplicationPart(typeof(Startup).Assembly)
             .AddControllersAsServices();
 
-         services.AddTransient<IComputeSmartContractService<NonFungibleTokenComputedTable>,NftComputationService>();
-         services.AddTransient(typeof(IComputeSmartContractService<>),typeof(ComputeSmartContractService<>));
-         services.AddTransient(typeof(ISmartContractHandlersFactory<>),typeof(SmartContractHandlersFactory<>));
+         services.AddTransient<IComputeSmartContractService<DaoContractTable>,ComputeSmartContractServiceWithSplitDocuments<DaoContractTable,DaoContractProposalTable>>();
+         services.AddTransient<IComputeSmartContractService<StandardTokenContractTable>,ComputeSmartContractServiceWithSplitDocuments<StandardTokenContractTable,StandardTokenHolderTable>>();
+         services.AddTransient<IComputeSmartContractService<NonFungibleTokenContractTable>,ComputeSmartContractServiceWithSplitDocuments<NonFungibleTokenContractTable,NonFungibleTokenTable>>();
 
-         ScanAssemblyAndRegisterTypeByNameAsTransient(services, typeof(ILogReader<DaoContractComputedTable>),
-            typeof(ILogReader<>).Assembly);
-         ScanAssemblyAndRegisterTypeByNameAsTransient(services, typeof(ILogReader<StandardTokenComputedTable>),
-            typeof(ILogReader<>).Assembly);
-         ScanAssemblyAndRegisterTypeByNameAsTransient(services, typeof(ILogReader<NonFungibleTokenComputedTable>),
-            typeof(ILogReader<>).Assembly);
+         services.AddTransient<ISmartContractTransactionsLookup<NonFungibleTokenContractTable>,NonFungibleTokenSmartContractTransactionsLookup>();
+         services.AddTransient(typeof(ISmartContractTransactionsLookup<>), typeof(SmartContractTransactionsLookup<>));
+
+
+
+         ScanAssemblyAndRegisterTypeByNameAsTransient(services, typeof(ILogReader<DaoContractTable,DaoContractProposalTable>),
+            typeof(ILogReader<DaoContractTable,DaoContractProposalTable>).Assembly);
+         ScanAssemblyAndRegisterTypeByNameAsTransient(services, typeof(ILogReader<StandardTokenContractTable,StandardTokenHolderTable>),
+            typeof(ILogReader<StandardTokenContractTable,StandardTokenHolderTable>).Assembly);
+         ScanAssemblyAndRegisterTypeByNameAsTransient(services, typeof(ILogReader<NonFungibleTokenContractTable,NonFungibleTokenTable>),
+            typeof(ILogReader<NonFungibleTokenContractTable,NonFungibleTokenTable>).Assembly);
+
+         services.AddTransient<ISmartContractHandlersFactory<DaoContractTable,DaoContractProposalTable>,SmartContractHandlersFactory<DaoContractTable,DaoContractProposalTable>>();
+         services.AddTransient<ISmartContractHandlersFactory<StandardTokenContractTable,StandardTokenHolderTable>,SmartContractHandlersFactory<StandardTokenContractTable,StandardTokenHolderTable>>();
+         services.AddTransient<ISmartContractHandlersFactory<NonFungibleTokenContractTable,NonFungibleTokenTable>,SmartContractHandlersFactory<NonFungibleTokenContractTable,NonFungibleTokenTable>>();
 
          RegisterSmartContractBuilder(services); //No need to scan the assembly as there won't be that many
+
+         services.AddScoped<TaskRunner,SmartContractSyncRunner>();
       }
 
       private static IServiceCollection RegisterSmartContractBuilder(IServiceCollection collection)
       {
-         collection.AddTransient<ISmartContractBuilder<DaoContractComputedTable>, DaoSmartContractBuilder>();
-         collection.AddTransient<ISmartContractBuilder<StandardTokenComputedTable>, StandardTokenSmartContractBuilder>();
-         collection.AddTransient<ISmartContractBuilder<NonFungibleTokenComputedTable>, NonFungibleTokenSmartContractBuilder>();
+         collection.AddTransient<ISmartContractBuilder<DaoContractTable>, DaoSmartContractBuilder>();
+         collection.AddTransient<ISmartContractBuilder<StandardTokenContractTable>, StandardTokenSmartContractBuilder>();
+         collection.AddTransient<ISmartContractBuilder<NonFungibleTokenContractTable>, NonFungibleTokenSmartContractBuilder>();
          return collection;
       }
 
diff --git a/src/Blockcore.Indexer.Cirrus/Client/Types/ContractReceiptResponse.cs b/src/Blockcore.Indexer.Cirrus/Client/Types/ContractReceiptResponse.cs
index 671e0838..fe324daf 100644
--- a/src/Blockcore.Indexer.Cirrus/Client/Types/ContractReceiptResponse.cs
+++ b/src/Blockcore.Indexer.Cirrus/Client/Types/ContractReceiptResponse.cs
@@ -12,5 +12,7 @@ public class ContractReceiptResponse : ReceiptResponse
       public ulong GasPrice { get; set; }
       public ulong Amount { get; set; }
       public ulong ContractBalance { get; set; }
+
+      public Dictionary<string, object> ContractData { get; set; }
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Controllers/CirrusQueryController.cs b/src/Blockcore.Indexer.Cirrus/Controllers/CirrusQueryController.cs
index d93dee3a..cf10ffa1 100644
--- a/src/Blockcore.Indexer.Cirrus/Controllers/CirrusQueryController.cs
+++ b/src/Blockcore.Indexer.Cirrus/Controllers/CirrusQueryController.cs
@@ -20,15 +20,15 @@ public class CirrusQueryController : Controller
    {
       private readonly IPagingHelper paging;
       private readonly ICirrusStorage cirrusMongoData;
-      readonly IComputeSmartContractService<DaoContractComputedTable> daoContractService;
-      readonly IComputeSmartContractService<StandardTokenComputedTable> standardTokenService;
-      readonly IComputeSmartContractService<NonFungibleTokenComputedTable> nonFungibleTokenService;
+      readonly IComputeSmartContractService<DaoContractTable> daoContractService;
+      readonly IComputeSmartContractService<StandardTokenContractTable> standardTokenService;
+      readonly IComputeSmartContractService<NonFungibleTokenContractTable> nonFungibleTokenService;
 
       /// <summary>
       /// Initializes a new instance of the <see cref="QueryController"/> class.
       /// </summary>
       public CirrusQueryController(IPagingHelper paging,
-         IComputeSmartContractService<DaoContractComputedTable> daoContractAggregator, ICirrusStorage cirrusMongoData, IComputeSmartContractService<StandardTokenComputedTable> standardTokenService, IComputeSmartContractService<NonFungibleTokenComputedTable> nonFungibleTokenService)
+         IComputeSmartContractService<DaoContractTable> daoContractAggregator, ICirrusStorage cirrusMongoData, IComputeSmartContractService<StandardTokenContractTable> standardTokenService, IComputeSmartContractService<NonFungibleTokenContractTable> nonFungibleTokenService)
       {
          this.paging = paging;
          daoContractService = daoContractAggregator;
@@ -52,10 +52,17 @@ public IActionResult GetContracts([MinLength(2)][MaxLength(100)] string contract
       }
 
       [HttpGet]
-      [Route("{address}/assets")]
-      public IActionResult GetAddressAssets([MinLength(30)][MaxLength(100)] string address, [Range(0, long.MaxValue)] int? offset = 0, [Range(1, 50)] int limit = 10)
+      [Route("collectables/{ownerAddress}")]
+      public IActionResult GetAddressAssets([MinLength(30)][MaxLength(100)] string ownerAddress, [Range(0, long.MaxValue)] int? offset = 0, [Range(1, 50)] int limit = 10)
       {
-         return Ok(cirrusMongoData.GetAssetsForAddressAsync(address,offset,limit).Result);
+         return Ok(cirrusMongoData.GetNonFungibleTokensForAddressAsync(ownerAddress,offset,limit).Result);
+      }
+
+      [HttpGet]
+      [Route("tokens/{ownerAddress}")]
+      public IActionResult GettokensForAddress([MinLength(30)][MaxLength(100)] string ownerAddress, [Range(0, long.MaxValue)] int? offset = 0, [Range(1, 50)] int limit = 10)
+      {
+         return Ok(cirrusMongoData.GetStandardTokensForAddressAsync(ownerAddress,offset,limit).Result);
       }
 
       [HttpGet]
@@ -98,7 +105,7 @@ public IActionResult GetContractCode([MinLength(30)][MaxLength(100)] string addr
       [SlowRequestsFilteerAttribute]
       public async Task<IActionResult> GetDaoContractByAddress([MinLength(30)][MaxLength(100)] string address)
       {
-         var contract = await daoContractService.ComputeSmartContractForAddressAsync(address);
+         var contract = await cirrusMongoData.GetDaoContractByAddressAsync(address);
 
          if (contract is null)
          {
@@ -113,7 +120,7 @@ public async Task<IActionResult> GetDaoContractByAddress([MinLength(30)][MaxLeng
       [SlowRequestsFilteerAttribute]
       public async Task<IActionResult> GetStandardTokenContractByAddress([MinLength(30)][MaxLength(100)] string address)
       {
-         var contract = await standardTokenService.ComputeSmartContractForAddressAsync(address);
+         var contract = await cirrusMongoData.GetStandardTokenContractByAddressAsync(address);
 
          if (contract is null)
          {
@@ -128,15 +135,13 @@ public async Task<IActionResult> GetStandardTokenContractByAddress([MinLength(30
       [SlowRequestsFilteerAttribute]
       public async Task<IActionResult> GetStandardTokenContractByAddress([MinLength(30)][MaxLength(100)] string address, [MinLength(30)][MaxLength(100)] string filterAddress)
       {
-         var contract = await standardTokenService.ComputeSmartContractForAddressAsync(address);
+         var contract = await cirrusMongoData.GetStandardTokenByIdAsync(address, filterAddress);
 
          if (contract is null)
          {
             return NotFound();
          }
 
-         contract.TokenHolders = contract.TokenHolders.Where(t => t.Address == filterAddress).ToList();
-
          return Ok(contract);
       }
 
@@ -145,7 +150,7 @@ public async Task<IActionResult> GetStandardTokenContractByAddress([MinLength(30
       [SlowRequestsFilteerAttribute]
       public async Task<IActionResult> GetNonFungibleTokenContractByAddress([MinLength(30)][MaxLength(100)] string address)
       {
-         var contract = await nonFungibleTokenService.ComputeSmartContractForAddressAsync(address);
+         var contract = await cirrusMongoData.GetNonFungibleTokenContractByAddressAsync(address);
 
          if (contract is null)
          {
@@ -161,9 +166,7 @@ public async Task<IActionResult> GetNonFungibleTokenContractByAddress([MinLength
       public async Task<IActionResult> GetNonFungibleTokenById([MinLength(30)][MaxLength(100)] string address,
          [MinLength(1)][MaxLength(100)] string id)
       {
-         var contract = await nonFungibleTokenService.ComputeSmartContractForAddressAsync(address);
-
-         var token = contract.Tokens.FirstOrDefault(_ => _.Id == id);
+         var token = await cirrusMongoData.GetNonFungibleTokenByIdAsync(address, id);
 
          if (token is null)
          {
diff --git a/src/Blockcore.Indexer.Cirrus/Models/QueryDAOContract.cs b/src/Blockcore.Indexer.Cirrus/Models/QueryDAOContract.cs
new file mode 100644
index 00000000..ec61aae4
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Models/QueryDAOContract.cs
@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+
+namespace Blockcore.Indexer.Cirrus.Models;
+
+public class QueryDAOContract
+{
+   public long CurrentAmount { get; set; }
+   public long MaxVotingDuration { get; set; }
+   public long MinVotingDuration { get; set; }
+   public long WhitelistedCount { get; set; }
+   public List<DaoContractDeposit> Deposits { get; set; }
+   public List<DaoContractProposalTable> Proposals { get; set; }
+   public List<string> ApprovedAddresses { get; set; }
+
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Models/QueryNonFungibleTokenContract.cs b/src/Blockcore.Indexer.Cirrus/Models/QueryNonFungibleTokenContract.cs
new file mode 100644
index 00000000..13604f3d
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Models/QueryNonFungibleTokenContract.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+
+namespace Blockcore.Indexer.Cirrus.Models;
+
+public class QueryNonFungibleTokenContract
+{
+   public string Name { get; set; }
+   public string Symbol { get; set; }
+   public string Owner { get; set; }
+   public bool OwnerOnlyMinting { get; set; }
+   public string PendingOwner { get; set; }
+   public List<string> PreviousOwners { get; set; }
+   public List<NonFungibleTokenTable> Tokens { get; set; }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Models/QueryStandardToken.cs b/src/Blockcore.Indexer.Cirrus/Models/QueryStandardToken.cs
new file mode 100644
index 00000000..4d029ab3
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Models/QueryStandardToken.cs
@@ -0,0 +1,12 @@
+namespace Blockcore.Indexer.Cirrus.Models;
+
+public class QueryStandardToken
+{
+   public string Name { get; set; }
+
+   public string Symbol { get; set; }
+
+   public long TotalSupply { get; set; }
+   public string Address { get; set; }
+   public long Amount { get; set; }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Models/QueryStandardTokenContract.cs b/src/Blockcore.Indexer.Cirrus/Models/QueryStandardTokenContract.cs
new file mode 100644
index 00000000..c5799507
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Models/QueryStandardTokenContract.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+
+namespace Blockcore.Indexer.Cirrus.Models;
+
+public class QueryStandardTokenContract
+{
+   public string Name { get; set; }
+
+   public string Symbol { get; set; }
+
+   public long TotalSupply { get; set; }
+
+   public long Decimals { get; set; }
+   public long CreatedOnBlock { get; set; }
+   public string CreatorAddress { get; set; }
+   public List<StandardTokenHolderTable> tokens { get; set; }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/ICirrusStorage.cs b/src/Blockcore.Indexer.Cirrus/Storage/ICirrusStorage.cs
index cf007c57..be95afa9 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/ICirrusStorage.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/ICirrusStorage.cs
@@ -1,5 +1,7 @@
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Blockcore.Indexer.Cirrus.Models;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
 using Blockcore.Indexer.Core.Storage.Types;
 
 namespace Blockcore.Indexer.Cirrus.Storage;
@@ -13,5 +15,12 @@ public interface ICirrusStorage
    QueryResult<QueryContractGroup> GroupedContracts();
    QueryResult<QueryContractList> ListContracts(string contractType, int? offset, int limit);
 
-   Task<QueryResult<QueryAddressAsset>> GetAssetsForAddressAsync(string address, int? offset, int limit);
+   Task<QueryDAOContract> GetDaoContractByAddressAsync(string contractAddress);
+   Task<QueryStandardTokenContract> GetStandardTokenContractByAddressAsync(string contractAddress);
+   Task<QueryNonFungibleTokenContract> GetNonFungibleTokenContractByAddressAsync(string contractAddress);
+   Task<NonFungibleTokenTable> GetNonFungibleTokenByIdAsync(string contractAddress, string tokenId);
+   Task<QueryStandardToken> GetStandardTokenByIdAsync(string contractAddress, string tokenId);
+   Task<QueryResult<QueryAddressAsset>> GetNonFungibleTokensForAddressAsync(string address, int? offset, int limit);
+   Task<QueryResult<QueryStandardToken>> GetStandardTokensForAddressAsync(string address, int? offset, int limit);
+   Task<List<string>> GetSmartContractsThatNeedsUpdatingAsync(params  string[] supportedTypes);
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusBlockRewindOperation.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusBlockRewindOperation.cs
new file mode 100644
index 00000000..9701c3f6
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusBlockRewindOperation.cs
@@ -0,0 +1,39 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Blockcore.Indexer.Core.Storage.Mongo;
+using MongoDB.Driver;
+
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo;
+
+public class CirrusBlockRewindOperation : BlockRewindOperation, IBlockRewindOperation
+{
+   public CirrusBlockRewindOperation(ICirrusMongoDb storage) : base(storage)
+   { }
+
+   public new async Task RewindBlockAsync(uint blockIndex)
+   {
+      await base.RewindBlockAsync(blockIndex);
+
+      var smartContractsToBeDeleted = ((ICirrusMongoDb)storage).SmartContractTable.AsQueryable()
+         .Where(_ => _.LastProcessedBlockHeight >= blockIndex)
+         .ToList();
+
+      var rewindTasks = smartContractsToBeDeleted.Select(_ => DeleteTokensForSmartContractAddressAsync(_.ContractAddress));
+
+      await Task.WhenAll(rewindTasks);
+   }
+
+   Task DeleteTokensForSmartContractAddressAsync(string address)
+   {
+      var nftTask = ((ICirrusMongoDb)storage).NonFungibleTokenTable
+         .DeleteManyAsync(t => t.Id.ContractAddress == address);
+
+      var tokenTask = ((ICirrusMongoDb)storage).DaoContractProposalTable
+         .DeleteManyAsync(t => t.Id.ContractAddress == address);
+
+      var daoTask = ((ICirrusMongoDb)storage).DaoContractProposalTable
+         .DeleteManyAsync(t => t.Id.ContractAddress == address);
+
+      return Task.WhenAll(nftTask,tokenTask, daoTask);
+   }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoBuilder.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoBuilder.cs
index 21008097..7d82afaa 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoBuilder.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoBuilder.cs
@@ -23,13 +23,28 @@ public override Task OnExecute()
             MongoDB.Bson.Serialization.BsonClassMap.RegisterClassMap<CirrusBlock>();
          }
 
+         if (!MongoDB.Bson.Serialization.BsonClassMap.IsClassMapRegistered(typeof(SmartContractTable)))
+         {
+            MongoDB.Bson.Serialization.BsonClassMap.RegisterClassMap<SmartContractTable>(_ =>
+            {
+               _.AutoMap();
+               _.MapIdProperty(_ => _.ContractAddress);
+               _.SetIsRootClass(true);
+               _.SetDiscriminator(nameof(SmartContractTable));
+            });
+         }
+
+         SetDocumentMapAndIgnoreExtraElements<DaoContractTable>();
+         SetDocumentMapAndIgnoreExtraElements<StandardTokenContractTable>();
+         SetDocumentMapAndIgnoreExtraElements<NonFungibleTokenContractTable>();
+
          SetDocumentMapAndIgnoreExtraElements<CirrusContractTable>();
          SetDocumentMapAndIgnoreExtraElements<CirrusContractCodeTable>();
-         SetDocumentMapAndIgnoreExtraElements<DaoContractComputedTable>();
-         SetDocumentMapAndIgnoreExtraElements<StandardTokenComputedTable>();
-         SetDocumentMapAndIgnoreExtraElements<NonFungibleTokenComputedTable>();
+         SetDocumentMapAndIgnoreExtraElements<DaoContractTable>();
+         SetDocumentMapAndIgnoreExtraElements<StandardTokenHolderTable>();
+         SetDocumentMapAndIgnoreExtraElements<DaoContractProposalTable>();
 
-         return Task.FromResult(1);
+         return Task.CompletedTask;
       }
 
       static void SetDocumentMapAndIgnoreExtraElements<T>()
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoData.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoData.cs
index 9742f263..4b534af6 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoData.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoData.cs
@@ -2,8 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using AutoMapper.Internal;
 using Blockcore.Indexer.Cirrus.Models;
-using Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
 using Blockcore.Indexer.Core.Client;
 using Blockcore.Indexer.Core.Crypto;
@@ -23,7 +23,6 @@ namespace Blockcore.Indexer.Cirrus.Storage.Mongo
    public class CirrusMongoData : MongoData, ICirrusStorage
    {
       readonly ICirrusMongoDb mongoDb;
-      readonly IComputeSmartContractService<NonFungibleTokenComputedTable> smartContractService;
 
       public CirrusMongoData(
          ILogger<MongoDb> dbLogger,
@@ -35,7 +34,7 @@ public CirrusMongoData(
          IScriptInterpeter scriptInterpeter,
          IMongoDatabase mongoDatabase,
          ICirrusMongoDb db,
-         IComputeSmartContractService<NonFungibleTokenComputedTable> smartContractService)
+         IBlockRewindOperation rewindOperation)
          : base(
             dbLogger,
             connection,
@@ -45,10 +44,10 @@ public CirrusMongoData(
             clientFactory,
             scriptInterpeter,
             mongoDatabase,
-            db)
+            db,
+            rewindOperation)
       {
          mongoDb = db;
-         this.smartContractService = smartContractService;
       }
 
       protected override async Task OnDeleteBlockAsync(SyncBlockInfo block)
@@ -118,6 +117,100 @@ public QueryResult<QueryContractList> ListContracts(string contractType, int? of
          };
       }
 
+      public async Task<QueryDAOContract> GetDaoContractByAddressAsync(string contractAddress)
+      {
+         var contract = await mongoDb.DaoContractTable.Find(_ => _.ContractAddress == contractAddress)
+            .SingleOrDefaultAsync();
+
+         if (contract is null)
+            return null;
+
+         var tokens = await mongoDb.DaoContractProposalTable.Find(_ => _.Id.ContractAddress == contractAddress)
+            .ToListAsync();
+
+         return new QueryDAOContract
+         {
+            Deposits = contract.Deposits,
+            Proposals = tokens,
+            ApprovedAddresses = contract.ApprovedAddresses,
+            CurrentAmount = contract.CurrentAmount,
+            WhitelistedCount = contract.WhitelistedCount,
+            MaxVotingDuration = contract.MaxVotingDuration,
+            MinVotingDuration = contract.MaxVotingDuration
+         };
+      }
+
+      public async Task<QueryStandardTokenContract> GetStandardTokenContractByAddressAsync(string contractAddress)
+      {
+         var contract = await mongoDb.SmartContractTable.Find(_ => _.ContractAddress == contractAddress)
+            .SingleOrDefaultAsync() as StandardTokenContractTable;
+
+         if (contract is null)
+            return null;
+
+         var tokens = await mongoDb.StandardTokenHolderTable.Find(_ => _.Id.ContractAddress == contractAddress)
+            .ToListAsync();
+
+         return new QueryStandardTokenContract
+         {
+            tokens = tokens,
+            Decimals = contract.Decimals,
+            Name = contract.Name,
+            Symbol = contract.Symbol,
+            CreatorAddress = contract.CreatorAddress,
+            TotalSupply = contract.TotalSupply,
+            CreatedOnBlock = contract.CreatedOnBlock
+         };
+      }
+
+      public async Task<QueryNonFungibleTokenContract> GetNonFungibleTokenContractByAddressAsync(string contractAddress)
+      {
+         var contract = await mongoDb.NonFungibleTokenContractTable.Find(_ => _.ContractAddress == contractAddress)
+            .SingleOrDefaultAsync();
+
+         if (contract is null)
+            return null;
+
+         var tokens = await mongoDb.NonFungibleTokenTable.Find(_ => _.Id.ContractAddress == contractAddress)
+            .ToListAsync();
+
+         return new QueryNonFungibleTokenContract
+         {
+            Name = contract.Name,
+            Owner = contract.Owner,
+            Symbol = contract.Symbol,
+            Tokens = tokens,
+            PendingOwner = contract.PendingOwner,
+            PreviousOwners = contract.PreviousOwners,
+            OwnerOnlyMinting = contract.OwnerOnlyMinting
+         };
+      }
+
+      public Task<NonFungibleTokenTable> GetNonFungibleTokenByIdAsync(string contractAddress, string tokenId)
+      {
+         return mongoDb.NonFungibleTokenTable.Find(_ =>
+               _.Id.ContractAddress == contractAddress && _.Id.TokenId == tokenId)
+            .FirstOrDefaultAsync();
+      }
+
+      public async Task<QueryStandardToken> GetStandardTokenByIdAsync(string contractAddress, string tokenId)
+      {
+         var token = await mongoDb.StandardTokenContractTable.Find(_ => _.ContractAddress == contractAddress)
+            .FirstOrDefaultAsync();
+         var tokenAmounts = await mongoDb.StandardTokenHolderTable.Find(_ => _.Id.ContractAddress == contractAddress &&
+                                                           _.Id.TokenId == tokenId)
+            .FirstOrDefaultAsync();
+
+         return new QueryStandardToken
+         {
+            Name = token.Name,
+            Symbol = token.Symbol,
+            TotalSupply = token.TotalSupply,
+            Address = tokenAmounts.Id.TokenId,
+            Amount = tokenAmounts.AmountChangesHistory.Sum(_ => _.Amount)
+         };
+      }
+
       public QueryContractCreate ContractCreate(string address)
       {
          IMongoQueryable<CirrusContractTable> cirrusContract = mongoDb.CirrusContractTable.AsQueryable()
@@ -128,10 +221,10 @@ public QueryContractCreate ContractCreate(string address)
          if (res.Count > 1)
             throw new ApplicationException("This is unexpected"); // todo: remove this temporary code
 
-         CirrusContractTable lastEntry = mongoDb.CirrusContractTable.AsQueryable()
+         CirrusContractTable lastEntry = mongoDb.CirrusContractTable
+            .AsQueryable()
             .OrderByDescending(b => b.BlockIndex)
-            .Where(q => q.ToAddress == address)
-            .FirstOrDefault();
+            .FirstOrDefault(q => q.ToAddress == address);
 
 
          return res.Select(item => new QueryContractCreate
@@ -251,38 +344,37 @@ public QueryContractCode ContractCode(string address)
          }).FirstOrDefault();
       }
 
-      public async Task<QueryResult<QueryAddressAsset>> GetAssetsForAddressAsync(string address, int? offset, int limit)
+      public async Task<QueryResult<QueryAddressAsset>> GetNonFungibleTokensForAddressAsync(string address, int? offset, int limit)
       {
-         int total = await mongoDb.NonFungibleTokenComputedTable
+         int total = await mongoDb.NonFungibleTokenTable
             .AsQueryable()
-            .SumAsync(_ => _.Tokens.Count(t => t.Owner == address));
+            .CountAsync(_ => _.Owner == address);
 
          int startPosition = offset ?? total - limit;
          int endPosition = startPosition + limit;
 
-         var contracts = await mongoDb.NonFungibleTokenComputedTable.Aggregate()
-            .Match(_ => _.Tokens.Any(t => t.Owner == address))
-            .Unwind(_ => _.Tokens)
-            .Match(_ => _["Tokens"]["Owner"] == address)
+         var dbTokens = await mongoDb.NonFungibleTokenTable.Aggregate()
+            .Match(_ => _.Owner == address)
+            //.SortBy(_ => _.) TODO David check if we need sorting for the FE
             .Skip(startPosition)
             .Limit(endPosition)
             .ToListAsync();
 
-         var tokens =
-            contracts.Select(contract =>
-               new QueryAddressAsset
-                  {
-                     Creator = contract["Tokens"]["Creator"].AsString,
-                     ContractId = contract["_id"].AsString,
-                     Id = contract["Tokens"]["_id"].AsString,
-                     Uri = contract["Tokens"]["Uri"].AsString,
-                     IsBurned = contract["Tokens"]["IsBurned"].AsBoolean,
-                     TransactionId =
-                        contract["Tokens"]["SalesHistory"].AsBsonArray.Any()
-                           ? contract["Tokens"]["SalesHistory"].AsBsonArray.Last()["TransactionId"].AsString
-                           : null,
-                     PricePaid = GetPricePaidFromHistory(contract["Tokens"]["SalesHistory"].AsBsonArray)
-                  });
+         var tokens = dbTokens.Select(_ => new QueryAddressAsset
+         {
+            Creator = _.Creator,
+            ContractId = _.Id.ContractAddress,
+            Id = _.Id.TokenId,
+            Uri = _.Uri,
+            IsBurned = _.IsBurned,
+            TransactionId = _.SalesHistory.LastOrDefault()?.TransactionId,
+            PricePaid = _.SalesHistory.LastOrDefault() switch
+            {
+               Auction auction => auction.HighestBid,
+               OnSale sale => sale.Price,
+               _ => 0
+            }
+         });
 
          return new QueryResult<QueryAddressAsset>
          {
@@ -290,18 +382,155 @@ public async Task<QueryResult<QueryAddressAsset>> GetAssetsForAddressAsync(strin
          };
       }
 
-      private static long? GetPricePaidFromHistory(BsonArray saleEvents)
+      public async Task<QueryResult<QueryStandardToken>> GetStandardTokensForAddressAsync(string address, int? offset, int limit)
       {
-         if (!saleEvents.Any())
-            return null;
+         int total = await mongoDb.StandardTokenHolderTable
+            .AsQueryable()
+            .CountAsync(_ => _.Id.TokenId == address);
+
+         if (total == 0)
+            return new QueryResult<QueryStandardToken> { Limit = limit, Offset = offset ?? 0, Total = total };
+
+         int startPosition = offset ?? total - limit;
+         int endPosition = startPosition + limit;
+
+         var dbTokens = await mongoDb.StandardTokenHolderTable.Aggregate()
+            .Match(_ => _.Id.TokenId == address)
+            .SortBy(_ => _.Id.ContractAddress)
+            .Skip(startPosition)
+            .Limit(endPosition)
+            .ToListAsync();
+
+         var addresses = dbTokens.Select(_ => _.Id.ContractAddress);
+
+         var smartContractDetails = await mongoDb.StandardTokenContractTable.AsQueryable()
+            .Where(_ => addresses.Contains(_.ContractAddress))
+            .ToListAsync();
+
+         var tokens = dbTokens.Select(_ =>
+         {
+            var smartContract = smartContractDetails.First(s => s.ContractAddress == _.Id.ContractAddress);
+
+            return new QueryStandardToken
+            {
+               Address = _.Id.TokenId,
+               Amount = _.AmountChangesHistory.Sum(a => a.Amount),
+               Name = smartContract.Name,
+               Symbol = smartContract.Symbol,
+               TotalSupply = smartContract.TotalSupply
+            };
+         });
 
-         var last = saleEvents.Last();
-         return last["_t"].AsBsonArray.Last().AsString switch
+         return new QueryResult<QueryStandardToken>
          {
-            nameof(Auction) => last["HighestBid"].AsInt64,
-            nameof(OnSale) => last["Price"].AsInt64,
-            _ => 0
+            Items = tokens, Limit = limit, Offset = offset ?? 0, Total = total
          };
       }
+
+      public async Task<List<SmartContractTable>> GetSmartContractsThatNeedsUpdatingAsync(long blockIndex)
+      {
+         var smartContractsNotComputed = await mongoDb.CirrusContractCodeTable.Aggregate()
+            .Lookup(mongoDb.SmartContractTable.CollectionNamespace.CollectionName,
+               new StringFieldDefinition<CirrusContractCodeTable>(nameof(CirrusContractCodeTable.ContractAddress)),
+               new StringFieldDefinition<SmartContractTable>(nameof(SmartContractTable.ContractAddress)),
+               new StringFieldDefinition<SmartContractTable[]>("output"))
+            .Unwind("output")
+            .Match(_ => _["output"].IsBsonNull ||
+                        _["output.BlockIndex"] < blockIndex)
+            .ReplaceRoot(_ => _["output"])
+            .As<SmartContractTable>()
+            .ToListAsync();
+
+         var smartContractsNotUpdated = await mongoDb.CirrusContractTable.Aggregate(PipelineDefinition<CirrusContractTable,SmartContractTable>.Create(
+            new []
+            {
+               new BsonDocument("$match",
+                  new BsonDocument { { "Success", true }, { "ToAddress", new BsonDocument("$ne", BsonNull.Value) } }),
+               new BsonDocument("$group",
+                  new BsonDocument
+                  {
+                     { "_id", "$ToAddress" },
+                     { "ContractCodeType", new BsonDocument("$first", "$ContractCodeType") },
+                     { "BlockIndex", new BsonDocument("$max", "$BlockIndex") }
+                  }),
+               new BsonDocument("$lookup",
+                  new BsonDocument
+                  {
+                     { "from", "SmartContractTable" },
+                     { "localField", "_id" },
+                     { "foreignField", "_id" },
+                     { "as", "output" }
+                  }),
+               new BsonDocument("$match",
+                  new BsonDocument("output",
+                     new BsonDocument("$ne",
+                        new BsonArray()))),
+               new BsonDocument("$unwind",
+                  new BsonDocument { { "path", "$output" }, { "preserveNullAndEmptyArrays", false } }),
+               new BsonDocument("$match",
+                  new BsonDocument("$expr",
+                     new BsonDocument("$gt",
+                        new BsonArray { "$BlockIndex", "$output.LastProcessedBlockHeight" }))),
+               new BsonDocument("$replaceRoot",
+                  new BsonDocument("newRoot", "$output"))
+            }))
+            .ToListAsync();
+
+         return smartContractsNotComputed.Concat(smartContractsNotUpdated).ToList();
+      }
+
+      public async Task<List<string>> GetSmartContractsThatNeedsUpdatingAsync(params string[] supportedTypes)
+      {
+         var smartContractsNotComputed = await mongoDb.CirrusContractCodeTable.Aggregate()
+            .Match(Builders<CirrusContractCodeTable>.Filter.In(_ => _.CodeType, supportedTypes))
+            .Lookup("SmartContractTable",
+               new StringFieldDefinition<CirrusContractCodeTable>("ContractAddress"),
+               new StringFieldDefinition<BsonDocument>("_id"),
+               new StringFieldDefinition<BsonDocument>("output"))
+            .Match(_ => _["output"] == new BsonArray())
+            .Project(_ => new { address = _["ContractAddress"] })
+            .ToListAsync();
+
+         var smartContractsNotUpdated = await mongoDb.CirrusContractTable.Aggregate(PipelineDefinition<CirrusContractTable,BsonDocument>.Create(
+               new []
+               {
+                  new BsonDocument("$match",
+                     new BsonDocument { { "Success", true }, { "ToAddress", new BsonDocument("$ne", BsonNull.Value) } }),
+                  new BsonDocument("$group",
+                     new BsonDocument
+                     {
+                        { "_id", "$ToAddress" },
+                        { "ContractCodeType", new BsonDocument("$first", "$ContractCodeType") },
+                        { "BlockIndex", new BsonDocument("$max", "$BlockIndex") }
+                     }),
+                  new BsonDocument("$lookup",
+                     new BsonDocument
+                     {
+                        { "from", "SmartContractTable" },
+                        { "localField", "_id" },
+                        { "foreignField", "_id" },
+                        { "as", "output" }
+                     }),
+                  new BsonDocument("$match",
+                     new BsonDocument("CodeType",
+                        new BsonDocument("$nin",
+                           new BsonArray(supportedTypes)))),
+                  new BsonDocument("$match",
+                     new BsonDocument("output",
+                        new BsonDocument("$ne",
+                           new BsonArray()))),
+                  new BsonDocument("$unwind",
+                     new BsonDocument { { "path", "$output" }, { "preserveNullAndEmptyArrays", false } }),
+                  new BsonDocument("$match",
+                     new BsonDocument("$expr",
+                        new BsonDocument("$gt",
+                           new BsonArray { "$BlockIndex", "$output.LastProcessedBlockHeight" }))),
+                  new BsonDocument("$project",
+                     new BsonDocument("address", "$ContractAddress"))
+               }))
+            .ToListAsync();
+
+         return smartContractsNotUpdated.Select(_ => _["_id"].AsString).ToList().Concat(smartContractsNotComputed.Select(s => s.address.AsString)).ToList();
+      }
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoDb.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoDb.cs
index 0016908e..bd151edb 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoDb.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/CirrusMongoDb.cs
@@ -7,9 +7,19 @@ namespace Blockcore.Indexer.Cirrus.Storage.Mongo;
 
 public class CirrusMongoDb : MongoDb, ICirrusMongoDb
 {
+   private const string SmartContractTableName = "SmartContractTable";
+
    public CirrusMongoDb(ILogger<MongoDb> logger, IMongoDatabase mongoDatabase) : base(logger, mongoDatabase)
    { }
 
+   public IMongoCollection<SmartContractTable> SmartContractTable
+   {
+      get
+      {
+         return mongoDatabase.GetCollection<SmartContractTable>(SmartContractTableName);
+      }
+   }
+
    public IMongoCollection<CirrusContractTable> CirrusContractTable
    {
       get
@@ -26,27 +36,51 @@ public IMongoCollection<CirrusContractCodeTable> CirrusContractCodeTable
       }
    }
 
-   public IMongoCollection<DaoContractComputedTable> DaoContractComputedTable
+   public IMongoCollection<DaoContractTable> DaoContractTable
+   {
+      get
+      {
+         return mongoDatabase.GetCollection<DaoContractTable>(SmartContractTableName);
+      }
+   }
+
+   public IMongoCollection<StandardTokenContractTable> StandardTokenContractTable
+   {
+      get
+      {
+         return mongoDatabase.GetCollection<StandardTokenContractTable>(SmartContractTableName);
+      }
+   }
+
+   public IMongoCollection<NonFungibleTokenContractTable> NonFungibleTokenContractTable
+   {
+      get
+      {
+         return mongoDatabase.GetCollection<NonFungibleTokenContractTable>(SmartContractTableName);
+      }
+   }
+
+   public IMongoCollection<NonFungibleTokenTable> NonFungibleTokenTable
    {
       get
       {
-         return mongoDatabase.GetCollection<DaoContractComputedTable>("DaoContractComputed");
+         return mongoDatabase.GetCollection<NonFungibleTokenTable>("NonFungibleToken");
       }
    }
 
-   public IMongoCollection<StandardTokenComputedTable> StandardTokenComputedTable
+   public IMongoCollection<DaoContractProposalTable> DaoContractProposalTable
    {
       get
       {
-         return mongoDatabase.GetCollection<StandardTokenComputedTable>("StandardTokenComputed");
+         return mongoDatabase.GetCollection<DaoContractProposalTable>("DaoContractProposal");
       }
    }
 
-   public IMongoCollection<NonFungibleTokenComputedTable> NonFungibleTokenComputedTable
+   public IMongoCollection<StandardTokenHolderTable> StandardTokenHolderTable
    {
       get
       {
-         return mongoDatabase.GetCollection<NonFungibleTokenComputedTable>("NonFungibleTokenComputed");
+         return mongoDatabase.GetCollection<StandardTokenHolderTable>("StandardTokenHolder");
       }
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/ICirrusMongoDb.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/ICirrusMongoDb.cs
index ce040f04..0e20b36c 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/ICirrusMongoDb.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/ICirrusMongoDb.cs
@@ -1,4 +1,3 @@
-using System;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
 using Blockcore.Indexer.Core.Storage.Mongo;
 using MongoDB.Driver;
@@ -7,9 +6,15 @@ namespace Blockcore.Indexer.Cirrus.Storage.Mongo;
 
 public interface ICirrusMongoDb : IMongoDb
 {
+   public IMongoCollection<SmartContractTable> SmartContractTable { get; }
    public IMongoCollection<CirrusContractTable> CirrusContractTable { get;}
    public IMongoCollection<CirrusContractCodeTable> CirrusContractCodeTable { get; }
-   public IMongoCollection<DaoContractComputedTable> DaoContractComputedTable { get; }
-   public IMongoCollection<StandardTokenComputedTable> StandardTokenComputedTable { get; }
-   public IMongoCollection<NonFungibleTokenComputedTable> NonFungibleTokenComputedTable { get; }
+   public IMongoCollection<DaoContractTable> DaoContractTable { get; }
+   public IMongoCollection<StandardTokenContractTable> StandardTokenContractTable { get; }
+   public IMongoCollection<NonFungibleTokenContractTable> NonFungibleTokenContractTable { get; }
+
+
+   public IMongoCollection<DaoContractProposalTable> DaoContractProposalTable{ get; }
+   public IMongoCollection<NonFungibleTokenTable> NonFungibleTokenTable { get; }
+   public IMongoCollection<StandardTokenHolderTable> StandardTokenHolderTable{ get; }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ComputeSmartContractService.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ComputeSmartContractServiceWithSplitDocuments.cs
similarity index 56%
rename from src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ComputeSmartContractService.cs
rename to src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ComputeSmartContractServiceWithSplitDocuments.cs
index 1be77cc2..e694f700 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ComputeSmartContractService.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ComputeSmartContractServiceWithSplitDocuments.cs
@@ -13,55 +13,99 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
 
-public class ComputeSmartContractService<T> : IComputeSmartContractService<T>
-   where T : SmartContractComputedBase, new()
+public class ComputeSmartContractServiceWithSplitDocuments<T,TDocument> : IComputeSmartContractService<T> where T : SmartContractTable, new() where TDocument : new()
 {
-   readonly ILogger<ComputeSmartContractService<T>> logger;
+   readonly ILogger<ComputeSmartContractServiceWithSplitDocuments<T,TDocument>> logger;
    readonly ICirrusMongoDb mongoDb;
-   readonly ISmartContractHandlersFactory<T> logReaderFactory;
+   readonly ISmartContractHandlersFactory<T,TDocument> logReaderFactory;
    readonly CirrusClient cirrusClient;
    readonly IMongoDatabase mongoDatabase;
+   readonly ISmartContractTransactionsLookup<T> transactionsLookup;
 
-   readonly T emptyContract;
-
-   public ComputeSmartContractService(ILogger<ComputeSmartContractService<T>> logger,
-      ICirrusMongoDb db,
-      ISmartContractHandlersFactory<T> logReaderFactory,
-      ICryptoClientFactory clientFactory,
-      SyncConnection connection,
-      IMongoDatabase mongoDatabase)
+   public ComputeSmartContractServiceWithSplitDocuments(
+      ILogger<ComputeSmartContractServiceWithSplitDocuments<T, TDocument>> logger,
+      ICirrusMongoDb mongoDb, ISmartContractHandlersFactory<T, TDocument> logReaderFactory,
+      ICryptoClientFactory clientFactory, SyncConnection connection, IMongoDatabase mongoDatabase,
+      ISmartContractTransactionsLookup<T> transactionsLookup)
    {
       this.logger = logger;
-      mongoDb = db;
+      this.mongoDb = mongoDb;
       this.logReaderFactory = logReaderFactory;
-      this.mongoDatabase = mongoDatabase;
       cirrusClient = (CirrusClient)clientFactory.Create(connection);
-      emptyContract = new T();
+      this.mongoDatabase = mongoDatabase;
+      this.transactionsLookup = transactionsLookup;
    }
 
-   public async Task<T> ComputeSmartContractForAddressAsync(string address)
+   public async Task ComputeSmartContractForAddressAsync(string address)
    {
       var contract = await LookupSmartContractForAddressAsync(address);
 
       if (contract is null)
-         return null;
+         return;
 
-      var contractTransactions = await mongoDb.CirrusContractTable
-         .AsQueryable()
-         .Where(_ => _.ToAddress == address && _.Success && _.BlockIndex > contract.LastProcessedBlockHeight)
-         .ToListAsync();
+      var contractTransactions =
+         await transactionsLookup.GetTransactionsForSmartContractAsync(address, contract.LastProcessedBlockHeight);
 
       if (contractTransactions.Any())
       {
          await AddNewTransactionsDataToDocumentAsync(address, contractTransactions, contract);
       }
+   }
 
-      return contract;
+   private async Task AddNewTransactionsDataToDocumentAsync(string address, List<CirrusContractTable> contractTransactions,
+      T contract)
+   {
+      var writeModels = new List<WriteModel<TDocument>>();
+
+      foreach (var contractTransaction in contractTransactions)
+      {
+         var reader = logReaderFactory.GetLogReader(contractTransaction.MethodName);
+
+         if (reader is null)
+         {
+            logger.LogInformation(
+               $"No reader found for method {contractTransaction.MethodName} on transaction id - {contractTransaction.TransactionId}");
+            throw new InvalidOperationException(
+               $"Reader was not found for transaction - {contractTransaction.TransactionId}");
+         }
+
+         if (!reader.IsTransactionLogComplete(contractTransaction.Logs))
+         {
+            var result = await cirrusClient.GetContractInfoAsync(contractTransaction.TransactionId);
+
+            contractTransaction.Logs = result.Logs;
+         }
+
+         WriteModel<TDocument>[] instructions =
+            reader.UpdateContractFromTransactionLog(contractTransaction, contract);
+
+         if (instructions is not null)
+            writeModels.AddRange(instructions);
+
+         contract.LastProcessedBlockHeight = contractTransaction.BlockIndex;
+      }
+
+      await GetSmartContractCollection<T>()
+         .FindOneAndReplaceAsync<T>(_ => _.ContractAddress == address, contract,
+            new FindOneAndReplaceOptions<T> { IsUpsert = true },
+            CancellationToken.None);
+
+      if (!writeModels.Any())
+         return;
+
+      var bulkWriteResult = await GetSmartContractTokenCollection<TDocument>()
+         .BulkWriteAsync(writeModels, new BulkWriteOptions { IsOrdered = true });
+
+      if (bulkWriteResult.ProcessedRequests.Count != writeModels.Count)
+      {
+         logger.LogError($"The bulk write operation on table {typeof(TDocument).Name}Table has failed");
+         throw new Exception("The bulk write operation has failed");
+      }
    }
 
    async Task<T> LookupSmartContractForAddressAsync(string address)
    {
-      T contract = await GetSmartContractCollection()
+      T contract = await GetSmartContractCollection<T>()
          .AsQueryable()
          .SingleOrDefaultAsync(_ => _.ContractAddress == address);
 
@@ -72,7 +116,7 @@ async Task<T> LookupSmartContractForAddressAsync(string address)
          .AsQueryable()
          .SingleOrDefaultAsync(_ => _.ContractAddress == address);
 
-      if (contractCode is null || contractCode.CodeType != emptyContract.ContractType)
+      if (contractCode is null )
       {
          logger.LogInformation(
             $"Request to compute smart contract for address {address} which was not found in the contract code table");
@@ -106,44 +150,19 @@ private async Task<T> CreateNewSmartContract(string address)
       return contract;
    }
 
-   private async Task AddNewTransactionsDataToDocumentAsync(string address, List<CirrusContractTable> contractTransactions,
-      T contract)
-   {
-      foreach (var contractTransaction in contractTransactions)
-      {
-         var reader = logReaderFactory.GetLogReader(contractTransaction.MethodName);
-
-         if (reader is null)
-         {
-            logger.LogInformation($"No reader found for method {contractTransaction.MethodName} on transaction id - {contractTransaction.TransactionId}");
-            throw new InvalidOperationException(
-               $"Reader was not found for transaction - {contractTransaction.TransactionId}");
-         }
-
-         if (!reader.IsTransactionLogComplete(contractTransaction.Logs))
-         {
-            var result = await cirrusClient.GetContractInfoAsync(contractTransaction.TransactionId);
-
-            contractTransaction.Logs = result.Logs;
-         }
-
-         reader.UpdateContractFromTransactionLog(contractTransaction, contract);
-
-         contract.LastProcessedBlockHeight = contractTransaction.BlockIndex;
-      }
-
-      await SaveTheContractAsync(address, contract);
-   }
-
    async Task SaveTheContractAsync(string address, T contract) =>
-      await GetSmartContractCollection()
+      await GetSmartContractCollection<T>()
          .FindOneAndReplaceAsync<T>(_ => _.ContractAddress == address, contract,
-         new FindOneAndReplaceOptions<T> { IsUpsert = true },
-         CancellationToken.None);
+            new FindOneAndReplaceOptions<T> { IsUpsert = true },
+            CancellationToken.None);
 
+   private IMongoCollection<TType> GetSmartContractCollection<TType>()
+   {
+      return mongoDatabase.GetCollection<TType>(nameof(SmartContractTable));
+   }
 
-   private IMongoCollection<T> GetSmartContractCollection()
+   private IMongoCollection<TType> GetSmartContractTokenCollection<TType>()
    {
-      return mongoDatabase.GetCollection<T>(typeof(T).Name.Replace("Table",string.Empty));
+      return mongoDatabase.GetCollection<TType>(typeof(TType).Name.Replace("Table",string.Empty));
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/AddToWhiteListLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/AddToWhiteListLogReader.cs
index fce8a952..6da06b4c 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/AddToWhiteListLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/AddToWhiteListLogReader.cs
@@ -1,19 +1,22 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-class WhitelistAddressesLogReader : ILogReader<DaoContractComputedTable>
+class WhitelistAddressesLogReader : ILogReader<DaoContractTable,DaoContractProposalTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType is "WhitelistAddresses" or "WhitelistAddress";
 
-   public bool IsTransactionLogComplete(LogResponse[] logs) => false;
+   public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      DaoContractComputedTable computedTable)
+   public WriteModel<DaoContractProposalTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      DaoContractTable computedTable)
    {
       computedTable.WhitelistedCount =  (long)contractTransaction.Logs.Single().Log.Data["whitelistedCount"];
       //TODO we don't have the address or a way to get it without reading the script in the transaction
+
+      return new WriteModel<DaoContractProposalTable>[]{};
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/BlacklistAddressesLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/BlacklistAddressesLogReader.cs
index 27427f71..6f88936d 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/BlacklistAddressesLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/BlacklistAddressesLogReader.cs
@@ -1,17 +1,20 @@
+using System;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-class BlacklistAddressesLogReader : ILogReader<DaoContractComputedTable>
+class BlacklistAddressesLogReader : ILogReader<DaoContractTable, DaoContractProposalTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType is "BlacklistAddresses" or "BlacklistAddress";
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => false;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      DaoContractComputedTable computedTable)
+   public WriteModel<DaoContractProposalTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      DaoContractTable computedTable)
    {
       //TODO
+      return Array.Empty<WriteModel<DaoContractProposalTable>>();
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/CreateProposalLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/CreateProposalLogReader.cs
index 20306bf3..6bcc74bb 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/CreateProposalLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/CreateProposalLogReader.cs
@@ -2,35 +2,35 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-class CreateProposalLogReader : ILogReader<DaoContractComputedTable>
+class CreateProposalLogReader : ILogReader<DaoContractTable,DaoContractProposalTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType == "CreateProposal";
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      DaoContractComputedTable computedTable)
+   public WriteModel<DaoContractProposalTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      DaoContractTable computedTable)
    {
       var logData = contractTransaction.Logs.First().Log.Data;
 
-      var proposal = new DaoContractProposal
+      var proposal = new DaoContractProposalTable
       {
          Recipient = (string)logData["recipent"],
          Amount = (long)logData["amount"],
-         Id = (int)(long)logData["proposalId"],
+         Id = new SmartContractTokenId
+         {
+            TokenId = ((long)logData["proposalId"]).ToString(),
+            ContractAddress = computedTable.ContractAddress
+         } ,
          Description = (string)logData["description"],
          ProposalStartedAtBlock = contractTransaction.BlockIndex,
          Votes = new List<DaoContractVoteDetails>()
       };
 
-      computedTable.Proposals ??= new List<DaoContractProposal>(proposal.Id);
-
-      if (computedTable.Proposals.Capacity < proposal.Id)
-         computedTable.Proposals.Capacity = (proposal.Id);
-
-      computedTable.Proposals.Insert(proposal.Id - 1,proposal);
+      return new [] { new InsertOneModel<DaoContractProposalTable>(proposal)};
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/DaoSmartContractBuilder.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/DaoSmartContractBuilder.cs
index 7e3d3a6c..f27a63b6 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/DaoSmartContractBuilder.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/DaoSmartContractBuilder.cs
@@ -2,11 +2,11 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-class DaoSmartContractBuilder : ISmartContractBuilder<DaoContractComputedTable>
+class DaoSmartContractBuilder : ISmartContractBuilder<DaoContractTable>
 {
    public bool CanBuildSmartContract(string contractCodeType) => contractCodeType.Equals("DAOContract");
 
-   public DaoContractComputedTable BuildSmartContract(CirrusContractTable createContractTransaction)
+   public DaoContractTable BuildSmartContract(CirrusContractTable createContractTransaction)
    {
       return new()
       {
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/DepositLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/DepositLogReader.cs
index ef42e6dc..2abbb259 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/DepositLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/DepositLogReader.cs
@@ -1,29 +1,36 @@
+using System;
 using System.Collections.Generic;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
+using MongoDB.Driver.Core.WireProtocol.Messages;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-class DepositLogReader : ILogReader<DaoContractComputedTable>
+class DepositLogReader : ILogReader<DaoContractTable,DaoContractProposalTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType == "Deposit";
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      DaoContractComputedTable computedTable)
+   public WriteModel<DaoContractProposalTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      DaoContractTable computedTable)
    {
       long amount = (long)contractTransaction.Logs[0].Log.Data["amount"];
 
       computedTable.Deposits ??= new List<DaoContractDeposit>();
 
-      computedTable.Deposits.Add(new DaoContractDeposit
+      var deposit = new DaoContractDeposit
       {
          Amount = amount,
          SenderAddress = (string)contractTransaction.Logs[0].Log.Data["sender"],
-         TransactionId = contractTransaction.TransactionId
-      });
+         TransactionId = contractTransaction.TransactionId,
+         BlockIndex = contractTransaction.BlockIndex
+      };
 
       computedTable.CurrentAmount += amount; //TODO sum the deposits subtract the proposals
+      computedTable.Deposits.Add(deposit);
+
+      return Array.Empty<WriteModel<DaoContractProposalTable>>();
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/ExecuteProposalLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/ExecuteProposalLogReader.cs
index 2d43e419..a044bee1 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/ExecuteProposalLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/ExecuteProposalLogReader.cs
@@ -2,31 +2,30 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-class ExecuteProposalLogReader : ILogReader<DaoContractComputedTable>
+class ExecuteProposalLogReader : ILogReader<DaoContractTable, DaoContractProposalTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType == "ExecuteProposal";
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      DaoContractComputedTable computedTable)
+   public WriteModel<DaoContractProposalTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      DaoContractTable computedTable)
    {
       var log = contractTransaction.Logs.First().Log.Data;
 
       computedTable.CurrentAmount -= (long)log["amount"];
 
-      int proposalId = (int)(long)log["proposalId"];
+      string proposalId = ((long)log["proposalId"]).ToString();
 
-      var proposal = computedTable.Proposals[proposalId - 1];
-
-      if (proposal.Id != proposalId || proposal.Recipient != (string)log["recipent"])
-         throw new ArgumentException(nameof(proposalId));
-
-      proposal.WasProposalAccepted = true;
-      proposal.ProposalCompletedAtBlock = contractTransaction.BlockIndex;
-      proposal.PayoutTransactionId = contractTransaction.TransactionId;
+      return new [] { new UpdateOneModel<DaoContractProposalTable>(Builders<DaoContractProposalTable>.Filter
+            .Where(_ => _.Id.TokenId ==  proposalId && _.Id.ContractAddress == computedTable.ContractAddress),
+         Builders<DaoContractProposalTable>.Update
+            .Set(_ => _.WasProposalAccepted,true)
+            .Set(_ => _.ProposalCompletedAtBlock,contractTransaction.BlockIndex)
+            .Set(_ => _.PayoutTransactionId,contractTransaction.TransactionId))};
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/GetOrPropertyCallsLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/GetOrPropertyCallsLogReader.cs
index 3f7a7ace..9b6863ed 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/GetOrPropertyCallsLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/GetOrPropertyCallsLogReader.cs
@@ -1,9 +1,10 @@
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-public class GetOrPropertyCallsLogReader : ILogReader<DaoContractComputedTable>
+public class GetOrPropertyCallsLogReader : ILogReader<DaoContractTable,DaoContractProposalTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.StartsWith("get_") ||
                                                              methodType.StartsWith("Get") ||
@@ -11,7 +12,9 @@ public bool CanReadLogForMethodType(string methodType) => methodType.StartsWith(
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      DaoContractComputedTable computedTable)
-   { }
+   public WriteModel<DaoContractProposalTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      DaoContractTable computedTable)
+   {
+      return null;
+   }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/UpdateMaxVotingDurationLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/UpdateMaxVotingDurationLogReader.cs
index ea0209a3..793ef4b4 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/UpdateMaxVotingDurationLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/UpdateMaxVotingDurationLogReader.cs
@@ -2,26 +2,29 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-class UpdateMaxVotingDurationLogReader : ILogReader<DaoContractComputedTable>
+class UpdateMaxVotingDurationLogReader : ILogReader<DaoContractTable,DaoContractProposalTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType == "UpdateMaxVotingDuration";
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => false;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      DaoContractComputedTable computedTable)
+   public WriteModel<DaoContractProposalTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      DaoContractTable computedTable)
    {
       var log = contractTransaction.Logs.SingleOrDefault();
 
-      if (log == null)
+      if (log == null) //TODO check if this issue persists
       {
-         return;
+         return Array.Empty<WriteModel<DaoContractProposalTable>>();;
          // throw new ArgumentException(contractTransaction.TransactionId);
       }
 
       computedTable.MaxVotingDuration = (long)log.Log.Data["maxVotingDuration"];
+
+      return Array.Empty<WriteModel<DaoContractProposalTable>>();
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/UpdateMinVotingDurationLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/UpdateMinVotingDurationLogReader.cs
index f2e594f7..1deb93ea 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/UpdateMinVotingDurationLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/UpdateMinVotingDurationLogReader.cs
@@ -1,20 +1,24 @@
+using System;
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-class UpdateMinVotingDurationLogReader : ILogReader<DaoContractComputedTable>
+class UpdateMinVotingDurationLogReader : ILogReader<DaoContractTable, DaoContractProposalTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType == "UpdateMinVotingDuration";
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => false;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      DaoContractComputedTable computedTable)
+   public WriteModel<DaoContractProposalTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      DaoContractTable computedTable)
    {
       if (!contractTransaction.Logs.Any())
-         return;
+         return null;
       computedTable.MinVotingDuration = (long)contractTransaction.Logs.Single().Log.Data["minVotingDuration"];
+
+      return Array.Empty<WriteModel<DaoContractProposalTable>>();
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/VoteLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/VoteLogReader.cs
index 4f073d62..ca67f119 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/VoteLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/Dao/VoteLogReader.cs
@@ -3,54 +3,46 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Bson;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.Dao;
 
-class VoteLogReader : ILogReader<DaoContractComputedTable>
+class VoteLogReader : ILogReader<DaoContractTable, DaoContractProposalTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType == "Vote";
 
-   public bool IsTransactionLogComplete(LogResponse[] logs) => true;
+   public bool IsTransactionLogComplete(LogResponse[] logs) => logs.Any(_ => _.Log.Event == "ProposalVotedLog");
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      DaoContractComputedTable computedTable)
+   public WriteModel<DaoContractProposalTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      DaoContractTable computedTable)
    {
-      if (contractTransaction.Logs.Length == 0)
+      if (contractTransaction.Logs.All(_ => _.Log.Event != "ProposalVotedLog"))
       {
          //TODO need to handle this wierd issue (example transaction id - 5faa9c5347ba378ea1b4dd9e957e398867f724a6ba4951ed65cde6529dbfd6a0)
-         return;
+         return null;
       }
 
       int id = (int)(long)contractTransaction.Logs.First().Log.Data["proposalId"];
       bool voteYesNo = (bool)contractTransaction.Logs.First().Log.Data["vote"];
       string voterAddress = (string)contractTransaction.Logs.First().Log.Data["voter"];
 
-      var proposal = computedTable.Proposals.SingleOrDefault(_ => _.Id == id);
+      var upsertVoter = new UpdateOneModel<DaoContractProposalTable>(Builders<DaoContractProposalTable>.Filter
+            .Where(_ => _.Id.ContractAddress == computedTable.ContractAddress && _.Id.TokenId == id.ToString()),
+         Builders<DaoContractProposalTable>.Update.AddToSet(_ => _.Votes,
+            new DaoContractVoteDetails { ProposalId = id, VoterAddress = voterAddress, PreviousVotes = new List<DaoContractVote>()}));
 
-      if (proposal is null)
-      {
-         throw new InvalidOperationException(
-            $"Proposal {id} not found for the vote transaction id - {contractTransaction.TransactionId}");
-      }
+      var insertVoteForVoter = new UpdateOneModel<DaoContractProposalTable>(Builders<DaoContractProposalTable>.Filter
+            .Where(_ => _.Id.ContractAddress == computedTable.ContractAddress && _.Id.TokenId == id.ToString()),
+         Builders<DaoContractProposalTable>.Update.AddToSet("Votes.$[j].PreviousVotes",
+            new DaoContractVote { IsApproved = voteYesNo, VotedOnBlock = contractTransaction.BlockIndex }));
 
-      var vote = proposal.Votes.FirstOrDefault(_ => _.VoterAddress == voterAddress);
-
-      if (vote != null)
+      insertVoteForVoter.ArrayFilters = new[]
       {
-         vote.PreviousVotes ??= new List<DaoContractVote>();
-         vote.PreviousVotes.Add(new DaoContractVote { IsApproved = vote.IsApproved,VotedOnBlock = vote.VotedOnBlock });
-         vote.IsApproved = voteYesNo;
-         vote.VotedOnBlock = contractTransaction.BlockIndex;
-      }
-      else
-      {
-         proposal.Votes.Add(new DaoContractVoteDetails
-         {
-            IsApproved = voteYesNo,
-            ProposalId = id,
-            VoterAddress = voterAddress,
-            VotedOnBlock = contractTransaction.BlockIndex,
-         });
-      }
+         new BsonDocumentArrayFilterDefinition<DaoContractVoteDetails>(
+            new BsonDocument("j.VoterAddress", voterAddress))
+      };
+
+      return new[] { upsertVoter, insertVoteForVoter };
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/IComputeSmartContractService.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/IComputeSmartContractService.cs
index ec2698e4..5de384f8 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/IComputeSmartContractService.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/IComputeSmartContractService.cs
@@ -3,7 +3,7 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
 
-public interface IComputeSmartContractService<T> where T : SmartContractComputedBase
+public interface IComputeSmartContractService<T> where T : SmartContractTable
 {
-   Task<T> ComputeSmartContractForAddressAsync(string address);
+   Task ComputeSmartContractForAddressAsync(string address);
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/IContractDataReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/IContractDataReader.cs
new file mode 100644
index 00000000..1f355780
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/IContractDataReader.cs
@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
+
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
+
+public interface IContractDataReader<in T> where T : SmartContractTable
+{
+   bool CanReadLogForMethodType(string methodType);
+   bool IsTransactionLogComplete(IDictionary<string,object> dictionary);
+   UpdateDefinition<TToken> UpdateContractFromTransactionLog<TToken>(CirrusContractTable contractTransaction,T computedTable);
+}
+
+class ContractDataReader : IContractDataReader<NonFungibleTokenContractTable>
+{
+   public bool CanReadLogForMethodType(string methodType)  => methodType.Equals("Burn");
+
+   public bool IsTransactionLogComplete(IDictionary<string, object> dictionary) => dictionary.ContainsKey("Burn");
+
+   public UpdateDefinition<Token> UpdateContractFromTransactionLog<Token>(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
+   {
+      return null;
+   }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ILogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ILogReader.cs
index 70301e30..7e2cecc1 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ILogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ILogReader.cs
@@ -1,11 +1,13 @@
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
 
-public interface ILogReader<in T> where T : SmartContractComputedBase
+public interface ILogReader<in T, TDocument> where T : SmartContractTable
+where TDocument : new()
 {
    bool CanReadLogForMethodType(string methodType);
    bool IsTransactionLogComplete(LogResponse[] logs);
-   void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,T computedTable);
+   WriteModel<TDocument>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,T computedTable);
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractBuilder.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractBuilder.cs
index 7f3353d5..021afbbc 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractBuilder.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractBuilder.cs
@@ -3,7 +3,7 @@
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
 
 public interface ISmartContractBuilder<T>
-where T : SmartContractComputedBase
+where T : SmartContractTable
 {
    bool CanBuildSmartContract(string contractCodeType);
 
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractHandlersFactory.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractHandlersFactory.cs
index 8b601c09..10c8e964 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractHandlersFactory.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractHandlersFactory.cs
@@ -2,9 +2,11 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
 
-public interface ISmartContractHandlersFactory<T> where T : SmartContractComputedBase
+public interface ISmartContractHandlersFactory<T,TDocument>
+   where T : SmartContractTable
+   where TDocument : new()
 {
-   ILogReader<T> GetLogReader(string methodName);
+   ILogReader<T, TDocument> GetLogReader(string methodName);
 
    ISmartContractBuilder<T> GetSmartContractBuilder(string contractType);
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractTransactionsLookup.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractTransactionsLookup.cs
new file mode 100644
index 00000000..4ea67caf
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/ISmartContractTransactionsLookup.cs
@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
+
+public interface ISmartContractTransactionsLookup<T> where T : SmartContractTable
+{
+   Task<List<CirrusContractTable>> GetTransactionsForSmartContractAsync(string address,
+      long lastProcessedBlockHeight);
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NFTComputedService.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NFTComputedService.cs
deleted file mode 100644
index b4a10e3b..00000000
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NFTComputedService.cs
+++ /dev/null
@@ -1,140 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Blockcore.Indexer.Cirrus.Client;
-using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
-using Blockcore.Indexer.Core.Client;
-using Blockcore.Indexer.Core.Operations.Types;
-using Microsoft.Extensions.Logging;
-using MongoDB.Driver;
-using MongoDB.Driver.Linq;
-
-namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
-
-public class NftComputationService : IComputeSmartContractService<NonFungibleTokenComputedTable>
-{
-   readonly ILogger<NftComputationService> logger;
-   readonly ICirrusMongoDb mongoDb;
-   readonly ISmartContractHandlersFactory<NonFungibleTokenComputedTable> logReaderFactory;
-   readonly CirrusClient cirrusClient;
-
-   public NftComputationService(ILogger<NftComputationService> logger,
-      ICirrusMongoDb mongoDb,
-      ISmartContractHandlersFactory<NonFungibleTokenComputedTable> logReaderFactory,
-      ICryptoClientFactory clientFactory,
-      SyncConnection connection)
-   {
-      this.logger = logger;
-      this.mongoDb = mongoDb;
-      this.logReaderFactory = logReaderFactory;
-      cirrusClient = (CirrusClient)clientFactory.Create(connection);
-   }
-
-   public async Task<NonFungibleTokenComputedTable> ComputeSmartContractForAddressAsync(string address)
-   {
-      var contract = await LookupSmartContractForAddressAsync(address);
-
-      if (contract is null)
-         return null;
-
-      var contractTransactions = await mongoDb.CirrusContractTable
-         .AsQueryable()
-         .Where(_ => (_.ToAddress == address ||
-                      _.Logs.Any(_ => _.Log.Data.ContainsKey("contract") && _.Log.Data["contract"] == address) ) &&
-                     (_.Success && _.BlockIndex > contract.LastProcessedBlockHeight ))
-         .ToListAsync();
-
-      if (contractTransactions.Any())
-      {
-         await AddNewTransactionsDataToDocumentAsync(address, contractTransactions, contract);
-      }
-
-      return contract;
-   }
-
-
-   async Task<NonFungibleTokenComputedTable> LookupSmartContractForAddressAsync(string address)
-   {
-      NonFungibleTokenComputedTable contract = await mongoDb.NonFungibleTokenComputedTable
-         .AsQueryable()
-         .SingleOrDefaultAsync(_ => _.ContractAddress == address);
-
-      if (contract is not null)
-         return contract;
-
-      var contractCode = await mongoDb.CirrusContractCodeTable
-         .AsQueryable()
-         .SingleOrDefaultAsync(_ => _.ContractAddress == address);
-
-      if (contractCode is null || contractCode.CodeType != "NonFungibleToken")
-      {
-         logger.LogInformation(
-            $"Request to compute smart contract for address {address} which was not found in the contract code table");
-         return null;
-      }
-
-      contract = await CreateNewSmartContract(address);
-
-      if (contract is null)
-         throw new ArgumentNullException($"Contract not found in the contract table for address {address}");
-
-      return contract;
-   }
-
-   private async Task<NonFungibleTokenComputedTable> CreateNewSmartContract(string address)
-   {
-      var contractCreationTransaction = await mongoDb.CirrusContractTable
-         .AsQueryable()
-         .Where(_ => _.NewContractAddress == address)
-         .SingleOrDefaultAsync();
-
-      if (contractCreationTransaction is null)
-         throw new ArgumentNullException(nameof(contractCreationTransaction));
-
-      var builder = logReaderFactory.GetSmartContractBuilder(contractCreationTransaction.ContractCodeType);
-
-      var contract = builder.BuildSmartContract(contractCreationTransaction);
-
-      await SaveTheContractAsync(address, contract);
-
-      return contract;
-   }
-
-   private async Task AddNewTransactionsDataToDocumentAsync(string address, List<CirrusContractTable> contractTransactions,
-      NonFungibleTokenComputedTable contract)
-   {
-      foreach (var contractTransaction in contractTransactions)
-      {
-         var reader = logReaderFactory.GetLogReader(contractTransaction.MethodName);
-
-         if (reader is null)
-         {
-            logger.LogInformation($"No reader found for method {contractTransaction.MethodName} on transaction id - {contractTransaction.TransactionId}");
-            throw new InvalidOperationException(
-               $"Reader was not found for transaction - {contractTransaction.TransactionId}");
-         }
-
-         if (!reader.IsTransactionLogComplete(contractTransaction.Logs))
-         {
-            var result = await cirrusClient.GetContractInfoAsync(contractTransaction.TransactionId);
-
-            contractTransaction.Logs = result.Logs;
-         }
-
-         reader.UpdateContractFromTransactionLog(contractTransaction, contract);
-
-         contract.LastProcessedBlockHeight = contractTransaction.BlockIndex;
-      }
-
-      await SaveTheContractAsync(address, contract);
-   }
-
-   async Task SaveTheContractAsync(string address, NonFungibleTokenComputedTable contract) =>
-      await mongoDb.NonFungibleTokenComputedTable
-         .FindOneAndReplaceAsync<NonFungibleTokenComputedTable>(_ => _.ContractAddress == address, contract,
-         new FindOneAndReplaceOptions<NonFungibleTokenComputedTable> { IsUpsert = true },
-         CancellationToken.None);
-
-}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/BurnLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/BurnLogReader.cs
index f1744256..678bc29a 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/BurnLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/BurnLogReader.cs
@@ -2,23 +2,29 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken;
 
-public class BurnLogReader: ILogReader<NonFungibleTokenComputedTable>
+public class BurnLogReader: ILogReader<NonFungibleTokenContractTable,Types.NonFungibleTokenTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("Burn");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       object tokenId = contractTransaction.Logs.SingleOrDefault().Log.Data["tokenId"];
 
       string id = tokenId is string ? (string)tokenId : Convert.ToString(tokenId);
 
-      computedTable.Tokens.Single(_ => _.Id == id)
-         .IsBurned = true;
+      // computedTable.Tokens.Single(_ => _.Id == id)
+      //    .IsBurned = true;
+
+      return new [] { new UpdateOneModel<Types.NonFungibleTokenTable>(
+         Builders<Types.NonFungibleTokenTable>.Filter
+            .Where(_ => _.Id.TokenId == tokenId && _.Id.ContractAddress == computedTable.ContractAddress),
+         Builders<Types.NonFungibleTokenTable>.Update.Set(_ => _.IsBurned, true))};
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/ClaimOwnershipLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/ClaimOwnershipLogReader.cs
index 6ee9cd9c..fbfb2652 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/ClaimOwnershipLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/ClaimOwnershipLogReader.cs
@@ -1,20 +1,22 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken;
 
-public class ClaimOwnershipLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class ClaimOwnershipLogReader : ILogReader<NonFungibleTokenContractTable, Types.NonFungibleTokenTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("ClaimOwnership");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       computedTable.Owner = (string)contractTransaction.Logs.SingleOrDefault().Log.Data["NewOwner"];
       computedTable.PreviousOwners.Add((string)contractTransaction.Logs.SingleOrDefault().Log.Data["PreviousOwner"]);
 
+      return null;
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/MintLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/MintLogReader.cs
index 84fb97fc..5fd3d6e3 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/MintLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/MintLogReader.cs
@@ -2,17 +2,18 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken;
 
-public class MintLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class MintLogReader : ILogReader<NonFungibleTokenContractTable,Types.NonFungibleTokenTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("Mint");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => false;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       var log = contractTransaction.Logs.First()?.Log;
       var uriLog = contractTransaction.Logs.Last()?.Log;
@@ -23,11 +24,14 @@ public void UpdateContractFromTransactionLog(CirrusContractTable contractTransac
       object tokenId = log.Data["tokenId"];
       string id = tokenId is string ? (string)tokenId : Convert.ToString(tokenId);
 
-      computedTable.Tokens.Add(new Token
+      return new [] { new InsertOneModel<Types.NonFungibleTokenTable>(new Types.NonFungibleTokenTable
       {
          Owner = (string)log.Data["to"],
-         Id = id,
+         Id = new SmartContractTokenId
+         {
+            TokenId = id,ContractAddress = computedTable.ContractAddress
+         },
          Uri = (string)uriLog.Data["tokenUri"]
-      });
+      })};
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/NonFungibleTokenSmartContractBuilder.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/NonFungibleTokenSmartContractBuilder.cs
index f85cbf6b..6bb37a3c 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/NonFungibleTokenSmartContractBuilder.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/NonFungibleTokenSmartContractBuilder.cs
@@ -5,11 +5,11 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken;
 
-public class NonFungibleTokenSmartContractBuilder : ISmartContractBuilder<NonFungibleTokenComputedTable>
+public class NonFungibleTokenSmartContractBuilder : ISmartContractBuilder<NonFungibleTokenContractTable>
 {
    public bool CanBuildSmartContract(string contractCodeType) => contractCodeType.Equals("NonFungibleToken");
 
-   public NonFungibleTokenComputedTable BuildSmartContract(CirrusContractTable createContractTransaction)
+   public NonFungibleTokenContractTable BuildSmartContract(CirrusContractTable createContractTransaction)
    {
       var logs = createContractTransaction.Logs.SingleOrDefault()?.Log;
 
@@ -25,7 +25,6 @@ public NonFungibleTokenComputedTable BuildSmartContract(CirrusContractTable crea
          Symbol =  (string)logs.Data["nftSymbol"],
          Owner = (string)logs.Data["nftOwner"],
          OwnerOnlyMinting = (bool)logs.Data["nftOwnerOnlyMinting"],
-         Tokens = new List<Token>()
       };
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/PendingOwnerLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/PendingOwnerLogReader.cs
index 0274b193..da8e438f 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/PendingOwnerLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/PendingOwnerLogReader.cs
@@ -1,18 +1,21 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken;
 
-public class PendingOwnerLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class PendingOwnerLogReader : ILogReader<NonFungibleTokenContractTable,Types.NonFungibleTokenTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("SetPendingOwner");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       computedTable.PendingOwner = (string)contractTransaction.Logs.SingleOrDefault()?.Log.Data["PendingOwner"] ?? string.Empty;
+
+      return null;
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SafeMintLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SafeMintLogReader.cs
index 99da546a..37e1a9c8 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SafeMintLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SafeMintLogReader.cs
@@ -3,17 +3,18 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken;
 
-public class SafeMintLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class SafeMintLogReader : ILogReader<NonFungibleTokenContractTable, Types.NonFungibleTokenTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("SafeMint");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => logs is { Length: 3 };
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       LogData log = contractTransaction.Logs[0].Log;
       LogData saleLog = contractTransaction.Logs[1].Log;
@@ -22,14 +23,17 @@ public void UpdateContractFromTransactionLog(CirrusContractTable contractTransac
       object tokenId = log.Data["tokenId"];
       string id = tokenId is string ? (string)tokenId : Convert.ToString(tokenId);
 
-      computedTable.Tokens.Add(new()
+      return new [] {new InsertOneModel<Types.NonFungibleTokenTable>(new()
       {
          Creator = contractTransaction.FromAddress,
          Owner = contractTransaction.FromAddress,
-         Id = id,
+         Id = new SmartContractTokenId
+         {
+            TokenId = id,ContractAddress = computedTable.ContractAddress
+         },
          Uri = (string)uriLog.Data["tokenUri"],
          SalesHistory = new() { SalesEventReader.SaleDetails(contractTransaction.TransactionId, saleLog, log) }
-      });
+      })};
    }
 
 
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SafeTransferFromLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SafeTransferFromLogReader.cs
index 527421de..c46cd3ff 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SafeTransferFromLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SafeTransferFromLogReader.cs
@@ -2,17 +2,18 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken;
 
-public class SafeTransferFromLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class SafeTransferFromLogReader : ILogReader<NonFungibleTokenContractTable,Types.NonFungibleTokenTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("SafeTransferFrom");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => logs is { Length: 2 };
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       var log = contractTransaction.Logs.First().Log;
       var saleLog = contractTransaction.Logs.Last().Log;
@@ -20,10 +21,13 @@ public void UpdateContractFromTransactionLog(CirrusContractTable contractTransac
       object tokenId = log.Data["tokenId"];
       string id = tokenId is string ? (string)tokenId : Convert.ToString(tokenId);
 
-      var token = computedTable.Tokens.First(_ => _.Id == id);
+      string owner = (string)saleLog.Data["seller"];
 
-      token.Owner = (string)saleLog.Data["seller"];
+      var sale = SalesEventReader.SaleDetails(contractTransaction.TransactionId, saleLog, log);
 
-      token.SalesHistory.Add(SalesEventReader.SaleDetails(contractTransaction.TransactionId, saleLog, log));
+       return new [] { new UpdateOneModel<Types.NonFungibleTokenTable>(Builders<Types.NonFungibleTokenTable>.Filter
+             .Where(_ => _.Id.TokenId == tokenId && _.Id.ContractAddress == computedTable.ContractAddress),
+          Builders<Types.NonFungibleTokenTable>.Update.Set(_ => _.Owner, owner)
+             .AddToSet(_ => _.SalesHistory, sale))};
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SalesEventReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SalesEventReader.cs
index 5c27866e..5626d99b 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SalesEventReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/SalesEventReader.cs
@@ -6,14 +6,14 @@ namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken
 
 public class SalesEventReader
 {
-   public static TokenSaleEvent SaleDetails(string transactionId, LogData saleLog, LogData log)
+   public static TokenSaleEvent SaleDetails(string transactionId, LogData detailsLog, LogData log)
    {
       try
       {
-         return saleLog.Event switch
+         return detailsLog.Event switch
          {
-            "TokenOnSaleLog" => GetSaleDetails(transactionId, saleLog, log),
-            "AuctionStartedLog" => GetAuctionDetails(transactionId, saleLog, log),
+            "TokenOnSaleLog" => GetSaleDetails(transactionId, detailsLog, log),
+            "AuctionStartedLog" => GetAuctionDetails(transactionId, detailsLog, log),
             _ => null
          };
       }
@@ -31,12 +31,12 @@ private static OnSale GetSaleDetails(string transactionId, LogData saleLog, LogD
          TransactionId = transactionId
       };
 
-   private static Auction GetAuctionDetails(string transactionId, LogData saleLog, LogData log) =>
+   private static Auction GetAuctionDetails(string transactionId, LogData auctionLog, LogData log) =>
       new()
-      {//TODO need to understand the auction logic and if it should have it's own reader
-         Seller = (string)log.Data["from"],
-         StartingPrice = (long)saleLog.Data["startingPrice"],
-         EndBlock = (long)saleLog.Data["endBlock"],
+      {
+         Seller = (string)auctionLog.Data["seller"],
+         StartingPrice = (long)auctionLog.Data["startingPrice"],
+         EndBlock = (long)auctionLog.Data["endBlock"],
          TransactionId = transactionId
       };
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/TransferLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/TransferLogReader.cs
index c2cddd2f..a43e6ccd 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/TransferLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleToken/TransferLogReader.cs
@@ -2,17 +2,18 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleToken;
 
-public class TransferLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class TransferLogReader : ILogReader<NonFungibleTokenContractTable, Types.NonFungibleTokenTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("TransferLog") || methodType.Equals("TransferFrom");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       var log = contractTransaction.Logs?.First();
 
@@ -21,15 +22,20 @@ public void UpdateContractFromTransactionLog(CirrusContractTable contractTransac
 
       string tokenId = (string)log.Log.Data["tokenId"];
 
-      var token = computedTable.Tokens.First(_ => _.Id == tokenId);
+      //var token = computedTable.Tokens.First(_ => _.Id == tokenId);
 
-      token.Owner = (string)log.Log.Data["to"];
+      string owner = (string)log.Log.Data["to"];
 
-      token.SalesHistory.Add(new OwnershipTransfer
+      var sale = new OwnershipTransfer
       {
          From = (string)log.Log.Data["from"],
          To = (string)log.Log.Data["to"],
          TransactionId = contractTransaction.TransactionId,
-      });
+      };
+
+      return new [] {new UpdateOneModel<Types.NonFungibleTokenTable>(Builders<Types.NonFungibleTokenTable>.Filter
+            .Where(_ => _.Id.TokenId == tokenId && _.Id.ContractAddress == computedTable.ContractAddress),
+         Builders<Types.NonFungibleTokenTable>.Update.Set(_ => _.Owner, owner)
+            .AddToSet(_ => _.SalesHistory, sale)) };
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenAuction/AuctionEndLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenAuction/AuctionEndLogReader.cs
index e050cd12..2d4dbd6c 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenAuction/AuctionEndLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenAuction/AuctionEndLogReader.cs
@@ -1,35 +1,81 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Bson;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleTokenAuction;
 
-public class AuctionEndLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class AuctionEndLogReader : ILogReader<NonFungibleTokenContractTable,Types.NonFungibleTokenTable>
 {
+   ICirrusMongoDb db;
+
+   public AuctionEndLogReader(ICirrusMongoDb db)
+   {
+      this.db = db;
+   }
+
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("AuctionEnd");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => logs is { Length: 2 };
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       var transferLog = contractTransaction.Logs[0];
       var auctionLog = contractTransaction.Logs[1];
 
       string tokenId = (string)transferLog.Log.Data["tokenId"];
 
-      var token = computedTable.Tokens.Single(_ => _.Id == tokenId);
-
-      var auctionEvent = (Auction) token.SalesHistory.Last(_ => _ is Auction);
-
-      auctionEvent.Success = auctionLog.Log.Event switch
+      bool success = auctionLog.Log.Event switch
       {
          "AuctionEndFailedLog" => false,
          "AuctionEndSucceedLog" => true,
-         _ => auctionEvent.Success
+         _ => false
+      };
+
+      UpdateOneModel<Types.NonFungibleTokenTable> updateInstruction;
+
+      if (success)
+      {
+         updateInstruction = new UpdateOneModel<Types.NonFungibleTokenTable>(Builders<Types.NonFungibleTokenTable>.Filter
+               .Where(_ => _.Id.TokenId == tokenId && _.Id.ContractAddress == computedTable.ContractAddress),
+            Builders<Types.NonFungibleTokenTable>.Update
+               .Set(_ => _.Owner, (string)auctionLog.Log.Data["highestBidder"])
+               .Set("SalesHistory.$[i].Success", true)
+               .Set("SalesHistory.$[i].AuctionEnded", true));
+
+         // updateInstruction.ArrayFilters = new[]
+         // {
+         //    new BsonDocumentArrayFilterDefinition<Auction>(
+         //       new BsonDocument("$and", new BsonArray(
+         //          new[]
+         //          {
+         //             new BsonDocument("i._t[1]", nameof(Auction)),
+         //             new BsonDocument("i.HighestBidTransactionId",
+         //                contractTransaction.TransactionId)
+         //          })))
+         // };
+      }
+      else
+      {
+         updateInstruction = new UpdateOneModel<Types.NonFungibleTokenTable>(Builders<Types.NonFungibleTokenTable>.Filter
+               .Where(_ => _.Id.TokenId == tokenId && _.Id.ContractAddress == computedTable.ContractAddress),
+            Builders<Types.NonFungibleTokenTable>.Update
+               .Set("SalesHistory.$[i].AuctionEnded", true));
+      }
+
+      updateInstruction.ArrayFilters = new[]
+      {
+         new BsonDocumentArrayFilterDefinition<Auction>(
+            new BsonDocument("$and", new BsonArray(
+               new[]
+               {
+                  new BsonDocument("i._t", nameof(Auction)),
+                  new BsonDocument("i.AuctionEnded",false)
+               })))
       };
 
-      if (auctionEvent.Success)
-         token.Owner = auctionEvent.HighestBidder;
+      return new[] { updateInstruction };
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenAuction/BidLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenAuction/BidLogReader.cs
index 5ca2a999..48744d55 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenAuction/BidLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenAuction/BidLogReader.cs
@@ -1,28 +1,51 @@
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Bson;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleTokenAuction;
 
-public class BidLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class BidLogReader : ILogReader<NonFungibleTokenContractTable,Types.NonFungibleTokenTable>
 {
+   ICirrusMongoDb db;
+
+   public BidLogReader(ICirrusMongoDb db)
+   {
+      this.db = db;
+   }
+
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("Bid");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       var auctionLog = contractTransaction.Logs?[0];
 
-     string tokenId = (string)auctionLog.Log.Data["tokenId"];
-
-      var token = computedTable.Tokens.Single(_ => _.Id == tokenId);
-
-      var auctionEvent = (Auction) token.SalesHistory.Last(_ => _ is Auction);
-
-      auctionEvent.HighestBid = (long)auctionLog.Log.Data["bid"];
-      auctionEvent.HighestBidder = (string)auctionLog.Log.Data["bidder"];
-      auctionEvent.HighestBidTransactionId = contractTransaction.TransactionId;
+      string tokenId = (string)auctionLog.Log.Data["tokenId"];
+
+      UpdateOneModel<Types.NonFungibleTokenTable> updateInstruction;
+
+      updateInstruction = new UpdateOneModel<Types.NonFungibleTokenTable>(Builders<Types.NonFungibleTokenTable>.Filter
+            .Where(_ => _.Id.TokenId == tokenId && _.Id.ContractAddress == computedTable.ContractAddress),
+         Builders<Types.NonFungibleTokenTable>.Update
+            .Set("SalesHistory.$[i].HighestBid", (long)auctionLog.Log.Data["bid"])
+            .Set("SalesHistory.$[i].HighestBidder", (string)auctionLog.Log.Data["bidder"])
+            .Set("SalesHistory.$[i].HighestBidTransactionId", contractTransaction.TransactionId));
+
+      updateInstruction.ArrayFilters = new[]
+      {
+         new BsonDocumentArrayFilterDefinition<Auction>(
+            new BsonDocument("$and", new BsonArray(
+               new[]
+               {
+                  new BsonDocument("i._t", nameof(Auction)),
+                  new BsonDocument("i.AuctionEnded",false)
+               })))
+      };
+
+      return new[] { updateInstruction };
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenSmartContractTransactionsLookup.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenSmartContractTransactionsLookup.cs
new file mode 100644
index 00000000..46c36d6c
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenSmartContractTransactionsLookup.cs
@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
+
+public class NonFungibleTokenSmartContractTransactionsLookup : ISmartContractTransactionsLookup<NonFungibleTokenContractTable>
+{
+   readonly ICirrusMongoDb mongoDb;
+
+   public NonFungibleTokenSmartContractTransactionsLookup(ICirrusMongoDb mongoDb)
+   {
+      this.mongoDb = mongoDb;
+   }
+
+   public async Task<List<CirrusContractTable>> GetTransactionsForSmartContractAsync(string address,
+      long lastProcessedBlockHeight)
+   {
+      return await mongoDb.CirrusContractTable
+         .AsQueryable()
+         .Where(_ => (_.ToAddress == address ||
+                      _.Logs.Any(l => l.Address == address)) &&
+                  //    _.Logs.Any(_ => _.Log.Data.ContainsKey("contract") && (string)_.Log.Data["contract"] == address)) &&
+                     (_.Success && _.BlockIndex > lastProcessedBlockHeight))
+         .ToListAsync();
+   }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenStore/BuyLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenStore/BuyLogReader.cs
index bdf8b2bb..2bca336c 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenStore/BuyLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenStore/BuyLogReader.cs
@@ -1,35 +1,59 @@
+using System;
 using System.Linq;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Bson;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleTokenStore;
 
-public class BuyLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class BuyLogReader : ILogReader<NonFungibleTokenContractTable, Types.NonFungibleTokenTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("Buy");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => logs is { Length: 2 };
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
-      var transferLog = contractTransaction.Logs[0];
-      var tokenPurchaseLog = contractTransaction.Logs[1];
+      var transferLog = contractTransaction.Logs.SingleOrDefault(_ => _.Log.Event == "TransferLog");
+      var tokenPurchaseLog = contractTransaction.Logs.SingleOrDefault(_ => _.Log.Event == "TokenPurchasedLog");
+      var royaltyPaidLog = contractTransaction.Logs.SingleOrDefault(_ => _.Log.Event == "RoyaltyPaidLog");
 
-      string seller = (string)tokenPurchaseLog.Log.Data["seller"];
+      string seller = tokenPurchaseLog?.Log.Data.ContainsKey("seller") ?? false
+         ? (string)tokenPurchaseLog.Log.Data["seller"]
+         :  string.Empty;
 
       string tokenId = (string)transferLog.Log.Data["tokenId"];
 
-      var token = computedTable.Tokens.Single(_ => _.Id == tokenId);
+      string buyer =(string)tokenPurchaseLog.Log.Data["buyer"];
 
-      token.Owner = (string)tokenPurchaseLog.Log.Data["buyer"];
+      var updateInstruction = new UpdateOneModel<Types.NonFungibleTokenTable>(Builders<Types.NonFungibleTokenTable>.Filter
+            .Where(_ => _.Id.TokenId == tokenId && _.Id.ContractAddress == computedTable.ContractAddress),
+         Builders<Types.NonFungibleTokenTable>.Update.Set(_ => _.Owner, buyer)
+            .Set("SalesHistory.$[i].Buyer", buyer)
+            .Set("SalesHistory.$[i].Sold", true)
+            .Set("SalesHistory.$[i].PurchaseTransactionId", contractTransaction.TransactionId));
 
-      var onSale = (OnSale)token.SalesHistory.Last(_ => _ is OnSale sale
-                                                        && sale.Seller == seller
-                                                        && !sale.Sold);
 
-      onSale.Buyer = (string)tokenPurchaseLog.Log.Data["buyer"];
-      onSale.Sold = true;
-      onSale.PurchaseTransactionId = contractTransaction.TransactionId;
+      var bsonFilterArray = new BsonArray(new[]
+      {
+         new BsonDocument("i._t", "OnSale"),
+         new BsonDocument("i.Sold", false)
+      });
+
+      if (seller != string.Empty)
+         bsonFilterArray.Add(new BsonDocument("i.Seller", seller));
+
+      updateInstruction.ArrayFilters = new[] { new BsonDocumentArrayFilterDefinition<OnSale>(
+         new BsonDocument("$and",bsonFilterArray)) };
+
+      if (royaltyPaidLog != null)
+      {
+         //TODO add the royalty data to the sale history
+      }
+
+
+      return new[] { updateInstruction };
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenStore/CancelSaleLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenStore/CancelSaleLogReader.cs
index 66558155..0930d280 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenStore/CancelSaleLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/NonFungibleTokenStore/CancelSaleLogReader.cs
@@ -1,31 +1,51 @@
 using System;
 using System.Linq;
+using System.Security.AccessControl;
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Bson;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.NonFungibleTokenStore;
 
-public class CancelSaleLogReader : ILogReader<NonFungibleTokenComputedTable>
+public class CancelSaleLogReader : ILogReader<NonFungibleTokenContractTable,Types.NonFungibleTokenTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.Equals("CancelSale");
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => logs is { Length: 2 };
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      NonFungibleTokenComputedTable computedTable)
+   public WriteModel<Types.NonFungibleTokenTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      NonFungibleTokenContractTable computedTable)
    {
       var transferLog = contractTransaction.Logs[0];
       var tokenPurchaseLog = contractTransaction.Logs[1];
 
       string tokenId = (string) transferLog.Log.Data["tokenId"];
 
-      var token = computedTable.Tokens.Single(_ => _.Id == tokenId);
+      //var token = computedTable.Tokens.Single(_ => _.Id == tokenId);
 
-      var saleEvent = (OnSale) token.SalesHistory.Last(_ => _ is OnSale);
+      // var saleEvent = (OnSale) token.SalesHistory.Last(_ => _ is OnSale);
+      //
+      // if (saleEvent.Seller != contractTransaction.FromAddress)
+      //    throw new InvalidOperationException($"The seller must cancel the sale order {saleEvent.TransactionId} for {contractTransaction.TransactionId}");
 
-      if (saleEvent.Seller != contractTransaction.FromAddress)
-         throw new InvalidOperationException($"The seller must cancel the sale order {saleEvent.TransactionId} for {contractTransaction.TransactionId}");
+      //token.SalesHistory.Remove(saleEvent);
 
-      token.SalesHistory.Remove(saleEvent);
+      var updateInstruction = new UpdateOneModel<Types.NonFungibleTokenTable>(Builders<Types.NonFungibleTokenTable>.Filter
+            .Where(_ => _.Id.TokenId == tokenId && _.Id.ContractAddress == computedTable.ContractAddress),
+         Builders<Types.NonFungibleTokenTable>.Update.Unset("SalesHistory.$[i]"));
+
+      updateInstruction.ArrayFilters = new[]
+      {
+         new BsonDocumentArrayFilterDefinition<OnSale>(new BsonDocument("$and",
+            new BsonArray(new[]
+            {
+               new BsonDocument("i.Seller", contractTransaction.FromAddress),
+               new BsonDocument("i._t", "OnSale"),
+               new BsonDocument("i.Sold", false)
+            })))
+      };
+
+      return new[] { updateInstruction };
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/SmartContractHandlersFactory.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/SmartContractHandlersFactory.cs
index fea30195..acd78ea8 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/SmartContractHandlersFactory.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/SmartContractHandlersFactory.cs
@@ -4,19 +4,20 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
 
-public class SmartContractHandlersFactory<T> : ISmartContractHandlersFactory<T>
-   where T : SmartContractComputedBase
+public class SmartContractHandlersFactory<T,TDocument> : ISmartContractHandlersFactory<T,TDocument>
+   where T : SmartContractTable
+   where TDocument : new()
 {
    readonly IEnumerable<ISmartContractBuilder<T>> builders;
-   readonly List<ILogReader<T>> readers;
+   readonly List<ILogReader<T,TDocument>> readers;
 
-   public SmartContractHandlersFactory(IEnumerable<ILogReader<T>> readers, IEnumerable<ISmartContractBuilder<T>> builders)
+   public SmartContractHandlersFactory(IEnumerable<ILogReader<T,TDocument>> readers, IEnumerable<ISmartContractBuilder<T>> builders)
    {
       this.builders = builders;
       this.readers = readers.ToList();
    }
 
-   public ILogReader<T> GetLogReader(string methodName)
+   public ILogReader<T, TDocument> GetLogReader(string methodName)
    {
       foreach (var reader in readers)
       {
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/SmartContractTransactionsLookup.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/SmartContractTransactionsLookup.cs
new file mode 100644
index 00000000..4e7764bc
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/SmartContractTransactionsLookup.cs
@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
+
+public class SmartContractTransactionsLookup<T> : ISmartContractTransactionsLookup<T> where T : SmartContractTable
+{
+   readonly ICirrusMongoDb mongoDb;
+
+   public SmartContractTransactionsLookup(ICirrusMongoDb mongoDb)
+   {
+      this.mongoDb = mongoDb;
+   }
+
+   public async Task<List<CirrusContractTable>> GetTransactionsForSmartContractAsync(string address, long lastProcessedBlockHeight)
+   {
+      return await mongoDb.CirrusContractTable
+         .AsQueryable()
+         .Where(_ => _.ToAddress == address && _.Success && _.BlockIndex > lastProcessedBlockHeight)
+         .ToListAsync();
+      ;
+   }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/GetOrPropertyLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/GetOrPropertyLogReader.cs
index b5531eb2..7caade5a 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/GetOrPropertyLogReader.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/GetOrPropertyLogReader.cs
@@ -1,9 +1,10 @@
 using Blockcore.Indexer.Cirrus.Client.Types;
 using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.StandardToken;
 
-class GetOrPropertyLogReader : ILogReader<StandardTokenComputedTable>
+class GetOrPropertyLogReader : ILogReader<StandardTokenContractTable,StandardTokenHolderTable>
 {
    public bool CanReadLogForMethodType(string methodType) => methodType.StartsWith("get_") ||
                                                              methodType.StartsWith("Get") ||
@@ -12,9 +13,9 @@ public bool CanReadLogForMethodType(string methodType) => methodType.StartsWith(
 
    public bool IsTransactionLogComplete(LogResponse[] logs) => true;
 
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      StandardTokenComputedTable computedTable)
+   public WriteModel<StandardTokenHolderTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      StandardTokenContractTable computedTable)
    {
-
+      return null;
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/StandardTokenSmartContractBuilder.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/StandardTokenSmartContractBuilder.cs
index 419f0ec0..9bb9a19b 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/StandardTokenSmartContractBuilder.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/StandardTokenSmartContractBuilder.cs
@@ -5,18 +5,25 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
 
-class StandardTokenSmartContractBuilder : ISmartContractBuilder<StandardTokenComputedTable>
+class StandardTokenSmartContractBuilder : ISmartContractBuilder<StandardTokenContractTable>
 {
+   readonly ICirrusMongoDb db;
+
+   public StandardTokenSmartContractBuilder(ICirrusMongoDb db)
+   {
+      this.db = db;
+   }
+
    public bool CanBuildSmartContract(string contractCodeType) => contractCodeType.Equals("StandardToken");
 
-   public StandardTokenComputedTable BuildSmartContract(CirrusContractTable createContractTransaction)
+   public StandardTokenContractTable BuildSmartContract(CirrusContractTable createContractTransaction)
    {
       var logs = createContractTransaction.Logs.SingleOrDefault()?.Log;
 
       if (logs is null)
          throw new InvalidOperationException("Missing logs for create transaction of smart contract");
 
-      return new()
+      return new StandardTokenContractTable
       {
          ContractAddress = createContractTransaction.NewContractAddress,
          ContractCreateTransactionId = createContractTransaction.TransactionId,
@@ -25,14 +32,8 @@ public StandardTokenComputedTable BuildSmartContract(CirrusContractTable createC
          Name = (string)logs.Data["tokenName"],
          Symbol = (string)logs.Data["tokenSymbole"],
          TotalSupply = (long)logs.Data["tokenTotalSupply"],
-         TokenHolders = new List<StandardTokenHolder>
-         {
-            new()
-            {
-               Address = createContractTransaction.FromAddress,
-               Amount = (long)logs.Data["tokenTotalSupply"]
-            }
-         }
+         CreatedOnBlock = createContractTransaction.BlockIndex,
+         CreatorAddress = createContractTransaction.FromAddress,
       };
    }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferFromLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferFromLogReader.cs
deleted file mode 100644
index a5890ad5..00000000
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferFromLogReader.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-using System.Linq;
-using Blockcore.Indexer.Cirrus.Client.Types;
-using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
-
-namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.StandardToken;
-
-public class TransferFromLogReader : ILogReader<StandardTokenComputedTable>
-{
-   public bool CanReadLogForMethodType(string methodType) => methodType.Equals("TransferFrom");
-
-   public bool IsTransactionLogComplete(LogResponse[] logs) => true;
-
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      StandardTokenComputedTable computedTable)
-   {
-      string fromAddress = (string)contractTransaction.Logs.Single().Log.Data["from"];
-      string toAddress = (string)contractTransaction.Logs.Single().Log.Data["to"];
-      long amount = (long)contractTransaction.Logs.Single().Log.Data["amount"];
-
-      var fromHolder = computedTable.TokenHolders.Single(_ => _.Address == fromAddress);
-      fromHolder.Amount -= amount;
-
-      var toHolder = computedTable.TokenHolders.SingleOrDefault(_ => _.Address == toAddress);
-      if (toHolder is null)
-      {
-         toHolder = new StandardTokenHolder { Address = toAddress };
-         computedTable.TokenHolders.Add(toHolder);
-      }
-
-      toHolder.Amount += amount;
-   }
-}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferToAndFromLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferToAndFromLogReader.cs
new file mode 100644
index 00000000..95e8ac96
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferToAndFromLogReader.cs
@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Blockcore.Indexer.Cirrus.Client.Types;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using MongoDB.Driver;
+
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.StandardToken;
+
+public class TransferToAndFromLogReader : ILogReader<StandardTokenContractTable, StandardTokenHolderTable>
+{
+   public bool CanReadLogForMethodType(string methodType) => methodType.Equals("TransferTo") || methodType.Equals("TransferFrom");
+
+   public bool IsTransactionLogComplete(LogResponse[] logs) => logs?.Any(_ => _.Log.Data.ContainsKey("from") &&
+                                                                             _.Log.Data.ContainsKey("to") &&
+                                                                             _.Log.Data.ContainsKey("amount")) ?? false;
+
+   public WriteModel<StandardTokenHolderTable>[] UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
+      StandardTokenContractTable computedTable)
+   {
+      if (contractTransaction.Logs == null || !contractTransaction.Logs.Any())
+      {
+         return Array.Empty<WriteModel<StandardTokenHolderTable>>(); //Need to understand why this happens (example transaction id - a03a7c0122668c9c6d5a7bb47494f903a89519d8fbec2df135eb6687047c58d5)
+      }
+
+      string fromAddress = (string)contractTransaction.Logs.SingleOrDefault().Log.Data["from"];
+      string toAddress = (string)contractTransaction.Logs.SingleOrDefault().Log.Data["to"];
+      object objectAmount = contractTransaction.Logs.SingleOrDefault().Log.Data["amount"];
+
+
+
+      long? amount = objectAmount switch
+      {
+         string => Convert.ToInt64(objectAmount),
+         long => (long?)objectAmount,
+         _ => throw new InvalidCastException(objectAmount.ToString())
+      };
+
+      var addCreatorTokenIfNotExists = new UpdateOneModel<StandardTokenHolderTable>(Builders<StandardTokenHolderTable>.Filter
+            .Where(_ => _.Id.TokenId == computedTable.CreatorAddress &&
+                        _.Id.ContractAddress == computedTable.ContractAddress),
+         Builders<StandardTokenHolderTable>.Update.SetOnInsert(_ => _.Id.TokenId, computedTable.CreatorAddress)
+            .SetOnInsert(_ => _.Id.ContractAddress, computedTable.ContractAddress)
+            .SetOnInsert(_ => _.AmountChangesHistory,
+               new List<StandardTokenAmountChange>
+               {
+                  new ()
+                  {
+                     Amount = computedTable.TotalSupply,
+                     BlockIndex = computedTable.CreatedOnBlock,
+                     TransactionId = computedTable.ContractCreateTransactionId
+                  }
+               }));
+
+      addCreatorTokenIfNotExists.IsUpsert = true;
+
+      var addToAddressIfNotExists = new UpdateOneModel<StandardTokenHolderTable>(Builders<StandardTokenHolderTable>.Filter
+            .Where(_ => _.Id.TokenId == toAddress && _.Id.ContractAddress == computedTable.ContractAddress),
+         Builders<StandardTokenHolderTable>.Update.SetOnInsert(_ => _.Id.TokenId, toAddress)
+            .SetOnInsert(_ => _.Id.ContractAddress, computedTable.ContractAddress));
+
+      addToAddressIfNotExists.IsUpsert = true;
+
+      return new WriteModel<StandardTokenHolderTable>[]
+      {
+         addCreatorTokenIfNotExists,
+         addToAddressIfNotExists,
+         new UpdateOneModel<StandardTokenHolderTable>(Builders<StandardTokenHolderTable>.Filter
+               .Where(_ => _.Id.TokenId == fromAddress && _.Id.ContractAddress == computedTable.ContractAddress),
+            Builders<StandardTokenHolderTable>.Update.AddToSet(_ => _.AmountChangesHistory, new StandardTokenAmountChange{Amount = -amount ?? 0,BlockIndex = contractTransaction.BlockIndex,TransactionId = contractTransaction.TransactionId})),
+         new UpdateOneModel<StandardTokenHolderTable>(Builders<StandardTokenHolderTable>.Filter
+               .Where(_ => _.Id.TokenId == toAddress && _.Id.ContractAddress == computedTable.ContractAddress),
+            Builders<StandardTokenHolderTable>.Update.AddToSet(_ => _.AmountChangesHistory, new StandardTokenAmountChange{Amount = amount ?? 0,BlockIndex = contractTransaction.BlockIndex,TransactionId = contractTransaction.TransactionId}))
+      };
+   }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferToLogReader.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferToLogReader.cs
deleted file mode 100644
index 0a296bc4..00000000
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/SmartContracts/StandardToken/TransferToLogReader.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-using System;
-using System.Linq;
-using Blockcore.Indexer.Cirrus.Client.Types;
-using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
-
-namespace Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts.StandardToken;
-
-public class TransferToLogReader : ILogReader<StandardTokenComputedTable>
-{
-   public bool CanReadLogForMethodType(string methodType) => methodType.Equals("TransferTo");
-
-   public bool IsTransactionLogComplete(LogResponse[] logs) =>
-      logs != null && logs.Length == 1 && logs.Single().Log.Data.Count == 3;
-
-   public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
-      StandardTokenComputedTable computedTable)
-   {
-      if (contractTransaction.Logs == null || !contractTransaction.Logs.Any())
-      {
-         return; //Need to understand why this happens (example transaction id - a03a7c0122668c9c6d5a7bb47494f903a89519d8fbec2df135eb6687047c58d5)
-      }
-
-      string fromAddress = (string)contractTransaction.Logs.SingleOrDefault().Log.Data["from"];
-      string toAddress = (string)contractTransaction.Logs.SingleOrDefault().Log.Data["to"];
-      long? amount = (long?)contractTransaction.Logs.SingleOrDefault().Log.Data["amount"];
-
-      if (fromAddress is null || toAddress is null || !amount.HasValue)
-      {
-         Console.WriteLine("");
-      }
-
-      var fromHolder = computedTable.TokenHolders.SingleOrDefault(_ => _.Address == fromAddress);
-      fromHolder = AddStandardTokenAccountHolder(computedTable, fromHolder, fromAddress);
-      fromHolder.Amount -= amount.Value;
-
-      var toHolder = computedTable.TokenHolders.SingleOrDefault(_ => _.Address == toAddress);
-      toHolder = AddStandardTokenAccountHolder(computedTable, toHolder, toAddress);
-
-      toHolder.Amount += amount.Value;
-
-
-   }
-
-   static StandardTokenHolder AddStandardTokenAccountHolder(StandardTokenComputedTable computedTable,
-      StandardTokenHolder? holder, string address)
-   {
-      if (holder is not null)
-         return holder;
-
-      holder = new StandardTokenHolder { Address = address };
-      computedTable.TokenHolders.Add(holder);
-
-      return holder;
-   }
-}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/CirrusContractCodeTable.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/CirrusContractCodeTable.cs
index 3d47c023..2ca72892 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/CirrusContractCodeTable.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/CirrusContractCodeTable.cs
@@ -1,6 +1,4 @@
-using Blockcore.Indexer.Cirrus.Client.Types;
-using Blockcore.Indexer.Core.Storage.Mongo.Types;
-using NBitcoin;
+using MongoDB.Bson.Serialization.Attributes;
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types
 {
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractDeposit.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractDeposit.cs
index 7da9f21f..9331170d 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractDeposit.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractDeposit.cs
@@ -6,4 +6,5 @@ public class DaoContractDeposit
    public long Amount { get; set; }
 
    public string TransactionId { get; set; }
+   public long BlockIndex { get; set; }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractProposal.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractProposalTable.cs
similarity index 88%
rename from src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractProposal.cs
rename to src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractProposalTable.cs
index 741677c6..6c73a0c6 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractProposal.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractProposalTable.cs
@@ -2,9 +2,8 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
 
-public class DaoContractProposal
+public class DaoContractProposalTable : SmartContractData
 {
-   public int Id { get; set; }
    public string Recipient { get; set; }
    public long Amount { get; set; }
    public string Description { get; set; }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractComputedTable.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractTable.cs
similarity index 67%
rename from src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractComputedTable.cs
rename to src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractTable.cs
index 7d67d332..56a5ea1a 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractComputedTable.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/DaoContractTable.cs
@@ -2,17 +2,12 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
 
-public class DaoContractComputedTable : SmartContractComputedBase
+public class DaoContractTable : SmartContractTable
 {
-   public override string ContractType { get; } = "DAOContract";
-
    public long CurrentAmount { get; set; }
    public long MaxVotingDuration { get; set; }
    public long MinVotingDuration { get; set; }
    public long WhitelistedCount { get; set; }
-
-   public List<DaoContractProposal> Proposals { get; set; }
-
    public List<DaoContractDeposit> Deposits { get; set; }
 
    public List<string> ApprovedAddresses { get; set; }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/NonFungibleTokenComputedTable.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/NonFungibleTokenContractTable.cs
similarity index 65%
rename from src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/NonFungibleTokenComputedTable.cs
rename to src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/NonFungibleTokenContractTable.cs
index 634e9d47..00a0d854 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/NonFungibleTokenComputedTable.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/NonFungibleTokenContractTable.cs
@@ -2,17 +2,12 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
 
-public class NonFungibleTokenComputedTable : SmartContractComputedBase
+public class NonFungibleTokenContractTable : SmartContractTable
 {
    public string Name { get; set; }
    public string Symbol { get; set; }
-
    public string Owner { get; set; }
-   public override string ContractType { get; } = "NonFungibleToken";
-
-   public List<Token> Tokens { get; set; }
    public bool OwnerOnlyMinting { get; set; }
    public string PendingOwner { get; set; }
-
    public List<string> PreviousOwners { get; set; }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/Token.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/NonFungibleTokenTable.cs
similarity index 85%
rename from src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/Token.cs
rename to src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/NonFungibleTokenTable.cs
index c85febd6..555d8863 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/Token.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/NonFungibleTokenTable.cs
@@ -2,10 +2,8 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
 
-public class Token
+public class NonFungibleTokenTable : SmartContractData
 {
-   public string Id { get; set; }
-
    public string Creator { get; set; }
    public string Owner { get; set; }
    public string Uri { get; set; }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/Sale.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/Sale.cs
index 137704a7..38a03734 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/Sale.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/Sale.cs
@@ -30,6 +30,7 @@ public class Auction : TokenSaleEvent
    public string Seller { get; set; }
    public long StartingPrice { get; set; }
    public long EndBlock { get; set; }
+   public bool AuctionEnded { get; set; }
 
    public string HighestBidder { get; set; }
    public long HighestBid { get; set; }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractData.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractData.cs
new file mode 100644
index 00000000..d241ac9e
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractData.cs
@@ -0,0 +1,9 @@
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+
+public class SmartContractData
+{
+   [BsonId]
+   public SmartContractTokenId Id { get; set; }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractComputedBase.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractTable.cs
similarity index 71%
rename from src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractComputedBase.cs
rename to src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractTable.cs
index 7f91ac25..1095dc51 100644
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractComputedBase.cs
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractTable.cs
@@ -2,12 +2,9 @@
 
 namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
 
-public abstract class SmartContractComputedBase
+public abstract class SmartContractTable
 {
-   [BsonId]
    public string ContractAddress { get; set; }
    public string ContractCreateTransactionId { get; set; }
    public long LastProcessedBlockHeight { get; set; }
-
-   public abstract string ContractType { get; }
 }
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractTokenId.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractTokenId.cs
new file mode 100644
index 00000000..1b95da8e
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/SmartContractTokenId.cs
@@ -0,0 +1,7 @@
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+
+public class SmartContractTokenId
+{
+   public string TokenId { get; set; }
+   public string ContractAddress { get; set; }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenAmountChange.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenAmountChange.cs
new file mode 100644
index 00000000..3cad4024
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenAmountChange.cs
@@ -0,0 +1,8 @@
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+
+public class StandardTokenAmountChange
+{
+   public long BlockIndex { get; set; } //This is for rewinds
+   public string TransactionId { get; set; }
+   public long Amount { get; set; }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenComputedTable.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenComputedTable.cs
deleted file mode 100644
index f77289f2..00000000
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenComputedTable.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-using System.Collections.Generic;
-
-namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
-
-public class StandardTokenComputedTable : SmartContractComputedBase
-{
-   public override string ContractType { get; } = "StandardToken";
-
-   public string Name { get; set; }
-
-   public string Symbol { get; set; }
-
-   public long TotalSupply { get; set; }
-
-   public long Decimals { get; set; }
-
-
-   public List<StandardTokenHolder> TokenHolders { get; set; } = new();
-}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenContractTable.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenContractTable.cs
new file mode 100644
index 00000000..7ad4e4cc
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenContractTable.cs
@@ -0,0 +1,14 @@
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+
+public class StandardTokenContractTable : SmartContractTable
+{
+   public string Name { get; set; }
+
+   public string Symbol { get; set; }
+
+   public long TotalSupply { get; set; }
+
+   public long Decimals { get; set; }
+   public long CreatedOnBlock { get; set; }
+   public string CreatorAddress { get; set; }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenHolder.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenHolder.cs
deleted file mode 100644
index 3c61f9e1..00000000
--- a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenHolder.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
-
-public class StandardTokenHolder
-{
-   public string Address { get; set; }
-   public long Amount { get; set; }
-}
diff --git a/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenHolderTable.cs b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenHolderTable.cs
new file mode 100644
index 00000000..844d1e28
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Storage/Mongo/Types/StandardTokenHolderTable.cs
@@ -0,0 +1,9 @@
+using System.Collections.Generic; 
+
+namespace Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+
+public class StandardTokenHolderTable : SmartContractData
+{
+   // public string Address { get; set; }
+   public List<StandardTokenAmountChange> AmountChangesHistory { get; set; }
+}
diff --git a/src/Blockcore.Indexer.Cirrus/Sync/SyncTasks/SmartContractSyncRunner.cs b/src/Blockcore.Indexer.Cirrus/Sync/SyncTasks/SmartContractSyncRunner.cs
new file mode 100644
index 00000000..f0b164e9
--- /dev/null
+++ b/src/Blockcore.Indexer.Cirrus/Sync/SyncTasks/SmartContractSyncRunner.cs
@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Blockcore.Indexer.Cirrus.Storage;
+using Blockcore.Indexer.Cirrus.Storage.Mongo;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.SmartContracts;
+using Blockcore.Indexer.Cirrus.Storage.Mongo.Types;
+using Blockcore.Indexer.Core.Settings;
+using Blockcore.Indexer.Core.Sync.SyncTasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using MongoDB.Driver;
+
+namespace Blockcore.Indexer.Cirrus.Sync.SyncTasks;
+
+public class SmartContractSyncRunner : TaskRunner
+{
+   ICirrusStorage storage;
+   ICirrusMongoDb db;
+   ILogger<SmartContractSyncRunner> logger;
+
+   readonly Dictionary<string, Func<string,Task>> supportedSmartContractTypes;
+
+   public SmartContractSyncRunner(IOptions<IndexerSettings> configuration,
+      ICirrusStorage storage,
+      IComputeSmartContractService<DaoContractTable> daoContractService,
+      IComputeSmartContractService<StandardTokenContractTable> standardTokenService,
+      IComputeSmartContractService<NonFungibleTokenContractTable> nonFungibleTokenService,
+      ICirrusMongoDb db,
+      ILogger<SmartContractSyncRunner> logger)
+      : base(configuration, logger)
+   {
+      this.storage = storage;
+      this.db = db;
+      this.logger = logger;
+
+      supportedSmartContractTypes = new Dictionary<string, Func<string,Task>>
+      {
+         { "DAOContract", daoContractService.ComputeSmartContractForAddressAsync },
+         { "StandardToken", standardTokenService.ComputeSmartContractForAddressAsync },
+         { "NonFungibleToken", nonFungibleTokenService.ComputeSmartContractForAddressAsync },
+      };
+
+      Delay = TimeSpan.FromMinutes(1);
+   }
+
+   public override async Task<bool> OnExecute()
+   {
+      if (!Runner.GlobalState.IndexModeCompleted ||
+          Runner.GlobalState.Blocked ||
+          Runner.GlobalState.ReorgMode ||
+          Runner.GlobalState.StoreTip == null ||
+          Runner.GlobalState.IndexMode)
+      {
+         return false;
+      }
+
+      logger.LogDebug($"Calling {nameof(storage.GetSmartContractsThatNeedsUpdatingAsync)}");
+
+      var smartContractAddresses = await storage.GetSmartContractsThatNeedsUpdatingAsync(supportedSmartContractTypes.Keys.ToArray());
+
+      if (!smartContractAddresses.Any())
+         return false;
+
+      logger.LogDebug($"Lookup found {smartContractAddresses.Count} that needs updating");
+
+      var types = db.CirrusContractCodeTable.AsQueryable()
+         .Where(_ => smartContractAddresses.Contains(_.ContractAddress))
+         .Select(_ => new { address = _.ContractAddress, contractType = _.CodeType })
+         .ToArray();
+
+      foreach (var type in types)
+      {
+         try
+         {
+            if (!supportedSmartContractTypes.ContainsKey(type.contractType))
+               continue;
+
+            Func<string, Task> serviceToRun = supportedSmartContractTypes[type.contractType];
+
+            await serviceToRun.Invoke(type.address);
+         }
+         catch (Exception e)
+         {
+            //We won't stop the loop so all other smart contracts can be computed
+            logger.LogError(e,$"unable to compute smart contract - {type.contractType} for address - {type.address}");
+         }
+      }
+
+      logger.LogDebug($"Completed execution of {nameof(SmartContractSyncRunner)}");
+
+      return false;
+   }
+}
diff --git a/src/Blockcore.Indexer.Core/Startup.cs b/src/Blockcore.Indexer.Core/Startup.cs
index 6f758ece..ef4c427b 100644
--- a/src/Blockcore.Indexer.Core/Startup.cs
+++ b/src/Blockcore.Indexer.Core/Startup.cs
@@ -154,6 +154,8 @@ public static void AddIndexerServices(IServiceCollection services, IConfiguratio
          services.AddTransient<IMapMongoBlockToStorageBlock, MapMongoBlockToStorageBlock>();
          services.AddSingleton<ICryptoClientFactory, CryptoClientFactory>();
          services.AddSingleton<ISyncBlockTransactionOperationBuilder, SyncBlockTransactionOperationBuilder>();
+
+         services.AddTransient<IBlockRewindOperation, BlockRewindOperation>();
       }
 
       public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
diff --git a/src/Blockcore.Indexer.Core/Storage/Mongo/BlockRewindOperation.cs b/src/Blockcore.Indexer.Core/Storage/Mongo/BlockRewindOperation.cs
index 78cd5e12..79d29dbd 100644
--- a/src/Blockcore.Indexer.Core/Storage/Mongo/BlockRewindOperation.cs
+++ b/src/Blockcore.Indexer.Core/Storage/Mongo/BlockRewindOperation.cs
@@ -1,7 +1,5 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
 using Blockcore.Indexer.Core.Storage.Mongo.Types;
 using MongoDB.Bson;
@@ -9,9 +7,16 @@
 
 namespace Blockcore.Indexer.Core.Storage.Mongo;
 
-public static class BlockRewindOperation
+public class BlockRewindOperation : IBlockRewindOperation
 {
-   public static async Task RewindBlockAsync(this IMongoDb storage, uint blockIndex)
+   protected IMongoDb storage;
+
+   public BlockRewindOperation(IMongoDb storage)
+   {
+      this.storage = storage;
+   }
+
+   public async Task RewindBlockAsync(uint blockIndex)
    {
       await StoreRewindBlockAsync(storage, blockIndex);
 
diff --git a/src/Blockcore.Indexer.Core/Storage/Mongo/IBlockRewindOperation.cs b/src/Blockcore.Indexer.Core/Storage/Mongo/IBlockRewindOperation.cs
new file mode 100644
index 00000000..dbafca3e
--- /dev/null
+++ b/src/Blockcore.Indexer.Core/Storage/Mongo/IBlockRewindOperation.cs
@@ -0,0 +1,8 @@
+using System.Threading.Tasks;
+
+namespace Blockcore.Indexer.Core.Storage.Mongo;
+
+public interface IBlockRewindOperation
+{
+   Task RewindBlockAsync(uint blockIndex);
+}
diff --git a/src/Blockcore.Indexer.Core/Storage/Mongo/MongoData.cs b/src/Blockcore.Indexer.Core/Storage/Mongo/MongoData.cs
index 84175a37..59520464 100644
--- a/src/Blockcore.Indexer.Core/Storage/Mongo/MongoData.cs
+++ b/src/Blockcore.Indexer.Core/Storage/Mongo/MongoData.cs
@@ -34,9 +34,11 @@ public class MongoData : IStorage
       private readonly IMapMongoBlockToStorageBlock mongoBlockToStorageBlock;
       readonly ICryptoClientFactory clientFactory;
 
+      readonly IBlockRewindOperation rewindOperation;
+
       public MongoData(ILogger<MongoDb> dbLogger, SyncConnection connection, IOptions<ChainSettings> chainConfiguration,
          GlobalState globalState, IMapMongoBlockToStorageBlock mongoBlockToStorageBlock, ICryptoClientFactory clientFactory,
-         IScriptInterpeter scriptInterpeter, IMongoDatabase mongoDatabase, IMongoDb db)
+         IScriptInterpeter scriptInterpeter, IMongoDatabase mongoDatabase, IMongoDb db, IBlockRewindOperation rewindOperation)
       {
          log = dbLogger;
          this.chainConfiguration = chainConfiguration.Value;
@@ -48,6 +50,7 @@ public MongoData(ILogger<MongoDb> dbLogger, SyncConnection connection, IOptions<
          this.scriptInterpeter = scriptInterpeter;
          this.mongoDatabase = mongoDatabase;
          mongoDb = db;
+         this.rewindOperation = rewindOperation;
       }
 
       /// <summary>
@@ -981,7 +984,7 @@ public async Task DeleteBlockAsync(string blockHash)
             log.LogWarning("Rewinding block without indexes this can be a long operation!");
          }
 
-         await mongoDb.RewindBlockAsync((uint)block.BlockIndex);
+         await rewindOperation.RewindBlockAsync((uint)block.BlockIndex);
 
          // signal to any child classes to deleted a block.
          await OnDeleteBlockAsync(block);
diff --git a/src/Blockcore.Indexer.Tests/Storage/Mongo/MongoStorageOperationsTests.cs b/src/Blockcore.Indexer.Tests/Storage/Mongo/MongoStorageOperationsTests.cs
index e4540d66..3f243dc8 100644
--- a/src/Blockcore.Indexer.Tests/Storage/Mongo/MongoStorageOperationsTests.cs
+++ b/src/Blockcore.Indexer.Tests/Storage/Mongo/MongoStorageOperationsTests.cs
@@ -94,8 +94,10 @@ public MongoStorageOperationsTests()
          globalState,
          new MapMongoBlockToStorageBlock(),
          scriptInterpeter.Object,
-         new MongoData(null, syncConnection, chainSetting.Object, globalState, new MapMongoBlockToStorageBlock(),
-            cryptoClientFactory.Object, scriptInterpeter.Object, mongodbMock.MongoDatabaseObject, mongodbMock.MongoDbObject));
+         new MongoData(null, syncConnection, chainSetting.Object, globalState,
+            new MapMongoBlockToStorageBlock(),
+            cryptoClientFactory.Object, scriptInterpeter.Object, mongodbMock.MongoDatabaseObject,
+            mongodbMock.MongoDbObject, new Mock<IBlockRewindOperation>().Object));
    }
 
    private static BlockInfo NewRandomBlockInfo => new()

From 0acf0708bb1434da3aaa5d710b50f3e3008babd1 Mon Sep 17 00:00:00 2001
From: TheDude <david@vsodir.onmicrosoft.com>
Date: Mon, 4 Jul 2022 10:44:39 +0100
Subject: [PATCH 09/11] Updated version

---
 CHANGELOG.md              | 27 +++++++++++++++++++++++++++
 package.json              |  2 +-
 src/Directory.Build.props |  2 +-
 3 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c1fdb770..ca5f02ed 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,30 @@
+## <small>0.2.36 (2022-07-04)</small>
+
+* Added endpoint that lists tokens for an owner address ([53c05c4](https://github.com/block-core/blockcore-indexer/commit/53c05c4))
+* Added rewind logic for smart contracts ([83f5b28](https://github.com/block-core/blockcore-indexer/commit/83f5b28))
+* Changed the assets endpoint to get data from the tokens table ([00e539f](https://github.com/block-core/blockcore-indexer/commit/00e539f))
+* Changed tokens to another table and fixing of debug issues - not complete ([8129f16](https://github.com/block-core/blockcore-indexer/commit/8129f16))
+* Deleted commented code ([2e9d14e](https://github.com/block-core/blockcore-indexer/commit/2e9d14e))
+* Deleted explicit code for NFT token (all is in the generic service now) ([3e1a66d](https://github.com/block-core/blockcore-indexer/commit/3e1a66d))
+* First step of changing smart contract saving of tokens to another document ([9847887](https://github.com/block-core/blockcore-indexer/commit/9847887))
+* Fix for change in the NFT store smart contract ([b7f8b5e](https://github.com/block-core/blockcore-indexer/commit/b7f8b5e))
+* Fixed API endpoints ([1cd1669](https://github.com/block-core/blockcore-indexer/commit/1cd1669))
+* Fixed error message and added delay time ([b0dac91](https://github.com/block-core/blockcore-indexer/commit/b0dac91))
+* Fixed issue with lookup ([5ffb39e](https://github.com/block-core/blockcore-indexer/commit/5ffb39e))
+* Fixed issued with the auction events ([6a53f72](https://github.com/block-core/blockcore-indexer/commit/6a53f72))
+* Fixed login on generic service to support NFT as well. ([45aab22](https://github.com/block-core/blockcore-indexer/commit/45aab22))
+* Fixed standard contract to work with split tables ([0568234](https://github.com/block-core/blockcore-indexer/commit/0568234))
+* Fixed the Dao smart contract to work with split tables ([eedf6a8](https://github.com/block-core/blockcore-indexer/commit/eedf6a8))
+* Fixed the logic in the runner to update smart contracts periodically ([270d8dc](https://github.com/block-core/blockcore-indexer/commit/270d8dc))
+* Fixed the OnSale event updating ([f137dc5](https://github.com/block-core/blockcore-indexer/commit/f137dc5))
+* Fixed token filter by id endpoint ([7c922f0](https://github.com/block-core/blockcore-indexer/commit/7c922f0))
+* Minor changes after PR ([bab404d](https://github.com/block-core/blockcore-indexer/commit/bab404d))
+* Moved all smart contracts to one table ([40e843d](https://github.com/block-core/blockcore-indexer/commit/40e843d))
+* Renamed methods ([84a3df6](https://github.com/block-core/blockcore-indexer/commit/84a3df6))
+* Updated version ([f62dc87](https://github.com/block-core/blockcore-indexer/commit/f62dc87))
+
+
+
 ## <small>0.2.35 (2022-06-24)</small>
 
 * Added caching for stats endpoint (#150) ([719f891](https://github.com/block-core/blockcore-indexer/commit/719f891)), closes [#150](https://github.com/block-core/blockcore-indexer/issues/150)
diff --git a/package.json b/package.json
index 49c3b9c1..87dd4cd9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "blockcoreindexer",
-  "version": "0.2.35",
+  "version": "0.2.36",
   "license": "MIT",
   "author": {
     "name": "Blockcore",
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index e7e01eaa..14fe6814 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
    <PropertyGroup>
-      <Version>0.2.35</Version>
+      <Version>0.2.36</Version>
       <TargetFramework>net6.0</TargetFramework>
       <Authors>Blockcore</Authors>
       <PackageLicenseExpression>MIT</PackageLicenseExpression>

From aaa13583120e39ae1a49f62f023bd346a8b38cc7 Mon Sep 17 00:00:00 2001
From: TheDude <davidgershony@gmail.com>
Date: Tue, 5 Jul 2022 12:02:47 +0100
Subject: [PATCH 10/11] Added missing binding for block rewind (#154)

Co-authored-by: TheDude <david@vsodir.onmicrosoft.com>
---
 src/Blockcore.Indexer.Cirrus/CirrusStartup.cs | 2 ++
 src/Blockcore.Indexer.Core/Startup.cs         | 2 --
 src/Blockcore.Indexer/Startup.cs              | 1 +
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Blockcore.Indexer.Cirrus/CirrusStartup.cs b/src/Blockcore.Indexer.Cirrus/CirrusStartup.cs
index 7f5ccc2e..bf415299 100644
--- a/src/Blockcore.Indexer.Cirrus/CirrusStartup.cs
+++ b/src/Blockcore.Indexer.Cirrus/CirrusStartup.cs
@@ -87,6 +87,8 @@ public void ConfigureServices(IServiceCollection services)
          RegisterSmartContractBuilder(services); //No need to scan the assembly as there won't be that many
 
          services.AddScoped<TaskRunner,SmartContractSyncRunner>();
+
+         services.AddTransient<IBlockRewindOperation, CirrusBlockRewindOperation>();
       }
 
       private static IServiceCollection RegisterSmartContractBuilder(IServiceCollection collection)
diff --git a/src/Blockcore.Indexer.Core/Startup.cs b/src/Blockcore.Indexer.Core/Startup.cs
index ef4c427b..6f758ece 100644
--- a/src/Blockcore.Indexer.Core/Startup.cs
+++ b/src/Blockcore.Indexer.Core/Startup.cs
@@ -154,8 +154,6 @@ public static void AddIndexerServices(IServiceCollection services, IConfiguratio
          services.AddTransient<IMapMongoBlockToStorageBlock, MapMongoBlockToStorageBlock>();
          services.AddSingleton<ICryptoClientFactory, CryptoClientFactory>();
          services.AddSingleton<ISyncBlockTransactionOperationBuilder, SyncBlockTransactionOperationBuilder>();
-
-         services.AddTransient<IBlockRewindOperation, BlockRewindOperation>();
       }
 
       public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
diff --git a/src/Blockcore.Indexer/Startup.cs b/src/Blockcore.Indexer/Startup.cs
index d0f66947..ddc5bc24 100644
--- a/src/Blockcore.Indexer/Startup.cs
+++ b/src/Blockcore.Indexer/Startup.cs
@@ -150,6 +150,7 @@ public static void AddIndexerServices(IServiceCollection services, IConfiguratio
          services.AddTransient<IMapMongoBlockToStorageBlock, MapMongoBlockToStorageBlock>();
          services.AddSingleton<ICryptoClientFactory, CryptoClientFactory>();
          services.AddSingleton<ISyncBlockTransactionOperationBuilder, SyncBlockTransactionOperationBuilder>();
+         services.AddTransient<IBlockRewindOperation, BlockRewindOperation>();
       }
 
       public void Configure(IApplicationBuilder app, IWebHostEnvironment env)

From cc00145ccce5d215a296479fd0ee45b83b054f9c Mon Sep 17 00:00:00 2001
From: TheDude <david@vsodir.onmicrosoft.com>
Date: Tue, 5 Jul 2022 12:46:50 +0100
Subject: [PATCH 11/11] Updated version and changelog

---
 CHANGELOG.md              | 29 ++++++++---------------------
 package.json              |  2 +-
 src/Directory.Build.props |  2 +-
 3 files changed, 10 insertions(+), 23 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ca5f02ed..989f1864 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,26 +1,13 @@
+## <small>0.2.37 (2022-07-05)</small>
+
+* Added missing binding for block rewind (#154) ([aaa1358](https://github.com/block-core/blockcore-indexer/commit/aaa1358)), closes [#154](https://github.com/block-core/blockcore-indexer/issues/154)
+
+
+
 ## <small>0.2.36 (2022-07-04)</small>
 
-* Added endpoint that lists tokens for an owner address ([53c05c4](https://github.com/block-core/blockcore-indexer/commit/53c05c4))
-* Added rewind logic for smart contracts ([83f5b28](https://github.com/block-core/blockcore-indexer/commit/83f5b28))
-* Changed the assets endpoint to get data from the tokens table ([00e539f](https://github.com/block-core/blockcore-indexer/commit/00e539f))
-* Changed tokens to another table and fixing of debug issues - not complete ([8129f16](https://github.com/block-core/blockcore-indexer/commit/8129f16))
-* Deleted commented code ([2e9d14e](https://github.com/block-core/blockcore-indexer/commit/2e9d14e))
-* Deleted explicit code for NFT token (all is in the generic service now) ([3e1a66d](https://github.com/block-core/blockcore-indexer/commit/3e1a66d))
-* First step of changing smart contract saving of tokens to another document ([9847887](https://github.com/block-core/blockcore-indexer/commit/9847887))
-* Fix for change in the NFT store smart contract ([b7f8b5e](https://github.com/block-core/blockcore-indexer/commit/b7f8b5e))
-* Fixed API endpoints ([1cd1669](https://github.com/block-core/blockcore-indexer/commit/1cd1669))
-* Fixed error message and added delay time ([b0dac91](https://github.com/block-core/blockcore-indexer/commit/b0dac91))
-* Fixed issue with lookup ([5ffb39e](https://github.com/block-core/blockcore-indexer/commit/5ffb39e))
-* Fixed issued with the auction events ([6a53f72](https://github.com/block-core/blockcore-indexer/commit/6a53f72))
-* Fixed login on generic service to support NFT as well. ([45aab22](https://github.com/block-core/blockcore-indexer/commit/45aab22))
-* Fixed standard contract to work with split tables ([0568234](https://github.com/block-core/blockcore-indexer/commit/0568234))
-* Fixed the Dao smart contract to work with split tables ([eedf6a8](https://github.com/block-core/blockcore-indexer/commit/eedf6a8))
-* Fixed the logic in the runner to update smart contracts periodically ([270d8dc](https://github.com/block-core/blockcore-indexer/commit/270d8dc))
-* Fixed the OnSale event updating ([f137dc5](https://github.com/block-core/blockcore-indexer/commit/f137dc5))
-* Fixed token filter by id endpoint ([7c922f0](https://github.com/block-core/blockcore-indexer/commit/7c922f0))
-* Minor changes after PR ([bab404d](https://github.com/block-core/blockcore-indexer/commit/bab404d))
-* Moved all smart contracts to one table ([40e843d](https://github.com/block-core/blockcore-indexer/commit/40e843d))
-* Renamed methods ([84a3df6](https://github.com/block-core/blockcore-indexer/commit/84a3df6))
+* Changed smart contracts to be seperate token and contract (#153) ([312c206](https://github.com/block-core/blockcore-indexer/commit/312c206)), closes [#153](https://github.com/block-core/blockcore-indexer/issues/153)
+* Updated version ([0acf070](https://github.com/block-core/blockcore-indexer/commit/0acf070))
 * Updated version ([f62dc87](https://github.com/block-core/blockcore-indexer/commit/f62dc87))
 
 
diff --git a/package.json b/package.json
index 87dd4cd9..423880b4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "blockcoreindexer",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "license": "MIT",
   "author": {
     "name": "Blockcore",
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index 14fe6814..ba9e583e 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
    <PropertyGroup>
-      <Version>0.2.36</Version>
+      <Version>0.2.37</Version>
       <TargetFramework>net6.0</TargetFramework>
       <Authors>Blockcore</Authors>
       <PackageLicenseExpression>MIT</PackageLicenseExpression>