Timestamp Based Fork Activation

src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs

@@ -102,15 +102,15 @@ protected async Task<EthereumTestResult> RunTest(BlockchainTest test, Stopwatch?
             if (test.NetworkAfterTransition != null)
             {
                 specProvider = new CustomSpecProvider(1,
-                    ((0, 0), Frontier.Instance),
-                    ((1, 0), test.Network),
-                    ((test.TransitionBlockNumber, 0), test.NetworkAfterTransition));
+                    (0, Frontier.Instance),
+                    (1, test.Network),
+                    (test.TransitionBlockNumber, test.NetworkAfterTransition));
             }
             else
             {
                 specProvider = new CustomSpecProvider(1,
-                    ((0, 0), Frontier.Instance), // TODO: this thing took a lot of time to find after it was removed!, genesis block is always initialized with Frontier
-                    ((1, 0), test.Network));
+                    (0, Frontier.Instance), // TODO: this thing took a lot of time to find after it was removed!, genesis block is always initialized with Frontier
+                    (1, test.Network));
             }
 
             if (specProvider.GenesisSpec != Frontier.Instance)

src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs

@@ -71,8 +71,8 @@ protected EthereumTestResult RunTest(GeneralStateTest test, ITxTracer txTracer)
             IDb codeDb = new MemDb();
 
             ISpecProvider specProvider = new CustomSpecProvider(1,
-                ((0, 0), Frontier.Instance), // TODO: this thing took a lot of time to find after it was removed!, genesis block is always initialized with Frontier
-                ((1, 0), test.Fork));
+                (0, Frontier.Instance), // TODO: this thing took a lot of time to find after it was removed!, genesis block is always initialized with Frontier
+                (1, test.Fork));
 
             if (specProvider.GenesisSpec != Frontier.Instance)
             {

src/Nethermind/Nethermind.Blockchain.Test/Validators/BlockValidatorTests.cs

@@ -34,7 +34,7 @@ public void When_more_uncles_than_allowed_returns_false()
             TxValidator txValidator = new(ChainId.Mainnet);
             ReleaseSpec releaseSpec = new();
             releaseSpec.MaximumUncleCount = 0;
-            ISpecProvider specProvider = new CustomSpecProvider(((0, 0), releaseSpec));
+            ISpecProvider specProvider = new CustomSpecProvider((0, releaseSpec));
 
             BlockValidator blockValidator = new(txValidator, Always.Valid, Always.Valid, specProvider, LimboLogs.Instance);
             bool noiseRemoved = blockValidator.ValidateSuggestedBlock(Build.A.Block.TestObject);

src/Nethermind/Nethermind.Core/Specs/ForkActivation.cs

@@ -5,20 +5,27 @@ namespace Nethermind.Core.Specs;
 public readonly struct ForkActivation : IEquatable<ForkActivation>, IComparable<ForkActivation>
 {
     public long BlockNumber { get; }
-    public ulong Timestamp { get; }
+    public ulong? Timestamp { get; }
 
-    public ForkActivation(long blockNumber, ulong timestamp = 0)
+    public ForkActivation(long blockNumber, ulong? timestamp = null)
     {
         BlockNumber = blockNumber;
         Timestamp = timestamp;
     }
+    public void Deconstruct(out long blockNumber, out ulong? timestamp)
+    {
+        blockNumber = BlockNumber;
+        timestamp = Timestamp;
+    }
 
     public static implicit operator ForkActivation(long blocknumber) => new(blocknumber);
 
-    public static implicit operator ForkActivation((long, ulong) blocknumberAndTimestamp)
-        => new(blocknumberAndTimestamp.Item1, blocknumberAndTimestamp.Item2);
+    public static implicit operator ForkActivation((long blocknumber, ulong timestamp) blocknumberAndTimestamp)
+        => new(blocknumberAndTimestamp.blocknumber, blocknumberAndTimestamp.timestamp);
+    public static implicit operator ForkActivation((long blocknumber, ulong? timestamp) blocknumberAndTimestamp)
+        => new(blocknumberAndTimestamp.blocknumber, blocknumberAndTimestamp.timestamp);
 
-    public static implicit operator (long, ulong)(ForkActivation forkActivation)
+    public static implicit operator (long blocknumber, ulong? timestamp)(ForkActivation forkActivation)
         => (forkActivation.BlockNumber, forkActivation.Timestamp);
 
     public bool Equals(ForkActivation other)
@@ -43,20 +50,9 @@ public override string ToString()
 
     public int CompareTo(ForkActivation other)
     {
-        if (BlockNumber < other.BlockNumber)
-            return -1;
-        if (BlockNumber > other.BlockNumber)
-            return 1;
-        if (BlockNumber == other.BlockNumber)
-        {
-            if (Timestamp < other.Timestamp)
-                return -1;
-            if (Timestamp > other.Timestamp)
-                return 1;
-            if (Timestamp == other.Timestamp)
-                return 0;
-        }
-        throw new InvalidOperationException("This is unreachable exception");
+        return Timestamp is null || other.Timestamp is null
+            ? BlockNumber.CompareTo(other.BlockNumber)
+            : Timestamp.Value.CompareTo(other.Timestamp.Value);
     }
 
     public static bool operator ==(ForkActivation first, ForkActivation second)

src/Nethermind/Nethermind.Core/Specs/ISpecProvider.cs

@@ -70,5 +70,7 @@ public interface ISpecProvider
         /// <param name="blockNumber"></param>
         /// <returns>A spec that is valid at the given chain height</returns>
         IReleaseSpec GetSpec(ForkActivation forkActivation);
+
+        IReleaseSpec GetSpec(long blockNumber, ulong timestamp) => GetSpec((blockNumber, timestamp));
     }
 }

