Add GetBalance to CoinView

src/Stratis.Bitcoin.Features.BlockStore/AddressIndexing/AddressIndexerCV.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NBitcoin;
+using Stratis.Bitcoin.Builder.Feature;
+using Stratis.Bitcoin.Consensus;
+using Stratis.Bitcoin.Controllers.Models;
+using Stratis.Bitcoin.Features.BlockStore.Models;
+using Stratis.Bitcoin.Features.Consensus.CoinViews;
+using Stratis.Bitcoin.Interfaces;
+
+namespace Stratis.Bitcoin.Features.BlockStore.AddressIndexing
+{
+    public class AddressIndexerCV : IAddressIndexer
+    {
+        private readonly Network network;
+        private readonly ICoinView coinView;
+        private readonly ChainIndexer chainIndexer;
+        private readonly IScriptAddressReader scriptAddressReader;
+
+        public ChainedHeader IndexerTip => GetTip();
+
+        public IFullNodeFeature InitializingFeature { set; private get; }
+
+        public AddressIndexerCV(Network network, ChainIndexer chainIndexer, IScriptAddressReader scriptAddressReader, ICoinView coinView)
+        {
+            this.network = network;
+            this.coinView = coinView;
+            this.chainIndexer = chainIndexer;
+            this.scriptAddressReader = scriptAddressReader;
+        }
+
+        private ChainedHeader GetTip()
+        {
+            this.coinView.Sync(this.chainIndexer);
+
+            return this.chainIndexer[this.coinView.GetTipHash().Hash];
+        }
+
+        public void Initialize()
+        {
+        }
+
+        private TxDestination AddressToDestination(string address)
+        {
+            var bitcoinAddress = BitcoinAddress.Create(address, this.network);
+            return this.scriptAddressReader.GetDestinationFromScriptPubKey(this.network, bitcoinAddress.ScriptPubKey).Single();
+        }
+
+        public AddressBalancesResult GetAddressBalances(string[] addresses, int minConfirmations = 0)
+        {
+            return new AddressBalancesResult()
+            {
+                Balances = addresses
+                    .Select(address => (address, destination: AddressToDestination(address)))
+                    .Select(t => new AddressBalanceResult()
+                {
+                    Address = t.address,
+                    Balance = (t.destination == null) ? 0 : new Money(this.coinView.GetBalance(t.destination).First().satoshis),
+
+                }).ToList()
+            };
+        }
+
+        public LastBalanceDecreaseTransactionModel GetLastBalanceDecreaseTransaction(string address)
+        {
+            throw new NotImplementedException();
+        }
+
+        private IEnumerable<AddressBalanceChange> ToDiff(List<AddressBalanceChange> addressBalanceChanges)
+        {
+            for (int i = addressBalanceChanges.Count - 1; i > 0; i--)
+            {
+                yield return new AddressBalanceChange() { 
+                    BalanceChangedHeight = addressBalanceChanges[i - 1].BalanceChangedHeight,
+                    Deposited = addressBalanceChanges[i - 1].Satoshi < addressBalanceChanges[i].Satoshi,
+                    Satoshi = Math.Abs(addressBalanceChanges[i - 1].Satoshi - addressBalanceChanges[i].Satoshi)
+                };
+            }
+        }
+
+        /// <inheritdoc/>
+        public VerboseAddressBalancesResult GetAddressIndexerState(string[] addresses)
+        {
+            // If the containing feature is not initialized then wait a bit.
+            this.InitializingFeature?.WaitInitialized();
+
+            return new VerboseAddressBalancesResult(this.IndexerTip.Height)
+            {
+                BalancesData = addresses
+                    .Select(address => (address, destination: AddressToDestination(address)))
+                    .Select(t => new AddressIndexerData()
+                {
+                    Address = t.address,                    
+                    BalanceChanges = (t.destination == null) ? new List<AddressBalanceChange>() : ToDiff(this.coinView.GetBalance(t.destination).Select(b => new AddressBalanceChange()
+                    {
+                         BalanceChangedHeight = (int)b.height,
+                         Deposited = b.satoshis >= 0,
+                         Satoshi = Math.Abs(b.satoshis)
+                    }).ToList()).ToList()
+                }).ToList()
+            };
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+}

src/Stratis.Bitcoin.Features.BlockStore/BlockStoreFeature.cs

@@ -199,7 +199,7 @@ public static IFullNodeBuilder UseBlockStore(this IFullNodeBuilder fullNodeBuild
 
                         services.AddSingleton<StoreSettings>();
                         services.AddSingleton<IBlockStoreQueueFlushCondition, BlockStoreQueueFlushCondition>();
-                        services.AddSingleton<IAddressIndexer, AddressIndexer>();
+                        services.AddSingleton<IAddressIndexer, AddressIndexerCV>();
                         services.AddSingleton<IUtxoIndexer, UtxoIndexer>();
                     });
             });

