public void Does_not_fail_when_proofs_are_longer_than_number_of_proofs_regression()
{
byte[] a = Bytes.FromHexString("0x000000000000000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaa");
byte[] b = Bytes.FromHexString("0x0000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
byte[] c = Bytes.FromHexString("0x00000000001ccccccccccccccccccccccccccccccccccccccccccccccccccccc");
byte[] d = Bytes.FromHexString("0x00000000001ddddddddddddddddddddddddddddddddddddddddddddddddddddd");
byte[] e = Bytes.FromHexString("0x00000000001eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
IDb memDb = new MemDb();
StateTree tree = new StateTree(memDb);
StorageTree storageTree = new StorageTree(memDb);
storageTree.Set(Keccak.Compute(a).Bytes, Rlp.Encode(Bytes.FromHexString("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(b).Bytes, Rlp.Encode(Bytes.FromHexString("0xab34000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(c).Bytes, Rlp.Encode(Bytes.FromHexString("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(d).Bytes, Rlp.Encode(Bytes.FromHexString("0xab78000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(e).Bytes, Rlp.Encode(Bytes.FromHexString("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Commit();
byte[] code = new byte[] { 1, 2, 3 };
Account account1 = Build.An.Account.WithBalance(1).WithStorageRoot(storageTree.RootHash).TestObject;
Account account2 = Build.An.Account.WithBalance(2).TestObject;
tree.Set(TestItem.AddressA, account1);
tree.Set(TestItem.AddressB, account2);
tree.Commit();
AccountProofCollector accountProofCollector = new AccountProofCollector(TestItem.AddressA, new byte[][] { a });
tree.Accept(accountProofCollector, tree.RootHash, true);
AccountProof proof = accountProofCollector.BuildResult();
TestToJson(proof, "{\"accountProof\":[\"0xe215a08c9a7cdf08d4425c138ef5ba3d1f6c2ae18786fe88d9a56230a00b3e83367b25\",\"0xf8518080808080a017934c1c90ce30ca48f32b4f449dab308cfba803fd6d142cab01eb1fad1b70038080808080808080a02352504a0cd6095829b18bae394d0c882d84eead7be5b6ad0a87daaff9d2fb4a8080\",\"0xf869a020227dead52ea912e013e7641ccd6b3b174498e55066b0c174a09c8c3cc4bf5eb846f8448001a0b2375a34ff2c8037d9ff04ebc16367b51d156d9a905ca54cef50bfad1a4c0711a0c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470\"],\"address\":\"0xb7705ae4c6f81b66cdb323c65f4e8133690fc099\",\"balance\":\"0x1\",\"codeHash\":\"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470\",\"nonce\":\"0x0\",\"storageHash\":\"0xb2375a34ff2c8037d9ff04ebc16367b51d156d9a905ca54cef50bfad1a4c0711\",\"storageProof\":[{\"key\":\"0x000000000000000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaa\",\"proof\":[\"0xf8918080a02474007b0486d5e951fe3fbcdae3e63cadf9c85cb8f178d3c7ca972e2d77705a808080808080a059c4fa21a1e4c40dc3c87e925befbb78a5b6f729865a12f6f0490d9801bcbf22a06b3576bbd6c91ca7128f69f728f3e30bf8980c6381430a5e80186d0dfec89d4e8080a098cfc3bf071c19a2e230165f4152bb98a5d1ab0fee47c952de65da85fcbdfdb2808080\",\"0xf85180a0aec9a5fc3ba2ebedf137fbcf6987b303c9d8718f75253e6e2444b81a4049e5b980808080808080808080a0397f22cb0ad24543caffaad031e3a0a538e5d8ac106d8f6858a703d442c0e4d380808080\",\"0xf84ca02046d62176084b9d1eace1c8bcc2353228d10569a500ccfd1bdbd8c093f4b4e9aaa9ab12000000000000000000000000000000000000000000000000000000000000000000000000000000\"],\"value\":\"0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000\"}]}");
}
public void Storage_trie_set_reset_with_short_zero()
{
StorageTree tree = new StorageTree(new TrieStore(new MemDb(), LimboLogs.Instance), Keccak.EmptyTreeHash, LimboLogs.Instance);
Keccak rootBefore = tree.RootHash;
tree.Set(1, new byte[] { 1 });
tree.Set(1, new byte[] { 0 });
tree.UpdateRootHash();
Keccak rootAfter = tree.RootHash;
Assert.AreEqual(rootBefore, rootAfter);
}
public void Storage_trie_set_reset_with_short_zero()
{
StorageTree tree = new StorageTree(new MemDb());
Keccak rootBefore = tree.RootHash;
tree.Set(1, new byte[] { 1 });
tree.Set(1, new byte[] { 0 });
tree.UpdateRootHash();
Keccak rootAfter = tree.RootHash;
Assert.AreEqual(rootBefore, rootAfter);
}
public void Storage_proofs_when_values_are_missing_setup()
{
byte[] a = Bytes.FromHexString("0x000000000000000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaa");
byte[] b = Bytes.FromHexString("0x0000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
byte[] c = Bytes.FromHexString("0x00000000001ccccccccccccccccccccccccccccccccccccccccccccccccccccc");
byte[] d = Bytes.FromHexString("0x00000000001ddddddddddddddddddddddddddddddddddddddddddddddddddddd");
byte[] e = Bytes.FromHexString("0x00000000001eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
IDb memDb = new MemDb();
TrieStore trieStore = new TrieStore(memDb, LimboLogs.Instance);
StateTree tree = new StateTree(trieStore, LimboLogs.Instance);
StorageTree storageTree = new StorageTree(trieStore, Keccak.EmptyTreeHash, LimboLogs.Instance);
storageTree.Set(Keccak.Compute(a).Bytes, Rlp.Encode(Bytes.FromHexString("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(c).Bytes, Rlp.Encode(Bytes.FromHexString("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(e).Bytes, Rlp.Encode(Bytes.FromHexString("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Commit(0);
byte[] code = new byte[] { 1, 2, 3 };
Account account1 = Build.An.Account.WithBalance(1).WithStorageRoot(storageTree.RootHash).TestObject;
Account account2 = Build.An.Account.WithBalance(2).TestObject;
tree.Set(TestItem.AddressA, account1);
tree.Set(TestItem.AddressB, account2);
tree.Commit(0);
TreeDumper dumper = new TreeDumper();
tree.Accept(dumper, tree.RootHash, true);
Console.WriteLine(dumper.ToString());
AccountProofCollector accountProofCollector = new AccountProofCollector(TestItem.AddressA, new byte[][] { a, b, c, d, e });
tree.Accept(accountProofCollector, tree.RootHash, true);
AccountProof proof = accountProofCollector.BuildResult();
Assert.AreEqual("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[0].Value?.ToHexString(true) ?? "0x");
Assert.AreEqual("0x00", proof.StorageProofs[1].Value?.ToHexString(true) ?? "0x");
Assert.AreEqual("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[2].Value?.ToHexString(true) ?? "0x");
Assert.AreEqual("0x00", proof.StorageProofs[3].Value?.ToHexString(true) ?? "0x");
Assert.AreEqual("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[4].Value?.ToHexString(true) ?? "0x");
proof.StorageProofs[1].Proof.Should().HaveCount(3);
proof.StorageProofs[3].Proof.Should().HaveCount(2);
}
public void Storage_proofs_have_values_set_complex_3_setup()
{
byte[] a = Bytes.FromHexString("0x000000000000000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaa");
byte[] b = Bytes.FromHexString("0x0000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
byte[] c = Bytes.FromHexString("0x00000000001ccccccccccccccccccccccccccccccccccccccccccccccccccccc");
byte[] d = Bytes.FromHexString("0x00000000001ddddddddddddddddddddddddddddddddddddddddddddddddddddd");
byte[] e = Bytes.FromHexString("0x00000000001eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
IDb memDb = new MemDb();
StateTree tree = new StateTree(memDb);
StorageTree storageTree = new StorageTree(memDb);
storageTree.Set(Keccak.Compute(a).Bytes, Rlp.Encode(Bytes.FromHexString("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(b).Bytes, Rlp.Encode(Bytes.FromHexString("0xab34000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(c).Bytes, Rlp.Encode(Bytes.FromHexString("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(d).Bytes, Rlp.Encode(Bytes.FromHexString("0xab78000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(e).Bytes, Rlp.Encode(Bytes.FromHexString("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Commit();
byte[] code = new byte[] { 1, 2, 3 };
Account account1 = Build.An.Account.WithBalance(1).WithStorageRoot(storageTree.RootHash).TestObject;
Account account2 = Build.An.Account.WithBalance(2).TestObject;
tree.Set(TestItem.AddressA, account1);
tree.Set(TestItem.AddressB, account2);
tree.Commit();
TreeDumper dumper = new TreeDumper();
tree.Accept(dumper, tree.RootHash, true);
Console.WriteLine(dumper.ToString());
AccountProofCollector accountProofCollector = new AccountProofCollector(TestItem.AddressA, new byte[][] { a, b, c, d, e });
tree.Accept(accountProofCollector, tree.RootHash, true);
AccountProof proof = accountProofCollector.BuildResult();
Assert.AreEqual("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[0].Value.ToHexString(true));
Assert.AreEqual("0xab34000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[1].Value.ToHexString(true));
Assert.AreEqual("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[2].Value.ToHexString(true));
Assert.AreEqual("0xab78000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[3].Value.ToHexString(true));
Assert.AreEqual("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[4].Value.ToHexString(true));
}
public void Storage_proofs_have_values_set_complex_2_setup()
{
Keccak a = new Keccak("0x000000000000000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaa");
Keccak b = new Keccak("0x0000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
Keccak c = new Keccak("0x0000000000cccccccccccccccccccccccccccccccccccccccccccccccccccccc");
Keccak d = new Keccak("0x0000000000dddddddddddddddddddddddddddddddddddddddddddddddddddddd");
Keccak e = new Keccak("0x0000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
IDb memDb = new MemDb();
StateTree tree = new StateTree(memDb);
StorageTree storageTree = new StorageTree(memDb);
storageTree.Set(a.Bytes, Rlp.Encode(Bytes.FromHexString("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(b.Bytes, Rlp.Encode(Bytes.FromHexString("0xab34000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(c.Bytes, Rlp.Encode(Bytes.FromHexString("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(d.Bytes, Rlp.Encode(Bytes.FromHexString("0xab78000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(e.Bytes, Rlp.Encode(Bytes.FromHexString("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Commit();
byte[] code = new byte[] { 1, 2, 3 };
Account account1 = Build.An.Account.WithBalance(1).WithStorageRoot(storageTree.RootHash).TestObject;
Account account2 = Build.An.Account.WithBalance(2).TestObject;
tree.Set(TestItem.AddressA, account1);
tree.Set(TestItem.AddressB, account2);
tree.Commit();
TreeDumper dumper = new TreeDumper();
tree.Accept(dumper, memDb, tree.RootHash);
Console.WriteLine(dumper.ToString());
ProofCollector proofCollector = new ProofCollector(TestItem.AddressA, new Keccak[] { a, b, c, d, e });
tree.Accept(proofCollector, memDb, tree.RootHash);
AccountProof proof = proofCollector.BuildResult();
Assert.AreEqual("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[0].Value.ToHexString(true));
Assert.AreEqual("0xab34000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[1].Value.ToHexString(true));
Assert.AreEqual("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[2].Value.ToHexString(true));
Assert.AreEqual("0xab78000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[3].Value.ToHexString(true));
Assert.AreEqual("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[4].Value.ToHexString(true));
}
private static StorageTree SetStorage(IDb db, byte i)
{
StorageTree remoteStorageTree = new StorageTree(db);
for (int j = 0; j < i; j++)
{
remoteStorageTree.Set((UInt256)j, new[] { (byte)j, i });
}
remoteStorageTree.Commit();
return(remoteStorageTree);
}
private static StorageTree SetStorage(ITrieStore trieStore, byte i)
{
StorageTree remoteStorageTree = new StorageTree(trieStore, Keccak.EmptyTreeHash, LimboLogs.Instance);
for (int j = 0; j < i; j++)
{
remoteStorageTree.Set((UInt256)j, new[] { (byte)j, i });
}
remoteStorageTree.Commit(0);
return(remoteStorageTree);
}
public static (StateTree stateTree, StorageTree storageTree) GetTrees(ITrieStore?store)
{
store ??= new TrieStore(new MemDb(), LimboLogs.Instance);
var storageTree = new StorageTree(store, LimboLogs.Instance);
storageTree.Set(SlotsWithPaths[0].Path, SlotsWithPaths[0].SlotRlpValue, false);
storageTree.Set(SlotsWithPaths[1].Path, SlotsWithPaths[1].SlotRlpValue, false);
storageTree.Set(SlotsWithPaths[2].Path, SlotsWithPaths[2].SlotRlpValue, false);
storageTree.Set(SlotsWithPaths[3].Path, SlotsWithPaths[3].SlotRlpValue, false);
storageTree.Set(SlotsWithPaths[4].Path, SlotsWithPaths[4].SlotRlpValue, false);
storageTree.Set(SlotsWithPaths[5].Path, SlotsWithPaths[5].SlotRlpValue, false);
storageTree.Commit(0);
var account = Build.An.Account.WithBalance(1).WithStorageRoot(storageTree.RootHash).TestObject;
var stateTree = new StateTree(store, LimboLogs.Instance);
stateTree.Set(AccountAddress0, account);
stateTree.Commit(0);
return(stateTree, storageTree);
}
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}");
}
}
}