src/Nethermind/Nethermind.Evm.Test/Eip1344Tests.cs

@@ -43,7 +43,7 @@ private void Test(ulong chainId)
         private class Custom0 : Eip1344Tests
         {
             protected override long BlockNumber => MainnetSpecProvider.IstanbulBlockNumber;
-            protected override ISpecProvider SpecProvider => new CustomSpecProvider(0, ((0, 0), Istanbul.Instance));
+            protected override ISpecProvider SpecProvider => new CustomSpecProvider(0, (0, Istanbul.Instance));
 
             [Test]
             public void given_custom_0_network_chain_id_opcode_puts_expected_value_onto_the_stack()
@@ -55,7 +55,7 @@ public void given_custom_0_network_chain_id_opcode_puts_expected_value_onto_the_
         private class Custom32000 : Eip1344Tests
         {
             protected override long BlockNumber => MainnetSpecProvider.IstanbulBlockNumber;
-            protected override ISpecProvider SpecProvider => new CustomSpecProvider(32000, ((0, 0), Istanbul.Instance));
+            protected override ISpecProvider SpecProvider => new CustomSpecProvider(32000, (0, Istanbul.Instance));
 
             [Test]
             public void given_custom_custom_32000_network_chain_id_opcode_puts_expected_value_onto_the_stack()

src/Nethermind/Nethermind.Evm.Test/Eip2028Tests.cs

@@ -30,7 +30,7 @@ public class Eip2028Tests : VirtualMachineTestsBase
         private class AfterIstanbul : Eip2028Tests
         {
             protected override long BlockNumber => MainnetSpecProvider.IstanbulBlockNumber;
-            protected override ISpecProvider SpecProvider => new CustomSpecProvider(32000, ((0, 0), Istanbul.Instance));
+            protected override ISpecProvider SpecProvider => new CustomSpecProvider(32000, (0, Istanbul.Instance));
 
             [Test]
             public void non_zero_transaction_data_cost_should_be_16()

src/Nethermind/Nethermind.Evm.Test/Eip3588Tests.cs

@@ -40,15 +40,15 @@ public class Eip3855Tests : VirtualMachineTestsBase
 
         private TestAllTracerWithOutput testBase(int repeat, bool isShanghai)
         {
-            long blockNumberParam = isShanghai ? BlockNumber : BlockNumber - 1;
+            ulong timestampParam = isShanghai ? Timestamp : Timestamp - 1;
             Prepare codeInitializer = Prepare.EvmCode;
             for (int i = 0; i < repeat; i++)
             {
                 codeInitializer.Op(Instruction.PUSH0);
             }
 
             byte[] code = codeInitializer.Done;
-            TestAllTracerWithOutput receipt = Execute(blockNumberParam, 1_000_000, code);
+            TestAllTracerWithOutput receipt = Execute(BlockNumber, 1_000_000, code, timestamp: timestampParam);
             return receipt;
         }
 

src/Nethermind/Nethermind.Evm.Test/InvalidOpcodeTests.cs

@@ -17,6 +17,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using FluentAssertions;
+using Nethermind.Core.Specs;
 using Nethermind.Core.Test;
 using Nethermind.Logging;
 using Nethermind.Specs;
@@ -137,19 +138,19 @@ public class InvalidOpcodeTests : VirtualMachineTestsBase
                                     )
                             )))))).ToArray();
 
