예제 #1
0
        private static IEnumerable <Output> GetTransactionOutputs(IRpcTransaction rpcTransaction)
        {
            foreach (var output in rpcTransaction.Outputs)
            {
                var addresses = new string[0];

                if (!string.IsNullOrEmpty(output.ScriptPublicKey.Hex))
                {
                    addresses = GetAddress(DecodeScriptHex(output.ScriptPublicKey.Hex));
                }

                yield return(new Output
                {
                    Value = output.Value,
                    Index = output.Index,
                    OutputScriptPublicKey = new OutputScriptPublicKey
                    {
                        Asm = output.ScriptPublicKey.Asm,
                        Hex = output.ScriptPublicKey.Hex,
                        RequestedSignatures = output.ScriptPublicKey.RequestedSignatures,
                        Type = output.ScriptPublicKey.Type,
                        OutputScriptPublicKeyAddresses = addresses.Select(address => new OutputScriptPublicKeyAddress
                        {
                            Address = address
                        })
                    }
                });
            }
        }
예제 #2
0
        public static async Task Main(string[] args)
        {
            ShowAscii();
            ConfigureServiceProvider();
            SetNetwork();

            var configuration = _serviceProvider.GetService <IConfiguration>();
            var mutexName     = configuration.GetValue <string>("MutexName");

            using (var mutex = new Mutex(false, mutexName))
            {
                if (!mutex.WaitOne(0, false))
                {
                    Console.WriteLine("Application already running");
                    return;
                }
                if (args?.FirstOrDefault() == "clear")
                {
                    Console.WriteLine("Are you sure you want to clear all data? [Yes/No]");
                    var answer = Console.ReadLine();
                    if (answer?.ToLower() == "yes")
                    {
                        Console.WriteLine("Clearing all data...");
                        var clearAllDataRepository = _serviceProvider.GetService <IClearAllDataRepository>();
                        await clearAllDataRepository.ClearAllData();

                        Console.WriteLine("All data cleared");
                        return;
                    }
                    else
                    {
                        Console.WriteLine("Aborted");
                        return;
                    }
                }

                while (true)
                {
                    var c = 0L;
                    c++;

                    await Task.Delay(500);

                    try
                    {
                        if (c % 12000 == 1)
                        {
                            Console.WriteLine("Still running");
                        }

                        var rpcBlockCountService  = _serviceProvider.GetService <IRpcBlockCountService>();
                        var rpcBlockService       = _serviceProvider.GetService <IRpcBlockService>();
                        var rpcTransactionService = _serviceProvider.GetService <IRpcTransactionService>();
                        var rpcBlockCount         = await rpcBlockCountService.GetBlockCount();

                        var blockCountRepository = _serviceProvider.GetService <IBlockRepository>();

                        var blockCount = await blockCountRepository.GetBlockHeight();

                        if (blockCount > 0)
                        {
                            blockCount++;
                        }

                        if (rpcBlockCount == blockCount - 1 && rpcBlockCount > 0)
                        {
                            continue;
                        }

                        for (var i = blockCount; i <= rpcBlockCount; i++)
                        {
                            using (var scope = _serviceProvider.CreateScope())
                            {
                                var blockRepository       = scope.ServiceProvider.GetService <IBlockRepository>();
                                var transactionRepository = scope.ServiceProvider
                                                            .GetService <ITransactionRepository>();

                                var rpcBlock = await rpcBlockService.GetBlock(i);

                                var block = new Block
                                {
                                    Id            = rpcBlock.Hash,
                                    Bits          = rpcBlock.Bits,
                                    Chainwork     = rpcBlock.Chainwork,
                                    Difficulty    = rpcBlock.Difficulty,
                                    Height        = rpcBlock.Height,
                                    MedianTime    = rpcBlock.MedianTime,
                                    Time          = rpcBlock.Time,
                                    Merkleroot    = rpcBlock.Merkleroot,
                                    Nonce         = rpcBlock.Nonce,
                                    Size          = rpcBlock.Size,
                                    Version       = rpcBlock.Version,
                                    Weight        = rpcBlock.Weight,
                                    PreviousBlock = rpcBlock.PreviousBlock == GenesisBlock ? null : rpcBlock.PreviousBlock,
                                    Json          = rpcBlock.Json
                                };

                                await blockRepository.Insert(block);

                                var blockOrder = 0L;
                                foreach (var rpcBlockTransaction in rpcBlock.Transactions)
                                {
                                    IRpcTransaction rpcTransaction = null;

                                    try
                                    {
                                        rpcTransaction = await rpcTransactionService.GetTransaction(rpcBlockTransaction);
                                    }
                                    catch (Exception)
                                    {
                                        if (block.Height > 0)
                                        {
                                            throw;
                                        }
                                    }

                                    if (rpcTransaction == null)
                                    {
                                        continue;
                                    }

                                    var transaction = new Transaction
                                    {
                                        BlockTime  = rpcTransaction.BlockTime,
                                        Hash       = rpcTransaction.TxId,
                                        Id         = rpcTransaction.TxId,
                                        Locktime   = rpcTransaction.Locktime,
                                        Size       = rpcTransaction.Size,
                                        Time       = rpcTransaction.Time,
                                        Version    = rpcTransaction.Version,
                                        Vsize      = rpcTransaction.Vsize,
                                        BlockId    = rpcTransaction.BlockHash,
                                        BlockOrder = blockOrder,
                                        Json       = rpcTransaction.Json
                                    };

                                    var inputs = rpcTransaction.Inputs.Select(p => new Input
                                    {
                                        Coinbase             = p.Coinbase,
                                        OutputIndex          = p.Vout,
                                        Sequence             = p.Sequence,
                                        TransactionId        = rpcTransaction.TxId,
                                        OutputTransactionId  = p.TxId,
                                        InputScriptSignature = p.ScriptSignature == null
                                            ? null
                                            : new InputScriptSignature
                                        {
                                            Asm = p.ScriptSignature.Asm,
                                            Hex = p.ScriptSignature.Hex
                                        }
                                    });

                                    var outputs = GetTransactionOutputs(rpcTransaction);

                                    await transactionRepository.Insert(transaction, inputs, outputs);

                                    blockOrder++;
                                }

                                await FrontEndNotification(block.Height);

                                if (block.Height % 100 == 0 || i == blockCount || i == rpcBlockCount)
                                {
                                    Console.WriteLine($"{block.Height} - {block.Id}");
                                }
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Error => {0}", e.Message);
                        await Task.Delay(10000);
                    }
                }
            }
        }