/// <summary>
/// Parses a Bitcoin block header.
/// </summary>
/// <param name="blockMemoryStreamReader">
/// Provides access to a section of the Bitcoin blockchain file.
/// </param>
/// <returns>
/// The block header information.
/// </returns>
/// <exception cref="InvalidBlockchainContentException">
/// Thrown if the block version is unknown.
/// </exception>
private static BlockHeader ParseBlockHeader(BlockMemoryStreamReader blockMemoryStreamReader)
{
BlockHeader blockHeader = new BlockHeader();
int positionInBaseStreamAtBlockHeaderStart = (int)blockMemoryStreamReader.BaseStream.Position;
blockHeader.BlockVersion = blockMemoryStreamReader.ReadUInt32();
//// TODO: We need to understand better what is different in V2 and V3.
if (blockHeader.BlockVersion != 1 &&
blockHeader.BlockVersion != 2 &&
blockHeader.BlockVersion != 3 &&
blockHeader.BlockVersion != 0x20000007 &&
blockHeader.BlockVersion != 0x30000000 &&
blockHeader.BlockVersion != 4 &&
blockHeader.BlockVersion != 0x20000000 &&
blockHeader.BlockVersion != 0x20000001 &&
blockHeader.BlockVersion != 0x30000001 &&
blockHeader.BlockVersion != 0x08000004 &&
blockHeader.BlockVersion != 0x20000002 &&
blockHeader.BlockVersion != 0x30000007 &&
blockHeader.BlockVersion != 0x20000004)
{
throw new UnknownBlockVersionException(string.Format(CultureInfo.InvariantCulture, "Unknown block version: {0} ({0:X}).", blockHeader.BlockVersion));
}
blockHeader.PreviousBlockHash = new ByteArray(blockMemoryStreamReader.ReadBytes(32).ReverseByteArray());
blockHeader.MerkleRootHash = new ByteArray(blockMemoryStreamReader.ReadBytes(32).ReverseByteArray());
blockHeader.BlockTimestampUnix = blockMemoryStreamReader.ReadUInt32();
blockHeader.BlockTimestamp = new DateTime(1970, 1, 1).AddSeconds(blockHeader.BlockTimestampUnix);
blockHeader.BlockTargetDifficulty = blockMemoryStreamReader.ReadUInt32();
blockHeader.BlockNonce = blockMemoryStreamReader.ReadUInt32();
int positionInBaseStreamAfterBlockHeaderEnd = (int)blockMemoryStreamReader.BaseStream.Position;
using (SHA256Managed sha256 = new SHA256Managed())
{
//// We need to calculate the double SHA256 hash of this transaction.
//// We need to access the buffer that contains the transaction that we jut read through.
//// Here we take advantage of the fact that the entire block was loaded as an in-memory buffer.
//// The base stream of blockMemoryStreamReader is that in-memory buffer.
byte[] baseBuffer = blockMemoryStreamReader.GetBuffer();
int blockHeaderBufferSize = positionInBaseStreamAfterBlockHeaderEnd - positionInBaseStreamAtBlockHeaderStart;
if (blockHeaderBufferSize != ExpectedBlockHeaderBufferSize)
{
// We have a problem. The block header should be 80 bytes in size.
throw new InvalidBlockchainContentException(string.Format(CultureInfo.InvariantCulture, "Block header buffer size has an invalid length: {0}. Expected: {1}.", blockHeaderBufferSize, ExpectedBlockHeaderBufferSize));
}
byte[] hash1 = sha256.ComputeHash(baseBuffer, positionInBaseStreamAtBlockHeaderStart, blockHeaderBufferSize);
blockHeader.BlockHash = new ByteArray(sha256.ComputeHash(hash1).ReverseByteArray());
}
return(blockHeader);
}
/// <summary>
/// Parses a Bitcoin transaction.
/// </summary>
/// <param name="blockMemoryStreamReader">
/// Provides access to a section of the Bitcoin blockchain file.
/// </param>
/// <returns>
/// The Bitcoin transaction that was parsed.
/// </returns>
private static Transaction ParseTransaction(BlockMemoryStreamReader blockMemoryStreamReader)
{
Transaction transaction = new Transaction();
int positionInBaseStreamAtTransactionStart = (int)blockMemoryStreamReader.BaseStream.Position;
transaction.TransactionVersion = blockMemoryStreamReader.ReadUInt32();
int inputsCount = (int)blockMemoryStreamReader.ReadVariableLengthInteger();
for (int inputIndex = 0; inputIndex < inputsCount; inputIndex++)
{
TransactionInput transactionInput = BlockchainParser.ParseTransactionInput(blockMemoryStreamReader);
transaction.AddInput(transactionInput);
}
int outputsCount = (int)blockMemoryStreamReader.ReadVariableLengthInteger();
for (int outputIndex = 0; outputIndex < outputsCount; outputIndex++)
{
TransactionOutput transactionOutput = BlockchainParser.ParseTransactionOutput(blockMemoryStreamReader);
transaction.AddOutput(transactionOutput);
}
// TODO: Need to find out more details about the semantic of TransactionLockTime.
transaction.TransactionLockTime = blockMemoryStreamReader.ReadUInt32();
int positionInBaseStreamAfterTransactionEnd = (int)blockMemoryStreamReader.BaseStream.Position;
using (SHA256Managed sha256 = new SHA256Managed())
{
//// We need to calculate the double SHA256 hash of this transaction.
//// We need to access the buffer that contains the transaction that we jut read through.
//// Here we take advantage of the fact that the entire block was loaded as an in-memory buffer.
//// The base stream of blockMemoryStreamReader is that in-memory buffer.
byte[] baseBuffer = blockMemoryStreamReader.GetBuffer();
int transactionBufferSize = positionInBaseStreamAfterTransactionEnd - positionInBaseStreamAtTransactionStart;
byte[] hash1 = sha256.ComputeHash(baseBuffer, positionInBaseStreamAtTransactionStart, transactionBufferSize);
transaction.TransactionHash = new ByteArray(sha256.ComputeHash(hash1).ReverseByteArray());
}
return(transaction);
}
/// <summary>
/// Parses a Bitcoin transaction.
/// </summary>
/// <param name="blockMemoryStreamReader">
/// Provides access to a section of the Bitcoin blockchain file.
/// </param>
/// <returns>
/// The Bitcoin transaction that was parsed.
/// </returns>
private static Transaction ParseTransaction(BlockMemoryStreamReader blockMemoryStreamReader)
{
Transaction transaction = new Transaction();
int positionInBaseStreamAtTransactionStart = (int)blockMemoryStreamReader.BaseStream.Position;
transaction.TransactionVersion = blockMemoryStreamReader.ReadUInt32();
int inputsCount = (int)blockMemoryStreamReader.ReadVariableLengthInteger();
bool isSegWit = false;
if (inputsCount == 0)
{
byte flag = blockMemoryStreamReader.ReadByte();
if (flag != 0x01)
{
throw new InvalidBlockchainContentException(string.Format(CultureInfo.InvariantCulture,
"Unknown transaction serialization. No input transactions, but SegWit flag was {0} instead of 1.", flag));
}
inputsCount = (int)blockMemoryStreamReader.ReadVariableLengthInteger();
isSegWit = true;
}
for (int inputIndex = 0; inputIndex < inputsCount; inputIndex++)
{
TransactionInput transactionInput = BlockchainParser.ParseTransactionInput(blockMemoryStreamReader);
transaction.AddInput(transactionInput);
}
int outputsCount = (int)blockMemoryStreamReader.ReadVariableLengthInteger();
for (int outputIndex = 0; outputIndex < outputsCount; outputIndex++)
{
TransactionOutput transactionOutput = BlockchainParser.ParseTransactionOutput(blockMemoryStreamReader);
transaction.AddOutput(transactionOutput);
}
int positionInBaseStreamAfterTxOuts = (int)blockMemoryStreamReader.BaseStream.Position;
if (isSegWit)
{
for (int inputIndex = 0; inputIndex < inputsCount; inputIndex++)
{
Witness witness = BlockchainParser.ParseWitness(blockMemoryStreamReader);
transaction.AddWitness(witness);
}
}
// TODO: Need to find out more details about the semantic of TransactionLockTime.
transaction.TransactionLockTime = blockMemoryStreamReader.ReadUInt32();
int positionInBaseStreamAfterTransactionEnd = (int)blockMemoryStreamReader.BaseStream.Position;
using (SHA256Managed sha256 = new SHA256Managed())
{
//// We need to calculate the double SHA256 hash of this transaction.
//// We need to access the buffer that contains the transaction that we jut read through.
//// Here we take advantage of the fact that the entire block was loaded as an in-memory buffer.
//// The base stream of blockMemoryStreamReader is that in-memory buffer.
//byte[] baseBuffer = blockMemoryStreamReader.GetBuffer();
//int transactionBufferSize = positionInBaseStreamAfterTransactionEnd - positionInBaseStreamAtTransactionStart;
byte[] baseBuffer = blockMemoryStreamReader.GetBuffer(), hash1 = null;
if (isSegWit)
{
using (SHA256Managed innerSHA256 = new SHA256Managed())
{
//// SegWit transactions are still identified by their txid, which is double SHA256 of the old
//// serialization format (i.e. no marker, flag, or witness). So, we need to calculate the txid by
//// recreating the old format as the input to the hash algorithm.
// First, the version number
innerSHA256.TransformBlock(baseBuffer, positionInBaseStreamAtTransactionStart, 4, baseBuffer, positionInBaseStreamAtTransactionStart);
// Skip the marker and flag (each one byte), then read in txins and txouts (starting with txin count)
int txStart = positionInBaseStreamAtTransactionStart + 6;
int txSize = positionInBaseStreamAfterTxOuts - txStart;
innerSHA256.TransformBlock(baseBuffer, txStart, txSize, baseBuffer, txStart);
///// After the transactions comes the segregated witness data, which is not included in the txid.
///// The only thing left to add to calcualte the txid is nLockTime located in the last 4 bytes
int lockTimeStart = positionInBaseStreamAfterTransactionEnd - 4;
innerSHA256.TransformFinalBlock(baseBuffer, lockTimeStart, 4);
hash1 = innerSHA256.Hash;
}
}
else
{
int transactionBufferSize = positionInBaseStreamAfterTransactionEnd - positionInBaseStreamAtTransactionStart;
hash1 = sha256.ComputeHash(baseBuffer, positionInBaseStreamAtTransactionStart, transactionBufferSize);
}
// byte[] hash1 = sha256.ComputeHash(baseBuffer, positionInBaseStreamAtTransactionStart, transactionBufferSize);
transaction.TransactionHash = new ByteArray(sha256.ComputeHash(hash1).ReverseByteArray());
}
return(transaction);
}
/// <summary>
/// Parses a Bitcoin transaction.
/// </summary>
/// <param name="blockMemoryStreamReader">
/// Provides access to a section of the Bitcoin blockchain file.
/// </param>
/// <returns>
/// The Bitcoin transaction that was parsed.
/// </returns>
private static Transaction ParseTransaction(BlockMemoryStreamReader blockMemoryStreamReader)
{
Transaction transaction = new Transaction();
int positionInBaseStreamAtTransactionStart = (int)blockMemoryStreamReader.BaseStream.Position;
transaction.TransactionVersion = blockMemoryStreamReader.ReadUInt32();
int inputsCount = (int)blockMemoryStreamReader.ReadVariableLengthInteger();
for (int inputIndex = 0; inputIndex < inputsCount; inputIndex++)
{
TransactionInput transactionInput = BlockchainParser.ParseTransactionInput(blockMemoryStreamReader);
transaction.AddInput(transactionInput);
}
int outputsCount = (int)blockMemoryStreamReader.ReadVariableLengthInteger();
for (int outputIndex = 0; outputIndex < outputsCount; outputIndex++)
{
TransactionOutput transactionOutput = BlockchainParser.ParseTransactionOutput(blockMemoryStreamReader);
transaction.AddOutput(transactionOutput);
}
// TODO: Need to find out more details about the semantic of TransactionLockTime.
transaction.TransactionLockTime = blockMemoryStreamReader.ReadUInt32();
int positionInBaseStreamAfterTransactionEnd = (int)blockMemoryStreamReader.BaseStream.Position;
using (SHA256Managed sha256 = new SHA256Managed())
{
//// We need to calculate the double SHA256 hash of this transaction.
//// We need to access the buffer that contains the transaction that we jut read through.
//// Here we take advantage of the fact that the entire block was loaded as an in-memory buffer.
//// The base stream of blockMemoryStreamReader is that in-memory buffer.
byte[] baseBuffer = blockMemoryStreamReader.GetBuffer();
int transactionBufferSize = positionInBaseStreamAfterTransactionEnd - positionInBaseStreamAtTransactionStart;
byte[] hash1 = sha256.ComputeHash(baseBuffer, positionInBaseStreamAtTransactionStart, transactionBufferSize);
transaction.TransactionHash = new ByteArray(sha256.ComputeHash(hash1).ReverseByteArray());
}
return transaction;
}
/// <summary>
/// Parses a Bitcoin block header.
/// </summary>
/// <param name="blockMemoryStreamReader">
/// Provides access to a section of the Bitcoin blockchain file.
/// </param>
/// <returns>
/// The block header information.
/// </returns>
/// <exception cref="InvalidBlockchainContentException">
/// Thrown if the block version is unknown.
/// </exception>
private static BlockHeader ParseBlockHeader(BlockMemoryStreamReader blockMemoryStreamReader)
{
BlockHeader blockHeader = new BlockHeader();
int positionInBaseStreamAtBlockHeaderStart = (int)blockMemoryStreamReader.BaseStream.Position;
blockHeader.BlockVersion = blockMemoryStreamReader.ReadUInt32();
// TODO: We need to understand better what is different in V2 and V3.
if (blockHeader.BlockVersion != 1 && blockHeader.BlockVersion != 2 && blockHeader.BlockVersion != 3)
{
throw new UnknownBlockVersionException(string.Format(CultureInfo.InvariantCulture, "Unknown block version: {0}.", blockHeader.BlockVersion));
}
blockHeader.PreviousBlockHash = new ByteArray(blockMemoryStreamReader.ReadBytes(32).ReverseByteArray());
blockHeader.MerkleRootHash = new ByteArray(blockMemoryStreamReader.ReadBytes(32).ReverseByteArray());
blockHeader.BlockTimestampUnix = blockMemoryStreamReader.ReadUInt32();
blockHeader.BlockTimestamp = new DateTime(1970, 1, 1).AddSeconds(blockHeader.BlockTimestampUnix);
blockHeader.BlockTargetDifficulty = blockMemoryStreamReader.ReadUInt32();
blockHeader.BlockNonce = blockMemoryStreamReader.ReadUInt32();
int positionInBaseStreamAfterBlockHeaderEnd = (int)blockMemoryStreamReader.BaseStream.Position;
using (SHA256Managed sha256 = new SHA256Managed())
{
//// We need to calculate the double SHA256 hash of this transaction.
//// We need to access the buffer that contains the transaction that we jut read through.
//// Here we take advantage of the fact that the entire block was loaded as an in-memory buffer.
//// The base stream of blockMemoryStreamReader is that in-memory buffer.
byte[] baseBuffer = blockMemoryStreamReader.GetBuffer();
int blockHeaderBufferSize = positionInBaseStreamAfterBlockHeaderEnd - positionInBaseStreamAtBlockHeaderStart;
if (blockHeaderBufferSize != ExpectedBlockHeaderBufferSize)
{
// We have a problem. The block header should be 80 bytes in size.
throw new InvalidBlockchainContentException(string.Format(CultureInfo.InvariantCulture, "Block header buffer size has an invalid length: {0}. Expected: {1}.", blockHeaderBufferSize, ExpectedBlockHeaderBufferSize));
}
byte[] hash1 = sha256.ComputeHash(baseBuffer, positionInBaseStreamAtBlockHeaderStart, blockHeaderBufferSize);
blockHeader.BlockHash = new ByteArray(sha256.ComputeHash(hash1).ReverseByteArray());
}
return blockHeader;
}