// Copyright 2023 The go-ethereum Authors

// This file is part of the go-ethereum library.

//

// The go-ethereum library is free software: you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// The go-ethereum library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public License

// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package ethapi

import (

"bytes"

"context"

"crypto/ecdsa"

"crypto/sha256"

"encoding/json"

"errors"

"fmt"

"maps"

"math"

"math/big"

"os"

"path/filepath"

"reflect"

"slices"

"strings"

"testing"

"time"

"github.com/ethereum/go-ethereum/accounts/abi"

"github.com/ethereum/go-ethereum/internal/ethapi/override"

"github.com/ethereum/go-ethereum/triedb"

"github.com/ethereum/go-ethereum"

"github.com/ethereum/go-ethereum/accounts"

"github.com/ethereum/go-ethereum/accounts/keystore"

"github.com/ethereum/go-ethereum/common"

"github.com/ethereum/go-ethereum/common/hexutil"

"github.com/ethereum/go-ethereum/consensus"

"github.com/ethereum/go-ethereum/consensus/beacon"

"github.com/ethereum/go-ethereum/consensus/ethash"

"github.com/ethereum/go-ethereum/core"

"github.com/ethereum/go-ethereum/core/filtermaps"

"github.com/ethereum/go-ethereum/core/rawdb"

"github.com/ethereum/go-ethereum/core/state"

"github.com/ethereum/go-ethereum/core/types"

"github.com/ethereum/go-ethereum/core/vm"

"github.com/ethereum/go-ethereum/crypto"

"github.com/ethereum/go-ethereum/crypto/kzg4844"

"github.com/ethereum/go-ethereum/ethdb"

"github.com/ethereum/go-ethereum/event"

"github.com/ethereum/go-ethereum/internal/blocktest"

"github.com/ethereum/go-ethereum/params"

"github.com/ethereum/go-ethereum/rpc"

"github.com/holiman/uint256"

"github.com/stretchr/testify/require"

)

func testTransactionMarshal(t *testing.T, tests []txData, config *params.ChainConfig) {

var (

signer = types.LatestSigner(config)

key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")

)

for i, tt := range tests {

var tx2 types.Transaction

tx, err := types.SignNewTx(key, signer, tt.Tx)

if err != nil {

t.Fatalf("test %d: signing failed: %v", i, err)

}

// Regular transaction

if data, err := json.Marshal(tx); err != nil {

t.Fatalf("test %d: marshalling failed; %v", i, err)

} else if err = tx2.UnmarshalJSON(data); err != nil {

t.Fatalf("test %d: sunmarshal failed: %v", i, err)

} else if want, have := tx.Hash(), tx2.Hash(); want != have {

t.Fatalf("test %d: stx changed, want %x have %x", i, want, have)

}

// rpcTransaction

rpcTx := newRPCTransaction(tx, common.Hash{}, 0, 0, 0, nil, config)

if data, err := json.Marshal(rpcTx); err != nil {

t.Fatalf("test %d: marshalling failed; %v", i, err)

} else if err = tx2.UnmarshalJSON(data); err != nil {

t.Fatalf("test %d: unmarshal failed: %v", i, err)

} else if want, have := tx.Hash(), tx2.Hash(); want != have {

t.Fatalf("test %d: tx changed, want %x have %x", i, want, have)

} else {

want, have := tt.Want, string(data)

require.JSONEqf(t, want, have, "test %d: rpc json not match, want %s have %s", i, want, have)

}

}

}

func TestTransaction_RoundTripRpcJSON(t *testing.T) {

t.Parallel()

var (

config = params.AllEthashProtocolChanges

tests = allTransactionTypes(common.Address{0xde, 0xad}, config)

)

testTransactionMarshal(t, tests, config)

}

func TestTransactionBlobTx(t *testing.T) {

t.Parallel()

config := *params.TestChainConfig

config.ShanghaiTime = new(uint64)

config.CancunTime = new(uint64)

tests := allBlobTxs(common.Address{0xde, 0xad}, &config)

testTransactionMarshal(t, tests, &config)

}

type txData struct {

Tx types.TxData

Want string

}

