XDC Reward handler

src/Nethermind/Chains/xdc.json

@@ -60,7 +60,9 @@
             "TimeoutPeriod":        10,
             "MinePeriod":           2
           }
-        ]
+        ],
+        "masternodeVotingContract": "0x0000000000000000000000000000000000000088",
+        "blockSignerContract": "0x0000000000000000000000000000000000000089"
       }
     }
   },

src/Nethermind/Nethermind.Xdc.Test/Helpers/TransactionBuilderXdcExtensions.cs

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Core.Test.Builders;
+using Nethermind.Xdc.Spec;
+
+namespace Nethermind.Xdc.Test.Helpers;
+
+public static class TransactionBuilderXdcExtensions
+{
+    // function sign(uint256 _blockNumber, bytes32 _blockHash)
+    // selector = 0xe341eaa4
+    private static ReadOnlySpan<byte> SignSelector => new byte[] { 0xE3, 0x41, 0xEA, 0xA4 };
+
+    /// <summary>Sets 'To' to the XDC block-signer contract from the spec.</summary>
+    public static TransactionBuilder<Transaction> ToBlockSignerContract(
+        this TransactionBuilder<Transaction> b, IXdcReleaseSpec spec)
+        => b.To(spec.BlockSignerContract);
+
+    /// <summary>
+    /// Appends ABI-encoded calldata for sign(uint256 _blockNumber, bytes32 _blockHash).
+    /// Calldata = 4-byte selector + 32-byte big-endian uint + 32-byte bytes32 (68 bytes total).
+    /// </summary>
+    public static TransactionBuilder<Transaction> WithXdcSigningData(
+        this TransactionBuilder<Transaction> b, long blockNumber, Hash256 blockHash)
+        => b.WithData(CreateSigningCalldata(blockNumber, blockHash));
+
+    private static byte[] CreateSigningCalldata(long blockNumber, Hash256 blockHash)
+    {
+        Span<byte> data = stackalloc byte[68]; // 4 + 32 + 32
+
+        // 0..3: selector
+        SignSelector.CopyTo(data);
+
+        // 4..35: uint256 blockNumber (big-endian, right-aligned in 32 bytes)
+        var be = BitConverter.GetBytes((ulong)blockNumber);
+        if (BitConverter.IsLittleEndian) Array.Reverse(be);
+        // last 8 bytes of that 32 are the ulong
+        for (int i = 0; i < 8; i++) data[4 + 24 + i] = be[i];
+
+        // 36..67: bytes32 blockHash
+        blockHash.Bytes.CopyTo(data.Slice(36, 32));
+
+        return data.ToArray();
+    }
+}

src/Nethermind/Nethermind.Xdc.Test/Helpers/XdcTestBlockchain.cs

@@ -10,6 +10,7 @@
 using Nethermind.Consensus.Comparers;
 using Nethermind.Consensus.Processing;
 using Nethermind.Consensus.Producers;
+using Nethermind.Consensus.Rewards;
 using Nethermind.Core;
 using Nethermind.Core.Specs;
 using Nethermind.Core.Test.Blockchain;
@@ -55,7 +56,7 @@ public static async Task<XdcTestBlockchain> Create(int blocksToAdd = 3, bool use
 
         if (testConfiguration.SuggestGenesisOnStart)
         {
-            // The block added event is not waited by genesis, but its needed to wait here so that `AddBlock` wait correctly.
+            // The block added event is not waited by genesis, but it's needed to wait here so that `AddBlock` waits correctly.
             Task newBlockWaiter = chain.BlockTree.WaitForNewBlock(chain.CancellationToken);
             chain.MainProcessingContext.GenesisLoader.Load();
             await newBlockWaiter;
@@ -173,7 +174,16 @@ protected override ContainerBuilder ConfigureContainer(ContainerBuilder builder,
             .AddSingleton<Configuration>()
             .AddSingleton<FromContainer>()
             .AddSingleton<FromXdcContainer>()
-            .AddScoped<IGenesisBuilder, XdcTestGenesisBuilder>()
+            .AddScoped<IGenesisBuilder>(ctx =>
+                new XdcTestGenesisBuilder(
+                    ctx.Resolve<ISpecProvider>(),
+                    ctx.Resolve<IWorldState>(),
+                    ctx.Resolve<ISnapshotManager>(),
+                    ctx.Resolve<IEnumerable<IGenesisPostProcessor>>().ToArray(),
+                    ctx.Resolve<Configuration>(),
+                    MasterNodeCandidates
+                )
+            )
             .AddSingleton<IBlockProducer, TestXdcBlockProducer>()
             .AddSingleton((ctx) => new CandidateContainer(MasterNodeCandidates))
             .AddSingleton<ISigner>(ctx =>
@@ -185,6 +195,7 @@ protected override ContainerBuilder ConfigureContainer(ContainerBuilder builder,
             })
             .AddSingleton((_) => BlockProducer)
             //.AddSingleton((_) => BlockProducerRunner)
+            .AddSingleton<IRewardCalculator, ZeroRewardCalculator>()
             .AddSingleton<IBlockProducerRunner, XdcHotStuff>()
             .AddSingleton<IProcessExitSource>(new ProcessExitSource(TestContext.CurrentContext.CancellationToken))
 
@@ -218,6 +229,7 @@ private IXdcReleaseSpec WrapReleaseSpec(IReleaseSpec spec)
         xdcSpec.LimitPenaltyEpoch = 2;
         xdcSpec.MinimumSigningTx = 1;
         xdcSpec.GasLimitBoundDivisor = 1024;
+        xdcSpec.BlockSignerContract = new Address("0x0000000000000000000000000000000000000089");
 
         V2ConfigParams[] v2ConfigParams = [
             new V2ConfigParams {
@@ -263,6 +275,8 @@ private IXdcReleaseSpec WrapReleaseSpec(IReleaseSpec spec)
         ];
 
         xdcSpec.V2Configs = v2ConfigParams.ToList();
+        xdcSpec.ValidateChainId = false;
+        xdcSpec.Reward = 5000;
         return xdcSpec;
     }
 
@@ -302,7 +316,8 @@ private class XdcTestGenesisBuilder(
         IWorldState state,
         ISnapshotManager snapshotManager,
         IGenesisPostProcessor[] postProcessors,
-        Configuration testConfiguration
+        Configuration testConfiguration,
+        List<PrivateKey> masterNodeCandidates
     ) : IGenesisBuilder
     {
         public Block Build()
@@ -311,6 +326,11 @@ public Block Build()
             state.CreateAccount(TestItem.AddressB, testConfiguration.AccountInitialValue);
             state.CreateAccount(TestItem.AddressC, testConfiguration.AccountInitialValue);
 
+            foreach (PrivateKey candidate in masterNodeCandidates)
+            {
+                state.CreateAccount(candidate.Address, testConfiguration.AccountInitialValue);
+            }
+
             IXdcReleaseSpec? finalSpec = (IXdcReleaseSpec)specProvider.GetFinalSpec();
 
             XdcBlockHeaderBuilder xdcBlockHeaderBuilder = new();
@@ -335,6 +355,11 @@ public Block Build()
         }
     }
 
+    private class ZeroRewardCalculator : IRewardCalculator
+    {
+        public BlockReward[] CalculateRewards(Block block) => Array.Empty<BlockReward>();
+    }
+
     public void ChangeReleaseSpec(Action<XdcReleaseSpec> reconfigure)
     {
         reconfigure((XdcReleaseSpec)SpecProvider.GetXdcSpec((XdcBlockHeader)BlockTree.Head!.Header));