-        private Dictionary<(long, ulong), Instruction[]> _validOpcodes
+        private Dictionary<ForkActivation, Instruction[]> _validOpcodes
             = new()
             {
-                {(0, 0UL), FrontierInstructions},
-                {(MainnetSpecProvider.HomesteadBlockNumber, 0UL), HomesteadInstructions},
-                {(MainnetSpecProvider.SpuriousDragonBlockNumber, 0UL), HomesteadInstructions},
-                {(MainnetSpecProvider.TangerineWhistleBlockNumber, 0UL), HomesteadInstructions},
-                {(MainnetSpecProvider.ByzantiumBlockNumber, 0UL), ByzantiumInstructions},
-                {(MainnetSpecProvider.ConstantinopleFixBlockNumber, 0UL), ConstantinopleFixInstructions},
-                {(MainnetSpecProvider.IstanbulBlockNumber, 0UL), IstanbulInstructions},
-                {(MainnetSpecProvider.MuirGlacierBlockNumber, 0UL), IstanbulInstructions},
-                {(MainnetSpecProvider.BerlinBlockNumber, 0UL), BerlinInstructions},
-                {(MainnetSpecProvider.LondonBlockNumber, 0UL), LondonInstructions},
+                {0, FrontierInstructions},
+                {MainnetSpecProvider.HomesteadBlockNumber, HomesteadInstructions},
+                {MainnetSpecProvider.SpuriousDragonBlockNumber, HomesteadInstructions},
+                {MainnetSpecProvider.TangerineWhistleBlockNumber, HomesteadInstructions},
+                {MainnetSpecProvider.ByzantiumBlockNumber, ByzantiumInstructions},
+                {MainnetSpecProvider.ConstantinopleFixBlockNumber, ConstantinopleFixInstructions},
+                {MainnetSpecProvider.IstanbulBlockNumber, IstanbulInstructions},
+                {MainnetSpecProvider.MuirGlacierBlockNumber, IstanbulInstructions},
+                {MainnetSpecProvider.BerlinBlockNumber, BerlinInstructions},
+                {MainnetSpecProvider.LondonBlockNumber, LondonInstructions},
                 {(MainnetSpecProvider.GrayGlacierBlockNumber, MainnetSpecProvider.ShanghaiBlockTimestamp), ShanghaiInstructions},
                 {(long.MaxValue, ulong.MaxValue), ShanghaiInstructions}
             };
@@ -164,20 +165,19 @@ protected override ILogManager GetLogManager()
             return _logManager;
         }
 
-        [TestCase(0, 0UL)]
-        [TestCase(MainnetSpecProvider.HomesteadBlockNumber, 0UL)]
-        [TestCase(MainnetSpecProvider.SpuriousDragonBlockNumber, 0UL)]
-        [TestCase(MainnetSpecProvider.TangerineWhistleBlockNumber, 0UL)]
-        [TestCase(MainnetSpecProvider.ByzantiumBlockNumber, 0UL)]
-        [TestCase(MainnetSpecProvider.IstanbulBlockNumber, 0UL)]
-        [TestCase(MainnetSpecProvider.ConstantinopleFixBlockNumber, 0UL)]
-        [TestCase(MainnetSpecProvider.MuirGlacierBlockNumber, 0UL)]
-        [TestCase(MainnetSpecProvider.BerlinBlockNumber, 0UL)]
-        [TestCase(MainnetSpecProvider.BerlinBlockNumber, 0UL)]
-        [TestCase(MainnetSpecProvider.LondonBlockNumber, 0UL)]
+        [TestCase(0)]
+        [TestCase(MainnetSpecProvider.HomesteadBlockNumber)]
+        [TestCase(MainnetSpecProvider.SpuriousDragonBlockNumber)]
+        [TestCase(MainnetSpecProvider.TangerineWhistleBlockNumber)]
+        [TestCase(MainnetSpecProvider.ByzantiumBlockNumber)]
+        [TestCase(MainnetSpecProvider.IstanbulBlockNumber)]
+        [TestCase(MainnetSpecProvider.ConstantinopleFixBlockNumber)]
+        [TestCase(MainnetSpecProvider.MuirGlacierBlockNumber)]
+        [TestCase(MainnetSpecProvider.BerlinBlockNumber)]
+        [TestCase(MainnetSpecProvider.LondonBlockNumber)]
         [TestCase(MainnetSpecProvider.GrayGlacierBlockNumber, MainnetSpecProvider.ShanghaiBlockTimestamp)]
         [TestCase(long.MaxValue, ulong.MaxValue)]
