public async Task <Block> GetBlock(string id)
        {
            Block block;

            try
            {
                block = await BlockRepository.GetById(id);

                if (block == null)
                {
                    block = await BlockchainDataProvider.GetBlock(id);

                    if (block != null)
                    {
                        await BlockRepository.Save(block);
                    }
                }
            }
            catch (Exception ex)
            {
                _log.LogError(ex.Message);
                return(null);
            }

            return(block);
        }
        public async Task <Block> GetBlock(string id)
        {
            Block block;

            try
            {
                block = await BlockRepository.GetById(id);

                if (block == null)
                {
                    block = await BlockchainDataProvider.GetBlock(id);

                    if (block != null)
                    {
                        await BlockRepository.Save(block);
                    }
                }
            }
            catch (Exception ex)
            {
                await Log.WriteError(this.GetType().ToString(), "GetBlock", $"block_id:{id}", ex, DateTime.Now);

                return(null);
            }

            return(block);
        }
        public async Task <Block> GetLastBlock()
        {
            Block block;

            try
            {
                block = await BlockchainDataProvider.GetLastBlock();
            }
            catch (Exception ex)
            {
                _log.LogError(ex.Message);
                return(null);
            }

            return(block);
        }
        public async Task <Block> GetLastBlock()
        {
            Block block;

            try
            {
                block = await BlockchainDataProvider.GetLastBlock();
            }
            catch (Exception ex)
            {
                await Log.WriteError(this.GetType().ToString(), "GetLastBlock", $"last_block", ex, DateTime.Now);

                return(null);
            }

            return(block);
        }
Exemple #5
0
        public async Task <Transaction> GetTransaction(string id)
        {
            Transaction transaction;

            try
            {
                transaction = await TransactionRepository.GetById(id);

                if (transaction == null)
                {
                    transaction = await BlockchainDataProvider.GetTransaction(id);

                    if (transaction == null)
                    {
                        return(null);
                    }

                    transaction.Block = await BlockService.GetBlock(transaction.Blockhash);

                    await TransactionRepository.Save(transaction);

                    foreach (var @in in transaction.TransactionIn)
                    {
                        if (@in.PrevTxIdPointer == null)
                        {
                            continue;
                        }
                        var inputTransaction = await BlockchainDataProvider.GetTransaction(@in.PrevTxIdPointer);

                        @in.PrevVOutFetchedValue = inputTransaction.TransactionsOut[@in.PrevVOutPointer].Value;
                    }
                }
            }
            catch (Exception ex)
            {
                _log.LogError(ex.Message);
                return(null);
            }

            return(transaction);
        }
Exemple #6
0
        public async Task <Transaction> GetTransaction(string id)
        {
            Transaction transaction;

            try
            {
                transaction = await TransactionRepository.GetById(id);

                if (transaction == null)
                {
                    transaction = await BlockchainDataProvider.GetTransaction(id);

                    if (transaction != null)
                    {
                        await BlockService.GetBlock(transaction.Blockhash);

                        foreach (var asset in transaction.Assets)
                        {
                            var assetExists = await AssetRepository.Exists(asset.Id);

                            if (!assetExists && !String.IsNullOrWhiteSpace(asset.MetadataUrl))
                            {
                                var assetData = await BlockchainDataProvider.GetMetadataContent(new Uri(asset.MetadataUrl));

                                await AssetRepository.Save(assetData);
                            }
                        }

                        await TransactionRepository.Save(transaction);
                    }
                }
            }
            catch (Exception ex)
            {
                await Log.WriteError(this.GetType().ToString(), "GetTransaction", $"transaction_id:{id}", ex, DateTime.Now);

                return(null);
            }

            return(transaction);
        }
Exemple #7
0
        public async Task <Address> GetAddress(string id)
        {
            Address address;

            try
            {
                address = await BlockchainDataProvider.GetAddress(id);

                if (address != null)
                {
                    await AddressRepository.UpdateAddress(address);
                }
            }
            catch (Exception ex)
            {
                _log.LogError(ex.Message);
                return(null);
            }

            return(address);
        }
        public async Task <AssetOwners> GetAssetOwners(string id)
        {
            AssetOwners assetOwner;

            try
            {
                var lastBlock = await BlockchainDataProvider.GetLastBlock();

                assetOwner = await AssetRepository.GetAssetOwners(id);

                assetOwner.BlockHeight = lastBlock.Height;
            }
            catch (Exception ex)
            {
                await Log.WriteError(this.GetType().ToString(), "GetAssetOwners", $"asset_id{id}", ex, DateTime.Now);

                return(null);
            }

            return(assetOwner);
        }
        public async Task <Address> GetAddress(string id)
        {
            Address address;

            try
            {
                address = await BlockchainDataProvider.GetAddress(id);

                if (address != null)
                {
                    await AddressRepository.UpdateAddress(address);
                }
            }
            catch (Exception ex)
            {
                await Log.WriteError(this.GetType().ToString(), "GetAddress", $"address_id:{id}", ex, DateTime.Now);

                return(null);
            }

            return(address);
        }
        public async Task <Asset> GetAsset(string id)
        {
            Asset asset;

            try
            {
                asset = await AssetRepository.GetById(id);

                if (asset == null)
                {
                    asset = await BlockchainDataProvider.GetAsset(id);

                    await AssetRepository.Save(asset);
                }
            }
            catch (Exception ex)
            {
                await Log.WriteError(this.GetType().ToString(), "GetAsset", $"asset_id:{id}", ex, DateTime.Now);

                return(null);
            }

            return(asset);
        }