func allTransactionTypes(addr common.Address, config *params.ChainConfig) []txData {

return []txData{

{

Tx: &types.LegacyTx{

Nonce: 5,

GasPrice: big.NewInt(6),

Gas: 7,

To: &addr,

Value: big.NewInt(8),

Data: []byte{0, 1, 2, 3, 4},

V: big.NewInt(9),

R: big.NewInt(10),

S: big.NewInt(11),

},

Want: `{

"blockHash": null,

"blockNumber": null,

"from": "0x71562b71999873db5b286df957af199ec94617f7",

"gas": "0x7",

"gasPrice": "0x6",

"hash": "0x5f3240454cd09a5d8b1c5d651eefae7a339262875bcd2d0e6676f3d989967008",

"input": "0x0001020304",

"nonce": "0x5",

"to": "0xdead000000000000000000000000000000000000",

"transactionIndex": null,

"value": "0x8",

"type": "0x0",

"chainId": "0x539",

"v": "0xa96",

"r": "0xbc85e96592b95f7160825d837abb407f009df9ebe8f1b9158a4b8dd093377f75",

"s": "0x1b55ea3af5574c536967b039ba6999ef6c89cf22fc04bcb296e0e8b0b9b576f5"

}`,

}, {

Tx: &types.LegacyTx{

Nonce: 5,

GasPrice: big.NewInt(6),

Gas: 7,

To: nil,

Value: big.NewInt(8),

Data: []byte{0, 1, 2, 3, 4},

V: big.NewInt(32),

R: big.NewInt(10),

S: big.NewInt(11),

},

Want: `{

"blockHash": null,

"blockNumber": null,

"from": "0x71562b71999873db5b286df957af199ec94617f7",

"gas": "0x7",

"gasPrice": "0x6",

"hash": "0x806e97f9d712b6cb7e781122001380a2837531b0fc1e5f5d78174ad4cb699873",

"input": "0x0001020304",

"nonce": "0x5",

"to": null,

"transactionIndex": null,

"value": "0x8",

"type": "0x0",

"chainId": "0x539",

"v": "0xa96",

"r": "0x9dc28b267b6ad4e4af6fe9289668f9305c2eb7a3241567860699e478af06835a",

"s": "0xa0b51a071aa9bed2cd70aedea859779dff039e3630ea38497d95202e9b1fec7"

}`,

},

{

Tx: &types.AccessListTx{

ChainID: config.ChainID,

Nonce: 5,

GasPrice: big.NewInt(6),

Gas: 7,

To: &addr,

Value: big.NewInt(8),

Data: []byte{0, 1, 2, 3, 4},

AccessList: types.AccessList{

types.AccessTuple{

Address: common.Address{0x2},

StorageKeys: []common.Hash{types.EmptyRootHash},

},

},

V: big.NewInt(32),

R: big.NewInt(10),

S: big.NewInt(11),

},

Want: `{

"blockHash": null,

"blockNumber": null,

"from": "0x71562b71999873db5b286df957af199ec94617f7",

"gas": "0x7",

"gasPrice": "0x6",

"hash": "0x121347468ee5fe0a29f02b49b4ffd1c8342bc4255146bb686cd07117f79e7129",

"input": "0x0001020304",

"nonce": "0x5",

"to": "0xdead000000000000000000000000000000000000",

"transactionIndex": null,

"value": "0x8",

"type": "0x1",

"accessList": [

{

"address": "0x0200000000000000000000000000000000000000",

"storageKeys": [

"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"

]

}

],

"chainId": "0x539",

"v": "0x0",

"r": "0xf372ad499239ae11d91d34c559ffc5dab4daffc0069e03afcabdcdf231a0c16b",

"s": "0x28573161d1f9472fa0fd4752533609e72f06414f7ab5588699a7141f65d2abf",

"yParity": "0x0"

}`,

}, {

Tx: &types.AccessListTx{

ChainID: config.ChainID,

Nonce: 5,

GasPrice: big.NewInt(6),

Gas: 7,

To: nil,

Value: big.NewInt(8),

Data: []byte{0, 1, 2, 3, 4},

AccessList: types.AccessList{

types.AccessTuple{

Address: common.Address{0x2},

StorageKeys: []common.Hash{types.EmptyRootHash},

},

},

V: big.NewInt(32),

R: big.NewInt(10),

S: big.NewInt(11),

},

Want: `{

"blockHash": null,

"blockNumber": null,

"from": "0x71562b71999873db5b286df957af199ec94617f7",

"gas": "0x7",

"gasPrice": "0x6",

"hash": "0x067c3baebede8027b0f828a9d933be545f7caaec623b00684ac0659726e2055b",

"input": "0x0001020304",

"nonce": "0x5",

"to": null,

"transactionIndex": null,

"value": "0x8",

"type": "0x1",

"accessList": [

{

"address": "0x0200000000000000000000000000000000000000",

"storageKeys": [

"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"

]

}

],

"chainId": "0x539",

"v": "0x1",

"r": "0x542981b5130d4613897fbab144796cb36d3cb3d7807d47d9c7f89ca7745b085c",

"s": "0x7425b9dd6c5deaa42e4ede35d0c4570c4624f68c28d812c10d806ffdf86ce63",

"yParity": "0x1"

}`,

}, {

Tx: &types.DynamicFeeTx{

ChainID: config.ChainID,

Nonce: 5,

GasTipCap: big.NewInt(6),

GasFeeCap: big.NewInt(9),

Gas: 7,

To: &addr,

Value: big.NewInt(8),

Data: []byte{0, 1, 2, 3, 4},

AccessList: types.AccessList{

types.AccessTuple{

Address: common.Address{0x2},

StorageKeys: []common.Hash{types.EmptyRootHash},

},

},

V: big.NewInt(32),

R: big.NewInt(10),

S: big.NewInt(11),

},

Want: `{

"blockHash": null,

"blockNumber": null,

"from": "0x71562b71999873db5b286df957af199ec94617f7",

"gas": "0x7",

"gasPrice": "0x9",

"maxFeePerGas": "0x9",

"maxPriorityFeePerGas": "0x6",

"hash": "0xb63e0b146b34c3e9cb7fbabb5b3c081254a7ded6f1b65324b5898cc0545d79ff",

"input": "0x0001020304",

"nonce": "0x5",

"to": "0xdead000000000000000000000000000000000000",

"transactionIndex": null,

"value": "0x8",

"type": "0x2",

"accessList": [

{

"address": "0x0200000000000000000000000000000000000000",

"storageKeys": [

"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"

]

}

],

"chainId": "0x539",

"v": "0x1",

"r": "0x3b167e05418a8932cd53d7578711fe1a76b9b96c48642402bb94978b7a107e80",

"s": "0x22f98a332d15ea2cc80386c1ebaa31b0afebfa79ebc7d039a1e0074418301fef",

"yParity": "0x1"

}`,

}, {

Tx: &types.DynamicFeeTx{

ChainID: config.ChainID,

Nonce: 5,

GasTipCap: big.NewInt(6),

GasFeeCap: big.NewInt(9),

Gas: 7,

To: nil,

Value: big.NewInt(8),

Data: []byte{0, 1, 2, 3, 4},

AccessList: types.AccessList{},

V: big.NewInt(32),

R: big.NewInt(10),

S: big.NewInt(11),

},

Want: `{

"blockHash": null,

"blockNumber": null,

"from": "0x71562b71999873db5b286df957af199ec94617f7",

"gas": "0x7",

"gasPrice": "0x9",

"maxFeePerGas": "0x9",

"maxPriorityFeePerGas": "0x6",

"hash": "0xcbab17ee031a9d5b5a09dff909f0a28aedb9b295ac0635d8710d11c7b806ec68",

"input": "0x0001020304",

"nonce": "0x5",

"to": null,

"transactionIndex": null,

"value": "0x8",

"type": "0x2",

"accessList": [],

"chainId": "0x539",

"v": "0x0",

"r": "0x6446b8a682db7e619fc6b4f6d1f708f6a17351a41c7fbd63665f469bc78b41b9",

"s": "0x7626abc15834f391a117c63450047309dbf84c5ce3e8e609b607062641e2de43",

"yParity": "0x0"

}`,

},

}

}

