/// <summary>
///
/// </summary>
/// <param name="interceptor"></param>
/// <returns></returns>
public ISession OpenSession(IInterceptor interceptor)
{
long timestamp = Timestamper.Next();
// specify true for autoClose because NHibernate has responsibility for
// the IDbConnection.
return(OpenSession(null, true, timestamp, interceptor));
}
// TODO: Try to understand what this is for and how it's used.
public long NextTimestamp()
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("NextTimestamp() invoked in region '{0}'.", _regionAlphaNumeric);
}
return(Timestamper.Next());
}
private async Task AddBlockInternal(params Transaction[] transactions)
{
await _oneAtATime.WaitOneAsync(CancellationToken.None);
foreach (Transaction transaction in transactions)
{
TxPool.AddTransaction(transaction, TxHandlingOptions.None);
}
Timestamper.Add(TimeSpan.FromSeconds(1));
BlockProducer.BuildNewBlock();
}
public void epoch_timestamp_in_seconds_and_milliseconds_should_be_valid()
{
var utcNow = DateTime.UtcNow;
var timestamper = new Timestamper(utcNow);
var epochSeconds = timestamper.EpochSeconds;
var epochMilliseconds = timestamper.EpochMilliseconds;
var unixUtcUntilNowSeconds = (ulong)utcNow.Subtract(Jan1St1970).TotalSeconds;
var unixUtcUntilNowMilliseconds = (ulong)utcNow.Subtract(Jan1St1970).TotalMilliseconds;
epochSeconds.Should().Be(unixUtcUntilNowSeconds);
epochMilliseconds.Should().Be(unixUtcUntilNowMilliseconds);
}
public void AsyncOperationsThrow()
{
var cache = new HashtableCacheProvider().BuildCache("region", new Dictionary <string, string>());
var strategy = CreateCache(cache);
CacheKey key = CreateCacheKey("key");
var stamp = Timestamper.Next();
Assert.ThrowsAsync <InvalidOperationException>(
() =>
strategy.PutAsync(key, "value", stamp, 0, null, false, default(CancellationToken)));
Assert.ThrowsAsync <InvalidOperationException>(() => strategy.GetAsync(key, stamp, default(CancellationToken)));
}
public void should_mark_transaction_as_removable()
{
var utcNow = DateTime.UtcNow;
var validator = GetValidator();
var timestamp = new Timestamper(utcNow);
var transaction1 = GetTransaction(utcNow, 5);
var transaction2 = GetTransaction(utcNow, 600);
var transaction3 = GetTransaction(utcNow, 1000);
var currentTimestamp = new UInt256(timestamp.EpochSeconds);
validator.IsRemovable(currentTimestamp, transaction1.Timestamp).Should().BeFalse();
validator.IsRemovable(currentTimestamp, transaction2.Timestamp).Should().BeFalse();
validator.IsRemovable(currentTimestamp, transaction3.Timestamp).Should().BeTrue();
}
public void VerifyIncrease()
{
long currentTicks = 0;
long newTicks = 0;
// the Timestampper will only generate 4095 increasing identifiers per millisecond.
for (int i = 0; i < 4095; i++)
{
newTicks = Timestamper.Next();
if ((newTicks - currentTicks) == 0)
{
Assert.Fail("diff was " + (newTicks - currentTicks) + ". It should always increase. Loop i=" + i +
" with currentTicks = " + currentTicks + " and newTicks = " + newTicks);
}
currentTicks = newTicks;
}
}
public void epoch_timestamp_in_seconds_and_milliseconds_should_be_valid()
{
// very strange fail once:
// Failed epoch_timestamp_in_seconds_and_milliseconds_should_be_valid [317 ms]
// Error Message:
// Expected value to be 1613321574133UL, but found 1613321574132UL.
DateTime utcNow = DateTime.UtcNow;
ITimestamper timestamper = new Timestamper(utcNow);
ulong epochSeconds = timestamper.UnixTime.Seconds;
ulong epochMilliseconds = timestamper.UnixTime.Milliseconds;
ulong unixUtcUntilNowSeconds = (ulong)utcNow.Subtract(Jan1St1970).TotalSeconds;
ulong unixUtcUntilNowMilliseconds = (ulong)utcNow.Subtract(Jan1St1970).TotalMilliseconds;
epochSeconds.Should().Be(unixUtcUntilNowSeconds);
epochMilliseconds.Should().Be(unixUtcUntilNowMilliseconds);
}
/// <summary>
/// Generate a timestamp
/// </summary>
/// <returns>a timestamp</returns>
public long NextTimestamp()
{
return(Timestamper.Next());
}
public async Task Can_process_mined_blocks()
{
int timeMultiplier = 1; // for debugging
TimeSpan miningDelay = TimeSpan.FromMilliseconds(50 * timeMultiplier);
/* logging & instrumentation */
// OneLoggerLogManager logger = new OneLoggerLogManager(new SimpleConsoleLogger(true));
ILogManager logManager = NullLogManager.Instance;
ILogger logger = logManager.GetClassLogger();
/* spec */
FakeSealer sealer = new FakeSealer(miningDelay);
RopstenSpecProvider specProvider = RopstenSpecProvider.Instance;
/* state & storage */
StateDb codeDb = new StateDb();
StateDb stateDb = new StateDb();
StateProvider stateProvider = new StateProvider(stateDb, codeDb, logManager);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, logManager);
/* store & validation */
EthereumEcdsa ecdsa = new EthereumEcdsa(specProvider, logManager);
MemDb receiptsDb = new MemDb();
MemDb traceDb = new MemDb();
TxPool txPool = new TxPool(NullTxStorage.Instance, Timestamper.Default, ecdsa, specProvider, new TxPoolConfig(), stateProvider, logManager);
IReceiptStorage receiptStorage = new PersistentReceiptStorage(receiptsDb, specProvider, logManager);
var blockInfoDb = new MemDb();
BlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, txPool, logManager);
Timestamper timestamper = new Timestamper();
DifficultyCalculator difficultyCalculator = new DifficultyCalculator(specProvider);
HeaderValidator headerValidator = new HeaderValidator(blockTree, sealer, specProvider, logManager);
OmmersValidator ommersValidator = new OmmersValidator(blockTree, headerValidator, logManager);
TxValidator txValidator = new TxValidator(ChainId.Ropsten);
BlockValidator blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, logManager);
TestTransactionsGenerator generator = new TestTransactionsGenerator(txPool, ecdsa, TimeSpan.FromMilliseconds(5 * timeMultiplier), NullLogManager.Instance);
generator.Start();
/* blockchain processing */
BlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, logManager);
TransactionProcessor processor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, logManager);
RewardCalculator rewardCalculator = new RewardCalculator(specProvider);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator,
processor, stateDb, codeDb, traceDb, stateProvider, storageProvider, txPool, receiptStorage, logManager);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, new TxSignaturesRecoveryStep(ecdsa, NullTxPool.Instance, LimboLogs.Instance), logManager, false, false);
/* load ChainSpec and init */
ChainSpecLoader loader = new ChainSpecLoader(new EthereumJsonSerializer());
string path = "chainspec.json";
logManager.GetClassLogger().Info($"Loading ChainSpec from {path}");
ChainSpec chainSpec = loader.Load(File.ReadAllText(path));
foreach (var allocation in chainSpec.Allocations)
{
stateProvider.CreateAccount(allocation.Key, allocation.Value.Balance);
if (allocation.Value.Code != null)
{
Keccak codeHash = stateProvider.UpdateCode(allocation.Value.Code);
stateProvider.UpdateCodeHash(allocation.Key, codeHash, specProvider.GenesisSpec);
}
}
stateProvider.Commit(specProvider.GenesisSpec);
chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot; // TODO: shall it be HeaderSpec and not BlockHeader?
chainSpec.Genesis.Header.Hash = BlockHeader.CalculateHash(chainSpec.Genesis.Header);
if (chainSpec.Genesis.Hash != new Keccak("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"))
{
throw new Exception("Unexpected genesis hash");
}
/* start processing */
blockTree.SuggestBlock(chainSpec.Genesis);
blockchainProcessor.Start();
MinedBlockProducer minedBlockProducer = new MinedBlockProducer(difficultyCalculator, txPool, blockchainProcessor, sealer, blockTree, timestamper, NullLogManager.Instance);
minedBlockProducer.Start();
ManualResetEventSlim manualResetEvent = new ManualResetEventSlim(false);
blockTree.NewHeadBlock += (sender, args) =>
{
if (args.Block.Number == 6)
{
manualResetEvent.Set();
}
};
manualResetEvent.Wait(miningDelay * 12 * timeMultiplier);
await minedBlockProducer.StopAsync();
int previousCount = 0;
int totalTx = 0;
for (int i = 0; i < 6; i++)
{
Block block = blockTree.FindBlock(i, BlockTreeLookupOptions.None);
logger.Info($"Block {i} with {block.Transactions.Length} txs");
ManualResetEventSlim blockProcessedEvent = new ManualResetEventSlim(false);
blockchainProcessor.ProcessingQueueEmpty += (sender, args) => blockProcessedEvent.Set();
blockchainProcessor.SuggestBlock(block, ProcessingOptions.ForceProcessing | ProcessingOptions.StoreReceipts | ProcessingOptions.ReadOnlyChain);
blockProcessedEvent.Wait(1000);
Tracer tracer = new Tracer(blockchainProcessor, receiptStorage, blockTree, new MemDb());
int currentCount = receiptsDb.Keys.Count;
logger.Info($"Current count of receipts {currentCount}");
logger.Info($"Previous count of receipts {previousCount}");
if (block.Transactions.Length > 0)
{
GethLikeTxTrace trace = tracer.Trace(block.Transactions[0].Hash, GethTraceOptions.Default);
Assert.AreSame(GethLikeTxTrace.QuickFail, trace);
Assert.AreNotEqual(previousCount, currentCount, $"receipts at block {i}");
totalTx += block.Transactions.Length;
}
previousCount = currentCount;
}
Assert.AreNotEqual(0, totalTx, "no tx in blocks");
}
/// <inheritdoc />
public override long NextTimestamp()
{
return(Timestamper.Next());
}
public async Task DoTestCacheAsync(ICacheProvider cacheProvider, CancellationToken cancellationToken = default(CancellationToken))
{
ICache cache = cacheProvider.BuildCache(typeof(String).FullName, new Dictionary <string, string>());
long longBefore = Timestamper.Next();
await(Task.Delay(15, cancellationToken));
long before = Timestamper.Next();
await(Task.Delay(15, cancellationToken));
ICacheConcurrencyStrategy ccs = new ReadWriteCache();
ccs.Cache = cache;
// cache something
CacheKey fooKey = CreateCacheKey("foo");
Assert.IsTrue(await(ccs.PutAsync(fooKey, "foo", before, null, null, false, cancellationToken)));
await(Task.Delay(15, cancellationToken));
long after = Timestamper.Next();
Assert.IsNull(await(ccs.GetAsync(fooKey, longBefore, cancellationToken)));
Assert.AreEqual("foo", await(ccs.GetAsync(fooKey, after, cancellationToken)));
Assert.IsFalse(await(ccs.PutAsync(fooKey, "foo", before, null, null, false, cancellationToken)));
// update it;
ISoftLock fooLock = await(ccs.LockAsync(fooKey, null, cancellationToken));
Assert.IsNull(await(ccs.GetAsync(fooKey, after, cancellationToken)));
Assert.IsNull(await(ccs.GetAsync(fooKey, longBefore, cancellationToken)));
Assert.IsFalse(await(ccs.PutAsync(fooKey, "foo", before, null, null, false, cancellationToken)));
await(Task.Delay(15, cancellationToken));
long whileLocked = Timestamper.Next();
Assert.IsFalse(await(ccs.PutAsync(fooKey, "foo", whileLocked, null, null, false, cancellationToken)));
await(Task.Delay(15, cancellationToken));
await(ccs.ReleaseAsync(fooKey, fooLock, cancellationToken));
Assert.IsNull(await(ccs.GetAsync(fooKey, after, cancellationToken)));
Assert.IsNull(await(ccs.GetAsync(fooKey, longBefore, cancellationToken)));
Assert.IsFalse(await(ccs.PutAsync(fooKey, "bar", whileLocked, null, null, false, cancellationToken)));
Assert.IsFalse(await(ccs.PutAsync(fooKey, "bar", after, null, null, false, cancellationToken)));
await(Task.Delay(15, cancellationToken));
long longAfter = Timestamper.Next();
Assert.IsTrue(await(ccs.PutAsync(fooKey, "baz", longAfter, null, null, false, cancellationToken)));
Assert.IsNull(await(ccs.GetAsync(fooKey, after, cancellationToken)));
Assert.IsNull(await(ccs.GetAsync(fooKey, whileLocked, cancellationToken)));
await(Task.Delay(15, cancellationToken));
long longLongAfter = Timestamper.Next();
Assert.AreEqual("baz", await(ccs.GetAsync(fooKey, longLongAfter, cancellationToken)));
// update it again, with multiple locks
ISoftLock fooLock1 = await(ccs.LockAsync(fooKey, null, cancellationToken));
ISoftLock fooLock2 = await(ccs.LockAsync(fooKey, null, cancellationToken));
Assert.IsNull(await(ccs.GetAsync(fooKey, longLongAfter, cancellationToken)));
await(Task.Delay(15, cancellationToken));
whileLocked = Timestamper.Next();
Assert.IsFalse(await(ccs.PutAsync(fooKey, "foo", whileLocked, null, null, false, cancellationToken)));
await(Task.Delay(15, cancellationToken));
await(ccs.ReleaseAsync(fooKey, fooLock2, cancellationToken));
await(Task.Delay(15, cancellationToken));
long betweenReleases = Timestamper.Next();
Assert.IsFalse(await(ccs.PutAsync(fooKey, "bar", betweenReleases, null, null, false, cancellationToken)));
Assert.IsNull(await(ccs.GetAsync(fooKey, betweenReleases, cancellationToken)));
await(Task.Delay(15, cancellationToken));
await(ccs.ReleaseAsync(fooKey, fooLock1, cancellationToken));
Assert.IsFalse(await(ccs.PutAsync(fooKey, "bar", whileLocked, null, null, false, cancellationToken)));
await(Task.Delay(15, cancellationToken));
longAfter = Timestamper.Next();
Assert.IsTrue(await(ccs.PutAsync(fooKey, "baz", longAfter, null, null, false, cancellationToken)));
Assert.IsNull(await(ccs.GetAsync(fooKey, whileLocked, cancellationToken)));
await(Task.Delay(15, cancellationToken));
longLongAfter = Timestamper.Next();
Assert.AreEqual("baz", await(ccs.GetAsync(fooKey, longLongAfter, cancellationToken)));
}
/// <summary>
/// Generate a timestamp
/// </summary>
/// <returns></returns>
public virtual long NextTimestamp()
{
return(Timestamper.Next());
}
public void DoTestCache(ICacheProvider cacheProvider)
{
ICache cache = cacheProvider.BuildCache(typeof(String).FullName, new Dictionary <string, string>());
long longBefore = Timestamper.Next();
Thread.Sleep(15);
long before = Timestamper.Next();
Thread.Sleep(15);
ICacheConcurrencyStrategy ccs = new ReadWriteCache();
ccs.Cache = cache;
// cache something
CacheKey fooKey = CreateCacheKey("foo");
Assert.IsTrue(ccs.Put(fooKey, "foo", before, null, null, false));
Thread.Sleep(15);
long after = Timestamper.Next();
Assert.IsNull(ccs.Get(fooKey, longBefore));
Assert.AreEqual("foo", ccs.Get(fooKey, after));
Assert.IsFalse(ccs.Put(fooKey, "foo", before, null, null, false));
// update it;
ISoftLock fooLock = ccs.Lock(fooKey, null);
Assert.IsNull(ccs.Get(fooKey, after));
Assert.IsNull(ccs.Get(fooKey, longBefore));
Assert.IsFalse(ccs.Put(fooKey, "foo", before, null, null, false));
Thread.Sleep(15);
long whileLocked = Timestamper.Next();
Assert.IsFalse(ccs.Put(fooKey, "foo", whileLocked, null, null, false));
Thread.Sleep(15);
ccs.Release(fooKey, fooLock);
Assert.IsNull(ccs.Get(fooKey, after));
Assert.IsNull(ccs.Get(fooKey, longBefore));
Assert.IsFalse(ccs.Put(fooKey, "bar", whileLocked, null, null, false));
Assert.IsFalse(ccs.Put(fooKey, "bar", after, null, null, false));
Thread.Sleep(15);
long longAfter = Timestamper.Next();
Assert.IsTrue(ccs.Put(fooKey, "baz", longAfter, null, null, false));
Assert.IsNull(ccs.Get(fooKey, after));
Assert.IsNull(ccs.Get(fooKey, whileLocked));
Thread.Sleep(15);
long longLongAfter = Timestamper.Next();
Assert.AreEqual("baz", ccs.Get(fooKey, longLongAfter));
// update it again, with multiple locks
ISoftLock fooLock1 = ccs.Lock(fooKey, null);
ISoftLock fooLock2 = ccs.Lock(fooKey, null);
Assert.IsNull(ccs.Get(fooKey, longLongAfter));
Thread.Sleep(15);
whileLocked = Timestamper.Next();
Assert.IsFalse(ccs.Put(fooKey, "foo", whileLocked, null, null, false));
Thread.Sleep(15);
ccs.Release(fooKey, fooLock2);
Thread.Sleep(15);
long betweenReleases = Timestamper.Next();
Assert.IsFalse(ccs.Put(fooKey, "bar", betweenReleases, null, null, false));
Assert.IsNull(ccs.Get(fooKey, betweenReleases));
Thread.Sleep(15);
ccs.Release(fooKey, fooLock1);
Assert.IsFalse(ccs.Put(fooKey, "bar", whileLocked, null, null, false));
Thread.Sleep(15);
longAfter = Timestamper.Next();
Assert.IsTrue(ccs.Put(fooKey, "baz", longAfter, null, null, false));
Assert.IsNull(ccs.Get(fooKey, whileLocked));
Thread.Sleep(15);
longLongAfter = Timestamper.Next();
Assert.AreEqual("baz", ccs.Get(fooKey, longLongAfter));
}
/// <inheritdoc /> public override long NextTimestamp() => Timestamper.Next();
