private async System.Threading.Tasks.Task <List <XStatus> > GetStatusFromNetworkAsync(string networkId)
        {
            Console.WriteLine($"Getting history data from nebula...");
            var lr   = new LogReader(networkId);
            var hist = (await lr.GetHistoryAsync())
                       .Where(x => x.TimeStamp > DateTime.UtcNow.AddDays(-1))
                       .ToList();

            // first get all accounts
            var allAccounts = hist.SelectMany(x => x.nodeStatus.Keys).Distinct().ToList();

            Console.WriteLine($"Got {hist.Count()} history entry for {networkId}. Unique account {allAccounts.Count()}");

            var count      = hist.Count;
            var statusList = new List <XStatus>();

            foreach (var acct in allAccounts)
            {
                var lastState = hist.Last(x => x.nodeStatus.ContainsKey(acct))
                                .nodeStatus[acct];

                if (lastState == null)
                {
                    continue;
                }

                var lastBB   = hist.Last().bb;
                var lastInBB = lastBB.ActiveNodes.FirstOrDefault(x => x.AccountID == acct);

                var xs = new XStatus
                {
                    NetworkId     = networkId,
                    AccountId     = acct,
                    OfflineCount  = count - hist.Count(x => x.nodeStatus.ContainsKey(acct)),
                    FullyUpgraded = CompareVersion(lastState.Status.version, LyraGlobal.NodeAppName),
                    IsPrimary     = lastBB.PrimaryAuthorizers.Contains(acct),
                    PosVotes      = lastInBB == null ? 0 : lastInBB.Votes,
                    SharedIp      = hist.Last(x => x.nodeStatus.ContainsKey(acct))
                                    .bb.NodeAddresses.Count(x => x.Value == hist.Last(x => x.nodeStatus.ContainsKey(acct))
                                                            .bb.NodeAddresses[acct]) > 1
                };

                // add db consist check
                xs.IsDbConsist = (lastState.Status.state == Lyra.Data.API.BlockChainState.Almighty ||
                                  lastState.Status.state == Lyra.Data.API.BlockChainState.Engaging);

                statusList.Add(xs);
            }

            return(statusList);
        }
        private async System.Threading.Tasks.Task PayNodeAsync(Wallet wallet, XStatus node, decimal package)
        {
            try
            {
                if (package != 0)
                {
                    var amount = package * node.GetRito();

                    if (amount < 1)
                    {
                        amount = 1;
                    }

                    node.PaidAmount = amount;
                }

                var result = await wallet.SendAsync(node.PaidAmount, node.AccountId);

                if (result.ResultCode != Lyra.Core.Blocks.APIResultCodes.Success)
                {
                    Console.WriteLine($"Failed to send: {result.ResultCode}");
                    await Task.Delay(10000);

                    await wallet.SyncAsync(null);

                    result = await wallet.SendAsync(node.PaidAmount, node.AccountId);

                    Console.WriteLine($"Retry result: {result.ResultCode}");
                }

                node.SuccessPaid = result.ResultCode == Lyra.Core.Blocks.APIResultCodes.Success;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error!!! {ex.Message}");
                node.SuccessPaid = false;
            }
        }