func allBlobTxs(addr common.Address, config *params.ChainConfig) []txData {

return []txData{

{

Tx: &types.BlobTx{

Nonce: 6,

GasTipCap: uint256.NewInt(1),

GasFeeCap: uint256.NewInt(5),

Gas: 6,

To: addr,

BlobFeeCap: uint256.NewInt(1),

BlobHashes: []common.Hash{{1}},

Value: new(uint256.Int),

V: uint256.NewInt(32),

R: uint256.NewInt(10),

S: uint256.NewInt(11),

},

Want: `{

"blockHash": null,

"blockNumber": null,

"from": "0x71562b71999873db5b286df957af199ec94617f7",

"gas": "0x6",

"gasPrice": "0x5",

"maxFeePerGas": "0x5",

"maxPriorityFeePerGas": "0x1",

"maxFeePerBlobGas": "0x1",

"hash": "0x1f2b59a20e61efc615ad0cbe936379d6bbea6f938aafaf35eb1da05d8e7f46a3",

"input": "0x",

"nonce": "0x6",

"to": "0xdead000000000000000000000000000000000000",

"transactionIndex": null,

"value": "0x0",

"type": "0x3",

"accessList": [],

"chainId": "0x1",

"blobVersionedHashes": [

"0x0100000000000000000000000000000000000000000000000000000000000000"

],

"v": "0x0",

"r": "0x618be8908e0e5320f8f3b48042a079fe5a335ebd4ed1422a7d2207cd45d872bc",

"s": "0x27b2bc6c80e849a8e8b764d4549d8c2efac3441e73cf37054eb0a9b9f8e89b27",

"yParity": "0x0"

}`,

},

}

}

