public static AssetCoinholdersViewModel Create(AssetViewModel asset, IBalanceSummary balanceSummary, int?atBlockHeight, IDictionary <string, double> addressChanges, IEnumerable <IBalanceBlock> blocksWithChanges, IBlockHeader currentBlock, IBlockHeader atBlockInfo) { var total = balanceSummary.AddressSummaries.Sum(p => p.Balance); var addressSummaries = balanceSummary.AddressSummaries .Select( p => BalanceAddressSummary.Create(p, total, asset.Divisibility, addressChanges.ContainsKey(p.Address) ? addressChanges[p.Address] : 0)) .Where(p => p.Balance != 0 || p.ChangeAtBlock != 0) .OrderByDescending(p => p.Balance) .ToList(); return(new AssetCoinholdersViewModel { Asset = asset, AddressSummaries = addressSummaries, Total = BitcoinUtils.CalculateColoredAssetQuantity(total, asset.Divisibility), Pagination = BlockPagination.Create(blocksWithChanges.Select(p => p.Height), atBlockHeight ?? currentBlock?.Height, currentBlock), CoinholdersCount = addressSummaries.Count, AtBlockDateTime = (atBlockInfo ?? currentBlock)?.Time.ToUniversalTime() }); }
protected async Task CheckHeaderAppendable(IBlockHeader header) { var blockHeader = (BlockHeader)header; #region genesis // TODO: more strict genesis if (blockHeader.Index == GlobalConfig.GenesisBlockHeight) { var curHash = await _chainManager.GetCurrentBlockHashAsync(_chainId); if (curHash.IsNull()) { await _chainManager.AddChainAsync(_chainId, header.GetHash()); } return; } #endregion genesis var prevHeader = await GetHeaderByHashAsync(blockHeader.PreviousBlockHash); if (prevHeader == null) { throw new InvalidOperationException($"Parent is unknown for {blockHeader}."); } var expected = ((BlockHeader)prevHeader).Index + 1; var actual = blockHeader.Index; if (actual != expected) { throw new InvalidOperationException($"Incorrect index. Expected: {expected}, actual: {actual}"); } }
public static Dictionary MarshalBlockHeader(this IBlockHeader header) => MarshalBlockHeader( MarshalPreEvaluationBlockHeader(header), header.StateRootHash, header.Signature, header.Hash );
public Mock <IBlock> MockBlock(IBlockHeader header, IBlockBody body) { Mock <IBlock> mock = new Mock <IBlock>(); mock.Setup(b => b.Header).Returns((BlockHeader)header); mock.Setup(b => b.Body).Returns((BlockBody)body); return(mock); }
protected async Task AddHeaderAsync(IBlockHeader header) { await CheckHeaderAppendable(header); await _blockManager.AddBlockHeaderAsync((BlockHeader)header); await MaybeSwitchBranch(header); MessageHub.Instance.Publish((BlockHeader)header); }
protected async Task MaybeSwitchBranch(IBlockHeader header) { var blockHeader = (BlockHeader)header; if (blockHeader.Index <= GlobalConfig.GenesisBlockHeight) { var hash = GetHeightHash(blockHeader.Index).OfType(HashType.CanonicalHash); // hash.Height = blockHeader.Index; await _dataStore.InsertAsync(hash, header.GetHash()); await _chainManager.UpdateCurrentBlockHashAsync(_chainId, header.GetHash()); return; } var currentBlockHash = await GetCurrentBlockHashAsync(); var currentHeader = await GetHeaderByHashAsync(currentBlockHash); if (currentHeader.GetHash().Equals(((BlockHeader)header).PreviousBlockHash) || ((BlockHeader)header).PreviousBlockHash.Equals(Hash.Genesis)) { var hash = GetHeightHash(((BlockHeader)header).Index).OfType(HashType.CanonicalHash); // hash.Height = ((BlockHeader) header).Index; await _dataStore.InsertAsync(hash, header.GetHash()); await _chainManager.UpdateCurrentBlockHashAsync(_chainId, header.GetHash()); return; } if (((BlockHeader)header).Index > ((BlockHeader)currentHeader).Index) { await _chainManager.UpdateCurrentBlockHashAsync(_chainId, header.GetHash()); var branches = await GetComparedBranchesAsync(currentHeader, header); if (branches.Item2.Count > 0) { foreach (var newBranchHeader in branches.Item2) { if (newBranchHeader == null) { break; } var hash = GetHeightHash(((BlockHeader)newBranchHeader).Index).OfType(HashType.CanonicalHash); // hash.Height = ((BlockHeader) newBranchHeader).Index; await _dataStore.InsertAsync(hash, newBranchHeader.GetHash()); } } } }
/// <summary> /// Creates a <see cref="Block{T}"/> instance by combining a block <paramref name="header"/> /// and <paramref name="transactions"/>. /// </summary> /// <param name="header">The block header.</param> /// <param name="transactions">The transactions to include.</param> /// <exception cref="InvalidBlockProtocolVersionException">Thrown when /// the <paramref name="header"/>'s <see cref="IBlockMetadata.ProtocolVersion"/> /// is less than 0, or greater than <see cref="BlockMetadata.CurrentProtocolVersion"/>, /// the latest known protocol version.</exception> /// <exception cref="InvalidBlockIndexException">Thrown when the <paramref name="header"/> /// has a negative <see cref="IBlockMetadata.Index"/>.</exception> /// <exception cref="InvalidBlockDifficultyException">Thrown when /// the <paramref name="header"/>'s <see cref="IBlockMetadata.Difficulty"/> is negative. /// </exception> /// <exception cref="InvalidBlockTotalDifficultyException">Thrown when /// the <paramref name="header"/>'s <see cref="IBlockMetadata.TotalDifficulty"/> is less /// than its <see cref="IBlockMetadata.Difficulty"/>.</exception> /// <exception cref="InvalidTxSignatureException">Thrown when any tx signature is invalid or /// not signed by its signer.</exception> /// <exception cref="InvalidTxPublicKeyException">Thrown when any tx signer is not derived /// from its its public key.</exception> /// <exception cref="InvalidTxNonceException">Thrown when the same tx nonce is used by /// a signer twice or more, or a tx nonce is used without its previous nonce by a signer. /// Note that this validates only a block's intrinsic integrity between its transactions, /// but does not guarantee integrity between blocks. Such validation needs to be conducted /// by <see cref="Blockchain.BlockChain{T}"/>.</exception> /// <exception cref="InvalidTxGenesisHashException">Thrown when transactions to set have /// inconsistent genesis hashes.</exception> /// <exception cref="InvalidBlockTxHashException">Thrown when the given block /// <paramref name="header"/>'s <see cref="IBlockMetadata.TxHash"/> is not consistent with /// its <paramref name="transactions"/>.</exception> /// <exception cref="InvalidBlockPreEvaluationHashException">Thrown when the given /// <paramref name="header"/> has an invalid /// <see cref="IPreEvaluationBlockHeader.PreEvaluationHash"/>.</exception> /// <exception cref="InvalidBlockNonceException">Thrown when the given /// <paramref name="header"/>'s <see cref="IPreEvaluationBlockHeader.Nonce"/> does not /// satisfy the required <see cref="PreEvaluationBlockHeader.Difficulty"/>.</exception> public Block(IBlockHeader header, IEnumerable <Transaction <T> > transactions) : this( new PreEvaluationBlock <T>( new BlockContent <T>(header, transactions), header.HashAlgorithm, header.Nonce, header.PreEvaluationHash ), header.StateRootHash, header.Signature ) { }
public static BlockHeaderViewModel Create(IBlockHeader header) { if (header != null) { return(new BlockHeaderViewModel { BlockId = header.Hash, Height = header.Height }); } return(null); }
protected async Task <Tuple <List <IBlockHeader>, List <IBlockHeader> > > GetComparedBranchesAsync( IBlockHeader oldHead, IBlockHeader newHead) { var tempOldHead = (BlockHeader)oldHead; var tempNewHead = (BlockHeader)newHead; var oldBranch = new List <IBlockHeader>(); var newBranch = new List <IBlockHeader>(); while (((BlockHeader)oldHead).Index > ((BlockHeader)newHead).Index) { oldBranch.Add(tempOldHead); tempOldHead = (BlockHeader) await GetHeaderByHashAsync(tempOldHead.PreviousBlockHash); } while (((BlockHeader)newHead).Index > ((BlockHeader)oldHead).Index) { newBranch.Add(tempNewHead); if (tempNewHead == null) { break; } tempNewHead = (BlockHeader) await GetHeaderByHashAsync(tempNewHead.PreviousBlockHash); } while (tempNewHead != null && tempOldHead.PreviousBlockHash != tempNewHead.PreviousBlockHash) { oldBranch.Add(tempOldHead); newBranch.Add(tempNewHead); tempOldHead = (BlockHeader) await GetHeaderByHashAsync(tempOldHead.PreviousBlockHash); tempNewHead = (BlockHeader) await GetHeaderByHashAsync(tempNewHead.PreviousBlockHash); } if (tempOldHead != null && tempNewHead != null) { oldBranch.Add(tempOldHead); newBranch.Add(tempNewHead); } return(Tuple.Create(oldBranch, newBranch)); }
public static BlockViewModel Create(IBlock ninjaBlock, IBlockHeader lastBlock) { return new BlockViewModel { Confirmations = ninjaBlock.Confirmations, Difficulty = ninjaBlock.Difficulty, Hash = ninjaBlock.Hash, Height = ninjaBlock.Height, MerkleRoot = ninjaBlock.MerkleRoot, Nonce = ninjaBlock.Nonce, PreviousBlock = ninjaBlock.PreviousBlock, Time = ninjaBlock.Time, AllTransactionIdList = new TransactionIdList(ninjaBlock.AllTransactionIds), ColoredTransactionIdList = new TransactionIdList(ninjaBlock.ColoredTransactionIds), UncoloredTransactionIdList = new TransactionIdList(ninjaBlock.UncoloredTransactionIds), TotalTransactions = ninjaBlock.TotalTransactions, ShowNextBlock = ninjaBlock.Height < lastBlock?.Height, NextBlockHeight = ninjaBlock.Height + 1 }; }
public static AddressBalanceViewModel Create(IAddressBalance balance, IReadOnlyDictionary <string, IAssetDefinition> assetDictionary, IBlockHeader lastBlock, IBlockHeader atBlock, IEnumerable <IGroup> offchainGroups, bool isHub) { var onchainColoredBalances = (balance.ColoredBalances ?? Enumerable.Empty <IColoredBalance>()).Select(p => ColoredBalance.Create(p, assetDictionary)).ToList(); var existedOnchainAssetsBalances = onchainColoredBalances.Select(p => p.AssetId).ToDictionary(p => p); //show balances for offchain assets with 0 onchain balance var missedOffchainColoredBalances = offchainGroups.Where(p => p.IsColored && !existedOnchainAssetsBalances.ContainsKey(p.AssetId)) .Select(p => p.AssetId) .Distinct() .Select(assetId => ColoredBalance.CreateEmpty(assetId, assetDictionary)); return(new AddressBalanceViewModel { AddressId = balance.AddressId, TotalConfirmedTransactions = balance.TotalTransactions, Balance = balance.BtcBalance, Assets = onchainColoredBalances.Union(missedOffchainColoredBalances).ToList(), UnconfirmedBalanceDelta = balance.UnconfirmedBalanceDelta, AssetDic = AssetDictionary.Create(assetDictionary), LastBlockHeight = lastBlock.Height, LastBlockDateTime = lastBlock.Time, AtBlockHeight = (atBlock ?? lastBlock).Height, AtBlockDateTime = (atBlock ?? lastBlock).Time, OffchainGroupsByAsset = OffchainGroupsByAsset.Create(offchainGroups, assetDictionary), TotalTransactionsCountCalculated = balance.TotalTransactionsCountCalculated, TotalSpendedTransactions = balance.TotalSpendedTransactions, TotalSpendedTransactionsCountCalculated = balance.TotalSpendedTransactionsCountCalculated, TotalReceivedTransactions = balance.TotalReceivedTransactions, TotalReceivedTransactionsCountCalculated = balance.TotalReceivedTransactionsCountCalculated, IsOffchainHub = isHub }); }
public async Task ParseLast() { IBlockHeader blockPtr = null; try { _console.Write(nameof(ParseBlocksFunctions), nameof(ParseLast), null, "Started"); blockPtr = await _blockService.GetLastBlockHeaderAsync(); while (blockPtr != null && !await _assetDefinitionParsedBlockRepository .IsBlockExistsAsync(AssetDefinitionParsedBlock.Create(blockPtr.Hash))) { _console.Write(nameof(ParseBlocksFunctions), nameof(ParseLast), new { blockPtr.Hash, blockPtr.Height }.ToJson(), $"Add parse block command {blockPtr.Height}"); await _parseBlockCommandProducer.CreateParseBlockCommand(blockPtr.Hash); blockPtr = await _blockService.GetBlockHeaderAsync((blockPtr.Height - 1).ToString()); } _console.Write(nameof(ParseBlocksFunctions), nameof(ParseLast), null, "Done"); } catch (Exception e) { await _log.WriteErrorAsync(nameof(ParseBlocksFunctions), nameof(ParseLast), new { blockHash = blockPtr?.Hash }.ToJson(), e); throw; } }
public byte[] Mine(IBlockHeader blockheader) { throw new NotImplementedException(); }
public Block(IBlockHeader blockHeader, IBlockBody blockBody) { BlockHeader = blockHeader; BlockBody = blockBody; }
public Block(IBlockHeader header, List <ITransaction> transactions) { this.BlockHeader = header; this.Transactions = transactions; }
public GenesisBlock(IBlockHeader blockHeader, IBlockBody blockBody) { BlockHeader = blockHeader; BlockBody = blockBody; }
//Constructor public Block(List <string> data, IBlockHeader header) { _tree = new MerkleTree(); _header = (Header)header; }
private void FillHeaderData(IBlockHeader header, Block result) { result.Confirmations = header.Confirmations; result.Height = header.Height; }
/// <summary> /// Mine the specified blockheader. /// </summary> /// <returns>does not but serilize the block</returns> /// <param name="blockheader">Blockheader.</param> public byte[] Mine(IBlockHeader blockheader) { // TODO: return a serlized block header return(null); }
public static BlockPagination Create(IEnumerable <int> changedAtHeights, int?atBlock, IBlockHeader currentBlock) { var ordered = changedAtHeights.OrderBy(p => p).ToList(); var at = atBlock ?? ordered.LastOrDefault(); if (currentBlock != null) { ordered.Add(currentBlock.Height); } var result = new BlockPagination { ChangedAtHeights = ordered.Distinct().ToList(), AtBlock = at, ShowCurrentBlock = atBlock != null }; return(result); }