123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661 |
- // Copyright 2021 The go-ethereum Authors
- // This file is part of the go-ethereum library.
- //
- // The go-ethereum library is free software: you can redistribute it and/or modify
- // it under the terms of the GNU Lesser General Public License as published by
- // the Free Software Foundation, either version 3 of the License, or
- // (at your option) any later version.
- //
- // The go-ethereum library is distributed in the hope that it will be useful,
- // but WITHOUT ANY WARRANTY; without even the implied warranty of
- // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- // GNU Lesser General Public License for more details.
- //
- // You should have received a copy of the GNU Lesser General Public License
- // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
- package tracers
- import (
- "bytes"
- "context"
- "crypto/ecdsa"
- "encoding/json"
- "errors"
- "fmt"
- "math/big"
- "reflect"
- "sort"
- "testing"
- "time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/mps"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
- )
- var (
- errStateNotFound = errors.New("state not found")
- errBlockNotFound = errors.New("block not found")
- errTransactionNotFound = errors.New("transaction not found")
- )
- type testBackend struct {
- chainConfig *params.ChainConfig
- engine consensus.Engine
- chaindb ethdb.Database
- chain *core.BlockChain
- }
- var _ Backend = &testBackend{}
- func newTestBackend(t *testing.T, n int, gspec *core.Genesis, generator func(i int, b *core.BlockGen)) *testBackend {
- backend := &testBackend{
- chainConfig: params.TestChainConfig,
- engine: ethash.NewFaker(),
- chaindb: rawdb.NewMemoryDatabase(),
- }
- // Generate blocks for testing
- gspec.Config = backend.chainConfig
- var (
- gendb = rawdb.NewMemoryDatabase()
- genesis = gspec.MustCommit(gendb)
- )
- blocks, _ := core.GenerateChain(backend.chainConfig, genesis, backend.engine, gendb, n, generator)
- // Import the canonical chain
- gspec.MustCommit(backend.chaindb)
- cacheConfig := &core.CacheConfig{
- TrieCleanLimit: 256,
- TrieDirtyLimit: 256,
- TrieTimeLimit: 5 * time.Minute,
- SnapshotLimit: 0,
- TrieDirtyDisabled: true, // Archive mode
- }
- chain, err := core.NewBlockChain(backend.chaindb, cacheConfig, backend.chainConfig, backend.engine, vm.Config{}, nil, nil, nil)
- if err != nil {
- t.Fatalf("failed to create tester chain: %v", err)
- }
- if n, err := chain.InsertChain(blocks); err != nil {
- t.Fatalf("block %d: failed to insert into chain: %v", n, err)
- }
- backend.chain = chain
- return backend
- }
- func (b *testBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
- return b.chain.GetHeaderByHash(hash), nil
- }
- func (b *testBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
- if number == rpc.PendingBlockNumber || number == rpc.LatestBlockNumber {
- return b.chain.CurrentHeader(), nil
- }
- return b.chain.GetHeaderByNumber(uint64(number)), nil
- }
- func (b *testBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
- return b.chain.GetBlockByHash(hash), nil
- }
- func (b *testBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
- if number == rpc.PendingBlockNumber || number == rpc.LatestBlockNumber {
- return b.chain.CurrentBlock(), nil
- }
- return b.chain.GetBlockByNumber(uint64(number)), nil
- }
- func (b *testBackend) GetTransaction(ctx context.Context, txHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
- tx, hash, blockNumber, index := rawdb.ReadTransaction(b.chaindb, txHash)
- if tx == nil {
- return nil, common.Hash{}, 0, 0, errTransactionNotFound
- }
- return tx, hash, blockNumber, index, nil
- }
- func (b *testBackend) RPCGasCap() uint64 {
- return 25000000
- }
- func (b *testBackend) ChainConfig() *params.ChainConfig {
- return b.chainConfig
- }
- func (b *testBackend) Engine() consensus.Engine {
- return b.engine
- }
- func (b *testBackend) ChainDb() ethdb.Database {
- return b.chaindb
- }
- func (b *testBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, checkLive bool) (*state.StateDB, mps.PrivateStateRepository, error) {
- statedb, privateStateRepo, err := b.chain.StateAt(block.Root())
- if err != nil {
- return nil, nil, errStateNotFound
- }
- return statedb, privateStateRepo, nil
- }
- func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, *state.StateDB, mps.PrivateStateRepository, error) {
- parent := b.chain.GetBlock(block.ParentHash(), block.NumberU64()-1)
- if parent == nil {
- return nil, vm.BlockContext{}, nil, nil, nil, errBlockNotFound
- }
- statedb, privateStateRepo, err := b.chain.StateAt(parent.Root())
- if err != nil {
- return nil, vm.BlockContext{}, nil, nil, nil, errStateNotFound
- }
- psm, err := b.chain.PrivateStateManager().ResolveForUserContext(ctx)
- if err != nil {
- return nil, vm.BlockContext{}, nil, nil, nil, err
- }
- privateState, err := privateStateRepo.StatePSI(psm.ID)
- if err != nil {
- return nil, vm.BlockContext{}, nil, nil, nil, errStateNotFound
- }
- if txIndex == 0 && len(block.Transactions()) == 0 {
- return nil, vm.BlockContext{}, statedb, privateState, privateStateRepo, nil
- }
- // Recompute transactions up to the target index.
- signer := types.MakeSigner(b.chainConfig, block.Number())
- for idx, tx := range block.Transactions() {
- msg, _ := tx.AsMessage(signer)
- txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), b.chain, nil)
- if idx == txIndex {
- return msg, context, statedb, privateState, privateStateRepo, nil
- }
- vmenv := vm.NewEVM(context, txContext, statedb, privateState, b.chainConfig, vm.Config{})
- if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil {
- return nil, vm.BlockContext{}, nil, nil, nil, fmt.Errorf("transaction %#x failed: %v", tx.Hash(), err)
- }
- statedb.Finalise(vmenv.ChainConfig().IsEIP158(block.Number()))
- }
- return nil, vm.BlockContext{}, nil, nil, nil, fmt.Errorf("transaction index %d out of range for block %#x", txIndex, block.Hash())
- }
- func (b *testBackend) GetBlockchain() *core.BlockChain {
- return b.chain
- }
- func TestTraceCall(t *testing.T) {
- t.Parallel()
- // Initialize test accounts
- accounts := newAccounts(3)
- genesis := &core.Genesis{Alloc: core.GenesisAlloc{
- accounts[0].addr: {Balance: big.NewInt(params.Ether)},
- accounts[1].addr: {Balance: big.NewInt(params.Ether)},
- accounts[2].addr: {Balance: big.NewInt(params.Ether)},
- }}
- genBlocks := 10
- signer := types.HomesteadSigner{}
- api := NewAPI(newTestBackend(t, genBlocks, genesis, func(i int, b *core.BlockGen) {
- // Transfer from account[0] to account[1]
- // value: 1000 wei
- // fee: 0 wei
- tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, big.NewInt(1000), params.TxGas, big.NewInt(0), nil), signer, accounts[0].key)
- b.AddTx(tx)
- }))
- var testSuite = []struct {
- blockNumber rpc.BlockNumber
- call ethapi.CallArgs
- config *TraceCallConfig
- expectErr error
- expect interface{}
- }{
- // Standard JSON trace upon the genesis, plain transfer.
- {
- blockNumber: rpc.BlockNumber(0),
- call: ethapi.CallArgs{
- From: &accounts[0].addr,
- To: &accounts[1].addr,
- Value: (*hexutil.Big)(big.NewInt(1000)),
- },
- config: nil,
- expectErr: nil,
- expect: ðapi.ExecutionResult{
- Gas: params.TxGas,
- Failed: false,
- ReturnValue: "",
- StructLogs: []ethapi.StructLogRes{},
- },
- },
- // Standard JSON trace upon the head, plain transfer.
- {
- blockNumber: rpc.BlockNumber(genBlocks),
- call: ethapi.CallArgs{
- From: &accounts[0].addr,
- To: &accounts[1].addr,
- Value: (*hexutil.Big)(big.NewInt(1000)),
- },
- config: nil,
- expectErr: nil,
- expect: ðapi.ExecutionResult{
- Gas: params.TxGas,
- Failed: false,
- ReturnValue: "",
- StructLogs: []ethapi.StructLogRes{},
- },
- },
- // Standard JSON trace upon the non-existent block, error expects
- {
- blockNumber: rpc.BlockNumber(genBlocks + 1),
- call: ethapi.CallArgs{
- From: &accounts[0].addr,
- To: &accounts[1].addr,
- Value: (*hexutil.Big)(big.NewInt(1000)),
- },
- config: nil,
- expectErr: fmt.Errorf("block #%d not found", genBlocks+1),
- expect: nil,
- },
- // Standard JSON trace upon the latest block
- {
- blockNumber: rpc.LatestBlockNumber,
- call: ethapi.CallArgs{
- From: &accounts[0].addr,
- To: &accounts[1].addr,
- Value: (*hexutil.Big)(big.NewInt(1000)),
- },
- config: nil,
- expectErr: nil,
- expect: ðapi.ExecutionResult{
- Gas: params.TxGas,
- Failed: false,
- ReturnValue: "",
- StructLogs: []ethapi.StructLogRes{},
- },
- },
- // Standard JSON trace upon the pending block
- {
- blockNumber: rpc.PendingBlockNumber,
- call: ethapi.CallArgs{
- From: &accounts[0].addr,
- To: &accounts[1].addr,
- Value: (*hexutil.Big)(big.NewInt(1000)),
- },
- config: nil,
- expectErr: nil,
- expect: ðapi.ExecutionResult{
- Gas: params.TxGas,
- Failed: false,
- ReturnValue: "",
- StructLogs: []ethapi.StructLogRes{},
- },
- },
- }
- for _, testspec := range testSuite {
- tc := &TraceCallConfig{}
- if testspec.config != nil {
- tc.LogConfig = testspec.config.LogConfig
- tc.Tracer = testspec.config.Tracer
- tc.Timeout = testspec.config.Timeout
- tc.Reexec = testspec.config.Reexec
- }
- result, err := api.TraceCall(context.Background(), testspec.call, rpc.BlockNumberOrHash{BlockNumber: &testspec.blockNumber}, tc)
- if testspec.expectErr != nil {
- if err == nil {
- t.Errorf("Expect error %v, get nothing", testspec.expectErr)
- continue
- }
- if !reflect.DeepEqual(err, testspec.expectErr) {
- t.Errorf("Error mismatch, want %v, get %v", testspec.expectErr, err)
- }
- } else {
- if err != nil {
- t.Errorf("Expect no error, get %v", err)
- continue
- }
- if !reflect.DeepEqual(result, testspec.expect) {
- t.Errorf("Result mismatch, want %v, get %v", testspec.expect, result)
- }
- }
- }
- }
- func TestOverridenTraceCall(t *testing.T) {
- t.Parallel()
- // Initialize test accounts
- accounts := newAccounts(3)
- genesis := &core.Genesis{Alloc: core.GenesisAlloc{
- accounts[0].addr: {Balance: big.NewInt(params.Ether)},
- accounts[1].addr: {Balance: big.NewInt(params.Ether)},
- accounts[2].addr: {Balance: big.NewInt(params.Ether)},
- }}
- genBlocks := 10
- signer := types.HomesteadSigner{}
- api := NewAPI(newTestBackend(t, genBlocks, genesis, func(i int, b *core.BlockGen) {
- // Transfer from account[0] to account[1]
- // value: 1000 wei
- // fee: 0 wei
- tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, big.NewInt(1000), params.TxGas, big.NewInt(0), nil), signer, accounts[0].key)
- b.AddTx(tx)
- }))
- randomAccounts, tracer := newAccounts(3), "callTracer"
- var testSuite = []struct {
- blockNumber rpc.BlockNumber
- call ethapi.CallArgs
- config *TraceCallConfig
- expectErr error
- expect *callTrace
- }{
- // Succcessful call with state overriding
- {
- blockNumber: rpc.PendingBlockNumber,
- call: ethapi.CallArgs{
- From: &randomAccounts[0].addr,
- To: &randomAccounts[1].addr,
- Value: (*hexutil.Big)(big.NewInt(1000)),
- },
- config: &TraceCallConfig{
- Tracer: &tracer,
- StateOverrides: ðapi.StateOverride{
- randomAccounts[0].addr: ethapi.OverrideAccount{Balance: newRPCBalance(new(big.Int).Mul(big.NewInt(1), big.NewInt(params.Ether)))},
- },
- },
- expectErr: nil,
- expect: &callTrace{
- Type: "CALL",
- From: randomAccounts[0].addr,
- To: randomAccounts[1].addr,
- Gas: newRPCUint64(24979000),
- GasUsed: newRPCUint64(0),
- Value: (*hexutil.Big)(big.NewInt(1000)),
- },
- },
- // Invalid call without state overriding
- {
- blockNumber: rpc.PendingBlockNumber,
- call: ethapi.CallArgs{
- From: &randomAccounts[0].addr,
- To: &randomAccounts[1].addr,
- Value: (*hexutil.Big)(big.NewInt(1000)),
- },
- config: &TraceCallConfig{
- Tracer: &tracer,
- },
- expectErr: core.ErrInsufficientFundsForTransfer,
- expect: nil,
- },
- // Successful simple contract call
- //
- // // SPDX-License-Identifier: GPL-3.0
- //
- // pragma solidity >=0.7.0 <0.8.0;
- //
- // /**
- // * @title Storage
- // * @dev Store & retrieve value in a variable
- // */
- // contract Storage {
- // uint256 public number;
- // constructor() {
- // number = block.number;
- // }
- // }
- {
- blockNumber: rpc.PendingBlockNumber,
- call: ethapi.CallArgs{
- From: &randomAccounts[0].addr,
- To: &randomAccounts[2].addr,
- Data: newRPCBytes(common.Hex2Bytes("8381f58a")), // call number()
- },
- config: &TraceCallConfig{
- Tracer: &tracer,
- StateOverrides: ðapi.StateOverride{
- randomAccounts[2].addr: ethapi.OverrideAccount{
- Code: newRPCBytes(common.Hex2Bytes("6080604052348015600f57600080fd5b506004361060285760003560e01c80638381f58a14602d575b600080fd5b60336049565b6040518082815260200191505060405180910390f35b6000548156fea2646970667358221220eab35ffa6ab2adfe380772a48b8ba78e82a1b820a18fcb6f59aa4efb20a5f60064736f6c63430007040033")),
- StateDiff: newStates([]common.Hash{{}}, []common.Hash{common.BigToHash(big.NewInt(123))}),
- },
- },
- },
- expectErr: nil,
- expect: &callTrace{
- Type: "CALL",
- From: randomAccounts[0].addr,
- To: randomAccounts[2].addr,
- Input: hexutil.Bytes(common.Hex2Bytes("8381f58a")),
- Output: hexutil.Bytes(common.BigToHash(big.NewInt(123)).Bytes()),
- Gas: newRPCUint64(24978936),
- GasUsed: newRPCUint64(2283),
- Value: (*hexutil.Big)(big.NewInt(0)),
- },
- },
- }
- for _, testspec := range testSuite {
- result, err := api.TraceCall(context.Background(), testspec.call, rpc.BlockNumberOrHash{BlockNumber: &testspec.blockNumber}, testspec.config)
- if testspec.expectErr != nil {
- if err == nil {
- t.Errorf("Expect error %v, get nothing", testspec.expectErr)
- continue
- }
- if !errors.Is(err, testspec.expectErr) {
- t.Errorf("Error mismatch, want %v, get %v", testspec.expectErr, err)
- }
- } else {
- if err != nil {
- t.Errorf("Expect no error, get %v", err)
- continue
- }
- ret := new(callTrace)
- if err := json.Unmarshal(result.(json.RawMessage), ret); err != nil {
- t.Fatalf("failed to unmarshal trace result: %v", err)
- }
- if !jsonEqual(ret, testspec.expect) {
- // uncomment this for easier debugging
- //have, _ := json.MarshalIndent(ret, "", " ")
- //want, _ := json.MarshalIndent(testspec.expect, "", " ")
- //t.Fatalf("trace mismatch: \nhave %+v\nwant %+v", string(have), string(want))
- t.Fatalf("trace mismatch: \nhave %+v\nwant %+v", ret, testspec.expect)
- }
- }
- }
- }
- func TestTraceTransaction(t *testing.T) {
- t.Parallel()
- // Initialize test accounts
- accounts := newAccounts(2)
- genesis := &core.Genesis{Alloc: core.GenesisAlloc{
- accounts[0].addr: {Balance: big.NewInt(params.Ether)},
- accounts[1].addr: {Balance: big.NewInt(params.Ether)},
- }}
- target := common.Hash{}
- signer := types.HomesteadSigner{}
- api := NewAPI(newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) {
- // Transfer from account[0] to account[1]
- // value: 1000 wei
- // fee: 0 wei
- tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, big.NewInt(1000), params.TxGas, big.NewInt(0), nil), signer, accounts[0].key)
- b.AddTx(tx)
- target = tx.Hash()
- }))
- result, err := api.TraceTransaction(context.Background(), target, nil)
- if err != nil {
- t.Errorf("Failed to trace transaction %v", err)
- }
- if !reflect.DeepEqual(result, ðapi.ExecutionResult{
- Gas: params.TxGas,
- Failed: false,
- ReturnValue: "",
- StructLogs: []ethapi.StructLogRes{},
- }) {
- t.Error("Transaction tracing result is different")
- }
- }
- func TestTraceBlock(t *testing.T) {
- t.Parallel()
- // Initialize test accounts
- accounts := newAccounts(3)
- genesis := &core.Genesis{Alloc: core.GenesisAlloc{
- accounts[0].addr: {Balance: big.NewInt(params.Ether)},
- accounts[1].addr: {Balance: big.NewInt(params.Ether)},
- accounts[2].addr: {Balance: big.NewInt(params.Ether)},
- }}
- genBlocks := 10
- signer := types.HomesteadSigner{}
- api := NewAPI(newTestBackend(t, genBlocks, genesis, func(i int, b *core.BlockGen) {
- // Transfer from account[0] to account[1]
- // value: 1000 wei
- // fee: 0 wei
- tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, big.NewInt(1000), params.TxGas, big.NewInt(0), nil), signer, accounts[0].key)
- b.AddTx(tx)
- }))
- var testSuite = []struct {
- blockNumber rpc.BlockNumber
- config *TraceConfig
- expect interface{}
- expectErr error
- }{
- // Trace genesis block, expect error
- {
- blockNumber: rpc.BlockNumber(0),
- config: nil,
- expect: nil,
- expectErr: errors.New("genesis is not traceable"),
- },
- // Trace head block
- {
- blockNumber: rpc.BlockNumber(genBlocks),
- config: nil,
- expectErr: nil,
- expect: []*txTraceResult{
- {
- Result: ðapi.ExecutionResult{
- Gas: params.TxGas,
- Failed: false,
- ReturnValue: "",
- StructLogs: []ethapi.StructLogRes{},
- },
- },
- },
- },
- // Trace non-existent block
- {
- blockNumber: rpc.BlockNumber(genBlocks + 1),
- config: nil,
- expectErr: fmt.Errorf("block #%d not found", genBlocks+1),
- expect: nil,
- },
- // Trace latest block
- {
- blockNumber: rpc.LatestBlockNumber,
- config: nil,
- expectErr: nil,
- expect: []*txTraceResult{
- {
- Result: ðapi.ExecutionResult{
- Gas: params.TxGas,
- Failed: false,
- ReturnValue: "",
- StructLogs: []ethapi.StructLogRes{},
- },
- },
- },
- },
- // Trace pending block
- {
- blockNumber: rpc.PendingBlockNumber,
- config: nil,
- expectErr: nil,
- expect: []*txTraceResult{
- {
- Result: ðapi.ExecutionResult{
- Gas: params.TxGas,
- Failed: false,
- ReturnValue: "",
- StructLogs: []ethapi.StructLogRes{},
- },
- },
- },
- },
- }
- for _, testspec := range testSuite {
- result, err := api.TraceBlockByNumber(context.Background(), testspec.blockNumber, testspec.config)
- if testspec.expectErr != nil {
- if err == nil {
- t.Errorf("Expect error %v, get nothing", testspec.expectErr)
- continue
- }
- if !reflect.DeepEqual(err, testspec.expectErr) {
- t.Errorf("Error mismatch, want %v, get %v", testspec.expectErr, err)
- }
- } else {
- if err != nil {
- t.Errorf("Expect no error, get %v", err)
- continue
- }
- if !reflect.DeepEqual(result, testspec.expect) {
- t.Errorf("Result mismatch, want %v, get %v", testspec.expect, result)
- }
- }
- }
- }
- type Account struct {
- key *ecdsa.PrivateKey
- addr common.Address
- }
- type Accounts []Account
- func (a Accounts) Len() int { return len(a) }
- func (a Accounts) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
- func (a Accounts) Less(i, j int) bool { return bytes.Compare(a[i].addr.Bytes(), a[j].addr.Bytes()) < 0 }
- func newAccounts(n int) (accounts Accounts) {
- for i := 0; i < n; i++ {
- key, _ := crypto.GenerateKey()
- addr := crypto.PubkeyToAddress(key.PublicKey)
- accounts = append(accounts, Account{key: key, addr: addr})
- }
- sort.Sort(accounts)
- return accounts
- }
- func newRPCBalance(balance *big.Int) **hexutil.Big {
- rpcBalance := (*hexutil.Big)(balance)
- return &rpcBalance
- }
- func newRPCUint64(number uint64) *hexutil.Uint64 {
- rpcUint64 := hexutil.Uint64(number)
- return &rpcUint64
- }
- func newRPCBytes(bytes []byte) *hexutil.Bytes {
- rpcBytes := hexutil.Bytes(bytes)
- return &rpcBytes
- }
- func newStates(keys []common.Hash, vals []common.Hash) *map[common.Hash]common.Hash {
- if len(keys) != len(vals) {
- panic("invalid input")
- }
- m := make(map[common.Hash]common.Hash)
- for i := 0; i < len(keys); i++ {
- m[keys[i]] = vals[i]
- }
- return &m
- }
|