Ejemplo n.º 1
0
        public void AddAccounts_OneLayer_GetRange()
        {
            SortedList <Keccak, TrieNode> list = new();

            for (int i = 0; i < 100; i++)
            {
                byte[]   accountBytes = TestItem.GenerateIndexedAccountRlp(i);
                Keccak   randomKeccak = TestItem.GetRandomKeccak();
                TrieNode leaf         = TrieNodeFactory.CreateLeaf(new HexPrefix(true), accountBytes);

                list.Add(randomKeccak, leaf);
            }

            SnapStorage storage = new();

            foreach (var item in list)
            {
                storage.AddLeafNode(item.Key, item.Value, 1001);
            }

            Keccak startingHash = list.Keys[20];
            Keccak endHash      = list.Keys[29];

            var range1 = storage.GetRange(startingHash, endHash, 1001);
            var range2 = storage.GetRange(startingHash, endHash, 1002);

            Assert.AreEqual(10, range1.Length);
            Assert.IsTrue(AreEqual(20, 29, list, range1));

            Assert.AreEqual(10, range2.Length);
            Assert.IsTrue(AreEqual(20, 29, list, range2));
        }
Ejemplo n.º 2
0
        public void AddAccounts_MultipleLayers_GetRange()
        {
            SortedList <Keccak, TrieNode> list = new();

            for (int i = 0; i < 100; i++)
            {
                byte[]   accountBytes = TestItem.GenerateIndexedAccountRlp(i);
                Keccak   randomKeccak = TestItem.GetRandomKeccak();
                TrieNode leaf         = TrieNodeFactory.CreateLeaf(new HexPrefix(true), accountBytes);

                list.Add(randomKeccak, leaf);
            }

            SnapStorage storage = new();

            // create bottom layer
            foreach (var item in list)
            {
                storage.AddLeafNode(item.Key, item.Value, 1001);
            }

            // block 1002
            byte[]   updateAccountBytes_1002 = TestItem.GenerateRandomAccountRlp();
            TrieNode updateAccount_1002      = TrieNodeFactory.CreateLeaf(new HexPrefix(true), updateAccountBytes_1002);

            storage.AddLeafNode(list.Keys[21], updateAccount_1002, 1002);

            byte[]   newAccountBytes_1002 = TestItem.GenerateRandomAccountRlp();
            TrieNode newAccount_1002      = TrieNodeFactory.CreateLeaf(new HexPrefix(true), newAccountBytes_1002);
            Keccak   newAddress           = TestItem.GetRandomKeccak();

            while (newAddress <= list.Keys[21] || newAddress >= list.Keys[22])
            {
                newAddress = TestItem.GetRandomKeccak();
            }
            storage.AddLeafNode(newAddress, newAccount_1002, 1002);

            // block 1003
            storage.AddLeafNode(list.Keys[21], null, 1003);


            Keccak startingHash = list.Keys[20];
            Keccak endHash      = list.Keys[30];

            var range_1001 = storage.GetRange(startingHash, endHash, 1001);
            var range_1002 = storage.GetRange(startingHash, endHash, 1002);
            var range_1003 = storage.GetRange(startingHash, endHash, 1003);

            Assert.AreEqual(11, range_1001.Length);
            Assert.IsTrue(AreEqual(20, 30, list, range_1001));

            Assert.AreEqual(12, range_1002.Length);
            Assert.AreEqual(range_1002[1].node, updateAccount_1002);
            Assert.AreEqual(range_1002[2].node, newAccount_1002);

            Assert.AreEqual(11, range_1003.Length);
            Assert.AreEqual(range_1003[1].node, newAccount_1002);
        }
        public async Task Can_read_dependent_items_from_state_db_while_waiting_for_dependencies()
        {
            StateDb codeDb  = new StateDb();
            StateDb stateDB = new StateDb();
            MemDb   tempDb  = new MemDb();

            SyncConfig syncConfig = new SyncConfig();

            syncConfig.FastSync = true;

            IBlockTree    blockTree = Substitute.For <IBlockTree>();
            ISyncPeerPool pool      = Substitute.For <ISyncPeerPool>();

            SyncProgressResolver syncProgressResolver = new SyncProgressResolver(blockTree, NullReceiptStorage.Instance, stateDB, new MemDb(), syncConfig, LimboLogs.Instance);
            ISyncModeSelector    syncModeSelector     = new MultiSyncModeSelector(syncProgressResolver, pool, syncConfig, LimboLogs.Instance);
            StateSyncFeed        stateSyncFeed        = new StateSyncFeed(codeDb, stateDB, tempDb, syncModeSelector, blockTree, LimboLogs.Instance);

            // so we want to setup a trie in a structure of -> branch into two leaves
            // so we can respond with the branch node and with leaves missing
            // and we can prove that we can read the branch from the temp DB while it is still missing from the State DB

            AccountDecoder accountDecoder = new AccountDecoder();

            TrieNode leaf   = TrieNodeFactory.CreateLeaf(new HexPrefix(true, new byte[] { 1, 2, 3 }), accountDecoder.Encode(Account.TotallyEmpty).Bytes);
            TrieNode branch = TrieNodeFactory.CreateBranch();

            branch.SetChild(1, leaf);
            branch.ResolveKey(true);

            // PatriciaTree tree = new PatriciaTree();
            // tree = new PatriciaTree();
            // tree.Set(branch.Keccak.Bytes, branch.Value);

            stateSyncFeed.ResetStateRoot(0, branch.Keccak);

            var request = await stateSyncFeed.PrepareRequest();

            BuildRequestAndHandleResponse(branch, request, stateSyncFeed);

            byte[] value = tempDb.Get(branch.Keccak);
            value.Should().BeEquivalentTo(branch.FullRlp);

            byte[] valueFromState = stateDB.Get(branch.Keccak);
            valueFromState.Should().BeNull();

            request = await stateSyncFeed.PrepareRequest();

            BuildRequestAndHandleResponse(leaf, request, stateSyncFeed);

            value = tempDb.Get(branch.Keccak);
            value.Should().BeNull();

            valueFromState = stateDB.Get(branch.Keccak);
            valueFromState.Should().BeEquivalentTo(branch.FullRlp);
        }
