public void Keep_in_cache()
{
StateProvider provider = new StateProvider(new StateDb(new MemDb()), Substitute.For <IDb>(), Logger);
provider.CreateAccount(_address1, 0);
provider.Commit(Frontier.Instance);
provider.GetBalance(_address1);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.Restore(-1);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.Restore(-1);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.Restore(-1);
Assert.AreEqual(UInt256.Zero, provider.GetBalance(_address1));
}
public async Task Can_ask_about_storage_in_parallel()
{
StorageCell storageCell = new StorageCell(_address1, UInt256.One);
IReleaseSpec spec = MuirGlacier.Instance;
MemDb stateDb = new MemDb();
TrieStore trieStore = new TrieStore(stateDb, Logger);
StateProvider provider = new StateProvider(trieStore, new MemDb(), Logger);
StorageProvider storageProvider = new StorageProvider(trieStore, provider, Logger);
void UpdateStorageValue(byte[] newValue)
{
storageProvider.Set(storageCell, newValue);
}
void AddOneToBalance()
{
provider.AddToBalance(_address1, 1, spec);
}
void CommitEverything()
{
storageProvider.Commit();
storageProvider.CommitTrees(0);
provider.Commit(spec);
provider.CommitTree(0);
}
provider.CreateAccount(_address1, 1);
CommitEverything();
AddOneToBalance();
UpdateStorageValue(new byte[] { 1 });
CommitEverything();
Keccak stateRoot0 = provider.StateRoot;
AddOneToBalance();
UpdateStorageValue(new byte[] { 2 });
CommitEverything();
Keccak stateRoot1 = provider.StateRoot;
AddOneToBalance();
UpdateStorageValue(new byte[] { 3 });
CommitEverything();
Keccak stateRoot2 = provider.StateRoot;
AddOneToBalance();
UpdateStorageValue(new byte[] { 4 });
CommitEverything();
Keccak stateRoot3 = provider.StateRoot;
StateReader reader =
new StateReader(new TrieStore(stateDb, LimboLogs.Instance), Substitute.For <IDb>(), Logger);
Task a = StartStorageTask(reader, stateRoot0, storageCell, new byte[] { 1 });
Task b = StartStorageTask(reader, stateRoot1, storageCell, new byte[] { 2 });
Task c = StartStorageTask(reader, stateRoot2, storageCell, new byte[] { 3 });
Task d = StartStorageTask(reader, stateRoot3, storageCell, new byte[] { 4 });
await Task.WhenAll(a, b, c, d);
}
public async Task Can_ask_about_balance_in_parallel()
{
IReleaseSpec spec = MainnetSpecProvider.Instance.GetSpec(MainnetSpecProvider.ConstantinopleFixBlockNumber);
MemDb stateDb = new MemDb();
StateProvider provider =
new StateProvider(new TrieStore(stateDb, Logger), Substitute.For <IDb>(), Logger);
provider.CreateAccount(_address1, 0);
provider.AddToBalance(_address1, 1, spec);
provider.Commit(spec);
provider.CommitTree(0);
Keccak stateRoot0 = provider.StateRoot;
provider.AddToBalance(_address1, 1, spec);
provider.Commit(spec);
provider.CommitTree(0);
Keccak stateRoot1 = provider.StateRoot;
provider.AddToBalance(_address1, 1, spec);
provider.Commit(spec);
provider.CommitTree(0);
Keccak stateRoot2 = provider.StateRoot;
provider.AddToBalance(_address1, 1, spec);
provider.Commit(spec);
provider.CommitTree(0);
Keccak stateRoot3 = provider.StateRoot;
provider.CommitTree(0);
StateReader reader =
new StateReader(new TrieStore(stateDb, LimboLogs.Instance), Substitute.For <IDb>(), Logger);
Task a = StartTask(reader, stateRoot0, 1);
Task b = StartTask(reader, stateRoot1, 2);
Task c = StartTask(reader, stateRoot2, 3);
Task d = StartTask(reader, stateRoot3, 4);
await Task.WhenAll(a, b, c, d);
}
public void Eip_158_zero_value_transfer_deletes()
{
StateTree tree = new StateTree(new MemDb());
StateProvider frontierProvider = new StateProvider(tree, Substitute.For <IDb>(), Logger);
frontierProvider.CreateAccount(_address1, 0);
frontierProvider.Commit(Frontier.Instance);
StateProvider provider = new StateProvider(tree, Substitute.For <IDb>(), Logger);
provider.AddToBalance(_address1, 0, SpuriousDragon.Instance);
provider.Commit(SpuriousDragon.Instance);
Assert.False(provider.AccountExists(_address1));
}
public void Touch_empty_trace_does_not_throw()
{
ParityLikeTxTracer tracer = new ParityLikeTxTracer(Build.A.Block.TestObject, null, ParityTraceTypes.StateDiff);
StateProvider provider = new StateProvider(new StateDb(new MemDb()), Substitute.For <IDb>(), Logger);
provider.CreateAccount(_address1, 0);
Account account = provider.GetAccount(_address1);
Assert.True(account.IsEmpty);
provider.Commit(Frontier.Instance); // commit empty account (before the empty account fix in Spurious Dragon)
Assert.True(provider.AccountExists(_address1));
provider.Reset(); // clear all caches
provider.GetBalance(_address1); // justcache
provider.AddToBalance(_address1, 0, SpuriousDragon.Instance); // touch
Assert.DoesNotThrow(() => provider.Commit(SpuriousDragon.Instance, tracer));
}
public void Eip_158_zero_value_transfer_deletes()
{
var trieStore = new TrieStore(new MemDb(), Logger);
StateProvider frontierProvider = new StateProvider(trieStore, _codeDb, Logger);
frontierProvider.CreateAccount(_address1, 0);
frontierProvider.Commit(Frontier.Instance);
frontierProvider.CommitTree(0);
StateProvider provider = new StateProvider(trieStore, _codeDb, Logger);
provider.StateRoot = frontierProvider.StateRoot;
provider.AddToBalance(_address1, 0, SpuriousDragon.Instance);
provider.Commit(SpuriousDragon.Instance);
Assert.False(provider.AccountExists(_address1));
_codeDb = Substitute.For <IDb>();
}
public void Restore_in_the_middle()
{
byte[] code = new byte[] { 1 };
StateProvider provider = new StateProvider(new StateDb(new MemDb()), Substitute.For <IDb>(), Logger);
provider.CreateAccount(_address1, 1);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.IncrementNonce(_address1);
Keccak codeHash = provider.UpdateCode(new byte[] { 1 });
provider.UpdateCodeHash(_address1, codeHash, Frontier.Instance);
provider.UpdateStorageRoot(_address1, Hash2);
Assert.AreEqual(UInt256.One, provider.GetNonce(_address1));
Assert.AreEqual(UInt256.One + 1, provider.GetBalance(_address1));
Assert.AreEqual(code, provider.GetCode(_address1));
provider.Restore(4);
Assert.AreEqual(UInt256.One, provider.GetNonce(_address1));
Assert.AreEqual(UInt256.One + 1, provider.GetBalance(_address1));
Assert.AreEqual(code, provider.GetCode(_address1));
provider.Restore(3);
Assert.AreEqual(UInt256.One, provider.GetNonce(_address1));
Assert.AreEqual(UInt256.One + 1, provider.GetBalance(_address1));
Assert.AreEqual(code, provider.GetCode(_address1));
provider.Restore(2);
Assert.AreEqual(UInt256.One, provider.GetNonce(_address1));
Assert.AreEqual(UInt256.One + 1, provider.GetBalance(_address1));
Assert.AreEqual(new byte[0], provider.GetCode(_address1));
provider.Restore(1);
Assert.AreEqual(UInt256.Zero, provider.GetNonce(_address1));
Assert.AreEqual(UInt256.One + 1, provider.GetBalance(_address1));
Assert.AreEqual(new byte[0], provider.GetCode(_address1));
provider.Restore(0);
Assert.AreEqual(UInt256.Zero, provider.GetNonce(_address1));
Assert.AreEqual(UInt256.One, provider.GetBalance(_address1));
Assert.AreEqual(new byte[0], provider.GetCode(_address1));
provider.Restore(-1);
Assert.AreEqual(false, provider.AccountExists(_address1));
}
public void Restore_update_restore()
{
StateProvider provider = new StateProvider(new StateDb(new MemDb()), Substitute.For <IDb>(), Logger);
provider.CreateAccount(_address1, 0);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.Restore(4);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.Restore(4);
Assert.AreEqual((UInt256)4, provider.GetBalance(_address1));
}
public void Update_balance_on_non_existing_acccount_throws()
{
StateProvider provider = new StateProvider(new StateDb(new MemDb()), Substitute.For <IDb>(), Logger);
Assert.Throws <InvalidOperationException>(() => provider.AddToBalance(TestItem.AddressA, 1.Ether(), Olympic.Instance));
}
// [TestCase(8, 32, 8, 1543322391)]
public void Fuzz_accounts_with_storage(
int accountsCount,
int blocksCount,
int lookupLimit,
int?seed)
{
int usedSeed = seed ?? _random.Next(int.MaxValue);
_random = new Random(usedSeed);
_logger.Info($"RANDOM SEED {usedSeed}");
string fileName = Path.GetTempFileName();
//string fileName = "C:\\Temp\\fuzz.txt";
_logger.Info(
$"Fuzzing with accounts: {accountsCount}, " +
$"blocks {blocksCount}, " +
$"lookup: {lookupLimit} into file {fileName}");
using FileStream fileStream = new FileStream(fileName, FileMode.Create);
using StreamWriter streamWriter = new StreamWriter(fileStream);
Queue <Keccak> rootQueue = new Queue <Keccak>();
MemDb memDb = new MemDb();
TrieStore trieStore = new TrieStore(memDb, Prune.WhenCacheReaches(1.MB()), Persist.IfBlockOlderThan(lookupLimit), _logManager);
StateProvider stateProvider = new StateProvider(trieStore, new MemDb(), _logManager);
StorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, _logManager);
Account[] accounts = new Account[accountsCount];
Address[] addresses = new Address[accountsCount];
for (int i = 0; i < accounts.Length; i++)
{
bool isEmptyValue = _random.Next(0, 2) == 0;
if (isEmptyValue)
{
accounts[i] = Account.TotallyEmpty;
}
else
{
accounts[i] = GenerateRandomAccount();
}
addresses[i] = TestItem.GetRandomAddress(_random);
}
for (int blockNumber = 0; blockNumber < blocksCount; blockNumber++)
{
bool isEmptyBlock = _random.Next(5) == 0;
if (!isEmptyBlock)
{
for (int i = 0; i < Math.Max(1, accountsCount / 8); i++)
{
int randomAddressIndex = _random.Next(addresses.Length);
int randomAccountIndex = _random.Next(accounts.Length);
Address address = addresses[randomAddressIndex];
Account account = accounts[randomAccountIndex];
if (stateProvider.AccountExists(address))
{
Account existing = stateProvider.GetAccount(address);
if (existing.Balance != account.Balance)
{
if (account.Balance > existing.Balance)
{
stateProvider.AddToBalance(
address, account.Balance - existing.Balance, MuirGlacier.Instance);
}
else
{
stateProvider.SubtractFromBalance(
address, existing.Balance - account.Balance, MuirGlacier.Instance);
}
stateProvider.IncrementNonce(address);
}
byte[] storage = new byte[1];
_random.NextBytes(storage);
storageProvider.Set(new StorageCell(address, 1), storage);
}
else if (!account.IsTotallyEmpty)
{
stateProvider.CreateAccount(address, account.Balance);
byte[] storage = new byte[1];
_random.NextBytes(storage);
storageProvider.Set(new StorageCell(address, 1), storage);
}
}
}
streamWriter.WriteLine(
$"Commit block {blockNumber} | empty: {isEmptyBlock}");
storageProvider.Commit();
stateProvider.Commit(MuirGlacier.Instance);
storageProvider.CommitTrees(blockNumber);
stateProvider.CommitTree(blockNumber);
rootQueue.Enqueue(stateProvider.StateRoot);
}
streamWriter.Flush();
fileStream.Seek(0, SeekOrigin.Begin);
streamWriter.WriteLine($"DB size: {memDb.Keys.Count}");
_logger.Info($"DB size: {memDb.Keys.Count}");
int verifiedBlocks = 0;
while (rootQueue.TryDequeue(out Keccak currentRoot))
{
try
{
stateProvider.StateRoot = currentRoot;
for (int i = 0; i < addresses.Length; i++)
{
Account account = stateProvider.GetAccount(addresses[i]);
if (account != null)
{
for (int j = 0; j < 256; j++)
{
storageProvider.Get(new StorageCell(addresses[i], (UInt256)j));
}
}
}
_logger.Info($"Verified positive {verifiedBlocks}");
}
catch (Exception ex)
{
if (verifiedBlocks % lookupLimit == 0)
{
throw new InvalidDataException(ex.ToString());
}
else
{
_logger.Info($"Verified negative {verifiedBlocks} which is ok here");
}
}
verifiedBlocks++;
}
}