func newTestAccountManager(t *testing.T) (*accounts.Manager, accounts.Account) {

var (

dir = t.TempDir()

am = accounts.NewManager(&accounts.Config{InsecureUnlockAllowed: true})

b = keystore.NewKeyStore(dir, 2, 1)

testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")

)

acc, err := b.ImportECDSA(testKey, "")

if err != nil {

t.Fatalf("failed to create test account: %v", err)

}

if err := b.Unlock(acc, ""); err != nil {

t.Fatalf("failed to unlock account: %v\n", err)

}

am.AddBackend(b)

return am, acc

}

type testBackend struct {

db ethdb.Database

chain *core.BlockChain

pending *types.Block

accman *accounts.Manager

acc accounts.Account

}

func newTestBackend(t *testing.T, n int, gspec *core.Genesis, engine consensus.Engine, generator func(i int, b *core.BlockGen)) *testBackend {

options := core.DefaultConfig().WithArchive(true)

options.TxLookupLimit = 0 // index all txs

accman, acc := newTestAccountManager(t)

gspec.Alloc[acc.Address] = types.Account{Balance: big.NewInt(params.Ether)}

// Generate blocks for testing

db, blocks, _ := core.GenerateChainWithGenesis(gspec, engine, n, generator)

chain, err := core.NewBlockChain(db, gspec, engine, options)

if err != nil {

t.Fatalf("failed to create tester chain: %v", err)

}

if n, err := chain.InsertChain(blocks); err != nil {

t.Fatalf("block %d: failed to insert into chain: %v", n, err)

}

backend := &testBackend{db: db, chain: chain, accman: accman, acc: acc}

return backend

}

// nolint:unused

func (b *testBackend) setPendingBlock(block *types.Block) {

b.pending = block

}

func (b testBackend) SyncProgress(ctx context.Context) ethereum.SyncProgress {

return ethereum.SyncProgress{}

}

