public decimal GetAccountBalance(string address)
        {
            var publicKeyHash = _addressEncoder.ExtractPublicKeyHash(address);

            var totalOut = Instructions
                           .Find(Query.EQ("Statistics.PublicKeyHash", publicKeyHash))
                           .Select(x => x.Entity)
                           .OfType <ValueInstruction>()
                           .Sum(x => x.Amount);


            var totalIn = Instructions
                          .Find(Query.EQ("Entity.Destination", publicKeyHash))
                          .Select(x => x.Entity)
                          .OfType <TransferInstruction>()
                          .Sum(x => x.Amount);

            return(totalIn - totalOut);
        }
        public decimal GetAccountBalance(string address)
        {
            var publicKeyHash = _addressEncoder.ExtractPublicKeyHash(address);

            var totalOut = 0;
            var totalIn  = 0;

            var outQry = MainChain.Aggregate()
                         .Unwind(x => x.Transactions)
                         .Unwind <PersistedInstruction>(new StringFieldDefinition <BsonDocument>("Transactions.Instructions"))
                         .Match(new BsonDocument("Transactions.Instructions.Statistics.PublicKeyHash", publicKeyHash))
                         .Group(new BsonDocument {
                { "_id", BsonNull.Value }, { "sum", new BsonDocument("$sum", "$Transactions.Instructions.Entity.Amount") }
            })
                         .SingleOrDefault();

            if (outQry != null)
            {
                if (outQry.TryGetValue("sum", out var bOut))
                {
                    totalOut = bOut.AsInt32;
                }
            }

            var inQry = MainChain.Aggregate()
                        .Unwind(x => x.Transactions)
                        .Unwind <PersistedInstruction>(new StringFieldDefinition <BsonDocument>("Transactions.Instructions"))
                        .Match(new BsonDocument("Transactions.Instructions.Entity.Destination", publicKeyHash))
                        .Group(new BsonDocument {
                { "_id", BsonNull.Value }, { "sum", new BsonDocument("$sum", "$Transactions.Instructions.Entity.Amount") }
            })
                        .SingleOrDefault();

            if (inQry != null)
            {
                if (inQry.TryGetValue("sum", out var bIn))
                {
                    totalIn = bIn.AsInt32;
                }
            }

            return(totalIn - totalOut);
        }
Esempio n. 3
0
        static void RunCommand(string command, KeyPair keys)
        {
            var args       = command.Split(' ');
            var ownAddress = _addressEncoder.EncodeAddress(keys.PublicKey, 0);

            switch (args[0])
            {
            case "help":
                PrintHelp();
                break;

            case "mine-genesis":
                Console.WriteLine("Mining...");
                _miner.Start(keys, true);
                break;

            case "mine":
                Console.WriteLine("Mining...");
                _miner.Start(keys, false);
                break;

            case "stop-mining":
                Console.WriteLine("Stopping...");
                _miner.Stop();
                break;

            case "peers":
                var peersIn  = _network.GetPeersIn();
                var peersOut = _network.GetPeersOut();
                Console.WriteLine("Incoming peers");
                PrintPeerList(peersIn);
                Console.WriteLine("Outgoing peers");
                PrintPeerList(peersOut);
                break;

            case "balance":
                if (args.Length == 1)
                {
                    Console.WriteLine($"Balance = {_txnRepo.GetAccountBalance(ownAddress)}");
                }
                else
                {
                    Console.WriteLine($"Balance = {_txnRepo.GetAccountBalance(args[1])}");
                }
                break;

            case "best-block":
                var header = _blockRepo.GetBestBlockHeader().Result;
                Console.WriteLine($"Height: {header.Height}, Id: {BitConverter.ToString(header.BlockId)}");
                break;

            case "gen-key":
                var genkeys = _sigService.GetKeyPairFromPhrase(args[1]);
                var address = _addressEncoder.EncodeAddress(genkeys.PublicKey, 0);
                Console.WriteLine($"{address}");
                break;

            case "avg-time":
                var avgTime = _blockRepo.GetAverageBlockTimeInSecs(DateTime.UtcNow.AddHours(-1), DateTime.UtcNow).Result;
                Console.WriteLine($"Avg time: {avgTime}s");
                break;

            case "send":
                if (args.Length != 3)
                {
                    Console.WriteLine("invalid command");
                    return;
                }

                var instruction = new TransferInstruction()
                {
                    PublicKey   = keys.PublicKey,
                    Amount      = Convert.ToInt32(args[2]),
                    Destination = _addressEncoder.ExtractPublicKeyHash(args[1])
                };

                Console.WriteLine($"Signing instruction");
                _sigService.SignInstruction(instruction, keys.PrivateKey);
                var txn = _txnBuilder.Build(new List <Instruction>()
                {
                    instruction
                }).Result;

                Console.WriteLine($"Sending transaction {BitConverter.ToString(txn.TransactionId)}");
                _host.SendTransaction(txn);
                break;

            default:
                Console.WriteLine("invalid command");
                break;
            }
        }