public static IEnumerable <OrderedBalanceChange> ExtractWalletBalances(
uint256 txId,
Transaction tx,
uint256 blockId,
BlockHeader blockHeader,
int height,
WalletRuleEntryCollection walletCollection)
{
Dictionary <string, OrderedBalanceChange> entitiesByWallet = new Dictionary <string, OrderedBalanceChange>();
var scriptBalances = ExtractScriptBalances(txId, tx, blockId, blockHeader, height);
foreach (var scriptBalance in scriptBalances)
{
foreach (var walletRuleEntry in walletCollection.GetRulesFor(scriptBalance.ScriptPubKey))
{
OrderedBalanceChange walletEntity = null;
if (!entitiesByWallet.TryGetValue(walletRuleEntry.WalletId, out walletEntity))
{
walletEntity = new OrderedBalanceChange(walletRuleEntry.WalletId, scriptBalance);
entitiesByWallet.Add(walletRuleEntry.WalletId, walletEntity);
}
walletEntity.Merge(scriptBalance, walletRuleEntry.Rule);
}
}
foreach (var b in entitiesByWallet.Values)
{
b.UpdateToScriptCoins();
}
return(entitiesByWallet.Values);
}
public void IndexWalletOrderedBalance(int height, Block block, WalletRuleEntryCollection walletRules)
{
try
{
IndexWalletOrderedBalanceAsync(height, block, walletRules).Wait();
}
catch (AggregateException ex)
{
ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
}
}
public Task IndexWalletOrderedBalanceAsync(int height, Block block, WalletRuleEntryCollection walletRules)
{
var table = Configuration.GetBalanceTable();
var blockId = block == null ? null : block.GetHash();
var entities =
block
.Transactions
.SelectMany(t => OrderedBalanceChange.ExtractWalletBalances(null, t, blockId, block.Header, height, walletRules))
.Select(t => t.ToEntity(ConsensusFactory))
.AsEnumerable();
return(IndexAsync(entities, table));
}
public void IndexWalletOrderedBalance(int height, Block block, WalletRuleEntryCollection walletRules)
{
var table = Configuration.GetBalanceTable();
var blockId = block.GetHash();
foreach (var transaction in block.Transactions)
{
var txId = transaction.GetHash();
var changes = OrderedBalanceChange.ExtractWalletBalances(txId, transaction, blockId, block.Header, height, walletRules).Select(c => c.ToEntity());
foreach (var group in changes.GroupBy(c => c.PartitionKey))
{
Index(group, table);
}
}
}
public void Listen(ConcurrentChain chain = null)
{
ListenerTrace.Info($"Connecting to node {_Configuration.Indexer.Node}");
var ip = Utils.ParseIpEndpoint(_Configuration.Indexer.Node, Configuration.Indexer.Network.DefaultPort);
ListenerTrace.Info($"Connecting to node ip {ip.ToString()}");
var node = Node.Connect(Configuration.Indexer.Network, ip);
ListenerTrace.Info($"Connected, trying handshake...");
node.VersionHandshake();
ListenerTrace.Info($"Hanshaked");
node.Disconnect();
_Chain = new ConcurrentChain(_Configuration.Indexer.Network);
_Indexer = Configuration.Indexer.CreateIndexer();
if (chain == null)
{
chain = new ConcurrentChain(_Configuration.Indexer.Network);
}
_Chain = chain;
ListenerTrace.Info("Fetching headers from " + _Chain.Tip.Height + " (from azure)");
var client = Configuration.Indexer.CreateIndexerClient();
client.SynchronizeChain(chain);
ListenerTrace.Info("Headers fetched tip " + _Chain.Tip.Height);
_Disposables.Add(_IndexerScheduler = new CustomThreadPoolTaskScheduler(50, 100, "Indexing Threads"));
_Indexer.TaskScheduler = _IndexerScheduler;
_Group = new NodesGroup(Configuration.Indexer.Network);
_Disposables.Add(_Group);
_Group.AllowSameGroup = true;
_Group.MaximumNodeConnection = 2;
AddressManager addrman = new AddressManager();
addrman.Add(new NetworkAddress(ip), IPAddress.Parse("127.0.0.1"));
_Group.NodeConnectionParameters.TemplateBehaviors.Add(new AddressManagerBehavior(addrman)
{
Mode = AddressManagerBehaviorMode.None
});
_Group.NodeConnectionParameters.TemplateBehaviors.Add(new ChainBehavior(_Chain)
{
SkipPoWCheck = true
});
_Group.NodeConnectionParameters.TemplateBehaviors.Add(new Behavior(this));
ListenerTrace.Info("Fetching wallet rules...");
_Wallets = _Configuration.Indexer.CreateIndexerClient().GetAllWalletRules();
ListenerTrace.Info("Wallet rules fetched");
ListenerTrace.Info("Fetching wallet subscriptions...");
_Subscriptions = new SubscriptionCollection(_Configuration.GetSubscriptionsTable().Read());
ListenerTrace.Info("Subscriptions fetched");
_Group.Connect();
ListenerTrace.Info("Fetching transactions to broadcast...");
_Disposables.Add(
Configuration
.Topics
.BroadcastedTransactions
.CreateConsumer("listener", true)
.EnsureSubscriptionExists()
.OnMessage((tx, ctl) =>
{
uint256 hash = null;
var repo = Configuration.Indexer.CreateIndexerClient();
var rejects = Configuration.GetRejectTable();
try
{
hash = tx.Transaction.GetHash();
var indexedTx = repo.GetTransaction(hash);
ListenerTrace.Info("Broadcasting " + hash);
var reject = rejects.ReadOne(hash.ToString());
if (reject != null)
{
ListenerTrace.Info("Abort broadcasting of rejected");
return;
}
if (_Broadcasting.Count > 1000)
{
_Broadcasting.Clear();
}
_Broadcasting.TryAdd(hash, tx.Transaction);
if (indexedTx == null || !indexedTx.BlockIds.Any(id => Chain.Contains(id)))
{
var unused = SendMessageAsync(tx.Transaction);
}
var reschedule = new[]
{
TimeSpan.FromMinutes(5),
TimeSpan.FromMinutes(10),
TimeSpan.FromHours(1),
TimeSpan.FromHours(6),
TimeSpan.FromHours(24),
};
if (tx.Tried <= reschedule.Length - 1)
{
ctl.RescheduleIn(reschedule[tx.Tried]);
tx.Tried++;
}
}
catch (Exception ex)
{
if (!_Disposed)
{
LastException = ex;
ListenerTrace.Error("Error for new broadcasted transaction " + hash, ex);
throw;
}
}
}));
ListenerTrace.Info("Transactions to broadcast fetched");
_Disposables.Add(_Configuration
.Topics
.SubscriptionChanges
.EnsureSubscriptionExists()
.AddUnhandledExceptionHandler(ExceptionOnMessagePump)
.OnMessage(c =>
{
using (_SubscriptionSlimLock.LockWrite())
{
if (c.Added)
{
_Subscriptions.Add(c.Subscription);
}
else
{
_Subscriptions.Remove(c.Subscription.Id);
}
}
}));
_Disposables.Add(_Configuration
.Topics
.SendNotifications
.AddUnhandledExceptionHandler(ExceptionOnMessagePump)
.OnMessageAsync((n, act) =>
{
return(SendAsync(n, act).ContinueWith(t =>
{
if (!_Disposed)
{
if (t.Exception != null)
{
LastException = t.Exception;
}
}
}));
}, new OnMessageOptions()
{
MaxConcurrentCalls = 1000,
AutoComplete = true,
AutoRenewTimeout = TimeSpan.Zero
}));
_Disposables.Add(Configuration
.Topics
.AddedAddresses
.CreateConsumer("updater", true)
.EnsureSubscriptionExists()
.AddUnhandledExceptionHandler(ExceptionOnMessagePump)
.OnMessage(evt =>
{
if (evt == null)
{
return;
}
ListenerTrace.Info("New wallet rule");
using (_WalletsSlimLock.LockWrite())
{
foreach (var address in evt)
{
_Wallets.Add(address.CreateWalletRuleEntry());
}
}
}));
}