github.com/theQRL/go-zond@v0.2.1/internal/zondapi/api_test.go (about)

     1  // Copyright 2023 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package zondapi
    18  
    19  import (
    20  	"context"
    21  	"encoding/json"
    22  	"errors"
    23  	"fmt"
    24  	"math/big"
    25  	"os"
    26  	"path/filepath"
    27  	"reflect"
    28  	"slices"
    29  	"testing"
    30  	"time"
    31  
    32  	"github.com/stretchr/testify/require"
    33  	"github.com/theQRL/go-qrllib/dilithium"
    34  	"github.com/theQRL/go-zond"
    35  	"github.com/theQRL/go-zond/accounts"
    36  	"github.com/theQRL/go-zond/common"
    37  	"github.com/theQRL/go-zond/common/hexutil"
    38  	"github.com/theQRL/go-zond/consensus"
    39  	"github.com/theQRL/go-zond/consensus/beacon"
    40  	"github.com/theQRL/go-zond/core"
    41  	"github.com/theQRL/go-zond/core/bloombits"
    42  	"github.com/theQRL/go-zond/core/rawdb"
    43  	"github.com/theQRL/go-zond/core/state"
    44  	"github.com/theQRL/go-zond/core/types"
    45  	"github.com/theQRL/go-zond/core/vm"
    46  	"github.com/theQRL/go-zond/crypto"
    47  	"github.com/theQRL/go-zond/crypto/pqcrypto"
    48  	"github.com/theQRL/go-zond/event"
    49  	"github.com/theQRL/go-zond/internal/blocktest"
    50  	"github.com/theQRL/go-zond/params"
    51  	"github.com/theQRL/go-zond/rpc"
    52  	"github.com/theQRL/go-zond/zonddb"
    53  )
    54  
    55  func testTransactionMarshal(t *testing.T, tests []txData, config *params.ChainConfig) {
    56  	t.Parallel()
    57  	var (
    58  		signer = types.LatestSigner(config)
    59  		key, _ = pqcrypto.HexToDilithium("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
    60  	)
    61  
    62  	for i, tt := range tests {
    63  		var tx2 types.Transaction
    64  		tx, err := types.SignNewTx(key, signer, tt.Tx)
    65  		if err != nil {
    66  			t.Fatalf("test %d: signing failed: %v", i, err)
    67  		}
    68  		// Regular transaction
    69  		if data, err := json.Marshal(tx); err != nil {
    70  			t.Fatalf("test %d: marshalling failed; %v", i, err)
    71  		} else if err = tx2.UnmarshalJSON(data); err != nil {
    72  			t.Fatalf("test %d: sunmarshal failed: %v", i, err)
    73  		} else if want, have := tx.Hash(), tx2.Hash(); want != have {
    74  			t.Fatalf("test %d: stx changed, want %x have %x", i, want, have)
    75  		}
    76  
    77  		// rpcTransaction
    78  		rpcTx := newRPCTransaction(tx, common.Hash{}, 0, 0, nil, config)
    79  		if data, err := json.Marshal(rpcTx); err != nil {
    80  			t.Fatalf("test %d: marshalling failed; %v", i, err)
    81  		} else if err = tx2.UnmarshalJSON(data); err != nil {
    82  			t.Fatalf("test %d: unmarshal failed: %v", i, err)
    83  		} else if want, have := tx.Hash(), tx2.Hash(); want != have {
    84  			t.Fatalf("test %d: tx changed, want %x have %x", i, want, have)
    85  		} else {
    86  			want, have := tt.Want, string(data)
    87  			require.JSONEqf(t, want, have, "test %d: rpc json not match, want %s have %s", i, want, have)
    88  		}
    89  	}
    90  }
    91  
    92  func TestTransaction_RoundTripRpcJSON(t *testing.T) {
    93  	var (
    94  		config = params.AllBeaconProtocolChanges
    95  		tests  = allTransactionTypes(common.Address{0xde, 0xad}, config)
    96  	)
    97  	testTransactionMarshal(t, tests, config)
    98  }
    99  
   100  type txData struct {
   101  	Tx   types.TxData
   102  	Want string
   103  }
   104  
   105  func allTransactionTypes(addr common.Address, config *params.ChainConfig) []txData {
   106  	return []txData{
   107  		{
   108  			Tx: &types.DynamicFeeTx{
   109  				ChainID:   config.ChainID,
   110  				Nonce:     5,
   111  				GasTipCap: big.NewInt(6),
   112  				GasFeeCap: big.NewInt(9),
   113  				Gas:       7,
   114  				To:        &addr,
   115  				Value:     big.NewInt(8),
   116  				Data:      []byte{0, 1, 2, 3, 4},
   117  				AccessList: types.AccessList{
   118  					types.AccessTuple{
   119  						Address:     common.Address{0x2},
   120  						StorageKeys: []common.Hash{types.EmptyRootHash},
   121  					},
   122  				},
   123  				Signature: []byte{},
   124  				PublicKey: []byte{},
   125  			},
   126  			Want: `{
   127  				"blockHash": null,
   128  				"blockNumber": null,
   129  				"from": "Z20a1a68e6818a1142f85671db01ef7226debf822",
   130  				"gas": "0x7",
   131  				"gasPrice": "0x9",
   132  				"maxFeePerGas": "0x9",
   133  				"maxPriorityFeePerGas": "0x6",
   134  				"hash": "0x88232264d509b4bfd84f5f1f9efc73ef8f1c4b478e5c7a945ff6296b6bd154e4",
   135  				"input": "0x0001020304",
   136  				"nonce": "0x5",
   137  				"to": "Zdead000000000000000000000000000000000000",
   138  				"transactionIndex": null,
   139  				"value": "0x8",
   140  				"type": "0x2",
   141  				"accessList": [
   142  					{
   143  						"address": "Z0200000000000000000000000000000000000000",
   144  						"storageKeys": [
   145  							"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"
   146  						]
   147  					}
   148  				],
   149  				"chainId": "0x539",
   150  				"signature": "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",
   151  				"publicKey": "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"
   152  			}`,
   153  		},
   154  		{
   155  			Tx: &types.DynamicFeeTx{
   156  				ChainID:    config.ChainID,
   157  				Nonce:      5,
   158  				GasTipCap:  big.NewInt(6),
   159  				GasFeeCap:  big.NewInt(9),
   160  				Gas:        7,
   161  				To:         nil,
   162  				Value:      big.NewInt(8),
   163  				Data:       []byte{0, 1, 2, 3, 4},
   164  				AccessList: types.AccessList{},
   165  				Signature:  []byte{},
   166  				PublicKey:  []byte{},
   167  			},
   168  			Want: `{
   169  					"blockHash": null,
   170  					"blockNumber": null,
   171  					"from": "Z20a1a68e6818a1142f85671db01ef7226debf822",
   172  					"gas": "0x7",
   173  					"gasPrice": "0x9",
   174  					"maxFeePerGas": "0x9",
   175  					"maxPriorityFeePerGas": "0x6",
   176  					"hash": "0xf897dd01bb279e3500cac8aea4fad94b9957dee7131378edb4633c72a3a1298e",
   177  					"input": "0x0001020304",
   178  					"nonce": "0x5",
   179  					"to": null,
   180  					"transactionIndex": null,
   181  					"value": "0x8",
   182  					"type": "0x2",
   183  					"accessList": [],
   184  					"chainId": "0x539",
   185  					"signature": "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",
   186  					"publicKey": "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"
   187  				}`,
   188  		},
   189  	}
   190  }
   191  
   192  type testBackend struct {
   193  	db      zonddb.Database
   194  	chain   *core.BlockChain
   195  	pending *types.Block
   196  }
   197  
   198  func newTestBackend(t *testing.T, n int, gspec *core.Genesis, engine consensus.Engine, generator func(i int, b *core.BlockGen)) *testBackend {
   199  	var (
   200  		cacheConfig = &core.CacheConfig{
   201  			TrieCleanLimit:    256,
   202  			TrieDirtyLimit:    256,
   203  			TrieTimeLimit:     5 * time.Minute,
   204  			SnapshotLimit:     0,
   205  			TrieDirtyDisabled: true, // Archive mode
   206  		}
   207  	)
   208  	// Generate blocks for testing
   209  	db, blocks, _ := core.GenerateChainWithGenesis(gspec, engine, n, generator)
   210  	txlookupLimit := uint64(0)
   211  	chain, err := core.NewBlockChain(db, cacheConfig, gspec, engine, vm.Config{}, &txlookupLimit)
   212  	if err != nil {
   213  		t.Fatalf("failed to create tester chain: %v", err)
   214  	}
   215  	if n, err := chain.InsertChain(blocks); err != nil {
   216  		t.Fatalf("block %d: failed to insert into chain: %v", n, err)
   217  	}
   218  
   219  	backend := &testBackend{db: db, chain: chain}
   220  	return backend
   221  }
   222  
   223  func (b *testBackend) setPendingBlock(block *types.Block) {
   224  	b.pending = block
   225  }
   226  
   227  func (b testBackend) SyncProgress() zond.SyncProgress { return zond.SyncProgress{} }
   228  func (b testBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
   229  	return big.NewInt(0), nil
   230  }
   231  func (b testBackend) FeeHistory(ctx context.Context, blockCount uint64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
   232  	return nil, nil, nil, nil, nil
   233  }
   234  func (b testBackend) ChainDb() zonddb.Database          { return b.db }
   235  func (b testBackend) AccountManager() *accounts.Manager { return nil }
   236  func (b testBackend) ExtRPCEnabled() bool               { return false }
   237  func (b testBackend) RPCGasCap() uint64                 { return 10000000 }
   238  func (b testBackend) RPCZVMTimeout() time.Duration      { return time.Second }
   239  func (b testBackend) RPCTxFeeCap() float64              { return 0 }
   240  func (b testBackend) SetHead(number uint64)             {}
   241  func (b testBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
   242  	if number == rpc.LatestBlockNumber {
   243  		return b.chain.CurrentBlock(), nil
   244  	}
   245  	if number == rpc.PendingBlockNumber && b.pending != nil {
   246  		return b.pending.Header(), nil
   247  	}
   248  	return b.chain.GetHeaderByNumber(uint64(number)), nil
   249  }
   250  func (b testBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
   251  	return b.chain.GetHeaderByHash(hash), nil
   252  }
   253  func (b testBackend) HeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error) {
   254  	if blockNr, ok := blockNrOrHash.Number(); ok {
   255  		return b.HeaderByNumber(ctx, blockNr)
   256  	}
   257  	if blockHash, ok := blockNrOrHash.Hash(); ok {
   258  		return b.HeaderByHash(ctx, blockHash)
   259  	}
   260  	panic("unknown type rpc.BlockNumberOrHash")
   261  }
   262  func (b testBackend) CurrentHeader() *types.Header { return b.chain.CurrentBlock() }
   263  func (b testBackend) CurrentBlock() *types.Header  { return b.chain.CurrentBlock() }
   264  func (b testBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
   265  	if number == rpc.LatestBlockNumber {
   266  		head := b.chain.CurrentBlock()
   267  		return b.chain.GetBlock(head.Hash(), head.Number.Uint64()), nil
   268  	}
   269  	if number == rpc.PendingBlockNumber {
   270  		return b.pending, nil
   271  	}
   272  	return b.chain.GetBlockByNumber(uint64(number)), nil
   273  }
   274  func (b testBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
   275  	return b.chain.GetBlockByHash(hash), nil
   276  }
   277  func (b testBackend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error) {
   278  	if blockNr, ok := blockNrOrHash.Number(); ok {
   279  		return b.BlockByNumber(ctx, blockNr)
   280  	}
   281  	if blockHash, ok := blockNrOrHash.Hash(); ok {
   282  		return b.BlockByHash(ctx, blockHash)
   283  	}
   284  	panic("unknown type rpc.BlockNumberOrHash")
   285  }
   286  func (b testBackend) GetBody(ctx context.Context, hash common.Hash, number rpc.BlockNumber) (*types.Body, error) {
   287  	return b.chain.GetBlock(hash, uint64(number.Int64())).Body(), nil
   288  }
   289  func (b testBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
   290  	if number == rpc.PendingBlockNumber {
   291  		panic("pending state not implemented")
   292  	}
   293  	header, err := b.HeaderByNumber(ctx, number)
   294  	if err != nil {
   295  		return nil, nil, err
   296  	}
   297  	if header == nil {
   298  		return nil, nil, errors.New("header not found")
   299  	}
   300  	stateDb, err := b.chain.StateAt(header.Root)
   301  	return stateDb, header, err
   302  }
   303  func (b testBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) {
   304  	if blockNr, ok := blockNrOrHash.Number(); ok {
   305  		return b.StateAndHeaderByNumber(ctx, blockNr)
   306  	}
   307  	panic("only implemented for number")
   308  }
   309  func (b testBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) { panic("implement me") }
   310  func (b testBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
   311  	header, err := b.HeaderByHash(ctx, hash)
   312  	if header == nil || err != nil {
   313  		return nil, err
   314  	}
   315  	receipts := rawdb.ReadReceipts(b.db, hash, header.Number.Uint64(), header.Time, b.chain.Config())
   316  	return receipts, nil
   317  }
   318  
   319  func (b testBackend) GetZVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockContext *vm.BlockContext) *vm.ZVM {
   320  	if vmConfig == nil {
   321  		vmConfig = b.chain.GetVMConfig()
   322  	}
   323  	txContext := core.NewZVMTxContext(msg)
   324  	context := core.NewZVMBlockContext(header, b.chain, nil)
   325  	if blockContext != nil {
   326  		context = *blockContext
   327  	}
   328  	return vm.NewZVM(context, txContext, state, b.chain.Config(), *vmConfig)
   329  }
   330  func (b testBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
   331  	panic("implement me")
   332  }
   333  func (b testBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {
   334  	panic("implement me")
   335  }
   336  func (b testBackend) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription {
   337  	panic("implement me")
   338  }
   339  func (b testBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
   340  	panic("implement me")
   341  }
   342  func (b testBackend) GetTransaction(ctx context.Context, txHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
   343  	tx, blockHash, blockNumber, index := rawdb.ReadTransaction(b.db, txHash)
   344  	return tx, blockHash, blockNumber, index, nil
   345  }
   346  func (b testBackend) GetPoolTransactions() (types.Transactions, error)         { panic("implement me") }
   347  func (b testBackend) GetPoolTransaction(txHash common.Hash) *types.Transaction { panic("implement me") }
   348  func (b testBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error) {
   349  	panic("implement me")
   350  }
   351  func (b testBackend) Stats() (pending int, queued int) { panic("implement me") }
   352  func (b testBackend) TxPoolContent() (map[common.Address][]*types.Transaction, map[common.Address][]*types.Transaction) {
   353  	panic("implement me")
   354  }
   355  func (b testBackend) TxPoolContentFrom(addr common.Address) ([]*types.Transaction, []*types.Transaction) {
   356  	panic("implement me")
   357  }
   358  func (b testBackend) SubscribeNewTxsEvent(events chan<- core.NewTxsEvent) event.Subscription {
   359  	panic("implement me")
   360  }
   361  func (b testBackend) ChainConfig() *params.ChainConfig { return b.chain.Config() }
   362  func (b testBackend) Engine() consensus.Engine         { return b.chain.Engine() }
   363  func (b testBackend) GetLogs(ctx context.Context, blockHash common.Hash, number uint64) ([][]*types.Log, error) {
   364  	panic("implement me")
   365  }
   366  func (b testBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
   367  	panic("implement me")
   368  }
   369  func (b testBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
   370  	panic("implement me")
   371  }
   372  func (b testBackend) BloomStatus() (uint64, uint64) { panic("implement me") }
   373  func (b testBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
   374  	panic("implement me")
   375  }
   376  
   377  func TestEstimateGas(t *testing.T) {
   378  	t.Parallel()
   379  	// Initialize test accounts
   380  	var (
   381  		accounts = newAccounts(2)
   382  		genesis  = &core.Genesis{
   383  			Config: params.TestChainConfig,
   384  			Alloc: core.GenesisAlloc{
   385  				accounts[0].addr: {Balance: big.NewInt(params.Ether)},
   386  				accounts[1].addr: {Balance: big.NewInt(params.Ether)},
   387  			},
   388  		}
   389  		genBlocks      = 10
   390  		signer         = types.ShanghaiSigner{ChainId: big.NewInt(1)}
   391  		randomAccounts = newAccounts(2)
   392  	)
   393  	api := NewBlockChainAPI(newTestBackend(t, genBlocks, genesis, beacon.NewFaker(), func(i int, b *core.BlockGen) {
   394  		// Transfer from account[0] to account[1]
   395  		//    value: 1000 wei
   396  		//    fee:   0 wei
   397  		tx, _ := types.SignTx(types.NewTx(&types.DynamicFeeTx{Nonce: uint64(i), To: &accounts[1].addr, Value: big.NewInt(1000), Gas: params.TxGas, GasFeeCap: b.BaseFee(), Data: nil}), signer, accounts[0].key)
   398  		b.AddTx(tx)
   399  	}))
   400  	var testSuite = []struct {
   401  		blockNumber rpc.BlockNumber
   402  		call        TransactionArgs
   403  		overrides   StateOverride
   404  		expectErr   error
   405  		want        uint64
   406  	}{
   407  		// simple transfer on latest block
   408  		{
   409  			blockNumber: rpc.LatestBlockNumber,
   410  			call: TransactionArgs{
   411  				From:  &accounts[0].addr,
   412  				To:    &accounts[1].addr,
   413  				Value: (*hexutil.Big)(big.NewInt(1000)),
   414  			},
   415  			expectErr: nil,
   416  			want:      21000,
   417  		},
   418  		// simple transfer with insufficient funds on latest block
   419  		{
   420  			blockNumber: rpc.LatestBlockNumber,
   421  			call: TransactionArgs{
   422  				From:  &randomAccounts[0].addr,
   423  				To:    &accounts[1].addr,
   424  				Value: (*hexutil.Big)(big.NewInt(1000)),
   425  			},
   426  			expectErr: core.ErrInsufficientFunds,
   427  			want:      21000,
   428  		},
   429  		// empty create
   430  		{
   431  			blockNumber: rpc.LatestBlockNumber,
   432  			call:        TransactionArgs{},
   433  			expectErr:   nil,
   434  			want:        53000,
   435  		},
   436  		{
   437  			blockNumber: rpc.LatestBlockNumber,
   438  			call:        TransactionArgs{},
   439  			overrides: StateOverride{
   440  				randomAccounts[0].addr: OverrideAccount{Balance: newRPCBalance(new(big.Int).Mul(big.NewInt(1), big.NewInt(params.Ether)))},
   441  			},
   442  			expectErr: nil,
   443  			want:      53000,
   444  		},
   445  		{
   446  			blockNumber: rpc.LatestBlockNumber,
   447  			call: TransactionArgs{
   448  				From:  &randomAccounts[0].addr,
   449  				To:    &randomAccounts[1].addr,
   450  				Value: (*hexutil.Big)(big.NewInt(1000)),
   451  			},
   452  			overrides: StateOverride{
   453  				randomAccounts[0].addr: OverrideAccount{Balance: newRPCBalance(big.NewInt(0))},
   454  			},
   455  			expectErr: core.ErrInsufficientFunds,
   456  		},
   457  	}
   458  	for i, tc := range testSuite {
   459  		result, err := api.EstimateGas(context.Background(), tc.call, &rpc.BlockNumberOrHash{BlockNumber: &tc.blockNumber}, &tc.overrides)
   460  		if tc.expectErr != nil {
   461  			if err == nil {
   462  				t.Errorf("test %d: want error %v, have nothing", i, tc.expectErr)
   463  				continue
   464  			}
   465  			if !errors.Is(err, tc.expectErr) {
   466  				t.Errorf("test %d: error mismatch, want %v, have %v", i, tc.expectErr, err)
   467  			}
   468  			continue
   469  		}
   470  		if err != nil {
   471  			t.Errorf("test %d: want no error, have %v", i, err)
   472  			continue
   473  		}
   474  		if uint64(result) != tc.want {
   475  			t.Errorf("test %d, result mismatch, have\n%v\n, want\n%v\n", i, uint64(result), tc.want)
   476  		}
   477  	}
   478  }
   479  
   480  func TestCall(t *testing.T) {
   481  	t.Parallel()
   482  	// Initialize test accounts
   483  	var (
   484  		accounts = newAccounts(3)
   485  		genesis  = &core.Genesis{
   486  			Config: params.TestChainConfig,
   487  			Alloc: core.GenesisAlloc{
   488  				accounts[0].addr: {Balance: big.NewInt(params.Ether)},
   489  				accounts[1].addr: {Balance: big.NewInt(params.Ether)},
   490  				accounts[2].addr: {Balance: big.NewInt(params.Ether)},
   491  			},
   492  		}
   493  		genBlocks = 10
   494  		signer    = types.ShanghaiSigner{ChainId: big.NewInt(1)}
   495  	)
   496  	api := NewBlockChainAPI(newTestBackend(t, genBlocks, genesis, beacon.NewFaker(), func(i int, b *core.BlockGen) {
   497  		// Transfer from account[0] to account[1]
   498  		//    value: 1000 wei
   499  		//    fee:   0 wei
   500  		tx, _ := types.SignTx(types.NewTx(&types.DynamicFeeTx{Nonce: uint64(i), To: &accounts[1].addr, Value: big.NewInt(1000), Gas: params.TxGas, GasFeeCap: b.BaseFee(), Data: nil}), signer, accounts[0].key)
   501  		b.AddTx(tx)
   502  	}))
   503  	randomAccounts := newAccounts(3)
   504  	var testSuite = []struct {
   505  		blockNumber    rpc.BlockNumber
   506  		overrides      StateOverride
   507  		call           TransactionArgs
   508  		blockOverrides BlockOverrides
   509  		expectErr      error
   510  		want           string
   511  	}{
   512  		// transfer on genesis
   513  		{
   514  			blockNumber: rpc.BlockNumber(0),
   515  			call: TransactionArgs{
   516  				From:  &accounts[0].addr,
   517  				To:    &accounts[1].addr,
   518  				Value: (*hexutil.Big)(big.NewInt(1000)),
   519  			},
   520  			expectErr: nil,
   521  			want:      "0x",
   522  		},
   523  		// transfer on the head
   524  		{
   525  			blockNumber: rpc.BlockNumber(genBlocks),
   526  			call: TransactionArgs{
   527  				From:  &accounts[0].addr,
   528  				To:    &accounts[1].addr,
   529  				Value: (*hexutil.Big)(big.NewInt(1000)),
   530  			},
   531  			expectErr: nil,
   532  			want:      "0x",
   533  		},
   534  		// transfer on a non-existent block, error expects
   535  		{
   536  			blockNumber: rpc.BlockNumber(genBlocks + 1),
   537  			call: TransactionArgs{
   538  				From:  &accounts[0].addr,
   539  				To:    &accounts[1].addr,
   540  				Value: (*hexutil.Big)(big.NewInt(1000)),
   541  			},
   542  			expectErr: errors.New("header not found"),
   543  		},
   544  		// transfer on the latest block
   545  		{
   546  			blockNumber: rpc.LatestBlockNumber,
   547  			call: TransactionArgs{
   548  				From:  &accounts[0].addr,
   549  				To:    &accounts[1].addr,
   550  				Value: (*hexutil.Big)(big.NewInt(1000)),
   551  			},
   552  			expectErr: nil,
   553  			want:      "0x",
   554  		},
   555  		// Call which can only succeed if state is state overridden
   556  		{
   557  			blockNumber: rpc.LatestBlockNumber,
   558  			call: TransactionArgs{
   559  				From:  &randomAccounts[0].addr,
   560  				To:    &randomAccounts[1].addr,
   561  				Value: (*hexutil.Big)(big.NewInt(1000)),
   562  			},
   563  			overrides: StateOverride{
   564  				randomAccounts[0].addr: OverrideAccount{Balance: newRPCBalance(new(big.Int).Mul(big.NewInt(1), big.NewInt(params.Ether)))},
   565  			},
   566  			want: "0x",
   567  		},
   568  		// Invalid call without state overriding
   569  		{
   570  			blockNumber: rpc.LatestBlockNumber,
   571  			call: TransactionArgs{
   572  				From:  &randomAccounts[0].addr,
   573  				To:    &randomAccounts[1].addr,
   574  				Value: (*hexutil.Big)(big.NewInt(1000)),
   575  			},
   576  			expectErr: core.ErrInsufficientFunds,
   577  		},
   578  		// Successful simple contract call
   579  		//
   580  		// // SPDX-License-Identifier: GPL-3.0
   581  		// // TODO(now.youtrack.cloud/issue/TGZ-30)
   582  		//  pragma hyperion >=0.7.0 <0.8.0;
   583  		//
   584  		//  /**
   585  		//   * @title Storage
   586  		//   * @dev Store & retrieve value in a variable
   587  		//   */
   588  		//  contract Storage {
   589  		//      uint256 public number;
   590  		//      constructor() {
   591  		//          number = block.number;
   592  		//      }
   593  		//  }
   594  		{
   595  			blockNumber: rpc.LatestBlockNumber,
   596  			call: TransactionArgs{
   597  				From: &randomAccounts[0].addr,
   598  				To:   &randomAccounts[2].addr,
   599  				Data: hex2Bytes("8381f58a"), // call number()
   600  			},
   601  			overrides: StateOverride{
   602  				randomAccounts[2].addr: OverrideAccount{
   603  					Code:      hex2Bytes("6080604052348015600f57600080fd5b506004361060285760003560e01c80638381f58a14602d575b600080fd5b60336049565b6040518082815260200191505060405180910390f35b6000548156fea2646970667358221220eab35ffa6ab2adfe380772a48b8ba78e82a1b820a18fcb6f59aa4efb20a5f60064736f6c63430007040033"),
   604  					StateDiff: &map[common.Hash]common.Hash{{}: common.BigToHash(big.NewInt(123))},
   605  				},
   606  			},
   607  			want: "0x000000000000000000000000000000000000000000000000000000000000007b",
   608  		},
   609  		// Block overrides should work
   610  		{
   611  			blockNumber: rpc.LatestBlockNumber,
   612  			call: TransactionArgs{
   613  				From: &accounts[1].addr,
   614  				Input: &hexutil.Bytes{
   615  					0x43,             // NUMBER
   616  					0x60, 0x00, 0x52, // MSTORE offset 0
   617  					0x60, 0x20, 0x60, 0x00, 0xf3,
   618  				},
   619  			},
   620  			blockOverrides: BlockOverrides{Number: (*hexutil.Big)(big.NewInt(11))},
   621  			want:           "0x000000000000000000000000000000000000000000000000000000000000000b",
   622  		},
   623  	}
   624  	for i, tc := range testSuite {
   625  		result, err := api.Call(context.Background(), tc.call, rpc.BlockNumberOrHash{BlockNumber: &tc.blockNumber}, &tc.overrides, &tc.blockOverrides)
   626  		if tc.expectErr != nil {
   627  			if err == nil {
   628  				t.Errorf("test %d: want error %v, have nothing", i, tc.expectErr)
   629  				continue
   630  			}
   631  			if !errors.Is(err, tc.expectErr) {
   632  				// Second try
   633  				if !reflect.DeepEqual(err, tc.expectErr) {
   634  					t.Errorf("test %d: error mismatch, want %v, have %v", i, tc.expectErr, err)
   635  				}
   636  			}
   637  			continue
   638  		}
   639  		if err != nil {
   640  			t.Errorf("test %d: want no error, have %v", i, err)
   641  			continue
   642  		}
   643  		if !reflect.DeepEqual(result.String(), tc.want) {
   644  			t.Errorf("test %d, result mismatch, have\n%v\n, want\n%v\n", i, result.String(), tc.want)
   645  		}
   646  	}
   647  }
   648  
   649  type Account struct {
   650  	key  *dilithium.Dilithium
   651  	addr common.Address
   652  }
   653  
   654  func newAccounts(n int) (accounts []Account) {
   655  	for i := 0; i < n; i++ {
   656  		key, _ := crypto.GenerateDilithiumKey()
   657  		addr := key.GetAddress()
   658  		accounts = append(accounts, Account{key: key, addr: addr})
   659  	}
   660  	slices.SortFunc(accounts, func(a, b Account) int { return a.addr.Cmp(b.addr) })
   661  	return accounts
   662  }
   663  
   664  func newRPCBalance(balance *big.Int) **hexutil.Big {
   665  	rpcBalance := (*hexutil.Big)(balance)
   666  	return &rpcBalance
   667  }
   668  
   669  func hex2Bytes(str string) *hexutil.Bytes {
   670  	rpcBytes := hexutil.Bytes(common.Hex2Bytes(str))
   671  	return &rpcBytes
   672  }
   673  
   674  func TestRPCMarshalBlock(t *testing.T) {
   675  	t.Parallel()
   676  	var (
   677  		txs []*types.Transaction
   678  		to  = common.BytesToAddress([]byte{0x11})
   679  	)
   680  	for i := uint64(1); i <= 4; i++ {
   681  		var tx *types.Transaction
   682  		if i%2 == 0 {
   683  			tx = types.NewTx(&types.DynamicFeeTx{
   684  				Nonce:     i,
   685  				GasFeeCap: big.NewInt(11111),
   686  				Gas:       1111,
   687  				To:        &to,
   688  				Value:     big.NewInt(111),
   689  				Data:      []byte{0x11, 0x11, 0x11},
   690  			})
   691  		} else {
   692  			tx = types.NewTx(&types.DynamicFeeTx{
   693  				ChainID:   big.NewInt(1337),
   694  				Nonce:     i,
   695  				GasFeeCap: big.NewInt(11111),
   696  				Gas:       1111,
   697  				To:        &to,
   698  				Value:     big.NewInt(111),
   699  				Data:      []byte{0x11, 0x11, 0x11},
   700  			})
   701  		}
   702  		txs = append(txs, tx)
   703  	}
   704  	block := types.NewBlock(&types.Header{Number: big.NewInt(100)}, &types.Body{Transactions: txs}, nil, blocktest.NewHasher())
   705  
   706  	var testSuite = []struct {
   707  		inclTx bool
   708  		fullTx bool
   709  		want   string
   710  	}{
   711  		// without txs
   712  		{
   713  			inclTx: false,
   714  			fullTx: false,
   715  			want: `{
   716  					"extraData": "0x",
   717  					"gasLimit": "0x0",
   718  					"gasUsed": "0x0",
   719  					"hash": "0x36b2055dd577db48cb2625b7448e3afd26c7b7108b8fb83837cc6f0381807c4f",
   720  					"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
   721  					"miner": "Z0000000000000000000000000000000000000000",
   722  					"number": "0x64",
   723  					"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
   724  					"prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000",
   725  					"receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
   726  					"size": "0x72df",
   727  					"stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
   728  					"timestamp": "0x0",
   729  					"transactionsRoot": "0xfda40e1eaee7aca3e597a67463c3e732bbd85e643ec3924f537c20f91ba6f9ca"
   730  				}`,
   731  		},
   732  		// only tx hashes
   733  		{
   734  			inclTx: true,
   735  			fullTx: false,
   736  			want: `{
   737  						"extraData": "0x",
   738  						"gasLimit": "0x0",
   739  						"gasUsed": "0x0",
   740  						"hash": "0x36b2055dd577db48cb2625b7448e3afd26c7b7108b8fb83837cc6f0381807c4f",
   741  						"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
   742  						"miner": "Z0000000000000000000000000000000000000000",
   743  						"number": "0x64",
   744  						"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
   745  						"prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000",
   746  						"receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
   747  						"size": "0x72df",
   748  						"stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
   749  						"timestamp": "0x0",
   750  						"transactions": [
   751  							"0x608f1f522dc754d227a27923dafd25ebeb23ee72dc1c56c13ed54954393f0635",
   752  							"0x2a181750debd4311025178efe71cac30116c055bdec2d1feb0750d69bf93e684",
   753  							"0x0db1a64132de5af29fc17acb90abae123434a5d2fce523da34209b6eb6b64ba8",
   754  							"0x9733fac71942cf3e96c4b519a884cb87437711fa94e35af7de48d99ef096f134"
   755  						],
   756  						"transactionsRoot": "0xfda40e1eaee7aca3e597a67463c3e732bbd85e643ec3924f537c20f91ba6f9ca"
   757  					}`,
   758  		},
   759  		// full tx details
   760  		{
   761  			inclTx: true,
   762  			fullTx: true,
   763  			want: `{
   764  						"extraData": "0x",
   765  						"gasLimit": "0x0",
   766  						"gasUsed": "0x0",
   767  						"hash": "0x36b2055dd577db48cb2625b7448e3afd26c7b7108b8fb83837cc6f0381807c4f",
   768  						"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
   769  						"miner": "Z0000000000000000000000000000000000000000",
   770  						"number": "0x64",
   771  						"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
   772  						"prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000",
   773  						"receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
   774  						"size": "0x72df",
   775  						"stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
   776  						"timestamp": "0x0",
   777  						"transactions": [
   778  							{
   779  								"blockHash": "0x36b2055dd577db48cb2625b7448e3afd26c7b7108b8fb83837cc6f0381807c4f",
   780  								"blockNumber": "0x64",
   781  								"from": "Z0000000000000000000000000000000000000000",
   782  								"gas": "0x457",
   783  								"gasPrice": "0x2b67",
   784  								"maxFeePerGas": "0x2b67",
   785  								"maxPriorityFeePerGas": "0x0",
   786  								"hash": "0x608f1f522dc754d227a27923dafd25ebeb23ee72dc1c56c13ed54954393f0635",
   787  								"input": "0x111111",
   788  								"nonce": "0x1",
   789  								"to": "Z0000000000000000000000000000000000000011",
   790  								"transactionIndex": "0x0",
   791  								"value": "0x6f",
   792  								"type": "0x2",
   793  								"accessList": [],
   794  								"chainId": "0x539",
   795  								"publicKey": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
   796  								"signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
   797  
   798  							},
   799  							{
   800  								"accessList": [],
   801  								"blockHash": "0x36b2055dd577db48cb2625b7448e3afd26c7b7108b8fb83837cc6f0381807c4f",
   802  								"blockNumber": "0x64",
   803  								"from": "Z0000000000000000000000000000000000000000",
   804  								"gas": "0x457",
   805  								"gasPrice": "0x2b67",
   806  								"hash": "0x2a181750debd4311025178efe71cac30116c055bdec2d1feb0750d69bf93e684",
   807  								"input": "0x111111",
   808  								"maxFeePerGas": "0x2b67",
   809  								"maxPriorityFeePerGas": "0x0",
   810  								"nonce": "0x2",
   811  								"to": "Z0000000000000000000000000000000000000011",
   812  								"transactionIndex": "0x1",
   813  								"value": "0x6f",
   814  								"type": "0x2",
   815  								"chainId": "0x0",
   816  								"publicKey": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
   817  								"signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
   818  							},
   819  							{
   820  								"blockHash": "0x36b2055dd577db48cb2625b7448e3afd26c7b7108b8fb83837cc6f0381807c4f",
   821  								"blockNumber": "0x64",
   822  								"from": "Z0000000000000000000000000000000000000000",
   823  								"gas": "0x457",
   824  								"gasPrice": "0x2b67",
   825  								"maxFeePerGas": "0x2b67",
   826  								"maxPriorityFeePerGas": "0x0",
   827  								"hash": "0x0db1a64132de5af29fc17acb90abae123434a5d2fce523da34209b6eb6b64ba8",
   828  								"input": "0x111111",
   829  								"nonce": "0x3",
   830  								"to": "Z0000000000000000000000000000000000000011",
   831  								"transactionIndex": "0x2",
   832  								"value": "0x6f",
   833  								"type": "0x2",
   834  								"accessList": [],
   835  								"chainId": "0x539",
   836  								"publicKey": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
   837  								"signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
   838  							},
   839  							{
   840  								"accessList": [],
   841  								"blockHash": "0x36b2055dd577db48cb2625b7448e3afd26c7b7108b8fb83837cc6f0381807c4f",
   842  								"blockNumber": "0x64",
   843  								"from": "Z0000000000000000000000000000000000000000",
   844  								"gas": "0x457",
   845  								"gasPrice": "0x2b67",
   846  								"hash": "0x9733fac71942cf3e96c4b519a884cb87437711fa94e35af7de48d99ef096f134",
   847  								"input": "0x111111",
   848  								"maxFeePerGas": "0x2b67",
   849  								"maxPriorityFeePerGas": "0x0",
   850  								"nonce": "0x4",
   851  								"to": "Z0000000000000000000000000000000000000011",
   852  								"transactionIndex": "0x3",
   853  								"value": "0x6f",
   854  								"type": "0x2",
   855  								"chainId": "0x0",
   856  								"publicKey": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
   857  								"signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
   858  							}
   859  						],
   860  						"transactionsRoot": "0xfda40e1eaee7aca3e597a67463c3e732bbd85e643ec3924f537c20f91ba6f9ca"
   861  					}`,
   862  		},
   863  	}
   864  
   865  	for i, tc := range testSuite {
   866  		resp := RPCMarshalBlock(block, tc.inclTx, tc.fullTx, params.MainnetChainConfig)
   867  		out, err := json.Marshal(resp)
   868  		if err != nil {
   869  			t.Errorf("test %d: json marshal error: %v", i, err)
   870  			continue
   871  		}
   872  		require.JSONEqf(t, tc.want, string(out), "test %d", i)
   873  	}
   874  }
   875  
   876  func TestRPCGetBlockOrHeader(t *testing.T) {
   877  	t.Parallel()
   878  
   879  	// Initialize test accounts
   880  	var (
   881  		acc1Key, _                = pqcrypto.HexToDilithium("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
   882  		acc2Key, _                = pqcrypto.HexToDilithium("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee")
   883  		acc1Addr                  = acc1Key.GetAddress()
   884  		acc2Addr   common.Address = acc2Key.GetAddress()
   885  		genesis                   = &core.Genesis{
   886  			Config: params.TestChainConfig,
   887  			Alloc: core.GenesisAlloc{
   888  				acc1Addr: {Balance: big.NewInt(params.Ether)},
   889  				acc2Addr: {Balance: big.NewInt(params.Ether)},
   890  			},
   891  		}
   892  		genBlocks = 10
   893  		signer    = types.ShanghaiSigner{ChainId: big.NewInt(1)}
   894  		tx        = types.NewTx(&types.DynamicFeeTx{
   895  			Nonce:     11,
   896  			GasFeeCap: big.NewInt(11111),
   897  			Gas:       1111,
   898  			To:        &acc2Addr,
   899  			Value:     big.NewInt(111),
   900  			Data:      []byte{0x11, 0x11, 0x11},
   901  		})
   902  		withdrawal = &types.Withdrawal{
   903  			Index:     0,
   904  			Validator: 1,
   905  			Address:   common.Address{0x12, 0x34},
   906  			Amount:    10,
   907  		}
   908  		pending = types.NewBlock(&types.Header{Number: big.NewInt(11), Time: 42}, &types.Body{Transactions: types.Transactions{tx}, Withdrawals: types.Withdrawals{withdrawal}}, nil, blocktest.NewHasher())
   909  	)
   910  	backend := newTestBackend(t, genBlocks, genesis, beacon.NewFaker(), func(i int, b *core.BlockGen) {
   911  		// Transfer from account[0] to account[1]
   912  		//    value: 1000 wei
   913  		//    fee:   0 wei
   914  		tx, _ := types.SignTx(types.NewTx(&types.DynamicFeeTx{Nonce: uint64(i), To: &acc2Addr, Value: big.NewInt(1000), Gas: params.TxGas, GasFeeCap: b.BaseFee(), Data: nil}), signer, acc1Key)
   915  		b.AddTx(tx)
   916  	})
   917  	backend.setPendingBlock(pending)
   918  	api := NewBlockChainAPI(backend)
   919  	blockHashes := make([]common.Hash, genBlocks+1)
   920  	ctx := context.Background()
   921  	for i := 0; i <= genBlocks; i++ {
   922  		header, err := backend.HeaderByNumber(ctx, rpc.BlockNumber(i))
   923  		if err != nil {
   924  			t.Errorf("failed to get block: %d err: %v", i, err)
   925  		}
   926  		blockHashes[i] = header.Hash()
   927  	}
   928  	pendingHash := pending.Hash()
   929  
   930  	var testSuite = []struct {
   931  		blockNumber rpc.BlockNumber
   932  		blockHash   *common.Hash
   933  		fullTx      bool
   934  		reqHeader   bool
   935  		file        string
   936  		expectErr   error
   937  	}{
   938  		// 0. latest header
   939  		{
   940  			blockNumber: rpc.LatestBlockNumber,
   941  			reqHeader:   true,
   942  			file:        "tag-latest",
   943  		},
   944  		// 1. genesis header
   945  		{
   946  			blockNumber: rpc.BlockNumber(0),
   947  			reqHeader:   true,
   948  			file:        "number-0",
   949  		},
   950  		// 2. #1 header
   951  		{
   952  			blockNumber: rpc.BlockNumber(1),
   953  			reqHeader:   true,
   954  			file:        "number-1",
   955  		},
   956  		// 3. latest-1 header
   957  		{
   958  			blockNumber: rpc.BlockNumber(9),
   959  			reqHeader:   true,
   960  			file:        "number-latest-1",
   961  		},
   962  		// 4. latest+1 header
   963  		{
   964  			blockNumber: rpc.BlockNumber(11),
   965  			reqHeader:   true,
   966  			file:        "number-latest+1",
   967  		},
   968  		// 5. pending header
   969  		{
   970  			blockNumber: rpc.PendingBlockNumber,
   971  			reqHeader:   true,
   972  			file:        "tag-pending",
   973  		},
   974  		// 6. latest block
   975  		{
   976  			blockNumber: rpc.LatestBlockNumber,
   977  			file:        "tag-latest",
   978  		},
   979  		// 7. genesis block
   980  		{
   981  			blockNumber: rpc.BlockNumber(0),
   982  			file:        "number-0",
   983  		},
   984  		// 8. #1 block
   985  		{
   986  			blockNumber: rpc.BlockNumber(1),
   987  			file:        "number-1",
   988  		},
   989  		// 9. latest-1 block
   990  		{
   991  			blockNumber: rpc.BlockNumber(9),
   992  			fullTx:      true,
   993  			file:        "number-latest-1",
   994  		},
   995  		// 10. latest+1 block
   996  		{
   997  			blockNumber: rpc.BlockNumber(11),
   998  			fullTx:      true,
   999  			file:        "number-latest+1",
  1000  		},
  1001  		// 11. pending block
  1002  		{
  1003  			blockNumber: rpc.PendingBlockNumber,
  1004  			file:        "tag-pending",
  1005  		},
  1006  		// 12. pending block + fullTx
  1007  		{
  1008  			blockNumber: rpc.PendingBlockNumber,
  1009  			fullTx:      true,
  1010  			file:        "tag-pending-fullTx",
  1011  		},
  1012  		// 13. latest header by hash
  1013  		{
  1014  			blockHash: &blockHashes[len(blockHashes)-1],
  1015  			reqHeader: true,
  1016  			file:      "hash-latest",
  1017  		},
  1018  		// 14. genesis header by hash
  1019  		{
  1020  			blockHash: &blockHashes[0],
  1021  			reqHeader: true,
  1022  			file:      "hash-0",
  1023  		},
  1024  		// 15. #1 header
  1025  		{
  1026  			blockHash: &blockHashes[1],
  1027  			reqHeader: true,
  1028  			file:      "hash-1",
  1029  		},
  1030  		// 16. latest-1 header
  1031  		{
  1032  			blockHash: &blockHashes[len(blockHashes)-2],
  1033  			reqHeader: true,
  1034  			file:      "hash-latest-1",
  1035  		},
  1036  		// 17. empty hash
  1037  		{
  1038  			blockHash: &common.Hash{},
  1039  			reqHeader: true,
  1040  			file:      "hash-empty",
  1041  		},
  1042  		// 18. pending hash
  1043  		{
  1044  			blockHash: &pendingHash,
  1045  			reqHeader: true,
  1046  			file:      `hash-pending`,
  1047  		},
  1048  		// 19. latest block
  1049  		{
  1050  			blockHash: &blockHashes[len(blockHashes)-1],
  1051  			file:      "hash-latest",
  1052  		},
  1053  		// 20. genesis block
  1054  		{
  1055  			blockHash: &blockHashes[0],
  1056  			file:      "hash-genesis",
  1057  		},
  1058  		// 21. #1 block
  1059  		{
  1060  			blockHash: &blockHashes[1],
  1061  			file:      "hash-1",
  1062  		},
  1063  		// 22. latest-1 block
  1064  		{
  1065  			blockHash: &blockHashes[len(blockHashes)-2],
  1066  			fullTx:    true,
  1067  			file:      "hash-latest-1-fullTx",
  1068  		},
  1069  		// 23. empty hash + body
  1070  		{
  1071  			blockHash: &common.Hash{},
  1072  			fullTx:    true,
  1073  			file:      "hash-empty-fullTx",
  1074  		},
  1075  		// 24. pending block
  1076  		{
  1077  			blockHash: &pendingHash,
  1078  			file:      `hash-pending`,
  1079  		},
  1080  		// 25. pending block + fullTx
  1081  		{
  1082  			blockHash: &pendingHash,
  1083  			fullTx:    true,
  1084  			file:      "hash-pending-fullTx",
  1085  		},
  1086  	}
  1087  
  1088  	for i, tt := range testSuite {
  1089  		var (
  1090  			result map[string]interface{}
  1091  			err    error
  1092  			rpc    string
  1093  		)
  1094  		if tt.blockHash != nil {
  1095  			if tt.reqHeader {
  1096  				result = api.GetHeaderByHash(context.Background(), *tt.blockHash)
  1097  				rpc = "zond_getHeaderByHash"
  1098  			} else {
  1099  				result, err = api.GetBlockByHash(context.Background(), *tt.blockHash, tt.fullTx)
  1100  				rpc = "zond_getBlockByHash"
  1101  			}
  1102  		} else {
  1103  			if tt.reqHeader {
  1104  				result, err = api.GetHeaderByNumber(context.Background(), tt.blockNumber)
  1105  				rpc = "zond_getHeaderByNumber"
  1106  			} else {
  1107  				result, err = api.GetBlockByNumber(context.Background(), tt.blockNumber, tt.fullTx)
  1108  				rpc = "zond_getBlockByNumber"
  1109  			}
  1110  		}
  1111  		if tt.expectErr != nil {
  1112  			if err == nil {
  1113  				t.Errorf("test %d: want error %v, have nothing", i, tt.expectErr)
  1114  				continue
  1115  			}
  1116  			if !errors.Is(err, tt.expectErr) {
  1117  				t.Errorf("test %d: error mismatch, want %v, have %v", i, tt.expectErr, err)
  1118  			}
  1119  			continue
  1120  		}
  1121  		if err != nil {
  1122  			t.Errorf("test %d: want no error, have %v", i, err)
  1123  			continue
  1124  		}
  1125  
  1126  		testRPCResponseWithFile(t, i, result, rpc, tt.file)
  1127  	}
  1128  }
  1129  
  1130  func setupReceiptBackend(t *testing.T, genBlocks int) (*testBackend, []common.Hash) {
  1131  	config := *params.TestChainConfig
  1132  	var (
  1133  		acc1Key, _                 = pqcrypto.HexToDilithium("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
  1134  		acc2Key, _                 = pqcrypto.HexToDilithium("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee")
  1135  		acc1Addr                   = acc1Key.GetAddress()
  1136  		acc2Addr    common.Address = acc2Key.GetAddress()
  1137  		contract, _                = common.NewAddressFromString("Z0000000000000000000000000000000000031ec7")
  1138  		genesis                    = &core.Genesis{
  1139  			Config: &config,
  1140  			Alloc: core.GenesisAlloc{
  1141  				acc1Addr: {Balance: big.NewInt(params.Ether)},
  1142  				acc2Addr: {Balance: big.NewInt(params.Ether)},
  1143  				// // SPDX-License-Identifier: GPL-3.0
  1144  				// // TODO(now.youtrack.cloud/issue/TGZ-30)
  1145  				// pragma hyperion >=0.7.0 <0.9.0;
  1146  				//
  1147  				// contract Token {
  1148  				//     event Transfer(address indexed from, address indexed to, uint256 value);
  1149  				//     function transfer(address to, uint256 value) public returns (bool) {
  1150  				//         emit Transfer(msg.sender, to, value);
  1151  				//         return true;
  1152  				//     }
  1153  				// }
  1154  				contract: {Balance: big.NewInt(params.Ether), Code: common.FromHex("0x608060405234801561001057600080fd5b506004361061002b5760003560e01c8063a9059cbb14610030575b600080fd5b61004a6004803603810190610045919061016a565b610060565b60405161005791906101c5565b60405180910390f35b60008273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516100bf91906101ef565b60405180910390a36001905092915050565b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000610101826100d6565b9050919050565b610111816100f6565b811461011c57600080fd5b50565b60008135905061012e81610108565b92915050565b6000819050919050565b61014781610134565b811461015257600080fd5b50565b6000813590506101648161013e565b92915050565b60008060408385031215610181576101806100d1565b5b600061018f8582860161011f565b92505060206101a085828601610155565b9150509250929050565b60008115159050919050565b6101bf816101aa565b82525050565b60006020820190506101da60008301846101b6565b92915050565b6101e981610134565b82525050565b600060208201905061020460008301846101e0565b9291505056fea2646970667358221220b469033f4b77b9565ee84e0a2f04d496b18160d26034d54f9487e57788fd36d564736f6c63430008120033")},
  1155  			},
  1156  		}
  1157  		signer   = types.LatestSignerForChainID(params.TestChainConfig.ChainID)
  1158  		txHashes = make([]common.Hash, genBlocks)
  1159  	)
  1160  
  1161  	backend := newTestBackend(t, genBlocks, genesis, beacon.New(), func(i int, b *core.BlockGen) {
  1162  		var (
  1163  			tx  *types.Transaction
  1164  			err error
  1165  		)
  1166  		switch i {
  1167  		case 0:
  1168  			// transfer 1000wei
  1169  			tx, err = types.SignTx(types.NewTx(&types.DynamicFeeTx{Nonce: uint64(i), To: &acc2Addr, Value: big.NewInt(1000), Gas: params.TxGas, GasFeeCap: b.BaseFee(), Data: nil}), types.ShanghaiSigner{ChainId: big.NewInt(1)}, acc1Key)
  1170  		case 1:
  1171  			// create contract
  1172  			tx, err = types.SignTx(types.NewTx(&types.DynamicFeeTx{Nonce: uint64(i), To: nil, Gas: 53100, GasFeeCap: b.BaseFee(), Data: common.FromHex("0x60806040")}), signer, acc1Key)
  1173  		case 2:
  1174  			// with logs
  1175  			// transfer(address to, uint256 value)
  1176  			data := fmt.Sprintf("0xa9059cbb%s%s", common.HexToHash(common.BigToHash(big.NewInt(int64(i + 1))).Hex()).String()[2:], common.BytesToHash([]byte{byte(i + 11)}).String()[2:])
  1177  			tx, err = types.SignTx(types.NewTx(&types.DynamicFeeTx{Nonce: uint64(i), To: &contract, Gas: 60000, GasFeeCap: b.BaseFee(), Data: common.FromHex(data)}), signer, acc1Key)
  1178  		case 3:
  1179  			// dynamic fee with logs
  1180  			// transfer(address to, uint256 value)
  1181  			data := fmt.Sprintf("0xa9059cbb%s%s", common.HexToHash(common.BigToHash(big.NewInt(int64(i + 1))).Hex()).String()[2:], common.BytesToHash([]byte{byte(i + 11)}).String()[2:])
  1182  			fee := big.NewInt(500)
  1183  			fee.Add(fee, b.BaseFee())
  1184  			tx, err = types.SignTx(types.NewTx(&types.DynamicFeeTx{Nonce: uint64(i), To: &contract, Gas: 60000, Value: big.NewInt(1), GasTipCap: big.NewInt(500), GasFeeCap: fee, Data: common.FromHex(data)}), signer, acc1Key)
  1185  		case 4:
  1186  			// access list with contract create
  1187  			accessList := types.AccessList{{
  1188  				Address:     contract,
  1189  				StorageKeys: []common.Hash{{0}},
  1190  			}}
  1191  			tx, err = types.SignTx(types.NewTx(&types.DynamicFeeTx{Nonce: uint64(i), To: nil, Gas: 58100, GasFeeCap: b.BaseFee(), Data: common.FromHex("0x60806040"), AccessList: accessList}), signer, acc1Key)
  1192  		case 5:
  1193  			// dynamic fee tx
  1194  			fee := big.NewInt(500)
  1195  			fee.Add(fee, b.BaseFee())
  1196  			tx, err = types.SignTx(types.NewTx(&types.DynamicFeeTx{
  1197  				Nonce:     uint64(i),
  1198  				GasTipCap: big.NewInt(1),
  1199  				GasFeeCap: fee,
  1200  				Gas:       params.TxGas,
  1201  				To:        &acc2Addr,
  1202  				Value:     big.NewInt(0),
  1203  			}), signer, acc1Key)
  1204  		}
  1205  		if err != nil {
  1206  			t.Errorf("failed to sign tx: %v", err)
  1207  		}
  1208  		if tx != nil {
  1209  			b.AddTx(tx)
  1210  			txHashes[i] = tx.Hash()
  1211  		}
  1212  	})
  1213  	return backend, txHashes
  1214  }
  1215  
  1216  func TestRPCGetTransactionReceipt(t *testing.T) {
  1217  	t.Parallel()
  1218  
  1219  	var (
  1220  		backend, txHashes = setupReceiptBackend(t, 6)
  1221  		api               = NewTransactionAPI(backend, new(AddrLocker))
  1222  	)
  1223  
  1224  	var testSuite = []struct {
  1225  		txHash common.Hash
  1226  		file   string
  1227  	}{
  1228  		// 0. normal success
  1229  		{
  1230  			txHash: txHashes[0],
  1231  			file:   "normal-transfer-tx",
  1232  		},
  1233  		// 1. create contract
  1234  		{
  1235  			txHash: txHashes[1],
  1236  			file:   "create-contract-tx",
  1237  		},
  1238  		// 2. with logs success
  1239  		{
  1240  			txHash: txHashes[2],
  1241  			file:   "with-logs",
  1242  		},
  1243  		// 3. dynamic tx with logs success
  1244  		{
  1245  			txHash: txHashes[3],
  1246  			file:   `dynamic-tx-with-logs`,
  1247  		},
  1248  		// 4. access list tx with create contract
  1249  		{
  1250  			txHash: txHashes[4],
  1251  			file:   "create-contract-with-access-list",
  1252  		},
  1253  		// 5. txhash empty
  1254  		{
  1255  			txHash: common.Hash{},
  1256  			file:   "txhash-empty",
  1257  		},
  1258  		// 6. txhash not found
  1259  		{
  1260  			txHash: common.HexToHash("deadbeef"),
  1261  			file:   "txhash-notfound",
  1262  		},
  1263  	}
  1264  
  1265  	for i, tt := range testSuite {
  1266  		var (
  1267  			result interface{}
  1268  			err    error
  1269  		)
  1270  		result, err = api.GetTransactionReceipt(context.Background(), tt.txHash)
  1271  		if err != nil {
  1272  			t.Errorf("test %d: want no error, have %v", i, err)
  1273  			continue
  1274  		}
  1275  		testRPCResponseWithFile(t, i, result, "zond_getTransactionReceipt", tt.file)
  1276  	}
  1277  }
  1278  
  1279  func TestRPCGetBlockReceipts(t *testing.T) {
  1280  	t.Parallel()
  1281  
  1282  	var (
  1283  		genBlocks  = 6
  1284  		backend, _ = setupReceiptBackend(t, genBlocks)
  1285  		api        = NewBlockChainAPI(backend)
  1286  	)
  1287  	blockHashes := make([]common.Hash, genBlocks+1)
  1288  	ctx := context.Background()
  1289  	for i := 0; i <= genBlocks; i++ {
  1290  		header, err := backend.HeaderByNumber(ctx, rpc.BlockNumber(i))
  1291  		if err != nil {
  1292  			t.Errorf("failed to get block: %d err: %v", i, err)
  1293  		}
  1294  		blockHashes[i] = header.Hash()
  1295  	}
  1296  
  1297  	var testSuite = []struct {
  1298  		test rpc.BlockNumberOrHash
  1299  		file string
  1300  	}{
  1301  		// 0. block without any txs(hash)
  1302  		{
  1303  			test: rpc.BlockNumberOrHashWithHash(blockHashes[0], false),
  1304  			file: "number-0",
  1305  		},
  1306  		// 1. block without any txs(number)
  1307  		{
  1308  			test: rpc.BlockNumberOrHashWithNumber(0),
  1309  			file: "number-1",
  1310  		},
  1311  		// 2. earliest tag
  1312  		{
  1313  			test: rpc.BlockNumberOrHashWithNumber(rpc.EarliestBlockNumber),
  1314  			file: "tag-earliest",
  1315  		},
  1316  		// 3. latest tag
  1317  		{
  1318  			test: rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber),
  1319  			file: "tag-latest",
  1320  		},
  1321  		// 4. block with transfer tx(hash)
  1322  		{
  1323  			test: rpc.BlockNumberOrHashWithHash(blockHashes[1], false),
  1324  			file: "block-with-transfer-tx",
  1325  		},
  1326  		// 5. block with contract create tx(number)
  1327  		{
  1328  			test: rpc.BlockNumberOrHashWithNumber(rpc.BlockNumber(2)),
  1329  			file: "block-with-contract-create-tx",
  1330  		},
  1331  
  1332  		// 6. block with contract call tx(hash)
  1333  		{
  1334  			test: rpc.BlockNumberOrHashWithHash(blockHashes[3], false),
  1335  			file: "block-with-contract-call-tx",
  1336  		},
  1337  		// 7. block with dynamic fee tx(number)
  1338  		{
  1339  			test: rpc.BlockNumberOrHashWithNumber(rpc.BlockNumber(4)),
  1340  			file: "block-with-dynamic-fee-tx",
  1341  		},
  1342  		// 8. block is empty
  1343  		{
  1344  			test: rpc.BlockNumberOrHashWithHash(common.Hash{}, false),
  1345  			file: "hash-empty",
  1346  		},
  1347  		// 9. block is not found
  1348  		{
  1349  			test: rpc.BlockNumberOrHashWithHash(common.HexToHash("deadbeef"), false),
  1350  			file: "hash-notfound",
  1351  		},
  1352  		// 10. block is not found
  1353  		{
  1354  			test: rpc.BlockNumberOrHashWithNumber(rpc.BlockNumber(genBlocks + 1)),
  1355  			file: "block-notfound",
  1356  		},
  1357  	}
  1358  
  1359  	for i, tt := range testSuite {
  1360  		var (
  1361  			result interface{}
  1362  			err    error
  1363  		)
  1364  		result, err = api.GetBlockReceipts(context.Background(), tt.test)
  1365  		if err != nil {
  1366  			t.Errorf("test %d: want no error, have %v", i, err)
  1367  			continue
  1368  		}
  1369  		testRPCResponseWithFile(t, i, result, "zond_getBlockReceipts", tt.file)
  1370  	}
  1371  }
  1372  
  1373  func testRPCResponseWithFile(t *testing.T, testid int, result interface{}, rpc string, file string) {
  1374  	data, err := json.MarshalIndent(result, "", "  ")
  1375  	if err != nil {
  1376  		t.Errorf("test %d: json marshal error", testid)
  1377  		return
  1378  	}
  1379  	outputFile := filepath.Join("testdata", fmt.Sprintf("%s-%s.json", rpc, file))
  1380  	if os.Getenv("WRITE_TEST_FILES") != "" {
  1381  		os.WriteFile(outputFile, data, 0644)
  1382  	}
  1383  	want, err := os.ReadFile(outputFile)
  1384  	if err != nil {
  1385  		t.Fatalf("error reading expected test file: %s output: %v", outputFile, err)
  1386  	}
  1387  	require.JSONEqf(t, string(want), string(data), "test %d: json not match, want: %s, have: %s", testid, string(want), string(data))
  1388  }