public void TestCalculateTransactionHash()
{
var expectedHash = UInt256.ParseHex("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b");
var tx = Transaction.Create
(
version: 1,
inputs: ImmutableArray.Create(
new TxInput
(
prevTxHash: UInt256.Zero,
prevTxOutputIndex: 4294967295,
scriptSignature: "04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73".HexToByteArray().ToImmutableArray(),
sequence: 4294967295
)),
outputs: ImmutableArray.Create(
new TxOutput
(
value: (UInt64)(50L * 100.MILLION()),
scriptPublicKey: "4104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac".HexToByteArray().ToImmutableArray()
)),
lockTime: 0
).Transaction;
Assert.AreEqual(expectedHash, tx.Hash);
}
public void TestToCompact()
{
var target1 = UInt256.ParseHex("404cb000000000000000000000000000000000000000000000000");
var expected1 = 0x1b0404cbU;
var actual1 = DataCalculator.ToCompact(target1);
Assert.AreEqual(expected1, actual1);
// difficulty: 1
var target2 = UInt256.ParseHex("ffff0000000000000000000000000000000000000000000000000000");
var expected2 = 0x1d00ffffU;
var actual2 = DataCalculator.ToCompact(target2);
Assert.AreEqual(expected2, actual2);
var target3 = UInt256.ParseHex("7fff0000000000000000000000000000000000000000000000000000");
var expected3 = 0x1c7fff00U;
var actual3 = DataCalculator.ToCompact(target3);
Assert.AreEqual(expected3, actual3);
var target4 = UInt256.ParseHex("000000000000000000000000000000000000000000000000000404cb");
var expected4 = 0x030404cbU;
var actual4 = DataCalculator.ToCompact(target4);
Assert.AreEqual(expected4, actual4);
}
public void TestUInt256Sha256()
{
var expected = SHA256Static.ComputeDoubleHash(UInt256.ParseHex(TestData.HEX_STRING_64).ToByteArray());
var actual = new UInt256(expected).ToByteArray();
CollectionAssert.AreEqual(expected, actual);
}
public void TestUInt256Inequality()
{
var expected = UInt256.ParseHex(TestData.HEX_STRING_64);
var actual = UInt256.Zero;
Assert.AreNotEqual(expected, actual);
Assert.IsFalse(expected == actual);
Assert.IsTrue(expected != actual);
CollectionAssert.AreNotEqual(expected.ToByteArray(), actual.ToByteArray());
}
public void TestUInt256RawBytes()
{
var expected = UInt256.ParseHex(TestData.HEX_STRING_64);
var actual1 = new UInt256(expected.ToByteArray());
var actual2 = new UInt256(new UInt256(expected.ToByteArray()).ToByteArray());
var actual3 = new UInt256(new UInt256(new UInt256(expected.ToByteArray()).ToByteArray()).ToByteArray());
Assert.AreEqual(expected, actual1);
Assert.AreEqual(expected, actual2);
Assert.AreEqual(expected, actual3);
}
public void TestUInt256HexString()
{
var hex = TestData.HEX_STRING_64;
var expected1 = "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b";
var expected2 = "[3b,a3,ed,fd,7a,7b,12,b2,7a,c7,2c,3e,67,76,8f,61,7f,c8,1b,c3,88,8a,51,32,3a,9f,b8,aa,4b,1e,5e,4a]";
var actual1 = UInt256.ParseHex(hex).ToHexNumberString();
var actual2 = UInt256.ParseHex(hex).ToHexDataString();
Assert.AreEqual(expected1, actual1);
Assert.AreEqual(expected2, actual2);
}
public void TestCalculateBlockHash()
{
var expectedHash = UInt256.ParseHex("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
var blockHeader = BlockHeader.Create
(
version: 1,
previousBlock: UInt256.Zero,
merkleRoot: UInt256.ParseHex("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"),
time: DateTimeOffset.FromUnixTimeSeconds(1231006505),
bits: 0x1D00FFFF,
nonce: 2083236893
);
Assert.AreEqual(expectedHash, DataCalculator.CalculateBlockHash(blockHeader));
Assert.AreEqual(expectedHash, DataCalculator.CalculateBlockHash(blockHeader.Version, blockHeader.PreviousBlock, blockHeader.MerkleRoot, blockHeader.Time, blockHeader.Bits, blockHeader.Nonce));
}
public void TestFromCompact()
{
var bits1 = 0x1b0404cbU;
var expected1 = UInt256.ParseHex("404cb000000000000000000000000000000000000000000000000");
var actual1 = DataCalculator.FromCompact(bits1);
Assert.AreEqual(expected1, actual1);
// difficulty: 1
var bits2 = 0x1d00ffffU;
var expected2 = UInt256.ParseHex("ffff0000000000000000000000000000000000000000000000000000");
var actual2 = DataCalculator.FromCompact(bits2);
Assert.AreEqual(expected2, actual2);
var bits3 = 0x030404cbU;
var expected3 = UInt256.ParseHex("000000000000000000000000000000000000000000000000404cb");
var actual3 = DataCalculator.FromCompact(bits3);
Assert.AreEqual(expected3, actual3);
}
public BlockProvider(string resourceName)
{
this.blocks = new ConcurrentDictionary <string, Block>();
this.heightNames = new Dictionary <int, string>();
this.hashNames = new Dictionary <UInt256, string>();
var assembly = Assembly.GetCallingAssembly();
var stream = assembly.GetManifestResourceStream(resourceName);
this.zip = new ZipArchive(stream);
foreach (var entry in zip.Entries)
{
var chunks = Path.GetFileNameWithoutExtension(entry.Name).Split('_');
var blockHeight = int.Parse(chunks[0]);
var blockHash = UInt256.ParseHex(chunks[1]);
heightNames.Add(blockHeight, entry.Name);
hashNames.Add(blockHash, entry.Name);
}
}
private void TestRollback(ITestStorageProvider provider)
{
ConsoleLoggingModule.Configure();
var logger = LogManager.GetCurrentClassLogger();
var blockCount = 10.THOUSAND();
var checkUtxoHashFrequencey = 1000;
var blockProvider = new TestNet3BlockProvider();
var blocks = blockProvider.ReadBlocks().Take(blockCount).ToList();
var genesisBlock = blocks[0];
var genesisHeader = new ChainedHeader(genesisBlock.Header, height: 0, totalWork: 0, dateSeen: DateTimeOffset.Now);
var genesisChain = Chain.CreateForGenesisBlock(genesisHeader);
var chainParams = new Testnet3Params();
var rules = new CoreRules(chainParams)
{
IgnoreScripts = true,
IgnoreSignatures = true,
IgnoreScriptErrors = true
};
using (var storageManager = provider.OpenStorageManager())
using (var coreStorage = new CoreStorage(storageManager))
using (var chainStateBuilder = new ChainStateBuilder(rules, coreStorage, storageManager))
{
// add blocks to storage
coreStorage.AddGenesisBlock(ChainedHeader.CreateForGenesisBlock(blocks[0].Header));
foreach (var block in blocks)
{
coreStorage.TryAddBlock(block);
}
// store empty utxo hash
var expectedUtxoHashes = new List <UInt256>();
using (var chainState = chainStateBuilder.ToImmutable())
expectedUtxoHashes.Add(UtxoCommitment.ComputeHash(chainState));
// calculate utxo forward and store its state at each step along the way
for (var blockIndex = 0; blockIndex < blocks.Count; blockIndex++)
{
logger.Info($"Adding: {blockIndex:N0}");
var block = blocks[blockIndex];
var chainedHeader = new ChainedHeader(block.Header, blockIndex, 0, DateTimeOffset.Now);
chainStateBuilder.AddBlockAsync(chainedHeader, block.Transactions.Select(
(tx, txIndex) => BlockTx.Create(txIndex, tx))).Wait();
if (blockIndex % checkUtxoHashFrequencey == 0 || blockIndex == blocks.Count - 1)
{
using (var chainState = chainStateBuilder.ToImmutable())
expectedUtxoHashes.Add(UtxoCommitment.ComputeHash(chainState));
}
}
// verify the utxo state before rolling back
var expectedLastUtxoHash = UInt256.ParseHex("5f155c7d8a5c850d5fb2566aec5110caa40e270184126d17022ae9780fd65fd9");
Assert.AreEqual(expectedLastUtxoHash, expectedUtxoHashes.Last());
expectedUtxoHashes.RemoveAt(expectedUtxoHashes.Count - 1);
// roll utxo backwards and validate its state at each step along the way
for (var blockIndex = blocks.Count - 1; blockIndex >= 0; blockIndex--)
{
logger.Info($"Rolling back: {blockIndex:N0}");
var block = blocks[blockIndex];
var chainedHeader = new ChainedHeader(block.Header, blockIndex, 0, DateTimeOffset.Now);
var blockTxes = block.Transactions.Select((tx, txIndex) => BlockTx.Create(txIndex, tx));
chainStateBuilder.RollbackBlock(chainedHeader, blockTxes);
if ((blockIndex - 1) % checkUtxoHashFrequencey == 0 || blockIndex == 0)
{
var expectedUtxoHash = expectedUtxoHashes.Last();
expectedUtxoHashes.RemoveAt(expectedUtxoHashes.Count - 1);
using (var chainState = chainStateBuilder.ToImmutable())
Assert.AreEqual(expectedUtxoHash, UtxoCommitment.ComputeHash(chainState));
}
}
// verify chain state was rolled all the way back
Assert.AreEqual(-1, chainStateBuilder.Chain.Height);
Assert.AreEqual(0, expectedUtxoHashes.Count);
// calculate utxo forward again
for (var blockIndex = 0; blockIndex < blocks.Count; blockIndex++)
{
logger.Info($"Adding: {blockIndex:N0}");
var block = blocks[blockIndex];
var chainedHeader = new ChainedHeader(block.Header, blockIndex, 0, DateTimeOffset.Now);
chainStateBuilder.AddBlockAsync(chainedHeader, block.Transactions.Select(
(tx, txIndex) => BlockTx.Create(txIndex, tx))).Wait();
}
// verify final utxo state again
using (var chainState = chainStateBuilder.ToImmutable())
Assert.AreEqual(expectedLastUtxoHash, UtxoCommitment.ComputeHash(chainState));
}
}