nethermind/src/Nethermind/Nethermind.Xdc.Test/Helpers/XdcBlockHeaderBuilder.cs at 9cd3e4d43c7ad5fcc67649b0db8a9fc03bc365d8 · NethermindEth/nethermind · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
// SPDX-License-Identifier: LGPL-3.0-only
using Nethermind.Core.Crypto;
using Nethermind.Crypto;
using Nethermind.Int256;
using Nethermind.Serialization.Rlp;
using Nethermind.Xdc;
using Nethermind.Xdc.RLP;
using Nethermind.Xdc.Types;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.PortableExecutable;

namespace Nethermind.Core.Test.Builders;

public class XdcBlockHeaderBuilder : BlockHeaderBuilder
{
    private XdcBlockHeader XdcTestObjectInternal => (XdcBlockHeader)TestObjectInternal;

    public new XdcBlockHeader TestObject => (XdcBlockHeader)base.TestObject;


    public XdcBlockHeaderBuilder()
    {
        TestObjectInternal = new XdcBlockHeader(
            Keccak.Compute("parent"),
            Keccak.OfAnEmptySequenceRlp,
            Address.Zero,
            UInt256.One,
            1,
            XdcConstants.TargetGasLimit,
            1_700_000_000,
            new byte[] { 1, 2, 3 })
        {
            StateRoot = Keccak.EmptyTreeHash,
            TxRoot = Keccak.EmptyTreeHash,
            ReceiptsRoot = Keccak.EmptyTreeHash,
            Bloom = Bloom.Empty,
            GasUsed = 21_000,
            MixHash = Keccak.Compute("mix_hash"),
            Nonce = 0,
            Validators = new byte[20 * 2],
            Validator = new byte[65],
            Penalties = Array.Empty<byte>(),
        };
    }

    public XdcBlockHeaderBuilder WithExtraFieldsV2(ExtraFieldsV2 extraFieldsV2)
    {
        EncodeExtraData(extraFieldsV2);
        return this;
    }

    public XdcBlockHeaderBuilder WithGeneratedExtraConsensusData(int signatureNumber = 72)
    {
        PrivateKeyGenerator keyBuilder = new PrivateKeyGenerator();
        return WithGeneratedExtraConsensusData(Enumerable.Range(0, signatureNumber).Select(i => keyBuilder.Generate()));
    }

    public XdcBlockHeaderBuilder WithGeneratedExtraConsensusData(IEnumerable<PrivateKey> keys)
    {
        QuorumCertificateDecoder qcEncoder = new QuorumCertificateDecoder();
        EthereumEcdsa ecdsa = new EthereumEcdsa(0);
        BlockRoundInfo blockRoundInfo = new BlockRoundInfo(Hash256.Zero, 1, 1);
        QuorumCertificate quorumForSigning = new QuorumCertificate(blockRoundInfo, null, 450);
        IEnumerable<Signature> signatures = keys.Select(k => ecdsa.Sign(k, Keccak.Compute(qcEncoder.Encode(quorumForSigning, RlpBehaviors.ForSealing).Bytes)));
        QuorumCertificate quorumCert = new QuorumCertificate(blockRoundInfo, [.. signatures], 450);
        ExtraFieldsV2 extraFieldsV2 = new ExtraFieldsV2(1, quorumCert);

        EncodeExtraData(extraFieldsV2);
        return this;
    }
    private void EncodeExtraData(ExtraFieldsV2 extraFieldsV2)
    {
        ExtraConsensusDataDecoder extraEncoder = new ExtraConsensusDataDecoder();
        Rlp extraEncoded = extraEncoder.Encode(extraFieldsV2);
        XdcTestObjectInternal.ExtraData = [0x2, .. extraEncoded.Bytes];
    }

    public XdcBlockHeaderBuilder WithExtraConsensusData(ExtraFieldsV2 extraFieldsV2)
    {
        XdcTestObjectInternal.ExtraConsensusData = extraFieldsV2;
        return this;
    }

    public new XdcBlockHeaderBuilder WithBaseFee(UInt256 baseFee)
    {
        TestObjectInternal.BaseFeePerGas = baseFee;
        return this;
    }

    public new XdcBlockHeaderBuilder WithHash(Hash256 hash256)
    {
        TestObjectInternal.Hash = hash256;
        return this;
    }

    public XdcBlockHeaderBuilder WithValidator(Signature signature)
    {
        XdcTestObjectInternal.Validator = signature.Bytes.ToArray();
        return this;
    }
    public XdcBlockHeaderBuilder WithValidator(byte[] bytes)
    {
        XdcTestObjectInternal.Validator = bytes;
        return this;
    }
    public XdcBlockHeaderBuilder WithValidators(Address[] validators)
    {
        XdcTestObjectInternal.Validators = validators.SelectMany(a => a.Bytes).ToArray();
        return this;
    }
    public XdcBlockHeaderBuilder WithValidators(byte[] validators)
    {
        XdcTestObjectInternal.Validators = validators;
        return this;
    }
    public XdcBlockHeaderBuilder WithPenalties(Address[] penalties)
    {
        XdcTestObjectInternal.Penalties = penalties.SelectMany(a => a.Bytes).ToArray();
        return this;
    }
    public XdcBlockHeaderBuilder WithPenalties(byte[] penalties)
    {
        XdcTestObjectInternal.Penalties = penalties;
        return this;
    }
}