func (b testBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {

return big.NewInt(0), nil

}

func (b testBackend) Chain() *core.BlockChain {

return b.chain

}

func (b testBackend) FeeHistory(ctx context.Context, blockCount uint64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, []*big.Int, []float64, error) {

return nil, nil, nil, nil, nil, nil, nil

}

func (b testBackend) BlobBaseFee(ctx context.Context) *big.Int { return new(big.Int) }

func (b testBackend) ChainDb() ethdb.Database { return b.db }

func (b testBackend) AccountManager() *accounts.Manager { return b.accman }

func (b testBackend) ExtRPCEnabled() bool { return false }

func (b testBackend) RPCGasCap() uint64 { return 10000000 }

func (b testBackend) RPCEVMTimeout() time.Duration { return time.Second }

func (b testBackend) RPCTxFeeCap() float64 { return 0 }

func (b testBackend) UnprotectedAllowed() bool { return false }

func (b testBackend) SetHead(number uint64) {}

func (b testBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {

if number == rpc.LatestBlockNumber {

return b.chain.CurrentBlock(), nil

}

if number == rpc.PendingBlockNumber && b.pending != nil {

return b.pending.Header(), nil

}

return b.chain.GetHeaderByNumber(uint64(number)), nil

}

func (b testBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {

return b.chain.GetHeaderByHash(hash), nil

}

func (b testBackend) HeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error) {

if blockNr, ok := blockNrOrHash.Number(); ok {

return b.HeaderByNumber(ctx, blockNr)

}

if blockHash, ok := blockNrOrHash.Hash(); ok {

return b.HeaderByHash(ctx, blockHash)

}

panic("unknown type rpc.BlockNumberOrHash")

}

func (b testBackend) CurrentHeader() *types.Header { return b.chain.CurrentHeader() }

func (b testBackend) CurrentBlock() *types.Header { return b.chain.CurrentBlock() }

func (b testBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {

if number == rpc.LatestBlockNumber {

head := b.chain.CurrentBlock()

return b.chain.GetBlock(head.Hash(), head.Number.Uint64()), nil

}

if number == rpc.PendingBlockNumber {

return b.pending, nil

}

if number == rpc.EarliestBlockNumber {

number = 0

}

return b.chain.GetBlockByNumber(uint64(number)), nil

}

func (b testBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {

return b.chain.GetBlockByHash(hash), nil

}

func (b testBackend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error) {

if blockNr, ok := blockNrOrHash.Number(); ok {

return b.BlockByNumber(ctx, blockNr)

}

if blockHash, ok := blockNrOrHash.Hash(); ok {

return b.BlockByHash(ctx, blockHash)

}

panic("unknown type rpc.BlockNumberOrHash")

}

func (b testBackend) GetBody(ctx context.Context, hash common.Hash, number rpc.BlockNumber) (*types.Body, error) {

return b.chain.GetBlock(hash, uint64(number.Int64())).Body(), nil

}

func (b testBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {

if number == rpc.PendingBlockNumber {

panic("pending state not implemented")

}

header, err := b.HeaderByNumber(ctx, number)

if err != nil {

return nil, nil, err

}

if header == nil {

return nil, nil, errors.New("header not found")

}

stateDb, err := b.chain.StateAt(header.Root)

return stateDb, header, err

}

func (b testBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) {

if blockNr, ok := blockNrOrHash.Number(); ok {

return b.StateAndHeaderByNumber(ctx, blockNr)

}

panic("only implemented for number")

}

func (b testBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) { panic("implement me") }

func (b testBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {

header, err := b.HeaderByHash(ctx, hash)

if header == nil || err != nil {

return nil, err

}

receipts := rawdb.ReadReceipts(b.db, hash, header.Number.Uint64(), header.Time, b.chain.Config())

return receipts, nil

}

func (b testBackend) GetBlobSidecars(ctx context.Context, hash common.Hash) (types.BlobSidecars, error) {

header, err := b.HeaderByHash(ctx, hash)

if header == nil || err != nil {

return nil, err

}

blobSidecars := rawdb.ReadBlobSidecars(b.db, hash, header.Number.Uint64())

return blobSidecars, nil

}

func (b testBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {

if b.pending != nil && hash == b.pending.Hash() {

return nil

}

return big.NewInt(1)

}

func (b testBackend) GetEVM(ctx context.Context, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockContext *vm.BlockContext) *vm.EVM {

if vmConfig == nil {

vmConfig = b.chain.GetVMConfig()

}

context := core.NewEVMBlockContext(header, b.chain, nil)

if blockContext != nil {

context = *blockContext

}

return vm.NewEVM(context, state, b.chain.Config(), *vmConfig)

}

func (b testBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {

panic("implement me")

}

func (b testBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {

panic("implement me")

}

func (b testBackend) SubscribeFinalizedHeaderEvent(ch chan<- core.FinalizedHeaderEvent) event.Subscription {

panic("implement me")

}

func (b testBackend) SubscribeNewVoteEvent(ch chan<- core.NewVoteEvent) event.Subscription {

panic("implement me")

}

func (b testBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {

panic("implement me")

}

func (b testBackend) GetCanonicalTransaction(txHash common.Hash) (bool, *types.Transaction, common.Hash, uint64, uint64) {

tx, blockHash, blockNumber, index := rawdb.ReadCanonicalTransaction(b.db, txHash)

return tx != nil, tx, blockHash, blockNumber, index

}

func (b testBackend) GetCanonicalReceipt(tx *types.Transaction, blockHash common.Hash, blockNumber, blockIndex uint64) (*types.Receipt, error) {

return b.chain.GetCanonicalReceipt(tx, blockHash, blockNumber, blockIndex)

}

func (b testBackend) TxIndexDone() bool {

return true

}

func (b testBackend) GetPoolTransactions() (types.Transactions, error) { panic("implement me") }

func (b testBackend) GetPoolTransaction(txHash common.Hash) *types.Transaction { panic("implement me") }

func (b testBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error) {

return 0, nil

}

func (b testBackend) Stats() (pending int, queued int) { panic("implement me") }

func (b testBackend) TxPoolContent() (map[common.Address][]*types.Transaction, map[common.Address][]*types.Transaction) {

panic("implement me")

}

func (b testBackend) TxPoolContentFrom(addr common.Address) ([]*types.Transaction, []*types.Transaction) {

panic("implement me")

}

func (b testBackend) SubscribeNewTxsEvent(events chan<- core.NewTxsEvent) event.Subscription {

panic("implement me")

}

func (b testBackend) ChainConfig() *params.ChainConfig { return b.chain.Config() }

func (b testBackend) Engine() consensus.Engine { return b.chain.Engine() }

func (b testBackend) CurrentValidators() ([]common.Address, error) { return []common.Address{}, nil }

func (b testBackend) GetLogs(ctx context.Context, blockHash common.Hash, number uint64) ([][]*types.Log, error) {

panic("implement me")

}

func (b testBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {

panic("implement me")

}

func (b testBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {

panic("implement me")

}

func (b testBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {

panic("implement me")

}

func (b *testBackend) MevRunning() bool { return false }

func (b *testBackend) HasBuilder(builder common.Address) bool { return false }

func (b *testBackend) MevParams() *types.MevParams {

return &types.MevParams{}

}

func (b *testBackend) StartMev() {}

func (b *testBackend) StopMev() {}

func (b *testBackend) AddBuilder(builder common.Address, builderUrl string) error { return nil }

func (b *testBackend) RemoveBuilder(builder common.Address) error { return nil }

func (b *testBackend) SendBid(ctx context.Context, bid *types.BidArgs) (common.Hash, error) {

panic("implement me")

}

func (b *testBackend) MinerInTurn() bool { return false }

func (b testBackend) CurrentView() *filtermaps.ChainView {

panic("implement me")

}

func (b testBackend) NewMatcherBackend() filtermaps.MatcherBackend {

panic("implement me")

}

func (b testBackend) HistoryPruningCutoff() uint64 {

bn, _ := b.chain.HistoryPruningCutoff()

return bn

}

func TestEstimateGas(t *testing.T) {

t.Parallel()

// Initialize test accounts

var (

accounts = newAccounts(4)

genesis = &core.Genesis{

Config: params.MergedTestChainConfig,

Alloc: types.GenesisAlloc{

accounts[0].addr: {Balance: big.NewInt(params.Ether)},

accounts[1].addr: {Balance: big.NewInt(params.Ether)},

accounts[2].addr: {Balance: big.NewInt(params.Ether), Code: append(types.DelegationPrefix, accounts[3].addr.Bytes()...)},

},

}

genBlocks = 10

signer = types.HomesteadSigner{}

randomAccounts = newAccounts(2)

)

packRevert := func(revertMessage string) []byte {

var revertSelector = crypto.Keccak256([]byte("Error(string)"))[:4]

stringType, _ := abi.NewType("string", "", nil)

args := abi.Arguments{

{Type: stringType},

}

encodedMessage, _ := args.Pack(revertMessage)

return append(revertSelector, encodedMessage...)

}

api := NewBlockChainAPI(newTestBackend(t, genBlocks, genesis, beacon.New(ethash.NewFaker()), func(i int, b *core.BlockGen) {

// Transfer from account[0] to account[1]

// value: 1000 wei

// fee: 0 wei

tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{Nonce: uint64(i), To: &accounts[1].addr, Value: big.NewInt(1000), Gas: params.TxGas, GasPrice: b.BaseFee(), Data: nil}), signer, accounts[0].key)

b.AddTx(tx)

b.SetPoS()

}))

setCodeAuthorization, _ := types.SignSetCode(accounts[0].key, types.SetCodeAuthorization{

Address: accounts[0].addr,

Nonce: uint64(genBlocks + 1),

})

var testSuite = []struct {

blockNumber rpc.BlockNumber

call TransactionArgs

overrides override.StateOverride

blockOverrides override.BlockOverrides

expectErr error

want uint64

}{

//simple transfer on latest block

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

To: &accounts[1].addr,

Value: (*hexutil.Big)(big.NewInt(1000)),

},

expectErr: nil,

want: 21000,

},

// simple transfer with insufficient funds on latest block

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &randomAccounts[0].addr,

To: &accounts[1].addr,

Value: (*hexutil.Big)(big.NewInt(1000)),

},

expectErr: core.ErrInsufficientFunds,

want: 21000,

},

// empty create

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{},

expectErr: nil,

want: 53000,

},

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{},

overrides: override.StateOverride{

randomAccounts[0].addr: override.OverrideAccount{Balance: newRPCBalance(new(big.Int).Mul(big.NewInt(1), big.NewInt(params.Ether)))},

},

expectErr: nil,

want: 53000,

},

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &randomAccounts[0].addr,

To: &randomAccounts[1].addr,

Value: (*hexutil.Big)(big.NewInt(1000)),

},

overrides: override.StateOverride{

randomAccounts[0].addr: override.OverrideAccount{Balance: newRPCBalance(big.NewInt(0))},

},

expectErr: core.ErrInsufficientFunds,

},

// Test for a bug where the gas price was set to zero but the basefee non-zero

//

// contract BasefeeChecker {

// constructor() {

// require(tx.gasprice >= block.basefee);

// if (tx.gasprice > 0) {

// require(block.basefee > 0);

// }

// }

//}

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

Input: hex2Bytes("6080604052348015600f57600080fd5b50483a1015601c57600080fd5b60003a111560315760004811603057600080fd5b5b603f80603e6000396000f3fe6080604052600080fdfea264697066735822122060729c2cee02b10748fae5200f1c9da4661963354973d9154c13a8e9ce9dee1564736f6c63430008130033"),

GasPrice: (*hexutil.Big)(big.NewInt(1_000_000_000)), // Legacy as pricing

},

expectErr: nil,

want: 67617,

},

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

Input: hex2Bytes("6080604052348015600f57600080fd5b50483a1015601c57600080fd5b60003a111560315760004811603057600080fd5b5b603f80603e6000396000f3fe6080604052600080fdfea264697066735822122060729c2cee02b10748fae5200f1c9da4661963354973d9154c13a8e9ce9dee1564736f6c63430008130033"),

MaxFeePerGas: (*hexutil.Big)(big.NewInt(1_000_000_000)), // 1559 gas pricing

},

expectErr: nil,

want: 67617,

},

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

Input: hex2Bytes("6080604052348015600f57600080fd5b50483a1015601c57600080fd5b60003a111560315760004811603057600080fd5b5b603f80603e6000396000f3fe6080604052600080fdfea264697066735822122060729c2cee02b10748fae5200f1c9da4661963354973d9154c13a8e9ce9dee1564736f6c63430008130033"),

GasPrice: nil, // No legacy gas pricing

MaxFeePerGas: nil, // No 1559 gas pricing

},

