public DebugModuleFactory(
IDbProvider dbProvider,
IBlockTree blockTree,
IJsonRpcConfig jsonRpcConfig,
IBlockValidator blockValidator,
IBlockPreprocessorStep recoveryStep,
IRewardCalculatorSource rewardCalculator,
IReceiptStorage receiptStorage,
IReceiptsMigration receiptsMigration,
ITrieNodeResolver trieStore,
IConfigProvider configProvider,
ISpecProvider specProvider,
ILogManager logManager)
{
_dbProvider = dbProvider.AsReadOnly(false);
_blockTree = blockTree.AsReadOnly();
_jsonRpcConfig = jsonRpcConfig ?? throw new ArgumentNullException(nameof(jsonRpcConfig));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_rewardCalculatorSource = rewardCalculator ?? throw new ArgumentNullException(nameof(rewardCalculator));
_receiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_receiptsMigration = receiptsMigration ?? throw new ArgumentNullException(nameof(receiptsMigration));
_trieStore = (trieStore ?? throw new ArgumentNullException(nameof(trieStore))).AsReadOnly();
_configProvider = configProvider ?? throw new ArgumentNullException(nameof(configProvider));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_logger = logManager.GetClassLogger();
}
void VisitSingleThread(ITreeVisitor treeVisitor, ITrieNodeResolver trieNodeResolver, TrieVisitContext visitContext)
{
// single threaded route
for (int i = 0; i < BranchesCount; i++)
{
VisitChild(i, GetChild(trieNodeResolver, i), trieNodeResolver, treeVisitor, visitContext);
}
}
public ReadOnlyTxProcessingEnv(
IDbProvider dbProvider,
ITrieNodeResolver trieStore,
IBlockTree blockTree,
ISpecProvider specProvider,
ILogManager logManager)
: this(dbProvider.AsReadOnly(false), trieStore.AsReadOnly(), blockTree.AsReadOnly(), specProvider, logManager)
{
}
public void Child_and_value_store_encode()
{
TrieNode node = new(NodeType.Branch);
node.SetChild(0, new TrieNode(NodeType.Leaf, TestItem.KeccakA));
ITrieNodeResolver tree = BuildATreeFromNode(node);
TrieNode decoded = new(NodeType.Unknown, node.Keccak);
decoded.ResolveNode(tree);
decoded.RlpEncode(tree);
}
public void Two_children_store_resolve_getnull_encode()
{
TrieNode node = new(NodeType.Branch);
node.SetChild(0, new TrieNode(NodeType.Leaf, TestItem.KeccakA));
node.SetChild(1, new TrieNode(NodeType.Leaf, TestItem.KeccakB));
ITrieNodeResolver tree = BuildATreeFromNode(node);
TrieNode decoded = new(NodeType.Unknown, node.Keccak);
decoded.ResolveNode(tree);
TrieNode child = decoded.GetChild(tree, 3);
decoded.RlpEncode(tree);
}
public void Two_children_store_resolve_delete_and_add_encode()
{
TrieNode node = new(NodeType.Branch);
node.SetChild(0, new TrieNode(NodeType.Leaf, TestItem.KeccakA));
node.SetChild(1, new TrieNode(NodeType.Leaf, TestItem.KeccakB));
ITrieNodeResolver tree = BuildATreeFromNode(node);
TrieNode decoded = new(NodeType.Unknown, node.Keccak);
decoded.ResolveNode(tree);
decoded = decoded.Clone();
decoded.SetChild(0, null);
decoded.SetChild(4, new TrieNode(NodeType.Leaf, TestItem.KeccakC));
decoded.RlpEncode(tree);
}
public byte[] Encode(ITrieNodeResolver tree, TrieNode?item)
{
Metrics.TreeNodeRlpEncodings++;
if (item is null)
{
throw new TrieException("An attempt was made to RLP encode a null node.");
}
return(item.NodeType switch
{
NodeType.Branch => RlpEncodeBranch(tree, item),
NodeType.Extension => EncodeExtension(tree, item),
NodeType.Leaf => EncodeLeaf(item),
_ => throw new TrieException($"An attempt was made to encode a trie node of type {item.NodeType}")
});
public SyncProgressResolver(IBlockTree blockTree,
IReceiptStorage receiptStorage,
IDb stateDb,
ITrieNodeResolver trieNodeResolver,
ISyncConfig syncConfig,
ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_receiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_stateDb = stateDb ?? throw new ArgumentNullException(nameof(stateDb));
_trieNodeResolver = trieNodeResolver ?? throw new ArgumentNullException(nameof(trieNodeResolver));
_syncConfig = syncConfig ?? throw new ArgumentNullException(nameof(syncConfig));
_bodiesBarrier = _syncConfig.AncientBodiesBarrierCalc;
_receiptsBarrier = _syncConfig.AncientReceiptsBarrierCalc;
}
void VisitChild(int i, TrieNode?child, ITrieNodeResolver resolver, ITreeVisitor v, TrieVisitContext context)
{
if (child != null)
{
child.ResolveKey(resolver, false);
if (v.ShouldVisit(child.Keccak !))
{
context.BranchChildIndex = i;
child.Accept(v, resolver, context);
}
if (child.IsPersisted)
{
UnresolveChild(i);
}
}
}
void VisitMultiThread(ITreeVisitor treeVisitor, ITrieNodeResolver trieNodeResolver, TrieVisitContext visitContext, TrieNode?[] children)
{
// multithreaded route
Parallel.For(0, BranchesCount, i =>
{
visitContext.Semaphore.Wait();
try
{
// we need to have separate context for each thread as context tracks level and branch child index
TrieVisitContext childContext = visitContext.Clone();
VisitChild(i, children[i], trieNodeResolver, treeVisitor, childContext);
}
finally
{
visitContext.Semaphore.Release();
}
});
}
internal void Accept(ITreeVisitor visitor, ITrieNodeResolver nodeResolver, TrieVisitContext trieVisitContext)
{
try
{
ResolveNode(nodeResolver);
}
catch (TrieException)
{
visitor.VisitMissingNode(Keccak, trieVisitContext);
return;
}
ResolveKey(nodeResolver, trieVisitContext.Level == 0);
switch (NodeType)
{
case NodeType.Branch:
{
public void Batch_not_db_regression()
{
TrieNode child = new(NodeType.Leaf);
child.Key = HexPrefix.Leaf("abc");
child.Value = new byte[200];
child.Seal();
TrieNode trieNode = new(NodeType.Extension);
trieNode.SetChild(0, child);
trieNode.Seal();
ITrieNodeResolver trieStore = Substitute.For <ITrieNodeResolver>();
trieStore.LoadRlp(Arg.Any <Keccak>()).Throws(new TrieException());
child.ResolveKey(trieStore, false);
child.IsPersisted = true;
trieStore.FindCachedOrUnknown(Arg.Any <Keccak>()).Returns(new TrieNode(NodeType.Unknown, child.Keccak !));
trieNode.GetChild(trieStore, 0);
Assert.Throws <TrieException>(() => trieNode.GetChild(trieStore, 0).ResolveNode(trieStore));
}
public TraceModuleFactory(
IDbProvider dbProvider,
IBlockTree blockTree,
ITrieNodeResolver trieNodeResolver,
IJsonRpcConfig jsonRpcConfig,
IBlockPreprocessorStep recoveryStep,
IRewardCalculatorSource rewardCalculatorSource,
IReceiptStorage receiptFinder,
ISpecProvider specProvider,
ILogManager logManager)
{
_dbProvider = dbProvider.AsReadOnly(false);
_blockTree = blockTree.AsReadOnly();
_trieNodeResolver = trieNodeResolver.AsReadOnly();
_jsonRpcConfig = jsonRpcConfig ?? throw new ArgumentNullException(nameof(jsonRpcConfig));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_rewardCalculatorSource =
rewardCalculatorSource ?? throw new ArgumentNullException(nameof(rewardCalculatorSource));
_receiptStorage = receiptFinder ?? throw new ArgumentNullException(nameof(receiptFinder));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_logger = logManager.GetClassLogger();
}
internal void Accept(ITreeVisitor visitor, ITrieNodeResolver nodeResolver, TrieVisitContext trieVisitContext)
{
try
{
ResolveNode(nodeResolver);
}
catch (TrieException)
{
visitor.VisitMissingNode(Keccak, trieVisitContext);
return;
}
ResolveKey(nodeResolver, trieVisitContext.Level == 0);
switch (NodeType)
{
case NodeType.Branch:
{
visitor.VisitBranch(this, trieVisitContext);
trieVisitContext.Level++;
for (int i = 0; i < 16; i++)
{
TrieNode child = GetChild(nodeResolver, i);
if (child != null)
{
child.ResolveKey(nodeResolver, false);
if (visitor.ShouldVisit(child.Keccak !))
{
trieVisitContext.BranchChildIndex = i;
child.Accept(visitor, nodeResolver, trieVisitContext);
}
if (child.IsPersisted)
{
UnresolveChild(i);
}
}
}
trieVisitContext.Level--;
trieVisitContext.BranchChildIndex = null;
break;
}
case NodeType.Extension:
{
visitor.VisitExtension(this, trieVisitContext);
TrieNode child = GetChild(nodeResolver, 0);
if (child == null)
{
throw new InvalidDataException($"Child of an extension {Key} should not be null.");
}
child.ResolveKey(nodeResolver, false);
if (visitor.ShouldVisit(child.Keccak !))
{
trieVisitContext.Level++;
trieVisitContext.BranchChildIndex = null;
child.Accept(visitor, nodeResolver, trieVisitContext);
trieVisitContext.Level--;
}
break;
}
case NodeType.Leaf:
{
visitor.VisitLeaf(this, trieVisitContext, Value);
if (!trieVisitContext.IsStorage && trieVisitContext.ExpectAccounts) // can combine these conditions
{
Account account = _accountDecoder.Decode(Value.AsRlpStream());
if (account.HasCode && visitor.ShouldVisit(account.CodeHash))
{
trieVisitContext.Level++;
trieVisitContext.BranchChildIndex = null;
visitor.VisitCode(account.CodeHash, trieVisitContext);
trieVisitContext.Level--;
}
if (account.HasStorage && visitor.ShouldVisit(account.StorageRoot))
{
trieVisitContext.IsStorage = true;
TrieNode storageRoot = new(NodeType.Unknown, account.StorageRoot);
trieVisitContext.Level++;
trieVisitContext.BranchChildIndex = null;
storageRoot.Accept(visitor, nodeResolver, trieVisitContext);
trieVisitContext.Level--;
trieVisitContext.IsStorage = false;
}
}
break;
}
default:
throw new TrieException($"An attempt was made to visit a node {Keccak} of type {NodeType}");
}
}
public static ReadOnlyTrieStore AsReadOnly(this ITrieNodeResolver trieStore)
{
return(new(trieStore));
}
public ReadOnlyTrieStore(ITrieNodeResolver trieStore)
{
_trieStore = trieStore ?? throw new ArgumentNullException(nameof(trieStore));
}