public void Chaotic_test()
{
const int accountsCount = 100;
CryptoRandom random = new CryptoRandom();
List <AddressWithStorage> addressesWithStorage = new List <AddressWithStorage>();
for (int i = 0; i < accountsCount; i++)
{
AddressWithStorage addressWithStorage = new AddressWithStorage();
addressWithStorage.StorageCells = new StorageCell[i];
byte[] addressBytes = random.GenerateRandomBytes(20);
addressWithStorage.Address = new Address(addressBytes);
for (int j = 0; j < i; j++)
{
byte[] storageIndex = random.GenerateRandomBytes(32);
UInt256 index = new UInt256(storageIndex);
StorageCell storageCell = new StorageCell(addressWithStorage.Address, index);
addressWithStorage.StorageCells[j] = storageCell;
}
addressesWithStorage.Add(addressWithStorage);
}
IDb memDb = new MemDb();
TrieStore trieStore = new TrieStore(memDb, LimboLogs.Instance);
StateTree tree = new StateTree(trieStore, LimboLogs.Instance);
for (int i = 0; i < accountsCount; i++)
{
Account account = Build.An.Account.WithBalance((UInt256)i).TestObject;
StorageTree storageTree = new StorageTree(trieStore, Keccak.EmptyTreeHash, LimboLogs.Instance);
for (int j = 0; j < i; j++)
{
storageTree.Set(addressesWithStorage[i].StorageCells[j].Index, new byte[1] {
1
});
}
storageTree.UpdateRootHash();
storageTree.Commit(0);
account = account.WithChangedStorageRoot(storageTree.RootHash);
tree.Set(addressesWithStorage[i].Address, account);
}
tree.UpdateRootHash();
tree.Commit(0);
for (int i = 0; i < accountsCount; i++)
{
AccountProofCollector collector = new AccountProofCollector(addressesWithStorage[i].Address, addressesWithStorage[i].StorageCells.Select(sc => sc.Index).ToArray());
tree.Accept(collector, tree.RootHash, true);
AccountProof accountProof = collector.BuildResult();
accountProof.Address.Should().Be(addressesWithStorage[i].Address);
accountProof.Balance.Should().Be((UInt256)i);
accountProof.Nonce.Should().Be(0);
accountProof.CodeHash.Should().Be(Keccak.OfAnEmptyString);
if (i != 0)
{
accountProof.StorageRoot.Should().NotBe(Keccak.EmptyTreeHash);
}
accountProof.StorageProofs.Length.Should().Be(i);
for (int j = 0; j < i; j++)
{
byte[] indexBytes = new byte[32];
addressesWithStorage[i].StorageCells[j].Index.ToBigEndian(indexBytes.AsSpan());
accountProof.StorageProofs[j].Key.ToHexString().Should().Be(indexBytes.ToHexString(), $"{i} {j}");
TrieNode node = new TrieNode(NodeType.Unknown, accountProof.StorageProofs[j].Proof.Last());
node.ResolveNode(null);
// TestContext.Write($"|[{i},{j}]");
if (node.Value.Length != 1)
{
TestContext.WriteLine();
TestContext.WriteLine(addressesWithStorage[i].Address);
TestContext.WriteLine(i);
foreach (StorageCell storageCell in addressesWithStorage[i].StorageCells)
{
TestContext.WriteLine("storage: " + storageCell.Index);
}
}
node.Value.Should().BeEquivalentTo(new byte[] { 1 });
}
}
}
public void _Test_storage_failed_case(string historicallyFailingCase)
{
string[] lines = historicallyFailingCase.Split(Environment.NewLine);
int storageCount = lines.Length - 2;
IDb memDb = new MemDb();
TrieStore trieStore = new TrieStore(memDb, LimboLogs.Instance);
StateTree tree = new StateTree(trieStore, LimboLogs.Instance);
Address address = new Address(Bytes.FromHexString(lines[0]));
int accountIndex = int.Parse(lines[1]);
UInt256[] indexes = new UInt256[storageCount];
for (int j = 0; j < storageCount; j++)
{
indexes[j] = UInt256.Parse(lines[j + 2].Replace("storage: ", string.Empty));
}
AddressWithStorage addressWithStorage = new AddressWithStorage();
addressWithStorage.StorageCells = new StorageCell[storageCount];
addressWithStorage.Address = address;
StorageTree storageTree = new StorageTree(trieStore, Keccak.EmptyTreeHash, LimboLogs.Instance);
for (int j = 0; j < storageCount; j++)
{
UInt256 index = UInt256.Parse(lines[j + 2].Replace("storage: ", string.Empty));
StorageCell storageCell = new StorageCell(address, index);
addressWithStorage.StorageCells[j] = storageCell;
byte[] rawKey = new byte[32];
addressWithStorage.StorageCells[j].Index.ToBigEndian(rawKey);
TestContext.WriteLine($"Set {Keccak.Compute(rawKey).Bytes.ToHexString()}");
storageTree.Set(addressWithStorage.StorageCells[j].Index, new byte[] { 1 });
storageTree.UpdateRootHash();
storageTree.Commit(0);
}
Account account = Build.An.Account.WithBalance((UInt256)accountIndex).WithStorageRoot(storageTree.RootHash).TestObject;
tree.Set(addressWithStorage.Address, account);
tree.UpdateRootHash();
tree.Commit(0);
TreeDumper treeDumper = new TreeDumper();
tree.Accept(treeDumper, tree.RootHash, true);
TestContext.WriteLine(treeDumper.ToString());
AccountProofCollector collector = new AccountProofCollector(address, indexes);
tree.Accept(collector, tree.RootHash, true);
AccountProof accountProof = collector.BuildResult();
accountProof.Address.Should().Be(address);
accountProof.Balance.Should().Be((UInt256)accountIndex);
accountProof.Nonce.Should().Be(0);
accountProof.CodeHash.Should().Be(Keccak.OfAnEmptyString);
if (accountIndex != 0)
{
accountProof.StorageRoot.Should().NotBe(Keccak.EmptyTreeHash);
}
accountProof.StorageProofs.Length.Should().Be(accountIndex);
for (int j = 0; j < accountProof.StorageProofs.Length; j++)
{
TrieNode node = new TrieNode(NodeType.Unknown, accountProof.StorageProofs[j].Proof.Last());
node.ResolveNode(new TrieStore(memDb, NullLogManager.Instance));
if (node.Value.Length != 1)
{
TestContext.WriteLine($"{j}");
// throw new InvalidDataException($"{j}");
}
}
}