expectErr: nil,

want: 67595,

},

// Blobs should have no effect on gas estimate

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

To: &accounts[1].addr,

Value: (*hexutil.Big)(big.NewInt(1)),

BlobHashes: []common.Hash{{0x01, 0x22}},

BlobFeeCap: (*hexutil.Big)(big.NewInt(1)),

},

want: 21000,

},

// // SPDX-License-Identifier: GPL-3.0

//pragma solidity >=0.8.2 <0.9.0;

//

//contract BlockOverridesTest {

// function call() public view returns (uint256) {

// return block.number;

// }

//

// function estimate() public view {

// revert(string.concat("block ", uint2str(block.number)));

// }

//

// function uint2str(uint256 _i) internal pure returns (string memory str) {

// if (_i == 0) {

// return "0";

// }

// uint256 j = _i;

// uint256 length;

// while (j != 0) {

// length++;

// j /= 10;

// }

// bytes memory bstr = new bytes(length);

// uint256 k = length;

// j = _i;

// while (j != 0) {

// bstr[--k] = bytes1(uint8(48 + (j % 10)));

// j /= 10;

// }

// str = string(bstr);

// }

//}

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

To: &accounts[1].addr,

Data: hex2Bytes("0x3592d016"), //estimate

},

overrides: override.StateOverride{

accounts[1].addr: override.OverrideAccount{

Code: hex2Bytes("608060405234801561000f575f5ffd5b5060043610610034575f3560e01c806328b5e32b146100385780633592d0161461004b575b5f5ffd5b4360405190815260200160405180910390f35b610053610055565b005b61005e4361009d565b60405160200161006e91906101a5565b60408051601f198184030181529082905262461bcd60e51b8252610094916004016101cd565b60405180910390fd5b6060815f036100c35750506040805180820190915260018152600360fc1b602082015290565b815f5b81156100ec57806100d681610216565b91506100e59050600a83610242565b91506100c6565b5f8167ffffffffffffffff81111561010657610106610255565b6040519080825280601f01601f191660200182016040528015610130576020820181803683370190505b508593509050815b831561019c57610149600a85610269565b61015490603061027c565b60f81b8261016183610295565b92508281518110610174576101746102aa565b60200101906001600160f81b03191690815f1a905350610195600a85610242565b9350610138565b50949350505050565b650313637b1b5960d51b81525f82518060208501600685015e5f920160060191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f83011684010191505092915050565b634e487b7160e01b5f52601160045260245ffd5b5f6001820161022757610227610202565b5060010190565b634e487b7160e01b5f52601260045260245ffd5b5f826102505761025061022e565b500490565b634e487b7160e01b5f52604160045260245ffd5b5f826102775761027761022e565b500690565b8082018082111561028f5761028f610202565b92915050565b5f816102a3576102a3610202565b505f190190565b634e487b7160e01b5f52603260045260245ffdfea2646970667358221220a253cad1e2e3523b8c053c1d0cd1e39d7f3bafcedd73440a244872701f05dab264736f6c634300081c0033"),

},

},