Ejemplo n.º 4
0
        public void Extension_can_accept_visitors()
        {
            ITreeVisitor     visitor = Substitute.For <ITreeVisitor>();
            TrieVisitContext context = new();
            TrieNode         ignore  = TrieNodeFactory.CreateLeaf(HexPrefix.Leaf("ccc"), Array.Empty <byte>());
            TrieNode         node    = TrieNodeFactory.CreateExtension(HexPrefix.Extension("aa"), ignore);

            node.Accept(visitor, NullTrieNodeResolver.Instance, context);

            visitor.Received().VisitExtension(node, context);
        }
Ejemplo n.º 5
0
        public void Leaf_with_contract_without_storage_and_empty_code_can_accept_visitors()
        {
            ITreeVisitor     visitor = Substitute.For <ITreeVisitor>();
            TrieVisitContext context = new();
            Account          account = new(1, 100, Keccak.EmptyTreeHash, Keccak.OfAnEmptyString);
            AccountDecoder   decoder = new();
            TrieNode         node    = TrieNodeFactory.CreateLeaf(HexPrefix.Leaf("aa"), decoder.Encode(account).Bytes);

            node.Accept(visitor, NullTrieNodeResolver.Instance, context);

            visitor.Received().VisitLeaf(node, context, node.Value);
        }
Ejemplo n.º 6
0
        public void Leaf_with_simple_account_can_accept_visitors()
        {
            ITreeVisitor     visitor = Substitute.For <ITreeVisitor>();
            TrieVisitContext context = new();
            Account          account = new(100);
            AccountDecoder   decoder = new();
            TrieNode         node    = TrieNodeFactory.CreateLeaf(HexPrefix.Leaf("aa"), decoder.Encode(account).Bytes);

            node.Accept(visitor, NullTrieNodeResolver.Instance, context);

            visitor.Received().VisitLeaf(node, context, node.Value);
        }
Ejemplo n.º 7
0
            public Context()
            {
                TiniestLeaf       = new TrieNode(NodeType.Leaf);
                TiniestLeaf.Key   = new HexPrefix(true, 5);
                TiniestLeaf.Value = new byte[] { 10 };

                HeavyLeaf       = new TrieNode(NodeType.Leaf);
                HeavyLeaf.Key   = new HexPrefix(true, new byte[20]);
                HeavyLeaf.Value = Keccak.EmptyTreeHash.Bytes.Concat(Keccak.EmptyTreeHash.Bytes).ToArray();

                Account        account = new(100);
                AccountDecoder decoder = new();

                AccountLeaf = TrieNodeFactory.CreateLeaf(
                    HexPrefix.Leaf("bbb"),
                    decoder.Encode(account).Bytes);
            }