From 8eb2df2c7f5e610b13d07dbe70c457f24f463e01 Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Thu, 10 Jul 2025 14:51:15 +0100 Subject: [PATCH 01/40] Update CLZ gas cost for devnet3 (#8953) --- .../Nethermind.Evm/Instructions/EvmInstructions.Math1Param.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math1Param.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math1Param.cs index 10adbed20ab..5c88c0ed604 100644 --- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math1Param.cs +++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math1Param.cs @@ -98,6 +98,8 @@ public struct OpIsZero : IOpMath1Param /// public struct OpCLZ : IOpMath1Param { + static long GasCost => GasCostOf.Low; + public static Word Operation(Word value) => value == default ? Vector256.Create((byte)0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0) : Vector256.Create(0UL, 0UL, 0UL, (ulong)value.CountLeadingZeroBits() << 56).AsByte(); From 9bd7d2f0f3d8908e1e37a2e8810c0024935a332d Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Thu, 10 Jul 2025 14:51:25 +0100 Subject: [PATCH 02/40] Update tx gas cap for devnet3 (#8954) --- src/Nethermind/Nethermind.Core/Eip7825Constants.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Nethermind/Nethermind.Core/Eip7825Constants.cs b/src/Nethermind/Nethermind.Core/Eip7825Constants.cs index 0a3e4bd02bb..df2311605b0 100644 --- a/src/Nethermind/Nethermind.Core/Eip7825Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip7825Constants.cs @@ -7,7 +7,7 @@ namespace Nethermind.Core; public static class Eip7825Constants { - public static readonly long DefaultTxGasLimitCap = 30_000_000; + public static readonly long DefaultTxGasLimitCap = 16_777_216; public static long GetTxGasLimitCap(IReleaseSpec spec) => spec.IsEip7825Enabled ? DefaultTxGasLimitCap : long.MaxValue; } From 113f22faff0611b148926a59f6be73d324b81fbc Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Thu, 10 Jul 2025 18:35:59 +0100 Subject: [PATCH 03/40] Don't block background tasks when syncing (#8971) * Don't block background tasks when syncing * fix test * fix compile warning * Concurrency 2 --- src/Nethermind/Nethermind.Api/IInitConfig.cs | 2 +- src/Nethermind/Nethermind.Api/InitConfig.cs | 2 +- .../Scheduler/BackgroundTaskSchedulerTests.cs | 14 ++++++++----- .../Scheduler/BackgroundTaskScheduler.cs | 18 +++++++++++----- .../Modules/PseudoNethermindModule.cs | 21 ++++++++++++++++++- .../Steps/InitializeBlockchain.cs | 1 + 6 files changed, 45 insertions(+), 13 deletions(-) diff --git a/src/Nethermind/Nethermind.Api/IInitConfig.cs b/src/Nethermind/Nethermind.Api/IInitConfig.cs index 8781c46716f..b22657683da 100644 --- a/src/Nethermind/Nethermind.Api/IInitConfig.cs +++ b/src/Nethermind/Nethermind.Api/IInitConfig.cs @@ -90,7 +90,7 @@ public interface IInitConfig : IConfig [ConfigItem(Description = "[TECHNICAL] Exit when block number is reached. Useful for scripting and testing.", DefaultValue = "null", HiddenFromDocs = true)] long? ExitOnBlockNumber { get; set; } - [ConfigItem(Description = "[TECHNICAL] Specify concurrency limit for background task.", DefaultValue = "1", HiddenFromDocs = true)] + [ConfigItem(Description = "[TECHNICAL] Specify concurrency limit for background task.", DefaultValue = "2", HiddenFromDocs = true)] int BackgroundTaskConcurrency { get; set; } [ConfigItem(Description = "[TECHNICAL] Specify max number of background task.", DefaultValue = "1024", HiddenFromDocs = true)] diff --git a/src/Nethermind/Nethermind.Api/InitConfig.cs b/src/Nethermind/Nethermind.Api/InitConfig.cs index 466d63e91b2..b1e2fff247b 100644 --- a/src/Nethermind/Nethermind.Api/InitConfig.cs +++ b/src/Nethermind/Nethermind.Api/InitConfig.cs @@ -36,7 +36,7 @@ public class InitConfig : IInitConfig public bool DisableMallocOpts { get; set; } = false; public INodeStorage.KeyScheme StateDbKeyScheme { get; set; } = INodeStorage.KeyScheme.Current; public long? ExitOnBlockNumber { get; set; } = null; - public int BackgroundTaskConcurrency { get; set; } = 1; + public int BackgroundTaskConcurrency { get; set; } = 2; public int BackgroundTaskMaxNumber { get; set; } = 1024; public bool InRunnerTest { get; set; } = false; diff --git a/src/Nethermind/Nethermind.Consensus.Test/Scheduler/BackgroundTaskSchedulerTests.cs b/src/Nethermind/Nethermind.Consensus.Test/Scheduler/BackgroundTaskSchedulerTests.cs index 7f803c531b3..934446632d7 100644 --- a/src/Nethermind/Nethermind.Consensus.Test/Scheduler/BackgroundTaskSchedulerTests.cs +++ b/src/Nethermind/Nethermind.Consensus.Test/Scheduler/BackgroundTaskSchedulerTests.cs @@ -9,6 +9,7 @@ using Nethermind.Consensus.Scheduler; using Nethermind.Core.Extensions; using Nethermind.Logging; +using Nethermind.TxPool; using NSubstitute; using NUnit.Framework; using TaskCompletionSource = DotNetty.Common.Concurrency.TaskCompletionSource; @@ -18,18 +19,21 @@ namespace Nethermind.Consensus.Test.Scheduler; public class BackgroundTaskSchedulerTests { private IBlockProcessor _blockProcessor; + private IChainHeadInfoProvider _chainHeadInfo; [SetUp] public void Setup() { _blockProcessor = Substitute.For(); + _chainHeadInfo = Substitute.For(); + _chainHeadInfo.IsSyncing.Returns(false); } [Test] public async Task Test_task_will_execute() { TaskCompletionSource tcs = new TaskCompletionSource(); - await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, 1, 65536, LimboLogs.Instance); + await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, _chainHeadInfo, 1, 65536, LimboLogs.Instance); scheduler.ScheduleTask(1, (_, token) => { @@ -43,7 +47,7 @@ public async Task Test_task_will_execute() [Test] public async Task Test_task_will_execute_concurrently_when_configured_so() { - await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, 2, 65536, LimboLogs.Instance); + await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, _chainHeadInfo, 2, 65536, LimboLogs.Instance); int counter = 0; @@ -68,7 +72,7 @@ public async Task Test_task_will_execute_concurrently_when_configured_so() [Test] public async Task Test_task_will_cancel_on_block_processing() { - await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, 2, 65536, LimboLogs.Instance); + await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, _chainHeadInfo, 2, 65536, LimboLogs.Instance); bool wasCancelled = false; @@ -96,7 +100,7 @@ public async Task Test_task_will_cancel_on_block_processing() [Test] public async Task Test_task_that_is_scheduled_during_block_processing_will_continue_after() { - await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, 2, 65536, LimboLogs.Instance); + await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, _chainHeadInfo, 2, 65536, LimboLogs.Instance); _blockProcessor.BlocksProcessing += Raise.EventWith(new BlocksProcessingEventArgs(null)); int executionCount = 0; @@ -119,7 +123,7 @@ public async Task Test_task_that_is_scheduled_during_block_processing_will_conti [Test] public async Task Test_task_that_is_scheduled_during_block_processing_but_deadlined_will_get_called_and_cancelled() { - await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, 2, 65536, LimboLogs.Instance); + await using BackgroundTaskScheduler scheduler = new BackgroundTaskScheduler(_blockProcessor, _chainHeadInfo, 2, 65536, LimboLogs.Instance); _blockProcessor.BlocksProcessing += Raise.EventWith(new BlocksProcessingEventArgs(null)); bool wasCancelled = false; diff --git a/src/Nethermind/Nethermind.Consensus/Scheduler/BackgroundTaskScheduler.cs b/src/Nethermind/Nethermind.Consensus/Scheduler/BackgroundTaskScheduler.cs index aac8a86994d..99e855b006a 100644 --- a/src/Nethermind/Nethermind.Consensus/Scheduler/BackgroundTaskScheduler.cs +++ b/src/Nethermind/Nethermind.Consensus/Scheduler/BackgroundTaskScheduler.cs @@ -11,6 +11,7 @@ using Nethermind.Consensus.Processing; using Nethermind.Core.Extensions; using Nethermind.Logging; +using Nethermind.TxPool; namespace Nethermind.Consensus.Scheduler; @@ -38,11 +39,12 @@ public class BackgroundTaskScheduler : IBackgroundTaskScheduler, IAsyncDisposabl private readonly Task[] _tasksExecutors; private readonly ILogger _logger; private readonly IBlockProcessor _blockProcessor; + private readonly IChainHeadInfoProvider _headInfo; private CancellationTokenSource _blockProcessorCancellationTokenSource; private bool _disposed = false; - public BackgroundTaskScheduler(IBlockProcessor blockProcessor, int concurrency, int capacity, ILogManager logManager) + public BackgroundTaskScheduler(IBlockProcessor blockProcessor, IChainHeadInfoProvider headInfo, int concurrency, int capacity, ILogManager logManager) { ArgumentOutOfRangeException.ThrowIfLessThan(concurrency, 1); ArgumentOutOfRangeException.ThrowIfLessThan(capacity, 1); @@ -55,6 +57,7 @@ public BackgroundTaskScheduler(IBlockProcessor blockProcessor, int concurrency, _taskQueue = Channel.CreateUnboundedPrioritized(); _logger = logManager.GetClassLogger(); _blockProcessor = blockProcessor; + _headInfo = headInfo; _restartQueueSignal = new ManualResetEventSlim(initialState: true); // As channel is unbounded (to be prioritized) we gate capacity with a semaphore _capacity = new SemaphoreSlim(initialCount: capacity); @@ -75,10 +78,15 @@ public BackgroundTaskScheduler(IBlockProcessor blockProcessor, int concurrency, private void BlockProcessorOnBlocksProcessing(object? sender, BlocksProcessingEventArgs e) { - // Reset background queue processing signal, causing it to wait - _restartQueueSignal.Reset(); - // On block processing, we cancel the block process cts, causing current task to get cancelled. - _blockProcessorCancellationTokenSource.Cancel(); + // If we are syncing we don't block background task processing + // as there are potentially no gaps between blocks + if (!_headInfo.IsSyncing) + { + // Reset background queue processing signal, causing it to wait + _restartQueueSignal.Reset(); + // On block processing, we cancel the block process cts, causing current task to get cancelled. + _blockProcessorCancellationTokenSource.Cancel(); + } } private void BlockProcessorOnBlockProcessed(object? sender, BlockProcessedEventArgs e) diff --git a/src/Nethermind/Nethermind.Core.Test/Modules/PseudoNethermindModule.cs b/src/Nethermind/Nethermind.Core.Test/Modules/PseudoNethermindModule.cs index 6b8ce72bd32..c141f4418e9 100644 --- a/src/Nethermind/Nethermind.Core.Test/Modules/PseudoNethermindModule.cs +++ b/src/Nethermind/Nethermind.Core.Test/Modules/PseudoNethermindModule.cs @@ -1,11 +1,11 @@ // SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using System; using System.IO.Abstractions; using System.Reflection; using Autofac; using Nethermind.Api; -using Nethermind.Blockchain.Filters; using Nethermind.Config; using Nethermind.Consensus; using Nethermind.Consensus.Scheduler; @@ -13,7 +13,10 @@ using Nethermind.Core.Timers; using Nethermind.Crypto; using Nethermind.Db; +using Nethermind.Evm; +using Nethermind.Evm.State; using Nethermind.Init.Modules; +using Nethermind.Int256; using Nethermind.JsonRpc; using Nethermind.KeyStore; using Nethermind.Logging; @@ -53,6 +56,7 @@ protected override void Load(ContainerBuilder builder) .AddSingleton() .AddSingleton((blockProcessingContext) => new BackgroundTaskScheduler( blockProcessingContext.BlockProcessor, + new ChainHeadInfoMock(), initConfig.BackgroundTaskConcurrency, initConfig.BackgroundTaskMaxNumber, logManager)) @@ -85,4 +89,19 @@ protected override void Load(ContainerBuilder builder) } }); } + + private class ChainHeadInfoMock : IChainHeadInfoProvider + { + public IChainHeadSpecProvider SpecProvider { get; } = null!; + public IReadOnlyStateProvider ReadOnlyStateProvider { get; } = null!; + public ICodeInfoRepository CodeInfoRepository { get; } = null!; + public long HeadNumber { get; } + public long? BlockGasLimit { get; } + public UInt256 CurrentBaseFee { get; } + public UInt256 CurrentFeePerBlobGas { get; } + public ProofVersion CurrentProofVersion { get; } + public bool IsSyncing { get => false; } + public bool IsProcessingBlock { get; } + public event EventHandler HeadChanged { add { } remove { } } + } } diff --git a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs index 8069ee6438a..158a794471f 100644 --- a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs +++ b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs @@ -132,6 +132,7 @@ protected virtual Task InitBlockchain() BackgroundTaskScheduler backgroundTaskScheduler = new BackgroundTaskScheduler( mainBlockProcessor, + chainHeadInfoProvider, initConfig.BackgroundTaskConcurrency, initConfig.BackgroundTaskMaxNumber, _api.LogManager); From af748bd20051b4577f0dabcb3f74cd2793488f19 Mon Sep 17 00:00:00 2001 From: Alexey Date: Fri, 11 Jul 2025 09:19:38 +0300 Subject: [PATCH 04/40] Rename blob metrics (#8972) --- src/Nethermind/Nethermind.Merge.Plugin/Metrics.cs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/Nethermind/Nethermind.Merge.Plugin/Metrics.cs b/src/Nethermind/Nethermind.Merge.Plugin/Metrics.cs index 5b872602043..752459cfcd3 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin/Metrics.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin/Metrics.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using System.ComponentModel; +using System.Runtime.Serialization; using Nethermind.Core.Attributes; namespace Nethermind.Merge.Plugin @@ -26,18 +27,22 @@ public static class Metrics [GaugeMetric] [Description("Number of Blobs requested by engine_getBlobsV1")] + [DataMember(Name = "execution_engine_getblobs_requested_total")] public static int NumberOfRequestedBlobs { get; set; } [GaugeMetric] [Description("Number of Blobs sent by engine_getBlobsV1")] + [DataMember(Name = "execution_engine_getblobs_available_total")] public static int NumberOfSentBlobs { get; set; } [GaugeMetric] [Description("Number of responses to engine_getBlobsV1 and engine_getBlobsV2 with all requested blobs")] + [DataMember(Name = "execution_engine_getblobs_hit_total")] public static int GetBlobsRequestsSuccessTotal { get; set; } [GaugeMetric] [Description("Number of responses to engine_getBlobsVX without all requested blobs")] + [DataMember(Name = "execution_engine_getblobs_miss_total")] public static int GetBlobsRequestsFailureTotal { get; set; } [CounterMetric] From 2ae971c6a8b615dfb43d90b648328d197feb56b6 Mon Sep 17 00:00:00 2001 From: Amirul Ashraf Date: Fri, 11 Jul 2025 16:27:46 +0800 Subject: [PATCH 05/40] Fix Taiko Engine Api (#8974) --- .../Container/OrderedComponentsTests.cs | 76 +++++++++++++++++++ .../Container/OrderedComponents.cs | 22 ++++++ ...redComponentsContainerBuilderExtensions.cs | 74 ++++++++++++++++++ .../ContainerBuilderExtensions.cs | 8 ++ .../Modules/IContainerBuilderExtensions.cs | 5 +- 5 files changed, 183 insertions(+), 2 deletions(-) create mode 100644 src/Nethermind/Nethermind.Core.Test/Container/OrderedComponentsTests.cs create mode 100644 src/Nethermind/Nethermind.Core/Container/OrderedComponents.cs create mode 100644 src/Nethermind/Nethermind.Core/Container/OrderedComponentsContainerBuilderExtensions.cs diff --git a/src/Nethermind/Nethermind.Core.Test/Container/OrderedComponentsTests.cs b/src/Nethermind/Nethermind.Core.Test/Container/OrderedComponentsTests.cs new file mode 100644 index 00000000000..5aa6cfa3dbd --- /dev/null +++ b/src/Nethermind/Nethermind.Core.Test/Container/OrderedComponentsTests.cs @@ -0,0 +1,76 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Collections.Generic; +using System.Linq; +using Autofac; +using FluentAssertions; +using Nethermind.Core.Container; +using NUnit.Framework; + +namespace Nethermind.Core.Test.Container; + +public class OrderedComponentsTests +{ + [Test] + public void TestNestedModuleConsistency() + { + using IContainer ctx = new ContainerBuilder() + .AddModule(new ModuleA()) + .AddLast(_ => new Item("4")) + .Build(); + + ctx.Resolve().Select(item => item.Name).Should().BeEquivalentTo(["1", "2", "3", "4"]); + ctx.Resolve>().Select(item => item.Name).Should().BeEquivalentTo(["1", "2", "3", "4"]); + ctx.Resolve>().Select(item => item.Name).Should().BeEquivalentTo(["1", "2", "3", "4"]); + } + + [Test] + public void TestAddFirst() + { + using IContainer ctx = new ContainerBuilder() + .AddLast(_ => new Item("2")) + .AddLast(_ => new Item("3")) + .AddFirst(_ => new Item("1")) + .Build(); + + ctx.Resolve().Select(item => item.Name).Should().BeEquivalentTo(["1", "2", "3"]); + } + + [Test] + public void TestDisallowIndividualRegistration() + { + Action act = () => new ContainerBuilder() + .AddLast(_ => new Item("1")) + .AddSingleton(_ => new Item("2")) + .Build(); + + act.Should().Throw(); + } + + private class ModuleA : Module + { + protected override void Load(ContainerBuilder builder) => + builder + .AddModule(new ModuleB()) + .AddLast(_ => new Item("3")); + } + + private class ModuleB : Module + { + protected override void Load(ContainerBuilder builder) => + builder + .AddModule(new ModuleC()) + .AddLast(_ => new Item("2")); + } + + + private class ModuleC : Module + { + protected override void Load(ContainerBuilder builder) => + builder + .AddLast(_ => new Item("1")); + } + private record Item(string Name); +} diff --git a/src/Nethermind/Nethermind.Core/Container/OrderedComponents.cs b/src/Nethermind/Nethermind.Core/Container/OrderedComponents.cs new file mode 100644 index 00000000000..4315b5c6f8a --- /dev/null +++ b/src/Nethermind/Nethermind.Core/Container/OrderedComponents.cs @@ -0,0 +1,22 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System.Collections.Generic; + +namespace Nethermind.Core.Container; + +public class OrderedComponents +{ + private IList _components = new List(); + public IEnumerable Components => _components; + + public void AddLast(T item) + { + _components.Add(item); + } + + public void AddFirst(T item) + { + _components.Insert(0, item); + } +} diff --git a/src/Nethermind/Nethermind.Core/Container/OrderedComponentsContainerBuilderExtensions.cs b/src/Nethermind/Nethermind.Core/Container/OrderedComponentsContainerBuilderExtensions.cs new file mode 100644 index 00000000000..be286cedbe8 --- /dev/null +++ b/src/Nethermind/Nethermind.Core/Container/OrderedComponentsContainerBuilderExtensions.cs @@ -0,0 +1,74 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Collections.Generic; +using System.Linq; +using Autofac; +using Autofac.Core; + +namespace Nethermind.Core.Container; + +/// +/// A set of dsl to register components where the order matter. Internally it has an +/// and uses decorators to add the items. The order of invocation matter, but there is explicit method like +/// allowing component that should appear first to appear first. +/// +public static class OrderedComponentsContainerBuilderExtensions +{ + public static ContainerBuilder AddLast(this ContainerBuilder builder, Func factory) => + builder + .EnsureOrderedComponents() + .AddDecorator>((ctx, orderedComponents) => + { + orderedComponents.AddLast(factory(ctx)); + return orderedComponents; + }); + + public static ContainerBuilder AddFirst(this ContainerBuilder builder, Func factory) => + builder + .EnsureOrderedComponents() + .AddDecorator>((ctx, orderedComponents) => + { + orderedComponents.AddFirst(factory(ctx)); + return orderedComponents; + }); + + private static ContainerBuilder EnsureOrderedComponents(this ContainerBuilder builder) + { + string registeredMarker = $"Registerd OrderedComponents For {typeof(T).Name}"; + if (!builder.Properties.TryAdd(registeredMarker, null)) + { + return builder; + } + + // Prevent registering separately which has no explicit ordering + builder.RegisterBuildCallback(scope => + { + if (scope.ComponentRegistry.ServiceRegistrationsFor(new TypedService(typeof(T))).Any()) + { + throw new InvalidOperationException( + $"Service of type {typeof(T).Name} must only be registered with one of DSL in {nameof(OrderedComponentsContainerBuilderExtensions)}"); + } + }); + + // Not a singleton which allow it to work seamlessly with scoped lifetime with additional component + builder.Add>(); + + builder + .Register((ctx) => ctx.Resolve>().Components) + .As>() + .Fixed(); + + builder.Register((ctx) => ctx.Resolve>().Components.ToArray()) + .As>() + .As() + .Fixed(); + + builder.Register((ctx) => ctx.Resolve>().Components.ToList()) + .As>() + .Fixed(); + + return builder; + } +} diff --git a/src/Nethermind/Nethermind.Core/ContainerBuilderExtensions.cs b/src/Nethermind/Nethermind.Core/ContainerBuilderExtensions.cs index e66ed9ec35d..b33a3e412c4 100644 --- a/src/Nethermind/Nethermind.Core/ContainerBuilderExtensions.cs +++ b/src/Nethermind/Nethermind.Core/ContainerBuilderExtensions.cs @@ -7,6 +7,7 @@ using Autofac; using Autofac.Builder; using Autofac.Core; +using Autofac.Core.Registration; using Autofac.Core.Resolving.Pipeline; using Autofac.Features.AttributeFilters; using Nethermind.Core.Container; @@ -478,6 +479,13 @@ private static Func CreateArgResolver(MethodInfo method } return (ctx) => ctx.Resolve(); } + + public static IRegistrationBuilder Fixed(this IRegistrationBuilder reg) + { + // Fixed registration is one where it is always the default. Can't be overridden by later registration. + reg.RegistrationData.Options |= RegistrationOptions.Fixed; + return reg; + } } /// diff --git a/src/Nethermind/Nethermind.JsonRpc/Modules/IContainerBuilderExtensions.cs b/src/Nethermind/Nethermind.JsonRpc/Modules/IContainerBuilderExtensions.cs index fb38935c7dd..29bd8e076b9 100644 --- a/src/Nethermind/Nethermind.JsonRpc/Modules/IContainerBuilderExtensions.cs +++ b/src/Nethermind/Nethermind.JsonRpc/Modules/IContainerBuilderExtensions.cs @@ -4,6 +4,7 @@ using System; using Autofac; using Nethermind.Core; +using Nethermind.Core.Container; namespace Nethermind.JsonRpc.Modules; @@ -19,7 +20,7 @@ public static ContainerBuilder RegisterSingletonJsonRpcModule(this Con public static ContainerBuilder RegisterSingletonJsonRpcModule(this ContainerBuilder builder) where T : IRpcModule { return builder - .AddSingleton((ctx) => + .AddLast((ctx) => { Lazy instance = ctx.Resolve>(); return new RpcModuleInfo(typeof(T), new LazyModulePool(new Lazy>(() => @@ -39,7 +40,7 @@ public static ContainerBuilder RegisterBoundedJsonRpcModule( return builder .AddSingleton() .AddSingleton, TFactory>() - .AddSingleton((ctx) => + .AddLast((ctx) => { Lazy> factory = ctx.Resolve>>(); return new RpcModuleInfo(typeof(T), new LazyModulePool(new Lazy>(() => From f41549984556c974977d7d8d8b3bc4cd2c36c211 Mon Sep 17 00:00:00 2001 From: Lukasz Rozmej Date: Fri, 11 Jul 2025 10:50:31 +0200 Subject: [PATCH 06/40] Better null-ckecks in TryGetCanonicalTransaction (#8969) * Better null-ckecks in TryGetCanonicalTransaction * fix test * fix whitespace * fix test --- .../Nethermind.Core/BlockExtensions.cs | 15 ++++++++ .../BlockchainBridgeTests.cs | 35 ++++++++++++------- .../Nethermind.Facade/BlockchainBridge.cs | 10 ++++-- 3 files changed, 44 insertions(+), 16 deletions(-) diff --git a/src/Nethermind/Nethermind.Core/BlockExtensions.cs b/src/Nethermind/Nethermind.Core/BlockExtensions.cs index c720cc27a2d..07fddd3951b 100644 --- a/src/Nethermind/Nethermind.Core/BlockExtensions.cs +++ b/src/Nethermind/Nethermind.Core/BlockExtensions.cs @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using Nethermind.Core.Crypto; using Nethermind.Core.Specs; using Nethermind.Int256; @@ -46,4 +47,18 @@ bool ParentBeforeTTD() /// /// public static bool IsTerminalBlock(this Block block, ISpecProvider specProvider) => block.Header.IsTerminalBlock(specProvider); + + public static int GetTransactionIndex(this Block block, in ValueHash256 txHash) + { + Transaction[] blockTransactions = block.Transactions; + for (int index = 0; index < blockTransactions.Length; index++) + { + if (blockTransactions[index].Hash == txHash) + { + return index; + } + } + + return -1; + } } diff --git a/src/Nethermind/Nethermind.Facade.Test/BlockchainBridgeTests.cs b/src/Nethermind/Nethermind.Facade.Test/BlockchainBridgeTests.cs index 8f23bd10b5a..7180f8b85f1 100644 --- a/src/Nethermind/Nethermind.Facade.Test/BlockchainBridgeTests.cs +++ b/src/Nethermind/Nethermind.Facade.Test/BlockchainBridgeTests.cs @@ -83,21 +83,28 @@ public void get_transaction_returns_null_when_block_not_found() public void get_transaction_returns_receipt_and_transaction_when_found() { int index = 5; - var receipt = Build.A.Receipt - .WithBlockHash(TestItem.KeccakB) - .WithTransactionHash(TestItem.KeccakA) - .WithIndex(index) - .TestObject; - IEnumerable transactions = Enumerable.Range(0, 10) - .Select(static i => Build.A.Transaction.WithNonce((UInt256)i).TestObject); - var block = Build.A.Block + Transaction[] transactions = Enumerable.Range(0, 10) + .Select(static i => Build.A.Transaction.WithNonce((UInt256)i).WithHash(TestItem.Keccaks[i]).TestObject) + .ToArray(); + Block block = Build.A.Block .WithTransactions(transactions.ToArray()) .TestObject; + TxReceipt[] receipts = block.Transactions.Select((t, i) => Build.A.Receipt + .WithBlockHash(TestItem.KeccakB) + .WithIndex(i) + .WithTransactionHash(t.Hash) + .TestObject + ).ToArray(); + ; _blockTree.FindBlock(TestItem.KeccakB, Arg.Any()).Returns(block); - _receiptStorage.FindBlockHash(TestItem.KeccakA).Returns(TestItem.KeccakB); - _receiptStorage.Get(block).Returns(new[] { receipt }); - _blockchainBridge.GetTransaction(TestItem.KeccakA).Should() - .BeEquivalentTo((receipt, Build.A.Transaction.WithNonce((UInt256)index).TestObject, UInt256.Zero)); + foreach (TxReceipt receipt in receipts) + { + _receiptStorage.FindBlockHash(receipt.TxHash!).Returns(TestItem.KeccakB); + } + _receiptStorage.Get(block).Returns(receipts); + var expectation = (receipts[index], Build.A.Transaction.WithNonce((UInt256)index).WithHash(TestItem.Keccaks[index]).TestObject, UInt256.Zero); + var result = _blockchainBridge.GetTransaction(transactions[index].Hash!); + result.Should().BeEquivalentTo(expectation); } [Test] @@ -193,10 +200,12 @@ public void GetReceiptAndGasInfo_returns_correct_results(bool isCanonical, bool .WithType(TxType.Blob) .WithMaxFeePerBlobGas(2) .WithBlobVersionedHashes(2) + .WithHash(txHash) .TestObject : Build.A.Transaction .WithGasPrice(effectiveGasPrice) .WithMaxFeePerGas(effectiveGasPrice) + .WithHash(txHash) .TestObject; Block block = postEip4844 ? Build.A.Block @@ -218,7 +227,7 @@ public void GetReceiptAndGasInfo_returns_correct_results(bool isCanonical, bool _blockTree.FindBlock(blockHash, Arg.Is(BlockTreeLookupOptions.RequireCanonical)).Returns(isCanonical ? block : null); _blockTree.FindBlock(blockHash, Arg.Is(BlockTreeLookupOptions.TotalDifficultyNotNeeded)).Returns(block); _receiptStorage.FindBlockHash(txHash).Returns(blockHash); - _receiptStorage.Get(block).Returns(new[] { receipt }); + _receiptStorage.Get(block).Returns([receipt]); (TxReceipt? Receipt, TxGasInfo? GasInfo, int LogIndexStart) result = postEip4844 ? (receipt, new(effectiveGasPrice, 1, 262144), 0) diff --git a/src/Nethermind/Nethermind.Facade/BlockchainBridge.cs b/src/Nethermind/Nethermind.Facade/BlockchainBridge.cs index d27c1095285..cc023f46a1b 100644 --- a/src/Nethermind/Nethermind.Facade/BlockchainBridge.cs +++ b/src/Nethermind/Nethermind.Facade/BlockchainBridge.cs @@ -80,9 +80,13 @@ private bool TryGetCanonicalTransaction( if (block is not null) { receipts = receiptStorage.Get(block); - receipt = receipts.ForTransaction(txHash); - transaction = block.Transactions[receipt.Index]; - return true; + int txIndex = block.GetTransactionIndex(txHash.ValueHash256); + if (txIndex != -1) + { + transaction = block.Transactions[txIndex]; + receipt = receipts.Length > txIndex && receipts[txIndex].TxHash == txHash ? receipts[txIndex] : null; + return true; + } } } From 31bbbeefd22b8c80d05a45a4e342ef04590ef3e9 Mon Sep 17 00:00:00 2001 From: Ruben Buniatyan Date: Fri, 11 Jul 2025 19:17:38 +0200 Subject: [PATCH 07/40] Revise JSON-RPC docs generation (#8967) --- tools/DocGen/JsonRpcGenerator.cs | 86 +++++++++++++++++++++----------- 1 file changed, 56 insertions(+), 30 deletions(-) diff --git a/tools/DocGen/JsonRpcGenerator.cs b/tools/DocGen/JsonRpcGenerator.cs index 00200b8c63f..2478d9e1d30 100644 --- a/tools/DocGen/JsonRpcGenerator.cs +++ b/tools/DocGen/JsonRpcGenerator.cs @@ -1,19 +1,26 @@ // SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only -using System.Reflection; using Nethermind.JsonRpc.Modules; using Nethermind.JsonRpc.Modules.Evm; using Nethermind.JsonRpc.Modules.Rpc; using Nethermind.JsonRpc.Modules.Subscribe; using Newtonsoft.Json; using Spectre.Console; +using System.Reflection; namespace Nethermind.DocGen; internal static class JsonRpcGenerator { - private const string _objectTypeName = "*object*"; + private static readonly string[] _assemblies = [ + "Nethermind.Consensus.Clique", + "Nethermind.Era1", + "Nethermind.Flashbots", + "Nethermind.HealthChecks", + "Nethermind.JsonRpc" + ]; + private const string _objectTypeName = "_object_"; internal static void Generate(string path) { @@ -26,8 +33,7 @@ internal static void Generate(string path) typeof(IRpcRpcModule).FullName, typeof(ISubscribeRpcModule).FullName }; - var types = new[] { "Nethermind.JsonRpc", "Nethermind.Consensus.Clique" } - .SelectMany(a => Assembly.Load(a).GetTypes()) + var types = _assemblies.SelectMany(a => Assembly.Load(a).GetTypes()) .Where(t => t.IsInterface && typeof(IRpcModule).IsAssignableFrom(t) && !excluded.Any(x => x is not null && (t.FullName?.Contains(x, StringComparison.Ordinal) ?? false))) .OrderBy(t => t.Name); @@ -42,16 +48,45 @@ internal static void Generate(string path) } } - var i = 0; + var methodMap = new Dictionary>(); foreach (var type in types) - WriteMarkdown(path, type, i++); + { + var attr = type.GetCustomAttribute(); + + if (attr is null) + { + AnsiConsole.MarkupLine($"[yellow]{type.Name} module type is missing[/]"); + continue; + } + + var ns = attr.ModuleType.ToLowerInvariant(); + var methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public); + + if (!methodMap.TryAdd(ns, methods)) + methodMap[ns] = methodMap[ns].Concat(methods); + } + + if (methodMap.TryGetValue("eth", out IEnumerable? ethMethods)) + { + // Inject the `subscribe` methods into `eth` + methodMap["eth"] = ethMethods! + .Concat(typeof(ISubscribeRpcModule).GetMethods(BindingFlags.Instance | BindingFlags.Public)); + } + + var i = 0; + + foreach (var (ns, methods) in methodMap) + { + methodMap[ns] = methods.OrderBy(m => m.Name); + + WriteMarkdown(path, ns, methodMap[ns], i++); + } } - private static void WriteMarkdown(string path, Type rpcType, int sidebarIndex) + private static void WriteMarkdown(string path, string ns, IEnumerable methods, int sidebarIndex) { - var rpcName = rpcType.Name[1..].Replace("RpcModule", null).ToLowerInvariant(); - var fileName = Path.Join(path, $"{rpcName}.md"); + var fileName = Path.Join(path, $"{ns}.md"); using var stream = File.Open(fileName, FileMode.Create); using var file = new StreamWriter(stream); @@ -59,8 +94,8 @@ private static void WriteMarkdown(string path, Type rpcType, int sidebarIndex) file.WriteLine($""" --- - title: {rpcName} namespace - sidebar_label: {rpcName} + title: {ns} namespace + sidebar_label: {ns} sidebar_position: {sidebarIndex} --- @@ -69,15 +104,6 @@ private static void WriteMarkdown(string path, Type rpcType, int sidebarIndex) """); - IEnumerable methods = rpcType - .GetMethods(BindingFlags.Instance | BindingFlags.Public); - - // Inject the `subscribe` methods into `eth` - if (rpcName.Equals("eth", StringComparison.Ordinal)) - methods = methods.Concat(typeof(ISubscribeRpcModule).GetMethods(BindingFlags.Instance | BindingFlags.Public)); - - methods = methods.OrderBy(m => m.Name); - foreach (var method in methods) { var attr = method.GetCustomAttribute(); @@ -271,7 +297,7 @@ private static void WriteFromFile(StreamWriter file, string fileName) } catch (Exception) { - Console.WriteLine($"Failed copying from {fileName}"); + AnsiConsole.WriteLine($"[red]Failed copying from[/] {fileName}"); } } @@ -283,28 +309,28 @@ private static string GetJsonTypeName(Type type) return GetJsonTypeName(underlyingType); if (type.IsEnum) - return "*integer*"; + return "_integer_"; if (TryGetEnumerableItemType(type, out var itemType, out var isDictionary)) return $"{(isDictionary ? "map" : "array")} of {GetJsonTypeName(itemType!)}"; return type.Name switch { - "Address" => "*string* (address)", + "Address" => "_string_ (address)", "BigInteger" or "Int32" or "Int64" or "Int64&" or "UInt64" - or "UInt256" => "*string* (hex integer)", - "BlockParameter" => "*string* (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`)", + or "UInt256" => "_string_ (hex integer)", + "BlockParameter" => "_string_ (block number or hash or either of `earliest`, `finalized`, `latest`, `pending`, or `safe`)", "Bloom" or "Byte" - or "Byte[]" => "*string* (hex data)", - "Boolean" => "*boolean*", - "Hash256" => "*string* (hash)", - "String" => "*string*", - "TxType" => "*string* (transaction type)", + or "Byte[]" => "_string_ (hex data)", + "Boolean" => "_boolean_", + "Hash256" => "_string_ (hash)", + "String" => "_string_", + "TxType" => "_string_ (transaction type)", _ => _objectTypeName }; } From 3efda4c86822fe2b24bedb0373278371a4938bfb Mon Sep 17 00:00:00 2001 From: Amirul Ashraf Date: Sun, 13 Jul 2025 06:50:37 +0800 Subject: [PATCH 08/40] Fix/OOM when downloading from genesis. (#8975) * Slight change in constructor * Stop putting more request when queue is high * Add unit test * Set budget as memory * Whitespace * Fix test --- .../Synchronization/ISyncConfig.cs | 7 ++- .../Synchronization/SyncConfig.cs | 3 +- .../Synchronization/MergeBlockDownloader.cs | 59 +++++++++++-------- .../BlockDownloaderTests.cs | 29 ++++++++- .../Blocks/BlockDownloader.cs | 47 +++++++++------ 5 files changed, 98 insertions(+), 47 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/Synchronization/ISyncConfig.cs b/src/Nethermind/Nethermind.Blockchain/Synchronization/ISyncConfig.cs index d8a08e3bc9f..dca9b597943 100644 --- a/src/Nethermind/Nethermind.Blockchain/Synchronization/ISyncConfig.cs +++ b/src/Nethermind/Nethermind.Blockchain/Synchronization/ISyncConfig.cs @@ -171,6 +171,9 @@ public interface ISyncConfig : IConfig [ConfigItem(Description = "_Technical._ Enable storage range split.", DefaultValue = "false", HiddenFromDocs = true)] bool EnableSnapSyncStorageRangeSplit { get; set; } - [ConfigItem(Description = "_Technical._ Max tx in forward sync buffer.", DefaultValue = "200000", HiddenFromDocs = true)] - int MaxTxInForwardSyncBuffer { get; set; } + [ConfigItem(Description = "_Technical._ Estimated size of memory for storing blocks during download.", DefaultValue = "200000000", HiddenFromDocs = true)] + long ForwardSyncDownloadBufferMemoryBudget { get; set; } + + [ConfigItem(Description = "_Technical._ Estimated max size of blocks in block processing queue before stop downloading.", DefaultValue = "200000000", HiddenFromDocs = true)] + long ForwardSyncBlockProcessingQueueMemoryBudget { get; set; } } diff --git a/src/Nethermind/Nethermind.Blockchain/Synchronization/SyncConfig.cs b/src/Nethermind/Nethermind.Blockchain/Synchronization/SyncConfig.cs index 30c68bb10fd..096d8f57444 100644 --- a/src/Nethermind/Nethermind.Blockchain/Synchronization/SyncConfig.cs +++ b/src/Nethermind/Nethermind.Blockchain/Synchronization/SyncConfig.cs @@ -83,7 +83,8 @@ public string? PivotHash public ulong FastHeadersMemoryBudget { get; set; } = (ulong)128.MB(); public bool EnableSnapSyncStorageRangeSplit { get; set; } = false; - public int MaxTxInForwardSyncBuffer { get; set; } = 20000; + public long ForwardSyncDownloadBufferMemoryBudget { get; set; } = 200.MiB(); + public long ForwardSyncBlockProcessingQueueMemoryBudget { get; set; } = 200.MiB(); public override string ToString() { diff --git a/src/Nethermind/Nethermind.Merge.Plugin/Synchronization/MergeBlockDownloader.cs b/src/Nethermind/Nethermind.Merge.Plugin/Synchronization/MergeBlockDownloader.cs index c0795285b97..5b3338f5506 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin/Synchronization/MergeBlockDownloader.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin/Synchronization/MergeBlockDownloader.cs @@ -5,6 +5,7 @@ using Nethermind.Blockchain; using Nethermind.Blockchain.Receipts; using Nethermind.Blockchain.Synchronization; +using Nethermind.Consensus.Processing; using Nethermind.Consensus.Validators; using Nethermind.Core; using Nethermind.Core.Specs; @@ -18,32 +19,38 @@ namespace Nethermind.Merge.Plugin.Synchronization { - public class MergeBlockDownloader : BlockDownloader + public class MergeBlockDownloader( + IBeaconPivot beaconPivot, + IBlockTree blockTree, + IBlockValidator blockValidator, + ISyncReport syncReport, + IReceiptStorage receiptStorage, + ISpecProvider specProvider, + IBetterPeerStrategy betterPeerStrategy, + IFullStateFinder fullStateFinder, + IForwardHeaderProvider forwardHeaderProvider, + ISyncPeerPool syncPeerPool, + IReceiptsRecovery receiptsRecovery, + IBlockProcessingQueue blockProcessingQueue, + ISyncConfig syncConfig, + ILogManager logManager) + : BlockDownloader( + blockTree, + blockValidator, + syncReport, + receiptStorage, + specProvider, + betterPeerStrategy, + fullStateFinder, + forwardHeaderProvider, + syncPeerPool, + receiptsRecovery, + blockProcessingQueue, + syncConfig, + logManager) { - private readonly IBeaconPivot _beaconPivot; - private readonly IBlockTree _blockTree; - private readonly ILogger _logger; - - public MergeBlockDownloader( - IBeaconPivot beaconPivot, - IBlockTree? blockTree, - IBlockValidator? blockValidator, - ISyncReport? syncReport, - IReceiptStorage? receiptStorage, - ISpecProvider specProvider, - IBetterPeerStrategy betterPeerStrategy, - IFullStateFinder fullStateFinder, - IForwardHeaderProvider forwardHeaderProvider, - ISyncPeerPool syncPeerPool, - ISyncConfig syncConfig, - ILogManager logManager) - : base(blockTree, blockValidator, syncReport, receiptStorage, - specProvider, betterPeerStrategy, fullStateFinder, forwardHeaderProvider, syncPeerPool, syncConfig, logManager) - { - _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); - _beaconPivot = beaconPivot; - _logger = logManager.GetClassLogger(); - } + private readonly IBlockTree _blockTree = blockTree; + private readonly ILogger _logger = logManager.GetClassLogger(); protected override BlockTreeSuggestOptions GetSuggestOption(bool shouldProcess, Block currentBlock) { @@ -51,7 +58,7 @@ protected override BlockTreeSuggestOptions GetSuggestOption(bool shouldProcess, shouldProcess ? BlockTreeSuggestOptions.ShouldProcess : BlockTreeSuggestOptions.None; bool isKnownBeaconBlock = _blockTree.IsKnownBeaconBlock(currentBlock.Number, currentBlock.GetOrCalculateHash()); - if (_logger.IsTrace) _logger.Trace($"Current block {currentBlock}, BeaconPivot: {_beaconPivot.PivotNumber}, IsKnownBeaconBlock: {isKnownBeaconBlock}"); + if (_logger.IsTrace) _logger.Trace($"Current block {currentBlock}, BeaconPivot: {beaconPivot.PivotNumber}, IsKnownBeaconBlock: {isKnownBeaconBlock}"); if (isKnownBeaconBlock) { diff --git a/src/Nethermind/Nethermind.Synchronization.Test/BlockDownloaderTests.cs b/src/Nethermind/Nethermind.Synchronization.Test/BlockDownloaderTests.cs index eabe15cffc8..03102bb2bc4 100644 --- a/src/Nethermind/Nethermind.Synchronization.Test/BlockDownloaderTests.cs +++ b/src/Nethermind/Nethermind.Synchronization.Test/BlockDownloaderTests.cs @@ -39,6 +39,7 @@ using Autofac.Features.AttributeFilters; using Humanizer; using Nethermind.Config; +using Nethermind.Consensus.Processing; using Nethermind.Core.Events; using Nethermind.Core.Test; using Nethermind.Core.Test.Modules; @@ -208,6 +209,32 @@ public async Task Catch_exception_from_forwardHeaderProvider() await act.Should().NotThrowAsync(); } + [Test] + public async Task Skit_spawning_request_when_block_processing_queue_is_high() + { + IForwardHeaderProvider mockForwardHeaderProvider = Substitute.For(); + IBlockProcessingQueue blockProcessingQueue = Substitute.For(); + blockProcessingQueue.Count.Returns(10000); + + await using IContainer node = CreateNode(configProvider: new ConfigProvider(new SyncConfig() + { + FastSync = true + }), + configurer: (builder) => builder + .AddSingleton(mockForwardHeaderProvider) + .AddSingleton(blockProcessingQueue)); + + Context ctx = node.Resolve(); + var request = await ctx.FastSyncFeedComponent.BlockDownloader.PrepareRequest( + DownloaderOptions.Insert, + 0, + CancellationToken.None); + + request.Should().BeNull(); + await mockForwardHeaderProvider.DidNotReceive() + .GetBlockHeaders(Arg.Any(), Arg.Any(), Arg.Any()); + } + [Test] public async Task Ancestor_lookup_simple() { @@ -492,7 +519,7 @@ public async Task Prune_download_requests_map() await using IContainer node = CreateNode(builder => builder .AddDecorator((_, syncConfig) => { - syncConfig.MaxTxInForwardSyncBuffer = 3200; + syncConfig.ForwardSyncDownloadBufferMemoryBudget = 3200000; return syncConfig; }) .AddSingleton(Always.Invalid)); diff --git a/src/Nethermind/Nethermind.Synchronization/Blocks/BlockDownloader.cs b/src/Nethermind/Nethermind.Synchronization/Blocks/BlockDownloader.cs index 36ce050588e..2050a8d7a52 100644 --- a/src/Nethermind/Nethermind.Synchronization/Blocks/BlockDownloader.cs +++ b/src/Nethermind/Nethermind.Synchronization/Blocks/BlockDownloader.cs @@ -9,6 +9,7 @@ using Nethermind.Blockchain; using Nethermind.Blockchain.Receipts; using Nethermind.Blockchain.Synchronization; +using Nethermind.Consensus.Processing; using Nethermind.Consensus.Validators; using Nethermind.Core; using Nethermind.Core.Collections; @@ -47,10 +48,12 @@ public class BlockDownloader : IForwardSyncController private readonly IFullStateFinder _fullStateFinder; private readonly IForwardHeaderProvider _forwardHeaderProvider; private readonly ISyncPeerPool _syncPeerPool; + private readonly IBlockProcessingQueue _processingQueue; private readonly ILogger _logger; // Estimated maximum tx in buffer used to estimate memory limit. Each tx is on average about 1KB. private readonly int _maxTxInBuffer; + private readonly int _maxTxInInProcessingQueue; private const int MinEstimateTxPerBlock = 10; // Header lookup need to be limited, because `IForwardHeaderProvider.GetBlockHeaders` can be slow. @@ -72,31 +75,35 @@ public class BlockDownloader : IForwardSyncController private SemaphoreSlim _requestLock = new(1); public BlockDownloader( - IBlockTree? blockTree, - IBlockValidator? blockValidator, - ISyncReport? syncReport, - IReceiptStorage? receiptStorage, - ISpecProvider? specProvider, + IBlockTree blockTree, + IBlockValidator blockValidator, + ISyncReport syncReport, + IReceiptStorage receiptStorage, + ISpecProvider specProvider, IBetterPeerStrategy betterPeerStrategy, IFullStateFinder fullStateFinder, IForwardHeaderProvider forwardHeaderProvider, ISyncPeerPool syncPeerPool, + IReceiptsRecovery receiptsRecovery, + IBlockProcessingQueue processingQueue, ISyncConfig syncConfig, - ILogManager? logManager) + ILogManager logManager) { - _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); - _blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator)); - _syncReport = syncReport ?? throw new ArgumentNullException(nameof(syncReport)); - _receiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage)); - _specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider)); - _betterPeerStrategy = betterPeerStrategy ?? throw new ArgumentNullException(nameof(betterPeerStrategy)); - _fullStateFinder = fullStateFinder ?? throw new ArgumentNullException(nameof(fullStateFinder)); + _blockTree = blockTree; + _blockValidator = blockValidator; + _syncReport = syncReport; + _receiptStorage = receiptStorage; + _specProvider = specProvider; + _betterPeerStrategy = betterPeerStrategy; + _fullStateFinder = fullStateFinder; _forwardHeaderProvider = forwardHeaderProvider; _syncPeerPool = syncPeerPool; - _logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager)); - _maxTxInBuffer = syncConfig.MaxTxInForwardSyncBuffer; - - _receiptsRecovery = new ReceiptsRecovery(new EthereumEcdsa(_specProvider.ChainId), _specProvider); + _logger = logManager.GetClassLogger(); + // Assume that each tx cost about 1kb. + _maxTxInBuffer = (int)(syncConfig.ForwardSyncDownloadBufferMemoryBudget / 1000); + _maxTxInInProcessingQueue = (int)(syncConfig.ForwardSyncBlockProcessingQueueMemoryBudget / 1000); + _receiptsRecovery = receiptsRecovery; + _processingQueue = processingQueue; _blockTree.NewHeadBlock += BlockTreeOnNewHeadBlock; } @@ -145,6 +152,12 @@ private void BlockTreeOnNewHeadBlock(object? sender, BlockEventArgs e) while (true) { + if (_processingQueue.Count > _maxTxInInProcessingQueue / _estimateTxPerBlock) + { + if (_logger.IsTrace) _logger.Trace("Processing queue full"); + return null; + } + using IOwnedReadOnlyList? headers = await _forwardHeaderProvider.GetBlockHeaders(fastSyncLag, HeaderLookupSize + 1, cancellation); if (cancellation.IsCancellationRequested) return null; // check before every heavy operation if (headers is null || headers.Count <= 1) return null; From 5ff551190c60c8fe17ce8252f797baa9f80aaff7 Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Sat, 12 Jul 2025 23:58:57 +0100 Subject: [PATCH 09/40] Cache PropertyInfo lookups for JsonRpc (#8976) --- .../Nethermind.Core/Collections/TypeAsKey.cs | 18 ++++++++ .../Nethermind.JsonRpc/JsonRpcService.cs | 43 ++++++++++++++++++- 2 files changed, 60 insertions(+), 1 deletion(-) create mode 100644 src/Nethermind/Nethermind.Core/Collections/TypeAsKey.cs diff --git a/src/Nethermind/Nethermind.Core/Collections/TypeAsKey.cs b/src/Nethermind/Nethermind.Core/Collections/TypeAsKey.cs new file mode 100644 index 00000000000..eea0bc6ebde --- /dev/null +++ b/src/Nethermind/Nethermind.Core/Collections/TypeAsKey.cs @@ -0,0 +1,18 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; + +namespace Nethermind.Core.Collections; + +public readonly struct TypeAsKey(Type key) : IEquatable +{ + private readonly Type _key = key; + + public static implicit operator Type(TypeAsKey key) => key._key; + public static implicit operator TypeAsKey(Type key) => new(key); + + public bool Equals(TypeAsKey other) => ReferenceEquals(_key, other._key); + public override int GetHashCode() => _key?.GetHashCode() ?? 0; + public override bool Equals(object? obj) => obj is TypeAsKey && Equals((TypeAsKey)obj); +} diff --git a/src/Nethermind/Nethermind.JsonRpc/JsonRpcService.cs b/src/Nethermind/Nethermind.JsonRpc/JsonRpcService.cs index 2aaab3bcd5d..82de21c147f 100644 --- a/src/Nethermind/Nethermind.JsonRpc/JsonRpcService.cs +++ b/src/Nethermind/Nethermind.JsonRpc/JsonRpcService.cs @@ -9,8 +9,10 @@ using System.Text; using System.Text.Json; using System.Text.Json.Serialization; +using System.Threading; using System.Threading.Tasks; using Nethermind.Core; +using Nethermind.Core.Collections; using Nethermind.Core.Threading; using Nethermind.JsonRpc.Exceptions; using Nethermind.JsonRpc.Modules; @@ -27,8 +29,11 @@ public class JsonRpcService : IJsonRpcService private readonly ILogger _logger; private readonly IRpcModuleProvider _rpcModuleProvider; private readonly HashSet _methodsLoggingFiltering; + private readonly Lock _propertyInfoModificationLock = new(); private readonly int _maxLoggedRequestParametersCharacters; + private Dictionary _propertyInfoCache = []; + public JsonRpcService(IRpcModuleProvider rpcModuleProvider, ILogManager logManager, IJsonRpcConfig jsonRpcConfig) { _logger = logManager.GetClassLogger(); @@ -196,7 +201,7 @@ private async Task ExecuteAsync(JsonRpcRequest request, string break; case Task task: await task; - resultWrapper = task.GetType().GetProperty("Result")?.GetValue(task) as IResultWrapper; + resultWrapper = GetResultProperty(task)?.GetValue(task) as IResultWrapper; break; } } @@ -244,6 +249,42 @@ private async Task ExecuteAsync(JsonRpcRequest request, string : GetSuccessResponse(methodName, resultWrapper.Data, request.Id, returnAction); } + private PropertyInfo? GetResultProperty(Task task) + { + Type type = task.GetType(); + if (_propertyInfoCache.TryGetValue(type, out PropertyInfo? value)) + { + return value; + } + + return GetResultPropertySlow(type); + } + + private PropertyInfo? GetResultPropertySlow(Type type) + { + lock (_propertyInfoModificationLock) + { + Dictionary current = _propertyInfoCache; + // Re-check inside the lock in case another thread already added it + if (current.TryGetValue(type, out PropertyInfo? value)) + { + return value; + } + + // Copy-on-write: create a new dictionary so we don't mutate + // the one other threads may be reading without locks. + Dictionary propertyInfoCache = new(current); + PropertyInfo? propertyInfo = type.GetProperty("Result"); + propertyInfoCache[type] = propertyInfo; + + // Publish the new cache instance atomically by swapping the reference. + // Readers grabbing _propertyInfoCache will now see the updated dictionary. + _propertyInfoCache = propertyInfoCache; + + return propertyInfo; + } + } + private void LogRequest(string methodName, JsonElement providedParameters, ExpectedParameter[] expectedParameters) { if (_logger.IsTrace && !_methodsLoggingFiltering.Contains(methodName)) From f9d769249cd4bf0d133acaf565b9e0b708bea97c Mon Sep 17 00:00:00 2001 From: "core-repository-dispatch-app[bot]" <173070810+core-repository-dispatch-app[bot]@users.noreply.github.com> Date: Sun, 13 Jul 2025 10:59:24 +0200 Subject: [PATCH 10/40] Auto-update fast sync settings (#8978) Co-authored-by: rubo --- src/Nethermind/Nethermind.Runner/configs/base-mainnet.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/base-sepolia.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/chiado.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/energyweb.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/gnosis.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/joc-testnet.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/mainnet.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/op-mainnet.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/op-sepolia.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/sepolia.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/volta.json | 6 +++--- .../Nethermind.Runner/configs/worldchain-mainnet.json | 4 ++-- .../Nethermind.Runner/configs/worldchain-sepolia.json | 4 ++-- 16 files changed, 38 insertions(+), 38 deletions(-) diff --git a/src/Nethermind/Nethermind.Runner/configs/base-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/base-mainnet.json index 936804423c3..f0d6ffb949c 100644 --- a/src/Nethermind/Nethermind.Runner/configs/base-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/base-mainnet.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 32550000, - "PivotHash": "0x18401c18220a361498819169d9bfea1ce6a4a81aedbde2359c7898153d6f2c8c" + "PivotNumber": 32780000, + "PivotHash": "0x28f0ac563c5dd0098c6ac3c23aa291e5164c77afcbb0ec6f915b5c2ce782cbf6" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/base-sepolia.json b/src/Nethermind/Nethermind.Runner/configs/base-sepolia.json index 77faf7da22a..e72ea30695e 100644 --- a/src/Nethermind/Nethermind.Runner/configs/base-sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/base-sepolia.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 28060000, - "PivotHash": "0x7ad8043c80402730514ce59464c612c022f151dc77cdb984138a64d007c6af7e" + "PivotNumber": 28290000, + "PivotHash": "0xde9a2994afb2da18d22b4051d2a67a7024c4fa2d6277e4e6022064332570b87d" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/chiado.json b/src/Nethermind/Nethermind.Runner/configs/chiado.json index 3038ddaba71..ce78beea0b5 100644 --- a/src/Nethermind/Nethermind.Runner/configs/chiado.json +++ b/src/Nethermind/Nethermind.Runner/configs/chiado.json @@ -18,8 +18,8 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 16590000, - "PivotHash": "0x3cefe8046445de2913a3382af451dc13f4c963746143b3f964c021ee0cfdf00f", + "PivotNumber": 16710000, + "PivotHash": "0xf5e5177ed8b0c340d7d39f31ca73a594b18203095a700868a3e70f673aa0c5b3", "PivotTotalDifficulty": "231708131825107706987652208063906496124457284", "FastSyncCatchUpHeightDelta": 10000000000, "UseGethLimitsInFastBlocks": false diff --git a/src/Nethermind/Nethermind.Runner/configs/energyweb.json b/src/Nethermind/Nethermind.Runner/configs/energyweb.json index 7e4e8da2eae..9cb16959521 100644 --- a/src/Nethermind/Nethermind.Runner/configs/energyweb.json +++ b/src/Nethermind/Nethermind.Runner/configs/energyweb.json @@ -13,9 +13,9 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 36400000, - "PivotHash": "0xa05aab97021365824b0c96f8afe8416d25fe1244b79c78ee69a7dc1e06e5aecd", - "PivotTotalDifficulty": "12386278155922160070066835710516362896611796376", + "PivotNumber": 36510000, + "PivotHash": "0xafe652ac0d78c419917ccdbbbb1cb8c38d790724ef97005cb3e1f821a84d1586", + "PivotTotalDifficulty": "12423709216283463301047806917333857399871718285", "UseGethLimitsInFastBlocks": false, "FastSyncCatchUpHeightDelta": 10000000000 }, diff --git a/src/Nethermind/Nethermind.Runner/configs/gnosis.json b/src/Nethermind/Nethermind.Runner/configs/gnosis.json index ffb19e1fd24..c0d8eab6642 100644 --- a/src/Nethermind/Nethermind.Runner/configs/gnosis.json +++ b/src/Nethermind/Nethermind.Runner/configs/gnosis.json @@ -14,8 +14,8 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 40930000, - "PivotHash": "0x6ddb21ab97a184413f4dd0ba8234fc855db80387bb0e81bbda939eae2a4a331e", + "PivotNumber": 41040000, + "PivotHash": "0x15849f57931cf7739eed0cdeb0da8df2ea16810b272dcf6d173dcca1af5cd245", "PivotTotalDifficulty": "8626000110427538733349499292577475819600160930", "UseGethLimitsInFastBlocks": false, "FastSyncCatchUpHeightDelta": 10000000000 diff --git a/src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json index 95d65fdbc76..21273eea87b 100644 --- a/src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json @@ -12,9 +12,9 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 18420000, - "PivotHash": "0xffeb9f9ad8c11d66c82bf8990272845aa4921436c9904881e51503ef05282cfd", - "PivotTotalDifficulty": "34109861" + "PivotNumber": 18540000, + "PivotHash": "0x3b79719300301258d503a57790407d64cb4d8dca3207643b6979b5659937dc40", + "PivotTotalDifficulty": "34293024" }, "Metrics": { "NodeName": "JOC-Mainnet" diff --git a/src/Nethermind/Nethermind.Runner/configs/joc-testnet.json b/src/Nethermind/Nethermind.Runner/configs/joc-testnet.json index 3b0efe6e861..a18c886578e 100644 --- a/src/Nethermind/Nethermind.Runner/configs/joc-testnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/joc-testnet.json @@ -12,9 +12,9 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 12030000, - "PivotHash": "0x457ddc5c999d67d6c2dc9ce8ec311bf1c18872eea4e96c5b373d2b4a843d221a", - "PivotTotalDifficulty": "20461347" + "PivotNumber": 12150000, + "PivotHash": "0x593af9bca041f58a9a41a75d56e61a2796b8b63e872427dc855683e767d62d47", + "PivotTotalDifficulty": "20653978" }, "Metrics": { "NodeName": "JOC-Testnet" diff --git a/src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json index db09cf22b84..b7b48a4f28b 100644 --- a/src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json @@ -17,9 +17,9 @@ }, "Sync": { "SnapSync": true, - "PivotNumber": 20600000, - "PivotHash": "0x3bd995cc93ee95a4f22ec785635c5e57bea06d8811e26ade9e361fdb4a179995", - "PivotTotalDifficulty": "41200001", + "PivotNumber": 20800000, + "PivotHash": "0x359161297fb9504f222e5543e2196d7229f3ea869a91a66d10ed6b9f421f038a", + "PivotTotalDifficulty": "41600001", "HeaderStateDistance": 6 }, "JsonRpc": { diff --git a/src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json b/src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json index 99451973e7d..1cb54492c84 100644 --- a/src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json @@ -17,9 +17,9 @@ }, "Sync": { "SnapSync": true, - "PivotNumber": 15310000, - "PivotHash": "0x3cadcb9db0e8e917e8bb03bfb245be22e0155158b2409e7f3f4528f9aca9f1c4", - "PivotTotalDifficulty": "30620001", + "PivotNumber": 15610000, + "PivotHash": "0x8405842b6afe9749d7c4dae84fbf95ee3febbe11b8291752183c72699f7aba8b", + "PivotTotalDifficulty": "31220001", "HeaderStateDistance": 6 }, "JsonRpc": { diff --git a/src/Nethermind/Nethermind.Runner/configs/mainnet.json b/src/Nethermind/Nethermind.Runner/configs/mainnet.json index af944dd64bf..a4256abf943 100644 --- a/src/Nethermind/Nethermind.Runner/configs/mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/mainnet.json @@ -10,8 +10,8 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 22855000, - "PivotHash": "0x9505301da162536954c841dfe9e7b31f01e53a33a0f0ebf1986f708494e4219b", + "PivotNumber": 22905000, + "PivotHash": "0x81116f98d56e3f037149f835477e93a36ebb307ae58853b4f1f695878d77dc8f", "PivotTotalDifficulty": "58750003716598352816469", "FastSyncCatchUpHeightDelta": "10000000000", "AncientReceiptsBarrier": 15537394, diff --git a/src/Nethermind/Nethermind.Runner/configs/op-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/op-mainnet.json index 5ee742d1fd7..2291e055de0 100644 --- a/src/Nethermind/Nethermind.Runner/configs/op-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/op-mainnet.json @@ -15,8 +15,8 @@ "FastSyncCatchUpHeightDelta": "10000000000", "AncientBodiesBarrier": 105235063, "AncientReceiptsBarrier": 105235063, - "PivotNumber": 138140000, - "PivotHash": "0x8ca37669a906d7b7fe18bbfb8dba3f14579f0d575cc631e83055c24bcf6a6fbe" + "PivotNumber": 138370000, + "PivotHash": "0x9a4caaacd0359b2b0be23710c96d2af4ca7f403a0d75b312f5833e1b205d36e4" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/op-sepolia.json b/src/Nethermind/Nethermind.Runner/configs/op-sepolia.json index 3dd3641d602..9f810e4e1ff 100644 --- a/src/Nethermind/Nethermind.Runner/configs/op-sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/op-sepolia.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 30040000, - "PivotHash": "0x3f1b0214d6b9a4b5dcab05bb28149dbb087613128120e05b971182777305ced0" + "PivotNumber": 30270000, + "PivotHash": "0x2f80ce1ac126baf2ceb86ccd2e157a018530f058edd70532fe92602fee2b00dd" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/sepolia.json b/src/Nethermind/Nethermind.Runner/configs/sepolia.json index d4ea95b458d..4660987c041 100644 --- a/src/Nethermind/Nethermind.Runner/configs/sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/sepolia.json @@ -18,8 +18,8 @@ "FastSync": true, "SnapSync": true, "UseGethLimitsInFastBlocks": true, - "PivotNumber": 8700000, - "PivotHash": "0x42403383b536689026cef7767119413d85ce41b1c7c622fd3dbf0f18432a00e7", + "PivotNumber": 8750000, + "PivotHash": "0x74560d628a79b7b585db1941d697b489eaaea0ad81634a0b7ff131c784ba90e9", "PivotTotalDifficulty": "17000018015853232", "FastSyncCatchUpHeightDelta": 10000000000, "AncientReceiptsBarrier": 1450409, diff --git a/src/Nethermind/Nethermind.Runner/configs/volta.json b/src/Nethermind/Nethermind.Runner/configs/volta.json index d94175d0cef..3cd40bd0647 100644 --- a/src/Nethermind/Nethermind.Runner/configs/volta.json +++ b/src/Nethermind/Nethermind.Runner/configs/volta.json @@ -17,9 +17,9 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 32560000, - "PivotHash": "0x84bac5e207fca78d1b109204a332c1cc68560eb9e949832d0b430c7e6ed90954", - "PivotTotalDifficulty": "11079593866945756370367477217978372964624592587", + "PivotNumber": 32680000, + "PivotHash": "0xe8e20981712f6df72b9ff23141ebb068dc2b0ccea48bfe9a99ee46cd5836f90f", + "PivotTotalDifficulty": "11120427750976268985983082170870185149999071660", "UseGethLimitsInFastBlocks": false, "FastSyncCatchUpHeightDelta": 10000000000 }, diff --git a/src/Nethermind/Nethermind.Runner/configs/worldchain-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/worldchain-mainnet.json index 796605b3d08..99fb11817ed 100644 --- a/src/Nethermind/Nethermind.Runner/configs/worldchain-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/worldchain-mainnet.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 16270000, - "PivotHash": "0x7d5188f3defc5a4bf3b562cc7cc8f4ca13bdaa943d303be4e1c4d9b00f7e2cfa" + "PivotNumber": 16500000, + "PivotHash": "0x5cdc5965f8ae1e261705fdce4c4379eb0f7c4eb725fd4b79eac9e473305694dc" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/worldchain-sepolia.json b/src/Nethermind/Nethermind.Runner/configs/worldchain-sepolia.json index f8eb21edc98..d0d0dd22f71 100644 --- a/src/Nethermind/Nethermind.Runner/configs/worldchain-sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/worldchain-sepolia.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 15670000, - "PivotHash": "0x8dcaa7f3f4f6cf58820ce0c6b4def07aec85626f12be553a7212d29d988251d8" + "PivotNumber": 15900000, + "PivotHash": "0xc52258828e1f01d64dc6e2455cb51baae4c77a91fed1b27e08760f01badc3e3e" }, "Discovery": { "DiscoveryVersion": "V5" From 8ee7c3f0a6177a99f18c3db51a2bde458cec591b Mon Sep 17 00:00:00 2001 From: "core-repository-dispatch-app[bot]" <173070810+core-repository-dispatch-app[bot]@users.noreply.github.com> Date: Sun, 13 Jul 2025 10:59:41 +0200 Subject: [PATCH 11/40] Update OP Superchain chains (#8979) Co-authored-by: emlautarom1 --- .../Chains/arena-z-mainnet.json.zst | Bin 87193 -> 87573 bytes .../Chains/automata-mainnet.json.zst | Bin 78563 -> 79091 bytes src/Nethermind/Chains/base-mainnet.json.zst | Bin 37630 -> 38188 bytes src/Nethermind/Chains/base-sepolia.json.zst | Bin 45920 -> 46145 bytes src/Nethermind/Chains/bob-mainnet.json.zst | Bin 69179 -> 70061 bytes src/Nethermind/Chains/boba-mainnet.json.zst | Bin 1669 -> 2166 bytes src/Nethermind/Chains/boba-sepolia.json.zst | Bin 1706 -> 2214 bytes src/Nethermind/Chains/camp-sepolia.json.zst | Bin 75146 -> 75708 bytes src/Nethermind/Chains/cyber-mainnet.json.zst | Bin 73223 -> 74037 bytes src/Nethermind/Chains/cyber-sepolia.json.zst | Bin 73131 -> 73977 bytes src/Nethermind/Chains/dictionary | Bin 65536 -> 65536 bytes .../Chains/ethernity-mainnet.json.zst | Bin 71344 -> 71897 bytes .../Chains/ethernity-sepolia.json.zst | Bin 75287 -> 75789 bytes .../Chains/fraxtal-mainnet.json.zst | Bin 143489 -> 144088 bytes src/Nethermind/Chains/funki-mainnet.json.zst | Bin 78556 -> 79115 bytes src/Nethermind/Chains/funki-sepolia.json.zst | Bin 73383 -> 74163 bytes .../Chains/hashkeychain-mainnet.json.zst | Bin 82121 -> 82640 bytes src/Nethermind/Chains/ink-mainnet.json.zst | Bin 87198 -> 87634 bytes src/Nethermind/Chains/ink-sepolia.json.zst | Bin 87279 -> 87680 bytes src/Nethermind/Chains/lisk-mainnet.json.zst | Bin 69178 -> 70089 bytes src/Nethermind/Chains/lisk-sepolia.json.zst | Bin 71325 -> 71845 bytes src/Nethermind/Chains/lyra-mainnet.json.zst | Bin 36846 -> 37389 bytes src/Nethermind/Chains/metal-mainnet.json.zst | Bin 69263 -> 70148 bytes src/Nethermind/Chains/metal-sepolia.json.zst | Bin 37320 -> 37845 bytes src/Nethermind/Chains/mint-mainnet.json.zst | Bin 69147 -> 70016 bytes src/Nethermind/Chains/mode-mainnet.json.zst | Bin 37460 -> 37986 bytes src/Nethermind/Chains/mode-sepolia.json.zst | Bin 42266 -> 42437 bytes src/Nethermind/Chains/op-mainnet.json.zst | Bin 2017 -> 2514 bytes src/Nethermind/Chains/op-sepolia.json.zst | Bin 49628 -> 50159 bytes .../Chains/orderly-mainnet.json.zst | Bin 37180 -> 37887 bytes src/Nethermind/Chains/ozean-sepolia.json.zst | Bin 71110 -> 71732 bytes .../Chains/pivotal-sepolia.json.zst | Bin 75182 -> 75696 bytes .../Chains/polynomial-mainnet.json.zst | Bin 69177 -> 70069 bytes src/Nethermind/Chains/race-mainnet.json.zst | Bin 70934 -> 71558 bytes src/Nethermind/Chains/race-sepolia.json.zst | Bin 71386 -> 72005 bytes .../Chains/redstone-mainnet.json.zst | Bin 69311 -> 70189 bytes .../Chains/settlus-mainnet-mainnet.json.zst | Bin 82887 -> 83456 bytes .../Chains/settlus-sepolia-sepolia.json.zst | Bin 87083 -> 87415 bytes src/Nethermind/Chains/shape-mainnet.json.zst | Bin 69335 -> 70248 bytes src/Nethermind/Chains/shape-sepolia.json.zst | Bin 73283 -> 74132 bytes src/Nethermind/Chains/snax-mainnet.json.zst | Bin 71258 -> 71925 bytes .../Chains/soneium-mainnet.json.zst | Bin 87252 -> 87616 bytes .../Chains/soneium-minato-sepolia.json.zst | Bin 78681 -> 79344 bytes src/Nethermind/Chains/sseed-mainnet.json.zst | Bin 71284 -> 71893 bytes src/Nethermind/Chains/swan-mainnet.json.zst | Bin 68345 -> 68897 bytes src/Nethermind/Chains/swell-mainnet.json.zst | Bin 82989 -> 83535 bytes src/Nethermind/Chains/tbn-mainnet.json.zst | Bin 82834 -> 83189 bytes src/Nethermind/Chains/tbn-sepolia.json.zst | Bin 75214 -> 75698 bytes .../Chains/unichain-mainnet.json.zst | Bin 116787 -> 117673 bytes .../Chains/unichain-sepolia.json.zst | Bin 101894 -> 102623 bytes .../Chains/worldchain-mainnet.json.zst | Bin 73319 -> 74152 bytes .../Chains/worldchain-sepolia.json.zst | Bin 73366 -> 74227 bytes .../Chains/xterio-eth-mainnet.json.zst | Bin 73276 -> 74079 bytes src/Nethermind/Chains/zora-mainnet.json.zst | Bin 41951 -> 42408 bytes src/Nethermind/Chains/zora-sepolia.json.zst | Bin 37298 -> 37837 bytes 55 files changed, 0 insertions(+), 0 deletions(-) diff --git a/src/Nethermind/Chains/arena-z-mainnet.json.zst b/src/Nethermind/Chains/arena-z-mainnet.json.zst index 2534fe883dfbc0fc2da467636b71e0fe9c357e48..5c589482f8317a7ca5f94cc93304c64ceb8f9f7c 100644 GIT binary patch delta 19329 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 delta 19005 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 diff --git a/src/Nethermind/Chains/automata-mainnet.json.zst b/src/Nethermind/Chains/automata-mainnet.json.zst index c55c4baec93ecdc93308445449e8db579a793a3d..2361dca88f7ff31b7f0a347a99eec584f2d43a2d 100644 GIT binary patch delta 15213 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 diff --git a/src/Nethermind/Chains/base-mainnet.json.zst b/src/Nethermind/Chains/base-mainnet.json.zst index bb65832b987fd6441f18a0ef51c18ab79e3fbcec..3bb992fc484239d4ffcfc887f36bddc7a2503bab 100644 GIT binary patch delta 6391 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 I$<+7%0Mj96k^lez delta 5740 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 diff --git a/src/Nethermind/Chains/base-sepolia.json.zst b/src/Nethermind/Chains/base-sepolia.json.zst index 06afc0e2b921ce9626412e725a92f90bf30e1c35..d862ac31dad330340a75c6d21eaa3af31b916b4b 100644 GIT binary patch delta 10174 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 delta 9954 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 diff --git a/src/Nethermind/Chains/bob-mainnet.json.zst b/src/Nethermind/Chains/bob-mainnet.json.zst index 81637577e2e84cc1bcac7a4f1a5b62d05149a0c1..1c815fa48d734333305630a48dac5ca2ee02d950 100644 GIT binary patch delta 8951 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 nqYJmM?KDyc=gre=nPPHp*1*M9LonOac= diff --git a/src/Nethermind/Chains/boba-mainnet.json.zst b/src/Nethermind/Chains/boba-mainnet.json.zst index 13dcc69c27d75ea34a4543c403c02c2526ff8c5e..a9e665651080fd8b4adc16f0de12470f4ff527d9 100644 GIT binary patch literal 2166 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 P`tMYDHZD=77U7Icc?=(` diff --git a/src/Nethermind/Chains/boba-sepolia.json.zst b/src/Nethermind/Chains/boba-sepolia.json.zst index 9fd3afa08a129bc3cc98b704f1ab7e26584ad852..8dd9115b0761a4279ebf596484cdfcff40587322 100644 GIT binary patch literal 2214 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 G@&5ooePI3o delta 11871 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 S#xc%(IJnr}MtdH$`~L^;q%GM1 diff --git a/src/Nethermind/Chains/cyber-mainnet.json.zst b/src/Nethermind/Chains/cyber-mainnet.json.zst index 6338983870370ffcaa2bc8c3f36851c0651f181c..cf022aac8d7b88ecef96e88124a2775d37c52ce8 100644 GIT binary patch delta 13065 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 delta 12255 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 delta 12155 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 diff --git a/src/Nethermind/Chains/dictionary b/src/Nethermind/Chains/dictionary index d523abde3f4a954173354b290af9d5f166529a97..acd327d0df2ad7e906fe00128b2c759367b5a4be 100644 GIT binary patch delta 21513 zcmeI4d$8qIb?3YL_H7y(nudNq>~5Mj{owb001DlR5PSh41_XiMQ(Nsu+Rnt3k_!fn zGtq>0n^Ynqk{Du@WlVFeF=i44rxM4MRw5>uOpsFJSc8fhM#oI7a+uF|?cX`~+)G1r z%9;6xd%N#B=l9#cz1LoQJ-%!0wa*=QEWP87r8D^lgD2j8;^H0Wtor+RpLpDf|1mi6 z(w8lL@$!Rr-SY20@|)LOdEMeGe&e1eezfSCE6@G?_w*mz^1cApG^qqfdis9Vu)mOXU`Q`?9 z@4XwR!ZmMnirwkwwZhW2hKVxt-ChO=_V)wo4VdXUJ#dzS1?T*_x>|h zZ;2}|l}%kUfg}r(APuu1N+2L8+};oFcK1EL^29Xa8bp;5)Smmz9qZsy&;?KiKpez|D z&)Tp_`mk!Usz5qwc$IZYRJB5ba4OSU)r&2`;N9cT)lArAzklA*LNSN_8&ah9oGHs;H&o^)MIbn@$xqu z-hW{K8xPorH&lnJ18=mqhq_na`uhEcU*m3j$C_(c(L=X3uiN)}{=DoL4%D4>9lR+} zXH9kRmu@|H?fwJZ8xL0p-k?E)H)Sw1?8?xn>0W=hT5x}M^ZL`L!yw4JI7*YUjGMH~ z`lxT)psK2z$p%TEmq`*7SzP34RHQ+eM($TP?7Ak*O4dDvyCq`93M9xYnh^APfh?wo zUCdRxQigm+l7qfLUJ#;`&Jd6=Pfb(oeL4G;Ew@a&SH1So>^radPt(UUP~K;05V$)Z zU$?6Ziv+ERO)a7_&Kq+XGd zSgI9uZ9Knq;M#F!qdlSD)OspXs8Ln zIjjprWa3u>O?oQtb;T5Q(6UejYnUvn)7+i>_?2$$81Sc>z)+&VMg)553Io?KP0^F;m>cGNy2EJsbnRvOR{gGsL1C!!2Hfz_#{lQTyfEv zmr#dds6>I8GJD!rlU!h>O@U-&$8Bc9tg%K77R#vTre~E%u&y9ua0Uscb&?236tS{y zC}|diy*`Ip)v!bn=j2r6d1sY`RRP&Zv1InTxCxAj8U*U4yGcP$bYuP}3F~IEBXy10 zjf+gg(LOh!Ndprr6A>fdg|Aw-5_$$r45}=4Uw=RJHb7CnjrsL;TvUqL#L z0&~%W2zd8lCZ6>=x_r|GNt8s;L&HRxRGLLp$}_2Fc3S6sFBcf*rMvr{`(Bv$Ws;?R6*OfQHBFvjzq%~Wahzow zM;XI3C~$&x>!QBna*EUFF`!vcM_m;`misUFykcgaR7+%`QhsqHw&ESuxW^U8VbHP) zaaOc-hEr!*OAG_1nPJ;BZgH@6S|v5ZCwQo??*hmSqatfrJhY)MTL0@^I)btu!8DOh z;+$6&&nud{?OPjmqAtzk?-&Ts6^#*5X}F9hpx}|6?%u~wx*6dfUo0oyi-0kFNpj@c z!bB;`V+gIBqi!e6FWwA;G`K3 zw8|Qz>qU9tUoX2w*h5;IA;Tui^e0(Pv&6J2??ISZlVlA}x@b|@I1iJ$ifcrnj=Q`G zlB`7@lNkJzcWuzJxIt8`sGGcrqN2uijAT$Fn4B@Oyi8-jZIU9hT~RadGOpq{16EaW zTXt31R|V=H_i>AVt@^r*Dj-2tM&Tf5VriA(Jku@_^)XV64FW!7C|wV%&Y~a>J3+ki ziq?dzV>)@?ByE|~VIC(ytTt!hv<`c)LEeRN+>{}@6Y|db70n|yH=TR)*Y>zo$DQTg z`PVC7g5ixzMl4HM698iicvFRSm?lAuyUd#!&8QlNs3VAP!>%pEt_gzo9&rcx%Hey~;`cES zJdtPVk)vn1iyvHlat^qFKZ6|9?vro3Xlt0oPzgRA+kPhBHxX+Ji(I(2a1TAQbV(k& zqrZ6e445m6M>plC_zZt)Kz&gR|8sdREdX~~NE=q$3%jYk@Og^M4>WY4CiKzFv+>Ya z^@7jC-3}FwTleQTtZ}#e&9ciTMA^C*lG5_XLt|e%nNuMwJQ*llHb)K>RltPEGKgQX z+uL0HT4{{upyz<^2kkW16DHtBY?XRV@DiF*Qff-xlW|`@UlXq6%R)fM~{Br^5tO=}ajW$IQODyNeY0N@V1VWWG|(p8sNsaQc9Y^$hM%LdFhF=~xvXGA0- zY#T3}v~LKc1W|RhE!@3JH=K=13xsjAMZeL8VVPw|#ge?UK-1lN)5g`(4>)I`P$zYw zkNa<0yM^n_!>;3OaP5t80A!q%?v%G>Ka-=iL|U*Jc{7Hx`ii`~i8HUpRA3{&!zVh; zX>0O;g`?Xj>)pwp+TuR@iB&rygqRVfaE6-UD!eBcKy+w|Q+F#Kf7z+{Ao(!)1)w3$ zwsm*@)h2h(4@38BZ$Eo+;qLs>8M7CjaCFLDx##A^+3bh+9GZUcrB_Y6k8FACNfH-+ z;7S-Lv)3;>w0KF^xX&NAVF|tex8ts#ilWqAx_swU6gTcRy{56dZ~5-2D68FH>9vU6 zQ_G*fH>&0%qD%lZjH=G$1=MIOmr6>IHNc9$Uytv*+mGM0s>L0^4+LHhM}_-?g%G!2oYDQSrWQ`K7QBDVh@}&PT=eiUd2LQuP|val7S8Tf#22EBPTN)-pmjQ zAzt>J7ko^fUjUwUC;v<19{u{Z)qM+arYpfNmMn~e*1i9&J7?kru@FM8yESBp%7FvK zQuZ`c^!J5ueez=??qP9Nswg> zDYS>nQ(x}=r*7ZKQj17NZ7uB*<_N16(4CU)bbr6<do`L435B{Ig zym?G>gGY}FIaZM7m}&z0ybt;;FAGdvkOKqKq>1aM?~1Gfb+ldBk`N$dfVXLq zgmK=2I*A#x0;ggNX|}>MU^Q8tHfduaPuWpcT_c+R@Ejy9r@NBZ-a9Lv=yLCMZ(8Zz z{*NbLZ|lRl;8Y11hIQ$(J|7%$R^xiLemzD_!Pvwa+Y@T5C&N787fXlj!;J^CzxAF+ zrcW}dR>-4BarTM}o?Lo%l{5tf&69jz5bt%jTzs{A z!6nO1{Mn{@eKq7`+}?fhz9#J(EHpo9S}6Z=dG*GZ>_0G8hSHp{!h5X*97El`SLG98 zRYY#@=XSY^|MN6qMN1r4s1C&S8$^Q}N~UfPxAFjk?cu<8i}#83?;8)Qx>KyQkKM)A*~DtPE)YuuDO2 zXCMb?$bf5tn8X^E#nNlmY1x1hgi>dEr4w*9WXAAHrP|2xs4JAwNG}xWEBbZDKLw=)ke!~8Ks7p1JadIkiUsL`6l(FxUmeb6$3R>V`J06Et5@!$bx<% z4oQo9@~^}2A{G+>?u1CPix6r2REV9oWJ?l*ynp@0zIgNAZi(n~=f7>5mHupn%duR)xUr@%E2 zrBb=u?NJjXx2oTWc(4+AMf3gn{ZQT#1zxO>(vj>vmtX(Ji}Z z4RVdjnxckz?k5VQ(tZji9IOGs1^9(EC8^6cl|rDn>c|nWTjj4RDA!d~L0M~5Q*Ci; z^REgTA@TldM*@V19zc1^vKg$PHO0qOFflR|MKWRFyT|>L!&+CPr`76mOO{%pq#i}MH94H<*y>m zUQEX1j(Ml2qLwhmMj)6f>jdkgzA#O>`&zaBX7LP6@7utpfJCb2IxQDmwf-_RMg1jY z`~u~P>?$g1SJR{i>>w9*wanaCtF1GU@~k`p9K~>FemW7`kP8S0y|iry1~HM|sJw7%Fn?5ezu{Xm!oyDFiTZS+^My&A#2r`~u4`F#Hz<{?Y!&RT?Guq?_5SZIWT zFqOZU39d6HAaP{;NI$w2O*ljH7o^CKV0%bJG6$$xc!IeYpWz{vK$oDF0q+a|jnt2T zbb=`)@zZd%1=5j3MSOA2J{y3e#MEl%(t8`}W1P0&_&ubxiF9Sukv;-w^DP+2Qn_Fn z5pl`nus)=yBKPvYIJ_>b%rslTMP5o&B2Vt&&#qk`LlYUNtP_|7JStp3s@#X(z4cUi zDc-|gZ+f%D1*>m#)9*TYzq(NJ7c|PFN)2fu!lOc&ni7*^s!Sd0-I1h)nS4g-{X|Dh z^ZU|q9+3jlXy`M48~m~2ovd|7*6m@7K*6OaLZPHZXoF|gD&U5PYdE06ieW;AYvQH1 zP;Af)*LY&M#zxF=jl2FDp9LfRDBOST__7~dl!oki8Ruzee9AMKZ2VfHOb1(}_7}os ze#yD%4$EMomyq}?$rwYGW}6s1VZH=VcdtADJi%fStp0r>sX{b}8pl`FrydtbhC7~s z+DvJqrsNUH`jVv?_<^P>H8OBQ@EKKs2e!Kc7E;Gt#kQD_wLT|q zSTWc1K-wj{(cXAK6|q5JT=Cm!CUB#f7~o>&Kq@0l@CDQ}5=Uf7DMYU>lAJ6dem!#Z zboTdr%r7@0xxn1$Q3IV)1W!Ng3lys=jllX5SS#%<2u6f!SuApT7VnYW7BhKXe^Y`x z`Yq9R8wYT!&qYS+ja+2hyBB@#Yy~3c(>0kVZsmrDp;YWuGJ*#t)AgWCk3!LB&pu)Eoc#YDcjmYEEJJJB zu=SyG?q2h^yWEm5ZoZfd?1E5F>Ntdjrho~Wj5#65FU3}ch+b92Cb#>+GuM+C_bV49_^(G(Smy1gtFGDkV&p)^M^^%x^NLn5AGmE8D~`>W z!h7w83rDftDlcNhlH((oM0`7PX3?f~i_k<7C` zf$_*aub0#Y6qkWH1=vmPR00%g7RX~YI) z1@)N?7vmfP@ADYv@gienay}Y@yeUJl2pBOufpwd7q<7b!948%Hb2Z6qt1EI>KfZm2 z$JJPF!kU_N0dr)nxnt|=XX5W?W<1ovWP0{@|M=Ra zQ^+OR@H1z({@E)QySvZccncKa3x`O!S87X$g_JC2*Z=al9H+$47aIp~oRN@Y_lA9U z|4Tb`PIqI1BDq54I4q^{`$zw9DA=pe$EQ>2^16;(080N~!eP_v$qi3+i zwr1rpSuHmsyQ?=|!v5fzmE`rtr5kqn1@70suxuSn!63?tg7HKdxh>miJIn3)!ZK24 zN~BAKjj0j5@si}bRv$OdhQIs#r5C~aWJvkMLgOZHCOT*bX{rq1!?vW16aR$POs4VD zVdMVimv*>)53F&U9$R}h;Cb?CNjT1Ruw`%#mVj+i_ln2%PQ`id-uu`GevWPl903+o zo75Q_n}i|ML1jetY*t9Oy_3lk6B5zpExO?!%R?dz6UzrqD9xi$O*nY8W$xqmoph75 z4m}zij^C~@-UMl9aiid&&q(#Dr#C>P`BlA>P5E#^4d=GY4Gu_+JR96V;J zkD)HeEr0y#GboH=S|Vh$^CZBh#FjzVgN0mnvC@#E)Q`sv*Vlk-?GxnBNCo zc^JtuPYw>mbU!+-T#KhS=RdATRZs3O@7lU1SokPRav%7Y?e610T+8O$SxX|)M_=0L z_I%~4vj__FDpJy#`30&9vOt>3l)TA&EEv?K``}kDcK_~um%H=6x_XNJQFqB#H|<8C zc!bIw>8~D7ijg@95HuJCZ$>|}uYce()9&cvt?vALE;+@Ue@#yk$CTZ}+0IQ&Na=aY z!~|?5c-$9sS?2!W!Eg#1-Of8N=CyRso8185g=x4PZ6A=_;}gcwmdBf^r`3uD?#uTC zFTo6INeora(P5~DE-XtWnh5sMM_rL-^O{rPs8>{sLF`V5sk&<2phCbmL-C#8f_01E zzxvFY{Fx8}k9j$@cZn#rcg8PQy>s>18j>QcLG%mlse35zRU98AUlR~xzHBrg35J0~ zz4Ei}%eQZs(dLawzR8nKb3$0D6cHvP<^*v;mDy2jELI8GwmXU~fIGrysoxDLwA}-0 z3)vA9$QUFQn~SyOIy1rQdT4ziNhUsOJ4VA$DgvsuYKUQLh0g4XhDNtXI84Qy?*7~N z9C>IJ*lwf@qt(GC;qGc#CiZppJ~YPpeSYr1W?cmq#vTS}l-BI37_Esw` z&#&iOK#p=xw)w(t?5wC` zX3`qtU*k)gS`A{*vZ*Kan%5m6DlufD3>MLh>fR6uw%L#-l^{I!2tThNXPY7BSS48bGgrKFyUW?djhhIYAg=jvpKh9)3ZTTmU-mQyQp;E{pR*HK-fW0Va5PF-PO~pXFAcWId}o! zU6)WsXJ&`|vXLXe&2`m|%2*=M07_j6{B|updSQ7wF=~Yo^RBG(X3WHDAbluD(=bXr zpzbmjR;y&IDn%b{fUCaA@?jASpIkkktCLKPR(jq7b~QRjCC<~exT|M6n|(JV6(^Kc zW^SUJi95$olrg)7p1mgwZK?B8~1;T%vaLyC+7Z7k@+wBKjHpQ zi}_2@l~VBT1>iD8FbW#eN+b%sg&7yNo`rLNgMN11E`Qgn4)&XfOPX~k1zxRTJ1E;QBRIzi? zhh0yV^0V|qveo*bzKMQ#!t?^?s9s3{SU&}wa8LnqbqZ+#J=((tVOzk)D`^<|DSc{j z)Q^XFF?;B2gplnCI=Aba+eY=e-uEkXBhCb^`ZOV*Nz>`CuyD#5Akm`x#$Wp+qv);e zJc}0lO))w2$?(uWPh@T8GEH7QxHefZSpt+8RsVaeNr)G&6)GIZzehB_b z%XN*ohL8y~!!>h`9{KRe7ZDV0e&67zoyZ4{0-}LeKK>lTV_#7o zr|gBZkqp2(2CO~Dk3=3{=ud?upo_>H{kR{)C6g({hzeUlq*CFbYUkg-8jxte%060t zf#j3mm^x*roK96yK^ucOhEk#?cSpYSj3{Mh0;MQ|pd$`w(-AcULnqq(0OL^AW3>x# zfCGzjg};=AsihL*MlL%e12nCC`K3mnM=F>=Kx3R|h%QKG2B0VGt&=YTQyQM5cs9I; zX#)Tp!@^N(F%OtK2Pk{gI65Wm!@Bsj7zOy@1V z=|1_1Ei+Z^(+V7!)NP+kWHhf@6mgQ+v~Ps4kt}>1mTjEA@~!A(eCZZt{C20#XisJT{;w#?!Oni>`T!t#4%k&9ccJ zjQV6Oc6X^05@(2BwMQXCG&iDpBa-GXr`fckHCc1hP2Q4}mx-adIvRF_#2!2UIy$}2 z!6?7;zyT={<+or>XzJE~XN|Fsr4z%bDtg+M14e6H9&s@PQ!Z(o?q!Gg;+uifh!mfj zAh-Ez#ylsQslFDWW@H`TIO9I>{FQrk+`;$LP**}f3*@VzhF=!b_fc`4L46p1yvuTX z|788#Q4Q{jChfqfuYo3A$&k@;KOE4XqeZu}z(J?oB*-{kWfd+gb~d+qx58q0QKRAn)@C2-_u@{GGQzTL+Kc;6j}#v#5FU{$pZ%0X5C6$&aPaZi3Ozaq8W)A9Hk+2o4*mlw!^J zrUK4CNP@^{lyvO!dLR>Rl^tHDC3(X;c6l+N zk~-5PFW-E!CwSGbm7hrp`9=iQFZ0SiZ~|jwmg1q?mgecR|N$r zn?^ADnZGKCjAei1N1K+b#$Nlc?uTp6co~%evGi|2^(8`|ncFk$>+KeLr4zWEJQ*+} zY16^)unO>%uUq=+$M?7|FW#6_fGiCpEstL6nTl8c9R*K+%4>=A9`^2DL0t>aFwrt_ z_b=HeJdHp|s3$Y597}*m;u4916V-jfJ!ta~&@+~`~4FJI#z7q#{lLiTO+4@wYQQo7>BYU8l z%6y}`;XK4KsGgCk&5=DWF2b!11&LG?3={8c%RP$yF$+I9e*c*VXANv{3DbCRzqFoV zS@1l}H63Wl?63SH`&PhJvEKc!WfxLFwBp^zUAWG^gGa@AVi$36z_C0UByC_ zWAIrvKu^M>i4{kZ#*9=edN=Pxb)gJ7^@YM#`p=l|H|~noiOEzPA`ECSJ!xF3woblb zpZoB8In`hXC52Ar`-(z)Qe4$eh}4hwnmrG5oSWk_e33!ImRXT>e4Sks#ncVOd~r-$ z5Gz1HL6fY~_rvg=1HE?Bu%XBeg||sZWvC9;@S7b!C|;4x`x+inRT?F7hLG+jo@d+YI^sz_p7LH~YLYkVG`9L%XYi&?-G$#O-Lh|N)t)YA zvxV2}7jdjWxy;VEu)sWO#y;wda!}cbZVt`(qFJv*qc}6>t5CGSW=}YMCG!35lZcm@ zj=S^5EImf)jfNU93+I~%1=gJ~s3vOZKK`xk?zBTYPNm9D=hPTxknqq=J#iY@3440d z&7-&YNL3NZc6c5_hKa4NaTO~ezag%AZ)<9h7bfl#0x&<^LYM#$w(W(%F%NZ)NXP2& zS6mS{8PWhh9H$BoPID-M`m!gVctHq2m$S{u;i(a{V-0vT^9%@YLPz j#_zBBz3aZaf`UHr&%OdI;A?hlwM;#N*?0VK&-DKWdPRsM delta 18353 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 diff --git a/src/Nethermind/Chains/ethernity-mainnet.json.zst b/src/Nethermind/Chains/ethernity-mainnet.json.zst index fd09aeb4c4148e73626b6489c158ff31b8e2db35..b38f5d9580bce75b7c38e7d17c4377fc6667801e 100644 GIT binary patch delta 8569 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 Z{_+S22>v%(#p#7mQAB83eVJ^p{vStJ?-c+5 diff --git a/src/Nethermind/Chains/ethernity-sepolia.json.zst b/src/Nethermind/Chains/ethernity-sepolia.json.zst index 8525a63e849eb9b9d99725e1f292f1fbbfbf25c5..52eca23cd6a6c4aade3f7a56d203d6c77be3af10 100644 GIT binary patch delta 12605 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 delta 12120 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 delta 14867 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 yCpsZ=?L{uwg`WEde)ab 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 diff --git a/src/Nethermind/Chains/hashkeychain-mainnet.json.zst b/src/Nethermind/Chains/hashkeychain-mainnet.json.zst index 424ad0b396903cfb80bdc625320e48778f6ba9d8..8d255065082987961a7a9a8516ac5d7c80130a06 100644 GIT binary patch delta 15370 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 a!u`LNyw66^&`N<150^pMFiCB7{r>>=oVZs2 diff --git a/src/Nethermind/Chains/pivotal-sepolia.json.zst b/src/Nethermind/Chains/pivotal-sepolia.json.zst index b93004104f7df303f0288b552c1e97134624f65a..73006de6b99169a95cc0ca9c41ccd12afb262107 100644 GIT binary patch delta 12534 zcmY+JQ*=_rCmJ)tIBk9Q87v z)~Z^ylTh`uP(a!imQP6Sa71wO%QrB1866gS)EKTXWH2a^KY#0I&q*kf4w=0)ydaQu zZh>|V*!GRtm*PZVq+noR&V)9Q=MW_j8r8~*u|{){uduL)__U0+l-ijD2vE9j@?8=T ze_;XJWT;@^aPXugqAY&~&?KC2K5~M1fHGqNE-^%!F~9`lCIvyT0#H(YAklaA%&x_Z(da1@YVc5i7%O33FeEe;f*^*6*PsvrLod2J z?o5a@8g~W{!`<>;cNpf(_|XKp^f{frgF9w$0$j8zw5BRkTRN1g05x!tIv;f^S~>fz z2DA(i2J&!l82^YCgkqr=FjB8LGDW5FK2Kj%zVw?Y0LHa0x#N4C{PW9gi{A& zDKUIaGzg8u-k%?Wzx>u-KIyAkx$$QhlV!l1Q&xq57*um z25MlNHIiD~PXI8`5g7Nm@%zn?@NotDZV?cWfvtgVE5Fig?RlS%Se>mc+5JL=uk-H+aQ36 zwK5~AD8NM~3Iu{hnyCka_(q94CcrTT+_+8lkGpD=o;U`jRH$se(&mLqzKvdSA|&4> zxkt1`$cRUZgG9j46QFT1@gbnG`Y_qf3Qd9wO&)2=!Tx?jMnbu|{f2KWZfgt|CWou`hKEx-*xF6bDbqdmB`GB!kI!qH7CGb& zt2ESoQ%p}38r6?V(QEcPu%+;jRQYxj8&p69DsqmaBGncQaE);?rFF(RkVGaC9fSxq zS`vQbM>OrT)|Q@w*bm;r!lebqdhH4aW7iXBiJFK)4zhfKhlh*Y<=-Ol-60~OAerHV z1&J~+aILJy>m8C05`H%eh`(H2saAY9V|41y` z2(H;b0>m|I@A@xZ|Kt1rxVio>mH)%?e~|x=?ce_;^M7dk4=nayKAd;e*5#;L8b~t) zP%SWScyaRR%q+s!H=zkh`u2wj_@D(Z>EP!k*;OFXNtimx&V*&d8LpG~WIAVwd5veA zx?S&KVLbGMl;?eNi#$!(7=;!V=lpMOvV-sm?4~+qY7LO)_hp3nO|%+zx_U{7+bY)) z!AR+h_8rnGlMD;OVlK?%q>4=2X#)~{kjSKeD zvnt@bRq6hyFaz|0bTE^uaVnHDpLFO{M?#2NG=BV$m~fYCn3uQ5160SD8?|OU^Uil8 zDZ=mfM@&&I?YknjkIn8etGtf>8=1Ipgk za|m#;`h@tzBP@&@v|kvwi6iZ}7*@7+w&}nb&r_UV1hkCyRnFFMKd>LlBhM2MohC$0 z3vSr#oPmNZCn<@1U?%*;*S~a75#1Dler1}hLG__?bBlD zUHMcDw=FPAu1T?#8Yvj?Z5D`r-SJN-=D=O)rJm82JpJ^_q5sQY+*W59{l^JYt7S&T zouh#~t+ksfZ{I-C^w_{uabRM*WE0#n!cJC7L`ajejaKcm2kR=E$7ON#3(eF-$g~jTSb|FMYW)7o-WBg zY&hnI`8HO4 zSGS%>-kX*SPiKo|Lcm&3LPw?RDB?WJ`+Y|&Tf(Tp*jXi*l2ro)ey;Kh=7!yzzny0| zWyW=TpN1nR8$A!I1Vc(qFOx2f6G)EC|1BLKQ}NG^(KiwACDZgbOHn+_F)E!$Z8edq7I|I?RvD#8!6kaEh)0Y7Kk&e(!#lz2Kq6p_p>qgG$ z@RxKB%r7His|tVhs*yxlY4i+PZ>G!poH%Wqscek)Q5{I~$Ew?0loHSn>9`GkDZTP} zu~wOhPE{~Kqu7Ki5ECKa#ifQoWA$1-ek9QAzj!cQ zjme$3|13|VJ!>srq`X6iN;SXI76cc5^6W9z4hz@gfUnu3Il znuf%gC;zZ@YTFVorIU|TuK4wwxkQ9M!pe^Mfjez^L&DrC=kvn{0y@nJoJOz+IlH**uKa$u>_wW&f2d zuxJavS+RY^Qb+ch@x74^J&F1lL_5yZKV4Gd1&9M#k0;7D&Zs5J{gF5wuUU9tY(&%B zfsX)YmLFg@7nn!WvHz#6(nW3*V+N7ZVxmThn>J{(!c~!AfC1!68*Ern$4pR%L{LLX z;RadZLP-C!Ls5ru*=3Rs6*ageQwal5AN{oRKIis~wxP4ApvaJ2b?gNx`Cd*RF?X-8 z?ve4)$CzleevrsQdMGqXXGkB;vl>(YzcTA9EgsDFH#n3>g;;Y}P)S#8jz3u4BXu6h1<()T~)ExrcCR)TT_y{^7jfomETT%9|MqKQrxY(9 z)ql`8$&7-y>BsA!(5Y0a6n2YpZDo`V^S;?QFtKCG+5xD&dp~O<7zcA zCUhdnNL!6@n(aFIaf)L&Z>fn< z_z5G|)Xn}qUmk{+{`w5a_oBNwO!(;$ZmR1dIMw`xb4%jxk6 znrH%T)5HE&xZleIB^7MIcc>tj!%)unqJfOC(K}_IKi;GLFAW`VfM)Ua&{X<)fZJ-C z4ECxe7kLEoFKY&%Hz)CacO~x@W1rV6MJd+OvU|GLNL{bw$cIM$h@2FQcQfC} z{;3Uk1$?IbW`X<5t26>IcJaN)#S+Q|dPa81y`U}ASkP5Z)-|}@kq09>u5LghG3whH z2R2mL)>%HW5EVJygOSoz+zn0b%v4s+oKJy%`<=ZJ!HfOVe-Z6GUC`OI<1Ffr^1ntb z4AP(aR!7@St&&W~knUGOU%W*g5X@OPhep%J-?ZaEzA(!%WV>U*oIU$e`YES;rNRYp zk_SS4Nn{0%5U0i3B%l*JWUjKL+S!2FxA9xL5pOt3g1Jgu5WPj0o0R z1VkEgq-isVNddRF1J0@=cuaI0sft{){OydG5#};*5|IapfqU@ z>%5N%FkWncLvUxqqfVi#q@={nBCSYdHRtk|5tsL(LCB!T8SATjRQhY`*er^c7Wz=<`R2^^`lIX{n8PIYlR3u2l`U zHP+G~dO+Z+XjffCkGdEbsSTC<7-@bgYnl$#mkRWdvcattIsu`k={-nxzCc}h=5u13 z>XlhoohB;q<6J1v$d{Emsi7&fwzp#kn+|vq9I1ZtWGV70vp?OI&TI3XUCeXlajJHl+AURYFx&O+R^e0M}Xh+RAz@N{s zdh968=d&pfNSZB)mnrJ?-;_LmBzGx02*Vn!F9H?#uPLO?2)rt@40FFX_9h;%tV@b>l(<#Aiful!(6v3Opf)(qFEWQSx>%?MgO-2OV+%?8)BshXl*{oC2p z!^{yBVdeiz(T%n`H%{V534R?g73Y_Fw`#MBDrdPi?}<|#16Wn5;inMziSD^3>``w( z_$Ti7htQ8weKFWgkn+c3E=YO5h6wPsQmGCHFO8+ z%|<^xdq>?!+**1(y^m8XaEKh&v;c$l1J#xQjjuWtKCXu`VVZt>7rY;snyh`KdPvlh zSo-?_;lN6{hA`NiaUn}mlZ!soSc=>2`=B0!&5dKP_Y=;YS#j~SiVUem%ax{3@0JaH z9aZbj0EV?!bNXoco~|4tezd6N4N9wJ%S~=TRKcRvPn4*^7B9vidFEf(a3>ZOP4QS1 zlR1Lt{dUw09k0-uO%;ehxk^>yBI$;_L>V?DosYI^A4(Z)uAg0%Yc@MUgy^u_BP%c% zt*J?>^>Hjt(}KHx=*{WLbn*pBF?+;`X3UuTx04u;&m-V}ni;tjq)i#bMK8lq&g*(^oB z8x(-rD&c6#%AG?mSW^Tj;mqnnUxXD3cB2`mLK~|{sLZwOPg78 z%He78T-O30vzk!Myg^x&W-## zcdF3Egkt?0&=KN*jce2T5eVXcW>O8j@@WH?v*4Ts-3d;CUdeTB-|=Bj%%MrV(A;A> zpqXz3&ILmxj}nW#lHz!~iqf-amRQl(TW4j{nN4H$WhiG#5wDOpX*{E$*71l~MLzFy4bv zraPpwk5MtKR2>=Si~wsA8lVlrd^s-!k@bg?8mUUr=o<1JI=#Gy{J z)1L7?)py9^RO}!Z{3;3RC&cHQrg0!w(H^GQsZ?>{g5_?prEyH(iY5tON3Ahd{~vHfzR&HsY>Xy2&N-j-Y69bnOpE z;LwjzpnAsQQ+hHKrFz5TqXq%Uaj5s0u74rO#~oK2BR4HjsLCk6bkza^!4KwV;7r)H zJCTf6%a~H{E6V5$z-r>PQT1V5;q4*~cU8}`qd@l8da6bv&{}F2!v3$Cr*l6+VMyVCvzt-$QKR6NA>Vi+z@-l zgFCf{o2}^Rub4_wm^IkQDXG=0S#n* z@fKkBh8lb#Ja=!bdV`aNScki01tXwGWtZT*7iuBeoLTxJ4fa%>!SM=Rx6PelmF-2o z%_{v=-0r%~jgb3HX=Q28_zmVjxy3O6q#z2m8{wa}lPMMR8EsF5U@Rg{Oh&0gLz^)A zqK7}By`q1O#S5Mqf;;$_!MA9dYXNk{u)+la4dawi z>}`rXBUrwH$s{n$Xw$>Fi44}Ix}=s7_akrWgyE?>Cx3mv3HwPLIHY*i;d~&_D?6PT zKN3Z1m2P)(-<5^vj0OJ{8_RU4Ve2-)!TT0d&YYR6?rqT`*+X%IdOkm7UHRM0L(buz z5|Aw?Zk5T`k*te&+Dew`D}^fsyo)ax&EpMvJXYirx~CCQ7SiM)qd^Wy{M-yB5{20# zghSPGoIFo=T2{nh5(Bmud}E}Qnq4pV-!!*c~Rq& zMb6c=E6gXZX<9B#mD3g%u_LwV+(|kX(u4p0dJe!y07vyVM0SFto+muNt{noWE`=R*W zY+ccYeAPTJ$4$i4vLcob=FaBDqOyPU(FEu=FX{c8FFQU>_oDFMe1&RuOpl9r zf`G>90%DZ^7u)^2(o<&8gu}5y1_6}v$(NE(19@(IaR72rHI42Qk{U#nGsO%m^K@28XN;1_(fVG%_jes> z(*>=37Ec+{(74*4Y|>`nM`j<=tjPWg6Y*2}TYPfJUBwN}BFZ+$I{X9>NANT!K~c`; z?t{32Qk7<^7437f=r9BuRwD;xn6=?}ve_ z_$Nju-Q9=69yscN?Ei!=ggN7pSdH~z zzOabgS;mj%JJ2dA4ln^SS>pGIYOaNkqn)dU`y2eaz_jlawljPe5A!@s8>j*M&Rk~e z3NNq!I!+XvS5pR`jb;Xc#N{zg(+@6|_@o1lI>w03FiWv0qFn!)fW6R0OOEW;ZpQA@f zDVBpHBHgsuv8w=Z)06eS-F;{21@VX59vMOv**Oav@0|*bf?n67b&(aoltV~cWv||f zabN>=7cqvkzrJyWiC{g?#KIAtuYYb4mqckH=x>-MnUOfVOO0t5jRCW(M(j)h)k&|? z4Q(#U=qCe>l#vd~^%sY{gM$u+$%40X{O9zI-3j|gAjSgFim)rZMVxLYE0tuWYl>b& z;ZNeMDyj}XxL3eWUgJ8Y>P|fh_WrmzT7-$Gwi%WR0aP-oa{T3O67NP=(XF2;%LH6w z=tc`U(*kUZ(MjgPmTUc-RQzSbu6*#d^pv8Lzt9UsFk4k}qm38}(sMTo3KbnhB7UT5#!dGz-@rz7UPCMB(;Y}%ub`JT zzx5wZELg1RP&SyNdaF8WNy7Ua!b{UihvdF{Eb4~cBjAuACc3FdPXb(Nyv}IMD)-9C zCoFLA!e5$|Y>#guShp~DDD;oNoD znmQU9XlOp%4_`>+6xp#O%SB2OW*Xno>SD?SaQ2TTyD`X&+$|*}#K9HH`x--1@F5#u zFzV)^iP6VUMMxpScYDc#;MhY5B6lMTw4MJX*^@YvY)5QHynui7QNu%7@1maIXB3Ui zMIh$`Id7f8f1(h&A{E5y^P~#nRe(WnBefq$)n45Km66tj>QR27wC#OK+K5aX4KP3l zn`OWh*`ss(WXGcTbfd?Io|-ND@s_~i0lOHKf)Z>d4Ot=%pKxhyoO(FGAh#A58}R+B zidHz}teWC!Uyc3&yp|5t(kW;^kmwkrG)5`e*S-iBG_7R-sXL>;wkf z)@Qy48+^hn?T4q}noDS!hEa1@~LB`~NZiV)J* zQW6dvV7unX36T4t3Cb4K=)fxsyT7!`OlsN&%7p|X`)QZMO8R0TdcRTM+jEavWNeLbY%f2sv)s<;0XMB|Kr&hpmexVJ&|fnDWIYRmTMZl1h{ zAB+S0d38zHC-kl6>|1LXdInB2yA=XA%xH6P-#`V_a}Wf#%Ho6CoR|DJ^$j+a@{}Q) zdJ!1Wr{MK`rp8B0<}yZqO%tpU!puFaWzxTo)30njc&0pRiF6VvZWM*OvDPcVS|*+q zfWB-ag?K?xP~7O4$3dF6VFN&RQd(~a$^}6}y47aYcp3XDdNiBgao|1p9i4DY2lDUQ zJNcaMK}WT8`5hY6%chOt7An8BV9MMgb7>kN1OY!}2l03IAiFSq!jOguIY)bRis*i6 zRdH8Ct_8>nymx-riHw8Xq|FM5;V~e{Y|C`qqUv^ZGE zuZc?9yt|+1(yko|?irB?Q4t(2hFxy`%>--A^)zO0{^H3U)$U=?t;1l3iQ;kwe@#D2 z|F{0w#@WdIO)^1V0^eO5oY0pDYmqf1$hv&7eWFO?J0&?ZoecaLPz=ME6c-U57Fw*| znH36r;1(7`WI%qTAyEL8N(SDH6b20dC;IQ8KOA*`Dq%eZ6M41Ifn=o(#p`O&@mW;t zM2J$VyE84|I*s2e$?}>=_VXN56F{8H3qa`Y*j=AhUf8QS`c$2+`89`-R|40tr({8v z_u1bhE?Vc$a{#PeF3Kh`<77`KqO#ADM2p~$Iy9faV{SqBcYua z$ER^pyaecN`QNKQ_pDaWjIZ2f7$dtEQHPJ>{-T3+k+6jjF4<8wOdsL1ipMy( zoR@039Vhuh??E!#rqKB&VOs2(qO4BccviE`@$5d}V z+{Tox@vUFoA0R||k_l%ba!aHo8+E23S{A2twrs543gH4VafA>ULLe*}mxA6Cb!Ox? zjWpfElmjGh+gJSgO2CuQZf-AK50H+*WqPbqe&p+_-+xdn$ofl(sW6(9%HWxu9lzxRUg?^{c7an}f z10C2Sl6ek@4v4iY3v_h!(JywS2Mespq_Qms{xxu8tIb-(azuLdSnrrx}8CJ z_%=xRhDO;aY^dG3GNE@3a&X>b$Iy9iRz(V2Sb2carMLYREhydec58g)ZaoP44X$G% z(kKjBQG03R(Sz8~TcaOS{)G<0{?j3?dILlU_qiuM4x!vsjj!cKPK{k=rJNZCA|k3q zgxlG*-H|S@=i_=A@H)C;ycwLDzwVumP4!{w(N-kI#iZ6W3|EFLh=rH|QTavW4p=Tk z945|jUBX>@?|sS5L1|Yl-z+_1ePkv*!J9JLs2&ffEAeU)(O?zrrb9*=^9c%7OM!EG zJH`ns*Q^Ob6rllu9d5zp=lcEp!?7B`TqFe)hEP8)g+u&f8$O(KnW@*3?mrnpBiPUA z0sApx(BaK@`S$Zj=EL;md%cy8{$>a|W(yeYL4w6ID-f-fxC4=AeAxH#Q(EpqhUOMc z8-5Q?TiLbcLa{>#Myxn;{BU7$oGG+gk^~s{5{)*p3q@N+n6dTBzCVHQIGdzyTXaZ}L4Q75F9{t3v z8SS02z!|b2LxCR4F+>Cq&)xU~b~zW#yCp&iXPmUI+OUqqs9pr2+6{kf0kHXC-<)Y9JWhIuP2AHC{IJ&b{Q}xPjc37YUc`6TXh~J1=Z-H5HcO~czA@8>;(PvHs~~H()C~=AwDlv3iLF1I7p`{(wv2AK_iT_k&Old+xWM%twxll~ zIlWlibRs&qJTU%&P@WK;)V(qTo@bnqzv?h88ACl=I)GJx`M?XH0V(1yi>P`W$}>Iq*%WdmR;2$rQ>(tP>@E94O5pTWnmX zx(#Y!uL0>DsQ^evg+&l0`o=eQe~&F}nTx9fl7!US6hIy6-48gj>%Q!%IY zGtkJ_rA3aI8sg(Lr+Zut@;1vJZ7I!JtJWm#iQkB>8|a^s*XS1o_6C}cy!)2aN`vy> zg9xm>NwNC^k5+ecSYw$j&v0k_qSb9oc05%~u@}eMj74&vyMfYwK{-vmuu2xCmr4mq zu<*<$RDZQ9EH!#SXi#?Xl=(45wkbOP@2GyiGAST#KI3#W*B-g`ly~dUNts67Z&6=8 zqXUK(n9@EQOJ?F~tgtgmXyh{8QyRfLd#%;NOKNKp$@j@j+6CfA1^0aEJx^bph5^#G zS^T)W9qV-nmO!q&n*&O*$^O+jP%qiicOkcK#1)6MuuyK4=gQYado$+51v{eH!dh6d zeHW)i#$O>K<{Zgn?;$lYJ8+iq#73OM_4Ku`WC7Hq`;jDjuJ(bzXuL}FMs0knxZ|4$Xr(Y4i1S{)6D zgd%!I9#|0z^U&`7P?*P{R)OWPMW~g)l z26^60;V_x#k$;j5VGC7J^)33QZW(jFA8Vd!7x-c!6d?qbM+?ngK$oRIi!od>VuKij zxThjnIcKBRMmx~Ljl0LxhCv!k#~Ya2 z7`hbfWeHr9&A9G-B(&i4qAecPSkV|A4?$Pe3!cXKyh2LC@*GZ}lxI8ZDqz&suJrw0 z4y<8dYqO>PRd~M)%o@iMwdn*=#jWZgE*^;!W2MZ@E_u0~6TZ;(%hVXfsA1jeL?P8) zqlX>bCH8v=3gS|A8vQfUYs13o(j(7eY?S9z)(Nnx+1kIJ65s%nPe9JVbneIzqNx)q zW5iDZ7b;e@sfH!}geMO8r`S+p9he&P09h47I?j;7gDX0@*|XRi1uM|4tBAqj5iec% z6(HJC(F!{tWTp!?M6z2+jnoXRnW-68jbYwe(Xw+<#?M{x>ex;0JT*^iQ=4K2AWA?{ zhR9?W8-7J@3N8J=BjFfa6ibrh^FIA zy}M`N8WE<*18qmuJT&F;DGvjG}Q_IM@ZO zbC!sPcE@X>?)8x!*-f0TzBXiG3^07v!pGY#MIj#(W@Z)*1C?VsK%mh2KzSK z&sil1W^=q$gTH-RdnpvB!G`8KV?*etzmn)lI-%yAjEv#6R|% zvUgFd57b2>&Qct9&?3P39D#p3N{PYyp-zKTnISZOBYL{zAc}g@DSbvA_I$=k%#H#y4(F6wPWDTO`9w@?)7U{6UND`dpQ4K zsbU9)KjDb9O0OU-zos7~`nWw3l6NAx zY(z1<9`txFWFA@%!Pho2Nf)}^w`hk_hyDcx1_i;&k?bT$45T7;Ioa6&f3Ca~1Afdk z1)N%tJh!0;ZbleB7xo7H*LdHI$h#6_`6%cOI9(TdY()9I8vNI&|L5>0^wB@&P`0rF zMF|Aw;jbuD58j*dWV|EvXiwt14*Pi}Hv3$d9&qYJ@~;u`m4HW}4hiB>kCkk1VjJi|zQsrY;Ombjqz>k{p1*PQeZ zvBmQPp|>phpdE427nB?G_tKsIURbH~VTby}nV^4{nP>rw9yzmAo-V61X8WfMrL9=Zh_ngnkd}stGE} z15k^i_6xGAG>C}0x&T5TC6b{8JS0Ly1gMwpu|BcjIU^bGokYQ)8Szx6A^iquVGhsh z%#djSDIJWY;;yk&T3s>?!_09klBnJ}_}M zOD=awhQy_&HcXBSR}QE1rg!6tA;(tCnJZ*t1*c`xs?GdmP3pT`})n2}I&(tMFAE7raU1T0kc#c(aM zB96MnJEPHt6rH7=bE)X8jGG!a=d=w8GpEuQiZkki@Zn!b2wqxf6P0rqG$$~i`tZlU zvkC=guD^1_?QO00x180&o!l`{@D*>%?eyNYgayH$w5d;dhkA@ixW>_Smo~mfJt;1suqz!@y0ed!XHVq;%_#1O!dS|MeG+k2 zNl^PDdW@@gw+FWe8(T*-K=%6M_N!a|QxO$Oe-*ymy?O3r=7dNNt{)6m@O5(S9~pDE z1IBoIoBPaSceDAYLH2VF7ocKQkEA)RY)QXt7Iru3$y2A~OUiiI>m$-H zCJM=~LuryEQY=ct%bO%J1WrQq2Ydhm8kUw80WvIdIJF*}I0+J70ssNaLs*(eFx7W5 zX{`M<{WGkJ_Qj!kJ59gGR8NAr)m(mN)+Wzd@0+{A{TUlIA3L8B#=W_rA^KmNyP5WM z(+J;upjMEFG`AErN+$)0qRC+nPPXW4Zi(-1lhn0Y~F|QzlhwTCNm=vUl6Mll-K8%hxn<+f4Z<$xzM~ zP_tv)A{x1?w8i^*jk*uX&+JpVxdwAlnTJ_i82L}f5~8C!Fik-V`A$3ji*akKMzZg^ z;ESj$W-Bftcg!{3{Ix-M@$8)ZcX8p|Wz{B=gyB@Vz^c2(jg7ZDU4;@mhPe*!_sjBcymXX`2{&v7HuW4U zDaz=iRm3erZ4sweRwY`c={2QeTl6;a-JKfUtr1?&ncBxkXgg*LZNBkN-zpH}*)6pb&(Ay*$Vz{h`DxvuD;}1MW=!gIHcB{MbT@ZNbb5qUssS%r z?9!$a&gnM)Xi!HGiBV49Q3*nJ@W{_Kh-Sp4lrveJY+BVO7pGXx({6a&mLZ|?$=zFf zcSPq=naR&kZjCz9$7moZ-UTIO@6Oy;MD+|?N{OK;BOh6pim@~nvF=0^PQd2Hf9rNgRru(SJBab)n}lr)JiVa zh~GR4Ci9~vE?qY6KtEhXI7PclC#p<1yq{UwErkN#3kp z&y1Y_v&@Dn=&|Jb!NwK6E4}r!4MKEH^m971v#8DzP86k#oQ27Z9&hsz zbdIxk%s4yF5T3EYkH6FDT&HDeJDIcCK3;mEj=ZW&)v6`8ilxIxM^DD0oB@Z#4hGO- zp+!oV4d_rt$O~ik56D|JnzEuro1#IoA%(HRL6X6R0{#u)zlmkuPou|`wMbsKd)M~|dr0K!tx0ary*HY6w{If}p)YrXz^ zmOvCH`f+-+K+#smbwKo#P=u=_xccoIIiC8RTTvg(^ZF&0*UqM9Kl1RGuOlE<%&u@}dak3MB!1UH>q4pL@Eo;> zXXBF7pHnz@dx8%~1{cI{*3!lH((qpr=isTIs6S#YYiuQH4Fc$H7`BY+1m~QjU}nSs zi&I~iaB_(y@QUC!_VkM?ud->KrXV54O*j>1aL%4!@ciVUvrItR3QS_Ov!dOAlGulT{s4K*6Uk)$UlW z^%Iedmr~La{_fa&Ji1PC_bnpln+sM`&?Bd!P0f$O`MWgc5>+bf$Mnk;8iqV7r*kI6 zbuufV(HK<>H>KbNhxbky3CM3R@qaCf-;9FTBLec~)oB&0*Eik1N@B_HcR(MNB>J~+FC_zY}q_N#f#WiRy$VSA=P4tZJ_Y313%`m+Y>VDQrT!I?gY^@g5fZojN0!vgt z2{MK{V{jSqJb-Deuw)~YYX}ezUs-3)&mp=-w2w%pmO;Z7xr6&Fq|q6%SDy;ys%ktS z;q;ZdQejk$`kaJ`DZre=wULyFR~iVrWk-M5Sad_TIYy(n+mToy9U>B7OfP9!ELvly z#6?3|St!*>avBBCcMk8_?w<|4bI zv09wVW#4$DNGBT%TIP0^_;UBAU%ApBWS9cM+B8J|a`2Z9q>dNBvD0ifAfBJvc&hN^hnZ&QS*uTtxdCe zk=?))!>Pt!vZmX9c~4gUk*V+rrEDev=U|S+Aau$XEF7F$;*FxVTD*b!$pLvHu{B?;3=Nhl z;E0iUo9d^#@QtmF=OPS8e0r=dO@q1z?^fuRQ%yGWx~H8;NUCK};vxr$~ zOth)sU7YjbC+7(c*v*U34o!GzGMR!GSnl0N#J`&9#SO zo#dPs5nL7DOq)ZJ-2@U*ssg&ynhUDqsQk)z%zj|CI)C4GPg%}ZA%C9dZHc{=>xXMQ zR$UWI9WD=qpSZqsd2%Q+To(AzR@&KV%OgJMLUQ^SM}lSUSk3_hch3ooS3bPI5nxG9 zoUdwDq9w?wv;w5?8WJ;hf#~2)Oym2TkGg6Z|3JFVJ13MMi$6_{!;7sF+={IKJqa)gzR#(Pg^o9sEEg5C5Q374YDV)4`6yU}foa6yiKKE0@y zg?<%--R6PjF3>D`GoVspGD#@!+3e zS=>_TM!&~4Du^?YALJT9Z<6aq!ZwuoNV2BEB5Ok;KC?~L;i0y-rx>FXcXD>{;$AS- zjx9c^)o9rnpr`JwAH@#(O77X;h2AWry=gvVb{hRWQ3iHyxwIntHHJ%2!ZGU`?ZA9o zNxe-fJ?_>yJ5FCX;|n=CXZQIY@`?(g*e*p76N;{$9k%?~#B-uFRp4Ia_=(p>h>R%(4DluXLIB3KeeYA)i7bz;SHj( z`mgMZwgEtzdWA%bi_NVe`mI({HcAhzBRoNml2Lm1V-Wq zjvQy|O8XUf3u*hpPnJ25p}Z3OoTF`R_ek1{p zgi|zCPOR{IUz2?#AC)z?@Wtb3UJ~xS4fzW>BwgkNM50+6{-c9BoG~40n5H_h^K9JthtEWhZfsTiQ0uO zHVQb`YRu?O+$oBdrB~(GKBbn%ZLSoAmdkIP9C2Fp`Q`C0sR2a)#_dsavWg+IA+JuO z(<#vS%ii@xpD1-EYQOiXWVE&lg2M`%Xt=Q+#=yKF)8ssoa_sI~zy$@%rBk z>S-O}O4k?c-h?r=6V(XDl$IlPIxun^H$D9N6o@`wAdV$M6fGI~!?Ti815nVFoUY|0 zGWu;aa|V#@yFp%_I_9>;fe?+1;#tvy_S4pn`7EfQc(lETO0+#WnF)sNCJnO~QwF}0 zJBqt?P*JGUco9ui=%<3?$r(K z%-ctq%GeZWXawcV9wq$<=;mMrXJ~=>)l9X%mq&Y{JJB=zC0$Q-y5%75IlE#Mk^?Pv z&wB!Bv49EnT@SkTdeG%W`a{fj3}ElHutm<=pz~*;RbUZi%)9Bk`lE!otZtM*_skLf z;@WE&5-u(x=WAC_>En`<)47E>ZSnQ;?KS-$-5#|tstTPRopUKI=19ZliHqFy1fNaP zS>Bt|C2e1P#Otir{Izw@NSdC<{j9+iqGTIa0{2aF=_T@a#_6Ld_Lxf2h znNq=)wS>iuw^7G+TjIUl!tGRWX`iP9Z(vTvMoCk$nx*dD_wIEVW4t zC9dfE1;cf$dmP84~V^&%%sIXRk^8|d5+;0*`d}r!$8fh*9|BXsw zKt!NaRI_`I)b|o8Okta{KmqKTx2eHJo2I^}wY&~(gp4Ls_JV8(sR+_n-0l2sM8k~% z_A*oGJQ@1OvR{Y}QRJ6R(BITpasIBdhKKhyOWq`J`G(zHWwh>=)fk)euln#qhQBW1 z;0es!sW)S}=k`0|>YYw{7B^{cZN*l~cUa_@^j zcjcv^l^1uWq%-bRZgd;qd?y?K_}&MOae#f{wYo2gOH?P4(;)%c;fsW4A{Qi-qm?av z6Wzk(b$R)xky4a0jX6+q1u2~nJj*wSIQ!ycjg{VqJGA``tVcrG3P@kb+h;uPvz^?G zbr!VvEKRIm6Lk$LUj-&uNH7T5e^u4O%57iud6t&NY2M)bIM6HxqUM+3B_>PHS~ZK; z_rkOhLQJ!0-H#^y;jKt;bYs2|vJhOSK5H^KoYeoSIE7zXR55s}#^0FtgJgVJ10w;| zM4wFw++mHRCFr?^dnfJfdPNHO_-n*W7Kz*nK73G8My~N~4*|U{B5}--zwc@}$^AJ* z&FtLRW90nRUGHw_){`%gO6{4mtn)*83V}zyo0L-jTUqg{Vy64-Zb-XiCYq`e3;qMLvb7`age1F@W5*7!Wy^hvn6Cp(+#mz=2g8r~*+|0M{h9+(u z;Hh;C_t7^pMR{|iSkUbQrut&W%v}{CCn^A2RR*e%r)F|?bVgl}gf902${PD*X>_b) zCdY=?D+^Jr-jC!Ic1cT$k?p*Hjd*lMK;Aj?Aao<1But=v!3_9v?0DyMm~k{E1N~4w z@`*wPR1;D#1fwI(BXrSE_t_qX9k%c#VlRcoMiR$8vzf?rdD8l@mHKUL`p(vSMVa4` z{7S!MBxkR%S5c#j$=aR*5f8i~FQK!4=UF-|8fd@b_T;YeOUu~G<1J1fkSY~!@J#Kq zX0ia99L9jfG`fxSL;qnUB-3%1FS5Ui}e7{zdyF;!crhnr@034|+FR*P1 zk7B&zAr=zk{K|8Z#j%F7xt4O@@g2{6OLfAw(OXUdEgUxAoWO)Lb#FM3Qs0O_$fUu# z&Uhc0xC|dei@Cjv%Cjq1eck(4DwYrA;#(&}^KXDbwVsQ6BxeSj-eYwuJ1jXg;5Lf3bI6w>K^BB(^C1**eOTf4^yO>3k1b z<-2fBY^wL#_Ox#y1g`SO8-KGl-0<9s*L3>SKPuZJu{N}7Blgznd~aO+kA%DJ9&wwN zH*jx`pXT%0b#*17%c;)mXil%_|%|(VPx-kZR=j#jOqPH zVzxZcds}ZOQ21BgW80Xnw!lqi%O)^h*gk*sM?q8lRp;+f`nIn+*TsKvFgI-_G_9FI z=FI5564dAUfFkjVQeaHe+|W^EvgOA+DdnX1ft}kIZXLXA2SFr%2zc~ZvW1>64g1fk zPoPwBn03m!J6UyuhpPgR@Er8G5PGwT89?HMR4WMx z>N0R@)`?{7ZqY{(H?day=B{qkL)I8&G$lm)j1Q!WCW8FAzc?u4V~v|5W@;vyYGlGq zKPP`gbR)kp9*d?DCA{0wsQzgRz{UZhGt6#n-)>PR@XFgU&hf#WX5J9cy$M}(aHF`X z0-d`LIAJ%wvATb-7rBo z>Gx#)6+jmqQr=Cb3~W>@W$sZrY67p=mw|FyVhC9g@>SyTt$o~;+!VGfU$%9loYtfG zV70W!LR)T!A4nD|KbCQuQeMFdaWrOaW3L2*i)U0TF0)IwORY*{0m^v^7U8Ou`A)Pc z0^{v;)^tZhInP!iuRu+R*0->(NonC2A^kkv(ycvqg!O}}A{=ZX{8lg-ZdTkv1yh8m z54Fj&$g4>Aq`*0fDr6Wr8itBqRyLK>dv4S_u6-7;Rmix^B-u>_!wUnaa*hb$KGQXl z!BqZr;y!1jwGuAGyHE;KoRJAE3?ea#9vHU|e<#aeezkd(C7^Zvh$PWGRSTu zVrIBlCCTbgfkc1o_YV$-ypSD?t{Ut`sLloz-%^t?iuwfz&;oA*_l2M&LU@tqXKW0H)8k!GI1NE~hK-OI$02NLoFZK~zm*m-7(@};PtmB7l zOiFwxTtG>#dP#U`Az*rLX(-4IC*aMGro4(v8Pof2$6#k*$6&JZGCE^LH2ioxc@*T5 z7U9<`a4Fl)eI|EdQ8TrYpZ)bgkTM;%u0svod^NorDiZ6alwSC1p*ef4cK+yd9^am- z>S7a8fTjdL=NU{A6|N)oyg^WGF~H7aEhs^7@!u=ZMFVbe?wCAbq-boo7+S$x33|qm z^an|=ngO*E>5%E+ng;KbL?k4re6!zVHSVLwjUF*<>@&pFmv^?Pne?mPnBe)NzA-LC zQuM&XbO&Jiw&t31C_r#};_y}A6=Gtk5qNR)1H*OgD3Ai~Q}cs*YOt}H$BmK~3!-y| zAQS}|2z(X7Vz!W^D8ymhgTWW4f}6?A*OA7rMG?Bh{3DzAga!Oxr>=SviiiMe#Y*a) zEdnCD1D*-T*H(rs*FU=lT`0h81q5IlSen1ntmDX;7|l=SF>T`!Ex|w_R$#0{B5X^{ z00Hu(pFIBNAEvyR)dRJL`nP(~xf;^ZGLqm^Yw`LeCW2f(wkfzNxUMEX6L(t-Ty36;Cc&o(WKz?7P@klPB-7Hqvnko*R_;E-ASRyE3ag*2 zubAy3+-HM?yI)42-2*wEiScZa)cQiX!k&UmLBmY?)3#&f^cDAtdm;d9aopM%IPuJS z52eMe4uD?34m}x)5Tid4u6*UBdSl0nBVP*mQ;@>XoSv9atbe=(3ct0uLSgErLQyMEYjO@8(uyN-bY#2elq=Dqv+*^v zcBC_A5T#+^WNgzLX;QVNWF|GFoTto>|LYDQsv5u-CAjDsw^+8Il!ekgit0B^a044Z z#AzexfTxezK5i##Cxa7nifkeq4$|Qr$H&0MFmuCZJkAKE*p#L(z7fm?w!jSt?@esW z%6R!?y}WZua)zUNy$d7R8~f*c@-?U|Cd7oB41v3Ff=hGQ$=;xmNcwS&!9GMwqH}%5 zA3wUBCtyRtF}3?x5HaJJ1@D-aL4=o8s_RY`S&CCa|Fek(7;{V$Ry;H$IB4@bAKGv* z(N{>!{=wMO;%pfV2~{ARI3SWN94!>?-y()YHcBRLK_Sb(+V4p^--PP93EK(g6H>`> z5ki}nsv&6BLd$jYlvtNPza9J2i`paG^Q>vS*xI-8jwieFNJ0Gkq8!HTM4{ww$)p?i zj-f+`_d2b^5p%Yn((&wcY-2r0!;!Xg8%({2xo5v4q`&N87>M-9SR*K(g|3}S{#uXr zo#?>V$fD%$3*IPqyYVbojA{ml$^H=dk8_=U87_n0#Xs%u?rSA5Z!ZU9T~_MKrKh0C zMONrAEm+jWR=(B1@3WEJ;f0OAFm^7dYtBg^=_BG7J|Ii(Xc&X)AmlKUh+!Akz(1%g zxIx6|n$5M7sX$Dp2~I6&C32!{LN}LkMNeinZKgc{3O4`mA~=c+#nDpQ z9>Qlw7bB?HY9_1^1lb4!DfPI>lIV;FheB^jw?bbEHQdcLI zHXiL$kw#}@MOZ@evF6W<`S4w~z^%^~9BA>B?_>FS?nt-O_||>kp?kUasOxu8ECnlx zl)i(lp%7em$9olLcd@5$3?7rt0~|G2NHm^hH2h$3kuswOxb?Z_`mCaya!Ohq{EJJW zr?}Wu9B^fh!naawJ==fx@gS27*nbxnc9^v4?QYOkZh_1nrCc@=WDdpTAXTAMSQ*ph zxm1zfzHx?rUX(>tE4~1S_Q!|8vB6rV{(DilJM-k@g>Ry2GLivpnU_C5x8k@P^2Cd$ z@<%>VSEsiA3mo>hozgJ(R!stS&OI~(0r17{e&Fq|j>xW<-Mv#an_d{^$%gdBv*wzj zDiw}%ho1(g!IC@O`p;#(J5XwB4wBS=u<7!&b9t}rH{~WtWK3vpciKn z+p_WZ!xDy~Vf4vQ^) zsTCVy5JS5?^gT!8#nRtFKgLfq!W;&|qXZpNiP#*0QZr|@Hj;LzkG98uo8p0C1yl7l zS@OOFn0t|+juA>Fhvh5n;}R&d!9C$kJ_GaQKMjIMKHnsi%}pr&oB@OM_=nrbPealh zetd@w$YP`I+o9oI#iXziWsiDn@*b{tzX~4ej1S%tajtT2mNcJg6+wr+b}9W3aP!ZJ z41EUwoO3MbM+rU6y>ewTW!~hYb>fV;} zvs$mtK}dQVy2$2#x9dC!f)I6A7YRaTW&^16KjB+`Rkh20!&{c${v9&7z-eXTG|^!5 zGyBenF0w{^oDi}l>qF&mxwUVCa|m;jvAqG37#?j_eA&5((oEeb zBs?XsTDqH3Q40N}9NNQ0*D_CRl_2>O`l)Z}b`pI)qSr`IoIlnUKpNHIAPePr^2Dt4 zrWAO#dia|vmG-y&ivl*qXJC=MIM@kJ142y08;=|+nr>iLosBgNIP4v9_%?877U^#C z=%PjTEw1Ohtt|dYPKbGWi`?B2tl6;SDZ`5F)#NGIg)J;ATo3b5PAi~A)?rd*r9l=^ zZFFFq?>ROO`Cd8=a`K>w#P!@&ptHqVKxr<=kxfN^ZNW5-ueM>JmZ1pg^8o90EuKbQLdUy0QVe8{ytj9r|TF} z%cZZ@oU9xw?V__9C7-I7)|2~DJ!F?Ad8kOtsZBAl5dOde-c)zJ&lFO3&lQ!O%r&ZE z#p$O-pgZ7+4)4%A4+LPF3A@FxHvgeiQJ(29}yNtxlR` z2dVv4oA3rwsr){p$5mrJeO4EJW(ZTg(>{q>553P4$YySBrQQa47k%nb9u`75<&&~i zh%auqUR21V*;>Q5rkhs}uhPDH*8X5Ckzr&GZt8PgNyLTg2S&CT8Mk)C1Eug7pn|p* zs~n2Gn@B65>UA12We6PR)MuoP%YKLYz}FIYUBUE$GO?9!-Abk0U$xJW!jy%Q*laDx zNb0uFlb$=(VF^s?+7N(CbHG_a$Y3#9v9+ltoV zr`~KXpY;cgc;{h8s$91IIImvR>)l9=M0ccHFBXRw-7YE*kV^;47GYz^enLX1BkclAuh$U5=6+i8s} z)=*KboQ;2?%mTigjNHoxZFR?&Mk1p2aim+`2-w1U3k}P75~LD?l8ItnGXQ2 znBaeNJ_I0nSe0`=p%#imCzqU4`iRke8ogB3xgvNxsGt0+ImUdgnWaFLvy(&+TV6=p zYMT56TeqyjhR)UD$}SGOe)b}W-DVe419KtU-pfI50eCY|X^U$h2Y{n-z2J?X2t7zr zi<@nEe%wM>+<)75oYR=rERk=ne3SB}BzX=F*BEI3gUki}?!!$Xue>(7@59uh!7Mxqdyu6tG|RF~{KYCS-CJB3;nIkWL&T%}mI>s0Gy;mRl;{ z-)JcW6o;Q>^bPhrVoOnAUjCtNaMObjY{H@b1hl1h!B5(H##5$(yBe--SH%Cl9A#Z4tx)f{#@qz%wEq6un4eyou##Cy&u(Tt)0mkyT>gR#t}$UnO{f1lOXWp`lw;)}uyhnuc#T`7e~{D7I<;6;6*Q>(9bDmJcBFgHH@G$_OyNz*(?gN%d?LejK+ zC1u5=98vuhs{@E}v#JKqXxG2>CEdv$Kru1JVx^0|g@=uJ^&^4B#7|fAQ=9*>zeZE; z6iore46{UiM9IZtDJLk>6F*T)stS$(0P+d7I7tQ5XT(Tbl=dU38?{KiQCcZ0A>DIH`&nhUMnxt7oo?bA3Up4fjhu_d`pL2flj z`8i`5uLQ4-g0|jI2tY}b`5~LsvK$Ki%L$Z;2?>ACVmKJ`oGnfFS`~tQrgKTB08Akg z<)MSTguEEa9J52IrN$`zA^4NlO8G}64dM5g?B^p#2uj?aE4#8$)xk;Z((~|vNR>KB zL@PPsil9j)-SE`w4h7^8;l*G31bS4XNc7K{KO@%DvhM~73U|`g4a3Tyv8@Vzq^LsM zM8k&@UbNLPf*GFBBU^?{SOa}#fa?$T%vHe2Boo~6SDob*MWU5w zvqLQ%C#R9*H@ zRDyykWnn_!?9lQq^jBr2DDV*hN4Du{Xj zVrh%yxmYL>(zgawR}(pxB?NO$Fc^@PpH1$DyRe;ber!^(v`GjJcy!=?hI%;ocAsNT z>&pqG6-?IXzi!xOt%OXcNdp%+YLUZ1=~-V;UyU@T-u73i+Bb-DcO$LmZk_nR$hoo( z63mKzGQ)2fR_OFq^+b-<;6O7d{zUXO%}sNP?~$1P$N9oD9VDL3Ge++LPhSR z=bflMH;{hMAxiK4Cqf!8Li4Vq?aQzpx}#<-nu1VZP!Ozqre@|AmeN*STwENST--do z|4&$P|JTR>3opOHpR2FLf$#H8f#;T_f3~6ut|4E3qCTL0UWm^<7iR{ZJCpjgqV`;c zrOwM@A?p(PHEjsVu)HS`wFsvUaAU${Fh*!Vg1xe(?g~>hO|kkwfDblFa5y~vAHoR9 A#{d8T diff --git a/src/Nethermind/Chains/polynomial-mainnet.json.zst b/src/Nethermind/Chains/polynomial-mainnet.json.zst index c1db2ea82fcef0bc0de14cff4fa9b9bedf568a10..fd7fd46e0995d91edb75d4d406e92ac3b3eafd60 100644 GIT binary patch delta 8955 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

9v`5eiWTP5_i~e!S+{5@kzNTQ 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 KO}7|L0lWuMZCIoL delta 19335 zcmXthVLxmfG%UKd?m)xF-K zddRgJNPwn;`4e16iJ@5tVh}VIflh`7#j%qD`Joop)HH=b8ho0u(` ztUP@U1Qr4W1SApM3X%qb45Bi2Og)IA9-r@P>MUunq@${4nJuWk0ar%`dAKgdTCzy( z{{!*=K@n4V)Y1A_Tj?TAc@*%!l=L6{FCb&Dh(FjJ>n>ZvUy=H7KGt8BMLeVQ=lW

OedDx7a;n|%r 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 k_5piIfZzYW+`~y-1=!B_AOAjr82|tP diff --git a/src/Nethermind/Chains/soneium-minato-sepolia.json.zst b/src/Nethermind/Chains/soneium-minato-sepolia.json.zst index 43586353af489acad86c6a2fa0fe94f96d2ab4f5..3713d8a31cebae371e4a7a70822bbba228f6ebe1 100644 GIT binary patch delta 15712 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 delta 15043 zcmZ|0Q*b8i6FnH))*IV4CeFmRtw|twfj_GoH||IUDeeW zr>pw8y?|Idh5%AGGkt+;%G1{g%JzW1BZWv&qsTRpBkxwbGjsfco~YNk0QXx3(AM%6 zt`X^AlZeB}@CKBDfPnN0|AAzLpoUn`8%62Na94k%`5z$pAHe+|K>Z)sV>E@)m*b~< zx5Z|KsHM!o^Z_=(;|6G;&qN5W1tauThFgdeU5bS4E)6yo%(#$<-dgW#&5g9jk+^f* zRh_E*FHipe@^r#`7>R^T>2y?}ETEA($_-+Cr8d}HL*}`F!4$S==X8+C1l8RQD1{1K zvLoF|mcTQmn}1-jFlys3)U9Vkl~My&4~#-><$NwnNCy%qvx$Wmp_e^wIL|9AxIw>$gkTvVlcX0 zTL&{7Sw&dbQ%+D5+~320;aDvZNnvU8nRmgGLSc}I*_l;i=TXeOxKM!uT2iNj6A(~+ zd499zLtrhSc)hnE%GAB^<6r@hAby6k0hF4<08LU`*9>d`>>TF^HLHUjw&=E(*mAZP1qV4I5C$92WhenQ~V^LaoYQDyh71E22=%SPtI02`gy<5X970|2F zUv4x9S&&DA&Dh7FaiwbqD#ZU+^B0pP67A>!x*9dF4?nJOnL@0n42h9L92hbIAru{s zvLT457V&GoFgUoGn%I25VWCghvY7~th)jN7F&M30`bj_^5Eid5A-7oGn~^XHhGj1q zC>jnDvJ@(cyQSvt?k^9&JTN2_RYQN!|K@TR2*O4G_pc%`gr6`7F|np02n-=R{Vg~; z1Uv|c{{Z-ZZ87u@o!5PN;a*=#C!fhq1h)lWxJlwHfQp{wOZe04AP?! zMz_Mre_7L$t@9BFG76EEb@<7jnjGyKUPApv5IigtLi;)UzBNn%-mjyzgQE%(zG4N& zp-@jcVVx)o-fMFm6vZMmmE9VVJ9ACI`+>W{tG(B&SKOF8B3#_5?!;&D&M<0T_F>Y0 zESYFvcY|qDaI~sNaET79HVR5&sH@eG_HBIbd`ce9505a))317xs3RQrJ&qx+Gz|U1j8Ml>xbyqA;%%%2HN!gOR(pJJvyPp=4``C4&M0YWFs>$nIvAbd z=A%L-(|czau^&7RnHoVet{B<6!h>VY7)nQ@mA%*wqIwb2hGvDh?bMvwrdS83Ma>L> zJsvB%*6#rArJDlv$t!OknEcICy5U8E^iuc-{8@P-D;DT9h!qF~yb z20|@;BbkDUXDq;Gwr8clPm4Kv`MjQWe$1Nr2Fiu$F-cLmgZ*L+Ky3_&TR`-{hx(ut z&^`cl?oVvwR z#(c86cqe%`sYJGr3aJK=x3XNcvezp^{2=rYI(iBi7JH~qncd>i%&8bg zlJ5mD{p;Q0+}iXkX~V@{EX`+Xt=-DI6&mhT^v7hqLd8T+*mxCzAxc*hqvy5^r{E0Y zsdN=>yLi3`Lf@?oy&tkHchie_@f#7m?(Ygsc%q zRIrCR+&-xx&y(RV$*C-s97nU>88`7Df~!jayfq{PY?k`Z4^`r z1$?WjQ8l2f4F4awCD6nrWW@l$lZ*dqa<+R)7tsL9N_wb8is1M}M^{7vqE&OG3bC&u zWgddz#pmv-D5)+2ZDg9oM##N#;FPz`&u0;>qfr5s4wVK=$ak^9!S@clR`5Ppk9;<=64IAWDVrH4n zF-1VEHigz&XOZ9vv|_sWAhIV{jHhl1AHj2ji$h7JnwaW6O&P zlTHVOXn`~C7;im~HBpWsF0zr6+`{FP!2@8EdKl5f`iT@qcuh=zWsNxfNq2UeUXtf- zty2ak!_x1lD<=borBX@WG=*1J5&uGHKFKp~&h%X*?ZJUD5o>}l%@C+9VqP(i=^`oX zdZu=1rer>vBo|oB1YyR(I9dkps*Nq5;uyh8*Kr~%WEtR6 z({jXPWpwHCPEHC8G*CnO^X@l&%;lG5c+$w6Wt+1(U;P)|J6s}*w#Qut46Cs9P!W&J z9|?6#QZoo8cAAkMHde8lk>4l(Dh3hRx+t>QD8AOKV!jGn3g!RVAWgYd%tj-eohouT z)gJneq;7@QJi@^%i2iiMJPIXXQk(;Y)_ABMfL8X_<4aDRQvwVONt9A+vFCXe_txjK zFPE1%$&O72!)Ee2$K2zS(~ov`9oZBU>JL6PP0}(GGKpqq>-Y! z!_i{qMHzz}DIQKo!*|LV81j!T%lY^2h z8e!qQSm5+oQ&7S>XRpSBYT_9=);PI2_c#1-qJ1zC!6A=&>frCh^)p^F%{zcbyF($B z-u^b`dY24l5g zNO=~fQpk&OQI~{-={960P_bMaq-b$fu7`1b>AdQWS4~T7z&W{AuA!}jGQ6V z>PLZzEV%|E+W_sRLa+*jHBA0olvXf!u3{Efw+JqoL`46nM<9P^kp zf$TUtJcUjT3T8sm%#6KsMTC5WBH^-k_33>`q!c0xmc!ttTUtb#d@$vDQ;Hmx)T{i4 zs_qh?;7VKDftJ2sUJ|%5cOb_%1T7>_#fw$0T*TJpF&WUg=@PQ{!2G**0JL%qTmfM| z2tNJoVLt-)Au1+jm&aJYl5&P6z7Yr8L@$T!IpgXyW-9(_-N#09b~@hj5Bc>7E9;4_`#X^e2-SY&1WPUu{?Zwja|7TkC;K5k^W+9 zO_@MARiuRcLGa)Fvz-P`<&v=yUGI2V{gY7>0iF(&Re#t0 z<_KsiRDv5b+ICatx*`+r`soZ9!&s<(Q0>cZeJSTE^z;#kq~9?z?`*q7C_42XUFU z&5h{>?bG!Db|&mvEfZ3sh$@@#%x3Z)ZA|Tv2B7wcS@q6r!^XC1dQM97sOZvHysxVz z6p47}j0HkT5imwuG9$I9YbkY5IKN6)Qx>GSJKMa8}p0WCj6n4;ZRj7YX&m@ppJ#UNI> z0yr`xzujyI-FU89bZ+*vwpqZNBkyuq6;oi{2?0p#)Vz9B6aUm_$~qv&WZyh# zMbFUqndK=N8ux8eR1rBXEB?^Il5=U18?kpbSEq2<{80=j7 z+bo|nIaK>}$@%b)DqatUbJ0JIhC;3kZD5D7#~5+pm|c=qD)d>{4y&|Esket%X;YGs zbGy@`%0x%y1l{#?pg2@`{IY|lIh7AkD~jdF)X8@`!){mP@2-zLPHiGWhq;R zUizsjEnGw2g?h%AJTE<5rebi^wsKlZ+A%g8%|yXi|vo z2SSa305fR37p7UnD1-q5?fRG56)4Ca7iMh4je{h?f-s_F3X3tL5;$)~54Qy*lZ^h_tobW2t6HjTI{GyzFi47*TPl;PVZ~0K(T@mRYBemrxJb+4J+OifuS*k`6j_QMfo>?ONlZEanLk z>=3{UoP~~wW+7SJ{{7Ee`JNbxp#OkB?6@W3_{56rodx#yfa5w)pLJh2?;_*;Sthm+ zWixb=OwVr+tG5&U6`PGPMFNu6fmRG1=-oQT=G`S;X(#y>iJ>=X!3f3?soceNwB0on zkkfOOJWFdqw9`T<^Ck#VuczCC5KpXP4PRC2$mn)7Zm_>}ejIY|!2bU4gBBOEED^(b zvInAId#^mLO^*uLg?*gGa9S;@>Q-L#m#w@-`!mR4+#S=*NByWq<;!@qxa=}Gd@|_U zF{C194bBSi$EDUE{$X<>WTaQ&$X@Z?P%bR$m~l#KFI91`vnWD6H*8U+;#mv=a|mOD zq%PS@i;h}ymj#uOywSAlP5eeI z@3vdu`!+8kxHwE+T7d6t5X{JP+A03X86^J!dI4JsS7Du+E~`&&GusR|Jw7k7!O8rl|3K|m8LVW7@N z?i{RHRE|4ZbEvBxTSXPeK(Ca{C)zC|D$_GglyAgZ=2efmzw_Q>i#hhMfb+%^&+^F| zilICpD|35DlN>>r`uFS|SNdC-lT57}kq!Wu*2GzF+TdA~!n*&CzbZ3viy3&DtOT4U zOb(o?LGiGBK&2O;0&FOkjxyu6co&#w5TlZQ5F?a6H}*M_f9BKF8HZr+?vfg(TCJZ? z@YHbWb+SIT!0g9)wU5Vmt>-%r5YHazjK0=&_#9^Z(IB?CBk~O^u44LU39Zd&?<57Z zkd7D?fHql6jV{?f)+{{~e7-K@(wx?6uE{JwA~;G%d9E3`GOgugZnu|YOl3Ur z?TI=z0RQ;0Jtdwq?O+e#$=r+hi{AxSX%_MVTg1pb#rKZ?`Sk<3Nv?nAD@8qppOiT_ zJDh1qvV*{T+r8C}7p!o+QTkm)eT{!=7rPp)5@ZK0UuP-BAn9TN{Lz;X-$?;(f+A{j z;SA^fnT?3iVK9W}%pG7@aoV462}Q;gL9tDfkgTIkL$}s+*(G>DDl@CPp;m?OW>uyo z5M}zp*B!4N@APRCT`CxsvfdsjlYL3I=pcrE)w+ zOOY_lS&~Vs+2eG|he-1Rcxr($-Ec{IS3NQ8r`(S_F4T1-zM*UvqVz_8UrgWx4f=$A zc(@VaMijmEo2)tXHiO@0eSu3SuL8N#Z}RaK|GqHa8r-k|k@YX`e<_^tT<}qwoE|q| zhq)bRp|)vfLtB-(0BD?V?1#{H3nI&Jzw)}n+o$~(oJw!y-@5qlk(8%fBofllPHuL;+qfjQ?u^>qpNpJ-RaAS8l=ksYi~f5R*0*X7 zD#M-08q4B_fB>hbY!op>|nm(J4m+OFmJ5PHu<8 zC=44!-oWHuQT3Y<@nctZ?8r7A9eV`i>@r?>8O(nm1|W%()HM!-1JBPE6E6_Q7+!Zg z8dE-w`8Bd^1rPEPq|P7xM8gx4MUA%=P~oi3t^A`-$ad8l>y6bt*!3%L^G&*Daii)R z6}8}2rK*I($Oh3JyHYP&ATAaCiOEe?XoB(az;F;=qbQkk=B0DPA#)YNrJd4fWyBX! zSH3`;Z}?ZUvvMSmqtw=IET-&z8T{NvLPhs6Ob}a!)V^JsP?6Cg^APmg&M_qOR#rxgzPl0_KO?jQ%&_3VW)ZPkjAFTh z=@4fxx@5>GA8sujeqy1CcK3W2PD2TEa11`?qCN;+`lUR}?Xe@;j)+@+4Cw2Vtetj? z!b^4!N*&X1>cwBGvoG9E=KCFmt;o!3-fgZrGCVgln6|-{Hor^T5TtO5P;0j^(^Fk{ zLGbNMz3dFkJfUu#hz*{aho@Ix9z_lXrtgcC^Ce5vTr?(pT4G%W*t1P%xS^3pknzXP<;c`$esncGt*liyd6zVGGN zadFhlQ~6VaF-;b};P>ZTyinRxRPyyPtfOjp7nXrZ-vNS)1Kawk_)rC~5rww%x{=BE_E0Rt-J%^Q5Zj4PP(qp*VhwN4P_P=&i zlvjXe(~u%H1~LiKv;m+05XQ%So4v}Z{3(G^BtvzqSZ?X7PGmviqvH9__P*mr_bm<6&48Ye#-qF&^ne~m1=M%CGi$_ANjQ{6yu{P% zB%@Dx4A8f320H2Yr)R|Y9u(3JMW=DRS=s@!Tsw8!t?KT>EBT?Q5fS*Hn3~|a2~9M`fe~ZU`#CG-` zFaz6Od|2wy*~0Izngb4F9WTCL=y_ZCaH@=&}sth|#z*wL0I`vFUUV6<15DTH<^=17-1C&Z3^+MghZn zr}-mE;sG9=o7|D#1^yGK+t*SEq{rbY>lOLqGeTXt!>4r^b;Wf8!Qb?;QX@bk8l%;a zAPL2>KjmR;T<8nwh0hX{Ll~2#%9;@wd}+3*sHZA8k~(mU{B1w$WY?&=+VYAs$x^rv zT7VT5oZ13cn}`{WT1+uSolvZ(w_{&N2a(KrSnS-bvxx5u z_?BfuSyc9-I8iHz;rg9UNDm-9Nn!%!A`@D2H&3;sCB0I5)gF+}_Z;LO0X_QzXZ5J}$uB2Lo(2oU3(XKB z11qsT7CgfAT4jMxpqKiJp-VW)1mSNaSuou(DD$Sd3B`~qizw01%q1Y4y%gpUYj%~` zUxKv`k>Quqy0lW=fF50iM|l_z3g*W{IkC(;xgbF>YOzVe8~O;mfYEjy_aiB(WXhFn zk55~Q^Z0{Fv6|XU9m5QK;Pr1j!WOdKCSuTl^5@kw7=D@V(suJ~#*beHySrHN*M5>5 z3%P!2znbw4QES}9!vujo1@D=rhr8wWBjCS(=Dvc{x<*TH0o>eW?akvVGuIhfx5~1f z)yUWQ&#i$jGxKF_M375V$lLx##CdamgQoY)7zk!GBvjqi!k!#MPPr>Kh-uW}V#`QN zQpY6Hi6s&=iOjSxW_jSll1yChIx}7e)C z@kfk@^o((2;pRZenN9P=?nuiR?DL2={0_bLdnMVpvJs1B7;F#a9MTIf&wu308kCfP ziL3Ca3TP6v#R;Vqxlpt)NEj|cGCOd` z@EAbOx2)TP{N6sr(rouSS?5q|L0`StT6?I>M3&{pjx?}+p|6J2+1E{I9!mlr{<~a3 z>DzoY4Mm@UX>3*hbGIFR46Sk0+$8-V!e*gyju(I0Gy0qzhM^K|0Wll^?>-e*ONv!C zMXR(&X8u9BmmgeyUQSHo+b8fu1)(lT+M|SWGZEO@-uBEpAP2wb%ZSG%QdbJ{ua|u= z{ula#${%3y6~wm|1>beo3Ec3PwlkQlOKq&mav}4#3A5)~;1{{3_arZ(sSUHYAcC&any0F8t?kxq$a7{F{nCmh&5yyv(tC^D*wgc(qB`ki(lU>#3_ zxm@OvWkx3DRDQ#sf_CDS@FSm@Gt{Be^&W}r!9gKT2@BD$W z#1DNsQ~Fn&y-CVoz`Tt}4)g_7t>Q&A7U(U>Zblzns#uyE_m7vXvx+P`^-uiLDYTYl(4v|up}p2ZtVh9W zX-`OregIqYUUoy)p1-t@(e4HSTg_voX})+{JonAY*l|;Hj0BF& zLayLnT@8$5Vvm@^DB9!--v36)*x4%gq_WK{As{&x)Ap3pCcSh++IkrNcXCq+>Tt+x zXl^wRim;Qrv1!;48_5aH$eWh=o?3P@!LY&ztDvhEvBg5frq9x{oL%TYU8t}xt8&lh zddk%Wyv}Iu4<@_}a%!Yz;o)`6ssi?)c9#0v(wVH{Pl^7+-Aj;MZ2i1H`-SWKSwZQf z1aDGJxLZtmHqV+Hw~Uj6#bmB^vOTx5ptt@oYdM!adHUJ?u-W{Aq4Dcak9LP?H6(9xoR|F-Y33j2ac$=`~)BGthsg3F93DZ|{1Tv2WnWPyj55BNnD! zMZjaaXm~37gzOI^zvs6dJoTQObUT2D??;>cQQ$9EkKog1I+{T&CP?64<4HTsVNE_=w z)c}NtZoyhgT{$vQNZoLp=)Wn==E4V_8cn#7=aw>=`Ya`r&(u?Ux%F)RQ`Q?bzmV^z z(OBALDHR72q{6Bp(e|4B>2Uqk31AAWWY2mo@KN=7x%2M$F{(;$>i}+`NdEpXq8T{t z;5J~IfJVq(Zj3ai!u!a%xp1#9KHg2Mdgj5JP%og42{%jWYSgq8(swpv`zF#$(BO@l z3)Y!q&4Ouz*J@rn}N9)9<}M@zq$=FIOD3H%1Mlw|P~A z?ymA?WXk9QR_*xf&I5~em7-+WC6DighE(*czZ}hG@uRm4i@cI^jLpS$N?5Lq&mJgw zr`GwzlKazEZaBN^gw6(0gnbOc@KrPoPj)!k;h@s{XaPbg4$A-ATqG5ZPS-}CvFmYpuog7j+>M_OKl7Bu!oV4!W z%`gd$CT4iAh=HCGC1&ZZxbJ<3@mUUwImu=;EWyL|lx)QJQRU`EIY%YvMb7>^FIceI z^ivQxx|Pdx(O9L)5yw>%H6<$(Sglbo)OlV-8oAuz^Cy;Ygd`x zyS{xne5?ub%6Nyk(n%eX)GH8{%r-xFG3&Kj^gaZy^}zdf^pwt6zcAklaH60NdyLlo{zW2OI06Y8_R+0!z7uA zfp@!8*YcCs__fX9XG2%|Kx_g#gqQ?_AdcqA#mc%bMC^TSL@;#zX7xZ_648%xgI}o= zJAuC74ZuT*n#s8!(h{9h{+e{DlgC3*5sFoGNMn-S;IvNWL`XmMu`oH`cyooEd}rNa zk~dX?g$uFkLimJcp{fW0J%c0`v5fM!?aWjc3Pw8%(~H%9S*w)~vopHQO=LtjHbIi! zgQA~LeMB*tkFmXzJzY>atk#^DC@-FVo2QLDTwq!->naB+9(HCsdT&akXgq9)hV_9!aYrU({#4#FN(SlForZ z6Qp_#=2=nw4`G3NF3cpBvM-7i1cn<~9d@1rxkQ?BfJ|@V1IoztM3^To_LxdGY09^v$9;RzZu>RITF#!r{tZVJ7@#&~Xv&-3omO+)8 zF>{dTjmv!@O{l3Gb58b4v@1KbA1JG|Qlq%vPp#Ci$3j!FMur%q(1E&C?CEjwC&W69 zM!QZPKjoWPX7DYasTUxet6wytqg}6lN1%i}QNOdaAUWXe{;}|A7oV6;8*}HRHbV5y z%7q#MHH|(2y0wFygy%fHV&k5+b5seR6}N3=w6_@-W2|)S*ho3E(_^>E2&6!^!yNed zxFw3BJb}_nGDvxeKRgdwz5Y81S5sOApMsIB5s_E;ai678&Sc);_}0ZLa_tjD0CQC_ zl0uaxLh7U;*Zd(u%|CZ7pf`)>zKdUak!}0u6l^nW3fLI@+z=v7>cIpQiK-#|rEnuoO-f=yfvOV1u4QYST<@<8HsoRc zTtWMk58>$|X4)I=d=X^ybR9y{763DlM zoA=1|mEWy7z^nIW&N~&+t!gA&-y}{|FJVT)>=JOcB&6jpNAb3KLV4ORlZJ-RzGu5K z`&)Ih1RJC|bK0AV1Qa?D;uC;b?cD&{>-v6|TmO3$vA`(wV8ZAi;QyNzRk@A~h1<^k zGk&iewTWOAG<~K=>LD+>3j&*McuU}S$rH4K8>AYaubRoo?Oa38CLb+olhkt$hdY46 zyFt1$;%+ng4EGD`VtOsfra(8Fm`Kyv;!Dc?{)K&qA_`7r1xU-7WnQ6eQ%)G8I|}Dc zvhLmML(vRd5vqJ5Ov6P^v!lwV`L~(%_Q&w?CodaX(V`z>)w(MYw=GBBGjJpf zaDObE0>jJFOsy@aW0@wcO>8elh0Da?NySLRM7mL>1=) zCH}^|byGBI1MK@|=rCkKa1ZcUMA2l<>lsKugR?}r{&{AYM;!!8m{TE+CL z52E;o3DhOzvwkSDFXgRcsJK%>Oof?~Jjsy-{D4B1T=QG8rqaARNmL4Y^EoSy^K!Kh&MN;nh@~2Lk z1Di_nA9FQInaf`ODb6@bCM)@?0iti6E}8H(QnKl<#4r~G~cTP6Q25mr`e z$adnp&wL8hcxAxnda2=F4CN)&5V)T$&_TSobeGzQ*aX$Knzzzfu~o0MIA5oB5YIWl z9HdHeC0C<_TL0AKQMBQP7sa(^IC4B6+;DDrV>89MfCc877*8Je;|mp~5~*74K+pq0 zl#|-^8_h;eqx#=|Z9q$^{A^pbAcj}x;I-eml2}>K7Kc!H3jg2-VxvWD%k8l_kcfx` z4wn!$Z#7zRWzQ7tGsEmmp;BGf?(olpD*JCX$X^3_E7o=eZ?AiByaHslf(YOJB3I2Z zzqAK`ijGV0#9(I(EF{J|pQMtHT2w{6AD}ak0udKOpX^yWwK6nCf;~nli;Qb`h(rwd-j+4pMCl)5 z#dTxnEp`pIsZPp+A{+m=MrnA`YA}RU8SZf)(-(AW8189LSGV!LbOq6R&(C)c5(?KD z9c7zsO{xNQ)sxu?N*y@wzif0ae4X~^P%20CtPeZLB+PsORpaLsSZUp=MZ!tlw#i@g z-)#_8X=B0HxdbeDx1|x6&iLP1yQY5rFK}Fkn))54Pn{r2e3hvEdU=Q8>;vtlu#6>9 zvWu;rUeU~jZ?eRYCGDWzkrtAIBSdMIRJuPXywQDh3}XfAL~^Az@hDk5*WaPGpzzK9 zHhkV1>v=%N7$oa*;H{f3G&=c0e^K8Y%ty{QD#O}>HS>U>ZCekGG-H@W1#>-DYTXpvQOvWp7M%dt)@>Sv4kW zBE$7xP#L@nQ5!orFI)e@YBmQUt*I=|UFs8COQ>$GRM=**M#ct}g)b}d5aZ~`En9e} z_gT{Dnc+W&5dyM@XDMv)0KGj%eB60_b<>g->(oewKi))|h2_tOq>`E@V7^TiJk7#| zS!SYa?{<2!Ktrn&-A(zDw*@$y3J!){iH*s2f+pjl{yP}z?vue`&`AO8Mq|(K#2L{QhTN!1?Pb=U;4Izx~Y^+>!@5y zMqn)cxaOZ(iIvNx!JMY7@YOySw+%m%u4WN73opJlU@zM6TPsJpxdQgzBp1p@@XGYc z|L$hO*9r(8@~(^-_X5N>VOS900+Hpqgf=A;z2fdvb(tc5%zV{u$UkMVwKuP4O}Ir&3|7=sk^aJ#g4$B%6B-XIDPVsP|H_m}x@tsO`1I`3Xa+ zEpn$*1B2zbh21zYV|)7*I%bv$+JO71*`PMeoWnl6O}N7k7#`pYGmxjKEt;RI!;$MG zzBIVdiIbfQG%vg%jv}5<*5Pa75X3WXj;3u+(Vefv6r~b!Lk2Vi+`+8L*IzOLmqQ;X zPpM@U;!|SmnVoCKzCGMvRbc@UKB?!>KZRdzz?;?0m!G8hO$bBLa)N3$`9Jmx!@6)c z1pd3vZ%`1EDa>I^g-Zm_^CLpP(Ns=OXwOCj%(l*wr?|Q_m`4LMQH&?|5QSS8ldnNr zy-18yY|#pPy6#dMBA-%_sqdpBa)fdv8hi}T^IwLWeRtp6HS0u|GpBZc{vgSIKQi{G z0oCsP*15ud8&KDl3NTun6vMAc7ePW5!jR@5RJ#f5pjy5Tx)Q!%d%&S@J{aHULpx+B#fbs-U@ziN z^tY55{lDgd`BhZM5d4O8O20G(!q#XKu&H?1jSHZr@E{K% zNWUe;#Kc7Z`@}cdq3y&rPtZ?=2J8`RG&e2KArB&%lO5zEn=n;-TsSc?*G>Xt*lILU zlh{67i-Z^=*p!i6uhnj$LP=AD!N$hlp;3B1sg&dp+xwR;eewCphgjM5(mA4 zLdCTAw%at5_2+0#wsB%)aE@291p zzmfXI0))1*V&7&UBp|t{9oX|e@>)Vb9IQW>DSSUT{Ttr)&IHKf`mAc5Aw~Wn2X8B_ z2&zJWK!7oG^B5VMn3|chF|)9;v2$>8{f}V(KaZH0w*JJv8IUbAo$tcL~lPcemhvaCevB4#7ECaF^i0_U_&Lv|mmC zs$Zt&X{!6S3U09;4q#|ze}&Z!LxZL&et{AM`Ef8~+0un!K&4f#Pz>~J&kEv5xcum> zKp|x-)qHNrpj=h@Ub+gE4+HfNXiHcW*bW$E8Wd;}vBUrqGAFoXe)!mQA9Eij)6B@q zWc)~~h`8f`60A3EBN`3_4orXoGN#;;w2i8z&@@GGYwh9KxOE(r$3{Uay{;~uY;YNo#|88axmIa^1M zY8MtI4)Gd*C;SP85`6V$#X)3c7u+aOARB5deM-NBi)^akv;&juB_3ugO;H01KnxB+ z42DT(j4GrX>YyAA!t!U&tkAlw!uLbjC_XIQ2LHx{i{B2ppcH?#z(#Fk;U@6RY1TpC zAj)$HmID!>gf~bNh<$~3%|%StAyPFhnALToRCeux7>}5tsMg*wM{NCBtY8DCwg@FQ#9>y$|jZMUCEkc5X zj_B-K22IciauU|>C*hyX*oT6Rf`!8ogMvcDM93&o-m7HK$qz!RMXQf&Y}yXx&9#>{ zIS)_>|6bfPKV8(>v%6zeR~93feB1Cy;%y?-v6&oYwvw9qr5#B@r54Od**Ty#G6Xc2 zxy62+ORT>xC~RP*_gY9{nGBL{>!`{*eOhDo?>XmGcR$}F+FEiSZ znOHVoM`*#ro!pZ!ITDqCH~=;xbE2S056K88hEGDHzz7L0AVVLJHNrB5GQ|%~xW7U$ z4JE?GAHG+_%0fo8ZVD(>jO~p`EzpO zn_h%eJbNq;dya$*&l2aHop5UuNiT8<2Fao@H)6Ze=F(qcxh@?!uRTt_oEA9DcKtVEIEM*L{|$LYaEj``fkYXCCGl^( zz5fIFr#Al6`Jascc>G7>KivPp{?Fyb|C#)cGUeq|Wu&FFd&ShGEOSzlZOV9#maGDV zT=M-uj`7Pg$yX*B`D51~Fj06=fbje`y2sM*fKsMV)lzFnIgr2KWoMIMu@_7DUN^$mV|4#QB$+~W98 ze6i{nm@LSgMuQoZbl2dBUo(sTED^X=%B(=jd{Gzzo$6;AI&SKaN z_|YsEY>9G|3S$R`a)j?oYmnV|V5C3J?xx91j}J#=#r}Zad>5mdntOb3XQ&G^FzWy_ zz>%;75Mz<@eVixaDj289^5XvQzX)_LC!71tM@c^CbN$XILb^5K-bHG0maJOlmf*VRyzzd}3vWUS(%Sr5-boSUsv+$<>>J z@&TC-pDCBcb5`}b*t~ED+%KV^$g`lUr>mW+zOS5Ukt#pVCdguE`m0Kniw;q#(mGX> zNXvDsQWZkiRbh7abFW4|QBEhGfR9`68|e>DaJ@-|>Aq<E#yOsK-YVLBiW=I;H;l~>PAy;7ZEc9!q60wLTc;O?XRBX>P zU`^zO*Wxwk0QzA;mk6E<3> zouH{q5Pf)>*PTd6%Z#ZL^|AF!#xoRUJ6o>~Ra!Tj8S_}F{i3Ho%{f#d`<|rZog__l zkhgV8e6A2Zj?XDk$ll<;HlcIID&s)&SLJ?ErlKREuxIyF-d3?;ciyCh4v>^tqSFQ| zmTGI2FZ|8d+oCOU?G+J6kv5;~z;>BF=2lQIJxZ6@%zC&>F&X5~*C$L zQsTk1p$eJ0nLJhRII*2Y7fen*wU*+J4ci#qSiW6Smrd&+@c*fvdxONqtH#KU$Ldpm zoma@^6KpMCCa7VB<%OKG+FxWPeP+Y z6UIk!HR43qAJwhnW$L;a7I7QpRyg<*5aGjVT+XE&d^VF@i1B+Otz!15s8aLlC1sGi z`Z%eXnmM{Hrsfli!ekbYxhQg;(ur9^BVYAmDIJxhcSwZ3@*xkO>0{xZu#aBRhhGO4O}q zd#V4is%TE-T6Fv5P{p*sa9N5%JCnMFO{I|zyJ_x$ne_N#7nWZEw>lD0YN7Z#eWs_y z%zo5sJIRfGS9&%H07xXEzTzb_e}7p=Emv+PqP!zkBQnTvyF46I=Mtvpj2=xiF;?aM zm6J^WDHhxLMtw5r{pmqvd684^HbqEEJ=9mz0_@vV{>4)>YtM2&YAjh3OfSgXZQ~-e zt8~x(IahZ{`paFHR&iCAU7PR9?cYl4oFT&{iwjNFQ&;;}bD;E~KBlrMVa7jE^8+Ju z<1c2*>GY%9l4n=Ox(=#SVYNLMaN($u z;x*S0|8K!0hy=mJZiWuK{bcBDKdR-`R!Fr?ifV-T-B+bP&q;8EPxmY5W1G))DufqV-Gfyd&C8xXPUzKzU7|51WO`|5&=W8}S{bE$ki z+8K(-GS_$e9*FuKGU_?#7l+moPKc4*|Ry6N(*{GujB;(wp4US&g zI#qi8lo)?pgf6WbKS-Evz9= z`%ouyLq&Vg%AdtGXx+`VBI%?nGkKUl=6=Kj=+|BcM?}AKl<>nt;T@}pkQC5P^5Tui zL>-F4AUe_%5S{q?B<^pim9j-`S#`^jXfdMAd?B0E4A5fr^W3|AlcHg+k0LWq#N-QB z0wZD%e4J~}~WUk$gd{F@pulgLo zEJb`Jhj{-^X|zuc;9eELrnzQ9%2o8Z4T8^sU8*?3rfPEk4rP;1jIc!tsJm9Ypx>hiLJUOb%}bJ6F(|!omd5-N zii~6P!yCM=fCX|DB3)asuH8%Yy#HL+z@{n4L~+P`c#(L2k}ZU~`MqlZ&L$T4?rK{Z zmK#7n|H9)>Qj${Ny%NW-PHvwOz%4`%lwA19q_yO*<46n5yzVk$VX<*m{XiCI#r&f5 zp}e^7^daK8(I4H0dsE0&LNnRiaOKkPx+EoYK$RQZI47*#ZfegsyZ~cf7&aGn zIJ`!wNlA1sQ1HCqDfzbIsC@_=9Wmw@?;=Dp;|GupcFhuPot_O9MZEEc4q?u5j25H# zEe9g@@r!uHhVAq=Jjj=DPBf+&y4#;0b?@3DXm(1xi}wO?%x_crTeR`%^+p7~*4dc1 zhSnQqK&?joa>I1YhRuhnFa8quxjpr7XkDtZ>2N_Ci?N=(dpjyJ$E3ibQz*O7m*Y&- zv8YF6Hn=}u)}~ut+u#o{F3to$ZrvHC{kh%jabM9-nzFr^nUEHztZDuX=RV!KF1Aaq zhtK~RYJHi{ZX#>#rn4gW7J5Hdo{?1ax4^sX6%>y38n5mL1CYhAK z^P;Q7+RarR>_wWy~>CD2&C&KUW9~>9^*ib z^%0rvPS|g{*|h74YGj@RnT*B#-kmOZ23J{!fo5k%=QMBH47>@nJsm@>H6|5^c^f6> zN1>i8xP5mnpIsQtNQrT7Rkdr3<9e^5_c>M^C_W@0{Mr9qqUek&yfSxE7EU{nV|S!n zCD|l>#!Y8`AUgHucb%=sUxgB(L3_#vSMFK7@@Yn)*~4oSK*G~+6e3(Qt(#W{tr%e& zkmri>V1f7IUBWal5jm)LHzQ7e(TF=%9tVy1ClnVXA?@8De-XI`^M}c+H{Sn9u|`S#%a%5W>HGZW6*xuy(mYmtJ4#t7yqu+E=*J zrI6{tX>0)wFR3`(19yB#JbKS)Zoi0P-NwfPH)?vkm78%4caG|wC`)3Rv6hPGY*J$t zEHTc1U4X69ai7`~+oTMq!!69(!MdtHcW8F`X`pu4($a3lBZ7aN z5Y`1b>?eCon8f2yT7m-H&2SuCNeEuvlGgU-|Jgsw=}*Oj8`Z%uqpDJ2d)t98T9eVm zt6|BC9GJdGe6>1Vut)+m2gs4m>so?lS_P|McAjqk`vKoBnO=)ox!XPFn4x*6B7?>T zJS_l5qaHWUA!6S?A|I8#!$J*`Y7hS@dh^ZR^%6?KZUWTRP4r7>#s#jrQdsz6GOw7Q zdmTuxjcOf%Np7xfsJIBB#W$blW7y-bD5$3imVfm1x?vV+wX}IJ7V1>%dMaziMN2^{ zO0%lfDI+^!9x#oP=FP91D!LaKlU&81Hleeo)a;oNN^288Z{kY!H$Yk?Q{71&zPDx# z{|ZI(y$E((LjCe2bsxpjjp53LkmlUyl?Xr*5-h^bcf)my(W3gTNyQr%oOdF;)=y7K z-rQY%y*HI8Zf zHaUe%n$r?*h(oxeJi>1@H^H1KZ$gpwZL}XmmSm_{pC?*>rhPR z$|c(B;%!>1nf5PV`Q{dfzU)J94Ffp$NKOBh?NkH#up0K7qbIA*4JH=JsBzSXXw?*~ zlBcPx9C;edXr_t7>4xc)_Kg-In58~tMy9a~%1$&o28Uz9 z$$p*4OME+vsxIowj{`%{h>vHP6Px0LPr=t*6AMjjZUz~d9j7t9oA#a+5rCN@^#!MT!U(QQrC6OP$5@oP zMRXeJo$G!|@mtWfivhjp#n*$A{97B0BGHy=a&hsT!}skA)aw!b)$70PJU+4xH8GZb zQQ$oTr&4-rI+?xWM8L3Y3Lx&A^FXP_EyM6<>M0I#S~2;g=>F4rz!D+CU;jgdf;out zfUDxC@|TOrtQNUig%Qr}B0BtW(&b-IAjuk$!|zR*talIVwv(JaG=x)sE=J47`Fg`8 z2t64nrw5V;4rm$onK50fs%Z1rgVLc;PNzeMd>@vG{-AwRR$Q-VZv$p48D39*61x1B z^p|6r^}HV%N#_zP#rWQAqq_w!O5-%5Ndz>R13gINk{@oT;3jE}RQ)DPXBAyPMX<(WulmYtp3mFVOH zcEb$Y?y1Y~(?df4^uV9k89todzvqx7GY?oem`|RuumLmDg&8{&IGwj`OuQ*eqV6cnzt~MfTXdD^Cm8a#7gvMS3edKNAlS}do;$%uVMQN%cO}F7|ByQ=$CO)J z6v9uNi%AfE!XY~p8o`dno{?>pEV>H44T@wpxIc>_LKd-37y=?{oW<4C`)r_;~O ze56GinqzpCQ;&r^dxWv7Gb;|<(I@?}nUXJctNxu;dj8KzR~1|+Nw^#0x#;WhrKs!L z+n*cxpVGtX^9FKLb@e9CqrTjj`*u8^CZe5}&5;gHSayU+`&<+_3rO&D;FcxoVV;Iz z?HAj3$P$R_P6mMVj1Ckm?9~9NmzAq&Eul&H+!<;#Wp|MpbWzQ3&U2LRsD<$(9sn{Y z`EooxTQ{9R+gT#26~&fw%5@m#S<#v?yfBrp2fV2Js}mh`{SOwuMjM$R;=o`pA|1gU z4Dw<3jzFxb!xQkFclYe%?|vwHE`22V4r(C=pZ7r{tZ{&+E5gK*qlsl5Yh@>cJj6TS z=A8W-U$|qHU++Id)wAQ0$}uzlh1!RwXf*n;l+&McpE&p+B!jBG^2nIb-fa{ zTLCkEf1wHt23XtXXA!kGdZS5z3lLJ@zk&Loy{$ra6aP{ci`cjX6BT&MQf^n?1sCL^ zLe$ndKmy>Ox1=S9r}R?P_bJzoaE1_rNJ(cu`0QFIgXNyKC=>oN&{pP>}I3n#{}>&0l!fD0x#hSo*yvOv}qOz%W8`z0&4 zt+0}z;n|dThdOI2UH87nnf&I6_Y)&{`R@ki=`!$AThL~)j<0FXqBM`9o}#_(ek;Lh ziT+rAB`nyMH%E7QBJR_By*FUfsdOBFMR&p_}rzF~I)`h!+ z`uc9h0^Z5#<22&tY~#GYS&~|Nk+z_+$0%6P2zT8TMGyyfJ3pQ~hsdoH9JN^^2S?t7 z9s`WT_3b4R-5`QJsIaTwDBE&Q{paXp;Q?pi z6o*j#)K#GNs-1f^TISO@B~HaF_egaXp<}Wv=QDC|p}EoUC434^%hhb+Q%ubK5V)L^ zP+8aiMYYQpBlAjT6#YB5N7!7pusz9lWkC3g(ioeyN-B%*(ViU3M>Dkz270hHvV({0 zL47lbc{Fu~{-N5uyz*-Ww+zabTj9F5Eo4OVaQp}Kjpkhdxqa?avu|5nqno}63c3vP zqM{9Qe>d-_lAp4vx2NE8$CuQgs7DMMJ5mq)(NlhPChIQv_8TZ*J&?@e%=^%P9AE)G zI>Zftd1(zk2!{P$$sm;ltGL*A_20jGtk^(upB?PG`wt)wE7qN{&lixcp@S^P728(U z)(eQwz&BW-{5iz2ZmvbdW240@{mFMNtbAL(1BRXU?e1Hf#4TIC!Aj5PZRbmyK6YFF!Lcpp z?WZkMK4-mt(Xo7xw#%C8PiMXFVby#Pr_-LC)|H-jvaA+}(|mQe$BIAjOy*+`ahX@j zdRXy$M)x^yb%rPrJFWl^tbFIKhfDTZUh!BLCX_Zc^nzfAo13xuAi*-Og#xfdh@PU_zn;nL-hPGk#_ zg0v^a0@NxVZxAs~tZAEcO6`H~7EnkRzIL#qw}S+g2yj5fV~rIIqzDxd)l-H}^CCqe zDwpY{oc%1%G?&w(h&iczH2mYYlY#O$#&#qY`h&}X1S{K)O(gJM(1wWnjI}(ZV4$51 z+v@$Shi9{`KB`6cZ4cFig!pSfliKFbOHt%vH(GP1gGDD*k# z5~?Myex63?-xU{o9EE(+SSwSvpX^Cs>YhH}h6TaSFDeZ2{2mcjfnK=R1062C(}jMW zvW!E87V5d9RbIabol+NS^VIO-H*FubvR!p=qG9EeyRR;Q{5KnMa75o4T^XJ6V{N8mPXS9xB5bK5Tk#$; z2`mv7m~}QGDPXh&Qw@{3=p>G(Z#=kKkuL@nybhol071-AY zJ0W`8iYWpKH@r6no@X2Vj{g7sTM0B28zaiX&wfX%MV}er8Yju5VPUFB8b44O-~JC> Ccz4zS delta 7906 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 bA_5-xczOB$Z#9b2@*}`IQ#N`sSls*%Gqx1| diff --git a/src/Nethermind/Chains/swan-mainnet.json.zst b/src/Nethermind/Chains/swan-mainnet.json.zst index f11e3e91a3e614b89359c68a39bda99b57bd44cd..60ca7a6ee23334dc26a5f87d7a8228ad2a81a71c 100644 GIT binary patch delta 7930 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 diff --git a/src/Nethermind/Chains/swell-mainnet.json.zst b/src/Nethermind/Chains/swell-mainnet.json.zst index 3d5711bf867d5707db39ab6c73b9deb2eab910d4..3f861d5110545997e5901798e120379322604a1b 100644 GIT binary patch delta 15541 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 delta 14995 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 delta 19316 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 KH(0S6Kl~q$I?nb0 delta 12032 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

bQbvgL-0t2692<;AFIcKhu?>f zG9hnrOa=UGjMyObM}6hwE0fgYj~&%Uc}-7m{%pBw&7Z@-uaS4**WDxGSDEp6bjsLL z(J2R(Q>f|-8{|#;3#aJhFUSrB3v&nr73^0hZqnmaakM`GKZ5ChXq6k!vq7k>bUG1h zSm>}HmD`bhDrAL)w#%0i4@$MMl|vVIS|F8$6Iy2>fb5Z<7Q$Oc1w+@tL+GjknCh|FRY0qQT2cOYckpvXbingCOnrawXd+b?F~9Kzo8% z3v6BF53S4N=#G`T{7ZkE#p{VHTn$O+(Bt+_v|Q*r-V`Alzqyxe#e_CGF2r5!9&Wdx zzf8%tA0izn-%z^tOO@M&|EU+*OAx?`FWkFfNm8aMn^h`io8$S3^9in-f?Fvr_7LF^ z0Dfo>Oe%`U;NNY2j_RHf+)MfxwFcSJHgkz;-eyZj!r_nru0g#GJtLK6AKfm!y66Hi=Z3h8G{Z+bWvf z0WTmTw?&-ZBe+{D3w33_Rc<{^*E(y3n&N( zk1G+ng(+-PoTR$V_O4aEN9H$piY*5H{5b5#tStM|0nM;?SIb(Zxv+Oj19v9HChW-~GrR|9#!LrFw~fLsQ; zumk`=2aL#GxJVo6bphMo@+k(m%B+Qj)o7vrFng~l0D@EH zLg#iXK|J|&7)F#MwVFve3z~W{dR%#O4`syjsz%+i5fi|+ElCG!=|{qfUCxmvsP<-*-k6~Sm=GPp-R4yy1jGe0SevpI7pzew zEY_H`w?-b`knHv-%O_|d^kY!}L}kaF`%&vFu0MD#Q6SSWQtFvmH}SXtOGaIQWuiBJ z^nPhj_W^P$5j}`HD^9%&qeB<12SEiZqlr@F48nH`7--gI>z*Wa@x-WL4hk`>Tw~mn z(qq;hHFijT8Wa<`r`6;6-9_k7A`WJuPT^*7=pf>7 zUnI^loETM=aNMXh>HO0BB?brS?S#J#lgUol%v>WS1=Z=If))OB;}}ElZZ8g>htwMcL7hCriA3U4 zOUP}tQLQ(v&f}-Pu-VG6f!(Ng$+ngi&v#IZB&_=aqr)(O>4Sgk0_2QO;ieSLKD?Pn z?PkNUe?%ZC@`gF+{ERfh#=l0N(|BHWPg}z%y^oUkiHv>ujwQY&PE9Xs%=qEiXwC|U`Cdygo4|tI}l;&ve!i}Fk$XRF-_5;Tylr)WD z9zl^J&qAFA6wr?>uXXUb5}AiZa#`nw>q>a;(RdzPK&zms8m|LDVLiMdtc)<+*5cvp zl*G9)n4d?HgKs2ypla>jbTSv?&F<(N>NJy9qufANv?y1TyIrGf<54^sd@R1M_w?es`ztacSg>B-)}BPA`T8A9hK}Y z4BMo-tYARI--I$-+}v7I8Lw%-pmMN8Hu%N5f+D;PCSAt94SF~)9e+!xVz>=qW;~4> z2K>=%adsL(I?`A*9DhV1LzNnyuN29WBG#t)KuTZFTjOpR*RP&1Otja@Vc?6^0DY86) z0hi@&d=j71NnG7R!*ZY)Sm~sKnw>b->xIyd4JUm_PYb_`6nn$R;yAZtvo*jm0WA=d zZhS&khM4K!eMQqh4`4U@t(gqBhsW_-_zP4}VOdW_s|$H7UOI*;!F?@Rgpxmvy;fPA zX72igCg$n2i;UtaDQLDesE0?nvT+JFfj-3Q>zJ7P4Tv+4Mx#U?Ec>4h^9HaDD*@db z@e}Qg%+sUNzLv;U#w3=CBBNI1WGHaL#C0sEfG1NN3bH_Zg*v|9H*_xp`+-jH%Y=t{ z)kHJ*Cq!Wq$AA1$-;lD*o+I-8-^uhV(3sD>m%l@~BdFSySDM@@uYBAE&NQ|W;c@v#yx{_=@ z1zI@Uvai$QO=0ERJVWP&(EKL^KuXwU-&QEOn*g`GY4Tr}WAQ{lJtWHdD4l!} zsL&WpAuzr}OKrnsKRMrXj(Xf++h=@*rl6Lv`K-X>fT+R2U3_KYOtDfsAPtCty?Cv8 z7v^pCw}e>kCAihsq0r)O_xNgrhh_?d$1Ls!q#lynju7{6^1PeOjSQnc z3-KtKv&$X-Nkp@4n|xF)V$!VShkwr)bQIlTKfjX18=obBuCsyjgGA$ z{v}>ou;?#PGb>O++Y=NU*hBtnjKV>Bhk|ZTLpRM;d($+-YeE0AJmp4&U-zV1595+5 z67v$Fg0U6=L!w) zk8F239u_NDdYgd^NOx1gCHQE&1rbQcf~^P!F@O(kU0or>%Eo5huF}Hy(yKL2*%F7i zn2#*(UXrcUo}|Tl16!FdwPUojxWLcx^~}w2FQ0uf)y*ye^i|4qDsVbo`Z-409zHh5 zQ2GOmK?HcVcM5wvVrHsvQ=%QYei~_0q{PZM@Or{$bB$g@sLGOe2Pn}KU0O z`h%xJWkQv7-1p*11HbnE14j5hU)p_0k)2+c5j~|oqWq0TFTCblbb2iDn8-c~INKxi zNkrdT*~Ru)0P*D~Z_mJC!e(iUXPm z+AFQEKFYyHC%e~`DZ>$+Lagr3XfM(`06|Nm{P*!p{YPbxuW8ndfTuH{IKHI$C=DTQ z5(8|3rEFS8MhVFijSwQD<_A726JU ztr)ndOWC4;X(p4WPLt`^Ss0u}S+n0?rJ-Tcu=c^)zHoS=>i83mg4e}U!dGQGs%`Vl zppXsvOg~SZuqA;4F^y=)p<8m6t74w(i42F;-$uJZXu%>ov0^fR>Q)t@3kTy4XG?BA z{=)O~!i4`Ky7vbvtDtWCat%*aczh#&_xnbbFqUNPB%$Fv=?=QZ-b1SC=zfq za?tA~HIyuDux}Q?hhmX;BH7H}a3zVe-Mfs&-`0^u_8CUFNXDta)D4nK#tcKMsRzEp zaGFOBn_P{T2cN>Ks8wu7z*aBc-h{59^4Bglz&Q=(oCV~PeBx&?1_fF^lszEf?Q4k4 z&>7G$nstmrjKq_xHyJ=OoELmbRU+=G>P&hRAbxJ6S77!S_0`LiU@S6CMiv$K>cjM# z+Z;gIh+@XG?RD19FD~+3#D;NG?E2aVX zo*;1t-M)YwSZx%DH(6-DF+vjB2D1>9-ZKs@yJ{gyQo{96hV}^YZ=?cU;brtV<)~@! z05VAolqyQ(E{YkhU#!Dak$bW`Lh3trlb5ef%|CVt0XQVA(C6U@*S3~}{J?+&HCSPc zf#V4awMfJ{zrZUt!at>K`TI=|+gcP|_4=l9r~X z1ZYBrDBy5lB0eOLg5bh1!a*owMliyDijegpWLFT~zTbV8*%dE)b%=3B=DKe31c?+ zlnPcpDvx)l9$;#}W1tj6A)~G>N&Z9vhOzJrDV@4$l1b#O09n8ESal&!v?N~cG6lf3 zs;Y=&Au9U72anhlN8}A@1!xEplYm3<*+NWGc&_oGM5f}I#8){5QChzoMa;OwCHFjr z_jGKt(OQ4OG0IvBF=dewW9Q#yTM2=p49TWbJ@sZ+1ku~)ywIf6pgf5I3n(PY-o#`( zjgz;4+g>b;J_r+4NB|_bIggRCiK&@68ygGgx($<*grxd#6KU(S2KoJ5bn-#?p$2&m z>18!I<6M;Kb!t=K3?$fw$?5;`kZtigH7eiVT>Tp2oy|^IydQ{ARd@?&R z{7It>67U_|oRgE2i<28<(2qyT%FRX$z=srAfS%eF@X0ubI5Hy^0=@#=8<4XSy#Vj$ zpzd;PwEy@TlMtoV$GreK%l-xM@{h;!hY(CWBme`PnVX%P1N2rw2npbY>HslU;DVCM zDL|ldLM)><(X&7SAEHx;Bga(YDlk~2ND6508Hn5T!?8_Y_AOHeXUB!UG@_#Q9 zlIzn?+}d|d(9|FUNWKf@Yn6lt;M>JD48+TniPzCz)kVnPR)h5)vIVPO=ICrGJ};9v8Bgl7EDIa&xNIu(t+&mPQvwymwGCV*gwfCR8Zn6onf3oNYv z8$gG3U%~o8)lCGTs5&Unce~U;InkWd^SpF0KdaU;I z-`2SFF4MM4B0F~Eaq4odU$^Rul^m@5gy!qekP1%|M z1s3-I4Ip6KSFmu<_8`Gu*4Te-lw51Z$J&@Axe?8&Z_urlX4pQKAvHU0ega7S+;E#wZ_^+SozpegF|NeiZ|886B JGSvS0e*nI(k3#?e delta 45366 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 z�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 diff --git a/src/Nethermind/Chains/unichain-sepolia.json.zst b/src/Nethermind/Chains/unichain-sepolia.json.zst index 823ff07bbab1f82f5e3a6ed5b11d52331003c19f..98e55cca2446e6674b3bfad9ac26ee43d39e114a 100644 GIT binary patch delta 29166 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 b0|59olTUslvpjF&0RhB=A91%IaRKKXW7M?& delta 28474 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 VZ!CNx15*JA$YW;XJj?Lq{{xqQQ(^!B delta 12384 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 a?4Yy8Lg5jZ)_Bem2nfXdRu-Po%l`ukOri1s diff --git a/src/Nethermind/Chains/xterio-eth-mainnet.json.zst b/src/Nethermind/Chains/xterio-eth-mainnet.json.zst index 811e0045e51a90a0c287933909162d681c984b25..c27949dfa61f2f1671ad9bb384c4e232de7c7f80 100644 GIT binary patch delta 12993 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 delta 12232 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 Vzet3ZE7lS)FglKwB#ybu{{taPI-&po diff --git a/src/Nethermind/Chains/zora-mainnet.json.zst b/src/Nethermind/Chains/zora-mainnet.json.zst index 7e3ebc3cc0b54ddcab8ee879dfd9a76e49fe5c4c..4d36c1b3f64eeaa043c3acfe815c657fcc94fce4 100644 GIT binary patch delta 8545 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 Z9Ng`kCFrDC6v~vA!uO$-kGeMW{{Y_uJxc%p delta 8085 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 diff --git a/src/Nethermind/Chains/zora-sepolia.json.zst b/src/Nethermind/Chains/zora-sepolia.json.zst index 35fd78bf85db8180f2c144fbca9c249f53570dbe..32a4747ad8d498678cef2cd7e69ffb1d60571393 100644 GIT binary patch delta 5823 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 W%l~sjcqvdH+4~J@C=}D!T=f6%*}IB7porZlI-$ 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

xP35d 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 delta 7634 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 delta 7929 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 diff --git a/src/Nethermind/Chains/redstone-mainnet.json.zst b/src/Nethermind/Chains/redstone-mainnet.json.zst index b0360bddf10f4fe9a8abfc48fa55472357c17513..abc22d4ec08abd002d69b31e2d5800a2c07cafd0 100644 GIT binary patch delta 9120 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 BrTYK? diff --git a/src/Nethermind/Chains/settlus-mainnet-mainnet.json.zst b/src/Nethermind/Chains/settlus-mainnet-mainnet.json.zst index bc0588206f2bd38f11d7aec67ce0177f0df8940b..254c38da84b7c90b16b0a4ce8ea1d4c772b4a9fe 100644 GIT binary patch delta 15472 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 Mx7Can*a-6f1Hu1>F#rGn delta 14902 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 TZypG+T5z5~Tb=;05#;{|Jd8(+ diff --git a/src/Nethermind/Chains/settlus-sepolia-sepolia.json.zst b/src/Nethermind/Chains/settlus-sepolia-sepolia.json.zst index d02be32e4b4e7ec7a8575bf326c384e394143794..6257c7afcfd6c32b987e7225e854af59c568edfe 100644 GIT binary patch delta 19421 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 E2NRXnkpKVy delta 19146 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 delta 8228 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 D&J%ir diff --git a/src/Nethermind/Chains/shape-sepolia.json.zst b/src/Nethermind/Chains/shape-sepolia.json.zst index 9a67857fc9c629897e8506ae701a5c8fce3aee28..82376a0654b8cfe9bc0bc7e3e48328b0b0840af2 100644 GIT binary patch delta 13163 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%0A1SXQC*u)b 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 delta 7955 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 ONUxw&bxDlYSN{W){TK`Y diff --git a/src/Nethermind/Chains/soneium-mainnet.json.zst b/src/Nethermind/Chains/soneium-mainnet.json.zst index a39062ecc465c56bd3738a1563269f413f211709..df7b6c752770e5b39682387e971dfe03ae1c4796 100644 GIT binary patch delta 19626 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 z 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

_a>7K8sXDESz-^qa1aXJtEpYUu zn#3g!Ot4HQ^{zfvA6Hs9xK~N#PJjLK(#O$0gL*g_%2Wb&(`IpVJFiN64ypk4oT3Ct za_xd&t)TjDf9EQGQ5_LF(0Q3uB!C}6;{5~hi)ch>e`h~_QJbD%#H~D{<3iC}okd-Q zCaEZEvrrn}RI5Y2s{?JD`7U;rZ8C@GvRT-rGo3rrdd!EvkjN9q#%`p*-&E?fyr;j- z$_Hf%0&8fyoyWO*cwzxZgt$#pF7eZ5;ahqi$|)2@ALZL)w2mLTi1HmU8pIEUp?nAF z-;6l8S-7AxsfEx@gSBN59ea%|@I$!&3j64Vt!rEB9KbL_#imsa(UwUs%$+MD>MXjU zeEaDIv;+P0&VhdpGGaB!U~qmWWMk--&Y~oukyJ!vKr#wx(0xY9_#rm=EoBbCmP^@Y zI7?^J4i)-32DRyrLxm2;eA@I6LxtwUbQfk`=}>a$k)%TjK~cmInyEyWo*2}I|3y@2 ze~ioKpSUnHu0zR(wUOwBAJlfTnSlu|W&1H(I@s^&2I-)G@y{pbZx)&e@2rka42dDy zx??_dcbeg8QiKlD<)f*TO?2F(ouJ$y(iqTGQb#oA5mCvn%oCUa9QR?H08I2(gW4zi^et3*^U2Iu~xy8pJelH8qsW zNi*N*E7cwB%w=@XA<`lZEd=G8Ld@@mw51V|8}xa{J@%}7fnPjwxFJ8fy{Z{zV62;F z4u*?pYtJX@(oBJG(nYi}qBcTzf&R^i)tf1PeVvn?F7pP2YcH-u{fKNrBia@Ws_FT* z@EmHW^9=~ow&%fvKomxJpQsavsci&6^Bse*!FPb~yt1Hi#up$P0$kve1Q)&X4s1@O0j+Y7Q1_>lDWYHDgg zwe;`yX3hWK9uiwm1!M$eKtsT3!Q-GEAV*LZ^qbBto*jTg=wCW&3L!wGkSsXqf9SBr zdJ*W|RovZyb=lwD^Zw%o?a=oN0(=f&!7a4_w*VUYx|3rbI3+I*NXsLj9#uQlz|H}A z&>H}av1C!F`4qo67FPlgkaD0=IxBdqb_k2<^o@Lc2%NftJd9S9u(3+VBS zz&z;)7>0gqBT6Cnp-fPSil-+~gF*p)C_m6Dpd%{xmv+z#27ci{t*A8kKf&O-4}J>< zC<%(dH0d4PX$1L9;MTvP+<_umLYtnr!e9w;)CmFLXc^F3#(*oB5FivS2cq*i4*hvHmRmt!osdUPh&bSQ>Gi(U*LcmlV1kt|p&mcEL2 zbSId=Wq*53C5;csszH0`$m{=e4Zy)}fV0Biw;IYsyVbxOg}>RtGk#xX9AGXf0>jY} wgc!tGZt48ChC0wr%XrW;(u`{juhU>GK^xHLM*?P2Fu+2|6!fDmTM6s&e+emuIsgCw From 72debe8177ab0ebb88f5a0d266de1cd055ae0bb6 Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Sun, 13 Jul 2025 13:21:49 +0100 Subject: [PATCH 12/40] Remove use of Linq.Sum from hot paths (#8977) * Remove use of Linq.Sum from hot paths * Simplify --- .../Validators/PendingValidatorsDecoder.cs | 8 +++- .../Nethermind.Core/Eip2930/AccessList.cs | 2 + .../ValidateBuilderSubmissionHandler.cs | 18 ++++++--- .../BlockBodyDecoder.cs | 40 +++++++++++++++++-- .../Eip2930/AccessListDecoder.cs | 15 ++++--- 5 files changed, 66 insertions(+), 17 deletions(-) diff --git a/src/Nethermind/Nethermind.Consensus.AuRa/Validators/PendingValidatorsDecoder.cs b/src/Nethermind/Nethermind.Consensus.AuRa/Validators/PendingValidatorsDecoder.cs index 22e1a168e92..7dc6dcc2894 100644 --- a/src/Nethermind/Nethermind.Consensus.AuRa/Validators/PendingValidatorsDecoder.cs +++ b/src/Nethermind/Nethermind.Consensus.AuRa/Validators/PendingValidatorsDecoder.cs @@ -2,7 +2,6 @@ // SPDX-License-Identifier: LGPL-3.0-only using System.Collections.Generic; -using System.Linq; using Nethermind.Core; using Nethermind.Serialization.Rlp; @@ -84,6 +83,11 @@ private static (int Total, int Addresses) GetContentLength(PendingValidators ite return (contentLength, addressesLength); } - private static int GetAddressesLength(Address[] addresses) => addresses.Sum(Rlp.LengthOf); + private static int GetAddressesLength(Address[] addresses) + { + const int AddressLengthWithRlpLengthPrefix = 1 + 20; + + return addresses.Length * AddressLengthWithRlpLengthPrefix; + } } } diff --git a/src/Nethermind/Nethermind.Core/Eip2930/AccessList.cs b/src/Nethermind/Nethermind.Core/Eip2930/AccessList.cs index 7d271adc44f..8d5cb5e9e16 100644 --- a/src/Nethermind/Nethermind.Core/Eip2930/AccessList.cs +++ b/src/Nethermind/Nethermind.Core/Eip2930/AccessList.cs @@ -116,6 +116,8 @@ public readonly void Dispose() { } private readonly int _index; private readonly int _count; + public int Count => _count; + public StorageKeysEnumerable(AccessList accessList, int index, int count) { _accessList = accessList; diff --git a/src/Nethermind/Nethermind.Flashbots/Handlers/ValidateBuilderSubmissionHandler.cs b/src/Nethermind/Nethermind.Flashbots/Handlers/ValidateBuilderSubmissionHandler.cs index 484369ac425..d037584a42f 100644 --- a/src/Nethermind/Nethermind.Flashbots/Handlers/ValidateBuilderSubmissionHandler.cs +++ b/src/Nethermind/Nethermind.Flashbots/Handlers/ValidateBuilderSubmissionHandler.cs @@ -3,25 +3,23 @@ using System; using System.Collections.Generic; -using System.Linq; using System.Threading.Tasks; using Nethermind.Blockchain; using Nethermind.Blockchain.Tracing; -using Nethermind.Flashbots.Data; using Nethermind.Consensus; using Nethermind.Consensus.Processing; using Nethermind.Consensus.Validators; using Nethermind.Core; +using Nethermind.Core.Crypto; using Nethermind.Core.Specs; using Nethermind.Crypto; using Nethermind.Evm; -using Nethermind.Evm.Tracing; +using Nethermind.Evm.State; +using Nethermind.Flashbots.Data; using Nethermind.Int256; using Nethermind.JsonRpc; using Nethermind.Logging; using Nethermind.Merge.Plugin.Data; -using Nethermind.Core.Crypto; -using Nethermind.Evm.State; using Nethermind.State.OverridableEnv; namespace Nethermind.Flashbots.Handlers; @@ -147,7 +145,15 @@ private bool ValidateBlock(Block block, BidTrace message, long registeredGasLimi private bool ValidateBlobsBundle(Transaction[] transactions, BlobsBundleV1 blobsBundle, out string? error) { // get sum of length of blobs of each transaction - int totalBlobsLength = transactions.Sum(t => t.BlobVersionedHashes is not null ? t.BlobVersionedHashes.Length : 0); + int totalBlobsLength = 0; + foreach (Transaction tx in transactions) + { + byte[]?[]? versionedHashes = tx.BlobVersionedHashes; + if (versionedHashes is not null) + { + totalBlobsLength += versionedHashes.Length; + } + } if (totalBlobsLength != blobsBundle.Blobs.Length) { diff --git a/src/Nethermind/Nethermind.Serialization.Rlp/BlockBodyDecoder.cs b/src/Nethermind/Nethermind.Serialization.Rlp/BlockBodyDecoder.cs index d3b619a846b..f7fc6028159 100644 --- a/src/Nethermind/Nethermind.Serialization.Rlp/BlockBodyDecoder.cs +++ b/src/Nethermind/Nethermind.Serialization.Rlp/BlockBodyDecoder.cs @@ -2,7 +2,6 @@ // SPDX-License-Identifier: LGPL-3.0-only using System; -using System.Linq; using Nethermind.Core; namespace Nethermind.Serialization.Rlp; @@ -41,11 +40,44 @@ public int GetBodyLength(BlockBody b) b.Withdrawals is not null ? GetWithdrawalsLength(b.Withdrawals) : null ); - private int GetTxLength(Transaction[] transactions) => transactions.Sum(t => _txDecoder.GetLength(t, RlpBehaviors.None)); + private int GetTxLength(Transaction[] transactions) + { + if (transactions.Length == 0) return 0; + + int sum = 0; + foreach (Transaction tx in transactions) + { + sum += _txDecoder.GetLength(tx, RlpBehaviors.None); + } + + return sum; + } + + private int GetUnclesLength(BlockHeader[] headers) + { + if (headers.Length == 0) return 0; + + int sum = 0; + foreach (BlockHeader header in headers) + { + sum += _headerDecoder.GetLength(header, RlpBehaviors.None); + } - private int GetUnclesLength(BlockHeader[] headers) => headers.Sum(t => _headerDecoder.GetLength(t, RlpBehaviors.None)); + return sum; + } + + private int GetWithdrawalsLength(Withdrawal[] withdrawals) + { + if (withdrawals.Length == 0) return 0; - private int GetWithdrawalsLength(Withdrawal[] withdrawals) => withdrawals.Sum(t => _withdrawalDecoderDecoder.GetLength(t, RlpBehaviors.None)); + int sum = 0; + foreach (Withdrawal withdrawal in withdrawals) + { + sum += _withdrawalDecoderDecoder.GetLength(withdrawal, RlpBehaviors.None); + } + + return sum; + } public BlockBody? Decode(ref Rlp.ValueDecoderContext ctx, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { diff --git a/src/Nethermind/Nethermind.Serialization.Rlp/Eip2930/AccessListDecoder.cs b/src/Nethermind/Nethermind.Serialization.Rlp/Eip2930/AccessListDecoder.cs index 47cd8b2a634..e61b35690cc 100644 --- a/src/Nethermind/Nethermind.Serialization.Rlp/Eip2930/AccessListDecoder.cs +++ b/src/Nethermind/Nethermind.Serialization.Rlp/Eip2930/AccessListDecoder.cs @@ -1,7 +1,6 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only -using System.Linq; using Nethermind.Core; using Nethermind.Core.Eip2930; using Nethermind.Int256; @@ -151,7 +150,7 @@ public void Encode(RlpStream stream, AccessList? item, RlpBehaviors rlpBehaviors // Index2 // ... // IndexN - AccessItemLengths lengths = new(storageKeys.Count()); + AccessItemLengths lengths = new(storageKeys.Count); stream.StartSequence(lengths.ContentLength); { stream.Encode(address); @@ -199,9 +198,15 @@ public AccessItemLengths(int indexesCount) private static int GetContentLength(AccessList accessList) { - return accessList - .Select(static entry => new AccessItemLengths(entry.StorageKeys.Count())) - .Sum(static lengths => lengths.SequenceLength); + int sum = 0; + foreach ((Address Address, AccessList.StorageKeysEnumerable StorageKeys) entry in accessList) + { + int indexesContentLength = entry.StorageKeys.Count * Rlp.LengthOfKeccakRlp; + int contentLength = Rlp.LengthOfSequence(indexesContentLength) + Rlp.LengthOfAddressRlp; + sum += Rlp.LengthOfSequence(contentLength); + } + + return sum; } } } From 979b2652d17f424753aa53e38079f2c6d4b4ed4c Mon Sep 17 00:00:00 2001 From: Amirul Ashraf Date: Mon, 14 Jul 2025 09:45:56 +0800 Subject: [PATCH 13/40] Isolate Tracer in Proof Module and remove IVisitingWorldState (#8981) * Scope the tracer * Use state reader in Tracer * Inline dump state * Remove accept * Delete IVisitingWorldState * Move dump state to state reader * Whitespace --- .../Nethermind.Api/IMainProcessingContext.cs | 4 +- .../Nethermind.Api/MainProcessingContext.cs | 4 +- .../Contract/TestContractBlockchain.cs | 4 +- .../Contract/ValidatorContractTests.cs | 4 +- .../Validators/ContractBasedValidatorTests.cs | 4 +- .../GenesisLoaderTests.cs | 2 +- .../Nethermind.Blockchain/GenesisLoader.cs | 61 +++++++++++----- .../IReadOnlyTxProcessingScope.cs | 3 +- .../ReadOnlyTxProcessingScopeTests.cs | 2 +- .../AutoReadOnlyTxProcessingEnvFactory.cs | 10 +-- .../Processing/ReadOnlyTxProcessingScope.cs | 5 +- .../Processing/ShareableTxProcessingSource.cs | 2 +- .../Nethermind.Consensus/Tracing/Tracer.cs | 4 +- .../Modules/MainBlockProcessingContext.cs | 3 +- .../Modules/TestBlockProcessingModule.cs | 2 +- .../PruningTrieStateFactory.cs | 2 +- .../Steps/InitializeBlockchain.cs | 2 +- .../Nethermind.Init/Steps/LoadGenesisBlock.cs | 32 ++------- .../Modules/Proof/ProofModuleFactory.cs | 44 +++++------- .../Modules/Proof/ProofRpcModule.cs | 71 +++++++++---------- .../Modules/Trace/TraceModuleFactory.cs | 4 +- .../StateProviderTests.cs | 26 ------- .../Nethermind.State.Test/StateReaderTests.cs | 27 +++++++ .../WorldStateManagerTests.cs | 6 +- .../Nethermind.State/IVisitingWorldState.cs | 30 -------- .../Nethermind.State/IWorldStateManager.cs | 8 +-- .../OverridableEnv/IOverridableEnv.cs | 3 +- .../OverridableEnv/OverridableEnvFactory.cs | 2 +- .../OverridableWorldStateManager.cs | 2 +- .../Nethermind.State/StateReaderExtensions.cs | 7 ++ src/Nethermind/Nethermind.State/WorldState.cs | 2 +- .../Nethermind.State/WorldStateManager.cs | 10 +-- 32 files changed, 180 insertions(+), 212 deletions(-) delete mode 100644 src/Nethermind/Nethermind.State/IVisitingWorldState.cs diff --git a/src/Nethermind/Nethermind.Api/IMainProcessingContext.cs b/src/Nethermind/Nethermind.Api/IMainProcessingContext.cs index ff3e6adeb99..ea70ce58696 100644 --- a/src/Nethermind/Nethermind.Api/IMainProcessingContext.cs +++ b/src/Nethermind/Nethermind.Api/IMainProcessingContext.cs @@ -4,8 +4,8 @@ using System.Threading.Tasks; using Nethermind.Consensus.Processing; using Nethermind.Core.ServiceStopper; +using Nethermind.Evm.State; using Nethermind.Evm.TransactionProcessing; -using Nethermind.State; namespace Nethermind.Api; @@ -21,7 +21,7 @@ public interface IMainProcessingContext : IStoppableService ITransactionProcessor TransactionProcessor { get; } IBlockProcessor BlockProcessor { get; } IBlockchainProcessor BlockchainProcessor { get; } - IVisitingWorldState WorldState { get; } + IWorldState WorldState { get; } Task IStoppableService.StopAsync() => BlockchainProcessor.StopAsync(); string IStoppableService.Description => "blockchain processor"; diff --git a/src/Nethermind/Nethermind.Api/MainProcessingContext.cs b/src/Nethermind/Nethermind.Api/MainProcessingContext.cs index b8e71564d7e..27b4b9f512c 100644 --- a/src/Nethermind/Nethermind.Api/MainProcessingContext.cs +++ b/src/Nethermind/Nethermind.Api/MainProcessingContext.cs @@ -2,8 +2,8 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Consensus.Processing; +using Nethermind.Evm.State; using Nethermind.Evm.TransactionProcessing; -using Nethermind.State; namespace Nethermind.Api; @@ -11,7 +11,7 @@ public record MainProcessingContext( ITransactionProcessor TransactionProcessor, IBlockProcessor BlockProcessor, IBlockchainProcessor BlockchainProcessor, - IVisitingWorldState WorldState + IWorldState WorldState ) : IMainProcessingContext { } diff --git a/src/Nethermind/Nethermind.AuRa.Test/Contract/TestContractBlockchain.cs b/src/Nethermind/Nethermind.AuRa.Test/Contract/TestContractBlockchain.cs index fd101cf2726..9a6b8b957e5 100644 --- a/src/Nethermind/Nethermind.AuRa.Test/Contract/TestContractBlockchain.cs +++ b/src/Nethermind/Nethermind.AuRa.Test/Contract/TestContractBlockchain.cs @@ -49,8 +49,10 @@ protected override Block GetGenesisBlock(IWorldState worldState) => new GenesisLoader( ChainSpec, SpecProvider, + StateReader, worldState, - TxProcessor) + TxProcessor, + LogManager) .Load(); } } diff --git a/src/Nethermind/Nethermind.AuRa.Test/Contract/ValidatorContractTests.cs b/src/Nethermind/Nethermind.AuRa.Test/Contract/ValidatorContractTests.cs index 4ed576a4333..7a52867ee51 100644 --- a/src/Nethermind/Nethermind.AuRa.Test/Contract/ValidatorContractTests.cs +++ b/src/Nethermind/Nethermind.AuRa.Test/Contract/ValidatorContractTests.cs @@ -30,14 +30,14 @@ public class ValidatorContractTests private readonly Address _contractAddress = Address.FromNumber(long.MaxValue); private ITransactionProcessor _transactionProcessor; private IReadOnlyTxProcessorSource _readOnlyTxProcessorSource; - private IVisitingWorldState _stateProvider; + private IWorldState _stateProvider; [SetUp] public void SetUp() { _block = new Block(Build.A.BlockHeader.WithStateRoot(TestItem.KeccakA).TestObject, new BlockBody()); _transactionProcessor = Substitute.For(); - _stateProvider = Substitute.For(); + _stateProvider = Substitute.For(); _readOnlyTxProcessorSource = Substitute.For(); _readOnlyTxProcessorSource.Build(_block.Header).Returns(new ReadOnlyTxProcessingScope(_transactionProcessor, _stateProvider)); } diff --git a/src/Nethermind/Nethermind.AuRa.Test/Validators/ContractBasedValidatorTests.cs b/src/Nethermind/Nethermind.AuRa.Test/Validators/ContractBasedValidatorTests.cs index c5dd6e83726..cfcdeaef145 100644 --- a/src/Nethermind/Nethermind.AuRa.Test/Validators/ContractBasedValidatorTests.cs +++ b/src/Nethermind/Nethermind.AuRa.Test/Validators/ContractBasedValidatorTests.cs @@ -38,7 +38,7 @@ namespace Nethermind.AuRa.Test.Validators; public class ContractBasedValidatorTests { - private IVisitingWorldState _stateProvider; + private IWorldState _stateProvider; private IAbiEncoder _abiEncoder; private ILogManager _logManager; private AuRaParameters.Validator _validator; @@ -62,7 +62,7 @@ public void SetUp() { _validatorStore = new ValidatorStore(new MemDb()); _validSealerStrategy = new ValidSealerStrategy(); - _stateProvider = Substitute.For(); + _stateProvider = Substitute.For(); _abiEncoder = Substitute.For(); _logManager = LimboLogs.Instance; _blockTree = Substitute.For(); diff --git a/src/Nethermind/Nethermind.Blockchain.Test/GenesisLoaderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/GenesisLoaderTests.cs index 212f509e162..ad74b4ea877 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/GenesisLoaderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/GenesisLoaderTests.cs @@ -60,7 +60,7 @@ private Block GetGenesisBlock(string chainspecPath) ISpecProvider specProvider = Substitute.For(); specProvider.GetSpec(Arg.Any()).Returns(Berlin.Instance); ITransactionProcessor transactionProcessor = Substitute.For(); - GenesisLoader genesisLoader = new(chainSpec, specProvider, stateProvider, transactionProcessor); + GenesisLoader genesisLoader = new(chainSpec, specProvider, worldStateManager.GlobalStateReader, stateProvider, transactionProcessor, LimboLogs.Instance); return genesisLoader.Load(); } diff --git a/src/Nethermind/Nethermind.Blockchain/GenesisLoader.cs b/src/Nethermind/Nethermind.Blockchain/GenesisLoader.cs index ccad5c1fe58..10469f4b88d 100644 --- a/src/Nethermind/Nethermind.Blockchain/GenesisLoader.cs +++ b/src/Nethermind/Nethermind.Blockchain/GenesisLoader.cs @@ -6,6 +6,7 @@ using System.Linq; using Nethermind.Blockchain.Tracing; using Nethermind.Core; +using Nethermind.Core.Crypto; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; using Nethermind.Crypto; @@ -13,60 +14,86 @@ using Nethermind.Evm; using Nethermind.Evm.State; using Nethermind.Evm.TransactionProcessing; +using Nethermind.Logging; using Nethermind.Specs.ChainSpecStyle; +using Nethermind.State; +using Nethermind.Trie; namespace Nethermind.Blockchain { public class GenesisLoader( ChainSpec chainSpec, ISpecProvider specProvider, + IStateReader stateReader, IWorldState stateProvider, - ITransactionProcessor transactionProcessor) + ITransactionProcessor transactionProcessor, + ILogManager logManager, + Hash256? expectedGenesisHash = null + ) { - private readonly ChainSpec _chainSpec = chainSpec ?? throw new ArgumentNullException(nameof(chainSpec)); - private readonly ISpecProvider _specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider)); - private readonly IWorldState _stateProvider = stateProvider ?? throw new ArgumentNullException(nameof(stateProvider)); - private readonly ITransactionProcessor _transactionProcessor = transactionProcessor ?? throw new ArgumentNullException(nameof(transactionProcessor)); + ILogger _logger = logManager.GetClassLogger(); public Block Load() { - Block genesis = _chainSpec.Genesis; + Block genesis = chainSpec.Genesis; Preallocate(genesis); // we no longer need the allocations - 0.5MB RAM, 9000 objects for mainnet - _chainSpec.Allocations = null; + chainSpec.Allocations = null; - if (!_chainSpec.GenesisStateUnavailable) + if (!chainSpec.GenesisStateUnavailable) { - _stateProvider.Commit(_specProvider.GenesisSpec, true); + stateProvider.Commit(specProvider.GenesisSpec, true); - _stateProvider.CommitTree(0); + stateProvider.CommitTree(0); - genesis.Header.StateRoot = _stateProvider.StateRoot; + genesis.Header.StateRoot = stateProvider.StateRoot; } genesis.Header.Hash = genesis.Header.CalculateHash(); + ValidateGenesisHash(expectedGenesisHash, genesis.Header); + return genesis; } + /// + /// If is null then it means that we do not care about the genesis hash (e.g. in some quick testing of private chains)/> + /// + /// + private void ValidateGenesisHash(Hash256? expectedGenesisHash, BlockHeader genesis) + { + if (expectedGenesisHash is not null && genesis.Hash != expectedGenesisHash) + { + if (_logger.IsTrace) _logger.Trace(stateReader.DumpState(genesis.StateRoot!)); + if (_logger.IsWarn) _logger.Warn(genesis.ToString(BlockHeader.Format.Full)); + if (_logger.IsError) _logger.Error($"Unexpected genesis hash, expected {expectedGenesisHash}, but was {genesis.Hash}"); + } + else + { + if (_logger.IsDebug) _logger.Info($"Genesis hash : {genesis.Hash}"); + } + + ThisNodeInfo.AddInfo("Genesis hash :", $"{genesis.Hash}"); + } + private void Preallocate(Block genesis) { - _transactionProcessor.SetBlockExecutionContext(new BlockExecutionContext(genesis.Header, specProvider.GetSpec(genesis.Header))); - foreach ((Address address, ChainSpecAllocation allocation) in _chainSpec.Allocations.OrderBy(static a => a.Key)) + transactionProcessor.SetBlockExecutionContext(new BlockExecutionContext(genesis.Header, specProvider.GetSpec(genesis.Header))); + foreach ((Address address, ChainSpecAllocation allocation) in chainSpec.Allocations.OrderBy(static a => a.Key)) { - _stateProvider.CreateAccount(address, allocation.Balance, allocation.Nonce); + stateProvider.CreateAccount(address, allocation.Balance, allocation.Nonce); if (allocation.Code is not null) { - _stateProvider.InsertCode(address, allocation.Code, _specProvider.GenesisSpec, true); + stateProvider.InsertCode(address, allocation.Code, specProvider.GenesisSpec, true); } if (allocation.Storage is not null) { foreach (KeyValuePair storage in allocation.Storage) { - _stateProvider.Set(new StorageCell(address, storage.Key), + stateProvider.Set(new StorageCell(address, storage.Key), storage.Value.WithoutLeadingZeros().ToArray()); } } @@ -81,7 +108,7 @@ private void Preallocate(Block genesis) }; CallOutputTracer outputTracer = new(); - _transactionProcessor.Execute(constructorTransaction, outputTracer); + transactionProcessor.Execute(constructorTransaction, outputTracer); if (outputTracer.StatusCode != StatusCode.Success) { diff --git a/src/Nethermind/Nethermind.Blockchain/IReadOnlyTxProcessingScope.cs b/src/Nethermind/Nethermind.Blockchain/IReadOnlyTxProcessingScope.cs index 6a91be73dee..5bd5bec4ae8 100644 --- a/src/Nethermind/Nethermind.Blockchain/IReadOnlyTxProcessingScope.cs +++ b/src/Nethermind/Nethermind.Blockchain/IReadOnlyTxProcessingScope.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using System; +using Nethermind.Evm.State; using Nethermind.Evm.TransactionProcessing; using Nethermind.State; @@ -10,6 +11,6 @@ namespace Nethermind.Blockchain; public interface IReadOnlyTxProcessingScope : IDisposable { ITransactionProcessor TransactionProcessor { get; } - IVisitingWorldState WorldState { get; } + IWorldState WorldState { get; } void Reset() => Dispose(); } diff --git a/src/Nethermind/Nethermind.Consensus.Test/ReadOnlyTxProcessingScopeTests.cs b/src/Nethermind/Nethermind.Consensus.Test/ReadOnlyTxProcessingScopeTests.cs index 8970392b624..9d19c6e9760 100644 --- a/src/Nethermind/Nethermind.Consensus.Test/ReadOnlyTxProcessingScopeTests.cs +++ b/src/Nethermind/Nethermind.Consensus.Test/ReadOnlyTxProcessingScopeTests.cs @@ -18,7 +18,7 @@ public void Test_WhenDispose_ThenStateRootWillReset() { ReadOnlyTxProcessingScope env = new ReadOnlyTxProcessingScope( Substitute.For(), - Substitute.For()); + Substitute.For()); env.Dispose(); diff --git a/src/Nethermind/Nethermind.Consensus/Processing/AutoReadOnlyTxProcessingEnvFactory.cs b/src/Nethermind/Nethermind.Consensus/Processing/AutoReadOnlyTxProcessingEnvFactory.cs index 9d62f9166af..785382c6415 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/AutoReadOnlyTxProcessingEnvFactory.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/AutoReadOnlyTxProcessingEnvFactory.cs @@ -16,11 +16,11 @@ public class AutoReadOnlyTxProcessingEnvFactory(ILifetimeScope parentLifetime, I { public IReadOnlyTxProcessorSource Create() { - IVisitingWorldState worldState = worldStateManager.CreateResettableWorldState(); + IWorldState worldState = worldStateManager.CreateResettableWorldState(); ILifetimeScope childScope = parentLifetime.BeginLifetimeScope((builder) => { builder - .AddSingleton(worldState).AddSingleton(worldState) + .AddSingleton(worldState) .AddSingleton(); }); @@ -29,18 +29,18 @@ public IReadOnlyTxProcessorSource Create() public IReadOnlyTxProcessorSource CreateForWarmingUp(IWorldState worldStateToWarmUp) { - IVisitingWorldState worldState = worldStateManager.CreateWorldStateForWarmingUp(worldStateToWarmUp); + IWorldState worldState = worldStateManager.CreateWorldStateForWarmingUp(worldStateToWarmUp); ILifetimeScope childScope = parentLifetime.BeginLifetimeScope((builder) => { builder - .AddSingleton(worldState).AddSingleton(worldState) + .AddSingleton(worldState) .AddSingleton(); }); return childScope.Resolve(); } - private class AutoReadOnlyTxProcessingEnv(ITransactionProcessor transactionProcessor, IVisitingWorldState worldState, ILifetimeScope lifetimeScope) : IReadOnlyTxProcessorSource, IDisposable + private class AutoReadOnlyTxProcessingEnv(ITransactionProcessor transactionProcessor, IWorldState worldState, ILifetimeScope lifetimeScope) : IReadOnlyTxProcessorSource, IDisposable { public IReadOnlyTxProcessingScope Build(BlockHeader? header) { diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingScope.cs b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingScope.cs index 647cd735fd7..ef7305ce53d 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingScope.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingScope.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Blockchain; +using Nethermind.Evm.State; using Nethermind.Evm.TransactionProcessing; using Nethermind.State; @@ -9,7 +10,7 @@ namespace Nethermind.Consensus.Processing; public class ReadOnlyTxProcessingScope( ITransactionProcessor transactionProcessor, - IVisitingWorldState worldState + IWorldState worldState ) : IReadOnlyTxProcessingScope { public void Dispose() @@ -19,5 +20,5 @@ public void Dispose() } public ITransactionProcessor TransactionProcessor => transactionProcessor; - public IVisitingWorldState WorldState => worldState; + public IWorldState WorldState => worldState; } diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ShareableTxProcessingSource.cs b/src/Nethermind/Nethermind.Consensus/Processing/ShareableTxProcessingSource.cs index a008af09854..b0ea3a22b5d 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/ShareableTxProcessingSource.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/ShareableTxProcessingSource.cs @@ -62,6 +62,6 @@ public void Dispose() public ITransactionProcessor TransactionProcessor => _scope.TransactionProcessor; - public IVisitingWorldState WorldState => _scope.WorldState; + public IWorldState WorldState => _scope.WorldState; } } diff --git a/src/Nethermind/Nethermind.Consensus/Tracing/Tracer.cs b/src/Nethermind/Nethermind.Consensus/Tracing/Tracer.cs index a46c5551ea1..0cbfb8156cf 100644 --- a/src/Nethermind/Nethermind.Consensus/Tracing/Tracer.cs +++ b/src/Nethermind/Nethermind.Consensus/Tracing/Tracer.cs @@ -12,7 +12,7 @@ namespace Nethermind.Consensus.Tracing { public class Tracer( - IVisitingWorldState worldState, + IStateReader stateReader, IBlockchainProcessor traceProcessor, IBlockchainProcessor executeProcessor, ProcessingOptions executeOptions = ProcessingOptions.Trace, @@ -38,7 +38,7 @@ public void Accept(ITreeVisitor visitor, Hash256 stateRoot) where TC ArgumentNullException.ThrowIfNull(visitor); ArgumentNullException.ThrowIfNull(stateRoot); - worldState.Accept(visitor, stateRoot); + stateReader.RunTreeVisitor(visitor, stateRoot); } } } diff --git a/src/Nethermind/Nethermind.Core.Test/Modules/MainBlockProcessingContext.cs b/src/Nethermind/Nethermind.Core.Test/Modules/MainBlockProcessingContext.cs index 0254f58755d..eede677fe6a 100644 --- a/src/Nethermind/Nethermind.Core.Test/Modules/MainBlockProcessingContext.cs +++ b/src/Nethermind/Nethermind.Core.Test/Modules/MainBlockProcessingContext.cs @@ -7,6 +7,7 @@ using Nethermind.Api; using Nethermind.Blockchain; using Nethermind.Consensus.Processing; +using Nethermind.Evm.State; using Nethermind.Evm.TransactionProcessing; using Nethermind.State; @@ -23,7 +24,7 @@ public record MainBlockProcessingContext( ILifetimeScope LifetimeScope, IBlockProcessingQueue BlockProcessingQueue, IBlockchainProcessor BlockchainProcessor, - IVisitingWorldState WorldState, + IWorldState WorldState, IBlockProcessor BlockProcessor, ITransactionProcessor TransactionProcessor, GenesisLoader GenesisLoader) : IMainProcessingContext, IAsyncDisposable diff --git a/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs b/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs index ffa463c0bfc..d9fcb974266 100644 --- a/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs +++ b/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs @@ -87,7 +87,7 @@ private MainBlockProcessingContext ConfigureMainBlockProcessingContext(ILifetime processingCtxBuilder // These are main block processing specific .AddScoped(mainCodeInfoRepository) - .AddSingleton(mainWorldState).AddSingleton(mainWorldState) + .AddSingleton(mainWorldState) .Bind() .AddScoped() .AddScoped(new BlockchainProcessor.Options diff --git a/src/Nethermind/Nethermind.Init/PruningTrieStateFactory.cs b/src/Nethermind/Nethermind.Init/PruningTrieStateFactory.cs index 64d2bee5df5..4326995923a 100644 --- a/src/Nethermind/Nethermind.Init/PruningTrieStateFactory.cs +++ b/src/Nethermind/Nethermind.Init/PruningTrieStateFactory.cs @@ -66,7 +66,7 @@ ILogManager logManager } IKeyValueStoreWithBatching codeDb = dbProvider.CodeDb; - IVisitingWorldState worldState = syncConfig.TrieHealing + IWorldState worldState = syncConfig.TrieHealing ? new HealingWorldState( mainWorldTrieStore, mainNodeStorage, diff --git a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs index 158a794471f..dccf339d516 100644 --- a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs +++ b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs @@ -66,7 +66,7 @@ protected virtual Task InitBlockchain() "- binary data -"); IStateReader stateReader = setApi.StateReader!; - IVisitingWorldState mainWorldState = _api.WorldStateManager!.GlobalWorldState; + IWorldState mainWorldState = _api.WorldStateManager!.GlobalWorldState; PreBlockCaches? preBlockCaches = (mainWorldState as IPreBlockCaches)?.Caches; CodeInfoRepository codeInfoRepository = new(preBlockCaches?.PrecompileCache); IChainHeadInfoProvider chainHeadInfoProvider = diff --git a/src/Nethermind/Nethermind.Init/Steps/LoadGenesisBlock.cs b/src/Nethermind/Nethermind.Init/Steps/LoadGenesisBlock.cs index 174d34ad215..c4c8e54c916 100644 --- a/src/Nethermind/Nethermind.Init/Steps/LoadGenesisBlock.cs +++ b/src/Nethermind/Nethermind.Init/Steps/LoadGenesisBlock.cs @@ -11,7 +11,6 @@ using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Logging; -using Nethermind.State; namespace Nethermind.Init.Steps { @@ -33,7 +32,6 @@ public LoadGenesisBlock(INethermindApi api) public async Task Execute(CancellationToken _) { _initConfig = _api.Config(); - Hash256? expectedGenesisHash = string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Hash256(_initConfig.GenesisHash); if (_api.BlockTree is null) { @@ -48,8 +46,6 @@ public async Task Execute(CancellationToken _) Load(mainProcessingContext); } - ValidateGenesisHash(expectedGenesisHash, mainProcessingContext.WorldState); - if (!_initConfig.ProcessingEnabled) { if (_logger.IsWarn) _logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false"); @@ -66,8 +62,11 @@ protected virtual void Load(IMainProcessingContext mainProcessingContext) Block genesis = new GenesisLoader( _api.ChainSpec, _api.SpecProvider, + _api.StateReader!, mainProcessingContext.WorldState, - mainProcessingContext.TransactionProcessor) + mainProcessingContext.TransactionProcessor, + _api.LogManager, + string.IsNullOrWhiteSpace(_initConfig?.GenesisHash) ? null : new Hash256(_initConfig.GenesisHash)) .Load(); ManualResetEventSlim genesisProcessedEvent = new(false); @@ -88,28 +87,5 @@ void GenesisProcessed(object? sender, BlockEventArgs args) throw new TimeoutException($"Genesis block was not processed after {_genesisProcessedTimeout.TotalSeconds} seconds. If you are running custom chain with very big genesis file consider increasing {nameof(BlocksConfig)}.{nameof(IBlocksConfig.GenesisTimeoutMs)}."); } } - - /// - /// If is null then it means that we do not care about the genesis hash (e.g. in some quick testing of private chains)/> - /// - /// - private void ValidateGenesisHash(Hash256? expectedGenesisHash, IVisitingWorldState worldState) - { - if (_api.BlockTree is null) throw new StepDependencyException(nameof(_api.BlockTree)); - - BlockHeader genesis = _api.BlockTree.Genesis ?? throw new NullReferenceException("Genesis block is null"); - if (expectedGenesisHash is not null && genesis.Hash != expectedGenesisHash) - { - if (_logger.IsTrace) _logger.Trace(worldState.DumpState()); - if (_logger.IsWarn) _logger.Warn(genesis.ToString(BlockHeader.Format.Full)); - if (_logger.IsError) _logger.Error($"Unexpected genesis hash, expected {expectedGenesisHash}, but was {genesis.Hash}"); - } - else - { - if (_logger.IsDebug) _logger.Info($"Genesis hash : {genesis.Hash}"); - } - - ThisNodeInfo.AddInfo("Genesis hash :", $"{genesis.Hash}"); - } } } diff --git a/src/Nethermind/Nethermind.JsonRpc/Modules/Proof/ProofModuleFactory.cs b/src/Nethermind/Nethermind.JsonRpc/Modules/Proof/ProofModuleFactory.cs index 58fb16c2923..980e516022e 100644 --- a/src/Nethermind/Nethermind.JsonRpc/Modules/Proof/ProofModuleFactory.cs +++ b/src/Nethermind/Nethermind.JsonRpc/Modules/Proof/ProofModuleFactory.cs @@ -2,57 +2,47 @@ // SPDX-License-Identifier: LGPL-3.0-only using Autofac; -using Nethermind.Blockchain; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.Processing; using Nethermind.Consensus.Rewards; using Nethermind.Consensus.Tracing; using Nethermind.Consensus.Validators; using Nethermind.Core; -using Nethermind.Core.Crypto; -using Nethermind.Evm.State; using Nethermind.Evm.TransactionProcessing; -using Nethermind.State; +using Nethermind.State.OverridableEnv; namespace Nethermind.JsonRpc.Modules.Proof { public class ProofModuleFactory( ILifetimeScope rootLifetimeScope, - IReadOnlyTxProcessingEnvFactory readOnlyTxProcessingEnvFactory + IOverridableEnvFactory overridableEnvFactory ) : ModuleFactoryBase { public override IProofRpcModule Create() { - // Note: No overridable world scope here. So there aren't any risk of leaking KV store. - IReadOnlyTxProcessingScope txProcessingEnv = readOnlyTxProcessingEnvFactory.Create().Build(null); + IOverridableEnv overridableEnv = overridableEnvFactory.Create(); - ILifetimeScope tracerScope = rootLifetimeScope.BeginLifetimeScope((builder) => - { - builder + ILifetimeScope tracerScope = rootLifetimeScope.BeginLifetimeScope((builder) => builder + .AddModule(overridableEnv) - // Standard read only chain setting - .Bind() - .AddScoped() - .AddDecorator() - .AddScoped(BlockchainProcessor.Options.NoReceipts) - .AddScoped(Always.Valid) // Why? + // Standard read only chain setting + .Bind() + .AddScoped() + .AddDecorator() + .AddScoped(BlockchainProcessor.Options.NoReceipts) + .AddScoped(Always.Valid) // Why? - // Specific for proof rpc - .AddScoped(new InMemoryReceiptStorage()) // Umm.... not `NullReceiptStorage`? - .AddScoped(NoBlockRewards.Instance) - .AddScoped(txProcessingEnv.WorldState).AddScoped(txProcessingEnv.WorldState) + // Specific for proof rpc + .AddScoped(new InMemoryReceiptStorage()) // Umm.... not `NullReceiptStorage`? + .AddScoped(NoBlockRewards.Instance) - .AddScoped() - ; - }); + .AddScoped()); // The tracer need a in memory receipts while the proof RPC does not. // Eh, its a good idea to separate what need block processing and what does not anyway. - ILifetimeScope proofRpcScope = rootLifetimeScope.BeginLifetimeScope((builder) => - { - builder.AddSingleton(tracerScope.Resolve()); - }); + ILifetimeScope proofRpcScope = rootLifetimeScope.BeginLifetimeScope((builder) => builder + .AddSingleton>(tracerScope.Resolve>())); proofRpcScope.Disposer.AddInstanceForAsyncDisposal(tracerScope); rootLifetimeScope.Disposer.AddInstanceForDisposal(proofRpcScope); diff --git a/src/Nethermind/Nethermind.JsonRpc/Modules/Proof/ProofRpcModule.cs b/src/Nethermind/Nethermind.JsonRpc/Modules/Proof/ProofRpcModule.cs index 0cecb3bce38..dbf22def65b 100644 --- a/src/Nethermind/Nethermind.JsonRpc/Modules/Proof/ProofRpcModule.cs +++ b/src/Nethermind/Nethermind.JsonRpc/Modules/Proof/ProofRpcModule.cs @@ -4,6 +4,8 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Runtime.CompilerServices; +using Nethermind.Blockchain; using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.Tracing; @@ -18,6 +20,7 @@ using Nethermind.JsonRpc.Data; using Nethermind.Logging; using Nethermind.Serialization.Rlp; +using Nethermind.State.OverridableEnv; using Nethermind.State.Proofs; namespace Nethermind.JsonRpc.Modules.Proof @@ -25,39 +28,27 @@ namespace Nethermind.JsonRpc.Modules.Proof /// /// /// - public class ProofRpcModule : IProofRpcModule + public class ProofRpcModule( + IOverridableEnv tracerEnv, + IBlockFinder blockFinder, + IReceiptFinder receiptFinder, + ISpecProvider specProvider) + : IProofRpcModule { - private readonly ILogger _logger; - private readonly ITracer _tracer; - private readonly IBlockFinder _blockFinder; - private readonly IReceiptFinder _receiptFinder; - private readonly ISpecProvider _specProvider; private readonly HeaderDecoder _headerDecoder = new(); private static readonly IRlpStreamDecoder _receiptDecoder = Rlp.GetStreamDecoder(); - public ProofRpcModule( - ITracer tracer, - IBlockFinder blockFinder, - IReceiptFinder receiptFinder, - ISpecProvider specProvider, - ILogManager logManager) - { - _tracer = tracer ?? throw new ArgumentNullException(nameof(tracer)); - _blockFinder = blockFinder ?? throw new ArgumentNullException(nameof(blockFinder)); - _receiptFinder = receiptFinder ?? throw new ArgumentNullException(nameof(receiptFinder)); - _specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider)); - _logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager)); - } - public ResultWrapper proof_call(TransactionForRpc tx, BlockParameter blockParameter) { - SearchResult searchResult = _blockFinder.SearchForHeader(blockParameter); + SearchResult searchResult = blockFinder.SearchForHeader(blockParameter); if (searchResult.IsError) { return ResultWrapper.Fail(searchResult); } BlockHeader sourceHeader = searchResult.Object; + using Scope scope = tracerEnv.BuildAndOverride(sourceHeader); + BlockHeader callHeader = new( sourceHeader.Hash, Keccak.OfAnEmptySequenceRlp, @@ -87,7 +78,7 @@ public ResultWrapper proof_call(TransactionForRpc tx, Block Block block = new(callHeader, new[] { transaction }, []); ProofBlockTracer proofBlockTracer = new(null, transaction.SenderAddress == Address.SystemUser); - _tracer.Trace(block, proofBlockTracer); + scope.Component.Trace(block, proofBlockTracer); CallResultWithProof callResultWithProof = new(); ProofTxTracer proofTxTracer = proofBlockTracer.BuildResult().Single(); @@ -97,33 +88,33 @@ public ResultWrapper proof_call(TransactionForRpc tx, Block // we collect proofs from before execution (after learning which addresses will be touched) // if we wanted to collect post execution proofs then we would need to use BeforeRestore on the tracer - callResultWithProof.Accounts = CollectAccountProofs(sourceHeader.StateRoot, proofTxTracer); + callResultWithProof.Accounts = CollectAccountProofs(scope.Component, sourceHeader.StateRoot, proofTxTracer); return ResultWrapper.Success(callResultWithProof); } public ResultWrapper proof_getTransactionByHash(Hash256 txHash, bool includeHeader) { - Hash256 blockHash = _receiptFinder.FindBlockHash(txHash); + Hash256 blockHash = receiptFinder.FindBlockHash(txHash); if (blockHash is null) { return ResultWrapper.Fail($"{txHash} receipt (transaction) could not be found", ErrorCodes.ResourceNotFound); } - SearchResult searchResult = _blockFinder.SearchForBlock(new BlockParameter(blockHash)); + SearchResult searchResult = blockFinder.SearchForBlock(new BlockParameter(blockHash)); if (searchResult.IsError) { return ResultWrapper.Fail(searchResult); } Block block = searchResult.Object; - TxReceipt receipt = _receiptFinder.Get(block).ForTransaction(txHash); + TxReceipt receipt = receiptFinder.Get(block).ForTransaction(txHash); Transaction[] txs = block.Transactions; Transaction transaction = txs[receipt.Index]; TransactionForRpcWithProof txWithProof = new(); - txWithProof.Transaction = TransactionForRpc.FromTransaction(transaction, block.Hash, block.Number, receipt.Index, block.BaseFeePerGas, _specProvider.ChainId); - txWithProof.TxProof = BuildTxProofs(txs, _specProvider.GetSpec(block.Header), receipt.Index); + txWithProof.Transaction = TransactionForRpc.FromTransaction(transaction, block.Hash, block.Number, receipt.Index, block.BaseFeePerGas, specProvider.ChainId); + txWithProof.TxProof = BuildTxProofs(txs, specProvider.GetSpec(block.Header), receipt.Index); if (includeHeader) { txWithProof.BlockHeader = _headerDecoder.Encode(block.Header).Bytes; @@ -134,35 +125,37 @@ public ResultWrapper proof_getTransactionByHash(Hash public ResultWrapper proof_getTransactionReceipt(Hash256 txHash, bool includeHeader) { - Hash256 blockHash = _receiptFinder.FindBlockHash(txHash); + Hash256 blockHash = receiptFinder.FindBlockHash(txHash); if (blockHash is null) { return ResultWrapper.Fail($"{txHash} receipt could not be found", ErrorCodes.ResourceNotFound); } - SearchResult searchResult = _blockFinder.SearchForBlock(new BlockParameter(blockHash)); + SearchResult searchResult = blockFinder.SearchForBlock(new BlockParameter(blockHash)); if (searchResult.IsError) { return ResultWrapper.Fail(searchResult); } Block block = searchResult.Object; - TxReceipt receipt = _receiptFinder.Get(block).ForTransaction(txHash); + using Scope scope = tracerEnv.BuildAndOverride(blockFinder.FindParentHeader(block.Header, BlockTreeLookupOptions.None)); + + TxReceipt receipt = receiptFinder.Get(block).ForTransaction(txHash); BlockReceiptsTracer receiptsTracer = new(); receiptsTracer.SetOtherTracer(NullBlockTracer.Instance); - _tracer.Trace(block, receiptsTracer); + scope.Component.Trace(block, receiptsTracer); TxReceipt[] receipts = receiptsTracer.TxReceipts.ToArray(); Transaction[] txs = block.Transactions; ReceiptWithProof receiptWithProof = new(); - IReleaseSpec spec = _specProvider.GetSpec(block.Header); + IReleaseSpec spec = specProvider.GetSpec(block.Header); Transaction? tx = txs.FirstOrDefault(x => x.Hash == txHash); - int logIndexStart = _receiptFinder.Get(block).GetBlockLogFirstIndex(receipt.Index); + int logIndexStart = receiptFinder.Get(block).GetBlockLogFirstIndex(receipt.Index); receiptWithProof.Receipt = new ReceiptForRpc(txHash, receipt, tx?.GetGasInfo(spec, block.Header) ?? new(), logIndexStart); receiptWithProof.ReceiptProof = BuildReceiptProofs(block.Header, receipts, receipt.Index); - receiptWithProof.TxProof = BuildTxProofs(txs, _specProvider.GetSpec(block.Header), receipt.Index); + receiptWithProof.TxProof = BuildTxProofs(txs, specProvider.GetSpec(block.Header), receipt.Index); if (includeHeader) { @@ -172,7 +165,7 @@ public ResultWrapper proof_getTransactionReceipt(Hash256 txHas return ResultWrapper.Success(receiptWithProof); } - private AccountProof[] CollectAccountProofs(Hash256 stateRoot, ProofTxTracer proofTxTracer) + private AccountProof[] CollectAccountProofs(ITracer tracer, Hash256 stateRoot, ProofTxTracer proofTxTracer) { List accountProofs = new(); foreach (Address address in proofTxTracer.Accounts) @@ -181,7 +174,7 @@ private AccountProof[] CollectAccountProofs(Hash256 stateRoot, ProofTxTracer pro .Where(s => s.Address == address) .Select(s => s.Index).ToArray()); - _tracer.Accept(collector, stateRoot); + tracer.Accept(collector, stateRoot); accountProofs.Add(collector.BuildResult()); } @@ -193,7 +186,7 @@ private byte[][] CollectHeaderBytes(ProofTxTracer proofTxTracer, BlockHeader tra List relevantHeaders = new() { tracedBlockHeader }; foreach (Hash256 blockHash in proofTxTracer.BlockHashes) { - relevantHeaders.Add(_blockFinder.FindHeader(blockHash)); + relevantHeaders.Add(blockFinder.FindHeader(blockHash)); } return relevantHeaders @@ -207,7 +200,7 @@ private static byte[][] BuildTxProofs(Transaction[] txs, IReleaseSpec releaseSpe private byte[][] BuildReceiptProofs(BlockHeader blockHeader, TxReceipt[] receipts, int index) { - return ReceiptTrie.CalculateReceiptProofs(_specProvider.GetSpec(blockHeader), receipts, index, _receiptDecoder); + return ReceiptTrie.CalculateReceiptProofs(specProvider.GetSpec(blockHeader), receipts, index, _receiptDecoder); } } } diff --git a/src/Nethermind/Nethermind.JsonRpc/Modules/Trace/TraceModuleFactory.cs b/src/Nethermind/Nethermind.JsonRpc/Modules/Trace/TraceModuleFactory.cs index 0124dfdf416..0108e003645 100644 --- a/src/Nethermind/Nethermind.JsonRpc/Modules/Trace/TraceModuleFactory.cs +++ b/src/Nethermind/Nethermind.JsonRpc/Modules/Trace/TraceModuleFactory.cs @@ -44,8 +44,8 @@ public override ITraceRpcModule Create() ILifetimeScope tracerLifetimeScope = rootLifetimeScope.BeginLifetimeScope((builder) => builder .AddModule(env) - .AddScoped((worldState) => new Tracer( - worldState, + .AddScoped((stateReader) => new Tracer( + stateReader, rpcProcessingScope.Resolve(), validationProcessingScope.Resolve(), traceOptions: ProcessingOptions.TraceTransactions))); diff --git a/src/Nethermind/Nethermind.State.Test/StateProviderTests.cs b/src/Nethermind/Nethermind.State.Test/StateProviderTests.cs index ecb8b298176..89f27f46714 100644 --- a/src/Nethermind/Nethermind.State.Test/StateProviderTests.cs +++ b/src/Nethermind/Nethermind.State.Test/StateProviderTests.cs @@ -63,32 +63,6 @@ public void Eip_158_touch_zero_value_system_account_is_not_deleted() ((WorldState)provider).GetAccount(systemUser).Should().NotBeNull(); } - [Test] - public void Can_dump_state() - { - WorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); - IVisitingWorldState provider = worldStateManager.GlobalWorldState; - provider.CreateAccount(TestItem.AddressA, 1.Ether()); - provider.Commit(MuirGlacier.Instance); - provider.CommitTree(0); - - string state = provider.DumpState(); - state.Should().NotBeEmpty(); - } - - [Test] - public void Can_accepts_visitors() - { - WorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); - IVisitingWorldState provider = worldStateManager.GlobalWorldState; - provider.CreateAccount(TestItem.AddressA, 1.Ether()); - provider.Commit(MuirGlacier.Instance); - provider.CommitTree(0); - - TrieStatsCollector visitor = new(new MemDb(), LimboLogs.Instance); - provider.Accept(visitor, provider.StateRoot); - } - [Test] public void Empty_commit_restore() { diff --git a/src/Nethermind/Nethermind.State.Test/StateReaderTests.cs b/src/Nethermind/Nethermind.State.Test/StateReaderTests.cs index 5a857604362..8f021ad4654 100644 --- a/src/Nethermind/Nethermind.State.Test/StateReaderTests.cs +++ b/src/Nethermind/Nethermind.State.Test/StateReaderTests.cs @@ -16,6 +16,7 @@ using Nethermind.Specs.Forks; using Nethermind.Evm.State; using Nethermind.State; +using Nethermind.Trie; using Nethermind.Trie.Pruning; using NSubstitute; using NUnit.Framework; @@ -362,5 +363,31 @@ public void IsInvalidContractSender_AccountHasDelegatedCodeBut3807IsNotEnabled_R Assert.That(result, Is.False); } + + [Test] + public void Can_accepts_visitors() + { + WorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); + IWorldState provider = worldStateManager.GlobalWorldState; + provider.CreateAccount(TestItem.AddressA, 1.Ether()); + provider.Commit(MuirGlacier.Instance); + provider.CommitTree(0); + + TrieStatsCollector visitor = new(new MemDb(), LimboLogs.Instance); + worldStateManager.GlobalStateReader.RunTreeVisitor(visitor, provider.StateRoot); + } + + [Test] + public void Can_dump_state() + { + WorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); + IWorldState provider = worldStateManager.GlobalWorldState; + provider.CreateAccount(TestItem.AddressA, 1.Ether()); + provider.Commit(MuirGlacier.Instance); + provider.CommitTree(0); + + string state = worldStateManager.GlobalStateReader.DumpState(provider.StateRoot); + state.Should().NotBeEmpty(); + } } } diff --git a/src/Nethermind/Nethermind.State.Test/WorldStateManagerTests.cs b/src/Nethermind/Nethermind.State.Test/WorldStateManagerTests.cs index 541abe7374a..764d146d52f 100644 --- a/src/Nethermind/Nethermind.State.Test/WorldStateManagerTests.cs +++ b/src/Nethermind/Nethermind.State.Test/WorldStateManagerTests.cs @@ -25,7 +25,7 @@ public class WorldStateManagerTests [Test] public void ShouldProxyGlobalWorldState() { - IVisitingWorldState worldState = Substitute.For(); + IWorldState worldState = Substitute.For(); IPruningTrieStore trieStore = Substitute.For(); IDbProvider dbProvider = TestMemDbProvider.Init(); WorldStateManager worldStateManager = new WorldStateManager(worldState, trieStore, dbProvider, LimboLogs.Instance); @@ -36,7 +36,7 @@ public void ShouldProxyGlobalWorldState() [Test] public void ShouldProxyReorgBoundaryEvent() { - IVisitingWorldState worldState = Substitute.For(); + IWorldState worldState = Substitute.For(); IPruningTrieStore trieStore = Substitute.For(); IDbProvider dbProvider = TestMemDbProvider.Init(); WorldStateManager worldStateManager = new WorldStateManager(worldState, trieStore, dbProvider, LimboLogs.Instance); @@ -52,7 +52,7 @@ public void ShouldProxyReorgBoundaryEvent() [TestCase(INodeStorage.KeyScheme.HalfPath, false)] public void ShouldNotSupportHashLookupOnHalfpath(INodeStorage.KeyScheme keyScheme, bool hashSupported) { - IVisitingWorldState worldState = Substitute.For(); + IWorldState worldState = Substitute.For(); IPruningTrieStore trieStore = Substitute.For(); IReadOnlyTrieStore readOnlyTrieStore = Substitute.For(); trieStore.AsReadOnly().Returns(readOnlyTrieStore); diff --git a/src/Nethermind/Nethermind.State/IVisitingWorldState.cs b/src/Nethermind/Nethermind.State/IVisitingWorldState.cs deleted file mode 100644 index 9c910919111..00000000000 --- a/src/Nethermind/Nethermind.State/IVisitingWorldState.cs +++ /dev/null @@ -1,30 +0,0 @@ -// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using Nethermind.Core.Crypto; -using Nethermind.Evm.State; -using Nethermind.Trie; - -namespace Nethermind.State; - -public interface IVisitingWorldState : IWorldState -{ - /// - /// Runs a visitor over trie. - /// - /// Visitor to run. - /// Root to run on. - /// Options to run visitor. - void Accept(ITreeVisitor visitor, Hash256 stateRoot, VisitingOptions? visitingOptions = null) - where TCtx : struct, INodeContext; -} - -public static class VisitingWorldStateExtensions -{ - public static string DumpState(this IVisitingWorldState stateProvider) - { - TreeDumper dumper = new(); - stateProvider.Accept(dumper, stateProvider.StateRoot); - return dumper.ToString(); - } -} diff --git a/src/Nethermind/Nethermind.State/IWorldStateManager.cs b/src/Nethermind/Nethermind.State/IWorldStateManager.cs index 6f509a8d091..bcfe10baa99 100644 --- a/src/Nethermind/Nethermind.State/IWorldStateManager.cs +++ b/src/Nethermind/Nethermind.State/IWorldStateManager.cs @@ -13,7 +13,7 @@ namespace Nethermind.State; public interface IWorldStateManager { - IVisitingWorldState GlobalWorldState { get; } + IWorldState GlobalWorldState { get; } IStateReader GlobalStateReader { get; } ISnapServer? SnapServer { get; } IReadOnlyKeyValueStore? HashServer { get; } @@ -22,14 +22,14 @@ public interface IWorldStateManager /// Used by read only tasks that need to execute blocks. ///

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%0A)1ZA1T_i8Cb;_!bf} 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 z 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 O@Fs(%CIi4A=>GthD6zHx diff --git a/src/Nethermind/Chains/lisk-mainnet.json.zst b/src/Nethermind/Chains/lisk-mainnet.json.zst index daedd2f5f5951c702f95f5d59fdf658815181dd9..df436ecac706cefdf382514c1702cd7a4bba1135 100644 GIT binary patch delta 9031 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 diff --git a/src/Nethermind/Chains/lisk-sepolia.json.zst b/src/Nethermind/Chains/lisk-sepolia.json.zst index 97a89d050b062f3a6e18e14159567bf950736305..f14f833bb8c6bfe83ddd312188cc7a359db0b9e5 100644 GIT binary patch delta 12135 zcmb7}Wl)|m+oo}Mch};s1s>d;;_~2L+~LOE-QC?vODXQ|UfkWaP`3Mi@6PPc-6Jz+ zW|B#A{)kMjE3XcwtO*8S_{R1QtrLy{NtJsA@l!yFg$W}{64o1HuA`6m2DjfKc1f=w z8sSai8e2TfAKKC|6o-|{0wzP*D zlF?c0;GGA))eT{bbXrKP@+q%R*6On+gJB)LGNbx=H55pxmq88Kr@QIIiHyk#i}$j& z4#d#m36fCrWd;RZ+XOSK4R*>5Vq56)+XY92Bg`RbB0@7v^c^FF!$SL7W@V~!+2X{b zHzU%U^!=a$fBk2h8~&=QS~Y>pBzaldAEEF1q3-VRO;-?Mzq^ zHOVs+d|hGG$2kDPtlsz=g{Y!nFK$fPG#*WS7}V?~=4I0d5zUrZ2`%JR5Fj9vD83`LQ+Y{8Usp>|YY>9(LPU|J3tAzraQ&M(NVgUr0>;wv+_67!qLW?*c+EFLS z3t`hbUk|>K!ct<;|6&1Ch;j1^_n6?}5e0{es}vh#d6YAv^riC*>V6R;lSQxIGM7Upgg>xD#~DrH}}-QGrOB~LX9 z?NATxZv})9%n@y{p3%dDAYr{soC%1q5Oo3*8LCqX!R!o$+kvoqC^oK24aw_=Zn(Bh zc~zv=5*;UBVQuJVZ-6(;C7G+ zO0H)xX3>X=Af^4Fkr?n8_{BgFc#_P=r)YU~*#MO;2nS{yr%WJhu@VNHc=udLZ)(gk{|J{F|`12x8p0bUmzVGq< z9A9rr`8N7^-g&#V{t;p2$}(&f`Y34FAZohqiWHS6Sw58kmP^O^x-4X1hf0Irgj9gx z35b=VK>Q6u^a#%d>JJW)W5Aw03^IW!1w-y^W1?8@G*S#f3^DjYG8Gfzp%4)$273n< zQOXjOm{1S}6@j6`>0;dVBH>UdA_H}-359t|!9|e4oev|Cuo9xeVlsow=%`5iZtA)- z?A(&v7#igWln@w@1E!QveI#NaHasE{AQl>lDo}?RqwF633fZ??v$H*{JFMUtNl(8$1>ZqUKErY}uDvxbeL*v8 z9Mb(3Ez2aM!_37bjzAguANfCh1ZHlY{{z>5xw`xx zs{f1Sf1&y>n;ZW_)_>6gwEl-Yap^nTUEREZDJ`wgJ6RA*pMf+}YM32~gjps?USM=s zR-I8j-|Ph8p1+3V=l)Q8HOS1WWhE8EOe#UZ?$x}GtY5uum=>GViyd`Tnb(5FHTBLk zvF7xBD~mOZc;XYOUyFp*LIGnYo!C;h+LGB3H+f8)T zxUXo)W>|?ZlRc)rV9chOz#v2_JabIQS!5(>5p-0{0cK`ynpicHffQ#BI;=&!#mnh* zM?7f>W-R-fMCIW>rkiIC{o>N1h*yp5Hu4fw|E|cE^nce9O(85294bJ-Ok)iP6X|t~ z08fF3tV4qn4u^`6=Z0tvspcdGP1IP3KksA-MUK%&x818izfDE+36c``r_wJEr=D;S zy$KZ&zZf&tzr$)01bSXo&7xtbLHVT)BPGsiNLdZ4425Y81kYk5!tc%W1W5wiUfz`w z(^Zt*rLqp_8SsBj19Eh4`u6z zYvqi%%WF%hc8=Pt$;$=26S>X_37ea%#yM}C0j)LIb1HnS5~8TDcQ|W@e;KlBiRk`T z&lXttrulq3{%)}`pCAa_2NjO)K_ z*evGT6$-qDQgYy_f$@7DD?V)8y5A1C393Kx4SS?a6e8{k^A1);alZT4xX~(AGFDc!a??$o4qDzRp)pSBS%!^M zW@A4up+NCGx^t2|Gr2Y4WK^Cdfcp9GZ2Y>8d|yJH)J*WqZxkBe zR2SDO)&|f0%S)t~gvd2Wkk+HE8*5&wi5e)4{-L%mA`=CE4RF7e5-;2v9o$Gq_^V%Mqi0mfgqLsKTL zks5^tf*29XaF=vPpP&Il2LU1esS9~m;YEAP{@e0;3 zsq5qZNe1z!z$GotPc2wDELLzB`*FVNeA95Ocg(xg?O&s20`7JAyfXwCV-lQiymYgj z8{Y4}%M3G4OByx!WG`ZoemN)8cf3}(EX#Za)~NH^c==RfPeM*nw7T=9wX~+e-!)^u zc>huU z8)p{H>6aYv^*-THhOlfpood?Le;!o^_CiWJ z`d4K1^7A16>{$x>a>3e!;|^2^AJ(FY;mV7pX+z99@|1`3^y~QrJ}jL%)Up9S;lk~b)?>-zzd>Wy~)aiS0>9XzuvO_-;r&EeHu z1bhCuh}43EK7kG<^%1PSXq$?kOm*N!;&2Ra{10Zhb#io=1;{&%MF|epX!$}sXcw-? zh9CqiY8FB<;Wxt7fp4R?4N#CB`349Fv_#pYi;M<8m9ds#kU|z zdR8FTSH@!hMNNc(*tDqbqrO8CVbpYNaW?j@bM~#JVNF#$@OVO2Q!ic+zUbMF$UJm- zTv-J}5y$WAkPL8t!3*ymel?qo`{LuAgd@JYi)MsQ!pX*S2ix#6^ z&@sTeJG+QPnE`@ZNe%DRgz;ZYf<@{tpWfYr*XG{2_Gn7y@`E~fq69JP!}$}2dgwye zG4=zB8bX{#@bk5vlvE_qUs=0Fp-XF}2XHjzKam^r4+9lqSa4Fun$BQ?UrXnP=~kW0 z(V$uFtQg8Y<6ZB-kc&aP@hRmJ>DO(b7Jm*N&FXmrOuSmDtPMGm@K)4 zC{<_V%<;8nq0@D&MJjhVNhW<`6HPlg1+{pHQJD1``Ua)&m9f$qNjXz8nwatWS*2)r zPx;NI2y0X%skr=qkJ69+G}mHm4zx1*?{jK5D8TZeOHz2nfT5~s+c}b)3eU7_@%Cx9 zPl)0VSRTU4^Rx5Z&^{SUPeJ2*J`}W5Fk@zSP2weBVi>Lk-BW{wXZC4!m20yA>s77h z6J|QKwF2?En_Qb{hSY%pfi>XR$@}qUNnmBowHcW|&!vH)j_s>pSj2?oQ zfqk`|cUSe%sQLPHe74q>(5>g_4)ivRr6=o*{L53G>t6pn|9N%%pkNip(6`WxelvV2 z){6RtviN+kVu5cUyMwv*t6Bt2eqoCF1fZZuvt4q!o%VHQc=MS5u6vM=x4*JZI0TA7 z3WmWdZu!8>L#WDJdb9@VmdFCdB)67gyXGM3X@aToVfb^*g87}>+$`D@`WuINjzc0p*HSNO` z>%QY~^C)5jk$9MjO5s0H-d>|Ej4e8BTJ3VaOd6{%iLW?{-9c*p=?iPk2&dy09gKIA z3WD?+<>|O5*ZO;Mc)Kbe-fyYIp@2uN;zY~f_ywY3K+7^j%|YtoyQ0p%YB&aMm-9Qx z7JnRKjWJy3vynLzC6!g`RYp8XJd;)Z*Ms`joBi^^4$KcfaM&ddskSR?DhJaN>z8n? zu`5O7VAOm4lzaB``~n_bd`%lppw&w@$G^amESWdA7Mt~VcC*P5=>jpr_>- zlc&fN;@W!T)J^&3xcY?1l33#q_LTCowOAuv8YA^LBnGCexQhzKmP<%}@h=i_+xBp$ zClj7?Oh+?eTLXj^yDbeDt(dgUb{~W+3JcpECYziwK_;5YF2}&u4nb4u15@~*2u&{= zX8P57s7KQ5b*CCSVqsH{U;v7a^}vR-i$aGJfcD(KAvK$Qv`N*q(+xf~2G+2zyWlfl8#@%Jqc^W(_6c zT@igkmV>NHAL2`jFgDIO$MUjH02B0u;f}V0nzt`PPsvHc%*S5Q_%(zyTYZW}fss<)`kOXWX+gBx z`^Ub^LN9Pw=6Op6;)s)ERRRvo@oB9W&bf*FZ%k>&4t7)$8kVgr#fu)SG{ALA#X zxVpC8yR+gWum8E3Uj1{O>RkIqh6E;{zRU8$=uoVA*Nars+%V$o7Z#Uc(93A%jHuVD zzO{vmpzhZEzNer*+~jD-rP=a~C(c)W&Idv{bu4PxuXEmxD zuWvEZ_U^8c`vhw~tch?8!aJaZW`d*-7ud3#i5tyhxi$KO1cvE-oX%q5BL3_`z=dcv z@Y_?9M@;XhseU!-9G8Im3MfZL4~DHWvv&IRkqy#~KW`2J1?4BsHB(eRgV5nw>aLXz7uDCh8$)wY8a;xN59hNSBiqH!Q3IFcazn-=-KHTs2g9e<#O zc=QK<3Mym&kd@$9d*&8<5p2-c-z7KItKj_CXcvlc^t8`^7ex^s3hzJPWbynNBt;*_ z>KEUwyx~)tlj&}XzK9G=UBp~)-m2^F|Zi4fvg)Q@Rs;S(pTg767c= zOK0N#aL~|tS8W&^axygf)qkp{@y)rb8M>#~zt>(%2rHNdP|ZNoIs(RWB%r2pf8s~_ z$8O9zyZSKLlzg6MEhQSP1f1_5gIx~Hi3O&goEG7ynMohL_u*)B-XL&2a)T5C#0hQ5 z7J(7isRrU?*B)=6H?mh_+#!3MK5Y^Hq>>rCWzt0+U|dm}ENj6D=2WuP!H+{sIpsBX z4R6aS?5e+X+eR;DDdb;7ujwE>9dmiK*(w;pDtqLg53M+neh}Q(lodyyzC{q39Fsr2 zkNk`r5gvJ{JP&>zdw!9ImbIt0|64?k0@R7Z2UZ7FQ@+1neX!?_N*2po3WmI9w@KK}B2b6XN6ZmC6bdwCe*s$bkx-;I~4FLbR z4`TD%lzMY`JHC&vf6wDmYo>gHOzW@s7k98OZ=L=9peilXBZQQ06O}~-53`O)P5<|Enc_rL7<+bTHpR;8s0a6J?y+2-+*^s6Z9G?wUX51m&vy9|;_0S`oQs*mU~QI; zQRs5WSCIx?yD&Szc8x2@FK}mZytaNrCqt>heW=y|(uKwwSJ;CqjGoKu8NgfMmUh}Q zz+;NZk~lt?rcAAPxvw-+$M>53t%Rgru{$nwDk;mT_)YPFP&JgZaWk{aafMA7s<>-H z`q2JEoJVUOA7kX4RgarF#z^-tt-yiT`yi9ax9w$rjI-vg{c!Zt_^;cRNxB9SSBq)h z0s~#kG|^>YU5hO3fVS2BG{CI>eDyGeX}tFKD4V{9`EG2QH|LkjMB3+dKNpKEt-l6$ z=4lp2FRPX*+VSnpRyiv5%q?RDcKNl<6HKD(_P1jk+K={kqiGgjUR)r~ta6l$ z1P;gY9YorjCq4o7-pym24R7`>qfEmFt1XlC+UdFn(>y9){^J(-|Fir5=vJ2}LG1Kr z=m47Wn?uVevW&q>(;z&4y0zADohn`^p&BE;n{MKEoY7=CFzz<)pE*hVy__`=HYIb@ zaT;j`9?`T32#wQ zW-qR6B`pI3K-7v;w1Kjo%d?&z>3np%Wb{p1B!uFd$PrCc9f_bcxu zZxsE7yP|~dqyXobSQ!P63Tckm(NXl3CCKlUqw$Y05Q>(jZZsDf^5Yb&4)eLh!->=m zIm~}E{qb;D-~3xd*uiRUQl005thbd?4rZq!-XK}tf;29oFp>hT9^~l~W$=3-h%+_; zTfW2D;k`W7dCj)*+i|UJ^pOx~EI4wzC!D?%zxuZS?Z3bkTAhl| z9P_JV>?t(~VxP5S-WkscwLh(WKbmMen7VHS!mLdQCs4@wxiMI>bTubC#->ksjSkiCx2&;nE(<}^gk_6$ z=3!m_VG}T2tGj9^^b%Uami80Os5d-qt-miOJlw=K(#IgVvjwEhvc6isN|t59YE^Rp zOC(A+$I~7YP$Z4NagEMe$A@U1VPv;ddSg+=)X*8nYWx4DAaDHqiBpiXlr613Vc6zr z%}eO6`w?z;{YA(w&<#;>?G}IGbmo=qkoLMtx^(P-*zy}A2KHp5>b1N9diy|8(F`(! zM(rCB{o7^=*qx_+9>k)=)6=pvqMgMDq=dW|^6qPiJ}D%;qRi7**%GsuY1`<#Z+mpv zdsx;>%3jCY1nOx0WhT?Az0{1Ff#^Ahk1qw(ET}od((xgGNG#>FtndCLc|ne_a?J<` zYV)1b!Nd|~l<)lACshThGdMS%(4$#aztlkm1xR7o69hZ9C#n&NAj&aEaCR*Mfd$E2 zV5ugA4E0H*8%*!QN7+?|)1(D(qAG+_{;U=JBm9d|NkF@ujeO=}@@uf6z~>u@&lEE< z+(-~9aA@U;v%j)+EVQ)T6)8({yj7l1*E;UwIY#8O`zjWX3No#eQ8~gBgC@I2YpAKU zCn`yo4AHJ8s@Y8|xAWD*d6M7&toTStZW=PIKnyW34h-fm@jwg;7zFV|j9Q9+xh`>- zFiNU`?irC45p!~Ta%=KN^j7qxNXS0!?bQgix#O|;bgVuyYFtMHM(fouj=?x>vGeN{~XNd_+1u5bi<9M zZ6ZG!#>j#n`OJaA4>t;^ayUW3_(C8V?jxf%9zeFb8cbcTw@Dq z9~O8!rQm#_Lr-ld`B8F#1kZX`cXmWE#ML}pJLGMiZ*O=7g(J6WqGrf7d*1%v7^0}jq99Th?lOVzm=IqstgM4zcMI5r7kJG0vN?njJ`i2`(HO^y#_&k^P-k= zls9)7N8qwEakXi7ccrweARg~lar6>DHK!m@YYnx6?4I5Jibusw1^&+0s~t+u{<|7{ zpL`oSSBm)xjyk+&{#op7Ei@1PLqL9^7DOIcHiW zlg{rM11ynBDSnDK`u$LqEqjB?n z(`m$3Eo#D3$XB?hbu#ZpghJcn`Z_hquvVkPfXpN*DOtLB?>&{98=8L{MfP{UHcp95 zF>tgXv&OnlEu6s8g{x`-k(P=s0*~%{@*tM#9H4V+hG-OpT3MZ(W5Ao(n0%Z(Gjd`= zfwVIcOA*)j>(8TL&NqZ!%4g+6<>uwSUt1N7#gu+45#S5E0%B$qqfA)@UJ?j&Gck#t z*;u_~p-`D5qsg0IW~9-Rof%Rl1Pnc=n-P8k<^hO~e%YV}v3^Qq&DPLHBy)jN!v2!w zGvEZii8rC&6*2=dG`y0ly^pLU>t8tB0%r~q8{6bxJRB)9RASbN0R|E#L=;;LDmHvJ zNeoL;4k?5}8dDqr^q-Wnq*$axd2M;A6YTcyh~kU>lgFSMf7K_ET#pM0mj&dzYyu4D zt7|*HZ953%^ z%cF7a{d|Q8ec?F}Y+UGzqtr`g(2W;T>r{sDdTn~Hb%BW9bi$6`*0syH5^BH}6!=rb>H+E_oTmAmHBcanv}xc9N8{E(*pdV^RAEFQ zaHdMa+RN%n{1sbWqE@xN!TGy_lk|!I95J<)gdw5EIiG%JQRR}6FDXMaH@J|52&+pb zpv2nA-Z9)kow$sMue!xJ%wO%1tR%EOJ^Ytj-@bY3@?9WU0K7>&FZGR=8X^!e#^|nG z9_xeESq8Agr9NFde+@$KoGO99cxVzMy%CuJDOqWim}(?37QZ;aoS6zgVh1pE;GFDQ=1W- zda6>g??~x1dogRdd0bK5X?~zwrf{D$vtSsws9<0EE-xa1){dlGgrO(*Vej~oUZwA{ zr)_7MkgX|E%2-j2LloEVes#>EXfN7QrpG!+CydP+Yu~)O$Mq6w*era16O&;$ir$ZkE8PZXJvJIwbhYDl)ZWj^n#z-s z5cIiC##gaa;(9)LT%@C3mF6ilCbHmuTgc4dVEHYSD%A!iu8$OOH)<=(j3-u@i1?(? zx}d^=`cw*vgSG#c&8eO5)td56{>$@J{UgM-tiAbdMBO3G7xBHQ?oG7|k4?^Nl2G6% zn5t7kuy;7)-D!l*#cgV@a)8ViG-IG}!Smy~*1!(lzv2r11*Yvxu*-(Bshkc&15E}Q z(nq5J#S@N}7;*t{0+(Fql5Y0$dRQ!S+u zno&H1({?&lO2&+=&zdOY8{oXv1pV zEHD?uMG2ixp^Wk;@~)#^lKgi&dyq|loPj`Ga4eCB@p%mZIJ#TC|O zIgGMWTnGu|z~i=&W$n<@ARvXy`j ztbSo#9g>7Gsr4V5&N?|;iLF4MOwaAYCK~pHVup{vhFDR=$}^04zPB4bQm|i^Pj77}5N|HhJfefO1mb`wrYBYD9m&dO*_~2sa38EsX9rdch&Dn56pUZS zaBTbHx-WbbnFNAypR1B-eHB;!FeqxzrgH(wk{8>XX_>Q56XyZxh)2vF@BH6ybL`ik zM}>Ht=@EUo$prTcE{wp1K1*}M#5{uVf}y}9*%e6UDsWr1+n$mkB+cn|;t!kT{@gEHzB*u|o(~q>)ba#RCbs)lSeBe3k`eH`&bD zlfW5pzMGI1Wg^PX)6ykmJep3xn=52^RVDH8B7Xeo3hbbKg^&^M&>#dKK+YN+xruD5D~d&>kXB3QAU>bOqT4g@TTZVl2r z=Ogv%V&MQ?GgCbHFBOz;JYmo(N=-;Li_5mssxGNvQePa9wamTlGrcYNK}w;1E31@o z{6ivs+~{I7~+A z+Rqm4p)i=oLhwweo*A%Qq2r`uPEKx9VAst)E8OTBTYTJ`=6-q_F#r@h!;pM}(?nT_ znf8Ny-IG$uuW(K3jGvAYS{CFNT(lQBz6wXCuU*I=ZWsuD6Yq`cE-y^`{#AUEHoSWy zm(YOnYa)D(PpNXN7HxgVnVH!6)no;w#j$&sOrsqYl&xUa=@$vl-#$}P`jBw0;Yw{t z>sm0{vr{EyK$+g}4Furc`l@!hH&b}}?e8%yrAPL;%KZilLUI_>`7{8bZMgg2W zW)LaCFVAQ1@6E7jbt&qH0xu7HQ?v97b?}iK{xJ38?W!up%sL-Bb`$PL55%oM)dCHd zppzkF(7_mryMtDXxE&@t8mq0W%QkwMGFO3cCRI}Ix&!r7+psaquJoa#4q*jE3Z{cgk>nK4lgP~Ai0h-^;$>tGjK>7 zTItE;%Xf$ZZ$WFsNy(-{sL1!jLSC>`{AP~M3jU~uN!Af#Ivw(RdlmuQu{>0PkgLHk zOQB4>0Xe{DG^ZU557jbDQhMS3{oV=B#re;}{_ek~mLjIbza1p)sIM&l4JF#ojh~7ZJ=*!)D`FkGW0z1*$(oIPTpJc(^ORP8HhcQti>EeBIt=W;W46 zuThRt*zZduZ$TxP9<@=s8W`B5(g^gA9lKagAWs)GIyAS>XbQB#=lW7vOUgL^TLSM_ z!ahj8S7CtO1$CVLU=zDciCt1h|8P4AZN(E5l?All4meJ%9T9KGI@_Q@s~(ai%>K^( z!K;F%X}I>al>y)irE-Ol?uSMnqpI=2UBMFwtdoseI{&`(=}STREm&G=Jan@CYr1xG zjM*A-PbV(qrF+?ss@WuTRS>uZqSWQCElB(FVE?cJa#9*4v^ViF4eo&7#$;suJCyJb zOb_}qm%T1A5hEZfWK8Fpa8UOUX$0}6%h5Bgc=xRkMC)E;iXV{dGd z{7v=UC+6GgvXxk1)*8G=r++3;nIdxULq4+(@A*5z@lRsCzt@rfb{qQX?+DKeXzf3R zm;PSMB2Mk-r*!#vwkH0A9cUcmwkCzJq_0TVQW$biFu5=g*C|cRcqwGU2mmcb(9zZf z_1|Xn_X~;X$D$1XJF-5h_4me;r~2>{?Bax_t+R=|6?RgXozP^-v7`d Q#gYXDsn@c_)^+&50K|R|umAu6 delta 11591 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 D4!Hpr diff --git a/src/Nethermind/Chains/lyra-mainnet.json.zst b/src/Nethermind/Chains/lyra-mainnet.json.zst index 83e969616d69e4a5660cad8c074467140526c3fe..0b58849fef78a0b26ca83e4c55c85651b0569794 100644 GIT binary patch delta 5838 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 delta 5143 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 delta 8235 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 Dxs9tt delta 8081 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 diff --git a/src/Nethermind/Chains/mode-mainnet.json.zst b/src/Nethermind/Chains/mode-mainnet.json.zst index 48b2a4aa09e890420daad26e4034cc837a40db46..4fd773468bc190aa8a3f7d942d244d37a5439b5b 100644 GIT binary patch delta 6192 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 X0Iv9Zo*o4gq!A^)xpJSC5+zZN(uiD> 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 diff --git a/src/Nethermind/Chains/mode-sepolia.json.zst b/src/Nethermind/Chains/mode-sepolia.json.zst index 4f3e1f63efbe7c66a8aedfe618abdf508695045b..4245b9c46a1ff8bd7e0af86c6682f973b33c9fd8 100644 GIT binary patch delta 9164 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 literal 2017 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 diff --git a/src/Nethermind/Chains/op-sepolia.json.zst b/src/Nethermind/Chains/op-sepolia.json.zst index 9aaca6a45ded6ef37b919acfa693ae10eac5baf4..640b70c7001c7c35334b724ec73c63f963539bd0 100644 GIT binary patch delta 8680 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 H2ZjFwv<)C5 diff --git a/src/Nethermind/Chains/orderly-mainnet.json.zst b/src/Nethermind/Chains/orderly-mainnet.json.zst index 0ecef288903c405020d22610f83892cb87c78b15..ac4c3aff88e58b49ec7ad36f924b08ea77f62f39 100644 GIT binary patch delta 6449 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 QK(_o*s82mv{+Rdw0VZrbWB>pF delta 5790 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 delta 7792 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

 /// - IVisitingWorldState CreateResettableWorldState(); + IWorldState CreateResettableWorldState(); /// /// Create a read only world state to warm up another world state /// /// Specify a world state to warm up by the returned world state. /// - IVisitingWorldState CreateWorldStateForWarmingUp(IWorldState forWarmup); + IWorldState CreateWorldStateForWarmingUp(IWorldState forWarmup); event EventHandler? ReorgBoundaryReached; @@ -55,6 +55,6 @@ public interface IWorldStateManager public interface IOverridableWorldScope { IDisposable BeginScope(BlockHeader? header); - IVisitingWorldState WorldState { get; } + IWorldState WorldState { get; } IStateReader GlobalStateReader { get; } } diff --git a/src/Nethermind/Nethermind.State/OverridableEnv/IOverridableEnv.cs b/src/Nethermind/Nethermind.State/OverridableEnv/IOverridableEnv.cs index 7b000ce479a..34f5aa1ac38 100644 --- a/src/Nethermind/Nethermind.State/OverridableEnv/IOverridableEnv.cs +++ b/src/Nethermind/Nethermind.State/OverridableEnv/IOverridableEnv.cs @@ -5,7 +5,6 @@ using System.Collections.Generic; using Autofac.Core; using Nethermind.Core; -using Nethermind.Core.Crypto; using Nethermind.Evm; using Nethermind.Evm.TransactionProcessing; @@ -32,6 +31,6 @@ public interface IOverridableEnv : IModule /// public interface IOverridableEnv { - Scope BuildAndOverride(BlockHeader header); + Scope BuildAndOverride(BlockHeader? header); Scope BuildAndOverride(BlockHeader header, Dictionary? stateOverride); } diff --git a/src/Nethermind/Nethermind.State/OverridableEnv/OverridableEnvFactory.cs b/src/Nethermind/Nethermind.State/OverridableEnv/OverridableEnvFactory.cs index 8b79190f841..bf1ee0b9ced 100644 --- a/src/Nethermind/Nethermind.State/OverridableEnv/OverridableEnvFactory.cs +++ b/src/Nethermind/Nethermind.State/OverridableEnv/OverridableEnvFactory.cs @@ -66,7 +66,7 @@ private void Reset() protected override void Load(ContainerBuilder builder) => builder - .AddScoped(overridableScope.WorldState).AddScoped(overridableScope.WorldState) + .AddScoped(overridableScope.WorldState) .AddScoped(overridableScope.GlobalStateReader) .AddScoped(this) .AddScoped(codeInfoRepository) diff --git a/src/Nethermind/Nethermind.State/OverridableWorldStateManager.cs b/src/Nethermind/Nethermind.State/OverridableWorldStateManager.cs index 1af2a85dc23..cd3a1e603dc 100644 --- a/src/Nethermind/Nethermind.State/OverridableWorldStateManager.cs +++ b/src/Nethermind/Nethermind.State/OverridableWorldStateManager.cs @@ -24,7 +24,7 @@ public OverridableWorldStateManager(IDbProvider dbProvider, IReadOnlyTrieStore t WorldState = new WorldState(overlayTrieStore, readOnlyDbProvider.CodeDb, logManager, null, true); } - public IVisitingWorldState WorldState { get; } + public IWorldState WorldState { get; } public IDisposable BeginScope(BlockHeader? header) { WorldState.SetBaseBlock(header); diff --git a/src/Nethermind/Nethermind.State/StateReaderExtensions.cs b/src/Nethermind/Nethermind.State/StateReaderExtensions.cs index 6c89c26ddb9..933ec39162b 100644 --- a/src/Nethermind/Nethermind.State/StateReaderExtensions.cs +++ b/src/Nethermind/Nethermind.State/StateReaderExtensions.cs @@ -54,5 +54,12 @@ public static TrieStats CollectStats(this IStateReader stateProvider, Hash256 ro }); return collector.Stats; } + + public static string DumpState(this IStateReader stateReader, Hash256 root) + { + TreeDumper dumper = new(); + stateReader.RunTreeVisitor(dumper, root); + return dumper.ToString(); + } } } diff --git a/src/Nethermind/Nethermind.State/WorldState.cs b/src/Nethermind/Nethermind.State/WorldState.cs index 5e1c6b92f53..2b6f293cf2f 100644 --- a/src/Nethermind/Nethermind.State/WorldState.cs +++ b/src/Nethermind/Nethermind.State/WorldState.cs @@ -25,7 +25,7 @@ namespace Nethermind.State { - public class WorldState : IVisitingWorldState, IPreBlockCaches + public class WorldState : IWorldState, IPreBlockCaches { internal readonly StateProvider _stateProvider; internal readonly PersistentStorageProvider _persistentStorageProvider; diff --git a/src/Nethermind/Nethermind.State/WorldStateManager.cs b/src/Nethermind/Nethermind.State/WorldStateManager.cs index c44dd1ee798..e71c7585e98 100644 --- a/src/Nethermind/Nethermind.State/WorldStateManager.cs +++ b/src/Nethermind/Nethermind.State/WorldStateManager.cs @@ -16,7 +16,7 @@ namespace Nethermind.State; public class WorldStateManager : IWorldStateManager { - private readonly IVisitingWorldState _worldState; + private readonly IWorldState _worldState; private readonly IPruningTrieStore _trieStore; private readonly IReadOnlyTrieStore _readOnlyTrieStore; private readonly ILogManager _logManager; @@ -26,7 +26,7 @@ public class WorldStateManager : IWorldStateManager private readonly ILastNStateRootTracker _lastNStateRootTracker; public WorldStateManager( - IVisitingWorldState worldState, + IWorldState worldState, IPruningTrieStore trieStore, IDbProvider dbProvider, ILogManager logManager, @@ -46,7 +46,7 @@ public WorldStateManager( _lastNStateRootTracker = lastNStateRootTracker; } - public IVisitingWorldState GlobalWorldState => _worldState; + public IWorldState GlobalWorldState => _worldState; public IReadOnlyKeyValueStore? HashServer => _trieStore.Scheme != INodeStorage.KeyScheme.Hash ? null : _trieStore.TrieNodeRlpStore; @@ -68,7 +68,7 @@ public void InitializeNetwork(IPathRecovery pathRecovery) public ISnapServer? SnapServer => _trieStore.Scheme == INodeStorage.KeyScheme.Hash ? null : new SnapServer.SnapServer(_readOnlyTrieStore, _readaOnlyCodeCb, GlobalStateReader, _logManager, _lastNStateRootTracker); - public IVisitingWorldState CreateResettableWorldState() + public IWorldState CreateResettableWorldState() { return new WorldState( _readOnlyTrieStore, @@ -76,7 +76,7 @@ public IVisitingWorldState CreateResettableWorldState() _logManager); } - public IVisitingWorldState CreateWorldStateForWarmingUp(IWorldState forWarmup) + public IWorldState CreateWorldStateForWarmingUp(IWorldState forWarmup) { PreBlockCaches? preBlockCaches = (forWarmup as IPreBlockCaches)?.Caches; return preBlockCaches is not null From ac37e35231613fc99deccc47344e77066c9ce459 Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Mon, 14 Jul 2025 09:42:21 +0100 Subject: [PATCH 14/40] More hot code in ConnectNodes (#8982) --- .../Nethermind.Trie/PatriciaTree.cs | 308 +++++++++--------- 1 file changed, 152 insertions(+), 156 deletions(-) diff --git a/src/Nethermind/Nethermind.Trie/PatriciaTree.cs b/src/Nethermind/Nethermind.Trie/PatriciaTree.cs index 89639eaac2c..be22cc01daa 100644 --- a/src/Nethermind/Nethermind.Trie/PatriciaTree.cs +++ b/src/Nethermind/Nethermind.Trie/PatriciaTree.cs @@ -636,6 +636,21 @@ static SpanSource ThrowNotSupported(TrieNode node) } private void ConnectNodes(TrieNode? node, in TraverseContext traverseContext) + { + // Fast tail-calls into generic + if (_logger.IsTrace) + { + ConnectNodes(node, in traverseContext); + } + else + { + // branch eliminates _loggerTrace statements + ConnectNodes(node, in traverseContext); + } + } + + private void ConnectNodes(TrieNode? node, in TraverseContext traverseContext) + where IsTrace : IFlag { TreePath path = traverseContext.UpdatePathTreePath; bool isRoot = IsNodeStackEmpty(); @@ -648,50 +663,36 @@ private void ConnectNodes(TrieNode? node, in TraverseContext traverseContext) path.TruncateMut(parentOnStack.PathLength); isRoot = IsNodeStackEmpty(); - - if (node.IsLeaf) - { - ThrowTrieExceptionLeftCannotBeParent(node, nextNode); - } - - if (node.IsBranch) + // Use NodeType once to reduce virtual calls + // and switch statement to not add additional long lived local variable + switch (node.NodeType) { - if (!(nextNode is null && !node.IsValidWithOneNodeLess)) - { - if (node.IsSealed) + case NodeType.Branch: + if (!(nextNode is null && !node.IsValidWithOneNodeLess)) { - node = node.Clone(); - } + if (node.IsSealed) + { + node = node.Clone(); + } - node.SetChild(parentOnStack.PathIndex, nextNode); - nextNode = node; - } - else - { - if (node.Value!.Length != 0) - { - // this only happens when we have branches with values - // which is not possible in the Ethereum protocol where keys are of equal lengths - // (it is possible in the more general trie definition) - TrieNode leafFromBranch = TrieNodeFactory.CreateLeaf([], node.Value); - if (_logger.IsTrace) _logger.Trace($"Converting {node} into {leafFromBranch}"); - nextNode = leafFromBranch; + node.SetChild(parentOnStack.PathIndex, nextNode); + nextNode = node; } else { /* all the cases below are when we have a branch that becomes something else - as a result of deleting one of the last two children */ + as a result of deleting one of the last two children */ /* case 1) - extension from branch - this is particularly interesting - we create an extension from - the implicit path in the branch children positions (marked as P) - P B B B B B B B B B B B B B B B - B X - - - - - - - - - - - - - - - case 2) - extended extension - B B B B B B B B B B B B B B B B - E X - - - - - - - - - - - - - - - case 3) - extended leaf - B B B B B B B B B B B B B B B B - L X - - - - - - - - - - - - - - */ + this is particularly interesting - we create an extension from + the implicit path in the branch children positions (marked as P) + P B B B B B B B B B B B B B B B + B X - - - - - - - - - - - - - - + case 2) - extended extension + B B B B B B B B B B B B B B B B + E X - - - - - - - - - - - - - - + case 3) - extended leaf + B B B B B B B B B B B B B B B B + L X - - - - - - - - - - - - - - */ int childNodeIndex = 0; for (int i = 0; i < 16; i++) @@ -708,157 +709,152 @@ L X - - - - - - - - - - - - - - */ if (childNode is null) { /* potential corrupted trie data state when we find a branch that has only one child */ - ThrowTrieExceptionCorruption(); + goto Corruption; } ResolveNode(childNode, in traverseContext, in path); path.TruncateOne(); - if (childNode.IsBranch) + NodeType childType = childNode.NodeType; + if (childType == NodeType.Branch) { - TrieNode extensionFromBranch = - TrieNodeFactory.CreateExtension(_singleByteKeys[childNodeIndex], childNode); - if (_logger.IsTrace) - _logger.Trace( - $"Extending child {childNodeIndex} {childNode} of {node} into {extensionFromBranch}"); + TrieNode extensionFromBranch = TrieNodeFactory.CreateExtension(_singleByteKeys[childNodeIndex], childNode); + if (IsTrace.IsActive) _logger.Trace($"Extending child {childNodeIndex} {childNode} of {node} into {extensionFromBranch}"); nextNode = extensionFromBranch; } - else if (childNode.IsExtension) + else if (childType == NodeType.Extension || childType == NodeType.Leaf) { - /* to test this case we need something like this initially */ - /* R - B B B B B B B B B B B B B B B B - E L - - - - - - - - - - - - - - - E - - - - - - - - - - - - - - - - B B B B B B B B B B B B B B B B - L L - - - - - - - - - - - - - - */ - - /* then we delete the leaf (marked as X) */ - /* R - B B B B B B B B B B B B B B B B - E X - - - - - - - - - - - - - - - E - - - - - - - - - - - - - - - - B B B B B B B B B B B B B B B B - L L - - - - - - - - - - - - - - */ - - /* and we end up with an extended extension (marked with +) - replacing what was previously a top-level branch */ - /* R - + - + - + - - - - - - - - - - - - - - - - B B B B B B B B B B B B B B B B - L L - - - - - - - - - - - - - - */ - byte[] newKey = Bytes.Concat((byte)childNodeIndex, childNode.Key); + TrieNode extendedNode = childNode.CloneWithChangedKey(newKey); - TrieNode extendedExtension = childNode.CloneWithChangedKey(newKey); - if (_logger.IsTrace) - _logger.Trace( - $"Extending child {childNodeIndex} {childNode} of {node} into {extendedExtension}"); - nextNode = extendedExtension; - } - else if (childNode.IsLeaf) - { - byte[] newKey = Bytes.Concat((byte)childNodeIndex, childNode.Key); - - TrieNode extendedLeaf = childNode.CloneWithChangedKey(newKey); - if (_logger.IsTrace) + if (IsTrace.IsActive) { - _logger.Trace($"Extending branch child {childNodeIndex} {childNode} into {extendedLeaf}"); - _logger.Trace($"Decrementing ref on a leaf extended up to eat a branch {childNode}"); - if (node.IsSealed) + if (childNode.IsExtension) + { + /* to test this case we need something like this initially */ + /* R + B B B B B B B B B B B B B B B B + E L - - - - - - - - - - - - - - + E - - - - - - - - - - - - - - - + B B B B B B B B B B B B B B B B + L L - - - - - - - - - - - - - - */ + + /* then we delete the leaf (marked as X) */ + /* R + B B B B B B B B B B B B B B B B + E X - - - - - - - - - - - - - - + E - - - - - - - - - - - - - - - + B B B B B B B B B B B B B B B B + L L - - - - - - - - - - - - - - */ + + /* and we end up with an extended extension (marked with +) + replacing what was previously a top-level branch */ + /* R + + + + + + - - - - - - - - - - - - - - - + B B B B B B B B B B B B B B B B + L L - - - - - - - - - - - - - - */ + + _logger.Trace($"Extending child {childNodeIndex} {childNode} of {node} into {extendedNode}"); + } + else if (childNode.IsLeaf) { - _logger.Trace($"Decrementing ref on a branch replaced by a leaf {node}"); + _logger.Trace($"Extending branch child {childNodeIndex} {childNode} into {extendedNode}"); + _logger.Trace($"Decrementing ref on a leaf extended up to eat a branch {childNode}"); + if (node.IsSealed) + { + _logger.Trace($"Decrementing ref on a branch replaced by a leaf {node}"); + } } } - - nextNode = extendedLeaf; + nextNode = extendedNode; } else { - ThrowInvalidNodeType(childNode); + node = childNode; + goto InvalidNodeType; } } - } - } - else if (node.IsExtension) - { - if (nextNode is null) - { - ThrowInvalidNullNode(node); - } - - if (nextNode.IsLeaf) - { - byte[] newKey = Bytes.Concat(node.Key, nextNode.Key); - TrieNode extendedLeaf = nextNode.CloneWithChangedKey(newKey); - if (_logger.IsTrace) - _logger.Trace($"Combining {node} and {nextNode} into {extendedLeaf}"); + break; + case NodeType.Extension: + if (nextNode is null) + { + goto NullNode; + } - nextNode = extendedLeaf; - } - else if (nextNode.IsExtension) - { - /* to test this case we need something like this initially */ - /* R - E - - - - - - - - - - - - - - - - B B B B B B B B B B B B B B B B - E L - - - - - - - - - - - - - - - E - - - - - - - - - - - - - - - - B B B B B B B B B B B B B B B B - L L - - - - - - - - - - - - - - */ - - /* then we delete the leaf (marked as X) */ - /* R - B B B B B B B B B B B B B B B B - E X - - - - - - - - - - - - - - - E - - - - - - - - - - - - - - - - B B B B B B B B B B B B B B B B - L L - - - - - - - - - - - - - - */ - - /* and we end up with an extended extension replacing what was previously a top-level branch*/ - /* R - E - E - E - - - - - - - - - - - - - - - - B B B B B B B B B B B B B B B B - L L - - - - - - - - - - - - - - */ - - byte[] newKey = Bytes.Concat(node.Key, nextNode.Key); - TrieNode extendedExtension = nextNode.CloneWithChangedKey(newKey); - if (_logger.IsTrace) - _logger.Trace($"Combining {node} and {nextNode} into {extendedExtension}"); - - nextNode = extendedExtension; - } - else if (nextNode.IsBranch) - { - if (node.IsSealed) + NodeType nextType = nextNode.NodeType; + if (nextType == NodeType.Branch) { - node = node.Clone(); + if (node.IsSealed) + { + node = node.Clone(); + } + + if (IsTrace.IsActive) _logger.Trace($"Connecting {node} with {nextNode}"); + node.SetChild(0, nextNode); + nextNode = node; } + else if (nextType == NodeType.Extension || nextType == NodeType.Leaf) + { + /* to test the Extension case we need something like this initially */ + /* R + E - - - - - - - - - - - - - - - + B B B B B B B B B B B B B B B B + E L - - - - - - - - - - - - - - + E - - - - - - - - - - - - - - - + B B B B B B B B B B B B B B B B + L L - - - - - - - - - - - - - - */ - if (_logger.IsTrace) _logger.Trace($"Connecting {node} with {nextNode}"); - node.SetChild(0, nextNode); - nextNode = node; - } - else - { - ThrowInvalidNodeType(nextNode); - } - } - else - { - ThrowInvalidNodeType(node); + /* then we delete the leaf (marked as X) */ + /* R + B B B B B B B B B B B B B B B B + E X - - - - - - - - - - - - - - + E - - - - - - - - - - - - - - - + B B B B B B B B B B B B B B B B + L L - - - - - - - - - - - - - - */ + + /* and we end up with an extended extension replacing what was previously a top-level branch*/ + /* R + E + E + E - - - - - - - - - - - - - - - + B B B B B B B B B B B B B B B B + L L - - - - - - - - - - - - - - */ + + byte[] newKey = Bytes.Concat(node.Key, nextNode.Key); + TrieNode extendedNode = nextNode.CloneWithChangedKey(newKey); + if (IsTrace.IsActive) _logger.Trace($"Combining {node} and {nextNode} into {extendedNode}"); + nextNode = extendedNode; + } + else + { + node = nextNode; + goto InvalidNodeType; + } + break; + case NodeType.Leaf: + goto LeafCannotBeParent; + default: + goto InvalidNodeType; } } RootRef = nextNode; + return; + + Corruption: + ThrowTrieExceptionCorruption(); + InvalidNodeType: + ThrowInvalidNodeType(node); + NullNode: + ThrowInvalidNullNode(node); + LeafCannotBeParent: + ThrowTrieExceptionLeafCannotBeParent(node, nextNode); [DoesNotReturn, StackTraceHidden] - static void ThrowTrieExceptionLeftCannotBeParent(TrieNode node, TrieNode nextNode) + static void ThrowTrieExceptionLeafCannotBeParent(TrieNode node, TrieNode nextNode) => throw new TrieException($"{nameof(NodeType.Leaf)} {node} cannot be a parent of {nextNode}"); [DoesNotReturn, StackTraceHidden] From 2b0e8382ba16be327fb825267409f95818f98b71 Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Mon, 14 Jul 2025 11:20:50 +0100 Subject: [PATCH 15/40] Only access "warmup" hashtable once per warmup (#8983) * Only access "warm" up hashtable once per warmup * Update src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs Co-authored-by: Lukasz Rozmej --------- Co-authored-by: Lukasz Rozmej --- .../Nethermind.Evm/Instructions/EvmInstructions.cs | 6 ++---- src/Nethermind/Nethermind.Evm/StackAccessTracker.cs | 12 ++++-------- 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs index ea696fdc83c..d59100ac94a 100644 --- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs +++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs @@ -366,10 +366,9 @@ private static bool ChargeAccountAccessGas(ref long gasAvailable, VirtualMachine } // If the account is cold (and not a precompile), charge the cold access cost. - if (vmState.AccessTracker.IsCold(address) && !address.IsPrecompile(spec)) + if (!address.IsPrecompile(spec) && vmState.AccessTracker.WarmUp(address)) { result = UpdateGas(GasCostOf.ColdAccountAccess, ref gasAvailable); - vmState.AccessTracker.WarmUp(address); } else if (chargeForWarm) { @@ -415,10 +414,9 @@ private static bool ChargeStorageAccessGas( } // If the storage cell is still cold, apply the higher cold access cost and mark it as warm. - if (accessTracker.IsCold(in storageCell)) + if (accessTracker.WarmUp(in storageCell)) { result = UpdateGas(GasCostOf.ColdSLoad, ref gasAvailable); - accessTracker.WarmUp(in storageCell); } // For SLOAD operations on already warmed-up storage, apply a lower warm-read cost. else if (storageAccessType == StorageAccessType.SLOAD) diff --git a/src/Nethermind/Nethermind.Evm/StackAccessTracker.cs b/src/Nethermind/Nethermind.Evm/StackAccessTracker.cs index b118838a51f..45a07cb1e6e 100644 --- a/src/Nethermind/Nethermind.Evm/StackAccessTracker.cs +++ b/src/Nethermind/Nethermind.Evm/StackAccessTracker.cs @@ -35,15 +35,11 @@ public StackAccessTracker() public readonly bool IsCold(in StorageCell storageCell) => !_trackingState.AccessedStorageCells.Contains(storageCell); - public readonly void WarmUp(Address address) - { - _trackingState.AccessedAddresses.Add(address); - } + public readonly bool WarmUp(Address address) + => _trackingState.AccessedAddresses.Add(address); - public readonly void WarmUp(in StorageCell storageCell) - { - _trackingState.AccessedStorageCells.Add(storageCell); - } + public readonly bool WarmUp(in StorageCell storageCell) + => _trackingState.AccessedStorageCells.Add(storageCell); public readonly bool WarmUpLargeContract(Address address) => _trackingState.LargeContractList.Add(address); From 5993011f66295eafbb4bde46fd57f76c11c44751 Mon Sep 17 00:00:00 2001 From: Alexey Date: Mon, 14 Jul 2025 17:46:24 +0300 Subject: [PATCH 16/40] EIP-7594: Constant maxBlobsPerTx (#8940) * Const maxBlobsPerTx * WS * Add tests(improve for the Gnosis case); add link --- .../Nethermind.Core/Eip7594Constants.cs | 12 ++++ .../ChainSpecBasedSpecProvider.cs | 4 -- .../Json/BlobScheduleSettings.cs | 2 - .../Nethermind.Specs/ReleaseSpec.cs | 4 +- .../Nethermind.Specs/TestSpecProvider.cs | 5 +- .../TxPoolTests.Blobs.cs | 68 +++++++++---------- .../Nethermind.TxPool.Test/TxPoolTests.cs | 5 +- 7 files changed, 50 insertions(+), 50 deletions(-) create mode 100644 src/Nethermind/Nethermind.Core/Eip7594Constants.cs diff --git a/src/Nethermind/Nethermind.Core/Eip7594Constants.cs b/src/Nethermind/Nethermind.Core/Eip7594Constants.cs new file mode 100644 index 00000000000..7f4feaa1860 --- /dev/null +++ b/src/Nethermind/Nethermind.Core/Eip7594Constants.cs @@ -0,0 +1,12 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +namespace Nethermind.Core; + +/// +/// See EIP-7594 +/// +public static class Eip7594Constants +{ + public const int MaxBlobsPerTx = 6; +} diff --git a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecBasedSpecProvider.cs b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecBasedSpecProvider.cs index fef56b8bce7..160a8ba2011 100644 --- a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecBasedSpecProvider.cs +++ b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecBasedSpecProvider.cs @@ -313,10 +313,6 @@ void SetBlobScheduleParameters() { releaseSpec.TargetBlobCount = blobSchedule.Target; releaseSpec.MaxBlobCount = blobSchedule.Max; - if (blobSchedule.MaxBlobsPerTx is not null) - { - releaseSpec.MaxBlobsPerTx = blobSchedule.MaxBlobsPerTx.Value; - } releaseSpec.BlobBaseFeeUpdateFraction = blobSchedule.BaseFeeUpdateFraction; } else if (releaseSpec.Eip4844TransitionTimestamp <= releaseStartTimestamp) diff --git a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/Json/BlobScheduleSettings.cs b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/Json/BlobScheduleSettings.cs index 248b4399127..37bd350ca76 100644 --- a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/Json/BlobScheduleSettings.cs +++ b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/Json/BlobScheduleSettings.cs @@ -13,8 +13,6 @@ public record class BlobScheduleSettings : IComparable public ulong Max { get; set; } - public ulong? MaxBlobsPerTx { get; set; } - public ulong BaseFeeUpdateFraction { get; set; } public int CompareTo(BlobScheduleSettings? other) => other is null ? 1 : Timestamp.CompareTo(other.Timestamp); diff --git a/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs b/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs index a50958a7d35..86e628738ab 100644 --- a/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs @@ -106,9 +106,7 @@ public bool IsEip1559Enabled public ulong TargetBlobCount { get; set; } public ulong MaxBlobCount { get; set; } - - private ulong? _maxBlobsPerTx; - public ulong MaxBlobsPerTx { get => _maxBlobsPerTx ?? MaxBlobCount; set => _maxBlobsPerTx = value; } + public ulong MaxBlobsPerTx => IsEip7594Enabled ? Math.Min(Eip7594Constants.MaxBlobsPerTx, MaxBlobCount) : MaxBlobCount; public UInt256 BlobBaseFeeUpdateFraction { get; set; } diff --git a/src/Nethermind/Nethermind.Specs/TestSpecProvider.cs b/src/Nethermind/Nethermind.Specs/TestSpecProvider.cs index 8f533ff05e9..09703b8b6e7 100644 --- a/src/Nethermind/Nethermind.Specs/TestSpecProvider.cs +++ b/src/Nethermind/Nethermind.Specs/TestSpecProvider.cs @@ -31,8 +31,7 @@ public void UpdateMergeTransitionInfo(long? blockNumber, UInt256? terminalTotalD public IReleaseSpec GenesisSpec { get; set; } - IReleaseSpec ISpecProvider.GetSpecInternal(ForkActivation forkActivation) => SpecToReturn; - + IReleaseSpec ISpecProvider.GetSpecInternal(ForkActivation forkActivation) => forkActivation.BlockNumber == 0 || forkActivation.BlockNumber < ForkOnBlockNumber ? GenesisSpec : SpecToReturn; public IReleaseSpec SpecToReturn { get; set; } public long? DaoBlockNumber { get; set; } @@ -46,6 +45,8 @@ public void UpdateMergeTransitionInfo(long? blockNumber, UInt256? terminalTotalD public ForkActivation[] TransitionActivations { get; set; } = new ForkActivation[] { (ForkActivation)0 }; public bool AllowTestChainOverride { get; set; } = true; + public long? ForkOnBlockNumber { get; set; } + private TestSpecProvider() { } public static readonly TestSpecProvider Instance = new(); diff --git a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs index e5e7b0481c3..9c92e315abd 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs @@ -1020,59 +1020,55 @@ private Transaction CreateBlobTx(PrivateKey sender, UInt256 nonce = default, int .SignedAndResolved(_ethereumEcdsa, sender).TestObject; } - [TestCaseSource(nameof(EvictionAccordingToLimitsTestCaseSource))] - public async Task should_evict_txs_with_too_many_blobs_after_fork(BlobScheduleSettings initial, BlobScheduleSettings updated, int[] blobTxBlobCounts) + [Test] + public async Task should_evict_txs_with_too_many_blobs_after_fork() { - ChainSpecBasedSpecProvider provider = new(new ChainSpec + const int regularMaxBlobCount = 9; + + TestSpecProvider provider = new(new ReleaseSpec + { + IsEip4844Enabled = true, + MaxBlobCount = regularMaxBlobCount, + }) { - Parameters = new ChainParameters + SpecToReturn = new ReleaseSpec { - Eip4844TransitionTimestamp = 0, - BlobSchedule = { - initial with { Timestamp = _blockTree.Head.Timestamp }, - updated with { Timestamp = _blockTree.Head.Timestamp + 1 }, - }, + IsEip4844Enabled = true, + IsEip7594Enabled = true, + MaxBlobCount = regularMaxBlobCount, }, - EngineChainSpecParametersProvider = Substitute.For() - }); + ForkOnBlockNumber = _blockTree.Head.Number + 1, + }; Block head = _blockTree.Head; _blockTree.FindBestSuggestedHeader().Returns(head.Header); - TxPoolConfig txPoolConfig = new() { BlobsSupport = BlobsSupportMode.InMemory, Size = 10 }; - _txPool = CreatePool(txPoolConfig, provider); + _txPool = CreatePool(specProvider: provider); EnsureSenderBalance(TestItem.AddressA, UInt256.MaxValue); - UInt256 nonce = 0; - - foreach (var blobCount in blobTxBlobCounts) - { - _txPool.SubmitTx(CreateBlobTx(TestItem.PrivateKeyA, nonce++, blobCount), TxHandlingOptions.None); - } - - Assert.That(_txPool.GetPendingBlobTransactionsCount(), Is.EqualTo(blobTxBlobCounts.Length)); + _txPool.SubmitTx(CreateBlobTx(TestItem.PrivateKeyA, 0, regularMaxBlobCount), TxHandlingOptions.None); + Assert.That(_txPool.GetPendingBlobTransactionsCount(), Is.EqualTo(1)); await AddBlock(); - return _txPool.GetPendingBlobTransactionsCount(); + Assert.That(_txPool.GetPendingBlobTransactionsCount(), Is.Zero); } - public static IEnumerable EvictionAccordingToLimitsTestCaseSource + [Test] + public void max_blobs_per_tx_should_not_exceed_max_blobs_per_block() { - get + const ulong regularMaxBlobCount = Eip7594Constants.MaxBlobsPerTx - 1; + + TestSpecProvider provider = new(new ReleaseSpec { - static TestCaseData MakeTestCase(string testName, BlobScheduleSettings initial, BlobScheduleSettings updated, int[] blobTxBlobCounts, int finalTxCount) - => new(initial, updated, blobTxBlobCounts) { TestName = $"EvictionAccordingToBlobLimits: {testName}", ExpectedResult = finalTxCount }; - - yield return MakeTestCase("Evicts when per block limit is set", - new BlobScheduleSettings { Max = 6 }, new BlobScheduleSettings { Max = 5 }, [6], 0); - yield return MakeTestCase("Evicts when per tx limit only is set", - new BlobScheduleSettings { Max = 6 }, new BlobScheduleSettings { Max = 6, MaxBlobsPerTx = 3 }, [6], 0); - yield return MakeTestCase("Evicts when per tx limit only is changed", - new BlobScheduleSettings { Max = 6, MaxBlobsPerTx = 3 }, new BlobScheduleSettings { Max = 6, MaxBlobsPerTx = 2 }, [2, 3, 2], 1); - yield return MakeTestCase("Evicts next txs too", - new BlobScheduleSettings { Max = 6 }, new BlobScheduleSettings { Max = 6, MaxBlobsPerTx = 3 }, [6, 3, 3, 3], 0); - } + IsEip4844Enabled = true, + IsEip7594Enabled = true, + MaxBlobCount = regularMaxBlobCount, + }); + + ulong maxBlobsPerTx = provider.GetSpec(_blockTree.Head!.Header).MaxBlobsPerTx; + + Assert.That(maxBlobsPerTx, Is.EqualTo(regularMaxBlobCount)); } } } diff --git a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs index 7987e6f5d23..279a6fdc54a 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs @@ -21,7 +21,6 @@ using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; using Nethermind.Evm; using Nethermind.Int256; using Nethermind.Logging; @@ -30,7 +29,6 @@ using Nethermind.Specs.Test; using Nethermind.Evm.State; using Nethermind.State; -using Nethermind.Trie.Pruning; using Nethermind.TxPool.Filters; using NSubstitute; using NUnit.Framework; @@ -1837,13 +1835,14 @@ public void Delegated_account_can_only_have_one_tx_with_current_account_nonce(in } - private static object[] NonceAndRemovedCases = + private static readonly object[] NonceAndRemovedCases = { new object[]{ true, 1, AcceptTxResult.Accepted }, new object[]{ true, 0, AcceptTxResult.Accepted}, new object[]{ false, 0, AcceptTxResult.Accepted}, new object[]{ false, 1, AcceptTxResult.NotCurrentNonceForDelegation}, }; + [TestCaseSource(nameof(NonceAndRemovedCases))] public void Tx_with_conflicting_pending_delegation_is_rejected_then_is_accepted_after_delegation_removal(bool withRemoval, int secondNonce, AcceptTxResult expected) { From f05894fb8b64a8f4f2b8d77794c23c04921a4062 Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Mon, 14 Jul 2025 15:53:17 +0100 Subject: [PATCH 17/40] Fail fast on Db corruption (#8986) * Fail fast on Db corruption * Fix tests * Update src/Nethermind/Nethermind.Db.Rocks/DbOnTheRocks.cs Co-authored-by: Ruben Buniatyan --------- Co-authored-by: Ruben Buniatyan --- src/Nethermind/Nethermind.Db.Rocks/DbOnTheRocks.cs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/Nethermind/Nethermind.Db.Rocks/DbOnTheRocks.cs b/src/Nethermind/Nethermind.Db.Rocks/DbOnTheRocks.cs index 82263e021f9..a2e8a492935 100644 --- a/src/Nethermind/Nethermind.Db.Rocks/DbOnTheRocks.cs +++ b/src/Nethermind/Nethermind.Db.Rocks/DbOnTheRocks.cs @@ -290,6 +290,12 @@ private void CreateMarkerIfCorrupt(RocksDbSharpException rocksDbException) { if (_logger.IsWarn) _logger.Warn($"Corrupted DB detected on path {_fullPath}. Please restart Nethermind to attempt repair."); _fileSystem.File.WriteAllText(CorruptMarkerPath, "marker"); + + // Don't kill tests checking corruption response + if (!rocksDbException.Message.Equals("Corruption: test corruption", StringComparison.Ordinal)) + { + Environment.FailFast("Fast shutdown due to DB corruption. Please restart."); + } } } From 9bb8edb394f042605efcbff358ff06b64e52c611 Mon Sep 17 00:00:00 2001 From: Ruben Buniatyan Date: Tue, 15 Jul 2025 10:22:56 +0200 Subject: [PATCH 18/40] Configure EWC Zurich hard fork (#8985) --- src/Nethermind/Chains/energyweb.json | 497 ++++++++++++++------------- 1 file changed, 256 insertions(+), 241 deletions(-) diff --git a/src/Nethermind/Chains/energyweb.json b/src/Nethermind/Chains/energyweb.json index c7941dbbcbd..cf5a8285ffc 100644 --- a/src/Nethermind/Chains/energyweb.json +++ b/src/Nethermind/Chains/energyweb.json @@ -1,249 +1,264 @@ { - "name": "EnergyWebChain", - "engine": { - "authorityRound": { - "params": { - "stepDuration": "5", - "validators": { - "contract": "0x1204700000000000000000000000000000000000" - }, - "maximumUncleCountTransition": "0", - "maximumUncleCount": "0", - "blockRewardContractAddress": "0x1204700000000000000000000000000000000002", - "blockRewardContractTransition": "0" - } + "name": "EnergyWebChain", + "engine": { + "authorityRound": { + "params": { + "stepDuration": "5", + "validators": { + "contract": "0x1204700000000000000000000000000000000000" + }, + "maximumUncleCountTransition": "0", + "maximumUncleCount": "0", + "blockRewardContractAddress": "0x1204700000000000000000000000000000000002", + "blockRewardContractTransition": "0", + "rewriteBytecode": { + "36871000": { + "0x1204700000000000000000000000000000000002": "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" + } } + } + } + }, + "params": { + "networkID": "0xF6", + "maximumExtraDataSize": "0x20", + "gasLimitBoundDivisor": "0x400", + "minGasLimit": "0x1388", + "maxCodeSize": "0x6000", + "maxCodeSizeTransition": "0x0", + "eip140Transition": "0x0", + "eip211Transition": "0x0", + "eip214Transition": "0x0", + "eip658Transition": "0x0", + "eip145Transition": "0x0", + "eip1014Transition": "0x0", + "eip1052Transition": "0x0", + "eip1283Transition": "0x4b1bb6", + "eip1344Transition": "0x4b1bb6", + "eip1706Transition": "0x4b1bb6", + "eip1884Transition": "0x4b1bb6", + "eip2028Transition": "0x4b1bb6", + "eip2929Transition": "0xc10499", + "eip2930Transition": "0xc10499", + "eip1559Transition": "0xe0d9ac", + "eip3198Transition": "0xe0d9ac", + "eip3541Transition": "0xe0d9ac", + "eip3529Transition": "0xe0d9ac", + "eip1559BaseFeeMaxChangeDenominator": "0x8", + "eip1559ElasticityMultiplier": "0x2", + "eip1559BaseFeeInitialValue": "0x3B9ACA00", + "registrar": "0x1204700000000000000000000000000000000006" + }, + "genesis": { + "seal": { + "authorityRound": { + "step": "0x0", + "signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } }, - "params": { - "networkID": "0xF6", - "maximumExtraDataSize": "0x20", - "gasLimitBoundDivisor": "0x400", - "minGasLimit": "0x1388", - "maxCodeSize": "0x6000", - "maxCodeSizeTransition": "0x0", - "eip140Transition": "0x0", - "eip211Transition": "0x0", - "eip214Transition": "0x0", - "eip658Transition": "0x0", - "eip145Transition": "0x0", - "eip1014Transition": "0x0", - "eip1052Transition": "0x0", - "eip1283Transition": "0x4b1bb6", - "eip1344Transition": "0x4b1bb6", - "eip1706Transition": "0x4b1bb6", - "eip1884Transition": "0x4b1bb6", - "eip2028Transition": "0x4b1bb6", - "eip2929Transition": "0xc10499", - "eip2930Transition": "0xc10499", - "eip1559Transition": "0xe0d9ac", - "eip3198Transition": "0xe0d9ac", - "eip3541Transition": "0xe0d9ac", - "eip3529Transition": "0xe0d9ac", - "eip1559BaseFeeMaxChangeDenominator": "0x8", - "eip1559ElasticityMultiplier": "0x2", - "eip1559BaseFeeInitialValue": "0x3B9ACA00", - "registrar": "0x1204700000000000000000000000000000000006" - }, - "genesis": { - "seal": { - "authorityRound": { - "step": "0x0", - "signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - } - }, - "difficulty": "0x20000", - "gasLimit": "0x5B8D80" - }, - "accounts": { - "0x0000000000000000000000000000000000000001": { - "balance": "1", - "builtin": { - "name": "ecrecover", - "activate_at": "0", - "pricing": { - "linear": { - "base": 3000, - "word": 0 - } - } - } - }, - "0x0000000000000000000000000000000000000002": { - "balance": "1", - "builtin": { - "name": "sha256", - "activate_at": "0", - "pricing": { - "linear": { - "base": 60, - "word": 12 - } - } - } - }, - "0x0000000000000000000000000000000000000003": { - "balance": "1", - "builtin": { - "name": "ripemd160", - "activate_at": "0", - "pricing": { - "linear": { - "base": 600, - "word": 120 - } - } - } - }, - "0x0000000000000000000000000000000000000004": { - "balance": "1", - "builtin": { - "name": "identity", - "activate_at": "0", - "pricing": { - "linear": { - "base": 15, - "word": 3 - } - } - } - }, - "0x0000000000000000000000000000000000000005": { - "balance": "1", - "builtin": { - "name": "modexp", - "pricing": { - "0": { - "price": { "modexp": { "divisor": 20 }} - }, - "0xc10499": { - "info": "EIP-2565: ModExp Gas Cost. Berlin hardfork (0xc10499)", - "price": { "modexp2565": {}} - } - } - } - }, - "0x0000000000000000000000000000000000000006": { - "balance": "1", - "builtin": { - "name": "alt_bn128_add", - "pricing": { - "0": { - "price": { "alt_bn128_const_operations": { "price": 500 }} - }, - "0x4b1bb6": { - "info": "EIP 1108 transition at block 4_922_294 (0x4b1bb6)", - "price": { "alt_bn128_const_operations": { "price": 150 }} - } - } - } - }, - "0x0000000000000000000000000000000000000007": { - "balance": "1", - "builtin": { - "name": "alt_bn128_mul", - "pricing": { - "0": { - "price": { "alt_bn128_const_operations": { "price": 40000 }} - }, - "0x4b1bb6": { - "info": "EIP 1108 transition at block 4_922_294 (0x4b1bb6)", - "price": { "alt_bn128_const_operations": { "price": 6000 }} - } - } - } - }, - "0x0000000000000000000000000000000000000008": { - "balance": "1", - "builtin": { - "name": "alt_bn128_pairing", - "pricing": { - "0": { - "price": { "alt_bn128_pairing": { "base": 100000, "pair": 80000 }} - }, - "0x4b1bb6": { - "info": "EIP 1108 transition at block 4_922_294 (0x4b1bb6)", - "price": { "alt_bn128_pairing": { "base": 45000, "pair": 34000 }} - } - } + "difficulty": "0x20000", + "gasLimit": "0x5B8D80" + }, + "accounts": { + "0x0000000000000000000000000000000000000001": { + "balance": "1", + "builtin": { + "name": "ecrecover", + "activate_at": "0", + "pricing": { + "linear": { + "base": 3000, + "word": 0 + } + } + } + }, + "0x0000000000000000000000000000000000000002": { + "balance": "1", + "builtin": { + "name": "sha256", + "activate_at": "0", + "pricing": { + "linear": { + "base": 60, + "word": 12 + } + } + } + }, + "0x0000000000000000000000000000000000000003": { + "balance": "1", + "builtin": { + "name": "ripemd160", + "activate_at": "0", + "pricing": { + "linear": { + "base": 600, + "word": 120 + } + } + } + }, + "0x0000000000000000000000000000000000000004": { + "balance": "1", + "builtin": { + "name": "identity", + "activate_at": "0", + "pricing": { + "linear": { + "base": 15, + "word": 3 + } + } + } + }, + "0x0000000000000000000000000000000000000005": { + "balance": "1", + "builtin": { + "name": "modexp", + "pricing": { + "0": { + "price": { "modexp": { "divisor": 20 } } + }, + "0xc10499": { + "info": "EIP-2565: ModExp Gas Cost. Berlin hardfork (0xc10499)", + "price": { "modexp2565": {} } + } + } + } + }, + "0x0000000000000000000000000000000000000006": { + "balance": "1", + "builtin": { + "name": "alt_bn128_add", + "pricing": { + "0": { + "price": { "alt_bn128_const_operations": { "price": 500 } } + }, + "0x4b1bb6": { + "info": "EIP 1108 transition at block 4_922_294 (0x4b1bb6)", + "price": { "alt_bn128_const_operations": { "price": 150 } } + } + } + } + }, + "0x0000000000000000000000000000000000000007": { + "balance": "1", + "builtin": { + "name": "alt_bn128_mul", + "pricing": { + "0": { + "price": { "alt_bn128_const_operations": { "price": 40000 } } + }, + "0x4b1bb6": { + "info": "EIP 1108 transition at block 4_922_294 (0x4b1bb6)", + "price": { "alt_bn128_const_operations": { "price": 6000 } } + } + } + } + }, + "0x0000000000000000000000000000000000000008": { + "balance": "1", + "builtin": { + "name": "alt_bn128_pairing", + "pricing": { + "0": { + "price": { + "alt_bn128_pairing": { + "base": 100000, + "pair": 80000 + } } - }, - "0x0000000000000000000000000000000000000009": { - "builtin": { - "name": "blake2_f", - "activate_at": "0x4b1bb6", - "pricing": { - "blake2_f": { - "gas_per_round": 1 - } - } + }, + "0x4b1bb6": { + "info": "EIP 1108 transition at block 4_922_294 (0x4b1bb6)", + "price": { + "alt_bn128_pairing": { + "base": 45000, + "pair": 34000 + } } - }, - "0x1204700000000000000000000000000000000005": { - "constructor": "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" - }, - "0x1204700000000000000000000000000000000003": { - "constructor": "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" - }, - "0x120470000000000000000000000000000000000a": { - "balance": "10901790566666700000000000", - "constructor": "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" - }, - "0x0cB1437200aea736788f1Fc56F327c0456c3598D": { - "balance": "250000000000000000" - }, - "0x74dd76E24B2CFB43C1b1a4498295d553D0843746": { - "balance": "250000000000000000" - }, - "0xeeB4CEEe443F9e0D17BdBD6Daa241681EE5E51c2": { - "balance": "250000000000000000" - }, - "0xA005caEa55375ae20e3aAEF746113535503ABC19": { - "balance": "250000000000000000" - }, - "0x90ae948bB410838bff9D024ed849dF6A7267Dacf": { - "balance": "250000000000000000" - }, - "0x740a5C5742833bEd72489fE6bf7EFc9B79428989": { - "balance": "250000000000000000" - }, - "0x1204700000000000000000000000000000000001": { - "constructor": "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" - }, - "0x1204700000000000000000000000000000000000": { - "constructor": "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" - }, - "0x1204700000000000000000000000000000000002": { - "constructor": "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" - }, - "0x1204700000000000000000000000000000000004": { - "balance": "41198207933333333690000000", - "constructor": "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" - }, - "0x1204700000000000000000000000000000000006": { - "constructor": "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" - }, - "0x1204700000000000000000000000000000000007": { - "constructor": "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" - }, - "0x1204700000000000000000000000000000000008": { - "constructor": "0x60806040523480156200001157600080fd5b506040516040806200298b8339810180604052620000339190810190620002a8565b336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a381600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555062000141816200014960201b60201c565b5050620003da565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415620001bc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620001b3906200032b565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff166000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6000815190506200028b81620003a6565b92915050565b600081519050620002a281620003c0565b92915050565b60008060408385031215620002bc57600080fd5b6000620002cc8582860162000291565b9250506020620002df858286016200027a565b9150509250929050565b6000620002f8601f836200034d565b91507f4e6577206f776e657220616464726573732063616e6e6f7420626520307830006000830152602082019050919050565b600060208201905081810360008301526200034681620002e9565b9050919050565b600082825260208201905092915050565b60006200036b8262000386565b9050919050565b60006200037f826200035e565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b620003b1816200035e565b8114620003bd57600080fd5b50565b620003cb8162000372565b8114620003d757600080fd5b50565b6125a180620003ea6000396000f3fe608060405234801561001057600080fd5b50600436106100f55760003560e01c8063954029c911610097578063eab7ad9211610066578063eab7ad92146102b2578063ee7ee0fd146102ce578063f2fde38b146102fe578063fbd74f841461031a576100f5565b8063954029c91461021a578063a999809f14610236578063b71da0d114610266578063da5393d514610296576100f5565b80636a564261116100d35780636a5642611461017857806370a05b18146101ae5780638da5cb5b146101de5780638f32d59b146101fc576100f5565b80631bab58f5146100fa5780632c5653e21461012a57806332d91c0e14610148575b600080fd5b610114600480360361010f9190810190611d82565b61034a565b60405161012191906123f7565b60405180910390f35b610132610767565b60405161013f919061233a565b60405180910390f35b610162600480360361015d9190810190611d82565b61078d565b60405161016f9190612355565b60405180910390f35b610192600480360361018d9190810190611d82565b61097e565b6040516101a597969594939291906122af565b60405180910390f35b6101c860048036036101c39190810190611d82565b610c2d565b6040516101d5919061228d565b60405180910390f35b6101e6610e1e565b6040516101f39190612257565b60405180910390f35b610204610e47565b6040516102119190612272565b60405180910390f35b610234600480360361022f9190810190611d82565b610e9e565b005b610250600480360361024b9190810190611d82565b610ff5565b60405161025d9190612355565b60405180910390f35b610280600480360361027b9190810190611d82565b6111e6565b60405161028d9190612272565b60405180910390f35b6102b060048036036102ab9190810190611d82565b611276565b005b6102cc60048036036102c79190810190611dd4565b611371565b005b6102e860048036036102e39190810190611d82565b611673565b6040516102f59190612272565b60405180910390f35b61031860048036036103139190810190611d82565b6117d9565b005b610334600480360361032f9190810190611d82565b61182c565b604051610341919061228d565b60405180910390f35b610352611b4b565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636ddc4a076040518163ffffffff1660e01b815260040160206040518083038186803b1580156103ba57600080fd5b505afa1580156103ce573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052506103f29190810190611dab565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461045f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161045690612377565b60405180910390fd5b600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206040518060e0016040529081600082018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156105425780601f1061051757610100808354040283529160200191610542565b820191906000526020600020905b81548152906001019060200180831161052557829003601f168201915b50505050508152602001600182018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156105e45780601f106105b9576101008083540402835291602001916105e4565b820191906000526020600020905b8154815290600101906020018083116105c757829003601f168201915b50505050508152602001600282018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156106865780601f1061065b57610100808354040283529160200191610686565b820191906000526020600020905b81548152906001019060200180831161066957829003601f168201915b50505050508152602001600382018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156107285780601f106106fd57610100808354040283529160200191610728565b820191906000526020600020905b81548152906001019060200180831161070b57829003601f168201915b505050505081526020016004820160009054906101000a900460ff16151515158152602001600582015481526020016006820154815250509050919050565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6060600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636ddc4a076040518163ffffffff1660e01b815260040160206040518083038186803b1580156107f757600080fd5b505afa15801561080b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525061082f9190810190611dab565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461089c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089390612377565b60405180910390fd5b600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206003018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156109725780601f1061094757610100808354040283529160200191610972565b820191906000526020600020905b81548152906001019060200180831161095557829003601f168201915b50505050509050919050565b6001602052806000526040600020600091509050806000018054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610a2a5780601f106109ff57610100808354040283529160200191610a2a565b820191906000526020600020905b815481529060010190602001808311610a0d57829003601f168201915b505050505090806001018054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610ac85780601f10610a9d57610100808354040283529160200191610ac8565b820191906000526020600020905b815481529060010190602001808311610aab57829003601f168201915b505050505090806002018054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610b665780601f10610b3b57610100808354040283529160200191610b66565b820191906000526020600020905b815481529060010190602001808311610b4957829003601f168201915b505050505090806003018054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610c045780601f10610bd957610100808354040283529160200191610c04565b820191906000526020600020905b815481529060010190602001808311610be757829003601f168201915b5050505050908060040160009054906101000a900460ff16908060050154908060060154905087565b6060600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636ddc4a076040518163ffffffff1660e01b815260040160206040518083038186803b158015610c9757600080fd5b505afa158015610cab573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250610ccf9190810190611dab565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610d3c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d3390612377565b60405180910390fd5b600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206002018054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610e125780601f10610de757610100808354040283529160200191610e12565b820191906000526020600020905b815481529060010190602001808311610df557829003601f168201915b50505050509050919050565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614905090565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636ddc4a076040518163ffffffff1660e01b815260040160206040518083038186803b158015610f0657600080fd5b505afa158015610f1a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250610f3e9190810190611dab565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610fab576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fa290612377565b60405180910390fd5b43600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206006018190555050565b6060600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636ddc4a076040518163ffffffff1660e01b815260040160206040518083038186803b15801561105f57600080fd5b505afa158015611073573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052506110979190810190611dab565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611104576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110fb90612377565b60405180910390fd5b600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206001018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156111da5780601f106111af576101008083540402835291602001916111da565b820191906000526020600020905b8154815290600101906020018083116111bd57829003601f168201915b50505050509050919050565b6000600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060060154600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060050154109050919050565b61127e610e47565b6112bd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112b4906123d7565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561132d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161132490612397565b60405180910390fd5b80600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636ddc4a076040518163ffffffff1660e01b815260040160206040518083038186803b1580156113d957600080fd5b505afa1580156113ed573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052506114119190810190611dab565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461147e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161147590612377565b60405180910390fd5b8888600160008d73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060000191906114cf929190611b8a565b508686600160008d73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206001019190611521929190611c0a565b508484600160008d73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206002019190611573929190611b8a565b508282600160008d73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060030191906115c5929190611c0a565b5080600160008c73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060040160006101000a81548160ff02191690831515021790555043600160008c73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206005018190555050505050505050505050565b6000600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636ddc4a076040518163ffffffff1660e01b815260040160206040518083038186803b1580156116dd57600080fd5b505afa1580156116f1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052506117159190810190611dab565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611782576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161177990612377565b60405180910390fd5b600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060040160009054906101000a900460ff169050919050565b6117e1610e47565b611820576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611817906123d7565b60405180910390fd5b61182981611a1d565b50565b6060600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636ddc4a076040518163ffffffff1660e01b815260040160206040518083038186803b15801561189657600080fd5b505afa1580156118aa573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052506118ce9190810190611dab565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461193b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161193290612377565b60405180910390fd5b600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000018054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015611a115780601f106119e657610100808354040283529160200191611a11565b820191906000526020600020905b8154815290600101906020018083116119f457829003601f168201915b50505050509050919050565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611a8d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a84906123b7565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff166000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6040518060e001604052806060815260200160608152602001606081526020016060815260200160001515815260200160008152602001600081525090565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10611bcb57803560ff1916838001178555611bf9565b82800160010185558215611bf9579182015b82811115611bf8578235825591602001919060010190611bdd565b5b509050611c069190611c8a565b5090565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10611c4b57803560ff1916838001178555611c79565b82800160010185558215611c79579182015b82811115611c78578235825591602001919060010190611c5d565b5b509050611c869190611c8a565b5090565b611cac91905b80821115611ca8576000816000905550600101611c90565b5090565b90565b600081359050611cbe81612539565b92915050565b600081519050611cd381612539565b92915050565b600081359050611ce881612550565b92915050565b60008083601f840112611d0057600080fd5b8235905067ffffffffffffffff811115611d1957600080fd5b602083019150836001820283011115611d3157600080fd5b9250929050565b60008083601f840112611d4a57600080fd5b8235905067ffffffffffffffff811115611d6357600080fd5b602083019150836001820283011115611d7b57600080fd5b9250929050565b600060208284031215611d9457600080fd5b6000611da284828501611caf565b91505092915050565b600060208284031215611dbd57600080fd5b6000611dcb84828501611cc4565b91505092915050565b60008060008060008060008060008060c08b8d031215611df357600080fd5b6000611e018d828e01611caf565b9a505060208b013567ffffffffffffffff811115611e1e57600080fd5b611e2a8d828e01611cee565b995099505060408b013567ffffffffffffffff811115611e4957600080fd5b611e558d828e01611d38565b975097505060608b013567ffffffffffffffff811115611e7457600080fd5b611e808d828e01611cee565b955095505060808b013567ffffffffffffffff811115611e9f57600080fd5b611eab8d828e01611d38565b935093505060a0611ebe8d828e01611cd9565b9150509295989b9194979a5092959850565b611ed981612489565b82525050565b611ee88161249b565b82525050565b611ef78161249b565b82525050565b6000611f0882612424565b611f128185612456565b9350611f228185602086016124f5565b611f2b81612528565b840191505092915050565b6000611f4182612419565b611f4b8185612445565b9350611f5b8185602086016124f5565b611f6481612528565b840191505092915050565b6000611f7a82612419565b611f848185612456565b9350611f948185602086016124f5565b611f9d81612528565b840191505092915050565b611fb1816124d1565b82525050565b6000611fc28261243a565b611fcc8185612478565b9350611fdc8185602086016124f5565b611fe581612528565b840191505092915050565b6000611ffb8261242f565b6120058185612467565b93506120158185602086016124f5565b61201e81612528565b840191505092915050565b60006120348261242f565b61203e8185612478565b935061204e8185602086016124f5565b61205781612528565b840191505092915050565b600061206f601383612478565b91507f4572726f723a206f6e6c794c6f676963204462000000000000000000000000006000830152602082019050919050565b60006120af602983612478565b91507f4572726f723a206e65774c6f6f6b5570206973206e6f7420616c6c6f7765642060008301527f746f2062652030783000000000000000000000000000000000000000000000006020830152604082019050919050565b6000612115601f83612478565b91507f4e6577206f776e657220616464726573732063616e6e6f7420626520307830006000830152602082019050919050565b6000612155601383612478565b91507f53656e646572206973206e6f74206f776e6572000000000000000000000000006000830152602082019050919050565b600060e08301600083015184820360008601526121a58282611f36565b915050602083015184820360208601526121bf8282611ff0565b915050604083015184820360408601526121d98282611f36565b915050606083015184820360608601526121f38282611ff0565b91505060808301516122086080860182611edf565b5060a083015161221b60a0860182612239565b5060c083015161222e60c0860182612239565b508091505092915050565b612242816124c7565b82525050565b612251816124c7565b82525050565b600060208201905061226c6000830184611ed0565b92915050565b60006020820190506122876000830184611eee565b92915050565b600060208201905081810360008301526122a78184611efd565b905092915050565b600060e08201905081810360008301526122c9818a611f6f565b905081810360208301526122dd8189612029565b905081810360408301526122f18188611f6f565b905081810360608301526123058187612029565b90506123146080830186611eee565b61232160a0830185612248565b61232e60c0830184612248565b98975050505050505050565b600060208201905061234f6000830184611fa8565b92915050565b6000602082019050818103600083015261236f8184611fb7565b905092915050565b6000602082019050818103600083015261239081612062565b9050919050565b600060208201905081810360008301526123b0816120a2565b9050919050565b600060208201905081810360008301526123d081612108565b9050919050565b600060208201905081810360008301526123f081612148565b9050919050565b600060208201905081810360008301526124118184612188565b905092915050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b6000612494826124a7565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006124dc826124e3565b9050919050565b60006124ee826124a7565b9050919050565b60005b838110156125135780820151818401526020810190506124f8565b83811115612522576000848401525b50505050565b6000601f19601f8301169050919050565b61254281612489565b811461254d57600080fd5b50565b6125598161249b565b811461256457600080fd5b5056fea265627a7a7230582045fea88fa096a11a15a5bb8e9f5993ca3ab8a38132e6c7a04eb7cd5458378c906c6578706572696d656e74616cf5003700000000000000000000000012047000000000000000000000000000000000070000000000000000000000001204700000000000000000000000000000000005" - }, - "0x1204700000000000000000000000000000000009": { - "constructor": "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" + } + } + } + }, + "0x0000000000000000000000000000000000000009": { + "builtin": { + "name": "blake2_f", + "activate_at": "0x4b1bb6", + "pricing": { + "blake2_f": { + "gas_per_round": 1 + } } + } + }, + "0x1204700000000000000000000000000000000005": { + "constructor": "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" + }, + "0x1204700000000000000000000000000000000003": { + "constructor": "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" + }, + "0x120470000000000000000000000000000000000a": { + "balance": "10901790566666700000000000", + "constructor": "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" + }, + "0x0cB1437200aea736788f1Fc56F327c0456c3598D": { + "balance": "250000000000000000" + }, + "0x74dd76E24B2CFB43C1b1a4498295d553D0843746": { + "balance": "250000000000000000" + }, + "0xeeB4CEEe443F9e0D17BdBD6Daa241681EE5E51c2": { + "balance": "250000000000000000" + }, + "0xA005caEa55375ae20e3aAEF746113535503ABC19": { + "balance": "250000000000000000" + }, + "0x90ae948bB410838bff9D024ed849dF6A7267Dacf": { + "balance": "250000000000000000" + }, + "0x740a5C5742833bEd72489fE6bf7EFc9B79428989": { + "balance": "250000000000000000" + }, + "0x1204700000000000000000000000000000000001": { + "constructor": "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" + }, + "0x1204700000000000000000000000000000000000": { + "constructor": "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" + }, + "0x1204700000000000000000000000000000000002": { + "constructor": "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" + }, + "0x1204700000000000000000000000000000000004": { + "balance": "41198207933333333690000000", + "constructor": "0x608060405260006001556a22140f53c2d216263ba2803073ffffffffffffffffffffffffffffffffffffffff16311462000085576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260238152602001806200150b6023913960400191505060405180910390fd5b620000956200010260201b60201c565b6a22140f53c2d216263ba28060015414620000fc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526028815260200180620014ba6028913960400191505060405180910390fd5b62001133565b62000136722d4606b65c033769968bcdc63881b90b0853f569264876ff9c85a7a8ee00635df22bc06200105960201b60201c565b6200016a726e371c454a2d081f3966c180ba2c6165d87de66901c3c03b52c63f027880635df22bc06200105960201b60201c565b6200019e72c2f65230815d30eaa1a4d057bcf0b72fe3cc4e6902a5a058fc295ed00000635df22bc06200105960201b60201c565b620001d37303cccdc799d4dc37d56e3f9dba7f9c210fa1086f6902a5a058fc295ed00000635df22bc06200105960201b60201c565b6200020873047d955877a55fbdac768573a9259f29b103a0666902a5a058fc295ed00000635df22bc06200105960201b60201c565b6200023d7306920bb91f7027176cf373996d39b539ba436d876969e10de76676d0800000635d79dee06200105960201b60201c565b620002727306fdb93aa64f33a8fb40a36c462a3f7a074d632c6901c3c03b52c63f027880635df22bc06200105960201b60201c565b620002a7730ad7ba4af33b485e6f2505c417554631a3e5643f6902a5a058fc295ed00000635df22bc06200105960201b60201c565b620002dc730dd959deb4c458cc2ac379898bf2c99f7a8f399b6901c3c03b52c63f027880635df22bc06200105960201b60201c565b62000311731153818a2eb49f0a71b27313c32814fc02e4db50694220bb939da668600000635df22bc06200105960201b60201c565b6200034773120470000000000000000000000000000000000a6a084595161401484a000000635d79dee06200105960201b60201c565b6200037c7315696134ebeed360dc90dc97ddd00bd07e1c11e96934f086f3b33b68400000635df22bc06200105960201b60201c565b620003b1731f0c30b1aa4c468b5beb02bac8df8f27617a2296692346646590efbaf71200635df22bc06200105960201b60201c565b620003e6732540ded041b6fedc0ff6f0cf26b891ec97c954006901c3c03b52c63f027880635df22bc06200105960201b60201c565b6200041b7325ae7b45d8646580dfcae403d29164729eb8642f691a784379d99db4200000635df22bc06200105960201b60201c565b6200045073349ebc5a6e853df121c84e999081e5992928e64f6934f086f3b33b68400000635df22bc06200105960201b60201c565b62000485733885d15573e45228dd54cd4fde9bfac64d702ed46901c3c03b52c63f027880635df22bc06200105960201b60201c565b620004ba733a9d83766c03c465851a38daa364ef7deccd1ece6934f086f3b33b68400000635df22bc06200105960201b60201c565b620004ef733abaa3f24428d6028f5a7fc5b18ce9d04ccec2296902a5a058fc295ed00000635df22bc06200105960201b60201c565b62000524733c9f867d9b3a595987e198786fa9ab722e5c2f9b6934f086f3b33b68400000635df22bc06200105960201b60201c565b62000559733f11b4ad17fde4695cad64e109ae92a679d87bfc6969e10de76676d0800000635d79dee06200105960201b60201c565b6200058e733f12af735238c6e2fa45efb5b2f3fae82df4c9226901c3c03b52c63f027880635df22bc06200105960201b60201c565b620005c373404bb9c13364522133b363d5c4adb7a88056b19d6902d2cd2bb7a39658b500635df22bc06200105960201b60201c565b620005f873428ab4b019ee3a9b9863b2b4bf1885ce6dff9a736902a5a058fc295ed00000635df22bc06200105960201b60201c565b6200062d7347428fc08e56388372e7c81ad4a1140d932d10966969e10de76676d0800000635d79dee06200105960201b60201c565b620006627348ee57faf61c0b963113e7921e6173629e6bc4436902a5a058fc295ed00000635df22bc06200105960201b60201c565b62000697734d0aa1c3459bf41e3ad4e4f40bbf029cb5723d836934f086f3b33b68400000635df22bc06200105960201b60201c565b620006cc7357f33efad76d4b783cf42c9e6cb08f4425dfe96e6902a5a058fc295ed00000635df22bc06200105960201b60201c565b62000701735b3fb4e1d6040615f3e681bec4c80b5d7c9580716901c3c03b52c63f027880635df22bc06200105960201b60201c565b62000736735fbb9c482034d287c5b3848fc2f9272abdd5bfa26903878076a58c80674b00635df22bc06200105960201b60201c565b6200076b73656e5569bef7781bf0db199d32027766053501ff69438ec266600555e00000635df22bc06200105960201b60201c565b620007a073664f991cdb2ffe6b6a568ede65b0208dbcce6f72691a784379d99db4200000635df22bc06200105960201b60201c565b620007d67369af0912dd44dce2b2373db4021788cbad84ff356a0422ca8b0a00a4250000006360c3f9006200105960201b60201c565b6200080b736a0a5da2a48ea87c2a906c53b3373642c29a4b6c6934f086f3b33b68400000635df22bc06200105960201b60201c565b62000840736cf32cc52e220c023c2d92b1d62310f46a6e2a136901c3c03b52c63f027880635df22bc06200105960201b60201c565b62000875736d516767e4068fc331bdb331fba7578bdb07a68c69234b04a2777d0408ee00635df22bc06200105960201b60201c565b620008aa736dd10e41a7a84fe23ab35fefa2f46c9895f87a2d693c8c4bde2deef1680000635df22bc06200105960201b60201c565b620008df737030892dbf9c2048e796296dda597f145754a1856969e10de76676d0800000635d79dee06200105960201b60201c565b62000914737ed62cf71d519d3bf293ef90829508f92f4ccccb6902a5a058fc295ed00000635df22bc06200105960201b60201c565b6200094a73871ba4266793ad11da537d4857de7ad49eab662b6a017293b0a9e69fd9c00000635df22bc06200105960201b60201c565b6200097f73880e8b0ece0171edd0247f8d13d348d77a6b9b296903878076a58c80674b00635df22bc06200105960201b60201c565b620009b373887f2b16847248bc757b69f3c695f24ff344daf268e9062e03b5c2908780635df22bc06200105960201b60201c565b620009e8738c994ada51d35b8519424368807fb99c103366866969e10de76676d0800000635d79dee06200105960201b60201c565b62000a1d739196e46d664ceda55cb45a2cc5ab5bd1b7e614e26902a5a058fc295ed00000635df22bc06200105960201b60201c565b62000a5273943c85b13f24083ec73815f7ba763b7c42ae02886902a5a058fc295ed00000635df22bc06200105960201b60201c565b62000a87739467b762550673f08b14423f8562048d5e3694226902a5a058fc295ed00000635df22bc06200105960201b60201c565b62000abc73949423db1bfee1ddec99c9d24a12a6ea27cb34896901c3c03b52c63f027880635df22bc06200105960201b60201c565b62000af17396a5eb172efdf262ed6beaaf0e20c6af71831fc96934f086f3b33b68400000635df22bc06200105960201b60201c565b62000b2673a69dca0814eaadc89b6dbe94c5e2110497690f6c6903878076a58c80674b00635df22bc06200105960201b60201c565b62000b5b73a720a8ee90f5013cae9bf7bcac1d153e42815454691a784379d99db4200000635df22bc06200105960201b60201c565b62000b9073b080454f190e76eb8e719560fa8cae50c71bcea96901c3c03b52c63f027880635df22bc06200105960201b60201c565b62000bc573b476ee7d610dae7b23b671ebc7bd6112e97729696902a5a058fc295ed00000635df22bc06200105960201b60201c565b62000bfb73b561618a3ea959a5e363643b267c4cb8fe4b1df76a0422ca8b0a00a4250000006360c3f9006200105960201b60201c565b62000c3073b5b6d8885fbf28f843cc7886de242b811d6952056901c3c03b52c63f027880635df22bc06200105960201b60201c565b62000c6573b61c11b6e42d459efaee8995c44db08507e468e169477d5529f68a63000000635df22bc06200105960201b60201c565b62000c9a73b999004b49c6b907d4278067da5c85195dcd7fc769081e0dddaff653f8b500635df22bc06200105960201b60201c565b62000ccf73be4888c5b021e5f16cd254de2d4eaf17625685c46934f086f3b33b68400000635df22bc06200105960201b60201c565b62000d0473c1d441a2ad43af7b4a3d8e3200d2ceb3a973099d6934f086f3b33b68400000635df22bc06200105960201b60201c565b62000d3973c58a20e290e858542d8e8bb07b600aeb9195fe306903878076a58c80674b00635df22bc06200105960201b60201c565b62000d6f73cfe7964b0b6412b013dc019bdf3afef58be565936a055084cc99f0bdbadd0000635df22bc06200105960201b60201c565b62000da473d33d4f83e85c92e0b53ffe4fc0e18b0e3632c0976901c3c03b52c63f027880635df22bc06200105960201b60201c565b62000dd973d44fb8de580d34f44789408cc9335c9a9ce0ce4d691ad0235eb930a0540000635df22bc06200105960201b60201c565b62000e0e73dacd80d8e1d4f117515caa477ee7599cdfc766196902a5a058fc295ed00000635df22bc06200105960201b60201c565b62000e4373db6cc57168c07b83a00f1f8871538446068824fc691a784379d99db4200000635df22bc06200105960201b60201c565b62000e7873de6b493d368316b9078454e37dce4968482dfbe96969e10de76676d0800000635d79dee06200105960201b60201c565b62000ead73e23c7cb60189bb2fd60625d2c2747b1e68f107766934f086f3b33b68400000635df22bc06200105960201b60201c565b62000ee273e6e8a111c89b05337049de9349c7c4880a396ef1691a784379d99db4200000635df22bc06200105960201b60201c565b62000f1773ebbddf28bf3224791b0510a2ab8813f182fe4e2b6901c3c03b52c63f027880635df22bc06200105960201b60201c565b62000f4c73f4e31018a926f64cb780cb9f5f027377bcfb26fc6907f0e10af47c1c700000635df22bc06200105960201b60201c565b62000f8173f8e6ecb4b0f17576525749bdf85524652cbf002e6901c3c03b52c63f027880635df22bc06200105960201b60201c565b62000fb773fd679097fe0f914642af9857e5799332fe2efa296a01a784379d99db42000000635d79dee06200105960201b60201c565b62000fed73fd7a30d3c2bd017a458610274c275059d308b2e76a01ff1675f219f5a8780000635df22bc06200105960201b60201c565b6200102273ffcf98c62c1bad480ab6846717b173a72e2dd090691a784379d99db4200000635df22bc06200105960201b60201c565b6200105773ffd9b871df6e93803c0877e98fc1722b39c00d786902a5a058fc295ed00000635df22bc06200105960201b60201c565b565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060008160000154148015620010b4575060008160010154145b6200110b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526029815260200180620014e26029913960400191505060405180910390fd5b8260016000828254019250508190555082816000018190555081816001018190555050505050565b61037780620011436000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c806318a5bbdc14610051578063192e7a7b146100b057806330f0dbe0146100f45780639976e12f14610112575b600080fd5b6100936004803603602081101561006757600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610130565b604051808381526020018281526020019250505060405180910390f35b6100f2600480360360208110156100c657600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610154565b005b6100fc610336565b6040518082815260200191505060405180910390f35b61011a610345565b6040518082815260200191505060405180910390f35b60006020528060005260406000206000915090508060000154908060010154905082565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506000816000015411610210576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260158152602001807f417661696c61626c6520616d6f756e742069732030000000000000000000000081525060200191505060405180910390fd5b80600101544211610289576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601a8152602001807f486f6c64696e6720706572696f64206973206e6f74206f76657200000000000081525060200191505060405180910390fd5b600081600001549050600082600001819055508273ffffffffffffffffffffffffffffffffffffffff166108fc829081150290604051600060405180830381858888f193505050501580156102e2573d6000803e3d6000fd5b508273ffffffffffffffffffffffffffffffffffffffff167f221c08a06b07a64803b3787861a3f276212fcccb51c2e6234077a9b8cb13047a826040518082815260200191505060405180910390a2505050565b6a22140f53c2d216263ba28081565b6001548156fea165627a7a72305820b0165b18a29fae78ec1f58bf69134a67ab02e21d059e757412318d8362284866002954617267657420616d6f756e742073686f756c6420657175616c2061637475616c20616d6f756e74486f6c64696e6720666f72207468697320616464726573732077617320616c7265616479207365742e42616c616e63652073686f756c6420657175616c2074617267657420616d6f756e742e" + }, + "0x1204700000000000000000000000000000000006": { + "constructor": "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" + }, + "0x1204700000000000000000000000000000000007": { + "constructor": "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" + }, + "0x1204700000000000000000000000000000000008": { + "constructor": "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" }, - "nodes": [ - "enode://6c2f5c236b88a1eba30a26f2114ec9b8c4d741495e21f9d59c1f7d2a19ba20fda52ed1e319d935f95441f9f3b944423ce8d032fa3019691df217129964680591@ewc-bootnode-01.energyweb.org:30303", - "enode://cc67008e850c4b64702f1664f18704dd23980fb574138588904270739dca3a9c417ac3f97077b0f4e4872a5db109195f7137c156314dbcc724eabd809044553e@ewc-bootnode-02.energyweb.org:30303", - "enode://41ff9e64e1277f4f1168894d77bcbfd810a184929e3e40a1f0cfc91802bff014cc920653ce1da79fd237c8ae719fd1b58524f9664ac6319fe57ebb63b2b9728d@ewc-bootnode-03.energyweb.org:30303", - "enode://d97233ccebecaa15e07c46fca34d355fd978ffb2b9194b2486e6978aa3dd74a638db0c80fe27e6258929000996c37aa92c70a73720bf480a479dd8ec15ba0535@ewc-bootnode-04.energyweb.org:30303", - "enode://80e49825bb6bdfbf69576fd4a5f7bb173db98c08439bd7a019e2d42548afbb1f70232b74ede42dbd99cc0de3990a0101d49543c1b299027d2fd6f5a2c81eff75@ewc-bootnode-05.energyweb.org:30303", - "enode://1cd00f54ddaa41793d32500f0cb123d43e95f5ed18220c367d5a4db7d111e5fb59f250c397e40977562881875827f022d88a51e51171daaebf916beaa60e2139@ewc-bootnode-06.energyweb.org:30303", - "enode://acd6673ac09eee760b7cce6a7e1cd1559294afd43c353b796cc5251cff04d8950c92f53fc3d8d727c97d1e1a0356ae16ec2447c06842ba6c2ff9f9fa0eb13629@ewc-bootnode-07.energyweb.org:30303", - "enode://d094aac598a05fc8d8347e009e1e9efaceb83dbb64c89e845f7181b53b6e9146e34caafaf658f66cfad1758c58908c560bde3bc873c18eb9d32150d4c89803c2@ewc-bootnode-08.energyweb.org:30303", - "enode://3a8588bd883ea3bce606b08e7ca71d55717077cb3d25d3c00421ac371fbae286b94f58ba2e739b17b64c4d0d3e19f1b0ae2e47962703b42d7f36f1b9a448d4ea@ewc-bootnode-09.energyweb.org:30303", - "enode://69749dbe7e6f5fceaeb0a16f60353b3ec04825a12400e6d581fe980275e96fecb464276e61d79fc1628e448f1f74da2985d778ea54e0e8e7c64d980f2b3b6a94@ewc-bootnode-10.energyweb.org:30303", - "enode://36c86675b4cf3b3ad9913a16b22acbec28c03aaba9fafeb97b6a293dbe9ccbe9ab9895663adb47387003258c8308344c1183c3f247a0812a1f3f53c9575bc582@ewc-bootnode-11.energyweb.org:30303", - "enode://b433e5eef569ee9f690a82d7aecc79769da7dd029c22229623253fbc55da4fd5a4b1352d3f46eb67044e100ca59d9ee667f36811041a6068dfbb625b5b34b4de@ewc-bootnode-12.energyweb.org:30303" - ] + "0x1204700000000000000000000000000000000009": { + "constructor": "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" + } + }, + "nodes": [ + "enode://6c2f5c236b88a1eba30a26f2114ec9b8c4d741495e21f9d59c1f7d2a19ba20fda52ed1e319d935f95441f9f3b944423ce8d032fa3019691df217129964680591@ewc-bootnode-01.energyweb.org:30303", + "enode://cc67008e850c4b64702f1664f18704dd23980fb574138588904270739dca3a9c417ac3f97077b0f4e4872a5db109195f7137c156314dbcc724eabd809044553e@ewc-bootnode-02.energyweb.org:30303", + "enode://41ff9e64e1277f4f1168894d77bcbfd810a184929e3e40a1f0cfc91802bff014cc920653ce1da79fd237c8ae719fd1b58524f9664ac6319fe57ebb63b2b9728d@ewc-bootnode-03.energyweb.org:30303", + "enode://d97233ccebecaa15e07c46fca34d355fd978ffb2b9194b2486e6978aa3dd74a638db0c80fe27e6258929000996c37aa92c70a73720bf480a479dd8ec15ba0535@ewc-bootnode-04.energyweb.org:30303", + "enode://80e49825bb6bdfbf69576fd4a5f7bb173db98c08439bd7a019e2d42548afbb1f70232b74ede42dbd99cc0de3990a0101d49543c1b299027d2fd6f5a2c81eff75@ewc-bootnode-05.energyweb.org:30303", + "enode://1cd00f54ddaa41793d32500f0cb123d43e95f5ed18220c367d5a4db7d111e5fb59f250c397e40977562881875827f022d88a51e51171daaebf916beaa60e2139@ewc-bootnode-06.energyweb.org:30303", + "enode://acd6673ac09eee760b7cce6a7e1cd1559294afd43c353b796cc5251cff04d8950c92f53fc3d8d727c97d1e1a0356ae16ec2447c06842ba6c2ff9f9fa0eb13629@ewc-bootnode-07.energyweb.org:30303", + "enode://d094aac598a05fc8d8347e009e1e9efaceb83dbb64c89e845f7181b53b6e9146e34caafaf658f66cfad1758c58908c560bde3bc873c18eb9d32150d4c89803c2@ewc-bootnode-08.energyweb.org:30303", + "enode://3a8588bd883ea3bce606b08e7ca71d55717077cb3d25d3c00421ac371fbae286b94f58ba2e739b17b64c4d0d3e19f1b0ae2e47962703b42d7f36f1b9a448d4ea@ewc-bootnode-09.energyweb.org:30303", + "enode://69749dbe7e6f5fceaeb0a16f60353b3ec04825a12400e6d581fe980275e96fecb464276e61d79fc1628e448f1f74da2985d778ea54e0e8e7c64d980f2b3b6a94@ewc-bootnode-10.energyweb.org:30303", + "enode://36c86675b4cf3b3ad9913a16b22acbec28c03aaba9fafeb97b6a293dbe9ccbe9ab9895663adb47387003258c8308344c1183c3f247a0812a1f3f53c9575bc582@ewc-bootnode-11.energyweb.org:30303", + "enode://b433e5eef569ee9f690a82d7aecc79769da7dd029c22229623253fbc55da4fd5a4b1352d3f46eb67044e100ca59d9ee667f36811041a6068dfbb625b5b34b4de@ewc-bootnode-12.energyweb.org:30303" + ] } From c9fe29c1fd7ace1f7669c093033268c523e51105 Mon Sep 17 00:00:00 2001 From: Micke <155267459+reallesee@users.noreply.github.com> Date: Tue, 15 Jul 2025 11:38:41 +0200 Subject: [PATCH 19/40] feat: Add RegexOptions.Compiled flag to NewPayloadJsonRpcValidator (#8984) --- .../JsonRpcValidator/Eth/NewPayloadJsonRpcValidator.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/Nethermind.Tools.Kute/JsonRpcValidator/Eth/NewPayloadJsonRpcValidator.cs b/tools/Nethermind.Tools.Kute/JsonRpcValidator/Eth/NewPayloadJsonRpcValidator.cs index dc302584065..1a78ae10d30 100644 --- a/tools/Nethermind.Tools.Kute/JsonRpcValidator/Eth/NewPayloadJsonRpcValidator.cs +++ b/tools/Nethermind.Tools.Kute/JsonRpcValidator/Eth/NewPayloadJsonRpcValidator.cs @@ -8,7 +8,7 @@ namespace Nethermind.Tools.Kute.JsonRpcValidator.Eth; public class NewPayloadJsonRpcValidator : IJsonRpcValidator { - private readonly Regex _pattern = new Regex("engine_newPayload"); + private readonly Regex _pattern = new Regex("engine_newPayload", RegexOptions.Compiled); public bool IsValid(JsonRpc request, JsonDocument? response) { From bea66a5b44e79931f15263e60073461da82f0045 Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Tue, 15 Jul 2025 12:15:50 +0100 Subject: [PATCH 20/40] Improve locking when looking up RlpDecoders (#8987) * Remove locking in RlpDecoder fast path * Feedback --- .../Nethermind.Serialization.Rlp/Rlp.cs | 28 +++++++++++++++---- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/src/Nethermind/Nethermind.Serialization.Rlp/Rlp.cs b/src/Nethermind/Nethermind.Serialization.Rlp/Rlp.cs index 0a603815def..582df031495 100644 --- a/src/Nethermind/Nethermind.Serialization.Rlp/Rlp.cs +++ b/src/Nethermind/Nethermind.Serialization.Rlp/Rlp.cs @@ -78,26 +78,41 @@ public Rlp(byte[] bytes) private static readonly Dictionary _decoderBuilder = new(); private static FrozenDictionary? _decoders; - private static Lock _decoderLock = new Lock(); + private static Lock _decoderLock = new(); public static FrozenDictionary Decoders { get { - using Lock.Scope _ = _decoderLock.EnterScope(); - return _decoders ??= _decoderBuilder.ToFrozenDictionary(); + FrozenDictionary decoders = _decoders; + if (decoders is not null) + { + // Already exists no need for lock + return decoders; + } + + return CreateDecoders(); } } + private static FrozenDictionary CreateDecoders() + { + using Lock.Scope _ = _decoderLock.EnterScope(); + // Recreate, if not already recreated + return _decoders ??= _decoderBuilder.ToFrozenDictionary(); + } + public static void ResetDecoders() { + using Lock.Scope _ = _decoderLock.EnterScope(); _decoderBuilder.Clear(); _decoders = null; RegisterDecoders(Assembly.GetAssembly(typeof(Rlp))); - Rlp.RegisterDecoder(typeof(Transaction), TxDecoder.Instance); + RegisterDecoder(typeof(Transaction), TxDecoder.Instance); } public static void RegisterDecoder(RlpDecoderKey key, IRlpDecoder decoder) { + using Lock.Scope _ = _decoderLock.EnterScope(); _decoderBuilder[key] = decoder; // Mark FrozenDictionary as null to force re-creation _decoders = null; @@ -146,6 +161,7 @@ public static void RegisterDecoders(Assembly assembly, bool canOverrideExistingD void AddEncoder(RlpDecoderKey key) { + using Lock.Scope _ = _decoderLock.EnterScope(); if (!_decoderBuilder.TryGetValue(key, out IRlpDecoder? value) || canOverrideExistingDecoders) { try @@ -1921,7 +1937,9 @@ public readonly struct RlpDecoderKey(Type type, string key = RlpDecoderKey.Defau public bool Equals(RlpDecoderKey other) => _type.Equals(other._type) && _key.Equals(other._key); - public override int GetHashCode() => HashCode.Combine(_type, _key); + public override int GetHashCode() => (int)BitOperations.Crc32C( + (uint)_type.GetHashCode(), + (uint)MemoryMarshal.AsBytes(_key.AsSpan()).FastHash()); public override bool Equals(object obj) => obj is RlpDecoderKey key && Equals(key); From 6ba2255face100a65aab7984e0f33ee6f5de9010 Mon Sep 17 00:00:00 2001 From: Marcin Sobczak <77129288+marcindsobczak@users.noreply.github.com> Date: Wed, 16 Jul 2025 15:56:15 +0200 Subject: [PATCH 21/40] Fix naming of data cost in ExecutePrecompile (#8994) fix naming of data cost --- src/Nethermind/Nethermind.Evm/VirtualMachine.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs index fd9d7ed9cfe..a6a7bfb62d5 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs @@ -965,7 +965,7 @@ private CallResult RunPrecompile(EvmState state) IReleaseSpec spec = BlockExecutionContext.Spec; long baseGasCost = precompile.BaseGasCost(spec); - long blobGasCost = precompile.DataGasCost(callData, spec); + long dataGasCost = precompile.DataGasCost(callData, spec); bool wasCreated = _worldState.AddToBalanceAndCreateIfNotExists(state.Env.ExecutingAccount, transferValue, spec); @@ -985,7 +985,7 @@ private CallResult RunPrecompile(EvmState state) _parityTouchBugAccount.ShouldDelete = true; } - if (!UpdateGas(checked(baseGasCost + blobGasCost), ref gasAvailable)) + if (!UpdateGas(checked(baseGasCost + dataGasCost), ref gasAvailable)) { return new(default, false, 0, true, EvmExceptionType.OutOfGas); } From b9f48a58a537eef6d1df641696af54d1e85c5127 Mon Sep 17 00:00:00 2001 From: Nikita Mescheryakov Date: Wed, 16 Jul 2025 17:22:45 +0300 Subject: [PATCH 22/40] Move precompiles (#8962) * Move precompiles * Fix build * Fix formating * EthereumCodeInfoRepository * Remove EthereumPrecompiles class * Move precompiles into separate project * Fix build --- .../BlockchainProcessorTests.cs | 2 +- .../Producers/DevBlockproducerTests.cs | 2 +- .../Nethermind.Blockchain.Test/ReorgTests.cs | 2 +- .../TransactionProcessorEip7702Tests.cs | 3 +- .../TransactionProcessorTests.cs | 3 +- .../CachedCodeInfoRepository.cs | 54 +++++ .../EthereumCodeInfoRepository.cs | 49 +++++ .../Nethermind.Blockchain/Metrics.cs | 195 +++++++++--------- .../Nethermind.Blockchain.csproj | 1 + .../CliqueBlockProducerTests.cs | 2 +- .../CensorshipDetectorTests.cs | 2 +- .../Processing/ProcessingStats.cs | 4 +- .../Modules/TestBlockProcessingModule.cs | 2 +- src/Nethermind/Nethermind.Db/Metrics.cs | 8 - .../Nethermind.Evm.Benchmark/EvmBenchmarks.cs | 3 +- .../MultipleUnsignedOperations.cs | 3 +- .../StaticCallBenchmarks.cs | 3 +- .../Blake2FPrecompile.cs | 61 ++++++ .../Bls/BlsConst.cs | 1 - .../Bls/BlsExtensions.cs | 0 .../Bls/Discount.cs | 149 +++++++++++++ .../Bls/G1AddPrecompile.cs | 2 +- .../Bls/G1MSMPrecompile.cs | 1 + .../Bls/G2AddPrecompile.cs | 2 +- .../Bls/G2MSMPrecompile.cs | 1 + .../Bls/MapFp2ToG2Precompile.cs | 2 +- .../Bls/MapFpToG1Precompile.cs | 1 + .../Bls/PairingCheckPrecompile.cs | 2 +- .../EcRecoverPrecompile.cs | 74 +++++++ .../Nethermind.Evm.Precompiles/Extensions.cs | 15 ++ .../IdentityPrecompile.cs | 31 +++ .../Nethermind.Evm.Precompiles/Metrics.cs | 82 ++++++++ .../ModExpPrecompile.cs | 3 +- .../ModExpPrecompilePreEip2565.cs | 132 ++++++++++++ .../Nethermind.Evm.Precompiles.csproj | 20 ++ .../PointEvaluationPrecompile.cs | 1 + .../Ripemd160Precompile.cs | 41 ++++ .../Secp256r1Precompile.cs | 1 + .../Sha256Precompile.cs | 37 ++++ .../Snarks/Bn254AddPrecompile.cs | 1 + .../Snarks/Bn254MulPrecompile.cs | 1 + .../Snarks/Bn254PairingPrecompile.cs | 1 + .../BlsG1AddPrecompileTests.cs | 2 +- .../BlsG2AddPrecompileTests.cs | 2 +- .../CodeInfoRepositoryTests.cs | 21 +- .../Nethermind.Evm.Test/Eip2537Tests.cs | 2 +- .../Nethermind.Evm.Test/Eip7823Tests.cs | 2 +- .../EvmPooledMemoryTests.cs | 5 +- .../Tracing/GasEstimationTests.cs | 3 +- .../Tracing/ParityLikeTxTracerTests.cs | 1 - .../TransactionProcessorEip4844Tests.cs | 3 +- .../TransactionProcessorEip7623Tests.cs | 3 +- .../TransactionProcessorFeeTests.cs | 3 +- .../VirtualMachineTestsBase.cs | 3 +- .../CodeInfoRepository.cs | 80 +------ .../Nethermind.Evm/ICodeInfoRepository.cs | 1 + .../Instructions/EvmInstructions.cs | 4 +- src/Nethermind/Nethermind.Evm/Metrics.cs | 61 +----- .../Precompiles/Blake2FPrecompile.cs | 61 ------ .../Precompiles/Bls/Discount.cs | 150 -------------- .../Precompiles/EcRecoverPrecompile.cs | 73 ------- .../Nethermind.Evm/Precompiles/Extensions.cs | 16 -- .../Precompiles/IdentityPrecompile.cs | 29 --- .../Precompiles/ModExpPrecompilePreEip2565.cs | 128 ------------ .../Precompiles/Ripemd160Precompile.cs | 39 ---- .../Precompiles/Sha256Precompile.cs | 34 --- .../Modules/BlockProcessingModule.cs | 2 +- .../Steps/InitializeBlockchain.cs | 9 +- .../Modules/ParityRpcModuleTests.cs | 3 +- .../Eth62ProtocolHandlerBenchmarks.cs | 2 +- .../Nethermind.Precompiles.Benchmark.csproj | 2 + .../OverridableCodeInfoRepository.cs | 5 + .../TransactionProcessorTests.cs | 4 +- .../DelegatedAccountFilterTest.cs | 16 +- .../NonceManagerTests.cs | 2 +- .../TxPoolTests.Blobs.cs | 2 +- .../Nethermind.TxPool.Test/TxPoolTests.cs | 2 +- src/Nethermind/Nethermind.slnx | 1 + tools/Evm/T8n/T8nExecutor.cs | 3 +- 79 files changed, 945 insertions(+), 834 deletions(-) create mode 100644 src/Nethermind/Nethermind.Blockchain/CachedCodeInfoRepository.cs create mode 100644 src/Nethermind/Nethermind.Blockchain/EthereumCodeInfoRepository.cs create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Blake2FPrecompile.cs rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Bls/BlsConst.cs (98%) rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Bls/BlsExtensions.cs (100%) create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Bls/Discount.cs rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Bls/G1AddPrecompile.cs (98%) rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Bls/G1MSMPrecompile.cs (99%) rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Bls/G2AddPrecompile.cs (98%) rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Bls/G2MSMPrecompile.cs (99%) rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Bls/MapFp2ToG2Precompile.cs (97%) rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Bls/MapFpToG1Precompile.cs (97%) rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Bls/PairingCheckPrecompile.cs (98%) create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/EcRecoverPrecompile.cs create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/IdentityPrecompile.cs create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Metrics.cs rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/ModExpPrecompile.cs (99%) create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Nethermind.Evm.Precompiles.csproj rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/PointEvaluationPrecompile.cs (98%) create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Ripemd160Precompile.cs rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Secp256r1Precompile.cs (96%) create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Sha256Precompile.cs rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Snarks/Bn254AddPrecompile.cs (97%) rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Snarks/Bn254MulPrecompile.cs (97%) rename src/Nethermind/{Nethermind.Evm/Precompiles => Nethermind.Evm.Precompiles}/Snarks/Bn254PairingPrecompile.cs (98%) rename src/Nethermind/{Nethermind.State => Nethermind.Evm}/CodeInfoRepository.cs (65%) delete mode 100644 src/Nethermind/Nethermind.Evm/Precompiles/Blake2FPrecompile.cs delete mode 100644 src/Nethermind/Nethermind.Evm/Precompiles/Bls/Discount.cs delete mode 100644 src/Nethermind/Nethermind.Evm/Precompiles/EcRecoverPrecompile.cs delete mode 100644 src/Nethermind/Nethermind.Evm/Precompiles/Extensions.cs delete mode 100644 src/Nethermind/Nethermind.Evm/Precompiles/IdentityPrecompile.cs delete mode 100644 src/Nethermind/Nethermind.Evm/Precompiles/ModExpPrecompilePreEip2565.cs delete mode 100644 src/Nethermind/Nethermind.Evm/Precompiles/Ripemd160Precompile.cs delete mode 100644 src/Nethermind/Nethermind.Evm/Precompiles/Sha256Precompile.cs diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs index 2851766175b..411681ccf17 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs @@ -524,7 +524,7 @@ public async Task Can_process_fast_sync() new FixedForkActivationChainHeadSpecProvider(specProvider, fixedBlock: 10_000_000), blockTree, readOnlyState, - new CodeInfoRepository()) + new EthereumCodeInfoRepository()) { HasSynced = true }; diff --git a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs index f6a4813dde6..76890d2dbee 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs @@ -52,7 +52,7 @@ public void Test() IWorldState stateProvider = worldStateManager.GlobalWorldState; IStateReader stateReader = worldStateManager.GlobalStateReader; BlockhashProvider blockhashProvider = new(blockTree, specProvider, stateProvider, LimboLogs.Instance); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); VirtualMachine virtualMachine = new( blockhashProvider, specProvider, diff --git a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs index e0f70a9182f..18bc2db36d2 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs @@ -72,7 +72,7 @@ public void Setup() .WithSpecProvider(specProvider) .TestObject; - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); TxPool.TxPool txPool = new( ecdsa, new BlobTxStorage(), diff --git a/src/Nethermind/Nethermind.Blockchain.Test/TransactionProcessorEip7702Tests.cs b/src/Nethermind/Nethermind.Blockchain.Test/TransactionProcessorEip7702Tests.cs index 5d2096cd3b7..c1365b1f81e 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/TransactionProcessorEip7702Tests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/TransactionProcessorEip7702Tests.cs @@ -19,6 +19,7 @@ using Nethermind.Core.Crypto; using System; using System.Linq; +using Nethermind.Blockchain; using Nethermind.Blockchain.Tracing; using Nethermind.Core.Test; using Nethermind.Int256; @@ -40,7 +41,7 @@ public void Setup() _specProvider = new TestSpecProvider(Prague.Instance); IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); _stateProvider = worldStateManager.GlobalWorldState; - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); diff --git a/src/Nethermind/Nethermind.Blockchain.Test/TransactionProcessorTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/TransactionProcessorTests.cs index 99fe538bc62..e515a2480ec 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/TransactionProcessorTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/TransactionProcessorTests.cs @@ -25,6 +25,7 @@ using NUnit.Framework; using Nethermind.Config; using System.Collections.Generic; +using Nethermind.Blockchain; using Nethermind.Blockchain.Tracing; using Nethermind.Core.Test; using Nethermind.State; @@ -60,7 +61,7 @@ public void Setup() _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); diff --git a/src/Nethermind/Nethermind.Blockchain/CachedCodeInfoRepository.cs b/src/Nethermind/Nethermind.Blockchain/CachedCodeInfoRepository.cs new file mode 100644 index 00000000000..b2077c19f96 --- /dev/null +++ b/src/Nethermind/Nethermind.Blockchain/CachedCodeInfoRepository.cs @@ -0,0 +1,54 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Collections.Concurrent; +using System.Collections.Frozen; +using System.Collections.Generic; +using Nethermind.Core; +using Nethermind.Core.Specs; +using Nethermind.Evm; +using Nethermind.Evm.CodeAnalysis; +using Nethermind.Evm.Precompiles; +using Nethermind.State; + +namespace Nethermind.Blockchain; + +public class CachedCodeInfoRepository( + FrozenDictionary precompiles, + ConcurrentDictionary? precompileCache) : CodeInfoRepository( + precompileCache is null + ? precompiles + : precompiles.ToFrozenDictionary(kvp => kvp.Key, kvp => CreateCachedPrecompile(kvp, precompileCache))) +{ + private static PrecompileInfo CreateCachedPrecompile( + in KeyValuePair originalPrecompile, + ConcurrentDictionary cache) => + new PrecompileInfo(new CachedPrecompile(originalPrecompile.Key.Value, originalPrecompile.Value.Precompile!, cache)); + + private class CachedPrecompile( + Address address, + IPrecompile precompile, + ConcurrentDictionary cache) : IPrecompile + { + public static Address Address => Address.Zero; + + public long BaseGasCost(IReleaseSpec releaseSpec) => precompile.BaseGasCost(releaseSpec); + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => precompile.DataGasCost(inputData, releaseSpec); + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + PreBlockCaches.PrecompileCacheKey key = new(address, inputData); + if (!cache.TryGetValue(key, out (byte[], bool) result)) + { + result = precompile.Run(inputData, releaseSpec); + // we need to rebuild the key with data copy as the data can be changed by VM processing + key = new PreBlockCaches.PrecompileCacheKey(address, inputData.ToArray()); + cache.TryAdd(key, result); + } + + return result; + } + } +} diff --git a/src/Nethermind/Nethermind.Blockchain/EthereumCodeInfoRepository.cs b/src/Nethermind/Nethermind.Blockchain/EthereumCodeInfoRepository.cs new file mode 100644 index 00000000000..35b95c86d5e --- /dev/null +++ b/src/Nethermind/Nethermind.Blockchain/EthereumCodeInfoRepository.cs @@ -0,0 +1,49 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System.Collections.Concurrent; +using System.Collections.Frozen; +using System.Collections.Generic; +using Nethermind.Core; +using Nethermind.Evm.CodeAnalysis; +using Nethermind.Evm.Precompiles; +using Nethermind.Evm.Precompiles.Bls; +using Nethermind.Evm.Precompiles.Snarks; +using Nethermind.State; + +namespace Nethermind.Blockchain; + +public class EthereumCodeInfoRepository( + ConcurrentDictionary? precompileCache = null) + : CachedCodeInfoRepository(Precompiles, precompileCache) +{ + private static FrozenDictionary Precompiles + { + get => new Dictionary + { + [EcRecoverPrecompile.Address] = new(EcRecoverPrecompile.Instance), + [Sha256Precompile.Address] = new(Sha256Precompile.Instance), + [Ripemd160Precompile.Address] = new(Ripemd160Precompile.Instance), + [IdentityPrecompile.Address] = new(IdentityPrecompile.Instance), + + [Bn254AddPrecompile.Address] = new(Bn254AddPrecompile.Instance), + [Bn254MulPrecompile.Address] = new(Bn254MulPrecompile.Instance), + [Bn254PairingPrecompile.Address] = new(Bn254PairingPrecompile.Instance), + [ModExpPrecompile.Address] = new(ModExpPrecompile.Instance), + + [Blake2FPrecompile.Address] = new(Blake2FPrecompile.Instance), + + [G1AddPrecompile.Address] = new(G1AddPrecompile.Instance), + [G1MSMPrecompile.Address] = new(G1MSMPrecompile.Instance), + [G2AddPrecompile.Address] = new(G2AddPrecompile.Instance), + [G2MSMPrecompile.Address] = new(G2MSMPrecompile.Instance), + [PairingCheckPrecompile.Address] = new(PairingCheckPrecompile.Instance), + [MapFpToG1Precompile.Address] = new(MapFpToG1Precompile.Instance), + [MapFp2ToG2Precompile.Address] = new(MapFp2ToG2Precompile.Instance), + + [PointEvaluationPrecompile.Address] = new(PointEvaluationPrecompile.Instance), + + [Secp256r1Precompile.Address] = new(Secp256r1Precompile.Instance), + }.ToFrozenDictionary(); + } +} diff --git a/src/Nethermind/Nethermind.Blockchain/Metrics.cs b/src/Nethermind/Nethermind.Blockchain/Metrics.cs index a778115dde6..91864c136fb 100644 --- a/src/Nethermind/Nethermind.Blockchain/Metrics.cs +++ b/src/Nethermind/Nethermind.Blockchain/Metrics.cs @@ -6,105 +6,104 @@ using Nethermind.Core.Attributes; using Nethermind.Core.Metric; using Nethermind.Int256; + // ReSharper disable InconsistentNaming -namespace Nethermind.Blockchain +namespace Nethermind.Blockchain; + +public static class Metrics { - public static class Metrics - { - [CounterMetric] - [Description("Total MGas processed")] - public static double Mgas { get; set; } - - [GaugeMetric] - [Description("MGas processed per second")] - public static double MgasPerSec { get; set; } - - [CounterMetric] - [Description("Total number of transactions processed")] - public static long Transactions { get; set; } - - [GaugeMetric] - [Description("Total number of blocks processed")] - public static long Blocks { get; set; } - - [CounterMetric] - [Description("Total number of chain reorganizations")] - public static long Reorganizations { get; set; } - - [GaugeMetric] - [Description("Number of blocks awaiting for recovery of public keys from signatures.")] - public static long RecoveryQueueSize { get; set; } - - [GaugeMetric] - [Description("Number of blocks awaiting for processing.")] - public static long ProcessingQueueSize { get; set; } - - [CounterMetric] - [Description("Total number of sealed blocks")] - public static long BlocksSealed { get; set; } - - [CounterMetric] - [Description("Total number of failed block seals")] - public static long FailedBlockSeals { get; set; } - - [GaugeMetric] - [Description("Gas Used in processed blocks")] - public static long GasUsed { get; set; } - - [GaugeMetric] - [Description("Gas Limit for processed blocks")] - public static long GasLimit { get; set; } - - [GaugeMetric] - [Description("Total difficulty on the chain")] - public static UInt256 TotalDifficulty { get; set; } - - [GaugeMetric] - [Description("Difficulty of the last block")] - public static UInt256 LastDifficulty { get; set; } - - [GaugeMetric] - [Description("Indicator if blocks can be produced")] - public static long CanProduceBlocks; - - [GaugeMetric] - [Description("Number of ms to process the last processed block.")] - public static long LastBlockProcessingTimeInMs; - - //EIP-2159: Common Prometheus Metrics Names for Clients - [GaugeMetric] - [Description("The current height of the canonical chain.")] - [DataMember(Name = "ethereum_blockchain_height")] - public static long BlockchainHeight { get; set; } - - //EIP-2159: Common Prometheus Metrics Names for Clients - [GaugeMetric] - [Description("The estimated highest block available.")] - [DataMember(Name = "ethereum_best_known_block_number")] - public static long BestKnownBlockNumber { get; set; } - - [GaugeMetric] - [Description("Number of invalid blocks.")] - public static long BadBlocks; - - [GaugeMetric] - [Description("Number of invalid blocks with extra data set to 'Nethermind'.")] - public static long BadBlocksByNethermindNodes; - - [GaugeMetric] - [Description("State root calculation time")] - public static double StateMerkleizationTime { get; set; } - - [DetailedMetric] - [ExponentialPowerHistogramMetric(Start = 10, Factor = 1.2, Count = 30)] - [Description("Histogram of block MGas per second")] - public static IMetricObserver BlockMGasPerSec { get; set; } = new NoopMetricObserver(); - - [DetailedMetric] - [ExponentialPowerHistogramMetric(Start = 100, Factor = 1.25, Count = 50)] - [Description("Histogram of block prorcessing time")] - public static IMetricObserver BlockProcessingTimeMicros { get; set; } = new NoopMetricObserver(); - - } + [CounterMetric] + [Description("Total MGas processed")] + public static double Mgas { get; set; } + + [GaugeMetric] + [Description("MGas processed per second")] + public static double MgasPerSec { get; set; } + + [CounterMetric] + [Description("Total number of transactions processed")] + public static long Transactions { get; set; } + + [GaugeMetric] + [Description("Total number of blocks processed")] + public static long Blocks { get; set; } + + [CounterMetric] + [Description("Total number of chain reorganizations")] + public static long Reorganizations { get; set; } + + [GaugeMetric] + [Description("Number of blocks awaiting for recovery of public keys from signatures.")] + public static long RecoveryQueueSize { get; set; } + + [GaugeMetric] + [Description("Number of blocks awaiting for processing.")] + public static long ProcessingQueueSize { get; set; } + + [CounterMetric] + [Description("Total number of sealed blocks")] + public static long BlocksSealed { get; set; } + + [CounterMetric] + [Description("Total number of failed block seals")] + public static long FailedBlockSeals { get; set; } + + [GaugeMetric] + [Description("Gas Used in processed blocks")] + public static long GasUsed { get; set; } + + [GaugeMetric] + [Description("Gas Limit for processed blocks")] + public static long GasLimit { get; set; } + + [GaugeMetric] + [Description("Total difficulty on the chain")] + public static UInt256 TotalDifficulty { get; set; } + + [GaugeMetric] + [Description("Difficulty of the last block")] + public static UInt256 LastDifficulty { get; set; } + + [GaugeMetric] + [Description("Indicator if blocks can be produced")] + public static long CanProduceBlocks; + + [GaugeMetric] + [Description("Number of ms to process the last processed block.")] + public static long LastBlockProcessingTimeInMs; + + //EIP-2159: Common Prometheus Metrics Names for Clients + [GaugeMetric] + [Description("The current height of the canonical chain.")] + [DataMember(Name = "ethereum_blockchain_height")] + public static long BlockchainHeight { get; set; } + + //EIP-2159: Common Prometheus Metrics Names for Clients + [GaugeMetric] + [Description("The estimated highest block available.")] + [DataMember(Name = "ethereum_best_known_block_number")] + public static long BestKnownBlockNumber { get; set; } + + [GaugeMetric] + [Description("Number of invalid blocks.")] + public static long BadBlocks; + + [GaugeMetric] + [Description("Number of invalid blocks with extra data set to 'Nethermind'.")] + public static long BadBlocksByNethermindNodes; + + [GaugeMetric] + [Description("State root calculation time")] + public static double StateMerkleizationTime { get; set; } + + [DetailedMetric] + [ExponentialPowerHistogramMetric(Start = 10, Factor = 1.2, Count = 30)] + [Description("Histogram of block MGas per second")] + public static IMetricObserver BlockMGasPerSec { get; set; } = new NoopMetricObserver(); + + [DetailedMetric] + [ExponentialPowerHistogramMetric(Start = 100, Factor = 1.25, Count = 50)] + [Description("Histogram of block prorcessing time")] + public static IMetricObserver BlockProcessingTimeMicros { get; set; } = new NoopMetricObserver(); } diff --git a/src/Nethermind/Nethermind.Blockchain/Nethermind.Blockchain.csproj b/src/Nethermind/Nethermind.Blockchain/Nethermind.Blockchain.csproj index 4889b390e5e..55f075ded74 100644 --- a/src/Nethermind/Nethermind.Blockchain/Nethermind.Blockchain.csproj +++ b/src/Nethermind/Nethermind.Blockchain/Nethermind.Blockchain.csproj @@ -9,6 +9,7 @@ + diff --git a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs index 7d75114dc6a..76427295f53 100644 --- a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs +++ b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs @@ -122,7 +122,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f ITransactionComparerProvider transactionComparerProvider = new TransactionComparerProvider(specProvider, blockTree); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); TxPool.TxPool txPool = new(_ethereumEcdsa, new BlobTxStorage(), new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(SepoliaSpecProvider.Instance), blockTree, stateProvider, codeInfoRepository), diff --git a/src/Nethermind/Nethermind.Consensus.Test/CensorshipDetectorTests.cs b/src/Nethermind/Nethermind.Consensus.Test/CensorshipDetectorTests.cs index d2797b8a1d5..8c5650976ba 100644 --- a/src/Nethermind/Nethermind.Consensus.Test/CensorshipDetectorTests.cs +++ b/src/Nethermind/Nethermind.Consensus.Test/CensorshipDetectorTests.cs @@ -259,7 +259,7 @@ private TxPool.TxPool CreatePool(bool eip1559Enabled = true) return new( _ethereumEcdsa, new BlobTxStorage(), - new ChainHeadInfoProvider(_specProvider, _blockTree, _stateProvider, new CodeInfoRepository()), + new ChainHeadInfoProvider(_specProvider, _blockTree, _stateProvider, new EthereumCodeInfoRepository()), new TxPoolConfig(), new TxValidator(_specProvider.ChainId), _logManager, diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ProcessingStats.cs b/src/Nethermind/Nethermind.Consensus/Processing/ProcessingStats.cs index 9ef10276ead..04aac92a486 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/ProcessingStats.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/ProcessingStats.cs @@ -73,7 +73,7 @@ public void CaptureStartStats() _startSStoreOps = Evm.Metrics.ThreadLocalSStoreOpcode; _startCallOps = Evm.Metrics.ThreadLocalCalls; _startEmptyCalls = Evm.Metrics.ThreadLocalEmptyCalls; - _startCachedContractsUsed = Db.Metrics.ThreadLocalCodeDbCache; + _startCachedContractsUsed = Evm.Metrics.ThreadLocalCodeDbCache; _startContractsAnalyzed = Evm.Metrics.ThreadLocalContractsAnalysed; _startCreateOps = Evm.Metrics.ThreadLocalCreates; _startSelfDestructOps = Evm.Metrics.ThreadLocalSelfDestructs; @@ -106,7 +106,7 @@ public void UpdateStats(Block? block, BlockHeader? baseBlock, long blockProcessi blockData.CurrentSStoreOps = Evm.Metrics.ThreadLocalSStoreOpcode; blockData.CurrentCallOps = Evm.Metrics.ThreadLocalCalls; blockData.CurrentEmptyCalls = Evm.Metrics.ThreadLocalEmptyCalls; - blockData.CurrentCachedContractsUsed = Db.Metrics.ThreadLocalCodeDbCache; + blockData.CurrentCachedContractsUsed = Evm.Metrics.ThreadLocalCodeDbCache; blockData.CurrentContractsAnalyzed = Evm.Metrics.ThreadLocalContractsAnalysed; blockData.CurrentCreatesOps = Evm.Metrics.ThreadLocalCreates; blockData.CurrentSelfDestructOps = Evm.Metrics.ThreadLocalSelfDestructs; diff --git a/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs b/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs index d9fcb974266..86730bb5863 100644 --- a/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs +++ b/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs @@ -38,7 +38,7 @@ protected override void Load(ContainerBuilder builder) { IWorldState worldState = ctx.Resolve().GlobalWorldState; PreBlockCaches? preBlockCaches = (worldState as IPreBlockCaches)?.Caches; - return new CodeInfoRepository(preBlockCaches?.PrecompileCache); + return new EthereumCodeInfoRepository(preBlockCaches?.PrecompileCache); }) .AddSingleton() diff --git a/src/Nethermind/Nethermind.Db/Metrics.cs b/src/Nethermind/Nethermind.Db/Metrics.cs index 8a510db9880..b4889866ab9 100644 --- a/src/Nethermind/Nethermind.Db/Metrics.cs +++ b/src/Nethermind/Nethermind.Db/Metrics.cs @@ -16,14 +16,6 @@ namespace Nethermind.Db { public static class Metrics { - [CounterMetric] - [Description("Number of Code DB cache reads.")] - public static long CodeDbCache => _codeDbCache.GetTotalValue(); - private static readonly ZeroContentionCounter _codeDbCache = new(); - [Description("Number of Code DB cache reads on thread.")] - internal static long ThreadLocalCodeDbCache => _codeDbCache.ThreadLocalValue; - internal static void IncrementCodeDbCache() => _codeDbCache.Increment(); - [CounterMetric] [Description("Number of State Trie cache hits.")] public static long StateTreeCache => _stateTreeCacheHits.GetTotalValue(); diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs b/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs index 1798cdc1c44..8133fda6708 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs @@ -17,6 +17,7 @@ using Nethermind.Logging; using Nethermind.State; using Nethermind.Trie.Pruning; +using Nethermind.Blockchain; namespace Nethermind.Evm.Benchmark { @@ -44,7 +45,7 @@ public void GlobalSetup() _stateProvider = worldStateManager.GlobalWorldState; _stateProvider.CreateAccount(Address.Zero, 1000.Ether()); _stateProvider.Commit(_spec); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); _virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, LimboLogs.Instance); _virtualMachine.SetBlockExecutionContext(new BlockExecutionContext(_header, _spec)); _virtualMachine.SetTxExecutionContext(new TxExecutionContext(Address.Zero, codeInfoRepository, null, 0)); diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs b/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs index 69df78ea3d8..1eecba667b4 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs @@ -19,6 +19,7 @@ using Nethermind.Specs.Forks; using Nethermind.State; using Nethermind.Trie.Pruning; +using Nethermind.Blockchain; namespace Nethermind.Evm.Benchmark; @@ -76,7 +77,7 @@ public void GlobalSetup() _stateProvider.Commit(_spec); Console.WriteLine(MuirGlacier.Instance); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); _virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, new OneLoggerLogManager(NullLogger.Instance)); _virtualMachine.SetBlockExecutionContext(new BlockExecutionContext(_header, _spec)); _virtualMachine.SetTxExecutionContext(new TxExecutionContext(Address.Zero, codeInfoRepository, null, 0)); diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs b/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs index bddc49f0e2a..0b91cd4607f 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs @@ -19,6 +19,7 @@ using Nethermind.Specs.Forks; using Nethermind.State; using Nethermind.Trie.Pruning; +using Nethermind.Blockchain; namespace Nethermind.Evm.Benchmark { @@ -87,7 +88,7 @@ public void GlobalSetup() _stateProvider.Commit(_spec); Console.WriteLine(MuirGlacier.Instance); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); _virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, new OneLoggerLogManager(NullLogger.Instance)); _virtualMachine.SetBlockExecutionContext(new BlockExecutionContext(_header, _spec)); _virtualMachine.SetTxExecutionContext(new TxExecutionContext(Address.Zero, codeInfoRepository, null, 0)); diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Blake2FPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Blake2FPrecompile.cs new file mode 100644 index 00000000000..f685e05daf5 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Blake2FPrecompile.cs @@ -0,0 +1,61 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using Nethermind.Core; +using Nethermind.Core.Extensions; +using Nethermind.Core.Specs; +using Nethermind.Crypto.Blake2; +using Nethermind.Evm.Precompiles; + +namespace Nethermind.Evm.Precompiles; + +public class Blake2FPrecompile : IPrecompile +{ + private const int RequiredInputLength = 213; + + private readonly Blake2Compression _blake = new(); + + public static readonly Blake2FPrecompile Instance = new(); + + public static Address Address { get; } = Address.FromNumber(9); + + public long BaseGasCost(IReleaseSpec releaseSpec) => 0; + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + if (inputData.Length != RequiredInputLength) + { + return 0; + } + + byte finalByte = inputData.Span[212]; + if (finalByte != 0 && finalByte != 1) + { + return 0; + } + + uint rounds = inputData[..4].Span.ReadEthUInt32(); + + return rounds; + } + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + if (inputData.Length != RequiredInputLength) + { + return IPrecompile.Failure; + } + + byte finalByte = inputData.Span[212]; + if (finalByte != 0 && finalByte != 1) + { + return IPrecompile.Failure; + } + + byte[] result = new byte[64]; + _blake.Compress(inputData.Span, result); + + return (result, true); + } +} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/BlsConst.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/BlsConst.cs similarity index 98% rename from src/Nethermind/Nethermind.Evm/Precompiles/Bls/BlsConst.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Bls/BlsConst.cs index 595e6ebcddd..513bfbfe946 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/BlsConst.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/BlsConst.cs @@ -1,7 +1,6 @@ // SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only -using System; using System.Linq; namespace Nethermind.Evm.Precompiles.Bls; diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/BlsExtensions.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/BlsExtensions.cs similarity index 100% rename from src/Nethermind/Nethermind.Evm/Precompiles/Bls/BlsExtensions.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Bls/BlsExtensions.cs diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/Discount.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/Discount.cs new file mode 100644 index 00000000000..4db149d1c9d --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/Discount.cs @@ -0,0 +1,149 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +namespace Nethermind.Evm.Precompiles.Bls; + +/// +/// https://eips.ethereum.org/EIPS/eip-2537 +/// +internal static class Discount +{ + public static int ForG1(int k) => k >= 128 ? _maxDiscountG1 : _discountTable[k].g1; + public static int ForG2(int k) => k >= 128 ? _maxDiscountG2 : _discountTable[k].g2; + + private const int _maxDiscountG1 = 519; + private const int _maxDiscountG2 = 524; + + private static readonly (int g1, int g2)[] _discountTable = + { + (0, 0), // 0 + (1000, 1000), // 1 + (949, 1000), // 2 + (848, 923), // 3 + (797, 884), // 4 + (764, 855), // 5 + (750, 832), // 6 + (738, 812), // 7 + (728, 796), // 8 + (719, 782), // 9 + (712, 770), // 10 + (705, 759), // 11 + (698, 749), // 12 + (692, 740), // 13 + (687, 732), // 14 + (682, 724), // 15 + (677, 717), // 16 + (673, 711), // 17 + (669, 704), // 18 + (665, 699), // 19 + (661, 693), // 20 + (658, 688), // 21 + (654, 683), // 22 + (651, 679), // 23 + (648, 674), // 24 + (645, 670), // 25 + (642, 666), // 26 + (640, 663), // 27 + (637, 659), // 28 + (635, 655), // 29 + (632, 652), // 30 + (630, 649), // 31 + (627, 646), // 32 + (625, 643), // 33 + (623, 640), // 34 + (621, 637), // 35 + (619, 634), // 36 + (617, 632), // 37 + (615, 629), // 38 + (613, 627), // 39 + (611, 624), // 40 + (609, 622), // 41 + (608, 620), // 42 + (606, 618), // 43 + (604, 615), // 44 + (603, 613), // 45 + (601, 611), // 46 + (599, 609), // 47 + (598, 607), // 48 + (596, 606), // 49 + (595, 604), // 50 + (593, 602), // 51 + (592, 600), // 52 + (591, 598), // 53 + (589, 597), // 54 + (588, 595), // 55 + (586, 593), // 56 + (585, 592), // 57 + (584, 590), // 58 + (582, 589), // 59 + (581, 587), // 60 + (580, 586), // 61 + (579, 584), // 62 + (577, 583), // 63 + (576, 582), // 64 + (575, 580), // 65 + (574, 579), // 66 + (573, 578), // 67 + (572, 576), // 68 + (570, 575), // 69 + (569, 574), // 70 + (568, 573), // 71 + (567, 571), // 72 + (566, 570), // 73 + (565, 569), // 74 + (564, 568), // 75 + (563, 567), // 76 + (562, 566), // 77 + (561, 565), // 78 + (560, 563), // 79 + (559, 562), // 80 + (558, 561), // 81 + (557, 560), // 82 + (556, 559), // 83 + (555, 558), // 84 + (554, 557), // 85 + (553, 556), // 86 + (552, 555), // 87 + (551, 554), // 88 + (550, 553), // 89 + (549, 552), // 90 + (548, 552), // 91 + (547, 551), // 92 + (547, 550), // 93 + (546, 549), // 94 + (545, 548), // 95 + (544, 547), // 96 + (543, 546), // 97 + (542, 545), // 98 + (541, 545), // 99 + (540, 544), // 100 + (540, 543), // 101 + (539, 542), // 102 + (538, 541), // 103 + (537, 541), // 104 + (536, 540), // 105 + (536, 539), // 106 + (535, 538), // 107 + (534, 537), // 108 + (533, 537), // 109 + (532, 536), // 110 + (532, 535), // 111 + (531, 535), // 112 + (530, 534), // 113 + (529, 533), // 114 + (528, 532), // 115 + (528, 532), // 116 + (527, 531), // 117 + (526, 530), // 118 + (525, 530), // 119 + (525, 529), // 120 + (524, 528), // 121 + (523, 528), // 122 + (522, 527), // 123 + (522, 526), // 124 + (521, 526), // 125 + (520, 525), // 126 + (520, 524), // 127 + (519, 524) // 128 + }; +} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/G1AddPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1AddPrecompile.cs similarity index 98% rename from src/Nethermind/Nethermind.Evm/Precompiles/Bls/G1AddPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1AddPrecompile.cs index eddb4893252..ab333c1c59d 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/G1AddPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1AddPrecompile.cs @@ -5,7 +5,7 @@ using System.Runtime.CompilerServices; using Nethermind.Core; using Nethermind.Core.Specs; - +using Nethermind.Evm.Precompiles; using G1 = Nethermind.Crypto.Bls.P1; namespace Nethermind.Evm.Precompiles.Bls; diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/G1MSMPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1MSMPrecompile.cs similarity index 99% rename from src/Nethermind/Nethermind.Evm/Precompiles/Bls/G1MSMPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1MSMPrecompile.cs index 9e5e466a997..45c6de2dbd4 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/G1MSMPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1MSMPrecompile.cs @@ -9,6 +9,7 @@ using G1 = Nethermind.Crypto.Bls.P1; using System.Runtime.CompilerServices; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Precompiles.Bls; diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/G2AddPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2AddPrecompile.cs similarity index 98% rename from src/Nethermind/Nethermind.Evm/Precompiles/Bls/G2AddPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2AddPrecompile.cs index 6e9094f6084..55df3c38ed1 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/G2AddPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2AddPrecompile.cs @@ -5,7 +5,7 @@ using System.Runtime.CompilerServices; using Nethermind.Core; using Nethermind.Core.Specs; - +using Nethermind.Evm.Precompiles; using G2 = Nethermind.Crypto.Bls.P2; namespace Nethermind.Evm.Precompiles.Bls; diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/G2MSMPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2MSMPrecompile.cs similarity index 99% rename from src/Nethermind/Nethermind.Evm/Precompiles/Bls/G2MSMPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2MSMPrecompile.cs index 3ed9ccc8396..c4a4a430028 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/G2MSMPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2MSMPrecompile.cs @@ -9,6 +9,7 @@ using G2 = Nethermind.Crypto.Bls.P2; using System.Runtime.CompilerServices; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Precompiles.Bls; diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/MapFp2ToG2Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFp2ToG2Precompile.cs similarity index 97% rename from src/Nethermind/Nethermind.Evm/Precompiles/Bls/MapFp2ToG2Precompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFp2ToG2Precompile.cs index d86a2f50c24..1d796aa046e 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/MapFp2ToG2Precompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFp2ToG2Precompile.cs @@ -5,7 +5,7 @@ using System.Runtime.CompilerServices; using Nethermind.Core; using Nethermind.Core.Specs; - +using Nethermind.Evm.Precompiles; using G2 = Nethermind.Crypto.Bls.P2; namespace Nethermind.Evm.Precompiles.Bls; diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/MapFpToG1Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFpToG1Precompile.cs similarity index 97% rename from src/Nethermind/Nethermind.Evm/Precompiles/Bls/MapFpToG1Precompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFpToG1Precompile.cs index bd1c776f296..f6ee5d0b11e 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/MapFpToG1Precompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFpToG1Precompile.cs @@ -5,6 +5,7 @@ using System.Runtime.CompilerServices; using Nethermind.Core; using Nethermind.Core.Specs; +using Nethermind.Evm.Precompiles; using G1 = Nethermind.Crypto.Bls.P1; namespace Nethermind.Evm.Precompiles.Bls; diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/PairingCheckPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/PairingCheckPrecompile.cs similarity index 98% rename from src/Nethermind/Nethermind.Evm/Precompiles/Bls/PairingCheckPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Bls/PairingCheckPrecompile.cs index 66270d26468..abd781f8cbf 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/PairingCheckPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/PairingCheckPrecompile.cs @@ -6,7 +6,7 @@ using Nethermind.Core; using Nethermind.Core.Collections; using Nethermind.Core.Specs; - +using Nethermind.Evm.Precompiles; using G1 = Nethermind.Crypto.Bls.P1; using G2 = Nethermind.Crypto.Bls.P2; using GT = Nethermind.Crypto.Bls.PT; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/EcRecoverPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/EcRecoverPrecompile.cs new file mode 100644 index 00000000000..93dd962008c --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/EcRecoverPrecompile.cs @@ -0,0 +1,74 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Runtime.CompilerServices; +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Core.Extensions; +using Nethermind.Core.Specs; +using Nethermind.Crypto; +using Nethermind.Evm.Precompiles; + +namespace Nethermind.Evm.Precompiles; + +public class EcRecoverPrecompile : IPrecompile +{ + public static readonly EcRecoverPrecompile Instance = new(); + + private EcRecoverPrecompile() + { + } + + public static Address Address { get; } = Address.FromNumber(1); + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; + + public long BaseGasCost(IReleaseSpec releaseSpec) => 3000L; + + private readonly byte[] _zero31 = new byte[31]; + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + Metrics.EcRecoverPrecompile++; + return inputData.Length >= 128 ? RunInternal(inputData.Span) : RunInternal(inputData); + } + + private (byte[], bool) RunInternal(ReadOnlyMemory inputData) + { + Span inputDataSpan = stackalloc byte[128]; + inputData.Span[..Math.Min(128, inputData.Length)] + .CopyTo(inputDataSpan[..Math.Min(128, inputData.Length)]); + + return RunInternal(inputDataSpan); + } + + private (byte[], bool) RunInternal(ReadOnlySpan inputDataSpan) + { + ReadOnlySpan vBytes = inputDataSpan.Slice(32, 32); + + // TEST: CALLCODEEcrecoverV_prefixedf0_d0g0v0 + // TEST: CALLCODEEcrecoverV_prefixedf0_d1g0v0 + if (!Bytes.AreEqual(_zero31, vBytes[..31])) + { + return ([], true); + } + + byte v = vBytes[31]; + if (v != 27 && v != 28) + { + return ([], true); + } + + Span publicKey = stackalloc byte[65]; + if (!EthereumEcdsa.RecoverAddressRaw(inputDataSpan.Slice(64, 64), Signature.GetRecoveryId(v), + inputDataSpan[..32], publicKey)) + { + return ([], true); + } + + byte[] result = ValueKeccak.Compute(publicKey.Slice(1, 64)).ToByteArray(); + result.AsSpan(0, 12).Clear(); + return (result, true); + } +} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs new file mode 100644 index 00000000000..768fdcb27d5 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs @@ -0,0 +1,15 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; + +namespace Nethermind.Evm.Precompiles; + +public static class Extensions +{ + public static void PrepareEthInput(this ReadOnlyMemory inputData, Span inputDataSpan) + { + inputData.Span[..Math.Min(inputDataSpan.Length, inputData.Length)] + .CopyTo(inputDataSpan[..Math.Min(inputDataSpan.Length, inputData.Length)]); + } +} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/IdentityPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/IdentityPrecompile.cs new file mode 100644 index 00000000000..1a81d115369 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/IdentityPrecompile.cs @@ -0,0 +1,31 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using Nethermind.Core; +using Nethermind.Core.Specs; +using Nethermind.Evm; +using Nethermind.Evm.Precompiles; + +namespace Nethermind.Evm.Precompiles; + +public class IdentityPrecompile : IPrecompile +{ + public static readonly IdentityPrecompile Instance = new(); + + private IdentityPrecompile() + { + } + + public static Address Address { get; } = Address.FromNumber(4); + + public long BaseGasCost(IReleaseSpec releaseSpec) => 15L; + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => + 3L * EvmInstructions.Div32Ceiling((ulong)inputData.Length); + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + return (inputData.ToArray(), true); + } +} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Metrics.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Metrics.cs new file mode 100644 index 00000000000..df9e22c613f --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Metrics.cs @@ -0,0 +1,82 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System.ComponentModel; +using Nethermind.Core.Attributes; + +namespace Nethermind.Evm.Precompiles; + +public class Metrics +{ + [CounterMetric] + [Description("Number of BN254_MUL precompile calls.")] + public static long Bn254MulPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BN254_ADD precompile calls.")] + public static long Bn254AddPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BN254_PAIRING precompile calls.")] + public static long Bn254PairingPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BLS12_G1ADD precompile calls.")] + public static long BlsG1AddPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BLS12_G1MUL precompile calls.")] + public static long BlsG1MulPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BLS12_G1MSM precompile calls.")] + public static long BlsG1MSMPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BLS12_G2ADD precompile calls.")] + public static long BlsG2AddPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BLS12_G2MUL precompile calls.")] + public static long BlsG2MulPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BLS12_G2MSM precompile calls.")] + public static long BlsG2MSMPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BLS12_PAIRING_CHECK precompile calls.")] + public static long BlsPairingCheckPrecompile { get; set; } + + [CounterMetric] + [Description("Number of BLS12_MAP_FP_TO_G1 precompile calls.")] + public static long BlsMapFpToG1Precompile { get; set; } + + [CounterMetric] + [Description("Number of BLS12_MAP_FP2_TO_G2 precompile calls.")] + public static long BlsMapFp2ToG2Precompile { get; set; } + + [CounterMetric] + [Description("Number of EC_RECOVERY precompile calls.")] + public static long EcRecoverPrecompile { get; set; } + + [CounterMetric] + [Description("Number of MODEXP precompile calls.")] + public static long ModExpPrecompile { get; set; } + + [CounterMetric] + [Description("Number of RIPEMD160 precompile calls.")] + public static long Ripemd160Precompile { get; set; } + + [CounterMetric] + [Description("Number of SHA256 precompile calls.")] + public static long Sha256Precompile { get; set; } + + [CounterMetric] + [Description("Number of Secp256r1 precompile calls.")] + public static long Secp256r1Precompile { get; set; } + + [CounterMetric] + [Description("Number of Point Evaluation precompile calls.")] + public static long PointEvaluationPrecompile { get; set; } +} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/ModExpPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs similarity index 99% rename from src/Nethermind/Nethermind.Evm/Precompiles/ModExpPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs index ffda26020a5..0083a354872 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/ModExpPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs @@ -3,10 +3,11 @@ using System; using System.Numerics; -using System.Runtime.InteropServices; using Nethermind.Core; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; +using Nethermind.Evm; +using Nethermind.Evm.Precompiles; using Nethermind.GmpBindings; using Nethermind.Int256; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs new file mode 100644 index 00000000000..982ff2463b0 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs @@ -0,0 +1,132 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Numerics; +using Nethermind.Core; +using Nethermind.Core.Extensions; +using Nethermind.Core.Specs; +using Nethermind.Evm.Precompiles; +using Nethermind.Int256; + +namespace Nethermind.Evm.Precompiles; + +/// +/// https://github.com/ethereum/EIPs/blob/vbuterin-patch-2/EIPS/bigint_modexp.md +/// +[Obsolete("Pre-eip2565 implementation")] +public class ModExpPrecompilePreEip2565 : IPrecompile +{ + public static ModExpPrecompilePreEip2565 Instance = new(); + private static readonly UInt256 Eight = 8; + + private ModExpPrecompilePreEip2565() + { + } + + public static Address Address { get; } = Address.FromNumber(5); + + public long BaseGasCost(IReleaseSpec releaseSpec) => 0L; + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + try + { + return inputData.Length >= 96 + ? DataGasCostInternal(inputData.Span.Slice(0, 96), inputData, releaseSpec) + : DataGasCostInternal(inputData, releaseSpec); + } + catch (OverflowException) + { + return long.MaxValue; + } + } + + private static long DataGasCostInternal(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + Span extendedInput = stackalloc byte[96]; + inputData[..Math.Min(96, inputData.Length)].Span + .CopyTo(extendedInput[..Math.Min(96, inputData.Length)]); + + return DataGasCostInternal(extendedInput, inputData, releaseSpec); + } + + private static long DataGasCostInternal(ReadOnlySpan extendedInput, ReadOnlyMemory inputData, + IReleaseSpec releaseSpec) + { + UInt256 baseLength = new(extendedInput[..32], true); + UInt256 expLength = new(extendedInput.Slice(32, 32), true); + UInt256 modulusLength = new(extendedInput.Slice(64, 32), true); + + UInt256 complexity = MultComplexity(UInt256.Max(baseLength, modulusLength)); + + byte[] expSignificantBytes = + inputData.Span.SliceWithZeroPaddingEmptyOnError(96 + (int)baseLength, (int)UInt256.Min(expLength, 32)); + + UInt256 lengthOver32 = expLength <= 32 ? 0 : expLength - 32; + UInt256 adjusted = AdjustedExponentLength(lengthOver32, expSignificantBytes); + UInt256 gas = complexity * UInt256.Max(adjusted, UInt256.One) / 20; + return gas > long.MaxValue ? long.MaxValue : (long)gas; + } + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + Metrics.ModExpPrecompile++; + + int baseLength = (int)inputData.Span.SliceWithZeroPaddingEmptyOnError(0, 32).ToUnsignedBigInteger(); + BigInteger expLengthBig = inputData.Span.SliceWithZeroPaddingEmptyOnError(32, 32).ToUnsignedBigInteger(); + int expLength = expLengthBig > int.MaxValue ? int.MaxValue : (int)expLengthBig; + int modulusLength = (int)inputData.Span.SliceWithZeroPaddingEmptyOnError(64, 32).ToUnsignedBigInteger(); + + BigInteger modulusInt = inputData.Span + .SliceWithZeroPaddingEmptyOnError(96 + baseLength + expLength, modulusLength).ToUnsignedBigInteger(); + + if (modulusInt.IsZero) + { + return (new byte[modulusLength], true); + } + + BigInteger baseInt = inputData.Span.SliceWithZeroPaddingEmptyOnError(96, baseLength).ToUnsignedBigInteger(); + BigInteger expInt = inputData.Span.SliceWithZeroPaddingEmptyOnError(96 + baseLength, expLength) + .ToUnsignedBigInteger(); + return (BigInteger.ModPow(baseInt, expInt, modulusInt).ToBigEndianByteArray(modulusLength), true); + } + + private static UInt256 MultComplexity(in UInt256 adjustedExponentLength) + { + if (adjustedExponentLength <= 64) + { + return adjustedExponentLength * adjustedExponentLength; + } + + if (adjustedExponentLength <= 1024) + { + return adjustedExponentLength * adjustedExponentLength / 4 + 96 * adjustedExponentLength - 3072; + } + + return adjustedExponentLength * adjustedExponentLength / 16 + 480 * adjustedExponentLength - 199680; + } + + private static UInt256 AdjustedExponentLength(in UInt256 lengthOver32, byte[] exponent) + { + bool overflow = false; + bool underflow = false; + UInt256 result; + + int leadingZeros = exponent.AsSpan().LeadingZerosCount(); + if (leadingZeros == exponent.Length) + { + overflow |= UInt256.MultiplyOverflow(lengthOver32, Eight, out result); + return overflow ? UInt256.MaxValue : result; + } + + overflow |= UInt256.AddOverflow(lengthOver32, (UInt256)exponent.Length, out result); + underflow |= UInt256.SubtractUnderflow(result, (UInt256)leadingZeros, out result); + underflow |= UInt256.SubtractUnderflow(result, UInt256.One, out result); + overflow |= UInt256.MultiplyOverflow(result, Eight, out result); + overflow |= UInt256.AddOverflow(result, (UInt256)exponent[leadingZeros].GetHighestSetBitIndex(), out result); + underflow |= UInt256.SubtractUnderflow(result, UInt256.One, out result); + + return overflow ? UInt256.MaxValue : underflow ? UInt256.MinValue : result; + } +} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Nethermind.Evm.Precompiles.csproj b/src/Nethermind/Nethermind.Evm.Precompiles/Nethermind.Evm.Precompiles.csproj new file mode 100644 index 00000000000..55e5375e5e4 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Nethermind.Evm.Precompiles.csproj @@ -0,0 +1,20 @@ + + + true + enable + + + + + + + + + + + + + + + + diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/PointEvaluationPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/PointEvaluationPrecompile.cs similarity index 98% rename from src/Nethermind/Nethermind.Evm/Precompiles/PointEvaluationPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/PointEvaluationPrecompile.cs index a392885d1ca..e9844eb8d5e 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/PointEvaluationPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/PointEvaluationPrecompile.cs @@ -8,6 +8,7 @@ using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Crypto; +using Nethermind.Evm.Precompiles; using Nethermind.Int256; namespace Nethermind.Evm.Precompiles; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Ripemd160Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Ripemd160Precompile.cs new file mode 100644 index 00000000000..20a7b0ed682 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Ripemd160Precompile.cs @@ -0,0 +1,41 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using Nethermind.Core; +using Nethermind.Core.Extensions; +using Nethermind.Core.Specs; +using Nethermind.Crypto; +using Nethermind.Evm; +using Nethermind.Evm.Precompiles; + +namespace Nethermind.Evm.Precompiles; + +public class Ripemd160Precompile : IPrecompile +{ + public static readonly Ripemd160Precompile Instance = new(); + + // missing in .NET Core + // private static RIPEMD160 _ripemd; + + private Ripemd160Precompile() + { + // missing in .NET Core + // _ripemd = RIPEMD160.Create(); + // _ripemd.Initialize(); + } + + public static Address Address { get; } = Address.FromNumber(3); + + public long BaseGasCost(IReleaseSpec releaseSpec) => 600L; + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => + 120L * EvmInstructions.Div32Ceiling((ulong)inputData.Length); + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + Metrics.Ripemd160Precompile++; + + return (Ripemd.Compute(inputData.ToArray()).PadLeft(32), true); + } +} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Secp256r1Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Secp256r1Precompile.cs similarity index 96% rename from src/Nethermind/Nethermind.Evm/Precompiles/Secp256r1Precompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Secp256r1Precompile.cs index 069161091f6..045bbc813f2 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Secp256r1Precompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Secp256r1Precompile.cs @@ -6,6 +6,7 @@ using Nethermind.Core.Extensions; using Nethermind.Core.Specs; using Nethermind.Crypto; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Precompiles; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Sha256Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Sha256Precompile.cs new file mode 100644 index 00000000000..019bf6e26c8 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Sha256Precompile.cs @@ -0,0 +1,37 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Security.Cryptography; +using Nethermind.Core; +using Nethermind.Core.Specs; +using Nethermind.Evm; +using Nethermind.Evm.Precompiles; + +namespace Nethermind.Evm.Precompiles; + +public class Sha256Precompile : IPrecompile +{ + public static readonly Sha256Precompile Instance = new(); + + private Sha256Precompile() + { + } + + public static Address Address { get; } = Address.FromNumber(2); + + public long BaseGasCost(IReleaseSpec releaseSpec) => 60L; + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => + 12L * EvmInstructions.Div32Ceiling((ulong)inputData.Length); + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + Metrics.Sha256Precompile++; + + byte[] output = new byte[SHA256.HashSizeInBytes]; + bool success = SHA256.TryHashData(inputData.Span, output, out int bytesWritten); + + return (output, success && bytesWritten == SHA256.HashSizeInBytes); + } +} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Snarks/Bn254AddPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs similarity index 97% rename from src/Nethermind/Nethermind.Evm/Precompiles/Snarks/Bn254AddPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs index 9c8e171836c..ea6fd404694 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Snarks/Bn254AddPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs @@ -5,6 +5,7 @@ using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Crypto; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Precompiles.Snarks; diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Snarks/Bn254MulPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs similarity index 97% rename from src/Nethermind/Nethermind.Evm/Precompiles/Snarks/Bn254MulPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs index 3a4bf261c95..92ba6ba5ed5 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Snarks/Bn254MulPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs @@ -5,6 +5,7 @@ using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Crypto; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Precompiles.Snarks; diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Snarks/Bn254PairingPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs similarity index 98% rename from src/Nethermind/Nethermind.Evm/Precompiles/Snarks/Bn254PairingPrecompile.cs rename to src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs index 22847a90c7e..541957ad683 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Snarks/Bn254PairingPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs @@ -6,6 +6,7 @@ using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Crypto; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Precompiles.Snarks; diff --git a/src/Nethermind/Nethermind.Evm.Test/BlsG1AddPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BlsG1AddPrecompileTests.cs index 24f70ffb0dd..7d79873921d 100644 --- a/src/Nethermind/Nethermind.Evm.Test/BlsG1AddPrecompileTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/BlsG1AddPrecompileTests.cs @@ -4,9 +4,9 @@ using System; using System.Collections.Generic; using FluentAssertions; +using Nethermind.Evm.Precompiles.Bls; using Nethermind.Core.Extensions; using Nethermind.Evm.Precompiles; -using Nethermind.Evm.Precompiles.Bls; using Nethermind.Specs.Forks; using NUnit.Framework; diff --git a/src/Nethermind/Nethermind.Evm.Test/BlsG2AddPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BlsG2AddPrecompileTests.cs index aa3d89c0fd3..560e4845af1 100644 --- a/src/Nethermind/Nethermind.Evm.Test/BlsG2AddPrecompileTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/BlsG2AddPrecompileTests.cs @@ -4,9 +4,9 @@ using System; using System.Collections.Generic; using FluentAssertions; +using Nethermind.Evm.Precompiles.Bls; using Nethermind.Core.Extensions; using Nethermind.Evm.Precompiles; -using Nethermind.Evm.Precompiles.Bls; using Nethermind.Specs.Forks; using NUnit.Framework; diff --git a/src/Nethermind/Nethermind.Evm.Test/CodeInfoRepositoryTests.cs b/src/Nethermind/Nethermind.Evm.Test/CodeInfoRepositoryTests.cs index 079dad1663e..efb46f409fa 100644 --- a/src/Nethermind/Nethermind.Evm.Test/CodeInfoRepositoryTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/CodeInfoRepositoryTests.cs @@ -3,23 +3,18 @@ using Nethermind.Core.Crypto; using Nethermind.Core; -using Nethermind.Crypto; -using Nethermind.Logging; -using Nethermind.Serialization.Rlp; using NSubstitute; using NUnit.Framework; -using System; using System.Collections.Generic; using Nethermind.Core.Test.Builders; using FluentAssertions; +using Nethermind.Blockchain; using Nethermind.Evm.State; using Nethermind.Core.Specs; using Nethermind.Evm.CodeAnalysis; using Nethermind.Core.Extensions; using Nethermind.Core.Test; -using Nethermind.Db; using Nethermind.State; -using Nethermind.Trie.Pruning; namespace Nethermind.Evm.Test; @@ -69,7 +64,7 @@ public void TryGetDelegation_CodeIsNotDelegation_ReturnsFalse(byte[] code) IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + EthereumCodeInfoRepository sut = new(); sut.TryGetDelegation(stateProvider, TestItem.AddressA, Substitute.For(), out _).Should().Be(false); } @@ -97,7 +92,7 @@ public void TryGetDelegation_CodeTryGetDelegation_ReturnsTrue(byte[] code) IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + EthereumCodeInfoRepository sut = new(); sut.TryGetDelegation(stateProvider, TestItem.AddressA, Substitute.For(), out _).Should().Be(true); } @@ -109,7 +104,7 @@ public void TryGetDelegation_CodeTryGetDelegation_CorrectDelegationAddressIsSet( IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + EthereumCodeInfoRepository sut = new(); Address result; sut.TryGetDelegation(stateProvider, TestItem.AddressA, Substitute.For(), out result); @@ -129,7 +124,7 @@ public void GetExecutableCodeHash_CodeTryGetDelegation_ReturnsHashOfDelegated(by stateProvider.CreateAccount(delegationAddress, 0); stateProvider.InsertCode(delegationAddress, delegationCode, Substitute.For()); - CodeInfoRepository sut = new(); + EthereumCodeInfoRepository sut = new(); sut.GetExecutableCodeHash(stateProvider, TestItem.AddressA, Substitute.For()).Should().Be(Keccak.Compute(code).ValueHash256); } @@ -142,7 +137,7 @@ public void GetExecutableCodeHash_CodeIsNotDelegation_ReturnsCodeHashOfAddress(b stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + EthereumCodeInfoRepository sut = new(); sut.GetExecutableCodeHash(stateProvider, TestItem.AddressA, Substitute.For()).Should().Be(Keccak.Compute(code).ValueHash256); } @@ -158,7 +153,7 @@ public void GetCachedCodeInfo_CodeTryGetDelegation_ReturnsCodeOfDelegation(byte[ stateProvider.CreateAccount(delegationAddress, 0); byte[] delegationCode = new byte[32]; stateProvider.InsertCode(delegationAddress, delegationCode, Substitute.For()); - CodeInfoRepository sut = new(); + EthereumCodeInfoRepository sut = new(); ICodeInfo result = sut.GetCachedCodeInfo(stateProvider, TestItem.AddressA, Substitute.For()); result.CodeSpan.ToArray().Should().BeEquivalentTo(delegationCode); @@ -172,7 +167,7 @@ public void GetCachedCodeInfo_CodeIsNotDelegation_ReturnsCodeOfAddress(byte[] co stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + EthereumCodeInfoRepository sut = new(); sut.GetCachedCodeInfo(stateProvider, TestItem.AddressA, Substitute.For()).Should().BeEquivalentTo(new CodeInfo(code)); } diff --git a/src/Nethermind/Nethermind.Evm.Test/Eip2537Tests.cs b/src/Nethermind/Nethermind.Evm.Test/Eip2537Tests.cs index 90936510c1a..9a079cd770c 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Eip2537Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Eip2537Tests.cs @@ -2,8 +2,8 @@ // SPDX-License-Identifier: LGPL-3.0-only using NUnit.Framework; -using Nethermind.Evm.Precompiles; using Nethermind.Evm.Precompiles.Bls; +using Nethermind.Evm.Precompiles; using Nethermind.Specs; namespace Nethermind.Evm.Test; diff --git a/src/Nethermind/Nethermind.Evm.Test/Eip7823Tests.cs b/src/Nethermind/Nethermind.Evm.Test/Eip7823Tests.cs index 9da085fea3c..a7331ba8dd8 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Eip7823Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Eip7823Tests.cs @@ -6,9 +6,9 @@ using System.Collections.Generic; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; +using Nethermind.Evm.Precompiles; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; -using Nethermind.Evm.Precompiles; using Nethermind.Int256; using Nethermind.Specs.Forks; using NUnit.Framework; diff --git a/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs b/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs index 443ec8916b4..5039a34eb8c 100644 --- a/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs @@ -9,7 +9,6 @@ using Nethermind.Core.Specs; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; using Nethermind.Evm.Tracing; using Nethermind.Evm.TransactionProcessing; using Nethermind.Int256; @@ -17,8 +16,8 @@ using Nethermind.Specs; using Nethermind.Specs.Forks; using Nethermind.Evm.State; -using Nethermind.Trie.Pruning; using FluentAssertions; +using Nethermind.Blockchain; using Nethermind.Core.Test; using Nethermind.State; using NUnit.Framework; @@ -152,7 +151,7 @@ private static string Run(byte[] input) IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; ISpecProvider specProvider = new TestSpecProvider(London.Instance); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); VirtualMachine virtualMachine = new( new TestBlockhashProvider(specProvider), specProvider, diff --git a/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs b/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs index 0e9431b1430..ac19bb707e0 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs @@ -3,6 +3,7 @@ using System; using FluentAssertions; +using Nethermind.Blockchain; using Nethermind.Blockchain.Tracing; using Nethermind.Config; using Nethermind.Core; @@ -392,7 +393,7 @@ public TestEnvironment() _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); diff --git a/src/Nethermind/Nethermind.Evm.Test/Tracing/ParityLikeTxTracerTests.cs b/src/Nethermind/Nethermind.Evm.Test/Tracing/ParityLikeTxTracerTests.cs index 89f6468f221..81f2fa555ad 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Tracing/ParityLikeTxTracerTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Tracing/ParityLikeTxTracerTests.cs @@ -11,7 +11,6 @@ using Nethermind.Int256; using Nethermind.Evm.Precompiles; using Nethermind.Blockchain.Tracing.ParityStyle; -using Nethermind.Evm.TransactionProcessing; using Nethermind.Evm.State; using NUnit.Framework; diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs index 74714732b2f..d035564f287 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs @@ -15,6 +15,7 @@ using Nethermind.Evm.State; using NUnit.Framework; using System.Collections.Generic; +using Nethermind.Blockchain; using Nethermind.Core.Test; using Nethermind.State; @@ -34,7 +35,7 @@ public void Setup() _specProvider = new TestSpecProvider(Cancun.Instance); IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); _stateProvider = worldStateManager.GlobalWorldState; - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7623Tests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7623Tests.cs index ec1d4dedc0f..a68e8dacba3 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7623Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7623Tests.cs @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using Nethermind.Blockchain; using Nethermind.Core; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; @@ -32,7 +33,7 @@ public void Setup() _specProvider = new TestSpecProvider(Prague.Instance); IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); _stateProvider = worldStateManager.GlobalWorldState; - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs index 253e14ce64c..38e5ebb8a54 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs @@ -4,6 +4,7 @@ using System; using System.Threading; using FluentAssertions; +using Nethermind.Blockchain; using Nethermind.Blockchain.Tracing; using Nethermind.Core; using Nethermind.Core.Extensions; @@ -45,7 +46,7 @@ public void Setup() _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); diff --git a/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs b/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs index 45f985e1043..1232894276d 100644 --- a/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs +++ b/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs @@ -20,7 +20,6 @@ using Nethermind.Logging; using Nethermind.Evm.State; using Nethermind.State; -using Nethermind.Trie.Pruning; using NUnit.Framework; namespace Nethermind.Evm.Test; @@ -70,7 +69,7 @@ public virtual void Setup() TestState = worldStateManager.GlobalWorldState; _ethereumEcdsa = new EthereumEcdsa(SpecProvider.ChainId); IBlockhashProvider blockhashProvider = new TestBlockhashProvider(SpecProvider); - CodeInfoRepository = new CodeInfoRepository(); + CodeInfoRepository = new EthereumCodeInfoRepository(); Machine = new VirtualMachine(blockhashProvider, SpecProvider, logManager); _processor = new TransactionProcessor(SpecProvider, TestState, Machine, CodeInfoRepository, logManager); } diff --git a/src/Nethermind/Nethermind.State/CodeInfoRepository.cs b/src/Nethermind/Nethermind.Evm/CodeInfoRepository.cs similarity index 65% rename from src/Nethermind/Nethermind.State/CodeInfoRepository.cs rename to src/Nethermind/Nethermind.Evm/CodeInfoRepository.cs index 23f5c998d42..c23fe3aad4e 100644 --- a/src/Nethermind/Nethermind.State/CodeInfoRepository.cs +++ b/src/Nethermind/Nethermind.Evm/CodeInfoRepository.cs @@ -2,9 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using System; -using System.Collections.Concurrent; using System.Collections.Frozen; -using System.Collections.Generic; using System.Data; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; @@ -12,63 +10,30 @@ using Nethermind.Core.Caching; using Nethermind.Core.Crypto; using Nethermind.Core.Specs; -using Nethermind.Evm; using Nethermind.Evm.CodeAnalysis; using Nethermind.Evm.EvmObjectFormat; using Nethermind.Evm.Precompiles; -using Nethermind.Evm.Precompiles.Bls; -using Nethermind.Evm.Precompiles.Snarks; using Nethermind.Evm.State; -namespace Nethermind.State; +namespace Nethermind.Evm; public class CodeInfoRepository : ICodeInfoRepository { - private static readonly FrozenDictionary _precompiles = InitializePrecompiledContracts(); private static readonly CodeLruCache _codeCache = new(); private readonly FrozenDictionary _localPrecompiles; - private static FrozenDictionary InitializePrecompiledContracts() + protected CodeInfoRepository(FrozenDictionary precompiles) { - return new Dictionary - { - [EcRecoverPrecompile.Address] = new PrecompileInfo(EcRecoverPrecompile.Instance), - [Sha256Precompile.Address] = new PrecompileInfo(Sha256Precompile.Instance), - [Ripemd160Precompile.Address] = new PrecompileInfo(Ripemd160Precompile.Instance), - [IdentityPrecompile.Address] = new PrecompileInfo(IdentityPrecompile.Instance), - - [Bn254AddPrecompile.Address] = new PrecompileInfo(Bn254AddPrecompile.Instance), - [Bn254MulPrecompile.Address] = new PrecompileInfo(Bn254MulPrecompile.Instance), - [Bn254PairingPrecompile.Address] = new PrecompileInfo(Bn254PairingPrecompile.Instance), - [ModExpPrecompile.Address] = new PrecompileInfo(ModExpPrecompile.Instance), - - [Blake2FPrecompile.Address] = new PrecompileInfo(Blake2FPrecompile.Instance), - - [G1AddPrecompile.Address] = new PrecompileInfo(G1AddPrecompile.Instance), - [G1MSMPrecompile.Address] = new PrecompileInfo(G1MSMPrecompile.Instance), - [G2AddPrecompile.Address] = new PrecompileInfo(G2AddPrecompile.Instance), - [G2MSMPrecompile.Address] = new PrecompileInfo(G2MSMPrecompile.Instance), - [PairingCheckPrecompile.Address] = new PrecompileInfo(PairingCheckPrecompile.Instance), - [MapFpToG1Precompile.Address] = new PrecompileInfo(MapFpToG1Precompile.Instance), - [MapFp2ToG2Precompile.Address] = new PrecompileInfo(MapFp2ToG2Precompile.Instance), - - [PointEvaluationPrecompile.Address] = new PrecompileInfo(PointEvaluationPrecompile.Instance), - - [Secp256r1Precompile.Address] = new PrecompileInfo(Secp256r1Precompile.Instance), - }.ToFrozenDictionary(); + _localPrecompiles = precompiles; } - public CodeInfoRepository(ConcurrentDictionary? precompileCache = null) - { - _localPrecompiles = precompileCache is null - ? _precompiles - : _precompiles.ToFrozenDictionary(kvp => kvp.Key, kvp => CreateCachedPrecompile(kvp, precompileCache)); - } + public bool IsPrecompile(Address address, IReleaseSpec spec) => + address.IsPrecompile(spec) && _localPrecompiles.ContainsKey(address); public ICodeInfo GetCachedCodeInfo(IWorldState worldState, Address codeSource, bool followDelegation, IReleaseSpec vmSpec, out Address? delegationAddress) { delegationAddress = null; - if (codeSource.IsPrecompile(vmSpec)) + if (IsPrecompile(codeSource, vmSpec)) { return _localPrecompiles[codeSource]; } @@ -119,7 +84,7 @@ private static ICodeInfo InternalGetCachedCode(IReadOnlyStateProvider worldState } else { - Db.Metrics.IncrementCodeDbCache(); + Metrics.IncrementCodeDbCache(); } return cachedCodeInfo; @@ -197,43 +162,12 @@ private static bool TryGetDelegatedAddress(ReadOnlySpan code, [NotNullWhen return false; } - private static PrecompileInfo CreateCachedPrecompile( - in KeyValuePair originalPrecompile, - ConcurrentDictionary cache) => - new PrecompileInfo(new CachedPrecompile(originalPrecompile.Key.Value, originalPrecompile.Value.Precompile!, cache)); - public bool TryGetDelegation(IReadOnlyStateProvider worldState, Address address, IReleaseSpec spec, [NotNullWhen(true)] out Address? delegatedAddress) => TryGetDelegatedAddress(InternalGetCachedCode(worldState, address, spec).CodeSpan, out delegatedAddress); public bool TryGetDelegation(IReadOnlyStateProvider worldState, in ValueHash256 codeHash, IReleaseSpec spec, [NotNullWhen(true)] out Address? delegatedAddress) => TryGetDelegatedAddress(InternalGetCachedCode(worldState, in codeHash, spec).CodeSpan, out delegatedAddress); - private class CachedPrecompile( - Address address, - IPrecompile precompile, - ConcurrentDictionary cache) : IPrecompile - { - public static Address Address => Address.Zero; - - public long BaseGasCost(IReleaseSpec releaseSpec) => precompile.BaseGasCost(releaseSpec); - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => precompile.DataGasCost(inputData, releaseSpec); - - public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - PreBlockCaches.PrecompileCacheKey key = new(address, inputData); - if (!cache.TryGetValue(key, out (byte[], bool) result)) - { - result = precompile.Run(inputData, releaseSpec); - // we need to rebuild the key with data copy as the data can be changed by VM processing - key = new PreBlockCaches.PrecompileCacheKey(address, inputData.ToArray()); - cache.TryAdd(key, result); - } - - return result; - } - } - private sealed class CodeLruCache { private const int CacheCount = 16; diff --git a/src/Nethermind/Nethermind.Evm/ICodeInfoRepository.cs b/src/Nethermind/Nethermind.Evm/ICodeInfoRepository.cs index 244b27961fd..0156a2ef723 100644 --- a/src/Nethermind/Nethermind.Evm/ICodeInfoRepository.cs +++ b/src/Nethermind/Nethermind.Evm/ICodeInfoRepository.cs @@ -13,6 +13,7 @@ namespace Nethermind.Evm; public interface ICodeInfoRepository { + bool IsPrecompile(Address address, IReleaseSpec spec); ICodeInfo GetCachedCodeInfo(IWorldState worldState, Address codeSource, bool followDelegation, IReleaseSpec vmSpec, out Address? delegationAddress); ValueHash256 GetExecutableCodeHash(IWorldState worldState, Address address, IReleaseSpec spec); void InsertCode(IWorldState state, ReadOnlyMemory code, Address codeOwner, IReleaseSpec spec); diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs index d59100ac94a..fb0b65ec7b7 100644 --- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs +++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs @@ -6,8 +6,8 @@ using System.Runtime.CompilerServices; using Nethermind.Core; using Nethermind.Core.Specs; -using Nethermind.Evm.Precompiles; +[assembly: InternalsVisibleTo("Nethermind.Evm.Precompiles")] namespace Nethermind.Evm; using unsafe OpCode = delegate*; using Int256; @@ -366,7 +366,7 @@ private static bool ChargeAccountAccessGas(ref long gasAvailable, VirtualMachine } // If the account is cold (and not a precompile), charge the cold access cost. - if (!address.IsPrecompile(spec) && vmState.AccessTracker.WarmUp(address)) + if (!vm.CodeInfoRepository.IsPrecompile(address, spec) && vmState.AccessTracker.WarmUp(address)) { result = UpdateGas(GasCostOf.ColdAccountAccess, ref gasAvailable); } diff --git a/src/Nethermind/Nethermind.Evm/Metrics.cs b/src/Nethermind/Nethermind.Evm/Metrics.cs index 1295d482470..328cf7aca88 100644 --- a/src/Nethermind/Nethermind.Evm/Metrics.cs +++ b/src/Nethermind/Nethermind.Evm/Metrics.cs @@ -13,6 +13,13 @@ namespace Nethermind.Evm; public class Metrics { + [CounterMetric] + [Description("Number of Code DB cache reads.")] + public static long CodeDbCache => _codeDbCache.GetTotalValue(); + private static readonly ZeroContentionCounter _codeDbCache = new(); + [Description("Number of Code DB cache reads on thread.")] + internal static long ThreadLocalCodeDbCache => _codeDbCache.ThreadLocalValue; + internal static void IncrementCodeDbCache() => _codeDbCache.Increment(); [CounterMetric] [Description("Number of EVM exceptions thrown by contracts.")] public static long EvmExceptions { get; set; } @@ -61,60 +68,6 @@ public class Metrics [Description("Number of EXP opcodes executed.")] public static long ExpOpcode { get; set; } - [Description("Number of BN254_MUL precompile calls.")] - public static long Bn254MulPrecompile { get; set; } - - [Description("Number of BN254_ADD precompile calls.")] - public static long Bn254AddPrecompile { get; set; } - - [Description("Number of BN254_PAIRING precompile calls.")] - public static long Bn254PairingPrecompile { get; set; } - - [Description("Number of BLS12_G1ADD precompile calls.")] - public static long BlsG1AddPrecompile { get; set; } - - [Description("Number of BLS12_G1MUL precompile calls.")] - public static long BlsG1MulPrecompile { get; set; } - - [Description("Number of BLS12_G1MSM precompile calls.")] - public static long BlsG1MSMPrecompile { get; set; } - - [Description("Number of BLS12_G2ADD precompile calls.")] - public static long BlsG2AddPrecompile { get; set; } - - [Description("Number of BLS12_G2MUL precompile calls.")] - public static long BlsG2MulPrecompile { get; set; } - - [Description("Number of BLS12_G2MSM precompile calls.")] - public static long BlsG2MSMPrecompile { get; set; } - - [Description("Number of BLS12_PAIRING_CHECK precompile calls.")] - public static long BlsPairingCheckPrecompile { get; set; } - - [Description("Number of BLS12_MAP_FP_TO_G1 precompile calls.")] - public static long BlsMapFpToG1Precompile { get; set; } - - [Description("Number of BLS12_MAP_FP2_TO_G2 precompile calls.")] - public static long BlsMapFp2ToG2Precompile { get; set; } - - [Description("Number of EC_RECOVERY precompile calls.")] - public static long EcRecoverPrecompile { get; set; } - - [Description("Number of MODEXP precompile calls.")] - public static long ModExpPrecompile { get; set; } - - [Description("Number of RIPEMD160 precompile calls.")] - public static long Ripemd160Precompile { get; set; } - - [Description("Number of SHA256 precompile calls.")] - public static long Sha256Precompile { get; set; } - - [Description("Number of Secp256r1 precompile calls.")] - public static long Secp256r1Precompile { get; set; } - - [Description("Number of Point Evaluation precompile calls.")] - public static long PointEvaluationPrecompile { get; set; } - [CounterMetric] [Description("Number of calls made to addresses without code.")] public static long EmptyCalls => _emptyCalls.GetTotalValue(); diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Blake2FPrecompile.cs b/src/Nethermind/Nethermind.Evm/Precompiles/Blake2FPrecompile.cs deleted file mode 100644 index 30c83984126..00000000000 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Blake2FPrecompile.cs +++ /dev/null @@ -1,61 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using Nethermind.Core; -using Nethermind.Core.Extensions; -using Nethermind.Core.Specs; -using Nethermind.Crypto.Blake2; - -namespace Nethermind.Evm.Precompiles -{ - public class Blake2FPrecompile : IPrecompile - { - private const int RequiredInputLength = 213; - - private readonly Blake2Compression _blake = new(); - - public static readonly Blake2FPrecompile Instance = new(); - - public static Address Address { get; } = Address.FromNumber(9); - - public long BaseGasCost(IReleaseSpec releaseSpec) => 0; - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - if (inputData.Length != RequiredInputLength) - { - return 0; - } - - byte finalByte = inputData.Span[212]; - if (finalByte != 0 && finalByte != 1) - { - return 0; - } - - uint rounds = inputData[..4].Span.ReadEthUInt32(); - - return rounds; - } - - public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - if (inputData.Length != RequiredInputLength) - { - return IPrecompile.Failure; - } - - byte finalByte = inputData.Span[212]; - if (finalByte != 0 && finalByte != 1) - { - return IPrecompile.Failure; - } - - byte[] result = new byte[64]; - _blake.Compress(inputData.Span, result); - - return (result, true); - } - } -} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/Discount.cs b/src/Nethermind/Nethermind.Evm/Precompiles/Bls/Discount.cs deleted file mode 100644 index 3b05ee5ecb1..00000000000 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Bls/Discount.cs +++ /dev/null @@ -1,150 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -namespace Nethermind.Evm.Precompiles.Bls -{ - /// - /// https://eips.ethereum.org/EIPS/eip-2537 - /// - internal static class Discount - { - public static int ForG1(int k) => k >= 128 ? _maxDiscountG1 : _discountTable[k].g1; - public static int ForG2(int k) => k >= 128 ? _maxDiscountG2 : _discountTable[k].g2; - - private const int _maxDiscountG1 = 519; - private const int _maxDiscountG2 = 524; - - private static readonly (int g1, int g2)[] _discountTable = - { - (0, 0), // 0 - (1000, 1000), // 1 - (949, 1000), // 2 - (848, 923), // 3 - (797, 884), // 4 - (764, 855), // 5 - (750, 832), // 6 - (738, 812), // 7 - (728, 796), // 8 - (719, 782), // 9 - (712, 770), // 10 - (705, 759), // 11 - (698, 749), // 12 - (692, 740), // 13 - (687, 732), // 14 - (682, 724), // 15 - (677, 717), // 16 - (673, 711), // 17 - (669, 704), // 18 - (665, 699), // 19 - (661, 693), // 20 - (658, 688), // 21 - (654, 683), // 22 - (651, 679), // 23 - (648, 674), // 24 - (645, 670), // 25 - (642, 666), // 26 - (640, 663), // 27 - (637, 659), // 28 - (635, 655), // 29 - (632, 652), // 30 - (630, 649), // 31 - (627, 646), // 32 - (625, 643), // 33 - (623, 640), // 34 - (621, 637), // 35 - (619, 634), // 36 - (617, 632), // 37 - (615, 629), // 38 - (613, 627), // 39 - (611, 624), // 40 - (609, 622), // 41 - (608, 620), // 42 - (606, 618), // 43 - (604, 615), // 44 - (603, 613), // 45 - (601, 611), // 46 - (599, 609), // 47 - (598, 607), // 48 - (596, 606), // 49 - (595, 604), // 50 - (593, 602), // 51 - (592, 600), // 52 - (591, 598), // 53 - (589, 597), // 54 - (588, 595), // 55 - (586, 593), // 56 - (585, 592), // 57 - (584, 590), // 58 - (582, 589), // 59 - (581, 587), // 60 - (580, 586), // 61 - (579, 584), // 62 - (577, 583), // 63 - (576, 582), // 64 - (575, 580), // 65 - (574, 579), // 66 - (573, 578), // 67 - (572, 576), // 68 - (570, 575), // 69 - (569, 574), // 70 - (568, 573), // 71 - (567, 571), // 72 - (566, 570), // 73 - (565, 569), // 74 - (564, 568), // 75 - (563, 567), // 76 - (562, 566), // 77 - (561, 565), // 78 - (560, 563), // 79 - (559, 562), // 80 - (558, 561), // 81 - (557, 560), // 82 - (556, 559), // 83 - (555, 558), // 84 - (554, 557), // 85 - (553, 556), // 86 - (552, 555), // 87 - (551, 554), // 88 - (550, 553), // 89 - (549, 552), // 90 - (548, 552), // 91 - (547, 551), // 92 - (547, 550), // 93 - (546, 549), // 94 - (545, 548), // 95 - (544, 547), // 96 - (543, 546), // 97 - (542, 545), // 98 - (541, 545), // 99 - (540, 544), // 100 - (540, 543), // 101 - (539, 542), // 102 - (538, 541), // 103 - (537, 541), // 104 - (536, 540), // 105 - (536, 539), // 106 - (535, 538), // 107 - (534, 537), // 108 - (533, 537), // 109 - (532, 536), // 110 - (532, 535), // 111 - (531, 535), // 112 - (530, 534), // 113 - (529, 533), // 114 - (528, 532), // 115 - (528, 532), // 116 - (527, 531), // 117 - (526, 530), // 118 - (525, 530), // 119 - (525, 529), // 120 - (524, 528), // 121 - (523, 528), // 122 - (522, 527), // 123 - (522, 526), // 124 - (521, 526), // 125 - (520, 525), // 126 - (520, 524), // 127 - (519, 524) // 128 - }; - } -} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/EcRecoverPrecompile.cs b/src/Nethermind/Nethermind.Evm/Precompiles/EcRecoverPrecompile.cs deleted file mode 100644 index ab785afd2ce..00000000000 --- a/src/Nethermind/Nethermind.Evm/Precompiles/EcRecoverPrecompile.cs +++ /dev/null @@ -1,73 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using System.Runtime.CompilerServices; -using Nethermind.Core; -using Nethermind.Core.Crypto; -using Nethermind.Core.Extensions; -using Nethermind.Core.Specs; -using Nethermind.Crypto; - -namespace Nethermind.Evm.Precompiles -{ - public class EcRecoverPrecompile : IPrecompile - { - public static readonly EcRecoverPrecompile Instance = new(); - - private EcRecoverPrecompile() - { - } - - public static Address Address { get; } = Address.FromNumber(1); - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; - - public long BaseGasCost(IReleaseSpec releaseSpec) => 3000L; - - private readonly byte[] _zero31 = new byte[31]; - - public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - Metrics.EcRecoverPrecompile++; - return inputData.Length >= 128 ? RunInternal(inputData.Span) : RunInternal(inputData); - } - - private (byte[], bool) RunInternal(ReadOnlyMemory inputData) - { - Span inputDataSpan = stackalloc byte[128]; - inputData.Span[..Math.Min(128, inputData.Length)] - .CopyTo(inputDataSpan[..Math.Min(128, inputData.Length)]); - - return RunInternal(inputDataSpan); - } - - private (byte[], bool) RunInternal(ReadOnlySpan inputDataSpan) - { - ReadOnlySpan vBytes = inputDataSpan.Slice(32, 32); - - // TEST: CALLCODEEcrecoverV_prefixedf0_d0g0v0 - // TEST: CALLCODEEcrecoverV_prefixedf0_d1g0v0 - if (!Bytes.AreEqual(_zero31, vBytes[..31])) - { - return ([], true); - } - - byte v = vBytes[31]; - if (v != 27 && v != 28) - { - return ([], true); - } - - Span publicKey = stackalloc byte[65]; - if (!EthereumEcdsa.RecoverAddressRaw(inputDataSpan.Slice(64, 64), Signature.GetRecoveryId(v), inputDataSpan[..32], publicKey)) - { - return ([], true); - } - - byte[] result = ValueKeccak.Compute(publicKey.Slice(1, 64)).ToByteArray(); - result.AsSpan(0, 12).Clear(); - return (result, true); - } - } -} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Extensions.cs b/src/Nethermind/Nethermind.Evm/Precompiles/Extensions.cs deleted file mode 100644 index 43ba06acdea..00000000000 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Extensions.cs +++ /dev/null @@ -1,16 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; - -namespace Nethermind.Evm.Precompiles -{ - public static class Extensions - { - public static void PrepareEthInput(this ReadOnlyMemory inputData, Span inputDataSpan) - { - inputData.Span[..Math.Min(inputDataSpan.Length, inputData.Length)] - .CopyTo(inputDataSpan[..Math.Min(inputDataSpan.Length, inputData.Length)]); - } - } -} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/IdentityPrecompile.cs b/src/Nethermind/Nethermind.Evm/Precompiles/IdentityPrecompile.cs deleted file mode 100644 index 224aa6fd42d..00000000000 --- a/src/Nethermind/Nethermind.Evm/Precompiles/IdentityPrecompile.cs +++ /dev/null @@ -1,29 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using Nethermind.Core; -using Nethermind.Core.Specs; - -namespace Nethermind.Evm.Precompiles -{ - public class IdentityPrecompile : IPrecompile - { - public static readonly IdentityPrecompile Instance = new(); - - private IdentityPrecompile() - { - } - - public static Address Address { get; } = Address.FromNumber(4); - - public long BaseGasCost(IReleaseSpec releaseSpec) => 15L; - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 3L * EvmInstructions.Div32Ceiling((ulong)inputData.Length); - - public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - return (inputData.ToArray(), true); - } - } -} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/ModExpPrecompilePreEip2565.cs b/src/Nethermind/Nethermind.Evm/Precompiles/ModExpPrecompilePreEip2565.cs deleted file mode 100644 index 71a6a83208b..00000000000 --- a/src/Nethermind/Nethermind.Evm/Precompiles/ModExpPrecompilePreEip2565.cs +++ /dev/null @@ -1,128 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using System.Numerics; -using Nethermind.Core; -using Nethermind.Core.Extensions; -using Nethermind.Core.Specs; -using Nethermind.Int256; - -namespace Nethermind.Evm.Precompiles -{ - /// - /// https://github.com/ethereum/EIPs/blob/vbuterin-patch-2/EIPS/bigint_modexp.md - /// - [Obsolete("Pre-eip2565 implementation")] - public class ModExpPrecompilePreEip2565 : IPrecompile - { - public static ModExpPrecompilePreEip2565 Instance = new(); - private static readonly UInt256 Eight = 8; - - private ModExpPrecompilePreEip2565() - { - } - - public static Address Address { get; } = Address.FromNumber(5); - - public long BaseGasCost(IReleaseSpec releaseSpec) => 0L; - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - try - { - return inputData.Length >= 96 - ? DataGasCostInternal(inputData.Span.Slice(0, 96), inputData, releaseSpec) - : DataGasCostInternal(inputData, releaseSpec); - } - catch (OverflowException) - { - return long.MaxValue; - } - } - - private static long DataGasCostInternal(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - Span extendedInput = stackalloc byte[96]; - inputData[..Math.Min(96, inputData.Length)].Span - .CopyTo(extendedInput[..Math.Min(96, inputData.Length)]); - - return DataGasCostInternal(extendedInput, inputData, releaseSpec); - } - - private static long DataGasCostInternal(ReadOnlySpan extendedInput, ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - UInt256 baseLength = new(extendedInput[..32], true); - UInt256 expLength = new(extendedInput.Slice(32, 32), true); - UInt256 modulusLength = new(extendedInput.Slice(64, 32), true); - - UInt256 complexity = MultComplexity(UInt256.Max(baseLength, modulusLength)); - - byte[] expSignificantBytes = inputData.Span.SliceWithZeroPaddingEmptyOnError(96 + (int)baseLength, (int)UInt256.Min(expLength, 32)); - - UInt256 lengthOver32 = expLength <= 32 ? 0 : expLength - 32; - UInt256 adjusted = AdjustedExponentLength(lengthOver32, expSignificantBytes); - UInt256 gas = complexity * UInt256.Max(adjusted, UInt256.One) / 20; - return gas > long.MaxValue ? long.MaxValue : (long)gas; - } - - public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - Metrics.ModExpPrecompile++; - - int baseLength = (int)inputData.Span.SliceWithZeroPaddingEmptyOnError(0, 32).ToUnsignedBigInteger(); - BigInteger expLengthBig = inputData.Span.SliceWithZeroPaddingEmptyOnError(32, 32).ToUnsignedBigInteger(); - int expLength = expLengthBig > int.MaxValue ? int.MaxValue : (int)expLengthBig; - int modulusLength = (int)inputData.Span.SliceWithZeroPaddingEmptyOnError(64, 32).ToUnsignedBigInteger(); - - BigInteger modulusInt = inputData.Span.SliceWithZeroPaddingEmptyOnError(96 + baseLength + expLength, modulusLength).ToUnsignedBigInteger(); - - if (modulusInt.IsZero) - { - return (new byte[modulusLength], true); - } - - BigInteger baseInt = inputData.Span.SliceWithZeroPaddingEmptyOnError(96, baseLength).ToUnsignedBigInteger(); - BigInteger expInt = inputData.Span.SliceWithZeroPaddingEmptyOnError(96 + baseLength, expLength).ToUnsignedBigInteger(); - return (BigInteger.ModPow(baseInt, expInt, modulusInt).ToBigEndianByteArray(modulusLength), true); - } - - private static UInt256 MultComplexity(in UInt256 adjustedExponentLength) - { - if (adjustedExponentLength <= 64) - { - return adjustedExponentLength * adjustedExponentLength; - } - - if (adjustedExponentLength <= 1024) - { - return adjustedExponentLength * adjustedExponentLength / 4 + 96 * adjustedExponentLength - 3072; - } - - return adjustedExponentLength * adjustedExponentLength / 16 + 480 * adjustedExponentLength - 199680; - } - - private static UInt256 AdjustedExponentLength(in UInt256 lengthOver32, byte[] exponent) - { - bool overflow = false; - bool underflow = false; - UInt256 result; - - int leadingZeros = exponent.AsSpan().LeadingZerosCount(); - if (leadingZeros == exponent.Length) - { - overflow |= UInt256.MultiplyOverflow(lengthOver32, Eight, out result); - return overflow ? UInt256.MaxValue : result; - } - - overflow |= UInt256.AddOverflow(lengthOver32, (UInt256)exponent.Length, out result); - underflow |= UInt256.SubtractUnderflow(result, (UInt256)leadingZeros, out result); - underflow |= UInt256.SubtractUnderflow(result, UInt256.One, out result); - overflow |= UInt256.MultiplyOverflow(result, Eight, out result); - overflow |= UInt256.AddOverflow(result, (UInt256)exponent[leadingZeros].GetHighestSetBitIndex(), out result); - underflow |= UInt256.SubtractUnderflow(result, UInt256.One, out result); - - return overflow ? UInt256.MaxValue : underflow ? UInt256.MinValue : result; - } - } -} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Ripemd160Precompile.cs b/src/Nethermind/Nethermind.Evm/Precompiles/Ripemd160Precompile.cs deleted file mode 100644 index 6e2135bfccf..00000000000 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Ripemd160Precompile.cs +++ /dev/null @@ -1,39 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using Nethermind.Core; -using Nethermind.Core.Extensions; -using Nethermind.Core.Specs; -using Nethermind.Crypto; - -namespace Nethermind.Evm.Precompiles -{ - public class Ripemd160Precompile : IPrecompile - { - public static readonly Ripemd160Precompile Instance = new(); - - // missing in .NET Core - // private static RIPEMD160 _ripemd; - - private Ripemd160Precompile() - { - // missing in .NET Core - // _ripemd = RIPEMD160.Create(); - // _ripemd.Initialize(); - } - - public static Address Address { get; } = Address.FromNumber(3); - - public long BaseGasCost(IReleaseSpec releaseSpec) => 600L; - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 120L * EvmInstructions.Div32Ceiling((ulong)inputData.Length); - - public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - Metrics.Ripemd160Precompile++; - - return (Ripemd.Compute(inputData.ToArray()).PadLeft(32), true); - } - } -} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/Sha256Precompile.cs b/src/Nethermind/Nethermind.Evm/Precompiles/Sha256Precompile.cs deleted file mode 100644 index 5be824b5311..00000000000 --- a/src/Nethermind/Nethermind.Evm/Precompiles/Sha256Precompile.cs +++ /dev/null @@ -1,34 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using System.Security.Cryptography; -using System.Threading; -using Nethermind.Core; -using Nethermind.Core.Specs; - -namespace Nethermind.Evm.Precompiles -{ - public class Sha256Precompile : IPrecompile - { - public static readonly Sha256Precompile Instance = new(); - - private Sha256Precompile() { } - - public static Address Address { get; } = Address.FromNumber(2); - - public long BaseGasCost(IReleaseSpec releaseSpec) => 60L; - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 12L * EvmInstructions.Div32Ceiling((ulong)inputData.Length); - - public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - Metrics.Sha256Precompile++; - - byte[] output = new byte[SHA256.HashSizeInBytes]; - bool success = SHA256.TryHashData(inputData.Span, output, out int bytesWritten); - - return (output, success && bytesWritten == SHA256.HashSizeInBytes); - } - } -} diff --git a/src/Nethermind/Nethermind.Init/Modules/BlockProcessingModule.cs b/src/Nethermind/Nethermind.Init/Modules/BlockProcessingModule.cs index 98588394299..f488ef4f9b2 100644 --- a/src/Nethermind/Nethermind.Init/Modules/BlockProcessingModule.cs +++ b/src/Nethermind/Nethermind.Init/Modules/BlockProcessingModule.cs @@ -40,7 +40,7 @@ protected override void Load(ContainerBuilder builder) // Block processing components common between rpc, validation and production .AddScoped() - .AddScoped() + .AddScoped() .AddScoped() .AddScoped() .AddScoped() diff --git a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs index dccf339d516..731ffbf8005 100644 --- a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs +++ b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs @@ -23,7 +23,6 @@ using Nethermind.Consensus.Withdrawals; using Nethermind.Core; using Nethermind.Core.Attributes; -using Nethermind.Core.Crypto; using Nethermind.Core.ServiceStopper; using Nethermind.Evm; using Nethermind.Evm.State; @@ -68,7 +67,7 @@ protected virtual Task InitBlockchain() IStateReader stateReader = setApi.StateReader!; IWorldState mainWorldState = _api.WorldStateManager!.GlobalWorldState; PreBlockCaches? preBlockCaches = (mainWorldState as IPreBlockCaches)?.Caches; - CodeInfoRepository codeInfoRepository = new(preBlockCaches?.PrecompileCache); + EthereumCodeInfoRepository codeInfoRepository = new(preBlockCaches?.PrecompileCache); IChainHeadInfoProvider chainHeadInfoProvider = new ChainHeadInfoProvider(getApi.SpecProvider!, getApi.BlockTree!, stateReader, codeInfoRepository); @@ -80,7 +79,7 @@ protected virtual Task InitBlockchain() new RecoverSignatures(getApi.EthereumEcdsa, getApi.SpecProvider, getApi.LogManager)); WarmupEvm(); - VirtualMachine virtualMachine = CreateVirtualMachine(codeInfoRepository, mainWorldState); + VirtualMachine virtualMachine = CreateVirtualMachine(mainWorldState); ITransactionProcessor transactionProcessor = CreateTransactionProcessor(codeInfoRepository, virtualMachine, mainWorldState); if (_api.SealValidator is null) throw new StepDependencyException(nameof(_api.SealValidator)); @@ -161,7 +160,7 @@ private void WarmupEvm() { IWorldState state = _api.WorldStateManager!.CreateResettableWorldState(); state.SetBaseBlock(null); - VirtualMachine.WarmUpEvmInstructions(state, new CodeInfoRepository()); + VirtualMachine.WarmUpEvmInstructions(state, new EthereumCodeInfoRepository()); } protected virtual ITransactionProcessor CreateTransactionProcessor(ICodeInfoRepository codeInfoRepository, IVirtualMachine virtualMachine, IWorldState worldState) @@ -176,7 +175,7 @@ protected virtual ITransactionProcessor CreateTransactionProcessor(ICodeInfoRepo _api.LogManager); } - protected VirtualMachine CreateVirtualMachine(CodeInfoRepository codeInfoRepository, IWorldState worldState) + protected VirtualMachine CreateVirtualMachine(IWorldState worldState) { if (_api.BlockTree is null) throw new StepDependencyException(nameof(_api.BlockTree)); if (_api.SpecProvider is null) throw new StepDependencyException(nameof(_api.SpecProvider)); diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs index dfaead65e34..e44b8c61362 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs @@ -34,7 +34,6 @@ using NSubstitute; using NUnit.Framework; using System; -using Nethermind.Evm; using Nethermind.State; namespace Nethermind.JsonRpc.Test.Modules @@ -78,7 +77,7 @@ public void Initialize() _txPool = new TxPool.TxPool(_ethereumEcdsa, new BlobTxStorage(), - new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(specProvider), _blockTree, stateProvider, new CodeInfoRepository()) { HasSynced = true }, + new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(specProvider), _blockTree, stateProvider, new EthereumCodeInfoRepository()) { HasSynced = true }, new TxPoolConfig(), new TxValidator(specProvider.ChainId), LimboLogs.Instance, diff --git a/src/Nethermind/Nethermind.Network.Benchmark/Eth62ProtocolHandlerBenchmarks.cs b/src/Nethermind/Nethermind.Network.Benchmark/Eth62ProtocolHandlerBenchmarks.cs index e3bfc72f98a..a19bd15b664 100644 --- a/src/Nethermind/Nethermind.Network.Benchmark/Eth62ProtocolHandlerBenchmarks.cs +++ b/src/Nethermind/Nethermind.Network.Benchmark/Eth62ProtocolHandlerBenchmarks.cs @@ -62,7 +62,7 @@ public void SetUp() TxPool.TxPool txPool = new TxPool.TxPool( ecdsa, new BlobTxStorage(), - new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(MainnetSpecProvider.Instance), tree, stateProvider, new CodeInfoRepository()), + new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(MainnetSpecProvider.Instance), tree, stateProvider, new EthereumCodeInfoRepository()), new TxPoolConfig(), new TxValidator(TestBlockchainIds.ChainId), LimboLogs.Instance, diff --git a/src/Nethermind/Nethermind.Precompiles.Benchmark/Nethermind.Precompiles.Benchmark.csproj b/src/Nethermind/Nethermind.Precompiles.Benchmark/Nethermind.Precompiles.Benchmark.csproj index 1fa7275f368..679565746ff 100644 --- a/src/Nethermind/Nethermind.Precompiles.Benchmark/Nethermind.Precompiles.Benchmark.csproj +++ b/src/Nethermind/Nethermind.Precompiles.Benchmark/Nethermind.Precompiles.Benchmark.csproj @@ -11,6 +11,8 @@ + + diff --git a/src/Nethermind/Nethermind.State/OverridableEnv/OverridableCodeInfoRepository.cs b/src/Nethermind/Nethermind.State/OverridableEnv/OverridableCodeInfoRepository.cs index 7e94f8ddb20..35088f63d75 100644 --- a/src/Nethermind/Nethermind.State/OverridableEnv/OverridableCodeInfoRepository.cs +++ b/src/Nethermind/Nethermind.State/OverridableEnv/OverridableCodeInfoRepository.cs @@ -25,6 +25,11 @@ public ICodeInfo GetCachedCodeInfo(IWorldState worldState, Address codeSource, b : codeInfoRepository.GetCachedCodeInfo(worldState, codeSource, followDelegation, vmSpec, out delegationAddress); } + public bool IsPrecompile(Address address, IReleaseSpec spec) => + _codeOverwrites.TryGetValue(address, out ICodeInfo result) + ? result.IsPrecompile + : codeInfoRepository.IsPrecompile(address, spec); + public void InsertCode(IWorldState state, ReadOnlyMemory code, Address codeOwner, IReleaseSpec spec) => codeInfoRepository.InsertCode(state, code, codeOwner, spec); diff --git a/src/Nethermind/Nethermind.Taiko.Test/TransactionProcessorTests.cs b/src/Nethermind/Nethermind.Taiko.Test/TransactionProcessorTests.cs index ab13bd88fb3..3b01b805af3 100644 --- a/src/Nethermind/Nethermind.Taiko.Test/TransactionProcessorTests.cs +++ b/src/Nethermind/Nethermind.Taiko.Test/TransactionProcessorTests.cs @@ -13,9 +13,9 @@ using Nethermind.Evm.State; using NUnit.Framework; using System.Collections; +using Nethermind.Blockchain; using Nethermind.Core.Test; using Nethermind.Evm; -using Nethermind.Evm.Test; using Nethermind.State; using Nethermind.Taiko.TaikoSpec; @@ -49,7 +49,7 @@ public void Setup() _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TaikoTransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); } diff --git a/src/Nethermind/Nethermind.TxPool.Test/DelegatedAccountFilterTest.cs b/src/Nethermind/Nethermind.TxPool.Test/DelegatedAccountFilterTest.cs index e4fd20fc504..9c1e9fea114 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/DelegatedAccountFilterTest.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/DelegatedAccountFilterTest.cs @@ -29,7 +29,7 @@ public void Accept_SenderIsNotDelegated_ReturnsAccepted() headInfoProvider.GetCurrentHeadSpec().Returns(Prague.Instance); TxDistinctSortedPool standardPool = new TxDistinctSortedPool(MemoryAllowance.MemPoolSize, Substitute.For>(), NullLogManager.Instance); TxDistinctSortedPool blobPool = new BlobTxDistinctSortedPool(10, Substitute.For>(), NullLogManager.Instance); - DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(), new DelegationCache()); + DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new EthereumCodeInfoRepository(), new DelegationCache()); Transaction transaction = Build.A.Transaction.SignedAndResolved(new EthereumEcdsa(0), TestItem.PrivateKeyA).TestObject; TxFilteringState state = new(transaction, Substitute.For()); @@ -44,7 +44,7 @@ public void Accept_SenderIsDelegatedWithNoTransactionsInPool_ReturnsAccepted() IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); byte[] code = [.. Eip7702Constants.DelegationHeader, .. TestItem.PrivateKeyA.Address.Bytes]; codeInfoRepository.InsertCode(stateProvider, code, TestItem.AddressA, Prague.Instance); IChainHeadSpecProvider headInfoProvider = Substitute.For(); @@ -72,7 +72,7 @@ public void Accept_SenderIsDelegatedWithOneTransactionInPoolWithSameNonce_Return IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); byte[] code = [.. Eip7702Constants.DelegationHeader, .. TestItem.PrivateKeyA.Address.Bytes]; codeInfoRepository.InsertCode(stateProvider, code, TestItem.AddressA, Prague.Instance); DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, stateProvider, codeInfoRepository, new DelegationCache()); @@ -96,7 +96,7 @@ public void Accept_SenderIsDelegatedWithOneTransactionInPoolWithDifferentNonce_R IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); byte[] code = [.. Eip7702Constants.DelegationHeader, .. TestItem.PrivateKeyA.Address.Bytes]; codeInfoRepository.InsertCode(stateProvider, code, TestItem.AddressA, Prague.Instance); DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, stateProvider, codeInfoRepository, new DelegationCache()); @@ -125,7 +125,7 @@ public void Accept_Eip7702IsNotActivated_ReturnsExpected(bool isActive, AcceptTx IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); byte[] code = [.. Eip7702Constants.DelegationHeader, .. TestItem.PrivateKeyA.Address.Bytes]; codeInfoRepository.InsertCode(stateProvider, code, TestItem.AddressA, Prague.Instance); DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, stateProvider, codeInfoRepository, new DelegationCache()); @@ -153,7 +153,7 @@ public void Accept_SenderHasPendingDelegation_OnlyAcceptsIfNonceIsExactMatch(int TxDistinctSortedPool blobPool = new BlobTxDistinctSortedPool(10, Substitute.For>(), NullLogManager.Instance); DelegationCache pendingDelegations = new(); pendingDelegations.IncrementDelegationCount(TestItem.AddressA); - DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(), pendingDelegations); + DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new EthereumCodeInfoRepository(), pendingDelegations); Transaction transaction = Build.A.Transaction.WithNonce((UInt256)nonce).SignedAndResolved(new EthereumEcdsa(0), TestItem.PrivateKeyA).TestObject; IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; @@ -173,7 +173,7 @@ public void Accept_AuthorityHasPendingTransaction_ReturnsDelegatorHasPendingTx(b headInfoProvider.GetCurrentHeadSpec().Returns(Prague.Instance); TxDistinctSortedPool standardPool = new TxDistinctSortedPool(MemoryAllowance.MemPoolSize, Substitute.For>(), NullLogManager.Instance); TxDistinctSortedPool blobPool = new BlobTxDistinctSortedPool(10, Substitute.For>(), NullLogManager.Instance); - DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(), new()); + DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new EthereumCodeInfoRepository(), new()); Transaction transaction; if (useBlobPool) { @@ -214,7 +214,7 @@ public void Accept_SetCodeTxHasAuthorityWithPendingTx_ReturnsDelegatorHasPending TxDistinctSortedPool blobPool = new BlobTxDistinctSortedPool(10, Substitute.For>(), NullLogManager.Instance); DelegationCache pendingDelegations = new(); pendingDelegations.IncrementDelegationCount(TestItem.AddressA); - DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(), pendingDelegations); + DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new EthereumCodeInfoRepository(), pendingDelegations); Transaction transaction = Build.A.Transaction .WithNonce(1) .SignedAndResolved(new EthereumEcdsa(0), TestItem.PrivateKeyA).TestObject; diff --git a/src/Nethermind/Nethermind.TxPool.Test/NonceManagerTests.cs b/src/Nethermind/Nethermind.TxPool.Test/NonceManagerTests.cs index ebd1e270117..3402c10146b 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/NonceManagerTests.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/NonceManagerTests.cs @@ -43,7 +43,7 @@ public void Setup() _blockTree.Head.Returns(block); _blockTree.FindBestSuggestedHeader().Returns(Build.A.BlockHeader.WithNumber(10000000).TestObject); - _headInfo = new ChainHeadInfoProvider(_specProvider, _blockTree, _stateProvider, new CodeInfoRepository()); + _headInfo = new ChainHeadInfoProvider(_specProvider, _blockTree, _stateProvider, new EthereumCodeInfoRepository()); _nonceManager = new NonceManager(_headInfo.ReadOnlyStateProvider); } diff --git a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs index 9c92e315abd..16e7597b2dc 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs @@ -466,7 +466,7 @@ public void should_allow_to_replace_blob_tx_by_the_one_with_network_wrapper_in_h IChainHeadSpecProvider specProvider = Substitute.For(); specProvider.GetCurrentHeadSpec().Returns(releaseSpec); - ChainHeadInfoProvider chainHeadInfoProvider = new(specProvider, _blockTree, _stateProvider, new CodeInfoRepository()); + ChainHeadInfoProvider chainHeadInfoProvider = new(specProvider, _blockTree, _stateProvider, new EthereumCodeInfoRepository()); _txPool = CreatePool(new TxPoolConfig() { BlobsSupport = BlobsSupportMode.InMemory, Size = 128 }, specProvider: specProvider, chainHeadInfoProvider: chainHeadInfoProvider); diff --git a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs index 279a6fdc54a..dff558165a1 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs @@ -2195,7 +2195,7 @@ private TxPool CreatePool( txStorage ??= new BlobTxStorage(); _headInfo = chainHeadInfoProvider; - _headInfo ??= new ChainHeadInfoProvider(specProvider, _blockTree, _stateProvider, new CodeInfoRepository()); + _headInfo ??= new ChainHeadInfoProvider(specProvider, _blockTree, _stateProvider, new EthereumCodeInfoRepository()); return new TxPool( _ethereumEcdsa, diff --git a/src/Nethermind/Nethermind.slnx b/src/Nethermind/Nethermind.slnx index 68022da596f..f11579ea877 100644 --- a/src/Nethermind/Nethermind.slnx +++ b/src/Nethermind/Nethermind.slnx @@ -95,6 +95,7 @@ + diff --git a/tools/Evm/T8n/T8nExecutor.cs b/tools/Evm/T8n/T8nExecutor.cs index 90b31aa23e3..672a09618e2 100644 --- a/tools/Evm/T8n/T8nExecutor.cs +++ b/tools/Evm/T8n/T8nExecutor.cs @@ -24,6 +24,7 @@ using Nethermind.Logging; using Nethermind.State; using Nethermind.Trie.Pruning; +using Nethermind.Blockchain; namespace Evm.T8n; @@ -39,7 +40,7 @@ public static T8nExecutionResult Execute(T8nCommandArguments arguments) IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; - CodeInfoRepository codeInfoRepository = new(); + EthereumCodeInfoRepository codeInfoRepository = new(); IBlockhashProvider blockhashProvider = ConstructBlockHashProvider(test); IVirtualMachine virtualMachine = new VirtualMachine( From 4540a7fe32f37ed57d19a443b06a20d440303441 Mon Sep 17 00:00:00 2001 From: Alexey Date: Wed, 16 Jul 2025 19:32:25 +0300 Subject: [PATCH 23/40] Add EIP-7910: Add eth_config (#8956) * Add eth_config * Update systemContracts, refactor * Fix next/last hash to be null --- .../CachedCodeInfoRepository.cs | 2 + .../Blockchain/TestBlockchain.cs | 5 +- .../Nethermind.Core/Eip2935Constants.cs | 2 + .../Nethermind.Core/Eip4788Constants.cs | 2 + .../Nethermind.Core/Eip6110Constants.cs | 2 + .../Nethermind.Core/Eip7002Constants.cs | 2 + .../Nethermind.Core/Eip7251Constants.cs | 2 + .../Blake2FPrecompile.cs | 3 +- .../Bls/G1AddPrecompile.cs | 2 + .../Bls/G1MSMPrecompile.cs | 2 + .../Bls/G2AddPrecompile.cs | 2 + .../Bls/G2MSMPrecompile.cs | 2 + .../Bls/MapFp2ToG2Precompile.cs | 2 + .../Bls/MapFpToG1Precompile.cs | 2 + .../Bls/PairingCheckPrecompile.cs | 2 + .../EcRecoverPrecompile.cs | 2 + .../Nethermind.Evm.Precompiles/Extensions.cs | 70 +++++++++++++++++++ .../IdentityPrecompile.cs | 2 + .../ModExpPrecompile.cs | 2 + .../ModExpPrecompilePreEip2565.cs | 2 + .../PointEvaluationPrecompile.cs | 2 + .../Ripemd160Precompile.cs | 2 + .../Secp256r1Precompile.cs | 2 + .../Sha256Precompile.cs | 2 + .../Snarks/Bn254AddPrecompile.cs | 2 + .../Snarks/Bn254MulPrecompile.cs | 2 + .../Snarks/Bn254PairingPrecompile.cs | 2 + .../Nethermind.Evm/Precompiles/IPrecompile.cs | 1 + .../EthModuleBenchmarks.cs | 33 +-------- .../Modules/BoundedModulePoolTests.cs | 3 +- .../Modules/SingletonModulePoolTests.cs | 3 +- .../Modules/TestRpcBlockchain.cs | 1 + .../Data/EthConfigResult.cs | 37 ++++++++++ .../Modules/Eth/EthModuleFactory.cs | 4 +- .../Modules/Eth/EthRpcModule.cs | 68 ++++++++++++++++++ .../Modules/Eth/IEthRpcModule.cs | 3 + src/Nethermind/Nethermind.Network/ForkInfo.cs | 51 ++++++++++++-- .../Nethermind.Network/IForkInfo.cs | 13 ++++ .../Rpc/OptimismEthRpcModuleTest.cs | 1 + .../Rpc/OptimismEthModuleFactory.cs | 5 +- .../Rpc/OptimismEthRpcModule.cs | 2 + 41 files changed, 307 insertions(+), 44 deletions(-) create mode 100644 src/Nethermind/Nethermind.JsonRpc/Data/EthConfigResult.cs diff --git a/src/Nethermind/Nethermind.Blockchain/CachedCodeInfoRepository.cs b/src/Nethermind/Nethermind.Blockchain/CachedCodeInfoRepository.cs index b2077c19f96..8ce1fbc8099 100644 --- a/src/Nethermind/Nethermind.Blockchain/CachedCodeInfoRepository.cs +++ b/src/Nethermind/Nethermind.Blockchain/CachedCodeInfoRepository.cs @@ -33,6 +33,8 @@ private class CachedPrecompile( { public static Address Address => Address.Zero; + public static string Name => ""; + public long BaseGasCost(IReleaseSpec releaseSpec) => precompile.BaseGasCost(releaseSpec); public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => precompile.DataGasCost(inputData, releaseSpec); diff --git a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs index 967729a330a..b9fac250056 100644 --- a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs +++ b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs @@ -41,6 +41,7 @@ using Nethermind.Specs.ChainSpecStyle; using Nethermind.Specs.Test; using Nethermind.Evm.State; +using Nethermind.Network; using Nethermind.State; using Nethermind.State.Repositories; using Nethermind.TxPool; @@ -58,6 +59,7 @@ public class TestBlockchain : IDisposable public IMainProcessingContext MainProcessingContext => _fromContainer.MainProcessingContext; public IReceiptStorage ReceiptStorage => _fromContainer.ReceiptStorage; public ITxPool TxPool => _fromContainer.TxPool; + public IForkInfo ForkInfo => _fromContainer.ForkInfo; public IWorldStateManager WorldStateManager => _fromContainer.WorldStateManager; public IReadOnlyTxProcessingEnvFactory ReadOnlyTxProcessingEnvFactory => _fromContainer.ReadOnlyTxProcessingEnvFactory; public IShareableTxProcessorSource ShareableTxProcessorSource => _fromContainer.ShareableTxProcessorSource; @@ -162,7 +164,8 @@ private record FromContainer( ManualTimestamper ManualTimestamper, IManualBlockProductionTrigger BlockProductionTrigger, IShareableTxProcessorSource ShareableTxProcessorSource, - ISealer Sealer + ISealer Sealer, + IForkInfo ForkInfo ) { } diff --git a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs index 63664121d6a..1cfd0c1efc0 100644 --- a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs @@ -8,6 +8,8 @@ namespace Nethermind.Core; /// public static class Eip2935Constants { + public const string ContractAddressKey = "HISTORY_STORAGE_ADDRESS"; + /// /// The HISTORY_STORAGE_ADDRESS parameter. /// diff --git a/src/Nethermind/Nethermind.Core/Eip4788Constants.cs b/src/Nethermind/Nethermind.Core/Eip4788Constants.cs index fed5db663d8..af10e162a95 100644 --- a/src/Nethermind/Nethermind.Core/Eip4788Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip4788Constants.cs @@ -8,6 +8,8 @@ namespace Nethermind.Core; /// public static class Eip4788Constants { + public const string ContractAddressKey = "BEACON_ROOTS_ADDRESS"; + /// /// Gets the BEACON_ROOTS_ADDRESS parameter. /// diff --git a/src/Nethermind/Nethermind.Core/Eip6110Constants.cs b/src/Nethermind/Nethermind.Core/Eip6110Constants.cs index 98eb35fa328..2fadd552747 100644 --- a/src/Nethermind/Nethermind.Core/Eip6110Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip6110Constants.cs @@ -5,6 +5,8 @@ namespace Nethermind.Core; public static class Eip6110Constants { + public const string ContractAddressKey = "DEPOSIT_CONTRACT_ADDRESS"; + public static readonly Address MainnetDepositContractAddress = new("0x00000000219ab540356cbb839cbe05303d7705fa"); public static readonly Address HoleskyDepositContractAddress = new("0x4242424242424242424242424242424242424242"); public static readonly Address SepoliaDepositContractAddress = new("0x7f02c3e3c98b133055b8b348b2ac625669ed295d"); diff --git a/src/Nethermind/Nethermind.Core/Eip7002Constants.cs b/src/Nethermind/Nethermind.Core/Eip7002Constants.cs index b786664cd81..f7033eae7c4 100644 --- a/src/Nethermind/Nethermind.Core/Eip7002Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip7002Constants.cs @@ -5,5 +5,7 @@ namespace Nethermind.Core; public static class Eip7002Constants { + public const string ContractAddressKey = "WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS"; + public static readonly Address WithdrawalRequestPredeployAddress = new("0x00000961Ef480Eb55e80D19ad83579A64c007002"); } diff --git a/src/Nethermind/Nethermind.Core/Eip7251Constants.cs b/src/Nethermind/Nethermind.Core/Eip7251Constants.cs index a0a453010e4..171c30d2abf 100644 --- a/src/Nethermind/Nethermind.Core/Eip7251Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip7251Constants.cs @@ -5,5 +5,7 @@ namespace Nethermind.Core; public static class Eip7251Constants { + public const string ContractAddressKey = "CONSOLIDATION_REQUEST_PREDEPLOY_ADDRESS"; + public static readonly Address ConsolidationRequestPredeployAddress = new("0x0000BBdDc7CE488642fb579F8B00f3a590007251"); } diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Blake2FPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Blake2FPrecompile.cs index f685e05daf5..74762e7ebd5 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Blake2FPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Blake2FPrecompile.cs @@ -6,7 +6,6 @@ using Nethermind.Core.Extensions; using Nethermind.Core.Specs; using Nethermind.Crypto.Blake2; -using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Precompiles; @@ -20,6 +19,8 @@ public class Blake2FPrecompile : IPrecompile public static Address Address { get; } = Address.FromNumber(9); + public static string Name => "BLAKE2F"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 0; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1AddPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1AddPrecompile.cs index ab333c1c59d..85ecf7dae0d 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1AddPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1AddPrecompile.cs @@ -23,6 +23,8 @@ private G1AddPrecompile() public static Address Address { get; } = Address.FromNumber(0x0b); + public static string Name => "BLS12_G1ADD"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 375L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1MSMPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1MSMPrecompile.cs index 45c6de2dbd4..80e92ab1cbf 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1MSMPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G1MSMPrecompile.cs @@ -26,6 +26,8 @@ private G1MSMPrecompile() public static Address Address { get; } = Address.FromNumber(0x0c); + public static string Name => "BLS12_G1MSM"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 0L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2AddPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2AddPrecompile.cs index 55df3c38ed1..734d8602449 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2AddPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2AddPrecompile.cs @@ -23,6 +23,8 @@ private G2AddPrecompile() public static Address Address { get; } = Address.FromNumber(0x0d); + public static string Name => "BLS12_G2ADD"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 600L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2MSMPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2MSMPrecompile.cs index c4a4a430028..8151e8c5f6a 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2MSMPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/G2MSMPrecompile.cs @@ -26,6 +26,8 @@ private G2MSMPrecompile() public static Address Address { get; } = Address.FromNumber(0xe); + public static string Name => "BLS12_G2MSM"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 0L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFp2ToG2Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFp2ToG2Precompile.cs index 1d796aa046e..cac3f490ff5 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFp2ToG2Precompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFp2ToG2Precompile.cs @@ -23,6 +23,8 @@ private MapFp2ToG2Precompile() public static Address Address { get; } = Address.FromNumber(0x11); + public static string Name => "BLS12_MAP_FP2_TO_G2"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 23800L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFpToG1Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFpToG1Precompile.cs index f6ee5d0b11e..f3689b5b98f 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFpToG1Precompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/MapFpToG1Precompile.cs @@ -23,6 +23,8 @@ private MapFpToG1Precompile() public static Address Address { get; } = Address.FromNumber(0x10); + public static string Name => "BLS12_MAP_FP_TO_G1"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 5500L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/PairingCheckPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/PairingCheckPrecompile.cs index abd781f8cbf..de45b8838a9 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Bls/PairingCheckPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Bls/PairingCheckPrecompile.cs @@ -25,6 +25,8 @@ private PairingCheckPrecompile() { } public static Address Address { get; } = Address.FromNumber(0xf); + public static string Name => "BLS12_PAIRING_CHECK"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 37700L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 32600L * (inputData.Length / PairSize); diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/EcRecoverPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/EcRecoverPrecompile.cs index 93dd962008c..a828db49404 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/EcRecoverPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/EcRecoverPrecompile.cs @@ -22,6 +22,8 @@ private EcRecoverPrecompile() public static Address Address { get; } = Address.FromNumber(1); + public static string Name => "ECREC"; + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; public long BaseGasCost(IReleaseSpec releaseSpec) => 3000L; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs index 768fdcb27d5..7e11eff53d5 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs @@ -1,7 +1,12 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using Nethermind.Core; +using Nethermind.Core.Specs; +using Nethermind.Evm.Precompiles.Bls; +using Nethermind.Evm.Precompiles.Snarks; using System; +using System.Collections.Generic; namespace Nethermind.Evm.Precompiles; @@ -12,4 +17,69 @@ public static void PrepareEthInput(this ReadOnlyMemory inputData, Span ListPrecompiles(this IReleaseSpec spec) + { + OrderedDictionary precompiles = []; + + AddPrecompile(); + AddPrecompile(); + AddPrecompile(); + AddPrecompile(); + + if (spec.ModExpEnabled) + { + AddPrecompile(); + } + + if (spec.Bn128Enabled) + { + AddPrecompile(); + AddPrecompile(); + AddPrecompile(); + } + + if (spec.BlakeEnabled) + { + AddPrecompile(); + } + + if (spec.IsEip4844Enabled) + { + AddPrecompile(); + } + + if (spec.Bls381Enabled) + { + AddPrecompile(); + AddPrecompile(); + AddPrecompile(); + AddPrecompile(); + AddPrecompile(); + AddPrecompile(); + AddPrecompile(); + } + + if (spec.IsEip7951Enabled) + { + AddPrecompile(); + } + + return precompiles; + + void AddPrecompile() where T : IPrecompile => precompiles[T.Address] = T.Name; + } + + public static OrderedDictionary ListSystemContracts(this IReleaseSpec spec) + { + OrderedDictionary systemContracts = []; + + if (spec.IsBeaconBlockRootAvailable) systemContracts[Eip4788Constants.ContractAddressKey] = Eip4788Constants.BeaconRootsAddress; + if (spec.ConsolidationRequestsEnabled) systemContracts[Eip7251Constants.ContractAddressKey] = Eip7251Constants.ConsolidationRequestPredeployAddress; + if (spec.DepositsEnabled) systemContracts[Eip6110Constants.ContractAddressKey] = spec.DepositContractAddress; + if (spec.IsEip2935Enabled) systemContracts[Eip2935Constants.ContractAddressKey] = Eip2935Constants.BlockHashHistoryAddress; + if (spec.WithdrawalRequestsEnabled) systemContracts[Eip7002Constants.ContractAddressKey] = Eip7002Constants.WithdrawalRequestPredeployAddress; + + return systemContracts; + } } diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/IdentityPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/IdentityPrecompile.cs index 1a81d115369..67317a39a42 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/IdentityPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/IdentityPrecompile.cs @@ -19,6 +19,8 @@ private IdentityPrecompile() public static Address Address { get; } = Address.FromNumber(4); + public static string Name => "ID"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 15L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs index 0083a354872..803b6a791ef 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs @@ -32,6 +32,8 @@ private ModExpPrecompile() public static Address Address { get; } = Address.FromNumber(5); + public static string Name => "MODEXP"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 0L; /// diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs index 982ff2463b0..c1186c809e8 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs @@ -26,6 +26,8 @@ private ModExpPrecompilePreEip2565() public static Address Address { get; } = Address.FromNumber(5); + public static string Name => "MODEXP"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 0L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/PointEvaluationPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/PointEvaluationPrecompile.cs index e9844eb8d5e..534113b911f 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/PointEvaluationPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/PointEvaluationPrecompile.cs @@ -24,6 +24,8 @@ public class PointEvaluationPrecompile : IPrecompile public static Address Address { get; } = Address.FromNumber(0x0a); + public static string Name => "KZG_POINT_EVALUATION"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 50000L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Ripemd160Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Ripemd160Precompile.cs index 20a7b0ed682..b4c3751bee6 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Ripemd160Precompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Ripemd160Precompile.cs @@ -27,6 +27,8 @@ private Ripemd160Precompile() public static Address Address { get; } = Address.FromNumber(3); + public static string Name => "RIPEMD160"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 600L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Secp256r1Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Secp256r1Precompile.cs index 045bbc813f2..ee198302462 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Secp256r1Precompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Secp256r1Precompile.cs @@ -17,6 +17,8 @@ public class Secp256r1Precompile : IPrecompile public static readonly Secp256r1Precompile Instance = new(); public static Address Address { get; } = Address.FromNumber(0x100); + public static string Name => "P256VERIFY"; + public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip7951Enabled ? 6900L : 3450L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Sha256Precompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Sha256Precompile.cs index 019bf6e26c8..5954820a265 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Sha256Precompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Sha256Precompile.cs @@ -20,6 +20,8 @@ private Sha256Precompile() public static Address Address { get; } = Address.FromNumber(2); + public static string Name => "SHA256"; + public long BaseGasCost(IReleaseSpec releaseSpec) => 60L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs index ea6fd404694..49c2e368906 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs @@ -18,6 +18,8 @@ public class Bn254AddPrecompile : IPrecompile public static Address Address { get; } = Address.FromNumber(6); + public static string Name => "BN256_ADD"; + public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip1108Enabled ? 150L : 500L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs index 92ba6ba5ed5..4634c877b80 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs @@ -18,6 +18,8 @@ public class Bn254MulPrecompile : IPrecompile public static Address Address { get; } = Address.FromNumber(7); + public static string Name => "BN256_MUL"; + public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip1108Enabled ? 6000L : 40000L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs index 541957ad683..9a1073103fb 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs @@ -22,6 +22,8 @@ public class Bn254PairingPrecompile : IPrecompile public static Address Address { get; } = Address.FromNumber(8); + public static string Name => "BN256_PAIRING"; + public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip1108Enabled ? 45000L : 100000L; public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => (releaseSpec.IsEip1108Enabled ? 34000L : 80000L) * (inputData.Length / PairSize); diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/IPrecompile.cs b/src/Nethermind/Nethermind.Evm/Precompiles/IPrecompile.cs index 55536651958..945cd177de1 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/IPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm/Precompiles/IPrecompile.cs @@ -10,6 +10,7 @@ namespace Nethermind.Evm.Precompiles public interface IPrecompile { static virtual Address Address => Address.Zero; + static virtual string Name => ""; long BaseGasCost(IReleaseSpec releaseSpec); diff --git a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs index fc00eaafe64..31e5bf34e9a 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs @@ -1,64 +1,32 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only -using System.Threading.Tasks; using Autofac; using BenchmarkDotNet.Attributes; using Nethermind.Api; using Nethermind.Blockchain; -using Nethermind.Blockchain.BeaconBlockRoot; -using Nethermind.Blockchain.Blocks; -using Nethermind.Blockchain.Filters; using Nethermind.Blockchain.Find; -using Nethermind.Blockchain.Headers; using Nethermind.Blockchain.Receipts; using Nethermind.Blockchain.Tracing; using Nethermind.Consensus.Processing; -using Nethermind.Consensus.Rewards; -using Nethermind.Consensus.Validators; using Nethermind.Core; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; using Nethermind.Specs; using Nethermind.Core.Test.Builders; -using Nethermind.Crypto; -using Nethermind.Db; -using Nethermind.Evm; using Nethermind.Evm.State; -using Nethermind.Evm.Tracing; using Nethermind.Facade; using Nethermind.JsonRpc.Modules.Eth; using Nethermind.Logging; using Nethermind.State; -using Nethermind.State.Repositories; -using Nethermind.Db.Blooms; -using Nethermind.Evm.TransactionProcessing; using Nethermind.Facade.Eth; using Nethermind.JsonRpc.Modules.Eth.FeeHistory; using Nethermind.JsonRpc.Modules.Eth.GasPrice; -using Nethermind.Trie.Pruning; using Nethermind.TxPool; using Nethermind.Wallet; -using BlockTree = Nethermind.Blockchain.BlockTree; -using Nethermind.Blockchain.Synchronization; using Nethermind.Config; -using Nethermind.Consensus.ExecutionRequests; -using Nethermind.Consensus; -using Nethermind.Consensus.Scheduler; -using Nethermind.Consensus.Withdrawals; -using Nethermind.Core.Test; using Nethermind.Core.Test.Modules; -using Nethermind.Facade.Find; -using Nethermind.Facade.Simulate; using Nethermind.Network; -using Nethermind.Network.Config; -using Nethermind.Network.P2P.Subprotocols.Eth; -using Nethermind.Network.Rlpx; -using Nethermind.Stats; -using Nethermind.Synchronization; -using Nethermind.Synchronization.ParallelSync; -using Nethermind.Synchronization.Peers; -using NSubstitute; namespace Nethermind.JsonRpc.Benchmark { @@ -112,6 +80,7 @@ public void GlobalSetup() _container.Resolve(), feeHistoryOracle, _container.Resolve(), + _container.Resolve(), new BlocksConfig().SecondsPerSlot); } diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/BoundedModulePoolTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/BoundedModulePoolTests.cs index f61e0aad47d..11e1e43e21e 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/BoundedModulePoolTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/BoundedModulePoolTests.cs @@ -55,7 +55,8 @@ public Task Initialize() Substitute.For(), Substitute.For(), Substitute.For(), - new BlocksConfig()), + new BlocksConfig(), + Substitute.For()), 1, 1000); return Task.CompletedTask; diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/SingletonModulePoolTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/SingletonModulePoolTests.cs index ad8a951819d..cde82c8033a 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/SingletonModulePoolTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/SingletonModulePoolTests.cs @@ -54,7 +54,8 @@ public Task Initialize() Substitute.For(), Substitute.For(), Substitute.For(), - new BlocksConfig()); + new BlocksConfig(), + Substitute.For()); return Task.CompletedTask; } diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TestRpcBlockchain.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TestRpcBlockchain.cs index 315ef62c37f..e9c169c2d31 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TestRpcBlockchain.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TestRpcBlockchain.cs @@ -200,6 +200,7 @@ public async Task Build(Action configurer) @this.FeeHistoryOracle ?? new FeeHistoryOracle(@this.BlockTree, @this.ReceiptStorage, @this.SpecProvider), @this.ProtocolsManager, + @this.ForkInfo, @this.BlocksConfig.SecondsPerSlot); protected override async Task Build(Action? configurer = null) diff --git a/src/Nethermind/Nethermind.JsonRpc/Data/EthConfigResult.cs b/src/Nethermind/Nethermind.JsonRpc/Data/EthConfigResult.cs new file mode 100644 index 00000000000..5f5b6407043 --- /dev/null +++ b/src/Nethermind/Nethermind.JsonRpc/Data/EthConfigResult.cs @@ -0,0 +1,37 @@ +using System.Collections.Generic; +using System.Text.Json.Nodes; +using Nethermind.Core; + +namespace Nethermind.JsonRpc.Data; + +public class EthConfig +{ + public required JsonNode Current { get; init; } + public required ulong CurrentHash { get; init; } + public required byte[] CurrentForkId { get; init; } + + public required JsonNode? Next { get; init; } + public required ulong? NextHash { get; init; } + public required byte[]? NextForkId { get; init; } + + public required JsonNode? Last { get; init; } + public required ulong? LastHash { get; init; } + public required byte[]? LastForkId { get; init; } +} + +public class ForkConfig +{ + public int? ActivationTime { get; init; } + public int? ActivationBlock { get; init; } + public required BlobScheduleSettingsForRpc? BlobSchedule { get; init; } + public required ulong ChainId { get; init; } + public required OrderedDictionary Precompiles { get; init; } + public required OrderedDictionary SystemContracts { get; init; } +} + +public class BlobScheduleSettingsForRpc +{ + public required int BaseFeeUpdateFraction { get; init; } + public required int Max { get; init; } + public required int Target { get; init; } +} diff --git a/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthModuleFactory.cs b/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthModuleFactory.cs index 4b499c9e599..d5b6001e4aa 100644 --- a/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthModuleFactory.cs +++ b/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthModuleFactory.cs @@ -32,7 +32,8 @@ public class EthModuleFactory( IEthSyncingInfo ethSyncingInfo, IFeeHistoryOracle feeHistoryOracle, IProtocolsManager protocolsManager, - IBlocksConfig blocksConfig) + IBlocksConfig blocksConfig, + IForkInfo forkInfo) : ModuleFactoryBase { private readonly ulong _secondsPerSlot = blocksConfig.SecondsPerSlot; @@ -55,6 +56,7 @@ public override IEthRpcModule Create() ethSyncingInfo, feeHistoryOracle, protocolsManager, + forkInfo, _secondsPerSlot); } } diff --git a/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthRpcModule.cs b/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthRpcModule.cs index c12d642192c..a95cef44870 100644 --- a/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthRpcModule.cs +++ b/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthRpcModule.cs @@ -3,12 +3,17 @@ using System; using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Security; using System.Text; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Text.RegularExpressions; using System.Threading; using System.Threading.Tasks; using DotNetty.Buffers; +using Force.Crc32; using Nethermind.Blockchain.Filters; using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; @@ -18,6 +23,7 @@ using Nethermind.Core.Extensions; using Nethermind.Core.Specs; using Nethermind.Evm; +using Nethermind.Evm.Precompiles; using Nethermind.Facade; using Nethermind.Facade.Eth; using Nethermind.Facade.Eth.RpcTransaction; @@ -31,6 +37,7 @@ using Nethermind.Logging; using Nethermind.Network; using Nethermind.Network.Contract.P2P; +using Nethermind.Serialization.Json; using Nethermind.Serialization.Rlp; using Nethermind.State; using Nethermind.State.Proofs; @@ -61,6 +68,7 @@ public partial class EthRpcModule( IEthSyncingInfo ethSyncingInfo, IFeeHistoryOracle feeHistoryOracle, IProtocolsManager protocolsManager, + IForkInfo forkInfo, ulong? secondsPerSlot) : IEthRpcModule { protected readonly Encoding _messageEncoding = Encoding.UTF8; @@ -79,6 +87,7 @@ public partial class EthRpcModule( protected readonly IFeeHistoryOracle _feeHistoryOracle = feeHistoryOracle ?? throw new ArgumentNullException(nameof(feeHistoryOracle)); protected readonly IProtocolsManager _protocolsManager = protocolsManager ?? throw new ArgumentNullException(nameof(protocolsManager)); protected readonly ulong _secondsPerSlot = secondsPerSlot ?? throw new ArgumentNullException(nameof(secondsPerSlot)); + readonly JsonSerializerOptions UnchangedDictionaryKeyOptions = new(EthereumJsonSerializer.JsonOptionsIndented) { DictionaryKeyPolicy = null }; public ResultWrapper eth_protocolVersion() { @@ -772,6 +781,65 @@ private ResultWrapper GetStateFailureResult(BlockHeader header }; } + public ResultWrapper eth_config() + { + ForkActivationsSummary forks = forkInfo.GetForkActivationsSummary(_blockFinder.Head?.Header); + + ForkConfig current = GetForkConfig(forks.Current, _specProvider); + ForkConfig? next = GetForkConfig(forks.Next, _specProvider); + ForkConfig? last = GetForkConfig(forks.Last, _specProvider); + + string serializedCurrent = JsonSerializer.Serialize(current, UnchangedDictionaryKeyOptions); + string? serializedNext = next is null ? null : JsonSerializer.Serialize(next, UnchangedDictionaryKeyOptions); + string? serializedLast = last is null ? null : JsonSerializer.Serialize(last, UnchangedDictionaryKeyOptions); + + return ResultWrapper.Success(new EthConfig + { + Current = JsonNode.Parse(serializedCurrent)!, + CurrentHash = GetCrc32FromJson(serializedCurrent).Value, + CurrentForkId = forks.CurrentForkId.HashBytes, + + Next = serializedNext is null ? null : JsonNode.Parse(serializedNext), + NextHash = GetCrc32FromJson(serializedNext), + NextForkId = forks.NextForkId?.HashBytes, + + Last = serializedLast is null ? null : JsonNode.Parse(serializedLast), + LastHash = GetCrc32FromJson(serializedLast), + LastForkId = forks.LastForkId?.HashBytes, + }); + + [return: NotNullIfNotNull(nameof(json))] + static uint? GetCrc32FromJson(string? json) => json is null ? null : Crc32Algorithm.Compute(Encoding.UTF8.GetBytes(RemoveWhitespace().Replace(json, ""))); + + static ForkConfig? GetForkConfig(ForkActivation? forkActivation, ISpecProvider specProvider) + { + if (forkActivation is null) + { + return null; + } + + IReleaseSpec? spec = specProvider.GetSpec(forkActivation.Value.BlockNumber, forkActivation.Value.Timestamp); + + return new ForkConfig + { + ActivationTime = forkActivation.Value.Timestamp is not null ? (int)forkActivation.Value.Timestamp : null, + ActivationBlock = forkActivation.Value.Timestamp is null ? (int)forkActivation.Value.BlockNumber : null, + BlobSchedule = spec.IsEip4844Enabled ? new BlobScheduleSettingsForRpc + { + BaseFeeUpdateFraction = (int)spec.BlobBaseFeeUpdateFraction, + Max = (int)spec.MaxBlobCount, + Target = (int)spec.TargetBlobCount, + } : null, + ChainId = specProvider.ChainId, + Precompiles = spec.ListPrecompiles(), + SystemContracts = spec.ListSystemContracts(), + }; + } + } + private CancellationTokenSource BuildTimeoutCancellationTokenSource() => _rpcConfig.BuildTimeoutCancellationToken(); + + [GeneratedRegex("\\s", RegexOptions.Compiled)] + private static partial Regex RemoveWhitespace(); } diff --git a/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/IEthRpcModule.cs b/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/IEthRpcModule.cs index a64170158db..f700581e4a3 100644 --- a/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/IEthRpcModule.cs +++ b/src/Nethermind/Nethermind.JsonRpc/Modules/Eth/IEthRpcModule.cs @@ -284,5 +284,8 @@ ResultWrapper eth_getTransactionByBlockNumberAndIndex( [JsonRpcMethod(IsImplemented = true, Description = "Retrieves Accounts via Address and Blocknumber", IsSharable = true)] ResultWrapper eth_getAccount([JsonRpcParameter(ExampleValue = "[\"0xaa00000000000000000000000000000000000000\", \"latest\"]")] Address accountAddress, BlockParameter? blockParameter = null); + + [JsonRpcMethod(IsImplemented = true, Description = "Provides configuration data for the current and next fork", IsSharable = true)] + ResultWrapper eth_config(); } } diff --git a/src/Nethermind/Nethermind.Network/ForkInfo.cs b/src/Nethermind/Nethermind.Network/ForkInfo.cs index db2eda1e451..f47393f515c 100644 --- a/src/Nethermind/Nethermind.Network/ForkInfo.cs +++ b/src/Nethermind/Nethermind.Network/ForkInfo.cs @@ -1,12 +1,6 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only -using System; -using System.Buffers.Binary; -using System.Collections.Generic; -using System.Numerics; -using System.Runtime.CompilerServices; -using System.Threading; using Force.Crc32; using Nethermind.Core; using Nethermind.Core.Collections; @@ -14,6 +8,12 @@ using Nethermind.Core.Specs; using Nethermind.Specs; using Nethermind.Synchronization; +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Threading; namespace Nethermind.Network { @@ -138,5 +138,44 @@ public ValidationResult ValidateForkId(ForkId peerId, BlockHeader? head) return ValidationResult.Valid; } + + public ForkActivationsSummary GetForkActivationsSummary(BlockHeader? head) + { + ForkActivation headActivation = new(head?.Number ?? 0, head.Number == 0 ? 0 : head?.Timestamp ?? 0); + + int indexOfActive = 0; + for (; indexOfActive < Forks.Length; indexOfActive++) + { + ForkActivation fork = Forks[indexOfActive].Activation; + + if (fork.Timestamp.HasValue ? fork.Timestamp >= headActivation.Timestamp : + fork.BlockNumber >= headActivation.BlockNumber) + { + break; + } + } + + bool isNextPresent = indexOfActive < Forks.Length - 1; + + // The fix for post-merge genesis + ForkActivation currentForkActivation = Forks[indexOfActive].Activation; + + if (currentForkActivation.BlockNumber is 0) + { + currentForkActivation = new ForkActivation(0, 0); + } + + return new ForkActivationsSummary + { + Current = currentForkActivation, + CurrentForkId = Forks[indexOfActive].Id, + + Next = isNextPresent ? Forks[indexOfActive + 1].Activation : null, + NextForkId = isNextPresent ? Forks[indexOfActive + 1].Id : null, + + Last = isNextPresent ? Forks[^1].Activation : null, + LastForkId = isNextPresent ? Forks[^1].Id : null, + }; + } } } diff --git a/src/Nethermind/Nethermind.Network/IForkInfo.cs b/src/Nethermind/Nethermind.Network/IForkInfo.cs index 4b13c1b4bcb..89988e75902 100644 --- a/src/Nethermind/Nethermind.Network/IForkInfo.cs +++ b/src/Nethermind/Nethermind.Network/IForkInfo.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Core; +using Nethermind.Core.Specs; namespace Nethermind.Network; @@ -16,4 +17,16 @@ public interface IForkInfo /// /// ValidationResult ValidateForkId(ForkId peerId, BlockHeader? head); + + ForkActivationsSummary GetForkActivationsSummary(BlockHeader? head); +} + +public readonly ref struct ForkActivationsSummary +{ + public ForkActivation Current { get; init; } + public ForkId CurrentForkId { get; init; } + public ForkActivation? Next { get; init; } + public ForkId? NextForkId { get; init; } + public ForkActivation? Last { get; init; } + public ForkId? LastForkId { get; init; } } diff --git a/src/Nethermind/Nethermind.Optimism.Test/Rpc/OptimismEthRpcModuleTest.cs b/src/Nethermind/Nethermind.Optimism.Test/Rpc/OptimismEthRpcModuleTest.cs index c6e7949b38b..a5e62b6887c 100644 --- a/src/Nethermind/Nethermind.Optimism.Test/Rpc/OptimismEthRpcModuleTest.cs +++ b/src/Nethermind/Nethermind.Optimism.Test/Rpc/OptimismEthRpcModuleTest.cs @@ -555,6 +555,7 @@ public static TestRpcBlockchain.Builder WithOptimismEthRpcMod blockchain.FeeHistoryOracle ?? new FeeHistoryOracle(blockchain.BlockTree, blockchain.ReceiptStorage, blockchain.SpecProvider), blockchain.ProtocolsManager, + blockchain.ForkInfo, new BlocksConfig().SecondsPerSlot, sequencerRpcClient, ecdsa, sealer, opSpecHelper diff --git a/src/Nethermind/Nethermind.Optimism/Rpc/OptimismEthModuleFactory.cs b/src/Nethermind/Nethermind.Optimism/Rpc/OptimismEthModuleFactory.cs index 9ae3cf8f69a..aa6db5df906 100644 --- a/src/Nethermind/Nethermind.Optimism/Rpc/OptimismEthModuleFactory.cs +++ b/src/Nethermind/Nethermind.Optimism/Rpc/OptimismEthModuleFactory.cs @@ -43,6 +43,7 @@ public class OptimismEthModuleFactory : ModuleFactoryBase private readonly IReceiptFinder _receiptFinder; private readonly IOptimismSpecHelper _opSpecHelper; private readonly IProtocolsManager _protocolsManager; + private readonly IForkInfo _forkInfo; private readonly ulong? _secondsPerSlot; private readonly IJsonRpcClient? _sequencerRpcClient; @@ -60,6 +61,7 @@ public OptimismEthModuleFactory(IJsonRpcConfig rpcConfig, IEthSyncingInfo ethSyncingInfo, IFeeHistoryOracle feeHistoryOracle, IProtocolsManager protocolsManager, + IForkInfo forkInfo, IBlocksConfig blocksConfig, IEthereumEcdsa ecdsa, IOptimismSpecHelper opSpecHelper, @@ -85,7 +87,7 @@ ITimestamper timestamper _receiptFinder = receiptFinder; _opSpecHelper = opSpecHelper; _protocolsManager = protocolsManager; - + _forkInfo = forkInfo; ILogger logger = logManager.GetClassLogger(); if (config.SequencerUrl is null && logger.IsWarn) { @@ -119,6 +121,7 @@ public override IOptimismEthRpcModule Create() _ethSyncingInfo, _feeHistoryOracle, _protocolsManager, + _forkInfo, _secondsPerSlot, _sequencerRpcClient, diff --git a/src/Nethermind/Nethermind.Optimism/Rpc/OptimismEthRpcModule.cs b/src/Nethermind/Nethermind.Optimism/Rpc/OptimismEthRpcModule.cs index b74f1fbaa5c..11edf540823 100644 --- a/src/Nethermind/Nethermind.Optimism/Rpc/OptimismEthRpcModule.cs +++ b/src/Nethermind/Nethermind.Optimism/Rpc/OptimismEthRpcModule.cs @@ -54,6 +54,7 @@ public OptimismEthRpcModule( IEthSyncingInfo ethSyncingInfo, IFeeHistoryOracle feeHistoryOracle, IProtocolsManager protocolsManager, + IForkInfo forkInfo, ulong? secondsPerSlot, IJsonRpcClient? sequencerRpcClient, @@ -74,6 +75,7 @@ public OptimismEthRpcModule( ethSyncingInfo, feeHistoryOracle, protocolsManager, + forkInfo, secondsPerSlot) { _sequencerRpcClient = sequencerRpcClient; From 9864df97f80c0e65fd92898e94ccebd838582918 Mon Sep 17 00:00:00 2001 From: Ruben Buniatyan Date: Thu, 17 Jul 2025 01:09:33 +0200 Subject: [PATCH 24/40] Replace `eth_pairings` with `mcl` (#8992) --- Directory.Packages.props | 2 +- nuget.config | 6 +- .../EthereumCodeInfoRepository.cs | 7 +- .../Nethermind.Evm.Precompiles/BN254.cs | 202 ++++++++++++++++++ .../BN254AddPrecompile.cs | 36 ++++ .../BN254MulPrecompile.cs | 36 ++++ .../BN254PairingPrecompile.cs | 50 +++++ .../Nethermind.Evm.Precompiles/Extensions.cs | 16 +- .../Nethermind.Evm.Precompiles.csproj | 2 +- .../Snarks/Bn254AddPrecompile.cs | 45 ---- .../Snarks/Bn254MulPrecompile.cs | 45 ---- .../Snarks/Bn254PairingPrecompile.cs | 66 ------ .../BN254AddPrecompileTests.cs | 34 +++ .../BN254MulPrecompileTests.cs | 34 +++ .../BN254PairingPrecompileTests.cs | 67 ++++++ .../BnAddPrecompileTests.cs | 37 ---- .../BnMulPrecompileTests.cs | 37 ---- .../BnPairPrecompileTests.cs | 68 ------ .../Nethermind.Evm.Test/Eip1108Tests.cs | 14 +- .../Nethermind.Evm/Nethermind.Evm.csproj | 6 - .../Nethermind.Evm/Precompiles/IPrecompile.cs | 2 +- ...54AddBenchmark.cs => BN254AddBenchmark.cs} | 5 +- ...54MulBenchmark.cs => BN254MulBenchmark.cs} | 5 +- ...gBenchmark.cs => BN254PairingBenchmark.cs} | 5 +- 24 files changed, 485 insertions(+), 342 deletions(-) create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/BN254.cs create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/BN254AddPrecompile.cs create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/BN254MulPrecompile.cs create mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/BN254PairingPrecompile.cs delete mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs delete mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs delete mode 100644 src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs create mode 100644 src/Nethermind/Nethermind.Evm.Test/BN254AddPrecompileTests.cs create mode 100644 src/Nethermind/Nethermind.Evm.Test/BN254MulPrecompileTests.cs create mode 100644 src/Nethermind/Nethermind.Evm.Test/BN254PairingPrecompileTests.cs delete mode 100644 src/Nethermind/Nethermind.Evm.Test/BnAddPrecompileTests.cs delete mode 100644 src/Nethermind/Nethermind.Evm.Test/BnMulPrecompileTests.cs delete mode 100644 src/Nethermind/Nethermind.Evm.Test/BnPairPrecompileTests.cs rename src/Nethermind/Nethermind.Precompiles.Benchmark/{Bn254AddBenchmark.cs => BN254AddBenchmark.cs} (72%) rename src/Nethermind/Nethermind.Precompiles.Benchmark/{Bn254MulBenchmark.cs => BN254MulBenchmark.cs} (72%) rename src/Nethermind/Nethermind.Precompiles.Benchmark/{Bn254PairingBenchmark.cs => BN254PairingBenchmark.cs} (71%) diff --git a/Directory.Packages.props b/Directory.Packages.props index 0097776ea5e..a60579e6ca5 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -48,7 +48,6 @@ - @@ -57,6 +56,7 @@ + diff --git a/nuget.config b/nuget.config index 9c3244f50fa..647f42894be 100644 --- a/nuget.config +++ b/nuget.config @@ -3,14 +3,14 @@ - + - + --> diff --git a/src/Nethermind/Nethermind.Blockchain/EthereumCodeInfoRepository.cs b/src/Nethermind/Nethermind.Blockchain/EthereumCodeInfoRepository.cs index 35b95c86d5e..c306c6abab4 100644 --- a/src/Nethermind/Nethermind.Blockchain/EthereumCodeInfoRepository.cs +++ b/src/Nethermind/Nethermind.Blockchain/EthereumCodeInfoRepository.cs @@ -8,7 +8,6 @@ using Nethermind.Evm.CodeAnalysis; using Nethermind.Evm.Precompiles; using Nethermind.Evm.Precompiles.Bls; -using Nethermind.Evm.Precompiles.Snarks; using Nethermind.State; namespace Nethermind.Blockchain; @@ -26,9 +25,9 @@ private static FrozenDictionary Precompiles [Ripemd160Precompile.Address] = new(Ripemd160Precompile.Instance), [IdentityPrecompile.Address] = new(IdentityPrecompile.Instance), - [Bn254AddPrecompile.Address] = new(Bn254AddPrecompile.Instance), - [Bn254MulPrecompile.Address] = new(Bn254MulPrecompile.Instance), - [Bn254PairingPrecompile.Address] = new(Bn254PairingPrecompile.Instance), + [BN254AddPrecompile.Address] = new(BN254AddPrecompile.Instance), + [BN254MulPrecompile.Address] = new(BN254MulPrecompile.Instance), + [BN254PairingPrecompile.Address] = new(BN254PairingPrecompile.Instance), [ModExpPrecompile.Address] = new(ModExpPrecompile.Instance), [Blake2FPrecompile.Address] = new(Blake2FPrecompile.Instance), diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/BN254.cs b/src/Nethermind/Nethermind.Evm.Precompiles/BN254.cs new file mode 100644 index 00000000000..a6cfd587f8d --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/BN254.cs @@ -0,0 +1,202 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Runtime.CompilerServices; +using Nethermind.MclBindings; + +namespace Nethermind.Evm.Precompiles; + +using static Mcl; + +[SkipLocalsInit] +internal static unsafe class BN254 +{ + internal const int PairSize = 192; + + static BN254() + { + if (mclBn_init(MCL_BN_SNARK1, MCLBN_COMPILED_TIME_VAR) != 0) + throw new InvalidOperationException("MCL initialization failed"); + } + + internal static bool Add(Span input, Span output) + { + if (input.Length != 128) + return false; + + if (!DeserializeG1(input[0..64], out mclBnG1 x)) + return false; + + if (!DeserializeG1(input[64..128], out mclBnG1 y)) + return false; + + mclBnG1_add(ref x, x, y); // x += y + mclBnG1_normalize(ref x, x); + + return SerializeG1(x, output); + } + + internal static bool Mul(Span input, Span output) + { + if (input.Length != 96) + return false; + + if (!DeserializeG1(input[0..64], out mclBnG1 x)) + return false; + + Span yData = input[64..]; + yData.Reverse(); // To little-endian + + mclBnFr y = default; + + fixed (byte* ptr = yData) + { + if (mclBnFr_setLittleEndianMod(ref y, (nint)ptr, 32) == -1 || mclBnFr_isValid(y) == 0) + return false; + } + + mclBnG1_mul(ref x, x, y); // x *= y + mclBnG1_normalize(ref x, x); + + return SerializeG1(x, output); + } + + internal static bool CheckPairing(Span input, Span output) + { + if (input.Length == 0) + { + output[31] = 1; + return true; + } + + if (input.Length % PairSize != 0) + return false; + + mclBnGT gt = default; + Unsafe.SkipInit(out mclBnGT previous); + var hasPrevious = false; + + for (int i = 0, count = input.Length; i < count; i += PairSize) + { + var i64 = i + 64; + + if (!DeserializeG1(input[i..i64], out mclBnG1 g1)) + return false; + + if (!DeserializeG2(input[i64..(i64 + 128)], out mclBnG2 g2)) + return false; + + if (mclBnG1_isZero(g1) == 1 || mclBnG2_isZero(g2) == 1) + continue; + + mclBn_pairing(ref gt, g1, g2); + + // Skip multiplication for the first pairing as there's no previous result + if (hasPrevious) + mclBnGT_mul(ref gt, gt, previous); // gt *= previous + + previous = gt; + hasPrevious = true; + } + + // If gt is zero, then no pairing was computed, and it's considered valid + if (mclBnGT_isOne(gt) == 1 || mclBnGT_isZero(gt) == 1) + { + output[31] = 1; + return true; + } + + return mclBnGT_isValid(gt) == 1; + } + + private static bool DeserializeG1(Span data, out mclBnG1 point) + { + point = default; + + // Check for all-zero data + if (data.IndexOfAnyExcept((byte)0) == -1) + return true; + + Span x = data[0..32]; + x.Reverse(); // To little-endian + + fixed (byte* ptr = x) + mclBnFp_setLittleEndian(ref point.x, (nint)ptr, 32); + + Span y = data[32..64]; + y.Reverse(); // To little-endian + + fixed (byte* ptr = y) + mclBnFp_setLittleEndian(ref point.y, (nint)ptr, 32); + + mclBnFp_setInt32(ref point.z, 1); + + return mclBnG1_isValid(point) == 1; + } + + private static bool DeserializeG2(Span data, out mclBnG2 point) + { + point = default; + + // Check for all-zero data + if (data.IndexOfAnyExcept((byte)0) == -1) + return true; + + Span x0 = data[32..64]; + Span x1 = data[0..32]; + x0.Reverse(); // To little-endian + x1.Reverse(); // To little-endian + + fixed (byte* ptr0 = x0) + fixed (byte* ptr1 = x1) + { + mclBnFp_setLittleEndian(ref point.x.d0, (nint)ptr0, 32); + mclBnFp_setLittleEndian(ref point.x.d1, (nint)ptr1, 32); + } + + Span y0 = data[96..128]; + Span y1 = data[64..96]; + y0.Reverse(); // To little-endian + y1.Reverse(); // To little-endian + + fixed (byte* ptr0 = y0) + fixed (byte* ptr1 = y1) + { + mclBnFp_setLittleEndian(ref point.y.d0, (nint)ptr0, 32); + mclBnFp_setLittleEndian(ref point.y.d1, (nint)ptr1, 32); + } + + mclBnFp_setInt32(ref point.z.d0, 1); + + return mclBnG2_isValid(point) == 1 && mclBnG2_isValidOrder(point) == 1; + } + + private static bool SerializeG1(in mclBnG1 point, Span output) + { + Span x = output[0..32]; + + fixed (byte* ptr = x) + { + var length = mclBnFp_getLittleEndian((nint)ptr, 32, point.x); + + if (length == nuint.Zero) + return false; + } + + Span y = output[32..64]; + + fixed (byte* ptr = y) + { + var length = mclBnFp_getLittleEndian((nint)ptr, 32, point.y); + + if (length == nuint.Zero) + return false; + } + + x.Reverse(); // To big-endian + y.Reverse(); // To big-endian + + return true; + } +} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/BN254AddPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/BN254AddPrecompile.cs new file mode 100644 index 00000000000..0d7ee731e6d --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/BN254AddPrecompile.cs @@ -0,0 +1,36 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using Nethermind.Core; +using Nethermind.Core.Specs; + +namespace Nethermind.Evm.Precompiles; + +/// +public class BN254AddPrecompile : IPrecompile +{ + public static readonly BN254AddPrecompile Instance = new(); + + public static Address Address { get; } = Address.FromNumber(6); + + /// + public static string Name => "BN256_ADD"; + + /// + public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip1108Enabled ? 150L : 500L; + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + Metrics.Bn254AddPrecompile++; + + Span input = stackalloc byte[128]; + Span output = stackalloc byte[64]; + + inputData.Span[0..Math.Min(inputData.Length, input.Length)].CopyTo(input); + + return BN254.Add(input, output) ? (output.ToArray(), true) : IPrecompile.Failure; + } +} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/BN254MulPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/BN254MulPrecompile.cs new file mode 100644 index 00000000000..3baddb95bf3 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/BN254MulPrecompile.cs @@ -0,0 +1,36 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using Nethermind.Core; +using Nethermind.Core.Specs; + +namespace Nethermind.Evm.Precompiles; + +/// +public class BN254MulPrecompile : IPrecompile +{ + public static readonly BN254MulPrecompile Instance = new(); + + public static Address Address { get; } = Address.FromNumber(7); + + /// + public static string Name => "BN256_MUL"; + + /// + public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip1108Enabled ? 6_000L : 40_000L; + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + Metrics.Bn254MulPrecompile++; + + Span input = stackalloc byte[96]; + Span output = stackalloc byte[64]; + + inputData.Span[0..Math.Min(inputData.Length, input.Length)].CopyTo(input); + + return BN254.Mul(input, output) ? (output.ToArray(), true) : IPrecompile.Failure; + } +} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/BN254PairingPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/BN254PairingPrecompile.cs new file mode 100644 index 00000000000..713c280a1e6 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Precompiles/BN254PairingPrecompile.cs @@ -0,0 +1,50 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Buffers; +using Nethermind.Core; +using Nethermind.Core.Specs; + +namespace Nethermind.Evm.Precompiles; + +/// +public class BN254PairingPrecompile : IPrecompile +{ + private const int PairingMaxInputSizeGranite = 112_687; + + public static readonly BN254PairingPrecompile Instance = new(); + + public static Address Address { get; } = Address.FromNumber(8); + + /// + public static string Name => "BN256_PAIRING"; + + /// + public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip1108Enabled ? 45_000L : 100_000L; + + public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => + (releaseSpec.IsEip1108Enabled ? 34_000L : 80_000L) * (inputData.Length / BN254.PairSize); + + public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + { + Metrics.Bn254PairingPrecompile++; + + if (releaseSpec.IsOpGraniteEnabled && inputData.Length > PairingMaxInputSizeGranite || + inputData.Length % BN254.PairSize > 0) + { + return IPrecompile.Failure; + } + + var input = ArrayPool.Shared.Rent(inputData.Length); + Span output = stackalloc byte[32]; + + inputData.CopyTo(input); + + var result = BN254.CheckPairing(input.AsSpan(0, inputData.Length), output); + + ArrayPool.Shared.Return(input); + + return result ? (output.ToArray(), true) : IPrecompile.Failure; + } +} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs index 7e11eff53d5..b7b9b425d5b 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs @@ -1,23 +1,15 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Evm.Precompiles.Bls; -using Nethermind.Evm.Precompiles.Snarks; -using System; using System.Collections.Generic; namespace Nethermind.Evm.Precompiles; public static class Extensions { - public static void PrepareEthInput(this ReadOnlyMemory inputData, Span inputDataSpan) - { - inputData.Span[..Math.Min(inputDataSpan.Length, inputData.Length)] - .CopyTo(inputDataSpan[..Math.Min(inputDataSpan.Length, inputData.Length)]); - } - public static OrderedDictionary ListPrecompiles(this IReleaseSpec spec) { OrderedDictionary precompiles = []; @@ -34,9 +26,9 @@ public static OrderedDictionary ListPrecompiles(this IReleaseSp if (spec.Bn128Enabled) { - AddPrecompile(); - AddPrecompile(); - AddPrecompile(); + AddPrecompile(); + AddPrecompile(); + AddPrecompile(); } if (spec.BlakeEnabled) diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Nethermind.Evm.Precompiles.csproj b/src/Nethermind/Nethermind.Evm.Precompiles/Nethermind.Evm.Precompiles.csproj index 55e5375e5e4..88e8f0f7f18 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Nethermind.Evm.Precompiles.csproj +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Nethermind.Evm.Precompiles.csproj @@ -12,9 +12,9 @@ - + diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs deleted file mode 100644 index 49c2e368906..00000000000 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254AddPrecompile.cs +++ /dev/null @@ -1,45 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using Nethermind.Core; -using Nethermind.Core.Specs; -using Nethermind.Crypto; -using Nethermind.Evm.Precompiles; - -namespace Nethermind.Evm.Precompiles.Snarks; - -/// -/// https://github.com/matter-labs/eip1962/blob/master/eip196_header.h -/// -public class Bn254AddPrecompile : IPrecompile -{ - public static readonly Bn254AddPrecompile Instance = new(); - - public static Address Address { get; } = Address.FromNumber(6); - - public static string Name => "BN256_ADD"; - - public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip1108Enabled ? 150L : 500L; - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; - - public unsafe (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - Metrics.Bn254AddPrecompile++; - return inputData.Length == 128 ? RunInternal(inputData.Span) : RunInternal(inputData); - } - - private static (byte[], bool) RunInternal(ReadOnlyMemory inputData) - { - Span inputDataSpan = stackalloc byte[128]; - inputData.PrepareEthInput(inputDataSpan); - return RunInternal(inputDataSpan); - } - - private static (byte[], bool) RunInternal(ReadOnlySpan inputDataSpan) - { - byte[] output = GC.AllocateUninitializedArray(64); - return Pairings.Bn254Add(inputDataSpan, output) ? (output, true) : IPrecompile.Failure; - } -} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs deleted file mode 100644 index 4634c877b80..00000000000 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254MulPrecompile.cs +++ /dev/null @@ -1,45 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using Nethermind.Core; -using Nethermind.Core.Specs; -using Nethermind.Crypto; -using Nethermind.Evm.Precompiles; - -namespace Nethermind.Evm.Precompiles.Snarks; - -/// -/// https://github.com/herumi/mcl/blob/master/api.md -/// -public class Bn254MulPrecompile : IPrecompile -{ - public static readonly Bn254MulPrecompile Instance = new(); - - public static Address Address { get; } = Address.FromNumber(7); - - public static string Name => "BN256_MUL"; - - public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip1108Enabled ? 6000L : 40000L; - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => 0L; - - public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - Metrics.Bn254MulPrecompile++; - return inputData.Length == 96 ? RunInternal(inputData.Span) : RunInternal(inputData); - } - - private static (byte[], bool) RunInternal(ReadOnlyMemory inputData) - { - Span inputDataSpan = stackalloc byte[96]; - inputData.PrepareEthInput(inputDataSpan); - return RunInternal(inputDataSpan); - } - - private static (byte[], bool) RunInternal(ReadOnlySpan inputDataSpan) - { - byte[] output = GC.AllocateUninitializedArray(64); - return Pairings.Bn254Mul(inputDataSpan, output) ? (output, true) : IPrecompile.Failure; - } -} diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs deleted file mode 100644 index 9a1073103fb..00000000000 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Snarks/Bn254PairingPrecompile.cs +++ /dev/null @@ -1,66 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using System.Buffers; -using Nethermind.Core; -using Nethermind.Core.Specs; -using Nethermind.Crypto; -using Nethermind.Evm.Precompiles; - -namespace Nethermind.Evm.Precompiles.Snarks; - -/// -/// https://github.com/herumi/mcl/blob/master/api.md -/// -public class Bn254PairingPrecompile : IPrecompile -{ - private const int Bn256PairingMaxInputSizeGranite = 112687; - private const int PairSize = 192; - - public static readonly Bn254PairingPrecompile Instance = new(); - - public static Address Address { get; } = Address.FromNumber(8); - - public static string Name => "BN256_PAIRING"; - - public long BaseGasCost(IReleaseSpec releaseSpec) => releaseSpec.IsEip1108Enabled ? 45000L : 100000L; - - public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) => (releaseSpec.IsEip1108Enabled ? 34000L : 80000L) * (inputData.Length / PairSize); - - public (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) - { - Metrics.Bn254PairingPrecompile++; - if (releaseSpec.IsOpGraniteEnabled && inputData.Length > Bn256PairingMaxInputSizeGranite) - { - return IPrecompile.Failure; - } - if (inputData.Length % PairSize > 0) - { - // note that it will not happen in case of null / 0 length - return IPrecompile.Failure; - } - - byte[] inputDataArray = ArrayPool.Shared.Rent(inputData.Length); - - /* we modify input in place here and this is save for EVM but not - safe in benchmarks so we need to remember to clone */ - Span output = stackalloc byte[64]; - Span inputDataSpanReshuffled = inputDataArray.AsSpan(0, inputData.Length); - ReadOnlySpan inputDataSpan = inputData.Span; - Span inputReshuffled = stackalloc byte[PairSize]; - for (int i = 0; i < inputData.Length / PairSize; i++) - { - inputDataSpan.Slice(i * PairSize + 0, 64).CopyTo(inputReshuffled[..64]); - inputDataSpan.Slice(i * PairSize + 64, 32).CopyTo(inputReshuffled.Slice(96, 32)); - inputDataSpan.Slice(i * PairSize + 96, 32).CopyTo(inputReshuffled.Slice(64, 32)); - inputDataSpan.Slice(i * PairSize + 128, 32).CopyTo(inputReshuffled.Slice(160, 32)); - inputDataSpan.Slice(i * PairSize + 160, 32).CopyTo(inputReshuffled.Slice(128, 32)); - inputReshuffled.CopyTo(inputDataSpanReshuffled.Slice(i * PairSize, PairSize)); - } - - bool result = Pairings.Bn254Pairing(inputDataSpanReshuffled, output); - ArrayPool.Shared.Return(inputDataArray); - return result ? (output[..32].ToArray(), true) : IPrecompile.Failure; - } -} diff --git a/src/Nethermind/Nethermind.Evm.Test/BN254AddPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BN254AddPrecompileTests.cs new file mode 100644 index 00000000000..0b4f408102f --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Test/BN254AddPrecompileTests.cs @@ -0,0 +1,34 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Evm.Precompiles; +using Nethermind.Specs.Forks; +using NUnit.Framework; +using System; + +namespace Nethermind.Evm.Test; + +public class BN254AddPrecompileTests +{ + [TestCase("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b3625f8c89ea3437f44f8fc8b6bfbb6312074dc6f983809a5e809ff4e1d076dd5850b38c7ced6e4daef9c4347f370d6d8b58f4b1d8dc61a3c59d651a0644a2a27cf", "0a6678fd675aa4d8f0d03a1feb921a27f38ebdcb860cc083653519655acd6d79172fd5b3b2bfdd44e43bcec3eace9347608f9f0a16f1e184cb3f52e6f259cbeb")] + [TestCase("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaa21315394462f1a39f87462dbceb92718b220e4f80af516f727ad85380fadefbc2e4f40ea7bbe2d4d71f13c84fd2ae24a4a24d9638dd78349d0dee8435a67cca6", "013f227997b410cbd96b137a114f5b12d5a3a53d7482797bcd1f116ff30ff1931effebc79dee208d036553beae8ca71afb3b4c00979560db3991c7e67c49103c")] + [TestCase("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774ba08ed1b33fe3cd3b1ac11571999e8f451f5bb28dd4019e58b8d24d91cf73dc38f11be2878bb118612a7627f022aa19a17b6eb599bba4185df357f81d052fff90b", "0e9e24a218333ed19a90051efabe246146a6d5017810140ef7e448030539038a230598b7d4127f5b4fd971820084c632ca940b29fcf30139cd1513bbbbf3a3dc")] + [TestCase("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa8071c35e297f7c55363cd2fd00d916c67fad3bdea15487bdc5cc7b720f3a2c8b776106c2a4cf61ab73f91f2258f1846b9be9d28b9a7e83503fa4f4b322bfc07223c", "22f8aa414eb0b9b296bed3fb355804e92ec0af419d9906335f50f032d87a8bf82643f41b228310b816c784c2c54dcfadeaa328b792dbe0d0e04741cd61dac155")] + [TestCase("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe571f752f85cf5cc01b2dfe279541032da61c2fcc8ae0dfc6d4253ba9b5d3c858231d03a84afe2a9f595ab03007400ccd36a2c0bc31203d881011dfc450c39b5abe", "1e51b9f09d8fc2e4ca11602326c2cfe191c6c6a47874526e80051197e9f6af842282e508ca489bf881e25cf9590151ff5cf94fa523683a0718d87abcc4d4a16f")] + [TestCase("0e6eab4103302750b22364bd1ec80e5edfb3ad06fa175ff2517ca49489f728e9050a17b5a594d0fd6fafed7fe5c447793fe9b617f0f97c3ee6dd29638f6c9232038de98419e242685862c118253ab7df7358f863a59170c37e606d5bd23c742f076ff3443f4e01b7d7ace1315fe50cf77c365d8d289c65303bcc11ba7961ab95", "2231ab2eee93d63596f718533ddbb95a86b13d39e1162897d791566e797f82952f39ea566bede8e7ba15f3c61b0e96275b2fc51800ee2baf2f9bd7acfa874f0a")] + [TestCase("1920c53c756f1ec1a40e0264e5f65808eafaeaa7b0885f89852297bc2186ac9d09416cc536a27b6d5616f74dd2bbbfb463b9961752e0aa38d47b5213994959ab015296293a5a1bb5e15a7d019787422cb3409e075e122c6fc5867f0c3f3715731782b870b6641d8d55323e27ebaea17909499877fda62e3ac1e2b2310cad5f9c", "0fa3236565b78b283f3ce63ca62bafb87c33407b11a077e39230ff37c054cf712a38174368bf872f80f78fb5222e95717183242b9d4da75c66243f043aed2fc5")] + [TestCase("001faaf97b965ffa633612b7c8f9f4be0b286b19662e5cbe6878019d8ba1382b16567ced7a7ee5c272bbc378a95c2436fb0c6133649c77e55a708b28419b5cac0750d51706ced69621c8e4ba1758ba90c39ba8b3b50507bfa545ace1737e360e283d609cd67a291fc3d720c5b1113eececba4ca31d58a1319d6a5a2fa89608f9", "044fe3c480840e5a8f544efd28a8bf3246f0741a8c61c3116e93d84773399c8b26c5b695120cd724aa2a5f4dfd3042c07f752be4c4a8b750398109d80f4772eb")] + [TestCase("128b65cb80257f3006fc20dbb6af6781da7e0f9213d2b909fd113ee0f2d2bb52251e288387db7be742fe67261f36a4f09eeb4763bbbaa1bb13af3dec65302a4115f64edf27478045bf45eded285544acaa7f2b3a2a36176acefc1a3d7181a73219d4344489688c2a2f16caf1141bc42021738339431b3a64cfbc293a73c1eddc", "0a20db61d2b74384ca184f20455ad1f380ba081f89e41c87ceb3fdbbba63c7aa1fbda20003ec799f306f70df7f53f91721e59353013ebf1647f5130903fff482")] + [TestCase("16a9fe4620e58d70109d6995fe5f9eb8b3d533280cc604a333dcf0fa688b62e20b972bf2daef6c10a41db685c2417b6f4362032421c8466277d3271b6e8706a809ad61a8a83df55f6cd293cd674338c35dbb32722e9db2d1a3371b43496c05fa09c73b138499e36453d67a2c9b543c2188918287c4eef2c3ccc9ebe1d6142d01", "005a68cc13a108287aa3ca0bd8bef95096ef22668e15c87f7cbe0167cd1cdc930359b9b2dd28843838cf74cb4af2cfd656690a7f73de771b891142db22fa61fb")] + public void Test(string input, string output) + { + byte[] inputData = Convert.FromHexString(input); + (byte[] outputData, bool success) = BN254AddPrecompile.Instance.Run(inputData, MuirGlacier.Instance); + + using (Assert.EnterMultipleScope()) + { + Assert.That(success, Is.True); + Assert.That(outputData, Is.EquivalentTo(Convert.FromHexString(output))); + } + } +} diff --git a/src/Nethermind/Nethermind.Evm.Test/BN254MulPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BN254MulPrecompileTests.cs new file mode 100644 index 00000000000..a4a088ce947 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Test/BN254MulPrecompileTests.cs @@ -0,0 +1,34 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Evm.Precompiles; +using Nethermind.Specs.Forks; +using NUnit.Framework; +using System; + +namespace Nethermind.Evm.Test; + +public class BN254MulPrecompileTests +{ + [TestCase("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b36ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0bf982b98a2757878c051bfe7eee228b12bc69274b918f08d9fcb21e9184ddc10b17c77cbf3c19d5d27e18cbd4a8c336afb488d0e92c18d56e64dd4ea5c437e6")] + [TestCase("25f8c89ea3437f44f8fc8b6bfbb6312074dc6f983809a5e809ff4e1d076dd5850b38c7ced6e4daef9c4347f370d6d8b58f4b1d8dc61a3c59d651a0644a2a27cfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "18a902ac147b2951531770c7c18a25e3dd87765e23f7e0c4e9d62b624a6e37450288473776e7e99b2aaa27e8f4656ea9ce5e634fd1ca1aab45315199ecaced2e")] + [TestCase("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0c6a880ffdd0737c53bfec9b65c9098a3298747bd4e5fd07026661b4cb804331116aeec88e11f49753df224c60c4bd8b8bc0a98b8d50f24ce64475268d227f4c")] + [TestCase("21315394462f1a39f87462dbceb92718b220e4f80af516f727ad85380fadefbc2e4f40ea7bbe2d4d71f13c84fd2ae24a4a24d9638dd78349d0dee8435a67cca6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "1d7985d51e53cdfbd73b051e9a74ab6e621b6b664a7efed00e30c1264f5623d02808eee3baec187160d2499b4aedbc665a532d245212a1be61e0d4b9b36f3075")] + [TestCase("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774baffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "15bd6ea71fd264e1bfb04eb6d97b4f3686c5bf36f91356fc13ddde3494e172d90b3f8392fd4cdd5d542887ea4ee0274835bf37b58edf927ef242b8704af52e92")] + [TestCase("08ed1b33fe3cd3b1ac11571999e8f451f5bb28dd4019e58b8d24d91cf73dc38f11be2878bb118612a7627f022aa19a17b6eb599bba4185df357f81d052fff90bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "26ec73a6134f8ebce33d675e1f2e6ff3ec066e8d255ffca6eb55ef2ab7c5c51d06500cfcd6950c92de24b90ca09be110f8f9c2fb4d9cb2a9f9677dd81c1c0607")] + [TestCase("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa807ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "06894837c70570eac651dae1a443b830c292c1801340ca4150c9d339177965e509ad8d4839bc83bd1852e6a8b71dcf01a1f7d6b6b174858ca02893bd5ace3eee")] + [TestCase("1c35e297f7c55363cd2fd00d916c67fad3bdea15487bdc5cc7b720f3a2c8b776106c2a4cf61ab73f91f2258f1846b9be9d28b9a7e83503fa4f4b322bfc07223cffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0e56eeb3f168767b21bce1489d9657f694951b25ea8a081f4ebf68469a1eb1e0293446d763ea9c40e52286f2ac504cfabb364b1f899b874b13d78879d25a5ec5")] + [TestCase("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe57ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "2f63f5f1275c401356e94adfbe5e8cff21485a9281e55d378a51eb93263a40802a817491a84e40c584481df4a5085b301c6fd66cb97856de55cd04df85a6a1d3")] + [TestCase("1f752f85cf5cc01b2dfe279541032da61c2fcc8ae0dfc6d4253ba9b5d3c858231d03a84afe2a9f595ab03007400ccd36a2c0bc31203d881011dfc450c39b5abeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0aa7b6fda656f23eab50e36db0519cdf79f4624d417253085907ebfd9aef38a414cdd2edce2b313fc6dd390628ac9fac910841706d55f9af2a064548694dc05c")] + public void Test(string input, string output) + { + byte[] inputData = Convert.FromHexString(input); + (byte[] outputData, bool success) = BN254MulPrecompile.Instance.Run(inputData, MuirGlacier.Instance); + + using (Assert.EnterMultipleScope()) + { + Assert.That(success, Is.True); + Assert.That(outputData, Is.EquivalentTo(Convert.FromHexString(output))); + } + } +} diff --git a/src/Nethermind/Nethermind.Evm.Test/BN254PairingPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BN254PairingPrecompileTests.cs new file mode 100644 index 00000000000..e351d2702c1 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Test/BN254PairingPrecompileTests.cs @@ -0,0 +1,67 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Evm.Precompiles; +using Nethermind.Specs.Forks; +using NUnit.Framework; +using System; + +namespace Nethermind.Evm.Test; + +public class BN254PairingPrecompileTests +{ + [TestCase("2722ae33a1d80f67a5da37ef2b7489dd39b1c98287fc408eb416e37de71bba1c3054f7ce76b782aa80254ce991fd5f115810e8f8f57ed0a12f30278112157c11165fa63e0d077c2b406c1001da54664d756636d6018616841c5b0d942519fecb1090ad3ca54838d2b89c0d2e3db3c2aff811d58bc32881d2ec947f473a8308a615b9fb021f60b7604ef07863fc6449504708718eaf59bd00f3620a9da16ed8830a95e72b8b56d1850126d77ddbdbd376e3b19f07a75071f0b958bd40471fe6900738bd659eab6973c3416b9e7c9660d341e8eee184c0f9c5ec59696f220903401e37dd4714f68da2a6affcf65a8cd26c7ae3fa0c0e5a3394887ceaebe4f49de90b501640d9ca26d1b466a9ea005b942b047fb519865b3413ccd90533d9902a85187c1fe325590f77ef42af537664469fa950986ce82c31eeaf1f6b348a3de3c6202ae189a9bf004bd80b9d8bdaa9b395a5263735242766aca3679ec3e547171b2a06ce9550542e6246331cbf852383c14830931cd63ededb0f21621b71e7f981", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("0eefcc4248b67e40298c48e0ed47dca1dbf6f6e377506899430b11bf03b17ede10c71a49ccfb43f8475de84b581eef9ab283c1238e172bf48150f29e1e56201204c9eaee6321d6ee36b8670498aa1c73665f3ecc7350c8ee09a573e692d26320171450a989ebe50e365b92d24c311fd830972e7b16a2523e634175c4e24c884a1a6bf429331081e6e930bd36e23bdf91bb8180a6e4129c11655cb9468093ceba0e9d0caa4d47983e49ee253051aaefd86cc6dd367384f89e2d166bd721c658122a55d1dc0b4bd2f33984f0099a6d44c85baa10aaca32d0ec89e494d24514a68c2d43c0e6576ec46f88dbdcc7c57d685a3eb9342ba7c71b62de9e6373bd9094ff0a716e218f8e4174821a7dc090fa93b7683e2a6e363afe3eb7287a7dcbf9ea090dada034b037e05a7c8b232b8c691b7f0c3b9a870d786e913d936f8256f2e8c0131bdc0ab71a147cb4d91bba85941c00ec91994d2e9e53b1929a14ee2e876dff021d8b2738aed0201234d3919498c918fd5340541ec616542d92d955df4c182902237ac6c6802585c60640eefde7c05fbdf206a5ec25dc3411a4e9b4e6b57be611bbc865815ccfb7c666b117834cbf2a7edd9c2baa691ee3d453c3652c49761b234be3f502cdf3d1e6258eb846afca7acb0fe13577e226ddd277daf32d1d0c5c25e39a0be0435820302ccb2763016b10d0dbde867c745fe86cfba8cc925a2eb72d4bb48beada74cddc1c791a980d9bf7601ce0aec444354a5c02185d392f66f50e4860e017fc0453fd1bb0453197ff5abfacd35b90e7d9b03ff0900cc857ef7f2f0ccd45b2e137fd53d99d027b79aa390ac021bf4d6aa95cc96bacd6a071386e21f73cf3d42f0ed82ca6f673bb89223e16386c7328385edb01eadd4ce28e5ab418861414b0b511cc6300bd0cc6c95538014be8a4a20d8cf56d74f4a63225302b1f065e5ce6c676af04344de377f580aad377dab935d532f2dce9daeb0f31d6900af84aeeab7ebb4390e6bbb4218558fba894959f2cc2fef8af5d1c16998a38c6076f86dbd858db5b0b15ca2cddb0092ef861188e0434f4232d7e3e884fa42bba", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("20b961c884a0ad42964edc3b580f607681058a33aee25d60f7dae9f060217ec119d77c703d1a93059a1baf9c17319ca9f1c5fb4a04855d6aedc308d9070f9769103dd1a1691e5fd39ff70241d7569c17764a3824e49664f5145f956abdd559af262f0e5677944e1834c3b5459e0bfb126d41a8afd73bfa12ee3ef45f17e81ca62dc7a825213952eb841f8942a113a5cbda01359751726ef26ce05491815806cb2bbefb942c709bb4fd01181e99ae1716ee28d0453ef725cb8ea45f7a4f93c6b3203b2360ffca610432f4d1053e633004d7a822ebd940e9a546a7d0f2038728921f1aa6348e2cb062d5e193a49d60214f2f0752fd32b57319b877958ef0f7eb9c1b32607b1f0ce57571b1c609260f757911ed8bcc3896e6c95a13655d11b6a7f929b9eabda75ba7d16a31ae4b7af7d0eb1bb349169df32fa20f4cfc959e722e0f24d21c9b7e68ef0e4e941aaffc472a7fa0b9d03b7097df3c993d108fa69d0a8b189dc5d953fcae14f53a800fa624429d2bbb94ec56f371e65dce393dc602ea2a04b4e2312aacb2061b9d55e615845b085696a908d76944bc822ca909212ac6bd05bb2fd64a97c2dd2e76b9ed90febf4fc236d4c466ab7afa4050101828fa67a02b0d987e9d5d717c8be7757e34354fc9a57198e5d8e867a8ff08b3e3020c84cc015904ec31cea03557ca10f0b7f5ea8b5215c80c01f5cc47bcac78c0d2f1f312135154f38704a2b7db3dc7c86be733e8880e07aa0712c2050627bdf56acd40482f36f73badb30e320c12bb66096c8bd7b978410dd5449f250519c6a122ceda572357aea961fec54427a6a1e6cb2d509210e0a6c049d39eefcf09191b561f361a2d372ecd78676d8180b6120c432178bf969e889d2e386ceb20642a0ab00f1c28263dfd316e344e8f9c1380b0fc5b3ce5bf524cae2978f53e6dff5c6cdf0743ee0c68b4b256d924d9635a4cfe45948e1f5c137369b47439912b113818d26e766d0ccf83a1e2015a3ac6f355345d4ab03f710bda2bf76f42eb7ae70aff6f955184031af5d2333c1dfca388231e1d78a53749973f0a6a01f8ad0018704c7db134592cdc9744ad7b88e407d0eb04696b62fd57be16c249043f670d881e8fb7573f9d0cc54a632cf9de52ee862a07e0d9dc11a3f4df8c9fcde0bc80f9fda1b8a84efb0b67884d640c14cc63211267d15a405fe9d03f9713fc79cb787934a778928b1f244b2e84e926f2d5a7e6d9a154873abd1899a7b20df25ae018279ed525e939da2333d4121573982541bb5fdd5d6570676ca6a2979f92a21a563924eaf1b2cc3c16190560061e4eaf988b117bbef2a7380429021d7190eee78b725bc42613725d2a2e3d1167ad6d74508c5322df36e614e10eedb067f8cfcb9573e9281b0b827e282d3416ccc69d13090246f223e743d077d3d167af6558cd17b8110b422b70462dfe3d677fe5a72c5125c9e67534c06a4070f0bcbd8f6a5d93a7691d63a2811e1908a4f98042938fec22a2372ff55c50d679bdb4dcef9a1ecc1dba4fbb54f6ba153aff2b0ba9da968ff1b07f22e95f4404a924ce1d68c9d4cddb10aa9680cdc2064aacfd45913bcc620e4cf277913eaa093e4b3ce25f40d1ac255f863fcf59c2066e98d7ecc5219edfdec9bdb718416fc65e1b48f3a5e33f40a459600bdf13c8144d022ace69574477c864aaa2cf989a862940f80b2c85e5737926e3fd1e18411d06df3079e19f11b85b2634cb2788caa2fa53cfca5de8888091dbd8cb73b3651e0c60e28b318329e56ce5cc18581966834f960344fe9645682b800bc138e5670f8f23befa1ac5f9caba7fca7179167d2df6ea237dee29bccc80eacabd5a51dc06f245eb13c8ba185388b1de78b300308010a551df2b5311f3ae838318d20297179bbf83449adaf1360b0b10494e299a9cc71672ce5774394144435ed65a061b230c57e56d08af54493bae064a3d94aba34faeab22b8056c9d1fd0b499bdade429c428761820248450189abe14f51cf3274aae5e2d65644e9866e1e5342faff915cc65f72d8210c6aab304b14ce4036862bef5e03cc6269ec755cad0f1bf285f0a67d6a9e5be0d4fe6e50b707331076cd11d96ea9c1c98575d21ca59083964fc06691da6e6e12b833b3b126f159d4fe2619b89bd86423b6cb9bfcb34480fa78c", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774ba0d2c492bf135ed45b0d6265c274d145d35b73afd41ee95d3f1da4bc8761038800251d138db1b9748ffc257b147a1aea66413b14df767f98f7ba02489c617eae51065ff2bd9a5b167db36225a35fd712d781309f4e2c8541a335b2c42bd2bcae4191cd528d749c52f3e198e534868d537867109419a32314886f6bb2bcd337773", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("03d310db98253bb4a3aaff90eeb790d236cbc5698d5a9a6014965acff56e759a1edc5e9ae29193d6e5deed5c3ac4171cae2da155880cf6058848318de6859ea21ee564b4d91e10d3c3a34787dc163a79bf9d571eeb67ff072609cbe19ff25fc7270e094c2467dcf6ecf8c97a09ef643cfff359cbec1426c5eb01864b5cf3c27309f432f65daced7c895c3748fa0b0dfc430584e419442a25b98e74400789801210fa7bc208e286ebea1f5c342a96782b563a0bc4cdb4c42ba151b9cb76eea93d0abcdaf6ffdf0cbf20235077c7bb3908b74b9a8252083f4b01dcbe84cab90fc71a9681988a15b7eea9ae8cb0c2210b870eec2366e0531c414abb65c668c6eb3e21d0be81c5698882ee63cb729ed3f5b725d7a670b76941ddffff9ddca50cf9af21e61a0ac51a17c0128baa2cda8f212b13943959cf26a7578342c93dd2de7deb194e408b546197d9ee99d643e5385dcb8d5904854d8a836763ab8ce20f9b5027222aced81c808247572971b490eef1515a49f651f7df254de2b35310bb5b78c218b2345c40036ea331bfcfb8536739a5e5530027709adae6632a3613cd0838cd204121beebd54ec6bb063ba5a6d84eeceda2a733260066c90d332425e992ef6c2b0f794d64952d560a422a7ff549a58bfaa0cf791ab6dfad1c4941e19078040324bad1c848f2d8efcd716f7d814c46e2632e74a5b8d455a64c55917b220aab982ed4bbed5f80fac726f4a95789fee7905eef0a241596acbea4268ec3f2b87f3129563b69a30c11a856f68c72f129988e8636c86f57467cba299cdb4917469b49137a989e5d714b4b882d4a455600940ab63b14f23e7934ddd62cf5181099c63b2f57525eb3d19451024a4e71ee09c72c5b7e0dff925001acaee126bcd29db5f600d8ff46230e348d08dcbcdb1f85a5a43aa7b4f51841f1d4f98c18bbb57651982cabdf6326194120727367bdae0b081aa7da12c8f8c6af0ce27d2f8d0f059fe1240c9c5a6993d344744d77bbb855960b6704e91846cf362444bff1ccaf45a7c217873a5d7834d0c1d7d9bab5f9934d7ac218834aa916d459d8ceafc280d59efb", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("198f03850c2c5df1bd5601c0a5cdae3cc955026dba50a79dd00aeefe49c48c252ee3bce85e4c7bb10fee21428a8b0c1328d662e152f36a6c62caaac2fe097c0b0c91b38273eedbc873b2172cce9eaf7af1463cb3fb064a49cff2dc95f0b5bc1224a1a5e52496677b5dfa29a4e314d7b32bd22c0f437679e12d0c49c9d84e988014d4d06a717737c0e36767b06809bba6bcda2707bd652b3f922c3a652dfc90b325d0de555188106e9c4bd93171a8377b9d53eeb93b0b259a91c7ba570591f4010f2dbb4dfc16b4fe806d2ed28daf51530d6b88a81c2ffb98d3a6c1153db9239421b7f52300ab7b6eb9d9ef4bd7d58811909cf4c4ad7a9f8546f56099eb6ae1370224ecd4af7d5ec18e5b0c8eb46a8bc774fc4ac6c4233aafe9bf22420ddea4752bff288e58f4bc80b1bb91b450652c120db2ece783788b8ff3beb20b2e8d3c7a2d90a5dc703456ffb854fe3a746143e82bd8e4aae8321ab59a93e5da9d615ede07f9f33a0a234486c63562fd9b27ee6615655b6880bd511475059ab40395d23c", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("08808ba03b1abc4b870cd2e50b3960e85ea4ffde76e97ea70e62feb5712ac68823f1f949786f8cf8a18323bbad75bc71afac4e2419181fee3a627a8980f5d36f243b9ecee8d6c2f2f1b91980e4f7136d16f70c94c5fdc21354adb977bc66d748207322b7980616a6e4f4ddc3f223c52a9a11b785298b69f4075349274adeebb21226d7ded357133a1e9a8472f9c0f23e248c1ca1974ae336f4316731f1f473bf00b29428be1694c86da00b5cfe677c1b3332c93105d18df718f9ff0053bcb7a620adf7f96265baa9a9b1512eb1d59834eb931491d360408061135a8b30ddbfdc284fb8dde65089a6359a11fc8d2725409e2bc1e52141f1dd38bd56d10015346d0aad6b6b34672e8ffda5085e97e2a7f82ff4e3e6660b83e151b778e2dfd1ef3f14b07ac31c0927a5cb27b0447051f1ea39baa7ef12572b9b5dc535ffa28341a220dc6c1d760064168c59b36eae9560df6433eb96acd58aa88499ac5f081eed30245b974d3078709e037860b2970943659596a88d529a36275b34b38c51ced169", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("09fa51b9f1972a041220b86a762c252262d942474d9c2ddaa8d292c79d34b8132771b3f3a480320bc7c9963dda5f4e8120b8f06a0cbc6095d37e0dbbf0b6f9ce23d0c74ab9b983b35311ad334580ad3e9b8ac6eb0ccd69a5097884056c8310e01317cbe87801a1bad8f362bfa07f65f4e6f0df7f1d3681cab1995df75f3caa2516abf6c2348309a172dfb07485e59d4b149d20741c740c9379f5d235c8b7dd922fc0496ddcb63fea074ce4aca7f9a91884b8f3158970ba3f03fd58608b50b7d511857f4a462fb73fa92204c79e81824de2825b74103238b4f8e601a2cb37121303b531c48bcf5c8ddf8e608cd16eef92bec33929ef4d8fe57572214999746567129e8547b1d2f8103bfab8af9a8849ef950c020c2a24c235c889dc65d54c6f00036688a10447a1ca50ecb46b9c77042a3e0959de2919eb62e55e08f94b3b491b05f4e65becdda13865c79072d38ca4a35cd934ccda724348e68631deb874a62d2bec9369394e4b5d549558b030a5b8681d23a67cb9d95465f531a39ae61782b729fc71bd60da082f1dd43572c15900fe35d03e10201fe93668c6e31e0e4330212b0fe78b06800bc1a549cdd0ff91ea7ada763609799901b63a1d3ecb446ad1110847890bfd62a9ad72ad058345167d3716969f4f0c1861e532fcf5dbcbdeec04018770d45b235156f127dc39b55ce54daaccb9b2bffaa9692591647fb85112a622ec7b25af397ed0c3738c242d8c7d98753b0a64f826ad284412b93decd25a091a8d6e03829186f4f33185c75bae823e2840d04ca583753b9ba7b9a215de06ce04ca57858bb1cf75033675d652331e737f7d98400ea1b42102273e74f75ec4a41716a588640c92a28e2d4bf4ca5a6c8fb6fb2d910ce2c882fee639f5e16f11cb1967f6d1826b83b4197e628bf36eead712652ea75027a48148059fb422bf03550f60639bae9064af3ee671b9168eef729fa30153c89843827a9991da684d72ef07e000a8e29e909b06936cc43d82c5bd6f7a4108014532483f674ed28df007232003493fff270b3289b402ba1eab4bf90cbbbdddaec3e70fd0eb648c0fa61b2c", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("1a4db8abfea95acd4ac4bdf3d9082de13dcb9b2a73d6aa98a296a7d7d1009a8a1e8a143f9ed8661a223e211c4f70b1ac1d5057d71e31f182637b6f26de9a59190e817e9fb476d397b0f09aa07d290cc830ceac3ef815c5b8f45caf2cdafd90e209888f93aab917c7b6a9f8ee7174ff889961ff3509256873a774926c0c5b9a0f1005b845c9f53465d9371efb0eb934ecc8db144d466eaf06614e89c77305c35501951dfd5ce7f374b05b2b2a0737a5251ce4d9f53f0ee7fe79399aa09d6bfe9414e57a7979f8f2d78a1c7dc790476265240fff65e18344caa11b0698a574d4412bb862b7c0f8283e05e10a9b6e3bd19e5b69f6988b3f470692f26c379c33132126a4d85b3499d830033f0388c18b8e7b824b5b0b57db1fe366a435b0c1a53c6000ed1afda982e3f8d71da60ede43dd562ae63597ec91b1cba21e1c9fd5b8fbd81795c6b9f6debf45b77638122c7333a59aaa2e7511f526f496feb84c20f651552581dd3c6f3d05c78234b559d784f502fa5dc0900ae7475ba88716e5ac3d499d", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("05fa7cb22fb8809abb745dc167279147fa174e0444cfc99a38f23f2b93e49ad62f7f94d2d206264a9358b54fc96ac31921948cf3c13d121c923991f0b47c04291b2582586c93d23816aac8ce2f90eb913e554211251bc9a2d64dd2efb9a905b80f73f8ca76c166aa5735d9370cf944306abfcac5a5874cc95b00b569f7eba01a1d92dac05e6fe60b5131a0d2e9c459d4b3deaf1a462332b285f90a25e5b61c211467961e060894bc8111abdbb66365b9da4a6700f2d530ae69289d2cc32185d004951597c8a0547ea22859b97dd87a37a8b4125bfcb513eff29e0bcae7a7dab00cb314388716efc2bee7b4294811db5bacaa3bcf720932e253f002b53e968f930bfa9409e358a1370c298a8cb622a0079bd7bf1a0e32e8f8dde7a0f56877945d2f95f233ceb61db914a2fc789bd35b3df37f62329a886194450ccc9e708d900c1fec898ed485e2970646f939313b33a6d3416476fcb249a96f6f11d030093f890621cd7af05f335e3514d7f10972f2b56614e917d9c4cb85178cce40f09a2291211e5387ed32f8c6f90d4c90d60fb08844a0fe0786717113aaf8060208331d3a03558a26134672a33a540774a5a994c549f2ec4e048e99c45f6f44692fa09ecf2d625e843fb3c186d9502acb5c9c3e6d0402ed815d76cf081e3ed847bdf8b0db0caddcd63f8dbab0b1ffdd45ae118ad1dcd7c1306c75a1f448a0e610994e5f300c058a66f63de3e94c81e96dd0cba0182c1371f61006d4cf9c9e24cc439d0cac280db62277ae92b4403f31d0bef2674900f1c21a0fb715b5cad4689154bbf53c2430b990502a5231b79e63246d15293a37918adf641bc8f8b18462909c8d1eea14434c1a33eb5a3b425729a7885db91c54240d3e8049c3d10811709dc86e71ed08d9b41714cb20a4d28f608d83b541cf998bef0ea0257f477e00c180b4e8ae4a0698e1e77ae24715eddf432eb950c3e26972a08521c31c484a733ce217b944f6190db804087bf4786ccbde4b6e149f2471121b29b6cb21d1f7baa6be1ad6ef18295d7425b744106a6fefb550e079074b1933af2bcf989c833a5f133f8e1c490e", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("001faaf97b965ffa633612b7c8f9f4be0b286b19662e5cbe6878019d8ba1382b16567ced7a7ee5c272bbc378a95c2436fb0c6133649c77e55a708b28419b5cac0c37556712bc94140738212a1372a4720ff269102f3f0dad4493b675a85463021e03f350aa8213bd6ce54987e7b32275bcead9a9096897b5c7dcd5964a17e07a2550f45b84e947f8e46267041f661de0ced333f91af090435c4bd6d9cecb4836096855fbc396b73c589e66ad989d7851c08bb55755f5771987d91925ffb40c2f", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("08a66cc423317e9d9560c307c7918b87672f3d99effd28b1d2bd2877e09fbba41a58977974f56dc522d159bffd0099791d207d2da49ee217055f5d0806e2dd0417b523e87e1d03b9498facd5df95cd85affaa681c2a43e51497997aa916318391835cc25b6a0979581ff7042a390a7315d8f5e938ea40dfdcb24822889e494cc18dcd8bedefa1c477913634203aa21a5a926595f62f4010eb3959d51acc430fa23ff858e75bc56f4d5054035aee0fb7264ecc4861ba1c44db81868108dcdc4dd099b58d1c3d880dda20c24def1b2c54cbb20ed9da85265983a00c1cf1facfcf903e39662a649ddbc4fa6927ed85694167b49ee5787bd755a5e4ff6fb82c32a9f20b8ce350fdb30744dc3dd1829ce8e7365a9ca56bfa4f79831355157a73fe99a17a534a927ed0e6cdfe9ae9befe94f581d20a4f19aa54c93149c95d53714c5a70771d55a8c477c0ebdde254d19e591fc3ecf011848276731a12a96a3267c5c710c76eb36abc43ab4d4b5a7a82770304fc2e9487512493dc5fd59aa6eb30402d0", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("1fc8f5de35d75e7446ef5703dcd7e07ad682030dd525b7620e1f7f36908d535e151d3453db1029bf894b5bded388d6a3fcf97d573bcccf93d27456ec79d9337d23ec8c4d66276cb927175d7bc25e3bf5a2252c4f83de5eabd695181834c67273017bea94aade8279f9b646a2e7f570a88aea7eb8bd51aaf40dbfe070a7228a5d06652252d3e68fc6fd6d76cd726513f0f757783f415762ecf16fb288ea9b10252a6ba1abfff1bf53aef31d24fc7d7c18d452ff529a04bb97e2aeaab748cc19762032882547249177d5cc51a46852ebc90ac17f098a3deb8dd8a37fd007bc2baf28714b756b948ac2b606fe0c4c1c3572423892040e5518f9e6abe89e7b1875bc25cd06956892564bd5e9e8557ba6c719e2ecedb4a4996817a8e77593af1321050b2488820e023afa5734ceab7072083831db2f7063cc57cd9852deab6918ca9b00b22e3956983827a599218890be78a3c0ac7f30d3a35d464a9cd4d4ef552576221f5a9cbdba030df39ed692fe2274fe2a99fda883aa4e724d54d6a0f74e0a89", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("273cc7b93b70bbfde8748d62210c033579947802560fd05dad9d65003482995b1b7379946dee0b15e90720dfff72cbb60b60b5aaa8490ed2b77e8f57a8906d1816836ad1a19ace6e0feaa4195ee6006280ce178b5987341221c6ae618794c10603ea811d60c99786835aff3871ef0163cdceec010fd806bd11adeae2a91f4cb6179a512e9627d2af3dfc8a36850e144c7255568b3154d41797e2ac4782234925047ecbe78073575c62a32129476a6456c61545eb98bbf925ae1d673a32d680e71f20ccd414fe03613ff7a3d330ab8bf8964cba66cdf3af8bb955cdc729014e692ef7c335beb80626f05301278f5e3b228bcc981736a258ea6bc4802392f081de265db5dda279bf034808ed23c8613341b31d3d29a2f65a367024af1376d1bb9907b7ed2f35386382b00fb0afa6c5643c170010e35824d8fc84d3604690fa18b404685df83549a5573c7228b29a7dde8679d8771a19e8af709ca46c60f8126e4b033a388adb6c574f85524ff523bc7c44b49c8731b763836e0a4ebf054f0008492b60683ad457d04d91f082e169606c6e5d6e172845fe586925db00a8e6a242c409a8c11d9bd07c2ebbdd653519e9a0f5d29576033ebab9a564e1b07d8909b014232fdeb565d57fecdf556f1b9753361e8d7ceaef0d4778b4669643a8f980ed9107e310cfb6db05062d60b0810fa4aa6ff9825ebc58ae839c844f82ad08d9a273161549f2d3778e678f8167640fde4f43d30f2f60d7ec8cc83673d0e5100235e405c743fcac26a09a44bfb9bbd6f767ccf6dd030879dae04027353dcbfc9a89af0f566f9e06f1a6035c08bd9873e41dc3bf009005f905fc0b9b74ea57a16c5a2411c984cf6d6d274f79bec9cea6021001d0729f412858eda5c909d8bdce6a24980d28d7ff8a6bc01cf9ba50e6613c5495f13a39ced02158862b29579c4cb0e947142fa8592c012a3038fe1178bcb515a016a06651e387087a9110ac43ea9548a520537d116ead0e2498e487613ebb81ef0f6f5210cb448e92f2cda4a4f57013ed1f922e1c90d8e8891a308adec863c0b48faf4b7581e0565ded5a8ac6bccdee08", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaa2e832e2bd419280d247658bb64323d59bbf47df41aa729d2168a272d66e306ff18ab999098bc5b30758183a160fcca776562d9a9370278aee9e6f71053e9358f0edd6252e0584efe53db6b3c40d1976d3849f08db15d39a0d7a6e327fc67f45e24925638e68e59cc22218917c61d2934c4e6353e2f62178a09627aed68c4e57a", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("0069c0c3d6aa9ca250e5bd3e2826e47936b6e479ad7c776caa5ac801dd5a1c2115226a94941ba68cd74c5b982235773c3a9cf6a71b1dc9d4d8307251f1d031c630316709df5c7f6af25fc5f698db87b1170fdf63bd2917bc21b5037452053dd30bec8492774364ac6ceca4b56b9b8d1aec0bcda12943dd1437e515fa7fe5bf8000c0e3fd9719382c09eded028cf0c9f866d0fec2fab515f6aa60249557270f2e25f0d2cf69c495554a426914354b553f3f6f269e0d5340b2593a5793138189ae214aa7d305903ecbdbc10d564e1ebc9455bf0e8aa3ba3321f8b9023b911cecab19239edfaa2efe905d8a5d6884da42815cc84b13d9c4fb3c304cd99d3d27b61e15063c61103bc76e80aadf05a3ae6a36f90013bce43fdb48bfc8e3e2e09f838d1dcd88fe88d48dcb4d6401442b46fd713c41d36dfbc50d8dad834a9615fc01581377baf2e5ec86b4bfe2123c9f1d5cac10fe0a79fff333ac86ebffe1aabb98252316b9995e22925907421897f44ffffa963b730c7edad138f41f54652ddd8c30", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("2761d967b3f2481435189a94502260dff1044c8cb24ea3809d0eec28cfdbf6c72c87711eaab02bf1f9940d504be3727789efbbb1c48370f61e2e4daad31be6de08a73a943ab3a7ea19633a4ef9e9bc1de68a51d778e41589504b8fb0818cdf88064eb3b5d1a63404e247cd5118a695b3b85d63e89c8512309d591701596f172a210f847e73452b29da165f6c76462f2ee76ff301b534bb0d2f0f7374b041e15612a910ab4044ec261965b917059383b5d5f5c9eb201eb61a6909fb5a610849aa1f4535e9a8bf16a4a4435004b8ab3a84bb6495a0d748ccfc25388832356732910e2936a799b55efa690fd821a3cb4d352cbb3f22ed5fe865f984e289329ca6591e4e4510639258f836e30c422e3a18fb76bdc121fd28ed77306a05b8a3299fec09decd53dc1620f84154fd333da06556e87fae4463cf02459964412fa50d4b082e0120af9b40957fb7ff0dd412f59cc0acc01c49021389cd470dec453e92faa3221680f87a61c96fefc9ada16473b853c4c92a03e1e38211a9487a2812f830760f4841710cf252069ea39d70793aac9b2f769a3954310546fc15a109f6d057d30f01c88e34c9ec83f28674534aa8ad16f61b744b293b63ae3c2fcb178a08408a1780e9ff8f2973152194ebd44ef8b158470d3f67d08425c7a9d99a4f1ee9502704bc22f9c0177342d11e54a0940cd9b51caa04c762f060d5262b5f31c66d088729dcf02930b56cf1a3bcdd147cab2fcfe913c53bf5456dc19edd706ad2122be5129ff68c503fcbe10cef00f314919b033000f43ca563f92e95a8a9dc19a867e400d5a976132900579ff4d8e1f64d86a453d7576e16459b641d574d2d9af32c0707107329853a55152341e8142e6bd97b51118d4777e44d347a3add4f6e73a6d52c0175507a0d4432b6a72508a8fe5838a14c953bb0a8834366aa0ace3a1c12a005e64fcf94cadbc98cb78a5f768409a1cda219c504f3c0e99d1e8de93601046528ceafcc22a3649dd0270094b4b3fbe55fae668028e67a8dc3378fb726cec2fd0c3322db4dccfde2f638c9e7cde93246102e9539f5ea6bf23e57bb3f60e8690e", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("28d6423856311fe86c30fcd983dfa63c95bc5adc1dee6fe0ad715dbe7bba3c091165ad57bbd71dba3d734f446b3a11cbfe5e02051f6898a677bdda5134738d5709661289bdac8badf175790f8e406755b33e54bcd8149e1e469de37447185f110efd4f6454886db697584e85127bf4826304d0d9559195b6d3f875cad607958903e94e1ca8dd25c626e31daf9cd26b3caa7ca2615690127aa11647cba037c92a20179a34c869f27fe9783e133f50fcc38bfb81200b9c635d0b9bbbbc789f4cb60511e5e1561aad84bba3d2495e4853046ae1972e687ccab832f34f19fe9b55db11d42ecbbbf14d945c29319a9a945f64610a2bb9059c0c89911556232bdc6c4b1e92ef35b5ecc024193888d764218828778507233cda5076633acd49986023ba1c0110745aacf972ffd66add373241c8285dc6c96928a6ca012b4e572f1897540deab5945fc017e575d40284abc7356a20bb85330533be288d0a14159da44efd1fc7bd3676093afa2c2d809cb5a14b913c5914c77b341f018f391cfecf0029a2090010e0c084f8c16f8496f1c6db02902cccc6cb8d58118e8dee1baaea679a370075a1886efcc99523c8abf69974f742c7d2de3e12598a963713b9bbc31a9f0a14b98584a1aaebc7649c481668a54d9da6fcb308f3dec33e0965775624f2f904298d6b7a0d04b3a217099a7daf390d5a7edfd72b1c8aab02e6f5cb440cd4a84214772064081adcf6e36148eec3bcbbbd12d363b4a76e7018159f559c2ff1c0d8051f9f9abbafb9032e3c95ebde21931a554fab74bfd7f3d61c939268c46ff9c82ffc5143ba27c7aacca19326cd8522f9d55e6b6d17d4b0586b81d86e76dfb9730782e23592d8d735517d63b6b51313e09681bfb6e66cee098ebb60ca3ebb18f80ddd80135c76e5e26ec2d004f572d267f940a5d5b82e35f4df366312e39387662343e67b7783310ea825278a262dea12bd5b1fa71735819e3e360f467d0af5f522234b4bd70b251d63a8dc9bc9e63117ca8342c3dbb3068df38229b5b34f2bd21097b0a55ece871e554a89aa97a7ecb95cd9e1f5ecea94274019d17b9943de13", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("15848a9e99c4a0719df209a705edfa52bdca729d0b73a9835880da9dc0cd2ace108b1a4ceabe6a8ba3dea041bb0dff513e7b99057d4b3c2aa378807de47dbc3627515ea8ee84feadb86577a1b7553b2016cc63807de89fcbc05bc3d53b0f23332872f837e4cde9fbf64bdd170d6488a3155bcd5b1fef4fa7ad10089bec8ea7b803713c878e32a49ff95dc2bbe7b1491c38258835dbca14ab343e88dc64004dae0f9ec7e3c20939b84e40bf66864e8129742feed7e1291d752c76bdf28e02d03b2c48bfe10367b611f37ab5847542df1d30baed8abc5380d6d80032d0e04af0d10e119d730f867b4e286a3c1c4cd04236999b9bb94d9001a4f144982d72df407d059e6ea753e84de7e8b41b2d0dca1cfb6b12afeb2564a5e24a2064f1b662a1a912e0bdf2470e896d7fda45c39a66c5c4a5297b4f19810ee37e33f7f50499326b1f70831beccc3eb5fb719d27f111e5c731cbeb4002519a4b3831ba896cffb608157b59ceb6f7a0518df929eac70c7bac9ef9c196ba21266ff47cee9bb0c60864", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa80728695310187ac477bdf3d7fb472e6374b1222f8ebcfcae72a8b1dc714ec853461fde556a4ef408d4a2ce89143674e9985eff87fa3df3ce6e7483c3a2f9b82bcb18df8612ef09775ec815b602e35eb6ec71ea6f7acebdc23667a60eb465e76d590500f7d19190ee1090bffe087045e97c913f7c5730110559665b3e8a9e0a526e", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("1920c53c756f1ec1a40e0264e5f65808eafaeaa7b0885f89852297bc2186ac9d09416cc536a27b6d5616f74dd2bbbfb463b9961752e0aa38d47b5213994959ab081c536b7d9a27636d0af7d4c8dad2e380cb2996a1d650a2e6123224294a6c86039e75a4a93bcc2798aec714e37b9b2602760e7ec7c6f3342e44018f2986da9b2d1ceb9ba9f7b923459d8b4701dfae12b3efd4174fa3705747fba6bce14a87720c15d04d2bd099f86ccaf9834b9588e88fdec8d04bba329d4fed580884f4b2bb", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("16a9fe4620e58d70109d6995fe5f9eb8b3d533280cc604a333dcf0fa688b62e20b972bf2daef6c10a41db685c2417b6f4362032421c8466277d3271b6e8706a8034c462aaaa7a3b4ed1266d755867524258c64b9553c46b2bd4d5c26aaedc66524e9d39a8749083573a1b84662c08ae15f16b75b9fd40089ee412f5e58dfad350e28b1c6e881a288290c7e9e12d23f122e61e89c43619f902c48d300ffe1734b014f125c1960a64127a16c8a17da5f21721e47b17575a94802a78711f45fe988", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("128b65cb80257f3006fc20dbb6af6781da7e0f9213d2b909fd113ee0f2d2bb52251e288387db7be742fe67261f36a4f09eeb4763bbbaa1bb13af3dec65302a4125ed8b2035e437f057cb45003f1c25510d7e232c7587581bdc3035064a96d2e32293733bfad88afa5adabcf320f055e3fe0d1ae733dc21f5e08fc234029be16a18414155506a4c287ac374bc28635be3e6b8fd0097554db051a45138f0b6140410f8c1e8992d53017580b1b806cd23729f9a2aefc6e60bb82606551c1393750b", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b3629f2c1dbcc614745f242077001ec9edd475acdab9ab435770d456bd22bbd2abf268683f9b1be0bde4508e2e25e51f6b44da3546e87524337d506fd03c4ff7ce01851abe58ef4e08916bec8034ca62c04cd08340ab6cc525e61706340926221651b71422869c92e49465200ca19033a8aa425f955be3d8329c4475503e45c00e1", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("18db259896bf7a55fbd739049dcd87bab41bca06dbe6ba477bd91293ecc7b72a080f9707ac098f3ac7a06fc4cddf9de9024723d7803df1e832f23facc344e09f1f0a58aa3d929cf73ef5fb29717b46818570f8acc287057a61f1bf19952d5d870a985a1377ac0068c32090c4f61af49e438888371fa281863746ad9c4505839a1635829f9dc1168b264dc1b35951410b3f509179a86259cd1bc219e0d9fb6571282e9a7a2784db855d8fc301a21574e67751c63574f552b5075cf0d54feb2ee7086ac4e5ca51c4e84405e5310187119e9283a8e1d4b9be261bea666f724501c302d9e8305711e2081373125393ea672966c2b7931d9de75640aacce9bdd8ff8109610ee10faabfae8ddd3bae29f8644762b842a90a4baca50bd37c4c8e346cdf2c0a29ba08d26cd5e2ea3ac028f2c13854b997da5de4020810d8d1df0b5ede16181628b1a3d5936ef9414119e8bc454d0209022d6c3b6722ed63bd3be9fd11ef16a94dc0c53b0283290c9189b46b2b2e727ac54299b70b73ccd31eadbbbce239183aa0627c185bbed1b35c46d0d2ab1e248f7a4ab6d1896afcb8cecd471911ef208db0fcb30c4d601aecc21ad3457e4a636a2bb289712a98153589c3674a774f08c0f49c7c290fab83aa67c3ed645856531b1e537e060fddb3b722849819cbfe04336ad8c78b7ecd068f1f543b4cf09a510bed3f39c8afd71b549b957d5b4fdd0f2251c9278bb30892b0ea4fbc771380481fdad33dfe0e9f49916e476823feed199cdc78bf86665cfec1b451e92bb8122597a0b28bdd5d380024756fe070aa101deeac40a4d371c0154aecdddb082f6891c7c3a5074e1b5c1b30e4b3ffcca6980bab17266f609f8c1616cf6c23c51e60b24d2ebcff2c7e486abd11f878ad231b2e69a5773f6986e289b67c70b92da16c0c8f2a8dcced737641061312f5fe17952151ca3275c32561490b233e7284a4690a777da485efacab5557307c6d8e588608aa1e46b4edfd86ff457f0ab244e624488e4563be1a0ee35df8b547c43e4e0411b1dce99279dab100f4137847c3bac64342dc95b9cdc2e5880ae61f898181d8", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("09d599a8c97251e5d1447076792891b8de719e3fc5b7b245e35c6a8af97dbe1b1cefb6a792c978414992b8c88ead994e8fc972bd8018a40e306eb0e5578b25ca21312203a90480fc7174fba1bb4b9802c930c38aff91399e78e2c76768daff422bbd652137299ba4ebda8016f7501bbfeb6de219561d3f924693efa9acfca2b81618159fd6039f1ee36963eedec8154312d592e6e1dba89d1747c4251bdb725a0c6d546f20a8b44f4517290a078310fd1af065e8ef20ed4ff94c0fd7b7c662be143e5a3414336749caf364eefdc5e30ee73d34d9462a44e90e085851eb93c9b6206426d020f657f36fec865bfa09bc619746c238c4cfa643529eea42aff19dc52abc81b078bdca796d77c4ac57e6a248fdf370d3cd12163c474aaa46eac2cec103b3cc21c58b94796153850268f274376dd6f1a36103e6f870a4eafa452923802c6ca8c36c4a0225e4d80bb8e62aaad963cc39bf9db92e1a0f45a353c82039dd1821a59d0fd59b5d0a0362128b95414fd2479542e1afab6e8fb23e06e9a547210cab4c461a3179e2f0a15c1a20e0569590bc30c8c7344a73db5fe76341efbd2c1d24f43820586b1449eaed8c7063d4e481a1a52d0c5a318f9b69e97c35a6393b016dcb50ee485d31c090cfffa92e709dd5bdf6b94dea9a7310f0c824ba78151003ae718fdd5682ae467b0f776cfdd02db3be8d2aa9d42c88638bffdf154920121c3580c8ff773cdab1bd6a9449d8f4d0dcfd5d3e1bd55acdaed1afb96e40c0dd233eee0523e0a36b7cbba083eb2919ab0a66836dabc699f6f5864d284090cba90d02024b706a23f6d6f84681ab223b9975aa15bfc6c37c1e1d43bcf8de71b10f2321d3e00d52c53f18415f2e87cd00940a6a3234e7400e170297db9b214a596d2a6ca0984a6e1aa1433eb239c30efb32093022dc1ec379567ebe899606324afd22052844ad5cb4241203b35d930334fdcb22754475653cf6138f51677c5759d0034a7400dc24da45b5d4c63576a83f299cc60b43b186de9d8d5120d36596299502031424a44c5970eeb1090ce35d7379a0654db261594a27b7ccec8bab8db83b26534bc2216a34a20a506366d22111acbf059df2198654cd69f1e4db9cf7d4801d135d29f2973a802ab859a35550a844ecde62bdb95e86bb6e974453b5bf2d031a4f3c2aa1d0be4af8f9013414719e7b75536b3e0dbd8250fa3feacd17416de420df18f7491d891ce8c01acf25ed54d37433830a1bb5f169716b07aeb67e4e6a05ce2b0d962f82ebcc36bca7c238f9e0d83f4b731b4447b2fb6f24636aee57260f1a72ebde3694aed548f7d8e20b3f9e119260b66d095e9992ca8645292eb45b01cb4b475f8cdb3126bd428b18745e504371be364d94d482648251a0ae1bb9ae2e976e6fd23476a9181e42a874a734f7efd1dc25037765e35a92885559ef4da81af8fe9ef0615a50760d000b68bff0f102771b9cf46bed9d5ce8565a558e41700bd46d271edbcac6a253a859cb7a172a3176fe6f9eebaf752417603efde4bda114f8788c8608a32c27fb3087189d92464788c4b62525f616c8725f6abf9d4dce07b8399a0e69860301eefd202480a12e054a920ea3dca3844f6309232c61fcfb17c43e311e336f593615004ed5a4b8be2ebde42af53d5fa32a7790ca80fc234a3034f9151c43f2eea7585049b4aad29392d9e9285b011b73cf2c6af955bb236b15857fb2789ec0149c253b23f8232627bd48f36ce4e8bea688d8b64d7469b2072912fb4719cb6894a14986fc875c84c220649f3c48e3a662f4c4f8b0c259529e2b6d3696c45cd1b11f02bd752022b0e7a2599bbca90cb8290789d71bd990d18418bba1e7fca94de8833d95851c88876c42fe817d3025a5076307c85b59add5f81771cbccfaaff14f7fb8807bf88902cdc39ca0a398f8bec67971cf8b771d941204515478d4c8dd014aa27e099cad61aa267ee25fb61d23e5d33ed0e2ad08bfd60c2af2b362d35851adaf161bf289d100b65ccf2050aab6c951e44a010140914e18ceed56ed6655d046f37dd75198590f95200ada816be88cff9fb1ed2aba308c1e556fa4987309f9d3c380432429cc72e8e146a24c339c989d2266c0f1503737075913b800fedc3b85ed5060567231334467aa6104824b79ca8f99ff263fff52", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("2bc49f4d8134cf72ce0883c589f4f6f0636db174b6176e063b3effdd57e3404309f61eba66408ad541dac082701734d6e6d4cf6f90bc0e65d6578f2d18563e221eb59aa8d8a9187b0857ab89a453fc53209855b300377bbca411998bdf9aa6730bd2384fa0ad96fcd1fc6c1a1a1fb80d4859770ca91b9559281736cfd6745d011cb39aee49da07d70b0f579101c412f1068ea82671859f09c4c1cb3ae74f8cc103fb73a573c8f147ae15610e4f97e291bcfe16556842e00e88ad70db0df2dc3a05430e574064f2d1de68795706bf99b1b6079a99bda3e5ec266567f2f9246e090f5976710762dfa75253c53ae1c2c88523ff08d0c2523d9409033aa2b7e4392000036daaeef66504945efa89111745e29d39ac317d798bbb1d14f84bdf5bfac91134d59ae245678087748ccfd3c65ecf2db2d05595cd6ed8452346713768c7411ab6efb518910157009fdc818e5d4e082da02f0618f4a3d6166f830b81a4e683023ad24b09b49bfd967c7adbe895811172f04a2b90b1379dac89a6fa1a91d8cb", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("240517a373fda7a2fef6ee9e9895505545c354433af3d3548b8537abb10d445c12e45a8b8c4d7a82ae27f0ffe3dd976b1242b040b96043ad31ce9f2ffa5bc707275ec5565ec4ccde5088b40c57c946be5d48b9ba34f956611ec87ed33d47500116f3ff1c54f920a4ba438c43501d2ef59e7c7eb2f8ebde852309bbfbc087af1b1742abd3e12ea49804bc4e8e59ecb9da6789392b1e12958ad653ad49f3d4d8450a1190ddff2fe9afa9dbea1e42222afe9715e1bced4e7ac4c20d89476ed6253c0bcfe3f03313340fd392b32bccfcab83f942f6b13d71e2a3159239c61c50c7bb199c36728784b46d5607ebd7cf5a055a3db4458ad6f0fb7e826d6a280daf625d1db3a467a1de6f3b848da16893902bb07fd0b63f6509dacae6693c7975fe09940b291b95276b136f58cf6f899cbb5a6f4009a4d069be6c0f8f0d6bfd7c38991f0e46dd20f14881ed44b216b44ba054b1f32c61d01f33326ec7f6c2ace3c8901414f211e03a121fcbb34f328205223d7f7ddff484efdd5d06e8886f2781f8e549", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("22f2e1830cea84486d7ff320365a5ead50d356379d7bc4f2b9d77dd298f36fd8087baa2aad4fd8bbca8cc0b525041e1b17aeb3ecc63086cdc6fd1ec2310bb8db243fe8ce837f106ef17e387f9d78df833811427d5338c83f0622f92a65101da31ab23d2eb26b70ff15decd58baf91a68ec85f149012d481da67f806b0571c9471928767c9a5576ba5fbd7cee08203e6de3d9dd36a756fc621700031081a80b7e1aee70334cfaeec2f7551368818353fbd5810266c7d1ba49de47cec9b81b6e82007aed597093879d894ea438d094f3373b51f31bd5993e026e76502bcb1334e32189a92e9df00c0b5c21811462933dd17a5328075b472a53ca61bd9e136701571e529e7c4912cb565a3819473e8cb2c45e0a7b17a63f11e509d80472921e86f92fabe095002240b012e60bc9159383bdbf515def6c41acf180adde6913625a7b11d22c04a21962ecdcb1b679168cc14899e2912f233ed37d116cbde2110af4861ca847018951f8d71a369874541390d23df3cf9e5031655d4e7af4affdda5ec50fb5b633ac619c06ff0312901dc9d949ddb443ded5f59662788c101859ed0cab1782bd118c15612ab18ecaeeb9226a0145c0c1d01428987b8a5523c6da78e015261c22b6d73323e863964a003fb93594743f70e9248ed6898776780a7f3ae7a41b07a0d873b1ece5c55c6c942a7c7249c3d9026fcc607a68fe6e73cd4a76a6821f86065d5e87ffecc2c47bbd85658eb21bbdacdb79f23b031a8c6df93e64574c06eb93cb065183692c4ae4dff2efd51615d926782da50054e4a280c5bafb913d02369aa17493b4fccafbe637b1b7c9e1225e7b6fb24720f778548e304e7617b407e83fd6e3da09599850d6399059fadd57c4fadb492f59ad3adb4783ccda65272f190a9ca862a6d9508d9b2513edecf47aaa4fdc7a64127dcccbe64b7f206d400148ee9fc305099c6a7334452f25473a58edc7161895ab52e3590ea600e2e885010b062ce0df9974072bf87f5a1c8072df23e612b254b688084b5958314efe190bb6fb66657b45e6f81fa7c5fd41004f815ffd08ec00cb46ced2b1f97b04e69b", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("0e6eab4103302750b22364bd1ec80e5edfb3ad06fa175ff2517ca49489f728e9050a17b5a594d0fd6fafed7fe5c447793fe9b617f0f97c3ee6dd29638f6c9232068b38fd28978b73b64592127317a542e084ea8291e404b88d3a731207104f9624d1ae64196a7d3b8e9fdcf72f9dce16d649fa3971daaca56405a0d331e2aa92210a32dfe27a36ca740e4d668066f7559acddea850fee4ebf9c9a241b337e771191a60da23a028dfc3b3b82c3d15802615f6386f29194e088936e3ffe96809eb", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe5712fa10f98bc3c4faa2a9729408e92a8b4e6d304abc539cc396820f696f23ecbb2b30d01fe71a3550fa6780e70305d28ea686b72aff7d23cd550f886fcd60f6b30d1142c81b9b27e329c498e4b241fa2ab0e0c62170cbe2a1e642589e4ff6ca54069ec036f519726e40596ede6cd47577c5cc24746754280add50bf87fe7404c8", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("1688243c91950e540e5acdc41b84ee9d2b1c0ecc84dc373d6fd5959baebb33df140c8a9c0ae42792290c177a97425bfbfaf7ef008b7656e906c2df69fbdce89a029c4ee67b639e4b6f7cf0536ba1f24bf61837351b5c74f12fb6cb0887aac3ea1d3c75ef1b03ad925b1b223901a8e7a4e16ef2bf6600e7c175529c18ba8008350aa0f1fd72acfd2bc3c50664eba62133ea85341f0b4ec0c3618f3738401a42ce1fc3592b9642716c47152c9e52881fac74773f705c15b7737e0831ced7a0f8371245c36152deacfd18a947b3f3c83a30652958dd9614b7beef8aa8b5cdb157462ac85cca98a10e6ec5efafdd593179f2f56c4febb1ae6f1d72a9661fd8ed51032b98467d16a6e8e6bfb427838659b8df567ca38ec17c979560bee66d1ab72f372d38efa3e51e7ad3ab06b5610e0631db0a385101b45d0fe47c25610213aa023208289e3f0845bc2197d57ac44b4a808b30aef09a344f80062bd75a1844715d3d0cf55d95f2fefda6a1bab5796626fbb6345796ef134109de55bd61654f54c71f16eb795694ab923473ee66eaa59bbf61de8f8dfa94c481cb4f224b3ba90ec87318c3ec099e1aeb3d63840ccba2159386cb3d71481ef18b5466901b71cdc6e75e1ce807182d1b89fcbaff954b80d8a58d49c953c05a64e2a326cb3ae4802a0f9f29719e2b60002727f32b49638ac3c1d4addc61cb260c4ac99307ba24a7743ad52f325d4f32b8477cbd99a218c2e4ecb3171cab016c51cd800663bec05624f1072775db17ff93e8b807067572c97cbc7321e9690b8fc4f193eb0f1a93ce96a5c20cf7cc3dbf579b54af41204b2451098724e9d8940bd4cabff1605f33592e5f002817dd14edab5e60dde89c66b3c93dc057c53b926b2077d63d2dbbf9316bd64c2bb1b35df3f9ce28954fbe15eb52a08aa70453112cc94ad923616aec0553dfce0d5e44001e7b139917b4cd2d32bca418f24f44bd7ffa16edc47ff8178efee06f28630c2816b74f232864deeea9073bdc2128d704d2375431c7bb196825b0ba890b5ecd90caa2107b346a40472b9972bdca3e388e38a2914e2c1f022a82d49b4f", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] + [TestCase("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed275dc4a288d1afb3cbb1ac09187524c7db36395df7be3b99e673b13a075a65ec1d9befcd05a5323e6da4d435f3b617cdb3af83285c2df711ef39c01571827f9d", "0000000000000000000000000000000000000000000000000000000000000001")] + [TestCase("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000001")] + [TestCase("192c207ae0491ac1b74673d0f05126dc5a3c4fa0e6d277492fe6f3f6ebb4880c168b043bbbd7ae8e60606a7adf85c3602d0cd195af875ad061b5a6b1ef19b64507caa9e61fc843cf2f3769884e7467dd341a07fac1374f901d6e0da3f47fd2ec2b31ee53ccd0449de5b996cb8159066ba398078ec282102f016265ddec59c3541b38870e413a29c6b0b709e0705b55ab61ccc2ce24bbee322f97bb40b1732a4b28d255308f12e81dc16363f0f4f1410e1e9dd297ccc79032c0379aeb707822f9", "0000000000000000000000000000000000000000000000000000000000000000")] + public void Test(string input, string output) + { + byte[] inputData = Convert.FromHexString(input); + (byte[] outputData, bool success) = BN254PairingPrecompile.Instance.Run(inputData, MuirGlacier.Instance); + + using (Assert.EnterMultipleScope()) + { + Assert.That(success, Is.True); + Assert.That(outputData, Is.EquivalentTo(Convert.FromHexString(output))); + } + } +} diff --git a/src/Nethermind/Nethermind.Evm.Test/BnAddPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BnAddPrecompileTests.cs deleted file mode 100644 index a22cd643b4f..00000000000 --- a/src/Nethermind/Nethermind.Evm.Test/BnAddPrecompileTests.cs +++ /dev/null @@ -1,37 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using Nethermind.Core.Extensions; -using Nethermind.Evm.Precompiles; -using Nethermind.Evm.Precompiles.Snarks; -using Nethermind.Specs.Forks; -using NUnit.Framework; - -namespace Nethermind.Evm.Test; - -public class BnAddPrecompileTests -{ - [Test] - public void Test() - { - byte[][] inputs = - { - Bytes.FromHexString("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b3625f8c89ea3437f44f8fc8b6bfbb6312074dc6f983809a5e809ff4e1d076dd5850b38c7ced6e4daef9c4347f370d6d8b58f4b1d8dc61a3c59d651a0644a2a27cf"), - Bytes.FromHexString("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaa21315394462f1a39f87462dbceb92718b220e4f80af516f727ad85380fadefbc2e4f40ea7bbe2d4d71f13c84fd2ae24a4a24d9638dd78349d0dee8435a67cca6"), - Bytes.FromHexString("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774ba08ed1b33fe3cd3b1ac11571999e8f451f5bb28dd4019e58b8d24d91cf73dc38f11be2878bb118612a7627f022aa19a17b6eb599bba4185df357f81d052fff90b"), - Bytes.FromHexString("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa8071c35e297f7c55363cd2fd00d916c67fad3bdea15487bdc5cc7b720f3a2c8b776106c2a4cf61ab73f91f2258f1846b9be9d28b9a7e83503fa4f4b322bfc07223c"), - Bytes.FromHexString("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe571f752f85cf5cc01b2dfe279541032da61c2fcc8ae0dfc6d4253ba9b5d3c858231d03a84afe2a9f595ab03007400ccd36a2c0bc31203d881011dfc450c39b5abe"), - Bytes.FromHexString("0e6eab4103302750b22364bd1ec80e5edfb3ad06fa175ff2517ca49489f728e9050a17b5a594d0fd6fafed7fe5c447793fe9b617f0f97c3ee6dd29638f6c9232038de98419e242685862c118253ab7df7358f863a59170c37e606d5bd23c742f076ff3443f4e01b7d7ace1315fe50cf77c365d8d289c65303bcc11ba7961ab95"), - Bytes.FromHexString("1920c53c756f1ec1a40e0264e5f65808eafaeaa7b0885f89852297bc2186ac9d09416cc536a27b6d5616f74dd2bbbfb463b9961752e0aa38d47b5213994959ab015296293a5a1bb5e15a7d019787422cb3409e075e122c6fc5867f0c3f3715731782b870b6641d8d55323e27ebaea17909499877fda62e3ac1e2b2310cad5f9c"), - Bytes.FromHexString("001faaf97b965ffa633612b7c8f9f4be0b286b19662e5cbe6878019d8ba1382b16567ced7a7ee5c272bbc378a95c2436fb0c6133649c77e55a708b28419b5cac0750d51706ced69621c8e4ba1758ba90c39ba8b3b50507bfa545ace1737e360e283d609cd67a291fc3d720c5b1113eececba4ca31d58a1319d6a5a2fa89608f9"), - Bytes.FromHexString("128b65cb80257f3006fc20dbb6af6781da7e0f9213d2b909fd113ee0f2d2bb52251e288387db7be742fe67261f36a4f09eeb4763bbbaa1bb13af3dec65302a4115f64edf27478045bf45eded285544acaa7f2b3a2a36176acefc1a3d7181a73219d4344489688c2a2f16caf1141bc42021738339431b3a64cfbc293a73c1eddc"), - Bytes.FromHexString("16a9fe4620e58d70109d6995fe5f9eb8b3d533280cc604a333dcf0fa688b62e20b972bf2daef6c10a41db685c2417b6f4362032421c8466277d3271b6e8706a809ad61a8a83df55f6cd293cd674338c35dbb32722e9db2d1a3371b43496c05fa09c73b138499e36453d67a2c9b543c2188918287c4eef2c3ccc9ebe1d6142d01") - }; - - for (int i = 0; i < inputs.Length; i++) - { - IPrecompile precompile = Bn254AddPrecompile.Instance; - _ = precompile.Run(inputs[i], MuirGlacier.Instance); - } - } -} diff --git a/src/Nethermind/Nethermind.Evm.Test/BnMulPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BnMulPrecompileTests.cs deleted file mode 100644 index be40da630d1..00000000000 --- a/src/Nethermind/Nethermind.Evm.Test/BnMulPrecompileTests.cs +++ /dev/null @@ -1,37 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using Nethermind.Core.Extensions; -using Nethermind.Evm.Precompiles; -using Nethermind.Evm.Precompiles.Snarks; -using Nethermind.Specs.Forks; -using NUnit.Framework; - -namespace Nethermind.Evm.Test; - -public class BnMulPrecompileTests -{ - [Test] - public void Test() - { - byte[][] inputs = - { - Bytes.FromHexString("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b36ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - Bytes.FromHexString("25f8c89ea3437f44f8fc8b6bfbb6312074dc6f983809a5e809ff4e1d076dd5850b38c7ced6e4daef9c4347f370d6d8b58f4b1d8dc61a3c59d651a0644a2a27cfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - Bytes.FromHexString("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - Bytes.FromHexString("21315394462f1a39f87462dbceb92718b220e4f80af516f727ad85380fadefbc2e4f40ea7bbe2d4d71f13c84fd2ae24a4a24d9638dd78349d0dee8435a67cca6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - Bytes.FromHexString("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774baffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - Bytes.FromHexString("08ed1b33fe3cd3b1ac11571999e8f451f5bb28dd4019e58b8d24d91cf73dc38f11be2878bb118612a7627f022aa19a17b6eb599bba4185df357f81d052fff90bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - Bytes.FromHexString("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa807ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - Bytes.FromHexString("1c35e297f7c55363cd2fd00d916c67fad3bdea15487bdc5cc7b720f3a2c8b776106c2a4cf61ab73f91f2258f1846b9be9d28b9a7e83503fa4f4b322bfc07223cffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - Bytes.FromHexString("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe57ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - Bytes.FromHexString("1f752f85cf5cc01b2dfe279541032da61c2fcc8ae0dfc6d4253ba9b5d3c858231d03a84afe2a9f595ab03007400ccd36a2c0bc31203d881011dfc450c39b5abeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), - }; - - for (int i = 0; i < inputs.Length; i++) - { - IPrecompile precompile = Bn254MulPrecompile.Instance; - _ = precompile.Run(inputs[i], MuirGlacier.Instance); - } - } -} diff --git a/src/Nethermind/Nethermind.Evm.Test/BnPairPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BnPairPrecompileTests.cs deleted file mode 100644 index 6f5d09ddd58..00000000000 --- a/src/Nethermind/Nethermind.Evm.Test/BnPairPrecompileTests.cs +++ /dev/null @@ -1,68 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using Nethermind.Core.Extensions; -using Nethermind.Evm.Precompiles; -using Nethermind.Evm.Precompiles.Snarks; -using Nethermind.Specs.Forks; -using NUnit.Framework; - -namespace Nethermind.Evm.Test; - -public class BnPairPrecompileTests -{ - [Test] - public void Test() - { - byte[][] inputs = - { - Bytes.FromHexString("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b3629f2c1dbcc614745f242077001ec9edd475acdab9ab435770d456bd22bbd2abf268683f9b1be0bde4508e2e25e51f6b44da3546e87524337d506fd03c4ff7ce01851abe58ef4e08916bec8034ca62c04cd08340ab6cc525e61706340926221651b71422869c92e49465200ca19033a8aa425f955be3d8329c4475503e45c00e1"), - Bytes.FromHexString("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaa2e832e2bd419280d247658bb64323d59bbf47df41aa729d2168a272d66e306ff18ab999098bc5b30758183a160fcca776562d9a9370278aee9e6f71053e9358f0edd6252e0584efe53db6b3c40d1976d3849f08db15d39a0d7a6e327fc67f45e24925638e68e59cc22218917c61d2934c4e6353e2f62178a09627aed68c4e57a"), - Bytes.FromHexString("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774ba0d2c492bf135ed45b0d6265c274d145d35b73afd41ee95d3f1da4bc8761038800251d138db1b9748ffc257b147a1aea66413b14df767f98f7ba02489c617eae51065ff2bd9a5b167db36225a35fd712d781309f4e2c8541a335b2c42bd2bcae4191cd528d749c52f3e198e534868d537867109419a32314886f6bb2bcd337773"), - Bytes.FromHexString("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa80728695310187ac477bdf3d7fb472e6374b1222f8ebcfcae72a8b1dc714ec853461fde556a4ef408d4a2ce89143674e9985eff87fa3df3ce6e7483c3a2f9b82bcb18df8612ef09775ec815b602e35eb6ec71ea6f7acebdc23667a60eb465e76d590500f7d19190ee1090bffe087045e97c913f7c5730110559665b3e8a9e0a526e"), - Bytes.FromHexString("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe5712fa10f98bc3c4faa2a9729408e92a8b4e6d304abc539cc396820f696f23ecbb2b30d01fe71a3550fa6780e70305d28ea686b72aff7d23cd550f886fcd60f6b30d1142c81b9b27e329c498e4b241fa2ab0e0c62170cbe2a1e642589e4ff6ca54069ec036f519726e40596ede6cd47577c5cc24746754280add50bf87fe7404c8"), - Bytes.FromHexString("0e6eab4103302750b22364bd1ec80e5edfb3ad06fa175ff2517ca49489f728e9050a17b5a594d0fd6fafed7fe5c447793fe9b617f0f97c3ee6dd29638f6c9232068b38fd28978b73b64592127317a542e084ea8291e404b88d3a731207104f9624d1ae64196a7d3b8e9fdcf72f9dce16d649fa3971daaca56405a0d331e2aa92210a32dfe27a36ca740e4d668066f7559acddea850fee4ebf9c9a241b337e771191a60da23a028dfc3b3b82c3d15802615f6386f29194e088936e3ffe96809eb"), - Bytes.FromHexString("1920c53c756f1ec1a40e0264e5f65808eafaeaa7b0885f89852297bc2186ac9d09416cc536a27b6d5616f74dd2bbbfb463b9961752e0aa38d47b5213994959ab081c536b7d9a27636d0af7d4c8dad2e380cb2996a1d650a2e6123224294a6c86039e75a4a93bcc2798aec714e37b9b2602760e7ec7c6f3342e44018f2986da9b2d1ceb9ba9f7b923459d8b4701dfae12b3efd4174fa3705747fba6bce14a87720c15d04d2bd099f86ccaf9834b9588e88fdec8d04bba329d4fed580884f4b2bb"), - Bytes.FromHexString("001faaf97b965ffa633612b7c8f9f4be0b286b19662e5cbe6878019d8ba1382b16567ced7a7ee5c272bbc378a95c2436fb0c6133649c77e55a708b28419b5cac0c37556712bc94140738212a1372a4720ff269102f3f0dad4493b675a85463021e03f350aa8213bd6ce54987e7b32275bcead9a9096897b5c7dcd5964a17e07a2550f45b84e947f8e46267041f661de0ced333f91af090435c4bd6d9cecb4836096855fbc396b73c589e66ad989d7851c08bb55755f5771987d91925ffb40c2f"), - Bytes.FromHexString("128b65cb80257f3006fc20dbb6af6781da7e0f9213d2b909fd113ee0f2d2bb52251e288387db7be742fe67261f36a4f09eeb4763bbbaa1bb13af3dec65302a4125ed8b2035e437f057cb45003f1c25510d7e232c7587581bdc3035064a96d2e32293733bfad88afa5adabcf320f055e3fe0d1ae733dc21f5e08fc234029be16a18414155506a4c287ac374bc28635be3e6b8fd0097554db051a45138f0b6140410f8c1e8992d53017580b1b806cd23729f9a2aefc6e60bb82606551c1393750b"), - Bytes.FromHexString("16a9fe4620e58d70109d6995fe5f9eb8b3d533280cc604a333dcf0fa688b62e20b972bf2daef6c10a41db685c2417b6f4362032421c8466277d3271b6e8706a8034c462aaaa7a3b4ed1266d755867524258c64b9553c46b2bd4d5c26aaedc66524e9d39a8749083573a1b84662c08ae15f16b75b9fd40089ee412f5e58dfad350e28b1c6e881a288290c7e9e12d23f122e61e89c43619f902c48d300ffe1734b014f125c1960a64127a16c8a17da5f21721e47b17575a94802a78711f45fe988"), - Bytes.FromHexString("1a4db8abfea95acd4ac4bdf3d9082de13dcb9b2a73d6aa98a296a7d7d1009a8a1e8a143f9ed8661a223e211c4f70b1ac1d5057d71e31f182637b6f26de9a59190e817e9fb476d397b0f09aa07d290cc830ceac3ef815c5b8f45caf2cdafd90e209888f93aab917c7b6a9f8ee7174ff889961ff3509256873a774926c0c5b9a0f1005b845c9f53465d9371efb0eb934ecc8db144d466eaf06614e89c77305c35501951dfd5ce7f374b05b2b2a0737a5251ce4d9f53f0ee7fe79399aa09d6bfe9414e57a7979f8f2d78a1c7dc790476265240fff65e18344caa11b0698a574d4412bb862b7c0f8283e05e10a9b6e3bd19e5b69f6988b3f470692f26c379c33132126a4d85b3499d830033f0388c18b8e7b824b5b0b57db1fe366a435b0c1a53c6000ed1afda982e3f8d71da60ede43dd562ae63597ec91b1cba21e1c9fd5b8fbd81795c6b9f6debf45b77638122c7333a59aaa2e7511f526f496feb84c20f651552581dd3c6f3d05c78234b559d784f502fa5dc0900ae7475ba88716e5ac3d499d"), - Bytes.FromHexString("1fc8f5de35d75e7446ef5703dcd7e07ad682030dd525b7620e1f7f36908d535e151d3453db1029bf894b5bded388d6a3fcf97d573bcccf93d27456ec79d9337d23ec8c4d66276cb927175d7bc25e3bf5a2252c4f83de5eabd695181834c67273017bea94aade8279f9b646a2e7f570a88aea7eb8bd51aaf40dbfe070a7228a5d06652252d3e68fc6fd6d76cd726513f0f757783f415762ecf16fb288ea9b10252a6ba1abfff1bf53aef31d24fc7d7c18d452ff529a04bb97e2aeaab748cc19762032882547249177d5cc51a46852ebc90ac17f098a3deb8dd8a37fd007bc2baf28714b756b948ac2b606fe0c4c1c3572423892040e5518f9e6abe89e7b1875bc25cd06956892564bd5e9e8557ba6c719e2ecedb4a4996817a8e77593af1321050b2488820e023afa5734ceab7072083831db2f7063cc57cd9852deab6918ca9b00b22e3956983827a599218890be78a3c0ac7f30d3a35d464a9cd4d4ef552576221f5a9cbdba030df39ed692fe2274fe2a99fda883aa4e724d54d6a0f74e0a89"), - Bytes.FromHexString("0069c0c3d6aa9ca250e5bd3e2826e47936b6e479ad7c776caa5ac801dd5a1c2115226a94941ba68cd74c5b982235773c3a9cf6a71b1dc9d4d8307251f1d031c630316709df5c7f6af25fc5f698db87b1170fdf63bd2917bc21b5037452053dd30bec8492774364ac6ceca4b56b9b8d1aec0bcda12943dd1437e515fa7fe5bf8000c0e3fd9719382c09eded028cf0c9f866d0fec2fab515f6aa60249557270f2e25f0d2cf69c495554a426914354b553f3f6f269e0d5340b2593a5793138189ae214aa7d305903ecbdbc10d564e1ebc9455bf0e8aa3ba3321f8b9023b911cecab19239edfaa2efe905d8a5d6884da42815cc84b13d9c4fb3c304cd99d3d27b61e15063c61103bc76e80aadf05a3ae6a36f90013bce43fdb48bfc8e3e2e09f838d1dcd88fe88d48dcb4d6401442b46fd713c41d36dfbc50d8dad834a9615fc01581377baf2e5ec86b4bfe2123c9f1d5cac10fe0a79fff333ac86ebffe1aabb98252316b9995e22925907421897f44ffffa963b730c7edad138f41f54652ddd8c30"), - Bytes.FromHexString("240517a373fda7a2fef6ee9e9895505545c354433af3d3548b8537abb10d445c12e45a8b8c4d7a82ae27f0ffe3dd976b1242b040b96043ad31ce9f2ffa5bc707275ec5565ec4ccde5088b40c57c946be5d48b9ba34f956611ec87ed33d47500116f3ff1c54f920a4ba438c43501d2ef59e7c7eb2f8ebde852309bbfbc087af1b1742abd3e12ea49804bc4e8e59ecb9da6789392b1e12958ad653ad49f3d4d8450a1190ddff2fe9afa9dbea1e42222afe9715e1bced4e7ac4c20d89476ed6253c0bcfe3f03313340fd392b32bccfcab83f942f6b13d71e2a3159239c61c50c7bb199c36728784b46d5607ebd7cf5a055a3db4458ad6f0fb7e826d6a280daf625d1db3a467a1de6f3b848da16893902bb07fd0b63f6509dacae6693c7975fe09940b291b95276b136f58cf6f899cbb5a6f4009a4d069be6c0f8f0d6bfd7c38991f0e46dd20f14881ed44b216b44ba054b1f32c61d01f33326ec7f6c2ace3c8901414f211e03a121fcbb34f328205223d7f7ddff484efdd5d06e8886f2781f8e549"), - Bytes.FromHexString("15848a9e99c4a0719df209a705edfa52bdca729d0b73a9835880da9dc0cd2ace108b1a4ceabe6a8ba3dea041bb0dff513e7b99057d4b3c2aa378807de47dbc3627515ea8ee84feadb86577a1b7553b2016cc63807de89fcbc05bc3d53b0f23332872f837e4cde9fbf64bdd170d6488a3155bcd5b1fef4fa7ad10089bec8ea7b803713c878e32a49ff95dc2bbe7b1491c38258835dbca14ab343e88dc64004dae0f9ec7e3c20939b84e40bf66864e8129742feed7e1291d752c76bdf28e02d03b2c48bfe10367b611f37ab5847542df1d30baed8abc5380d6d80032d0e04af0d10e119d730f867b4e286a3c1c4cd04236999b9bb94d9001a4f144982d72df407d059e6ea753e84de7e8b41b2d0dca1cfb6b12afeb2564a5e24a2064f1b662a1a912e0bdf2470e896d7fda45c39a66c5c4a5297b4f19810ee37e33f7f50499326b1f70831beccc3eb5fb719d27f111e5c731cbeb4002519a4b3831ba896cffb608157b59ceb6f7a0518df929eac70c7bac9ef9c196ba21266ff47cee9bb0c60864"), - Bytes.FromHexString("08a66cc423317e9d9560c307c7918b87672f3d99effd28b1d2bd2877e09fbba41a58977974f56dc522d159bffd0099791d207d2da49ee217055f5d0806e2dd0417b523e87e1d03b9498facd5df95cd85affaa681c2a43e51497997aa916318391835cc25b6a0979581ff7042a390a7315d8f5e938ea40dfdcb24822889e494cc18dcd8bedefa1c477913634203aa21a5a926595f62f4010eb3959d51acc430fa23ff858e75bc56f4d5054035aee0fb7264ecc4861ba1c44db81868108dcdc4dd099b58d1c3d880dda20c24def1b2c54cbb20ed9da85265983a00c1cf1facfcf903e39662a649ddbc4fa6927ed85694167b49ee5787bd755a5e4ff6fb82c32a9f20b8ce350fdb30744dc3dd1829ce8e7365a9ca56bfa4f79831355157a73fe99a17a534a927ed0e6cdfe9ae9befe94f581d20a4f19aa54c93149c95d53714c5a70771d55a8c477c0ebdde254d19e591fc3ecf011848276731a12a96a3267c5c710c76eb36abc43ab4d4b5a7a82770304fc2e9487512493dc5fd59aa6eb30402d0"), - Bytes.FromHexString("08808ba03b1abc4b870cd2e50b3960e85ea4ffde76e97ea70e62feb5712ac68823f1f949786f8cf8a18323bbad75bc71afac4e2419181fee3a627a8980f5d36f243b9ecee8d6c2f2f1b91980e4f7136d16f70c94c5fdc21354adb977bc66d748207322b7980616a6e4f4ddc3f223c52a9a11b785298b69f4075349274adeebb21226d7ded357133a1e9a8472f9c0f23e248c1ca1974ae336f4316731f1f473bf00b29428be1694c86da00b5cfe677c1b3332c93105d18df718f9ff0053bcb7a620adf7f96265baa9a9b1512eb1d59834eb931491d360408061135a8b30ddbfdc284fb8dde65089a6359a11fc8d2725409e2bc1e52141f1dd38bd56d10015346d0aad6b6b34672e8ffda5085e97e2a7f82ff4e3e6660b83e151b778e2dfd1ef3f14b07ac31c0927a5cb27b0447051f1ea39baa7ef12572b9b5dc535ffa28341a220dc6c1d760064168c59b36eae9560df6433eb96acd58aa88499ac5f081eed30245b974d3078709e037860b2970943659596a88d529a36275b34b38c51ced169"), - Bytes.FromHexString("198f03850c2c5df1bd5601c0a5cdae3cc955026dba50a79dd00aeefe49c48c252ee3bce85e4c7bb10fee21428a8b0c1328d662e152f36a6c62caaac2fe097c0b0c91b38273eedbc873b2172cce9eaf7af1463cb3fb064a49cff2dc95f0b5bc1224a1a5e52496677b5dfa29a4e314d7b32bd22c0f437679e12d0c49c9d84e988014d4d06a717737c0e36767b06809bba6bcda2707bd652b3f922c3a652dfc90b325d0de555188106e9c4bd93171a8377b9d53eeb93b0b259a91c7ba570591f4010f2dbb4dfc16b4fe806d2ed28daf51530d6b88a81c2ffb98d3a6c1153db9239421b7f52300ab7b6eb9d9ef4bd7d58811909cf4c4ad7a9f8546f56099eb6ae1370224ecd4af7d5ec18e5b0c8eb46a8bc774fc4ac6c4233aafe9bf22420ddea4752bff288e58f4bc80b1bb91b450652c120db2ece783788b8ff3beb20b2e8d3c7a2d90a5dc703456ffb854fe3a746143e82bd8e4aae8321ab59a93e5da9d615ede07f9f33a0a234486c63562fd9b27ee6615655b6880bd511475059ab40395d23c"), - Bytes.FromHexString("2722ae33a1d80f67a5da37ef2b7489dd39b1c98287fc408eb416e37de71bba1c3054f7ce76b782aa80254ce991fd5f115810e8f8f57ed0a12f30278112157c11165fa63e0d077c2b406c1001da54664d756636d6018616841c5b0d942519fecb1090ad3ca54838d2b89c0d2e3db3c2aff811d58bc32881d2ec947f473a8308a615b9fb021f60b7604ef07863fc6449504708718eaf59bd00f3620a9da16ed8830a95e72b8b56d1850126d77ddbdbd376e3b19f07a75071f0b958bd40471fe6900738bd659eab6973c3416b9e7c9660d341e8eee184c0f9c5ec59696f220903401e37dd4714f68da2a6affcf65a8cd26c7ae3fa0c0e5a3394887ceaebe4f49de90b501640d9ca26d1b466a9ea005b942b047fb519865b3413ccd90533d9902a85187c1fe325590f77ef42af537664469fa950986ce82c31eeaf1f6b348a3de3c6202ae189a9bf004bd80b9d8bdaa9b395a5263735242766aca3679ec3e547171b2a06ce9550542e6246331cbf852383c14830931cd63ededb0f21621b71e7f981"), - Bytes.FromHexString("2bc49f4d8134cf72ce0883c589f4f6f0636db174b6176e063b3effdd57e3404309f61eba66408ad541dac082701734d6e6d4cf6f90bc0e65d6578f2d18563e221eb59aa8d8a9187b0857ab89a453fc53209855b300377bbca411998bdf9aa6730bd2384fa0ad96fcd1fc6c1a1a1fb80d4859770ca91b9559281736cfd6745d011cb39aee49da07d70b0f579101c412f1068ea82671859f09c4c1cb3ae74f8cc103fb73a573c8f147ae15610e4f97e291bcfe16556842e00e88ad70db0df2dc3a05430e574064f2d1de68795706bf99b1b6079a99bda3e5ec266567f2f9246e090f5976710762dfa75253c53ae1c2c88523ff08d0c2523d9409033aa2b7e4392000036daaeef66504945efa89111745e29d39ac317d798bbb1d14f84bdf5bfac91134d59ae245678087748ccfd3c65ecf2db2d05595cd6ed8452346713768c7411ab6efb518910157009fdc818e5d4e082da02f0618f4a3d6166f830b81a4e683023ad24b09b49bfd967c7adbe895811172f04a2b90b1379dac89a6fa1a91d8cb"), - Bytes.FromHexString("03d310db98253bb4a3aaff90eeb790d236cbc5698d5a9a6014965acff56e759a1edc5e9ae29193d6e5deed5c3ac4171cae2da155880cf6058848318de6859ea21ee564b4d91e10d3c3a34787dc163a79bf9d571eeb67ff072609cbe19ff25fc7270e094c2467dcf6ecf8c97a09ef643cfff359cbec1426c5eb01864b5cf3c27309f432f65daced7c895c3748fa0b0dfc430584e419442a25b98e74400789801210fa7bc208e286ebea1f5c342a96782b563a0bc4cdb4c42ba151b9cb76eea93d0abcdaf6ffdf0cbf20235077c7bb3908b74b9a8252083f4b01dcbe84cab90fc71a9681988a15b7eea9ae8cb0c2210b870eec2366e0531c414abb65c668c6eb3e21d0be81c5698882ee63cb729ed3f5b725d7a670b76941ddffff9ddca50cf9af21e61a0ac51a17c0128baa2cda8f212b13943959cf26a7578342c93dd2de7deb194e408b546197d9ee99d643e5385dcb8d5904854d8a836763ab8ce20f9b5027222aced81c808247572971b490eef1515a49f651f7df254de2b35310bb5b78c218b2345c40036ea331bfcfb8536739a5e5530027709adae6632a3613cd0838cd204121beebd54ec6bb063ba5a6d84eeceda2a733260066c90d332425e992ef6c2b0f794d64952d560a422a7ff549a58bfaa0cf791ab6dfad1c4941e19078040324bad1c848f2d8efcd716f7d814c46e2632e74a5b8d455a64c55917b220aab982ed4bbed5f80fac726f4a95789fee7905eef0a241596acbea4268ec3f2b87f3129563b69a30c11a856f68c72f129988e8636c86f57467cba299cdb4917469b49137a989e5d714b4b882d4a455600940ab63b14f23e7934ddd62cf5181099c63b2f57525eb3d19451024a4e71ee09c72c5b7e0dff925001acaee126bcd29db5f600d8ff46230e348d08dcbcdb1f85a5a43aa7b4f51841f1d4f98c18bbb57651982cabdf6326194120727367bdae0b081aa7da12c8f8c6af0ce27d2f8d0f059fe1240c9c5a6993d344744d77bbb855960b6704e91846cf362444bff1ccaf45a7c217873a5d7834d0c1d7d9bab5f9934d7ac218834aa916d459d8ceafc280d59efb"), - Bytes.FromHexString("2761d967b3f2481435189a94502260dff1044c8cb24ea3809d0eec28cfdbf6c72c87711eaab02bf1f9940d504be3727789efbbb1c48370f61e2e4daad31be6de08a73a943ab3a7ea19633a4ef9e9bc1de68a51d778e41589504b8fb0818cdf88064eb3b5d1a63404e247cd5118a695b3b85d63e89c8512309d591701596f172a210f847e73452b29da165f6c76462f2ee76ff301b534bb0d2f0f7374b041e15612a910ab4044ec261965b917059383b5d5f5c9eb201eb61a6909fb5a610849aa1f4535e9a8bf16a4a4435004b8ab3a84bb6495a0d748ccfc25388832356732910e2936a799b55efa690fd821a3cb4d352cbb3f22ed5fe865f984e289329ca6591e4e4510639258f836e30c422e3a18fb76bdc121fd28ed77306a05b8a3299fec09decd53dc1620f84154fd333da06556e87fae4463cf02459964412fa50d4b082e0120af9b40957fb7ff0dd412f59cc0acc01c49021389cd470dec453e92faa3221680f87a61c96fefc9ada16473b853c4c92a03e1e38211a9487a2812f830760f4841710cf252069ea39d70793aac9b2f769a3954310546fc15a109f6d057d30f01c88e34c9ec83f28674534aa8ad16f61b744b293b63ae3c2fcb178a08408a1780e9ff8f2973152194ebd44ef8b158470d3f67d08425c7a9d99a4f1ee9502704bc22f9c0177342d11e54a0940cd9b51caa04c762f060d5262b5f31c66d088729dcf02930b56cf1a3bcdd147cab2fcfe913c53bf5456dc19edd706ad2122be5129ff68c503fcbe10cef00f314919b033000f43ca563f92e95a8a9dc19a867e400d5a976132900579ff4d8e1f64d86a453d7576e16459b641d574d2d9af32c0707107329853a55152341e8142e6bd97b51118d4777e44d347a3add4f6e73a6d52c0175507a0d4432b6a72508a8fe5838a14c953bb0a8834366aa0ace3a1c12a005e64fcf94cadbc98cb78a5f768409a1cda219c504f3c0e99d1e8de93601046528ceafcc22a3649dd0270094b4b3fbe55fae668028e67a8dc3378fb726cec2fd0c3322db4dccfde2f638c9e7cde93246102e9539f5ea6bf23e57bb3f60e8690e"), - Bytes.FromHexString("28d6423856311fe86c30fcd983dfa63c95bc5adc1dee6fe0ad715dbe7bba3c091165ad57bbd71dba3d734f446b3a11cbfe5e02051f6898a677bdda5134738d5709661289bdac8badf175790f8e406755b33e54bcd8149e1e469de37447185f110efd4f6454886db697584e85127bf4826304d0d9559195b6d3f875cad607958903e94e1ca8dd25c626e31daf9cd26b3caa7ca2615690127aa11647cba037c92a20179a34c869f27fe9783e133f50fcc38bfb81200b9c635d0b9bbbbc789f4cb60511e5e1561aad84bba3d2495e4853046ae1972e687ccab832f34f19fe9b55db11d42ecbbbf14d945c29319a9a945f64610a2bb9059c0c89911556232bdc6c4b1e92ef35b5ecc024193888d764218828778507233cda5076633acd49986023ba1c0110745aacf972ffd66add373241c8285dc6c96928a6ca012b4e572f1897540deab5945fc017e575d40284abc7356a20bb85330533be288d0a14159da44efd1fc7bd3676093afa2c2d809cb5a14b913c5914c77b341f018f391cfecf0029a2090010e0c084f8c16f8496f1c6db02902cccc6cb8d58118e8dee1baaea679a370075a1886efcc99523c8abf69974f742c7d2de3e12598a963713b9bbc31a9f0a14b98584a1aaebc7649c481668a54d9da6fcb308f3dec33e0965775624f2f904298d6b7a0d04b3a217099a7daf390d5a7edfd72b1c8aab02e6f5cb440cd4a84214772064081adcf6e36148eec3bcbbbd12d363b4a76e7018159f559c2ff1c0d8051f9f9abbafb9032e3c95ebde21931a554fab74bfd7f3d61c939268c46ff9c82ffc5143ba27c7aacca19326cd8522f9d55e6b6d17d4b0586b81d86e76dfb9730782e23592d8d735517d63b6b51313e09681bfb6e66cee098ebb60ca3ebb18f80ddd80135c76e5e26ec2d004f572d267f940a5d5b82e35f4df366312e39387662343e67b7783310ea825278a262dea12bd5b1fa71735819e3e360f467d0af5f522234b4bd70b251d63a8dc9bc9e63117ca8342c3dbb3068df38229b5b34f2bd21097b0a55ece871e554a89aa97a7ecb95cd9e1f5ecea94274019d17b9943de13"), - Bytes.FromHexString("09fa51b9f1972a041220b86a762c252262d942474d9c2ddaa8d292c79d34b8132771b3f3a480320bc7c9963dda5f4e8120b8f06a0cbc6095d37e0dbbf0b6f9ce23d0c74ab9b983b35311ad334580ad3e9b8ac6eb0ccd69a5097884056c8310e01317cbe87801a1bad8f362bfa07f65f4e6f0df7f1d3681cab1995df75f3caa2516abf6c2348309a172dfb07485e59d4b149d20741c740c9379f5d235c8b7dd922fc0496ddcb63fea074ce4aca7f9a91884b8f3158970ba3f03fd58608b50b7d511857f4a462fb73fa92204c79e81824de2825b74103238b4f8e601a2cb37121303b531c48bcf5c8ddf8e608cd16eef92bec33929ef4d8fe57572214999746567129e8547b1d2f8103bfab8af9a8849ef950c020c2a24c235c889dc65d54c6f00036688a10447a1ca50ecb46b9c77042a3e0959de2919eb62e55e08f94b3b491b05f4e65becdda13865c79072d38ca4a35cd934ccda724348e68631deb874a62d2bec9369394e4b5d549558b030a5b8681d23a67cb9d95465f531a39ae61782b729fc71bd60da082f1dd43572c15900fe35d03e10201fe93668c6e31e0e4330212b0fe78b06800bc1a549cdd0ff91ea7ada763609799901b63a1d3ecb446ad1110847890bfd62a9ad72ad058345167d3716969f4f0c1861e532fcf5dbcbdeec04018770d45b235156f127dc39b55ce54daaccb9b2bffaa9692591647fb85112a622ec7b25af397ed0c3738c242d8c7d98753b0a64f826ad284412b93decd25a091a8d6e03829186f4f33185c75bae823e2840d04ca583753b9ba7b9a215de06ce04ca57858bb1cf75033675d652331e737f7d98400ea1b42102273e74f75ec4a41716a588640c92a28e2d4bf4ca5a6c8fb6fb2d910ce2c882fee639f5e16f11cb1967f6d1826b83b4197e628bf36eead712652ea75027a48148059fb422bf03550f60639bae9064af3ee671b9168eef729fa30153c89843827a9991da684d72ef07e000a8e29e909b06936cc43d82c5bd6f7a4108014532483f674ed28df007232003493fff270b3289b402ba1eab4bf90cbbbdddaec3e70fd0eb648c0fa61b2c"), - Bytes.FromHexString("18db259896bf7a55fbd739049dcd87bab41bca06dbe6ba477bd91293ecc7b72a080f9707ac098f3ac7a06fc4cddf9de9024723d7803df1e832f23facc344e09f1f0a58aa3d929cf73ef5fb29717b46818570f8acc287057a61f1bf19952d5d870a985a1377ac0068c32090c4f61af49e438888371fa281863746ad9c4505839a1635829f9dc1168b264dc1b35951410b3f509179a86259cd1bc219e0d9fb6571282e9a7a2784db855d8fc301a21574e67751c63574f552b5075cf0d54feb2ee7086ac4e5ca51c4e84405e5310187119e9283a8e1d4b9be261bea666f724501c302d9e8305711e2081373125393ea672966c2b7931d9de75640aacce9bdd8ff8109610ee10faabfae8ddd3bae29f8644762b842a90a4baca50bd37c4c8e346cdf2c0a29ba08d26cd5e2ea3ac028f2c13854b997da5de4020810d8d1df0b5ede16181628b1a3d5936ef9414119e8bc454d0209022d6c3b6722ed63bd3be9fd11ef16a94dc0c53b0283290c9189b46b2b2e727ac54299b70b73ccd31eadbbbce239183aa0627c185bbed1b35c46d0d2ab1e248f7a4ab6d1896afcb8cecd471911ef208db0fcb30c4d601aecc21ad3457e4a636a2bb289712a98153589c3674a774f08c0f49c7c290fab83aa67c3ed645856531b1e537e060fddb3b722849819cbfe04336ad8c78b7ecd068f1f543b4cf09a510bed3f39c8afd71b549b957d5b4fdd0f2251c9278bb30892b0ea4fbc771380481fdad33dfe0e9f49916e476823feed199cdc78bf86665cfec1b451e92bb8122597a0b28bdd5d380024756fe070aa101deeac40a4d371c0154aecdddb082f6891c7c3a5074e1b5c1b30e4b3ffcca6980bab17266f609f8c1616cf6c23c51e60b24d2ebcff2c7e486abd11f878ad231b2e69a5773f6986e289b67c70b92da16c0c8f2a8dcced737641061312f5fe17952151ca3275c32561490b233e7284a4690a777da485efacab5557307c6d8e588608aa1e46b4edfd86ff457f0ab244e624488e4563be1a0ee35df8b547c43e4e0411b1dce99279dab100f4137847c3bac64342dc95b9cdc2e5880ae61f898181d8"), - Bytes.FromHexString("1688243c91950e540e5acdc41b84ee9d2b1c0ecc84dc373d6fd5959baebb33df140c8a9c0ae42792290c177a97425bfbfaf7ef008b7656e906c2df69fbdce89a029c4ee67b639e4b6f7cf0536ba1f24bf61837351b5c74f12fb6cb0887aac3ea1d3c75ef1b03ad925b1b223901a8e7a4e16ef2bf6600e7c175529c18ba8008350aa0f1fd72acfd2bc3c50664eba62133ea85341f0b4ec0c3618f3738401a42ce1fc3592b9642716c47152c9e52881fac74773f705c15b7737e0831ced7a0f8371245c36152deacfd18a947b3f3c83a30652958dd9614b7beef8aa8b5cdb157462ac85cca98a10e6ec5efafdd593179f2f56c4febb1ae6f1d72a9661fd8ed51032b98467d16a6e8e6bfb427838659b8df567ca38ec17c979560bee66d1ab72f372d38efa3e51e7ad3ab06b5610e0631db0a385101b45d0fe47c25610213aa023208289e3f0845bc2197d57ac44b4a808b30aef09a344f80062bd75a1844715d3d0cf55d95f2fefda6a1bab5796626fbb6345796ef134109de55bd61654f54c71f16eb795694ab923473ee66eaa59bbf61de8f8dfa94c481cb4f224b3ba90ec87318c3ec099e1aeb3d63840ccba2159386cb3d71481ef18b5466901b71cdc6e75e1ce807182d1b89fcbaff954b80d8a58d49c953c05a64e2a326cb3ae4802a0f9f29719e2b60002727f32b49638ac3c1d4addc61cb260c4ac99307ba24a7743ad52f325d4f32b8477cbd99a218c2e4ecb3171cab016c51cd800663bec05624f1072775db17ff93e8b807067572c97cbc7321e9690b8fc4f193eb0f1a93ce96a5c20cf7cc3dbf579b54af41204b2451098724e9d8940bd4cabff1605f33592e5f002817dd14edab5e60dde89c66b3c93dc057c53b926b2077d63d2dbbf9316bd64c2bb1b35df3f9ce28954fbe15eb52a08aa70453112cc94ad923616aec0553dfce0d5e44001e7b139917b4cd2d32bca418f24f44bd7ffa16edc47ff8178efee06f28630c2816b74f232864deeea9073bdc2128d704d2375431c7bb196825b0ba890b5ecd90caa2107b346a40472b9972bdca3e388e38a2914e2c1f022a82d49b4f"), - Bytes.FromHexString("0eefcc4248b67e40298c48e0ed47dca1dbf6f6e377506899430b11bf03b17ede10c71a49ccfb43f8475de84b581eef9ab283c1238e172bf48150f29e1e56201204c9eaee6321d6ee36b8670498aa1c73665f3ecc7350c8ee09a573e692d26320171450a989ebe50e365b92d24c311fd830972e7b16a2523e634175c4e24c884a1a6bf429331081e6e930bd36e23bdf91bb8180a6e4129c11655cb9468093ceba0e9d0caa4d47983e49ee253051aaefd86cc6dd367384f89e2d166bd721c658122a55d1dc0b4bd2f33984f0099a6d44c85baa10aaca32d0ec89e494d24514a68c2d43c0e6576ec46f88dbdcc7c57d685a3eb9342ba7c71b62de9e6373bd9094ff0a716e218f8e4174821a7dc090fa93b7683e2a6e363afe3eb7287a7dcbf9ea090dada034b037e05a7c8b232b8c691b7f0c3b9a870d786e913d936f8256f2e8c0131bdc0ab71a147cb4d91bba85941c00ec91994d2e9e53b1929a14ee2e876dff021d8b2738aed0201234d3919498c918fd5340541ec616542d92d955df4c182902237ac6c6802585c60640eefde7c05fbdf206a5ec25dc3411a4e9b4e6b57be611bbc865815ccfb7c666b117834cbf2a7edd9c2baa691ee3d453c3652c49761b234be3f502cdf3d1e6258eb846afca7acb0fe13577e226ddd277daf32d1d0c5c25e39a0be0435820302ccb2763016b10d0dbde867c745fe86cfba8cc925a2eb72d4bb48beada74cddc1c791a980d9bf7601ce0aec444354a5c02185d392f66f50e4860e017fc0453fd1bb0453197ff5abfacd35b90e7d9b03ff0900cc857ef7f2f0ccd45b2e137fd53d99d027b79aa390ac021bf4d6aa95cc96bacd6a071386e21f73cf3d42f0ed82ca6f673bb89223e16386c7328385edb01eadd4ce28e5ab418861414b0b511cc6300bd0cc6c95538014be8a4a20d8cf56d74f4a63225302b1f065e5ce6c676af04344de377f580aad377dab935d532f2dce9daeb0f31d6900af84aeeab7ebb4390e6bbb4218558fba894959f2cc2fef8af5d1c16998a38c6076f86dbd858db5b0b15ca2cddb0092ef861188e0434f4232d7e3e884fa42bba"), - Bytes.FromHexString("05fa7cb22fb8809abb745dc167279147fa174e0444cfc99a38f23f2b93e49ad62f7f94d2d206264a9358b54fc96ac31921948cf3c13d121c923991f0b47c04291b2582586c93d23816aac8ce2f90eb913e554211251bc9a2d64dd2efb9a905b80f73f8ca76c166aa5735d9370cf944306abfcac5a5874cc95b00b569f7eba01a1d92dac05e6fe60b5131a0d2e9c459d4b3deaf1a462332b285f90a25e5b61c211467961e060894bc8111abdbb66365b9da4a6700f2d530ae69289d2cc32185d004951597c8a0547ea22859b97dd87a37a8b4125bfcb513eff29e0bcae7a7dab00cb314388716efc2bee7b4294811db5bacaa3bcf720932e253f002b53e968f930bfa9409e358a1370c298a8cb622a0079bd7bf1a0e32e8f8dde7a0f56877945d2f95f233ceb61db914a2fc789bd35b3df37f62329a886194450ccc9e708d900c1fec898ed485e2970646f939313b33a6d3416476fcb249a96f6f11d030093f890621cd7af05f335e3514d7f10972f2b56614e917d9c4cb85178cce40f09a2291211e5387ed32f8c6f90d4c90d60fb08844a0fe0786717113aaf8060208331d3a03558a26134672a33a540774a5a994c549f2ec4e048e99c45f6f44692fa09ecf2d625e843fb3c186d9502acb5c9c3e6d0402ed815d76cf081e3ed847bdf8b0db0caddcd63f8dbab0b1ffdd45ae118ad1dcd7c1306c75a1f448a0e610994e5f300c058a66f63de3e94c81e96dd0cba0182c1371f61006d4cf9c9e24cc439d0cac280db62277ae92b4403f31d0bef2674900f1c21a0fb715b5cad4689154bbf53c2430b990502a5231b79e63246d15293a37918adf641bc8f8b18462909c8d1eea14434c1a33eb5a3b425729a7885db91c54240d3e8049c3d10811709dc86e71ed08d9b41714cb20a4d28f608d83b541cf998bef0ea0257f477e00c180b4e8ae4a0698e1e77ae24715eddf432eb950c3e26972a08521c31c484a733ce217b944f6190db804087bf4786ccbde4b6e149f2471121b29b6cb21d1f7baa6be1ad6ef18295d7425b744106a6fefb550e079074b1933af2bcf989c833a5f133f8e1c490e"), - Bytes.FromHexString("273cc7b93b70bbfde8748d62210c033579947802560fd05dad9d65003482995b1b7379946dee0b15e90720dfff72cbb60b60b5aaa8490ed2b77e8f57a8906d1816836ad1a19ace6e0feaa4195ee6006280ce178b5987341221c6ae618794c10603ea811d60c99786835aff3871ef0163cdceec010fd806bd11adeae2a91f4cb6179a512e9627d2af3dfc8a36850e144c7255568b3154d41797e2ac4782234925047ecbe78073575c62a32129476a6456c61545eb98bbf925ae1d673a32d680e71f20ccd414fe03613ff7a3d330ab8bf8964cba66cdf3af8bb955cdc729014e692ef7c335beb80626f05301278f5e3b228bcc981736a258ea6bc4802392f081de265db5dda279bf034808ed23c8613341b31d3d29a2f65a367024af1376d1bb9907b7ed2f35386382b00fb0afa6c5643c170010e35824d8fc84d3604690fa18b404685df83549a5573c7228b29a7dde8679d8771a19e8af709ca46c60f8126e4b033a388adb6c574f85524ff523bc7c44b49c8731b763836e0a4ebf054f0008492b60683ad457d04d91f082e169606c6e5d6e172845fe586925db00a8e6a242c409a8c11d9bd07c2ebbdd653519e9a0f5d29576033ebab9a564e1b07d8909b014232fdeb565d57fecdf556f1b9753361e8d7ceaef0d4778b4669643a8f980ed9107e310cfb6db05062d60b0810fa4aa6ff9825ebc58ae839c844f82ad08d9a273161549f2d3778e678f8167640fde4f43d30f2f60d7ec8cc83673d0e5100235e405c743fcac26a09a44bfb9bbd6f767ccf6dd030879dae04027353dcbfc9a89af0f566f9e06f1a6035c08bd9873e41dc3bf009005f905fc0b9b74ea57a16c5a2411c984cf6d6d274f79bec9cea6021001d0729f412858eda5c909d8bdce6a24980d28d7ff8a6bc01cf9ba50e6613c5495f13a39ced02158862b29579c4cb0e947142fa8592c012a3038fe1178bcb515a016a06651e387087a9110ac43ea9548a520537d116ead0e2498e487613ebb81ef0f6f5210cb448e92f2cda4a4f57013ed1f922e1c90d8e8891a308adec863c0b48faf4b7581e0565ded5a8ac6bccdee08"), - Bytes.FromHexString("22f2e1830cea84486d7ff320365a5ead50d356379d7bc4f2b9d77dd298f36fd8087baa2aad4fd8bbca8cc0b525041e1b17aeb3ecc63086cdc6fd1ec2310bb8db243fe8ce837f106ef17e387f9d78df833811427d5338c83f0622f92a65101da31ab23d2eb26b70ff15decd58baf91a68ec85f149012d481da67f806b0571c9471928767c9a5576ba5fbd7cee08203e6de3d9dd36a756fc621700031081a80b7e1aee70334cfaeec2f7551368818353fbd5810266c7d1ba49de47cec9b81b6e82007aed597093879d894ea438d094f3373b51f31bd5993e026e76502bcb1334e32189a92e9df00c0b5c21811462933dd17a5328075b472a53ca61bd9e136701571e529e7c4912cb565a3819473e8cb2c45e0a7b17a63f11e509d80472921e86f92fabe095002240b012e60bc9159383bdbf515def6c41acf180adde6913625a7b11d22c04a21962ecdcb1b679168cc14899e2912f233ed37d116cbde2110af4861ca847018951f8d71a369874541390d23df3cf9e5031655d4e7af4affdda5ec50fb5b633ac619c06ff0312901dc9d949ddb443ded5f59662788c101859ed0cab1782bd118c15612ab18ecaeeb9226a0145c0c1d01428987b8a5523c6da78e015261c22b6d73323e863964a003fb93594743f70e9248ed6898776780a7f3ae7a41b07a0d873b1ece5c55c6c942a7c7249c3d9026fcc607a68fe6e73cd4a76a6821f86065d5e87ffecc2c47bbd85658eb21bbdacdb79f23b031a8c6df93e64574c06eb93cb065183692c4ae4dff2efd51615d926782da50054e4a280c5bafb913d02369aa17493b4fccafbe637b1b7c9e1225e7b6fb24720f778548e304e7617b407e83fd6e3da09599850d6399059fadd57c4fadb492f59ad3adb4783ccda65272f190a9ca862a6d9508d9b2513edecf47aaa4fdc7a64127dcccbe64b7f206d400148ee9fc305099c6a7334452f25473a58edc7161895ab52e3590ea600e2e885010b062ce0df9974072bf87f5a1c8072df23e612b254b688084b5958314efe190bb6fb66657b45e6f81fa7c5fd41004f815ffd08ec00cb46ced2b1f97b04e69b"), - Bytes.FromHexString("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"), - Bytes.FromHexString("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"), - Bytes.FromHexString("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"), - Bytes.FromHexString("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"), - Bytes.FromHexString("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"), - Bytes.FromHexString("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"), - Bytes.FromHexString("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"), - Bytes.FromHexString("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"), - Bytes.FromHexString("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"), - Bytes.FromHexString("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"), - }; - - for (int i = 0; i < inputs.Length; i++) - { - byte[] cloned = inputs[i].Clone() as byte[]; - IPrecompile precompile = Bn254PairingPrecompile.Instance; - _ = precompile.Run(cloned, MuirGlacier.Instance); - } - } -} diff --git a/src/Nethermind/Nethermind.Evm.Test/Eip1108Tests.cs b/src/Nethermind/Nethermind.Evm.Test/Eip1108Tests.cs index 3a41d38d74d..12724009977 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Eip1108Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Eip1108Tests.cs @@ -2,8 +2,8 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Specs; -using Nethermind.Evm.Precompiles.Snarks; using NUnit.Framework; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Test; @@ -26,7 +26,7 @@ public void Test_add_before_istanbul() { _blockNumberAdjustment = -1; byte[] code = Prepare.EvmCode - .CallWithInput(Bn254AddPrecompile.Address, 1000L, new byte[128]) + .CallWithInput(BN254AddPrecompile.Address, 1000L, new byte[128]) .Done; TestAllTracerWithOutput result = Execute(code); Assert.That(result.StatusCode, Is.EqualTo(StatusCode.Success)); @@ -37,7 +37,7 @@ public void Test_add_before_istanbul() public void Test_add_after_istanbul() { byte[] code = Prepare.EvmCode - .CallWithInput(Bn254AddPrecompile.Address, 1000L, new byte[128]) + .CallWithInput(BN254AddPrecompile.Address, 1000L, new byte[128]) .Done; TestAllTracerWithOutput result = Execute(code); Assert.That(result.StatusCode, Is.EqualTo(StatusCode.Success)); @@ -49,7 +49,7 @@ public void Test_mul_before_istanbul() { _blockNumberAdjustment = -1; byte[] code = Prepare.EvmCode - .CallWithInput(Bn254MulPrecompile.Address, 50000L, new byte[128]) + .CallWithInput(BN254MulPrecompile.Address, 50000L, new byte[128]) .Done; TestAllTracerWithOutput result = Execute(code); Assert.That(result.StatusCode, Is.EqualTo(StatusCode.Success)); @@ -60,7 +60,7 @@ public void Test_mul_before_istanbul() public void Test_mul_after_istanbul() { byte[] code = Prepare.EvmCode - .CallWithInput(Bn254MulPrecompile.Address, 10000L, new byte[128]) + .CallWithInput(BN254MulPrecompile.Address, 10000L, new byte[128]) .Done; TestAllTracerWithOutput result = Execute(code); Assert.That(result.StatusCode, Is.EqualTo(StatusCode.Success)); @@ -72,7 +72,7 @@ public void Test_pairing_before_istanbul() { _blockNumberAdjustment = -1; byte[] code = Prepare.EvmCode - .CallWithInput(Bn254PairingPrecompile.Address, 200000L, new byte[192]) + .CallWithInput(BN254PairingPrecompile.Address, 200000L, new byte[192]) .Done; TestAllTracerWithOutput result = Execute(BlockNumber, 1000000L, code); Assert.That(result.StatusCode, Is.EqualTo(StatusCode.Success)); @@ -83,7 +83,7 @@ public void Test_pairing_before_istanbul() public void Test_pairing_after_istanbul() { byte[] code = Prepare.EvmCode - .CallWithInput(Bn254PairingPrecompile.Address, 200000L, new byte[192]) + .CallWithInput(BN254PairingPrecompile.Address, 200000L, new byte[192]) .Done; TestAllTracerWithOutput result = Execute(BlockNumber, 1000000L, code); Assert.That(result.StatusCode, Is.EqualTo(StatusCode.Success)); diff --git a/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj b/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj index 19204858cf8..968541ac1aa 100644 --- a/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj +++ b/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj @@ -10,10 +10,4 @@ - - - - - - diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/IPrecompile.cs b/src/Nethermind/Nethermind.Evm/Precompiles/IPrecompile.cs index 945cd177de1..b6f3c929476 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/IPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm/Precompiles/IPrecompile.cs @@ -10,7 +10,7 @@ namespace Nethermind.Evm.Precompiles public interface IPrecompile { static virtual Address Address => Address.Zero; - static virtual string Name => ""; + static virtual string Name => string.Empty; long BaseGasCost(IReleaseSpec releaseSpec); diff --git a/src/Nethermind/Nethermind.Precompiles.Benchmark/Bn254AddBenchmark.cs b/src/Nethermind/Nethermind.Precompiles.Benchmark/BN254AddBenchmark.cs similarity index 72% rename from src/Nethermind/Nethermind.Precompiles.Benchmark/Bn254AddBenchmark.cs rename to src/Nethermind/Nethermind.Precompiles.Benchmark/BN254AddBenchmark.cs index 70fad31a0f4..580095c0a3a 100644 --- a/src/Nethermind/Nethermind.Precompiles.Benchmark/Bn254AddBenchmark.cs +++ b/src/Nethermind/Nethermind.Precompiles.Benchmark/BN254AddBenchmark.cs @@ -3,15 +3,14 @@ using System.Collections.Generic; using Nethermind.Evm.Precompiles; -using Nethermind.Evm.Precompiles.Snarks; namespace Nethermind.Precompiles.Benchmark; -public class Bn254AddBenchmark : PrecompileBenchmarkBase +public class BN254AddBenchmark : PrecompileBenchmarkBase { protected override IEnumerable Precompiles => new[] { - Bn254AddPrecompile.Instance + BN254AddPrecompile.Instance }; protected override string InputsDirectory => "bnadd"; diff --git a/src/Nethermind/Nethermind.Precompiles.Benchmark/Bn254MulBenchmark.cs b/src/Nethermind/Nethermind.Precompiles.Benchmark/BN254MulBenchmark.cs similarity index 72% rename from src/Nethermind/Nethermind.Precompiles.Benchmark/Bn254MulBenchmark.cs rename to src/Nethermind/Nethermind.Precompiles.Benchmark/BN254MulBenchmark.cs index 75e2566f5a8..a9e9b1d9695 100644 --- a/src/Nethermind/Nethermind.Precompiles.Benchmark/Bn254MulBenchmark.cs +++ b/src/Nethermind/Nethermind.Precompiles.Benchmark/BN254MulBenchmark.cs @@ -3,15 +3,14 @@ using System.Collections.Generic; using Nethermind.Evm.Precompiles; -using Nethermind.Evm.Precompiles.Snarks; namespace Nethermind.Precompiles.Benchmark; -public class Bn254MulBenchmark : PrecompileBenchmarkBase +public class BN254MulBenchmark : PrecompileBenchmarkBase { protected override IEnumerable Precompiles => new[] { - Bn254MulPrecompile.Instance + BN254MulPrecompile.Instance }; protected override string InputsDirectory => "bnmul"; diff --git a/src/Nethermind/Nethermind.Precompiles.Benchmark/Bn254PairingBenchmark.cs b/src/Nethermind/Nethermind.Precompiles.Benchmark/BN254PairingBenchmark.cs similarity index 71% rename from src/Nethermind/Nethermind.Precompiles.Benchmark/Bn254PairingBenchmark.cs rename to src/Nethermind/Nethermind.Precompiles.Benchmark/BN254PairingBenchmark.cs index 75afae7838a..93ea0a11a82 100644 --- a/src/Nethermind/Nethermind.Precompiles.Benchmark/Bn254PairingBenchmark.cs +++ b/src/Nethermind/Nethermind.Precompiles.Benchmark/BN254PairingBenchmark.cs @@ -3,15 +3,14 @@ using System.Collections.Generic; using Nethermind.Evm.Precompiles; -using Nethermind.Evm.Precompiles.Snarks; namespace Nethermind.Precompiles.Benchmark; -public class Bn254PairingBenchmark : PrecompileBenchmarkBase +public class BN254PairingBenchmark : PrecompileBenchmarkBase { protected override IEnumerable Precompiles => new[] { - Bn254PairingPrecompile.Instance + BN254PairingPrecompile.Instance }; protected override string InputsDirectory => "bnpair"; From c7366456e049790368b51bf0e82fc55cc144e3e5 Mon Sep 17 00:00:00 2001 From: Ruben Buniatyan Date: Thu, 17 Jul 2025 18:37:00 +0200 Subject: [PATCH 25/40] Unify BN254 naming (#9004) --- src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs | 2 +- .../Nethermind.Core/Specs/ReleaseSpecDecorator.cs | 2 +- src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs | 2 +- .../Nethermind.Evm/Precompiles/AddressExtensions.cs | 6 +++--- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs b/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs index f3250d2437f..ef0163a626c 100644 --- a/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs @@ -402,7 +402,7 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec public bool ModExpEnabled => IsEip198Enabled; - public bool Bn128Enabled => IsEip196Enabled && IsEip197Enabled; + public bool BN254Enabled => IsEip196Enabled && IsEip197Enabled; public bool BlakeEnabled => IsEip152Enabled; diff --git a/src/Nethermind/Nethermind.Core/Specs/ReleaseSpecDecorator.cs b/src/Nethermind/Nethermind.Core/Specs/ReleaseSpecDecorator.cs index 2da9efc5a45..65aef9301ec 100644 --- a/src/Nethermind/Nethermind.Core/Specs/ReleaseSpecDecorator.cs +++ b/src/Nethermind/Nethermind.Core/Specs/ReleaseSpecDecorator.cs @@ -112,7 +112,7 @@ public class ReleaseSpecDecorator(IReleaseSpec spec) : IReleaseSpec public virtual bool UseTxAccessLists => spec.UseTxAccessLists; public virtual bool AddCoinbaseToTxAccessList => spec.AddCoinbaseToTxAccessList; public virtual bool ModExpEnabled => spec.ModExpEnabled; - public virtual bool Bn128Enabled => spec.Bn128Enabled; + public virtual bool BN254Enabled => spec.BN254Enabled; public virtual bool BlakeEnabled => spec.BlakeEnabled; public virtual bool Bls381Enabled => spec.Bls381Enabled; public virtual bool ChargeForTopLevelCreate => spec.ChargeForTopLevelCreate; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs b/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs index b7b9b425d5b..834de118fe2 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/Extensions.cs @@ -24,7 +24,7 @@ public static OrderedDictionary ListPrecompiles(this IReleaseSp AddPrecompile(); } - if (spec.Bn128Enabled) + if (spec.BN254Enabled) { AddPrecompile(); AddPrecompile(); diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/AddressExtensions.cs b/src/Nethermind/Nethermind.Evm/Precompiles/AddressExtensions.cs index eb6392747bb..2ea5c2f3dbb 100644 --- a/src/Nethermind/Nethermind.Evm/Precompiles/AddressExtensions.cs +++ b/src/Nethermind/Nethermind.Evm/Precompiles/AddressExtensions.cs @@ -24,9 +24,9 @@ public static bool IsPrecompile(this Address address, IReleaseSpec releaseSpec) 0x03 => true, 0x04 => true, 0x05 => releaseSpec.ModExpEnabled, - 0x06 => releaseSpec.Bn128Enabled, - 0x07 => releaseSpec.Bn128Enabled, - 0x08 => releaseSpec.Bn128Enabled, + 0x06 => releaseSpec.BN254Enabled, + 0x07 => releaseSpec.BN254Enabled, + 0x08 => releaseSpec.BN254Enabled, 0x09 => releaseSpec.BlakeEnabled, 0x0a => releaseSpec.IsEip4844Enabled, 0x0b => releaseSpec.Bls381Enabled, From 763442dff456f16c14c0b995a63e49be859d78c1 Mon Sep 17 00:00:00 2001 From: Amirul Ashraf Date: Fri, 18 Jul 2025 14:06:20 +0800 Subject: [PATCH 26/40] Refactor/Move init DB to DI (#8997) --- .../Nethermind.Api/BasicApiExtensions.cs | 5 - .../Nethermind.Api/IApiWithStores.cs | 2 +- src/Nethermind/Nethermind.Api/IBasicApi.cs | 3 +- .../Nethermind.Api/NethermindApi.cs | 6 +- .../Nethermind.AuRa.Test/AuRaPluginTests.cs | 1 - .../FullPruning/FullPruningDiskTest.cs | 19 ++- .../Producers/DevBlockproducerTests.cs | 100 +++----------- .../Nethermind.Blockchain.Test/ReorgTests.cs | 1 + .../KeyedMapperRegistrationSourceTests.cs | 25 ++++ .../Db/TestMemDbProvider.cs | 44 ++++++ .../Modules/PseudoNethermindModule.cs | 1 - .../Modules/TestBlockProcessingModule.cs | 2 +- .../Modules/TestEnvironmentModule.cs | 1 - .../TestWorldStateFactory.cs | 1 + .../KeyedMapperRegistrationSource.cs | 48 +++++++ .../ContainerBuilderExtensions.cs | 5 + .../Nethermind.Db.Rocks/RocksDbFactory.cs | 7 + .../Nethermind.Db.Test/DbProviderTests.cs | 62 --------- .../Nethermind.Db.Test/DbTrackerTests.cs | 33 +++++ .../ReadOnlyDbProviderTests.cs | 3 +- .../Rpc/RpcDbFactoryTests.cs | 12 +- .../StandardDbInitializerTests.cs | 38 ++++-- src/Nethermind/Nethermind.Db/DbModule.cs | 84 ------------ src/Nethermind/Nethermind.Db/DbProvider.cs | 80 +---------- src/Nethermind/Nethermind.Db/DbTracker.cs | 46 +++++++ src/Nethermind/Nethermind.Db/IDbProvider.cs | 5 - .../Nethermind.Db/ReadOnlyDbProvider.cs | 15 --- .../Nethermind.Db/RocksDbInitializer.cs | 83 ------------ .../Nethermind.Db/StandardDbInitializer.cs | 77 ----------- .../Nethermind.Db/TestMemDbProvider.cs | 27 ---- .../VirtualMachineTestsBase.cs | 1 + .../Rbuilder/RbuilderRpcModuleTests.cs | 1 + .../InitDatabaseSnapshot.cs | 2 +- .../Modules/ContainerBuilderExtensions.cs | 25 ++++ .../Nethermind.Init/Modules/DbModule.cs | 126 ++++++++++++++++++ .../Modules/NethermindModule.cs | 15 ++- .../Modules/WorldStateModule.cs | 19 +++ .../Nethermind.Init/Steps/InitDatabase.cs | 81 +---------- .../Steps/InitializeBlockchain.cs | 1 - .../Nethermind.Init/Steps/StartMonitoring.cs | 5 +- .../Modules/ParityRpcModuleTests.cs | 1 + .../Modules/Proof/ProofRpcModuleTests.cs | 1 + .../Nethermind.JsonRpc.TraceStore.csproj | 1 + .../TraceStorePlugin.cs | 24 +++- .../TraceStorePruner.cs | 8 ++ .../AuRaMergeEngineModuleTests.cs | 1 - .../MergePluginTests.cs | 1 - .../InitializeBlockchainOptimism.cs | 1 - .../Ethereum/ContextWithMocks.cs | 1 - .../EthereumRunnerTests.cs | 2 - .../Nethermind.State.Test/StateReaderTests.cs | 1 + .../WorldStateManagerTests.cs | 1 + .../SnapSync/SnapServerTest.cs | 22 ++- .../TestSynchronizerModule.cs | 7 +- .../InitializeBlockchainTaiko.cs | 1 - .../Nethermind.Taiko/TaikoPlugin.cs | 4 +- .../OverlayTrieStoreTests.cs | 1 + .../Pruning/TreeStoreTests.cs | 1 + .../PruningScenariosTests.cs | 1 + 59 files changed, 532 insertions(+), 660 deletions(-) create mode 100644 src/Nethermind/Nethermind.Core.Test/Container/KeyedMapperRegistrationSourceTests.cs create mode 100644 src/Nethermind/Nethermind.Core.Test/Db/TestMemDbProvider.cs create mode 100644 src/Nethermind/Nethermind.Core/Container/KeyedMapperRegistrationSource.cs delete mode 100644 src/Nethermind/Nethermind.Db.Test/DbProviderTests.cs create mode 100644 src/Nethermind/Nethermind.Db.Test/DbTrackerTests.cs delete mode 100644 src/Nethermind/Nethermind.Db/DbModule.cs create mode 100644 src/Nethermind/Nethermind.Db/DbTracker.cs delete mode 100644 src/Nethermind/Nethermind.Db/RocksDbInitializer.cs delete mode 100644 src/Nethermind/Nethermind.Db/StandardDbInitializer.cs delete mode 100644 src/Nethermind/Nethermind.Db/TestMemDbProvider.cs create mode 100644 src/Nethermind/Nethermind.Init/Modules/DbModule.cs diff --git a/src/Nethermind/Nethermind.Api/BasicApiExtensions.cs b/src/Nethermind/Nethermind.Api/BasicApiExtensions.cs index 6afb0a78299..9f8fa9db333 100644 --- a/src/Nethermind/Nethermind.Api/BasicApiExtensions.cs +++ b/src/Nethermind/Nethermind.Api/BasicApiExtensions.cs @@ -12,10 +12,5 @@ public static T Config(this IBasicApi api) where T : IConfig { return api.ConfigProvider.GetConfig(); } - - public static T Db(this IBasicApi api, string dbName) where T : class, IDb - { - return api.DbProvider!.GetDb(dbName); - } } } diff --git a/src/Nethermind/Nethermind.Api/IApiWithStores.cs b/src/Nethermind/Nethermind.Api/IApiWithStores.cs index e14288276da..5ee936c38d6 100644 --- a/src/Nethermind/Nethermind.Api/IApiWithStores.cs +++ b/src/Nethermind/Nethermind.Api/IApiWithStores.cs @@ -17,7 +17,7 @@ namespace Nethermind.Api { public interface IApiWithStores : IBasicApi { - IBlobTxStorage? BlobTxStorage { get; set; } + IBlobTxStorage BlobTxStorage { get; } IBlockTree? BlockTree { get; set; } IBloomStorage? BloomStorage { get; set; } IChainLevelInfoRepository? ChainLevelInfoRepository { get; set; } diff --git a/src/Nethermind/Nethermind.Api/IBasicApi.cs b/src/Nethermind/Nethermind.Api/IBasicApi.cs index 5acfe0e6c14..d1dcc2260b7 100644 --- a/src/Nethermind/Nethermind.Api/IBasicApi.cs +++ b/src/Nethermind/Nethermind.Api/IBasicApi.cs @@ -30,8 +30,7 @@ public interface IBasicApi [SkipServiceCollection] IConfigProvider ConfigProvider { get; } ICryptoRandom CryptoRandom { get; } - IDbProvider? DbProvider { get; set; } - IDbFactory? DbFactory { get; set; } + IDbProvider DbProvider { get; } IEthereumEcdsa EthereumEcdsa { get; } [SkipServiceCollection] IJsonSerializer EthereumJsonSerializer { get; } diff --git a/src/Nethermind/Nethermind.Api/NethermindApi.cs b/src/Nethermind/Nethermind.Api/NethermindApi.cs index 853f0e71fa0..bf9f7af369c 100644 --- a/src/Nethermind/Nethermind.Api/NethermindApi.cs +++ b/src/Nethermind/Nethermind.Api/NethermindApi.cs @@ -4,7 +4,6 @@ using System.Collections.Generic; using System.IO.Abstractions; using Autofac; -using Nethermind.Abi; using Nethermind.Api.Extensions; using Nethermind.Blockchain; using Nethermind.Blockchain.Blocks; @@ -71,7 +70,7 @@ public IBlockchainBridge CreateBlockchainBridge() return Context.Resolve().CreateBlockchainBridge(); } - public IBlobTxStorage? BlobTxStorage { get; set; } + public IBlobTxStorage BlobTxStorage => Context.Resolve(); public CompositeBlockPreprocessorStep BlockPreprocessor { get; } = new(); public IBlockProcessingQueue? BlockProcessingQueue { get; set; } public IBlockProducer? BlockProducer { get; set; } @@ -82,8 +81,7 @@ public IBlockchainBridge CreateBlockchainBridge() public IChainLevelInfoRepository? ChainLevelInfoRepository { get; set; } public IConfigProvider ConfigProvider => _dependencies.ConfigProvider; public ICryptoRandom CryptoRandom => Context.Resolve(); - public IDbProvider? DbProvider { get; set; } - public IDbFactory? DbFactory { get; set; } + public IDbProvider DbProvider => Context.Resolve(); public ISigner? EngineSigner { get; set; } public ISignerStore? EngineSignerStore { get; set; } public IEnode? Enode { get; set; } diff --git a/src/Nethermind/Nethermind.AuRa.Test/AuRaPluginTests.cs b/src/Nethermind/Nethermind.AuRa.Test/AuRaPluginTests.cs index 7e5c393078a..d520f50b3c1 100644 --- a/src/Nethermind/Nethermind.AuRa.Test/AuRaPluginTests.cs +++ b/src/Nethermind/Nethermind.AuRa.Test/AuRaPluginTests.cs @@ -43,7 +43,6 @@ public void Init_when_not_AuRa_doesnt_trow() Substitute.For(), testNethermindContainer); AuRaNethermindApi api = new AuRaNethermindApi(apiDependencies); - api.DbProvider = TestMemDbProvider.Init(); Action init = () => auRaPlugin.Init(api); init.Should().NotThrow(); } diff --git a/src/Nethermind/Nethermind.Blockchain.Test/FullPruning/FullPruningDiskTest.cs b/src/Nethermind/Nethermind.Blockchain.Test/FullPruning/FullPruningDiskTest.cs index e01f5edfb9f..735c602aa5d 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/FullPruning/FullPruningDiskTest.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/FullPruning/FullPruningDiskTest.cs @@ -10,6 +10,7 @@ using System.Threading.Tasks; using Autofac; using FluentAssertions; +using Nethermind.Api; using Nethermind.Blockchain.FullPruning; using Nethermind.Config; using Nethermind.Core; @@ -75,16 +76,14 @@ protected override async Task Build(Action? co return chain; } - protected override ContainerBuilder ConfigureContainer(ContainerBuilder builder, IConfigProvider configProvider) - { - IDbProvider dbProvider = new DbProvider(); - RocksDbFactory rocksDbFactory = new(new DbConfig(), LimboLogs.Instance, TempDirectory.Path); - StandardDbInitializer standardDbInitializer = new(dbProvider, rocksDbFactory, new FileSystem()); - standardDbInitializer.InitStandardDbs(true); - - return base.ConfigureContainer(builder, configProvider) - .AddSingleton(dbProvider); - } + protected override ContainerBuilder ConfigureContainer(ContainerBuilder builder, IConfigProvider configProvider) => + // Reenable rocksdb + base.ConfigureContainer(builder, configProvider) + .AddSingleton() + .Intercept((initConfig) => + { + initConfig.BaseDbPath = TempDirectory.Path; + }); public override void Dispose() { diff --git a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs index 76890d2dbee..87e39b16a3a 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs @@ -2,30 +2,16 @@ // SPDX-License-Identifier: LGPL-3.0-only using System.Threading; +using Autofac; using FluentAssertions; -using Nethermind.Blockchain.BeaconBlockRoot; -using Nethermind.Blockchain.Blocks; -using Nethermind.Blockchain.Receipts; -using Nethermind.Config; +using Nethermind.Api; using Nethermind.Consensus; -using Nethermind.Consensus.ExecutionRequests; -using Nethermind.Consensus.Processing; using Nethermind.Consensus.Producers; -using Nethermind.Consensus.Rewards; using Nethermind.Consensus.Transactions; using Nethermind.Consensus.Validators; -using Nethermind.Consensus.Withdrawals; using Nethermind.Core; -using Nethermind.Core.Specs; -using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; -using Nethermind.Db; -using Nethermind.Evm; -using Nethermind.Evm.TransactionProcessing; -using Nethermind.Logging; -using Nethermind.Specs; -using Nethermind.Evm.State; -using Nethermind.State; +using Nethermind.Core.Test.Modules; using NUnit.Framework; namespace Nethermind.Blockchain.Test.Producers; @@ -35,70 +21,18 @@ public class DevBlockProducerTests [Test, MaxTime(Timeout.MaxTestTime)] public void Test() { - ISpecProvider specProvider = MainnetSpecProvider.Instance; - DbProvider dbProvider = new(); - dbProvider.RegisterDb(DbNames.BlockInfos, new MemDb()); - dbProvider.RegisterDb(DbNames.Blocks, new MemDb()); - dbProvider.RegisterDb(DbNames.Headers, new MemDb()); - dbProvider.RegisterDb(DbNames.State, new MemDb()); - dbProvider.RegisterDb(DbNames.Code, new MemDb()); - dbProvider.RegisterDb(DbNames.Metadata, new MemDb()); + using IContainer container = new ContainerBuilder() + .AddModule(new TestNethermindModule()) + .AddSingleton(Always.Valid) + .AddSingleton() + .AddScoped>() + .Build(); - BlockTree blockTree = Build.A.BlockTree() - .WithoutSettingHead - .TestObject; + IBlockTree blockTree = container.Resolve(); + IManualBlockProductionTrigger trigger = container.Resolve(); - IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(dbProvider, LimboLogs.Instance); - IWorldState stateProvider = worldStateManager.GlobalWorldState; - IStateReader stateReader = worldStateManager.GlobalStateReader; - BlockhashProvider blockhashProvider = new(blockTree, specProvider, stateProvider, LimboLogs.Instance); - EthereumCodeInfoRepository codeInfoRepository = new(); - VirtualMachine virtualMachine = new( - blockhashProvider, - specProvider, - LimboLogs.Instance); - TransactionProcessor txProcessor = new( - specProvider, - stateProvider, - virtualMachine, - codeInfoRepository, - LimboLogs.Instance); - BlockProcessor blockProcessor = new BlockProcessor( - specProvider, - Always.Valid, - NoBlockRewards.Instance, - new BlockProcessor.BlockValidationTransactionsExecutor(new ExecuteTransactionProcessorAdapter(txProcessor), stateProvider), - stateProvider, - NullReceiptStorage.Instance, - new BeaconBlockRootHandler(txProcessor, stateProvider), - new BlockhashStore(specProvider, stateProvider), - LimboLogs.Instance, - new WithdrawalProcessor(stateProvider, LimboLogs.Instance), - new ExecutionRequestsProcessor(txProcessor)); - BlockchainProcessor blockchainProcessor = new( - blockTree, - blockProcessor, - NullRecoveryStep.Instance, - stateReader, - LimboLogs.Instance, - BlockchainProcessor.Options.Default); - BuildBlocksWhenRequested trigger = new(); - ManualTimestamper timestamper = new ManualTimestamper(); - DevBlockProducer devBlockProducer = new( - EmptyTxSource.Instance, - blockchainProcessor, - stateProvider, - blockTree, - timestamper, - specProvider, - new BlocksConfig(), - LimboLogs.Instance); - - StandardBlockProducerRunner blockProducerRunner = new StandardBlockProducerRunner(trigger, blockTree, devBlockProducer); - - blockchainProcessor.Start(); - blockProducerRunner.Start(); - ProducedBlockSuggester _ = new ProducedBlockSuggester(blockTree, blockProducerRunner); + container.Resolve().BlockchainProcessor.Start(); + container.Resolve().Start(); AutoResetEvent autoResetEvent = new(false); @@ -111,4 +45,12 @@ public void Test() autoResetEvent.WaitOne(1000).Should().BeTrue("1"); blockTree.Head!.Number.Should().Be(1); } + + private class EmptyTxSourceFactory : IBlockProducerTxSourceFactory + { + public ITxSource Create() + { + return EmptyTxSource.Instance; + } + } } diff --git a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs index 18bc2db36d2..bf5d76667bd 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs @@ -17,6 +17,7 @@ using Nethermind.Core.Specs; using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; +using Nethermind.Core.Test.Db; using Nethermind.Crypto; using Nethermind.Db; using Nethermind.Evm; diff --git a/src/Nethermind/Nethermind.Core.Test/Container/KeyedMapperRegistrationSourceTests.cs b/src/Nethermind/Nethermind.Core.Test/Container/KeyedMapperRegistrationSourceTests.cs new file mode 100644 index 00000000000..9b697e1c3c6 --- /dev/null +++ b/src/Nethermind/Nethermind.Core.Test/Container/KeyedMapperRegistrationSourceTests.cs @@ -0,0 +1,25 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Autofac; +using FluentAssertions; +using NUnit.Framework; + +namespace Nethermind.Core.Test.Container; + +public class KeyedMapperRegistrationSourceTests +{ + [Test] + public void TestCanMap() + { + using IContainer cont = new ContainerBuilder() + .AddKeyedSingleton("Key", new ClassA("Property1")) + .AddKeyedAdapter((a) => new ClassB(a.Property)) + .Build(); + + cont.ResolveKeyed("Key").Property.Should().Be("Property1"); + } + + private record ClassA(string Property); + private record ClassB(string Property); +} diff --git a/src/Nethermind/Nethermind.Core.Test/Db/TestMemDbProvider.cs b/src/Nethermind/Nethermind.Core.Test/Db/TestMemDbProvider.cs new file mode 100644 index 00000000000..b13c69f5aff --- /dev/null +++ b/src/Nethermind/Nethermind.Core.Test/Db/TestMemDbProvider.cs @@ -0,0 +1,44 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + + +using System; +using System.Threading.Tasks; +using Autofac; +using Nethermind.Api; +using Nethermind.Blockchain.Receipts; +using Nethermind.Blockchain.Synchronization; +using Nethermind.Db; +using Nethermind.Init.Modules; + +namespace Nethermind.Core.Test.Db +{ + public class TestMemDbProvider + { + public static Task InitAsync() + { + return Task.FromResult(Init()); + } + + public static IDbProvider Init() + { + return new ContainerBuilder() + .AddModule(new DbModule(new InitConfig() { DiagnosticMode = DiagnosticMode.MemDb }, new ReceiptConfig(), new SyncConfig())) + .AddSingleton() + .Build() + .Resolve(); + } + } + + /// + /// Like , but also dispose lifetime scope. Useful for existing test to make sure + /// container is disposed properly. + /// + public class ContainerOwningDbProvider(ILifetimeScope ctx) : DbProvider(ctx), IDisposable + { + public override void Dispose() + { + ctx.Dispose(); + } + } +} diff --git a/src/Nethermind/Nethermind.Core.Test/Modules/PseudoNethermindModule.cs b/src/Nethermind/Nethermind.Core.Test/Modules/PseudoNethermindModule.cs index c141f4418e9..5d2a0f13e2a 100644 --- a/src/Nethermind/Nethermind.Core.Test/Modules/PseudoNethermindModule.cs +++ b/src/Nethermind/Nethermind.Core.Test/Modules/PseudoNethermindModule.cs @@ -61,7 +61,6 @@ protected override void Load(ContainerBuilder builder) initConfig.BackgroundTaskMaxNumber, logManager)) .AddSingleton(new FileSystem()) - .AddSingleton(new DbProvider()) .AddSingleton(new ProcessExitSource(default)) .AddSingleton() diff --git a/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs b/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs index 86730bb5863..07434083950 100644 --- a/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs +++ b/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs @@ -115,7 +115,7 @@ private MainBlockProcessingContext ConfigureMainBlockProcessingContext(ILifetime return innerScope.Resolve(); } - private class AutoBlockProducerFactory(ILifetimeScope rootLifetime, IBlockProducerEnvFactory producerEnvFactory) : IBlockProducerFactory where T : IBlockProducer + public class AutoBlockProducerFactory(ILifetimeScope rootLifetime, IBlockProducerEnvFactory producerEnvFactory) : IBlockProducerFactory where T : IBlockProducer { public IBlockProducer InitBlockProducer() { diff --git a/src/Nethermind/Nethermind.Core.Test/Modules/TestEnvironmentModule.cs b/src/Nethermind/Nethermind.Core.Test/Modules/TestEnvironmentModule.cs index 664c4a0c3cb..90b4e668fb9 100644 --- a/src/Nethermind/Nethermind.Core.Test/Modules/TestEnvironmentModule.cs +++ b/src/Nethermind/Nethermind.Core.Test/Modules/TestEnvironmentModule.cs @@ -39,7 +39,6 @@ protected override void Load(ContainerBuilder builder) builder .AddSingleton(new TestLogManager(LogLevel.Error)) // Limbologs actually have IsTrace set to true, so actually slow. .AddSingleton((_) => new MemDbFactory()) - .AddSingleton(TestMemDbProvider.Init()) // These two dont use db provider .AddKeyedSingleton(DbNames.PeersDb, (_) => new MemDb()) .AddKeyedSingleton(DbNames.DiscoveryNodes, (_) => new MemDb()) diff --git a/src/Nethermind/Nethermind.Core.Test/TestWorldStateFactory.cs b/src/Nethermind/Nethermind.Core.Test/TestWorldStateFactory.cs index 27517c12d8f..afe1a55f29a 100644 --- a/src/Nethermind/Nethermind.Core.Test/TestWorldStateFactory.cs +++ b/src/Nethermind/Nethermind.Core.Test/TestWorldStateFactory.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Consensus.Validators; +using Nethermind.Core.Test.Db; using Nethermind.Db; using Nethermind.Logging; using Nethermind.Evm.State; diff --git a/src/Nethermind/Nethermind.Core/Container/KeyedMapperRegistrationSource.cs b/src/Nethermind/Nethermind.Core/Container/KeyedMapperRegistrationSource.cs new file mode 100644 index 00000000000..dd0e7b21ed1 --- /dev/null +++ b/src/Nethermind/Nethermind.Core/Container/KeyedMapperRegistrationSource.cs @@ -0,0 +1,48 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Collections.Generic; +using System.Linq; +using Autofac; +using Autofac.Core; +using Autofac.Core.Activators.Delegate; +using Autofac.Core.Lifetime; +using Autofac.Core.Registration; + +namespace Nethermind.Core.Container; + +/// +/// Utility that map between two type that act on keyed service. +/// +/// +/// +/// +public class KeyedMapperRegistrationSource(Func mapper) : IRegistrationSource where TFrom : notnull +{ + public IEnumerable RegistrationsFor(Service service, Func> registrationAccessor) + { + if (service is not KeyedService keyedService || keyedService.ServiceType != typeof(TTo)) + { + // Not a keyed service + return Enumerable.Empty(); + } + + ComponentRegistration registration = new ComponentRegistration( + Guid.NewGuid(), + new DelegateActivator(keyedService.ServiceType, (c, p) => + { + TFrom from = c.ResolveKeyed(keyedService.ServiceKey); + return mapper(from)!; + }), + new RootScopeLifetime(), + InstanceSharing.Shared, + InstanceOwnership.OwnedByLifetimeScope, + new[] { service }, + new Dictionary()); + + return [registration]; + } + + public bool IsAdapterForIndividualComponents => true; +} diff --git a/src/Nethermind/Nethermind.Core/ContainerBuilderExtensions.cs b/src/Nethermind/Nethermind.Core/ContainerBuilderExtensions.cs index b33a3e412c4..0fe01a8c5ca 100644 --- a/src/Nethermind/Nethermind.Core/ContainerBuilderExtensions.cs +++ b/src/Nethermind/Nethermind.Core/ContainerBuilderExtensions.cs @@ -486,6 +486,11 @@ public static IRegistrationBuilder Fixed(this reg.RegistrationData.Options |= RegistrationOptions.Fixed; return reg; } + + public static ContainerBuilder AddKeyedAdapter(this ContainerBuilder builder, Func mapper) where TFrom : notnull + { + return builder.AddSource(new KeyedMapperRegistrationSource(mapper)); + } } /// diff --git a/src/Nethermind/Nethermind.Db.Rocks/RocksDbFactory.cs b/src/Nethermind/Nethermind.Db.Rocks/RocksDbFactory.cs index 53eb3eb7c50..e0c02bbbe04 100644 --- a/src/Nethermind/Nethermind.Db.Rocks/RocksDbFactory.cs +++ b/src/Nethermind/Nethermind.Db.Rocks/RocksDbFactory.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using System; +using Nethermind.Api; using Nethermind.Db.Rocks.Config; using Nethermind.Logging; @@ -17,6 +18,12 @@ public class RocksDbFactory : IDbFactory private readonly IntPtr _sharedCache; + public RocksDbFactory(IDbConfig dbConfig, IInitConfig initConfig, ILogManager logManager) + : this(dbConfig, logManager, initConfig.BaseDbPath) + { + + } + public RocksDbFactory(IDbConfig dbConfig, ILogManager logManager, string basePath) { _dbConfig = dbConfig; diff --git a/src/Nethermind/Nethermind.Db.Test/DbProviderTests.cs b/src/Nethermind/Nethermind.Db.Test/DbProviderTests.cs deleted file mode 100644 index edc441243f8..00000000000 --- a/src/Nethermind/Nethermind.Db.Test/DbProviderTests.cs +++ /dev/null @@ -1,62 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using NUnit.Framework; - -namespace Nethermind.Db.Test; - -[Parallelizable(ParallelScope.All)] -public class DbProviderTests -{ - [Test] - public void DbProvider_CanRegisterMemDb() - { - MemDbFactory memDbFactory = new MemDbFactory(); - using (DbProvider dbProvider = new DbProvider()) - { - IDb memDb = memDbFactory.CreateDb(new DbSettings("MemDb", "MemDb")); - dbProvider.RegisterDb("MemDb", memDb); - IDb db = dbProvider.GetDb("MemDb"); - Assert.That(db, Is.EqualTo(memDb)); - } - } - - [Test] - public void DbProvider_CanRegisterColumnsDb() - { - using (DbProvider dbProvider = new DbProvider()) - { - MemDbFactory memDbFactory = new MemDbFactory(); - IColumnsDb memSnapshotableDb = memDbFactory.CreateColumnsDb("ColumnsDb"); - dbProvider.RegisterColumnDb("ColumnsDb", memSnapshotableDb); - IColumnsDb columnsDb = dbProvider.GetColumnDb("ColumnsDb"); - Assert.That(columnsDb, Is.EqualTo(memSnapshotableDb)); - Assert.That(memSnapshotableDb is IColumnsDb, Is.True); - } - } - - [Test] - public void DbProvider_ThrowExceptionOnRegisteringTheSameDb() - { - using (DbProvider dbProvider = new DbProvider()) - { - MemDbFactory memDbFactory = new MemDbFactory(); - IColumnsDb memSnapshotableDb = memDbFactory.CreateColumnsDb("ColumnsDb"); - dbProvider.RegisterColumnDb("ColumnsDb", memSnapshotableDb); - Assert.Throws(() => dbProvider.RegisterColumnDb("columnsdb", new MemColumnsDb())); - } - } - - [Test] - public void DbProvider_ThrowExceptionOnGettingNotRegisteredDb() - { - using (DbProvider dbProvider = new DbProvider()) - { - MemDbFactory memDbFactory = new MemDbFactory(); - IColumnsDb memSnapshotableDb = memDbFactory.CreateColumnsDb("ColumnsDb"); - dbProvider.RegisterColumnDb("ColumnsDb", memSnapshotableDb); - Assert.Throws(() => dbProvider.GetColumnDb("differentdb")); - } - } -} diff --git a/src/Nethermind/Nethermind.Db.Test/DbTrackerTests.cs b/src/Nethermind/Nethermind.Db.Test/DbTrackerTests.cs new file mode 100644 index 00000000000..27a1344fc3f --- /dev/null +++ b/src/Nethermind/Nethermind.Db.Test/DbTrackerTests.cs @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: LGPL-3.0-only + +using System.Linq; +using Autofac; +using FluentAssertions; +using Nethermind.Core; +using NUnit.Framework; + +namespace Nethermind.Db.Test; + +public class DbTrackerTests +{ + [Test] + public void TestTrackOnlyCreatedDb() + { + using IContainer container = new ContainerBuilder() + .AddSingleton() + .AddDecorator() + .AddSingleton() + .Build(); + + IDbFactory dbFactory = container.Resolve(); + + DbTracker tracker = container.Resolve(); + tracker.GetAllDbMeta().Count().Should().Be(0); + + dbFactory.CreateDb(new DbSettings("TestDb", "TestDb")); + + tracker.GetAllDbMeta().Count().Should().Be(1); + var firstEntry = tracker.GetAllDbMeta().First(); + firstEntry.Key.Should().Be("TestDb"); + } +} diff --git a/src/Nethermind/Nethermind.Db.Test/ReadOnlyDbProviderTests.cs b/src/Nethermind/Nethermind.Db.Test/ReadOnlyDbProviderTests.cs index 5bb30423e2d..7bbeaa18d68 100644 --- a/src/Nethermind/Nethermind.Db.Test/ReadOnlyDbProviderTests.cs +++ b/src/Nethermind/Nethermind.Db.Test/ReadOnlyDbProviderTests.cs @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using NSubstitute; using NUnit.Framework; namespace Nethermind.Db.Test @@ -12,7 +13,7 @@ public class ReadOnlyDbProviderTests [TestCase(false)] public void Can_clear(bool localChanges) { - ReadOnlyDbProvider dbProvider = new(new DbProvider(), localChanges); + ReadOnlyDbProvider dbProvider = new(Substitute.For(), localChanges); dbProvider.ClearTempChanges(); } } diff --git a/src/Nethermind/Nethermind.Db.Test/Rpc/RpcDbFactoryTests.cs b/src/Nethermind/Nethermind.Db.Test/Rpc/RpcDbFactoryTests.cs index 276b7251286..09b1d477fbb 100644 --- a/src/Nethermind/Nethermind.Db.Test/Rpc/RpcDbFactoryTests.cs +++ b/src/Nethermind/Nethermind.Db.Test/Rpc/RpcDbFactoryTests.cs @@ -2,7 +2,10 @@ // SPDX-License-Identifier: LGPL-3.0-only using System.IO.Abstractions; +using Autofac; using FluentAssertions; +using Nethermind.Core; +using Nethermind.Core.Test.Modules; using Nethermind.Db.FullPruning; using Nethermind.Db.Rpc; using Nethermind.JsonRpc.Client; @@ -31,9 +34,12 @@ static void ValidateDb(params object[] dbs) IJsonRpcClient jsonRpcClient = Substitute.For(); IDbFactory rpcDbFactory = new RpcDbFactory(new MemDbFactory(), jsonSerializer, jsonRpcClient, LimboLogs.Instance); - IDbProvider memDbProvider = new DbProvider(); - StandardDbInitializer standardDbInitializer = new(memDbProvider, rpcDbFactory, Substitute.For()); - standardDbInitializer.InitStandardDbs(true); + using IContainer container = new ContainerBuilder() + .AddModule(new TestNethermindModule()) + .AddSingleton(rpcDbFactory) + .Build(); + + IDbProvider memDbProvider = container.Resolve(); ValidateDb>( memDbProvider.ReceiptsDb); diff --git a/src/Nethermind/Nethermind.Db.Test/StandardDbInitializerTests.cs b/src/Nethermind/Nethermind.Db.Test/StandardDbInitializerTests.cs index 6b927954aae..c47dfff4c42 100644 --- a/src/Nethermind/Nethermind.Db.Test/StandardDbInitializerTests.cs +++ b/src/Nethermind/Nethermind.Db.Test/StandardDbInitializerTests.cs @@ -5,10 +5,17 @@ using System.IO; using System.IO.Abstractions; using System.Threading.Tasks; +using Autofac; using FluentAssertions; +using Nethermind.Api; +using Nethermind.Blockchain.Receipts; +using Nethermind.Blockchain.Synchronization; +using Nethermind.Core; +using Nethermind.Core.Test.Db; using Nethermind.Db.FullPruning; using Nethermind.Db.Rocks; using Nethermind.Db.Rocks.Config; +using Nethermind.Init.Modules; using Nethermind.Logging; using NSubstitute; using NUnit.Framework; @@ -66,16 +73,31 @@ public async Task InitializerTests_WithPruning() dbProvider.StateDb.Should().BeOfType(); } - private async Task InitializeStandardDb(bool useReceipts, bool useMemDb, string path) + private Task InitializeStandardDb(bool useReceipts, bool useMemDb, string path) { - IDbProvider dbProvider = new DbProvider(); - IDbFactory dbFactory = useMemDb - ? new MemDbFactory() - : new RocksDbFactory(new DbConfig(), LimboLogs.Instance, Path.Combine(_folderWithDbs, path)); + IInitConfig initConfig = new InitConfig() + { + DiagnosticMode = useMemDb ? DiagnosticMode.MemDb : DiagnosticMode.None, + BaseDbPath = path + }; - StandardDbInitializer initializer = new(dbProvider, dbFactory, Substitute.For()); - await initializer.InitStandardDbsAsync(useReceipts); - return dbProvider; + IContainer container = new ContainerBuilder() + .AddModule(new DbModule(initConfig, new ReceiptConfig() + { + StoreReceipts = useReceipts + }, new SyncConfig() + { + DownloadReceiptsInFastSync = useReceipts + })) + .AddModule(new WorldStateModule(initConfig)) // For the full pruning db + .AddSingleton(new DbConfig()) + .AddSingleton(initConfig) + .AddSingleton(LimboLogs.Instance) + .AddSingleton() + .AddSingleton() + .Build(); + + return Task.FromResult(container.Resolve()); } private static Type GetReceiptsType(bool useReceipts, Type receiptType = null) => useReceipts ? receiptType ?? typeof(ColumnsDb) : typeof(ReadOnlyColumnsDb); diff --git a/src/Nethermind/Nethermind.Db/DbModule.cs b/src/Nethermind/Nethermind.Db/DbModule.cs deleted file mode 100644 index 9405740570a..00000000000 --- a/src/Nethermind/Nethermind.Db/DbModule.cs +++ /dev/null @@ -1,84 +0,0 @@ -// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using Autofac; -using Nethermind.Core; - -namespace Nethermind.Db; - -public class DbModule : Module -{ - protected override void Load(ContainerBuilder builder) - { - base.Load(builder); - builder - .AddScoped((dbProvider) => dbProvider.AsReadOnly(false)); - - // TODO: Have hooks that automatically get these - string[] dbNames = [ - DbNames.State, - DbNames.Code, - DbNames.Metadata, - DbNames.BlockNumbers, - DbNames.BadBlocks, - DbNames.Blocks, - DbNames.Headers, - DbNames.BlockInfos, - DbNames.BadBlocks, - DbNames.Bloom, - DbNames.Metadata, - ]; - foreach (string dbName in dbNames) - { - ConfigureDb(builder, dbName); - } - - ConfigureColumnDb(builder, DbNames.Receipts); - } - - private static void ConfigureDb(ContainerBuilder builder, string dbName) - { - builder.Register((ctx) => - { - IDbProvider dbProvider = ctx.Resolve(); - IDb db = dbProvider.GetDb(dbName); - return db; - }) - .ExternallyOwned() - .Named(dbName) - .Named(dbName) - .Named(dbName) - .Named(dbName); - - builder.Register((ctx) => - { - IDbProvider dbProvider = ctx.Resolve(); - IDb db = dbProvider.GetDb(dbName); - return db as ITunableDb ?? new NoopTunableDb(); - }) - .ExternallyOwned() - .Named(dbName); - } - - - private static void ConfigureColumnDb(ContainerBuilder builder, string dbName) - { - builder.Register((ctx) => - { - IDbProvider dbProvider = ctx.Resolve(); - IColumnsDb db = dbProvider.GetColumnDb(dbName); - return db; - }) - .ExternallyOwned() - .As>(); - - builder.Register((ctx) => - { - IDbProvider dbProvider = ctx.Resolve(); - IColumnsDb db = dbProvider.GetColumnDb(dbName); - return db as ITunableDb ?? new NoopTunableDb(); - }) - .ExternallyOwned() - .Named(dbName); - } -} diff --git a/src/Nethermind/Nethermind.Db/DbProvider.cs b/src/Nethermind/Nethermind.Db/DbProvider.cs index bf7b9ee02e4..4c4583025ea 100644 --- a/src/Nethermind/Nethermind.Db/DbProvider.cs +++ b/src/Nethermind/Nethermind.Db/DbProvider.cs @@ -1,94 +1,24 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only -using System; -using System.Collections.Concurrent; -using System.Collections.Generic; -using System.IO; +using Autofac; namespace Nethermind.Db { - public class DbProvider : IDbProvider + public class DbProvider(IComponentContext ctx) : IDbProvider { - private readonly ConcurrentDictionary _registeredDbs = - new(StringComparer.InvariantCultureIgnoreCase); - private readonly ConcurrentDictionary _registeredColumnDbs = - new(StringComparer.InvariantCultureIgnoreCase); - - public IDictionary RegisteredDbs => _registeredDbs; - public IDictionary RegisteredColumnDbs => _registeredColumnDbs; - - public void Dispose() + public virtual void Dispose() { - foreach (KeyValuePair registeredDb in _registeredDbs) - { - registeredDb.Value?.Dispose(); - } } public T GetDb(string dbName) where T : class, IDb { - if (!_registeredDbs.TryGetValue(dbName, out IDb? found)) - { - throw new ArgumentException($"{dbName} database has not been registered in {nameof(DbProvider)}."); - } - - if (found is not T result) - { - throw new IOException( - $"An attempt was made to resolve DB {dbName} as {typeof(T)} while its type is {found.GetType()}."); - } - - return result; - } - - public void RegisterDb(string dbName, T db) where T : class, IDb - { - if (_registeredDbs.ContainsKey(dbName)) - { - throw new ArgumentException($"{dbName} has already registered."); - } - - _registeredDbs.TryAdd(dbName, db); + return (T)ctx.ResolveKeyed(dbName); } public IColumnsDb GetColumnDb(string dbName) { - if (!_registeredColumnDbs.TryGetValue(dbName, out object found)) - { - throw new ArgumentException($"{dbName} database has not been registered in {nameof(DbProvider)}."); - } - - if (found is not IColumnsDb result) - { - throw new IOException( - $"An attempt was made to resolve DB {dbName} as {typeof(T)} while its type is {found.GetType()}."); - } - - return result; - } - - public void RegisterColumnDb(string dbName, IColumnsDb db) - { - if (_registeredColumnDbs.ContainsKey(dbName)) - { - throw new ArgumentException($"{dbName} has already registered."); - } - - _registeredColumnDbs.TryAdd(dbName, db); - } - - public IEnumerable> GetAllDbMeta() - { - foreach (KeyValuePair kv in _registeredDbs) - { - yield return new KeyValuePair(kv.Key, kv.Value); - } - - foreach (KeyValuePair kv in _registeredColumnDbs) - { - yield return new KeyValuePair(kv.Key, (IDbMeta)kv.Value); - } + return ctx.Resolve>(); } } } diff --git a/src/Nethermind/Nethermind.Db/DbTracker.cs b/src/Nethermind/Nethermind.Db/DbTracker.cs new file mode 100644 index 00000000000..343d51f0d0f --- /dev/null +++ b/src/Nethermind/Nethermind.Db/DbTracker.cs @@ -0,0 +1,46 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Collections.Generic; +using NonBlocking; + +namespace Nethermind.Db; + +public class DbTracker +{ + private readonly ConcurrentDictionary _createdDbs = new ConcurrentDictionary(); + + public void AddDb(string name, IDbMeta dbMeta) + { + _createdDbs.TryAdd(name, dbMeta); + } + + public IEnumerable> GetAllDbMeta() + { + return _createdDbs; + } + + public class DbFactoryInterceptor(DbTracker tracker, IDbFactory baseFactory) : IDbFactory + { + public IDb CreateDb(DbSettings dbSettings) + { + IDb db = baseFactory.CreateDb(dbSettings); + if (db is IDbMeta dbMeta) + { + tracker.AddDb(dbSettings.DbName, dbMeta); + } + return db; + } + + public IColumnsDb CreateColumnsDb(DbSettings dbSettings) where T : struct, Enum + { + IColumnsDb db = baseFactory.CreateColumnsDb(dbSettings); + if (db is IDbMeta dbMeta) + { + tracker.AddDb(dbSettings.DbName, dbMeta); + } + return db; + } + } +} diff --git a/src/Nethermind/Nethermind.Db/IDbProvider.cs b/src/Nethermind/Nethermind.Db/IDbProvider.cs index 7786271bc74..038d70c3842 100644 --- a/src/Nethermind/Nethermind.Db/IDbProvider.cs +++ b/src/Nethermind/Nethermind.Db/IDbProvider.cs @@ -2,7 +2,6 @@ // SPDX-License-Identifier: LGPL-3.0-only using System; -using System.Collections.Generic; namespace Nethermind.Db { @@ -26,9 +25,5 @@ public interface IDbProvider : IDisposable T GetDb(string dbName) where T : class, IDb; IColumnsDb GetColumnDb(string dbName); - - void RegisterDb(string dbName, T db) where T : class, IDb; - void RegisterColumnDb(string dbName, IColumnsDb db); - IEnumerable> GetAllDbMeta(); } } diff --git a/src/Nethermind/Nethermind.Db/ReadOnlyDbProvider.cs b/src/Nethermind/Nethermind.Db/ReadOnlyDbProvider.cs index 60f10da4bbb..e3546012967 100644 --- a/src/Nethermind/Nethermind.Db/ReadOnlyDbProvider.cs +++ b/src/Nethermind/Nethermind.Db/ReadOnlyDbProvider.cs @@ -56,20 +56,5 @@ public IColumnsDb GetColumnDb(string dbName) .GetColumnDb(dbName) .CreateReadOnly(_createInMemoryWriteStore)); } - - public void RegisterDb(string dbName, T db) where T : class, IDb - { - _wrappedProvider.RegisterDb(dbName, db); - } - - public void RegisterColumnDb(string dbName, IColumnsDb db) - { - _wrappedProvider.RegisterColumnDb(dbName, db); - } - - public IEnumerable> GetAllDbMeta() - { - return _wrappedProvider.GetAllDbMeta(); - } } } diff --git a/src/Nethermind/Nethermind.Db/RocksDbInitializer.cs b/src/Nethermind/Nethermind.Db/RocksDbInitializer.cs deleted file mode 100644 index 26be4d0ff27..00000000000 --- a/src/Nethermind/Nethermind.Db/RocksDbInitializer.cs +++ /dev/null @@ -1,83 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using System.Collections.Generic; -using System.Threading.Tasks; -using Nethermind.Core.Collections; - -namespace Nethermind.Db -{ - public abstract class RocksDbInitializer - { - private readonly IDbProvider _dbProvider; - protected IDbFactory DbFactory { get; } - - private readonly List _registrations = new(); - - protected RocksDbInitializer(IDbProvider? dbProvider, IDbFactory? dbFactory) - { - _dbProvider = dbProvider ?? throw new ArgumentNullException(nameof(dbProvider)); - DbFactory = dbFactory ?? NullDbFactory.Instance; - } - - protected void RegisterCustomDb(string dbName, Func dbFunc) - { - void Action() - { - IDb db = dbFunc(); - _dbProvider.RegisterDb(dbName, db); - } - - _registrations.Add(Action); - } - - protected void RegisterCustomColumnDb(string dbName, Func> dbFunc) - { - void Action() - { - IColumnsDb db = dbFunc(); - _dbProvider.RegisterColumnDb(dbName, db); - } - - _registrations.Add(Action); - } - - protected void RegisterDb(DbSettings settings) => - AddRegisterAction(settings.DbName, () => CreateDb(settings)); - - protected void RegisterColumnsDb(DbSettings settings) where T : struct, Enum => - AddRegisterAction(settings.DbName, () => CreateColumnDb(settings)); - - private void AddRegisterAction(string dbName, Func dbCreation) => - _registrations.Add(() => _dbProvider.RegisterDb(dbName, dbCreation())); - private void AddRegisterAction(string dbName, Func> dbCreation) => - _registrations.Add(() => _dbProvider.RegisterColumnDb(dbName, dbCreation())); - - private IDb CreateDb(DbSettings settings) => DbFactory.CreateDb(settings); - - private IColumnsDb CreateColumnDb(DbSettings settings) where T : struct, Enum => - DbFactory.CreateColumnsDb(settings); - - protected void InitAll() - { - foreach (var registration in _registrations) - { - registration.Invoke(); - } - } - - protected async Task InitAllAsync() - { - using ArrayPoolList allInitializers = new(_registrations.Count); - foreach (Action registration in _registrations) - { - allInitializers.Add(Task.Run(() => registration.Invoke())); - } - - await Task.WhenAll(allInitializers.AsSpan()); - } - - protected static string GetTitleDbName(string dbName) => char.ToUpper(dbName[0]) + dbName[1..]; - } -} diff --git a/src/Nethermind/Nethermind.Db/StandardDbInitializer.cs b/src/Nethermind/Nethermind.Db/StandardDbInitializer.cs deleted file mode 100644 index 8a91bd8a4bc..00000000000 --- a/src/Nethermind/Nethermind.Db/StandardDbInitializer.cs +++ /dev/null @@ -1,77 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System.IO.Abstractions; -using System.Threading; -using System.Threading.Tasks; -using Nethermind.Db.FullPruning; - -namespace Nethermind.Db -{ - public class StandardDbInitializer : RocksDbInitializer - { - private readonly IFileSystem _fileSystem; - - public StandardDbInitializer( - IDbProvider? dbProvider, - IDbFactory? rocksDbFactory, - IFileSystem? fileSystem = null) - : base(dbProvider, rocksDbFactory) - { - _fileSystem = fileSystem ?? new FileSystem(); - } - - public void InitStandardDbs(bool useReceiptsDb, bool useBlobsDb = true) - { - RegisterAll(useReceiptsDb, useBlobsDb); - InitAll(); - } - - public Task InitStandardDbsAsync(bool useReceiptsDb, bool useBlobsDb = true) - { - RegisterAll(useReceiptsDb, useBlobsDb); - return InitAllAsync(); - } - - private void RegisterAll(bool useReceiptsDb, bool useBlobsDb) - { - RegisterDb(BuildDbSettings(DbNames.Blocks)); - RegisterDb(BuildDbSettings(DbNames.Headers)); - RegisterDb(BuildDbSettings(DbNames.BlockNumbers)); - RegisterDb(BuildDbSettings(DbNames.BlockInfos)); - RegisterDb(BuildDbSettings(DbNames.BadBlocks)); - - DbSettings stateDbSettings = BuildDbSettings(DbNames.State); - RegisterCustomDb(DbNames.State, () => new FullPruningDb( - stateDbSettings, - DbFactory is not MemDbFactory - ? new FullPruningInnerDbFactory(DbFactory, _fileSystem, stateDbSettings.DbPath) - : DbFactory, - () => Interlocked.Increment(ref Metrics.StateDbInPruningWrites))); - - RegisterDb(BuildDbSettings(DbNames.Code)); - RegisterDb(BuildDbSettings(DbNames.Bloom)); - if (useReceiptsDb) - { - RegisterColumnsDb(BuildDbSettings(DbNames.Receipts)); - } - else - { - RegisterCustomColumnDb(DbNames.Receipts, () => new ReadOnlyColumnsDb(new MemColumnsDb(), false)); - } - RegisterDb(BuildDbSettings(DbNames.Metadata)); - if (useBlobsDb) - { - RegisterColumnsDb(BuildDbSettings(DbNames.BlobTransactions)); - } - } - - private static DbSettings BuildDbSettings(string dbName, bool deleteOnStart = false) - { - return new(GetTitleDbName(dbName), dbName) - { - DeleteOnStart = deleteOnStart - }; - } - } -} diff --git a/src/Nethermind/Nethermind.Db/TestMemDbProvider.cs b/src/Nethermind/Nethermind.Db/TestMemDbProvider.cs deleted file mode 100644 index b8276b5a583..00000000000 --- a/src/Nethermind/Nethermind.Db/TestMemDbProvider.cs +++ /dev/null @@ -1,27 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - - -using System.Threading.Tasks; - -namespace Nethermind.Db -{ - public class TestMemDbProvider - { - public static async Task InitAsync() - { - IDbProvider memDbProvider = new DbProvider(); - StandardDbInitializer? standardDbInitializer = new StandardDbInitializer(memDbProvider, new MemDbFactory()); - await standardDbInitializer.InitStandardDbsAsync(true); - return memDbProvider; - } - - public static IDbProvider Init() - { - IDbProvider memDbProvider = new DbProvider(); - StandardDbInitializer? standardDbInitializer = new StandardDbInitializer(memDbProvider, new MemDbFactory()); - standardDbInitializer.InitStandardDbs(true); - return memDbProvider; - } - } -} diff --git a/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs b/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs index 1232894276d..18d2e3287ab 100644 --- a/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs +++ b/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs @@ -16,6 +16,7 @@ using Nethermind.Int256; using Nethermind.Evm.Tracing; using Nethermind.Blockchain.Tracing.GethStyle; +using Nethermind.Core.Test.Db; using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; using Nethermind.Evm.State; diff --git a/src/Nethermind/Nethermind.Flashbots.Test/Rbuilder/RbuilderRpcModuleTests.cs b/src/Nethermind/Nethermind.Flashbots.Test/Rbuilder/RbuilderRpcModuleTests.cs index e0030f64f47..fe5636f3110 100644 --- a/src/Nethermind/Nethermind.Flashbots.Test/Rbuilder/RbuilderRpcModuleTests.cs +++ b/src/Nethermind/Nethermind.Flashbots.Test/Rbuilder/RbuilderRpcModuleTests.cs @@ -10,6 +10,7 @@ using Nethermind.Core.Crypto; using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; +using Nethermind.Core.Test.Db; using Nethermind.Db; using Nethermind.Evm.TransactionProcessing; using Nethermind.Flashbots.Modules.Rbuilder; diff --git a/src/Nethermind/Nethermind.Init.Snapshot/InitDatabaseSnapshot.cs b/src/Nethermind/Nethermind.Init.Snapshot/InitDatabaseSnapshot.cs index f15a56c24c6..6481c384d23 100644 --- a/src/Nethermind/Nethermind.Init.Snapshot/InitDatabaseSnapshot.cs +++ b/src/Nethermind/Nethermind.Init.Snapshot/InitDatabaseSnapshot.cs @@ -19,7 +19,7 @@ public class InitDatabaseSnapshot : InitDatabase private readonly INethermindApi _api; private readonly ILogger _logger; - public InitDatabaseSnapshot(INethermindApi api) : base(api) + public InitDatabaseSnapshot(INethermindApi api) : base() { _api = api; _logger = _api.LogManager.GetClassLogger(); diff --git a/src/Nethermind/Nethermind.Init/Modules/ContainerBuilderExtensions.cs b/src/Nethermind/Nethermind.Init/Modules/ContainerBuilderExtensions.cs index 78835d53050..556179e7201 100644 --- a/src/Nethermind/Nethermind.Init/Modules/ContainerBuilderExtensions.cs +++ b/src/Nethermind/Nethermind.Init/Modules/ContainerBuilderExtensions.cs @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using System; using Autofac; using Nethermind.Api; using Nethermind.Core; @@ -41,4 +42,28 @@ public static ContainerBuilder AddNetworkStorage(this ContainerBuilder builder, return new NetworkStorage(db, logManager); }); } + + // Note: The convention for `dbName` is that it is camelCase. + // this is not necessarily true for plugins. More importantly, this is also the path. Use the second overload for a more + // explicit param. + public static ContainerBuilder AddDatabase(this ContainerBuilder builder, string dbName) => builder + .AddDatabase(dbName, GetTitleDbName(dbName), dbName); + + public static ContainerBuilder AddDatabase(this ContainerBuilder builder, string keyName, string dbName, string path) => builder + .AddKeyedSingleton(keyName, (ctx) => ctx.Resolve() + .CreateDb(new DbSettings(dbName, path))); + + public static ContainerBuilder AddColumnDatabase(this ContainerBuilder builder, string dbName) where T : struct, Enum => + builder + .AddSingleton>((ctx) => ctx.Resolve() + .CreateColumnsDb(new DbSettings(GetTitleDbName(dbName), dbName))) + + .AddKeyedSingleton(dbName, (ctx) => + { + IColumnsDb db = ctx.Resolve>(); + if (db is ITunableDb tunableDb) return tunableDb; + return new NoopTunableDb(); + }); + + private static string GetTitleDbName(string dbName) => char.ToUpper(dbName[0]) + dbName[1..]; } diff --git a/src/Nethermind/Nethermind.Init/Modules/DbModule.cs b/src/Nethermind/Nethermind.Init/Modules/DbModule.cs new file mode 100644 index 00000000000..e78d9604220 --- /dev/null +++ b/src/Nethermind/Nethermind.Init/Modules/DbModule.cs @@ -0,0 +1,126 @@ +// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using Autofac; +using Nethermind.Api; +using Nethermind.Blockchain.Receipts; +using Nethermind.Blockchain.Synchronization; +using Nethermind.Core; +using Nethermind.Db; +using Nethermind.Db.Rocks; +using Nethermind.Db.Rpc; +using Nethermind.JsonRpc.Client; +using Nethermind.Logging; +using Nethermind.Serialization.Json; + +namespace Nethermind.Init.Modules; + +/// +/// Declares the default database and some classes for utility functions. +/// Additional databases can be added by plugin using the or +/// DSL. These just create a keyed , +/// so plugins can override individual database separately. To override all, replace . +/// These are all lazy as usual and no database is created until a service that require them is created. +/// +/// +/// +/// +public class DbModule( + IInitConfig initConfig, + IReceiptConfig receiptConfig, + ISyncConfig syncConfig +) : Module +{ + protected override void Load(ContainerBuilder builder) + { + builder + .AddSingleton() + .AddSingleton() + .AddScoped((dbProvider) => dbProvider.AsReadOnly(false)) + + // Allow requesting keyed specialization instead of `IDb`. + .AddKeyedAdapter((db) => db) + .AddKeyedAdapter((db) => db) + .AddKeyedAdapter((db) => + { + if (db is ITunableDb tunableDb) return tunableDb; + return new NoopTunableDb(); + }) + .AddKeyedAdapter((kv) => kv) + + // Monitoring use these to track active db. We intercept db factory to keep them lazy. Does not + // track db that is not created by db factory though... + .AddSingleton() + .AddDecorator() + + .AddDatabase(DbNames.State) + .AddDatabase(DbNames.Code) + .AddDatabase(DbNames.Metadata) + .AddDatabase(DbNames.BlockNumbers) + .AddDatabase(DbNames.BadBlocks) + .AddDatabase(DbNames.Blocks) + .AddDatabase(DbNames.Headers) + .AddDatabase(DbNames.BlockInfos) + .AddDatabase(DbNames.BadBlocks) + .AddDatabase(DbNames.Bloom) + .AddDatabase(DbNames.Metadata) + .AddDatabase(DbNames.BlobTransactions) + + .AddColumnDatabase(DbNames.Receipts) + .AddColumnDatabase(DbNames.BlobTransactions) + ; + + switch (initConfig.DiagnosticMode) + { + case DiagnosticMode.MemDb: + builder.AddSingleton(); + break; + case DiagnosticMode.RpcDb: + builder.AddDecorator(CreateRpcDbFactory); + break; + case DiagnosticMode.ReadOnlyDb: + builder.AddDecorator(); + break; + } + + // Change receipt db to readonlycolumndb if receipt is disabled + bool useReceiptsDb = receiptConfig.StoreReceipts || syncConfig.DownloadReceiptsInFastSync; + if (!useReceiptsDb) + { + builder.AddSingleton>((_) => new ReadOnlyColumnsDb(new MemColumnsDb(), false)); + } + + } + + private IDbFactory CreateRpcDbFactory( + IComponentContext ctx, + IDbFactory baseDbFactory) + { + IJsonSerializer jsonSerializer = ctx.Resolve(); + ILogManager logManager = ctx.Resolve(); + + RpcDbFactory rpcDbFactory = new( + baseDbFactory, + jsonSerializer, + new BasicJsonRpcClient( + new Uri(initConfig.RpcDbUrl), + jsonSerializer, + logManager + ), logManager); + return rpcDbFactory; + } + + private class ReadOnlyDbFactory(IDbFactory baseDbFactory) : IDbFactory + { + public IDb CreateDb(DbSettings dbSettings) + { + return baseDbFactory.CreateDb(dbSettings).AsReadOnly(true); + } + + public IColumnsDb CreateColumnsDb(DbSettings dbSettings) where T : struct, Enum + { + return baseDbFactory.CreateColumnsDb(dbSettings).CreateReadOnly(true); + } + } +} diff --git a/src/Nethermind/Nethermind.Init/Modules/NethermindModule.cs b/src/Nethermind/Nethermind.Init/Modules/NethermindModule.cs index 811dd729f4b..5ba9059520d 100644 --- a/src/Nethermind/Nethermind.Init/Modules/NethermindModule.cs +++ b/src/Nethermind/Nethermind.Init/Modules/NethermindModule.cs @@ -8,14 +8,13 @@ using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Blockchain.Spec; +using Nethermind.Blockchain.Synchronization; using Nethermind.Config; using Nethermind.Core; using Nethermind.Core.ServiceStopper; using Nethermind.Core.Specs; using Nethermind.Crypto; -using Nethermind.Db; using Nethermind.Era1; -using Nethermind.Facade.Simulate; using Nethermind.JsonRpc; using Nethermind.Logging; using Nethermind.Network.Config; @@ -40,17 +39,22 @@ protected override void Load(ContainerBuilder builder) .AddModule(new AppInputModule(chainSpec, configProvider, logManager)) .AddModule(new NetworkModule(configProvider)) .AddModule(new DiscoveryModule(configProvider.GetConfig(), configProvider.GetConfig())) + .AddModule(new DbModule( + configProvider.GetConfig(), + configProvider.GetConfig(), + configProvider.GetConfig() + )) .AddModule(new WorldStateModule(configProvider.GetConfig())) .AddModule(new BuiltInStepsModule()) .AddModule(new RpcModules(configProvider.GetConfig())) .AddModule(new EraModule()) .AddSource(new ConfigRegistrationSource()) - .AddModule(new DbModule()) .AddModule(new BlockProcessingModule()) .AddSingleton() .Bind() .AddSingleton((bt) => bt.AsReadOnly()) + .AddSingleton() .AddKeyedSingleton(IProtectedPrivateKey.NodeKey, (ctx) => ctx.Resolve().NodeKey!) .AddSingleton(Nethermind.Abi.AbiEncoder.Instance) @@ -67,6 +71,11 @@ protected override void Load(ContainerBuilder builder) .AddSingleton() .Add() // Not a singleton so that dispose is registered to correct lifetime ; + + if (!configProvider.GetConfig().BlobsSupport.IsPersistentStorage()) + { + builder.AddSingleton(NullBlobTxStorage.Instance); + } } // Just a wrapper to make it clear, these three are expected to be available at the time of configurations. diff --git a/src/Nethermind/Nethermind.Init/Modules/WorldStateModule.cs b/src/Nethermind/Nethermind.Init/Modules/WorldStateModule.cs index 9f4ddc96c45..64f7db5d99f 100644 --- a/src/Nethermind/Nethermind.Init/Modules/WorldStateModule.cs +++ b/src/Nethermind/Nethermind.Init/Modules/WorldStateModule.cs @@ -1,6 +1,8 @@ // SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using System.IO.Abstractions; +using System.Threading; using Autofac; using Nethermind.Api; using Nethermind.Api.Steps; @@ -8,6 +10,7 @@ using Nethermind.Blockchain.Synchronization; using Nethermind.Core; using Nethermind.Db; +using Nethermind.Db.FullPruning; using Nethermind.Evm.State; using Nethermind.JsonRpc.Modules; using Nethermind.JsonRpc.Modules.Admin; @@ -23,6 +26,20 @@ protected override void Load(ContainerBuilder builder) { builder + // Special case for state db with pruning trie state. + .AddKeyedSingleton(DbNames.State, (ctx) => + { + DbSettings stateDbSettings = new DbSettings(GetTitleDbName(DbNames.State), DbNames.State); + IFileSystem fileSystem = ctx.Resolve(); + IDbFactory dbFactory = ctx.Resolve(); + return new FullPruningDb( + stateDbSettings, + dbFactory is not MemDbFactory + ? new FullPruningInnerDbFactory(dbFactory, fileSystem, stateDbSettings.DbPath) + : dbFactory, + () => Interlocked.Increment(ref Nethermind.Db.Metrics.StateDbInPruningWrites)); + }) + .AddSingleton(ctx => { IInitConfig initConfig = ctx.Resolve(); @@ -91,4 +108,6 @@ public PruningTrieStateFactoryOutput(PruningTrieStateFactory factory) AdminRpcModule = adminRpc; } } + + private static string GetTitleDbName(string dbName) => char.ToUpper(dbName[0]) + dbName[1..]; } diff --git a/src/Nethermind/Nethermind.Init/Steps/InitDatabase.cs b/src/Nethermind/Nethermind.Init/Steps/InitDatabase.cs index 8b540ac978c..6d737d25d8c 100644 --- a/src/Nethermind/Nethermind.Init/Steps/InitDatabase.cs +++ b/src/Nethermind/Nethermind.Init/Steps/InitDatabase.cs @@ -1,95 +1,24 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only -using System; -using System.IO; -using System.Reflection; using System.Threading; using System.Threading.Tasks; -using Nethermind.Api; using Nethermind.Api.Steps; -using Nethermind.Blockchain.Receipts; -using Nethermind.Blockchain.Synchronization; -using Nethermind.Db; -using Nethermind.Db.Rocks; -using Nethermind.Db.Rocks.Config; -using Nethermind.Db.Rpc; -using Nethermind.JsonRpc.Client; -using Nethermind.Logging; -using Nethermind.Trie; -using Nethermind.TxPool; +using Nethermind.Core.Attributes; namespace Nethermind.Init.Steps { [RunnerStepDependencies(typeof(ApplyMemoryHint))] + [Todo("Remove. Need to move `InitDatabaseSnapshot` to its own step also")] public class InitDatabase : IStep { - private readonly INethermindApi _api; - - public InitDatabase(INethermindApi api) - { - _api = api; - } - - public virtual async Task Execute(CancellationToken _) + public InitDatabase() { - ILogger logger = _api.LogManager.GetClassLogger(); - - /* sync */ - IDbConfig dbConfig = _api.Config(); - ISyncConfig syncConfig = _api.Config(); - IInitConfig initConfig = _api.Config(); - ITxPoolConfig txPoolConfig = _api.Config(); - IReceiptConfig receiptConfig = _api.Config(); - - foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties()) - { - if (logger.IsDebug) logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}"); - } - - try - { - bool useReceiptsDb = receiptConfig.StoreReceipts || syncConfig.DownloadReceiptsInFastSync; - bool useBlobsDb = txPoolConfig.BlobsSupport.IsPersistentStorage(); - InitDbApi(initConfig, dbConfig, receiptConfig.StoreReceipts || syncConfig.DownloadReceiptsInFastSync); - _api.DisposeStack.Push(_api.DbProvider!); - StandardDbInitializer dbInitializer = new(_api.DbProvider, _api.DbFactory, _api.FileSystem); - await dbInitializer.InitStandardDbsAsync(useReceiptsDb, useBlobsDb); - _api.BlobTxStorage = useBlobsDb - ? new BlobTxStorage(_api.DbProvider!.BlobTransactionsDb) - : NullBlobTxStorage.Instance; - } - catch (TypeInitializationException ex) - { - if (logger.IsError) - logger.Error("Failed loading RocksDB", ex); - } } - private void InitDbApi(IInitConfig initConfig, IDbConfig dbConfig, bool storeReceipts) + public virtual Task Execute(CancellationToken _) { - switch (initConfig.DiagnosticMode) - { - case DiagnosticMode.RpcDb: - _api.DbProvider = new DbProvider(); - RocksDbFactory rocksDbFactory = new(dbConfig, _api.LogManager, Path.Combine(initConfig.BaseDbPath, "debug")); - RpcDbFactory rpcDbFactory = new(rocksDbFactory, _api.EthereumJsonSerializer, new BasicJsonRpcClient(new Uri(initConfig.RpcDbUrl), _api.EthereumJsonSerializer, _api.LogManager), _api.LogManager); - _api.DbFactory = rpcDbFactory; - break; - case DiagnosticMode.ReadOnlyDb: - DbProvider rocksDbProvider = new(); - _api.DbProvider = new ReadOnlyDbProvider(rocksDbProvider, storeReceipts); // ToDo storeReceipts as createInMemoryWriteStore - bug? - _api.DbFactory = new RocksDbFactory(dbConfig, _api.LogManager, Path.Combine(initConfig.BaseDbPath, "debug")); - break; - case DiagnosticMode.MemDb: - _api.DbProvider = new DbProvider(); - _api.DbFactory = new MemDbFactory(); - break; - default: - _api.DbProvider = new DbProvider(); - _api.DbFactory = new RocksDbFactory(dbConfig, _api.LogManager, initConfig.BaseDbPath); - break; - } + return Task.CompletedTask; } } } diff --git a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs index 731ffbf8005..b47e18a5024 100644 --- a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs +++ b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs @@ -219,7 +219,6 @@ protected virtual BlockProcessor CreateBlockProcessor( ITransactionProcessor transactionProcessor, IWorldState worldState) { - if (_api.DbProvider is null) throw new StepDependencyException(nameof(_api.DbProvider)); if (_api.RewardCalculatorSource is null) throw new StepDependencyException(nameof(_api.RewardCalculatorSource)); if (_api.BlockTree is null) throw new StepDependencyException(nameof(_api.BlockTree)); if (_api.WorldStateManager is null) throw new StepDependencyException(nameof(_api.WorldStateManager)); diff --git a/src/Nethermind/Nethermind.Init/Steps/StartMonitoring.cs b/src/Nethermind/Nethermind.Init/Steps/StartMonitoring.cs index 92ad942412a..a06dfb91065 100644 --- a/src/Nethermind/Nethermind.Init/Steps/StartMonitoring.cs +++ b/src/Nethermind/Nethermind.Init/Steps/StartMonitoring.cs @@ -10,6 +10,7 @@ using Nethermind.Core.ServiceStopper; using Nethermind.Db; using Nethermind.Facade.Eth; +using Nethermind.Init.Modules; using Nethermind.Logging; using Nethermind.Monitoring; using Nethermind.Monitoring.Config; @@ -21,7 +22,7 @@ namespace Nethermind.Init.Steps; [RunnerStepDependencies(typeof(InitializeBlockTree))] public class StartMonitoring( IEthSyncingInfo ethSyncingInfo, - IDbProvider dbProvider, + DbTracker dbTracker, IPruningConfig pruningConfig, ISyncConfig syncConfig, IServiceStopper serviceStopper, @@ -86,7 +87,7 @@ private void SetupMetrics(IMonitoringService monitoringService) { monitoringService.AddMetricsUpdateAction(() => { - foreach (KeyValuePair kv in dbProvider.GetAllDbMeta()) + foreach (KeyValuePair kv in dbTracker.GetAllDbMeta()) { // Note: At the moment, the metric for a columns db is combined across column. IDbMeta.DbMetric dbMetric = kv.Value.GatherMetric(includeSharedCache: kv.Key == DbNames.State); // Only include shared cache if state db diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs index e44b8c61362..b64953e2c84 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs @@ -34,6 +34,7 @@ using NSubstitute; using NUnit.Framework; using System; +using Nethermind.Core.Test.Db; using Nethermind.State; namespace Nethermind.JsonRpc.Test.Modules diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Proof/ProofRpcModuleTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Proof/ProofRpcModuleTests.cs index e47a97788dc..87e775b08ee 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Proof/ProofRpcModuleTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Proof/ProofRpcModuleTests.cs @@ -30,6 +30,7 @@ using Nethermind.Core.Buffers; using Nethermind.Core.Specs; using Nethermind.Core.Test; +using Nethermind.Core.Test.Db; using Nethermind.Core.Test.Modules; using Nethermind.Evm.Tracing.State; using Nethermind.Facade.Eth.RpcTransaction; diff --git a/src/Nethermind/Nethermind.JsonRpc.TraceStore/Nethermind.JsonRpc.TraceStore.csproj b/src/Nethermind/Nethermind.JsonRpc.TraceStore/Nethermind.JsonRpc.TraceStore.csproj index f3d846e11e9..d4989e37be3 100644 --- a/src/Nethermind/Nethermind.JsonRpc.TraceStore/Nethermind.JsonRpc.TraceStore.csproj +++ b/src/Nethermind/Nethermind.JsonRpc.TraceStore/Nethermind.JsonRpc.TraceStore.csproj @@ -8,6 +8,7 @@ + diff --git a/src/Nethermind/Nethermind.JsonRpc.TraceStore/TraceStorePlugin.cs b/src/Nethermind/Nethermind.JsonRpc.TraceStore/TraceStorePlugin.cs index f77621415aa..fe69626430a 100644 --- a/src/Nethermind/Nethermind.JsonRpc.TraceStore/TraceStorePlugin.cs +++ b/src/Nethermind/Nethermind.JsonRpc.TraceStore/TraceStorePlugin.cs @@ -1,23 +1,27 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using Autofac; +using Autofac.Core; using Nethermind.Api; using Nethermind.Api.Extensions; using Nethermind.Db; using Nethermind.Blockchain.Tracing.ParityStyle; +using Nethermind.Core; using Nethermind.JsonRpc.Modules; using Nethermind.JsonRpc.Modules.Trace; using Nethermind.Logging; +using Nethermind.Init.Modules; namespace Nethermind.JsonRpc.TraceStore; public class TraceStorePlugin(ITraceStoreConfig traceStoreConfig) : INethermindPlugin { - private const string DbName = "TraceStore"; + public const string DbName = "TraceStore"; + private INethermindApi _api = null!; private IJsonRpcConfig _jsonRpcConfig = null!; private IDb? _db; - private TraceStorePruner? _pruner; private ILogManager _logManager = null!; private ILogger _logger; private ITraceSerializer? _traceSerializer; @@ -37,13 +41,12 @@ public Task Init(INethermindApi nethermindApi) _traceSerializer = new ParityLikeTraceSerializer(_logManager, traceStoreConfig.MaxDepth, traceStoreConfig.VerifySerialized); // Setup DB - _db = _api.DbFactory!.CreateDb(new DbSettings(DbName, DbName.ToLower())); - _api.DbProvider!.RegisterDb(DbName, _db); + _db = _api.Context.ResolveKeyed(DbName); //Setup pruning if configured if (traceStoreConfig.BlocksToKeep != 0) { - _pruner = new TraceStorePruner(_api.BlockTree!, _db, traceStoreConfig.BlocksToKeep, _logManager); + _api.Context.Resolve(); } return Task.CompletedTask; @@ -80,8 +83,15 @@ public Task InitRpcModules() public ValueTask DisposeAsync() { - _pruner?.Dispose(); - _db?.Dispose(); return default; } + + public IModule Module => new TracerStorePluginModule(); + + private class TracerStorePluginModule : Module + { + protected override void Load(ContainerBuilder builder) => builder + .AddDatabase(DbName) + .AddSingleton(); + } } diff --git a/src/Nethermind/Nethermind.JsonRpc.TraceStore/TraceStorePruner.cs b/src/Nethermind/Nethermind.JsonRpc.TraceStore/TraceStorePruner.cs index ce4091abf40..a13f58bf278 100644 --- a/src/Nethermind/Nethermind.JsonRpc.TraceStore/TraceStorePruner.cs +++ b/src/Nethermind/Nethermind.JsonRpc.TraceStore/TraceStorePruner.cs @@ -1,8 +1,10 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using Autofac.Features.AttributeFilters; using Nethermind.Blockchain; using Nethermind.Core; +using Nethermind.Core.Container; using Nethermind.Db; using Nethermind.Logging; @@ -18,6 +20,12 @@ public class TraceStorePruner : IDisposable private readonly int _blockToKeep; private readonly ILogger _logger; + [UseConstructorForDependencyInjection] + public TraceStorePruner(IBlockTree blockTree, [KeyFilter(TraceStorePlugin.DbName)] IDb db, ITraceStoreConfig traceStoreConfig, ILogManager logManager) + : this(blockTree, db, traceStoreConfig.BlocksToKeep, logManager) + { + } + public TraceStorePruner(IBlockTree blockTree, IDb db, int blockToKeep, ILogManager logManager) { _blockTree = blockTree; diff --git a/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs b/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs index 3fab9da0b28..8b591f6fa0a 100644 --- a/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs +++ b/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs @@ -144,7 +144,6 @@ protected override ContainerBuilder ConfigureContainer(ContainerBuilder builder, { // Yes getting from `TestBlockchain` itself, since steps are not run // and some of these are not from DI. you know... chicken and egg, but dont forgot about rooster. - api.DbProvider = DbProvider; api.TxPool = TxPool; api.TransactionComparerProvider = TransactionComparerProvider; api.FinalizationManager = Substitute.For(); diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/MergePluginTests.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/MergePluginTests.cs index 340386ddf01..8f037d54294 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/MergePluginTests.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/MergePluginTests.cs @@ -71,7 +71,6 @@ private IContainer BuildContainer(IConfigProvider? configProvider = null) Build.MockOutNethermindApi((NethermindApi)api); api.BlockProcessingQueue?.IsEmpty.Returns(true); - api.DbFactory = new MemDbFactory(); }) .Build(); } diff --git a/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs b/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs index 82dab7e72d9..737744f7b1c 100644 --- a/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs +++ b/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs @@ -58,7 +58,6 @@ protected override ITransactionProcessor CreateTransactionProcessor(ICodeInfoRep protected override BlockProcessor CreateBlockProcessor(BlockCachePreWarmer? preWarmer, ITransactionProcessor transactionProcessor, IWorldState worldState) { - if (api.DbProvider is null) throw new StepDependencyException(nameof(api.DbProvider)); if (api.RewardCalculatorSource is null) throw new StepDependencyException(nameof(api.RewardCalculatorSource)); if (api.SpecHelper is null) throw new StepDependencyException(nameof(api.SpecHelper)); if (api.SpecProvider is null) throw new StepDependencyException(nameof(api.SpecProvider)); diff --git a/src/Nethermind/Nethermind.Runner.Test/Ethereum/ContextWithMocks.cs b/src/Nethermind/Nethermind.Runner.Test/Ethereum/ContextWithMocks.cs index c5109eb2a6c..b8117387ba4 100644 --- a/src/Nethermind/Nethermind.Runner.Test/Ethereum/ContextWithMocks.cs +++ b/src/Nethermind/Nethermind.Runner.Test/Ethereum/ContextWithMocks.cs @@ -111,7 +111,6 @@ public static void MockOutNethermindApi(NethermindApi api) api.TxPool = Substitute.For(); api.Wallet = Substitute.For(); api.BlockTree = Substitute.For(); - api.DbProvider = TestMemDbProvider.Init(); api.ReceiptStorage = Substitute.For(); api.BloomStorage = Substitute.For(); api.BlockProducer = Substitute.For(); diff --git a/src/Nethermind/Nethermind.Runner.Test/EthereumRunnerTests.cs b/src/Nethermind/Nethermind.Runner.Test/EthereumRunnerTests.cs index 06d40d24d68..834a4535e15 100644 --- a/src/Nethermind/Nethermind.Runner.Test/EthereumRunnerTests.cs +++ b/src/Nethermind/Nethermind.Runner.Test/EthereumRunnerTests.cs @@ -209,8 +209,6 @@ public async Task Smoke_CanResolveAllSteps((string file, ConfigProvider configPr api.FileSystem = Substitute.For(); api.BlockTree = Substitute.For(); api.ReceiptStorage = Substitute.For(); - api.DbFactory = new MemDbFactory(); - api.DbProvider = await TestMemDbProvider.InitAsync(); api.BlockProducerRunner = Substitute.For(); if (api is AuRaNethermindApi auRaNethermindApi) diff --git a/src/Nethermind/Nethermind.State.Test/StateReaderTests.cs b/src/Nethermind/Nethermind.State.Test/StateReaderTests.cs index 8f021ad4654..56216191d18 100644 --- a/src/Nethermind/Nethermind.State.Test/StateReaderTests.cs +++ b/src/Nethermind/Nethermind.State.Test/StateReaderTests.cs @@ -9,6 +9,7 @@ using Nethermind.Core.Specs; using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; +using Nethermind.Core.Test.Db; using Nethermind.Db; using Nethermind.Specs; using Nethermind.Int256; diff --git a/src/Nethermind/Nethermind.State.Test/WorldStateManagerTests.cs b/src/Nethermind/Nethermind.State.Test/WorldStateManagerTests.cs index 764d146d52f..e8242c706fc 100644 --- a/src/Nethermind/Nethermind.State.Test/WorldStateManagerTests.cs +++ b/src/Nethermind/Nethermind.State.Test/WorldStateManagerTests.cs @@ -8,6 +8,7 @@ using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Test.Builders; +using Nethermind.Core.Test.Db; using Nethermind.Core.Test.Modules; using Nethermind.Db; using Nethermind.Logging; diff --git a/src/Nethermind/Nethermind.Synchronization.Test/SnapSync/SnapServerTest.cs b/src/Nethermind/Nethermind.Synchronization.Test/SnapSync/SnapServerTest.cs index 2de2c94f8ce..2c17a1316ea 100644 --- a/src/Nethermind/Nethermind.Synchronization.Test/SnapSync/SnapServerTest.cs +++ b/src/Nethermind/Nethermind.Synchronization.Test/SnapSync/SnapServerTest.cs @@ -269,12 +269,11 @@ public void TestGetStorageRange() SnapServer server = new(store.AsReadOnly(), codeDb, CreateConstantStateRootTracker(true), LimboLogs.Instance); - IDbProvider dbProviderClient = new DbProvider(); - dbProviderClient.RegisterDb(DbNames.State, new MemDb()); - dbProviderClient.RegisterDb(DbNames.Code, new MemDb()); + IDb codeDb2 = new MemDb(); + IDb stateDb2 = new MemDb(); - using ProgressTracker progressTracker = new(dbProviderClient.StateDb, new TestSyncConfig(), new StateSyncPivot(null!, new TestSyncConfig(), LimboLogs.Instance), LimboLogs.Instance); - SnapProvider snapProvider = new(progressTracker, dbProviderClient.CodeDb, new NodeStorage(dbProviderClient.StateDb), LimboLogs.Instance); + using ProgressTracker progressTracker = new(stateDb2, new TestSyncConfig(), new StateSyncPivot(null!, new TestSyncConfig(), LimboLogs.Instance), LimboLogs.Instance); + SnapProvider snapProvider = new(progressTracker, codeDb2, new NodeStorage(stateDb2), LimboLogs.Instance); (IOwnedReadOnlyList> storageSlots, IOwnedReadOnlyList? proofs) = server.GetStorageRanges(inputStateTree.RootHash, [TestItem.Tree.AccountsWithPaths[0]], @@ -309,10 +308,6 @@ public void TestGetStorageRange_NoSlotsForAccount() SnapServer server = new(store.AsReadOnly(), codeDb, CreateConstantStateRootTracker(true), LimboLogs.Instance); - IDbProvider dbProviderClient = new DbProvider(); - dbProviderClient.RegisterDb(DbNames.State, new MemDb()); - dbProviderClient.RegisterDb(DbNames.Code, new MemDb()); - ValueHash256 lastStorageHash = TestItem.Tree.SlotsWithPaths[^1].Path; var asInt = lastStorageHash.ToUInt256(); ValueHash256 beyondLast = new ValueHash256((++asInt).ToBigEndian()); @@ -339,12 +334,11 @@ public void TestGetStorageRangeMulti() SnapServer server = new(store.AsReadOnly(), codeDb, CreateConstantStateRootTracker(true), LimboLogs.Instance); - IDbProvider dbProviderClient = new DbProvider(); - dbProviderClient.RegisterDb(DbNames.State, new MemDb()); - dbProviderClient.RegisterDb(DbNames.Code, new MemDb()); + IDb stateDb2 = new MemDb(); + IDb codeDb2 = new MemDb(); - using ProgressTracker progressTracker = new(dbProviderClient.StateDb, new TestSyncConfig(), new StateSyncPivot(null!, new TestSyncConfig(), LimboLogs.Instance), LimboLogs.Instance); - SnapProvider snapProvider = new(progressTracker, dbProviderClient.CodeDb, new NodeStorage(dbProviderClient.StateDb), LimboLogs.Instance); + using ProgressTracker progressTracker = new(stateDb2, new TestSyncConfig(), new StateSyncPivot(null!, new TestSyncConfig(), LimboLogs.Instance), LimboLogs.Instance); + SnapProvider snapProvider = new(progressTracker, codeDb2, new NodeStorage(stateDb2), LimboLogs.Instance); Hash256 startRange = Keccak.Zero; while (true) diff --git a/src/Nethermind/Nethermind.Synchronization.Test/TestSynchronizerModule.cs b/src/Nethermind/Nethermind.Synchronization.Test/TestSynchronizerModule.cs index b35ff56bced..c4f86941504 100644 --- a/src/Nethermind/Nethermind.Synchronization.Test/TestSynchronizerModule.cs +++ b/src/Nethermind/Nethermind.Synchronization.Test/TestSynchronizerModule.cs @@ -2,11 +2,14 @@ // SPDX-License-Identifier: LGPL-3.0-only using Autofac; +using Nethermind.Api; using Nethermind.Blockchain; +using Nethermind.Blockchain.Receipts; using Nethermind.Blockchain.Synchronization; using Nethermind.Core; using Nethermind.Core.Timers; using Nethermind.Db; +using Nethermind.Init.Modules; using Nethermind.Logging; using Nethermind.Stats; using Nethermind.Trie; @@ -22,8 +25,8 @@ protected override void Load(ContainerBuilder builder) builder .AddModule(new SynchronizerModule(syncConfig)) - .AddModule(new DbModule()) - .AddSingleton(TestMemDbProvider.Init()) + .AddModule(new DbModule(new InitConfig(), new ReceiptConfig(), syncConfig)) + .AddSingleton((_) => new MemDbFactory()) .Map(dbProvider => new NodeStorage(dbProvider.StateDb)) .AddSingleton(Substitute.For()) .AddSingleton(Substitute.For()) diff --git a/src/Nethermind/Nethermind.Taiko/InitializeBlockchainTaiko.cs b/src/Nethermind/Nethermind.Taiko/InitializeBlockchainTaiko.cs index ba7f68f7eef..b790047a024 100644 --- a/src/Nethermind/Nethermind.Taiko/InitializeBlockchainTaiko.cs +++ b/src/Nethermind/Nethermind.Taiko/InitializeBlockchainTaiko.cs @@ -47,7 +47,6 @@ protected override ITransactionProcessor CreateTransactionProcessor(ICodeInfoRep protected override BlockProcessor CreateBlockProcessor(BlockCachePreWarmer? preWarmer, ITransactionProcessor transactionProcessor, IWorldState worldState) { - if (_api.DbProvider is null) throw new StepDependencyException(nameof(_api.DbProvider)); if (_api.RewardCalculatorSource is null) throw new StepDependencyException(nameof(_api.RewardCalculatorSource)); if (_api.SpecProvider is null) throw new StepDependencyException(nameof(_api.SpecProvider)); if (_api.BlockTree is null) throw new StepDependencyException(nameof(_api.BlockTree)); diff --git a/src/Nethermind/Nethermind.Taiko/TaikoPlugin.cs b/src/Nethermind/Nethermind.Taiko/TaikoPlugin.cs index be415bcb2b7..771dcbb845f 100644 --- a/src/Nethermind/Nethermind.Taiko/TaikoPlugin.cs +++ b/src/Nethermind/Nethermind.Taiko/TaikoPlugin.cs @@ -29,6 +29,7 @@ using Nethermind.Serialization.Rlp; using Autofac; using Autofac.Core; +using Nethermind.Init.Modules; using Nethermind.JsonRpc.Modules.Eth.GasPrice; using Nethermind.Serialization.Json; using Nethermind.Taiko.BlockTransactionExecutors; @@ -103,8 +104,7 @@ protected override void Load(ContainerBuilder builder) // L1 origin store .AddSingleton, L1OriginDecoder>() - .AddKeyedSingleton(L1OriginStore.L1OriginDbName, ctx => ctx - .Resolve().CreateDb(new DbSettings(L1OriginStore.L1OriginDbName, L1OriginStore.L1OriginDbName.ToLower()))) + .AddDatabase(L1OriginStore.L1OriginDbName, L1OriginStore.L1OriginDbName, L1OriginStore.L1OriginDbName.ToLower()) .AddSingleton() // Sync modification diff --git a/src/Nethermind/Nethermind.Trie.Test/OverlayTrieStoreTests.cs b/src/Nethermind/Nethermind.Trie.Test/OverlayTrieStoreTests.cs index 493ff8e6934..29cf8d7767f 100644 --- a/src/Nethermind/Nethermind.Trie.Test/OverlayTrieStoreTests.cs +++ b/src/Nethermind/Nethermind.Trie.Test/OverlayTrieStoreTests.cs @@ -7,6 +7,7 @@ using Nethermind.Core.Crypto; using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; +using Nethermind.Core.Test.Db; using Nethermind.Db; using Nethermind.Logging; using Nethermind.Trie.Pruning; diff --git a/src/Nethermind/Nethermind.Trie.Test/Pruning/TreeStoreTests.cs b/src/Nethermind/Nethermind.Trie.Test/Pruning/TreeStoreTests.cs index b794d694717..2a72fcf2e84 100644 --- a/src/Nethermind/Nethermind.Trie.Test/Pruning/TreeStoreTests.cs +++ b/src/Nethermind/Nethermind.Trie.Test/Pruning/TreeStoreTests.cs @@ -11,6 +11,7 @@ using Nethermind.Core.Extensions; using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; +using Nethermind.Core.Test.Db; using Nethermind.Db; using Nethermind.Int256; using Nethermind.Logging; diff --git a/src/Nethermind/Nethermind.Trie.Test/PruningScenariosTests.cs b/src/Nethermind/Nethermind.Trie.Test/PruningScenariosTests.cs index 1a8057c4e25..f2114ee1edb 100644 --- a/src/Nethermind/Nethermind.Trie.Test/PruningScenariosTests.cs +++ b/src/Nethermind/Nethermind.Trie.Test/PruningScenariosTests.cs @@ -10,6 +10,7 @@ using Nethermind.Core.Crypto; using Nethermind.Core.Extensions; using Nethermind.Core.Test.Builders; +using Nethermind.Core.Test.Db; using Nethermind.Db; using Nethermind.Int256; using Nethermind.Logging; From fb343c0f11663f7e8a7550fb4474edaff9245421 Mon Sep 17 00:00:00 2001 From: Siddharth Vaderaa Date: Fri, 18 Jul 2025 18:39:38 +0200 Subject: [PATCH 27/40] Wait to read channel before reading --- src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs b/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs index f66ff49b969..812c05bd50e 100644 --- a/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs +++ b/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs @@ -77,6 +77,7 @@ private static async Task WorkerLoop(int taskLimit, IVMConfig config, ILogger lo Task[] taskPool = new Task[taskLimit]; Array.Fill(taskPool, Task.CompletedTask); + await _channel.Reader.WaitToReadAsync(_cts.Token); await foreach (var codeInfo in _channel.Reader.ReadAllAsync(_cts.Token)) { int index = Task.WaitAny(taskPool); From 71ed14f64a767fbf04830a6d0a9b65c82cedc6d9 Mon Sep 17 00:00:00 2001 From: Ruben Buniatyan Date: Sat, 19 Jul 2025 00:21:02 +0200 Subject: [PATCH 28/40] Fix BN254 point deserialization (#9009) --- .../Nethermind.Evm.Precompiles/BN254.cs | 51 +++++----- .../BN254AddPrecompileTests.cs | 27 +++--- .../BN254MulPrecompileTests.cs | 27 +++--- .../BN254PairingPrecompileTests.cs | 93 ++++++++++--------- 4 files changed, 105 insertions(+), 93 deletions(-) diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/BN254.cs b/src/Nethermind/Nethermind.Evm.Precompiles/BN254.cs index a6cfd587f8d..fb4ced5f60f 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/BN254.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/BN254.cs @@ -3,6 +3,7 @@ using System; using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; using Nethermind.MclBindings; namespace Nethermind.Evm.Precompiles; @@ -50,7 +51,7 @@ internal static bool Mul(Span input, Span output) mclBnFr y = default; - fixed (byte* ptr = yData) + fixed (byte* ptr = &MemoryMarshal.GetReference(yData)) { if (mclBnFr_setLittleEndianMod(ref y, (nint)ptr, 32) == -1 || mclBnFr_isValid(y) == 0) return false; @@ -121,14 +122,20 @@ private static bool DeserializeG1(Span data, out mclBnG1 point) Span x = data[0..32]; x.Reverse(); // To little-endian - fixed (byte* ptr = x) - mclBnFp_setLittleEndian(ref point.x, (nint)ptr, 32); + fixed (byte* ptr = &MemoryMarshal.GetReference(x)) + { + if (mclBnFp_deserialize(ref point.x, (nint)ptr, 32) == nuint.Zero) + return false; + } Span y = data[32..64]; y.Reverse(); // To little-endian - fixed (byte* ptr = y) - mclBnFp_setLittleEndian(ref point.y, (nint)ptr, 32); + fixed (byte* ptr = &MemoryMarshal.GetReference(y)) + { + if (mclBnFp_deserialize(ref point.y, (nint)ptr, 32) == nuint.Zero) + return false; + } mclBnFp_setInt32(ref point.z, 1); @@ -148,11 +155,14 @@ private static bool DeserializeG2(Span data, out mclBnG2 point) x0.Reverse(); // To little-endian x1.Reverse(); // To little-endian - fixed (byte* ptr0 = x0) - fixed (byte* ptr1 = x1) + fixed (byte* ptr0 = &MemoryMarshal.GetReference(x0)) + fixed (byte* ptr1 = &MemoryMarshal.GetReference(x1)) { - mclBnFp_setLittleEndian(ref point.x.d0, (nint)ptr0, 32); - mclBnFp_setLittleEndian(ref point.x.d1, (nint)ptr1, 32); + if (mclBnFp_deserialize(ref point.x.d0, (nint)ptr0, 32) == nuint.Zero) + return false; + + if (mclBnFp_deserialize(ref point.x.d1, (nint)ptr1, 32) == nuint.Zero) + return false; } Span y0 = data[96..128]; @@ -160,11 +170,14 @@ private static bool DeserializeG2(Span data, out mclBnG2 point) y0.Reverse(); // To little-endian y1.Reverse(); // To little-endian - fixed (byte* ptr0 = y0) - fixed (byte* ptr1 = y1) + fixed (byte* ptr0 = &MemoryMarshal.GetReference(y0)) + fixed (byte* ptr1 = &MemoryMarshal.GetReference(y1)) { - mclBnFp_setLittleEndian(ref point.y.d0, (nint)ptr0, 32); - mclBnFp_setLittleEndian(ref point.y.d1, (nint)ptr1, 32); + if (mclBnFp_deserialize(ref point.y.d0, (nint)ptr0, 32) == nuint.Zero) + return false; + + if (mclBnFp_deserialize(ref point.y.d1, (nint)ptr1, 32) == nuint.Zero) + return false; } mclBnFp_setInt32(ref point.z.d0, 1); @@ -176,21 +189,17 @@ private static bool SerializeG1(in mclBnG1 point, Span output) { Span x = output[0..32]; - fixed (byte* ptr = x) + fixed (byte* ptr = &MemoryMarshal.GetReference(x)) { - var length = mclBnFp_getLittleEndian((nint)ptr, 32, point.x); - - if (length == nuint.Zero) + if (mclBnFp_getLittleEndian((nint)ptr, 32, point.x) == nuint.Zero) return false; } Span y = output[32..64]; - fixed (byte* ptr = y) + fixed (byte* ptr = &MemoryMarshal.GetReference(y)) { - var length = mclBnFp_getLittleEndian((nint)ptr, 32, point.y); - - if (length == nuint.Zero) + if (mclBnFp_getLittleEndian((nint)ptr, 32, point.y) == nuint.Zero) return false; } diff --git a/src/Nethermind/Nethermind.Evm.Test/BN254AddPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BN254AddPrecompileTests.cs index 0b4f408102f..e33e0122ec9 100644 --- a/src/Nethermind/Nethermind.Evm.Test/BN254AddPrecompileTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/BN254AddPrecompileTests.cs @@ -10,24 +10,25 @@ namespace Nethermind.Evm.Test; public class BN254AddPrecompileTests { - [TestCase("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b3625f8c89ea3437f44f8fc8b6bfbb6312074dc6f983809a5e809ff4e1d076dd5850b38c7ced6e4daef9c4347f370d6d8b58f4b1d8dc61a3c59d651a0644a2a27cf", "0a6678fd675aa4d8f0d03a1feb921a27f38ebdcb860cc083653519655acd6d79172fd5b3b2bfdd44e43bcec3eace9347608f9f0a16f1e184cb3f52e6f259cbeb")] - [TestCase("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaa21315394462f1a39f87462dbceb92718b220e4f80af516f727ad85380fadefbc2e4f40ea7bbe2d4d71f13c84fd2ae24a4a24d9638dd78349d0dee8435a67cca6", "013f227997b410cbd96b137a114f5b12d5a3a53d7482797bcd1f116ff30ff1931effebc79dee208d036553beae8ca71afb3b4c00979560db3991c7e67c49103c")] - [TestCase("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774ba08ed1b33fe3cd3b1ac11571999e8f451f5bb28dd4019e58b8d24d91cf73dc38f11be2878bb118612a7627f022aa19a17b6eb599bba4185df357f81d052fff90b", "0e9e24a218333ed19a90051efabe246146a6d5017810140ef7e448030539038a230598b7d4127f5b4fd971820084c632ca940b29fcf30139cd1513bbbbf3a3dc")] - [TestCase("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa8071c35e297f7c55363cd2fd00d916c67fad3bdea15487bdc5cc7b720f3a2c8b776106c2a4cf61ab73f91f2258f1846b9be9d28b9a7e83503fa4f4b322bfc07223c", "22f8aa414eb0b9b296bed3fb355804e92ec0af419d9906335f50f032d87a8bf82643f41b228310b816c784c2c54dcfadeaa328b792dbe0d0e04741cd61dac155")] - [TestCase("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe571f752f85cf5cc01b2dfe279541032da61c2fcc8ae0dfc6d4253ba9b5d3c858231d03a84afe2a9f595ab03007400ccd36a2c0bc31203d881011dfc450c39b5abe", "1e51b9f09d8fc2e4ca11602326c2cfe191c6c6a47874526e80051197e9f6af842282e508ca489bf881e25cf9590151ff5cf94fa523683a0718d87abcc4d4a16f")] - [TestCase("0e6eab4103302750b22364bd1ec80e5edfb3ad06fa175ff2517ca49489f728e9050a17b5a594d0fd6fafed7fe5c447793fe9b617f0f97c3ee6dd29638f6c9232038de98419e242685862c118253ab7df7358f863a59170c37e606d5bd23c742f076ff3443f4e01b7d7ace1315fe50cf77c365d8d289c65303bcc11ba7961ab95", "2231ab2eee93d63596f718533ddbb95a86b13d39e1162897d791566e797f82952f39ea566bede8e7ba15f3c61b0e96275b2fc51800ee2baf2f9bd7acfa874f0a")] - [TestCase("1920c53c756f1ec1a40e0264e5f65808eafaeaa7b0885f89852297bc2186ac9d09416cc536a27b6d5616f74dd2bbbfb463b9961752e0aa38d47b5213994959ab015296293a5a1bb5e15a7d019787422cb3409e075e122c6fc5867f0c3f3715731782b870b6641d8d55323e27ebaea17909499877fda62e3ac1e2b2310cad5f9c", "0fa3236565b78b283f3ce63ca62bafb87c33407b11a077e39230ff37c054cf712a38174368bf872f80f78fb5222e95717183242b9d4da75c66243f043aed2fc5")] - [TestCase("001faaf97b965ffa633612b7c8f9f4be0b286b19662e5cbe6878019d8ba1382b16567ced7a7ee5c272bbc378a95c2436fb0c6133649c77e55a708b28419b5cac0750d51706ced69621c8e4ba1758ba90c39ba8b3b50507bfa545ace1737e360e283d609cd67a291fc3d720c5b1113eececba4ca31d58a1319d6a5a2fa89608f9", "044fe3c480840e5a8f544efd28a8bf3246f0741a8c61c3116e93d84773399c8b26c5b695120cd724aa2a5f4dfd3042c07f752be4c4a8b750398109d80f4772eb")] - [TestCase("128b65cb80257f3006fc20dbb6af6781da7e0f9213d2b909fd113ee0f2d2bb52251e288387db7be742fe67261f36a4f09eeb4763bbbaa1bb13af3dec65302a4115f64edf27478045bf45eded285544acaa7f2b3a2a36176acefc1a3d7181a73219d4344489688c2a2f16caf1141bc42021738339431b3a64cfbc293a73c1eddc", "0a20db61d2b74384ca184f20455ad1f380ba081f89e41c87ceb3fdbbba63c7aa1fbda20003ec799f306f70df7f53f91721e59353013ebf1647f5130903fff482")] - [TestCase("16a9fe4620e58d70109d6995fe5f9eb8b3d533280cc604a333dcf0fa688b62e20b972bf2daef6c10a41db685c2417b6f4362032421c8466277d3271b6e8706a809ad61a8a83df55f6cd293cd674338c35dbb32722e9db2d1a3371b43496c05fa09c73b138499e36453d67a2c9b543c2188918287c4eef2c3ccc9ebe1d6142d01", "005a68cc13a108287aa3ca0bd8bef95096ef22668e15c87f7cbe0167cd1cdc930359b9b2dd28843838cf74cb4af2cfd656690a7f73de771b891142db22fa61fb")] - public void Test(string input, string output) + [TestCase("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b3625f8c89ea3437f44f8fc8b6bfbb6312074dc6f983809a5e809ff4e1d076dd5850b38c7ced6e4daef9c4347f370d6d8b58f4b1d8dc61a3c59d651a0644a2a27cf", "0a6678fd675aa4d8f0d03a1feb921a27f38ebdcb860cc083653519655acd6d79172fd5b3b2bfdd44e43bcec3eace9347608f9f0a16f1e184cb3f52e6f259cbeb", true)] + [TestCase("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaa21315394462f1a39f87462dbceb92718b220e4f80af516f727ad85380fadefbc2e4f40ea7bbe2d4d71f13c84fd2ae24a4a24d9638dd78349d0dee8435a67cca6", "013f227997b410cbd96b137a114f5b12d5a3a53d7482797bcd1f116ff30ff1931effebc79dee208d036553beae8ca71afb3b4c00979560db3991c7e67c49103c", true)] + [TestCase("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774ba08ed1b33fe3cd3b1ac11571999e8f451f5bb28dd4019e58b8d24d91cf73dc38f11be2878bb118612a7627f022aa19a17b6eb599bba4185df357f81d052fff90b", "0e9e24a218333ed19a90051efabe246146a6d5017810140ef7e448030539038a230598b7d4127f5b4fd971820084c632ca940b29fcf30139cd1513bbbbf3a3dc", true)] + [TestCase("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa8071c35e297f7c55363cd2fd00d916c67fad3bdea15487bdc5cc7b720f3a2c8b776106c2a4cf61ab73f91f2258f1846b9be9d28b9a7e83503fa4f4b322bfc07223c", "22f8aa414eb0b9b296bed3fb355804e92ec0af419d9906335f50f032d87a8bf82643f41b228310b816c784c2c54dcfadeaa328b792dbe0d0e04741cd61dac155", true)] + [TestCase("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe571f752f85cf5cc01b2dfe279541032da61c2fcc8ae0dfc6d4253ba9b5d3c858231d03a84afe2a9f595ab03007400ccd36a2c0bc31203d881011dfc450c39b5abe", "1e51b9f09d8fc2e4ca11602326c2cfe191c6c6a47874526e80051197e9f6af842282e508ca489bf881e25cf9590151ff5cf94fa523683a0718d87abcc4d4a16f", true)] + [TestCase("0e6eab4103302750b22364bd1ec80e5edfb3ad06fa175ff2517ca49489f728e9050a17b5a594d0fd6fafed7fe5c447793fe9b617f0f97c3ee6dd29638f6c9232038de98419e242685862c118253ab7df7358f863a59170c37e606d5bd23c742f076ff3443f4e01b7d7ace1315fe50cf77c365d8d289c65303bcc11ba7961ab95", "2231ab2eee93d63596f718533ddbb95a86b13d39e1162897d791566e797f82952f39ea566bede8e7ba15f3c61b0e96275b2fc51800ee2baf2f9bd7acfa874f0a", true)] + [TestCase("1920c53c756f1ec1a40e0264e5f65808eafaeaa7b0885f89852297bc2186ac9d09416cc536a27b6d5616f74dd2bbbfb463b9961752e0aa38d47b5213994959ab015296293a5a1bb5e15a7d019787422cb3409e075e122c6fc5867f0c3f3715731782b870b6641d8d55323e27ebaea17909499877fda62e3ac1e2b2310cad5f9c", "0fa3236565b78b283f3ce63ca62bafb87c33407b11a077e39230ff37c054cf712a38174368bf872f80f78fb5222e95717183242b9d4da75c66243f043aed2fc5", true)] + [TestCase("001faaf97b965ffa633612b7c8f9f4be0b286b19662e5cbe6878019d8ba1382b16567ced7a7ee5c272bbc378a95c2436fb0c6133649c77e55a708b28419b5cac0750d51706ced69621c8e4ba1758ba90c39ba8b3b50507bfa545ace1737e360e283d609cd67a291fc3d720c5b1113eececba4ca31d58a1319d6a5a2fa89608f9", "044fe3c480840e5a8f544efd28a8bf3246f0741a8c61c3116e93d84773399c8b26c5b695120cd724aa2a5f4dfd3042c07f752be4c4a8b750398109d80f4772eb", true)] + [TestCase("128b65cb80257f3006fc20dbb6af6781da7e0f9213d2b909fd113ee0f2d2bb52251e288387db7be742fe67261f36a4f09eeb4763bbbaa1bb13af3dec65302a4115f64edf27478045bf45eded285544acaa7f2b3a2a36176acefc1a3d7181a73219d4344489688c2a2f16caf1141bc42021738339431b3a64cfbc293a73c1eddc", "0a20db61d2b74384ca184f20455ad1f380ba081f89e41c87ceb3fdbbba63c7aa1fbda20003ec799f306f70df7f53f91721e59353013ebf1647f5130903fff482", true)] + [TestCase("16a9fe4620e58d70109d6995fe5f9eb8b3d533280cc604a333dcf0fa688b62e20b972bf2daef6c10a41db685c2417b6f4362032421c8466277d3271b6e8706a809ad61a8a83df55f6cd293cd674338c35dbb32722e9db2d1a3371b43496c05fa09c73b138499e36453d67a2c9b543c2188918287c4eef2c3ccc9ebe1d6142d01", "005a68cc13a108287aa3ca0bd8bef95096ef22668e15c87f7cbe0167cd1cdc930359b9b2dd28843838cf74cb4af2cfd656690a7f73de771b891142db22fa61fb", true)] + [TestCase("0ef704cd9e3c0b10fbfdadae2fb02b1b8679d24684b9a8ced52d2890fb61453e20edded55ab925e685ff207c41edb00ea85eaf74918864a97d75924beb3e5d1c3431d14cfbe9a5a1244e88ada99303090b48f7580ae1e3aa0c82cd92025c03e41b1c9200304be38b893bd18ca5b528bb34fbcd8126c1104f0465a7ae1bf44556", "", false)] + public void Test(string input, string output, bool status) { byte[] inputData = Convert.FromHexString(input); - (byte[] outputData, bool success) = BN254AddPrecompile.Instance.Run(inputData, MuirGlacier.Instance); + (byte[] outputData, bool outcome) = BN254AddPrecompile.Instance.Run(inputData, MuirGlacier.Instance); using (Assert.EnterMultipleScope()) { - Assert.That(success, Is.True); + Assert.That(outcome, Is.EqualTo(status)); Assert.That(outputData, Is.EquivalentTo(Convert.FromHexString(output))); } } diff --git a/src/Nethermind/Nethermind.Evm.Test/BN254MulPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BN254MulPrecompileTests.cs index a4a088ce947..6a473ce52ce 100644 --- a/src/Nethermind/Nethermind.Evm.Test/BN254MulPrecompileTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/BN254MulPrecompileTests.cs @@ -10,24 +10,25 @@ namespace Nethermind.Evm.Test; public class BN254MulPrecompileTests { - [TestCase("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b36ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0bf982b98a2757878c051bfe7eee228b12bc69274b918f08d9fcb21e9184ddc10b17c77cbf3c19d5d27e18cbd4a8c336afb488d0e92c18d56e64dd4ea5c437e6")] - [TestCase("25f8c89ea3437f44f8fc8b6bfbb6312074dc6f983809a5e809ff4e1d076dd5850b38c7ced6e4daef9c4347f370d6d8b58f4b1d8dc61a3c59d651a0644a2a27cfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "18a902ac147b2951531770c7c18a25e3dd87765e23f7e0c4e9d62b624a6e37450288473776e7e99b2aaa27e8f4656ea9ce5e634fd1ca1aab45315199ecaced2e")] - [TestCase("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0c6a880ffdd0737c53bfec9b65c9098a3298747bd4e5fd07026661b4cb804331116aeec88e11f49753df224c60c4bd8b8bc0a98b8d50f24ce64475268d227f4c")] - [TestCase("21315394462f1a39f87462dbceb92718b220e4f80af516f727ad85380fadefbc2e4f40ea7bbe2d4d71f13c84fd2ae24a4a24d9638dd78349d0dee8435a67cca6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "1d7985d51e53cdfbd73b051e9a74ab6e621b6b664a7efed00e30c1264f5623d02808eee3baec187160d2499b4aedbc665a532d245212a1be61e0d4b9b36f3075")] - [TestCase("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774baffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "15bd6ea71fd264e1bfb04eb6d97b4f3686c5bf36f91356fc13ddde3494e172d90b3f8392fd4cdd5d542887ea4ee0274835bf37b58edf927ef242b8704af52e92")] - [TestCase("08ed1b33fe3cd3b1ac11571999e8f451f5bb28dd4019e58b8d24d91cf73dc38f11be2878bb118612a7627f022aa19a17b6eb599bba4185df357f81d052fff90bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "26ec73a6134f8ebce33d675e1f2e6ff3ec066e8d255ffca6eb55ef2ab7c5c51d06500cfcd6950c92de24b90ca09be110f8f9c2fb4d9cb2a9f9677dd81c1c0607")] - [TestCase("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa807ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "06894837c70570eac651dae1a443b830c292c1801340ca4150c9d339177965e509ad8d4839bc83bd1852e6a8b71dcf01a1f7d6b6b174858ca02893bd5ace3eee")] - [TestCase("1c35e297f7c55363cd2fd00d916c67fad3bdea15487bdc5cc7b720f3a2c8b776106c2a4cf61ab73f91f2258f1846b9be9d28b9a7e83503fa4f4b322bfc07223cffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0e56eeb3f168767b21bce1489d9657f694951b25ea8a081f4ebf68469a1eb1e0293446d763ea9c40e52286f2ac504cfabb364b1f899b874b13d78879d25a5ec5")] - [TestCase("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe57ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "2f63f5f1275c401356e94adfbe5e8cff21485a9281e55d378a51eb93263a40802a817491a84e40c584481df4a5085b301c6fd66cb97856de55cd04df85a6a1d3")] - [TestCase("1f752f85cf5cc01b2dfe279541032da61c2fcc8ae0dfc6d4253ba9b5d3c858231d03a84afe2a9f595ab03007400ccd36a2c0bc31203d881011dfc450c39b5abeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0aa7b6fda656f23eab50e36db0519cdf79f4624d417253085907ebfd9aef38a414cdd2edce2b313fc6dd390628ac9fac910841706d55f9af2a064548694dc05c")] - public void Test(string input, string output) + [TestCase("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b36ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0bf982b98a2757878c051bfe7eee228b12bc69274b918f08d9fcb21e9184ddc10b17c77cbf3c19d5d27e18cbd4a8c336afb488d0e92c18d56e64dd4ea5c437e6", true)] + [TestCase("25f8c89ea3437f44f8fc8b6bfbb6312074dc6f983809a5e809ff4e1d076dd5850b38c7ced6e4daef9c4347f370d6d8b58f4b1d8dc61a3c59d651a0644a2a27cfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "18a902ac147b2951531770c7c18a25e3dd87765e23f7e0c4e9d62b624a6e37450288473776e7e99b2aaa27e8f4656ea9ce5e634fd1ca1aab45315199ecaced2e", true)] + [TestCase("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0c6a880ffdd0737c53bfec9b65c9098a3298747bd4e5fd07026661b4cb804331116aeec88e11f49753df224c60c4bd8b8bc0a98b8d50f24ce64475268d227f4c", true)] + [TestCase("21315394462f1a39f87462dbceb92718b220e4f80af516f727ad85380fadefbc2e4f40ea7bbe2d4d71f13c84fd2ae24a4a24d9638dd78349d0dee8435a67cca6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "1d7985d51e53cdfbd73b051e9a74ab6e621b6b664a7efed00e30c1264f5623d02808eee3baec187160d2499b4aedbc665a532d245212a1be61e0d4b9b36f3075", true)] + [TestCase("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774baffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "15bd6ea71fd264e1bfb04eb6d97b4f3686c5bf36f91356fc13ddde3494e172d90b3f8392fd4cdd5d542887ea4ee0274835bf37b58edf927ef242b8704af52e92", true)] + [TestCase("08ed1b33fe3cd3b1ac11571999e8f451f5bb28dd4019e58b8d24d91cf73dc38f11be2878bb118612a7627f022aa19a17b6eb599bba4185df357f81d052fff90bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "26ec73a6134f8ebce33d675e1f2e6ff3ec066e8d255ffca6eb55ef2ab7c5c51d06500cfcd6950c92de24b90ca09be110f8f9c2fb4d9cb2a9f9677dd81c1c0607", true)] + [TestCase("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa807ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "06894837c70570eac651dae1a443b830c292c1801340ca4150c9d339177965e509ad8d4839bc83bd1852e6a8b71dcf01a1f7d6b6b174858ca02893bd5ace3eee", true)] + [TestCase("1c35e297f7c55363cd2fd00d916c67fad3bdea15487bdc5cc7b720f3a2c8b776106c2a4cf61ab73f91f2258f1846b9be9d28b9a7e83503fa4f4b322bfc07223cffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0e56eeb3f168767b21bce1489d9657f694951b25ea8a081f4ebf68469a1eb1e0293446d763ea9c40e52286f2ac504cfabb364b1f899b874b13d78879d25a5ec5", true)] + [TestCase("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe57ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "2f63f5f1275c401356e94adfbe5e8cff21485a9281e55d378a51eb93263a40802a817491a84e40c584481df4a5085b301c6fd66cb97856de55cd04df85a6a1d3", true)] + [TestCase("1f752f85cf5cc01b2dfe279541032da61c2fcc8ae0dfc6d4253ba9b5d3c858231d03a84afe2a9f595ab03007400ccd36a2c0bc31203d881011dfc450c39b5abeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0aa7b6fda656f23eab50e36db0519cdf79f4624d417253085907ebfd9aef38a414cdd2edce2b313fc6dd390628ac9fac910841706d55f9af2a064548694dc05c", true)] + [TestCase("3431d14cfbe9a5a1244e88ada99303090b48f7580ae1e3aa0c82cd92025c03e41b1c9200304be38b893bd18ca5b528bb34fbcd8126c1104f0465a7ae1bf44556ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "", false)] + public void Test(string input, string output, bool status) { byte[] inputData = Convert.FromHexString(input); - (byte[] outputData, bool success) = BN254MulPrecompile.Instance.Run(inputData, MuirGlacier.Instance); + (byte[] outputData, bool outcome) = BN254MulPrecompile.Instance.Run(inputData, MuirGlacier.Instance); using (Assert.EnterMultipleScope()) { - Assert.That(success, Is.True); + Assert.That(outcome, Is.EqualTo(status)); Assert.That(outputData, Is.EquivalentTo(Convert.FromHexString(output))); } } diff --git a/src/Nethermind/Nethermind.Evm.Test/BN254PairingPrecompileTests.cs b/src/Nethermind/Nethermind.Evm.Test/BN254PairingPrecompileTests.cs index e351d2702c1..13bdfa73f6a 100644 --- a/src/Nethermind/Nethermind.Evm.Test/BN254PairingPrecompileTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/BN254PairingPrecompileTests.cs @@ -10,57 +10,58 @@ namespace Nethermind.Evm.Test; public class BN254PairingPrecompileTests { - [TestCase("2722ae33a1d80f67a5da37ef2b7489dd39b1c98287fc408eb416e37de71bba1c3054f7ce76b782aa80254ce991fd5f115810e8f8f57ed0a12f30278112157c11165fa63e0d077c2b406c1001da54664d756636d6018616841c5b0d942519fecb1090ad3ca54838d2b89c0d2e3db3c2aff811d58bc32881d2ec947f473a8308a615b9fb021f60b7604ef07863fc6449504708718eaf59bd00f3620a9da16ed8830a95e72b8b56d1850126d77ddbdbd376e3b19f07a75071f0b958bd40471fe6900738bd659eab6973c3416b9e7c9660d341e8eee184c0f9c5ec59696f220903401e37dd4714f68da2a6affcf65a8cd26c7ae3fa0c0e5a3394887ceaebe4f49de90b501640d9ca26d1b466a9ea005b942b047fb519865b3413ccd90533d9902a85187c1fe325590f77ef42af537664469fa950986ce82c31eeaf1f6b348a3de3c6202ae189a9bf004bd80b9d8bdaa9b395a5263735242766aca3679ec3e547171b2a06ce9550542e6246331cbf852383c14830931cd63ededb0f21621b71e7f981", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("0eefcc4248b67e40298c48e0ed47dca1dbf6f6e377506899430b11bf03b17ede10c71a49ccfb43f8475de84b581eef9ab283c1238e172bf48150f29e1e56201204c9eaee6321d6ee36b8670498aa1c73665f3ecc7350c8ee09a573e692d26320171450a989ebe50e365b92d24c311fd830972e7b16a2523e634175c4e24c884a1a6bf429331081e6e930bd36e23bdf91bb8180a6e4129c11655cb9468093ceba0e9d0caa4d47983e49ee253051aaefd86cc6dd367384f89e2d166bd721c658122a55d1dc0b4bd2f33984f0099a6d44c85baa10aaca32d0ec89e494d24514a68c2d43c0e6576ec46f88dbdcc7c57d685a3eb9342ba7c71b62de9e6373bd9094ff0a716e218f8e4174821a7dc090fa93b7683e2a6e363afe3eb7287a7dcbf9ea090dada034b037e05a7c8b232b8c691b7f0c3b9a870d786e913d936f8256f2e8c0131bdc0ab71a147cb4d91bba85941c00ec91994d2e9e53b1929a14ee2e876dff021d8b2738aed0201234d3919498c918fd5340541ec616542d92d955df4c182902237ac6c6802585c60640eefde7c05fbdf206a5ec25dc3411a4e9b4e6b57be611bbc865815ccfb7c666b117834cbf2a7edd9c2baa691ee3d453c3652c49761b234be3f502cdf3d1e6258eb846afca7acb0fe13577e226ddd277daf32d1d0c5c25e39a0be0435820302ccb2763016b10d0dbde867c745fe86cfba8cc925a2eb72d4bb48beada74cddc1c791a980d9bf7601ce0aec444354a5c02185d392f66f50e4860e017fc0453fd1bb0453197ff5abfacd35b90e7d9b03ff0900cc857ef7f2f0ccd45b2e137fd53d99d027b79aa390ac021bf4d6aa95cc96bacd6a071386e21f73cf3d42f0ed82ca6f673bb89223e16386c7328385edb01eadd4ce28e5ab418861414b0b511cc6300bd0cc6c95538014be8a4a20d8cf56d74f4a63225302b1f065e5ce6c676af04344de377f580aad377dab935d532f2dce9daeb0f31d6900af84aeeab7ebb4390e6bbb4218558fba894959f2cc2fef8af5d1c16998a38c6076f86dbd858db5b0b15ca2cddb0092ef861188e0434f4232d7e3e884fa42bba", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774ba0d2c492bf135ed45b0d6265c274d145d35b73afd41ee95d3f1da4bc8761038800251d138db1b9748ffc257b147a1aea66413b14df767f98f7ba02489c617eae51065ff2bd9a5b167db36225a35fd712d781309f4e2c8541a335b2c42bd2bcae4191cd528d749c52f3e198e534868d537867109419a32314886f6bb2bcd337773", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("03d310db98253bb4a3aaff90eeb790d236cbc5698d5a9a6014965acff56e759a1edc5e9ae29193d6e5deed5c3ac4171cae2da155880cf6058848318de6859ea21ee564b4d91e10d3c3a34787dc163a79bf9d571eeb67ff072609cbe19ff25fc7270e094c2467dcf6ecf8c97a09ef643cfff359cbec1426c5eb01864b5cf3c27309f432f65daced7c895c3748fa0b0dfc430584e419442a25b98e74400789801210fa7bc208e286ebea1f5c342a96782b563a0bc4cdb4c42ba151b9cb76eea93d0abcdaf6ffdf0cbf20235077c7bb3908b74b9a8252083f4b01dcbe84cab90fc71a9681988a15b7eea9ae8cb0c2210b870eec2366e0531c414abb65c668c6eb3e21d0be81c5698882ee63cb729ed3f5b725d7a670b76941ddffff9ddca50cf9af21e61a0ac51a17c0128baa2cda8f212b13943959cf26a7578342c93dd2de7deb194e408b546197d9ee99d643e5385dcb8d5904854d8a836763ab8ce20f9b5027222aced81c808247572971b490eef1515a49f651f7df254de2b35310bb5b78c218b2345c40036ea331bfcfb8536739a5e5530027709adae6632a3613cd0838cd204121beebd54ec6bb063ba5a6d84eeceda2a733260066c90d332425e992ef6c2b0f794d64952d560a422a7ff549a58bfaa0cf791ab6dfad1c4941e19078040324bad1c848f2d8efcd716f7d814c46e2632e74a5b8d455a64c55917b220aab982ed4bbed5f80fac726f4a95789fee7905eef0a241596acbea4268ec3f2b87f3129563b69a30c11a856f68c72f129988e8636c86f57467cba299cdb4917469b49137a989e5d714b4b882d4a455600940ab63b14f23e7934ddd62cf5181099c63b2f57525eb3d19451024a4e71ee09c72c5b7e0dff925001acaee126bcd29db5f600d8ff46230e348d08dcbcdb1f85a5a43aa7b4f51841f1d4f98c18bbb57651982cabdf6326194120727367bdae0b081aa7da12c8f8c6af0ce27d2f8d0f059fe1240c9c5a6993d344744d77bbb855960b6704e91846cf362444bff1ccaf45a7c217873a5d7834d0c1d7d9bab5f9934d7ac218834aa916d459d8ceafc280d59efb", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("198f03850c2c5df1bd5601c0a5cdae3cc955026dba50a79dd00aeefe49c48c252ee3bce85e4c7bb10fee21428a8b0c1328d662e152f36a6c62caaac2fe097c0b0c91b38273eedbc873b2172cce9eaf7af1463cb3fb064a49cff2dc95f0b5bc1224a1a5e52496677b5dfa29a4e314d7b32bd22c0f437679e12d0c49c9d84e988014d4d06a717737c0e36767b06809bba6bcda2707bd652b3f922c3a652dfc90b325d0de555188106e9c4bd93171a8377b9d53eeb93b0b259a91c7ba570591f4010f2dbb4dfc16b4fe806d2ed28daf51530d6b88a81c2ffb98d3a6c1153db9239421b7f52300ab7b6eb9d9ef4bd7d58811909cf4c4ad7a9f8546f56099eb6ae1370224ecd4af7d5ec18e5b0c8eb46a8bc774fc4ac6c4233aafe9bf22420ddea4752bff288e58f4bc80b1bb91b450652c120db2ece783788b8ff3beb20b2e8d3c7a2d90a5dc703456ffb854fe3a746143e82bd8e4aae8321ab59a93e5da9d615ede07f9f33a0a234486c63562fd9b27ee6615655b6880bd511475059ab40395d23c", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("08808ba03b1abc4b870cd2e50b3960e85ea4ffde76e97ea70e62feb5712ac68823f1f949786f8cf8a18323bbad75bc71afac4e2419181fee3a627a8980f5d36f243b9ecee8d6c2f2f1b91980e4f7136d16f70c94c5fdc21354adb977bc66d748207322b7980616a6e4f4ddc3f223c52a9a11b785298b69f4075349274adeebb21226d7ded357133a1e9a8472f9c0f23e248c1ca1974ae336f4316731f1f473bf00b29428be1694c86da00b5cfe677c1b3332c93105d18df718f9ff0053bcb7a620adf7f96265baa9a9b1512eb1d59834eb931491d360408061135a8b30ddbfdc284fb8dde65089a6359a11fc8d2725409e2bc1e52141f1dd38bd56d10015346d0aad6b6b34672e8ffda5085e97e2a7f82ff4e3e6660b83e151b778e2dfd1ef3f14b07ac31c0927a5cb27b0447051f1ea39baa7ef12572b9b5dc535ffa28341a220dc6c1d760064168c59b36eae9560df6433eb96acd58aa88499ac5f081eed30245b974d3078709e037860b2970943659596a88d529a36275b34b38c51ced169", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("09fa51b9f1972a041220b86a762c252262d942474d9c2ddaa8d292c79d34b8132771b3f3a480320bc7c9963dda5f4e8120b8f06a0cbc6095d37e0dbbf0b6f9ce23d0c74ab9b983b35311ad334580ad3e9b8ac6eb0ccd69a5097884056c8310e01317cbe87801a1bad8f362bfa07f65f4e6f0df7f1d3681cab1995df75f3caa2516abf6c2348309a172dfb07485e59d4b149d20741c740c9379f5d235c8b7dd922fc0496ddcb63fea074ce4aca7f9a91884b8f3158970ba3f03fd58608b50b7d511857f4a462fb73fa92204c79e81824de2825b74103238b4f8e601a2cb37121303b531c48bcf5c8ddf8e608cd16eef92bec33929ef4d8fe57572214999746567129e8547b1d2f8103bfab8af9a8849ef950c020c2a24c235c889dc65d54c6f00036688a10447a1ca50ecb46b9c77042a3e0959de2919eb62e55e08f94b3b491b05f4e65becdda13865c79072d38ca4a35cd934ccda724348e68631deb874a62d2bec9369394e4b5d549558b030a5b8681d23a67cb9d95465f531a39ae61782b729fc71bd60da082f1dd43572c15900fe35d03e10201fe93668c6e31e0e4330212b0fe78b06800bc1a549cdd0ff91ea7ada763609799901b63a1d3ecb446ad1110847890bfd62a9ad72ad058345167d3716969f4f0c1861e532fcf5dbcbdeec04018770d45b235156f127dc39b55ce54daaccb9b2bffaa9692591647fb85112a622ec7b25af397ed0c3738c242d8c7d98753b0a64f826ad284412b93decd25a091a8d6e03829186f4f33185c75bae823e2840d04ca583753b9ba7b9a215de06ce04ca57858bb1cf75033675d652331e737f7d98400ea1b42102273e74f75ec4a41716a588640c92a28e2d4bf4ca5a6c8fb6fb2d910ce2c882fee639f5e16f11cb1967f6d1826b83b4197e628bf36eead712652ea75027a48148059fb422bf03550f60639bae9064af3ee671b9168eef729fa30153c89843827a9991da684d72ef07e000a8e29e909b06936cc43d82c5bd6f7a4108014532483f674ed28df007232003493fff270b3289b402ba1eab4bf90cbbbdddaec3e70fd0eb648c0fa61b2c", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("1a4db8abfea95acd4ac4bdf3d9082de13dcb9b2a73d6aa98a296a7d7d1009a8a1e8a143f9ed8661a223e211c4f70b1ac1d5057d71e31f182637b6f26de9a59190e817e9fb476d397b0f09aa07d290cc830ceac3ef815c5b8f45caf2cdafd90e209888f93aab917c7b6a9f8ee7174ff889961ff3509256873a774926c0c5b9a0f1005b845c9f53465d9371efb0eb934ecc8db144d466eaf06614e89c77305c35501951dfd5ce7f374b05b2b2a0737a5251ce4d9f53f0ee7fe79399aa09d6bfe9414e57a7979f8f2d78a1c7dc790476265240fff65e18344caa11b0698a574d4412bb862b7c0f8283e05e10a9b6e3bd19e5b69f6988b3f470692f26c379c33132126a4d85b3499d830033f0388c18b8e7b824b5b0b57db1fe366a435b0c1a53c6000ed1afda982e3f8d71da60ede43dd562ae63597ec91b1cba21e1c9fd5b8fbd81795c6b9f6debf45b77638122c7333a59aaa2e7511f526f496feb84c20f651552581dd3c6f3d05c78234b559d784f502fa5dc0900ae7475ba88716e5ac3d499d", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("05fa7cb22fb8809abb745dc167279147fa174e0444cfc99a38f23f2b93e49ad62f7f94d2d206264a9358b54fc96ac31921948cf3c13d121c923991f0b47c04291b2582586c93d23816aac8ce2f90eb913e554211251bc9a2d64dd2efb9a905b80f73f8ca76c166aa5735d9370cf944306abfcac5a5874cc95b00b569f7eba01a1d92dac05e6fe60b5131a0d2e9c459d4b3deaf1a462332b285f90a25e5b61c211467961e060894bc8111abdbb66365b9da4a6700f2d530ae69289d2cc32185d004951597c8a0547ea22859b97dd87a37a8b4125bfcb513eff29e0bcae7a7dab00cb314388716efc2bee7b4294811db5bacaa3bcf720932e253f002b53e968f930bfa9409e358a1370c298a8cb622a0079bd7bf1a0e32e8f8dde7a0f56877945d2f95f233ceb61db914a2fc789bd35b3df37f62329a886194450ccc9e708d900c1fec898ed485e2970646f939313b33a6d3416476fcb249a96f6f11d030093f890621cd7af05f335e3514d7f10972f2b56614e917d9c4cb85178cce40f09a2291211e5387ed32f8c6f90d4c90d60fb08844a0fe0786717113aaf8060208331d3a03558a26134672a33a540774a5a994c549f2ec4e048e99c45f6f44692fa09ecf2d625e843fb3c186d9502acb5c9c3e6d0402ed815d76cf081e3ed847bdf8b0db0caddcd63f8dbab0b1ffdd45ae118ad1dcd7c1306c75a1f448a0e610994e5f300c058a66f63de3e94c81e96dd0cba0182c1371f61006d4cf9c9e24cc439d0cac280db62277ae92b4403f31d0bef2674900f1c21a0fb715b5cad4689154bbf53c2430b990502a5231b79e63246d15293a37918adf641bc8f8b18462909c8d1eea14434c1a33eb5a3b425729a7885db91c54240d3e8049c3d10811709dc86e71ed08d9b41714cb20a4d28f608d83b541cf998bef0ea0257f477e00c180b4e8ae4a0698e1e77ae24715eddf432eb950c3e26972a08521c31c484a733ce217b944f6190db804087bf4786ccbde4b6e149f2471121b29b6cb21d1f7baa6be1ad6ef18295d7425b744106a6fefb550e079074b1933af2bcf989c833a5f133f8e1c490e", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("001faaf97b965ffa633612b7c8f9f4be0b286b19662e5cbe6878019d8ba1382b16567ced7a7ee5c272bbc378a95c2436fb0c6133649c77e55a708b28419b5cac0c37556712bc94140738212a1372a4720ff269102f3f0dad4493b675a85463021e03f350aa8213bd6ce54987e7b32275bcead9a9096897b5c7dcd5964a17e07a2550f45b84e947f8e46267041f661de0ced333f91af090435c4bd6d9cecb4836096855fbc396b73c589e66ad989d7851c08bb55755f5771987d91925ffb40c2f", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("08a66cc423317e9d9560c307c7918b87672f3d99effd28b1d2bd2877e09fbba41a58977974f56dc522d159bffd0099791d207d2da49ee217055f5d0806e2dd0417b523e87e1d03b9498facd5df95cd85affaa681c2a43e51497997aa916318391835cc25b6a0979581ff7042a390a7315d8f5e938ea40dfdcb24822889e494cc18dcd8bedefa1c477913634203aa21a5a926595f62f4010eb3959d51acc430fa23ff858e75bc56f4d5054035aee0fb7264ecc4861ba1c44db81868108dcdc4dd099b58d1c3d880dda20c24def1b2c54cbb20ed9da85265983a00c1cf1facfcf903e39662a649ddbc4fa6927ed85694167b49ee5787bd755a5e4ff6fb82c32a9f20b8ce350fdb30744dc3dd1829ce8e7365a9ca56bfa4f79831355157a73fe99a17a534a927ed0e6cdfe9ae9befe94f581d20a4f19aa54c93149c95d53714c5a70771d55a8c477c0ebdde254d19e591fc3ecf011848276731a12a96a3267c5c710c76eb36abc43ab4d4b5a7a82770304fc2e9487512493dc5fd59aa6eb30402d0", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("1fc8f5de35d75e7446ef5703dcd7e07ad682030dd525b7620e1f7f36908d535e151d3453db1029bf894b5bded388d6a3fcf97d573bcccf93d27456ec79d9337d23ec8c4d66276cb927175d7bc25e3bf5a2252c4f83de5eabd695181834c67273017bea94aade8279f9b646a2e7f570a88aea7eb8bd51aaf40dbfe070a7228a5d06652252d3e68fc6fd6d76cd726513f0f757783f415762ecf16fb288ea9b10252a6ba1abfff1bf53aef31d24fc7d7c18d452ff529a04bb97e2aeaab748cc19762032882547249177d5cc51a46852ebc90ac17f098a3deb8dd8a37fd007bc2baf28714b756b948ac2b606fe0c4c1c3572423892040e5518f9e6abe89e7b1875bc25cd06956892564bd5e9e8557ba6c719e2ecedb4a4996817a8e77593af1321050b2488820e023afa5734ceab7072083831db2f7063cc57cd9852deab6918ca9b00b22e3956983827a599218890be78a3c0ac7f30d3a35d464a9cd4d4ef552576221f5a9cbdba030df39ed692fe2274fe2a99fda883aa4e724d54d6a0f74e0a89", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("273cc7b93b70bbfde8748d62210c033579947802560fd05dad9d65003482995b1b7379946dee0b15e90720dfff72cbb60b60b5aaa8490ed2b77e8f57a8906d1816836ad1a19ace6e0feaa4195ee6006280ce178b5987341221c6ae618794c10603ea811d60c99786835aff3871ef0163cdceec010fd806bd11adeae2a91f4cb6179a512e9627d2af3dfc8a36850e144c7255568b3154d41797e2ac4782234925047ecbe78073575c62a32129476a6456c61545eb98bbf925ae1d673a32d680e71f20ccd414fe03613ff7a3d330ab8bf8964cba66cdf3af8bb955cdc729014e692ef7c335beb80626f05301278f5e3b228bcc981736a258ea6bc4802392f081de265db5dda279bf034808ed23c8613341b31d3d29a2f65a367024af1376d1bb9907b7ed2f35386382b00fb0afa6c5643c170010e35824d8fc84d3604690fa18b404685df83549a5573c7228b29a7dde8679d8771a19e8af709ca46c60f8126e4b033a388adb6c574f85524ff523bc7c44b49c8731b763836e0a4ebf054f0008492b60683ad457d04d91f082e169606c6e5d6e172845fe586925db00a8e6a242c409a8c11d9bd07c2ebbdd653519e9a0f5d29576033ebab9a564e1b07d8909b014232fdeb565d57fecdf556f1b9753361e8d7ceaef0d4778b4669643a8f980ed9107e310cfb6db05062d60b0810fa4aa6ff9825ebc58ae839c844f82ad08d9a273161549f2d3778e678f8167640fde4f43d30f2f60d7ec8cc83673d0e5100235e405c743fcac26a09a44bfb9bbd6f767ccf6dd030879dae04027353dcbfc9a89af0f566f9e06f1a6035c08bd9873e41dc3bf009005f905fc0b9b74ea57a16c5a2411c984cf6d6d274f79bec9cea6021001d0729f412858eda5c909d8bdce6a24980d28d7ff8a6bc01cf9ba50e6613c5495f13a39ced02158862b29579c4cb0e947142fa8592c012a3038fe1178bcb515a016a06651e387087a9110ac43ea9548a520537d116ead0e2498e487613ebb81ef0f6f5210cb448e92f2cda4a4f57013ed1f922e1c90d8e8891a308adec863c0b48faf4b7581e0565ded5a8ac6bccdee08", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaa2e832e2bd419280d247658bb64323d59bbf47df41aa729d2168a272d66e306ff18ab999098bc5b30758183a160fcca776562d9a9370278aee9e6f71053e9358f0edd6252e0584efe53db6b3c40d1976d3849f08db15d39a0d7a6e327fc67f45e24925638e68e59cc22218917c61d2934c4e6353e2f62178a09627aed68c4e57a", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("0069c0c3d6aa9ca250e5bd3e2826e47936b6e479ad7c776caa5ac801dd5a1c2115226a94941ba68cd74c5b982235773c3a9cf6a71b1dc9d4d8307251f1d031c630316709df5c7f6af25fc5f698db87b1170fdf63bd2917bc21b5037452053dd30bec8492774364ac6ceca4b56b9b8d1aec0bcda12943dd1437e515fa7fe5bf8000c0e3fd9719382c09eded028cf0c9f866d0fec2fab515f6aa60249557270f2e25f0d2cf69c495554a426914354b553f3f6f269e0d5340b2593a5793138189ae214aa7d305903ecbdbc10d564e1ebc9455bf0e8aa3ba3321f8b9023b911cecab19239edfaa2efe905d8a5d6884da42815cc84b13d9c4fb3c304cd99d3d27b61e15063c61103bc76e80aadf05a3ae6a36f90013bce43fdb48bfc8e3e2e09f838d1dcd88fe88d48dcb4d6401442b46fd713c41d36dfbc50d8dad834a9615fc01581377baf2e5ec86b4bfe2123c9f1d5cac10fe0a79fff333ac86ebffe1aabb98252316b9995e22925907421897f44ffffa963b730c7edad138f41f54652ddd8c30", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("2761d967b3f2481435189a94502260dff1044c8cb24ea3809d0eec28cfdbf6c72c87711eaab02bf1f9940d504be3727789efbbb1c48370f61e2e4daad31be6de08a73a943ab3a7ea19633a4ef9e9bc1de68a51d778e41589504b8fb0818cdf88064eb3b5d1a63404e247cd5118a695b3b85d63e89c8512309d591701596f172a210f847e73452b29da165f6c76462f2ee76ff301b534bb0d2f0f7374b041e15612a910ab4044ec261965b917059383b5d5f5c9eb201eb61a6909fb5a610849aa1f4535e9a8bf16a4a4435004b8ab3a84bb6495a0d748ccfc25388832356732910e2936a799b55efa690fd821a3cb4d352cbb3f22ed5fe865f984e289329ca6591e4e4510639258f836e30c422e3a18fb76bdc121fd28ed77306a05b8a3299fec09decd53dc1620f84154fd333da06556e87fae4463cf02459964412fa50d4b082e0120af9b40957fb7ff0dd412f59cc0acc01c49021389cd470dec453e92faa3221680f87a61c96fefc9ada16473b853c4c92a03e1e38211a9487a2812f830760f4841710cf252069ea39d70793aac9b2f769a3954310546fc15a109f6d057d30f01c88e34c9ec83f28674534aa8ad16f61b744b293b63ae3c2fcb178a08408a1780e9ff8f2973152194ebd44ef8b158470d3f67d08425c7a9d99a4f1ee9502704bc22f9c0177342d11e54a0940cd9b51caa04c762f060d5262b5f31c66d088729dcf02930b56cf1a3bcdd147cab2fcfe913c53bf5456dc19edd706ad2122be5129ff68c503fcbe10cef00f314919b033000f43ca563f92e95a8a9dc19a867e400d5a976132900579ff4d8e1f64d86a453d7576e16459b641d574d2d9af32c0707107329853a55152341e8142e6bd97b51118d4777e44d347a3add4f6e73a6d52c0175507a0d4432b6a72508a8fe5838a14c953bb0a8834366aa0ace3a1c12a005e64fcf94cadbc98cb78a5f768409a1cda219c504f3c0e99d1e8de93601046528ceafcc22a3649dd0270094b4b3fbe55fae668028e67a8dc3378fb726cec2fd0c3322db4dccfde2f638c9e7cde93246102e9539f5ea6bf23e57bb3f60e8690e", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("28d6423856311fe86c30fcd983dfa63c95bc5adc1dee6fe0ad715dbe7bba3c091165ad57bbd71dba3d734f446b3a11cbfe5e02051f6898a677bdda5134738d5709661289bdac8badf175790f8e406755b33e54bcd8149e1e469de37447185f110efd4f6454886db697584e85127bf4826304d0d9559195b6d3f875cad607958903e94e1ca8dd25c626e31daf9cd26b3caa7ca2615690127aa11647cba037c92a20179a34c869f27fe9783e133f50fcc38bfb81200b9c635d0b9bbbbc789f4cb60511e5e1561aad84bba3d2495e4853046ae1972e687ccab832f34f19fe9b55db11d42ecbbbf14d945c29319a9a945f64610a2bb9059c0c89911556232bdc6c4b1e92ef35b5ecc024193888d764218828778507233cda5076633acd49986023ba1c0110745aacf972ffd66add373241c8285dc6c96928a6ca012b4e572f1897540deab5945fc017e575d40284abc7356a20bb85330533be288d0a14159da44efd1fc7bd3676093afa2c2d809cb5a14b913c5914c77b341f018f391cfecf0029a2090010e0c084f8c16f8496f1c6db02902cccc6cb8d58118e8dee1baaea679a370075a1886efcc99523c8abf69974f742c7d2de3e12598a963713b9bbc31a9f0a14b98584a1aaebc7649c481668a54d9da6fcb308f3dec33e0965775624f2f904298d6b7a0d04b3a217099a7daf390d5a7edfd72b1c8aab02e6f5cb440cd4a84214772064081adcf6e36148eec3bcbbbd12d363b4a76e7018159f559c2ff1c0d8051f9f9abbafb9032e3c95ebde21931a554fab74bfd7f3d61c939268c46ff9c82ffc5143ba27c7aacca19326cd8522f9d55e6b6d17d4b0586b81d86e76dfb9730782e23592d8d735517d63b6b51313e09681bfb6e66cee098ebb60ca3ebb18f80ddd80135c76e5e26ec2d004f572d267f940a5d5b82e35f4df366312e39387662343e67b7783310ea825278a262dea12bd5b1fa71735819e3e360f467d0af5f522234b4bd70b251d63a8dc9bc9e63117ca8342c3dbb3068df38229b5b34f2bd21097b0a55ece871e554a89aa97a7ecb95cd9e1f5ecea94274019d17b9943de13", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("15848a9e99c4a0719df209a705edfa52bdca729d0b73a9835880da9dc0cd2ace108b1a4ceabe6a8ba3dea041bb0dff513e7b99057d4b3c2aa378807de47dbc3627515ea8ee84feadb86577a1b7553b2016cc63807de89fcbc05bc3d53b0f23332872f837e4cde9fbf64bdd170d6488a3155bcd5b1fef4fa7ad10089bec8ea7b803713c878e32a49ff95dc2bbe7b1491c38258835dbca14ab343e88dc64004dae0f9ec7e3c20939b84e40bf66864e8129742feed7e1291d752c76bdf28e02d03b2c48bfe10367b611f37ab5847542df1d30baed8abc5380d6d80032d0e04af0d10e119d730f867b4e286a3c1c4cd04236999b9bb94d9001a4f144982d72df407d059e6ea753e84de7e8b41b2d0dca1cfb6b12afeb2564a5e24a2064f1b662a1a912e0bdf2470e896d7fda45c39a66c5c4a5297b4f19810ee37e33f7f50499326b1f70831beccc3eb5fb719d27f111e5c731cbeb4002519a4b3831ba896cffb608157b59ceb6f7a0518df929eac70c7bac9ef9c196ba21266ff47cee9bb0c60864", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa80728695310187ac477bdf3d7fb472e6374b1222f8ebcfcae72a8b1dc714ec853461fde556a4ef408d4a2ce89143674e9985eff87fa3df3ce6e7483c3a2f9b82bcb18df8612ef09775ec815b602e35eb6ec71ea6f7acebdc23667a60eb465e76d590500f7d19190ee1090bffe087045e97c913f7c5730110559665b3e8a9e0a526e", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("1920c53c756f1ec1a40e0264e5f65808eafaeaa7b0885f89852297bc2186ac9d09416cc536a27b6d5616f74dd2bbbfb463b9961752e0aa38d47b5213994959ab081c536b7d9a27636d0af7d4c8dad2e380cb2996a1d650a2e6123224294a6c86039e75a4a93bcc2798aec714e37b9b2602760e7ec7c6f3342e44018f2986da9b2d1ceb9ba9f7b923459d8b4701dfae12b3efd4174fa3705747fba6bce14a87720c15d04d2bd099f86ccaf9834b9588e88fdec8d04bba329d4fed580884f4b2bb", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("16a9fe4620e58d70109d6995fe5f9eb8b3d533280cc604a333dcf0fa688b62e20b972bf2daef6c10a41db685c2417b6f4362032421c8466277d3271b6e8706a8034c462aaaa7a3b4ed1266d755867524258c64b9553c46b2bd4d5c26aaedc66524e9d39a8749083573a1b84662c08ae15f16b75b9fd40089ee412f5e58dfad350e28b1c6e881a288290c7e9e12d23f122e61e89c43619f902c48d300ffe1734b014f125c1960a64127a16c8a17da5f21721e47b17575a94802a78711f45fe988", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("128b65cb80257f3006fc20dbb6af6781da7e0f9213d2b909fd113ee0f2d2bb52251e288387db7be742fe67261f36a4f09eeb4763bbbaa1bb13af3dec65302a4125ed8b2035e437f057cb45003f1c25510d7e232c7587581bdc3035064a96d2e32293733bfad88afa5adabcf320f055e3fe0d1ae733dc21f5e08fc234029be16a18414155506a4c287ac374bc28635be3e6b8fd0097554db051a45138f0b6140410f8c1e8992d53017580b1b806cd23729f9a2aefc6e60bb82606551c1393750b", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b3629f2c1dbcc614745f242077001ec9edd475acdab9ab435770d456bd22bbd2abf268683f9b1be0bde4508e2e25e51f6b44da3546e87524337d506fd03c4ff7ce01851abe58ef4e08916bec8034ca62c04cd08340ab6cc525e61706340926221651b71422869c92e49465200ca19033a8aa425f955be3d8329c4475503e45c00e1", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("18db259896bf7a55fbd739049dcd87bab41bca06dbe6ba477bd91293ecc7b72a080f9707ac098f3ac7a06fc4cddf9de9024723d7803df1e832f23facc344e09f1f0a58aa3d929cf73ef5fb29717b46818570f8acc287057a61f1bf19952d5d870a985a1377ac0068c32090c4f61af49e438888371fa281863746ad9c4505839a1635829f9dc1168b264dc1b35951410b3f509179a86259cd1bc219e0d9fb6571282e9a7a2784db855d8fc301a21574e67751c63574f552b5075cf0d54feb2ee7086ac4e5ca51c4e84405e5310187119e9283a8e1d4b9be261bea666f724501c302d9e8305711e2081373125393ea672966c2b7931d9de75640aacce9bdd8ff8109610ee10faabfae8ddd3bae29f8644762b842a90a4baca50bd37c4c8e346cdf2c0a29ba08d26cd5e2ea3ac028f2c13854b997da5de4020810d8d1df0b5ede16181628b1a3d5936ef9414119e8bc454d0209022d6c3b6722ed63bd3be9fd11ef16a94dc0c53b0283290c9189b46b2b2e727ac54299b70b73ccd31eadbbbce239183aa0627c185bbed1b35c46d0d2ab1e248f7a4ab6d1896afcb8cecd471911ef208db0fcb30c4d601aecc21ad3457e4a636a2bb289712a98153589c3674a774f08c0f49c7c290fab83aa67c3ed645856531b1e537e060fddb3b722849819cbfe04336ad8c78b7ecd068f1f543b4cf09a510bed3f39c8afd71b549b957d5b4fdd0f2251c9278bb30892b0ea4fbc771380481fdad33dfe0e9f49916e476823feed199cdc78bf86665cfec1b451e92bb8122597a0b28bdd5d380024756fe070aa101deeac40a4d371c0154aecdddb082f6891c7c3a5074e1b5c1b30e4b3ffcca6980bab17266f609f8c1616cf6c23c51e60b24d2ebcff2c7e486abd11f878ad231b2e69a5773f6986e289b67c70b92da16c0c8f2a8dcced737641061312f5fe17952151ca3275c32561490b233e7284a4690a777da485efacab5557307c6d8e588608aa1e46b4edfd86ff457f0ab244e624488e4563be1a0ee35df8b547c43e4e0411b1dce99279dab100f4137847c3bac64342dc95b9cdc2e5880ae61f898181d8", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("2f5a89469bfe012ba76459c35dc24c1aaddec05eee130879f7258d71c97f03072a93777508a68599449e21e16cf2b640f0ac5256231548f2c9e50ae4ab5e2ab7164dab50c5945811423d8717b2f08c524dca34fe055110059a5bb8efefef74e41c89dcffa0b3df9389dbab8f04a89cc52d76485eb690c5a80978f41c33be93f42a7f7a7181c0431613af56e9c2d461a71c0dca94aa3e19736d8cbc3467d841db2815f183c8fb13e36b83a9a6dd99238975ee7578b4dcd316c82818ce012092902aea97784a5249ed59850e30f1d7eb74e9526ad94f5c32af18124ae5913cf456064aae479b94db0dda94455282d2a5bcffd99d5e7749d631125dee0f33c3c0c1288aae58ea8eb4202f12883fc0fcdd68822e03f63a12d6242b0087a8a1495f7c1be646ac485c0d2b972185613095e4d65cc62bcf5b3913de994b430027ea5baf0e30fec7ffcd23b4d7a6adca3c8c994e17f94c76042af6b48441963bd5b478ab11aba040f130739fce83eb9c79c4a86eb251f79152f92afe5d81602744259567095129ca02f619571508cd4f14e669bc759afdf2a98f105ee1d19cc5c8666a7b2059b1d1d6524ebee64551aff3c1c058bc84ba359a85153c6840f9fb99406e4400750e00181c4c86d88d338f58ddd60e5a5b80f83d1926b199951fd27012377c28f1e937b0867a30e1617c85e1dc0a867aa5807b719aa1496cd41acd4a3cb2991018dfefe4eb662fa1a8c892d1971077cb3b81e43c75f412bf4ff67fa9e815cd179228ad0e86867ebd465e80e0523cae366cccf230dd02b58b4dc334f76d8efc1c1657225ab3c04d3e48ef50feb4b1133655c54465ace6d5f4d9222997430e302028fe47b83ec99feb177ddd4def70f8d7c3d774e6198476216ee7d9409b159426b7fcfe50427a47af55719f445ce0ac65f6b444825fa7fb4aa602fa343ae8040e62f09e7e4fd1db2662c0087ca9782f37626d91df409123399dd5c2823268f725da972ca1fae6732cfbf12bd9e5869b5dd7ade24e58d1914de52a6e6c24df6e25c64ab46e4bc7f94167fbe9daa225946046a1261b42fa6d1de0d471ec68aa9f22401b525d3f7e9847bd13103aa28e4bf2e1f47a545f3f7cdcf1621fd9c50cc10f0a2bb7c52925b718b23d79422d7990c7273427262817896b3aaaca889ded820c917c1610cdfcc5821b58b4aea58c86d5793d520d9d8da0a26503fed44591a409f0a9eb7fe6a724ac3f3f7e156c549fa4b51fd0a05231f3fc26b3754ef8aa031a9235db06ff5857739b5ac772d671f809e865cd6d9549bb2f4372f194ee2db50e8e538da6c93dc08c2e85e029c1bfaf6132f18723c06bda51310ef1b746078a2a81296acde9cd3c2de9c5085d319a33d367fb2d19db1b610a376087d1d4596b22909b27282665c97809407bce99fea04e3ebb87e95e0df79e41d67857447f71018c7682174152456cd66cdd61175e8d139985b502ef4a4730334311d794a9a219b49ef5a08c7d3e6b4142a36591873fe04e3f6c218982bb9a7892d8edfb33d90c10f844fde21c32be49991aff39b1c5d5a0875f0ca696b016821fde000d76711b26c07ccd8f5fb96f3a5a5be4d92116c5a786f1f0f762029fb04ad749802df01b91fe1767d07ad8d6fc7b12dacc12c1e0dd32301b60f5579b2e13d751ea08d620421abc8a1bf2246e62468498a1550687dffd7e15c5e7a74fa55b81d5bdeeb6236265d34c29d7d7ff5cbdf071e6489a784e75ed652aba5814530dc2fe2a065c299c3011037f4aec635d14bd3c9a6113b7411d745cdbe920133008642310a3231c7acee4ae528f9cbd2aa8e73f7fdc37067fa7eac6ba22d4bb9b40b96fde7d371d47cd1b8dbc4d5d4a8bf2b60721b9c1b21cb53e268751ec7212804ad98355dc12f7c8d64a99628ac80dac6acbe0b16220fa9ddba015ba16f06c8c57ccfd506418ebdf0ce1738762d3505949ffea9427406d55605b54d05e1c8f1f63cc760f7818f76c8f1552dd6e7572c2e2e84e7ecc83febedf5a789977325ab2fea33a61140baaa1f9d64fb647b4ed54db970b32eb9aec6aba90e6e8ad68b2293e39ef6768074635c4e095ae39e6374b99a6abc4e89155d6e1c5a0a135703c5be082fd44d715060535996f9642fecc139d06a140f8f78b100099740dc0325156b43727224a", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("2bc49f4d8134cf72ce0883c589f4f6f0636db174b6176e063b3effdd57e3404309f61eba66408ad541dac082701734d6e6d4cf6f90bc0e65d6578f2d18563e221eb59aa8d8a9187b0857ab89a453fc53209855b300377bbca411998bdf9aa6730bd2384fa0ad96fcd1fc6c1a1a1fb80d4859770ca91b9559281736cfd6745d011cb39aee49da07d70b0f579101c412f1068ea82671859f09c4c1cb3ae74f8cc103fb73a573c8f147ae15610e4f97e291bcfe16556842e00e88ad70db0df2dc3a05430e574064f2d1de68795706bf99b1b6079a99bda3e5ec266567f2f9246e090f5976710762dfa75253c53ae1c2c88523ff08d0c2523d9409033aa2b7e4392000036daaeef66504945efa89111745e29d39ac317d798bbb1d14f84bdf5bfac91134d59ae245678087748ccfd3c65ecf2db2d05595cd6ed8452346713768c7411ab6efb518910157009fdc818e5d4e082da02f0618f4a3d6166f830b81a4e683023ad24b09b49bfd967c7adbe895811172f04a2b90b1379dac89a6fa1a91d8cb", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("240517a373fda7a2fef6ee9e9895505545c354433af3d3548b8537abb10d445c12e45a8b8c4d7a82ae27f0ffe3dd976b1242b040b96043ad31ce9f2ffa5bc707275ec5565ec4ccde5088b40c57c946be5d48b9ba34f956611ec87ed33d47500116f3ff1c54f920a4ba438c43501d2ef59e7c7eb2f8ebde852309bbfbc087af1b1742abd3e12ea49804bc4e8e59ecb9da6789392b1e12958ad653ad49f3d4d8450a1190ddff2fe9afa9dbea1e42222afe9715e1bced4e7ac4c20d89476ed6253c0bcfe3f03313340fd392b32bccfcab83f942f6b13d71e2a3159239c61c50c7bb199c36728784b46d5607ebd7cf5a055a3db4458ad6f0fb7e826d6a280daf625d1db3a467a1de6f3b848da16893902bb07fd0b63f6509dacae6693c7975fe09940b291b95276b136f58cf6f899cbb5a6f4009a4d069be6c0f8f0d6bfd7c38991f0e46dd20f14881ed44b216b44ba054b1f32c61d01f33326ec7f6c2ace3c8901414f211e03a121fcbb34f328205223d7f7ddff484efdd5d06e8886f2781f8e549", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("22f2e1830cea84486d7ff320365a5ead50d356379d7bc4f2b9d77dd298f36fd8087baa2aad4fd8bbca8cc0b525041e1b17aeb3ecc63086cdc6fd1ec2310bb8db243fe8ce837f106ef17e387f9d78df833811427d5338c83f0622f92a65101da31ab23d2eb26b70ff15decd58baf91a68ec85f149012d481da67f806b0571c9471928767c9a5576ba5fbd7cee08203e6de3d9dd36a756fc621700031081a80b7e1aee70334cfaeec2f7551368818353fbd5810266c7d1ba49de47cec9b81b6e82007aed597093879d894ea438d094f3373b51f31bd5993e026e76502bcb1334e32189a92e9df00c0b5c21811462933dd17a5328075b472a53ca61bd9e136701571e529e7c4912cb565a3819473e8cb2c45e0a7b17a63f11e509d80472921e86f92fabe095002240b012e60bc9159383bdbf515def6c41acf180adde6913625a7b11d22c04a21962ecdcb1b679168cc14899e2912f233ed37d116cbde2110af4861ca847018951f8d71a369874541390d23df3cf9e5031655d4e7af4affdda5ec50fb5b633ac619c06ff0312901dc9d949ddb443ded5f59662788c101859ed0cab1782bd118c15612ab18ecaeeb9226a0145c0c1d01428987b8a5523c6da78e015261c22b6d73323e863964a003fb93594743f70e9248ed6898776780a7f3ae7a41b07a0d873b1ece5c55c6c942a7c7249c3d9026fcc607a68fe6e73cd4a76a6821f86065d5e87ffecc2c47bbd85658eb21bbdacdb79f23b031a8c6df93e64574c06eb93cb065183692c4ae4dff2efd51615d926782da50054e4a280c5bafb913d02369aa17493b4fccafbe637b1b7c9e1225e7b6fb24720f778548e304e7617b407e83fd6e3da09599850d6399059fadd57c4fadb492f59ad3adb4783ccda65272f190a9ca862a6d9508d9b2513edecf47aaa4fdc7a64127dcccbe64b7f206d400148ee9fc305099c6a7334452f25473a58edc7161895ab52e3590ea600e2e885010b062ce0df9974072bf87f5a1c8072df23e612b254b688084b5958314efe190bb6fb66657b45e6f81fa7c5fd41004f815ffd08ec00cb46ced2b1f97b04e69b", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("0e6eab4103302750b22364bd1ec80e5edfb3ad06fa175ff2517ca49489f728e9050a17b5a594d0fd6fafed7fe5c447793fe9b617f0f97c3ee6dd29638f6c9232068b38fd28978b73b64592127317a542e084ea8291e404b88d3a731207104f9624d1ae64196a7d3b8e9fdcf72f9dce16d649fa3971daaca56405a0d331e2aa92210a32dfe27a36ca740e4d668066f7559acddea850fee4ebf9c9a241b337e771191a60da23a028dfc3b3b82c3d15802615f6386f29194e088936e3ffe96809eb", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe5712fa10f98bc3c4faa2a9729408e92a8b4e6d304abc539cc396820f696f23ecbb2b30d01fe71a3550fa6780e70305d28ea686b72aff7d23cd550f886fcd60f6b30d1142c81b9b27e329c498e4b241fa2ab0e0c62170cbe2a1e642589e4ff6ca54069ec036f519726e40596ede6cd47577c5cc24746754280add50bf87fe7404c8", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("1688243c91950e540e5acdc41b84ee9d2b1c0ecc84dc373d6fd5959baebb33df140c8a9c0ae42792290c177a97425bfbfaf7ef008b7656e906c2df69fbdce89a029c4ee67b639e4b6f7cf0536ba1f24bf61837351b5c74f12fb6cb0887aac3ea1d3c75ef1b03ad925b1b223901a8e7a4e16ef2bf6600e7c175529c18ba8008350aa0f1fd72acfd2bc3c50664eba62133ea85341f0b4ec0c3618f3738401a42ce1fc3592b9642716c47152c9e52881fac74773f705c15b7737e0831ced7a0f8371245c36152deacfd18a947b3f3c83a30652958dd9614b7beef8aa8b5cdb157462ac85cca98a10e6ec5efafdd593179f2f56c4febb1ae6f1d72a9661fd8ed51032b98467d16a6e8e6bfb427838659b8df567ca38ec17c979560bee66d1ab72f372d38efa3e51e7ad3ab06b5610e0631db0a385101b45d0fe47c25610213aa023208289e3f0845bc2197d57ac44b4a808b30aef09a344f80062bd75a1844715d3d0cf55d95f2fefda6a1bab5796626fbb6345796ef134109de55bd61654f54c71f16eb795694ab923473ee66eaa59bbf61de8f8dfa94c481cb4f224b3ba90ec87318c3ec099e1aeb3d63840ccba2159386cb3d71481ef18b5466901b71cdc6e75e1ce807182d1b89fcbaff954b80d8a58d49c953c05a64e2a326cb3ae4802a0f9f29719e2b60002727f32b49638ac3c1d4addc61cb260c4ac99307ba24a7743ad52f325d4f32b8477cbd99a218c2e4ecb3171cab016c51cd800663bec05624f1072775db17ff93e8b807067572c97cbc7321e9690b8fc4f193eb0f1a93ce96a5c20cf7cc3dbf579b54af41204b2451098724e9d8940bd4cabff1605f33592e5f002817dd14edab5e60dde89c66b3c93dc057c53b926b2077d63d2dbbf9316bd64c2bb1b35df3f9ce28954fbe15eb52a08aa70453112cc94ad923616aec0553dfce0d5e44001e7b139917b4cd2d32bca418f24f44bd7ffa16edc47ff8178efee06f28630c2816b74f232864deeea9073bdc2128d704d2375431c7bb196825b0ba890b5ecd90caa2107b346a40472b9972bdca3e388e38a2914e2c1f022a82d49b4f", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000")] - [TestCase("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed275dc4a288d1afb3cbb1ac09187524c7db36395df7be3b99e673b13a075a65ec1d9befcd05a5323e6da4d435f3b617cdb3af83285c2df711ef39c01571827f9d", "0000000000000000000000000000000000000000000000000000000000000001")] - [TestCase("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000001")] - [TestCase("192c207ae0491ac1b74673d0f05126dc5a3c4fa0e6d277492fe6f3f6ebb4880c168b043bbbd7ae8e60606a7adf85c3602d0cd195af875ad061b5a6b1ef19b64507caa9e61fc843cf2f3769884e7467dd341a07fac1374f901d6e0da3f47fd2ec2b31ee53ccd0449de5b996cb8159066ba398078ec282102f016265ddec59c3541b38870e413a29c6b0b709e0705b55ab61ccc2ce24bbee322f97bb40b1732a4b28d255308f12e81dc16363f0f4f1410e1e9dd297ccc79032c0379aeb707822f9", "0000000000000000000000000000000000000000000000000000000000000000")] - public void Test(string input, string output) + [TestCase("2722ae33a1d80f67a5da37ef2b7489dd39b1c98287fc408eb416e37de71bba1c3054f7ce76b782aa80254ce991fd5f115810e8f8f57ed0a12f30278112157c11165fa63e0d077c2b406c1001da54664d756636d6018616841c5b0d942519fecb1090ad3ca54838d2b89c0d2e3db3c2aff811d58bc32881d2ec947f473a8308a615b9fb021f60b7604ef07863fc6449504708718eaf59bd00f3620a9da16ed8830a95e72b8b56d1850126d77ddbdbd376e3b19f07a75071f0b958bd40471fe6900738bd659eab6973c3416b9e7c9660d341e8eee184c0f9c5ec59696f220903401e37dd4714f68da2a6affcf65a8cd26c7ae3fa0c0e5a3394887ceaebe4f49de90b501640d9ca26d1b466a9ea005b942b047fb519865b3413ccd90533d9902a85187c1fe325590f77ef42af537664469fa950986ce82c31eeaf1f6b348a3de3c6202ae189a9bf004bd80b9d8bdaa9b395a5263735242766aca3679ec3e547171b2a06ce9550542e6246331cbf852383c14830931cd63ededb0f21621b71e7f981", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("0eefcc4248b67e40298c48e0ed47dca1dbf6f6e377506899430b11bf03b17ede10c71a49ccfb43f8475de84b581eef9ab283c1238e172bf48150f29e1e56201204c9eaee6321d6ee36b8670498aa1c73665f3ecc7350c8ee09a573e692d26320171450a989ebe50e365b92d24c311fd830972e7b16a2523e634175c4e24c884a1a6bf429331081e6e930bd36e23bdf91bb8180a6e4129c11655cb9468093ceba0e9d0caa4d47983e49ee253051aaefd86cc6dd367384f89e2d166bd721c658122a55d1dc0b4bd2f33984f0099a6d44c85baa10aaca32d0ec89e494d24514a68c2d43c0e6576ec46f88dbdcc7c57d685a3eb9342ba7c71b62de9e6373bd9094ff0a716e218f8e4174821a7dc090fa93b7683e2a6e363afe3eb7287a7dcbf9ea090dada034b037e05a7c8b232b8c691b7f0c3b9a870d786e913d936f8256f2e8c0131bdc0ab71a147cb4d91bba85941c00ec91994d2e9e53b1929a14ee2e876dff021d8b2738aed0201234d3919498c918fd5340541ec616542d92d955df4c182902237ac6c6802585c60640eefde7c05fbdf206a5ec25dc3411a4e9b4e6b57be611bbc865815ccfb7c666b117834cbf2a7edd9c2baa691ee3d453c3652c49761b234be3f502cdf3d1e6258eb846afca7acb0fe13577e226ddd277daf32d1d0c5c25e39a0be0435820302ccb2763016b10d0dbde867c745fe86cfba8cc925a2eb72d4bb48beada74cddc1c791a980d9bf7601ce0aec444354a5c02185d392f66f50e4860e017fc0453fd1bb0453197ff5abfacd35b90e7d9b03ff0900cc857ef7f2f0ccd45b2e137fd53d99d027b79aa390ac021bf4d6aa95cc96bacd6a071386e21f73cf3d42f0ed82ca6f673bb89223e16386c7328385edb01eadd4ce28e5ab418861414b0b511cc6300bd0cc6c95538014be8a4a20d8cf56d74f4a63225302b1f065e5ce6c676af04344de377f580aad377dab935d532f2dce9daeb0f31d6900af84aeeab7ebb4390e6bbb4218558fba894959f2cc2fef8af5d1c16998a38c6076f86dbd858db5b0b15ca2cddb0092ef861188e0434f4232d7e3e884fa42bba", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("20b961c884a0ad42964edc3b580f607681058a33aee25d60f7dae9f060217ec119d77c703d1a93059a1baf9c17319ca9f1c5fb4a04855d6aedc308d9070f9769103dd1a1691e5fd39ff70241d7569c17764a3824e49664f5145f956abdd559af262f0e5677944e1834c3b5459e0bfb126d41a8afd73bfa12ee3ef45f17e81ca62dc7a825213952eb841f8942a113a5cbda01359751726ef26ce05491815806cb2bbefb942c709bb4fd01181e99ae1716ee28d0453ef725cb8ea45f7a4f93c6b3203b2360ffca610432f4d1053e633004d7a822ebd940e9a546a7d0f2038728921f1aa6348e2cb062d5e193a49d60214f2f0752fd32b57319b877958ef0f7eb9c1b32607b1f0ce57571b1c609260f757911ed8bcc3896e6c95a13655d11b6a7f929b9eabda75ba7d16a31ae4b7af7d0eb1bb349169df32fa20f4cfc959e722e0f24d21c9b7e68ef0e4e941aaffc472a7fa0b9d03b7097df3c993d108fa69d0a8b189dc5d953fcae14f53a800fa624429d2bbb94ec56f371e65dce393dc602ea2a04b4e2312aacb2061b9d55e615845b085696a908d76944bc822ca909212ac6bd05bb2fd64a97c2dd2e76b9ed90febf4fc236d4c466ab7afa4050101828fa67a02b0d987e9d5d717c8be7757e34354fc9a57198e5d8e867a8ff08b3e3020c84cc015904ec31cea03557ca10f0b7f5ea8b5215c80c01f5cc47bcac78c0d2f1f312135154f38704a2b7db3dc7c86be733e8880e07aa0712c2050627bdf56acd40482f36f73badb30e320c12bb66096c8bd7b978410dd5449f250519c6a122ceda572357aea961fec54427a6a1e6cb2d509210e0a6c049d39eefcf09191b561f361a2d372ecd78676d8180b6120c432178bf969e889d2e386ceb20642a0ab00f1c28263dfd316e344e8f9c1380b0fc5b3ce5bf524cae2978f53e6dff5c6cdf0743ee0c68b4b256d924d9635a4cfe45948e1f5c137369b47439912b113818d26e766d0ccf83a1e2015a3ac6f355345d4ab03f710bda2bf76f42eb7ae70aff6f955184031af5d2333c1dfca388231e1d78a53749973f0a6a01f8ad0018704c7db134592cdc9744ad7b88e407d0eb04696b62fd57be16c249043f670d881e8fb7573f9d0cc54a632cf9de52ee862a07e0d9dc11a3f4df8c9fcde0bc80f9fda1b8a84efb0b67884d640c14cc63211267d15a405fe9d03f9713fc79cb787934a778928b1f244b2e84e926f2d5a7e6d9a154873abd1899a7b20df25ae018279ed525e939da2333d4121573982541bb5fdd5d6570676ca6a2979f92a21a563924eaf1b2cc3c16190560061e4eaf988b117bbef2a7380429021d7190eee78b725bc42613725d2a2e3d1167ad6d74508c5322df36e614e10eedb067f8cfcb9573e9281b0b827e282d3416ccc69d13090246f223e743d077d3d167af6558cd17b8110b422b70462dfe3d677fe5a72c5125c9e67534c06a4070f0bcbd8f6a5d93a7691d63a2811e1908a4f98042938fec22a2372ff55c50d679bdb4dcef9a1ecc1dba4fbb54f6ba153aff2b0ba9da968ff1b07f22e95f4404a924ce1d68c9d4cddb10aa9680cdc2064aacfd45913bcc620e4cf277913eaa093e4b3ce25f40d1ac255f863fcf59c2066e98d7ecc5219edfdec9bdb718416fc65e1b48f3a5e33f40a459600bdf13c8144d022ace69574477c864aaa2cf989a862940f80b2c85e5737926e3fd1e18411d06df3079e19f11b85b2634cb2788caa2fa53cfca5de8888091dbd8cb73b3651e0c60e28b318329e56ce5cc18581966834f960344fe9645682b800bc138e5670f8f23befa1ac5f9caba7fca7179167d2df6ea237dee29bccc80eacabd5a51dc06f245eb13c8ba185388b1de78b300308010a551df2b5311f3ae838318d20297179bbf83449adaf1360b0b10494e299a9cc71672ce5774394144435ed65a061b230c57e56d08af54493bae064a3d94aba34faeab22b8056c9d1fd0b499bdade429c428761820248450189abe14f51cf3274aae5e2d65644e9866e1e5342faff915cc65f72d8210c6aab304b14ce4036862bef5e03cc6269ec755cad0f1bf285f0a67d6a9e5be0d4fe6e50b707331076cd11d96ea9c1c98575d21ca59083964fc06691da6e6e12b833b3b126f159d4fe2619b89bd86423b6cb9bfcb34480fa78c", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("0341b65d1b32805aedf29c4704ae125b98bb9b736d6e05bd934320632bf46bb60d22bc985718acbcf51e3740c1565f66ff890dfd2302fc51abc999c83d8774ba0d2c492bf135ed45b0d6265c274d145d35b73afd41ee95d3f1da4bc8761038800251d138db1b9748ffc257b147a1aea66413b14df767f98f7ba02489c617eae51065ff2bd9a5b167db36225a35fd712d781309f4e2c8541a335b2c42bd2bcae4191cd528d749c52f3e198e534868d537867109419a32314886f6bb2bcd337773", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("03d310db98253bb4a3aaff90eeb790d236cbc5698d5a9a6014965acff56e759a1edc5e9ae29193d6e5deed5c3ac4171cae2da155880cf6058848318de6859ea21ee564b4d91e10d3c3a34787dc163a79bf9d571eeb67ff072609cbe19ff25fc7270e094c2467dcf6ecf8c97a09ef643cfff359cbec1426c5eb01864b5cf3c27309f432f65daced7c895c3748fa0b0dfc430584e419442a25b98e74400789801210fa7bc208e286ebea1f5c342a96782b563a0bc4cdb4c42ba151b9cb76eea93d0abcdaf6ffdf0cbf20235077c7bb3908b74b9a8252083f4b01dcbe84cab90fc71a9681988a15b7eea9ae8cb0c2210b870eec2366e0531c414abb65c668c6eb3e21d0be81c5698882ee63cb729ed3f5b725d7a670b76941ddffff9ddca50cf9af21e61a0ac51a17c0128baa2cda8f212b13943959cf26a7578342c93dd2de7deb194e408b546197d9ee99d643e5385dcb8d5904854d8a836763ab8ce20f9b5027222aced81c808247572971b490eef1515a49f651f7df254de2b35310bb5b78c218b2345c40036ea331bfcfb8536739a5e5530027709adae6632a3613cd0838cd204121beebd54ec6bb063ba5a6d84eeceda2a733260066c90d332425e992ef6c2b0f794d64952d560a422a7ff549a58bfaa0cf791ab6dfad1c4941e19078040324bad1c848f2d8efcd716f7d814c46e2632e74a5b8d455a64c55917b220aab982ed4bbed5f80fac726f4a95789fee7905eef0a241596acbea4268ec3f2b87f3129563b69a30c11a856f68c72f129988e8636c86f57467cba299cdb4917469b49137a989e5d714b4b882d4a455600940ab63b14f23e7934ddd62cf5181099c63b2f57525eb3d19451024a4e71ee09c72c5b7e0dff925001acaee126bcd29db5f600d8ff46230e348d08dcbcdb1f85a5a43aa7b4f51841f1d4f98c18bbb57651982cabdf6326194120727367bdae0b081aa7da12c8f8c6af0ce27d2f8d0f059fe1240c9c5a6993d344744d77bbb855960b6704e91846cf362444bff1ccaf45a7c217873a5d7834d0c1d7d9bab5f9934d7ac218834aa916d459d8ceafc280d59efb", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("198f03850c2c5df1bd5601c0a5cdae3cc955026dba50a79dd00aeefe49c48c252ee3bce85e4c7bb10fee21428a8b0c1328d662e152f36a6c62caaac2fe097c0b0c91b38273eedbc873b2172cce9eaf7af1463cb3fb064a49cff2dc95f0b5bc1224a1a5e52496677b5dfa29a4e314d7b32bd22c0f437679e12d0c49c9d84e988014d4d06a717737c0e36767b06809bba6bcda2707bd652b3f922c3a652dfc90b325d0de555188106e9c4bd93171a8377b9d53eeb93b0b259a91c7ba570591f4010f2dbb4dfc16b4fe806d2ed28daf51530d6b88a81c2ffb98d3a6c1153db9239421b7f52300ab7b6eb9d9ef4bd7d58811909cf4c4ad7a9f8546f56099eb6ae1370224ecd4af7d5ec18e5b0c8eb46a8bc774fc4ac6c4233aafe9bf22420ddea4752bff288e58f4bc80b1bb91b450652c120db2ece783788b8ff3beb20b2e8d3c7a2d90a5dc703456ffb854fe3a746143e82bd8e4aae8321ab59a93e5da9d615ede07f9f33a0a234486c63562fd9b27ee6615655b6880bd511475059ab40395d23c", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("08808ba03b1abc4b870cd2e50b3960e85ea4ffde76e97ea70e62feb5712ac68823f1f949786f8cf8a18323bbad75bc71afac4e2419181fee3a627a8980f5d36f243b9ecee8d6c2f2f1b91980e4f7136d16f70c94c5fdc21354adb977bc66d748207322b7980616a6e4f4ddc3f223c52a9a11b785298b69f4075349274adeebb21226d7ded357133a1e9a8472f9c0f23e248c1ca1974ae336f4316731f1f473bf00b29428be1694c86da00b5cfe677c1b3332c93105d18df718f9ff0053bcb7a620adf7f96265baa9a9b1512eb1d59834eb931491d360408061135a8b30ddbfdc284fb8dde65089a6359a11fc8d2725409e2bc1e52141f1dd38bd56d10015346d0aad6b6b34672e8ffda5085e97e2a7f82ff4e3e6660b83e151b778e2dfd1ef3f14b07ac31c0927a5cb27b0447051f1ea39baa7ef12572b9b5dc535ffa28341a220dc6c1d760064168c59b36eae9560df6433eb96acd58aa88499ac5f081eed30245b974d3078709e037860b2970943659596a88d529a36275b34b38c51ced169", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("09fa51b9f1972a041220b86a762c252262d942474d9c2ddaa8d292c79d34b8132771b3f3a480320bc7c9963dda5f4e8120b8f06a0cbc6095d37e0dbbf0b6f9ce23d0c74ab9b983b35311ad334580ad3e9b8ac6eb0ccd69a5097884056c8310e01317cbe87801a1bad8f362bfa07f65f4e6f0df7f1d3681cab1995df75f3caa2516abf6c2348309a172dfb07485e59d4b149d20741c740c9379f5d235c8b7dd922fc0496ddcb63fea074ce4aca7f9a91884b8f3158970ba3f03fd58608b50b7d511857f4a462fb73fa92204c79e81824de2825b74103238b4f8e601a2cb37121303b531c48bcf5c8ddf8e608cd16eef92bec33929ef4d8fe57572214999746567129e8547b1d2f8103bfab8af9a8849ef950c020c2a24c235c889dc65d54c6f00036688a10447a1ca50ecb46b9c77042a3e0959de2919eb62e55e08f94b3b491b05f4e65becdda13865c79072d38ca4a35cd934ccda724348e68631deb874a62d2bec9369394e4b5d549558b030a5b8681d23a67cb9d95465f531a39ae61782b729fc71bd60da082f1dd43572c15900fe35d03e10201fe93668c6e31e0e4330212b0fe78b06800bc1a549cdd0ff91ea7ada763609799901b63a1d3ecb446ad1110847890bfd62a9ad72ad058345167d3716969f4f0c1861e532fcf5dbcbdeec04018770d45b235156f127dc39b55ce54daaccb9b2bffaa9692591647fb85112a622ec7b25af397ed0c3738c242d8c7d98753b0a64f826ad284412b93decd25a091a8d6e03829186f4f33185c75bae823e2840d04ca583753b9ba7b9a215de06ce04ca57858bb1cf75033675d652331e737f7d98400ea1b42102273e74f75ec4a41716a588640c92a28e2d4bf4ca5a6c8fb6fb2d910ce2c882fee639f5e16f11cb1967f6d1826b83b4197e628bf36eead712652ea75027a48148059fb422bf03550f60639bae9064af3ee671b9168eef729fa30153c89843827a9991da684d72ef07e000a8e29e909b06936cc43d82c5bd6f7a4108014532483f674ed28df007232003493fff270b3289b402ba1eab4bf90cbbbdddaec3e70fd0eb648c0fa61b2c", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("1a4db8abfea95acd4ac4bdf3d9082de13dcb9b2a73d6aa98a296a7d7d1009a8a1e8a143f9ed8661a223e211c4f70b1ac1d5057d71e31f182637b6f26de9a59190e817e9fb476d397b0f09aa07d290cc830ceac3ef815c5b8f45caf2cdafd90e209888f93aab917c7b6a9f8ee7174ff889961ff3509256873a774926c0c5b9a0f1005b845c9f53465d9371efb0eb934ecc8db144d466eaf06614e89c77305c35501951dfd5ce7f374b05b2b2a0737a5251ce4d9f53f0ee7fe79399aa09d6bfe9414e57a7979f8f2d78a1c7dc790476265240fff65e18344caa11b0698a574d4412bb862b7c0f8283e05e10a9b6e3bd19e5b69f6988b3f470692f26c379c33132126a4d85b3499d830033f0388c18b8e7b824b5b0b57db1fe366a435b0c1a53c6000ed1afda982e3f8d71da60ede43dd562ae63597ec91b1cba21e1c9fd5b8fbd81795c6b9f6debf45b77638122c7333a59aaa2e7511f526f496feb84c20f651552581dd3c6f3d05c78234b559d784f502fa5dc0900ae7475ba88716e5ac3d499d", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("05fa7cb22fb8809abb745dc167279147fa174e0444cfc99a38f23f2b93e49ad62f7f94d2d206264a9358b54fc96ac31921948cf3c13d121c923991f0b47c04291b2582586c93d23816aac8ce2f90eb913e554211251bc9a2d64dd2efb9a905b80f73f8ca76c166aa5735d9370cf944306abfcac5a5874cc95b00b569f7eba01a1d92dac05e6fe60b5131a0d2e9c459d4b3deaf1a462332b285f90a25e5b61c211467961e060894bc8111abdbb66365b9da4a6700f2d530ae69289d2cc32185d004951597c8a0547ea22859b97dd87a37a8b4125bfcb513eff29e0bcae7a7dab00cb314388716efc2bee7b4294811db5bacaa3bcf720932e253f002b53e968f930bfa9409e358a1370c298a8cb622a0079bd7bf1a0e32e8f8dde7a0f56877945d2f95f233ceb61db914a2fc789bd35b3df37f62329a886194450ccc9e708d900c1fec898ed485e2970646f939313b33a6d3416476fcb249a96f6f11d030093f890621cd7af05f335e3514d7f10972f2b56614e917d9c4cb85178cce40f09a2291211e5387ed32f8c6f90d4c90d60fb08844a0fe0786717113aaf8060208331d3a03558a26134672a33a540774a5a994c549f2ec4e048e99c45f6f44692fa09ecf2d625e843fb3c186d9502acb5c9c3e6d0402ed815d76cf081e3ed847bdf8b0db0caddcd63f8dbab0b1ffdd45ae118ad1dcd7c1306c75a1f448a0e610994e5f300c058a66f63de3e94c81e96dd0cba0182c1371f61006d4cf9c9e24cc439d0cac280db62277ae92b4403f31d0bef2674900f1c21a0fb715b5cad4689154bbf53c2430b990502a5231b79e63246d15293a37918adf641bc8f8b18462909c8d1eea14434c1a33eb5a3b425729a7885db91c54240d3e8049c3d10811709dc86e71ed08d9b41714cb20a4d28f608d83b541cf998bef0ea0257f477e00c180b4e8ae4a0698e1e77ae24715eddf432eb950c3e26972a08521c31c484a733ce217b944f6190db804087bf4786ccbde4b6e149f2471121b29b6cb21d1f7baa6be1ad6ef18295d7425b744106a6fefb550e079074b1933af2bcf989c833a5f133f8e1c490e", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("001faaf97b965ffa633612b7c8f9f4be0b286b19662e5cbe6878019d8ba1382b16567ced7a7ee5c272bbc378a95c2436fb0c6133649c77e55a708b28419b5cac0c37556712bc94140738212a1372a4720ff269102f3f0dad4493b675a85463021e03f350aa8213bd6ce54987e7b32275bcead9a9096897b5c7dcd5964a17e07a2550f45b84e947f8e46267041f661de0ced333f91af090435c4bd6d9cecb4836096855fbc396b73c589e66ad989d7851c08bb55755f5771987d91925ffb40c2f", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("08a66cc423317e9d9560c307c7918b87672f3d99effd28b1d2bd2877e09fbba41a58977974f56dc522d159bffd0099791d207d2da49ee217055f5d0806e2dd0417b523e87e1d03b9498facd5df95cd85affaa681c2a43e51497997aa916318391835cc25b6a0979581ff7042a390a7315d8f5e938ea40dfdcb24822889e494cc18dcd8bedefa1c477913634203aa21a5a926595f62f4010eb3959d51acc430fa23ff858e75bc56f4d5054035aee0fb7264ecc4861ba1c44db81868108dcdc4dd099b58d1c3d880dda20c24def1b2c54cbb20ed9da85265983a00c1cf1facfcf903e39662a649ddbc4fa6927ed85694167b49ee5787bd755a5e4ff6fb82c32a9f20b8ce350fdb30744dc3dd1829ce8e7365a9ca56bfa4f79831355157a73fe99a17a534a927ed0e6cdfe9ae9befe94f581d20a4f19aa54c93149c95d53714c5a70771d55a8c477c0ebdde254d19e591fc3ecf011848276731a12a96a3267c5c710c76eb36abc43ab4d4b5a7a82770304fc2e9487512493dc5fd59aa6eb30402d0", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("1fc8f5de35d75e7446ef5703dcd7e07ad682030dd525b7620e1f7f36908d535e151d3453db1029bf894b5bded388d6a3fcf97d573bcccf93d27456ec79d9337d23ec8c4d66276cb927175d7bc25e3bf5a2252c4f83de5eabd695181834c67273017bea94aade8279f9b646a2e7f570a88aea7eb8bd51aaf40dbfe070a7228a5d06652252d3e68fc6fd6d76cd726513f0f757783f415762ecf16fb288ea9b10252a6ba1abfff1bf53aef31d24fc7d7c18d452ff529a04bb97e2aeaab748cc19762032882547249177d5cc51a46852ebc90ac17f098a3deb8dd8a37fd007bc2baf28714b756b948ac2b606fe0c4c1c3572423892040e5518f9e6abe89e7b1875bc25cd06956892564bd5e9e8557ba6c719e2ecedb4a4996817a8e77593af1321050b2488820e023afa5734ceab7072083831db2f7063cc57cd9852deab6918ca9b00b22e3956983827a599218890be78a3c0ac7f30d3a35d464a9cd4d4ef552576221f5a9cbdba030df39ed692fe2274fe2a99fda883aa4e724d54d6a0f74e0a89", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("273cc7b93b70bbfde8748d62210c033579947802560fd05dad9d65003482995b1b7379946dee0b15e90720dfff72cbb60b60b5aaa8490ed2b77e8f57a8906d1816836ad1a19ace6e0feaa4195ee6006280ce178b5987341221c6ae618794c10603ea811d60c99786835aff3871ef0163cdceec010fd806bd11adeae2a91f4cb6179a512e9627d2af3dfc8a36850e144c7255568b3154d41797e2ac4782234925047ecbe78073575c62a32129476a6456c61545eb98bbf925ae1d673a32d680e71f20ccd414fe03613ff7a3d330ab8bf8964cba66cdf3af8bb955cdc729014e692ef7c335beb80626f05301278f5e3b228bcc981736a258ea6bc4802392f081de265db5dda279bf034808ed23c8613341b31d3d29a2f65a367024af1376d1bb9907b7ed2f35386382b00fb0afa6c5643c170010e35824d8fc84d3604690fa18b404685df83549a5573c7228b29a7dde8679d8771a19e8af709ca46c60f8126e4b033a388adb6c574f85524ff523bc7c44b49c8731b763836e0a4ebf054f0008492b60683ad457d04d91f082e169606c6e5d6e172845fe586925db00a8e6a242c409a8c11d9bd07c2ebbdd653519e9a0f5d29576033ebab9a564e1b07d8909b014232fdeb565d57fecdf556f1b9753361e8d7ceaef0d4778b4669643a8f980ed9107e310cfb6db05062d60b0810fa4aa6ff9825ebc58ae839c844f82ad08d9a273161549f2d3778e678f8167640fde4f43d30f2f60d7ec8cc83673d0e5100235e405c743fcac26a09a44bfb9bbd6f767ccf6dd030879dae04027353dcbfc9a89af0f566f9e06f1a6035c08bd9873e41dc3bf009005f905fc0b9b74ea57a16c5a2411c984cf6d6d274f79bec9cea6021001d0729f412858eda5c909d8bdce6a24980d28d7ff8a6bc01cf9ba50e6613c5495f13a39ced02158862b29579c4cb0e947142fa8592c012a3038fe1178bcb515a016a06651e387087a9110ac43ea9548a520537d116ead0e2498e487613ebb81ef0f6f5210cb448e92f2cda4a4f57013ed1f922e1c90d8e8891a308adec863c0b48faf4b7581e0565ded5a8ac6bccdee08", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("23f16f1bcc31bd002746da6fa3825209af9a356ccd99cf79604a430dd592bcd90a03caeda9c5aa40cdc9e4166e083492885dad36c72714e3697e34a4bc72ccaa2e832e2bd419280d247658bb64323d59bbf47df41aa729d2168a272d66e306ff18ab999098bc5b30758183a160fcca776562d9a9370278aee9e6f71053e9358f0edd6252e0584efe53db6b3c40d1976d3849f08db15d39a0d7a6e327fc67f45e24925638e68e59cc22218917c61d2934c4e6353e2f62178a09627aed68c4e57a", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("0069c0c3d6aa9ca250e5bd3e2826e47936b6e479ad7c776caa5ac801dd5a1c2115226a94941ba68cd74c5b982235773c3a9cf6a71b1dc9d4d8307251f1d031c630316709df5c7f6af25fc5f698db87b1170fdf63bd2917bc21b5037452053dd30bec8492774364ac6ceca4b56b9b8d1aec0bcda12943dd1437e515fa7fe5bf8000c0e3fd9719382c09eded028cf0c9f866d0fec2fab515f6aa60249557270f2e25f0d2cf69c495554a426914354b553f3f6f269e0d5340b2593a5793138189ae214aa7d305903ecbdbc10d564e1ebc9455bf0e8aa3ba3321f8b9023b911cecab19239edfaa2efe905d8a5d6884da42815cc84b13d9c4fb3c304cd99d3d27b61e15063c61103bc76e80aadf05a3ae6a36f90013bce43fdb48bfc8e3e2e09f838d1dcd88fe88d48dcb4d6401442b46fd713c41d36dfbc50d8dad834a9615fc01581377baf2e5ec86b4bfe2123c9f1d5cac10fe0a79fff333ac86ebffe1aabb98252316b9995e22925907421897f44ffffa963b730c7edad138f41f54652ddd8c30", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("2761d967b3f2481435189a94502260dff1044c8cb24ea3809d0eec28cfdbf6c72c87711eaab02bf1f9940d504be3727789efbbb1c48370f61e2e4daad31be6de08a73a943ab3a7ea19633a4ef9e9bc1de68a51d778e41589504b8fb0818cdf88064eb3b5d1a63404e247cd5118a695b3b85d63e89c8512309d591701596f172a210f847e73452b29da165f6c76462f2ee76ff301b534bb0d2f0f7374b041e15612a910ab4044ec261965b917059383b5d5f5c9eb201eb61a6909fb5a610849aa1f4535e9a8bf16a4a4435004b8ab3a84bb6495a0d748ccfc25388832356732910e2936a799b55efa690fd821a3cb4d352cbb3f22ed5fe865f984e289329ca6591e4e4510639258f836e30c422e3a18fb76bdc121fd28ed77306a05b8a3299fec09decd53dc1620f84154fd333da06556e87fae4463cf02459964412fa50d4b082e0120af9b40957fb7ff0dd412f59cc0acc01c49021389cd470dec453e92faa3221680f87a61c96fefc9ada16473b853c4c92a03e1e38211a9487a2812f830760f4841710cf252069ea39d70793aac9b2f769a3954310546fc15a109f6d057d30f01c88e34c9ec83f28674534aa8ad16f61b744b293b63ae3c2fcb178a08408a1780e9ff8f2973152194ebd44ef8b158470d3f67d08425c7a9d99a4f1ee9502704bc22f9c0177342d11e54a0940cd9b51caa04c762f060d5262b5f31c66d088729dcf02930b56cf1a3bcdd147cab2fcfe913c53bf5456dc19edd706ad2122be5129ff68c503fcbe10cef00f314919b033000f43ca563f92e95a8a9dc19a867e400d5a976132900579ff4d8e1f64d86a453d7576e16459b641d574d2d9af32c0707107329853a55152341e8142e6bd97b51118d4777e44d347a3add4f6e73a6d52c0175507a0d4432b6a72508a8fe5838a14c953bb0a8834366aa0ace3a1c12a005e64fcf94cadbc98cb78a5f768409a1cda219c504f3c0e99d1e8de93601046528ceafcc22a3649dd0270094b4b3fbe55fae668028e67a8dc3378fb726cec2fd0c3322db4dccfde2f638c9e7cde93246102e9539f5ea6bf23e57bb3f60e8690e", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("28d6423856311fe86c30fcd983dfa63c95bc5adc1dee6fe0ad715dbe7bba3c091165ad57bbd71dba3d734f446b3a11cbfe5e02051f6898a677bdda5134738d5709661289bdac8badf175790f8e406755b33e54bcd8149e1e469de37447185f110efd4f6454886db697584e85127bf4826304d0d9559195b6d3f875cad607958903e94e1ca8dd25c626e31daf9cd26b3caa7ca2615690127aa11647cba037c92a20179a34c869f27fe9783e133f50fcc38bfb81200b9c635d0b9bbbbc789f4cb60511e5e1561aad84bba3d2495e4853046ae1972e687ccab832f34f19fe9b55db11d42ecbbbf14d945c29319a9a945f64610a2bb9059c0c89911556232bdc6c4b1e92ef35b5ecc024193888d764218828778507233cda5076633acd49986023ba1c0110745aacf972ffd66add373241c8285dc6c96928a6ca012b4e572f1897540deab5945fc017e575d40284abc7356a20bb85330533be288d0a14159da44efd1fc7bd3676093afa2c2d809cb5a14b913c5914c77b341f018f391cfecf0029a2090010e0c084f8c16f8496f1c6db02902cccc6cb8d58118e8dee1baaea679a370075a1886efcc99523c8abf69974f742c7d2de3e12598a963713b9bbc31a9f0a14b98584a1aaebc7649c481668a54d9da6fcb308f3dec33e0965775624f2f904298d6b7a0d04b3a217099a7daf390d5a7edfd72b1c8aab02e6f5cb440cd4a84214772064081adcf6e36148eec3bcbbbd12d363b4a76e7018159f559c2ff1c0d8051f9f9abbafb9032e3c95ebde21931a554fab74bfd7f3d61c939268c46ff9c82ffc5143ba27c7aacca19326cd8522f9d55e6b6d17d4b0586b81d86e76dfb9730782e23592d8d735517d63b6b51313e09681bfb6e66cee098ebb60ca3ebb18f80ddd80135c76e5e26ec2d004f572d267f940a5d5b82e35f4df366312e39387662343e67b7783310ea825278a262dea12bd5b1fa71735819e3e360f467d0af5f522234b4bd70b251d63a8dc9bc9e63117ca8342c3dbb3068df38229b5b34f2bd21097b0a55ece871e554a89aa97a7ecb95cd9e1f5ecea94274019d17b9943de13", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("15848a9e99c4a0719df209a705edfa52bdca729d0b73a9835880da9dc0cd2ace108b1a4ceabe6a8ba3dea041bb0dff513e7b99057d4b3c2aa378807de47dbc3627515ea8ee84feadb86577a1b7553b2016cc63807de89fcbc05bc3d53b0f23332872f837e4cde9fbf64bdd170d6488a3155bcd5b1fef4fa7ad10089bec8ea7b803713c878e32a49ff95dc2bbe7b1491c38258835dbca14ab343e88dc64004dae0f9ec7e3c20939b84e40bf66864e8129742feed7e1291d752c76bdf28e02d03b2c48bfe10367b611f37ab5847542df1d30baed8abc5380d6d80032d0e04af0d10e119d730f867b4e286a3c1c4cd04236999b9bb94d9001a4f144982d72df407d059e6ea753e84de7e8b41b2d0dca1cfb6b12afeb2564a5e24a2064f1b662a1a912e0bdf2470e896d7fda45c39a66c5c4a5297b4f19810ee37e33f7f50499326b1f70831beccc3eb5fb719d27f111e5c731cbeb4002519a4b3831ba896cffb608157b59ceb6f7a0518df929eac70c7bac9ef9c196ba21266ff47cee9bb0c60864", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("279e2a1eee50ae1e3fe441dcd58475c40992735644de5c8f6299b6f0c1fe41af21b37bd13a881181d56752e31cf494003a9d396eb908452718469bc5c75aa80728695310187ac477bdf3d7fb472e6374b1222f8ebcfcae72a8b1dc714ec853461fde556a4ef408d4a2ce89143674e9985eff87fa3df3ce6e7483c3a2f9b82bcb18df8612ef09775ec815b602e35eb6ec71ea6f7acebdc23667a60eb465e76d590500f7d19190ee1090bffe087045e97c913f7c5730110559665b3e8a9e0a526e", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("1920c53c756f1ec1a40e0264e5f65808eafaeaa7b0885f89852297bc2186ac9d09416cc536a27b6d5616f74dd2bbbfb463b9961752e0aa38d47b5213994959ab081c536b7d9a27636d0af7d4c8dad2e380cb2996a1d650a2e6123224294a6c86039e75a4a93bcc2798aec714e37b9b2602760e7ec7c6f3342e44018f2986da9b2d1ceb9ba9f7b923459d8b4701dfae12b3efd4174fa3705747fba6bce14a87720c15d04d2bd099f86ccaf9834b9588e88fdec8d04bba329d4fed580884f4b2bb", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("16a9fe4620e58d70109d6995fe5f9eb8b3d533280cc604a333dcf0fa688b62e20b972bf2daef6c10a41db685c2417b6f4362032421c8466277d3271b6e8706a8034c462aaaa7a3b4ed1266d755867524258c64b9553c46b2bd4d5c26aaedc66524e9d39a8749083573a1b84662c08ae15f16b75b9fd40089ee412f5e58dfad350e28b1c6e881a288290c7e9e12d23f122e61e89c43619f902c48d300ffe1734b014f125c1960a64127a16c8a17da5f21721e47b17575a94802a78711f45fe988", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("1fa11f66353f7a956254f3b98892d9c0f81a654f6609e0f0af13c2f8766c6f16194657ac1800e822825a05aa50d889e603dbbf4fc8e954f3b6f25fb23d5a5479142bf7baf53de4fc8668bbd4c019c0f6b7af0fec0c17ab0b107c83d25e4d18a52ef429052a9b35b41d51163583d57d79c420be96a1554051174b9ea1698878f11b36ee817c1b97813172a6418fb2937898fe7847dde90b6ff50b6b2a34cded942f593eeabb3b9d60300b894b05f78594a82af66d9117ea00224b4a21d7cf9ff51f70c6b295fa70454024594501c593b3aa26e4a93e66a0f38c3fa1d28c1612e91d631437bb2c0b4c9848a8fd19a1f8e3ac50ae338c9b516cc4049310ba4df21f287c33f63043e7e6ab5a1d13f7e759924743b9e46ded795c2c5ab93a909a3f7315530c731d9ba3398de10f401474f70944267f7ae20d0721edb0c0d48aacdfb501132d8f620cf839dfb326b07e46879ef281630486e202f6a5b3ee25d7bfa5d80e850b940cb4236be15cff7fa6f0afe97d4074d08cc84e9fc2c3af23892d61b63026dba27ff40c376fbe12ba44f231cb58178d22dcdf94e555a0fde0266d30002dab14694741bbac573bd15720b01915261df1442a03b424fbeea31b9f525c090ba172060641818b4c8221b8e01aab9788bb736e262e18f179221f6db532bae8058c38b8572443b8e87233d95e71b98acb2c946f149becc8ce8f259a89bffe962917050d74536bb197c472473578db35d84baa6c6ae9f9b436f0be637300423f198a1c23d945422603b6867cc421baac70d469d72d81380292e07297df63b5c01d61214817267145a6b0aea09a9bf2159d7360c4a7eb0a8c28a7e455c8ea3b540b5fc38fa57a56e8987689e52dc7ca0342c83789b8cb5717473014e1802469d01ca6d73befee617ad1012a1aeec56bc4d85e5f9fa8c98a49640c3543752250e921ef6447d718c318e7375b8903222b36ca85554932dcde661bd0e757a2037f4a1ab9425315926458a4e98d280cc10ed597c6c1af13de72471b52bc15d998d3232d2d849b0f73599c8ef253dda011b06a0f5c7fca436be16db5a6c389fb9cebbe0cf834015436d91dee19a986853c38160ad423bf52b4131487b5dafabece4d352e5dd076ceae35ef158c4b8016d3e4358c5e00a6d6fba7b3e319af57cfb7eeab1b64d4fd598ff6ebc85bf4e00445567736905d23864b42926019dcb0d924e90113ab53b025ba35c881dcf5a659f07632d4afae70d36c2cc547fb18898eca81401dba824b34f4ca6aef0edafa43b22378182199c62f74664f8bd35ab7836b318526669195ff4f5ce7fbad03d22789113e2328e4c4e49e3d81c78384315490295817075dbe3988e067faf0e1b4a9341a202e2616676282e029960b4ca852f528ed0e3f852bd6074625bfd6f46948973ac6ddf8fd1fa87a304eae65a6b2a53d50ea05db05521cfe31ec72869bcdfeb019276208720a0d33ee2ca8ab00ec09099e9c235971953f2ad06d4df01028cbe0f6449758345cb1d4ae4bedb642f84ca9e69e21eb1b1d639939504d29f7649423a34e9ddd3fc1e1648d3a6f717af7efd47f841696819248f6d189b54becec21119346431546391cba18e4badd3660cfba53a91c3b2218293d03778fafeff37c2ea71c3bb6823a1eeef64065f4b45cff7169a02a9934fda95861ec8d0768bc5cad58f79d854bd32503a3c72fe40417cee1d4d81a9d1e78f93cf5cafd2362809d788176ab88c1007a69f234a60a50cd0c00857600e144962a0dd987d284313a55210246ec51f3975707719aaa3f8cf6ef757c47226a5907f5019a2d5a82cea4b790e0deb00f70646c7124b8202b5f29f26dc20a12f4430158da8c567ff51da95b9e26ec39bbaac5e32f6a3cede1f933a8b76aa805201d3367d76248671d8412345ecaf89c599e5a88b93d347ad99a6e249af4a322a73a9d41b0d5350111018c3d9987926037a027101683dc814ec07f07daa46d103731cfa07557be53f12153ae35de17d65274fcc4bd4e15ac961d837a8e68ad24b542fa29ffca7fa5d883d1413e6c8183aff268ab0b4c516d88088a0102e2fb2999edcab90a5efc1a3f78ef830660161c361cf699eab00341565881f1c374f50b5012db4af00642b53ec15a66a315cfcbeac29674c3e619870d04810bea6268", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("128b65cb80257f3006fc20dbb6af6781da7e0f9213d2b909fd113ee0f2d2bb52251e288387db7be742fe67261f36a4f09eeb4763bbbaa1bb13af3dec65302a4125ed8b2035e437f057cb45003f1c25510d7e232c7587581bdc3035064a96d2e32293733bfad88afa5adabcf320f055e3fe0d1ae733dc21f5e08fc234029be16a18414155506a4c287ac374bc28635be3e6b8fd0097554db051a45138f0b6140410f8c1e8992d53017580b1b806cd23729f9a2aefc6e60bb82606551c1393750b", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b3629f2c1dbcc614745f242077001ec9edd475acdab9ab435770d456bd22bbd2abf268683f9b1be0bde4508e2e25e51f6b44da3546e87524337d506fd03c4ff7ce01851abe58ef4e08916bec8034ca62c04cd08340ab6cc525e61706340926221651b71422869c92e49465200ca19033a8aa425f955be3d8329c4475503e45c00e1", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("18db259896bf7a55fbd739049dcd87bab41bca06dbe6ba477bd91293ecc7b72a080f9707ac098f3ac7a06fc4cddf9de9024723d7803df1e832f23facc344e09f1f0a58aa3d929cf73ef5fb29717b46818570f8acc287057a61f1bf19952d5d870a985a1377ac0068c32090c4f61af49e438888371fa281863746ad9c4505839a1635829f9dc1168b264dc1b35951410b3f509179a86259cd1bc219e0d9fb6571282e9a7a2784db855d8fc301a21574e67751c63574f552b5075cf0d54feb2ee7086ac4e5ca51c4e84405e5310187119e9283a8e1d4b9be261bea666f724501c302d9e8305711e2081373125393ea672966c2b7931d9de75640aacce9bdd8ff8109610ee10faabfae8ddd3bae29f8644762b842a90a4baca50bd37c4c8e346cdf2c0a29ba08d26cd5e2ea3ac028f2c13854b997da5de4020810d8d1df0b5ede16181628b1a3d5936ef9414119e8bc454d0209022d6c3b6722ed63bd3be9fd11ef16a94dc0c53b0283290c9189b46b2b2e727ac54299b70b73ccd31eadbbbce239183aa0627c185bbed1b35c46d0d2ab1e248f7a4ab6d1896afcb8cecd471911ef208db0fcb30c4d601aecc21ad3457e4a636a2bb289712a98153589c3674a774f08c0f49c7c290fab83aa67c3ed645856531b1e537e060fddb3b722849819cbfe04336ad8c78b7ecd068f1f543b4cf09a510bed3f39c8afd71b549b957d5b4fdd0f2251c9278bb30892b0ea4fbc771380481fdad33dfe0e9f49916e476823feed199cdc78bf86665cfec1b451e92bb8122597a0b28bdd5d380024756fe070aa101deeac40a4d371c0154aecdddb082f6891c7c3a5074e1b5c1b30e4b3ffcca6980bab17266f609f8c1616cf6c23c51e60b24d2ebcff2c7e486abd11f878ad231b2e69a5773f6986e289b67c70b92da16c0c8f2a8dcced737641061312f5fe17952151ca3275c32561490b233e7284a4690a777da485efacab5557307c6d8e588608aa1e46b4edfd86ff457f0ab244e624488e4563be1a0ee35df8b547c43e4e0411b1dce99279dab100f4137847c3bac64342dc95b9cdc2e5880ae61f898181d8", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("09d599a8c97251e5d1447076792891b8de719e3fc5b7b245e35c6a8af97dbe1b1cefb6a792c978414992b8c88ead994e8fc972bd8018a40e306eb0e5578b25ca21312203a90480fc7174fba1bb4b9802c930c38aff91399e78e2c76768daff422bbd652137299ba4ebda8016f7501bbfeb6de219561d3f924693efa9acfca2b81618159fd6039f1ee36963eedec8154312d592e6e1dba89d1747c4251bdb725a0c6d546f20a8b44f4517290a078310fd1af065e8ef20ed4ff94c0fd7b7c662be143e5a3414336749caf364eefdc5e30ee73d34d9462a44e90e085851eb93c9b6206426d020f657f36fec865bfa09bc619746c238c4cfa643529eea42aff19dc52abc81b078bdca796d77c4ac57e6a248fdf370d3cd12163c474aaa46eac2cec103b3cc21c58b94796153850268f274376dd6f1a36103e6f870a4eafa452923802c6ca8c36c4a0225e4d80bb8e62aaad963cc39bf9db92e1a0f45a353c82039dd1821a59d0fd59b5d0a0362128b95414fd2479542e1afab6e8fb23e06e9a547210cab4c461a3179e2f0a15c1a20e0569590bc30c8c7344a73db5fe76341efbd2c1d24f43820586b1449eaed8c7063d4e481a1a52d0c5a318f9b69e97c35a6393b016dcb50ee485d31c090cfffa92e709dd5bdf6b94dea9a7310f0c824ba78151003ae718fdd5682ae467b0f776cfdd02db3be8d2aa9d42c88638bffdf154920121c3580c8ff773cdab1bd6a9449d8f4d0dcfd5d3e1bd55acdaed1afb96e40c0dd233eee0523e0a36b7cbba083eb2919ab0a66836dabc699f6f5864d284090cba90d02024b706a23f6d6f84681ab223b9975aa15bfc6c37c1e1d43bcf8de71b10f2321d3e00d52c53f18415f2e87cd00940a6a3234e7400e170297db9b214a596d2a6ca0984a6e1aa1433eb239c30efb32093022dc1ec379567ebe899606324afd22052844ad5cb4241203b35d930334fdcb22754475653cf6138f51677c5759d0034a7400dc24da45b5d4c63576a83f299cc60b43b186de9d8d5120d36596299502031424a44c5970eeb1090ce35d7379a0654db261594a27b7ccec8bab8db83b26534bc2216a34a20a506366d22111acbf059df2198654cd69f1e4db9cf7d4801d135d29f2973a802ab859a35550a844ecde62bdb95e86bb6e974453b5bf2d031a4f3c2aa1d0be4af8f9013414719e7b75536b3e0dbd8250fa3feacd17416de420df18f7491d891ce8c01acf25ed54d37433830a1bb5f169716b07aeb67e4e6a05ce2b0d962f82ebcc36bca7c238f9e0d83f4b731b4447b2fb6f24636aee57260f1a72ebde3694aed548f7d8e20b3f9e119260b66d095e9992ca8645292eb45b01cb4b475f8cdb3126bd428b18745e504371be364d94d482648251a0ae1bb9ae2e976e6fd23476a9181e42a874a734f7efd1dc25037765e35a92885559ef4da81af8fe9ef0615a50760d000b68bff0f102771b9cf46bed9d5ce8565a558e41700bd46d271edbcac6a253a859cb7a172a3176fe6f9eebaf752417603efde4bda114f8788c8608a32c27fb3087189d92464788c4b62525f616c8725f6abf9d4dce07b8399a0e69860301eefd202480a12e054a920ea3dca3844f6309232c61fcfb17c43e311e336f593615004ed5a4b8be2ebde42af53d5fa32a7790ca80fc234a3034f9151c43f2eea7585049b4aad29392d9e9285b011b73cf2c6af955bb236b15857fb2789ec0149c253b23f8232627bd48f36ce4e8bea688d8b64d7469b2072912fb4719cb6894a14986fc875c84c220649f3c48e3a662f4c4f8b0c259529e2b6d3696c45cd1b11f02bd752022b0e7a2599bbca90cb8290789d71bd990d18418bba1e7fca94de8833d95851c88876c42fe817d3025a5076307c85b59add5f81771cbccfaaff14f7fb8807bf88902cdc39ca0a398f8bec67971cf8b771d941204515478d4c8dd014aa27e099cad61aa267ee25fb61d23e5d33ed0e2ad08bfd60c2af2b362d35851adaf161bf289d100b65ccf2050aab6c951e44a010140914e18ceed56ed6655d046f37dd75198590f95200ada816be88cff9fb1ed2aba308c1e556fa4987309f9d3c380432429cc72e8e146a24c339c989d2266c0f1503737075913b800fedc3b85ed5060567231334467aa6104824b79ca8f99ff263fff52", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("2bc49f4d8134cf72ce0883c589f4f6f0636db174b6176e063b3effdd57e3404309f61eba66408ad541dac082701734d6e6d4cf6f90bc0e65d6578f2d18563e221eb59aa8d8a9187b0857ab89a453fc53209855b300377bbca411998bdf9aa6730bd2384fa0ad96fcd1fc6c1a1a1fb80d4859770ca91b9559281736cfd6745d011cb39aee49da07d70b0f579101c412f1068ea82671859f09c4c1cb3ae74f8cc103fb73a573c8f147ae15610e4f97e291bcfe16556842e00e88ad70db0df2dc3a05430e574064f2d1de68795706bf99b1b6079a99bda3e5ec266567f2f9246e090f5976710762dfa75253c53ae1c2c88523ff08d0c2523d9409033aa2b7e4392000036daaeef66504945efa89111745e29d39ac317d798bbb1d14f84bdf5bfac91134d59ae245678087748ccfd3c65ecf2db2d05595cd6ed8452346713768c7411ab6efb518910157009fdc818e5d4e082da02f0618f4a3d6166f830b81a4e683023ad24b09b49bfd967c7adbe895811172f04a2b90b1379dac89a6fa1a91d8cb", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("240517a373fda7a2fef6ee9e9895505545c354433af3d3548b8537abb10d445c12e45a8b8c4d7a82ae27f0ffe3dd976b1242b040b96043ad31ce9f2ffa5bc707275ec5565ec4ccde5088b40c57c946be5d48b9ba34f956611ec87ed33d47500116f3ff1c54f920a4ba438c43501d2ef59e7c7eb2f8ebde852309bbfbc087af1b1742abd3e12ea49804bc4e8e59ecb9da6789392b1e12958ad653ad49f3d4d8450a1190ddff2fe9afa9dbea1e42222afe9715e1bced4e7ac4c20d89476ed6253c0bcfe3f03313340fd392b32bccfcab83f942f6b13d71e2a3159239c61c50c7bb199c36728784b46d5607ebd7cf5a055a3db4458ad6f0fb7e826d6a280daf625d1db3a467a1de6f3b848da16893902bb07fd0b63f6509dacae6693c7975fe09940b291b95276b136f58cf6f899cbb5a6f4009a4d069be6c0f8f0d6bfd7c38991f0e46dd20f14881ed44b216b44ba054b1f32c61d01f33326ec7f6c2ace3c8901414f211e03a121fcbb34f328205223d7f7ddff484efdd5d06e8886f2781f8e549", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("22f2e1830cea84486d7ff320365a5ead50d356379d7bc4f2b9d77dd298f36fd8087baa2aad4fd8bbca8cc0b525041e1b17aeb3ecc63086cdc6fd1ec2310bb8db243fe8ce837f106ef17e387f9d78df833811427d5338c83f0622f92a65101da31ab23d2eb26b70ff15decd58baf91a68ec85f149012d481da67f806b0571c9471928767c9a5576ba5fbd7cee08203e6de3d9dd36a756fc621700031081a80b7e1aee70334cfaeec2f7551368818353fbd5810266c7d1ba49de47cec9b81b6e82007aed597093879d894ea438d094f3373b51f31bd5993e026e76502bcb1334e32189a92e9df00c0b5c21811462933dd17a5328075b472a53ca61bd9e136701571e529e7c4912cb565a3819473e8cb2c45e0a7b17a63f11e509d80472921e86f92fabe095002240b012e60bc9159383bdbf515def6c41acf180adde6913625a7b11d22c04a21962ecdcb1b679168cc14899e2912f233ed37d116cbde2110af4861ca847018951f8d71a369874541390d23df3cf9e5031655d4e7af4affdda5ec50fb5b633ac619c06ff0312901dc9d949ddb443ded5f59662788c101859ed0cab1782bd118c15612ab18ecaeeb9226a0145c0c1d01428987b8a5523c6da78e015261c22b6d73323e863964a003fb93594743f70e9248ed6898776780a7f3ae7a41b07a0d873b1ece5c55c6c942a7c7249c3d9026fcc607a68fe6e73cd4a76a6821f86065d5e87ffecc2c47bbd85658eb21bbdacdb79f23b031a8c6df93e64574c06eb93cb065183692c4ae4dff2efd51615d926782da50054e4a280c5bafb913d02369aa17493b4fccafbe637b1b7c9e1225e7b6fb24720f778548e304e7617b407e83fd6e3da09599850d6399059fadd57c4fadb492f59ad3adb4783ccda65272f190a9ca862a6d9508d9b2513edecf47aaa4fdc7a64127dcccbe64b7f206d400148ee9fc305099c6a7334452f25473a58edc7161895ab52e3590ea600e2e885010b062ce0df9974072bf87f5a1c8072df23e612b254b688084b5958314efe190bb6fb66657b45e6f81fa7c5fd41004f815ffd08ec00cb46ced2b1f97b04e69b", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("0e6eab4103302750b22364bd1ec80e5edfb3ad06fa175ff2517ca49489f728e9050a17b5a594d0fd6fafed7fe5c447793fe9b617f0f97c3ee6dd29638f6c9232068b38fd28978b73b64592127317a542e084ea8291e404b88d3a731207104f9624d1ae64196a7d3b8e9fdcf72f9dce16d649fa3971daaca56405a0d331e2aa92210a32dfe27a36ca740e4d668066f7559acddea850fee4ebf9c9a241b337e771191a60da23a028dfc3b3b82c3d15802615f6386f29194e088936e3ffe96809eb", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("0af6f1fd0b29a4f055c91a472f285e919d430a2b73912ae659224e24a458c65e2c1a52f5abf3e86410b9a603159b0bf51abf4d72cbd5e8161a7b5c47d60dfe5712fa10f98bc3c4faa2a9729408e92a8b4e6d304abc539cc396820f696f23ecbb2b30d01fe71a3550fa6780e70305d28ea686b72aff7d23cd550f886fcd60f6b30d1142c81b9b27e329c498e4b241fa2ab0e0c62170cbe2a1e642589e4ff6ca54069ec036f519726e40596ede6cd47577c5cc24746754280add50bf87fe7404c8", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("1688243c91950e540e5acdc41b84ee9d2b1c0ecc84dc373d6fd5959baebb33df140c8a9c0ae42792290c177a97425bfbfaf7ef008b7656e906c2df69fbdce89a029c4ee67b639e4b6f7cf0536ba1f24bf61837351b5c74f12fb6cb0887aac3ea1d3c75ef1b03ad925b1b223901a8e7a4e16ef2bf6600e7c175529c18ba8008350aa0f1fd72acfd2bc3c50664eba62133ea85341f0b4ec0c3618f3738401a42ce1fc3592b9642716c47152c9e52881fac74773f705c15b7737e0831ced7a0f8371245c36152deacfd18a947b3f3c83a30652958dd9614b7beef8aa8b5cdb157462ac85cca98a10e6ec5efafdd593179f2f56c4febb1ae6f1d72a9661fd8ed51032b98467d16a6e8e6bfb427838659b8df567ca38ec17c979560bee66d1ab72f372d38efa3e51e7ad3ab06b5610e0631db0a385101b45d0fe47c25610213aa023208289e3f0845bc2197d57ac44b4a808b30aef09a344f80062bd75a1844715d3d0cf55d95f2fefda6a1bab5796626fbb6345796ef134109de55bd61654f54c71f16eb795694ab923473ee66eaa59bbf61de8f8dfa94c481cb4f224b3ba90ec87318c3ec099e1aeb3d63840ccba2159386cb3d71481ef18b5466901b71cdc6e75e1ce807182d1b89fcbaff954b80d8a58d49c953c05a64e2a326cb3ae4802a0f9f29719e2b60002727f32b49638ac3c1d4addc61cb260c4ac99307ba24a7743ad52f325d4f32b8477cbd99a218c2e4ecb3171cab016c51cd800663bec05624f1072775db17ff93e8b807067572c97cbc7321e9690b8fc4f193eb0f1a93ce96a5c20cf7cc3dbf579b54af41204b2451098724e9d8940bd4cabff1605f33592e5f002817dd14edab5e60dde89c66b3c93dc057c53b926b2077d63d2dbbf9316bd64c2bb1b35df3f9ce28954fbe15eb52a08aa70453112cc94ad923616aec0553dfce0d5e44001e7b139917b4cd2d32bca418f24f44bd7ffa16edc47ff8178efee06f28630c2816b74f232864deeea9073bdc2128d704d2375431c7bb196825b0ba890b5ecd90caa2107b346a40472b9972bdca3e388e38a2914e2c1f022a82d49b4f", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("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", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed275dc4a288d1afb3cbb1ac09187524c7db36395df7be3b99e673b13a075a65ec1d9befcd05a5323e6da4d435f3b617cdb3af83285c2df711ef39c01571827f9d", "0000000000000000000000000000000000000000000000000000000000000001", true)] + [TestCase("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000001", true)] + [TestCase("192c207ae0491ac1b74673d0f05126dc5a3c4fa0e6d277492fe6f3f6ebb4880c168b043bbbd7ae8e60606a7adf85c3602d0cd195af875ad061b5a6b1ef19b64507caa9e61fc843cf2f3769884e7467dd341a07fac1374f901d6e0da3f47fd2ec2b31ee53ccd0449de5b996cb8159066ba398078ec282102f016265ddec59c3541b38870e413a29c6b0b709e0705b55ab61ccc2ce24bbee322f97bb40b1732a4b28d255308f12e81dc16363f0f4f1410e1e9dd297ccc79032c0379aeb707822f9", "0000000000000000000000000000000000000000000000000000000000000000", true)] + [TestCase("3431d14cfbe9a5a1244e88ada99303090b48f7580ae1e3aa0c82cd92025c03e41b1c9200304be38b893bd18ca5b528bb34fbcd8126c1104f0465a7ae1bf4455607caa9e61fc843cf2f3769884e7467dd341a07fac1374f901d6e0da3f47fd2ec2b31ee53ccd0449de5b996cb8159066ba398078ec282102f016265ddec59c3541b38870e413a29c6b0b709e0705b55ab61ccc2ce24bbee322f97bb40b1732a4b28d255308f12e81dc16363f0f4f1410e1e9dd297ccc79032c0379aeb707822f9", "", false)] + public void Test(string input, string output, bool status) { byte[] inputData = Convert.FromHexString(input); - (byte[] outputData, bool success) = BN254PairingPrecompile.Instance.Run(inputData, MuirGlacier.Instance); + (byte[] outputData, bool outcome) = BN254PairingPrecompile.Instance.Run(inputData, MuirGlacier.Instance); using (Assert.EnterMultipleScope()) { - Assert.That(success, Is.True); + Assert.That(outcome, Is.EqualTo(status)); Assert.That(outputData, Is.EquivalentTo(Convert.FromHexString(output))); } } From 6538915c14fe721f6eb9f43100ac32a92c5bd4f4 Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Sat, 19 Jul 2025 00:17:25 +0100 Subject: [PATCH 29/40] Optimize ModExp (#9008) * Optimize ModExp * Faaster * Moar * work as nuint * use nint * cast via int * Remove unneeded casts * Move OldRuns to tests * fix benchmarks * Feedback * Less branches * Less branches * fixed invalid --- src/Nethermind/Benchmarks.slnx | 1 + .../Extensions/ByteArrayExtensions.cs | 15 +- .../Nethermind.Core/Extensions/Bytes.cs | 2 +- .../ModExpPrecompile.cs | 305 ++++++++++++------ .../ModExpPrecompilePreEip2565.cs | 7 +- .../Nethermind.Evm.Test/Eip2565Tests.cs | 43 ++- .../Nethermind.Evm.Test/Eip7823Tests.cs | 4 +- .../EvmInstructions.Math2Param.cs | 2 +- .../ModExpBenchmark.cs | 20 +- 9 files changed, 263 insertions(+), 136 deletions(-) diff --git a/src/Nethermind/Benchmarks.slnx b/src/Nethermind/Benchmarks.slnx index 7ba0c11e37f..1466a214d66 100644 --- a/src/Nethermind/Benchmarks.slnx +++ b/src/Nethermind/Benchmarks.slnx @@ -14,6 +14,7 @@ + diff --git a/src/Nethermind/Nethermind.Core/Extensions/ByteArrayExtensions.cs b/src/Nethermind/Nethermind.Core/Extensions/ByteArrayExtensions.cs index 92bda49291a..94c1c12f86a 100644 --- a/src/Nethermind/Nethermind.Core/Extensions/ByteArrayExtensions.cs +++ b/src/Nethermind/Nethermind.Core/Extensions/ByteArrayExtensions.cs @@ -56,18 +56,23 @@ public static byte[] SliceWithZeroPaddingEmptyOnError(this byte[] bytes, int sta return slice; } - public static byte[] SliceWithZeroPaddingEmptyOnError(this ReadOnlySpan bytes, int startIndex, int length) + public static ReadOnlySpan SliceWithZeroPaddingEmptyOnError(this ReadOnlySpan bytes, int startIndex, int length) { int copiedFragmentLength = Math.Min(bytes.Length - startIndex, length); if (copiedFragmentLength <= 0) { - return []; + return default; } - byte[] slice = new byte[length]; + ReadOnlySpan sliced = bytes.Slice(startIndex, copiedFragmentLength); + if (copiedFragmentLength < length) + { + byte[] extended = new byte[length]; + sliced.CopyTo(extended); + sliced = extended; + } - bytes.Slice(startIndex, copiedFragmentLength).CopyTo(slice.AsSpan(0, copiedFragmentLength)); - return slice; + return sliced; } } diff --git a/src/Nethermind/Nethermind.Core/Extensions/Bytes.cs b/src/Nethermind/Nethermind.Core/Extensions/Bytes.cs index 0f78e509169..39158a6c10b 100644 --- a/src/Nethermind/Nethermind.Core/Extensions/Bytes.cs +++ b/src/Nethermind/Nethermind.Core/Extensions/Bytes.cs @@ -182,7 +182,7 @@ public static bool IsZero(this ReadOnlySpan bytes) return bytes.IndexOfAnyExcept((byte)0) < 0; } - public static int LeadingZerosCount(this Span bytes, int startIndex = 0) + public static int LeadingZerosCount(this ReadOnlySpan bytes, int startIndex = 0) { int nonZeroIndex = bytes[startIndex..].IndexOfAnyExcept((byte)0); return nonZeroIndex < 0 ? bytes.Length - startIndex : nonZeroIndex; diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs index 803b6a791ef..010a6418329 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs @@ -2,19 +2,21 @@ // SPDX-License-Identifier: LGPL-3.0-only using System; -using System.Numerics; +using System.Buffers.Binary; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; using Nethermind.Core; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; -using Nethermind.Evm; -using Nethermind.Evm.Precompiles; using Nethermind.GmpBindings; using Nethermind.Int256; namespace Nethermind.Evm.Precompiles; /// -/// https://github.com/ethereum/EIPs/blob/vbuterin-patch-2/EIPS/bigint_modexp.md +/// https://github.com/ethereum/EIPs/blob/vbuterin-patch-2/EIPS/bigint_modexp.md /// public class ModExpPrecompile : IPrecompile { @@ -24,7 +26,13 @@ public class ModExpPrecompile : IPrecompile /// This constant defines the upper limit for the size of the input data that can be processed. /// For more details, see: https://eips.ethereum.org/EIPS/eip-7823 /// - public const int ModExpMaxInputSizeEip7823 = 1024; + public const uint ModExpMaxInputSizeEip7823 = 1024; + + private const int LengthSize = 32; + private const int StartBaseLength = 0; + private const int StartExpLength = 32; + private const int StartModLength = 64; + private const int LengthsLengths = StartModLength + LengthSize; private ModExpPrecompile() { @@ -57,9 +65,10 @@ public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec try { - return inputData.Length >= 96 - ? DataGasCostInternal(inputData.Span.Slice(0, 96), inputData, releaseSpec) - : DataGasCostInternal(inputData, releaseSpec); + ReadOnlySpan span = inputData.Span; + return span.Length >= LengthsLengths + ? DataGasCostInternal(span, releaseSpec) + : DataGasCostShortInternal(span, releaseSpec); } catch (OverflowException) { @@ -67,32 +76,32 @@ public long DataGasCost(ReadOnlyMemory inputData, IReleaseSpec releaseSpec } } - private static long DataGasCostInternal(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + [MethodImpl(MethodImplOptions.NoInlining)] + private static long DataGasCostShortInternal(ReadOnlySpan inputData, IReleaseSpec releaseSpec) { - Span extendedInput = stackalloc byte[96]; - inputData[..Math.Min(96, inputData.Length)].Span - .CopyTo(extendedInput[..Math.Min(96, inputData.Length)]); + Debug.Assert(inputData.Length < LengthsLengths); + + Span extendedInput = stackalloc byte[LengthsLengths]; + inputData.CopyTo(extendedInput); - return DataGasCostInternal(extendedInput, inputData, releaseSpec); + return DataGasCostInternal(extendedInput, releaseSpec); } - private static long DataGasCostInternal(ReadOnlySpan extendedInput, ReadOnlyMemory inputData, IReleaseSpec releaseSpec) + private static long DataGasCostInternal(ReadOnlySpan inputData, IReleaseSpec releaseSpec) { - UInt256 baseLength = new(extendedInput[..32], true); - UInt256 expLength = new(extendedInput.Slice(32, 32), true); - UInt256 modulusLength = new(extendedInput.Slice(64, 32), true); - + (uint baseLength, uint expLength, uint modulusLength) = GetInputLengths(inputData); if (ExceedsMaxInputSize(releaseSpec, baseLength, expLength, modulusLength)) { return long.MaxValue; } - UInt256 complexity = MultComplexity(baseLength, modulusLength, releaseSpec.IsEip7883Enabled); + ulong complexity = MultComplexity(baseLength, modulusLength, releaseSpec.IsEip7883Enabled); - UInt256 expLengthUpTo32 = UInt256.Min(32, expLength); - UInt256 startIndex = 96 + baseLength; //+ expLength - expLengthUpTo32; // Geth takes head here, why? - UInt256 exp = new(inputData.Span.SliceWithZeroPaddingEmptyOnError((int)startIndex, (int)expLengthUpTo32), true); + uint expLengthUpTo32 = Math.Min(LengthSize, expLength); + uint startIndex = LengthsLengths + baseLength; //+ expLength - expLengthUpTo32; // Geth takes head here, why? + UInt256 exp = new(inputData.SliceWithZeroPaddingEmptyOnError((int)startIndex, (int)expLengthUpTo32), isBigEndian: true); UInt256 iterationCount = CalculateIterationCount(expLength, exp, releaseSpec.IsEip7883Enabled); + bool overflow = UInt256.MultiplyOverflow(complexity, iterationCount, out UInt256 result); result /= 3; return result > long.MaxValue || overflow @@ -100,31 +109,129 @@ private static long DataGasCostInternal(ReadOnlySpan extendedInput, ReadOn : Math.Max(releaseSpec.IsEip7883Enabled ? GasCostOf.MinModExpEip7883 : GasCostOf.MinModExpEip2565, (long)result); } - private static bool ExceedsMaxInputSize(IReleaseSpec releaseSpec, UInt256 baseLength, UInt256 expLength, UInt256 modulusLength) - => releaseSpec.IsEip7823Enabled && - (baseLength > ModExpMaxInputSizeEip7823 || expLength > ModExpMaxInputSizeEip7823 || modulusLength > ModExpMaxInputSizeEip7823); + private static bool ExceedsMaxInputSize(IReleaseSpec releaseSpec, uint baseLength, uint expLength, uint modulusLength) + { + return releaseSpec.IsEip7823Enabled + ? (baseLength > ModExpMaxInputSizeEip7823 | expLength > ModExpMaxInputSizeEip7823 | modulusLength > ModExpMaxInputSizeEip7823) + : (baseLength | modulusLength) > int.MaxValue; + } - private static (int, int, int) GetInputLengths(ReadOnlyMemory inputData) + [MethodImpl(MethodImplOptions.NoInlining)] + private (uint baseLength, uint expLength, uint modulusLength) GetInputLengthsShort(ReadOnlySpan inputData) { - Span extendedInput = stackalloc byte[96]; - inputData[..Math.Min(96, inputData.Length)].Span - .CopyTo(extendedInput[..Math.Min(96, inputData.Length)]); + Debug.Assert(inputData.Length < LengthsLengths); + + Span extendedInput = stackalloc byte[LengthsLengths]; + inputData.CopyTo(extendedInput); + + return GetInputLengths(extendedInput); + } - int baseLength = (int)new UInt256(extendedInput[..32], true); - UInt256 expLengthUint256 = new(extendedInput.Slice(32, 32), true); - int expLength = expLengthUint256 > Array.MaxLength ? Array.MaxLength : (int)expLengthUint256; - int modulusLength = (int)new UInt256(extendedInput.Slice(64, 32), true); + private static (uint baseLength, uint expLength, uint modulusLength) GetInputLengths(ReadOnlySpan inputData) + { + // Test if too high + if (Vector256.IsSupported) + { + ref var firstByte = ref MemoryMarshal.GetReference(inputData); + Vector256 mask = ~Vector256.Create(0, 0, 0, 0, 0, 0, 0, uint.MaxValue).AsByte(); + if (Vector256.BitwiseAnd( + Vector256.BitwiseOr( + Vector256.BitwiseOr( + Unsafe.ReadUnaligned>(ref firstByte), + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, StartExpLength))), + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, 64))), + mask) != Vector256.Zero) + { + return GetInputLengthsMayOverflow(inputData); + } + } + else if (Vector128.IsSupported) + { + ref var firstByte = ref MemoryMarshal.GetReference(inputData); + Vector128 mask = ~Vector128.Create(0, 0, 0, uint.MaxValue).AsByte(); + if (Vector128.BitwiseOr( + Vector128.BitwiseOr( + Vector128.BitwiseOr( + Unsafe.ReadUnaligned>(ref firstByte), + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, StartExpLength))), + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, 64))), + Vector128.BitwiseAnd( + Vector128.BitwiseOr( + Vector128.BitwiseOr( + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, 16)), + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, StartExpLength + 16))), + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, StartModLength + 16))), + mask) + ) != Vector128.Zero) + { + return GetInputLengthsMayOverflow(inputData); + } + } + else if (inputData.Slice(StartBaseLength, LengthSize - sizeof(uint)).IndexOfAnyExcept((byte)0) >= 0 || + inputData.Slice(StartExpLength, LengthSize - sizeof(uint)).IndexOfAnyExcept((byte)0) >= 0 || + inputData.Slice(StartModLength, LengthSize - sizeof(uint)).IndexOfAnyExcept((byte)0) >= 0) + { + return GetInputLengthsMayOverflow(inputData); + } + uint baseLength = BinaryPrimitives.ReadUInt32BigEndian(inputData.Slice(32 - sizeof(uint), sizeof(uint))); + uint expLength = BinaryPrimitives.ReadUInt32BigEndian(inputData.Slice(64 - sizeof(uint), sizeof(uint))); + uint modulusLength = BinaryPrimitives.ReadUInt32BigEndian(inputData.Slice(96 - sizeof(uint), sizeof(uint))); return (baseLength, expLength, modulusLength); } + [MethodImpl(MethodImplOptions.NoInlining)] + private static (uint baseLength, uint expLength, uint modulusLength) GetInputLengthsMayOverflow(ReadOnlySpan inputData) + { + // Only valid if baseLength and modulusLength are zero; when expLength doesn't matter + if (Vector256.IsSupported) + { + ref var firstByte = ref MemoryMarshal.GetReference(inputData); + if (Vector256.BitwiseOr( + Unsafe.ReadUnaligned>(ref firstByte), + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, StartModLength))) + != Vector256.Zero) + { + // Overflow + return (uint.MaxValue, uint.MaxValue, uint.MaxValue); + } + } + else if (Vector128.IsSupported) + { + ref var firstByte = ref MemoryMarshal.GetReference(inputData); + if (Vector128.BitwiseOr( + Vector128.BitwiseOr( + Unsafe.ReadUnaligned>(ref firstByte), + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, 16))), + Vector128.BitwiseOr( + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, StartModLength)), + Unsafe.ReadUnaligned>(ref Unsafe.Add(ref firstByte, StartModLength + 16))) + ) != Vector128.Zero) + { + // Overflow + return (uint.MaxValue, uint.MaxValue, uint.MaxValue); + } + } + else if (inputData.Slice(StartBaseLength, LengthSize).IndexOfAnyExcept((byte)0) >= 0 || + inputData.Slice(StartModLength, LengthSize).IndexOfAnyExcept((byte)0) >= 0) + { + // Overflow + return (uint.MaxValue, uint.MaxValue, uint.MaxValue); + } + + return (0, uint.MaxValue, 0); + } + public unsafe (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec releaseSpec) { Metrics.ModExpPrecompile++; - (int baseLength, int expLength, int modulusLength) = GetInputLengths(inputData); + ReadOnlySpan inputSpan = inputData.Span; + (uint baseLength, uint expLength, uint modulusLength) = inputSpan.Length >= LengthsLengths + ? GetInputLengths(inputSpan) + : GetInputLengthsShort(inputSpan); - if (ExceedsMaxInputSize(releaseSpec, (uint)baseLength, (uint)expLength, (uint)modulusLength)) + if (ExceedsMaxInputSize(releaseSpec, baseLength, expLength, modulusLength)) return IPrecompile.Failure; // if both are 0, then expLength can be huge, which leads to a potential buffer too big exception @@ -133,10 +240,11 @@ public unsafe (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec re using var modulusInt = mpz_t.Create(); - fixed (byte* modulusData = inputData.Span.SliceWithZeroPaddingEmptyOnError(96 + baseLength + expLength, modulusLength)) + ReadOnlySpan modulusDataSpan = inputSpan.SliceWithZeroPaddingEmptyOnError(96 + (int)baseLength + (int)expLength, (int)modulusLength); + if (modulusDataSpan.Length > 0) { - if (modulusData is not null) - Gmp.mpz_import(modulusInt, (nuint)modulusLength, 1, 1, 1, nuint.Zero, (nint)modulusData); + fixed (byte* modulusData = &MemoryMarshal.GetReference(modulusDataSpan)) + Gmp.mpz_import(modulusInt, modulusLength, 1, 1, 1, nuint.Zero, (nint)modulusData); } if (Gmp.mpz_sgn(modulusInt) == 0) @@ -146,49 +254,32 @@ public unsafe (byte[], bool) Run(ReadOnlyMemory inputData, IReleaseSpec re using var expInt = mpz_t.Create(); using var powmResult = mpz_t.Create(); - fixed (byte* baseData = inputData.Span.SliceWithZeroPaddingEmptyOnError(96, baseLength)) - fixed (byte* expData = inputData.Span.SliceWithZeroPaddingEmptyOnError(96 + baseLength, expLength)) + ReadOnlySpan baseDataSpan = inputSpan.SliceWithZeroPaddingEmptyOnError(96, (int)baseLength); + if (baseDataSpan.Length > 0) { - if (baseData is not null) - Gmp.mpz_import(baseInt, (nuint)baseLength, 1, 1, 1, nuint.Zero, (nint)baseData); + fixed (byte* baseData = &MemoryMarshal.GetReference(baseDataSpan)) + Gmp.mpz_import(baseInt, baseLength, 1, 1, 1, nuint.Zero, (nint)baseData); + } - if (expData is not null) - Gmp.mpz_import(expInt, (nuint)expLength, 1, 1, 1, nuint.Zero, (nint)expData); + ReadOnlySpan expDataSpan = inputSpan.SliceWithZeroPaddingEmptyOnError(96 + (int)baseLength, (int)expLength); + if (expDataSpan.Length > 0) + { + fixed (byte* expData = &MemoryMarshal.GetReference(expDataSpan)) + Gmp.mpz_import(expInt, expLength, 1, 1, 1, nuint.Zero, (nint)expData); } Gmp.mpz_powm(powmResult, baseInt, expInt, modulusInt); - var powmResultLen = (int)(Gmp.mpz_sizeinbase(powmResult, 2) + 7) / 8; - var offset = modulusLength - powmResultLen; - byte[] result = new byte[modulusLength]; + nint powmResultLen = (nint)(Gmp.mpz_sizeinbase(powmResult, 2) + 7) / 8; + nint offset = (int)modulusLength - powmResultLen; - fixed (byte* ptr = result) + byte[] result = new byte[modulusLength]; + fixed (byte* ptr = &MemoryMarshal.GetArrayDataReference(result)) Gmp.mpz_export((nint)(ptr + offset), out _, 1, 1, 1, nuint.Zero, powmResult); return (result, true); } - [Obsolete("This is a previous implementation using BigInteger instead of GMP")] - public static (byte[], bool) OldRun(byte[] inputData) - { - Metrics.ModExpPrecompile++; - - (int baseLength, int expLength, int modulusLength) = GetInputLengths(inputData); - - BigInteger modulusInt = inputData - .SliceWithZeroPaddingEmptyOnError(96 + baseLength + expLength, modulusLength).ToUnsignedBigInteger(); - - if (modulusInt.IsZero) - { - return (new byte[modulusLength], true); - } - - BigInteger baseInt = inputData.SliceWithZeroPaddingEmptyOnError(96, baseLength).ToUnsignedBigInteger(); - BigInteger expInt = inputData.SliceWithZeroPaddingEmptyOnError(96 + baseLength, expLength) - .ToUnsignedBigInteger(); - return (BigInteger.ModPow(baseInt, expInt, modulusInt).ToBigEndianByteArray(modulusLength), true); - } - /// /// def calculate_multiplication_complexity(base_length, modulus_length): /// max_length = max(base_length, modulus_length) @@ -196,23 +287,33 @@ public static (byte[], bool) OldRun(byte[] inputData) /// return words**2 /// /// - private static UInt256 MultComplexity(in UInt256 baseLength, in UInt256 modulusLength, bool isEip7883Enabled) + private static ulong MultComplexity(uint baseLength, uint modulusLength, bool isEip7883Enabled) { - UInt256 maxLength = UInt256.Max(baseLength, modulusLength); - UInt256.Mod(maxLength, 8, out UInt256 mod8); - UInt256 words = (maxLength / 8) + (mod8.IsZero ? UInt256.Zero : UInt256.One); + // Pick the larger of the two + uint max = baseLength > modulusLength ? baseLength : modulusLength; + + // Compute ceil(max/8) via a single add + shift + // (max + 7) >> 3 == (max + 7) / 8, rounding up + ulong words = ((ulong)max + 7u) >> 3; + + // Square it once + ulong sq = words * words; + // If EIP-7883 => small-case = 16, else 2*sq when max>32 if (isEip7883Enabled) { - return maxLength > 32 ? 2 * words * words : 16; + return max > LengthSize + ? (sq << 1) // 2 * words * words + : 16UL; // constant floor } - return words * words; + // Otherwise plain square + return sq; } - static readonly UInt256 IterationCountMultiplierEip2565 = 8; + static readonly ulong IterationCountMultiplierEip2565 = 8; - static readonly UInt256 IterationCountMultiplierEip7883 = 16; + static readonly ulong IterationCountMultiplierEip7883 = 16; /// /// def calculate_iteration_count(exponent_length, exponent): @@ -226,38 +327,36 @@ private static UInt256 MultComplexity(in UInt256 baseLength, in UInt256 modulusL /// /// /// - private static UInt256 CalculateIterationCount(UInt256 exponentLength, UInt256 exponent, bool isEip7883Enabled) + private static UInt256 CalculateIterationCount(uint exponentLength, UInt256 exponent, bool isEip7883Enabled) { - try + ulong iterationCount; + uint overflow = 0; + if (exponentLength <= LengthSize) + { + iterationCount = (uint)Math.Max(1, exponent.BitLen - 1); + } + else { - UInt256 iterationCount; - if (exponentLength <= 32) + uint bitLength = (uint)exponent.BitLen; + if (bitLength > 0) { - iterationCount = exponent.IsZero ? UInt256.Zero : (UInt256)(exponent.BitLen - 1); + bitLength--; } - else + + ulong multiplicationResult = (exponentLength - LengthSize) * (isEip7883Enabled ? IterationCountMultiplierEip7883 : IterationCountMultiplierEip2565); + iterationCount = multiplicationResult + bitLength; + if (iterationCount < multiplicationResult) { - int bitLength = (exponent & UInt256.MaxValue).BitLen; - if (bitLength > 0) - { - bitLength--; - } - - bool overflow = UInt256.MultiplyOverflow(exponentLength - 32, - isEip7883Enabled ? IterationCountMultiplierEip7883 : IterationCountMultiplierEip2565, - out UInt256 multiplicationResult); - overflow |= UInt256.AddOverflow(multiplicationResult, (UInt256)bitLength, out iterationCount); - if (overflow) - { - return UInt256.MaxValue; - } + // Overflowed + overflow = 1; + } + else if (iterationCount < 1) + { + // Min 1 iteration + iterationCount = 1; } - - return UInt256.Max(iterationCount, UInt256.One); - } - catch (OverflowException) - { - return UInt256.MaxValue; } + + return new UInt256(iterationCount, overflow); } } diff --git a/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs index c1186c809e8..c646b8b40a6 100644 --- a/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs +++ b/src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompilePreEip2565.cs @@ -6,7 +6,6 @@ using Nethermind.Core; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; -using Nethermind.Evm.Precompiles; using Nethermind.Int256; namespace Nethermind.Evm.Precompiles; @@ -62,7 +61,7 @@ private static long DataGasCostInternal(ReadOnlySpan extendedInput, ReadOn UInt256 complexity = MultComplexity(UInt256.Max(baseLength, modulusLength)); - byte[] expSignificantBytes = + ReadOnlySpan expSignificantBytes = inputData.Span.SliceWithZeroPaddingEmptyOnError(96 + (int)baseLength, (int)UInt256.Min(expLength, 32)); UInt256 lengthOver32 = expLength <= 32 ? 0 : expLength - 32; @@ -109,13 +108,13 @@ private static UInt256 MultComplexity(in UInt256 adjustedExponentLength) return adjustedExponentLength * adjustedExponentLength / 16 + 480 * adjustedExponentLength - 199680; } - private static UInt256 AdjustedExponentLength(in UInt256 lengthOver32, byte[] exponent) + private static UInt256 AdjustedExponentLength(in UInt256 lengthOver32, ReadOnlySpan exponent) { bool overflow = false; bool underflow = false; UInt256 result; - int leadingZeros = exponent.AsSpan().LeadingZerosCount(); + int leadingZeros = exponent.LeadingZerosCount(); if (leadingZeros == exponent.Length) { overflow |= UInt256.MultiplyOverflow(lengthOver32, Eight, out result); diff --git a/src/Nethermind/Nethermind.Evm.Test/Eip2565Tests.cs b/src/Nethermind/Nethermind.Evm.Test/Eip2565Tests.cs index afc87008b9a..14e715eb990 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Eip2565Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Eip2565Tests.cs @@ -3,10 +3,12 @@ using System; using System.Linq; +using System.Numerics; using FluentAssertions; using MathNet.Numerics.Random; using Nethermind.Core.Extensions; using Nethermind.Evm.Precompiles; +using Nethermind.Int256; using Nethermind.Specs.Forks; using NUnit.Framework; @@ -25,13 +27,12 @@ public void Simple_routine([Random(int.MinValue, int.MaxValue, 100)] int seed) string randomInput = string.Format("{0}{0}{0}{1}", Length64, data.ToHexString()); Prepare input = Prepare.EvmCode.FromCode(randomInput); + byte[] inputData = input.Done.ToArray(); - (ReadOnlyMemory, bool) gmpPair = ModExpPrecompile.Instance.Run(input.Done.ToArray(), Berlin.Instance); -#pragma warning disable 618 - (ReadOnlyMemory, bool) bigIntPair = ModExpPrecompile.OldRun(input.Done.ToArray()); -#pragma warning restore 618 + (ReadOnlyMemory, bool) gmpPair = ModExpPrecompile.Instance.Run(inputData, Berlin.Instance); + (ReadOnlyMemory, bool) bigIntPair = BigIntegerModExp(inputData); - Assert.That(bigIntPair.Item1.ToArray(), Is.EqualTo(gmpPair.Item1.ToArray())); + Assert.That(gmpPair.Item1.ToArray(), Is.EqualTo(bigIntPair.Item1.ToArray())); } [Test] @@ -51,5 +52,37 @@ public void ModExp_run_should_not_throw_exception(string inputStr) long gas = ModExpPrecompile.Instance.DataGasCost(input.Done, London.Instance); gas.Should().Be(200); } + + private static (byte[], bool) BigIntegerModExp(byte[] inputData) + { + (int baseLength, int expLength, int modulusLength) = GetInputLengths(inputData); + + BigInteger modulusInt = inputData + .SliceWithZeroPaddingEmptyOnError(96 + baseLength + expLength, modulusLength).ToUnsignedBigInteger(); + + if (modulusInt.IsZero) + { + return (new byte[modulusLength], true); + } + + BigInteger baseInt = inputData.SliceWithZeroPaddingEmptyOnError(96, baseLength).ToUnsignedBigInteger(); + BigInteger expInt = inputData.SliceWithZeroPaddingEmptyOnError(96 + baseLength, expLength) + .ToUnsignedBigInteger(); + return (BigInteger.ModPow(baseInt, expInt, modulusInt).ToBigEndianByteArray(modulusLength), true); + } + + private static (int baseLength, int expLength, int modulusLength) GetInputLengths(ReadOnlySpan inputData) + { + Span extendedInput = stackalloc byte[96]; + inputData[..Math.Min(96, inputData.Length)] + .CopyTo(extendedInput[..Math.Min(96, inputData.Length)]); + + int baseLength = (int)new UInt256(extendedInput[..32], true); + UInt256 expLengthUint256 = new(extendedInput.Slice(32, 32), true); + int expLength = expLengthUint256 > Array.MaxLength ? Array.MaxLength : (int)expLengthUint256; + int modulusLength = (int)new UInt256(extendedInput.Slice(64, 32), true); + + return (baseLength, expLength, modulusLength); + } } } diff --git a/src/Nethermind/Nethermind.Evm.Test/Eip7823Tests.cs b/src/Nethermind/Nethermind.Evm.Test/Eip7823Tests.cs index a7331ba8dd8..578e214fbbf 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Eip7823Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Eip7823Tests.cs @@ -60,8 +60,8 @@ public void TestInvalid(string inputHex) byte[] input = Bytes.FromHexString(inputHex); - Assert.Throws(() => TestSuccess(input, specDisabled)); - Assert.Throws(() => TestSuccess(input, specEnabled)); + Assert.That(TestSuccess(input, specDisabled), Is.EqualTo(false)); + Assert.That(TestSuccess(input, specEnabled), Is.EqualTo(false)); Assert.That(TestGas(input, specDisabled), Is.EqualTo(long.MaxValue)); Assert.That(TestGas(input, specEnabled), Is.EqualTo(long.MaxValue)); diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math2Param.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math2Param.cs index 20dfa34d688..3cf253b5243 100644 --- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math2Param.cs +++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math2Param.cs @@ -269,7 +269,7 @@ public static EvmExceptionType InstructionExp(VirtualMachine vm, r goto StackUnderflow; // Pop the exponent as a 256-bit word. - Span bytes = stack.PopWord256(); + ReadOnlySpan bytes = stack.PopWord256(); // Determine the effective byte-length of the exponent. int leadingZeros = bytes.LeadingZerosCount(); diff --git a/src/Nethermind/Nethermind.Precompiles.Benchmark/ModExpBenchmark.cs b/src/Nethermind/Nethermind.Precompiles.Benchmark/ModExpBenchmark.cs index e8d5934b828..1a7f8a3ad00 100644 --- a/src/Nethermind/Nethermind.Precompiles.Benchmark/ModExpBenchmark.cs +++ b/src/Nethermind/Nethermind.Precompiles.Benchmark/ModExpBenchmark.cs @@ -3,22 +3,12 @@ using System; using System.Collections.Generic; -using BenchmarkDotNet.Attributes; using Nethermind.Evm.Precompiles; -namespace Nethermind.Precompiles.Benchmark -{ - public class ModExpBenchmark : PrecompileBenchmarkBase - { - protected override IEnumerable Precompiles => new[] { ModExpPrecompile.Instance }; - protected override string InputsDirectory => "modexp"; +namespace Nethermind.Precompiles.Benchmark; - [Benchmark] - public (ReadOnlyMemory, bool) BigInt() - { -#pragma warning disable CS0618 // Type or member is obsolete - return ModExpPrecompile.OldRun(Input.Bytes); -#pragma warning restore CS0618 // Type or member is obsolete - } - } +public class ModExpBenchmark : PrecompileBenchmarkBase +{ + protected override IEnumerable Precompiles => new[] { ModExpPrecompile.Instance }; + protected override string InputsDirectory => "modexp"; } From 0a5591d4a68c45b6cc8be81e7d07d2469f1f4eae Mon Sep 17 00:00:00 2001 From: Amirul Ashraf Date: Sat, 19 Jul 2025 11:25:59 +0800 Subject: [PATCH 30/40] Remove last orphan readonly tx processing scope. (#9005) --- .../StartBlockProducerAuRa.cs | 38 ++++++++----------- 1 file changed, 15 insertions(+), 23 deletions(-) diff --git a/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/StartBlockProducerAuRa.cs b/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/StartBlockProducerAuRa.cs index f0222a28601..7d6b1015565 100644 --- a/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/StartBlockProducerAuRa.cs +++ b/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/StartBlockProducerAuRa.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Autofac; using Autofac.Features.AttributeFilters; using Nethermind.Abi; using Nethermind.Blockchain; @@ -64,13 +65,14 @@ public class StartBlockProducerAuRa( ITxPool txPool, IStateReader apiStateReader, ITransactionComparerProvider transactionComparerProvider, - CompositeBlockPreprocessorStep compositeBlockPreprocessorStep, [KeyFilter(IProtectedPrivateKey.NodeKey)] IProtectedPrivateKey protectedPrivateKey, ICryptoRandom cryptoRandom, IBlockValidator blockValidator, IRewardCalculatorSource rewardCalculatorSource, IAuRaStepCalculator stepCalculator, AuRaGasLimitOverrideFactory gasLimitOverrideFactory, + IWorldStateManager worldStateManager, + ILifetimeScope lifetimeScope, ILogManager logManager) { private readonly AuRaChainSpecEngineParameters _parameters = chainSpec.EngineChainSpecParametersProvider @@ -125,14 +127,14 @@ public IBlockProducer BuildProducer() return blockProducer; } - private BlockProcessor CreateBlockProcessor(IReadOnlyTxProcessingScope changeableTxProcessingEnv) + private BlockProcessor CreateBlockProcessor(ITransactionProcessor txProcessor, IWorldState worldState) { ITxFilter auRaTxFilter = apiTxAuRaFilterBuilders.CreateAuRaTxFilter( new LocalTxFilter(engineSigner)); _validator = new AuRaValidatorFactory(abiEncoder, - changeableTxProcessingEnv.WorldState, - changeableTxProcessingEnv.TransactionProcessor, + worldState, + txProcessor, blockTree, readOnlyTxProcessingEnvFactory.Create(), receiptStorage, @@ -158,9 +160,6 @@ private BlockProcessor CreateBlockProcessor(IReadOnlyTxProcessingScope changeabl IDictionary> rewriteBytecode = _parameters.RewriteBytecode; ContractRewriter? contractRewriter = rewriteBytecode?.Count > 0 ? new ContractRewriter(rewriteBytecode) : null; - ITransactionProcessor txProcessor = changeableTxProcessingEnv.TransactionProcessor; - IWorldState worldState = changeableTxProcessingEnv.WorldState; - var transactionExecutor = new BlockProcessor.BlockProductionTransactionsExecutor( new BuildUpTransactionProcessorAdapter(txProcessor), worldState, @@ -258,24 +257,17 @@ BlockProducerEnv Create() { ReadOnlyBlockTree readOnlyBlockTree = blockTree.AsReadOnly(); - IReadOnlyTxProcessorSource txProcessingEnv = readOnlyTxProcessingEnvFactory.Create(); - IReadOnlyTxProcessingScope scope = txProcessingEnv.Build(null); - BlockProcessor blockProcessor = CreateBlockProcessor(scope); - - IBlockchainProcessor blockchainProcessor = - new BlockchainProcessor( - readOnlyBlockTree, - blockProcessor, - compositeBlockPreprocessorStep, - apiStateReader, - logManager, - BlockchainProcessor.Options.NoReceipts); + IWorldState worldState = worldStateManager.CreateResettableWorldState(); + ILifetimeScope innerLifetime = lifetimeScope.BeginLifetimeScope((builder) => builder + .AddSingleton(worldState) + .AddSingleton(BlockchainProcessor.Options.NoReceipts) + .AddSingleton(CreateBlockProcessor) + .AddDecorator()); + lifetimeScope.Disposer.AddInstanceForAsyncDisposal(innerLifetime); - OneTimeChainProcessor chainProcessor = new( - scope.WorldState, - blockchainProcessor); + IBlockchainProcessor chainProcessor = innerLifetime.Resolve(); - return new BlockProducerEnv(readOnlyBlockTree, chainProcessor, scope.WorldState, CreateTxSourceForProducer()); + return new BlockProducerEnv(readOnlyBlockTree, chainProcessor, worldState, CreateTxSourceForProducer()); } return _blockProducerContext ??= Create(); From 661f070af69fe04baf35965a02e8216e59f633bb Mon Sep 17 00:00:00 2001 From: Siddharth Vaderaa Date: Sat, 19 Jul 2025 15:16:00 +0200 Subject: [PATCH 31/40] Fix workerloop --- .../Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs b/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs index 812c05bd50e..ff72e740cfc 100644 --- a/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs +++ b/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs @@ -77,13 +77,18 @@ private static async Task WorkerLoop(int taskLimit, IVMConfig config, ILogger lo Task[] taskPool = new Task[taskLimit]; Array.Fill(taskPool, Task.CompletedTask); - await _channel.Reader.WaitToReadAsync(_cts.Token); - await foreach (var codeInfo in _channel.Reader.ReadAllAsync(_cts.Token)) + while (await _channel.Reader.WaitToReadAsync(_cts.Token)) { - int index = Task.WaitAny(taskPool); - Metrics.DecrementIlvmAotQueueSize(); - taskPool[index] = Task.Run(() => ProcessCodeInfoAsync(config, logger, codeInfo)); + await foreach (var codeInfo in _channel.Reader.ReadAllAsync(_cts.Token)) + { + int index = Task.WaitAny(taskPool); + + Metrics.DecrementIlvmAotQueueSize(); + + taskPool[index] = Task.Run(async () => await ProcessCodeInfoAsync(config, logger, codeInfo)); + } + } } catch (Exception ex) From 5413713259a0bd2322effc54a602e819fbd005bd Mon Sep 17 00:00:00 2001 From: Siddharth Vaderaa Date: Sat, 19 Jul 2025 15:37:15 +0200 Subject: [PATCH 32/40] Replace read all with try read --- .../Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs b/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs index ff72e740cfc..dc77198e57d 100644 --- a/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs +++ b/src/Nethermind/Nethermind.Evm/CodeAnalysis/IL/IlAnalyzer.cs @@ -79,16 +79,17 @@ private static async Task WorkerLoop(int taskLimit, IVMConfig config, ILogger lo while (await _channel.Reader.WaitToReadAsync(_cts.Token)) { - - await foreach (var codeInfo in _channel.Reader.ReadAllAsync(_cts.Token)) + while (_channel.Reader.TryRead(out CodeInfo? codeInfo)) { + if (codeInfo is null) + break; + int index = Task.WaitAny(taskPool); Metrics.DecrementIlvmAotQueueSize(); taskPool[index] = Task.Run(async () => await ProcessCodeInfoAsync(config, logger, codeInfo)); } - } } catch (Exception ex) From 48c33346d23cfc1e7f9e5cd081bfd7925fc0c5ab Mon Sep 17 00:00:00 2001 From: Siddharth Vaderaa Date: Sat, 19 Jul 2025 20:41:31 +0200 Subject: [PATCH 33/40] Update config for tests --- src/Nethermind/Nethermind.Evm.Test/ILEVM/IlEvmTests.cs | 1 + .../Nethermind.Evm.Test/ILEVM/RealContractTestsBase.cs | 6 +++++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/Nethermind/Nethermind.Evm.Test/ILEVM/IlEvmTests.cs b/src/Nethermind/Nethermind.Evm.Test/ILEVM/IlEvmTests.cs index 31e1eaade1c..a116bffc7a6 100644 --- a/src/Nethermind/Nethermind.Evm.Test/ILEVM/IlEvmTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/ILEVM/IlEvmTests.cs @@ -1862,6 +1862,7 @@ public void Execution_Swap_Happens_When_Compilation_Occurs() IlEvmEnabledMode = ILMode.AOT_MODE, IlEvmAnalysisThreshold = 1, IlEvmAnalysisQueueMaxSize = 1, + IlEvmAllowedContracts = [], }, Prague.Instance); byte[] bytecode = diff --git a/src/Nethermind/Nethermind.Evm.Test/ILEVM/RealContractTestsBase.cs b/src/Nethermind/Nethermind.Evm.Test/ILEVM/RealContractTestsBase.cs index ac3ff85b283..f2ca6f2a0a4 100644 --- a/src/Nethermind/Nethermind.Evm.Test/ILEVM/RealContractTestsBase.cs +++ b/src/Nethermind/Nethermind.Evm.Test/ILEVM/RealContractTestsBase.cs @@ -60,7 +60,11 @@ protected RealContractTestsBase(bool useIlEVM) } else { - _config = new VMConfig(); + _config = new VMConfig + { + IsILEvmEnabled = false, + IlEvmEnabledMode = ILMode.NO_ILVM + }; } } From 8075f5f90ec357d467cf18094afac0bcdbe63972 Mon Sep 17 00:00:00 2001 From: Ruben Buniatyan Date: Sun, 20 Jul 2025 10:34:16 +0200 Subject: [PATCH 34/40] Update winget command (#9011) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a989abb7d9b..5b34a6e61d3 100644 --- a/README.md +++ b/README.md @@ -47,7 +47,7 @@ The standalone release builds are available on [GitHub Releases](https://github. On Windows, Nethermind can be installed via Windows Package Manager: ```powershell - winget install nethermind + winget install --id Nethermind.Nethermind ``` - **macOS** From d2230a01a95016baa336a51e330e17b15f4b55cd Mon Sep 17 00:00:00 2001 From: "core-repository-dispatch-app[bot]" <173070810+core-repository-dispatch-app[bot]@users.noreply.github.com> Date: Sun, 20 Jul 2025 10:34:33 +0200 Subject: [PATCH 35/40] Auto-update fast sync settings (#9013) Co-authored-by: rubo --- src/Nethermind/Nethermind.Runner/configs/base-mainnet.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/base-sepolia.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/chiado.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/energyweb.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/gnosis.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/joc-testnet.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json | 6 +++--- src/Nethermind/Nethermind.Runner/configs/mainnet.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/op-mainnet.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/op-sepolia.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/sepolia.json | 4 ++-- src/Nethermind/Nethermind.Runner/configs/volta.json | 6 +++--- .../Nethermind.Runner/configs/worldchain-mainnet.json | 4 ++-- .../Nethermind.Runner/configs/worldchain-sepolia.json | 4 ++-- 16 files changed, 38 insertions(+), 38 deletions(-) diff --git a/src/Nethermind/Nethermind.Runner/configs/base-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/base-mainnet.json index f0d6ffb949c..bce44570880 100644 --- a/src/Nethermind/Nethermind.Runner/configs/base-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/base-mainnet.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 32780000, - "PivotHash": "0x28f0ac563c5dd0098c6ac3c23aa291e5164c77afcbb0ec6f915b5c2ce782cbf6" + "PivotNumber": 33080000, + "PivotHash": "0xf8426b70e8f3da4c5f473fbb4cc76b767781c7ae6e7ff630b2b834c0a60e30a0" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/base-sepolia.json b/src/Nethermind/Nethermind.Runner/configs/base-sepolia.json index e72ea30695e..396f6d7cf26 100644 --- a/src/Nethermind/Nethermind.Runner/configs/base-sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/base-sepolia.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 28290000, - "PivotHash": "0xde9a2994afb2da18d22b4051d2a67a7024c4fa2d6277e4e6022064332570b87d" + "PivotNumber": 28590000, + "PivotHash": "0xc168f8c4b4d80a72758d851549d4f4a7d2bb97f1521589106245befea37f7a88" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/chiado.json b/src/Nethermind/Nethermind.Runner/configs/chiado.json index ce78beea0b5..f700945802a 100644 --- a/src/Nethermind/Nethermind.Runner/configs/chiado.json +++ b/src/Nethermind/Nethermind.Runner/configs/chiado.json @@ -18,8 +18,8 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 16710000, - "PivotHash": "0xf5e5177ed8b0c340d7d39f31ca73a594b18203095a700868a3e70f673aa0c5b3", + "PivotNumber": 16830000, + "PivotHash": "0x6889240d237418570a6055c05ea3f9dd6d9e0f073467b6d54805ceaae805c32e", "PivotTotalDifficulty": "231708131825107706987652208063906496124457284", "FastSyncCatchUpHeightDelta": 10000000000, "UseGethLimitsInFastBlocks": false diff --git a/src/Nethermind/Nethermind.Runner/configs/energyweb.json b/src/Nethermind/Nethermind.Runner/configs/energyweb.json index 9cb16959521..0d25a77e7fd 100644 --- a/src/Nethermind/Nethermind.Runner/configs/energyweb.json +++ b/src/Nethermind/Nethermind.Runner/configs/energyweb.json @@ -13,9 +13,9 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 36510000, - "PivotHash": "0xafe652ac0d78c419917ccdbbbb1cb8c38d790724ef97005cb3e1f821a84d1586", - "PivotTotalDifficulty": "12423709216283463301047806917333857399871718285", + "PivotNumber": 36610000, + "PivotHash": "0xf619256a2563f55749a80af079ab657eb2b3c5f80679805d2aaa5433bc496eb9", + "PivotTotalDifficulty": "12457737452975557147394144378077034221017104410", "UseGethLimitsInFastBlocks": false, "FastSyncCatchUpHeightDelta": 10000000000 }, diff --git a/src/Nethermind/Nethermind.Runner/configs/gnosis.json b/src/Nethermind/Nethermind.Runner/configs/gnosis.json index c0d8eab6642..710ddcfcff7 100644 --- a/src/Nethermind/Nethermind.Runner/configs/gnosis.json +++ b/src/Nethermind/Nethermind.Runner/configs/gnosis.json @@ -14,8 +14,8 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 41040000, - "PivotHash": "0x15849f57931cf7739eed0cdeb0da8df2ea16810b272dcf6d173dcca1af5cd245", + "PivotNumber": 41160000, + "PivotHash": "0x201f9950e670b6010d99186595c6bbc1bc19896701d448e759edb71f90cc18f8", "PivotTotalDifficulty": "8626000110427538733349499292577475819600160930", "UseGethLimitsInFastBlocks": false, "FastSyncCatchUpHeightDelta": 10000000000 diff --git a/src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json index 21273eea87b..86576eed4f5 100644 --- a/src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/joc-mainnet.json @@ -12,9 +12,9 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 18540000, - "PivotHash": "0x3b79719300301258d503a57790407d64cb4d8dca3207643b6979b5659937dc40", - "PivotTotalDifficulty": "34293024" + "PivotNumber": 18660000, + "PivotHash": "0x54fa59d40aa87afcccde55694a9341eb6d4b0f232203b1b65892f40ab5735604", + "PivotTotalDifficulty": "34476648" }, "Metrics": { "NodeName": "JOC-Mainnet" diff --git a/src/Nethermind/Nethermind.Runner/configs/joc-testnet.json b/src/Nethermind/Nethermind.Runner/configs/joc-testnet.json index a18c886578e..e97473e83ed 100644 --- a/src/Nethermind/Nethermind.Runner/configs/joc-testnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/joc-testnet.json @@ -12,9 +12,9 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 12150000, - "PivotHash": "0x593af9bca041f58a9a41a75d56e61a2796b8b63e872427dc855683e767d62d47", - "PivotTotalDifficulty": "20653978" + "PivotNumber": 12270000, + "PivotHash": "0xd715f8b77c3db8c0685ac6b84421a42e17db7196b24a439d3f2932565e6fe4f0", + "PivotTotalDifficulty": "20849186" }, "Metrics": { "NodeName": "JOC-Testnet" diff --git a/src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json index b7b48a4f28b..f578ed24fb6 100644 --- a/src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/linea-mainnet.json @@ -17,9 +17,9 @@ }, "Sync": { "SnapSync": true, - "PivotNumber": 20800000, - "PivotHash": "0x359161297fb9504f222e5543e2196d7229f3ea869a91a66d10ed6b9f421f038a", - "PivotTotalDifficulty": "41600001", + "PivotNumber": 21040000, + "PivotHash": "0x85b7e32e1db604ce21099ef22d3a9a5e19a37f3aaee60da4f8bea439378cdeb8", + "PivotTotalDifficulty": "42080001", "HeaderStateDistance": 6 }, "JsonRpc": { diff --git a/src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json b/src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json index 1cb54492c84..14b834579e7 100644 --- a/src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/linea-sepolia.json @@ -17,9 +17,9 @@ }, "Sync": { "SnapSync": true, - "PivotNumber": 15610000, - "PivotHash": "0x8405842b6afe9749d7c4dae84fbf95ee3febbe11b8291752183c72699f7aba8b", - "PivotTotalDifficulty": "31220001", + "PivotNumber": 15900000, + "PivotHash": "0xee15aaab2eb0ff68763e4155a423fa67e0e5aaa4d40429dbbbd7f7dcce99dab8", + "PivotTotalDifficulty": "31800001", "HeaderStateDistance": 6 }, "JsonRpc": { diff --git a/src/Nethermind/Nethermind.Runner/configs/mainnet.json b/src/Nethermind/Nethermind.Runner/configs/mainnet.json index a4256abf943..2e3593aa864 100644 --- a/src/Nethermind/Nethermind.Runner/configs/mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/mainnet.json @@ -10,8 +10,8 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 22905000, - "PivotHash": "0x81116f98d56e3f037149f835477e93a36ebb307ae58853b4f1f695878d77dc8f", + "PivotNumber": 22955000, + "PivotHash": "0x6d6adb1e43494a8d8936eb2a0aec49036db5f18e30c035d6b131da7e41c9fc96", "PivotTotalDifficulty": "58750003716598352816469", "FastSyncCatchUpHeightDelta": "10000000000", "AncientReceiptsBarrier": 15537394, diff --git a/src/Nethermind/Nethermind.Runner/configs/op-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/op-mainnet.json index 2291e055de0..7a9066040aa 100644 --- a/src/Nethermind/Nethermind.Runner/configs/op-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/op-mainnet.json @@ -15,8 +15,8 @@ "FastSyncCatchUpHeightDelta": "10000000000", "AncientBodiesBarrier": 105235063, "AncientReceiptsBarrier": 105235063, - "PivotNumber": 138370000, - "PivotHash": "0x9a4caaacd0359b2b0be23710c96d2af4ca7f403a0d75b312f5833e1b205d36e4" + "PivotNumber": 138670000, + "PivotHash": "0xfcc242fb6a8711365bb1795111845f2b0cd8759d183b2a03d5f103419b64271f" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/op-sepolia.json b/src/Nethermind/Nethermind.Runner/configs/op-sepolia.json index 9f810e4e1ff..0b3502c78a7 100644 --- a/src/Nethermind/Nethermind.Runner/configs/op-sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/op-sepolia.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 30270000, - "PivotHash": "0x2f80ce1ac126baf2ceb86ccd2e157a018530f058edd70532fe92602fee2b00dd" + "PivotNumber": 30570000, + "PivotHash": "0x370ec14de902ce138d46eeeb337761d5c1a714fd12073a8096a73b875d6732da" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/sepolia.json b/src/Nethermind/Nethermind.Runner/configs/sepolia.json index 4660987c041..daa77ab2184 100644 --- a/src/Nethermind/Nethermind.Runner/configs/sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/sepolia.json @@ -18,8 +18,8 @@ "FastSync": true, "SnapSync": true, "UseGethLimitsInFastBlocks": true, - "PivotNumber": 8750000, - "PivotHash": "0x74560d628a79b7b585db1941d697b489eaaea0ad81634a0b7ff131c784ba90e9", + "PivotNumber": 8799000, + "PivotHash": "0xddb69b6cabd779e5c1afb25952e563017079cf31d7b5d2c8622067416abd4a6e", "PivotTotalDifficulty": "17000018015853232", "FastSyncCatchUpHeightDelta": 10000000000, "AncientReceiptsBarrier": 1450409, diff --git a/src/Nethermind/Nethermind.Runner/configs/volta.json b/src/Nethermind/Nethermind.Runner/configs/volta.json index 3cd40bd0647..40ef23e67b0 100644 --- a/src/Nethermind/Nethermind.Runner/configs/volta.json +++ b/src/Nethermind/Nethermind.Runner/configs/volta.json @@ -17,9 +17,9 @@ "Sync": { "FastSync": true, "SnapSync": true, - "PivotNumber": 32680000, - "PivotHash": "0xe8e20981712f6df72b9ff23141ebb068dc2b0ccea48bfe9a99ee46cd5836f90f", - "PivotTotalDifficulty": "11120427750976268985983082170870185149999071660", + "PivotNumber": 32800000, + "PivotHash": "0x11c0fc1fc1d8f0bb77adb515295e73f6b24dc568ca8a99a8ff92998d031cf52e", + "PivotTotalDifficulty": "11161261635006781601598687123761997335373551401", "UseGethLimitsInFastBlocks": false, "FastSyncCatchUpHeightDelta": 10000000000 }, diff --git a/src/Nethermind/Nethermind.Runner/configs/worldchain-mainnet.json b/src/Nethermind/Nethermind.Runner/configs/worldchain-mainnet.json index 99fb11817ed..61a49f2bf72 100644 --- a/src/Nethermind/Nethermind.Runner/configs/worldchain-mainnet.json +++ b/src/Nethermind/Nethermind.Runner/configs/worldchain-mainnet.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 16500000, - "PivotHash": "0x5cdc5965f8ae1e261705fdce4c4379eb0f7c4eb725fd4b79eac9e473305694dc" + "PivotNumber": 16800000, + "PivotHash": "0x844ebc24471652792d1c2ee2808792d1c279b68f36c75d29d8385678e3632485" }, "Discovery": { "DiscoveryVersion": "V5" diff --git a/src/Nethermind/Nethermind.Runner/configs/worldchain-sepolia.json b/src/Nethermind/Nethermind.Runner/configs/worldchain-sepolia.json index d0d0dd22f71..c67399e81bc 100644 --- a/src/Nethermind/Nethermind.Runner/configs/worldchain-sepolia.json +++ b/src/Nethermind/Nethermind.Runner/configs/worldchain-sepolia.json @@ -13,8 +13,8 @@ "FastSync": true, "SnapSync": true, "FastSyncCatchUpHeightDelta": "10000000000", - "PivotNumber": 15900000, - "PivotHash": "0xc52258828e1f01d64dc6e2455cb51baae4c77a91fed1b27e08760f01badc3e3e" + "PivotNumber": 16200000, + "PivotHash": "0xefdd20a0c9c705b3ca34f7259d7efc4a8481af2abfbef6a63f576b637bd3bb23" }, "Discovery": { "DiscoveryVersion": "V5" From f4c1c9f55f380c217a32b5e60c875d0ca3610740 Mon Sep 17 00:00:00 2001 From: "core-repository-dispatch-app[bot]" <173070810+core-repository-dispatch-app[bot]@users.noreply.github.com> Date: Sun, 20 Jul 2025 10:34:55 +0200 Subject: [PATCH 36/40] Update OP Superchain chains (#9014) Co-authored-by: emlautarom1 From dc7276fcadd3d07388e1b386a92a440055c6ca82 Mon Sep 17 00:00:00 2001 From: Ben {chmark} Adams Date: Sun, 20 Jul 2025 09:50:03 +0100 Subject: [PATCH 37/40] Tidy up ecdsa overloads (#9015) * Tidy up ecdsa overloads * put back the increase --- .../Nethermind.Consensus.Clique/SnapshotManager.cs | 2 +- src/Nethermind/Nethermind.Crypto/EthereumEcdsa.cs | 10 +--------- src/Nethermind/Nethermind.Crypto/IEthereumEcdsa.cs | 3 --- src/Nethermind/Nethermind.Crypto/NullEthereumEcdsa.cs | 5 ----- .../Nethermind.Optimism/OptimismEthereumEcdsa.cs | 2 -- 5 files changed, 2 insertions(+), 20 deletions(-) diff --git a/src/Nethermind/Nethermind.Consensus.Clique/SnapshotManager.cs b/src/Nethermind/Nethermind.Consensus.Clique/SnapshotManager.cs index f909b71f131..e782eac5931 100644 --- a/src/Nethermind/Nethermind.Consensus.Clique/SnapshotManager.cs +++ b/src/Nethermind/Nethermind.Consensus.Clique/SnapshotManager.cs @@ -67,7 +67,7 @@ public Address GetBlockSealer(BlockHeader header) Signature signature = new(signatureBytes); signature.V += Signature.VOffset; ValueHash256 message = CalculateCliqueHeaderHash(header); - Address address = _ecdsa.RecoverAddress(signatureBytes, in message); + Address address = _ecdsa.RecoverAddress(signature, in message); _signatures.Set(header.Hash, address); return address; } diff --git a/src/Nethermind/Nethermind.Crypto/EthereumEcdsa.cs b/src/Nethermind/Nethermind.Crypto/EthereumEcdsa.cs index 00fd2905cef..73f844d8aca 100644 --- a/src/Nethermind/Nethermind.Crypto/EthereumEcdsa.cs +++ b/src/Nethermind/Nethermind.Crypto/EthereumEcdsa.cs @@ -4,10 +4,8 @@ using System; using System.Globalization; using System.Numerics; -using System.Runtime.CompilerServices; using Nethermind.Core; using Nethermind.Core.Crypto; -using Nethermind.Core.Specs; namespace Nethermind.Crypto { @@ -27,15 +25,9 @@ public class EthereumEcdsa(ulong chainId) : Ecdsa, IEthereumEcdsa public ulong ChainId => chainId; - public EthereumEcdsa(ISpecProvider specProvider) : this(specProvider.ChainId) - { - } - public Address? RecoverAddress(Signature signature, in ValueHash256 message) => RecoverAddress(signature.Bytes, signature.RecoveryId, message.Bytes); - public Address? RecoverAddress(Span signatureBytes65, in ValueHash256 message) => RecoverAddress(signatureBytes65[..64], signatureBytes65[64], message.Bytes); - - public static Address? RecoverAddress(Span signatureBytes64, byte v, ReadOnlySpan message) + private static Address? RecoverAddress(Span signatureBytes64, byte v, ReadOnlySpan message) { Span publicKey = stackalloc byte[65]; bool success = SpanSecP256k1.RecoverKeyFromCompact( diff --git a/src/Nethermind/Nethermind.Crypto/IEthereumEcdsa.cs b/src/Nethermind/Nethermind.Crypto/IEthereumEcdsa.cs index ed03f79d939..b4a02f65c09 100644 --- a/src/Nethermind/Nethermind.Crypto/IEthereumEcdsa.cs +++ b/src/Nethermind/Nethermind.Crypto/IEthereumEcdsa.cs @@ -14,8 +14,5 @@ public interface IEthereumEcdsa : IEcdsa => RecoverAddress(signature, in message.ValueHash256); Address? RecoverAddress(Signature signature, in ValueHash256 message); - Address? RecoverAddress(Span signatureBytes, Hash256 message) - => RecoverAddress(signatureBytes, in message.ValueHash256); - Address? RecoverAddress(Span signatureBytes, in ValueHash256 message); } } diff --git a/src/Nethermind/Nethermind.Crypto/NullEthereumEcdsa.cs b/src/Nethermind/Nethermind.Crypto/NullEthereumEcdsa.cs index 739d61d290c..9274ff54140 100644 --- a/src/Nethermind/Nethermind.Crypto/NullEthereumEcdsa.cs +++ b/src/Nethermind/Nethermind.Crypto/NullEthereumEcdsa.cs @@ -37,11 +37,6 @@ public Address RecoverAddress(Transaction tx, bool useSignatureChainId = false) throw new InvalidOperationException($"{nameof(NullEthereumEcdsa)} does not expect any calls"); } - public Address RecoverAddress(Span signatureBytes, in ValueHash256 message) - { - throw new InvalidOperationException($"{nameof(NullEthereumEcdsa)} does not expect any calls"); - } - public bool Verify(Address sender, Transaction tx) { throw new InvalidOperationException($"{nameof(NullEthereumEcdsa)} does not expect any calls"); diff --git a/src/Nethermind/Nethermind.Optimism/OptimismEthereumEcdsa.cs b/src/Nethermind/Nethermind.Optimism/OptimismEthereumEcdsa.cs index 44d807cddbd..b72cf8e29fb 100644 --- a/src/Nethermind/Nethermind.Optimism/OptimismEthereumEcdsa.cs +++ b/src/Nethermind/Nethermind.Optimism/OptimismEthereumEcdsa.cs @@ -19,6 +19,4 @@ public OptimismEthereumEcdsa(IEthereumEcdsa ethereumEcdsa) _ethereumEcdsa = ethereumEcdsa; } public Address? RecoverAddress(Signature signature, in ValueHash256 message) => _ethereumEcdsa.RecoverAddress(signature, in message); - - public Address? RecoverAddress(Span signatureBytes, in ValueHash256 message) => _ethereumEcdsa.RecoverAddress(signatureBytes, in message); } From 4aae1930b50d9305f84698d4700f6a7eed1a5e10 Mon Sep 17 00:00:00 2001 From: Siddharth Vaderaa Date: Sun, 20 Jul 2025 11:57:32 +0200 Subject: [PATCH 38/40] Tracing check to allow ilevm to be enabled for node and tests --- .../Nethermind.Evm.Test/ILEVM/PrimFibbTests.cs | 6 +++++- .../Nethermind.Evm/IVirtualMachine.cs | 5 +++-- .../Nethermind.Evm/Tracing/ITxTracer.cs | 18 ++++++++++++++++++ .../TransactionProcessor.cs | 4 +++- .../Nethermind.Evm/VirtualMachine.cs | 10 ++++++---- .../Simulate/SimulateVirtualMachine.cs | 7 +++++-- 6 files changed, 40 insertions(+), 10 deletions(-) diff --git a/src/Nethermind/Nethermind.Evm.Test/ILEVM/PrimFibbTests.cs b/src/Nethermind/Nethermind.Evm.Test/ILEVM/PrimFibbTests.cs index e4ac562419c..bdada4f17cd 100644 --- a/src/Nethermind/Nethermind.Evm.Test/ILEVM/PrimFibbTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/ILEVM/PrimFibbTests.cs @@ -199,7 +199,11 @@ public void EquivalenceTest(UInt256 number) { var bytecode = ResolveBytecode(Number); - IlVirtualMachineTestsBase standardChain = new IlVirtualMachineTestsBase(new VMConfig(), Prague.Instance); + IlVirtualMachineTestsBase standardChain = new IlVirtualMachineTestsBase(new VMConfig() + { + IsILEvmEnabled = false, + IlEvmEnabledMode = ILMode.NO_ILVM + }, Prague.Instance); Path.Combine(Directory.GetCurrentDirectory(), "GeneratedContracts.dll"); IlVirtualMachineTestsBase enhancedChain = new IlVirtualMachineTestsBase(new VMConfig diff --git a/src/Nethermind/Nethermind.Evm/IVirtualMachine.cs b/src/Nethermind/Nethermind.Evm/IVirtualMachine.cs index 3dfc4e3acff..7a11d6c80a3 100644 --- a/src/Nethermind/Nethermind.Evm/IVirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/IVirtualMachine.cs @@ -10,8 +10,9 @@ namespace Nethermind.Evm { public interface IVirtualMachine { - TransactionSubstate ExecuteTransaction(EvmState state, IWorldState worldState, ITxTracer txTracer) - where TTracingInst : struct, IFlag; + TransactionSubstate ExecuteTransaction(EvmState state, IWorldState worldState, ITxTracer txTracer) + where TTracingInst : struct, IFlag + where TEnablePrecompilation : struct, IFlag; ref readonly BlockExecutionContext BlockExecutionContext { get; } ref readonly TxExecutionContext TxExecutionContext { get; } void SetBlockExecutionContext(in BlockExecutionContext blockExecutionContext); diff --git a/src/Nethermind/Nethermind.Evm/Tracing/ITxTracer.cs b/src/Nethermind/Nethermind.Evm/Tracing/ITxTracer.cs index 084d942314e..a7cef60895f 100644 --- a/src/Nethermind/Nethermind.Evm/Tracing/ITxTracer.cs +++ b/src/Nethermind/Nethermind.Evm/Tracing/ITxTracer.cs @@ -150,6 +150,24 @@ public interface ITxTracer : IWorldStateTracer, IDisposable || IsTracingFees || IsTracingLogs; + bool IsIlEvmInCompatible => // only allow reciepts for now, this enables ilevm to be easily tested by the existing setup + IsTracingActions + || IsTracingOpLevelStorage + || IsTracingMemory + || IsTracingInstructions + || IsTracingRefunds + || IsTracingCode + || IsTracingStack + || IsTracingBlockHash + || IsTracingAccess + || IsTracingFees + || IsTracingLogs + || IsTracingState + || IsTracingStorage; + + bool IsIlEvmCompatible => !IsIlEvmInCompatible; + + /// /// Transaction completed successfully /// diff --git a/src/Nethermind/Nethermind.Evm/TransactionProcessing/TransactionProcessor.cs b/src/Nethermind/Nethermind.Evm/TransactionProcessing/TransactionProcessor.cs index 0e5458317f6..de2add32831 100644 --- a/src/Nethermind/Nethermind.Evm/TransactionProcessing/TransactionProcessor.cs +++ b/src/Nethermind/Nethermind.Evm/TransactionProcessing/TransactionProcessor.cs @@ -637,7 +637,9 @@ private int ExecuteEvmCall( using (EvmState state = EvmState.RentTopLevel(gasAvailable, executionType, in env, in accessedItems, in snapshot)) { - substate = VirtualMachine.ExecuteTransaction(state, WorldState, tracer); + substate = tracer.IsIlEvmCompatible + ? VirtualMachine.ExecuteTransaction(state, WorldState, tracer) + : VirtualMachine.ExecuteTransaction(state, WorldState, tracer); gasAvailable = state.GasAvailable; } diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs index 80362f1291c..dc8769e5b9d 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs @@ -135,11 +135,12 @@ public sealed unsafe partial class VirtualMachine( /// /// Thrown when an EVM-specific error occurs during execution. /// - public TransactionSubstate ExecuteTransaction( + public TransactionSubstate ExecuteTransaction( EvmState evmState, IWorldState worldState, ITxTracer txTracer) where TTracingInst : struct, IFlag + where TEnablePrecompilation : struct, IFlag { // Initialize dependencies for transaction tracing and state access. _txTracer = txTracer; @@ -191,9 +192,9 @@ public TransactionSubstate ExecuteTransaction( // Execute the regular EVM call if valid code is present; otherwise, mark as invalid. if (_currentState.Env.CodeInfo is not null) { - callResult = _txTracer.IsTracing - ? ExecuteCall(_previousCallResult, previousCallOutput, _previousCallOutputDestination) - : ExecuteCall(_previousCallResult, previousCallOutput, _previousCallOutputDestination); + callResult = _vmConfig.IsVmOptimizationEnabled + ? ExecuteCall(_previousCallResult, previousCallOutput, _previousCallOutputDestination) + : ExecuteCall(_previousCallResult, previousCallOutput, _previousCallOutputDestination); } else { @@ -1056,6 +1057,7 @@ private CallResult ExecuteCall( ZeroPaddedSpan previousCallOutput, scoped in UInt256 previousCallOutputDestination) where TTracingInst : struct, IFlag + where TEnablePrecompilation : struct, IFlag { EvmState vmState = _currentState; // Obtain a reference to the execution environment for convenience. diff --git a/src/Nethermind/Nethermind.Facade/Simulate/SimulateVirtualMachine.cs b/src/Nethermind/Nethermind.Facade/Simulate/SimulateVirtualMachine.cs index 77d1c518c71..4777e2f026f 100644 --- a/src/Nethermind/Nethermind.Facade/Simulate/SimulateVirtualMachine.cs +++ b/src/Nethermind/Nethermind.Facade/Simulate/SimulateVirtualMachine.cs @@ -12,15 +12,18 @@ namespace Nethermind.Facade.Simulate; public class SimulateVirtualMachine(IVirtualMachine virtualMachine) : IVirtualMachine { - public TransactionSubstate ExecuteTransaction(EvmState state, IWorldState worldState, ITxTracer txTracer) + public TransactionSubstate ExecuteTransaction(EvmState state, IWorldState worldState, ITxTracer txTracer) where TTracingInst : struct, IFlag + where TEnablePrecompilation : struct, IFlag { if (txTracer.IsTracingActions && TryGetLogsMutator(txTracer, out ITxLogsMutator logsMutator)) { logsMutator.SetLogsToMutate(state.AccessTracker.Logs); } - return virtualMachine.ExecuteTransaction(state, worldState, txTracer); + return txTracer.IsIlEvmCompatible + ? virtualMachine.ExecuteTransaction(state, worldState, txTracer) + : virtualMachine.ExecuteTransaction(state, worldState, txTracer); } private static bool TryGetLogsMutator(ITxTracer txTracer, [NotNullWhen(true)] out ITxLogsMutator? txLogsMutator) From 288fcaa1da854495bdbaa282aa9c0d714a85ba8f Mon Sep 17 00:00:00 2001 From: Siddharth Vaderaa Date: Sun, 20 Jul 2025 14:02:55 +0200 Subject: [PATCH 39/40] Update verified --- ...de_number=43_result=701408733.verified.txt | 9 +- ...ibbBytecode_number=5_result=8.verified.txt | 9 +- ...code_number=40001263_result=1.verified.txt | 9 +- ...ecode_number=8000010_result=0.verified.txt | 9 +- ...oxyTests.Verify_useIlEvm=True.verified.txt | 1638 +-------------- ...EthTests.Verify_useIlEvm=True.verified.txt | 1834 +---------------- 6 files changed, 57 insertions(+), 3451 deletions(-) diff --git a/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=FibbBytecode_number=43_result=701408733.verified.txt b/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=FibbBytecode_number=43_result=701408733.verified.txt index 2e74095c61e..b7881b10ce7 100644 --- a/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=FibbBytecode_number=43_result=701408733.verified.txt +++ b/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=FibbBytecode_number=43_result=701408733.verified.txt @@ -20,8 +20,6 @@ brtrue.s j3 ldarg.1 call Boolean get_ShouldJump() brtrue.s j1 - -j7: ldarg.0 ldarg.1 call Segment[17::31] @@ -30,7 +28,7 @@ ldarg.1 call Boolean get_ShouldJump() brtrue.s j1 -j8: +j7: ldarg.0 ldfld Nethermind.Evm.EvmState EvmState call Boolean get_IsStatic() @@ -77,11 +75,8 @@ ldloc.0 ldc.i4.s 11 beq.s j6 ldloc.0 -ldc.i4.s 17 -beq.s j7 -ldloc.0 ldc.i4.s 32 -beq.s j8 +beq.s j7 br.s InvalidJumpDestination StaticCallViolation: diff --git a/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=FibbBytecode_number=5_result=8.verified.txt b/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=FibbBytecode_number=5_result=8.verified.txt index 2e74095c61e..b7881b10ce7 100644 --- a/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=FibbBytecode_number=5_result=8.verified.txt +++ b/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=FibbBytecode_number=5_result=8.verified.txt @@ -20,8 +20,6 @@ brtrue.s j3 ldarg.1 call Boolean get_ShouldJump() brtrue.s j1 - -j7: ldarg.0 ldarg.1 call Segment[17::31] @@ -30,7 +28,7 @@ ldarg.1 call Boolean get_ShouldJump() brtrue.s j1 -j8: +j7: ldarg.0 ldfld Nethermind.Evm.EvmState EvmState call Boolean get_IsStatic() @@ -77,11 +75,8 @@ ldloc.0 ldc.i4.s 11 beq.s j6 ldloc.0 -ldc.i4.s 17 -beq.s j7 -ldloc.0 ldc.i4.s 32 -beq.s j8 +beq.s j7 br.s InvalidJumpDestination StaticCallViolation: diff --git a/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=PrimBytecode_number=40001263_result=1.verified.txt b/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=PrimBytecode_number=40001263_result=1.verified.txt index 2e74095c61e..b7881b10ce7 100644 --- a/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=PrimBytecode_number=40001263_result=1.verified.txt +++ b/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=PrimBytecode_number=40001263_result=1.verified.txt @@ -20,8 +20,6 @@ brtrue.s j3 ldarg.1 call Boolean get_ShouldJump() brtrue.s j1 - -j7: ldarg.0 ldarg.1 call Segment[17::31] @@ -30,7 +28,7 @@ ldarg.1 call Boolean get_ShouldJump() brtrue.s j1 -j8: +j7: ldarg.0 ldfld Nethermind.Evm.EvmState EvmState call Boolean get_IsStatic() @@ -77,11 +75,8 @@ ldloc.0 ldc.i4.s 11 beq.s j6 ldloc.0 -ldc.i4.s 17 -beq.s j7 -ldloc.0 ldc.i4.s 32 -beq.s j8 +beq.s j7 br.s InvalidJumpDestination StaticCallViolation: diff --git a/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=PrimBytecode_number=8000010_result=0.verified.txt b/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=PrimBytecode_number=8000010_result=0.verified.txt index 2e74095c61e..b7881b10ce7 100644 --- a/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=PrimBytecode_number=8000010_result=0.verified.txt +++ b/src/Nethermind/Nethermind.Evm.Test/ILEVM/SyntheticTest.Verify_useIlEvm=True_benchmarkName=PrimBytecode_number=8000010_result=0.verified.txt @@ -20,8 +20,6 @@ brtrue.s j3 ldarg.1 call Boolean get_ShouldJump() brtrue.s j1 - -j7: ldarg.0 ldarg.1 call Segment[17::31] @@ -30,7 +28,7 @@ ldarg.1 call Boolean get_ShouldJump() brtrue.s j1 -j8: +j7: ldarg.0 ldfld Nethermind.Evm.EvmState EvmState call Boolean get_IsStatic() @@ -77,11 +75,8 @@ ldloc.0 ldc.i4.s 11 beq.s j6 ldloc.0 -ldc.i4.s 17 -beq.s j7 -ldloc.0 ldc.i4.s 32 -beq.s j8 +beq.s j7 br.s InvalidJumpDestination StaticCallViolation: diff --git a/src/Nethermind/Nethermind.Evm.Test/ILEVM/USDCProxyTests.Verify_useIlEvm=True.verified.txt b/src/Nethermind/Nethermind.Evm.Test/ILEVM/USDCProxyTests.Verify_useIlEvm=True.verified.txt index eb84eb0d19a..b7881b10ce7 100644 --- a/src/Nethermind/Nethermind.Evm.Test/ILEVM/USDCProxyTests.Verify_useIlEvm=True.verified.txt +++ b/src/Nethermind/Nethermind.Evm.Test/ILEVM/USDCProxyTests.Verify_useIlEvm=True.verified.txt @@ -2,966 +2,42 @@ ldobj Nethermind.Evm.CodeAnalysis.IL.ILChunkExecutionState ldfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState ldc.i4.2 -beq j2 +beq.s j2 j4: j5: ldarg.0 ldarg.1 -call Segment[0::12] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j6: -ldarg.0 -ldarg.1 -call Segment[13::64] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j7: -ldarg.0 -ldarg.1 -call Segment[65::75] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j8: -ldarg.0 -ldarg.1 -call Segment[76::86] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j9: -ldarg.0 -ldarg.1 -call Segment[87::97] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j10: -ldarg.0 -ldarg.1 -call Segment[98::108] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j11: -ldarg.0 -ldarg.1 -call Segment[109::116] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j12: -ldarg.0 -ldarg.1 -call Segment[117::118] -brtrue j3 - -j13: -ldarg.0 -ldarg.1 -call Segment[119::126] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j14: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j15 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j15: -ldarg.0 -ldarg.1 -call Segment[127::130] -brtrue j3 - -j17: -ldarg.0 -ldarg.1 -call Segment[131::183] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j18: -ldarg.0 -ldarg.1 -call Segment[184::185] -brtrue j3 - -j19: -ldarg.0 -ldarg.1 -call Segment[186::261] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j20: -ldarg.0 -ldarg.1 -call Segment[262::263] -brtrue j3 - -j21: -ldarg.0 -ldarg.1 -call Segment[264::271] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j22: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j23 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j23: -ldarg.0 -ldarg.1 -call Segment[272::275] -brtrue j3 - -j25: -ldarg.0 -ldarg.1 -call Segment[276::284] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j26: -ldarg.0 -ldarg.1 -call Segment[285::350] -brtrue j3 - -j27: -ldarg.0 -ldarg.1 -call Segment[351::358] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j28: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j29 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j29: -ldarg.0 -ldarg.1 -call Segment[359::362] -brtrue j3 - -j31: -ldarg.0 -ldarg.1 -call Segment[363::415] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j32: -ldarg.0 -ldarg.1 -call Segment[416::417] -brtrue j3 - -j33: -ldarg.0 -ldarg.1 -call Segment[418::425] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j34: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j35 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j35: -ldarg.0 -ldarg.1 -call Segment[426::429] -brtrue j3 - -j37: -ldarg.0 -ldarg.1 -call Segment[430::438] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j38: -ldarg.0 -ldarg.1 -call Segment[439::504] -brtrue j3 - -j39: -ldarg.0 -ldarg.1 -call Segment[505::512] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j40: -ldarg.0 -ldarg.1 -call Segment[513::523] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j41: -ldarg.0 -ldarg.1 -call Segment[524::528] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j42: -ldarg.0 -ldarg.1 -call Segment[529::530] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j43: -ldarg.0 -ldarg.1 -call Segment[531::538] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j44: -ldarg.0 -ldarg.1 -call Segment[539::590] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j45: -ldarg.0 -ldarg.1 -call Segment[591::598] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j46: -ldarg.0 -ldarg.1 -call Segment[599::603] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j47: -ldarg.0 -ldarg.1 -call Segment[604::611] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j48: -ldarg.0 -ldarg.1 -call Segment[612::612] -brtrue j3 - -j49: -ldarg.0 -ldarg.1 -call Segment[613::615] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j50: -ldarg.0 -ldarg.1 -call Segment[616::623] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j51: -ldarg.0 -ldarg.1 -call Segment[624::675] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j52: -ldarg.0 -ldarg.1 -call Segment[676::683] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j53: -ldarg.0 -ldarg.1 -call Segment[684::742] -brtrue j3 -ldarg.1 -call Boolean get_ShouldHalt() -brtrue j3 - -j54: - -j55: -ldarg.0 -ldarg.1 -call Segment[743::752] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j56: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j57 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j57: -ldarg.0 -ldarg.1 -call Segment[753::756] -brtrue j3 - -j59: -ldarg.0 -ldarg.1 -call Segment[757::761] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j60: -ldarg.0 -ldarg.1 -call Segment[762::769] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j61: -ldarg.0 -ldarg.1 -call Segment[770::770] -brtrue j3 - -j62: -ldarg.0 -ldarg.1 -call Segment[771::775] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j63: -ldarg.0 -ldarg.1 -call Segment[776::785] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j64: -ldarg.0 -ldarg.1 -call Segment[786::837] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j65: -ldarg.0 -ldarg.1 -call Segment[838::844] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j66: -ldarg.0 -ldarg.1 -call Segment[845::851] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j67: -ldarg.0 -ldarg.1 -call Segment[852::859] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j68: -ldarg.0 -ldarg.1 -call Segment[860::860] -brtrue j3 - -j69: -ldarg.0 -ldarg.1 -call Segment[861::863] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j70: -ldarg.0 -ldarg.1 -call Segment[864::871] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j71: -ldarg.0 -ldarg.1 -call Segment[872::923] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j72: -ldarg.0 -ldarg.1 -call Segment[924::978] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j73: -ldloca.s 54 -call Boolean get_HasValue() -brtrue.s j74 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 54 - -j74: -ldarg.0 -ldarg.1 -call Segment[979::1125] -brtrue j3 - -j76: -ldarg.0 -ldarg.1 -call Segment[1126::1166] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j77: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation -ldarg.0 -ldarg.1 -call Segment[1167::1292] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j78: -ldarg.0 -ldarg.1 -call Segment[1293::1297] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j79: -ldarg.0 -ldarg.1 -call Segment[1298::1305] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j80: -ldarg.0 -ldarg.1 -call Segment[1306::1306] -brtrue j3 - -j81: -ldarg.0 -ldarg.1 -call Segment[1307::1309] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j82: -ldarg.0 -ldarg.1 -call Segment[1310::1319] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j83: -ldarg.0 -ldarg.1 -call Segment[1320::1371] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j84: -ldarg.0 -ldarg.1 -call Segment[1372::1378] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j85: -ldarg.0 -ldarg.1 -call Segment[1379::1385] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j86: -ldarg.0 -ldarg.1 -call Segment[1386::1393] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j87: -ldarg.0 -ldarg.1 -call Segment[1394::1394] -brtrue j3 - -j88: -ldarg.0 -ldarg.1 -call Segment[1395::1397] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j89: -ldarg.0 -ldarg.1 -call Segment[1398::1405] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j90: -ldarg.0 -ldarg.1 -call Segment[1406::1459] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j91: -ldloca.s 54 -call Boolean get_HasValue() -brtrue.s j92 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 54 - -j92: -ldarg.0 -ldarg.1 -call Segment[1460::1606] -brtrue j3 - -j94: -ldarg.0 -ldarg.1 -call Segment[1607::1614] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j95: -ldarg.0 -ldarg.1 -call Segment[1615::1616] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j96: -ldarg.0 -ldarg.1 -call Segment[1617::1665] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j97: -ldloca.s 58 -call Boolean get_HasValue() -brtrue.s j98 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 244 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 58 - -j98: -ldarg.0 -ldarg.1 -call Segment[1666::1680] -brtrue j3 -ldarg.1 -call Boolean get_ShouldHalt() -brtrue j3 - -j100: - -j101: -ldloca.s 59 -call Boolean get_HasValue() -brtrue.s j102 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4.s 61 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4.s 62 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 59 - -j102: -ldarg.0 -ldarg.1 -call Segment[1681::1694] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j104: -ldloca.s 60 -call Boolean get_HasValue() -brtrue.s j105 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4.s 61 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 60 - -j105: -ldarg.0 -ldarg.1 -call Segment[1695::1698] -brtrue j3 - -j107: -ldloca.s 61 -call Boolean get_HasValue() -brtrue.s j108 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4.s 61 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 61 - -j108: -ldarg.0 -ldarg.1 -call Segment[1699::1703] -brtrue j3 - -j110: -ldarg.0 -ldarg.1 -call Segment[1704::1752] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j111: -ldarg.0 -ldarg.1 -call Segment[1753::1761] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j112: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation -ldarg.0 -ldarg.1 -call Segment[1762::1863] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j113: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation -ldarg.0 -ldarg.1 -call Segment[1864::1910] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j114: -ldarg.0 -ldarg.1 -call Segment[1911::1912] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j115: -ldarg.0 -ldarg.1 -call Segment[1913::1923] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 +call Segment[0::10] +brtrue.s j3 -j116: +j6: ldarg.0 ldarg.1 -call Segment[1924::1930] -brtrue j3 +call Segment[11::16] +brtrue.s j3 ldarg.1 call Boolean get_ShouldJump() -brtrue j1 - -j117: -ldloca.s 54 -call Boolean get_HasValue() -brtrue.s j118 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 54 - -j118: -ldarg.0 -ldarg.1 -call Segment[1931::2077] -brtrue.s j3 - -j120: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation +brtrue.s j1 ldarg.0 ldarg.1 -call Segment[2078::2122] +call Segment[17::31] brtrue.s j3 ldarg.1 call Boolean get_ShouldJump() brtrue.s j1 -j121: +j7: +ldarg.0 +ldfld Nethermind.Evm.EvmState EvmState +call Boolean get_IsStatic() +brtrue.s StaticCallViolation ldarg.0 ldarg.1 -call Segment[2123::2141] +call Segment[32::39] brtrue.s j3 ldarg.1 -call Boolean get_ShouldJump() -brtrue.s j1 -ldarg.1 ldc.i4.4 stfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState @@ -981,694 +57,28 @@ ldarg.1 ldc.i4.1 stfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState ldloc.0 -ldc.i4 2186 +ldc.i4.s 40 bge.s j3 ldloc.0 ldc.i4.0 -beq j4 -ldloc.0 -ldc.i4 743 -beq j54 -ldloc.0 -ldc.i4 1681 -beq j100 -br InvalidJumpDestination +beq.s j4 +br.s InvalidJumpDestination j1: ldarg.1 ldfld Int32 JumpDestination stloc.0 ldloc.0 -ldc.i4.s 127 -and -switch j122, j123, j124, j125, j126, j127, j128, j129, j130, j131, j132, j133, j134, j135, j136, j137, j138, j139, j140, j141, j142, j143, j144, j145, j146, j147, j148, j149, j150, j151, j152, j153, j154, j155, j156, j157, j158, j159, j160, j161, j162, j163, j164, j165, j166, j167, j168, j169, j170, j171, j172, j173, j174, j175, j176, j177, j178, j179, j180, j181, j182, j183, j184, j185, j186, j187, j188, j189, j190, j191, j192, j193, j194, j195, j196, j197, j198, j199, j200, j201, j202, j203, j204, j205, j206, j207, j208, j209, j210, j211, j212, j213, j214, j215, j216, j217, j218, j219, j220, j221, j222, j223, j224, j225, j226, j227, j228, j229, j230, j231, j232, j233, j234, j235, j236, j237, j238, j239, j240, j241, j242, j243, j244, j245, j246, j247, j248, j249 - -j122: -ldloc.0 ldc.i4.0 -beq j5 -br InvalidJumpDestination - -j123: -ldloc.0 -ldc.i4 513 -beq j40 -br InvalidJumpDestination - -j124: -ldloc.0 -ldc.i4 770 -beq j61 -ldloc.0 -ldc.i4 1666 -beq j97 -br InvalidJumpDestination - -j125: -ldloc.0 -ldc.i4 131 -beq j17 -ldloc.0 -ldc.i4 771 -beq j62 -br InvalidJumpDestination - -j126: -ldloc.0 -ldc.i4 1924 -beq j116 -br InvalidJumpDestination - -j127: -br InvalidJumpDestination - -j128: -ldloc.0 -ldc.i4 262 -beq j20 -br InvalidJumpDestination - -j129: -br InvalidJumpDestination - -j130: -ldloc.0 -ldc.i4 264 -beq j21 -ldloc.0 -ldc.i4 776 -beq j63 -br InvalidJumpDestination - -j131: -br InvalidJumpDestination - -j132: -br InvalidJumpDestination - -j133: -ldloc.0 -ldc.i4 1931 -beq j117 -br InvalidJumpDestination - -j134: -ldloc.0 -ldc.i4 524 -beq j41 -br InvalidJumpDestination - -j135: -ldloc.0 -ldc.i4.s 13 -beq j6 -ldloc.0 -ldc.i4 1293 -beq j78 -br InvalidJumpDestination - -j136: -br InvalidJumpDestination - -j137: -ldloc.0 -ldc.i4 1167 -beq j77 -br InvalidJumpDestination - -j138: -ldloc.0 -ldc.i4 272 -beq j22 -br InvalidJumpDestination - -j139: -ldloc.0 -ldc.i4 529 -beq j42 -ldloc.0 -ldc.i4 1681 -beq j101 -br InvalidJumpDestination - -j140: -ldloc.0 -ldc.i4 786 -beq j64 -ldloc.0 -ldc.i4 1298 -beq j79 -br InvalidJumpDestination - -j141: -ldloc.0 -ldc.i4 531 -beq j43 -br InvalidJumpDestination - -j142: -ldloc.0 -ldc.i4 276 -beq j25 -br InvalidJumpDestination - -j143: -br InvalidJumpDestination - -j144: -br InvalidJumpDestination - -j145: -br InvalidJumpDestination - -j146: -br InvalidJumpDestination - -j147: -br InvalidJumpDestination - -j148: -ldloc.0 -ldc.i4 1306 -beq j80 -br InvalidJumpDestination - -j149: -ldloc.0 -ldc.i4 539 -beq j44 -ldloc.0 -ldc.i4 1307 -beq j81 -br InvalidJumpDestination - -j150: -ldloc.0 -ldc.i4 924 -beq j72 -br InvalidJumpDestination - -j151: -ldloc.0 -ldc.i4 285 -beq j26 -br InvalidJumpDestination - -j152: -ldloc.0 -ldc.i4 1310 -beq j82 -ldloc.0 -ldc.i4 2078 -beq j120 -br InvalidJumpDestination - -j153: -ldloc.0 -ldc.i4 1695 -beq j104 -br InvalidJumpDestination - -j154: -ldloc.0 -ldc.i4 416 -beq j32 -br InvalidJumpDestination - -j155: -br InvalidJumpDestination - -j156: -ldloc.0 -ldc.i4 418 -beq j33 -br InvalidJumpDestination - -j157: -ldloc.0 -ldc.i4 1699 -beq j107 -br InvalidJumpDestination - -j158: -ldloc.0 -ldc.i4 676 -beq j52 -br InvalidJumpDestination - -j159: -br InvalidJumpDestination - -j160: -br InvalidJumpDestination - -j161: -br InvalidJumpDestination - -j162: -ldloc.0 -ldc.i4 1320 -beq j83 -ldloc.0 -ldc.i4 1704 -beq j110 -br InvalidJumpDestination - -j163: -br InvalidJumpDestination - -j164: -ldloc.0 -ldc.i4 426 -beq j34 -br InvalidJumpDestination - -j165: -br InvalidJumpDestination - -j166: -ldloc.0 -ldc.i4 684 -beq j53 -br InvalidJumpDestination - -j167: -br InvalidJumpDestination - -j168: -ldloc.0 -ldc.i4 430 -beq j37 -br InvalidJumpDestination - -j169: -br InvalidJumpDestination - -j170: -br InvalidJumpDestination - -j171: -br InvalidJumpDestination - -j172: -br InvalidJumpDestination - -j173: -br InvalidJumpDestination - -j174: -ldloc.0 -ldc.i4 1460 -beq j91 -br InvalidJumpDestination - -j175: -br InvalidJumpDestination - -j176: -br InvalidJumpDestination - -j177: -ldloc.0 -ldc.i4 439 -beq j38 -br InvalidJumpDestination - -j178: -ldloc.0 -ldc.i4 184 -beq j18 -br InvalidJumpDestination - -j179: -br InvalidJumpDestination - -j180: -ldloc.0 -ldc.i4 186 -beq j19 -br InvalidJumpDestination - -j181: -br InvalidJumpDestination - -j182: -br InvalidJumpDestination - -j183: -br InvalidJumpDestination - -j184: -br InvalidJumpDestination - -j185: -br InvalidJumpDestination - -j186: -br InvalidJumpDestination - -j187: -ldloc.0 -ldc.i4.s 65 -beq j7 -br InvalidJumpDestination - -j188: -br InvalidJumpDestination - -j189: -br InvalidJumpDestination - -j190: -br InvalidJumpDestination - -j191: -br InvalidJumpDestination - -j192: -ldloc.0 -ldc.i4 838 -beq j65 -br InvalidJumpDestination - -j193: -ldloc.0 -ldc.i4 1607 -beq j94 -br InvalidJumpDestination - -j194: -ldloc.0 -ldc.i4 1864 -beq j113 -br InvalidJumpDestination - -j195: -br InvalidJumpDestination - -j196: -br InvalidJumpDestination - -j197: -ldloc.0 -ldc.i4 2123 -beq j121 -br InvalidJumpDestination - -j198: -ldloc.0 -ldc.i4.s 76 -beq j8 -br InvalidJumpDestination - -j199: -ldloc.0 -ldc.i4 845 -beq j66 -br InvalidJumpDestination - -j200: -br InvalidJumpDestination - -j201: -ldloc.0 -ldc.i4 591 -beq j45 -ldloc.0 -ldc.i4 1615 -beq j95 -br InvalidJumpDestination - -j202: -br InvalidJumpDestination - -j203: -ldloc.0 -ldc.i4 1617 -beq j96 -br InvalidJumpDestination - -j204: -br InvalidJumpDestination - -j205: -ldloc.0 -ldc.i4 979 -beq j73 -br InvalidJumpDestination - -j206: -ldloc.0 -ldc.i4 852 -beq j67 -br InvalidJumpDestination - -j207: -br InvalidJumpDestination - -j208: -br InvalidJumpDestination - -j209: -ldloc.0 -ldc.i4.s 87 -beq j9 -ldloc.0 -ldc.i4 599 -beq j46 -br InvalidJumpDestination - -j210: -br InvalidJumpDestination - -j211: -ldloc.0 -ldc.i4 1753 -beq j111 -br InvalidJumpDestination - -j212: -br InvalidJumpDestination - -j213: -br InvalidJumpDestination - -j214: -ldloc.0 -ldc.i4 604 -beq j47 -ldloc.0 -ldc.i4 860 -beq j68 -ldloc.0 -ldc.i4 1372 -beq j84 -br InvalidJumpDestination - -j215: -ldloc.0 -ldc.i4 861 -beq j69 -br InvalidJumpDestination - -j216: -br InvalidJumpDestination - -j217: -ldloc.0 -ldc.i4 351 -beq j27 -br InvalidJumpDestination - -j218: -ldloc.0 -ldc.i4 864 -beq j70 -br InvalidJumpDestination - -j219: -br InvalidJumpDestination - -j220: -ldloc.0 -ldc.i4.s 98 -beq j10 -ldloc.0 -ldc.i4 1762 -beq j112 -br InvalidJumpDestination - -j221: -ldloc.0 -ldc.i4 1379 -beq j85 -br InvalidJumpDestination - -j222: +beq.s j5 ldloc.0 -ldc.i4 612 -beq j48 -br InvalidJumpDestination - -j223: -ldloc.0 -ldc.i4 613 -beq j49 -br InvalidJumpDestination - -j224: -ldloc.0 -ldc.i4 1126 -beq j76 -br InvalidJumpDestination - -j225: -ldloc.0 -ldc.i4 359 -beq j28 -ldloc.0 -ldc.i4 743 -beq j55 -br InvalidJumpDestination - -j226: -ldloc.0 -ldc.i4 616 -beq j50 -ldloc.0 -ldc.i4 872 -beq j71 -br InvalidJumpDestination - -j227: -br InvalidJumpDestination - -j228: -ldloc.0 -ldc.i4 1386 -beq j86 -br InvalidJumpDestination - -j229: -ldloc.0 -ldc.i4 363 -beq j31 -br InvalidJumpDestination - -j230: -br InvalidJumpDestination - -j231: -ldloc.0 -ldc.i4.s 109 -beq j11 -br InvalidJumpDestination - -j232: -br InvalidJumpDestination - -j233: -br InvalidJumpDestination - -j234: -ldloc.0 -ldc.i4 624 -beq j51 -br InvalidJumpDestination - -j235: -ldloc.0 -ldc.i4 753 -beq j56 -br InvalidJumpDestination - -j236: -ldloc.0 -ldc.i4 1394 -beq j87 -br InvalidJumpDestination - -j237: -ldloc.0 -ldc.i4 1395 -beq j88 -br InvalidJumpDestination - -j238: -br InvalidJumpDestination - -j239: -ldloc.0 -ldc.i4.s 117 -beq j12 -ldloc.0 -ldc.i4 757 -beq j59 -br InvalidJumpDestination - -j240: -ldloc.0 -ldc.i4 1398 -beq j89 -br InvalidJumpDestination - -j241: -ldloc.0 -ldc.i4.s 119 -beq j13 -ldloc.0 -ldc.i4 1911 -beq j114 -br InvalidJumpDestination - -j242: -br.s InvalidJumpDestination - -j243: -ldloc.0 -ldc.i4 505 -beq j39 -ldloc.0 -ldc.i4 1913 -beq j115 -br.s InvalidJumpDestination - -j244: -ldloc.0 -ldc.i4 762 -beq j60 -br.s InvalidJumpDestination - -j245: -br.s InvalidJumpDestination - -j246: -br.s InvalidJumpDestination - -j247: -br.s InvalidJumpDestination - -j248: -ldloc.0 -ldc.i4 1406 -beq j90 -br.s InvalidJumpDestination - -j249: +ldc.i4.s 11 +beq.s j6 ldloc.0 -ldc.i4.s 127 -beq j14 +ldc.i4.s 32 +beq.s j7 br.s InvalidJumpDestination -BadInstruction: -ldarg.1 -dup -ldc.i4.1 -stfld Nethermind.Evm.EvmExceptionType ExceptionType -ldc.i4.8 -stfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState -br j3 - StaticCallViolation: ldarg.1 dup @@ -1676,7 +86,7 @@ ldc.i4.s 11 stfld Nethermind.Evm.EvmExceptionType ExceptionType ldc.i4.8 stfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState -br j3 +br.s j3 InvalidJumpDestination: ldarg.1 @@ -1685,4 +95,4 @@ ldc.i4.8 stfld Nethermind.Evm.EvmExceptionType ExceptionType ldc.i4.8 stfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState -br j3 +br.s j3 diff --git a/src/Nethermind/Nethermind.Evm.Test/ILEVM/WrappedEthTests.Verify_useIlEvm=True.verified.txt b/src/Nethermind/Nethermind.Evm.Test/ILEVM/WrappedEthTests.Verify_useIlEvm=True.verified.txt index 2d948384abe..b7881b10ce7 100644 --- a/src/Nethermind/Nethermind.Evm.Test/ILEVM/WrappedEthTests.Verify_useIlEvm=True.verified.txt +++ b/src/Nethermind/Nethermind.Evm.Test/ILEVM/WrappedEthTests.Verify_useIlEvm=True.verified.txt @@ -2,1107 +2,40 @@ ldobj Nethermind.Evm.CodeAnalysis.IL.ILChunkExecutionState ldfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState ldc.i4.2 -beq j2 +beq.s j2 j4: j5: ldarg.0 ldarg.1 -call Segment[0::12] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 +call Segment[0::10] +brtrue.s j3 j6: ldarg.0 ldarg.1 -call Segment[13::64] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j7: -ldarg.0 -ldarg.1 -call Segment[65::75] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j8: -ldarg.0 -ldarg.1 -call Segment[76::86] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j9: -ldarg.0 -ldarg.1 -call Segment[87::97] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j10: -ldarg.0 -ldarg.1 -call Segment[98::108] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j11: -ldarg.0 -ldarg.1 -call Segment[109::119] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j12: -ldarg.0 -ldarg.1 -call Segment[120::130] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j13: -ldarg.0 -ldarg.1 -call Segment[131::141] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j14: -ldarg.0 -ldarg.1 -call Segment[142::152] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j15: -ldarg.0 -ldarg.1 -call Segment[153::163] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j16: -ldarg.0 -ldarg.1 -call Segment[164::174] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j17: -ldarg.0 -ldarg.1 -call Segment[175::182] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j18: -ldarg.0 -ldarg.1 -call Segment[183::184] -brtrue j3 - -j19: -ldarg.0 -ldarg.1 -call Segment[185::191] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j20: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j21 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j21: -ldarg.0 -ldarg.1 -call Segment[192::195] -brtrue j3 - -j23: -ldarg.0 -ldarg.1 -call Segment[196::203] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j24: -ldarg.0 -ldarg.1 -call Segment[204::240] -brtrue j3 - -j25: -ldarg.0 -ldarg.1 -call Segment[241::249] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j26: -ldarg.0 -ldarg.1 -call Segment[250::267] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j27: -ldarg.0 -ldarg.1 -call Segment[268::287] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j28: -ldarg.0 -ldarg.1 -call Segment[288::312] -brtrue j3 - -j29: -ldarg.0 -ldarg.1 -call Segment[313::326] -brtrue j3 - -j30: -ldarg.0 -ldarg.1 -call Segment[327::333] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j31: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j32 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j32: -ldarg.0 -ldarg.1 -call Segment[334::337] -brtrue j3 - -j34: -ldarg.0 -ldarg.1 -call Segment[338::390] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j35: -ldarg.0 -ldarg.1 -call Segment[391::416] -brtrue j3 - -j36: -ldarg.0 -ldarg.1 -call Segment[417::423] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j37: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j38 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j38: -ldarg.0 -ldarg.1 -call Segment[424::427] -brtrue j3 - -j40: -ldarg.0 -ldarg.1 -call Segment[428::435] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j41: -ldarg.0 -ldarg.1 -call Segment[436::457] -brtrue j3 - -j42: -ldarg.0 -ldarg.1 -call Segment[458::464] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j43: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j44 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j44: -ldarg.0 -ldarg.1 -call Segment[465::468] -brtrue j3 - -j46: -ldarg.0 -ldarg.1 -call Segment[469::552] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j47: -ldarg.0 -ldarg.1 -call Segment[553::578] -brtrue j3 - -j48: -ldarg.0 -ldarg.1 -call Segment[579::585] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j49: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j50 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j50: -ldarg.0 -ldarg.1 -call Segment[586::589] -brtrue j3 - -j52: -ldarg.0 -ldarg.1 -call Segment[590::611] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j53: -ldarg.0 -ldarg.1 -call Segment[612::613] -brtrue j3 - -j54: -ldarg.0 -ldarg.1 -call Segment[614::620] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j55: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j56 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j56: -ldarg.0 -ldarg.1 -call Segment[621::624] -brtrue j3 - -j58: -ldarg.0 -ldarg.1 -call Segment[625::632] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j59: -ldarg.0 -ldarg.1 -call Segment[633::660] -brtrue j3 - -j60: -ldarg.0 -ldarg.1 -call Segment[661::667] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j61: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j62 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j62: -ldarg.0 -ldarg.1 -call Segment[668::671] -brtrue j3 - -j64: -ldarg.0 -ldarg.1 -call Segment[672::715] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j65: -ldarg.0 -ldarg.1 -call Segment[716::737] -brtrue j3 - -j66: -ldarg.0 -ldarg.1 -call Segment[738::744] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j67: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j68 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j68: -ldarg.0 -ldarg.1 -call Segment[745::748] -brtrue j3 - -j70: -ldarg.0 -ldarg.1 -call Segment[749::756] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j71: -ldarg.0 -ldarg.1 -call Segment[757::793] -brtrue j3 - -j72: -ldarg.0 -ldarg.1 -call Segment[794::802] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j73: -ldarg.0 -ldarg.1 -call Segment[803::820] -brtrue j3 +call Segment[11::16] +brtrue.s j3 ldarg.1 call Boolean get_ShouldJump() -brtrue j1 - -j74: +brtrue.s j1 ldarg.0 ldarg.1 -call Segment[821::840] -brtrue j3 +call Segment[17::31] +brtrue.s j3 ldarg.1 call Boolean get_ShouldJump() -brtrue j1 - -j75: -ldarg.0 -ldarg.1 -call Segment[841::865] -brtrue j3 - -j76: -ldarg.0 -ldarg.1 -call Segment[866::879] -brtrue j3 - -j77: -ldarg.0 -ldarg.1 -call Segment[880::886] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j78: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j79 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j79: -ldarg.0 -ldarg.1 -call Segment[887::890] -brtrue j3 - -j81: -ldarg.0 -ldarg.1 -call Segment[891::943] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j82: -ldarg.0 -ldarg.1 -call Segment[944::969] -brtrue j3 - -j83: -ldarg.0 -ldarg.1 -call Segment[970::977] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j84: -ldarg.0 -ldarg.1 -call Segment[978::979] -brtrue j3 - -j85: -ldarg.0 -ldarg.1 -call Segment[980::986] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j86: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j87 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j87: -ldarg.0 -ldarg.1 -call Segment[987::990] -brtrue j3 - -j89: -ldarg.0 -ldarg.1 -call Segment[991::1065] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j90: -ldarg.0 -ldarg.1 -call Segment[1066::1087] -brtrue j3 - -j91: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation -ldarg.0 -ldarg.1 -call Segment[1088::1244] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j92: -ldarg.0 -ldarg.1 -call Segment[1245::1324] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j93: -ldarg.0 -ldarg.1 -call Segment[1325::1332] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j94: -ldarg.0 -ldarg.1 -call Segment[1333::1351] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j95: -ldarg.0 -ldarg.1 -call Segment[1352::1365] -brtrue j3 - -j96: -ldarg.0 -ldarg.1 -call Segment[1366::1385] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j97: -ldarg.0 -ldarg.1 -call Segment[1386::1394] -brtrue j3 - -j98: -ldarg.0 -ldarg.1 -call Segment[1395::1402] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j99: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation -ldarg.0 -ldarg.1 -call Segment[1403::1644] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j100: -ldarg.0 -ldarg.1 -call Segment[1645::1675] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j101: -ldarg.0 -ldarg.1 -call Segment[1676::1751] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j102: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j103 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j103: -ldarg.0 -ldarg.1 -call Segment[1752::1755] -brtrue j3 - -j105: -ldarg.0 -ldarg.1 -call Segment[1756::1810] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j106: -ldarg.0 -ldarg.1 -call Segment[1811::1971] -brtrue j3 - -j107: -ldarg.0 -ldarg.1 -call Segment[1972::1977] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j108: -ldarg.0 -ldarg.1 -call Segment[1978::2111] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j109: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j110 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j110: -ldarg.0 -ldarg.1 -call Segment[2112::2115] -brtrue j3 - -j112: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation -ldarg.0 -ldarg.1 -call Segment[2116::2254] -brtrue j3 - -j113: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation -ldarg.0 -ldarg.1 -call Segment[2255::2520] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j114: -ldarg.0 -ldarg.1 -call Segment[2521::2594] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j115: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j116 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j116: -ldarg.0 -ldarg.1 -call Segment[2595::2598] -brtrue j3 - -j118: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation -ldarg.0 -ldarg.1 -call Segment[2599::2724] -brtrue j3 -ldarg.1 -call Boolean get_ShouldHalt() -brtrue j3 - -j119: - -j120: -ldarg.0 -ldarg.1 -call Segment[2725::2735] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j121: -ldloca.s 36 -call Boolean get_HasValue() -brtrue.s j122 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 253 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 36 - -j122: -ldarg.0 -ldarg.1 -call Segment[2736::2739] -brtrue j3 - -j124: -ldarg.0 -ldfld Nethermind.Evm.EvmState EvmState -call Boolean get_IsStatic() -brtrue StaticCallViolation -ldarg.0 -ldarg.1 -call Segment[2740::2820] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j125: -ldarg.0 -ldarg.1 -call Segment[2821::2839] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j126: -ldarg.0 -ldarg.1 -call Segment[2840::2863] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j127: -ldarg.0 -ldarg.1 -call Segment[2864::2943] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j128: -ldarg.0 -ldarg.1 -call Segment[2944::2951] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j129: -ldarg.0 -ldarg.1 -call Segment[2952::2970] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j130: -ldarg.0 -ldarg.1 -call Segment[2971::2984] -brtrue j3 - -j131: -ldarg.0 -ldarg.1 -call Segment[2985::3004] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j132: -ldarg.0 -ldarg.1 -call Segment[3005::3013] -brtrue j3 - -j133: -ldarg.0 -ldarg.1 -call Segment[3014::3021] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j134: -ldarg.0 -ldarg.1 -call Segment[3022::3034] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j135: -ldarg.0 -ldarg.1 -call Segment[3035::3042] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j136: -ldarg.0 -ldarg.1 -call Segment[3043::3079] -brtrue j3 -ldarg.1 -call Boolean get_ShouldJump() -brtrue j1 - -j137: - -j138: -ldloca.s 74 -call Boolean get_HasValue() -brtrue.s j139 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 250 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 74 - -j139: -ldarg.0 -ldarg.1 -call Segment[3102::3111] -brtrue.s j3 -ldarg.1 -call Boolean get_ShouldHalt() -brtrue.s j3 - -j141: - -j142: -ldloca.s 75 -call Boolean get_HasValue() -brtrue.s j143 -ldarg.0 -ldfld Nethermind.Evm.VirtualMachine Vm -call Nethermind.Core.Specs.IReleaseSpec get_Spec() -ldc.i4 250 -call Boolean IsEnabled(Nethermind.Core.Specs.IReleaseSpec, Nethermind.Evm.Instruction) -brfalse BadInstruction -ldc.i4.1 -newobj Void .ctor(Boolean) -stloc.s 75 - -j143: -ldarg.0 -ldarg.1 -call Segment[3112::3112] -brtrue.s j3 -ldarg.1 -call Boolean get_ShouldHalt() -brtrue.s j3 - -j145: +brtrue.s j1 -j146: +j7: +ldarg.0 +ldfld Nethermind.Evm.EvmState EvmState +call Boolean get_IsStatic() +brtrue.s StaticCallViolation ldarg.0 ldarg.1 -call Segment[3113::3122] +call Segment[32::39] brtrue.s j3 ldarg.1 ldc.i4.4 @@ -1124,745 +57,28 @@ ldarg.1 ldc.i4.1 stfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState ldloc.0 -ldc.i4 3124 +ldc.i4.s 40 bge.s j3 ldloc.0 ldc.i4.0 -beq j4 -ldloc.0 -ldc.i4 2725 -beq j119 -ldloc.0 -ldc.i4 3102 -beq j137 -ldloc.0 -ldc.i4 3112 -beq j141 -ldloc.0 -ldc.i4 3113 -beq.s j145 -br InvalidJumpDestination +beq.s j4 +br.s InvalidJumpDestination j1: ldarg.1 ldfld Int32 JumpDestination stloc.0 ldloc.0 -ldc.i4.s 127 -and -switch j147, j148, j149, j150, j151, j152, j153, j154, j155, j156, j157, j158, j159, j160, j161, j162, j163, j164, j165, j166, j167, j168, j169, j170, j171, j172, j173, j174, j175, j176, j177, j178, j179, j180, j181, j182, j183, j184, j185, j186, j187, j188, j189, j190, j191, j192, j193, j194, j195, j196, j197, j198, j199, j200, j201, j202, j203, j204, j205, j206, j207, j208, j209, j210, j211, j212, j213, j214, j215, j216, j217, j218, j219, j220, j221, j222, j223, j224, j225, j226, j227, j228, j229, j230, j231, j232, j233, j234, j235, j236, j237, j238, j239, j240, j241, j242, j243, j244, j245, j246, j247, j248, j249, j250, j251, j252, j253, j254, j255, j256, j257, j258, j259, j260, j261, j262, j263, j264, j265, j266, j267, j268, j269, j270, j271, j272, j273, j274 - -j147: -ldloc.0 ldc.i4.0 -beq j5 -ldloc.0 -ldc.i4 2944 -beq j128 -br InvalidJumpDestination - -j148: -br InvalidJumpDestination - -j149: -br InvalidJumpDestination - -j150: -ldloc.0 -ldc.i4 131 -beq j13 -br InvalidJumpDestination - -j151: -br InvalidJumpDestination - -j152: -ldloc.0 -ldc.i4 2821 -beq j125 -br InvalidJumpDestination - -j153: -br InvalidJumpDestination - -j154: -ldloc.0 -ldc.i4 391 -beq j35 -br InvalidJumpDestination - -j155: -ldloc.0 -ldc.i4 2952 -beq j129 -br InvalidJumpDestination - -j156: -br InvalidJumpDestination - -j157: -br InvalidJumpDestination - -j158: -br InvalidJumpDestination - -j159: -ldloc.0 -ldc.i4 268 -beq j27 -ldloc.0 -ldc.i4 1676 -beq j101 -br InvalidJumpDestination - -j160: -ldloc.0 -ldc.i4.s 13 -beq j6 -br InvalidJumpDestination - -j161: -ldloc.0 -ldc.i4 142 -beq j14 -br InvalidJumpDestination - -j162: -br InvalidJumpDestination - -j163: -br InvalidJumpDestination - -j164: -br InvalidJumpDestination - -j165: -br InvalidJumpDestination - -j166: -ldloc.0 -ldc.i4 1811 -beq j106 -br InvalidJumpDestination - -j167: -br InvalidJumpDestination - -j168: -ldloc.0 -ldc.i4 661 -beq j60 -br InvalidJumpDestination - -j169: -br InvalidJumpDestination - -j170: -br InvalidJumpDestination - -j171: -ldloc.0 -ldc.i4 2840 -beq j126 -br InvalidJumpDestination - -j172: -ldloc.0 -ldc.i4 153 -beq j15 -br InvalidJumpDestination - -j173: -ldloc.0 -ldc.i4 794 -beq j72 -br InvalidJumpDestination - -j174: -ldloc.0 -ldc.i4 2971 -beq j130 -br InvalidJumpDestination - -j175: -ldloc.0 -ldc.i4 668 -beq j61 -br InvalidJumpDestination - -j176: -br InvalidJumpDestination - -j177: -ldloc.0 -ldc.i4 3102 -beq j138 -br InvalidJumpDestination - -j178: -br InvalidJumpDestination - -j179: -ldloc.0 -ldc.i4 288 -beq j28 -ldloc.0 -ldc.i4 672 -beq j64 -br InvalidJumpDestination - -j180: -ldloc.0 -ldc.i4 417 -beq j36 -br InvalidJumpDestination - -j181: -br InvalidJumpDestination - -j182: -ldloc.0 -ldc.i4 803 -beq j73 -ldloc.0 -ldc.i4 2595 -beq j115 -br InvalidJumpDestination - -j183: -ldloc.0 -ldc.i4 164 -beq j16 -br InvalidJumpDestination - -j184: -ldloc.0 -ldc.i4 2725 -beq j120 -br InvalidJumpDestination - -j185: -br InvalidJumpDestination - -j186: -ldloc.0 -ldc.i4 2599 -beq j118 -br InvalidJumpDestination - -j187: -ldloc.0 -ldc.i4 424 -beq j37 -ldloc.0 -ldc.i4 3112 -beq j142 -br InvalidJumpDestination - -j188: -ldloc.0 -ldc.i4 553 -beq j47 -ldloc.0 -ldc.i4 2985 -beq j131 -ldloc.0 -ldc.i4 3113 -beq j146 -br InvalidJumpDestination - -j189: -ldloc.0 -ldc.i4 1066 -beq j90 -br InvalidJumpDestination - -j190: -br InvalidJumpDestination - -j191: -ldloc.0 -ldc.i4 428 -beq j40 -br InvalidJumpDestination - -j192: -ldloc.0 -ldc.i4 1325 -beq j93 -br InvalidJumpDestination - -j193: -br InvalidJumpDestination - -j194: -ldloc.0 -ldc.i4 175 -beq j17 -br InvalidJumpDestination - -j195: -ldloc.0 -ldc.i4 944 -beq j82 -ldloc.0 -ldc.i4 2736 -beq j121 -ldloc.0 -ldc.i4 2864 -beq j127 -br InvalidJumpDestination - -j196: -br InvalidJumpDestination - -j197: -br InvalidJumpDestination - -j198: -br InvalidJumpDestination - -j199: -ldloc.0 -ldc.i4 436 -beq j41 -ldloc.0 -ldc.i4 1972 -beq j107 -ldloc.0 -ldc.i4 2740 -beq j124 -br InvalidJumpDestination - -j200: -ldloc.0 -ldc.i4 821 -beq j74 -ldloc.0 -ldc.i4 1333 -beq j94 -br InvalidJumpDestination - -j201: -br InvalidJumpDestination - -j202: -ldloc.0 -ldc.i4 183 -beq j18 -br InvalidJumpDestination - -j203: -br InvalidJumpDestination - -j204: -ldloc.0 -ldc.i4 185 -beq j19 -ldloc.0 -ldc.i4 313 -beq j29 -br InvalidJumpDestination - -j205: -ldloc.0 -ldc.i4 1978 -beq j108 -br InvalidJumpDestination - -j206: -br InvalidJumpDestination - -j207: -br InvalidJumpDestination - -j208: -ldloc.0 -ldc.i4 3005 -beq j132 -br InvalidJumpDestination - -j209: -br InvalidJumpDestination - -j210: -br InvalidJumpDestination - -j211: -ldloc.0 -ldc.i4 192 -beq j20 -ldloc.0 -ldc.i4 1088 -beq j91 -ldloc.0 -ldc.i4 2112 -beq j109 -br InvalidJumpDestination - -j212: -ldloc.0 -ldc.i4.s 65 -beq j7 -br InvalidJumpDestination - -j213: -br InvalidJumpDestination - -j214: -ldloc.0 -ldc.i4 579 -beq j48 -br InvalidJumpDestination - -j215: -ldloc.0 -ldc.i4 196 -beq j23 -ldloc.0 -ldc.i4 2116 -beq j112 -br InvalidJumpDestination - -j216: -br InvalidJumpDestination - -j217: -ldloc.0 -ldc.i4 3014 -beq j133 -br InvalidJumpDestination - -j218: -ldloc.0 -ldc.i4 327 -beq j30 -br InvalidJumpDestination - -j219: -ldloc.0 -ldc.i4 1352 -beq j95 -br InvalidJumpDestination - -j220: -ldloc.0 -ldc.i4 841 -beq j75 -br InvalidJumpDestination - -j221: -ldloc.0 -ldc.i4 458 -beq j42 -ldloc.0 -ldc.i4 586 -beq j49 -ldloc.0 -ldc.i4 970 -beq j83 -br InvalidJumpDestination - -j222: -br InvalidJumpDestination - -j223: -ldloc.0 -ldc.i4.s 76 -beq j8 -ldloc.0 -ldc.i4 204 -beq j24 -ldloc.0 -ldc.i4 716 -beq j65 -br InvalidJumpDestination - -j224: -br InvalidJumpDestination - -j225: -ldloc.0 -ldc.i4 334 -beq j31 -ldloc.0 -ldc.i4 590 -beq j52 -ldloc.0 -ldc.i4 3022 -beq j134 -br InvalidJumpDestination - -j226: -ldloc.0 -ldc.i4 2255 -beq j113 -br InvalidJumpDestination - -j227: -br InvalidJumpDestination - -j228: -ldloc.0 -ldc.i4 465 -beq j43 -br InvalidJumpDestination - -j229: -ldloc.0 -ldc.i4 338 -beq j34 -ldloc.0 -ldc.i4 978 -beq j84 -br InvalidJumpDestination - -j230: -br InvalidJumpDestination - -j231: -ldloc.0 -ldc.i4 980 -beq j85 -br InvalidJumpDestination - -j232: -ldloc.0 -ldc.i4 469 -beq j46 -br InvalidJumpDestination - -j233: -ldloc.0 -ldc.i4 1366 -beq j96 -br InvalidJumpDestination - -j234: -ldloc.0 -ldc.i4.s 87 -beq j9 -br InvalidJumpDestination - -j235: -ldloc.0 -ldc.i4 1752 -beq j102 -br InvalidJumpDestination - -j236: -ldloc.0 -ldc.i4 2521 -beq j114 -br InvalidJumpDestination - -j237: -br InvalidJumpDestination - -j238: -ldloc.0 -ldc.i4 987 -beq j86 -ldloc.0 -ldc.i4 3035 -beq j135 -br InvalidJumpDestination - -j239: -ldloc.0 -ldc.i4 1756 -beq j105 -br InvalidJumpDestination - -j240: -ldloc.0 -ldc.i4 1245 -beq j92 -br InvalidJumpDestination - -j241: -br InvalidJumpDestination - -j242: -ldloc.0 -ldc.i4 991 -beq j89 -br InvalidJumpDestination - -j243: -br InvalidJumpDestination - -j244: -br InvalidJumpDestination - -j245: -ldloc.0 -ldc.i4.s 98 -beq j10 +beq.s j5 ldloc.0 -ldc.i4 738 -beq j66 -ldloc.0 -ldc.i4 866 -beq j76 -br InvalidJumpDestination - -j246: -ldloc.0 -ldc.i4 3043 -beq j136 -br InvalidJumpDestination - -j247: -ldloc.0 -ldc.i4 612 -beq j53 -br InvalidJumpDestination - -j248: -br InvalidJumpDestination - -j249: -ldloc.0 -ldc.i4 614 -beq j54 -br InvalidJumpDestination - -j250: -br InvalidJumpDestination - -j251: -br InvalidJumpDestination - -j252: -ldloc.0 -ldc.i4 745 -beq j67 -br InvalidJumpDestination - -j253: -ldloc.0 -ldc.i4 1386 -beq j97 -br InvalidJumpDestination - -j254: -br InvalidJumpDestination - -j255: -br InvalidJumpDestination - -j256: -ldloc.0 -ldc.i4.s 109 -beq j11 -ldloc.0 -ldc.i4 621 -beq j55 -ldloc.0 -ldc.i4 749 -beq j70 -ldloc.0 -ldc.i4 1645 -beq j100 -br InvalidJumpDestination - -j257: -br InvalidJumpDestination - -j258: -br InvalidJumpDestination - -j259: -ldloc.0 -ldc.i4 880 -beq j77 -br InvalidJumpDestination - -j260: -ldloc.0 -ldc.i4 241 -beq j25 -ldloc.0 -ldc.i4 625 -beq j58 -br InvalidJumpDestination - -j261: -br InvalidJumpDestination - -j262: -ldloc.0 -ldc.i4 1395 -beq j98 -br InvalidJumpDestination - -j263: -br InvalidJumpDestination - -j264: -ldloc.0 -ldc.i4 757 -beq j71 -br InvalidJumpDestination - -j265: -br InvalidJumpDestination - -j266: -ldloc.0 -ldc.i4 887 -beq j78 -br InvalidJumpDestination - -j267: -ldloc.0 -ldc.i4.s 120 -beq j12 -br.s InvalidJumpDestination - -j268: -ldloc.0 -ldc.i4 633 -beq j59 -br.s InvalidJumpDestination - -j269: -ldloc.0 -ldc.i4 250 -beq j26 -br.s InvalidJumpDestination - -j270: -ldloc.0 -ldc.i4 891 -beq j81 +ldc.i4.s 11 +beq.s j6 ldloc.0 -ldc.i4 1403 -beq j99 -br.s InvalidJumpDestination - -j271: -br.s InvalidJumpDestination - -j272: -br.s InvalidJumpDestination - -j273: -br.s InvalidJumpDestination - -j274: +ldc.i4.s 32 +beq.s j7 br.s InvalidJumpDestination -BadInstruction: -ldarg.1 -dup -ldc.i4.1 -stfld Nethermind.Evm.EvmExceptionType ExceptionType -ldc.i4.8 -stfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState -br j3 - StaticCallViolation: ldarg.1 dup @@ -1870,7 +86,7 @@ ldc.i4.s 11 stfld Nethermind.Evm.EvmExceptionType ExceptionType ldc.i4.8 stfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState -br j3 +br.s j3 InvalidJumpDestination: ldarg.1 @@ -1879,4 +95,4 @@ ldc.i4.8 stfld Nethermind.Evm.EvmExceptionType ExceptionType ldc.i4.8 stfld Nethermind.Evm.CodeAnalysis.IL.ContractState ContractState -br j3 +br.s j3 From e5ef85b799d4206f46e52b305decf32e3d980ea9 Mon Sep 17 00:00:00 2001 From: Siddharth Vaderaa Date: Sun, 20 Jul 2025 15:25:10 +0200 Subject: [PATCH 40/40] .. --- src/Nethermind/Nethermind.Evm/VirtualMachine.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs index dc8769e5b9d..540b94042d3 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs @@ -1078,7 +1078,7 @@ private CallResult ExecuteCall( if(typeof(TEnablePrecompilation) == typeof(OnFlag)) { - // IlAnalyzer.Analyse(env.CodeInfo as CodeInfo, ILMode.AOT_MODE, _vmConfig, _logger); + //if (env.CodeInfo.CodeHash is not null) IlAnalyzer.Analyse(env.CodeInfo as CodeInfo, ILMode.AOT_MODE, _vmConfig, _logger); env.CodeInfo.NoticeExecution(_vmConfig, _logger, Spec); } }