blockOverrides: override.BlockOverrides{Number: (*hexutil.Big)(big.NewInt(11))},

expectErr: newRevertError(packRevert("block 11")),

},

// Should be able to send to an EIP-7702 delegated account.

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

To: &accounts[2].addr,

Value: (*hexutil.Big)(big.NewInt(1)),

},

want: 21000,

},

// Should be able to send as EIP-7702 delegated account.

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[2].addr,

To: &accounts[1].addr,

Value: (*hexutil.Big)(big.NewInt(1)),

},

want: 21000,

},

// Should be able to estimate SetCodeTx.

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

To: &accounts[1].addr,

Value: (*hexutil.Big)(big.NewInt(0)),

AuthorizationList: []types.SetCodeAuthorization{setCodeAuthorization},

},

want: 46000,

},

// Should retrieve the code of 0xef0001 || accounts[0].addr and return an invalid opcode error.

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

To: &accounts[0].addr,

Value: (*hexutil.Big)(big.NewInt(0)),

AuthorizationList: []types.SetCodeAuthorization{setCodeAuthorization},

},

expectErr: errors.New("invalid opcode: opcode 0xef not defined"),

},

// SetCodeTx with empty authorization list should fail.

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

To: &common.Address{},

Value: (*hexutil.Big)(big.NewInt(0)),