src/Stratis.Bitcoin.Features.Consensus.Tests/CoinViews/CoinviewTests.cs

@@ -43,7 +43,7 @@ public CoinviewTests()
             this.nodeStats = new NodeStats(this.dateTimeProvider, NodeSettings.Default(this.network), new Mock<IVersionProvider>().Object);
 
             this.coindb = new DBreezeCoindb(this.network, this.dataFolder, this.dateTimeProvider, this.loggerFactory, this.nodeStats, new DBreezeSerializer(this.network.Consensus.ConsensusFactory));
-            this.coindb.Initialize(new ChainedHeader(this.network.GetGenesis().Header, this.network.GenesisHash, 0));
+            this.coindb.Initialize(false);
 
             this.chainIndexer = new ChainIndexer(this.network);
             this.stakeChainStore = new StakeChainStore(this.network, this.chainIndexer, (IStakedb)this.coindb, this.loggerFactory);

src/Stratis.Bitcoin.Features.Consensus/CoinViews/CachedCoinView.cs

@@ -5,8 +5,10 @@
 using System.Threading;
 using Microsoft.Extensions.Logging;
 using NBitcoin;
+using Stratis.Bitcoin.Configuration;
 using Stratis.Bitcoin.Configuration.Settings;
 using Stratis.Bitcoin.Consensus;
+using Stratis.Bitcoin.Consensus.Rules;
 using Stratis.Bitcoin.Features.Consensus.ProvenBlockHeaders;
 using Stratis.Bitcoin.Features.Consensus.Rules.CommonRules;
 using Stratis.Bitcoin.Interfaces;
@@ -114,6 +116,10 @@ public long GetScriptSize
         /// <remarks>All access to this object has to be protected by <see cref="lockobj"/>.</remarks>
         private readonly Dictionary<OutPoint, CacheItem> cachedUtxoItems;
 
+        /// <summary>Tracks pending balance updates for dirty cache entries.</summary>
+        /// <remarks>All access to this object has to be protected by <see cref="lockobj"/>.</remarks>
+        private readonly Dictionary<TxDestination, Dictionary<uint, long>> cacheBalancesByDestination;
+
         /// <summary>Number of items in the cache.</summary>
         /// <remarks>The getter violates the lock contract on <see cref="cachedUtxoItems"/>, but the lock here is unnecessary as the <see cref="cachedUtxoItems"/> is marked as readonly.</remarks>
         private int cacheCount => this.cachedUtxoItems.Count;
@@ -127,35 +133,38 @@ public long GetScriptSize
         private long rewindDataSizeBytes;
         private DateTime lastCacheFlushTime;
         private readonly Network network;
-        private readonly ICheckpoints checkpoints;
         private readonly IDateTimeProvider dateTimeProvider;
         private readonly IBlockStore blockStore;
         private readonly CancellationTokenSource cancellationToken;
         private readonly ConsensusSettings consensusSettings;
+        private readonly bool addressIndexingEnabled;
         private CachePerformanceSnapshot latestPerformanceSnapShot;
+        private IScriptAddressReader scriptAddressReader;
 
         private readonly Random random;
 
