mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2025-01-05 02:24:29 +00:00
99 lines
2.7 KiB
Go
99 lines
2.7 KiB
Go
package eth1_utils
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/holiman/uint256"
|
|
libcommon "github.com/ledgerwatch/erigon-lib/common"
|
|
"github.com/ledgerwatch/erigon/common/math"
|
|
"github.com/ledgerwatch/erigon/core/types"
|
|
"github.com/ledgerwatch/erigon/crypto"
|
|
"github.com/ledgerwatch/erigon/params"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func makeBlock(txCount, uncleCount, withdrawalCount int) *types.Block {
|
|
var (
|
|
key, _ = crypto.GenerateKey()
|
|
txs = make([]types.Transaction, txCount)
|
|
receipts = make([]*types.Receipt, len(txs))
|
|
signer = types.LatestSigner(params.TestChainConfig)
|
|
uncles = make([]*types.Header, uncleCount)
|
|
withdrawals = make([]*types.Withdrawal, withdrawalCount)
|
|
)
|
|
header := &types.Header{
|
|
Difficulty: math.BigPow(11, 11),
|
|
Number: math.BigPow(2, 9),
|
|
GasLimit: 12345678,
|
|
GasUsed: 1476322,
|
|
Time: 9876543,
|
|
Extra: []byte("test block"),
|
|
}
|
|
for i := range txs {
|
|
amount, _ := uint256.FromBig(math.BigPow(2, int64(i)))
|
|
price := uint256.NewInt(300000)
|
|
data := make([]byte, 100)
|
|
tx := types.NewTransaction(uint64(i), libcommon.Address{}, amount, 123457, price, data)
|
|
signedTx, err := types.SignTx(tx, *signer, key)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
txs[i] = signedTx
|
|
receipts[i] = types.NewReceipt(false, tx.GetGas())
|
|
}
|
|
for i := range uncles {
|
|
uncles[i] = &types.Header{
|
|
Difficulty: math.BigPow(11, 11),
|
|
Number: math.BigPow(2, 9),
|
|
GasLimit: 12345678,
|
|
GasUsed: 1476322,
|
|
Time: 9876543,
|
|
Extra: []byte("test uncle"),
|
|
}
|
|
}
|
|
for i := range withdrawals {
|
|
withdrawals[i] = &types.Withdrawal{
|
|
Index: uint64(i),
|
|
Validator: uint64(i),
|
|
Amount: uint64(10 * i),
|
|
}
|
|
}
|
|
return types.NewBlock(header, txs, uncles, receipts, withdrawals)
|
|
}
|
|
|
|
func TestBlockRpcConversion(t *testing.T) {
|
|
t.Parallel()
|
|
require := require.New(t)
|
|
testBlock := makeBlock(50, 2, 3)
|
|
|
|
// header conversions
|
|
rpcHeader := HeaderToHeaderRPC(testBlock.Header())
|
|
roundTripHeader, err := HeaderRpcToHeader(rpcHeader)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
require.Equal(testBlock.Header(), roundTripHeader)
|
|
|
|
// body conversions
|
|
rpcBlock := ConvertBlockToRPC(testBlock)
|
|
roundTripBody, err := ConvertRawBlockBodyFromRpc(rpcBlock.Body)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
testBlockRaw := testBlock.RawBody()
|
|
require.Greater(len(testBlockRaw.Transactions), 0)
|
|
require.Greater(len(testBlockRaw.Uncles), 0)
|
|
require.Greater(len(testBlockRaw.Withdrawals), 0)
|
|
require.Equal(testBlockRaw, roundTripBody) // validates txns, uncles, and withdrawals
|
|
}
|
|
|
|
func TestBigIntConversion(t *testing.T) {
|
|
t.Parallel()
|
|
require := require.New(t)
|
|
|
|
val := math.BigPow(2, 32)
|
|
rpcVal := ConvertBigIntToRpc(val)
|
|
roundTripVal := ConvertBigIntFromRpc(rpcVal)
|
|
require.Equal(val, roundTripVal)
|
|
}
|