AuthorizationList: []types.SetCodeAuthorization{},

},

expectErr: core.ErrEmptyAuthList,

},

// SetCodeTx with nil `to` should fail.

{

blockNumber: rpc.LatestBlockNumber,

call: TransactionArgs{

From: &accounts[0].addr,

To: nil,

Value: (*hexutil.Big)(big.NewInt(0)),

AuthorizationList: []types.SetCodeAuthorization{setCodeAuthorization},

},

expectErr: core.ErrSetCodeTxCreate,

},

}

for i, tc := range testSuite {

result, err := api.EstimateGas(context.Background(), tc.call, &rpc.BlockNumberOrHash{BlockNumber: &tc.blockNumber}, &tc.overrides, &tc.blockOverrides)

if tc.expectErr != nil {

if err == nil {

t.Errorf("test %d: want error %v, have nothing", i, tc.expectErr)

continue

}

if !errors.Is(err, tc.expectErr) {

if err.Error() != tc.expectErr.Error() {

t.Errorf("test %d: error mismatch, want %v, have %v", i, tc.expectErr, err)

}

}

continue

}

if err != nil {

t.Errorf("test %d: want no error, have %v", i, err)

continue

}

if float64(result) > float64(tc.want)*(1+estimateGasErrorRatio) {

t.Errorf("test %d, result mismatch, have\n%v\n, want\n%v\n", i, uint64(result), tc.want)

}

}

}

func TestCall(t *testing.T) {

t.Parallel()

// Initialize test accounts

var (

accounts = newAccounts(3)

dad = common.HexToAddress("0x0000000000000000000000000000000000000dad")

genesis = &core.Genesis{

Config: params.MergedTestChainConfig,

Alloc: types.GenesisAlloc{

accounts[0].addr: {Balance: big.NewInt(params.Ether)},

accounts[1].addr: {Balance: big.NewInt(params.Ether)},

accounts[2].addr: {Balance: big.NewInt(params.Ether)},

dad: {

Balance: big.NewInt(params.Ether),

Nonce: 1,

Storage: map[common.Hash]common.Hash{

common.Hash{}: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"),

},

},

},

}

genBlocks = 10

signer = types.HomesteadSigner{}

)

api := NewBlockChainAPI(newTestBackend(t, genBlocks, genesis, beacon.New(ethash.NewFaker()), func(i int, b *core.BlockGen) {

// Transfer from account[0] to account[1]