-        public CachedCoinView(Network network, ICheckpoints checkpoints, ICoindb coindb, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory, INodeStats nodeStats, ConsensusSettings consensusSettings, 
-            StakeChainStore stakeChainStore = null, IRewindDataIndexCache rewindDataIndexCache = null, IBlockStore blockStore = null, INodeLifetime nodeLifetime = null)
+        public CachedCoinView(Network network, ICheckpoints checkpoints, ICoindb coindb, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory, INodeStats nodeStats, ConsensusSettings consensusSettings,
+            StakeChainStore stakeChainStore = null, IRewindDataIndexCache rewindDataIndexCache = null, IScriptAddressReader scriptAddressReader = null, IBlockStore blockStore = null, INodeLifetime nodeLifetime = null, NodeSettings nodeSettings = null)
         {
             Guard.NotNull(coindb, nameof(CachedCoinView.coindb));
 
             this.coindb = coindb;
             this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
             this.network = network;
-            this.checkpoints = checkpoints;
             this.dateTimeProvider = dateTimeProvider;
             this.consensusSettings = consensusSettings;
             this.stakeChainStore = stakeChainStore;
             this.rewindDataIndexCache = rewindDataIndexCache;
             this.blockStore = blockStore;
-            this.cancellationToken = (nodeLifetime == null) ? new CancellationTokenSource() : CancellationTokenSource.CreateLinkedTokenSource(nodeLifetime.ApplicationStopping);
+            this.cancellationToken = (nodeLifetime == null) ? new CancellationTokenSource(): CancellationTokenSource.CreateLinkedTokenSource(nodeLifetime.ApplicationStopping);
             this.lockobj = new object();
             this.cachedUtxoItems = new Dictionary<OutPoint, CacheItem>();
+            this.cacheBalancesByDestination = new Dictionary<TxDestination, Dictionary<uint, long>>();
             this.performanceCounter = new CachePerformanceCounter(this.dateTimeProvider);
             this.lastCacheFlushTime = this.dateTimeProvider.GetUtcNow();
             this.cachedRewindData = new Dictionary<int, RewindData>();
+            this.scriptAddressReader = scriptAddressReader;
+            this.addressIndexingEnabled = nodeSettings?.ConfigReader.GetOrDefault("addressindex", false) ?? false;
             this.random = new Random();
 
             this.MaxCacheSizeBytes = consensusSettings.MaxCoindbCacheInMB * 1024 * 1024;
@@ -200,7 +209,7 @@ public void Sync(ChainIndexer chainIndexer)
 
         public void Initialize(ChainedHeader chainTip, ChainIndexer chainIndexer, IConsensusRuleEngine consensusRuleEngine)
         {
-            this.coindb.Initialize(chainTip);
+            this.coindb.Initialize(this.addressIndexingEnabled);
 
             Sync(chainIndexer);
 
@@ -469,10 +478,11 @@ public void Flush(bool force = true)
 
                 this.logger.LogDebug("Flushing {0} items.", modify.Count);
 
-                this.coindb.SaveChanges(modify, this.innerBlockHash, this.blockHash, this.cachedRewindData.Select(c => c.Value).ToList());
+                this.coindb.SaveChanges(modify, this.cacheBalancesByDestination, this.innerBlockHash, this.blockHash, this.cachedRewindData.Select(c => c.Value).ToList());
 
                 // All the cached utxos are now on disk so we can clear the cached entry list.
                 this.cachedUtxoItems.Clear();
+                this.cacheBalancesByDestination.Clear();
                 this.cacheSizeBytes = 0;
 
                 this.cachedRewindData.Clear();
@@ -564,6 +574,10 @@ public void SaveChanges(IList<UnspentOutput> outputs, HashHeightPair oldBlockHas
                     {
                         // DELETE COINS
 
+                        // Record the UTXO as having been spent at this height.
+                        if (cacheItem.Coins != null)
+                            this.RecordBalanceChange(cacheItem.Coins.TxOut.ScriptPubKey, -cacheItem.Coins.TxOut.Value, (uint)nextBlockHash.Height);
+
                         // In cases of an output spent in the same block 
                         // it wont exist in cash or in disk so its safe to remove it
                         if (cacheItem.Coins == null)
@@ -612,6 +626,9 @@ public void SaveChanges(IList<UnspentOutput> outputs, HashHeightPair oldBlockHas
                     {
                         // ADD COINS
 
+                        // Update the balance.
+                        this.RecordBalanceChange(output.Coins.TxOut.ScriptPubKey, output.Coins.TxOut.Value, output.Coins.Height);
+
                         if (cacheItem.Coins != null)
                         {
                             // Allow overrides.
@@ -693,6 +710,7 @@ public HashHeightPair Rewind(HashHeightPair target = null)
 
                 // All the cached utxos are now on disk so we can clear the cached entry list.
                 this.cachedUtxoItems.Clear();
+                this.cacheBalancesByDestination.Clear();
                 this.cacheSizeBytes = 0;
                 this.dirtyCacheCount = 0;
 
@@ -749,5 +767,62 @@ private void AddBenchStats(StringBuilder log)
 
             this.latestPerformanceSnapShot = snapShot;
         }
+
+        private void RecordBalanceChange(Script scriptPubKey, long satoshis, uint height)
+        {
+            if (!this.coindb.BalanceIndexingEnabled || scriptPubKey.Length == 0 || satoshis == 0)
+                return;
+
+            foreach (TxDestination txDestination in this.scriptAddressReader.GetDestinationFromScriptPubKey(this.network, scriptPubKey))
+            {
+                if (!this.cacheBalancesByDestination.TryGetValue(txDestination, out Dictionary<uint, long> value))
+                {
+                    value = new Dictionary<uint, long>();
+                    this.cacheBalancesByDestination[txDestination] = value;
+                }
+
+                if (!value.TryGetValue(height, out long balance))
+                    balance = 0;
+
+                balance += satoshis;
+
+                value[height] = balance;
+            }
+        }
+
+        public IEnumerable<(uint, long)> GetBalance(TxDestination txDestination)
+        {
+            IEnumerable<(uint, long)> CachedBalances()
+            {
+                if (this.cacheBalancesByDestination.TryGetValue(txDestination, out Dictionary<uint, long> itemsByHeight))
+                {
+                    long balance = 0;
+
+                    foreach (uint height in itemsByHeight.Keys.OrderBy(k => k))
+                    {
+                        balance += itemsByHeight[height];
+                        yield return (height, balance);
+                    }
+                }
+            }
+
+            bool first = true;
+            foreach ((uint height, long satoshis) in this.coindb.GetBalance(txDestination))
+            {
+                if (first)
+                {
+                    first = false;
+
+                    foreach ((uint height2, long satoshis2) in CachedBalances().Reverse())
+                        yield return (height2, satoshis2 + satoshis);
+                }
+
+                yield return (height, satoshis);
+            }
+
+            if (first)
+                foreach ((uint height2, long satoshis2) in CachedBalances().Reverse())
+                    yield return (height2, satoshis2);
+        }
     }
 }

src/Stratis.Bitcoin.Features.Consensus/CoinViews/CoinView.cs

@@ -84,5 +84,15 @@ public interface ICoinView
         /// </summary>
         /// <param name="height">The height of the block.</param>
         RewindData GetRewindData(int height);
+
+        /// <summary>
+        /// Returns a combination of (height, satoshis) values with the cumulative balance up to the corresponding height.
+        /// </summary>
+        /// <param name="txDestination">The destination value derived from the address being queried.</param>
+        /// <returns>A combination of (height, satoshis) values with the cumulative balance up to the corresponding height.</returns>
+        /// <remarks>Balance updates (even when nett 0) are delivered for every height at which transactions for the address 
+        /// had been recorded and as such the returned heights can be used in conjunction with the block store to discover 
+        /// all related transactions.</remarks>
+        IEnumerable<(uint height, long satoshis)> GetBalance(TxDestination txDestination);
     }
 }