diff --git a/.gitmodules b/.gitmodules index f5c94ba7c69..5d7c0fddcb0 100644 --- a/.gitmodules +++ b/.gitmodules @@ -4,3 +4,6 @@ [submodule "src/bench_precompiles"] path = src/bench_precompiles url = https://github.com/shamatar/bench_precompiles.git +[submodule "src/Nethermind/Paprika"] + path = src/Nethermind/Paprika + url = git@github.com:NethermindEth/Paprika.git diff --git a/Directory.Packages.props b/Directory.Packages.props index dbe931357dd..4a8244937b3 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -24,7 +24,9 @@ + + @@ -84,6 +86,7 @@ + diff --git a/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs b/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs index 374f738ab79..851e0aad324 100644 --- a/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs +++ b/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs @@ -36,6 +36,9 @@ using Nethermind.Merge.Plugin; using Nethermind.JsonRpc; using System.Reflection; +using Paprika; +using Paprika.Store; +using PaprikaPlugin; namespace Ethereum.Test.Base; @@ -133,6 +136,12 @@ protected async Task RunTest(BlockchainTest test, Stopwatch? .AddSingleton(specProvider) .AddSingleton(_logManager) .AddSingleton(rewardCalculator) + .AddModule(new PaprikaPluginModule(new PaprikaConfig() + { + })) + .AddSingleton(PagedDb.NativeMemoryDb( + 10.MB(), + 16)) .AddSingleton(DifficultyCalculator); if (isEngineTest) diff --git a/src/Nethermind/Ethereum.Test.Base/Ethereum.Test.Base.csproj b/src/Nethermind/Ethereum.Test.Base/Ethereum.Test.Base.csproj index 4aa22e32cb1..967f4ed4eeb 100644 --- a/src/Nethermind/Ethereum.Test.Base/Ethereum.Test.Base.csproj +++ b/src/Nethermind/Ethereum.Test.Base/Ethereum.Test.Base.csproj @@ -19,5 +19,6 @@ + diff --git a/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs b/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs index 39dbc151790..6a47bbf849e 100644 --- a/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs +++ b/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs @@ -25,6 +25,9 @@ using System; using System.Collections.Generic; using System.Diagnostics; +using Paprika; +using Paprika.Store; +using PaprikaPlugin; namespace Ethereum.Test.Base { @@ -82,6 +85,12 @@ protected EthereumTestResult RunTest(GeneralStateTest test, ITxTracer txTracer) .AddSingleton(new TestBlockhashProvider()) .AddSingleton(specProvider) .AddSingleton(_logManager) + .AddModule(new PaprikaPluginModule(new PaprikaConfig() + { + })) + .AddSingleton(PagedDb.NativeMemoryDb( + 10.MB(), + 16)) .Build(); IMainProcessingContext mainBlockProcessingContext = container.Resolve(); diff --git a/src/Nethermind/EthereumTests.slnx b/src/Nethermind/EthereumTests.slnx index b5e21d12b74..381e2466448 100644 --- a/src/Nethermind/EthereumTests.slnx +++ b/src/Nethermind/EthereumTests.slnx @@ -67,4 +67,6 @@ + + diff --git a/src/Nethermind/Nethermind.Blockchain.Test.Runner/PerfTest.cs b/src/Nethermind/Nethermind.Blockchain.Test.Runner/PerfTest.cs index 15c318d02b7..f5e6a14cca8 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test.Runner/PerfTest.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test.Runner/PerfTest.cs @@ -28,6 +28,7 @@ public IEnumerable RunTests() bool isNewLine = true; foreach (GeneralStateTest test in tests) { + Console.WriteLine($"RUNNING {test.Name}"); if (test.LoadFailure is not null) { continue; diff --git a/src/Nethermind/Nethermind.Blockchain.Test.Runner/Program.cs b/src/Nethermind/Nethermind.Blockchain.Test.Runner/Program.cs index f2c6c946004..9c2ead440e5 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test.Runner/Program.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test.Runner/Program.cs @@ -34,6 +34,7 @@ private static async Task RunManualTestingLoop() string[] input = Console.ReadLine().Split(); string command = input[0]; string testWildcard = input.Length <= 1 ? null : input[1]; + Console.Error.WriteLine($"Command {command}"); Stopwatch stopwatch = new Stopwatch(); if (command == "p") @@ -53,6 +54,7 @@ private static async Task RunManualTestingLoop() } else { + Console.Error.WriteLine("Break?"); break; } @@ -76,6 +78,7 @@ private static async Task RunManualTestingLoop() private static void WrapAndRunDirectoryStateTests(IStateTestRunner stateTest) { + Console.Error.WriteLine($"Running {stateTest}"); var result = stateTest.RunTests().ToList(); var failedTestsInCategory = result.Where(r => !r.Pass).Select(t => t.Name + " " + t.LoadFailure).ToArray(); AllFailingTests.AddRange(failedTestsInCategory); @@ -169,7 +172,7 @@ private static void RunAllStateTests(string testWildcard, Func new(Nonce, Balance, StorageRoot, CodeHash); + + public override string ToString() + { + return $"N:{Nonce},B:{Balance},S:{StorageRoot},C:{CodeHash}"; + } } public readonly struct AccountStruct : IEquatable diff --git a/src/Nethermind/Nethermind.Evm/State/IWorldStateScopeProvider.cs b/src/Nethermind/Nethermind.Evm/State/IWorldStateScopeProvider.cs index 61a6ac119d0..cf11d391a4e 100644 --- a/src/Nethermind/Nethermind.Evm/State/IWorldStateScopeProvider.cs +++ b/src/Nethermind/Nethermind.Evm/State/IWorldStateScopeProvider.cs @@ -79,7 +79,7 @@ public interface IStorageTree { Hash256 RootHash { get; } - byte[] Get(in UInt256 index); + byte[]? Get(in UInt256 index); void HintGet(in UInt256 index, byte[]? value); @@ -88,7 +88,7 @@ public interface IStorageTree /// /// /// - byte[] Get(in ValueHash256 hash); + byte[]? Get(in ValueHash256 hash); } public interface IWorldStateWriteBatch : IDisposable diff --git a/src/Nethermind/Nethermind.Paprika/IPaprikaConfig.cs b/src/Nethermind/Nethermind.Paprika/IPaprikaConfig.cs new file mode 100644 index 00000000000..bce282b5fc3 --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/IPaprikaConfig.cs @@ -0,0 +1,30 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Config; + +namespace Nethermind.Paprika; + +public interface IPaprikaConfig: IConfig +{ + [ConfigItem(Description = "Enable paprika", DefaultValue = "false", HiddenFromDocs = true)] + public bool Enabled { get; set; } + + [ConfigItem(Description = "Paprika db size in GB", DefaultValue = "128", HiddenFromDocs = true)] + public long SizeGb { get; set; } + + [ConfigItem(Description = "Paprika history depth", DefaultValue = "128", HiddenFromDocs = true)] + public byte HistoryDepth { get; set; } + + [ConfigItem(Description = "Paprika flush", DefaultValue = "false", HiddenFromDocs = true)] + public bool FlushToDisk { get; set; } + + [ConfigItem(Description = "Paprika flush", DefaultValue = "2", HiddenFromDocs = true)] + int FinalizationQueueLimit { get; set; } + + [ConfigItem(Description = "Automatic finalaization", DefaultValue = "2", HiddenFromDocs = true)] + int AutomaticallyFinalizeAfter { get; set; } + + [ConfigItem(Description = "Import from triestore", DefaultValue = "false", HiddenFromDocs = true)] + bool ImportFromTrieStore { get; set; } +} diff --git a/src/Nethermind/Nethermind.Paprika/Importer/ImporterStep.cs b/src/Nethermind/Nethermind.Paprika/Importer/ImporterStep.cs new file mode 100644 index 00000000000..b89d3f2d0a5 --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/Importer/ImporterStep.cs @@ -0,0 +1,96 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Autofac.Features.AttributeFilters; +using Nethermind.Api.Steps; +using Nethermind.Blockchain; +using Nethermind.Config; +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Db; +using Nethermind.Init.Steps; +using Nethermind.Logging; +using Nethermind.Monitoring; +using Nethermind.Trie; +using IDb = Paprika.IDb; + +namespace Nethermind.Paprika.Importer; + +[RunnerStepDependencies( + dependencies: [typeof(InitializeBlockTree)], + dependents: [typeof(InitializeBlockchain)] +)] +public class ImporterStep( + IBlockTree blockTree, + global::Paprika.Chain.Blockchain paprikaBlockchain, + [KeyFilter(DbNames.State)] INodeStorage stateNodeStorage, + IProcessExitSource exitSource, + IDisposableStack disposableStack, + IDb db, + ILogManager logManager): IStep +{ + ILogger _logger = logManager.GetClassLogger(); + + public async Task Execute(CancellationToken cancellationToken) + { + Console.Error.WriteLine("execute start"); + new NethermindKestrelMetricServer(9999).Start(); + disposableStack.Push(Prometheus.MeterAdapter.StartListening()); + + Hash256 rootHash; + using (var readOnly = paprikaBlockchain.StartReadOnlyLatestFromDb()) + { + rootHash = readOnly.Hash.ToNethHash(); + } + + if (rootHash != Hash256.Zero) + { + _logger.Warn($"Import skipped as has existing root hash. {rootHash}"); + return; + } + + BlockHeader? head = blockTree.Head?.Header; + if (head is null) + { + _logger.Warn($"Import skipped as head is null. {rootHash}"); + return; + } + + _logger.Info($"Starting paprika import from head {head.ToString(BlockHeader.Format.Short)}. StateRoot: {head.StateRoot}"); + + // LMDB + // db.ForceSync(); + var visitor = new PaprikaCopyingVisitor(paprikaBlockchain, 50000, false, logManager); + + var trieStore = new RawTrieStore(stateNodeStorage); + PatriciaTree trie = new PatriciaTree(trieStore, logManager); + trie.RootHash = head.StateRoot!; + + var visit = Task.Run(() => + { + trie.Accept(visitor, trie.RootHash, new VisitingOptions + { + MaxDegreeOfParallelism = 8, + //FullScanMemoryBudget = 1L * 1024 * 1024 * 1024 + }); + + visitor.Finish(); + }); + + var copy = visitor.Copy(); + await Task.WhenAll(visit, copy); + + var finalRootHash = await copy; + var rootHashNeth = finalRootHash.ToNethHash(); + + if (rootHashNeth != head.StateRoot) + { + throw new Exception($"Import failed. Root hash mismatched. Expected {head.StateRoot}, got {rootHashNeth}"); + } + + db.Flush(); + + _logger.Info("Imported statedb to paprika. Exiting...."); + exitSource.Exit(0); + } +} diff --git a/src/Nethermind/Nethermind.Paprika/Importer/Measurement.cs b/src/Nethermind/Nethermind.Paprika/Importer/Measurement.cs new file mode 100644 index 00000000000..8c084b8ffb4 --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/Importer/Measurement.cs @@ -0,0 +1,131 @@ +using System.Collections.Concurrent; +using System.Diagnostics.Metrics; +using HdrHistogram; +using Spectre.Console; +using Spectre.Console.Rendering; + +namespace Nethermind.Paprika.Importer; + +interface IMeasurement : IRenderable +{ + void Update(double measurement, ReadOnlySpan> tags); +} + +abstract class Measurement : JustInTimeRenderable, IMeasurement +{ + private readonly Instrument _instrument; + private const long NoValue = Int64.MaxValue; + + private long _value; + + private Measurement(Instrument instrument) + { + _instrument = instrument; + } + + protected override IRenderable Build() + { + var value = Volatile.Read(ref _value); + return value == NoValue ? new Text("") : new Text(value.ToString()); + } + + public void Update(double measurement, ReadOnlySpan> tags) + { + var updated = Update(measurement); + var previous = Interlocked.Exchange(ref _value, updated); + + if (updated != previous) + { + MarkAsDirty(); + } + } + + protected abstract long Update(double measurement); + + public override string ToString() => $"{nameof(Instrument)}: {_instrument.Name}, Value: {Volatile.Read(ref _value)}"; + + public static IMeasurement Build(Instrument instrument) + { + var type = instrument.GetType(); + if (type.IsGenericType) + { + var definition = type.GetGenericTypeDefinition(); + + if (definition == typeof(ObservableGauge<>)) + { + return new GaugeMeasurement(instrument); + } + + if (definition == typeof(Counter<>)) + { + return new CounterMeasurement(instrument); + } + + if (definition == typeof(Histogram<>)) + { + return new HistogramHdrMeasurement(instrument); + } + } + + throw new NotImplementedException($"Not implemented for type {type}"); + } + + private class GaugeMeasurement(Instrument instrument) : Measurement(instrument) + { + protected override long Update(double measurement) => (long)measurement; + } + + private class HistogramLastMeasurement(Instrument instrument) : Measurement(instrument) + { + protected override long Update(double measurement) + { + return (long)measurement; + } + } + + private class HistogramHdrMeasurement(Instrument instrument) : JustInTimeRenderable, IMeasurement + { + private readonly ConcurrentQueue _measurements = new(); + private readonly LongHistogram _histogram = new(1, 1, int.MaxValue, 4); + + protected override IRenderable Build() + { + // dequeue all first + while (_measurements.TryDequeue(out var measurement)) + { + if (measurement > 0) + { + _histogram.RecordValue(measurement); + } + } + + try + { + var p50 = _histogram.GetValueAtPercentile(50).ToString().PadLeft(5); + var p90 = _histogram.GetValueAtPercentile(90).ToString().PadLeft(5); + var p99 = _histogram.GetValueAtPercentile(99).ToString().PadLeft(5); + + return new Markup($"[green]{p50}[/] |[yellow]{p90}[/] |[red]{p99}[/]"); + } + catch + { + return new Text(" N/A yet"); + } + } + + public void Update(double measurement, ReadOnlySpan> tags) + { + _measurements.Enqueue((long)measurement); + MarkAsDirty(); + } + + public override string ToString() => $"{nameof(Instrument)}: {instrument.Name}, Histogram"; + } + + private class CounterMeasurement(Instrument instrument) : Measurement(instrument) + { + private long _sum; + + protected override long Update(double measurement) => Interlocked.Add(ref _sum, (long)measurement); + } +} diff --git a/src/Nethermind/Nethermind.Paprika/Importer/MetricsReporter.cs b/src/Nethermind/Nethermind.Paprika/Importer/MetricsReporter.cs new file mode 100644 index 00000000000..7a88c2fb43b --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/Importer/MetricsReporter.cs @@ -0,0 +1,75 @@ +using System.Diagnostics.Metrics; +using System.Runtime.InteropServices; + +namespace Nethermind.Paprika.Importer; + +public class MetricsReporter : IDisposable +{ + private readonly object _sync = new(); + private readonly MeterListener _listener; + private readonly Dictionary> _instrument2State = new(); + + public MetricsReporter() + { + _listener = new MeterListener + { + InstrumentPublished = (instrument, listener) => + { + if (ShouldReport(instrument) == false) + return; + + lock (_sync) + { + var meter = instrument.Meter; + ref var dict = ref CollectionsMarshal.GetValueRefOrAddDefault(_instrument2State, meter, + out var exists); + + if (!exists) + { + dict = new Dictionary(); + } + + var state = Measurement.Build(instrument); + dict!.Add(instrument, state); + + listener.EnableMeasurementEvents(instrument, state); + } + }, + MeasurementsCompleted = (instrument, cookie) => + { + if (ShouldReport(instrument) == false) + return; + + lock (_sync) + { + var instruments = _instrument2State[instrument.Meter]; + instruments.Remove(instrument, out _); + if (instruments.Count == 0) + _instrument2State.Remove(instrument.Meter); + } + } + }; + + _listener.Start(); + + _listener.SetMeasurementEventCallback((i, m, l, c) => ((IMeasurement)c!).Update(m, l)); + _listener.SetMeasurementEventCallback((i, m, l, c) => ((IMeasurement)c!).Update(m, l)); + _listener.SetMeasurementEventCallback((i, m, l, c) => ((IMeasurement)c!).Update(m, l)); + _listener.SetMeasurementEventCallback((i, m, l, c) => ((IMeasurement)c!).Update(m, l)); + _listener.SetMeasurementEventCallback((i, m, l, c) => ((IMeasurement)c!).Update(m, l)); + _listener.SetMeasurementEventCallback((i, m, l, c) => ((IMeasurement)c!).Update(m, l)); + _listener.SetMeasurementEventCallback((i, m, l, c) => ((IMeasurement)c!).Update((double)m, l)); + } + + private static bool ShouldReport(Instrument instrument) => instrument.Meter.Name.Contains("Paprika"); + + public void Observe() + { + _listener.RecordObservableInstruments(); + } + + public void Dispose() + { + _listener.Dispose(); + } +} diff --git a/src/Nethermind/Nethermind.Paprika/Importer/PaprikaCopyingVisitor.cs b/src/Nethermind/Nethermind.Paprika/Importer/PaprikaCopyingVisitor.cs new file mode 100644 index 00000000000..b75d72c2da2 --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/Importer/PaprikaCopyingVisitor.cs @@ -0,0 +1,267 @@ +using System.Diagnostics.Metrics; +using System.Runtime.CompilerServices; +using System.Threading.Channels; +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Logging; +using Nethermind.Serialization.Rlp; +using Nethermind.Trie; +using Paprika.Chain; +using Paprika.Utils; +using Account = Paprika.Account; +using Keccak = Paprika.Crypto.Keccak; + +namespace Nethermind.Paprika.Importer; + +public class PaprikaCopyingVisitor : ITreeVisitor, IDisposable +{ + struct Item + { + private readonly ValueHash256 _account; + + // account + private readonly Nethermind.Core.Account? _accountValue; + + // storage + private readonly ValueHash256 _storage; + private readonly byte[]? _data; + + public Item(ValueHash256 account, Nethermind.Core.Account accountValue) + { + _account = account; + _accountValue = accountValue; + } + + public Item(ValueHash256 account, ValueHash256 storage, byte[] data) + { + _account = account; + _storage = storage; + _data = data; + } + + public bool IsAccount => _accountValue != null; + + public bool Apply(IWorldState block, bool skipStorage) + { + var addr = AsPaprika(_account); + + if (_accountValue != null) + { + var v = _accountValue; + var codeHash = AsPaprika(v.CodeHash); + + var storageRoot = skipStorage ? AsPaprika(v.StorageRoot) : Keccak.EmptyTreeHash; + + // import account with empty tree hash so that it can be dirtied properly + block.SetAccount(addr, new Account(v.Balance, v.Nonce, codeHash, storageRoot)); + return true; + } + + if (skipStorage == false) + { + block.SetStorage(addr, AsPaprika(_storage), _data); + return true; + } + + return false; + } + } + + private readonly global::Paprika.Chain.Blockchain _blockchain; + private readonly int _batchSize; + private readonly bool _skipStorage; + private readonly Channel _channel; + + private readonly Meter _meter; + + private readonly MetricsExtensions.IAtomicIntGauge _accountsVisitedGauge; + private readonly MetricsExtensions.IAtomicIntGauge _accountsAddedGauge; + private readonly ILogger _logger; + + public PaprikaCopyingVisitor(global::Paprika.Chain.Blockchain blockchain, int batchSize, bool skipStorage, ILogManager logManager) + { + _meter = new Meter("Paprika.Importer"); + + _accountsVisitedGauge = _meter.CreateAtomicObservableGauge("Accounts visited", "count"); + _accountsAddedGauge = _meter.CreateAtomicObservableGauge("Accounts added", "count"); + + _blockchain = blockchain; + + var options = new BoundedChannelOptions(2_000_000) + { + SingleReader = true, + SingleWriter = false, + AllowSynchronousContinuations = false + }; + + _channel = Channel.CreateBounded(options); + + _batchSize = batchSize; + _skipStorage = skipStorage; + _logger = logManager.GetClassLogger(); + } + + private long _writtenItems = 0; + + private void Add(Item item) + { + while (_channel.Writer.TryWrite(item) == false) + { + Thread.Sleep(TimeSpan.FromSeconds(1)); + } + + if (Interlocked.Increment(ref _writtenItems) % 100_000 == 0) + { + _logger.Info($"Written items: {_writtenItems:N0}"); + } + } + + public bool ExpectAccounts => true; + + public void Finish() + { + _channel.Writer.Complete(); + _logger.Info($"Read complete. Written items: {_writtenItems}"); + } + + public async Task Copy() + { + var parent = Keccak.Zero; + uint number = 1; + + var reader = _channel.Reader; + + var batch = new Queue(); + var finalization = new Queue(); + const int finalizationDepth = 4; + + while (await reader.WaitToReadAsync()) + { + await BuildBatch(reader, batch); + + using var block = _blockchain.StartNew(parent); + + var added = 0; + while (batch.TryDequeue(out var item)) + { + if (item.Apply(block, _skipStorage)) + { + if (item.IsAccount) + { + added += 1; + } + } + } + + _accountsAddedGauge.Add(added); + + // commit & finalize + var hash = block.Commit(number); + + finalization.Enqueue(hash); + + if (finalization.Count == finalizationDepth) + { + _blockchain.Finalize(finalization.Dequeue()); + } + + // update + number++; + parent = hash; + } + + while (finalization.TryDequeue(out var keccak)) + { + _blockchain.Finalize(keccak); + } + + return parent; + } + + private async Task BuildBatch(ChannelReader reader, Queue batch) + { + while (await reader.WaitToReadAsync()) + { + while (reader.TryRead(out var item)) + { + batch.Enqueue(item); + + if (batch.Count == _batchSize) + { + return; + } + } + } + } + + private static Keccak AsPaprika(Hash256 keccak) + { + Unsafe.SkipInit(out Keccak k); + keccak.Bytes.CopyTo(k.BytesAsSpan); + return k; + } + + private static Keccak AsPaprika(ValueHash256 keccak) + { + Unsafe.SkipInit(out Keccak k); + keccak.Bytes.CopyTo(k.BytesAsSpan); + return k; + } + + public void Dispose() => _meter.Dispose(); + public bool IsFullDbScan => true; + public bool ShouldVisit(in PathContext nodeContext, in ValueHash256 nextNode) => true; + + public void VisitTree(in PathContext nodeContext, in ValueHash256 rootHash) + { + } + + public void VisitMissingNode(in PathContext nodeContext, in ValueHash256 nodeHash) + { + throw new Exception("The node is missing!"); + } + + public void VisitBranch(in PathContext nodeContext, TrieNode node) + { + } + + public void VisitExtension(in PathContext nodeContext, TrieNode node) + { + } + + public void VisitAccount(in PathContext nodeContext, TrieNode node, in AccountStruct account) + { + } + + public void VisitLeaf(in PathContext nodeContext, TrieNode node) + { + var context = nodeContext.Add(node.Key!); + var path = context.AsNibblePath; + + if (path.Length == 64) + { + ValueHash256 account = default; + path.RawSpan.CopyTo(account.BytesAsSpan); + + _accountsVisitedGauge.Add(1); + + Rlp.ValueDecoderContext decoderContext = new Rlp.ValueDecoderContext(node.Value.Span); + Add(new Item(account, Rlp.Decode(ref decoderContext))); + } + else + { + ValueHash256 account = default; + ValueHash256 storage = default; + + path.RawSpan.Slice(0, 32).CopyTo(account.BytesAsSpan); + path.RawSpan.Slice(32).CopyTo(storage.BytesAsSpan); + + Rlp.ValueDecoderContext rlp = new Rlp.ValueDecoderContext(node.Value.Span); + Add(new(account, storage, rlp.DecodeByteArray())); + } + } + + public void VisitCode(in PathContext nodeContext, Hash256 codeHash) + { + } +} diff --git a/src/Nethermind/Nethermind.Paprika/Importer/PathContext.cs b/src/Nethermind/Nethermind.Paprika/Importer/PathContext.cs new file mode 100644 index 00000000000..c531fad522d --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/Importer/PathContext.cs @@ -0,0 +1,56 @@ +using System.Runtime.InteropServices; +using Nethermind.Core.Crypto; +using Nethermind.Trie; +using Paprika.Data; + +namespace Nethermind.Paprika.Importer; + +[StructLayout(LayoutKind.Explicit, Size = SizeOf)] +public struct PathContext : INodeContext +{ + public const int SizeOf = PathLength + sizeof(int); + private const int PathLength = 64; + + [FieldOffset(0)] + public byte First; + + [FieldOffset(PathLength)] public int Length; + + public Span Span => MemoryMarshal.CreateSpan(ref First, PathLength); + + public PathContext Add(ReadOnlySpan nibblePath) + { + var added = NibblePath.FromRawNibbles(nibblePath, stackalloc byte[(nibblePath.Length + 1) / 2]); + var current = NibblePath.FromKey(Span).SliceTo(Length); + + Span workingSet = stackalloc byte[current.MaxByteLength + added.MaxByteLength + 2]; + var appended = current.Append(added, workingSet); + + var result = default(PathContext); + appended.RawSpan.CopyTo(result.Span); + result.Length = appended.Length; + + return result; + } + + public PathContext Add(byte nibble) + { + var current = NibblePath.FromKey(Span).SliceTo(Length); + + Span workingSet = stackalloc byte[current.MaxByteLength + 2]; + var appended = current.AppendNibble(nibble, workingSet); + + var result = default(PathContext); + appended.RawSpan.CopyTo(result.Span); + result.Length = appended.Length; + + return result; + } + + public PathContext AddStorage(in ValueHash256 storage) + { + return this; + } + + public NibblePath AsNibblePath => NibblePath.FromKey(Span).SliceTo(Length); +} diff --git a/src/Nethermind/Nethermind.Paprika/Nethermind.Paprika.csproj b/src/Nethermind/Nethermind.Paprika/Nethermind.Paprika.csproj new file mode 100644 index 00000000000..8a1dec4dc32 --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/Nethermind.Paprika.csproj @@ -0,0 +1,23 @@ + + + + net10.0 + enable + enable + + + + + + + + + + + + + ..\..\..\..\..\.nuget\packages\spectre.console\0.51.1\lib\net9.0\Spectre.Console.dll + + + + diff --git a/src/Nethermind/Nethermind.Paprika/PaprikaConfig.cs b/src/Nethermind/Nethermind.Paprika/PaprikaConfig.cs new file mode 100644 index 00000000000..89bcc4e369a --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/PaprikaConfig.cs @@ -0,0 +1,15 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +namespace Nethermind.Paprika; + +public class PaprikaConfig: IPaprikaConfig +{ + public bool Enabled { get; set; } = false; + public long SizeGb { get; set; } = 512; + public byte HistoryDepth { get; set; } = 128; + public bool FlushToDisk { get; set; } = false; + public int FinalizationQueueLimit { get; set; } = 2; + public int AutomaticallyFinalizeAfter { get; set; } = 4; + public bool ImportFromTrieStore { get; set; } +} diff --git a/src/Nethermind/Nethermind.Paprika/PaprikaNethermindCompatExtensions.cs b/src/Nethermind/Nethermind.Paprika/PaprikaNethermindCompatExtensions.cs new file mode 100644 index 00000000000..c46db68b42f --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/PaprikaNethermindCompatExtensions.cs @@ -0,0 +1,70 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Int256; +using Nethermind.State; +using Keccak = Paprika.Crypto.Keccak; + +namespace Nethermind.Paprika; + +public static class PaprikaNethermindCompatExtensions +{ + public static Keccak ToPaprikaKeccak(this Hash256 hash) + { + return new Keccak(hash.Bytes); + } + + public static Keccak ToPaprikaKeccak(this ValueHash256 hash) + { + return new Keccak(hash.Bytes); + } + + public static Keccak ToPaprikaKeccak(this Address address) + { + return address.ToAccountPath.ToPaprikaKeccak(); + } + + public static Keccak SlotToPaprikaKeccak(this UInt256 slot) + { + var key = new Keccak(); + StorageTree.ComputeKeyWithLookup(slot, key.BytesAsSpan); + return key; + } + + public static Hash256 ToNethHash(this Keccak hash) + { + return new Hash256(hash.BytesAsSpan); + } + + public static Account ToNethAccount(this global::Paprika.Account account) + { + return new Account( + account.Nonce, + account.Balance, + account.StorageRootHash.ToNethHash(), + account.CodeHash.ToNethHash() + ); + } + + public static AccountStruct ToNethAccountStruct(this global::Paprika.Account account) + { + return new AccountStruct( + account.Nonce, + account.Balance, + account.StorageRootHash.ToNethHash(), + account.CodeHash.ToNethHash() + ); + } + + public static global::Paprika.Account ToPaprikaAccount(this Account account) + { + return new global::Paprika.Account( + account.Balance, + account.Nonce, + account.CodeHash.ToPaprikaKeccak(), + account.StorageRoot.ToPaprikaKeccak() + ); + } +} diff --git a/src/Nethermind/Nethermind.Paprika/PaprikaPlugin.cs b/src/Nethermind/Nethermind.Paprika/PaprikaPlugin.cs new file mode 100644 index 00000000000..483b72ba743 --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/PaprikaPlugin.cs @@ -0,0 +1,77 @@ +using Autofac; +using Autofac.Core; +using Nethermind.Api; +using Nethermind.Api.Extensions; +using Nethermind.Api.Steps; +using Nethermind.Core; +using Nethermind.Core.Extensions; +using Nethermind.Paprika.Importer; +using Nethermind.State; +using Paprika; +using Paprika.Chain; +using Paprika.Merkle; +using Paprika.Store; + +namespace Nethermind.Paprika; + +public class PaprikaPlugin(IPaprikaConfig paprikaConfig): INethermindPlugin +{ + public string Name => "Paprika"; + public string Description => "Paprika State Db"; + public string Author => "Nethermind"; + public bool Enabled => paprikaConfig.Enabled; + public IModule Module { get; } = new PaprikaPluginModule(paprikaConfig); +} + +public class PaprikaPluginModule(IPaprikaConfig paprikaConfig) : Module +{ + protected override void Load(ContainerBuilder builder) + { + base.Load(builder); + + builder + .AddSingleton() + .AddSingleton(ConfigureDb) + .AddSingleton((_) => new ComputeMerkleBehavior(ComputeMerkleBehavior.ParallelismNone)) + .AddSingleton(CreatePaprikaBlockchain) + .AddSingleton() + + ; + + if (paprikaConfig.ImportFromTrieStore) + { + builder.AddStep(typeof(ImporterStep)); + } + } + + private IDb ConfigureDb(IInitConfig initConfig, IPaprikaConfig paprikaConfig) + { + if (initConfig.DiagnosticMode == DiagnosticMode.MemDb) + { + return PagedDb.NativeMemoryDb( + paprikaConfig.SizeGb.GiB(), + paprikaConfig.HistoryDepth); + } + + var dbPath = initConfig.BaseDbPath + "/paprika/"; + + return PagedDb.MemoryMappedDb( + paprikaConfig.SizeGb.GiB(), + paprikaConfig.HistoryDepth, // TODO: CHange history depht to more than a byte + dbPath, + paprikaConfig.FlushToDisk); + } + + private global::Paprika.Chain.Blockchain CreatePaprikaBlockchain(IDb paprikaDb, ComputeMerkleBehavior merkleBehavior, MetricsReporter metricsReporter) + { + return new global::Paprika.Chain.Blockchain( + paprikaDb, + merkleBehavior, + minFlushDelay: TimeSpan.FromMinutes(1), + cacheBudgetStateAndStorage: CacheBudget.Options.None, + cacheBudgetPreCommit: CacheBudget.Options.None, + finalizationQueueLimit: paprikaConfig.FinalizationQueueLimit, + automaticallyFinalizeAfter: paprikaConfig.AutomaticallyFinalizeAfter, + beforeMetricsDisposed: () => metricsReporter.Observe()); + } +} diff --git a/src/Nethermind/Nethermind.Paprika/PaprikaScope.cs b/src/Nethermind/Nethermind.Paprika/PaprikaScope.cs new file mode 100644 index 00000000000..f4beaf6b11c --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/PaprikaScope.cs @@ -0,0 +1,187 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Core.Extensions; +using Nethermind.Evm.State; +using Nethermind.Int256; +using Paprika.Chain; +using IWorldState = Paprika.Chain.IWorldState; + +namespace Nethermind.Paprika; + +internal class PaprikaScope( + IWorldState paprikaWorldState, + IWorldStateScopeProvider.ICodeDb codeDb, + SemaphoreSlim scopeLock, + bool isReadOnly, + global::Paprika.Chain.Blockchain paprikaBlockchain) : IWorldStateScopeProvider.IScope +{ + public void Dispose() + { + paprikaWorldState.Dispose(); + scopeLock.Release(); + } + + public Hash256 RootHash => paprikaWorldState.Hash.ToNethHash(); + + public void UpdateRootHash() + { + // Paprika auto update on `Hash` getter + } + + public Account? Get(Address address) + { + return paprikaWorldState.GetAccount(address.ToAccountPath.ToPaprikaKeccak()).ToNethAccount(); + } + + public void HintGet(Address address, Account? account) + { + // TODO: Probably not needed + } + + public IWorldStateScopeProvider.ICodeDb CodeDb => codeDb; + public static long DebugBlockNumber { get; set; } + + public static bool Debug; + + public IWorldStateScopeProvider.IStorageTree CreateStorageTree(Address address) + { + return new PaprikaStorageTree(paprikaWorldState, address.ToPaprikaKeccak()); + } + + public IWorldStateScopeProvider.IWorldStateWriteBatch StartWriteBatch(int estimatedAccountNum) + { + return new PaprikaWriteBatcher(paprikaWorldState); + } + + public void Commit(long blockNumber) + { + if (!isReadOnly) + { + paprikaWorldState.Commit((uint)blockNumber); + + if (blockNumber == 0) + { + paprikaBlockchain.Finalize(paprikaWorldState.Hash); + } + } + } + + private class PaprikaStorageTree(IWorldState paprikaWorldState, global::Paprika.Crypto.Keccak address) : IWorldStateScopeProvider.IStorageTree + { + public Hash256 RootHash => Keccak.Zero; + // public Hash256 RootHash => paprikaWorldState.GetAccount(address).StorageRootHash.ToNethHash(); + + public byte[]? Get(in UInt256 index) + { + Span buffer = stackalloc byte[32]; + global::Paprika.Crypto.Keccak key = index.SlotToPaprikaKeccak(); + buffer = paprikaWorldState.GetStorage(address, key, buffer); + return buffer.IsEmpty ? null : buffer.ToArray(); + } + + public void HintGet(in UInt256 index, byte[]? value) + { + } + + public byte[]? Get(in ValueHash256 hash) + { + return null; + } + } + + private class PaprikaWriteBatcher(IWorldState paprikaWorldState) : IWorldStateScopeProvider.IWorldStateWriteBatch + { + private Lock _writeLock = new Lock(); + + public void Dispose() + { + } + +#pragma warning disable CS0067 + public event EventHandler? OnAccountUpdated; // TODO: Umm.... +#pragma warning restore CS0067 + public void Set(Address key, Account? account) + { + using var _ = _writeLock.EnterScope(); + var paprikaKeccak = key.ToPaprikaKeccak(); + if (account?.Nonce != 0) + { + Console.Error.WriteLine($"{PaprikaScope.DebugBlockNumber} Non zero nonce is {paprikaKeccak}:{key.ToAccountPath} {account}"); + } + + /* + Paprika.Account originalAccount = paprikaWorldState.GetAccount(paprikaKeccak); + + // I dont know man.... I'm just trying things out. + paprikaWorldState.SetAccount(key.ToPaprikaKeccak(), + new Paprika.Account( + account?.Balance ?? originalAccount.Balance, + account?.Nonce ?? originalAccount.Nonce, + account?.CodeHash?.ToPaprikaKeccak() ?? originalAccount.CodeHash, + originalAccount.StorageRootHash) + ); + */ + if (PaprikaScope.Debug) + { + Console.Error.WriteLine($"Set {paprikaKeccak} to {account}"); + } + if (account == null) + { + paprikaWorldState.DestroyAccount(paprikaKeccak); + } + else + { + paprikaWorldState.SetAccount(paprikaKeccak, account.ToPaprikaAccount()); + } + } + + public IWorldStateScopeProvider.IStorageWriteBatch CreateStorageWriteBatch(Address key, int estimatedEntries) + { + return new PaprikaStorageWriter( + paprikaWorldState.GetStorageSetter(key.ToPaprikaKeccak()), + paprikaWorldState, + key.ToPaprikaKeccak(), + paprikaWorldState.GetAccount(key.ToPaprikaKeccak()).IsEmpty, + _writeLock + ); + } + } + + private class PaprikaStorageWriter( + IStorageSetter setter, + IWorldState worldState, + global::Paprika.Crypto.Keccak account, +#pragma warning disable CS9113 // Parameter is unread. + bool originallyEmpty, +#pragma warning restore CS9113 // Parameter is unread. + Lock writeLock + ) : IWorldStateScopeProvider.IStorageWriteBatch + { + public void Dispose() + { + } + + public void Set(in UInt256 index, byte[] value) + { + if (PaprikaScope.Debug) + { + Console.Error.WriteLine($"Set {account}:{index} to {value?.ToHexString()}"); + } + using var _ = writeLock.EnterScope(); + setter.SetStorage(index.SlotToPaprikaKeccak(), value); + } + + public void Clear() + { + if (PaprikaScope.Debug) + { + Console.Error.WriteLine($"destroy account {account}"); + } + using var _ = writeLock.EnterScope(); + worldState.DestroyAccount(account); + } + } +} diff --git a/src/Nethermind/Nethermind.Paprika/PaprikaStateReader.cs b/src/Nethermind/Nethermind.Paprika/PaprikaStateReader.cs new file mode 100644 index 00000000000..4c121d08037 --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/PaprikaStateReader.cs @@ -0,0 +1,50 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Db; +using Nethermind.Int256; +using Nethermind.State; +using Nethermind.Trie; +using Paprika.Chain; +using Keccak = Paprika.Crypto.Keccak; + +namespace Nethermind.Paprika; + +public class PaprikaStateReader(IReadOnlyWorldStateAccessor readOnlyWorldStateAccessor, IDb codeDb): IStateReader +{ + + public bool TryGetAccount(BlockHeader? baseBlock, Address address, out AccountStruct account) + { + global::Paprika.Account acc = readOnlyWorldStateAccessor.GetAccount( + (baseBlock?.StateRoot ?? Nethermind.Core.Crypto.Keccak.EmptyTreeHash).ToPaprikaKeccak(), + address.ToPaprikaKeccak()); + + account = acc.ToNethAccountStruct(); + return !account.IsTotallyEmpty; + } + + public ReadOnlySpan GetStorage(BlockHeader? baseBlock, Address address, in UInt256 index) + { + Span buffer = stackalloc byte[32]; + Keccak root = (baseBlock?.StateRoot ?? Nethermind.Core.Crypto.Keccak.EmptyTreeHash).ToPaprikaKeccak(); + buffer = readOnlyWorldStateAccessor.GetStorage(root, address.ToPaprikaKeccak(), index.SlotToPaprikaKeccak(), buffer); + return buffer.IsEmpty ? null : buffer.ToArray(); + } + + public byte[]? GetCode(Hash256 codeHash) => codeHash == Nethermind.Core.Crypto.Keccak.OfAnEmptyString ? [] : codeDb[codeHash.Bytes]; + public byte[]? GetCode(in ValueHash256 codeHash) => codeHash == Nethermind.Core.Crypto.Keccak.OfAnEmptyString.ValueHash256 ? [] : codeDb[codeHash.Bytes]; + + + public void RunTreeVisitor(ITreeVisitor treeVisitor, Hash256 stateRoot, VisitingOptions? visitingOptions = null) where TCtx : struct, INodeContext + { + throw new NotImplementedException(); + } + + public bool HasStateForBlock(BlockHeader? baseBlock) + { + Keccak root = (baseBlock?.StateRoot ?? Nethermind.Core.Crypto.Keccak.EmptyTreeHash).ToPaprikaKeccak(); + return readOnlyWorldStateAccessor.HasState(root); + } +} diff --git a/src/Nethermind/Nethermind.Paprika/PaprikaWorldStateManager.cs b/src/Nethermind/Nethermind.Paprika/PaprikaWorldStateManager.cs new file mode 100644 index 00000000000..f1607259ec3 --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/PaprikaWorldStateManager.cs @@ -0,0 +1,92 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Autofac.Features.AttributeFilters; +using Nethermind.Core; +using Nethermind.Db; +using Nethermind.Evm.State; +using Nethermind.State; +using Nethermind.State.SnapServer; +using Nethermind.Trie.Pruning; +using Paprika.Merkle; + +namespace Nethermind.Paprika; + +public class PaprikaWorldStateManager: IWorldStateManager, IAsyncDisposable +{ + private global::Paprika.Chain.Blockchain _paprikaBlockchain; + private global::Paprika.IDb _paprikaDb; + private PaprikaStateReader _stateReader; + + private ComputeMerkleBehavior _merkleBehavior; + private IWorldStateScopeProvider _mainScopeProvider; + private readonly IDb _codeDb; + private SemaphoreSlim _scopeLock = new SemaphoreSlim(1); + + public PaprikaWorldStateManager( + global::Paprika.IDb paprikaDb, + [KeyFilter(DbNames.Code)] IDb codeDb, + ComputeMerkleBehavior computeMerkleBehavior, + global::Paprika.Chain.Blockchain paprikaBlockchain) + { + _paprikaDb = paprikaDb; + _codeDb = codeDb; + _merkleBehavior = computeMerkleBehavior; + _paprikaBlockchain = paprikaBlockchain; + + var readOnlyWorldStateAccessor = _paprikaBlockchain.BuildReadOnlyAccessor(); + _stateReader = new PaprikaStateReader(readOnlyWorldStateAccessor, codeDb); + + _mainScopeProvider = + new PaprikaWorldStateScopeProvider(_paprikaBlockchain, codeDb, _scopeLock); + } + + public IWorldStateScopeProvider GlobalWorldState => _mainScopeProvider; + public IStateReader GlobalStateReader => _stateReader; + public ISnapServer? SnapServer => null; + public IReadOnlyKeyValueStore? HashServer => null; + public IWorldStateScopeProvider CreateResettableWorldState() + { + return new PaprikaReadOnlyStateScopeProvider(_paprikaBlockchain, _codeDb, _scopeLock); + } + +#pragma warning disable CS0067 + public event EventHandler? ReorgBoundaryReached; // TODO: How? +#pragma warning restore CS0067 + public IOverridableWorldScope CreateOverridableWorldScope() + { + return new PaprikaOverridableWorldScope( + new PaprikaReadOnlyStateScopeProvider(_paprikaBlockchain, _codeDb, _scopeLock), _stateReader); + + } + + public bool VerifyTrie(BlockHeader stateAtBlock, CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } + + public void FlushCache(CancellationToken cancellationToken) + { + // TODO: Flush + } + + private bool _wasDisposed = false; + + public ValueTask DisposeAsync() + { + if (_wasDisposed) return ValueTask.CompletedTask; + _wasDisposed = true; + _merkleBehavior.Dispose(); + return ValueTask.CompletedTask; + } + + // Just a fake one + private class PaprikaOverridableWorldScope(IWorldStateScopeProvider worldStateScopeProvider, IStateReader stateReader) : IOverridableWorldScope + { + public IWorldStateScopeProvider WorldState => worldStateScopeProvider; + public IStateReader GlobalStateReader => stateReader; + public void ResetOverrides() + { + } + } +} diff --git a/src/Nethermind/Nethermind.Paprika/PaprikaWorldStateScopeProvider.cs b/src/Nethermind/Nethermind.Paprika/PaprikaWorldStateScopeProvider.cs new file mode 100644 index 00000000000..6b980e9f3a2 --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/PaprikaWorldStateScopeProvider.cs @@ -0,0 +1,64 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Core; +using Nethermind.Evm.State; +using Nethermind.State; +using Paprika.Chain; +using IWorldState = Paprika.Chain.IWorldState; + +namespace Nethermind.Paprika; + +public class PaprikaWorldStateScopeProvider( + global::Paprika.Chain.Blockchain paprikaBlockchain, + IKeyValueStoreWithBatching codeDb, + SemaphoreSlim scopeLock): IWorldStateScopeProvider +{ + public bool HasRoot(BlockHeader? baseBlock) + { + return paprikaBlockchain.HasState((baseBlock?.StateRoot ?? Nethermind.Core.Crypto.Keccak.EmptyTreeHash).ToPaprikaKeccak()); + } + + public IWorldStateScopeProvider.IScope BeginScope(BlockHeader? baseBlock) + { + scopeLock.Wait(); + + IWorldState paprikaWorldState = paprikaBlockchain.StartNew( + (baseBlock?.StateRoot ?? Nethermind.Core.Crypto.Keccak.EmptyTreeHash).ToPaprikaKeccak()); + + PaprikaScope scope = new PaprikaScope(paprikaWorldState, new KeyValueWithBatchingBackedCodeDb(codeDb), scopeLock, false, paprikaBlockchain); + PaprikaScope.DebugBlockNumber = baseBlock?.Number ?? 0; + + if (baseBlock?.Number == 46348) + { + PaprikaScope.Debug = true; + } + else + { + PaprikaScope.Debug = false; + } + + return scope; + } +} + +public class PaprikaReadOnlyStateScopeProvider( + global::Paprika.Chain.Blockchain paprikaBlockchain, + IKeyValueStoreWithBatching codeDb, +#pragma warning disable CS9113 // Parameter is unread. + SemaphoreSlim scopeLock): IWorldStateScopeProvider +#pragma warning restore CS9113 // Parameter is unread. +{ + public bool HasRoot(BlockHeader? baseBlock) + { + return paprikaBlockchain.HasState((baseBlock?.StateRoot ?? Nethermind.Core.Crypto.Keccak.EmptyTreeHash).ToPaprikaKeccak()); + } + + public IWorldStateScopeProvider.IScope BeginScope(BlockHeader? baseBlock) + { + IReadOnlyWorldState paprikaWorldState = paprikaBlockchain.StartReadOnly( + (baseBlock?.StateRoot ?? Nethermind.Core.Crypto.Keccak.EmptyTreeHash).ToPaprikaKeccak()); + + return new ReadOnlyPaprikaScope(paprikaWorldState, new KeyValueWithBatchingBackedCodeDb(codeDb)); + } +} diff --git a/src/Nethermind/Nethermind.Paprika/ReadOnlyPaprikaScope.cs b/src/Nethermind/Nethermind.Paprika/ReadOnlyPaprikaScope.cs new file mode 100644 index 00000000000..aed02c1c49b --- /dev/null +++ b/src/Nethermind/Nethermind.Paprika/ReadOnlyPaprikaScope.cs @@ -0,0 +1,106 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Evm.State; +using Nethermind.Int256; +using Paprika.Chain; + +namespace Nethermind.Paprika; + +internal class ReadOnlyPaprikaScope(IReadOnlyWorldState paprikaWorldState, IWorldStateScopeProvider.ICodeDb codeDb) : IWorldStateScopeProvider.IScope +{ + public void Dispose() + { + paprikaWorldState.Dispose(); + } + + public Hash256 RootHash => paprikaWorldState.Hash.ToNethHash(); + + public void UpdateRootHash() + { + // TODO: Need to call pre commit behaviour manually maybe + } + + public Account? Get(Address address) + { + return paprikaWorldState.GetAccount(address.ToAccountPath.ToPaprikaKeccak()).ToNethAccount(); + } + + public void HintGet(Address address, Account? account) + { + // TODO: Probably not needed + } + + public IWorldStateScopeProvider.ICodeDb CodeDb => codeDb; + public IWorldStateScopeProvider.IStorageTree CreateStorageTree(Address address) + { + return new PaprikaStorageTree(paprikaWorldState, address.ToPaprikaKeccak()); + } + + public IWorldStateScopeProvider.IWorldStateWriteBatch StartWriteBatch(int estimatedAccountNum) + { + return new NoopWriteBatch(); + } + + public void Commit(long blockNumber) + { + } + + private class PaprikaStorageTree(IStateStorageAccessor paprikaWorldState, global::Paprika.Crypto.Keccak address) : IWorldStateScopeProvider.IStorageTree + { + public Hash256 RootHash => paprikaWorldState.GetAccount(address).CodeHash.ToNethHash(); + public byte[]? Get(in UInt256 index) + { + Span buffer = stackalloc byte[32]; + global::Paprika.Crypto.Keccak key = index.SlotToPaprikaKeccak(); + paprikaWorldState.GetStorage(address, key, buffer); + return buffer.IsEmpty ? null : buffer.ToArray(); + } + + public void HintGet(in UInt256 index, byte[]? value) + { + } + + public byte[]? Get(in ValueHash256 hash) + { + return null; + } + } + + private class NoopWriteBatch: IWorldStateScopeProvider.IWorldStateWriteBatch + { + public void Dispose() + { + + } + +#pragma warning disable CS0067 + public event EventHandler? OnAccountUpdated; +#pragma warning restore CS0067 + public void Set(Address key, Account? account) + { + } + + public IWorldStateScopeProvider.IStorageWriteBatch CreateStorageWriteBatch(Address key, int estimatedEntries) + { + return new NoopStorageWriteBatch(); + } + } + + private class NoopStorageWriteBatch : IWorldStateScopeProvider.IStorageWriteBatch + { + public void Dispose() + { + } + + public void Set(in UInt256 index, byte[] value) + { + } + + public void Clear() + { + } + } +} diff --git a/src/Nethermind/Nethermind.Runner/Nethermind.Runner.csproj b/src/Nethermind/Nethermind.Runner/Nethermind.Runner.csproj index cb91c1f9558..ce749b0f846 100644 --- a/src/Nethermind/Nethermind.Runner/Nethermind.Runner.csproj +++ b/src/Nethermind/Nethermind.Runner/Nethermind.Runner.csproj @@ -65,6 +65,7 @@ + @@ -73,6 +74,7 @@ + diff --git a/src/Nethermind/Nethermind.Runner/NethermindPlugins.cs b/src/Nethermind/Nethermind.Runner/NethermindPlugins.cs index ac3d28dbb8e..6a71f0abd3d 100644 --- a/src/Nethermind/Nethermind.Runner/NethermindPlugins.cs +++ b/src/Nethermind/Nethermind.Runner/NethermindPlugins.cs @@ -26,5 +26,6 @@ public static class NethermindPlugins typeof(Nethermind.Taiko.TaikoPlugin), typeof(Nethermind.UPnP.Plugin.UPnPPlugin), typeof(Nethermind.Xdc.XdcPlugin), + typeof(Nethermind.Paprika.PaprikaPlugin), ]; } diff --git a/src/Nethermind/Nethermind.Runner/packages.lock.json b/src/Nethermind/Nethermind.Runner/packages.lock.json index 66249443c4c..4f2899eda21 100644 --- a/src/Nethermind/Nethermind.Runner/packages.lock.json +++ b/src/Nethermind/Nethermind.Runner/packages.lock.json @@ -21,7 +21,10 @@ "type": "Direct", "requested": "[10.0.0, )", "resolved": "10.0.0", - "contentHash": "ECaTMB4NdV9W1es9J6tN0yoXRPUHKMi5+2L7hcVZ5k9zVdxccIx6+vMllwEYcdTaO0mCETEmdH4F0KxCqgnPaw==" + "contentHash": "ECaTMB4NdV9W1es9J6tN0yoXRPUHKMi5+2L7hcVZ5k9zVdxccIx6+vMllwEYcdTaO0mCETEmdH4F0KxCqgnPaw==", + "dependencies": { + "Microsoft.Extensions.FileProviders.Abstractions": "10.0.0" + } }, "Microsoft.VisualStudio.Azure.Containers.Tools.Targets": { "type": "Direct", @@ -53,7 +56,10 @@ "AspNetCore.HealthChecks.UI.Core": { "type": "Transitive", "resolved": "9.0.0", - "contentHash": "TVriy4hgYnhfqz6NAzv8qe62Q8wf82iKUL6WV9selqeFZTq1ILi39Sic6sFQegRysvAVcnxKP/vY8z9Fk8x6XQ==" + "contentHash": "TVriy4hgYnhfqz6NAzv8qe62Q8wf82iKUL6WV9selqeFZTq1ILi39Sic6sFQegRysvAVcnxKP/vY8z9Fk8x6XQ==", + "dependencies": { + "Microsoft.Extensions.Diagnostics.HealthChecks": "8.0.11" + } }, "AspNetCore.HealthChecks.UI.Data": { "type": "Transitive", @@ -69,7 +75,8 @@ "resolved": "1.4.0", "contentHash": "1cnkP90c+zNcRyabjKSA3VYJvpYfkGEpXeekfF8KdTFo3VyUUFOioAsANbG8nsMyedGcmUOqHWd1d3fOXke4VA==", "dependencies": { - "NETStandard.Library": "1.6.1" + "NETStandard.Library": "1.6.1", + "System.Buffers": "4.4.0" } }, "Common.Logging": { @@ -77,13 +84,23 @@ "resolved": "3.4.1", "contentHash": "5eZ/vgEOqzLg4PypZqnJ+wMhhgHyckicbZY4iDxqQ4FtOz0CpdYZ0xQ78aszMzeAJZiLLb5VdR9tPfunVQLz6g==", "dependencies": { - "Common.Logging.Core": "3.4.1" + "Common.Logging.Core": "3.4.1", + "Microsoft.CSharp": "4.0.1", + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Globalization": "4.0.11", + "System.Reflection.TypeExtensions": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Threading": "4.0.11" } }, "Common.Logging.Core": { "type": "Transitive", "resolved": "3.4.1", - "contentHash": "wLHldZHvxsSD6Ahonfj00/SkfHfKqO+YT6jsUwVm8Rch1REL9IArHAcSLXxYxYfu5/4ydGtmXvOtaH3AkVPu0A==" + "contentHash": "wLHldZHvxsSD6Ahonfj00/SkfHfKqO+YT6jsUwVm8Rch1REL9IArHAcSLXxYxYfu5/4ydGtmXvOtaH3AkVPu0A==", + "dependencies": { + "Microsoft.CSharp": "4.0.1" + } }, "FastEnum.Core": { "type": "Transitive", @@ -110,13 +127,17 @@ "resolved": "2.46.6", "contentHash": "ZoRg3KmOJ2urTF4+u3H0b1Yv10xzz2Y/flFWS2tnRmj8dbKLeiJaSRqu4LOBD3ova90evqLkVZ85kUkC4JT4lw==", "dependencies": { - "Grpc.Core.Api": "2.46.6" + "Grpc.Core.Api": "2.46.6", + "System.Memory": "4.5.3" } }, "Grpc.Core.Api": { "type": "Transitive", "resolved": "2.46.6", - "contentHash": "Z7HJGqJYyKb53qfp1jf0wRDYs3sxOnkAFxXAW6q52LLmX/zxzjtFLI9eaWO5UC0weiWjn4iT1FzR+tj9qYZAMg==" + "contentHash": "Z7HJGqJYyKb53qfp1jf0wRDYs3sxOnkAFxXAW6q52LLmX/zxzjtFLI9eaWO5UC0weiWjn4iT1FzR+tj9qYZAMg==", + "dependencies": { + "System.Memory": "4.5.3" + } }, "Humanizer.Core": { "type": "Transitive", @@ -133,7 +154,8 @@ "resolved": "5.2.1", "contentHash": "OuPhDNAw/EoJVEmYO6/ChZUBcug4OGoGKTKLUyBCsGhlKegxJk25LYQ0EL7GCBMgkEL+BYNJukNZyaJ+JNaWog==", "dependencies": { - "IdentityModel": "5.2.0" + "IdentityModel": "5.2.0", + "Microsoft.Extensions.Logging": "6.0.0" } }, "IPNetwork2": { @@ -189,6 +211,16 @@ "resolved": "5.0.0", "contentHash": "pg1W2VwaEQMAiTpGK840hZgzavnqjlCMTVSbtVCXVyT+7AX4mc1o89SPv4TBlAjhgCOo9c1Y+jZ5m3ti2YgGgA==" }, + "Microsoft.AspNetCore.Cryptography.Internal": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "jGlm8BsWcN1IIxLaxcHP6s0u2OEiBMa0HPCiWkMK7xox/h4WP2CRMyk7tV0cJC5LdM3JoR5UUqU2cxat6ElwlA==" + }, + "Microsoft.AspNetCore.DataProtection.Abstractions": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "MFwimSi2FH/CMGydm5EnoQFORoaArEX4QG1nijiRN05XUyJqzWwIlYT4AvnhoU1cGett/EvD416f7OnrDisbiA==" + }, "Microsoft.Bcl.AsyncInterfaces": { "type": "Transitive", "resolved": "6.0.0", @@ -197,19 +229,29 @@ "Microsoft.ClearScript.Core": { "type": "Transitive", "resolved": "7.5.0", - "contentHash": "7BfzQZA7LdgpfJGSy/GBzKuURb32UpJGQObH5WAavkUxS/u9h/KaEl8N4812F6f4UWVrtwI5XdRgLMu6ukt38A==" + "contentHash": "7BfzQZA7LdgpfJGSy/GBzKuURb32UpJGQObH5WAavkUxS/u9h/KaEl8N4812F6f4UWVrtwI5XdRgLMu6ukt38A==", + "dependencies": { + "Microsoft.Win32.Registry": "5.0.0" + } }, "Microsoft.ClearScript.V8.ICUData": { "type": "Transitive", "resolved": "7.5.0", - "contentHash": "brX7rIjvZPt/ZDSZOPf36ULxhlsFcEgg2WLeOXCFkexTH7MWgUGy//6vMry/QvTLhSgDrs5z+8SbEU1krnuxRg==" + "contentHash": "brX7rIjvZPt/ZDSZOPf36ULxhlsFcEgg2WLeOXCFkexTH7MWgUGy//6vMry/QvTLhSgDrs5z+8SbEU1krnuxRg==", + "dependencies": { + "System.Text.RegularExpressions": "4.3.1" + } }, "Microsoft.CodeAnalysis.Common": { "type": "Transitive", "resolved": "4.5.0", "contentHash": "lwAbIZNdnY0SUNoDmZHkVUwLO8UyNnyyh1t/4XsbFxi4Ounb3xszIYZaWhyj5ZjyfcwqwmtMbE7fUTVCqQEIdQ==", "dependencies": { - "Microsoft.CodeAnalysis.Analyzers": "3.3.3" + "Microsoft.CodeAnalysis.Analyzers": "3.3.3", + "System.Collections.Immutable": "6.0.0", + "System.Reflection.Metadata": "6.0.1", + "System.Runtime.CompilerServices.Unsafe": "6.0.0", + "System.Text.Encoding.CodePages": "6.0.0" } }, "Microsoft.CodeAnalysis.CSharp.Workspaces": { @@ -231,7 +273,32 @@ "Humanizer.Core": "2.14.1", "Microsoft.Bcl.AsyncInterfaces": "6.0.0", "Microsoft.CodeAnalysis.Common": "[4.5.0]", - "System.Composition": "6.0.0" + "System.Composition": "6.0.0", + "System.IO.Pipelines": "6.0.3", + "System.Threading.Channels": "6.0.0" + } + }, + "Microsoft.CSharp": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "17h8b5mXa87XYKrrVqdgZ38JefSUqLChUQpXgSnpzsM0nDOhE40FTeNWOJ/YmySGV6tG6T8+hjz6vxbknHJr6A==", + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Dynamic.Runtime": "4.0.11", + "System.Globalization": "4.0.11", + "System.Linq": "4.1.0", + "System.Linq.Expressions": "4.1.0", + "System.ObjectModel": "4.0.12", + "System.Reflection": "4.1.0", + "System.Reflection.Extensions": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Reflection.TypeExtensions": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.InteropServices": "4.1.0", + "System.Threading": "4.0.11" } }, "Microsoft.EntityFrameworkCore": { @@ -240,7 +307,9 @@ "contentHash": "stbjWBTtpQ1HtqXMFyKnXFTr76PvaOHI2b2h85JqBi3eZr00nspvR/a90Zwh8CQ4rVawqLiTG0+0yZQWaav+sQ==", "dependencies": { "Microsoft.EntityFrameworkCore.Abstractions": "8.0.11", - "Microsoft.EntityFrameworkCore.Analyzers": "8.0.11" + "Microsoft.EntityFrameworkCore.Analyzers": "8.0.11", + "Microsoft.Extensions.Caching.Memory": "8.0.1", + "Microsoft.Extensions.Logging": "8.0.1" } }, "Microsoft.EntityFrameworkCore.Abstractions": { @@ -278,14 +347,174 @@ "resolved": "8.0.11", "contentHash": "3TuuW3i5I4Ro0yoaHmi2MqEDGObOVuhLaMEnd/heaLB1fcvm4fu4PevmC4BOWnI0vo176AIlV5o4rEQciLoohw==", "dependencies": { - "Microsoft.EntityFrameworkCore": "8.0.11" + "Microsoft.EntityFrameworkCore": "8.0.11", + "Microsoft.Extensions.Configuration.Abstractions": "8.0.0" + } + }, + "Microsoft.Extensions.Caching.Abstractions": { + "type": "Transitive", + "resolved": "8.0.0", + "contentHash": "3KuSxeHoNYdxVYfg2IRZCThcrlJ1XJqIXkAWikCsbm5C/bCjv7G0WoKDyuR98Q+T607QT2Zl5GsbGRkENcV2yQ==", + "dependencies": { + "Microsoft.Extensions.Primitives": "8.0.0" + } + }, + "Microsoft.Extensions.Caching.Memory": { + "type": "Transitive", + "resolved": "8.0.1", + "contentHash": "HFDnhYLccngrzyGgHkjEDU5FMLn4MpOsr5ElgsBMC4yx6lJh4jeWO7fHS8+TXPq+dgxCmUa/Trl8svObmwW4QA==", + "dependencies": { + "Microsoft.Extensions.Caching.Abstractions": "8.0.0", + "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.2", + "Microsoft.Extensions.Logging.Abstractions": "8.0.2", + "Microsoft.Extensions.Options": "8.0.2", + "Microsoft.Extensions.Primitives": "8.0.0" + } + }, + "Microsoft.Extensions.Configuration": { + "type": "Transitive", + "resolved": "9.0.0", + "contentHash": "YIMO9T3JL8MeEXgVozKt2v79hquo/EFtnY0vgxmLnUvk1Rei/halI7kOWZL2RBeV9FMGzgM9LZA8CVaNwFMaNA==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "9.0.0", + "Microsoft.Extensions.Primitives": "9.0.0" + } + }, + "Microsoft.Extensions.Configuration.Abstractions": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "d2kDKnCsJvY7mBVhcjPSp9BkJk48DsaHPg5u+Oy4f8XaOqnEedRy/USyvnpHL92wpJ6DrTPy7htppUUzskbCXQ==", + "dependencies": { + "Microsoft.Extensions.Primitives": "10.0.0" + } + }, + "Microsoft.Extensions.Configuration.Binder": { + "type": "Transitive", + "resolved": "9.0.0", + "contentHash": "RiScL99DcyngY9zJA2ROrri7Br8tn5N4hP4YNvGdTN/bvg1A3dwvDOxHnNZ3Im7x2SJ5i4LkX1uPiR/MfSFBLQ==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "9.0.0" } }, + "Microsoft.Extensions.DependencyInjection.Abstractions": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA==" + }, "Microsoft.Extensions.DependencyModel": { "type": "Transitive", "resolved": "8.0.2", "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" }, + "Microsoft.Extensions.Diagnostics": { + "type": "Transitive", + "resolved": "8.0.0", + "contentHash": "3PZp/YSkIXrF7QK7PfC1bkyRYwqOHpWFad8Qx+4wkuumAeXo1NHaxpS9LboNA9OvNSAu+QOVlXbMyoY+pHSqcw==", + "dependencies": { + "Microsoft.Extensions.Configuration": "8.0.0", + "Microsoft.Extensions.Diagnostics.Abstractions": "8.0.0", + "Microsoft.Extensions.Options.ConfigurationExtensions": "8.0.0" + } + }, + "Microsoft.Extensions.Diagnostics.Abstractions": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "SfK89ytD61S7DgzorFljSkUeluC1ncn6dtZgwc0ot39f/BEYWBl5jpgvodxduoYAs1d9HG8faCDRZxE95UMo2A==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0", + "Microsoft.Extensions.Options": "10.0.0" + } + }, + "Microsoft.Extensions.Diagnostics.HealthChecks": { + "type": "Transitive", + "resolved": "8.0.11", + "contentHash": "zLgN22Zp9pk8RHlwssRTexw4+a6wqOnKWN+VejdPn5Yhjql4XiBhkFo35Nu8mmqHIk/UEmmCnMGLWq75aFfkOw==", + "dependencies": { + "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions": "8.0.11", + "Microsoft.Extensions.Hosting.Abstractions": "8.0.1", + "Microsoft.Extensions.Logging.Abstractions": "8.0.2", + "Microsoft.Extensions.Options": "8.0.2" + } + }, + "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions": { + "type": "Transitive", + "resolved": "8.0.11", + "contentHash": "So3JUdRxozRjvQ3cxU6F3nI/i4emDnjane6yMYcJhvTTTu29ltlIdoXjkFGRceIWz8yKvuEpzXItZ0x5GvN2nQ==" + }, + "Microsoft.Extensions.FileProviders.Abstractions": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "/ppSdehKk3fuXjlqCDgSOtjRK/pSHU8eWgzSHfHdwVm5BP4Dgejehkw+PtxKG2j98qTDEHDst2Y99aNsmJldmw==", + "dependencies": { + "Microsoft.Extensions.Primitives": "10.0.0" + } + }, + "Microsoft.Extensions.Hosting.Abstractions": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "KrN6TGFwCwqOkLLk/idW/XtDQh+8In+CL9T4M1Dx+5ScsjTq4TlVbal8q532m82UYrMr6RiQJF2HvYCN0QwVsA==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.0", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0", + "Microsoft.Extensions.Diagnostics.Abstractions": "10.0.0", + "Microsoft.Extensions.FileProviders.Abstractions": "10.0.0", + "Microsoft.Extensions.Logging.Abstractions": "10.0.0" + } + }, + "Microsoft.Extensions.Http": { + "type": "Transitive", + "resolved": "8.0.0", + "contentHash": "cWz4caHwvx0emoYe7NkHPxII/KkTI8R/LC9qdqJqnKv2poTJ4e2qqPGQqvRoQ5kaSA4FU5IV3qFAuLuOhoqULQ==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "8.0.0", + "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0", + "Microsoft.Extensions.Diagnostics": "8.0.0", + "Microsoft.Extensions.Logging": "8.0.0", + "Microsoft.Extensions.Logging.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.0" + } + }, + "Microsoft.Extensions.Logging.Configuration": { + "type": "Transitive", + "resolved": "9.0.0", + "contentHash": "H05HiqaNmg6GjH34ocYE9Wm1twm3Oz2aXZko8GTwGBzM7op2brpAA8pJ5yyD1OpS1mXUtModBYOlcZ/wXeWsSg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "9.0.0", + "Microsoft.Extensions.Configuration.Abstractions": "9.0.0", + "Microsoft.Extensions.Configuration.Binder": "9.0.0", + "Microsoft.Extensions.DependencyInjection.Abstractions": "9.0.0", + "Microsoft.Extensions.Logging": "9.0.0", + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", + "Microsoft.Extensions.Options": "9.0.0", + "Microsoft.Extensions.Options.ConfigurationExtensions": "9.0.0" + } + }, + "Microsoft.Extensions.Options": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "8oCAgXOow5XDrY9HaXX1QmH3ORsyZO/ANVHBlhLyCeWTH5Sg4UuqZeOTWJi6484M+LqSx0RqQXDJtdYy2BNiLQ==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0", + "Microsoft.Extensions.Primitives": "10.0.0" + } + }, + "Microsoft.Extensions.Options.ConfigurationExtensions": { + "type": "Transitive", + "resolved": "9.0.0", + "contentHash": "Ob3FXsXkcSMQmGZi7qP07EQ39kZpSBlTcAZLbJLdI4FIf0Jug8biv2HTavWmnTirchctPlq9bl/26CXtQRguzA==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "9.0.0", + "Microsoft.Extensions.Configuration.Binder": "9.0.0", + "Microsoft.Extensions.DependencyInjection.Abstractions": "9.0.0", + "Microsoft.Extensions.Options": "9.0.0", + "Microsoft.Extensions.Primitives": "9.0.0" + } + }, + "Microsoft.Extensions.Primitives": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "inRnbpCS0nwO/RuoZIAqxQUuyjaknOOnCEZB55KSMMjRhl0RQDttSmLSGsUJN3RQ3ocf5NDLFd2mOQViHqMK5w==" + }, "Microsoft.IdentityModel.Abstractions": { "type": "Transitive", "resolved": "8.15.0", @@ -304,13 +533,28 @@ "resolved": "8.15.0", "contentHash": "zUE9ysJXBtXlHHRtcRK3Sp8NzdCI1z/BRDTXJQ2TvBoI0ENRtnufYIep0O5TSCJRJGDwwuLTUx+l/bEYZUxpCA==", "dependencies": { + "Microsoft.Extensions.Logging.Abstractions": "10.0.0", "Microsoft.IdentityModel.Logging": "8.15.0" } }, "Microsoft.NETCore.Platforms": { "type": "Transitive", - "resolved": "1.1.0", - "contentHash": "kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==" + "resolved": "5.0.0", + "contentHash": "VyPlqzH2wavqquTcYpkIIAQ6WdenuKoFN0BdYBbCWsclXacSOHNQn66Gt4z5NBqEYW0FAPm5rlvki9ZiCij5xQ==" + }, + "Microsoft.NETCore.Targets": { + "type": "Transitive", + "resolved": "1.1.3", + "contentHash": "3Wrmi0kJDzClwAC+iBdUBpEKmEle8FQNsCs77fkiOIw/9oYA07bL1EZNX0kQ2OMN3xpwvl0vAtOCYY3ndDNlhQ==" + }, + "Microsoft.Win32.Registry": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dDoKi0PnDz31yAyETfRntsLArTlVAVzUzCIvvEDsDsucrl33Dl8pIJG06ePTJTI3tGpeyHS9Cq7Foc/s4EeKcg==", + "dependencies": { + "System.Security.AccessControl": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } }, "Mono.TextTemplating": { "type": "Transitive", @@ -354,13 +598,18 @@ "dependencies": { "Nethermind.DotNetty.Buffers": "1.0.2.76", "Nethermind.DotNetty.Common": "1.0.2.76", - "Nethermind.DotNetty.Transport": "1.0.2.76" + "Nethermind.DotNetty.Transport": "1.0.2.76", + "System.Collections.Immutable": "1.5.0" } }, "Nethermind.DotNetty.Common": { "type": "Transitive", "resolved": "1.0.2.76", - "contentHash": "rraxAOK8Pww3ReW2NkCCr/pwXTp88gI4lXaeA5TriPnp1wZg8jJdZYIj2m2+HKkVtw1C1F1sRA7FzfgBodA3Tw==" + "contentHash": "rraxAOK8Pww3ReW2NkCCr/pwXTp88gI4lXaeA5TriPnp1wZg8jJdZYIj2m2+HKkVtw1C1F1sRA7FzfgBodA3Tw==", + "dependencies": { + "Microsoft.Extensions.Logging": "5.0.0", + "System.Runtime.CompilerServices.Unsafe": "5.0.0" + } }, "Nethermind.Libp2p.Core": { "type": "Transitive", @@ -369,6 +618,9 @@ "dependencies": { "BouncyCastle.Cryptography": "2.4.0", "Google.Protobuf": "3.28.3", + "Microsoft.Extensions.DependencyInjection": "9.0.0", + "Microsoft.Extensions.DependencyInjection.Abstractions": "9.0.0", + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", "Nethermind.Multiformats.Address": "1.1.8", "SimpleBase": "4.0.2" } @@ -379,6 +631,7 @@ "contentHash": "8hEzwS9eYYy1xvmXq+6VcfKcOflEmnPdT5UA8Lhr0cdK2af+wV6tMwHhuvqF0L7N+bdaFMNcUUhBhy17jafutw==", "dependencies": { "Google.Protobuf": "3.28.3", + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", "Nethermind.Libp2p.Core": "1.0.0-preview.45", "Nethermind.Libp2p.Protocols.IpTcp": "1.0.0-preview.45" } @@ -388,6 +641,7 @@ "resolved": "1.0.0-preview.45", "contentHash": "vDoUfrz/45OEKc9TMEs9l0wPWW4r49opS/J+bh3zUTMLaWWf9jl8zkbPh5mz9moBh1JdDVuLRSPT3zRd8/Gvkg==", "dependencies": { + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", "Nethermind.Libp2p.Core": "1.0.0-preview.45" } }, @@ -397,6 +651,7 @@ "contentHash": "NZhHziBoq9mGeqV8o0QMoKOnBLjyPEIhEIcsnL6rdV4nJ1PwRWort8O811dh4aWq8rxVm1dkj66U4Q/ZwEX+JQ==", "dependencies": { "Makaretu.Dns.Multicast": "0.27.0", + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", "Nethermind.Libp2p.Core": "1.0.0-preview.45" } }, @@ -454,6 +709,7 @@ "contentHash": "TfdjpazHxi/Pxfa8oR3wPDoWzgTJJ9L0OHQo5hkozte9mpa8sUim+cfIiEC9qtAjq4D1/MfpvfQaZZzeRh2akQ==", "dependencies": { "BouncyCastle.Cryptography": "2.4.0", + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", "Nethermind.Libp2p.Core": "1.0.0-preview.45" } }, @@ -471,6 +727,7 @@ "resolved": "1.0.0-preview.45", "contentHash": "BJXIfz9T1zPRJjVHGn4qJLvZu2vKnjoSoT9Zd+nYePc+C4ESwhtFuuHHSirnuKqJ/GVY2v8lvhb+fnjYSV3E8w==", "dependencies": { + "Microsoft.Extensions.Logging": "9.0.0", "Nethermind.Libp2p.Core": "1.0.0-preview.45", "Nethermind.Libp2p.Protocols.Quic": "1.0.0-preview.45" } @@ -480,6 +737,7 @@ "resolved": "1.0.0-preview.45", "contentHash": "ElNnTVoTxpHZMGTFbKTndQ1C3jFMMVLQfK1wzJVAw5sD294Yur42UKxdHtrzQJEJ/XHARz5ORxwtWcbprCQLDA==", "dependencies": { + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", "Nethermind.Libp2p.Core": "1.0.0-preview.45" } }, @@ -529,6 +787,9 @@ "contentHash": "fYnHQ8yZcj9W0fPGbzMkZUnE14aGGTFS8WE0Ow2hXiGhJ61Tv71cTi1yuugHxPCLyb87JpWMkq4lix8Rf06vtA==", "dependencies": { "NETStandard.Library": "1.6.1", + "System.Buffers": "4.5.0", + "System.Memory": "4.5.0", + "System.ValueTuple": "4.4.0", "libsodium": "1.0.16" } }, @@ -562,18 +823,48 @@ "prometheus-net": { "type": "Transitive", "resolved": "8.2.1", - "contentHash": "3wVgdEPOCBF752s2xps5T+VH+c9mJK8S8GKEDg49084P6JZMumTZI5Te6aJ9MQpX0sx7om6JOnBpIi7ZBmmiDQ==" + "contentHash": "3wVgdEPOCBF752s2xps5T+VH+c9mJK8S8GKEDg49084P6JZMumTZI5Te6aJ9MQpX0sx7om6JOnBpIi7ZBmmiDQ==", + "dependencies": { + "Microsoft.Extensions.Http": "3.1.0", + "Microsoft.Extensions.ObjectPool": "7.0.0" + } }, "SimpleBase": { "type": "Transitive", "resolved": "4.0.2", - "contentHash": "sNKHP2Qzy4DafamgH44UGg1YeyHFT08AMgHPraxYt4CVBoHHYD5f0MjbBfdmtGca69xikPU5aV8H+MMP7ZnfIg==" + "contentHash": "sNKHP2Qzy4DafamgH44UGg1YeyHFT08AMgHPraxYt4CVBoHHYD5f0MjbBfdmtGca69xikPU5aV8H+MMP7ZnfIg==", + "dependencies": { + "System.Memory": "4.5.5" + } + }, + "System.Buffers": { + "type": "Transitive", + "resolved": "4.5.0", + "contentHash": "pL2ChpaRRWI/p4LXyy4RgeWlYF2sgfj/pnVMvBqwNFr5cXg7CXNnWZWxrOONLg8VGdFB8oB+EG2Qw4MLgTOe+A==" }, "System.CodeDom": { "type": "Transitive", "resolved": "4.4.0", "contentHash": "2sCCb7doXEwtYAbqzbF/8UAeDRMNmPaQbU2q50Psg1J9KzumyVVCgKQY8s53WIPTufNT0DpSe9QRvVjOzfDWBA==" }, + "System.Collections": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "YUJGz6eFKqS0V//mLt25vFGrrCvOnsXjlvFQs+KimpwNxug9x0Pzy4PlFMU3Q2IzqAa9G2L4LsK3+9vCBK7oTg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + } + }, + "System.Collections.Immutable": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "l4zZJ1WU2hqpQQHXz1rvC3etVZN+2DLmQMO79FhOTZHMn8tDRr+WU287sbomD0BETlmKDn0ygUgVy9k5xkkJdA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.0.0" + } + }, "System.Composition": { "type": "Transitive", "resolved": "6.0.0", @@ -622,6 +913,53 @@ "System.Composition.Runtime": "6.0.0" } }, + "System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "w5U95fVKHY4G8ASs/K5iK3J5LY+/dLFd4vKejsnI/ZhBsWS9hQakfx3Zr7lRWKg4tAw9r4iktyvsTagWkqYCiw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + } + }, + "System.Diagnostics.EventLog": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "uaFRda9NjtbJRkdx311eXlAA3n2em7223c1A8d1VWyl+4FL9vkG7y2lpPfBU9HYdj/9KgdRNdn1vFK8ZYCYT/A==" + }, + "System.Dynamic.Runtime": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "db34f6LHYM0U0JpE+sOmjar27BnqTVkbLJhgfwMpTdgTigG/Hna3m2MYVwnFzGGKnEJk2UXFuoVTr8WUbU91/A==", + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Globalization": "4.0.11", + "System.Linq": "4.1.0", + "System.Linq.Expressions": "4.1.0", + "System.ObjectModel": "4.0.12", + "System.Reflection": "4.1.0", + "System.Reflection.Emit": "4.0.1", + "System.Reflection.Emit.ILGeneration": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Reflection.TypeExtensions": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Threading": "4.0.11" + } + }, + "System.Globalization": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "B95h0YLEL2oSnwF/XjqSWKnwKOy/01VWkNlsCeMTFJLLabflpGV26nK164eRs5GiaRSBGpOxQ3pKoSnnyZN5pg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + } + }, "System.IdentityModel.Tokens.Jwt": { "type": "Transitive", "resolved": "7.1.2", @@ -631,140 +969,443 @@ "Microsoft.IdentityModel.Tokens": "7.1.2" } }, - "System.Reactive": { + "System.IO": { "type": "Transitive", - "resolved": "6.0.0", - "contentHash": "31kfaW4ZupZzPsI5PVe77VhnvFF55qgma7KZr/E0iFTs6fmdhhG8j0mgEx620iLTey1EynOkEfnyTjtNEpJzGw==" + "resolved": "4.1.0", + "contentHash": "3KlTJceQc3gnGIaHZ7UBZO26SHL1SHE4ddrmiwumFnId+CEHP+O8r386tZKaE6zlk5/mF8vifMBzHj9SaXN+mQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading.Tasks": "4.0.11" + } }, - "Testably.Abstractions.FileSystem.Interface": { + "System.IO.Pipelines": { "type": "Transitive", - "resolved": "9.0.0", - "contentHash": "uksk86YlnzAdyfVNu3wICU0X5iXVe9LF7Q3UkngNliHWEvM5gvAlOUr+jmd9JwmbJWISH5+i1vyXE02lEVz7WQ==" + "resolved": "6.0.3", + "contentHash": "ryTgF+iFkpGZY1vRQhfCzX0xTdlV3pyaTTqRu2ETbEv+HlV7O6y7hyQURnghNIXvctl5DuZ//Dpks6HdL/Txgw==" }, - "Tmds.LibC": { + "System.Linq": { "type": "Transitive", - "resolved": "0.2.0", - "contentHash": "+RvLuNHOLW7cxzgDe9yHLoayBgjsuH2/gJtJnuVMxweKrxxYT6TwQNAmt06SFWpjwk68aRcwwD4FfMMA6tZvVA==" + "resolved": "4.1.0", + "contentHash": "bQ0iYFOQI0nuTnt+NQADns6ucV4DUvMdwN6CbkB1yj8i7arTGiTN5eok1kQwdnnNWSDZfIUySQY+J3d5KjWn0g==", + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0" + } }, - "YamlDotNet": { + "System.Linq.Expressions": { "type": "Transitive", - "resolved": "16.0.0", - "contentHash": "kZ4jR5ltFhnjaUqK9x81zXRIUTH4PTXTTEmJDNQdkDLQhcv+2Nl19r0dCSvPW1mstOYBfXTnjdieRbUO6gHMDw==" + "resolved": "4.1.0", + "contentHash": "I+y02iqkgmCAyfbqOmSDOgqdZQ5tTj80Akm5BPSS8EeB0VGWdy6X1KCoYe8Pk6pwDoAKZUOdLVxnTJcExiv5zw==", + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Globalization": "4.0.11", + "System.IO": "4.1.0", + "System.Linq": "4.1.0", + "System.ObjectModel": "4.0.12", + "System.Reflection": "4.1.0", + "System.Reflection.Emit": "4.0.1", + "System.Reflection.Emit.ILGeneration": "4.0.1", + "System.Reflection.Emit.Lightweight": "4.0.1", + "System.Reflection.Extensions": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Reflection.TypeExtensions": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Threading": "4.0.11" + } + }, + "System.Memory": { + "type": "Transitive", + "resolved": "4.5.5", + "contentHash": "XIWiDvKPXaTveaB7HVganDlOCRoj03l+jrwNvcge/t8vhGYKvqV+dMv6G4SAX2NoNmN0wZfVPTAlFwZcZvVOUw==" }, - "nethermind.abi": { - "type": "Project", + "System.ObjectModel": { + "type": "Transitive", + "resolved": "4.0.12", + "contentHash": "tAgJM1xt3ytyMoW4qn4wIqgJYm7L7TShRZG4+Q4Qsi2PCcj96pXN7nRywS9KkB3p/xDUjc2HSwP9SROyPYDYKQ==", "dependencies": { - "MathNet.Numerics.FSharp": "[5.0.0, )", - "Nethermind.Core": "[1.36.0-unstable, )" + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Threading": "4.0.11" } }, - "nethermind.api": { - "type": "Project", + "System.Reactive": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "31kfaW4ZupZzPsI5PVe77VhnvFF55qgma7KZr/E0iFTs6fmdhhG8j0mgEx620iLTey1EynOkEfnyTjtNEpJzGw==" + }, + "System.Reflection": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "JCKANJ0TI7kzoQzuwB/OoJANy1Lg338B6+JVacPl4TpUwi3cReg3nMLplMq2uqYfHFQpKIlHAUVAJlImZz/4ng==", "dependencies": { - "Nethermind.Blockchain": "[1.36.0-unstable, )", - "Nethermind.Facade": "[1.36.0-unstable, )", - "Nethermind.Grpc": "[1.36.0-unstable, )", - "Nethermind.History": "[1.36.0-unstable, )", - "Nethermind.JsonRpc": "[1.36.0-unstable, )", - "Nethermind.Monitoring": "[1.36.0-unstable, )", - "Nethermind.Network": "[1.36.0-unstable, )", - "Nethermind.Sockets": "[1.36.0-unstable, )" + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0" } }, - "nethermind.blockchain": { - "type": "Project", + "System.Reflection.Emit": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "P2wqAj72fFjpP6wb9nSfDqNBMab+2ovzSDzUZK7MVIm54tBJEPr9jWfSjjoTpPwj1LeKcmX3vr0ttyjSSFM47g==", "dependencies": { - "Microsoft.ClearScript.V8.Native.linux-arm64": "[7.5.0, )", - "Microsoft.ClearScript.V8.Native.linux-x64": "[7.5.0, )", - "Microsoft.ClearScript.V8.Native.osx-arm64": "[7.5.0, )", - "Microsoft.ClearScript.V8.Native.osx-x64": "[7.5.0, )", - "Microsoft.ClearScript.V8.Native.win-x64": "[7.5.0, )", - "Nethermind.Abi": "[1.36.0-unstable, )", - "Nethermind.Core": "[1.36.0-unstable, )", - "Nethermind.Db": "[1.36.0-unstable, )", - "Nethermind.Evm": "[1.36.0-unstable, )", - "Nethermind.Evm.Precompiles": "[1.36.0-unstable, )", - "Nethermind.Network.Stats": "[1.36.0-unstable, )", - "Nethermind.Specs": "[1.36.0-unstable, )", - "Nethermind.State": "[1.36.0-unstable, )", - "Nethermind.TxPool": "[1.36.0-unstable, )", - "Polly": "[8.6.4, )" + "System.IO": "4.1.0", + "System.Reflection": "4.1.0", + "System.Reflection.Emit.ILGeneration": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0" } }, - "nethermind.config": { - "type": "Project", + "System.Reflection.Emit.ILGeneration": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "Ov6dU8Bu15Bc7zuqttgHF12J5lwSWyTf1S+FJouUXVMSqImLZzYaQ+vRr1rQ0OZ0HqsrwWl4dsKHELckQkVpgA==", "dependencies": { - "Nethermind.Core": "[1.36.0-unstable, )", - "NonBlocking": "[2.1.2, )", - "System.Configuration.ConfigurationManager": "[10.0.0, )" + "System.Reflection": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0" } }, - "nethermind.consensus": { - "type": "Project", + "System.Reflection.Emit.Lightweight": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "sSzHHXueZ5Uh0OLpUQprhr+ZYJrLPA2Cmr4gn0wj9+FftNKXx8RIMKvO9qnjk2ebPYUjZ+F2ulGdPOsvj+MEjA==", "dependencies": { - "Nethermind.Blockchain": "[1.36.0-unstable, )", - "Nethermind.Config": "[1.36.0-unstable, )", - "Nethermind.Core": "[1.36.0-unstable, )", - "Nethermind.Crypto": "[1.36.0-unstable, )", - "Nethermind.Evm": "[1.36.0-unstable, )", - "Nethermind.TxPool": "[1.36.0-unstable, )" + "System.Reflection": "4.1.0", + "System.Reflection.Emit.ILGeneration": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0" } }, - "nethermind.consensus.aura": { - "type": "Project", + "System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "GYrtRsZcMuHF3sbmRHfMYpvxZoIN2bQGrYGerUiWLEkqdEUQZhH3TRSaC/oI4wO0II1RKBPlpIa1TOMxIcOOzQ==", "dependencies": { - "BouncyCastle.Cryptography": "[2.6.2, )", - "Nethermind.Abi": "[1.36.0-unstable, )", - "Nethermind.Api": "[1.36.0-unstable, )", - "Nethermind.Blockchain": "[1.36.0-unstable, )", - "Nethermind.Facade": "[1.36.0-unstable, )", - "Nethermind.Init": "[1.36.0-unstable, )", - "Nethermind.Specs": "[1.36.0-unstable, )", - "Nethermind.Synchronization": "[1.36.0-unstable, )", - "Nito.Collections.Deque": "[1.2.1, )" + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0" } }, - "nethermind.consensus.clique": { - "type": "Project", + "System.Reflection.Metadata": { + "type": "Transitive", + "resolved": "6.0.1", + "contentHash": "III/lNMSn0ZRBuM9m5Cgbiho5j81u0FAEagFX5ta2DKbljZ3T0IpD8j+BIiHQPeKqJppWS9bGEp6JnKnWKze0g==", "dependencies": { - "Nethermind.Api": "[1.36.0-unstable, )", - "Nethermind.Blockchain": "[1.36.0-unstable, )", - "Nethermind.Consensus": "[1.36.0-unstable, )", - "Nethermind.JsonRpc": "[1.36.0-unstable, )" + "System.Collections.Immutable": "6.0.0" } }, - "nethermind.consensus.ethash": { - "type": "Project", + "System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "4inTox4wTBaDhB7V3mPvp9XlCbeGYWVEM9/fXALd52vNEAVisc1BoVWQPuUuD0Ga//dNbA/WeMy9u9mzLxGTHQ==", "dependencies": { - "Nethermind.Api": "[1.36.0-unstable, )", - "Nethermind.Blockchain": "[1.36.0-unstable, )", - "Nethermind.Consensus": "[1.36.0-unstable, )", - "Nethermind.Core": "[1.36.0-unstable, )", - "Nethermind.Crypto": "[1.36.0-unstable, )", - "Nethermind.Serialization.Rlp": "[1.36.0-unstable, )", - "Nethermind.Specs": "[1.36.0-unstable, )" + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" } }, - "nethermind.core": { - "type": "Project", + "System.Reflection.TypeExtensions": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "tsQ/ptQ3H5FYfON8lL4MxRk/8kFyE0A+tGPXmVP967cT/gzLHYxIejIYSxp4JmIeFHVP78g/F2FE1mUUTbDtrg==", "dependencies": { - "Autofac": "[9.0.0, )", - "Autofac.Extensions.DependencyInjection": "[10.0.0, )", - "FastEnum": "[2.0.6, )", - "Microsoft.IO.RecyclableMemoryStream": "[3.0.1, )", - "Microsoft.IdentityModel.JsonWebTokens": "[8.15.0, )", - "Nethermind.Crypto.SecP256k1": "[1.5.0, )", - "Nethermind.Logging": "[1.36.0-unstable, )", - "Nethermind.Numerics.Int256": "[1.3.6, )", - "NonBlocking": "[2.1.2, )", - "TestableIO.System.IO.Abstractions.Wrappers": "[22.0.16, )" + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0" } }, - "nethermind.crypto": { - "type": "Project", + "System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "TxwVeUNoTgUOdQ09gfTjvW411MF+w9MBYL7AtNVc+HtBCFlutPLhUCdZjNkjbhj3bNQWMdHboF0KIWEOjJssbA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Globalization": "4.0.11", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0" + } + }, + "System.Runtime": { + "type": "Transitive", + "resolved": "4.3.1", + "contentHash": "abhfv1dTK6NXOmu4bgHIONxHyEqFjW8HwXPmpY9gmll+ix9UNo4XDcmzJn6oLooftxNssVHdJC1pGT9jkSynQg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.1", + "Microsoft.NETCore.Targets": "1.1.3" + } + }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg==" + }, + "System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "CUOHjTT/vgP0qGW22U4/hDlOqXmcPq5YicBaXdUR2UiUoLwBT+olO6we4DVbq57jeX5uXH2uerVZhf0qGj+sVQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + } + }, + "System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "nCJvEKguXEvk2ymk1gqj625vVnlK3/xdGzx0vOKicQkoquaTBJTP13AIYkocSUwHCLNBwUbXTqTWGDxBTWpt7g==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + } + }, + "System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "16eu3kjHS633yYdkjwShDHZLRNMKVi/s0bY8ODiqJ2RfMhDMAwxZaUaWVnZ2P71kr/or+X9o/xFWtNqz8ivieQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Handles": "4.0.1" + } + }, + "System.Security.AccessControl": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dagJ1mHZO3Ani8GH0PHpPEe/oYO+rVdbQjvjJkBRNQkX4t0r1iaeGn8+/ybkSLEan3/slM0t59SVdHzuHf2jmw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } + }, + "System.Security.Cryptography.Pkcs": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "UPWqLSygJlFerRi9XNIuM0a1VC8gHUIufyP24xQ0sc+XimqUAEcjpOz9DhKpyDjH+5B/wO3RpC0KpkEeDj/ddg==" + }, + "System.Security.Cryptography.Xml": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "Vb1vrLKtg0icvKk0GCzCErclNRH6NB7TMZ9BgXH9xqQ0lFlByQeoVwbewteJDuOPh1774GuVLD7rQrxhrpCCuA==", + "dependencies": { + "System.Security.Cryptography.Pkcs": "10.0.0" + } + }, + "System.Security.Principal.Windows": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "t0MGLukB5WAVU9bO3MGzvlGnyJPgUlcwerXn1kzBRjwLKixT96XV0Uza41W49gVd8zEMFu9vQEFlv0IOrytICA==" + }, + "System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "U3gGeMlDZXxCEiY4DwVLSacg+DFWCvoiX+JThA/rvw37Sqrku7sEFeVBBBMBnfB6FeZHsyDx85HlKL19x0HtZA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + } + }, + "System.Text.Encoding.CodePages": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "ZFCILZuOvtKPauZ/j/swhvw68ZRi9ATCfvGbk1QfydmcXBkIWecWKn/250UH7rahZ5OoDBaiAudJtPvLwzw85A==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.0.0" + } + }, + "System.Text.RegularExpressions": { + "type": "Transitive", + "resolved": "4.3.1", + "contentHash": "N0kNRrWe4+nXOWlpLT4LAY5brb8caNFlUuIRpraCVMDLYutKkol1aV079rQjLuSxKMJT2SpBQsYX9xbcTMmzwg==", + "dependencies": { + "System.Runtime": "4.3.1" + } + }, + "System.Threading": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "N+3xqIcg3VDKyjwwCGaZ9HawG9aC6cSDI+s7ROma310GQo8vilFZa86hqKppwTHleR/G0sfOzhvgnUxWCR/DrQ==", + "dependencies": { + "System.Runtime": "4.1.0", + "System.Threading.Tasks": "4.0.11" + } + }, + "System.Threading.Channels": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "TY8/9+tI0mNaUMgntOxxaq2ndTkdXqLSxvPmas7XEqOlv9lQtB7wLjYGd756lOaO7Dvb5r/WXhluM+0Xe87v5Q==" + }, + "System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "k1S4Gc6IGwtHGT8188RSeGaX86Qw/wnrgNLshJvsdNUOPP9etMmo8S07c+UlOAx4K/xLuN9ivA1bD0LVurtIxQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + } + }, + "System.Threading.Tasks.Dataflow": { + "type": "Transitive", + "resolved": "8.0.0", + "contentHash": "7V0I8tPa9V7UxMx/+7DIwkhls5ouaEMQx6l/GwGm1Y8kJQ61On9B/PxCXFLbgu5/C47g0BP2CUYs+nMv1+Oaqw==" + }, + "System.ValueTuple": { + "type": "Transitive", + "resolved": "4.4.0", + "contentHash": "BahUww/+mdP4ARCAh2RQhQTg13wYLVrBb9SYVgW8ZlrwjraGCXHGjo0oIiUfZ34LUZkMMR+RAzR7dEY4S1HeQQ==" + }, + "Testably.Abstractions.FileSystem.Interface": { + "type": "Transitive", + "resolved": "9.0.0", + "contentHash": "uksk86YlnzAdyfVNu3wICU0X5iXVe9LF7Q3UkngNliHWEvM5gvAlOUr+jmd9JwmbJWISH5+i1vyXE02lEVz7WQ==" + }, + "Tmds.LibC": { + "type": "Transitive", + "resolved": "0.2.0", + "contentHash": "+RvLuNHOLW7cxzgDe9yHLoayBgjsuH2/gJtJnuVMxweKrxxYT6TwQNAmt06SFWpjwk68aRcwwD4FfMMA6tZvVA==" + }, + "YamlDotNet": { + "type": "Transitive", + "resolved": "16.0.0", + "contentHash": "kZ4jR5ltFhnjaUqK9x81zXRIUTH4PTXTTEmJDNQdkDLQhcv+2Nl19r0dCSvPW1mstOYBfXTnjdieRbUO6gHMDw==" + }, + "nethermind.abi": { + "type": "Project", + "dependencies": { + "MathNet.Numerics.FSharp": "[5.0.0, )", + "Nethermind.Core": "[1.36.0-unstable, )" + } + }, + "nethermind.api": { + "type": "Project", + "dependencies": { + "Nethermind.Blockchain": "[1.36.0-unstable, )", + "Nethermind.Facade": "[1.36.0-unstable, )", + "Nethermind.Grpc": "[1.36.0-unstable, )", + "Nethermind.History": "[1.36.0-unstable, )", + "Nethermind.JsonRpc": "[1.36.0-unstable, )", + "Nethermind.Monitoring": "[1.36.0-unstable, )", + "Nethermind.Network": "[1.36.0-unstable, )", + "Nethermind.Sockets": "[1.36.0-unstable, )" + } + }, + "nethermind.blockchain": { + "type": "Project", + "dependencies": { + "Microsoft.ClearScript.V8.Native.linux-arm64": "[7.5.0, )", + "Microsoft.ClearScript.V8.Native.linux-x64": "[7.5.0, )", + "Microsoft.ClearScript.V8.Native.osx-arm64": "[7.5.0, )", + "Microsoft.ClearScript.V8.Native.osx-x64": "[7.5.0, )", + "Microsoft.ClearScript.V8.Native.win-x64": "[7.5.0, )", + "Nethermind.Abi": "[1.36.0-unstable, )", + "Nethermind.Core": "[1.36.0-unstable, )", + "Nethermind.Db": "[1.36.0-unstable, )", + "Nethermind.Evm": "[1.36.0-unstable, )", + "Nethermind.Evm.Precompiles": "[1.36.0-unstable, )", + "Nethermind.Network.Stats": "[1.36.0-unstable, )", + "Nethermind.Specs": "[1.36.0-unstable, )", + "Nethermind.State": "[1.36.0-unstable, )", + "Nethermind.TxPool": "[1.36.0-unstable, )", + "Polly": "[8.6.4, )" + } + }, + "nethermind.config": { + "type": "Project", + "dependencies": { + "Nethermind.Core": "[1.36.0-unstable, )", + "NonBlocking": "[2.1.2, )", + "System.Configuration.ConfigurationManager": "[10.0.0, )" + } + }, + "nethermind.consensus": { + "type": "Project", + "dependencies": { + "Nethermind.Blockchain": "[1.36.0-unstable, )", + "Nethermind.Config": "[1.36.0-unstable, )", + "Nethermind.Core": "[1.36.0-unstable, )", + "Nethermind.Crypto": "[1.36.0-unstable, )", + "Nethermind.Evm": "[1.36.0-unstable, )", + "Nethermind.TxPool": "[1.36.0-unstable, )" + } + }, + "nethermind.consensus.aura": { + "type": "Project", + "dependencies": { + "BouncyCastle.Cryptography": "[2.6.2, )", + "Nethermind.Abi": "[1.36.0-unstable, )", + "Nethermind.Api": "[1.36.0-unstable, )", + "Nethermind.Blockchain": "[1.36.0-unstable, )", + "Nethermind.Facade": "[1.36.0-unstable, )", + "Nethermind.Init": "[1.36.0-unstable, )", + "Nethermind.Specs": "[1.36.0-unstable, )", + "Nethermind.Synchronization": "[1.36.0-unstable, )", + "Nito.Collections.Deque": "[1.2.1, )" + } + }, + "nethermind.consensus.clique": { + "type": "Project", + "dependencies": { + "Nethermind.Api": "[1.36.0-unstable, )", + "Nethermind.Blockchain": "[1.36.0-unstable, )", + "Nethermind.Consensus": "[1.36.0-unstable, )", + "Nethermind.JsonRpc": "[1.36.0-unstable, )" + } + }, + "nethermind.consensus.ethash": { + "type": "Project", + "dependencies": { + "Nethermind.Api": "[1.36.0-unstable, )", + "Nethermind.Blockchain": "[1.36.0-unstable, )", + "Nethermind.Consensus": "[1.36.0-unstable, )", + "Nethermind.Core": "[1.36.0-unstable, )", + "Nethermind.Crypto": "[1.36.0-unstable, )", + "Nethermind.Serialization.Rlp": "[1.36.0-unstable, )", + "Nethermind.Specs": "[1.36.0-unstable, )" + } + }, + "nethermind.core": { + "type": "Project", + "dependencies": { + "Autofac": "[9.0.0, )", + "Autofac.Extensions.DependencyInjection": "[10.0.0, )", + "FastEnum": "[2.0.6, )", + "Microsoft.Extensions.DependencyInjection": "[10.0.0, )", + "Microsoft.Extensions.ObjectPool": "[10.0.0, )", + "Microsoft.IO.RecyclableMemoryStream": "[3.0.1, )", + "Microsoft.IdentityModel.JsonWebTokens": "[8.15.0, )", + "Nethermind.Crypto.SecP256k1": "[1.5.0, )", + "Nethermind.Logging": "[1.36.0-unstable, )", + "Nethermind.Numerics.Int256": "[1.3.6, )", + "NonBlocking": "[2.1.2, )", + "TestableIO.System.IO.Abstractions.Wrappers": "[22.0.16, )" + } + }, + "nethermind.crypto": { + "type": "Project", "dependencies": { "BouncyCastle.Cryptography": "[2.6.2, )", "Ckzg.Bindings": "[2.1.5.1542, )", + "Microsoft.AspNetCore.DataProtection": "[10.0.0, )", + "Microsoft.AspNetCore.DataProtection.Extensions": "[10.0.0, )", "Nethermind.Core": "[1.36.0-unstable, )", "Nethermind.Crypto.Bls": "[1.0.5, )", "Nethermind.Serialization.Rlp": "[1.36.0-unstable, )", @@ -1077,6 +1718,16 @@ "Snappier": "[1.2.0, )" } }, + "nethermind.paprika": { + "type": "Project", + "dependencies": { + "Nethermind.Api": "[1.36.0-unstable, )", + "Nethermind.Config": "[1.36.0-unstable, )", + "Nethermind.Init": "[1.36.0-unstable, )", + "Nethermind.State": "[1.36.0-unstable, )", + "Paprika": "[1.0.0, )" + } + }, "nethermind.seq": { "type": "Project", "dependencies": { @@ -1224,6 +1875,22 @@ "Nethermind.Init": "[1.36.0-unstable, )" } }, + "paprika": { + "type": "Project", + "dependencies": { + "HdrHistogram": "[2.5.0, )", + "Nethermind.Numerics.Int256": "[1.3.6, )", + "NonBlocking": "[2.1.2, )" + } + }, + "paprikaplugin": { + "type": "Project", + "dependencies": { + "Nethermind.Api": "[1.36.0-unstable, )", + "Nethermind.Init": "[1.36.0-unstable, )", + "Paprika": "[1.0.0, )" + } + }, "AspNetCore.HealthChecks.UI": { "type": "CentralTransitive", "requested": "[9.0.0, )", @@ -1232,7 +1899,8 @@ "dependencies": { "AspNetCore.HealthChecks.UI.Data": "9.0.0", "KubernetesClient": "15.0.1", - "Microsoft.EntityFrameworkCore.Design": "8.0.11" + "Microsoft.EntityFrameworkCore.Design": "8.0.11", + "Microsoft.Extensions.Http": "8.0.0" } }, "AspNetCore.HealthChecks.UI.InMemory.Storage": { @@ -1257,7 +1925,8 @@ "resolved": "10.0.0", "contentHash": "ZjR/onUlP7BzQ7VBBigQepWLAyAzi3VRGX3pP6sBqkPRiT61fsTZqbTpRUKxo30TMgbs1o3y6bpLbETix4SJog==", "dependencies": { - "Autofac": "8.1.0" + "Autofac": "8.1.0", + "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.1" } }, "BouncyCastle.Cryptography": { @@ -1336,6 +2005,15 @@ "Grpc.Core": "2.46.6" } }, + "HdrHistogram": { + "type": "CentralTransitive", + "requested": "[2.5.0, )", + "resolved": "2.5.0", + "contentHash": "RE1wG9tbQJDnfgKnBYiR8DNIPC3a9oZeUqDOQmpxcH/xBOqU7T6R20YVndKtk6STglQyGaZCRnWue8WcAo87OA==", + "dependencies": { + "NETStandard.Library": "1.6.1" + } + }, "MathNet.Numerics.FSharp": { "type": "CentralTransitive", "requested": "[5.0.0, )", @@ -1346,6 +2024,31 @@ "MathNet.Numerics": "5.0.0" } }, + "Microsoft.AspNetCore.DataProtection": { + "type": "CentralTransitive", + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "RKU345im2k3hqboK+2ZcBa6oReAUr1m4c/8kf/6/rATNjxVFvWmCMLIP4U1lHhYat+Zmv1TpOlCw+8/7xATRhA==", + "dependencies": { + "Microsoft.AspNetCore.Cryptography.Internal": "10.0.0", + "Microsoft.AspNetCore.DataProtection.Abstractions": "10.0.0", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0", + "Microsoft.Extensions.Hosting.Abstractions": "10.0.0", + "Microsoft.Extensions.Logging.Abstractions": "10.0.0", + "Microsoft.Extensions.Options": "10.0.0", + "System.Security.Cryptography.Xml": "10.0.0" + } + }, + "Microsoft.AspNetCore.DataProtection.Extensions": { + "type": "CentralTransitive", + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "FRBizffEDpUVIkb0RnIgSzQmSuFa9mLEvbROakrkSzRythB/qubj8j4U0vuxyfAXrLSuQdsbogMHlCTPC/4QeQ==", + "dependencies": { + "Microsoft.AspNetCore.DataProtection": "10.0.0", + "Microsoft.Extensions.DependencyInjection": "10.0.0" + } + }, "Microsoft.ClearScript.V8": { "type": "CentralTransitive", "requested": "[7.5.0, )", @@ -1402,28 +2105,76 @@ "Microsoft.CodeAnalysis.Common": "[4.5.0]" } }, - "Microsoft.IdentityModel.JsonWebTokens": { + "Microsoft.Extensions.DependencyInjection": { "type": "CentralTransitive", - "requested": "[8.15.0, )", - "resolved": "8.15.0", - "contentHash": "3513f5VzvOZy3ELd42wGnh1Q3e83tlGAuXFSNbENpgWYoAhLLzgFtd5PiaOPGAU0gqKhYGVzKavghLUGfX3HQg==", + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "f0RBabswJq+gRu5a+hWIobrLWiUYPKMhCD9WO3sYBAdSy3FFH14LMvLVFZc2kPSCimBLxSuitUhsd6tb0TAY6A==", "dependencies": { - "Microsoft.IdentityModel.Tokens": "8.15.0" + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0" } }, - "Microsoft.IO.RecyclableMemoryStream": { + "Microsoft.Extensions.Logging": { "type": "CentralTransitive", - "requested": "[3.0.1, )", - "resolved": "3.0.1", - "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g==" + "requested": "[8.0.0, )", + "resolved": "9.0.0", + "contentHash": "crjWyORoug0kK7RSNJBTeSE6VX8IQgLf3nUpTB9m62bPXp/tzbnOsnbe8TXEG0AASNaKZddnpHKw7fET8E++Pg==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection": "9.0.0", + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", + "Microsoft.Extensions.Options": "9.0.0" + } }, - "Nethermind.Crypto.Bls": { + "Microsoft.Extensions.Logging.Abstractions": { "type": "CentralTransitive", - "requested": "[1.0.5, )", - "resolved": "1.0.5", - "contentHash": "SYdQOFVVcC3R3VAm9Dv+u4Mc1yqHZETxt4tN3a+AFeOnEtUmpcjwVwYkkiiUIIrr6vQVVOUuwsDmaa9l3u45IQ==" + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "FU/IfjDfwaMuKr414SSQNTIti/69bHEMb+QKrskRb26oVqpx3lNFXMjs/RC9ZUuhBhcwDM2BwOgoMw+PZ+beqQ==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0" + } }, - "Nethermind.Crypto.SecP256k1": { + "Microsoft.Extensions.Logging.Console": { + "type": "CentralTransitive", + "requested": "[10.0.0, )", + "resolved": "9.0.0", + "contentHash": "yDZ4zsjl7N0K+R/1QTNpXBd79Kaf4qNLHtjk4NaG82UtNg2Z6etJywwv6OarOv3Rp7ocU7uIaRY4CrzHRO/d3w==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "9.0.0", + "Microsoft.Extensions.Logging": "9.0.0", + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", + "Microsoft.Extensions.Logging.Configuration": "9.0.0", + "Microsoft.Extensions.Options": "9.0.0" + } + }, + "Microsoft.Extensions.ObjectPool": { + "type": "CentralTransitive", + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "bpeCq0IYmVLACyEUMzFIOQX+zZUElG1t+nu1lSxthe7B+1oNYking7b91305+jNB6iwojp9fqTY9O+Nh7ULQxg==" + }, + "Microsoft.IdentityModel.JsonWebTokens": { + "type": "CentralTransitive", + "requested": "[8.15.0, )", + "resolved": "8.15.0", + "contentHash": "3513f5VzvOZy3ELd42wGnh1Q3e83tlGAuXFSNbENpgWYoAhLLzgFtd5PiaOPGAU0gqKhYGVzKavghLUGfX3HQg==", + "dependencies": { + "Microsoft.IdentityModel.Tokens": "8.15.0" + } + }, + "Microsoft.IO.RecyclableMemoryStream": { + "type": "CentralTransitive", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g==" + }, + "Nethermind.Crypto.Bls": { + "type": "CentralTransitive", + "requested": "[1.0.5, )", + "resolved": "1.0.5", + "contentHash": "SYdQOFVVcC3R3VAm9Dv+u4Mc1yqHZETxt4tN3a+AFeOnEtUmpcjwVwYkkiiUIIrr6vQVVOUuwsDmaa9l3u45IQ==" + }, + "Nethermind.Crypto.SecP256k1": { "type": "CentralTransitive", "requested": "[1.5.0, )", "resolved": "1.5.0", @@ -1441,7 +2192,8 @@ "resolved": "1.0.2.76", "contentHash": "bI9wc+xazOgsgibMvPaMWtQ4dNWktBBCo3fZeUVFgEsDBMwagl3GqIozx4D1I1GbozkhCpUD55Q2KGx0CuDHHQ==", "dependencies": { - "Nethermind.DotNetty.Common": "1.0.2.76" + "Nethermind.DotNetty.Common": "1.0.2.76", + "System.Runtime.CompilerServices.Unsafe": "5.0.0" } }, "Nethermind.DotNetty.Handlers": { @@ -1478,6 +2230,9 @@ "resolved": "1.0.0-preview.45", "contentHash": "OLV+fEkqbG+kFfQnFgkOloX8a1QPCJnTZfTkviOKgWo7vVlOnmePIvy0Tk963LVpmRmjreMCTvLLOh3yB1ZCJQ==", "dependencies": { + "Microsoft.Extensions.DependencyInjection": "9.0.0", + "Microsoft.Extensions.Logging": "9.0.0", + "Microsoft.Extensions.Logging.Console": "9.0.0", "Nethermind.Libp2p.Core": "1.0.0-preview.45", "Nethermind.Libp2p.Protocols.Identify": "1.0.0-preview.45", "Nethermind.Libp2p.Protocols.MDns": "1.0.0-preview.45", @@ -1499,6 +2254,7 @@ "contentHash": "VK0g5fehGQbarfAzqwCFfNLhU7BBQBEkVypjt/ToOD619FhDMjqJJ1FuBPC0EP6Gmf2whG55cYnIBoGQdrNgtA==", "dependencies": { "Makaretu.Dns.Multicast": "0.27.0", + "Microsoft.Extensions.Logging.Abstractions": "9.0.0", "Nethermind.Libp2p.Core": "1.0.0-preview.45", "Nethermind.Libp2p.Protocols.Pubsub": "1.0.0-preview.45" } @@ -1531,7 +2287,10 @@ "type": "CentralTransitive", "requested": "[2.1.2, )", "resolved": "2.1.2", - "contentHash": "yTP24PcuFmUw1RxQgYmIMxvpAJ1ciT/zv8Sb7OZHTuM/x9Tupz+DvEqeu9HykSYmI3/bGuy1ZZ7k/rZgfuIAuw==" + "contentHash": "yTP24PcuFmUw1RxQgYmIMxvpAJ1ciT/zv8Sb7OZHTuM/x9Tupz+DvEqeu9HykSYmI3/bGuy1ZZ7k/rZgfuIAuw==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "4.3.0" + } }, "Open.NAT.Core": { "type": "CentralTransitive", @@ -1546,9 +2305,15 @@ "contentHash": "WjVYiDxyZ3z00kuJJXuWJwRqkWfTrZF1v7qWz4mMASRP6AEhDCF4jMdCuAWkH1uPj00kkluONOc426Z//FcjDw==", "dependencies": { "BouncyCastle.Cryptography": "2.4.0", + "Microsoft.Extensions.Caching.Memory": "8.0.0", + "Microsoft.Extensions.DependencyInjection": "8.0.0", + "Microsoft.Extensions.Logging": "8.0.0", + "Microsoft.Extensions.Logging.Console": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", "NBitcoin.Secp256k1": "3.1.5", "PierTwo.Lantern.Discv5.Enr": "1.0.0-preview.6", - "PierTwo.Lantern.Discv5.Rlp": "1.0.0-preview.6" + "PierTwo.Lantern.Discv5.Rlp": "1.0.0-preview.6", + "System.Threading.Tasks.Dataflow": "8.0.0" } }, "Polly": { @@ -1593,6 +2358,7 @@ "resolved": "10.0.0", "contentHash": "0B+BzJ6pPMrRzJrVsttKf9MfDj6Syw9xoY+agcS9VssYQali1446+jTf5v1K94AMFUBxLXqDZlaTjO5edaI3jA==", "dependencies": { + "System.Diagnostics.EventLog": "10.0.0", "System.Security.Cryptography.ProtectedData": "10.0.0" } }, @@ -1617,6 +2383,7 @@ "resolved": "5.3.0", "contentHash": "uhdDM+gruCEhHRCKCoyali1HJp0wSS/HBs5X9XZwULNKM2y5ML188TsvcEgWEFOx0NOaHfGNtfoC0cd1p2NOIg==", "dependencies": { + "Microsoft.Extensions.Logging.Abstractions": "8.0.0", "Microsoft.IO.RecyclableMemoryStream": "3.0.0", "System.Reactive": "6.0.0" } @@ -1634,7 +2401,8 @@ "resolved": "2.46.6", "contentHash": "ZoRg3KmOJ2urTF4+u3H0b1Yv10xzz2Y/flFWS2tnRmj8dbKLeiJaSRqu4LOBD3ova90evqLkVZ85kUkC4JT4lw==", "dependencies": { - "Grpc.Core.Api": "2.46.6" + "Grpc.Core.Api": "2.46.6", + "System.Memory": "4.5.3" } }, "libsodium": { @@ -1642,97 +2410,387 @@ "resolved": "1.0.20", "contentHash": "fMO6HpAbvLagobzBH6eU36riWF01lCAweX34D5eugqjuXA+WS5MnV1ngE+2Sw3LvGvxZlmyLp9416t57dMZ5og==" }, - "Tmds.LibC": { + "Microsoft.Win32.Registry": { "type": "Transitive", - "resolved": "0.2.0", - "contentHash": "+RvLuNHOLW7cxzgDe9yHLoayBgjsuH2/gJtJnuVMxweKrxxYT6TwQNAmt06SFWpjwk68aRcwwD4FfMMA6tZvVA==" + "resolved": "5.0.0", + "contentHash": "dDoKi0PnDz31yAyETfRntsLArTlVAVzUzCIvvEDsDsucrl33Dl8pIJG06ePTJTI3tGpeyHS9Cq7Foc/s4EeKcg==", + "dependencies": { + "System.Security.AccessControl": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } }, - "Ckzg.Bindings": { - "type": "CentralTransitive", - "requested": "[2.1.5.1542, )", - "resolved": "2.1.5.1542", - "contentHash": "GFXmOjg5fZ8s+836/HdKiyXbJ+J73wVX6hNmUE6Isb1rA8dI2SMLeW1m48s+ZNIPN9ENJb8Daq1GwmMjBGjUVQ==" + "runtime.any.System.Collections": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "23g6rqftKmovn2cLeGsuHUYm0FD7pdutb0uQMJpZ3qTvq+zHkgmt6J65VtRry4WDGYlmkMa4xDACtaQ94alNag==", + "dependencies": { + "System.Runtime": "4.3.0" + } }, - "Microsoft.ClearScript.V8.Native.linux-arm64": { - "type": "CentralTransitive", - "requested": "[7.5.0, )", - "resolved": "7.5.0", - "contentHash": "UU+3Bef3UnwQgP8hKobT09ucYuYubVFiseAsuRUvmjvOBVu7yHRES+nXBNYSvDi88fMTp/HBUknpYQdrfoDemQ==" + "runtime.any.System.Globalization": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "sMDBnad4rp4t7GY442Jux0MCUuKL4otn5BK6Ni0ARTXTSpRNBzZ7hpMfKSvnVSED5kYJm96YOWsqV0JH0d2uuw==" }, - "Microsoft.ClearScript.V8.Native.linux-x64": { - "type": "CentralTransitive", - "requested": "[7.5.0, )", - "resolved": "7.5.0", - "contentHash": "snoN9oRwKqShA32IsuCanLjNtP8hros2WOrOBL7g+ED3AV40qwrsbfKwWq37BzogrfsF1aEVoDkBpE19Az7DVQ==" + "runtime.any.System.IO": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "SDZ5AD1DtyRoxYtEcqQ3HDlcrorMYXZeCt7ZhG9US9I5Vva+gpIWDGMkcwa5XiKL0ceQKRZIX2x0XEjLX7PDzQ==" }, - "Microsoft.ClearScript.V8.Native.osx-arm64": { - "type": "CentralTransitive", - "requested": "[7.5.0, )", - "resolved": "7.5.0", - "contentHash": "CkMgeX0I0+bXUzoaVoJdV86/k0H2PEukqCoZ8zQ28msB6YHeRX6FJTfvOQ0l6UTX5HaBHGG3CWUI04uBYe6M+A==" + "runtime.any.System.Reflection": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "hLC3A3rI8jipR5d9k7+f0MgRCW6texsAp0MWkN/ci18FMtQ9KH7E2vDn/DH2LkxsszlpJpOn9qy6Z6/69rH6eQ==" }, - "Microsoft.ClearScript.V8.Native.osx-x64": { - "type": "CentralTransitive", - "requested": "[7.5.0, )", - "resolved": "7.5.0", - "contentHash": "yXoXLWKJJgW5V6ez1aMa+ZS2nCef0X4iTYzPS9bTSYl9y7D4R2Ie2KrfR8nLO2rhOKimIMx3MH49Zh1CYruN/g==" + "runtime.any.System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "cPhT+Vqu52+cQQrDai/V91gubXUnDKNRvlBnH+hOgtGyHdC17aQIU64EaehwAQymd7kJA5rSrVRNfDYrbhnzyA==" }, - "Microsoft.ClearScript.V8.Native.win-x64": { - "type": "CentralTransitive", - "requested": "[7.5.0, )", - "resolved": "7.5.0", - "contentHash": "DKMxDLboTNflYkwDQ/ELrSf1vXTpew5UZ8xzrXSVKYFBU570VA6NKh1etEGhufuCuDyU7Je5L2g6H+19Dbl+tA==" + "runtime.any.System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Nrm1p3armp6TTf2xuvaa+jGTTmncALWFq22CpmwRvhDf6dE9ZmH40EbOswD4GnFLrMRS0Ki6Kx5aUPmKK/hZBg==" }, - "Nethermind.Crypto.Bls": { - "type": "CentralTransitive", - "requested": "[1.0.5, )", - "resolved": "1.0.5", - "contentHash": "SYdQOFVVcC3R3VAm9Dv+u4Mc1yqHZETxt4tN3a+AFeOnEtUmpcjwVwYkkiiUIIrr6vQVVOUuwsDmaa9l3u45IQ==" + "runtime.any.System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Lxb89SMvf8w9p9+keBLyL6H6x/TEmc6QVsIIA0T36IuyOY3kNvIdyGddA2qt35cRamzxF8K5p0Opq4G4HjNbhQ==" }, - "Nethermind.Crypto.SecP256k1": { - "type": "CentralTransitive", - "requested": "[1.5.0, )", - "resolved": "1.5.0", - "contentHash": "+mNlEgN1gYDB6f4jRcYssaE6/AlSoPr7eLDQHQoX+tXcnGRzgnArezPwz82TsWxruQGDh5h9Qfowa0xt4Xz59g==" + "runtime.any.System.Runtime": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "fRS7zJgaG9NkifaAxGGclDDoRn9HC7hXACl52Or06a/fxdzDajWb5wov3c6a+gVSlekRoexfjwQSK9sh5um5LQ==", + "dependencies": { + "System.Private.Uri": "4.3.0" + } }, - "Nethermind.Crypto.SecP256r1": { - "type": "CentralTransitive", - "requested": "[1.0.0-preview.6, )", - "resolved": "1.0.0-preview.6", - "contentHash": "wFfpg1ofZz5nsjN8TAKUg0mdUCskmOUO0lFk3LcoeRkVnQ5Rw2rYzsJxgPFfnxAABH/EPPs62S7oF8E0Ayjjeg==" + "runtime.any.System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "GG84X6vufoEzqx8PbeBKheE4srOhimv+yLtGb/JkR3Y2FmoqmueLNFU4Xx8Y67plFpltQSdK74x0qlEhIpv/CQ==" }, - "Nethermind.GmpBindings": { - "type": "CentralTransitive", - "requested": "[1.0.3, )", - "resolved": "1.0.3", - "contentHash": "EE12z2k4ku0ugfI01utaQR8EbBoEMLI4QAKKGrfz5Fvbw/YtXTqDDzvKtBTleOB9YBH7oTpH9T9ZFtKgKZMj2g==" + "runtime.any.System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "lBoFeQfxe/4eqjPi46E0LU/YaCMdNkQ8B4MZu/mkzdIAZh8RQ1NYZSj0egrQKdgdvlPFtP4STtob40r4o2DBAw==" }, - "Nethermind.MclBindings": { - "type": "CentralTransitive", - "requested": "[1.0.3, )", - "resolved": "1.0.3", - "contentHash": "hgT2oiMFqItNXv5vzIbhhlgqPJK4qnOHaYmUiR4jJsaWiqDRH05YtqYeMQq2+oyBOf8REtuGOW5RZ7+agRSEbg==" + "runtime.any.System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "+ihI5VaXFCMVPJNstG4O4eo1CfbrByLxRrQQTqOTp1ttK0kUKDqOdBSTaCB2IBk/QtjDrs6+x4xuezyMXdm0HQ==" }, - "RocksDB": { - "type": "CentralTransitive", - "requested": "[10.4.2.62659, 10.4.2.62659]", - "resolved": "10.4.2.62659", - "contentHash": "+ZY7koKclaRz7+3QiCbXprWK4++Cwh0Hhqj+5Z5fcZpQvoIoo+iM9iAdCo+W5ha9XOLeI0YWbi9nZt12dNVBMg==" - } - }, - "net10.0/linux-x64": { - "Grpc.Core": { + "runtime.any.System.Threading.Tasks": { "type": "Transitive", - "resolved": "2.46.6", - "contentHash": "ZoRg3KmOJ2urTF4+u3H0b1Yv10xzz2Y/flFWS2tnRmj8dbKLeiJaSRqu4LOBD3ova90evqLkVZ85kUkC4JT4lw==", + "resolved": "4.3.0", + "contentHash": "OhBAVBQG5kFj1S+hCEQ3TUHBAEtZ3fbEMgZMRNdN8A0Pj4x+5nTELEqL59DU0TjKVE6II3dqKw4Dklb3szT65w==" + }, + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "HdSSp5MnJSsg08KMfZThpuLPJpPwE5hBXvHwoKWosyHHfe8Mh5WKT0ylEOf6yNzX6Ngjxe4Whkafh5q7Ymac4Q==" + }, + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "+yH1a49wJMy8Zt4yx5RhJrxO/DBDByAiCzNwiETI+1S4mPdCu0OY4djdciC7Vssk0l22wQaDLrXxXkp+3+7bVA==" + }, + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "c3YNH1GQJbfIPJeCnr4avseugSqPrxwIqzthYyZDN6EuOyNOzq+y2KSUfRcXauya1sF4foESTgwM5e1A8arAKw==" + }, + "runtime.native.System": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "c/qWt2LieNZIj1jGnVNsE2Kl23Ya2aSTBuXMD6V7k9KWr6l16Tqdwq+hJScEpWER9753NWC8h96PaVNY5Ld7Jw==", "dependencies": { - "Grpc.Core.Api": "2.46.6" + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0" } }, - "libsodium": { + "runtime.native.System.Security.Cryptography.OpenSsl": { "type": "Transitive", - "resolved": "1.0.20", - "contentHash": "fMO6HpAbvLagobzBH6eU36riWF01lCAweX34D5eugqjuXA+WS5MnV1ngE+2Sw3LvGvxZlmyLp9416t57dMZ5og==" + "resolved": "4.3.0", + "contentHash": "NS1U+700m4KFRHR5o4vo9DSlTmlCKu/u7dtE5sUHVIPB+xpXxYQvgBgA6wEIeCz6Yfn0Z52/72WYsToCEPJnrw==", + "dependencies": { + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } + }, + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "b3pthNgxxFcD+Pc0WSEoC0+md3MyhRS6aCEeenvNE3Fdw1HyJ18ZhRFVJJzIeR/O/jpxPboB805Ho0T3Ul7w8A==" + }, + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "KeLz4HClKf+nFS7p/6Fi/CqyLXh81FpiGzcmuS8DGi9lUqSnZ6Es23/gv2O+1XVGfrbNmviF7CckBpavkBoIFQ==" + }, + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "X7IdhILzr4ROXd8mI1BUCQMSHSQwelUlBjF1JyTKCjXaOGn2fB4EKBxQbCK2VjO3WaWIdlXZL3W6TiIVnrhX4g==" + }, + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "nyFNiCk/r+VOiIqreLix8yN+q3Wga9+SE8BCgkf+2BwEKiNx6DyvFjCgkfV743/grxv8jHJ8gUK4XEQw7yzRYg==" + }, + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "ytoewC6wGorL7KoCAvRfsgoJPJbNq+64k2SqW6JcOAebWsFUvCCYgfzQMrnpvPiEl4OrblUlhF2ji+Q1+SVLrQ==" + }, + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "I8bKw2I8k58Wx7fMKQJn2R8lamboCAiHfHeV/pS65ScKWMMI0+wJkLYlEKvgW1D/XvSl/221clBoR2q9QNNM7A==" + }, + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "VB5cn/7OzUfzdnC8tqAIMQciVLiq2epm2NrAm1E9OjNRyG4lVhfR61SMcLizejzQP8R8Uf/0l5qOIbUEi+RdEg==" + }, + "runtime.unix.System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "WV8KLRHWVUVUDduFnvGMHt0FsEt2wK6xPl1EgDKlaMx2KnZ43A/O0GzP8wIuvAC7mq4T9V1mm90r+PXkL9FPdQ==", + "dependencies": { + "runtime.native.System": "4.3.0" + } + }, + "runtime.unix.System.Private.Uri": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "ooWzobr5RAq34r9uan1r/WPXJYG1XWy9KanrxNvEnBzbFdQbMG7Y3bVi4QxR7xZMNLOxLLTAyXvnSkfj5boZSg==", + "dependencies": { + "runtime.native.System": "4.3.0" + } + }, + "runtime.unix.System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "zQiTBVpiLftTQZW8GFsV0gjYikB1WMkEPIxF5O6RkUrSV/OgvRRTYgeFQha/0keBpuS0HYweraGRwhfhJ7dj7w==", + "dependencies": { + "System.Private.Uri": "4.3.0", + "runtime.native.System": "4.3.0", + "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } + }, + "System.Collections": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "YUJGz6eFKqS0V//mLt25vFGrrCvOnsXjlvFQs+KimpwNxug9x0Pzy4PlFMU3Q2IzqAa9G2L4LsK3+9vCBK7oTg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Collections": "4.3.0" + } + }, + "System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "w5U95fVKHY4G8ASs/K5iK3J5LY+/dLFd4vKejsnI/ZhBsWS9hQakfx3Zr7lRWKg4tAw9r4iktyvsTagWkqYCiw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.unix.System.Diagnostics.Debug": "4.3.0" + } + }, + "System.Diagnostics.EventLog": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "uaFRda9NjtbJRkdx311eXlAA3n2em7223c1A8d1VWyl+4FL9vkG7y2lpPfBU9HYdj/9KgdRNdn1vFK8ZYCYT/A==" + }, + "System.Globalization": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "B95h0YLEL2oSnwF/XjqSWKnwKOy/01VWkNlsCeMTFJLLabflpGV26nK164eRs5GiaRSBGpOxQ3pKoSnnyZN5pg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Globalization": "4.3.0" + } + }, + "System.IO": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "3KlTJceQc3gnGIaHZ7UBZO26SHL1SHE4ddrmiwumFnId+CEHP+O8r386tZKaE6zlk5/mF8vifMBzHj9SaXN+mQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading.Tasks": "4.0.11", + "runtime.any.System.IO": "4.3.0" + } + }, + "System.Private.Uri": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "I4SwANiUGho1esj4V4oSlPllXjzCZDE+5XXso2P03LW2vOda2Enzh8DWOxwN6hnrJyp314c7KuVu31QYhRzOGg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "runtime.unix.System.Private.Uri": "4.3.0" + } + }, + "System.Reflection": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "JCKANJ0TI7kzoQzuwB/OoJANy1Lg338B6+JVacPl4TpUwi3cReg3nMLplMq2uqYfHFQpKIlHAUVAJlImZz/4ng==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection": "4.3.0" + } + }, + "System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "GYrtRsZcMuHF3sbmRHfMYpvxZoIN2bQGrYGerUiWLEkqdEUQZhH3TRSaC/oI4wO0II1RKBPlpIa1TOMxIcOOzQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Extensions": "4.3.0" + } + }, + "System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "4inTox4wTBaDhB7V3mPvp9XlCbeGYWVEM9/fXALd52vNEAVisc1BoVWQPuUuD0Ga//dNbA/WeMy9u9mzLxGTHQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Primitives": "4.3.0" + } + }, + "System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "TxwVeUNoTgUOdQ09gfTjvW411MF+w9MBYL7AtNVc+HtBCFlutPLhUCdZjNkjbhj3bNQWMdHboF0KIWEOjJssbA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Globalization": "4.0.11", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Resources.ResourceManager": "4.3.0" + } + }, + "System.Runtime": { + "type": "Transitive", + "resolved": "4.3.1", + "contentHash": "abhfv1dTK6NXOmu4bgHIONxHyEqFjW8HwXPmpY9gmll+ix9UNo4XDcmzJn6oLooftxNssVHdJC1pGT9jkSynQg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.1", + "Microsoft.NETCore.Targets": "1.1.3", + "runtime.any.System.Runtime": "4.3.0" + } + }, + "System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "CUOHjTT/vgP0qGW22U4/hDlOqXmcPq5YicBaXdUR2UiUoLwBT+olO6we4DVbq57jeX5uXH2uerVZhf0qGj+sVQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.unix.System.Runtime.Extensions": "4.3.0" + } + }, + "System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "nCJvEKguXEvk2ymk1gqj625vVnlK3/xdGzx0vOKicQkoquaTBJTP13AIYkocSUwHCLNBwUbXTqTWGDxBTWpt7g==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Runtime.Handles": "4.3.0" + } + }, + "System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "16eu3kjHS633yYdkjwShDHZLRNMKVi/s0bY8ODiqJ2RfMhDMAwxZaUaWVnZ2P71kr/or+X9o/xFWtNqz8ivieQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "runtime.any.System.Runtime.InteropServices": "4.3.0" + } + }, + "System.Security.AccessControl": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dagJ1mHZO3Ani8GH0PHpPEe/oYO+rVdbQjvjJkBRNQkX4t0r1iaeGn8+/ybkSLEan3/slM0t59SVdHzuHf2jmw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } + }, + "System.Security.Cryptography.Pkcs": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "UPWqLSygJlFerRi9XNIuM0a1VC8gHUIufyP24xQ0sc+XimqUAEcjpOz9DhKpyDjH+5B/wO3RpC0KpkEeDj/ddg==" + }, + "System.Security.Principal.Windows": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "t0MGLukB5WAVU9bO3MGzvlGnyJPgUlcwerXn1kzBRjwLKixT96XV0Uza41W49gVd8zEMFu9vQEFlv0IOrytICA==" + }, + "System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "U3gGeMlDZXxCEiY4DwVLSacg+DFWCvoiX+JThA/rvw37Sqrku7sEFeVBBBMBnfB6FeZHsyDx85HlKL19x0HtZA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Text.Encoding": "4.3.0" + } + }, + "System.Text.Encoding.CodePages": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "ZFCILZuOvtKPauZ/j/swhvw68ZRi9ATCfvGbk1QfydmcXBkIWecWKn/250UH7rahZ5OoDBaiAudJtPvLwzw85A==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.0.0" + } + }, + "System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "k1S4Gc6IGwtHGT8188RSeGaX86Qw/wnrgNLshJvsdNUOPP9etMmo8S07c+UlOAx4K/xLuN9ivA1bD0LVurtIxQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Threading.Tasks": "4.3.0" + } }, "Tmds.LibC": { "type": "Transitive", @@ -1812,13 +2870,14 @@ "contentHash": "+ZY7koKclaRz7+3QiCbXprWK4++Cwh0Hhqj+5Z5fcZpQvoIoo+iM9iAdCo+W5ha9XOLeI0YWbi9nZt12dNVBMg==" } }, - "net10.0/osx-arm64": { + "net10.0/linux-x64": { "Grpc.Core": { "type": "Transitive", "resolved": "2.46.6", "contentHash": "ZoRg3KmOJ2urTF4+u3H0b1Yv10xzz2Y/flFWS2tnRmj8dbKLeiJaSRqu4LOBD3ova90evqLkVZ85kUkC4JT4lw==", "dependencies": { - "Grpc.Core.Api": "2.46.6" + "Grpc.Core.Api": "2.46.6", + "System.Memory": "4.5.3" } }, "libsodium": { @@ -1826,97 +2885,1337 @@ "resolved": "1.0.20", "contentHash": "fMO6HpAbvLagobzBH6eU36riWF01lCAweX34D5eugqjuXA+WS5MnV1ngE+2Sw3LvGvxZlmyLp9416t57dMZ5og==" }, - "Tmds.LibC": { + "Microsoft.Win32.Registry": { "type": "Transitive", - "resolved": "0.2.0", - "contentHash": "+RvLuNHOLW7cxzgDe9yHLoayBgjsuH2/gJtJnuVMxweKrxxYT6TwQNAmt06SFWpjwk68aRcwwD4FfMMA6tZvVA==" + "resolved": "5.0.0", + "contentHash": "dDoKi0PnDz31yAyETfRntsLArTlVAVzUzCIvvEDsDsucrl33Dl8pIJG06ePTJTI3tGpeyHS9Cq7Foc/s4EeKcg==", + "dependencies": { + "System.Security.AccessControl": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } }, - "Ckzg.Bindings": { - "type": "CentralTransitive", - "requested": "[2.1.5.1542, )", - "resolved": "2.1.5.1542", - "contentHash": "GFXmOjg5fZ8s+836/HdKiyXbJ+J73wVX6hNmUE6Isb1rA8dI2SMLeW1m48s+ZNIPN9ENJb8Daq1GwmMjBGjUVQ==" + "runtime.any.System.Collections": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "23g6rqftKmovn2cLeGsuHUYm0FD7pdutb0uQMJpZ3qTvq+zHkgmt6J65VtRry4WDGYlmkMa4xDACtaQ94alNag==", + "dependencies": { + "System.Runtime": "4.3.0" + } }, - "Microsoft.ClearScript.V8.Native.linux-arm64": { + "runtime.any.System.Globalization": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "sMDBnad4rp4t7GY442Jux0MCUuKL4otn5BK6Ni0ARTXTSpRNBzZ7hpMfKSvnVSED5kYJm96YOWsqV0JH0d2uuw==" + }, + "runtime.any.System.IO": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "SDZ5AD1DtyRoxYtEcqQ3HDlcrorMYXZeCt7ZhG9US9I5Vva+gpIWDGMkcwa5XiKL0ceQKRZIX2x0XEjLX7PDzQ==" + }, + "runtime.any.System.Reflection": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "hLC3A3rI8jipR5d9k7+f0MgRCW6texsAp0MWkN/ci18FMtQ9KH7E2vDn/DH2LkxsszlpJpOn9qy6Z6/69rH6eQ==" + }, + "runtime.any.System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "cPhT+Vqu52+cQQrDai/V91gubXUnDKNRvlBnH+hOgtGyHdC17aQIU64EaehwAQymd7kJA5rSrVRNfDYrbhnzyA==" + }, + "runtime.any.System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Nrm1p3armp6TTf2xuvaa+jGTTmncALWFq22CpmwRvhDf6dE9ZmH40EbOswD4GnFLrMRS0Ki6Kx5aUPmKK/hZBg==" + }, + "runtime.any.System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Lxb89SMvf8w9p9+keBLyL6H6x/TEmc6QVsIIA0T36IuyOY3kNvIdyGddA2qt35cRamzxF8K5p0Opq4G4HjNbhQ==" + }, + "runtime.any.System.Runtime": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "fRS7zJgaG9NkifaAxGGclDDoRn9HC7hXACl52Or06a/fxdzDajWb5wov3c6a+gVSlekRoexfjwQSK9sh5um5LQ==", + "dependencies": { + "System.Private.Uri": "4.3.0" + } + }, + "runtime.any.System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "GG84X6vufoEzqx8PbeBKheE4srOhimv+yLtGb/JkR3Y2FmoqmueLNFU4Xx8Y67plFpltQSdK74x0qlEhIpv/CQ==" + }, + "runtime.any.System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "lBoFeQfxe/4eqjPi46E0LU/YaCMdNkQ8B4MZu/mkzdIAZh8RQ1NYZSj0egrQKdgdvlPFtP4STtob40r4o2DBAw==" + }, + "runtime.any.System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "+ihI5VaXFCMVPJNstG4O4eo1CfbrByLxRrQQTqOTp1ttK0kUKDqOdBSTaCB2IBk/QtjDrs6+x4xuezyMXdm0HQ==" + }, + "runtime.any.System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "OhBAVBQG5kFj1S+hCEQ3TUHBAEtZ3fbEMgZMRNdN8A0Pj4x+5nTELEqL59DU0TjKVE6II3dqKw4Dklb3szT65w==" + }, + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "HdSSp5MnJSsg08KMfZThpuLPJpPwE5hBXvHwoKWosyHHfe8Mh5WKT0ylEOf6yNzX6Ngjxe4Whkafh5q7Ymac4Q==" + }, + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "+yH1a49wJMy8Zt4yx5RhJrxO/DBDByAiCzNwiETI+1S4mPdCu0OY4djdciC7Vssk0l22wQaDLrXxXkp+3+7bVA==" + }, + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "c3YNH1GQJbfIPJeCnr4avseugSqPrxwIqzthYyZDN6EuOyNOzq+y2KSUfRcXauya1sF4foESTgwM5e1A8arAKw==" + }, + "runtime.native.System": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "c/qWt2LieNZIj1jGnVNsE2Kl23Ya2aSTBuXMD6V7k9KWr6l16Tqdwq+hJScEpWER9753NWC8h96PaVNY5Ld7Jw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0" + } + }, + "runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "NS1U+700m4KFRHR5o4vo9DSlTmlCKu/u7dtE5sUHVIPB+xpXxYQvgBgA6wEIeCz6Yfn0Z52/72WYsToCEPJnrw==", + "dependencies": { + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } + }, + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "b3pthNgxxFcD+Pc0WSEoC0+md3MyhRS6aCEeenvNE3Fdw1HyJ18ZhRFVJJzIeR/O/jpxPboB805Ho0T3Ul7w8A==" + }, + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "KeLz4HClKf+nFS7p/6Fi/CqyLXh81FpiGzcmuS8DGi9lUqSnZ6Es23/gv2O+1XVGfrbNmviF7CckBpavkBoIFQ==" + }, + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "X7IdhILzr4ROXd8mI1BUCQMSHSQwelUlBjF1JyTKCjXaOGn2fB4EKBxQbCK2VjO3WaWIdlXZL3W6TiIVnrhX4g==" + }, + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "nyFNiCk/r+VOiIqreLix8yN+q3Wga9+SE8BCgkf+2BwEKiNx6DyvFjCgkfV743/grxv8jHJ8gUK4XEQw7yzRYg==" + }, + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "ytoewC6wGorL7KoCAvRfsgoJPJbNq+64k2SqW6JcOAebWsFUvCCYgfzQMrnpvPiEl4OrblUlhF2ji+Q1+SVLrQ==" + }, + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "I8bKw2I8k58Wx7fMKQJn2R8lamboCAiHfHeV/pS65ScKWMMI0+wJkLYlEKvgW1D/XvSl/221clBoR2q9QNNM7A==" + }, + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "VB5cn/7OzUfzdnC8tqAIMQciVLiq2epm2NrAm1E9OjNRyG4lVhfR61SMcLizejzQP8R8Uf/0l5qOIbUEi+RdEg==" + }, + "runtime.unix.System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "WV8KLRHWVUVUDduFnvGMHt0FsEt2wK6xPl1EgDKlaMx2KnZ43A/O0GzP8wIuvAC7mq4T9V1mm90r+PXkL9FPdQ==", + "dependencies": { + "runtime.native.System": "4.3.0" + } + }, + "runtime.unix.System.Private.Uri": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "ooWzobr5RAq34r9uan1r/WPXJYG1XWy9KanrxNvEnBzbFdQbMG7Y3bVi4QxR7xZMNLOxLLTAyXvnSkfj5boZSg==", + "dependencies": { + "runtime.native.System": "4.3.0" + } + }, + "runtime.unix.System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "zQiTBVpiLftTQZW8GFsV0gjYikB1WMkEPIxF5O6RkUrSV/OgvRRTYgeFQha/0keBpuS0HYweraGRwhfhJ7dj7w==", + "dependencies": { + "System.Private.Uri": "4.3.0", + "runtime.native.System": "4.3.0", + "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } + }, + "System.Collections": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "YUJGz6eFKqS0V//mLt25vFGrrCvOnsXjlvFQs+KimpwNxug9x0Pzy4PlFMU3Q2IzqAa9G2L4LsK3+9vCBK7oTg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Collections": "4.3.0" + } + }, + "System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "w5U95fVKHY4G8ASs/K5iK3J5LY+/dLFd4vKejsnI/ZhBsWS9hQakfx3Zr7lRWKg4tAw9r4iktyvsTagWkqYCiw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.unix.System.Diagnostics.Debug": "4.3.0" + } + }, + "System.Diagnostics.EventLog": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "uaFRda9NjtbJRkdx311eXlAA3n2em7223c1A8d1VWyl+4FL9vkG7y2lpPfBU9HYdj/9KgdRNdn1vFK8ZYCYT/A==" + }, + "System.Globalization": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "B95h0YLEL2oSnwF/XjqSWKnwKOy/01VWkNlsCeMTFJLLabflpGV26nK164eRs5GiaRSBGpOxQ3pKoSnnyZN5pg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Globalization": "4.3.0" + } + }, + "System.IO": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "3KlTJceQc3gnGIaHZ7UBZO26SHL1SHE4ddrmiwumFnId+CEHP+O8r386tZKaE6zlk5/mF8vifMBzHj9SaXN+mQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading.Tasks": "4.0.11", + "runtime.any.System.IO": "4.3.0" + } + }, + "System.Private.Uri": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "I4SwANiUGho1esj4V4oSlPllXjzCZDE+5XXso2P03LW2vOda2Enzh8DWOxwN6hnrJyp314c7KuVu31QYhRzOGg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "runtime.unix.System.Private.Uri": "4.3.0" + } + }, + "System.Reflection": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "JCKANJ0TI7kzoQzuwB/OoJANy1Lg338B6+JVacPl4TpUwi3cReg3nMLplMq2uqYfHFQpKIlHAUVAJlImZz/4ng==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection": "4.3.0" + } + }, + "System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "GYrtRsZcMuHF3sbmRHfMYpvxZoIN2bQGrYGerUiWLEkqdEUQZhH3TRSaC/oI4wO0II1RKBPlpIa1TOMxIcOOzQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Extensions": "4.3.0" + } + }, + "System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "4inTox4wTBaDhB7V3mPvp9XlCbeGYWVEM9/fXALd52vNEAVisc1BoVWQPuUuD0Ga//dNbA/WeMy9u9mzLxGTHQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Primitives": "4.3.0" + } + }, + "System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "TxwVeUNoTgUOdQ09gfTjvW411MF+w9MBYL7AtNVc+HtBCFlutPLhUCdZjNkjbhj3bNQWMdHboF0KIWEOjJssbA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Globalization": "4.0.11", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Resources.ResourceManager": "4.3.0" + } + }, + "System.Runtime": { + "type": "Transitive", + "resolved": "4.3.1", + "contentHash": "abhfv1dTK6NXOmu4bgHIONxHyEqFjW8HwXPmpY9gmll+ix9UNo4XDcmzJn6oLooftxNssVHdJC1pGT9jkSynQg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.1", + "Microsoft.NETCore.Targets": "1.1.3", + "runtime.any.System.Runtime": "4.3.0" + } + }, + "System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "CUOHjTT/vgP0qGW22U4/hDlOqXmcPq5YicBaXdUR2UiUoLwBT+olO6we4DVbq57jeX5uXH2uerVZhf0qGj+sVQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.unix.System.Runtime.Extensions": "4.3.0" + } + }, + "System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "nCJvEKguXEvk2ymk1gqj625vVnlK3/xdGzx0vOKicQkoquaTBJTP13AIYkocSUwHCLNBwUbXTqTWGDxBTWpt7g==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Runtime.Handles": "4.3.0" + } + }, + "System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "16eu3kjHS633yYdkjwShDHZLRNMKVi/s0bY8ODiqJ2RfMhDMAwxZaUaWVnZ2P71kr/or+X9o/xFWtNqz8ivieQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "runtime.any.System.Runtime.InteropServices": "4.3.0" + } + }, + "System.Security.AccessControl": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dagJ1mHZO3Ani8GH0PHpPEe/oYO+rVdbQjvjJkBRNQkX4t0r1iaeGn8+/ybkSLEan3/slM0t59SVdHzuHf2jmw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } + }, + "System.Security.Cryptography.Pkcs": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "UPWqLSygJlFerRi9XNIuM0a1VC8gHUIufyP24xQ0sc+XimqUAEcjpOz9DhKpyDjH+5B/wO3RpC0KpkEeDj/ddg==" + }, + "System.Security.Principal.Windows": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "t0MGLukB5WAVU9bO3MGzvlGnyJPgUlcwerXn1kzBRjwLKixT96XV0Uza41W49gVd8zEMFu9vQEFlv0IOrytICA==" + }, + "System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "U3gGeMlDZXxCEiY4DwVLSacg+DFWCvoiX+JThA/rvw37Sqrku7sEFeVBBBMBnfB6FeZHsyDx85HlKL19x0HtZA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Text.Encoding": "4.3.0" + } + }, + "System.Text.Encoding.CodePages": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "ZFCILZuOvtKPauZ/j/swhvw68ZRi9ATCfvGbk1QfydmcXBkIWecWKn/250UH7rahZ5OoDBaiAudJtPvLwzw85A==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.0.0" + } + }, + "System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "k1S4Gc6IGwtHGT8188RSeGaX86Qw/wnrgNLshJvsdNUOPP9etMmo8S07c+UlOAx4K/xLuN9ivA1bD0LVurtIxQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Threading.Tasks": "4.3.0" + } + }, + "Tmds.LibC": { + "type": "Transitive", + "resolved": "0.2.0", + "contentHash": "+RvLuNHOLW7cxzgDe9yHLoayBgjsuH2/gJtJnuVMxweKrxxYT6TwQNAmt06SFWpjwk68aRcwwD4FfMMA6tZvVA==" + }, + "Ckzg.Bindings": { + "type": "CentralTransitive", + "requested": "[2.1.5.1542, )", + "resolved": "2.1.5.1542", + "contentHash": "GFXmOjg5fZ8s+836/HdKiyXbJ+J73wVX6hNmUE6Isb1rA8dI2SMLeW1m48s+ZNIPN9ENJb8Daq1GwmMjBGjUVQ==" + }, + "Microsoft.ClearScript.V8.Native.linux-arm64": { + "type": "CentralTransitive", + "requested": "[7.5.0, )", + "resolved": "7.5.0", + "contentHash": "UU+3Bef3UnwQgP8hKobT09ucYuYubVFiseAsuRUvmjvOBVu7yHRES+nXBNYSvDi88fMTp/HBUknpYQdrfoDemQ==" + }, + "Microsoft.ClearScript.V8.Native.linux-x64": { + "type": "CentralTransitive", + "requested": "[7.5.0, )", + "resolved": "7.5.0", + "contentHash": "snoN9oRwKqShA32IsuCanLjNtP8hros2WOrOBL7g+ED3AV40qwrsbfKwWq37BzogrfsF1aEVoDkBpE19Az7DVQ==" + }, + "Microsoft.ClearScript.V8.Native.osx-arm64": { + "type": "CentralTransitive", + "requested": "[7.5.0, )", + "resolved": "7.5.0", + "contentHash": "CkMgeX0I0+bXUzoaVoJdV86/k0H2PEukqCoZ8zQ28msB6YHeRX6FJTfvOQ0l6UTX5HaBHGG3CWUI04uBYe6M+A==" + }, + "Microsoft.ClearScript.V8.Native.osx-x64": { + "type": "CentralTransitive", + "requested": "[7.5.0, )", + "resolved": "7.5.0", + "contentHash": "yXoXLWKJJgW5V6ez1aMa+ZS2nCef0X4iTYzPS9bTSYl9y7D4R2Ie2KrfR8nLO2rhOKimIMx3MH49Zh1CYruN/g==" + }, + "Microsoft.ClearScript.V8.Native.win-x64": { + "type": "CentralTransitive", + "requested": "[7.5.0, )", + "resolved": "7.5.0", + "contentHash": "DKMxDLboTNflYkwDQ/ELrSf1vXTpew5UZ8xzrXSVKYFBU570VA6NKh1etEGhufuCuDyU7Je5L2g6H+19Dbl+tA==" + }, + "Nethermind.Crypto.Bls": { + "type": "CentralTransitive", + "requested": "[1.0.5, )", + "resolved": "1.0.5", + "contentHash": "SYdQOFVVcC3R3VAm9Dv+u4Mc1yqHZETxt4tN3a+AFeOnEtUmpcjwVwYkkiiUIIrr6vQVVOUuwsDmaa9l3u45IQ==" + }, + "Nethermind.Crypto.SecP256k1": { + "type": "CentralTransitive", + "requested": "[1.5.0, )", + "resolved": "1.5.0", + "contentHash": "+mNlEgN1gYDB6f4jRcYssaE6/AlSoPr7eLDQHQoX+tXcnGRzgnArezPwz82TsWxruQGDh5h9Qfowa0xt4Xz59g==" + }, + "Nethermind.Crypto.SecP256r1": { + "type": "CentralTransitive", + "requested": "[1.0.0-preview.6, )", + "resolved": "1.0.0-preview.6", + "contentHash": "wFfpg1ofZz5nsjN8TAKUg0mdUCskmOUO0lFk3LcoeRkVnQ5Rw2rYzsJxgPFfnxAABH/EPPs62S7oF8E0Ayjjeg==" + }, + "Nethermind.GmpBindings": { + "type": "CentralTransitive", + "requested": "[1.0.3, )", + "resolved": "1.0.3", + "contentHash": "EE12z2k4ku0ugfI01utaQR8EbBoEMLI4QAKKGrfz5Fvbw/YtXTqDDzvKtBTleOB9YBH7oTpH9T9ZFtKgKZMj2g==" + }, + "Nethermind.MclBindings": { + "type": "CentralTransitive", + "requested": "[1.0.3, )", + "resolved": "1.0.3", + "contentHash": "hgT2oiMFqItNXv5vzIbhhlgqPJK4qnOHaYmUiR4jJsaWiqDRH05YtqYeMQq2+oyBOf8REtuGOW5RZ7+agRSEbg==" + }, + "RocksDB": { + "type": "CentralTransitive", + "requested": "[10.4.2.62659, 10.4.2.62659]", + "resolved": "10.4.2.62659", + "contentHash": "+ZY7koKclaRz7+3QiCbXprWK4++Cwh0Hhqj+5Z5fcZpQvoIoo+iM9iAdCo+W5ha9XOLeI0YWbi9nZt12dNVBMg==" + } + }, + "net10.0/osx-arm64": { + "Grpc.Core": { + "type": "Transitive", + "resolved": "2.46.6", + "contentHash": "ZoRg3KmOJ2urTF4+u3H0b1Yv10xzz2Y/flFWS2tnRmj8dbKLeiJaSRqu4LOBD3ova90evqLkVZ85kUkC4JT4lw==", + "dependencies": { + "Grpc.Core.Api": "2.46.6", + "System.Memory": "4.5.3" + } + }, + "libsodium": { + "type": "Transitive", + "resolved": "1.0.20", + "contentHash": "fMO6HpAbvLagobzBH6eU36riWF01lCAweX34D5eugqjuXA+WS5MnV1ngE+2Sw3LvGvxZlmyLp9416t57dMZ5og==" + }, + "Microsoft.Win32.Registry": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dDoKi0PnDz31yAyETfRntsLArTlVAVzUzCIvvEDsDsucrl33Dl8pIJG06ePTJTI3tGpeyHS9Cq7Foc/s4EeKcg==", + "dependencies": { + "System.Security.AccessControl": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } + }, + "runtime.any.System.Collections": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "23g6rqftKmovn2cLeGsuHUYm0FD7pdutb0uQMJpZ3qTvq+zHkgmt6J65VtRry4WDGYlmkMa4xDACtaQ94alNag==", + "dependencies": { + "System.Runtime": "4.3.0" + } + }, + "runtime.any.System.Globalization": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "sMDBnad4rp4t7GY442Jux0MCUuKL4otn5BK6Ni0ARTXTSpRNBzZ7hpMfKSvnVSED5kYJm96YOWsqV0JH0d2uuw==" + }, + "runtime.any.System.IO": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "SDZ5AD1DtyRoxYtEcqQ3HDlcrorMYXZeCt7ZhG9US9I5Vva+gpIWDGMkcwa5XiKL0ceQKRZIX2x0XEjLX7PDzQ==" + }, + "runtime.any.System.Reflection": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "hLC3A3rI8jipR5d9k7+f0MgRCW6texsAp0MWkN/ci18FMtQ9KH7E2vDn/DH2LkxsszlpJpOn9qy6Z6/69rH6eQ==" + }, + "runtime.any.System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "cPhT+Vqu52+cQQrDai/V91gubXUnDKNRvlBnH+hOgtGyHdC17aQIU64EaehwAQymd7kJA5rSrVRNfDYrbhnzyA==" + }, + "runtime.any.System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Nrm1p3armp6TTf2xuvaa+jGTTmncALWFq22CpmwRvhDf6dE9ZmH40EbOswD4GnFLrMRS0Ki6Kx5aUPmKK/hZBg==" + }, + "runtime.any.System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Lxb89SMvf8w9p9+keBLyL6H6x/TEmc6QVsIIA0T36IuyOY3kNvIdyGddA2qt35cRamzxF8K5p0Opq4G4HjNbhQ==" + }, + "runtime.any.System.Runtime": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "fRS7zJgaG9NkifaAxGGclDDoRn9HC7hXACl52Or06a/fxdzDajWb5wov3c6a+gVSlekRoexfjwQSK9sh5um5LQ==", + "dependencies": { + "System.Private.Uri": "4.3.0" + } + }, + "runtime.any.System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "GG84X6vufoEzqx8PbeBKheE4srOhimv+yLtGb/JkR3Y2FmoqmueLNFU4Xx8Y67plFpltQSdK74x0qlEhIpv/CQ==" + }, + "runtime.any.System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "lBoFeQfxe/4eqjPi46E0LU/YaCMdNkQ8B4MZu/mkzdIAZh8RQ1NYZSj0egrQKdgdvlPFtP4STtob40r4o2DBAw==" + }, + "runtime.any.System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "+ihI5VaXFCMVPJNstG4O4eo1CfbrByLxRrQQTqOTp1ttK0kUKDqOdBSTaCB2IBk/QtjDrs6+x4xuezyMXdm0HQ==" + }, + "runtime.any.System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "OhBAVBQG5kFj1S+hCEQ3TUHBAEtZ3fbEMgZMRNdN8A0Pj4x+5nTELEqL59DU0TjKVE6II3dqKw4Dklb3szT65w==" + }, + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "HdSSp5MnJSsg08KMfZThpuLPJpPwE5hBXvHwoKWosyHHfe8Mh5WKT0ylEOf6yNzX6Ngjxe4Whkafh5q7Ymac4Q==" + }, + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "+yH1a49wJMy8Zt4yx5RhJrxO/DBDByAiCzNwiETI+1S4mPdCu0OY4djdciC7Vssk0l22wQaDLrXxXkp+3+7bVA==" + }, + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "c3YNH1GQJbfIPJeCnr4avseugSqPrxwIqzthYyZDN6EuOyNOzq+y2KSUfRcXauya1sF4foESTgwM5e1A8arAKw==" + }, + "runtime.native.System": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "c/qWt2LieNZIj1jGnVNsE2Kl23Ya2aSTBuXMD6V7k9KWr6l16Tqdwq+hJScEpWER9753NWC8h96PaVNY5Ld7Jw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0" + } + }, + "runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "NS1U+700m4KFRHR5o4vo9DSlTmlCKu/u7dtE5sUHVIPB+xpXxYQvgBgA6wEIeCz6Yfn0Z52/72WYsToCEPJnrw==", + "dependencies": { + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } + }, + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "b3pthNgxxFcD+Pc0WSEoC0+md3MyhRS6aCEeenvNE3Fdw1HyJ18ZhRFVJJzIeR/O/jpxPboB805Ho0T3Ul7w8A==" + }, + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "KeLz4HClKf+nFS7p/6Fi/CqyLXh81FpiGzcmuS8DGi9lUqSnZ6Es23/gv2O+1XVGfrbNmviF7CckBpavkBoIFQ==" + }, + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "X7IdhILzr4ROXd8mI1BUCQMSHSQwelUlBjF1JyTKCjXaOGn2fB4EKBxQbCK2VjO3WaWIdlXZL3W6TiIVnrhX4g==" + }, + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "nyFNiCk/r+VOiIqreLix8yN+q3Wga9+SE8BCgkf+2BwEKiNx6DyvFjCgkfV743/grxv8jHJ8gUK4XEQw7yzRYg==" + }, + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "ytoewC6wGorL7KoCAvRfsgoJPJbNq+64k2SqW6JcOAebWsFUvCCYgfzQMrnpvPiEl4OrblUlhF2ji+Q1+SVLrQ==" + }, + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "I8bKw2I8k58Wx7fMKQJn2R8lamboCAiHfHeV/pS65ScKWMMI0+wJkLYlEKvgW1D/XvSl/221clBoR2q9QNNM7A==" + }, + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "VB5cn/7OzUfzdnC8tqAIMQciVLiq2epm2NrAm1E9OjNRyG4lVhfR61SMcLizejzQP8R8Uf/0l5qOIbUEi+RdEg==" + }, + "runtime.unix.System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "WV8KLRHWVUVUDduFnvGMHt0FsEt2wK6xPl1EgDKlaMx2KnZ43A/O0GzP8wIuvAC7mq4T9V1mm90r+PXkL9FPdQ==", + "dependencies": { + "runtime.native.System": "4.3.0" + } + }, + "runtime.unix.System.Private.Uri": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "ooWzobr5RAq34r9uan1r/WPXJYG1XWy9KanrxNvEnBzbFdQbMG7Y3bVi4QxR7xZMNLOxLLTAyXvnSkfj5boZSg==", + "dependencies": { + "runtime.native.System": "4.3.0" + } + }, + "runtime.unix.System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "zQiTBVpiLftTQZW8GFsV0gjYikB1WMkEPIxF5O6RkUrSV/OgvRRTYgeFQha/0keBpuS0HYweraGRwhfhJ7dj7w==", + "dependencies": { + "System.Private.Uri": "4.3.0", + "runtime.native.System": "4.3.0", + "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } + }, + "System.Collections": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "YUJGz6eFKqS0V//mLt25vFGrrCvOnsXjlvFQs+KimpwNxug9x0Pzy4PlFMU3Q2IzqAa9G2L4LsK3+9vCBK7oTg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Collections": "4.3.0" + } + }, + "System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "w5U95fVKHY4G8ASs/K5iK3J5LY+/dLFd4vKejsnI/ZhBsWS9hQakfx3Zr7lRWKg4tAw9r4iktyvsTagWkqYCiw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.unix.System.Diagnostics.Debug": "4.3.0" + } + }, + "System.Diagnostics.EventLog": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "uaFRda9NjtbJRkdx311eXlAA3n2em7223c1A8d1VWyl+4FL9vkG7y2lpPfBU9HYdj/9KgdRNdn1vFK8ZYCYT/A==" + }, + "System.Globalization": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "B95h0YLEL2oSnwF/XjqSWKnwKOy/01VWkNlsCeMTFJLLabflpGV26nK164eRs5GiaRSBGpOxQ3pKoSnnyZN5pg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Globalization": "4.3.0" + } + }, + "System.IO": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "3KlTJceQc3gnGIaHZ7UBZO26SHL1SHE4ddrmiwumFnId+CEHP+O8r386tZKaE6zlk5/mF8vifMBzHj9SaXN+mQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading.Tasks": "4.0.11", + "runtime.any.System.IO": "4.3.0" + } + }, + "System.Private.Uri": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "I4SwANiUGho1esj4V4oSlPllXjzCZDE+5XXso2P03LW2vOda2Enzh8DWOxwN6hnrJyp314c7KuVu31QYhRzOGg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "runtime.unix.System.Private.Uri": "4.3.0" + } + }, + "System.Reflection": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "JCKANJ0TI7kzoQzuwB/OoJANy1Lg338B6+JVacPl4TpUwi3cReg3nMLplMq2uqYfHFQpKIlHAUVAJlImZz/4ng==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection": "4.3.0" + } + }, + "System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "GYrtRsZcMuHF3sbmRHfMYpvxZoIN2bQGrYGerUiWLEkqdEUQZhH3TRSaC/oI4wO0II1RKBPlpIa1TOMxIcOOzQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Extensions": "4.3.0" + } + }, + "System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "4inTox4wTBaDhB7V3mPvp9XlCbeGYWVEM9/fXALd52vNEAVisc1BoVWQPuUuD0Ga//dNbA/WeMy9u9mzLxGTHQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Primitives": "4.3.0" + } + }, + "System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "TxwVeUNoTgUOdQ09gfTjvW411MF+w9MBYL7AtNVc+HtBCFlutPLhUCdZjNkjbhj3bNQWMdHboF0KIWEOjJssbA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Globalization": "4.0.11", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Resources.ResourceManager": "4.3.0" + } + }, + "System.Runtime": { + "type": "Transitive", + "resolved": "4.3.1", + "contentHash": "abhfv1dTK6NXOmu4bgHIONxHyEqFjW8HwXPmpY9gmll+ix9UNo4XDcmzJn6oLooftxNssVHdJC1pGT9jkSynQg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.1", + "Microsoft.NETCore.Targets": "1.1.3", + "runtime.any.System.Runtime": "4.3.0" + } + }, + "System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "CUOHjTT/vgP0qGW22U4/hDlOqXmcPq5YicBaXdUR2UiUoLwBT+olO6we4DVbq57jeX5uXH2uerVZhf0qGj+sVQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.unix.System.Runtime.Extensions": "4.3.0" + } + }, + "System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "nCJvEKguXEvk2ymk1gqj625vVnlK3/xdGzx0vOKicQkoquaTBJTP13AIYkocSUwHCLNBwUbXTqTWGDxBTWpt7g==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Runtime.Handles": "4.3.0" + } + }, + "System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "16eu3kjHS633yYdkjwShDHZLRNMKVi/s0bY8ODiqJ2RfMhDMAwxZaUaWVnZ2P71kr/or+X9o/xFWtNqz8ivieQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "runtime.any.System.Runtime.InteropServices": "4.3.0" + } + }, + "System.Security.AccessControl": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dagJ1mHZO3Ani8GH0PHpPEe/oYO+rVdbQjvjJkBRNQkX4t0r1iaeGn8+/ybkSLEan3/slM0t59SVdHzuHf2jmw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } + }, + "System.Security.Cryptography.Pkcs": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "UPWqLSygJlFerRi9XNIuM0a1VC8gHUIufyP24xQ0sc+XimqUAEcjpOz9DhKpyDjH+5B/wO3RpC0KpkEeDj/ddg==" + }, + "System.Security.Principal.Windows": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "t0MGLukB5WAVU9bO3MGzvlGnyJPgUlcwerXn1kzBRjwLKixT96XV0Uza41W49gVd8zEMFu9vQEFlv0IOrytICA==" + }, + "System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "U3gGeMlDZXxCEiY4DwVLSacg+DFWCvoiX+JThA/rvw37Sqrku7sEFeVBBBMBnfB6FeZHsyDx85HlKL19x0HtZA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Text.Encoding": "4.3.0" + } + }, + "System.Text.Encoding.CodePages": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "ZFCILZuOvtKPauZ/j/swhvw68ZRi9ATCfvGbk1QfydmcXBkIWecWKn/250UH7rahZ5OoDBaiAudJtPvLwzw85A==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.0.0" + } + }, + "System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "k1S4Gc6IGwtHGT8188RSeGaX86Qw/wnrgNLshJvsdNUOPP9etMmo8S07c+UlOAx4K/xLuN9ivA1bD0LVurtIxQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Threading.Tasks": "4.3.0" + } + }, + "Tmds.LibC": { + "type": "Transitive", + "resolved": "0.2.0", + "contentHash": "+RvLuNHOLW7cxzgDe9yHLoayBgjsuH2/gJtJnuVMxweKrxxYT6TwQNAmt06SFWpjwk68aRcwwD4FfMMA6tZvVA==" + }, + "Ckzg.Bindings": { + "type": "CentralTransitive", + "requested": "[2.1.5.1542, )", + "resolved": "2.1.5.1542", + "contentHash": "GFXmOjg5fZ8s+836/HdKiyXbJ+J73wVX6hNmUE6Isb1rA8dI2SMLeW1m48s+ZNIPN9ENJb8Daq1GwmMjBGjUVQ==" + }, + "Microsoft.ClearScript.V8.Native.linux-arm64": { "type": "CentralTransitive", "requested": "[7.5.0, )", "resolved": "7.5.0", "contentHash": "UU+3Bef3UnwQgP8hKobT09ucYuYubVFiseAsuRUvmjvOBVu7yHRES+nXBNYSvDi88fMTp/HBUknpYQdrfoDemQ==" }, - "Microsoft.ClearScript.V8.Native.linux-x64": { - "type": "CentralTransitive", - "requested": "[7.5.0, )", - "resolved": "7.5.0", - "contentHash": "snoN9oRwKqShA32IsuCanLjNtP8hros2WOrOBL7g+ED3AV40qwrsbfKwWq37BzogrfsF1aEVoDkBpE19Az7DVQ==" + "Microsoft.ClearScript.V8.Native.linux-x64": { + "type": "CentralTransitive", + "requested": "[7.5.0, )", + "resolved": "7.5.0", + "contentHash": "snoN9oRwKqShA32IsuCanLjNtP8hros2WOrOBL7g+ED3AV40qwrsbfKwWq37BzogrfsF1aEVoDkBpE19Az7DVQ==" + }, + "Microsoft.ClearScript.V8.Native.osx-arm64": { + "type": "CentralTransitive", + "requested": "[7.5.0, )", + "resolved": "7.5.0", + "contentHash": "CkMgeX0I0+bXUzoaVoJdV86/k0H2PEukqCoZ8zQ28msB6YHeRX6FJTfvOQ0l6UTX5HaBHGG3CWUI04uBYe6M+A==" + }, + "Microsoft.ClearScript.V8.Native.osx-x64": { + "type": "CentralTransitive", + "requested": "[7.5.0, )", + "resolved": "7.5.0", + "contentHash": "yXoXLWKJJgW5V6ez1aMa+ZS2nCef0X4iTYzPS9bTSYl9y7D4R2Ie2KrfR8nLO2rhOKimIMx3MH49Zh1CYruN/g==" + }, + "Microsoft.ClearScript.V8.Native.win-x64": { + "type": "CentralTransitive", + "requested": "[7.5.0, )", + "resolved": "7.5.0", + "contentHash": "DKMxDLboTNflYkwDQ/ELrSf1vXTpew5UZ8xzrXSVKYFBU570VA6NKh1etEGhufuCuDyU7Je5L2g6H+19Dbl+tA==" + }, + "Nethermind.Crypto.Bls": { + "type": "CentralTransitive", + "requested": "[1.0.5, )", + "resolved": "1.0.5", + "contentHash": "SYdQOFVVcC3R3VAm9Dv+u4Mc1yqHZETxt4tN3a+AFeOnEtUmpcjwVwYkkiiUIIrr6vQVVOUuwsDmaa9l3u45IQ==" + }, + "Nethermind.Crypto.SecP256k1": { + "type": "CentralTransitive", + "requested": "[1.5.0, )", + "resolved": "1.5.0", + "contentHash": "+mNlEgN1gYDB6f4jRcYssaE6/AlSoPr7eLDQHQoX+tXcnGRzgnArezPwz82TsWxruQGDh5h9Qfowa0xt4Xz59g==" + }, + "Nethermind.Crypto.SecP256r1": { + "type": "CentralTransitive", + "requested": "[1.0.0-preview.6, )", + "resolved": "1.0.0-preview.6", + "contentHash": "wFfpg1ofZz5nsjN8TAKUg0mdUCskmOUO0lFk3LcoeRkVnQ5Rw2rYzsJxgPFfnxAABH/EPPs62S7oF8E0Ayjjeg==" + }, + "Nethermind.GmpBindings": { + "type": "CentralTransitive", + "requested": "[1.0.3, )", + "resolved": "1.0.3", + "contentHash": "EE12z2k4ku0ugfI01utaQR8EbBoEMLI4QAKKGrfz5Fvbw/YtXTqDDzvKtBTleOB9YBH7oTpH9T9ZFtKgKZMj2g==" + }, + "Nethermind.MclBindings": { + "type": "CentralTransitive", + "requested": "[1.0.3, )", + "resolved": "1.0.3", + "contentHash": "hgT2oiMFqItNXv5vzIbhhlgqPJK4qnOHaYmUiR4jJsaWiqDRH05YtqYeMQq2+oyBOf8REtuGOW5RZ7+agRSEbg==" + }, + "RocksDB": { + "type": "CentralTransitive", + "requested": "[10.4.2.62659, 10.4.2.62659]", + "resolved": "10.4.2.62659", + "contentHash": "+ZY7koKclaRz7+3QiCbXprWK4++Cwh0Hhqj+5Z5fcZpQvoIoo+iM9iAdCo+W5ha9XOLeI0YWbi9nZt12dNVBMg==" + } + }, + "net10.0/osx-x64": { + "Grpc.Core": { + "type": "Transitive", + "resolved": "2.46.6", + "contentHash": "ZoRg3KmOJ2urTF4+u3H0b1Yv10xzz2Y/flFWS2tnRmj8dbKLeiJaSRqu4LOBD3ova90evqLkVZ85kUkC4JT4lw==", + "dependencies": { + "Grpc.Core.Api": "2.46.6", + "System.Memory": "4.5.3" + } + }, + "libsodium": { + "type": "Transitive", + "resolved": "1.0.20", + "contentHash": "fMO6HpAbvLagobzBH6eU36riWF01lCAweX34D5eugqjuXA+WS5MnV1ngE+2Sw3LvGvxZlmyLp9416t57dMZ5og==" + }, + "Microsoft.Win32.Registry": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dDoKi0PnDz31yAyETfRntsLArTlVAVzUzCIvvEDsDsucrl33Dl8pIJG06ePTJTI3tGpeyHS9Cq7Foc/s4EeKcg==", + "dependencies": { + "System.Security.AccessControl": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } + }, + "runtime.any.System.Collections": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "23g6rqftKmovn2cLeGsuHUYm0FD7pdutb0uQMJpZ3qTvq+zHkgmt6J65VtRry4WDGYlmkMa4xDACtaQ94alNag==", + "dependencies": { + "System.Runtime": "4.3.0" + } + }, + "runtime.any.System.Globalization": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "sMDBnad4rp4t7GY442Jux0MCUuKL4otn5BK6Ni0ARTXTSpRNBzZ7hpMfKSvnVSED5kYJm96YOWsqV0JH0d2uuw==" + }, + "runtime.any.System.IO": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "SDZ5AD1DtyRoxYtEcqQ3HDlcrorMYXZeCt7ZhG9US9I5Vva+gpIWDGMkcwa5XiKL0ceQKRZIX2x0XEjLX7PDzQ==" + }, + "runtime.any.System.Reflection": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "hLC3A3rI8jipR5d9k7+f0MgRCW6texsAp0MWkN/ci18FMtQ9KH7E2vDn/DH2LkxsszlpJpOn9qy6Z6/69rH6eQ==" + }, + "runtime.any.System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "cPhT+Vqu52+cQQrDai/V91gubXUnDKNRvlBnH+hOgtGyHdC17aQIU64EaehwAQymd7kJA5rSrVRNfDYrbhnzyA==" + }, + "runtime.any.System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Nrm1p3armp6TTf2xuvaa+jGTTmncALWFq22CpmwRvhDf6dE9ZmH40EbOswD4GnFLrMRS0Ki6Kx5aUPmKK/hZBg==" + }, + "runtime.any.System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Lxb89SMvf8w9p9+keBLyL6H6x/TEmc6QVsIIA0T36IuyOY3kNvIdyGddA2qt35cRamzxF8K5p0Opq4G4HjNbhQ==" + }, + "runtime.any.System.Runtime": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "fRS7zJgaG9NkifaAxGGclDDoRn9HC7hXACl52Or06a/fxdzDajWb5wov3c6a+gVSlekRoexfjwQSK9sh5um5LQ==", + "dependencies": { + "System.Private.Uri": "4.3.0" + } + }, + "runtime.any.System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "GG84X6vufoEzqx8PbeBKheE4srOhimv+yLtGb/JkR3Y2FmoqmueLNFU4Xx8Y67plFpltQSdK74x0qlEhIpv/CQ==" + }, + "runtime.any.System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "lBoFeQfxe/4eqjPi46E0LU/YaCMdNkQ8B4MZu/mkzdIAZh8RQ1NYZSj0egrQKdgdvlPFtP4STtob40r4o2DBAw==" + }, + "runtime.any.System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "+ihI5VaXFCMVPJNstG4O4eo1CfbrByLxRrQQTqOTp1ttK0kUKDqOdBSTaCB2IBk/QtjDrs6+x4xuezyMXdm0HQ==" + }, + "runtime.any.System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "OhBAVBQG5kFj1S+hCEQ3TUHBAEtZ3fbEMgZMRNdN8A0Pj4x+5nTELEqL59DU0TjKVE6II3dqKw4Dklb3szT65w==" + }, + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "HdSSp5MnJSsg08KMfZThpuLPJpPwE5hBXvHwoKWosyHHfe8Mh5WKT0ylEOf6yNzX6Ngjxe4Whkafh5q7Ymac4Q==" + }, + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "+yH1a49wJMy8Zt4yx5RhJrxO/DBDByAiCzNwiETI+1S4mPdCu0OY4djdciC7Vssk0l22wQaDLrXxXkp+3+7bVA==" + }, + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "c3YNH1GQJbfIPJeCnr4avseugSqPrxwIqzthYyZDN6EuOyNOzq+y2KSUfRcXauya1sF4foESTgwM5e1A8arAKw==" + }, + "runtime.native.System": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "c/qWt2LieNZIj1jGnVNsE2Kl23Ya2aSTBuXMD6V7k9KWr6l16Tqdwq+hJScEpWER9753NWC8h96PaVNY5Ld7Jw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0" + } + }, + "runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "NS1U+700m4KFRHR5o4vo9DSlTmlCKu/u7dtE5sUHVIPB+xpXxYQvgBgA6wEIeCz6Yfn0Z52/72WYsToCEPJnrw==", + "dependencies": { + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } + }, + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "b3pthNgxxFcD+Pc0WSEoC0+md3MyhRS6aCEeenvNE3Fdw1HyJ18ZhRFVJJzIeR/O/jpxPboB805Ho0T3Ul7w8A==" + }, + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "KeLz4HClKf+nFS7p/6Fi/CqyLXh81FpiGzcmuS8DGi9lUqSnZ6Es23/gv2O+1XVGfrbNmviF7CckBpavkBoIFQ==" + }, + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "X7IdhILzr4ROXd8mI1BUCQMSHSQwelUlBjF1JyTKCjXaOGn2fB4EKBxQbCK2VjO3WaWIdlXZL3W6TiIVnrhX4g==" + }, + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "nyFNiCk/r+VOiIqreLix8yN+q3Wga9+SE8BCgkf+2BwEKiNx6DyvFjCgkfV743/grxv8jHJ8gUK4XEQw7yzRYg==" + }, + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "ytoewC6wGorL7KoCAvRfsgoJPJbNq+64k2SqW6JcOAebWsFUvCCYgfzQMrnpvPiEl4OrblUlhF2ji+Q1+SVLrQ==" + }, + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "I8bKw2I8k58Wx7fMKQJn2R8lamboCAiHfHeV/pS65ScKWMMI0+wJkLYlEKvgW1D/XvSl/221clBoR2q9QNNM7A==" + }, + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "VB5cn/7OzUfzdnC8tqAIMQciVLiq2epm2NrAm1E9OjNRyG4lVhfR61SMcLizejzQP8R8Uf/0l5qOIbUEi+RdEg==" }, - "Microsoft.ClearScript.V8.Native.osx-arm64": { - "type": "CentralTransitive", - "requested": "[7.5.0, )", - "resolved": "7.5.0", - "contentHash": "CkMgeX0I0+bXUzoaVoJdV86/k0H2PEukqCoZ8zQ28msB6YHeRX6FJTfvOQ0l6UTX5HaBHGG3CWUI04uBYe6M+A==" + "runtime.unix.System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "WV8KLRHWVUVUDduFnvGMHt0FsEt2wK6xPl1EgDKlaMx2KnZ43A/O0GzP8wIuvAC7mq4T9V1mm90r+PXkL9FPdQ==", + "dependencies": { + "runtime.native.System": "4.3.0" + } }, - "Microsoft.ClearScript.V8.Native.osx-x64": { - "type": "CentralTransitive", - "requested": "[7.5.0, )", - "resolved": "7.5.0", - "contentHash": "yXoXLWKJJgW5V6ez1aMa+ZS2nCef0X4iTYzPS9bTSYl9y7D4R2Ie2KrfR8nLO2rhOKimIMx3MH49Zh1CYruN/g==" + "runtime.unix.System.Private.Uri": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "ooWzobr5RAq34r9uan1r/WPXJYG1XWy9KanrxNvEnBzbFdQbMG7Y3bVi4QxR7xZMNLOxLLTAyXvnSkfj5boZSg==", + "dependencies": { + "runtime.native.System": "4.3.0" + } }, - "Microsoft.ClearScript.V8.Native.win-x64": { - "type": "CentralTransitive", - "requested": "[7.5.0, )", - "resolved": "7.5.0", - "contentHash": "DKMxDLboTNflYkwDQ/ELrSf1vXTpew5UZ8xzrXSVKYFBU570VA6NKh1etEGhufuCuDyU7Je5L2g6H+19Dbl+tA==" + "runtime.unix.System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "zQiTBVpiLftTQZW8GFsV0gjYikB1WMkEPIxF5O6RkUrSV/OgvRRTYgeFQha/0keBpuS0HYweraGRwhfhJ7dj7w==", + "dependencies": { + "System.Private.Uri": "4.3.0", + "runtime.native.System": "4.3.0", + "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } }, - "Nethermind.Crypto.Bls": { - "type": "CentralTransitive", - "requested": "[1.0.5, )", - "resolved": "1.0.5", - "contentHash": "SYdQOFVVcC3R3VAm9Dv+u4Mc1yqHZETxt4tN3a+AFeOnEtUmpcjwVwYkkiiUIIrr6vQVVOUuwsDmaa9l3u45IQ==" + "System.Collections": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "YUJGz6eFKqS0V//mLt25vFGrrCvOnsXjlvFQs+KimpwNxug9x0Pzy4PlFMU3Q2IzqAa9G2L4LsK3+9vCBK7oTg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Collections": "4.3.0" + } }, - "Nethermind.Crypto.SecP256k1": { - "type": "CentralTransitive", - "requested": "[1.5.0, )", - "resolved": "1.5.0", - "contentHash": "+mNlEgN1gYDB6f4jRcYssaE6/AlSoPr7eLDQHQoX+tXcnGRzgnArezPwz82TsWxruQGDh5h9Qfowa0xt4Xz59g==" + "System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "w5U95fVKHY4G8ASs/K5iK3J5LY+/dLFd4vKejsnI/ZhBsWS9hQakfx3Zr7lRWKg4tAw9r4iktyvsTagWkqYCiw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.unix.System.Diagnostics.Debug": "4.3.0" + } }, - "Nethermind.Crypto.SecP256r1": { - "type": "CentralTransitive", - "requested": "[1.0.0-preview.6, )", - "resolved": "1.0.0-preview.6", - "contentHash": "wFfpg1ofZz5nsjN8TAKUg0mdUCskmOUO0lFk3LcoeRkVnQ5Rw2rYzsJxgPFfnxAABH/EPPs62S7oF8E0Ayjjeg==" + "System.Diagnostics.EventLog": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "uaFRda9NjtbJRkdx311eXlAA3n2em7223c1A8d1VWyl+4FL9vkG7y2lpPfBU9HYdj/9KgdRNdn1vFK8ZYCYT/A==" }, - "Nethermind.GmpBindings": { - "type": "CentralTransitive", - "requested": "[1.0.3, )", - "resolved": "1.0.3", - "contentHash": "EE12z2k4ku0ugfI01utaQR8EbBoEMLI4QAKKGrfz5Fvbw/YtXTqDDzvKtBTleOB9YBH7oTpH9T9ZFtKgKZMj2g==" + "System.Globalization": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "B95h0YLEL2oSnwF/XjqSWKnwKOy/01VWkNlsCeMTFJLLabflpGV26nK164eRs5GiaRSBGpOxQ3pKoSnnyZN5pg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Globalization": "4.3.0" + } }, - "Nethermind.MclBindings": { - "type": "CentralTransitive", - "requested": "[1.0.3, )", - "resolved": "1.0.3", - "contentHash": "hgT2oiMFqItNXv5vzIbhhlgqPJK4qnOHaYmUiR4jJsaWiqDRH05YtqYeMQq2+oyBOf8REtuGOW5RZ7+agRSEbg==" + "System.IO": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "3KlTJceQc3gnGIaHZ7UBZO26SHL1SHE4ddrmiwumFnId+CEHP+O8r386tZKaE6zlk5/mF8vifMBzHj9SaXN+mQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading.Tasks": "4.0.11", + "runtime.any.System.IO": "4.3.0" + } }, - "RocksDB": { - "type": "CentralTransitive", - "requested": "[10.4.2.62659, 10.4.2.62659]", - "resolved": "10.4.2.62659", - "contentHash": "+ZY7koKclaRz7+3QiCbXprWK4++Cwh0Hhqj+5Z5fcZpQvoIoo+iM9iAdCo+W5ha9XOLeI0YWbi9nZt12dNVBMg==" - } - }, - "net10.0/osx-x64": { - "Grpc.Core": { + "System.Private.Uri": { "type": "Transitive", - "resolved": "2.46.6", - "contentHash": "ZoRg3KmOJ2urTF4+u3H0b1Yv10xzz2Y/flFWS2tnRmj8dbKLeiJaSRqu4LOBD3ova90evqLkVZ85kUkC4JT4lw==", + "resolved": "4.3.0", + "contentHash": "I4SwANiUGho1esj4V4oSlPllXjzCZDE+5XXso2P03LW2vOda2Enzh8DWOxwN6hnrJyp314c7KuVu31QYhRzOGg==", "dependencies": { - "Grpc.Core.Api": "2.46.6" + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "runtime.unix.System.Private.Uri": "4.3.0" } }, - "libsodium": { + "System.Reflection": { "type": "Transitive", - "resolved": "1.0.20", - "contentHash": "fMO6HpAbvLagobzBH6eU36riWF01lCAweX34D5eugqjuXA+WS5MnV1ngE+2Sw3LvGvxZlmyLp9416t57dMZ5og==" + "resolved": "4.1.0", + "contentHash": "JCKANJ0TI7kzoQzuwB/OoJANy1Lg338B6+JVacPl4TpUwi3cReg3nMLplMq2uqYfHFQpKIlHAUVAJlImZz/4ng==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection": "4.3.0" + } + }, + "System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "GYrtRsZcMuHF3sbmRHfMYpvxZoIN2bQGrYGerUiWLEkqdEUQZhH3TRSaC/oI4wO0II1RKBPlpIa1TOMxIcOOzQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Extensions": "4.3.0" + } + }, + "System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "4inTox4wTBaDhB7V3mPvp9XlCbeGYWVEM9/fXALd52vNEAVisc1BoVWQPuUuD0Ga//dNbA/WeMy9u9mzLxGTHQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Primitives": "4.3.0" + } + }, + "System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "TxwVeUNoTgUOdQ09gfTjvW411MF+w9MBYL7AtNVc+HtBCFlutPLhUCdZjNkjbhj3bNQWMdHboF0KIWEOjJssbA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Globalization": "4.0.11", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Resources.ResourceManager": "4.3.0" + } + }, + "System.Runtime": { + "type": "Transitive", + "resolved": "4.3.1", + "contentHash": "abhfv1dTK6NXOmu4bgHIONxHyEqFjW8HwXPmpY9gmll+ix9UNo4XDcmzJn6oLooftxNssVHdJC1pGT9jkSynQg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.1", + "Microsoft.NETCore.Targets": "1.1.3", + "runtime.any.System.Runtime": "4.3.0" + } + }, + "System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "CUOHjTT/vgP0qGW22U4/hDlOqXmcPq5YicBaXdUR2UiUoLwBT+olO6we4DVbq57jeX5uXH2uerVZhf0qGj+sVQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.unix.System.Runtime.Extensions": "4.3.0" + } + }, + "System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "nCJvEKguXEvk2ymk1gqj625vVnlK3/xdGzx0vOKicQkoquaTBJTP13AIYkocSUwHCLNBwUbXTqTWGDxBTWpt7g==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Runtime.Handles": "4.3.0" + } + }, + "System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "16eu3kjHS633yYdkjwShDHZLRNMKVi/s0bY8ODiqJ2RfMhDMAwxZaUaWVnZ2P71kr/or+X9o/xFWtNqz8ivieQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "runtime.any.System.Runtime.InteropServices": "4.3.0" + } + }, + "System.Security.AccessControl": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dagJ1mHZO3Ani8GH0PHpPEe/oYO+rVdbQjvjJkBRNQkX4t0r1iaeGn8+/ybkSLEan3/slM0t59SVdHzuHf2jmw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } + }, + "System.Security.Cryptography.Pkcs": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "UPWqLSygJlFerRi9XNIuM0a1VC8gHUIufyP24xQ0sc+XimqUAEcjpOz9DhKpyDjH+5B/wO3RpC0KpkEeDj/ddg==" + }, + "System.Security.Principal.Windows": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "t0MGLukB5WAVU9bO3MGzvlGnyJPgUlcwerXn1kzBRjwLKixT96XV0Uza41W49gVd8zEMFu9vQEFlv0IOrytICA==" + }, + "System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "U3gGeMlDZXxCEiY4DwVLSacg+DFWCvoiX+JThA/rvw37Sqrku7sEFeVBBBMBnfB6FeZHsyDx85HlKL19x0HtZA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Text.Encoding": "4.3.0" + } + }, + "System.Text.Encoding.CodePages": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "ZFCILZuOvtKPauZ/j/swhvw68ZRi9ATCfvGbk1QfydmcXBkIWecWKn/250UH7rahZ5OoDBaiAudJtPvLwzw85A==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.0.0" + } + }, + "System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "k1S4Gc6IGwtHGT8188RSeGaX86Qw/wnrgNLshJvsdNUOPP9etMmo8S07c+UlOAx4K/xLuN9ivA1bD0LVurtIxQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Threading.Tasks": "4.3.0" + } }, "Tmds.LibC": { "type": "Transitive", @@ -2002,7 +4301,8 @@ "resolved": "2.46.6", "contentHash": "ZoRg3KmOJ2urTF4+u3H0b1Yv10xzz2Y/flFWS2tnRmj8dbKLeiJaSRqu4LOBD3ova90evqLkVZ85kUkC4JT4lw==", "dependencies": { - "Grpc.Core.Api": "2.46.6" + "Grpc.Core.Api": "2.46.6", + "System.Memory": "4.5.3" } }, "libsodium": { @@ -2010,6 +4310,298 @@ "resolved": "1.0.20", "contentHash": "fMO6HpAbvLagobzBH6eU36riWF01lCAweX34D5eugqjuXA+WS5MnV1ngE+2Sw3LvGvxZlmyLp9416t57dMZ5og==" }, + "Microsoft.Win32.Registry": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dDoKi0PnDz31yAyETfRntsLArTlVAVzUzCIvvEDsDsucrl33Dl8pIJG06ePTJTI3tGpeyHS9Cq7Foc/s4EeKcg==", + "dependencies": { + "System.Security.AccessControl": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } + }, + "runtime.any.System.Collections": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "23g6rqftKmovn2cLeGsuHUYm0FD7pdutb0uQMJpZ3qTvq+zHkgmt6J65VtRry4WDGYlmkMa4xDACtaQ94alNag==", + "dependencies": { + "System.Runtime": "4.3.0" + } + }, + "runtime.any.System.Globalization": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "sMDBnad4rp4t7GY442Jux0MCUuKL4otn5BK6Ni0ARTXTSpRNBzZ7hpMfKSvnVSED5kYJm96YOWsqV0JH0d2uuw==" + }, + "runtime.any.System.IO": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "SDZ5AD1DtyRoxYtEcqQ3HDlcrorMYXZeCt7ZhG9US9I5Vva+gpIWDGMkcwa5XiKL0ceQKRZIX2x0XEjLX7PDzQ==" + }, + "runtime.any.System.Reflection": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "hLC3A3rI8jipR5d9k7+f0MgRCW6texsAp0MWkN/ci18FMtQ9KH7E2vDn/DH2LkxsszlpJpOn9qy6Z6/69rH6eQ==" + }, + "runtime.any.System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "cPhT+Vqu52+cQQrDai/V91gubXUnDKNRvlBnH+hOgtGyHdC17aQIU64EaehwAQymd7kJA5rSrVRNfDYrbhnzyA==" + }, + "runtime.any.System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Nrm1p3armp6TTf2xuvaa+jGTTmncALWFq22CpmwRvhDf6dE9ZmH40EbOswD4GnFLrMRS0Ki6Kx5aUPmKK/hZBg==" + }, + "runtime.any.System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "Lxb89SMvf8w9p9+keBLyL6H6x/TEmc6QVsIIA0T36IuyOY3kNvIdyGddA2qt35cRamzxF8K5p0Opq4G4HjNbhQ==" + }, + "runtime.any.System.Runtime": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "fRS7zJgaG9NkifaAxGGclDDoRn9HC7hXACl52Or06a/fxdzDajWb5wov3c6a+gVSlekRoexfjwQSK9sh5um5LQ==", + "dependencies": { + "System.Private.Uri": "4.3.0" + } + }, + "runtime.any.System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "GG84X6vufoEzqx8PbeBKheE4srOhimv+yLtGb/JkR3Y2FmoqmueLNFU4Xx8Y67plFpltQSdK74x0qlEhIpv/CQ==" + }, + "runtime.any.System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "lBoFeQfxe/4eqjPi46E0LU/YaCMdNkQ8B4MZu/mkzdIAZh8RQ1NYZSj0egrQKdgdvlPFtP4STtob40r4o2DBAw==" + }, + "runtime.any.System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "+ihI5VaXFCMVPJNstG4O4eo1CfbrByLxRrQQTqOTp1ttK0kUKDqOdBSTaCB2IBk/QtjDrs6+x4xuezyMXdm0HQ==" + }, + "runtime.any.System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "OhBAVBQG5kFj1S+hCEQ3TUHBAEtZ3fbEMgZMRNdN8A0Pj4x+5nTELEqL59DU0TjKVE6II3dqKw4Dklb3szT65w==" + }, + "runtime.win.System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "hHHP0WCStene2jjeYcuDkETozUYF/3sHVRHAEOgS3L15hlip24ssqCTnJC28Z03Wpo078oMcJd0H4egD2aJI8g==" + }, + "runtime.win.System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "RkgHVhUPvzZxuUubiZe8yr/6CypRVXj0VBzaR8hsqQ8f+rUo7e4PWrHTLOCjd8fBMGWCrY//fi7Ku3qXD7oHRw==", + "dependencies": { + "System.Private.Uri": "4.3.0" + } + }, + "System.Collections": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "YUJGz6eFKqS0V//mLt25vFGrrCvOnsXjlvFQs+KimpwNxug9x0Pzy4PlFMU3Q2IzqAa9G2L4LsK3+9vCBK7oTg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Collections": "4.3.0" + } + }, + "System.Diagnostics.Debug": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "w5U95fVKHY4G8ASs/K5iK3J5LY+/dLFd4vKejsnI/ZhBsWS9hQakfx3Zr7lRWKg4tAw9r4iktyvsTagWkqYCiw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.win.System.Diagnostics.Debug": "4.3.0" + } + }, + "System.Diagnostics.EventLog": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "uaFRda9NjtbJRkdx311eXlAA3n2em7223c1A8d1VWyl+4FL9vkG7y2lpPfBU9HYdj/9KgdRNdn1vFK8ZYCYT/A==" + }, + "System.Globalization": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "B95h0YLEL2oSnwF/XjqSWKnwKOy/01VWkNlsCeMTFJLLabflpGV26nK164eRs5GiaRSBGpOxQ3pKoSnnyZN5pg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Globalization": "4.3.0" + } + }, + "System.IO": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "3KlTJceQc3gnGIaHZ7UBZO26SHL1SHE4ddrmiwumFnId+CEHP+O8r386tZKaE6zlk5/mF8vifMBzHj9SaXN+mQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading.Tasks": "4.0.11", + "runtime.any.System.IO": "4.3.0" + } + }, + "System.Private.Uri": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "I4SwANiUGho1esj4V4oSlPllXjzCZDE+5XXso2P03LW2vOda2Enzh8DWOxwN6hnrJyp314c7KuVu31QYhRzOGg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0" + } + }, + "System.Reflection": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "JCKANJ0TI7kzoQzuwB/OoJANy1Lg338B6+JVacPl4TpUwi3cReg3nMLplMq2uqYfHFQpKIlHAUVAJlImZz/4ng==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection": "4.3.0" + } + }, + "System.Reflection.Extensions": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "GYrtRsZcMuHF3sbmRHfMYpvxZoIN2bQGrYGerUiWLEkqdEUQZhH3TRSaC/oI4wO0II1RKBPlpIa1TOMxIcOOzQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Extensions": "4.3.0" + } + }, + "System.Reflection.Primitives": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "4inTox4wTBaDhB7V3mPvp9XlCbeGYWVEM9/fXALd52vNEAVisc1BoVWQPuUuD0Ga//dNbA/WeMy9u9mzLxGTHQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Reflection.Primitives": "4.3.0" + } + }, + "System.Resources.ResourceManager": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "TxwVeUNoTgUOdQ09gfTjvW411MF+w9MBYL7AtNVc+HtBCFlutPLhUCdZjNkjbhj3bNQWMdHboF0KIWEOjJssbA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Globalization": "4.0.11", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "runtime.any.System.Resources.ResourceManager": "4.3.0" + } + }, + "System.Runtime": { + "type": "Transitive", + "resolved": "4.3.1", + "contentHash": "abhfv1dTK6NXOmu4bgHIONxHyEqFjW8HwXPmpY9gmll+ix9UNo4XDcmzJn6oLooftxNssVHdJC1pGT9jkSynQg==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.1", + "Microsoft.NETCore.Targets": "1.1.3", + "runtime.any.System.Runtime": "4.3.0" + } + }, + "System.Runtime.Extensions": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "CUOHjTT/vgP0qGW22U4/hDlOqXmcPq5YicBaXdUR2UiUoLwBT+olO6we4DVbq57jeX5uXH2uerVZhf0qGj+sVQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.win.System.Runtime.Extensions": "4.3.0" + } + }, + "System.Runtime.Handles": { + "type": "Transitive", + "resolved": "4.0.1", + "contentHash": "nCJvEKguXEvk2ymk1gqj625vVnlK3/xdGzx0vOKicQkoquaTBJTP13AIYkocSUwHCLNBwUbXTqTWGDxBTWpt7g==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Runtime.Handles": "4.3.0" + } + }, + "System.Runtime.InteropServices": { + "type": "Transitive", + "resolved": "4.1.0", + "contentHash": "16eu3kjHS633yYdkjwShDHZLRNMKVi/s0bY8ODiqJ2RfMhDMAwxZaUaWVnZ2P71kr/or+X9o/xFWtNqz8ivieQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "runtime.any.System.Runtime.InteropServices": "4.3.0" + } + }, + "System.Security.AccessControl": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dagJ1mHZO3Ani8GH0PHpPEe/oYO+rVdbQjvjJkBRNQkX4t0r1iaeGn8+/ybkSLEan3/slM0t59SVdHzuHf2jmw==", + "dependencies": { + "Microsoft.NETCore.Platforms": "5.0.0", + "System.Security.Principal.Windows": "5.0.0" + } + }, + "System.Security.Cryptography.Pkcs": { + "type": "Transitive", + "resolved": "10.0.0", + "contentHash": "UPWqLSygJlFerRi9XNIuM0a1VC8gHUIufyP24xQ0sc+XimqUAEcjpOz9DhKpyDjH+5B/wO3RpC0KpkEeDj/ddg==" + }, + "System.Security.Principal.Windows": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "t0MGLukB5WAVU9bO3MGzvlGnyJPgUlcwerXn1kzBRjwLKixT96XV0Uza41W49gVd8zEMFu9vQEFlv0IOrytICA==" + }, + "System.Text.Encoding": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "U3gGeMlDZXxCEiY4DwVLSacg+DFWCvoiX+JThA/rvw37Sqrku7sEFeVBBBMBnfB6FeZHsyDx85HlKL19x0HtZA==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Text.Encoding": "4.3.0" + } + }, + "System.Text.Encoding.CodePages": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "ZFCILZuOvtKPauZ/j/swhvw68ZRi9ATCfvGbk1QfydmcXBkIWecWKn/250UH7rahZ5OoDBaiAudJtPvLwzw85A==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.0.0" + } + }, + "System.Threading.Tasks": { + "type": "Transitive", + "resolved": "4.0.11", + "contentHash": "k1S4Gc6IGwtHGT8188RSeGaX86Qw/wnrgNLshJvsdNUOPP9etMmo8S07c+UlOAx4K/xLuN9ivA1bD0LVurtIxQ==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "runtime.any.System.Threading.Tasks": "4.3.0" + } + }, "Tmds.LibC": { "type": "Transitive", "resolved": "0.2.0", diff --git a/src/Nethermind/Nethermind.State/KeyValueWithBatchingBackedCodeDb.cs b/src/Nethermind/Nethermind.State/KeyValueWithBatchingBackedCodeDb.cs new file mode 100644 index 00000000000..598a865af97 --- /dev/null +++ b/src/Nethermind/Nethermind.State/KeyValueWithBatchingBackedCodeDb.cs @@ -0,0 +1,36 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Linq; +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Evm.State; + +namespace Nethermind.State; + +public class KeyValueWithBatchingBackedCodeDb(IKeyValueStoreWithBatching codeDb) : IWorldStateScopeProvider.ICodeDb +{ + public byte[]? GetCode(in ValueHash256 codeHash) + { + return codeDb[codeHash.Bytes]?.ToArray(); + } + + public IWorldStateScopeProvider.ICodeSetter BeginCodeWrite() + { + return new CodeSetter(codeDb.StartWriteBatch()); + } + + private class CodeSetter(IWriteBatch writeBatch) : IWorldStateScopeProvider.ICodeSetter + { + public void Set(in ValueHash256 codeHash, ReadOnlySpan code) + { + writeBatch.PutSpan(codeHash.Bytes, code); + } + + public void Dispose() + { + writeBatch.Dispose(); + } + } +} diff --git a/src/Nethermind/Nethermind.State/ScoreProviderLogger.cs b/src/Nethermind/Nethermind.State/ScoreProviderLogger.cs new file mode 100644 index 00000000000..26694ff387e --- /dev/null +++ b/src/Nethermind/Nethermind.State/ScoreProviderLogger.cs @@ -0,0 +1,121 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Core.Extensions; +using Nethermind.Evm.State; +using Nethermind.Int256; + +namespace Nethermind.State; + +public class ScoreProviderLogger(IWorldStateScopeProvider.IScope baseScope): IWorldStateScopeProvider.IScope +{ + public void Dispose() + { + baseScope.Dispose(); + } + + public Hash256 RootHash => baseScope.RootHash; + + public void UpdateRootHash() + { + baseScope.UpdateRootHash(); + Console.Error.WriteLine($"Update root to {RootHash}"); + } + + public Account? Get(Address address) + { + return baseScope.Get(address); + } + + public void HintGet(Address address, Account? account) + { + baseScope.HintGet(address, account); + } + + public IWorldStateScopeProvider.ICodeDb CodeDb => baseScope.CodeDb; + + public IWorldStateScopeProvider.IStorageTree CreateStorageTree(Address address) + { + return new StorageTreeLogger(baseScope.CreateStorageTree(address)); + } + + public IWorldStateScopeProvider.IWorldStateWriteBatch StartWriteBatch(int estimatedAccountNum) + { + return new WorldStateWriteLogger(baseScope.StartWriteBatch(estimatedAccountNum)); + } + + public void Commit(long blockNumber) + { + baseScope.Commit(blockNumber); + Console.Error.WriteLine($"Commit {blockNumber} to {RootHash}"); + } + + public class StorageTreeLogger(IWorldStateScopeProvider.IStorageTree baseStorageTree) + : IWorldStateScopeProvider.IStorageTree + { + public Hash256 RootHash => baseStorageTree.RootHash; + + public byte[] Get(in UInt256 index) + { + return baseStorageTree.Get(in index); + } + + public void HintGet(in UInt256 index, byte[]? value) + { + baseStorageTree.HintGet(in index, value); + } + + public byte[] Get(in ValueHash256 hash) + { + return baseStorageTree.Get(in hash); + } + } + + public class WorldStateWriteLogger(IWorldStateScopeProvider.IWorldStateWriteBatch writeBatch) : IWorldStateScopeProvider.IWorldStateWriteBatch + { + public void Dispose() + { + writeBatch.Dispose(); + } + + public event EventHandler? OnAccountUpdated + { + add => writeBatch.OnAccountUpdated += value; + remove => writeBatch.OnAccountUpdated -= value; + } + + public void Set(Address key, Account? account) + { + Console.Error.WriteLine($"Set key {key.ToAccountPath}, {account}"); + writeBatch.Set(key, account); + } + + public IWorldStateScopeProvider.IStorageWriteBatch CreateStorageWriteBatch(Address key, int estimatedEntries) + { + return new StorageWriteBatch(writeBatch.CreateStorageWriteBatch(key, estimatedEntries), key); + } + } + + public class StorageWriteBatch(IWorldStateScopeProvider.IStorageWriteBatch writeBatch, Address addr) : IWorldStateScopeProvider.IStorageWriteBatch + { + public void Dispose() + { + writeBatch.Dispose(); + } + + public void Set(in UInt256 index, byte[] value) + { + Console.Error.WriteLine($"Set storage key {addr}: {index}, {value?.ToHexString()}"); + writeBatch.Set(in index, value); + } + + public void Clear() + { + Console.Error.WriteLine($"Clear {addr}"); + writeBatch.Clear(); + } + } +} diff --git a/src/Nethermind/Nethermind.State/TrieStoreScopeProvider.cs b/src/Nethermind/Nethermind.State/TrieStoreScopeProvider.cs index dbe11a5150e..9ecf5166cb0 100644 --- a/src/Nethermind/Nethermind.State/TrieStoreScopeProvider.cs +++ b/src/Nethermind/Nethermind.State/TrieStoreScopeProvider.cs @@ -6,7 +6,6 @@ using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -using System.Linq; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Threading.Tasks; @@ -53,7 +52,17 @@ public IWorldStateScopeProvider.IScope BeginScope(BlockHeader? baseBlock) var trieStoreCloser = _trieStore.BeginScope(baseBlock); _backingStateTree.RootHash = baseBlock?.StateRoot ?? Keccak.EmptyTreeHash; - return new TrieStoreWorldStateBackendScope(_backingStateTree, this, _codeDb, trieStoreCloser, _logManager); + IWorldStateScopeProvider.IScope scope = new TrieStoreWorldStateBackendScope(_backingStateTree, this, _codeDb, trieStoreCloser, _logManager); + PatriciaTree.Debug = false; + PatriciaTree.DebugBlockNumber = baseBlock?.Number ?? 0; + if (baseBlock?.Number == 46348) + { + PatriciaTree.Debug = true; + Console.Error.WriteLine($"Starting root {baseBlock?.StateRoot}"); + scope = new ScoreProviderLogger(scope); + } + + return scope; } protected virtual StorageTree CreateStorageTree(Address address, Hash256 storageRoot) @@ -291,30 +300,4 @@ public void Dispose() } } } - - private class KeyValueWithBatchingBackedCodeDb(IKeyValueStoreWithBatching codeDb) : IWorldStateScopeProvider.ICodeDb - { - public byte[]? GetCode(in ValueHash256 codeHash) - { - return codeDb[codeHash.Bytes]?.ToArray(); - } - - public IWorldStateScopeProvider.ICodeSetter BeginCodeWrite() - { - return new CodeSetter(codeDb.StartWriteBatch()); - } - - private class CodeSetter(IWriteBatch writeBatch) : IWorldStateScopeProvider.ICodeSetter - { - public void Set(in ValueHash256 codeHash, ReadOnlySpan code) - { - writeBatch.PutSpan(codeHash.Bytes, code); - } - - public void Dispose() - { - writeBatch.Dispose(); - } - } - } } diff --git a/src/Nethermind/Nethermind.Synchronization.Test/E2ESyncTests.cs b/src/Nethermind/Nethermind.Synchronization.Test/E2ESyncTests.cs index 398d142a009..e86a419b55e 100644 --- a/src/Nethermind/Nethermind.Synchronization.Test/E2ESyncTests.cs +++ b/src/Nethermind/Nethermind.Synchronization.Test/E2ESyncTests.cs @@ -49,6 +49,8 @@ using Nethermind.TxPool; using NUnit.Framework; using NUnit.Framework.Internal; +using Paprika.Store; +using Nethermind.Paprika; namespace Nethermind.Synchronization.Test; @@ -66,7 +68,8 @@ public enum DbMode { Default, Hash, - NoPruning + NoPruning, + Paprika } public static IEnumerable CreateTestCases() @@ -74,9 +77,11 @@ public static IEnumerable CreateTestCases() yield return new TestFixtureParameters(DbMode.Default, false); yield return new TestFixtureParameters(DbMode.Hash, false); yield return new TestFixtureParameters(DbMode.NoPruning, false); + yield return new TestFixtureParameters(DbMode.Paprika, false); yield return new TestFixtureParameters(DbMode.Default, true); yield return new TestFixtureParameters(DbMode.Hash, true); yield return new TestFixtureParameters(DbMode.NoPruning, true); + yield return new TestFixtureParameters(DbMode.Paprika, true); } private static TimeSpan SetupTimeout = TimeSpan.FromSeconds(60); @@ -157,6 +162,12 @@ private async Task CreateNode(PrivateKey nodeKey, Func(); + pruningConfig.Enabled = true; + break; + } } var builder = new ContainerBuilder() @@ -261,6 +272,7 @@ public async Task FullSync() [Retry(5)] public async Task FastSync() { + if (dbMode == DbMode.Paprika) Assert.Ignore(); using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource().ThatCancelAfter(TestTimeout); PrivateKey clientKey = TestItem.PrivateKeyC; @@ -294,6 +306,7 @@ private async Task SetPivot(SyncConfig syncConfig, CancellationToken cancellatio [Retry(5)] public async Task SnapSync() { + if (dbMode == DbMode.Paprika) Assert.Ignore(); if (dbMode == DbMode.Hash) Assert.Ignore("Hash db does not support snap sync"); using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource().ThatCancelAfter(TestTimeout); diff --git a/src/Nethermind/Nethermind.Synchronization.Test/Nethermind.Synchronization.Test.csproj b/src/Nethermind/Nethermind.Synchronization.Test/Nethermind.Synchronization.Test.csproj index dd5ddd9b757..013467f1fdc 100644 --- a/src/Nethermind/Nethermind.Synchronization.Test/Nethermind.Synchronization.Test.csproj +++ b/src/Nethermind/Nethermind.Synchronization.Test/Nethermind.Synchronization.Test.csproj @@ -12,6 +12,7 @@ + diff --git a/src/Nethermind/Nethermind.Trie/PatriciaTree.cs b/src/Nethermind/Nethermind.Trie/PatriciaTree.cs index 4f04300e3d3..46d65fae355 100644 --- a/src/Nethermind/Nethermind.Trie/PatriciaTree.cs +++ b/src/Nethermind/Nethermind.Trie/PatriciaTree.cs @@ -71,6 +71,10 @@ public Hash256 RootHash set => SetRootHash(value, true); } + public static long DebugBlockNumber { get; set; } + + public static bool Debug = false; + public PatriciaTree() : this(NullTrieStore.Instance, EmptyTreeHash, true, NullLogManager.Instance) { diff --git a/src/Nethermind/Nethermind.Trie/TrieNode.cs b/src/Nethermind/Nethermind.Trie/TrieNode.cs index 6f14f86b2f6..d8aa3c9f209 100644 --- a/src/Nethermind/Nethermind.Trie/TrieNode.cs +++ b/src/Nethermind/Nethermind.Trie/TrieNode.cs @@ -493,6 +493,15 @@ public void ResolveKey(ITrieNodeResolver tree, ref TreePath path, } Keccak = GenerateKey(tree, ref path, bufferPool, canBeParallel); + if (PatriciaTree.Debug) + { + Console.Error.WriteLine($"{path} {Keccak}"); + } + + if (Keccak == new Hash256("0x6ff49d948433101a7b4504af5f9deae3e3b99fa056bd5544d2f2df901d203540")) + { + Console.Error.WriteLine($"found strange at {PatriciaTree.DebugBlockNumber} {path} {Keccak}"); + } } public Hash256? GenerateKey(ITrieNodeResolver tree, ref TreePath path, @@ -1240,34 +1249,34 @@ private void SeekChildNotNull(ref ValueRlpStream rlpStream, int index) { case 0: case 128: - { - data = childOrRef = _nullNode; - break; - } + { + data = childOrRef = _nullNode; + break; + } case 160: - { - rlpStream.Position--; - Hash256 keccak = rlpStream.DecodeKeccak(); - - TrieNode child = tree.FindCachedOrUnknown(childPath, keccak); - data = childOrRef = child; + { + rlpStream.Position--; + Hash256 keccak = rlpStream.DecodeKeccak(); - if (IsPersisted && !child.IsPersisted) - { - child.CallRecursively(_markPersisted, null, ref childPath, tree, false, - NullLogger.Instance); - } + TrieNode child = tree.FindCachedOrUnknown(childPath, keccak); + data = childOrRef = child; - break; - } - default: + if (IsPersisted && !child.IsPersisted) { - rlpStream.Position--; - ReadOnlySpan fullRlp = rlpStream.PeekNextItem(); - TrieNode child = new(NodeType.Unknown, fullRlp.ToArray()); - data = childOrRef = child; - break; + child.CallRecursively(_markPersisted, null, ref childPath, tree, false, + NullLogger.Instance); } + + break; + } + default: + { + rlpStream.Position--; + ReadOnlySpan fullRlp = rlpStream.PeekNextItem(); + TrieNode child = new(NodeType.Unknown, fullRlp.ToArray()); + data = childOrRef = child; + break; + } } } } @@ -1314,30 +1323,30 @@ internal int ResolveAllChildBranch(ITrieNodeResolver tree, ref TreePath path, Sp { case 0: case 128: - { - rlpStream.Position++; - output[i] = null; - break; - } + { + rlpStream.Position++; + output[i] = null; + break; + } case 160: - { - path.SetLast(i); - Hash256 keccak = rlpStream.DecodeKeccak(); - TrieNode child = tree.FindCachedOrUnknown(path, keccak); - chCount++; - output[i] = child; + { + path.SetLast(i); + Hash256 keccak = rlpStream.DecodeKeccak(); + TrieNode child = tree.FindCachedOrUnknown(path, keccak); + chCount++; + output[i] = child; - break; - } + break; + } default: - { - ReadOnlySpan fullRlp = rlpStream.PeekNextItem(); - TrieNode child = new(NodeType.Unknown, fullRlp.ToArray()); - rlpStream.SkipItem(); - chCount++; - output[i] = child; - break; - } + { + ReadOnlySpan fullRlp = rlpStream.PeekNextItem(); + TrieNode child = new(NodeType.Unknown, fullRlp.ToArray()); + rlpStream.SkipItem(); + chCount++; + output[i] = child; + break; + } } } @@ -1430,36 +1439,36 @@ public ref struct ChildIterator(TrieNode node) { case 0: case 128: - { - data = childOrRef = _nullNode; - _currentStreamIndex++; - break; - } + { + data = childOrRef = _nullNode; + _currentStreamIndex++; + break; + } case 160: - { - _rlpStream.Position--; - Hash256 keccak = _rlpStream.DecodeKeccak(); - _currentStreamIndex++; - - TrieNode child = tree.FindCachedOrUnknown(childPath, keccak); - data = childOrRef = child; + { + _rlpStream.Position--; + Hash256 keccak = _rlpStream.DecodeKeccak(); + _currentStreamIndex++; - if (node.IsPersisted && !child.IsPersisted) - { - child.CallRecursively(_markPersisted, null, ref childPath, tree, false, - NullLogger.Instance); - } + TrieNode child = tree.FindCachedOrUnknown(childPath, keccak); + data = childOrRef = child; - break; - } - default: + if (node.IsPersisted && !child.IsPersisted) { - _rlpStream.Position--; - ReadOnlySpan fullRlp = _rlpStream.PeekNextItem(); - TrieNode child = new(NodeType.Unknown, fullRlp.ToArray()); - data = childOrRef = child; - break; + child.CallRecursively(_markPersisted, null, ref childPath, tree, false, + NullLogger.Instance); } + + break; + } + default: + { + _rlpStream.Position--; + ReadOnlySpan fullRlp = _rlpStream.PeekNextItem(); + TrieNode child = new(NodeType.Unknown, fullRlp.ToArray()); + data = childOrRef = child; + break; + } } } } diff --git a/src/Nethermind/Nethermind.slnx b/src/Nethermind/Nethermind.slnx index e73865e7af3..e3594b2a4eb 100644 --- a/src/Nethermind/Nethermind.slnx +++ b/src/Nethermind/Nethermind.slnx @@ -112,6 +112,7 @@ + @@ -127,4 +128,7 @@ - + + + + \ No newline at end of file diff --git a/src/Nethermind/Paprika b/src/Nethermind/Paprika new file mode 160000 index 00000000000..13bd54092ef --- /dev/null +++ b/src/Nethermind/Paprika @@ -0,0 +1 @@ +Subproject commit 13bd54092effa46a7d6f1d34c6e4638630197a46