-        public void Test(long blockNumber, ulong timestamp)
+        public void Test(long blockNumber, ulong? timestamp = null)
         {
             ILogger logger = _logManager.GetClassLogger();
             Instruction[] validOpcodes = _validOpcodes[(blockNumber, timestamp)];
@@ -189,7 +189,7 @@ public void Test(long blockNumber, ulong timestamp)
                     .Done;
 
                 bool isValidOpcode = ((Instruction)i != Instruction.INVALID) && validOpcodes.Contains((Instruction)i);
-                TestAllTracerWithOutput result = Execute(blockNumber, 1_000_000, code, timestamp: timestamp);
+                TestAllTracerWithOutput result = Execute(blockNumber, 1_000_000, code, timestamp: timestamp ?? 0);
 
                 if (isValidOpcode)
                 {

src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs

@@ -62,7 +62,7 @@ public class VirtualMachineTestsBase
         protected virtual long BlockNumber => MainnetSpecProvider.ByzantiumBlockNumber;
         protected virtual ulong Timestamp => 0UL;
         protected virtual ISpecProvider SpecProvider => MainnetSpecProvider.Instance;
-        protected IReleaseSpec Spec => SpecProvider.GetSpec((BlockNumber, Timestamp));
+        protected IReleaseSpec Spec => SpecProvider.GetSpec(BlockNumber, Timestamp);
 
         protected virtual ILogManager GetLogManager()
         {
@@ -118,7 +118,7 @@ protected T Execute<T>(T tracer, params byte[] code) where T : ITxTracer
             return tracer;
         }
 
-        protected TestAllTracerWithOutput Execute(long blockNumber, long gasLimit, byte[] code, long blockGasLimit = DefaultBlockGasLimit, ulong timestamp = ulong.MaxValue)
+        protected TestAllTracerWithOutput Execute(long blockNumber, long gasLimit, byte[] code, long blockGasLimit = DefaultBlockGasLimit, ulong timestamp = 0)
         {
             (Block block, Transaction transaction) = PrepareTx(blockNumber, gasLimit, code, blockGasLimit: blockGasLimit, timestamp: timestamp);
             TestAllTracerWithOutput tracer = CreateTracer();
@@ -133,7 +133,7 @@ protected TestAllTracerWithOutput Execute(long blockNumber, long gasLimit, byte[
             SenderRecipientAndMiner senderRecipientAndMiner = null,
             int value = 1,
             long blockGasLimit = DefaultBlockGasLimit,
-            ulong timestamp = ulong.MaxValue)
+            ulong timestamp = 0)
         {
             senderRecipientAndMiner ??= SenderRecipientAndMiner.Default;
             TestState.CreateAccount(senderRecipientAndMiner.Sender, 100.Ether());
@@ -208,7 +208,7 @@ protected Block BuildBlock(long blockNumber, SenderRecipientAndMiner senderRecip
 
         protected virtual Block BuildBlock(long blockNumber, SenderRecipientAndMiner senderRecipientAndMiner,
             Transaction tx, long blockGasLimit = DefaultBlockGasLimit,
-            ulong timestamp = ulong.MaxValue)
+            ulong timestamp = 0)
         {
             senderRecipientAndMiner ??= SenderRecipientAndMiner.Default;
             return Build.A.Block.WithNumber(blockNumber)

src/Nethermind/Nethermind.JsonRpc.Test/Modules/GasPriceOracleTests.cs

@@ -299,7 +299,7 @@ public void AddValidTxAndReturnCount_GivenNonEip1559Txs_EffectiveGasPriceProperl
         }
 
         public static ISpecProvider GetSpecProviderWithEip1559EnabledAs(bool isEip1559) =>
-            new CustomSpecProvider(((0, 0), isEip1559 ? London.Instance : Berlin.Instance));
+            new CustomSpecProvider((0, isEip1559 ? London.Instance : Berlin.Instance));
 
         [Test]
         public void GetGasPricesFromRecentBlocks_IfNoValidTxsInABlock_DefaultPriceAddedToListInstead()

src/Nethermind/Nethermind.Specs.Test/CustomSpecProvider.cs

@@ -44,10 +44,10 @@ public CustomSpecProvider(ulong chainId, params (ForkActivation forkActivation,
                 throw new ArgumentException($"There must be at least one release specified when instantiating {nameof(CustomSpecProvider)}", $"{nameof(transitions)}");
             }
 
-            _transitions = transitions.OrderBy(r => r.Item1).ToArray();
-            TransitionBlocks = _transitions.Select(t => t.Item1).ToArray();
+            _transitions = transitions.OrderBy(r => r.forkActivation).ToArray();
+            TransitionBlocks = _transitions.Select(t => t.forkActivation).ToArray();
 
-            if (transitions[0].Item1.BlockNumber != 0L)
+            if (transitions[0].forkActivation.BlockNumber != 0L)
             {
                 throw new ArgumentException($"First release specified when instantiating {nameof(CustomSpecProvider)} should be at genesis block (0)", $"{nameof(transitions)}");
             }
@@ -75,7 +75,7 @@ public IReleaseSpec GetSpec(ForkActivation forkActivation)
             IReleaseSpec spec = _transitions[0].Release;
             for (int i = 1; i < _transitions.Length; i++)
             {
-                if (forkActivation >= _transitions[i].Item1)
+                if (forkActivation >= _transitions[i].forkActivation)
                 {
                     spec = _transitions[i].Release;
                 }

src/Nethermind/Nethermind.Specs.Test/CustomSpecProviderTests.cs

@@ -32,17 +32,17 @@ public void When_no_transitions_specified_throws_argument_exception()
         [Test]
         public void When_first_release_is_not_at_block_zero_then_throws_argument_exception()
         {
-            Assert.Throws<ArgumentException>(() => _ = new CustomSpecProvider(((1, 0), Byzantium.Instance)), "ordered");
+            Assert.Throws<ArgumentException>(() => _ = new CustomSpecProvider((1, Byzantium.Instance)), "ordered");
 
             Assert.Throws<ArgumentException>(() => _ = new CustomSpecProvider(
-                ((1, 0), Byzantium.Instance),
-                ((0, 0), Frontier.Instance)), "not ordered");
+                (1, Byzantium.Instance),
+                (0, Frontier.Instance)), "not ordered");
         }
 
         [Test]
         public void When_only_one_release_is_specified_then_returns_that_release()
         {
-            var specProvider = new CustomSpecProvider(((0, 0), Byzantium.Instance));
+            var specProvider = new CustomSpecProvider((0, Byzantium.Instance));
             Assert.IsInstanceOf<Byzantium>(specProvider.GetSpec(0), "0");
             Assert.IsInstanceOf<Byzantium>(specProvider.GetSpec(1), "1");
         }
@@ -52,8 +52,8 @@ public void Can_find_dao_block_number()
         {
             long daoBlockNumber = 100;
             var specProvider = new CustomSpecProvider(
-                ((0L, 0), Frontier.Instance),
-                ((daoBlockNumber, 0), Dao.Instance));
+                (0L, Frontier.Instance),
+                (daoBlockNumber, Dao.Instance));
 
             Assert.AreEqual(daoBlockNumber, specProvider.DaoBlockNumber);
         }
@@ -62,8 +62,8 @@ public void Can_find_dao_block_number()
         public void If_no_dao_then_no_dao_block_number()
         {
             var specProvider = new CustomSpecProvider(
-                ((0L, 0), Frontier.Instance),
-                ((1L, 0), Homestead.Instance));
+                (0L, Frontier.Instance),
+                (1L, Homestead.Instance));
 
             Assert.IsNull(specProvider.DaoBlockNumber);
         }
@@ -72,15 +72,15 @@ public void If_no_dao_then_no_dao_block_number()
         public void When_more_releases_specified_then_transitions_work()
         {
             var specProvider = new CustomSpecProvider(
-                ((0, 0), Frontier.Instance),
-                ((1, 0), Homestead.Instance));
+                (0, Frontier.Instance),
+                (1, Homestead.Instance));
             Assert.IsInstanceOf<Frontier>(specProvider.GetSpec(0), "2 releases, block 0");
             Assert.IsInstanceOf<Homestead>(specProvider.GetSpec(1), "2 releases, block 1");
 
             specProvider = new CustomSpecProvider(
-                ((0, 0), Frontier.Instance),
-                ((1, 0), Homestead.Instance),
-                ((10, 0), Byzantium.Instance));
+                (0, Frontier.Instance),
+                (1, Homestead.Instance),
+                (10, Byzantium.Instance));
             Assert.IsInstanceOf<Frontier>(specProvider.GetSpec(0), "3 releases, block 0");
             Assert.IsInstanceOf<Homestead>(specProvider.GetSpec(1), "3 releases, block 1");
             Assert.IsInstanceOf<Byzantium>(specProvider.GetSpec(100), "3 releases, block 10");