public MemoryBlockchain(Block? genesisBlock = null)
{
this.shutdownToken = new CancellationToken();
this.random = new Random();
// create the key pair that block rewards will be sent to
var keyPair = TransactionManager.CreateKeyPair();
this._coinbasePrivateKey = keyPair.Item1;
this._coinbasePublicKey = keyPair.Item2;
// initialize unit test storage
this._storageContext = new MemoryStorageContext();
this._cacheContext = new CacheContext(this._storageContext);
// initialize unit test rules
this._rules = new UnitTestRules(this._cacheContext);
// initialize blockchain calculator
this._calculator = new BlockchainCalculator(this._rules, this._cacheContext, this.shutdownToken);
// create and mine the genesis block
this._genesisBlock = genesisBlock ?? MineEmptyBlock(0);
// update genesis blockchain and add to storage
this._rules.SetGenesisBlock(this._genesisBlock);
this._currentBlockchain = this._rules.GenesisBlockchain;
this._genesisChainedBlock = AddBlock(this._genesisBlock, null).Item2;
}
public MainWindow()
{
try
{
//TODO
//MainnetRules.BypassValidation = true;
//MainnetRules.BypassExecuteScript = true;
ScriptEngine.BypassVerifySignature = true;
#if SQLITE
var storageContext = new SQLiteStorageContext();
var knownAddressStorage = new BitSharp.Storage.SQLite.KnownAddressStorage(storageContext);
this.storageContext = storageContext;
#elif FIREBIRD
var storageContext = new FirebirdStorageContext();
var knownAddressStorage = new BitSharp.Storage.Firebird.KnownAddressStorage(storageContext);
this.storageContext = storageContext;
#elif SQL_SERVER
var storageContext = new SqlServerStorageContext();
var knownAddressStorage = new BitSharp.Storage.SqlServer.KnownAddressStorage(storageContext);
this.storageContext = storageContext;
#endif
this.cacheContext = new CacheContext(this.storageContext);
this.rules = new MainnetRules(this.cacheContext);
this.blockchainDaemon = new BlockchainDaemon(this.rules, this.cacheContext);
this.localClient = new LocalClient(LocalClientType.MainNet, this.blockchainDaemon, knownAddressStorage);
// setup view model
this.viewModel = new MainWindowViewModel(this.blockchainDaemon);
InitializeComponent();
// start the blockchain daemon
this.blockchainDaemon.Start();
this.viewModel.ViewBlockchainLast();
// start p2p client
this.localClient.Start();
this.DataContext = this.viewModel;
}
catch (Exception e)
{
Debug.WriteLine(e);
throw;
}
}
public static void Main(string[] args)
{
//TODO
//MainnetRules.BypassValidation = true;
//MainnetRules.BypassExecuteScript = true;
ScriptEngine.BypassVerifySignature = true;
using (var storageContext = new MemoryStorageContext())
using (var cacheContext = new CacheContext(storageContext))
{
var rules = new Testnet2Rules(cacheContext);
using (var blockchainDaemon = new BlockchainDaemon(rules, cacheContext))
using (var knownAddressStorage = new MemoryStorage<NetworkAddressKey, NetworkAddressWithTime>(storageContext))
using (var localClient = new LocalClient(LocalClientType.ComparisonToolTestNet, blockchainDaemon, knownAddressStorage))
{
// start the blockchain daemon
blockchainDaemon.Start();
// start p2p client
localClient.Start();
var projectFolder = Environment.CurrentDirectory;
while (projectFolder.Contains(@"\bin"))
projectFolder = Path.GetDirectoryName(projectFolder);
File.Delete(Path.Combine(projectFolder, "Bitcoinj-comparison.log"));
var javaProcessStartInfo = new ProcessStartInfo
{
FileName = @"C:\Program Files\Java\jdk1.7.0_25\bin\java.exe",
WorkingDirectory = projectFolder,
Arguments = @"-Djava.util.logging.config.file={0}\bitcoinj.log.properties -jar {0}\bitcoinj.jar".Format2(projectFolder),
UseShellExecute = false
};
var javaProcess = Process.Start(javaProcessStartInfo);
javaProcess.WaitForExit((int)TimeSpan.FromMinutes(5).TotalMilliseconds);
Console.ReadLine();
}
}
}
public BlockHeaderCache(CacheContext cacheContext, long maxFlushMemorySize, long maxCacheMemorySize)
: base("BlockHeaderCache", cacheContext.StorageContext.BlockHeaderStorage, maxFlushMemorySize, maxCacheMemorySize, BlockHeader.SizeEstimator)
{
this._cacheContext = cacheContext;
}
public BlockchainCalculator(IBlockchainRules rules, CacheContext cacheContext, CancellationToken shutdownToken)
{
this._rules = rules;
this._cacheContext = cacheContext;
this.shutdownToken = shutdownToken;
}
public MainnetRules(CacheContext cacheContext)
{
this._cacheContext = cacheContext;
this._highestTarget = UInt256.Parse("00000000FFFF0000000000000000000000000000000000000000000000000000", NumberStyles.HexNumber);
this._genesisBlock =
new Block
(
header: new BlockHeader
(
version: 1,
previousBlock: 0,
merkleRoot: UInt256.Parse("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b", NumberStyles.HexNumber),
time: 1231006505,
bits: 486604799,
nonce: 2083236893
),
transactions: ImmutableArray.Create
(
new Transaction
(
version: 1,
inputs: ImmutableArray.Create
(
new TxInput
(
previousTxOutputKey: new TxOutputKey
(
txHash: 0,
txOutputIndex: 0xFFFFFFFF
),
scriptSignature: ImmutableArray.Create<byte>
(
0x04, 0xFF, 0xFF, 0x00, 0x1D, 0x01, 0x04, 0x45, 0x54, 0x68, 0x65, 0x20, 0x54, 0x69, 0x6D, 0x65,
0x73, 0x20, 0x30, 0x33, 0x2F, 0x4A, 0x61, 0x6E, 0x2F, 0x32, 0x30, 0x30, 0x39, 0x20, 0x43, 0x68,
0x61, 0x6E, 0x63, 0x65, 0x6C, 0x6C, 0x6F, 0x72, 0x20, 0x6F, 0x6E, 0x20, 0x62, 0x72, 0x69, 0x6E,
0x6B, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x62, 0x61, 0x69, 0x6C,
0x6F, 0x75, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x62, 0x61, 0x6E, 0x6B, 0x73
),
sequence: 0xFFFFFFFF
)
),
outputs: ImmutableArray.Create
(
new TxOutput
(
value: 50 * SATOSHI_PER_BTC,
scriptPublicKey: ImmutableArray.Create<byte>
(
0x41, 0x04, 0x67, 0x8A, 0xFD, 0xB0, 0xFE, 0x55, 0x48, 0x27, 0x19, 0x67, 0xF1, 0xA6, 0x71, 0x30,
0xB7, 0x10, 0x5C, 0xD6, 0xA8, 0x28, 0xE0, 0x39, 0x09, 0xA6, 0x79, 0x62, 0xE0, 0xEA, 0x1F, 0x61,
0xDE, 0xB6, 0x49, 0xF6, 0xBC, 0x3F, 0x4C, 0xEF, 0x38, 0xC4, 0xF3, 0x55, 0x04, 0xE5, 0x1E, 0xC1,
0x12, 0xDE, 0x5C, 0x38, 0x4D, 0xF7, 0xBA, 0x0B, 0x8D, 0x57, 0x8A, 0x4C, 0x70, 0x2B, 0x6B, 0xF1,
0x1D, 0x5F, 0xAC
)
)
),
lockTime: 0
)
)
);
this._genesisChainedBlock =
new ChainedBlock
(
blockHash: this._genesisBlock.Hash,
previousBlockHash: this._genesisBlock.Header.PreviousBlock,
height: 0,
totalWork: this._genesisBlock.Header.CalculateWork()
);
this._genesisBlockchain =
new Data.Blockchain
(
blockList: ImmutableList.Create(this._genesisChainedBlock),
blockListHashes: ImmutableHashSet.Create(this._genesisBlock.Hash),
utxo: ImmutableDictionary.Create<UInt256, UnspentTx>() // genesis block coinbase is not included in utxo, it is unspendable
);
}
public BlockchainDaemon(IBlockchainRules rules, CacheContext cacheContext)
{
this.shutdownToken = new CancellationTokenSource();
this._rules = rules;
this._cacheContext = cacheContext;
this._calculator = new BlockchainCalculator(this._rules, this._cacheContext, this.shutdownToken.Token);
this._winningBlock = this._rules.GenesisChainedBlock;
this._winningBlockchain = ImmutableArray.Create(this._rules.GenesisChainedBlock);
this.winningBlockchainLock = new ReaderWriterLockSlim();
this._currentBlockchain = this._rules.GenesisBlockchain;
this.currentBlockchainLock = new ReaderWriterLockSlim();
//TODO
this.lastCurrentBlockchainWrite = Guid.NewGuid();
this.missingBlocks = new ConcurrentSetBuilder<UInt256>();
this.unchainedBlocks = new ConcurrentSetBuilder<UInt256>();
this.missingChainedBlocks = new ConcurrentSet<UInt256>();
this.missingTransactions = new ConcurrentSet<UInt256>();
// write genesis block out to storage
this._cacheContext.BlockCache.UpdateValue(this._rules.GenesisBlock.Hash, this._rules.GenesisBlock);
this._cacheContext.ChainedBlockCache.UpdateValue(this._rules.GenesisChainedBlock.BlockHash, this._rules.GenesisChainedBlock);
// wait for genesis block to be flushed
this._cacheContext.BlockCache.WaitForStorageFlush();
this._cacheContext.ChainedBlockCache.WaitForStorageFlush();
// pre-fill the chained block and header caches
//this._cacheContext.BlockHeaderCache.FillCache();
this._cacheContext.ChainedBlockCache.FillCache();
// wire up cache events
this._cacheContext.BlockHeaderCache.OnAddition += OnBlockHeaderAddition;
this._cacheContext.BlockHeaderCache.OnModification += OnBlockHeaderModification;
this._cacheContext.BlockCache.OnAddition += OnBlockAddition;
this._cacheContext.BlockCache.OnModification += OnBlockModification;
this._cacheContext.ChainedBlockCache.OnAddition += OnChainedBlockAddition;
this._cacheContext.ChainedBlockCache.OnModification += OnChainedBlockModification;
this.unchainedBlocks.UnionWith(this.CacheContext.BlockHeaderCache.GetAllKeys());
this.unchainedBlocks.ExceptWith(this.CacheContext.ChainedBlockCache.GetAllKeys());
// create workers
this.chainingWorker = new Worker("BlockchainDaemon.ChainingWorker", ChainingWorker,
runOnStart: true, waitTime: TimeSpan.FromSeconds(1), maxIdleTime: TimeSpan.FromSeconds(30));
this.winnerWorker = new Worker("BlockchainDaemon.WinnerWorker", WinnerWorker,
runOnStart: true, waitTime: TimeSpan.FromSeconds(1), maxIdleTime: TimeSpan.FromSeconds(30));
this.validationWorker = new Worker("BlockchainDaemon.ValidationWorker", ValidationWorker,
runOnStart: true, waitTime: TimeSpan.FromSeconds(10), maxIdleTime: TimeSpan.FromMinutes(5));
this.blockchainWorker = new Worker("BlockchainDaemon.BlockchainWorker", BlockchainWorker,
runOnStart: true, waitTime: TimeSpan.FromSeconds(5), maxIdleTime: TimeSpan.FromMinutes(5));
this.validateCurrentChainWorker = new Worker("BlockchainDaemon.ValidateCurrentChainWorker", ValidateCurrentChainWorker,
runOnStart: true, waitTime: TimeSpan.FromMinutes(30), maxIdleTime: TimeSpan.FromMinutes(30));
this.writeBlockchainWorker = new Worker("BlockchainDaemon.WriteBlockchainWorker", WriteBlockchainWorker,
runOnStart: true, waitTime: TimeSpan.FromMinutes(5), maxIdleTime: TimeSpan.FromMinutes(30));
}
public Testnet2Rules(CacheContext cacheContext)
: base(cacheContext)
{
this._genesisBlock =
new Block
(
header: new BlockHeader
(
version: 1,
previousBlock: 0,
merkleRoot: UInt256.Parse("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b", NumberStyles.HexNumber),
time: 1296688602,
bits: 0x207FFFFF,
nonce: 2
),
transactions: ImmutableArray.Create
(
new Transaction
(
version: 1,
inputs: ImmutableArray.Create
(
new TxInput
(
previousTxOutputKey: new TxOutputKey
(
txHash: 0,
txOutputIndex: 0xFFFFFFFF
),
scriptSignature: ImmutableArray.Create<byte>
(
0x04, 0xFF, 0xFF, 0x00, 0x1D, 0x01, 0x04, 0x45, 0x54, 0x68, 0x65, 0x20, 0x54, 0x69, 0x6D, 0x65,
0x73, 0x20, 0x30, 0x33, 0x2F, 0x4A, 0x61, 0x6E, 0x2F, 0x32, 0x30, 0x30, 0x39, 0x20, 0x43, 0x68,
0x61, 0x6E, 0x63, 0x65, 0x6C, 0x6C, 0x6F, 0x72, 0x20, 0x6F, 0x6E, 0x20, 0x62, 0x72, 0x69, 0x6E,
0x6B, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x62, 0x61, 0x69, 0x6C,
0x6F, 0x75, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x62, 0x61, 0x6E, 0x6B, 0x73
),
sequence: 0xFFFFFFFF
)
),
outputs: ImmutableArray.Create
(
new TxOutput
(
value: (UInt64)(50L * 100.MILLION()),
scriptPublicKey: ImmutableArray.Create<byte>
(
0x41, 0x04, 0x67, 0x8A, 0xFD, 0xB0, 0xFE, 0x55, 0x48, 0x27, 0x19, 0x67, 0xF1, 0xA6, 0x71, 0x30,
0xB7, 0x10, 0x5C, 0xD6, 0xA8, 0x28, 0xE0, 0x39, 0x09, 0xA6, 0x79, 0x62, 0xE0, 0xEA, 0x1F, 0x61,
0xDE, 0xB6, 0x49, 0xF6, 0xBC, 0x3F, 0x4C, 0xEF, 0x38, 0xC4, 0xF3, 0x55, 0x04, 0xE5, 0x1E, 0xC1,
0x12, 0xDE, 0x5C, 0x38, 0x4D, 0xF7, 0xBA, 0x0B, 0x8D, 0x57, 0x8A, 0x4C, 0x70, 0x2B, 0x6B, 0xF1,
0x1D, 0x5F, 0xAC
)
)
),
lockTime: 0
)
)
);
Debug.Assert(_genesisBlock.Hash == UInt256.Parse("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206", NumberStyles.HexNumber));
this._genesisChainedBlock =
new ChainedBlock
(
blockHash: this._genesisBlock.Hash,
previousBlockHash: this._genesisBlock.Header.PreviousBlock,
height: 0,
totalWork: this._genesisBlock.Header.CalculateWork()
);
this._genesisBlockchain =
new Data.Blockchain
(
blockList: ImmutableList.Create(this._genesisChainedBlock),
blockListHashes: ImmutableHashSet.Create(this._genesisBlock.Hash),
utxo: ImmutableDictionary.Create<UInt256, UnspentTx>() // genesis block coinbase is not included in utxo, it is unspendable
);
}
public BlockStorage(CacheContext cacheContext)
{
this._cacheContext = cacheContext;
}
public UnitTestRules(CacheContext cacheContext)
: base(cacheContext)
{
this._highestTarget = Target0;
}
public TransactionCache(CacheContext cacheContext, long maxCacheMemorySize)
: base("TransactionCache", new TransactionStorage(cacheContext), 0, maxCacheMemorySize, Transaction.SizeEstimator)
{
this._cacheContext = cacheContext;
}
public TransactionStorage(CacheContext cacheContext)
{
this._cacheContext = cacheContext;
}
