From d0dc349fd36bd79f94516c866251783641ed12f1 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi <1591639+s1na@users.noreply.github.com> Date: Wed, 31 Aug 2022 16:14:53 +0200 Subject: [PATCH 01/51] graphql: return correct logs for tx (#25612) * graphql: fix tx logs * minor * Use optimized search for selecting tx logs --- graphql/graphql.go | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/graphql/graphql.go b/graphql/graphql.go index 97b460c205ce..66c25841db98 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -22,6 +22,7 @@ import ( "errors" "fmt" "math/big" + "sort" "strconv" "github.com/ethereum/go-ethereum" @@ -478,13 +479,16 @@ func (t *Transaction) getLogs(ctx context.Context) (*[]*Log, error) { if err != nil { return nil, err } - ret := make([]*Log, 0, len(logs)) - for _, log := range logs { + var ret []*Log + // Select tx logs from all block logs + ix := sort.Search(len(logs), func(i int) bool { return uint64(logs[i].TxIndex) == t.index }) + for ix < len(logs) && uint64(logs[ix].TxIndex) == t.index { ret = append(ret, &Log{ r: t.r, transaction: t, - log: log, + log: logs[ix], }) + ix++ } return &ret, nil } From 3b41be695e6e12829abf6e5edec0606ee37f14d9 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi <1591639+s1na@users.noreply.github.com> Date: Tue, 13 Sep 2022 21:49:52 +0200 Subject: [PATCH 02/51] graphql: fixes missing tx logs (#25745) * graphql: fix tx logs * graphql: refactor test service setup * graphql: add test for tx logs --- graphql/graphql.go | 2 +- graphql/graphql_test.go | 227 +++++++++++++++++++++------------------- graphql/service.go | 9 +- 3 files changed, 124 insertions(+), 114 deletions(-) diff --git a/graphql/graphql.go b/graphql/graphql.go index 66c25841db98..356ff669fb16 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -481,7 +481,7 @@ func (t *Transaction) getLogs(ctx context.Context) (*[]*Log, error) { } var ret []*Log // Select tx logs from all block logs - ix := sort.Search(len(logs), func(i int) bool { return uint64(logs[i].TxIndex) == t.index }) + ix := sort.Search(len(logs), func(i int) bool { return uint64(logs[i].TxIndex) >= t.index }) for ix < len(logs) && uint64(logs[ix].TxIndex) == t.index { ret = append(ret, &Log{ r: t.r, diff --git a/graphql/graphql_test.go b/graphql/graphql_test.go index d55f4e063486..491c73152113 100644 --- a/graphql/graphql_test.go +++ b/graphql/graphql_test.go @@ -17,6 +17,8 @@ package graphql import ( + "context" + "encoding/json" "fmt" "io" "math/big" @@ -51,15 +53,21 @@ func TestBuildSchema(t *testing.T) { } defer stack.Close() // Make sure the schema can be parsed and matched up to the object model. - if err := newHandler(stack, nil, nil, []string{}, []string{}); err != nil { + if _, err := newHandler(stack, nil, nil, []string{}, []string{}); err != nil { t.Errorf("Could not construct GraphQL handler: %v", err) } } // Tests that a graphQL request is successfully handled when graphql is enabled on the specified endpoint func TestGraphQLBlockSerialization(t *testing.T) { - stack := createNode(t, true, false) + stack := createNode(t) defer stack.Close() + genesis := &core.Genesis{ + Config: params.AllEthashProtocolChanges, + GasLimit: 11500000, + Difficulty: big.NewInt(1048576), + } + newGQLService(t, stack, genesis, 10, func(i int, gen *core.BlockGen) {}) // start node if err := stack.Start(); err != nil { t.Fatalf("could not start node: %v", err) @@ -161,8 +169,55 @@ func TestGraphQLBlockSerialization(t *testing.T) { } func TestGraphQLBlockSerializationEIP2718(t *testing.T) { - stack := createNode(t, true, true) + // Account for signing txes + var ( + key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + address = crypto.PubkeyToAddress(key.PublicKey) + funds = big.NewInt(1000000000000000) + dad = common.HexToAddress("0x0000000000000000000000000000000000000dad") + ) + stack := createNode(t) defer stack.Close() + genesis := &core.Genesis{ + Config: params.AllEthashProtocolChanges, + GasLimit: 11500000, + Difficulty: big.NewInt(1048576), + Alloc: core.GenesisAlloc{ + address: {Balance: funds}, + // The address 0xdad sloads 0x00 and 0x01 + dad: { + Code: []byte{byte(vm.PC), byte(vm.PC), byte(vm.SLOAD), byte(vm.SLOAD)}, + Nonce: 0, + Balance: big.NewInt(0), + }, + }, + BaseFee: big.NewInt(params.InitialBaseFee), + } + signer := types.LatestSigner(genesis.Config) + newGQLService(t, stack, genesis, 1, func(i int, gen *core.BlockGen) { + gen.SetCoinbase(common.Address{1}) + tx, _ := types.SignNewTx(key, signer, &types.LegacyTx{ + Nonce: uint64(0), + To: &dad, + Value: big.NewInt(100), + Gas: 50000, + GasPrice: big.NewInt(params.InitialBaseFee), + }) + gen.AddTx(tx) + tx, _ = types.SignNewTx(key, signer, &types.AccessListTx{ + ChainID: genesis.Config.ChainID, + Nonce: uint64(1), + To: &dad, + Gas: 30000, + GasPrice: big.NewInt(params.InitialBaseFee), + Value: big.NewInt(50), + AccessList: types.AccessList{{ + Address: dad, + StorageKeys: []common.Hash{{0}}, + }}, + }) + gen.AddTx(tx) + }) // start node if err := stack.Start(); err != nil { t.Fatalf("could not start node: %v", err) @@ -198,7 +253,7 @@ func TestGraphQLBlockSerializationEIP2718(t *testing.T) { // Tests that a graphQL request is not handled successfully when graphql is not enabled on the specified endpoint func TestGraphQLHTTPOnSamePort_GQLRequest_Unsuccessful(t *testing.T) { - stack := createNode(t, false, false) + stack := createNode(t) defer stack.Close() if err := stack.Start(); err != nil { t.Fatalf("could not start node: %v", err) @@ -212,7 +267,59 @@ func TestGraphQLHTTPOnSamePort_GQLRequest_Unsuccessful(t *testing.T) { assert.Equal(t, http.StatusNotFound, resp.StatusCode) } -func createNode(t *testing.T, gqlEnabled bool, txEnabled bool) *node.Node { +func TestGraphQLTransactionLogs(t *testing.T) { + var ( + key, _ = crypto.GenerateKey() + addr = crypto.PubkeyToAddress(key.PublicKey) + dadStr = "0x0000000000000000000000000000000000000dad" + dad = common.HexToAddress(dadStr) + genesis = &core.Genesis{ + Config: params.AllEthashProtocolChanges, + GasLimit: 11500000, + Difficulty: big.NewInt(1048576), + Alloc: core.GenesisAlloc{ + addr: {Balance: big.NewInt(params.Ether)}, + dad: { + // LOG0(0, 0), LOG0(0, 0), RETURN(0, 0) + Code: common.Hex2Bytes("60006000a060006000a060006000f3"), + Nonce: 0, + Balance: big.NewInt(0), + }, + }, + } + signer = types.LatestSigner(genesis.Config) + stack = createNode(t) + ) + defer stack.Close() + + handler := newGQLService(t, stack, genesis, 1, func(i int, gen *core.BlockGen) { + tx, _ := types.SignNewTx(key, signer, &types.LegacyTx{To: &dad, Gas: 100000, GasPrice: big.NewInt(params.InitialBaseFee)}) + gen.AddTx(tx) + tx, _ = types.SignNewTx(key, signer, &types.LegacyTx{To: &dad, Nonce: 1, Gas: 100000, GasPrice: big.NewInt(params.InitialBaseFee)}) + gen.AddTx(tx) + tx, _ = types.SignNewTx(key, signer, &types.LegacyTx{To: &dad, Nonce: 2, Gas: 100000, GasPrice: big.NewInt(params.InitialBaseFee)}) + gen.AddTx(tx) + }) + // start node + if err := stack.Start(); err != nil { + t.Fatalf("could not start node: %v", err) + } + query := `{block { transactions { logs { account { address } } } } }` + res := handler.Schema.Exec(context.Background(), query, "", map[string]interface{}{}) + if res.Errors != nil { + t.Fatalf("graphql query failed: %v", res.Errors) + } + have, err := json.Marshal(res.Data) + if err != nil { + t.Fatalf("failed to encode graphql response: %s", err) + } + want := fmt.Sprintf(`{"block":{"transactions":[{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]}]}}`, dadStr, dadStr, dadStr, dadStr, dadStr, dadStr) + if string(have) != want { + t.Errorf("response unmatch. expected %s, got %s", want, have) + } +} + +func createNode(t *testing.T) *node.Node { stack, err := node.New(&node.Config{ HTTPHost: "127.0.0.1", HTTPPort: 0, @@ -222,83 +329,12 @@ func createNode(t *testing.T, gqlEnabled bool, txEnabled bool) *node.Node { if err != nil { t.Fatalf("could not create node: %v", err) } - if !gqlEnabled { - return stack - } - if !txEnabled { - createGQLService(t, stack) - } else { - createGQLServiceWithTransactions(t, stack) - } return stack } -func createGQLService(t *testing.T, stack *node.Node) { - // create backend - ethConf := ðconfig.Config{ - Genesis: &core.Genesis{ - Config: params.AllEthashProtocolChanges, - GasLimit: 11500000, - Difficulty: big.NewInt(1048576), - }, - Ethash: ethash.Config{ - PowMode: ethash.ModeFake, - }, - NetworkId: 1337, - TrieCleanCache: 5, - TrieCleanCacheJournal: "triecache", - TrieCleanCacheRejournal: 60 * time.Minute, - TrieDirtyCache: 5, - TrieTimeout: 60 * time.Minute, - SnapshotCache: 5, - } - ethBackend, err := eth.New(stack, ethConf) - if err != nil { - t.Fatalf("could not create eth backend: %v", err) - } - // Create some blocks and import them - chain, _ := core.GenerateChain(params.AllEthashProtocolChanges, ethBackend.BlockChain().Genesis(), - ethash.NewFaker(), ethBackend.ChainDb(), 10, func(i int, gen *core.BlockGen) {}) - _, err = ethBackend.BlockChain().InsertChain(chain) - if err != nil { - t.Fatalf("could not create import blocks: %v", err) - } - // create gql service - filterSystem := filters.NewFilterSystem(ethBackend.APIBackend, filters.Config{}) - err = New(stack, ethBackend.APIBackend, filterSystem, []string{}, []string{}) - if err != nil { - t.Fatalf("could not create graphql service: %v", err) - } -} - -func createGQLServiceWithTransactions(t *testing.T, stack *node.Node) { - // create backend - key, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") - address := crypto.PubkeyToAddress(key.PublicKey) - funds := big.NewInt(1000000000000000) - dad := common.HexToAddress("0x0000000000000000000000000000000000000dad") - +func newGQLService(t *testing.T, stack *node.Node, gspec *core.Genesis, genBlocks int, genfunc func(i int, gen *core.BlockGen)) *handler { ethConf := ðconfig.Config{ - Genesis: &core.Genesis{ - Config: params.AllEthashProtocolChanges, - GasLimit: 11500000, - Difficulty: big.NewInt(1048576), - Alloc: core.GenesisAlloc{ - address: {Balance: funds}, - // The address 0xdad sloads 0x00 and 0x01 - dad: { - Code: []byte{ - byte(vm.PC), - byte(vm.PC), - byte(vm.SLOAD), - byte(vm.SLOAD), - }, - Nonce: 0, - Balance: big.NewInt(0), - }, - }, - BaseFee: big.NewInt(params.InitialBaseFee), - }, + Genesis: gspec, Ethash: ethash.Config{ PowMode: ethash.ModeFake, }, @@ -310,49 +346,22 @@ func createGQLServiceWithTransactions(t *testing.T, stack *node.Node) { TrieTimeout: 60 * time.Minute, SnapshotCache: 5, } - ethBackend, err := eth.New(stack, ethConf) if err != nil { t.Fatalf("could not create eth backend: %v", err) } - signer := types.LatestSigner(ethConf.Genesis.Config) - - legacyTx, _ := types.SignNewTx(key, signer, &types.LegacyTx{ - Nonce: uint64(0), - To: &dad, - Value: big.NewInt(100), - Gas: 50000, - GasPrice: big.NewInt(params.InitialBaseFee), - }) - envelopTx, _ := types.SignNewTx(key, signer, &types.AccessListTx{ - ChainID: ethConf.Genesis.Config.ChainID, - Nonce: uint64(1), - To: &dad, - Gas: 30000, - GasPrice: big.NewInt(params.InitialBaseFee), - Value: big.NewInt(50), - AccessList: types.AccessList{{ - Address: dad, - StorageKeys: []common.Hash{{0}}, - }}, - }) - // Create some blocks and import them chain, _ := core.GenerateChain(params.AllEthashProtocolChanges, ethBackend.BlockChain().Genesis(), - ethash.NewFaker(), ethBackend.ChainDb(), 1, func(i int, b *core.BlockGen) { - b.SetCoinbase(common.Address{1}) - b.AddTx(legacyTx) - b.AddTx(envelopTx) - }) - + ethash.NewFaker(), ethBackend.ChainDb(), genBlocks, genfunc) _, err = ethBackend.BlockChain().InsertChain(chain) if err != nil { t.Fatalf("could not create import blocks: %v", err) } - // create gql service + // Set up handler filterSystem := filters.NewFilterSystem(ethBackend.APIBackend, filters.Config{}) - err = New(stack, ethBackend.APIBackend, filterSystem, []string{}, []string{}) + handler, err := newHandler(stack, ethBackend.APIBackend, filterSystem, []string{}, []string{}) if err != nil { t.Fatalf("could not create graphql service: %v", err) } + return handler } diff --git a/graphql/service.go b/graphql/service.go index 019026bc7ea7..6f6e58335991 100644 --- a/graphql/service.go +++ b/graphql/service.go @@ -57,17 +57,18 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { // New constructs a new GraphQL service instance. func New(stack *node.Node, backend ethapi.Backend, filterSystem *filters.FilterSystem, cors, vhosts []string) error { - return newHandler(stack, backend, filterSystem, cors, vhosts) + _, err := newHandler(stack, backend, filterSystem, cors, vhosts) + return err } // newHandler returns a new `http.Handler` that will answer GraphQL queries. // It additionally exports an interactive query browser on the / endpoint. -func newHandler(stack *node.Node, backend ethapi.Backend, filterSystem *filters.FilterSystem, cors, vhosts []string) error { +func newHandler(stack *node.Node, backend ethapi.Backend, filterSystem *filters.FilterSystem, cors, vhosts []string) (*handler, error) { q := Resolver{backend, filterSystem} s, err := graphql.ParseSchema(schema, &q) if err != nil { - return err + return nil, err } h := handler{Schema: s} handler := node.NewHTTPHandlerStack(h, cors, vhosts, nil) @@ -76,5 +77,5 @@ func newHandler(stack *node.Node, backend ethapi.Backend, filterSystem *filters. stack.RegisterHandler("GraphQL", "/graphql", handler) stack.RegisterHandler("GraphQL", "/graphql/", handler) - return nil + return &h, nil } From 972007a517c49ee9e2a359950d81c74467492ed2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Wed, 14 Sep 2022 11:07:10 +0200 Subject: [PATCH 03/51] Release Geth v1.10.24 --- params/version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/params/version.go b/params/version.go index 5f24b41f2852..349bdf1c18d1 100644 --- a/params/version.go +++ b/params/version.go @@ -23,7 +23,7 @@ import ( const ( VersionMajor = 1 // Major version component of the current release VersionMinor = 10 // Minor version component of the current release - VersionPatch = 23 // Patch version component of the current release + VersionPatch = 24 // Patch version component of the current release VersionMeta = "stable" // Version metadata to append to the version string ) From 8f61fc8b73565ff15d27fd9731b945d9d1878ec3 Mon Sep 17 00:00:00 2001 From: Marius van der Wijden Date: Thu, 15 Sep 2022 17:50:54 +0200 Subject: [PATCH 04/51] params: set TerminalTotalDifficultyPassed to true (#25769) * params: set TerminalTotalDifficultyPassed to true * Update params/config.go Co-authored-by: Martin Holst Swende --- params/config.go | 39 ++++++++++++++++++++------------------- 1 file changed, 20 insertions(+), 19 deletions(-) diff --git a/params/config.go b/params/config.go index 4d6eec8939bc..80e671f9bf41 100644 --- a/params/config.go +++ b/params/config.go @@ -59,25 +59,26 @@ var ( // MainnetChainConfig is the chain parameters to run a node on the main network. MainnetChainConfig = &ChainConfig{ - ChainID: big.NewInt(1), - HomesteadBlock: big.NewInt(1_150_000), - DAOForkBlock: big.NewInt(1_920_000), - DAOForkSupport: true, - EIP150Block: big.NewInt(2_463_000), - EIP150Hash: common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"), - EIP155Block: big.NewInt(2_675_000), - EIP158Block: big.NewInt(2_675_000), - ByzantiumBlock: big.NewInt(4_370_000), - ConstantinopleBlock: big.NewInt(7_280_000), - PetersburgBlock: big.NewInt(7_280_000), - IstanbulBlock: big.NewInt(9_069_000), - MuirGlacierBlock: big.NewInt(9_200_000), - BerlinBlock: big.NewInt(12_244_000), - LondonBlock: big.NewInt(12_965_000), - ArrowGlacierBlock: big.NewInt(13_773_000), - GrayGlacierBlock: big.NewInt(15_050_000), - TerminalTotalDifficulty: MainnetTerminalTotalDifficulty, // 58_750_000_000_000_000_000_000 - Ethash: new(EthashConfig), + ChainID: big.NewInt(1), + HomesteadBlock: big.NewInt(1_150_000), + DAOForkBlock: big.NewInt(1_920_000), + DAOForkSupport: true, + EIP150Block: big.NewInt(2_463_000), + EIP150Hash: common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"), + EIP155Block: big.NewInt(2_675_000), + EIP158Block: big.NewInt(2_675_000), + ByzantiumBlock: big.NewInt(4_370_000), + ConstantinopleBlock: big.NewInt(7_280_000), + PetersburgBlock: big.NewInt(7_280_000), + IstanbulBlock: big.NewInt(9_069_000), + MuirGlacierBlock: big.NewInt(9_200_000), + BerlinBlock: big.NewInt(12_244_000), + LondonBlock: big.NewInt(12_965_000), + ArrowGlacierBlock: big.NewInt(13_773_000), + GrayGlacierBlock: big.NewInt(15_050_000), + TerminalTotalDifficulty: MainnetTerminalTotalDifficulty, // 58_750_000_000_000_000_000_000 + TerminalTotalDifficultyPassed: true, + Ethash: new(EthashConfig), } // MainnetTrustedCheckpoint contains the light client trusted checkpoint for the main network. From 69568c554880b3567bace64f8848ff1be27d084d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Thu, 15 Sep 2022 17:55:58 +0200 Subject: [PATCH 05/51] params: release Geth v1.10.25 --- params/version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/params/version.go b/params/version.go index 349bdf1c18d1..3b5978e849cd 100644 --- a/params/version.go +++ b/params/version.go @@ -23,7 +23,7 @@ import ( const ( VersionMajor = 1 // Major version component of the current release VersionMinor = 10 // Minor version component of the current release - VersionPatch = 24 // Patch version component of the current release + VersionPatch = 25 // Patch version component of the current release VersionMeta = "stable" // Version metadata to append to the version string ) From 85e469f787be53192fcbcee86ce67635020a4ad5 Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Wed, 31 Aug 2022 17:58:18 +0200 Subject: [PATCH 06/51] eth/protocols/snap: fix problems due to idle-but-busy peers (#25651) --- eth/protocols/snap/sync.go | 90 +++++++++++++++++++++++--------------- 1 file changed, 55 insertions(+), 35 deletions(-) diff --git a/eth/protocols/snap/sync.go b/eth/protocols/snap/sync.go index deaa4456e0fd..1455bacbcb88 100644 --- a/eth/protocols/snap/sync.go +++ b/eth/protocols/snap/sync.go @@ -2248,14 +2248,18 @@ func (s *Syncer) OnAccounts(peer SyncPeer, id uint64, hashes []common.Hash, acco // Whether or not the response is valid, we can mark the peer as idle and // notify the scheduler to assign a new task. If the response is invalid, // we'll drop the peer in a bit. + defer func() { + s.lock.Lock() + defer s.lock.Unlock() + if _, ok := s.peers[peer.ID()]; ok { + s.accountIdlers[peer.ID()] = struct{}{} + } + select { + case s.update <- struct{}{}: + default: + } + }() s.lock.Lock() - if _, ok := s.peers[peer.ID()]; ok { - s.accountIdlers[peer.ID()] = struct{}{} - } - select { - case s.update <- struct{}{}: - default: - } // Ensure the response is for a valid request req, ok := s.accountReqs[id] if !ok { @@ -2360,14 +2364,18 @@ func (s *Syncer) onByteCodes(peer SyncPeer, id uint64, bytecodes [][]byte) error // Whether or not the response is valid, we can mark the peer as idle and // notify the scheduler to assign a new task. If the response is invalid, // we'll drop the peer in a bit. + defer func() { + s.lock.Lock() + defer s.lock.Unlock() + if _, ok := s.peers[peer.ID()]; ok { + s.bytecodeIdlers[peer.ID()] = struct{}{} + } + select { + case s.update <- struct{}{}: + default: + } + }() s.lock.Lock() - if _, ok := s.peers[peer.ID()]; ok { - s.bytecodeIdlers[peer.ID()] = struct{}{} - } - select { - case s.update <- struct{}{}: - default: - } // Ensure the response is for a valid request req, ok := s.bytecodeReqs[id] if !ok { @@ -2469,14 +2477,18 @@ func (s *Syncer) OnStorage(peer SyncPeer, id uint64, hashes [][]common.Hash, slo // Whether or not the response is valid, we can mark the peer as idle and // notify the scheduler to assign a new task. If the response is invalid, // we'll drop the peer in a bit. + defer func() { + s.lock.Lock() + defer s.lock.Unlock() + if _, ok := s.peers[peer.ID()]; ok { + s.storageIdlers[peer.ID()] = struct{}{} + } + select { + case s.update <- struct{}{}: + default: + } + }() s.lock.Lock() - if _, ok := s.peers[peer.ID()]; ok { - s.storageIdlers[peer.ID()] = struct{}{} - } - select { - case s.update <- struct{}{}: - default: - } // Ensure the response is for a valid request req, ok := s.storageReqs[id] if !ok { @@ -2596,14 +2608,18 @@ func (s *Syncer) OnTrieNodes(peer SyncPeer, id uint64, trienodes [][]byte) error // Whether or not the response is valid, we can mark the peer as idle and // notify the scheduler to assign a new task. If the response is invalid, // we'll drop the peer in a bit. + defer func() { + s.lock.Lock() + defer s.lock.Unlock() + if _, ok := s.peers[peer.ID()]; ok { + s.trienodeHealIdlers[peer.ID()] = struct{}{} + } + select { + case s.update <- struct{}{}: + default: + } + }() s.lock.Lock() - if _, ok := s.peers[peer.ID()]; ok { - s.trienodeHealIdlers[peer.ID()] = struct{}{} - } - select { - case s.update <- struct{}{}: - default: - } // Ensure the response is for a valid request req, ok := s.trienodeHealReqs[id] if !ok { @@ -2691,14 +2707,18 @@ func (s *Syncer) onHealByteCodes(peer SyncPeer, id uint64, bytecodes [][]byte) e // Whether or not the response is valid, we can mark the peer as idle and // notify the scheduler to assign a new task. If the response is invalid, // we'll drop the peer in a bit. + defer func() { + s.lock.Lock() + defer s.lock.Unlock() + if _, ok := s.peers[peer.ID()]; ok { + s.bytecodeHealIdlers[peer.ID()] = struct{}{} + } + select { + case s.update <- struct{}{}: + default: + } + }() s.lock.Lock() - if _, ok := s.peers[peer.ID()]; ok { - s.bytecodeHealIdlers[peer.ID()] = struct{}{} - } - select { - case s.update <- struct{}{}: - default: - } // Ensure the response is for a valid request req, ok := s.bytecodeHealReqs[id] if !ok { From 937ea491f95e5676d2ce3e0364ba9f05452bc351 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Fri, 9 Sep 2022 11:42:57 +0300 Subject: [PATCH 07/51] eth/protocols/snap: throttle trie heal requests when peers DoS us (#25666) * eth/protocols/snap: throttle trie heal requests when peers DoS us * eth/protocols/snap: lower heal throttle log to debug Co-authored-by: Martin Holst Swende * eth/protocols/snap: fix comment Co-authored-by: Martin Holst Swende --- eth/protocols/snap/sync.go | 107 ++++++++++++++++++++++++++++++++++--- 1 file changed, 100 insertions(+), 7 deletions(-) diff --git a/eth/protocols/snap/sync.go b/eth/protocols/snap/sync.go index 1455bacbcb88..eb8260bf7c97 100644 --- a/eth/protocols/snap/sync.go +++ b/eth/protocols/snap/sync.go @@ -21,10 +21,12 @@ import ( "encoding/json" "errors" "fmt" + gomath "math" "math/big" "math/rand" "sort" "sync" + "sync/atomic" "time" "github.com/ethereum/go-ethereum/common" @@ -78,6 +80,29 @@ const ( // and waste round trip times. If it's too high, we're capping responses and // waste bandwidth. maxTrieRequestCount = maxRequestSize / 512 + + // trienodeHealRateMeasurementImpact is the impact a single measurement has on + // the local node's trienode processing capacity. A value closer to 0 reacts + // slower to sudden changes, but it is also more stable against temporary hiccups. + trienodeHealRateMeasurementImpact = 0.005 + + // minTrienodeHealThrottle is the minimum divisor for throttling trie node + // heal requests to avoid overloading the local node and exessively expanding + // the state trie bedth wise. + minTrienodeHealThrottle = 1 + + // maxTrienodeHealThrottle is the maximum divisor for throttling trie node + // heal requests to avoid overloading the local node and exessively expanding + // the state trie bedth wise. + maxTrienodeHealThrottle = maxTrieRequestCount + + // trienodeHealThrottleIncrease is the multiplier for the throttle when the + // rate of arriving data is higher than the rate of processing it. + trienodeHealThrottleIncrease = 1.33 + + // trienodeHealThrottleDecrease is the divisor for the throttle when the + // rate of arriving data is lower than the rate of processing it. + trienodeHealThrottleDecrease = 1.25 ) var ( @@ -431,6 +456,11 @@ type Syncer struct { trienodeHealReqs map[uint64]*trienodeHealRequest // Trie node requests currently running bytecodeHealReqs map[uint64]*bytecodeHealRequest // Bytecode requests currently running + trienodeHealRate float64 // Average heal rate for processing trie node data + trienodeHealPend uint64 // Number of trie nodes currently pending for processing + trienodeHealThrottle float64 // Divisor for throttling the amount of trienode heal data requested + trienodeHealThrottled time.Time // Timestamp the last time the throttle was updated + trienodeHealSynced uint64 // Number of state trie nodes downloaded trienodeHealBytes common.StorageSize // Number of state trie bytes persisted to disk trienodeHealDups uint64 // Number of state trie nodes already processed @@ -476,9 +506,10 @@ func NewSyncer(db ethdb.KeyValueStore) *Syncer { trienodeHealIdlers: make(map[string]struct{}), bytecodeHealIdlers: make(map[string]struct{}), - trienodeHealReqs: make(map[uint64]*trienodeHealRequest), - bytecodeHealReqs: make(map[uint64]*bytecodeHealRequest), - stateWriter: db.NewBatch(), + trienodeHealReqs: make(map[uint64]*trienodeHealRequest), + bytecodeHealReqs: make(map[uint64]*bytecodeHealRequest), + trienodeHealThrottle: maxTrienodeHealThrottle, // Tune downward instead of insta-filling with junk + stateWriter: db.NewBatch(), extProgress: new(SyncProgress), } @@ -1321,6 +1352,10 @@ func (s *Syncer) assignTrienodeHealTasks(success chan *trienodeHealResponse, fai if cap > maxTrieRequestCount { cap = maxTrieRequestCount } + cap = int(float64(cap) / s.trienodeHealThrottle) + if cap <= 0 { + cap = 1 + } var ( hashes = make([]common.Hash, 0, cap) paths = make([]string, 0, cap) @@ -2090,6 +2125,10 @@ func (s *Syncer) processStorageResponse(res *storageResponse) { // processTrienodeHealResponse integrates an already validated trienode response // into the healer tasks. func (s *Syncer) processTrienodeHealResponse(res *trienodeHealResponse) { + var ( + start = time.Now() + fills int + ) for i, hash := range res.hashes { node := res.nodes[i] @@ -2098,6 +2137,8 @@ func (s *Syncer) processTrienodeHealResponse(res *trienodeHealResponse) { res.task.trieTasks[res.paths[i]] = res.hashes[i] continue } + fills++ + // Push the trie node into the state syncer s.trienodeHealSynced++ s.trienodeHealBytes += common.StorageSize(len(node)) @@ -2121,6 +2162,50 @@ func (s *Syncer) processTrienodeHealResponse(res *trienodeHealResponse) { log.Crit("Failed to persist healing data", "err", err) } log.Debug("Persisted set of healing data", "type", "trienodes", "bytes", common.StorageSize(batch.ValueSize())) + + // Calculate the processing rate of one filled trie node + rate := float64(fills) / (float64(time.Since(start)) / float64(time.Second)) + + // Update the currently measured trienode queueing and processing throughput. + // + // The processing rate needs to be updated uniformly independent if we've + // processed 1x100 trie nodes or 100x1 to keep the rate consistent even in + // the face of varying network packets. As such, we cannot just measure the + // time it took to process N trie nodes and update once, we need one update + // per trie node. + // + // Naively, that would be: + // + // for i:=0; i time.Second { + // Periodically adjust the trie node throttler + if float64(pending) > 2*s.trienodeHealRate { + s.trienodeHealThrottle *= trienodeHealThrottleIncrease + } else { + s.trienodeHealThrottle /= trienodeHealThrottleDecrease + } + if s.trienodeHealThrottle > maxTrienodeHealThrottle { + s.trienodeHealThrottle = maxTrienodeHealThrottle + } else if s.trienodeHealThrottle < minTrienodeHealThrottle { + s.trienodeHealThrottle = minTrienodeHealThrottle + } + s.trienodeHealThrottled = time.Now() + + log.Debug("Updated trie node heal throttler", "rate", s.trienodeHealRate, "pending", pending, "throttle", s.trienodeHealThrottle) + } } // processBytecodeHealResponse integrates an already validated bytecode response @@ -2655,10 +2740,12 @@ func (s *Syncer) OnTrieNodes(peer SyncPeer, id uint64, trienodes [][]byte) error // Cross reference the requested trienodes with the response to find gaps // that the serving node is missing - hasher := sha3.NewLegacyKeccak256().(crypto.KeccakState) - hash := make([]byte, 32) - - nodes := make([][]byte, len(req.hashes)) + var ( + hasher = sha3.NewLegacyKeccak256().(crypto.KeccakState) + hash = make([]byte, 32) + nodes = make([][]byte, len(req.hashes)) + fills uint64 + ) for i, j := 0, 0; i < len(trienodes); i++ { // Find the next hash that we've been served, leaving misses with nils hasher.Reset() @@ -2670,16 +2757,22 @@ func (s *Syncer) OnTrieNodes(peer SyncPeer, id uint64, trienodes [][]byte) error } if j < len(req.hashes) { nodes[j] = trienodes[i] + fills++ j++ continue } // We've either ran out of hashes, or got unrequested data logger.Warn("Unexpected healing trienodes", "count", len(trienodes)-i) + // Signal this request as failed, and ready for rescheduling s.scheduleRevertTrienodeHealRequest(req) return errors.New("unexpected healing trienode") } // Response validated, send it to the scheduler for filling + atomic.AddUint64(&s.trienodeHealPend, fills) + defer func() { + atomic.AddUint64(&s.trienodeHealPend, ^(fills - 1)) + }() response := &trienodeHealResponse{ paths: req.paths, task: req.task, From a32e69a28c2abef6a6b96e8d2466f1f27fd693ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Tue, 6 Sep 2022 12:57:03 +0300 Subject: [PATCH 08/51] trie: check childrens' existence concurrently for snap heal (#25694) --- trie/sync.go | 57 +++++++++++++++++++++++++++++++++++----------------- 1 file changed, 39 insertions(+), 18 deletions(-) diff --git a/trie/sync.go b/trie/sync.go index 303fcbfa22e2..862ce7e16e6c 100644 --- a/trie/sync.go +++ b/trie/sync.go @@ -19,6 +19,7 @@ package trie import ( "errors" "fmt" + "sync" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/prque" @@ -381,11 +382,11 @@ func (s *Sync) scheduleCodeRequest(req *codeRequest) { // retrieval scheduling. func (s *Sync) children(req *nodeRequest, object node) ([]*nodeRequest, error) { // Gather all the children of the node, irrelevant whether known or not - type child struct { + type childNode struct { path []byte node node } - var children []child + var children []childNode switch node := (object).(type) { case *shortNode: @@ -393,14 +394,14 @@ func (s *Sync) children(req *nodeRequest, object node) ([]*nodeRequest, error) { if hasTerm(key) { key = key[:len(key)-1] } - children = []child{{ + children = []childNode{{ node: node.Val, path: append(append([]byte(nil), req.path...), key...), }} case *fullNode: for i := 0; i < 17; i++ { if node.Children[i] != nil { - children = append(children, child{ + children = append(children, childNode{ node: node.Children[i], path: append(append([]byte(nil), req.path...), byte(i)), }) @@ -410,7 +411,10 @@ func (s *Sync) children(req *nodeRequest, object node) ([]*nodeRequest, error) { panic(fmt.Sprintf("unknown node: %+v", node)) } // Iterate over the children, and request all unknown ones - requests := make([]*nodeRequest, 0, len(children)) + var ( + missing = make(chan *nodeRequest, len(children)) + pending sync.WaitGroup + ) for _, child := range children { // Notify any external watcher of a new key/value node if req.callback != nil { @@ -433,19 +437,36 @@ func (s *Sync) children(req *nodeRequest, object node) ([]*nodeRequest, error) { if s.membatch.hasNode(child.path) { continue } - // If database says duplicate, then at least the trie node is present - // and we hold the assumption that it's NOT legacy contract code. - chash := common.BytesToHash(node) - if rawdb.HasTrieNode(s.database, chash) { - continue - } - // Locally unknown node, schedule for retrieval - requests = append(requests, &nodeRequest{ - path: child.path, - hash: chash, - parent: req, - callback: req.callback, - }) + // Check the presence of children concurrently + pending.Add(1) + go func(child childNode) { + defer pending.Done() + + // If database says duplicate, then at least the trie node is present + // and we hold the assumption that it's NOT legacy contract code. + chash := common.BytesToHash(node) + if rawdb.HasTrieNode(s.database, chash) { + return + } + // Locally unknown node, schedule for retrieval + missing <- &nodeRequest{ + path: child.path, + hash: chash, + parent: req, + callback: req.callback, + } + }(child) + } + } + pending.Wait() + + requests := make([]*nodeRequest, 0, len(children)) + for done := false; !done; { + select { + case miss := <-missing: + requests = append(requests, miss) + default: + done = true } } return requests, nil From 99bbb337011ef614fc5d25c130aa1cef92915366 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Tue, 20 Sep 2022 14:14:24 +0300 Subject: [PATCH 09/51] eth: fix a rare datarace on CHT challenge reply / shutdown (#25831) --- eth/handler.go | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/eth/handler.go b/eth/handler.go index 4224a9f33a84..143147b0c815 100644 --- a/eth/handler.go +++ b/eth/handler.go @@ -391,11 +391,16 @@ func (h *handler) runEthPeer(peer *eth.Peer, handler eth.Handler) error { if h.checkpointHash != (common.Hash{}) { // Request the peer's checkpoint header for chain height/weight validation resCh := make(chan *eth.Response) - if _, err := peer.RequestHeadersByNumber(h.checkpointNumber, 1, 0, false, resCh); err != nil { + + req, err := peer.RequestHeadersByNumber(h.checkpointNumber, 1, 0, false, resCh) + if err != nil { return err } // Start a timer to disconnect if the peer doesn't reply in time go func() { + // Ensure the request gets cancelled in case of error/drop + defer req.Close() + timeout := time.NewTimer(syncChallengeTimeout) defer timeout.Stop() @@ -437,10 +442,15 @@ func (h *handler) runEthPeer(peer *eth.Peer, handler eth.Handler) error { // If we have any explicit peer required block hashes, request them for number, hash := range h.requiredBlocks { resCh := make(chan *eth.Response) - if _, err := peer.RequestHeadersByNumber(number, 1, 0, false, resCh); err != nil { + + req, err := peer.RequestHeadersByNumber(number, 1, 0, false, resCh) + if err != nil { return err } - go func(number uint64, hash common.Hash) { + go func(number uint64, hash common.Hash, req *eth.Request) { + // Ensure the request gets cancelled in case of error/drop + defer req.Close() + timeout := time.NewTimer(syncChallengeTimeout) defer timeout.Stop() @@ -469,7 +479,7 @@ func (h *handler) runEthPeer(peer *eth.Peer, handler eth.Handler) error { peer.Log().Warn("Required block challenge timed out, dropping", "addr", peer.RemoteAddr(), "type", peer.Name()) h.removePeer(peer.ID()) } - }(number, hash) + }(number, hash, req) } // Handle incoming messages until the connection is torn down return handler(peer) From 27600a5b8452c39ce9ef5c502c98a0c1ee35859b Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Thu, 27 Oct 2022 15:25:01 +0200 Subject: [PATCH 10/51] eth/filters: change filter block to be by-ref (#26054) This PR changes the block field in the filter to be a pointer, to disambiguate between empty hash and no hash --- eth/filters/filter.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/eth/filters/filter.go b/eth/filters/filter.go index 0a70c9ece1db..8d80647fc241 100644 --- a/eth/filters/filter.go +++ b/eth/filters/filter.go @@ -34,8 +34,8 @@ type Filter struct { addresses []common.Address topics [][]common.Hash - block common.Hash // Block hash if filtering a single block - begin, end int64 // Range interval if filtering multiple blocks + block *common.Hash // Block hash if filtering a single block + begin, end int64 // Range interval if filtering multiple blocks matcher *bloombits.Matcher } @@ -78,7 +78,7 @@ func (sys *FilterSystem) NewRangeFilter(begin, end int64, addresses []common.Add func (sys *FilterSystem) NewBlockFilter(block common.Hash, addresses []common.Address, topics [][]common.Hash) *Filter { // Create a generic filter and convert it into a block filter filter := newFilter(sys, addresses, topics) - filter.block = block + filter.block = &block return filter } @@ -96,8 +96,8 @@ func newFilter(sys *FilterSystem, addresses []common.Address, topics [][]common. // first block that contains matches, updating the start of the filter accordingly. func (f *Filter) Logs(ctx context.Context) ([]*types.Log, error) { // If we're doing singleton block filtering, execute and return - if f.block != (common.Hash{}) { - header, err := f.sys.backend.HeaderByHash(ctx, f.block) + if f.block != nil { + header, err := f.sys.backend.HeaderByHash(ctx, *f.block) if err != nil { return nil, err } From 211dbb719711420358a3cdf718ce476c212adcf5 Mon Sep 17 00:00:00 2001 From: Jordan Krage Date: Wed, 2 Nov 2022 09:29:33 -0500 Subject: [PATCH 11/51] rpc: handle wrong HTTP batch response length (#26064) --- rpc/client.go | 1 + rpc/client_test.go | 48 ++++++++++++++++++++++++++++++++++++++++++++++ rpc/http.go | 3 +++ 3 files changed, 52 insertions(+) diff --git a/rpc/client.go b/rpc/client.go index d3ce0297754c..fcd31319a3c5 100644 --- a/rpc/client.go +++ b/rpc/client.go @@ -31,6 +31,7 @@ import ( ) var ( + ErrBadResult = errors.New("bad result in JSON-RPC response") ErrClientQuit = errors.New("client is closed") ErrNoResult = errors.New("no result in JSON-RPC response") ErrSubscriptionQueueOverflow = errors.New("subscription queue overflow") diff --git a/rpc/client_test.go b/rpc/client_test.go index 04c847d0d626..5ae549d86533 100644 --- a/rpc/client_test.go +++ b/rpc/client_test.go @@ -19,6 +19,7 @@ package rpc import ( "context" "encoding/json" + "errors" "fmt" "math/rand" "net" @@ -144,6 +145,53 @@ func TestClientBatchRequest(t *testing.T) { } } +func TestClientBatchRequest_len(t *testing.T) { + b, err := json.Marshal([]jsonrpcMessage{ + {Version: "2.0", ID: json.RawMessage("1"), Method: "foo", Result: json.RawMessage(`"0x1"`)}, + {Version: "2.0", ID: json.RawMessage("2"), Method: "bar", Result: json.RawMessage(`"0x2"`)}, + }) + if err != nil { + t.Fatal("failed to encode jsonrpc message:", err) + } + s := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) { + _, err := rw.Write(b) + if err != nil { + t.Error("failed to write response:", err) + } + })) + t.Cleanup(s.Close) + + client, err := Dial(s.URL) + if err != nil { + t.Fatal("failed to dial test server:", err) + } + defer client.Close() + + t.Run("too-few", func(t *testing.T) { + batch := []BatchElem{ + {Method: "foo"}, + {Method: "bar"}, + {Method: "baz"}, + } + ctx, cancelFn := context.WithTimeout(context.Background(), time.Second) + defer cancelFn() + if err := client.BatchCallContext(ctx, batch); !errors.Is(err, ErrBadResult) { + t.Errorf("expected %q but got: %v", ErrBadResult, err) + } + }) + + t.Run("too-many", func(t *testing.T) { + batch := []BatchElem{ + {Method: "foo"}, + } + ctx, cancelFn := context.WithTimeout(context.Background(), time.Second) + defer cancelFn() + if err := client.BatchCallContext(ctx, batch); !errors.Is(err, ErrBadResult) { + t.Errorf("expected %q but got: %v", ErrBadResult, err) + } + }) +} + func TestClientNotify(t *testing.T) { server := newTestServer() defer server.Stop() diff --git a/rpc/http.go b/rpc/http.go index 858d80858652..b82ea2707a54 100644 --- a/rpc/http.go +++ b/rpc/http.go @@ -173,6 +173,9 @@ func (c *Client) sendBatchHTTP(ctx context.Context, op *requestOp, msgs []*jsonr if err := json.NewDecoder(respBody).Decode(&respmsgs); err != nil { return err } + if len(respmsgs) != len(msgs) { + return fmt.Errorf("batch has %d requests but response has %d: %w", len(msgs), len(respmsgs), ErrBadResult) + } for i := 0; i < len(respmsgs); i++ { op.resp <- &respmsgs[i] } From e5eb32acee19cc9fca6a03b10283b7484246b15a Mon Sep 17 00:00:00 2001 From: Felix Lange Date: Thu, 3 Nov 2022 11:59:33 +0100 Subject: [PATCH 12/51] params: release geth v1.10.26 stable --- params/version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/params/version.go b/params/version.go index 3b5978e849cd..d9a3958512c3 100644 --- a/params/version.go +++ b/params/version.go @@ -23,7 +23,7 @@ import ( const ( VersionMajor = 1 // Major version component of the current release VersionMinor = 10 // Minor version component of the current release - VersionPatch = 25 // Patch version component of the current release + VersionPatch = 26 // Patch version component of the current release VersionMeta = "stable" // Version metadata to append to the version string ) From 37748e5db6874bb3c886967d19d9da9ba4197249 Mon Sep 17 00:00:00 2001 From: Devon Bear Date: Mon, 16 Jan 2023 18:18:58 -0500 Subject: [PATCH 13/51] stateful --- core/vm/contracts.go | 57 +++++++++++++++++++++-------------------- core/vm/evm.go | 57 +++++++++++++++++++++++++++++------------ core/vm/instructions.go | 19 +++++++++----- go.mod | 2 -- go.sum | 34 +++--------------------- 5 files changed, 87 insertions(+), 82 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 1b832b638695..93b75fb38d34 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -36,8 +36,8 @@ import ( // requires a deterministic gas count based on the input size of the Run method of the // contract. type PrecompiledContract interface { - RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use - Run(input []byte) ([]byte, error) // Run runs the precompiled contract + RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use + Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) // Run runs the precompiled contract } // PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum @@ -151,7 +151,7 @@ func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uin return nil, 0, ErrOutOfGas } suppliedGas -= gasCost - output, err := p.Run(input) + output, err := p.Run(nil, input, common.Address{}, nil, true) return output, suppliedGas, err } @@ -162,7 +162,7 @@ func (c *ecrecover) RequiredGas(input []byte) uint64 { return params.EcrecoverGas } -func (c *ecrecover) Run(input []byte) ([]byte, error) { +func (c *ecrecover) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { const ecRecoverInputLength = 128 input = common.RightPadBytes(input, ecRecoverInputLength) @@ -203,7 +203,7 @@ type sha256hash struct{} func (c *sha256hash) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.Sha256PerWordGas + params.Sha256BaseGas } -func (c *sha256hash) Run(input []byte) ([]byte, error) { +func (c *sha256hash) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { h := sha256.Sum256(input) return h[:], nil } @@ -218,7 +218,7 @@ type ripemd160hash struct{} func (c *ripemd160hash) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.Ripemd160PerWordGas + params.Ripemd160BaseGas } -func (c *ripemd160hash) Run(input []byte) ([]byte, error) { +func (c *ripemd160hash) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { ripemd := ripemd160.New() ripemd.Write(input) return common.LeftPadBytes(ripemd.Sum(nil), 32), nil @@ -234,8 +234,8 @@ type dataCopy struct{} func (c *dataCopy) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.IdentityPerWordGas + params.IdentityBaseGas } -func (c *dataCopy) Run(in []byte) ([]byte, error) { - return in, nil +func (c *dataCopy) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { + return input, nil } // bigModExp implements a native big integer exponential modular operation. @@ -264,9 +264,10 @@ var ( // modexpMultComplexity implements bigModexp multComplexity formula, as defined in EIP-198 // // def mult_complexity(x): -// if x <= 64: return x ** 2 -// elif x <= 1024: return x ** 2 // 4 + 96 * x - 3072 -// else: return x ** 2 // 16 + 480 * x - 199680 +// +// if x <= 64: return x ** 2 +// elif x <= 1024: return x ** 2 // 4 + 96 * x - 3072 +// else: return x ** 2 // 16 + 480 * x - 199680 // // where is x is max(length_of_MODULUS, length_of_BASE) func modexpMultComplexity(x *big.Int) *big.Int { @@ -360,7 +361,7 @@ func (c *bigModExp) RequiredGas(input []byte) uint64 { return gas.Uint64() } -func (c *bigModExp) Run(input []byte) ([]byte, error) { +func (c *bigModExp) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { var ( baseLen = new(big.Int).SetBytes(getData(input, 0, 32)).Uint64() expLen = new(big.Int).SetBytes(getData(input, 32, 32)).Uint64() @@ -433,7 +434,7 @@ func (c *bn256AddIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256AddGasIstanbul } -func (c *bn256AddIstanbul) Run(input []byte) ([]byte, error) { +func (c *bn256AddIstanbul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Add(input) } @@ -446,7 +447,7 @@ func (c *bn256AddByzantium) RequiredGas(input []byte) uint64 { return params.Bn256AddGasByzantium } -func (c *bn256AddByzantium) Run(input []byte) ([]byte, error) { +func (c *bn256AddByzantium) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Add(input) } @@ -471,7 +472,7 @@ func (c *bn256ScalarMulIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasIstanbul } -func (c *bn256ScalarMulIstanbul) Run(input []byte) ([]byte, error) { +func (c *bn256ScalarMulIstanbul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256ScalarMul(input) } @@ -484,7 +485,7 @@ func (c *bn256ScalarMulByzantium) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasByzantium } -func (c *bn256ScalarMulByzantium) Run(input []byte) ([]byte, error) { +func (c *bn256ScalarMulByzantium) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256ScalarMul(input) } @@ -539,7 +540,7 @@ func (c *bn256PairingIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasIstanbul + uint64(len(input)/192)*params.Bn256PairingPerPointGasIstanbul } -func (c *bn256PairingIstanbul) Run(input []byte) ([]byte, error) { +func (c *bn256PairingIstanbul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Pairing(input) } @@ -552,7 +553,7 @@ func (c *bn256PairingByzantium) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasByzantium + uint64(len(input)/192)*params.Bn256PairingPerPointGasByzantium } -func (c *bn256PairingByzantium) Run(input []byte) ([]byte, error) { +func (c *bn256PairingByzantium) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Pairing(input) } @@ -578,7 +579,7 @@ var ( errBlake2FInvalidFinalFlag = errors.New("invalid final flag") ) -func (c *blake2F) Run(input []byte) ([]byte, error) { +func (c *blake2F) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Make sure the input is valid (correct length and final flag) if len(input) != blake2FInputLength { return nil, errBlake2FInvalidInputLength @@ -632,7 +633,7 @@ func (c *bls12381G1Add) RequiredGas(input []byte) uint64 { return params.Bls12381G1AddGas } -func (c *bls12381G1Add) Run(input []byte) ([]byte, error) { +func (c *bls12381G1Add) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1Add precompile. // > G1 addition call expects `256` bytes as an input that is interpreted as byte concatenation of two G1 points (`128` bytes each). // > Output is an encoding of addition operation result - single G1 point (`128` bytes). @@ -670,7 +671,7 @@ func (c *bls12381G1Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G1MulGas } -func (c *bls12381G1Mul) Run(input []byte) ([]byte, error) { +func (c *bls12381G1Mul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1Mul precompile. // > G1 multiplication call expects `160` bytes as an input that is interpreted as byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiplication operation result - single G1 point (`128` bytes). @@ -720,7 +721,7 @@ func (c *bls12381G1MultiExp) RequiredGas(input []byte) uint64 { return (uint64(k) * params.Bls12381G1MulGas * discount) / 1000 } -func (c *bls12381G1MultiExp) Run(input []byte) ([]byte, error) { +func (c *bls12381G1MultiExp) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1MultiExp precompile. // G1 multiplication call expects `160*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes). // Output is an encoding of multiexponentiation operation result - single G1 point (`128` bytes). @@ -763,7 +764,7 @@ func (c *bls12381G2Add) RequiredGas(input []byte) uint64 { return params.Bls12381G2AddGas } -func (c *bls12381G2Add) Run(input []byte) ([]byte, error) { +func (c *bls12381G2Add) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2Add precompile. // > G2 addition call expects `512` bytes as an input that is interpreted as byte concatenation of two G2 points (`256` bytes each). // > Output is an encoding of addition operation result - single G2 point (`256` bytes). @@ -801,7 +802,7 @@ func (c *bls12381G2Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G2MulGas } -func (c *bls12381G2Mul) Run(input []byte) ([]byte, error) { +func (c *bls12381G2Mul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2MUL precompile logic. // > G2 multiplication call expects `288` bytes as an input that is interpreted as byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiplication operation result - single G2 point (`256` bytes). @@ -851,7 +852,7 @@ func (c *bls12381G2MultiExp) RequiredGas(input []byte) uint64 { return (uint64(k) * params.Bls12381G2MulGas * discount) / 1000 } -func (c *bls12381G2MultiExp) Run(input []byte) ([]byte, error) { +func (c *bls12381G2MultiExp) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2MultiExp precompile logic // > G2 multiplication call expects `288*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiexponentiation operation result - single G2 point (`256` bytes). @@ -894,7 +895,7 @@ func (c *bls12381Pairing) RequiredGas(input []byte) uint64 { return params.Bls12381PairingBaseGas + uint64(len(input)/384)*params.Bls12381PairingPerPairGas } -func (c *bls12381Pairing) Run(input []byte) ([]byte, error) { +func (c *bls12381Pairing) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Pairing precompile logic. // > Pairing call expects `384*k` bytes as an inputs that is interpreted as byte concatenation of `k` slices. Each slice has the following structure: // > - `128` bytes of G1 point encoding @@ -973,7 +974,7 @@ func (c *bls12381MapG1) RequiredGas(input []byte) uint64 { return params.Bls12381MapG1Gas } -func (c *bls12381MapG1) Run(input []byte) ([]byte, error) { +func (c *bls12381MapG1) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Map_To_G1 precompile. // > Field-to-curve call expects `64` bytes an an input that is interpreted as a an element of the base field. // > Output of this call is `128` bytes and is G1 point following respective encoding rules. @@ -1008,7 +1009,7 @@ func (c *bls12381MapG2) RequiredGas(input []byte) uint64 { return params.Bls12381MapG2Gas } -func (c *bls12381MapG2) Run(input []byte) ([]byte, error) { +func (c *bls12381MapG2) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Map_FP2_TO_G2 precompile logic. // > Field-to-curve call expects `128` bytes an an input that is interpreted as a an element of the quadratic extension field. // > Output of this call is `256` bytes and is G2 point following respective encoding rules. diff --git a/core/vm/evm.go b/core/vm/evm.go index dd55618bf812..628839c7257f 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -41,14 +41,22 @@ type ( GetHashFunc func(uint64) common.Hash ) -func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) { +type PrecompileRegistry interface { + GetContract(addr common.Address) (PrecompiledContract, bool) +} + +type BasePrecompileRegistry struct { + chainRules params.Rules +} + +func (bpm *BasePrecompileRegistry) GetContract(addr common.Address) (PrecompiledContract, bool) { var precompiles map[common.Address]PrecompiledContract switch { - case evm.chainRules.IsBerlin: + case bpm.chainRules.IsBerlin: precompiles = PrecompiledContractsBerlin - case evm.chainRules.IsIstanbul: + case bpm.chainRules.IsIstanbul: precompiles = PrecompiledContractsIstanbul - case evm.chainRules.IsByzantium: + case bpm.chainRules.IsByzantium: precompiles = PrecompiledContractsByzantium default: precompiles = PrecompiledContractsHomestead @@ -57,6 +65,17 @@ func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) { return p, ok } +func RunContract(sdb StateDB, p PrecompiledContract, input []byte, caller common.Address, + value *big.Int, suppliedGas uint64, readonly bool) (ret []byte, remainingGas uint64, err error) { + gasCost := p.RequiredGas(input) + if suppliedGas < gasCost { + return nil, 0, ErrOutOfGas + } + suppliedGas -= gasCost + output, err := p.Run(sdb, input, caller, value, readonly) + return output, suppliedGas, err +} + // BlockContext provides the EVM with auxiliary information. Once provided // it shouldn't be modified. type BlockContext struct { @@ -75,7 +94,7 @@ type BlockContext struct { Time *big.Int // Provides information for TIME Difficulty *big.Int // Provides information for DIFFICULTY BaseFee *big.Int // Provides information for BASEFEE - Random *common.Hash // Provides information for RANDOM + Random *common.Hash // Provides information for PREVRANDAO } // TxContext provides the EVM with information about a transaction. @@ -101,6 +120,8 @@ type EVM struct { TxContext // StateDB gives access to the underlying state StateDB StateDB + // PrecompileRegistry gives access to the precompiled contracts + PrecompileRegistry PrecompileRegistry // Depth is the current call stack depth int @@ -127,9 +148,12 @@ type EVM struct { // only ever be used *once*. func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config) *EVM { evm := &EVM{ - Context: blockCtx, - TxContext: txCtx, - StateDB: statedb, + Context: blockCtx, + TxContext: txCtx, + StateDB: statedb, + PrecompileRegistry: &BasePrecompileRegistry{ + chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil), + }, Config: config, chainConfig: chainConfig, chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil), @@ -175,7 +199,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - p, isPrecompile := evm.precompile(addr) + p, isPrecompile := evm.PrecompileRegistry.GetContract(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -212,7 +236,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas) + ret, gas, err = RunContract(evm.StateDB, p, input, caller.Address(), value, gas, false) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -274,8 +298,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompile(addr); isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas) + if p, isPrecompile := evm.PrecompileRegistry.GetContract(addr); isPrecompile { + ret, gas, err = RunContract(evm.StateDB, p, input, caller.Address(), value, gas, true) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -315,8 +339,9 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompile(addr); isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas) + if p, isPrecompile := evm.PrecompileRegistry.GetContract(addr); isPrecompile { + parent := caller.(*Contract) + ret, gas, err = RunContract(evm.StateDB, p, input, parent.CallerAddress, parent.value, gas, false) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -364,8 +389,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if p, isPrecompile := evm.precompile(addr); isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas) + if p, isPrecompile := evm.PrecompileRegistry.GetContract(addr); isPrecompile { + ret, gas, err = RunContract(evm.StateDB, p, input, caller.Address(), new(big.Int), gas, true) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' diff --git a/core/vm/instructions.go b/core/vm/instructions.go index 92be3bf259a3..eacc77587a20 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -392,16 +392,21 @@ func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) // opExtCodeHash returns the code hash of a specified account. // There are several cases when the function is called, while we can relay everything // to `state.GetCodeHash` function to ensure the correctness. -// (1) Caller tries to get the code hash of a normal contract account, state +// +// (1) Caller tries to get the code hash of a normal contract account, state +// // should return the relative code hash and set it as the result. // -// (2) Caller tries to get the code hash of a non-existent account, state should +// (2) Caller tries to get the code hash of a non-existent account, state should +// // return common.Hash{} and zero will be set as the result. // -// (3) Caller tries to get the code hash for an account without contract code, +// (3) Caller tries to get the code hash for an account without contract code, +// // state should return emptyCodeHash(0xc5d246...) as the result. // -// (4) Caller tries to get the code hash of a precompiled account, the result +// (4) Caller tries to get the code hash of a precompiled account, the result +// // should be zero or emptyCodeHash. // // It is worth noting that in order to avoid unnecessary create and clean, @@ -410,10 +415,12 @@ func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) // If the precompile account is not transferred any amount on a private or // customized chain, the return value will be zero. // -// (5) Caller tries to get the code hash for an account which is marked as suicided +// (5) Caller tries to get the code hash for an account which is marked as suicided +// // in the current transaction, the code hash of this account should be returned. // -// (6) Caller tries to get the code hash for an account which is marked as deleted, +// (6) Caller tries to get the code hash for an account which is marked as deleted, +// // this account should be regarded as a non-existent account and zero should be returned. func opExtCodeHash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) { slot := scope.Stack.peek() diff --git a/go.mod b/go.mod index 4a769c7a2dca..db292bb00999 100644 --- a/go.mod +++ b/go.mod @@ -82,11 +82,9 @@ require ( github.com/deepmap/oapi-codegen v1.8.2 // indirect github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91 // indirect github.com/garslo/gogen v0.0.0-20170306192744-1d203ffc1f61 // indirect - github.com/go-logfmt/logfmt v0.4.0 // indirect github.com/go-ole/go-ole v1.2.1 // indirect github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect - github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 // indirect github.com/kylelemons/godebug v1.1.0 // indirect github.com/mattn/go-runewidth v0.0.9 // indirect github.com/mitchellh/mapstructure v1.4.1 // indirect diff --git a/go.sum b/go.sum index 4b27867fbc79..8686cbcd2e6a 100644 --- a/go.sum +++ b/go.sum @@ -127,9 +127,8 @@ github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlK github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= -github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI= -github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU= github.com/garslo/gogen v0.0.0-20170306192744-1d203ffc1f61 h1:IZqZOB2fydHte3kUgxrzK5E1fW7RQGeDwE8F/ZZnUYc= github.com/garslo/gogen v0.0.0-20170306192744-1d203ffc1f61/go.mod h1:Q0X6pkwTILDlzrGEckF6HKjXe48EgsY/l7K7vhY4MW8= github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= @@ -156,7 +155,6 @@ github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5Nq github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= -github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= github.com/gofrs/uuid v3.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= @@ -204,7 +202,6 @@ github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXi github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs= github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= @@ -231,7 +228,6 @@ github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ= github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y= github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= -github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/influxdata/flux v0.65.1/go.mod h1:J754/zds0vvpfwuq7Gc2wRdVwEodfpCFM7mYlOw2LqY= github.com/influxdata/influxdb v1.8.3 h1:WEypI1BQFTT4teLM+1qkEcvUi0dAvopAI/ir0vAiBg8= @@ -320,29 +316,19 @@ github.com/naoina/go-stringutil v0.1.0 h1:rCUeRUHjBjGTSHl0VC00jUPLz8/F9dDzYI70Hz github.com/naoina/go-stringutil v0.1.0/go.mod h1:XJ2SJL9jCtBh+P9q5btrd/Ylo8XwT/h1USek5+NqSA0= github.com/naoina/toml v0.1.2-0.20170918210437-9fafd6967416 h1:shk/vn9oCoOTmwcouEdwIeOtOGA/ELRUw/GwvxwfT+0= github.com/naoina/toml v0.1.2-0.20170918210437-9fafd6967416/go.mod h1:NBIhNtsFMo3G2szEBne+bO4gS192HuIYRqfvOWb4i1E= +github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= -github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= -github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.10.3 h1:OoxbjfXVZyod1fmWYhI7SEyaD8B00ynP3T+D5GiyHOY= github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA= github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= -github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= -github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= -github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= -github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c= -github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= -github.com/onsi/gomega v1.7.1 h1:K0jcRCwNQM3vFGh1ppMtDh/+7ApJrjldlX8fA0jDTLQ= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= -github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= -github.com/onsi/gomega v1.19.0 h1:4ieX6qQjPP/BfC3mpsAtIGGlxTWPeA3Inl/7DtXw1tw= -github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro= github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/opentracing/opentracing-go v1.0.3-0.20180606204148-bd9c31933947/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU= @@ -408,14 +394,8 @@ github.com/stretchr/testify v1.7.2 h1:4jaiDzPyXQvSd7D0EjG45355tLlV3VOECpq10pLC+8 github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= github.com/supranational/blst v0.3.8-0.20220526154634-513d2456b344 h1:m+8fKfQwCAy1QjzINvKe/pYtLjo2dl59x2w9YSEJxuY= github.com/supranational/blst v0.3.8-0.20220526154634-513d2456b344/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= -github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE= -github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= -github.com/syndtr/goleveldb v1.0.1-0.20220614013038-64ee5596c38a h1:1ur3QoCqvE5fl+nylMaIr9PVV1w343YRDtsy+Rwu7XI= -github.com/syndtr/goleveldb v1.0.1-0.20220614013038-64ee5596c38a/go.mod h1:RRCYJbIwD5jmqPI9XoAFR0OcDxqUctll6zUj/+B4S48= -github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d h1:vfofYNRScrDdvS342BElfbETmL1Aiz3i2t0zfRj16Hs= -github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d/go.mod h1:RRCYJbIwD5jmqPI9XoAFR0OcDxqUctll6zUj/+B4S48= github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE= github.com/tklauser/go-sysconf v0.3.5 h1:uu3Xl4nkLzQfXNsWn15rPc/HQCJKObbt1dKJeWp3vU4= github.com/tklauser/go-sysconf v0.3.5/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI= @@ -509,11 +489,9 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210220033124-5f55cee0dc0d/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= golang.org/x/net v0.0.0-20210610132358-84b48f89b13b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220607020251-c690dde0001d h1:4SFsTMi4UahlKoloni7L4eYzhFRifURQLw+yv0QDCx8= golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -560,7 +538,6 @@ golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -569,8 +546,6 @@ golang.org/x/sys v0.0.0-20210420205809-ac73e9fd8988/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a h1:dGzPydgVsqGcTRVwiLJ1jVbufYwmzD3LfVPLKsKg+0k= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= @@ -618,7 +593,6 @@ golang.org/x/tools v0.0.0-20191126055441-b0650ceb63d9/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200108203644-89082a384178/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.8-0.20211029000441-d6a9af8af023 h1:0c3L82FDQ5rt1bjTBlchS8t6RQ6299/+5bWMnRLh+uI= golang.org/x/tools v0.1.8-0.20211029000441-d6a9af8af023/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= From cdf5821f6fa56faae77e19c6fa62ce9529c5d0d9 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 18 Jan 2023 11:57:21 -0500 Subject: [PATCH 14/51] use PrecompileExecutor --- core/vm/contracts.go | 15 --------- core/vm/evm.go | 80 +++++++++++++++----------------------------- 2 files changed, 27 insertions(+), 68 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 93b75fb38d34..fbce62a56613 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -140,21 +140,6 @@ func ActivePrecompiles(rules params.Rules) []common.Address { } } -// RunPrecompiledContract runs and evaluates the output of a precompiled contract. -// It returns -// - the returned bytes, -// - the _remaining_ gas, -// - any error that occurred -func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error) { - gasCost := p.RequiredGas(input) - if suppliedGas < gasCost { - return nil, 0, ErrOutOfGas - } - suppliedGas -= gasCost - output, err := p.Run(nil, input, common.Address{}, nil, true) - return output, suppliedGas, err -} - // ECRECOVER implemented as a native contract. type ecrecover struct{} diff --git a/core/vm/evm.go b/core/vm/evm.go index 628839c7257f..6705a675b914 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -41,39 +41,15 @@ type ( GetHashFunc func(uint64) common.Hash ) -type PrecompileRegistry interface { - GetContract(addr common.Address) (PrecompiledContract, bool) -} - -type BasePrecompileRegistry struct { - chainRules params.Rules -} - -func (bpm *BasePrecompileRegistry) GetContract(addr common.Address) (PrecompiledContract, bool) { - var precompiles map[common.Address]PrecompiledContract - switch { - case bpm.chainRules.IsBerlin: - precompiles = PrecompiledContractsBerlin - case bpm.chainRules.IsIstanbul: - precompiles = PrecompiledContractsIstanbul - case bpm.chainRules.IsByzantium: - precompiles = PrecompiledContractsByzantium - default: - precompiles = PrecompiledContractsHomestead - } - p, ok := precompiles[addr] - return p, ok -} - -func RunContract(sdb StateDB, p PrecompiledContract, input []byte, caller common.Address, - value *big.Int, suppliedGas uint64, readonly bool) (ret []byte, remainingGas uint64, err error) { - gasCost := p.RequiredGas(input) - if suppliedGas < gasCost { - return nil, 0, ErrOutOfGas - } - suppliedGas -= gasCost - output, err := p.Run(sdb, input, caller, value, readonly) - return output, suppliedGas, err +// `PrecompileExecutor` is allows the EVM to execute a precompiled contract. +type PrecompileExecutor interface { + // `Exists` returns if a precompiled contract was found at `addr`. + Exists(addr common.Address) bool + + // `Run` runs a precompiled contract and returns the leftover gas. + Run(sdb StateDB, input []byte, caller common.Address, + value *big.Int, suppliedGas uint64, readonly bool, + ) (ret []byte, leftOverGas uint64, err error) } // BlockContext provides the EVM with auxiliary information. Once provided @@ -120,8 +96,8 @@ type EVM struct { TxContext // StateDB gives access to the underlying state StateDB StateDB - // PrecompileRegistry gives access to the precompiled contracts - PrecompileRegistry PrecompileRegistry + // precompileExecutor gives access to the precompiled contracts + precompileExecutor PrecompileExecutor // Depth is the current call stack depth int @@ -146,17 +122,15 @@ type EVM struct { // NewEVM returns a new EVM. The returned EVM is not thread safe and should // only ever be used *once*. -func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config) *EVM { +func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileExecutor PrecompileExecutor) *EVM { evm := &EVM{ - Context: blockCtx, - TxContext: txCtx, - StateDB: statedb, - PrecompileRegistry: &BasePrecompileRegistry{ - chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil), - }, - Config: config, - chainConfig: chainConfig, - chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil), + Context: blockCtx, + TxContext: txCtx, + StateDB: statedb, + precompileExecutor: precompileExecutor, + Config: config, + chainConfig: chainConfig, + chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil), } evm.interpreter = NewEVMInterpreter(evm, config) return evm @@ -199,7 +173,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - p, isPrecompile := evm.PrecompileRegistry.GetContract(addr) + isPrecompile := evm.precompileExecutor.Exists(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -236,7 +210,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = RunContract(evm.StateDB, p, input, caller.Address(), value, gas, false) + ret, gas, err = evm.precompileExecutor.Run(evm.StateDB, input, caller.Address(), value, gas, false) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -298,8 +272,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.PrecompileRegistry.GetContract(addr); isPrecompile { - ret, gas, err = RunContract(evm.StateDB, p, input, caller.Address(), value, gas, true) + if evm.precompileExecutor.Exists(addr) { + ret, gas, err = evm.precompileExecutor.Run(evm.StateDB, input, caller.Address(), value, gas, true) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -339,9 +313,9 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.PrecompileRegistry.GetContract(addr); isPrecompile { + if evm.precompileExecutor.Exists(addr) { parent := caller.(*Contract) - ret, gas, err = RunContract(evm.StateDB, p, input, parent.CallerAddress, parent.value, gas, false) + ret, gas, err = evm.precompileExecutor.Run(evm.StateDB, input, parent.CallerAddress, parent.value, gas, false) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -389,8 +363,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if p, isPrecompile := evm.PrecompileRegistry.GetContract(addr); isPrecompile { - ret, gas, err = RunContract(evm.StateDB, p, input, caller.Address(), new(big.Int), gas, true) + if evm.precompileExecutor.Exists(addr) { + ret, gas, err = evm.precompileExecutor.Run(evm.StateDB, input, caller.Address(), new(big.Int), gas, true) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' From 2def4f08d7197fd1f219c6343efdfcc3a34cf3f0 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 18 Jan 2023 12:15:01 -0500 Subject: [PATCH 15/51] use host terminology --- core/vm/evm.go | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 6705a675b914..64f469701cf6 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -41,15 +41,15 @@ type ( GetHashFunc func(uint64) common.Hash ) -// `PrecompileExecutor` is allows the EVM to execute a precompiled contract. -type PrecompileExecutor interface { +// `PrecompileHost` is allows the EVM to execute a precompiled contract. +type PrecompileHost interface { // `Exists` returns if a precompiled contract was found at `addr`. Exists(addr common.Address) bool // `Run` runs a precompiled contract and returns the leftover gas. Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, suppliedGas uint64, readonly bool, - ) (ret []byte, leftOverGas uint64, err error) + ) (ret []byte, remainingGas uint64, err error) } // BlockContext provides the EVM with auxiliary information. Once provided @@ -96,8 +96,8 @@ type EVM struct { TxContext // StateDB gives access to the underlying state StateDB StateDB - // precompileExecutor gives access to the precompiled contracts - precompileExecutor PrecompileExecutor + // precompileHost gives access to the precompiled contracts + precompileHost PrecompileHost // Depth is the current call stack depth int @@ -122,15 +122,15 @@ type EVM struct { // NewEVM returns a new EVM. The returned EVM is not thread safe and should // only ever be used *once*. -func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileExecutor PrecompileExecutor) *EVM { +func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileHost PrecompileHost) *EVM { evm := &EVM{ - Context: blockCtx, - TxContext: txCtx, - StateDB: statedb, - precompileExecutor: precompileExecutor, - Config: config, - chainConfig: chainConfig, - chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil), + Context: blockCtx, + TxContext: txCtx, + StateDB: statedb, + precompileHost: precompileHost, + Config: config, + chainConfig: chainConfig, + chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil), } evm.interpreter = NewEVMInterpreter(evm, config) return evm @@ -173,7 +173,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - isPrecompile := evm.precompileExecutor.Exists(addr) + isPrecompile := evm.precompileHost.Exists(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -210,7 +210,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.precompileExecutor.Run(evm.StateDB, input, caller.Address(), value, gas, false) + ret, gas, err = evm.precompileHost.Run(evm.StateDB, input, caller.Address(), value, gas, false) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -272,8 +272,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if evm.precompileExecutor.Exists(addr) { - ret, gas, err = evm.precompileExecutor.Run(evm.StateDB, input, caller.Address(), value, gas, true) + if evm.precompileHost.Exists(addr) { + ret, gas, err = evm.precompileHost.Run(evm.StateDB, input, caller.Address(), value, gas, true) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -313,9 +313,9 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if evm.precompileExecutor.Exists(addr) { + if evm.precompileHost.Exists(addr) { parent := caller.(*Contract) - ret, gas, err = evm.precompileExecutor.Run(evm.StateDB, input, parent.CallerAddress, parent.value, gas, false) + ret, gas, err = evm.precompileHost.Run(evm.StateDB, input, parent.CallerAddress, parent.value, gas, false) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -363,8 +363,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if evm.precompileExecutor.Exists(addr) { - ret, gas, err = evm.precompileExecutor.Run(evm.StateDB, input, caller.Address(), new(big.Int), gas, true) + if evm.precompileHost.Exists(addr) { + ret, gas, err = evm.precompileHost.Run(evm.StateDB, input, caller.Address(), new(big.Int), gas, true) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' From b7ecb9efd6c3df1b76f9773b6d630c29fb5e496a Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 18 Jan 2023 13:38:06 -0500 Subject: [PATCH 16/51] return precompiledContract and bool --- core/vm/evm.go | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 64f469701cf6..b7f1f9a40e89 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -44,10 +44,10 @@ type ( // `PrecompileHost` is allows the EVM to execute a precompiled contract. type PrecompileHost interface { // `Exists` returns if a precompiled contract was found at `addr`. - Exists(addr common.Address) bool + Exists(addr common.Address) (PrecompiledContract, bool) // `Run` runs a precompiled contract and returns the leftover gas. - Run(sdb StateDB, input []byte, caller common.Address, + Run(p PrecompiledContract, sdb StateDB, input []byte, caller common.Address, value *big.Int, suppliedGas uint64, readonly bool, ) (ret []byte, remainingGas uint64, err error) } @@ -173,7 +173,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - isPrecompile := evm.precompileHost.Exists(addr) + p, isPrecompile := evm.precompileHost.Exists(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -210,7 +210,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.precompileHost.Run(evm.StateDB, input, caller.Address(), value, gas, false) + ret, gas, err = evm.precompileHost.Run(p, evm.StateDB, input, caller.Address(), value, gas, false) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -272,8 +272,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if evm.precompileHost.Exists(addr) { - ret, gas, err = evm.precompileHost.Run(evm.StateDB, input, caller.Address(), value, gas, true) + if p, isPrecompile := evm.precompileHost.Exists(addr); isPrecompile { + ret, gas, err = evm.precompileHost.Run(p, evm.StateDB, input, caller.Address(), value, gas, true) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -313,9 +313,9 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if evm.precompileHost.Exists(addr) { + if p, isPrecompile := evm.precompileHost.Exists(addr); isPrecompile { parent := caller.(*Contract) - ret, gas, err = evm.precompileHost.Run(evm.StateDB, input, parent.CallerAddress, parent.value, gas, false) + ret, gas, err = evm.precompileHost.Run(p, evm.StateDB, input, parent.CallerAddress, parent.value, gas, false) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -363,8 +363,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if evm.precompileHost.Exists(addr) { - ret, gas, err = evm.precompileHost.Run(evm.StateDB, input, caller.Address(), new(big.Int), gas, true) + if p, isPrecompile := evm.precompileHost.Exists(addr); isPrecompile { + ret, gas, err = evm.precompileHost.Run(p, evm.StateDB, input, caller.Address(), new(big.Int), gas, true) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' From d1c5ff3ddf0ddf58740e28ed3f5d535e2f8f9d14 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 18 Jan 2023 13:52:25 -0500 Subject: [PATCH 17/51] use ctx in Run instead of statedb --- core/vm/contracts.go | 47 ++++++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 23 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index fbce62a56613..d1fadab1b3cc 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -17,6 +17,7 @@ package vm import ( + "context" "crypto/sha256" "encoding/binary" "errors" @@ -36,8 +37,8 @@ import ( // requires a deterministic gas count based on the input size of the Run method of the // contract. type PrecompiledContract interface { - RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use - Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) // Run runs the precompiled contract + RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use + Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) // Run runs the precompiled contract } // PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum @@ -147,7 +148,7 @@ func (c *ecrecover) RequiredGas(input []byte) uint64 { return params.EcrecoverGas } -func (c *ecrecover) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *ecrecover) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { const ecRecoverInputLength = 128 input = common.RightPadBytes(input, ecRecoverInputLength) @@ -188,7 +189,7 @@ type sha256hash struct{} func (c *sha256hash) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.Sha256PerWordGas + params.Sha256BaseGas } -func (c *sha256hash) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *sha256hash) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { h := sha256.Sum256(input) return h[:], nil } @@ -203,7 +204,7 @@ type ripemd160hash struct{} func (c *ripemd160hash) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.Ripemd160PerWordGas + params.Ripemd160BaseGas } -func (c *ripemd160hash) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *ripemd160hash) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { ripemd := ripemd160.New() ripemd.Write(input) return common.LeftPadBytes(ripemd.Sum(nil), 32), nil @@ -219,7 +220,7 @@ type dataCopy struct{} func (c *dataCopy) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.IdentityPerWordGas + params.IdentityBaseGas } -func (c *dataCopy) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *dataCopy) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return input, nil } @@ -346,7 +347,7 @@ func (c *bigModExp) RequiredGas(input []byte) uint64 { return gas.Uint64() } -func (c *bigModExp) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bigModExp) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { var ( baseLen = new(big.Int).SetBytes(getData(input, 0, 32)).Uint64() expLen = new(big.Int).SetBytes(getData(input, 32, 32)).Uint64() @@ -419,7 +420,7 @@ func (c *bn256AddIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256AddGasIstanbul } -func (c *bn256AddIstanbul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256AddIstanbul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Add(input) } @@ -432,7 +433,7 @@ func (c *bn256AddByzantium) RequiredGas(input []byte) uint64 { return params.Bn256AddGasByzantium } -func (c *bn256AddByzantium) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256AddByzantium) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Add(input) } @@ -457,7 +458,7 @@ func (c *bn256ScalarMulIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasIstanbul } -func (c *bn256ScalarMulIstanbul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256ScalarMulIstanbul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256ScalarMul(input) } @@ -470,7 +471,7 @@ func (c *bn256ScalarMulByzantium) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasByzantium } -func (c *bn256ScalarMulByzantium) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256ScalarMulByzantium) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256ScalarMul(input) } @@ -525,7 +526,7 @@ func (c *bn256PairingIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasIstanbul + uint64(len(input)/192)*params.Bn256PairingPerPointGasIstanbul } -func (c *bn256PairingIstanbul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256PairingIstanbul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Pairing(input) } @@ -538,7 +539,7 @@ func (c *bn256PairingByzantium) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasByzantium + uint64(len(input)/192)*params.Bn256PairingPerPointGasByzantium } -func (c *bn256PairingByzantium) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256PairingByzantium) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Pairing(input) } @@ -564,7 +565,7 @@ var ( errBlake2FInvalidFinalFlag = errors.New("invalid final flag") ) -func (c *blake2F) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *blake2F) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Make sure the input is valid (correct length and final flag) if len(input) != blake2FInputLength { return nil, errBlake2FInvalidInputLength @@ -618,7 +619,7 @@ func (c *bls12381G1Add) RequiredGas(input []byte) uint64 { return params.Bls12381G1AddGas } -func (c *bls12381G1Add) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G1Add) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1Add precompile. // > G1 addition call expects `256` bytes as an input that is interpreted as byte concatenation of two G1 points (`128` bytes each). // > Output is an encoding of addition operation result - single G1 point (`128` bytes). @@ -656,7 +657,7 @@ func (c *bls12381G1Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G1MulGas } -func (c *bls12381G1Mul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G1Mul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1Mul precompile. // > G1 multiplication call expects `160` bytes as an input that is interpreted as byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiplication operation result - single G1 point (`128` bytes). @@ -706,7 +707,7 @@ func (c *bls12381G1MultiExp) RequiredGas(input []byte) uint64 { return (uint64(k) * params.Bls12381G1MulGas * discount) / 1000 } -func (c *bls12381G1MultiExp) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G1MultiExp) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1MultiExp precompile. // G1 multiplication call expects `160*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes). // Output is an encoding of multiexponentiation operation result - single G1 point (`128` bytes). @@ -749,7 +750,7 @@ func (c *bls12381G2Add) RequiredGas(input []byte) uint64 { return params.Bls12381G2AddGas } -func (c *bls12381G2Add) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G2Add) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2Add precompile. // > G2 addition call expects `512` bytes as an input that is interpreted as byte concatenation of two G2 points (`256` bytes each). // > Output is an encoding of addition operation result - single G2 point (`256` bytes). @@ -787,7 +788,7 @@ func (c *bls12381G2Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G2MulGas } -func (c *bls12381G2Mul) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G2Mul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2MUL precompile logic. // > G2 multiplication call expects `288` bytes as an input that is interpreted as byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiplication operation result - single G2 point (`256` bytes). @@ -837,7 +838,7 @@ func (c *bls12381G2MultiExp) RequiredGas(input []byte) uint64 { return (uint64(k) * params.Bls12381G2MulGas * discount) / 1000 } -func (c *bls12381G2MultiExp) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G2MultiExp) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2MultiExp precompile logic // > G2 multiplication call expects `288*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiexponentiation operation result - single G2 point (`256` bytes). @@ -880,7 +881,7 @@ func (c *bls12381Pairing) RequiredGas(input []byte) uint64 { return params.Bls12381PairingBaseGas + uint64(len(input)/384)*params.Bls12381PairingPerPairGas } -func (c *bls12381Pairing) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381Pairing) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Pairing precompile logic. // > Pairing call expects `384*k` bytes as an inputs that is interpreted as byte concatenation of `k` slices. Each slice has the following structure: // > - `128` bytes of G1 point encoding @@ -959,7 +960,7 @@ func (c *bls12381MapG1) RequiredGas(input []byte) uint64 { return params.Bls12381MapG1Gas } -func (c *bls12381MapG1) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381MapG1) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Map_To_G1 precompile. // > Field-to-curve call expects `64` bytes an an input that is interpreted as a an element of the base field. // > Output of this call is `128` bytes and is G1 point following respective encoding rules. @@ -994,7 +995,7 @@ func (c *bls12381MapG2) RequiredGas(input []byte) uint64 { return params.Bls12381MapG2Gas } -func (c *bls12381MapG2) Run(sdb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381MapG2) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Map_FP2_TO_G2 precompile logic. // > Field-to-curve call expects `128` bytes an an input that is interpreted as a an element of the quadratic extension field. // > Output of this call is `256` bytes and is G2 point following respective encoding rules. From 12579d823bbb28d0306dc1c4b9e5c691a77fc5ee Mon Sep 17 00:00:00 2001 From: Devon Bear Date: Thu, 19 Jan 2023 13:45:13 -0500 Subject: [PATCH 18/51] change to ph --- accounts/abi/bind/bind.go | 2 +- core/vm/evm.go | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index dac43f70e234..46bc31185f0c 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -190,7 +190,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] } eventIdentifiers[normalizedName] = true normalized.Name = normalizedName - + used := make(map[string]bool) normalized.Inputs = make([]abi.Argument, len(original.Inputs)) copy(normalized.Inputs, original.Inputs) diff --git a/core/vm/evm.go b/core/vm/evm.go index b7f1f9a40e89..ce83251a8684 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -47,7 +47,7 @@ type PrecompileHost interface { Exists(addr common.Address) (PrecompiledContract, bool) // `Run` runs a precompiled contract and returns the leftover gas. - Run(p PrecompiledContract, sdb StateDB, input []byte, caller common.Address, + Run(p PrecompiledContract, input []byte, caller common.Address, value *big.Int, suppliedGas uint64, readonly bool, ) (ret []byte, remainingGas uint64, err error) } @@ -210,7 +210,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.precompileHost.Run(p, evm.StateDB, input, caller.Address(), value, gas, false) + ret, gas, err = evm.precompileHost.Run(p, input, caller.Address(), value, gas, false) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -273,7 +273,7 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, // It is allowed to call precompiles, even via delegatecall if p, isPrecompile := evm.precompileHost.Exists(addr); isPrecompile { - ret, gas, err = evm.precompileHost.Run(p, evm.StateDB, input, caller.Address(), value, gas, true) + ret, gas, err = evm.precompileHost.Run(p, input, caller.Address(), value, gas, true) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -315,7 +315,7 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by // It is allowed to call precompiles, even via delegatecall if p, isPrecompile := evm.precompileHost.Exists(addr); isPrecompile { parent := caller.(*Contract) - ret, gas, err = evm.precompileHost.Run(p, evm.StateDB, input, parent.CallerAddress, parent.value, gas, false) + ret, gas, err = evm.precompileHost.Run(p, input, parent.CallerAddress, parent.value, gas, false) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -364,7 +364,7 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte } if p, isPrecompile := evm.precompileHost.Exists(addr); isPrecompile { - ret, gas, err = evm.precompileHost.Run(p, evm.StateDB, input, caller.Address(), new(big.Int), gas, true) + ret, gas, err = evm.precompileHost.Run(p, input, caller.Address(), new(big.Int), gas, true) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' From f1ef333979feb23db3b82568ee01f6e370ea5f71 Mon Sep 17 00:00:00 2001 From: Devon Bear Date: Thu, 19 Jan 2023 18:35:22 -0500 Subject: [PATCH 19/51] bing bong --- core/vm/evm.go | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index ce83251a8684..b9e2e791196a 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -122,20 +122,25 @@ type EVM struct { // NewEVM returns a new EVM. The returned EVM is not thread safe and should // only ever be used *once*. -func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileHost PrecompileHost) *EVM { +func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config) *EVM { evm := &EVM{ - Context: blockCtx, - TxContext: txCtx, - StateDB: statedb, - precompileHost: precompileHost, - Config: config, - chainConfig: chainConfig, - chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil), + Context: blockCtx, + TxContext: txCtx, + StateDB: statedb, + Config: config, + chainConfig: chainConfig, + chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil), } evm.interpreter = NewEVMInterpreter(evm, config) return evm } +func NewEVMWithPrecompileHost(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileHost PrecompileHost) *EVM { + evm := NewEVM(blockCtx, txCtx, statedb, chainConfig, config) + evm.precompileHost = precompileHost + return evm +} + // Reset resets the EVM with a new transaction context.Reset // This is not threadsafe and should only be done very cautiously. func (evm *EVM) Reset(txCtx TxContext, statedb StateDB) { From e604f74112846712688282dc342a9e8c40a5ba92 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Mon, 23 Jan 2023 14:43:24 -0500 Subject: [PATCH 20/51] rename to runner --- core/vm/evm.go | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index b9e2e791196a..b425e65d5c7d 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -41,8 +41,8 @@ type ( GetHashFunc func(uint64) common.Hash ) -// `PrecompileHost` is allows the EVM to execute a precompiled contract. -type PrecompileHost interface { +// `PrecompileRunner` is allows the EVM to execute a precompiled contract. +type PrecompileRunner interface { // `Exists` returns if a precompiled contract was found at `addr`. Exists(addr common.Address) (PrecompiledContract, bool) @@ -96,8 +96,8 @@ type EVM struct { TxContext // StateDB gives access to the underlying state StateDB StateDB - // precompileHost gives access to the precompiled contracts - precompileHost PrecompileHost + // precompileRunner gives access to the precompiled contracts + precompileRunner PrecompileRunner // Depth is the current call stack depth int @@ -135,9 +135,9 @@ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig return evm } -func NewEVMWithPrecompileHost(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileHost PrecompileHost) *EVM { +func NewEVMWithPrecompileHost(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileRunner PrecompileRunner) *EVM { evm := NewEVM(blockCtx, txCtx, statedb, chainConfig, config) - evm.precompileHost = precompileHost + evm.precompileRunner = precompileRunner return evm } @@ -178,7 +178,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - p, isPrecompile := evm.precompileHost.Exists(addr) + p, isPrecompile := evm.precompileRunner.Exists(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -215,7 +215,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.precompileHost.Run(p, input, caller.Address(), value, gas, false) + ret, gas, err = evm.precompileRunner.Run(p, input, caller.Address(), value, gas, false) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -277,8 +277,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompileHost.Exists(addr); isPrecompile { - ret, gas, err = evm.precompileHost.Run(p, input, caller.Address(), value, gas, true) + if p, isPrecompile := evm.precompileRunner.Exists(addr); isPrecompile { + ret, gas, err = evm.precompileRunner.Run(p, input, caller.Address(), value, gas, true) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -318,9 +318,9 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompileHost.Exists(addr); isPrecompile { + if p, isPrecompile := evm.precompileRunner.Exists(addr); isPrecompile { parent := caller.(*Contract) - ret, gas, err = evm.precompileHost.Run(p, input, parent.CallerAddress, parent.value, gas, false) + ret, gas, err = evm.precompileRunner.Run(p, input, parent.CallerAddress, parent.value, gas, false) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -368,8 +368,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if p, isPrecompile := evm.precompileHost.Exists(addr); isPrecompile { - ret, gas, err = evm.precompileHost.Run(p, input, caller.Address(), new(big.Int), gas, true) + if p, isPrecompile := evm.precompileRunner.Exists(addr); isPrecompile { + ret, gas, err = evm.precompileRunner.Run(p, input, caller.Address(), new(big.Int), gas, true) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' From 6dfd7b1c0c5d5371ba22e25cbd2a576287972175 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Mon, 23 Jan 2023 14:52:37 -0500 Subject: [PATCH 21/51] rename constructor --- core/vm/evm.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index b425e65d5c7d..027218c894ff 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -135,7 +135,7 @@ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig return evm } -func NewEVMWithPrecompileHost(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileRunner PrecompileRunner) *EVM { +func NewEVMWithPrecompiles(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileRunner PrecompileRunner) *EVM { evm := NewEVM(blockCtx, txCtx, statedb, chainConfig, config) evm.precompileRunner = precompileRunner return evm From 6b58c1d41d7177175e3de1938a6acc465d40a6d7 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Tue, 24 Jan 2023 12:54:21 -0500 Subject: [PATCH 22/51] new precompile function types --- core/vm/evm.go | 49 +++++++++++++++++++++++++++---------------------- 1 file changed, 27 insertions(+), 22 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 027218c894ff..a8d1b05f7429 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -41,16 +41,14 @@ type ( GetHashFunc func(uint64) common.Hash ) -// `PrecompileRunner` is allows the EVM to execute a precompiled contract. -type PrecompileRunner interface { - // `Exists` returns if a precompiled contract was found at `addr`. - Exists(addr common.Address) (PrecompiledContract, bool) - - // `Run` runs a precompiled contract and returns the leftover gas. - Run(p PrecompiledContract, input []byte, caller common.Address, - value *big.Int, suppliedGas uint64, readonly bool, - ) (ret []byte, remainingGas uint64, err error) -} +// `PrecompileExists` returns if a precompiled contract was found at `addr`. +type PrecompileExists func(addr common.Address) (p PrecompiledContract, found bool) + +// `RunPrecompile` runs a precompiled contract and returns the remaining gas. +type RunPrecompile func( + p PrecompiledContract, input []byte, caller common.Address, + value *big.Int, suppliedGas uint64, readonly bool, +) (ret []byte, remainingGas uint64, err error) // BlockContext provides the EVM with auxiliary information. Once provided // it shouldn't be modified. @@ -96,8 +94,11 @@ type EVM struct { TxContext // StateDB gives access to the underlying state StateDB StateDB - // precompileRunner gives access to the precompiled contracts - precompileRunner PrecompileRunner + // precompileExists searches an address for a precompiled + // contract + precompileExists PrecompileExists + // runPrecompile gives access running a precompiled contract + runPrecompile RunPrecompile // Depth is the current call stack depth int @@ -135,9 +136,13 @@ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig return evm } -func NewEVMWithPrecompiles(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileRunner PrecompileRunner) *EVM { +func NewEVMWithPrecompiles( + blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, + config Config, precompileExists PrecompileExists, runPrecompile RunPrecompile, +) *EVM { evm := NewEVM(blockCtx, txCtx, statedb, chainConfig, config) - evm.precompileRunner = precompileRunner + evm.precompileExists = precompileExists + evm.runPrecompile = runPrecompile return evm } @@ -178,7 +183,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - p, isPrecompile := evm.precompileRunner.Exists(addr) + p, isPrecompile := evm.precompileExists(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -215,7 +220,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.precompileRunner.Run(p, input, caller.Address(), value, gas, false) + ret, gas, err = evm.runPrecompile(p, input, caller.Address(), value, gas, false) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -277,8 +282,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompileRunner.Exists(addr); isPrecompile { - ret, gas, err = evm.precompileRunner.Run(p, input, caller.Address(), value, gas, true) + if p, isPrecompile := evm.precompileExists(addr); isPrecompile { + ret, gas, err = evm.runPrecompile(p, input, caller.Address(), value, gas, true) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -318,9 +323,9 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompileRunner.Exists(addr); isPrecompile { + if p, isPrecompile := evm.precompileExists(addr); isPrecompile { parent := caller.(*Contract) - ret, gas, err = evm.precompileRunner.Run(p, input, parent.CallerAddress, parent.value, gas, false) + ret, gas, err = evm.runPrecompile(p, input, parent.CallerAddress, parent.value, gas, false) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -368,8 +373,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if p, isPrecompile := evm.precompileRunner.Exists(addr); isPrecompile { - ret, gas, err = evm.precompileRunner.Run(p, input, caller.Address(), new(big.Int), gas, true) + if p, isPrecompile := evm.precompileExists(addr); isPrecompile { + ret, gas, err = evm.runPrecompile(p, input, caller.Address(), new(big.Int), gas, true) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' From 8f77e9a6b0383ffce433654dbe59b9e5d78c6dde Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Tue, 24 Jan 2023 14:46:22 -0500 Subject: [PATCH 23/51] precompile controller --- core/vm/evm.go | 48 +++++++++++++++++++++++------------------------- 1 file changed, 23 insertions(+), 25 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index a8d1b05f7429..00ff2729491a 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -41,14 +41,16 @@ type ( GetHashFunc func(uint64) common.Hash ) -// `PrecompileExists` returns if a precompiled contract was found at `addr`. -type PrecompileExists func(addr common.Address) (p PrecompiledContract, found bool) - -// `RunPrecompile` runs a precompiled contract and returns the remaining gas. -type RunPrecompile func( - p PrecompiledContract, input []byte, caller common.Address, - value *big.Int, suppliedGas uint64, readonly bool, -) (ret []byte, remainingGas uint64, err error) +// `PrecompileController` allows the EVM to execute a precompiled contract. +type PrecompileController interface { + // `Exists` returns if a precompiled contract was found at `addr`. + Exists(addr common.Address) (p PrecompiledContract, found bool) + + // `Run` runs a precompiled contract and returns the remaining gas. + Run(p PrecompiledContract, input []byte, caller common.Address, + value *big.Int, suppliedGas uint64, readonly bool, + ) (ret []byte, remainingGas uint64, err error) +} // BlockContext provides the EVM with auxiliary information. Once provided // it shouldn't be modified. @@ -94,11 +96,8 @@ type EVM struct { TxContext // StateDB gives access to the underlying state StateDB StateDB - // precompileExists searches an address for a precompiled - // contract - precompileExists PrecompileExists - // runPrecompile gives access running a precompiled contract - runPrecompile RunPrecompile + // precompileController finds and runs precompiled contracts + precompileController PrecompileController // Depth is the current call stack depth int @@ -137,12 +136,11 @@ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig } func NewEVMWithPrecompiles( - blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, - config Config, precompileExists PrecompileExists, runPrecompile RunPrecompile, + blockCtx BlockContext, txCtx TxContext, statedb StateDB, + chainConfig *params.ChainConfig, config Config, precompileController PrecompileController, ) *EVM { evm := NewEVM(blockCtx, txCtx, statedb, chainConfig, config) - evm.precompileExists = precompileExists - evm.runPrecompile = runPrecompile + evm.precompileController = precompileController return evm } @@ -183,7 +181,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - p, isPrecompile := evm.precompileExists(addr) + p, isPrecompile := evm.precompileController.Exists(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -220,7 +218,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.runPrecompile(p, input, caller.Address(), value, gas, false) + ret, gas, err = evm.precompileController.Run(p, input, caller.Address(), value, gas, false) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -282,8 +280,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompileExists(addr); isPrecompile { - ret, gas, err = evm.runPrecompile(p, input, caller.Address(), value, gas, true) + if p, isPrecompile := evm.precompileController.Exists(addr); isPrecompile { + ret, gas, err = evm.precompileController.Run(p, input, caller.Address(), value, gas, true) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -323,9 +321,9 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompileExists(addr); isPrecompile { + if p, isPrecompile := evm.precompileController.Exists(addr); isPrecompile { parent := caller.(*Contract) - ret, gas, err = evm.runPrecompile(p, input, parent.CallerAddress, parent.value, gas, false) + ret, gas, err = evm.precompileController.Run(p, input, parent.CallerAddress, parent.value, gas, false) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -373,8 +371,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if p, isPrecompile := evm.precompileExists(addr); isPrecompile { - ret, gas, err = evm.runPrecompile(p, input, caller.Address(), new(big.Int), gas, true) + if p, isPrecompile := evm.precompileController.Exists(addr); isPrecompile { + ret, gas, err = evm.precompileController.Run(p, input, caller.Address(), new(big.Int), gas, true) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' From eca0bbbbabc5308e4829ddad39ea55dd457c6828 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 25 Jan 2023 13:43:24 -0500 Subject: [PATCH 24/51] make PrecompileController public --- core/vm/evm.go | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 00ff2729491a..335c0726a821 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -96,8 +96,8 @@ type EVM struct { TxContext // StateDB gives access to the underlying state StateDB StateDB - // precompileController finds and runs precompiled contracts - precompileController PrecompileController + // PrecompileController finds and runs precompiled contracts + PrecompileController PrecompileController // Depth is the current call stack depth int @@ -140,7 +140,7 @@ func NewEVMWithPrecompiles( chainConfig *params.ChainConfig, config Config, precompileController PrecompileController, ) *EVM { evm := NewEVM(blockCtx, txCtx, statedb, chainConfig, config) - evm.precompileController = precompileController + evm.PrecompileController = precompileController return evm } @@ -181,7 +181,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - p, isPrecompile := evm.precompileController.Exists(addr) + p, isPrecompile := evm.PrecompileController.Exists(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -218,7 +218,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.precompileController.Run(p, input, caller.Address(), value, gas, false) + ret, gas, err = evm.PrecompileController.Run(p, input, caller.Address(), value, gas, false) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -280,8 +280,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompileController.Exists(addr); isPrecompile { - ret, gas, err = evm.precompileController.Run(p, input, caller.Address(), value, gas, true) + if p, isPrecompile := evm.PrecompileController.Exists(addr); isPrecompile { + ret, gas, err = evm.PrecompileController.Run(p, input, caller.Address(), value, gas, true) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -321,9 +321,9 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.precompileController.Exists(addr); isPrecompile { + if p, isPrecompile := evm.PrecompileController.Exists(addr); isPrecompile { parent := caller.(*Contract) - ret, gas, err = evm.precompileController.Run(p, input, parent.CallerAddress, parent.value, gas, false) + ret, gas, err = evm.PrecompileController.Run(p, input, parent.CallerAddress, parent.value, gas, false) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -371,8 +371,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if p, isPrecompile := evm.precompileController.Exists(addr); isPrecompile { - ret, gas, err = evm.precompileController.Run(p, input, caller.Address(), new(big.Int), gas, true) + if p, isPrecompile := evm.PrecompileController.Exists(addr); isPrecompile { + ret, gas, err = evm.PrecompileController.Run(p, input, caller.Address(), new(big.Int), gas, true) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' From cdf3a3943650f380c14b946f34f73b816205f2ae Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 25 Jan 2023 14:17:25 -0500 Subject: [PATCH 25/51] ctx setter --- core/vm/evm.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/vm/evm.go b/core/vm/evm.go index 335c0726a821..0b580e47bced 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -17,6 +17,7 @@ package vm import ( + "context" "math/big" "sync/atomic" "time" @@ -43,6 +44,9 @@ type ( // `PrecompileController` allows the EVM to execute a precompiled contract. type PrecompileController interface { + // `SetEphemeralContext` sets the precompile's native environment context. + SetEphemeralContext(ctx context.Context) + // `Exists` returns if a precompiled contract was found at `addr`. Exists(addr common.Address) (p PrecompiledContract, found bool) From dc459cd07e42694777173e1433d78af816ee620f Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 25 Jan 2023 14:28:01 -0500 Subject: [PATCH 26/51] add statedb in contract.Run --- core/vm/contracts.go | 46 ++++++++++++++++++++++---------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index d1fadab1b3cc..6c4e91f02dc1 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -37,8 +37,8 @@ import ( // requires a deterministic gas count based on the input size of the Run method of the // contract. type PrecompiledContract interface { - RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use - Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) // Run runs the precompiled contract + RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use + Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) // Run runs the precompiled contract } // PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum @@ -148,7 +148,7 @@ func (c *ecrecover) RequiredGas(input []byte) uint64 { return params.EcrecoverGas } -func (c *ecrecover) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *ecrecover) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { const ecRecoverInputLength = 128 input = common.RightPadBytes(input, ecRecoverInputLength) @@ -189,7 +189,7 @@ type sha256hash struct{} func (c *sha256hash) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.Sha256PerWordGas + params.Sha256BaseGas } -func (c *sha256hash) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *sha256hash) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { h := sha256.Sum256(input) return h[:], nil } @@ -204,7 +204,7 @@ type ripemd160hash struct{} func (c *ripemd160hash) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.Ripemd160PerWordGas + params.Ripemd160BaseGas } -func (c *ripemd160hash) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *ripemd160hash) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { ripemd := ripemd160.New() ripemd.Write(input) return common.LeftPadBytes(ripemd.Sum(nil), 32), nil @@ -220,7 +220,7 @@ type dataCopy struct{} func (c *dataCopy) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.IdentityPerWordGas + params.IdentityBaseGas } -func (c *dataCopy) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *dataCopy) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return input, nil } @@ -347,7 +347,7 @@ func (c *bigModExp) RequiredGas(input []byte) uint64 { return gas.Uint64() } -func (c *bigModExp) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bigModExp) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { var ( baseLen = new(big.Int).SetBytes(getData(input, 0, 32)).Uint64() expLen = new(big.Int).SetBytes(getData(input, 32, 32)).Uint64() @@ -420,7 +420,7 @@ func (c *bn256AddIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256AddGasIstanbul } -func (c *bn256AddIstanbul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256AddIstanbul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Add(input) } @@ -433,7 +433,7 @@ func (c *bn256AddByzantium) RequiredGas(input []byte) uint64 { return params.Bn256AddGasByzantium } -func (c *bn256AddByzantium) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256AddByzantium) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Add(input) } @@ -458,7 +458,7 @@ func (c *bn256ScalarMulIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasIstanbul } -func (c *bn256ScalarMulIstanbul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256ScalarMulIstanbul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256ScalarMul(input) } @@ -471,7 +471,7 @@ func (c *bn256ScalarMulByzantium) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasByzantium } -func (c *bn256ScalarMulByzantium) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256ScalarMulByzantium) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256ScalarMul(input) } @@ -526,7 +526,7 @@ func (c *bn256PairingIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasIstanbul + uint64(len(input)/192)*params.Bn256PairingPerPointGasIstanbul } -func (c *bn256PairingIstanbul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256PairingIstanbul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Pairing(input) } @@ -539,7 +539,7 @@ func (c *bn256PairingByzantium) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasByzantium + uint64(len(input)/192)*params.Bn256PairingPerPointGasByzantium } -func (c *bn256PairingByzantium) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256PairingByzantium) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Pairing(input) } @@ -565,7 +565,7 @@ var ( errBlake2FInvalidFinalFlag = errors.New("invalid final flag") ) -func (c *blake2F) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *blake2F) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Make sure the input is valid (correct length and final flag) if len(input) != blake2FInputLength { return nil, errBlake2FInvalidInputLength @@ -619,7 +619,7 @@ func (c *bls12381G1Add) RequiredGas(input []byte) uint64 { return params.Bls12381G1AddGas } -func (c *bls12381G1Add) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G1Add) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1Add precompile. // > G1 addition call expects `256` bytes as an input that is interpreted as byte concatenation of two G1 points (`128` bytes each). // > Output is an encoding of addition operation result - single G1 point (`128` bytes). @@ -657,7 +657,7 @@ func (c *bls12381G1Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G1MulGas } -func (c *bls12381G1Mul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G1Mul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1Mul precompile. // > G1 multiplication call expects `160` bytes as an input that is interpreted as byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiplication operation result - single G1 point (`128` bytes). @@ -707,7 +707,7 @@ func (c *bls12381G1MultiExp) RequiredGas(input []byte) uint64 { return (uint64(k) * params.Bls12381G1MulGas * discount) / 1000 } -func (c *bls12381G1MultiExp) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G1MultiExp) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1MultiExp precompile. // G1 multiplication call expects `160*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes). // Output is an encoding of multiexponentiation operation result - single G1 point (`128` bytes). @@ -750,7 +750,7 @@ func (c *bls12381G2Add) RequiredGas(input []byte) uint64 { return params.Bls12381G2AddGas } -func (c *bls12381G2Add) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G2Add) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2Add precompile. // > G2 addition call expects `512` bytes as an input that is interpreted as byte concatenation of two G2 points (`256` bytes each). // > Output is an encoding of addition operation result - single G2 point (`256` bytes). @@ -788,7 +788,7 @@ func (c *bls12381G2Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G2MulGas } -func (c *bls12381G2Mul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G2Mul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2MUL precompile logic. // > G2 multiplication call expects `288` bytes as an input that is interpreted as byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiplication operation result - single G2 point (`256` bytes). @@ -838,7 +838,7 @@ func (c *bls12381G2MultiExp) RequiredGas(input []byte) uint64 { return (uint64(k) * params.Bls12381G2MulGas * discount) / 1000 } -func (c *bls12381G2MultiExp) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G2MultiExp) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2MultiExp precompile logic // > G2 multiplication call expects `288*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiexponentiation operation result - single G2 point (`256` bytes). @@ -881,7 +881,7 @@ func (c *bls12381Pairing) RequiredGas(input []byte) uint64 { return params.Bls12381PairingBaseGas + uint64(len(input)/384)*params.Bls12381PairingPerPairGas } -func (c *bls12381Pairing) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381Pairing) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Pairing precompile logic. // > Pairing call expects `384*k` bytes as an inputs that is interpreted as byte concatenation of `k` slices. Each slice has the following structure: // > - `128` bytes of G1 point encoding @@ -960,7 +960,7 @@ func (c *bls12381MapG1) RequiredGas(input []byte) uint64 { return params.Bls12381MapG1Gas } -func (c *bls12381MapG1) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381MapG1) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Map_To_G1 precompile. // > Field-to-curve call expects `64` bytes an an input that is interpreted as a an element of the base field. // > Output of this call is `128` bytes and is G1 point following respective encoding rules. @@ -995,7 +995,7 @@ func (c *bls12381MapG2) RequiredGas(input []byte) uint64 { return params.Bls12381MapG2Gas } -func (c *bls12381MapG2) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381MapG2) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Map_FP2_TO_G2 precompile logic. // > Field-to-curve call expects `128` bytes an an input that is interpreted as a an element of the quadratic extension field. // > Output of this call is `256` bytes and is G2 point following respective encoding rules. From 60266f5b05ef2f102eca8b9f9c23cc44d5003268 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 25 Jan 2023 15:05:38 -0500 Subject: [PATCH 27/51] use Prepare on controller --- core/vm/evm.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 0b580e47bced..e8814e2ed261 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -44,8 +44,8 @@ type ( // `PrecompileController` allows the EVM to execute a precompiled contract. type PrecompileController interface { - // `SetEphemeralContext` sets the precompile's native environment context. - SetEphemeralContext(ctx context.Context) + // `Prepare` sets the precompile's native environment context and stateDB. + Prepare(ctx context.Context, statedb StateDB) // `Exists` returns if a precompiled contract was found at `addr`. Exists(addr common.Address) (p PrecompiledContract, found bool) From 952aea289a629d57c3d4985135d7da3dbe64d788 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 25 Jan 2023 17:07:28 -0500 Subject: [PATCH 28/51] prepare for state transition --- core/vm/evm.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index e8814e2ed261..7ac8351b6705 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -17,7 +17,6 @@ package vm import ( - "context" "math/big" "sync/atomic" "time" @@ -44,8 +43,9 @@ type ( // `PrecompileController` allows the EVM to execute a precompiled contract. type PrecompileController interface { - // `Prepare` sets the precompile's native environment context and stateDB. - Prepare(ctx context.Context, statedb StateDB) + // `PrepareForStateTransition` holds the precompile native statedb + // before beginning a state transition. + PrepareForStateTransition(statedb StateDB) error // `Exists` returns if a precompiled contract was found at `addr`. Exists(addr common.Address) (p PrecompiledContract, found bool) From ca260e974759bb8d6a618f45d79bedd48b00d959 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Thu, 2 Feb 2023 11:08:39 -0500 Subject: [PATCH 29/51] contract has registry key --- core/vm/contracts.go | 85 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 6c4e91f02dc1..5420d261df38 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -37,6 +37,7 @@ import ( // requires a deterministic gas count based on the input size of the Run method of the // contract. type PrecompiledContract interface { + RegistryKey() common.Address RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) // Run runs the precompiled contract } @@ -144,6 +145,10 @@ func ActivePrecompiles(rules params.Rules) []common.Address { // ECRECOVER implemented as a native contract. type ecrecover struct{} +func (c *ecrecover) RegistryKey() common.Address { + return common.BytesToAddress([]byte{1}) +} + func (c *ecrecover) RequiredGas(input []byte) uint64 { return params.EcrecoverGas } @@ -182,6 +187,10 @@ func (c *ecrecover) Run(ctx context.Context, statedb StateDB, input []byte, call // SHA256 implemented as a native contract. type sha256hash struct{} +func (c *sha256hash) RegistryKey() common.Address { + return common.BytesToAddress([]byte{2}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. // // This method does not require any overflow checking as the input size gas costs @@ -197,6 +206,10 @@ func (c *sha256hash) Run(ctx context.Context, statedb StateDB, input []byte, cal // RIPEMD160 implemented as a native contract. type ripemd160hash struct{} +func (c *ripemd160hash) RegistryKey() common.Address { + return common.BytesToAddress([]byte{3}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. // // This method does not require any overflow checking as the input size gas costs @@ -213,6 +226,10 @@ func (c *ripemd160hash) Run(ctx context.Context, statedb StateDB, input []byte, // data copy implemented as a native contract. type dataCopy struct{} +func (c *dataCopy) RegistryKey() common.Address { + return common.BytesToAddress([]byte{4}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. // // This method does not require any overflow checking as the input size gas costs @@ -229,6 +246,10 @@ type bigModExp struct { eip2565 bool } +func (c *bigModExp) RegistryKey() common.Address { + return common.BytesToAddress([]byte{5}) +} + var ( big0 = big.NewInt(0) big1 = big.NewInt(1) @@ -415,6 +436,10 @@ func runBn256Add(input []byte) ([]byte, error) { // Istanbul consensus rules. type bn256AddIstanbul struct{} +func (c *bn256AddIstanbul) RegistryKey() common.Address { + return common.BytesToAddress([]byte{6}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bn256AddIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256AddGasIstanbul @@ -428,6 +453,10 @@ func (c *bn256AddIstanbul) Run(ctx context.Context, statedb StateDB, input []byt // conforming to Byzantium consensus rules. type bn256AddByzantium struct{} +func (c *bn256AddByzantium) RegistryKey() common.Address { + return common.BytesToAddress([]byte{6}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bn256AddByzantium) RequiredGas(input []byte) uint64 { return params.Bn256AddGasByzantium @@ -453,6 +482,10 @@ func runBn256ScalarMul(input []byte) ([]byte, error) { // multiplication conforming to Istanbul consensus rules. type bn256ScalarMulIstanbul struct{} +func (c *bn256ScalarMulIstanbul) RegistryKey() common.Address { + return common.BytesToAddress([]byte{7}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bn256ScalarMulIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasIstanbul @@ -466,6 +499,10 @@ func (c *bn256ScalarMulIstanbul) Run(ctx context.Context, statedb StateDB, input // multiplication conforming to Byzantium consensus rules. type bn256ScalarMulByzantium struct{} +func (c *bn256ScalarMulByzantium) RegistryKey() common.Address { + return common.BytesToAddress([]byte{7}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bn256ScalarMulByzantium) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasByzantium @@ -521,6 +558,10 @@ func runBn256Pairing(input []byte) ([]byte, error) { // conforming to Istanbul consensus rules. type bn256PairingIstanbul struct{} +func (c *bn256PairingIstanbul) RegistryKey() common.Address { + return common.BytesToAddress([]byte{8}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bn256PairingIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasIstanbul + uint64(len(input)/192)*params.Bn256PairingPerPointGasIstanbul @@ -534,6 +575,10 @@ func (c *bn256PairingIstanbul) Run(ctx context.Context, statedb StateDB, input [ // conforming to Byzantium consensus rules. type bn256PairingByzantium struct{} +func (c *bn256PairingByzantium) RegistryKey() common.Address { + return common.BytesToAddress([]byte{8}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bn256PairingByzantium) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasByzantium + uint64(len(input)/192)*params.Bn256PairingPerPointGasByzantium @@ -545,6 +590,10 @@ func (c *bn256PairingByzantium) Run(ctx context.Context, statedb StateDB, input type blake2F struct{} +func (c *blake2F) RegistryKey() common.Address { + return common.BytesToAddress([]byte{9}) +} + func (c *blake2F) RequiredGas(input []byte) uint64 { // If the input is malformed, we can't calculate the gas, return 0 and let the // actual call choke and fault. @@ -614,6 +663,10 @@ var ( // bls12381G1Add implements EIP-2537 G1Add precompile. type bls12381G1Add struct{} +func (c *bls12381G1Add) RegistryKey() common.Address { + return common.BytesToAddress([]byte{10}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bls12381G1Add) RequiredGas(input []byte) uint64 { return params.Bls12381G1AddGas @@ -652,6 +705,10 @@ func (c *bls12381G1Add) Run(ctx context.Context, statedb StateDB, input []byte, // bls12381G1Mul implements EIP-2537 G1Mul precompile. type bls12381G1Mul struct{} +func (c *bls12381G1Mul) RegistryKey() common.Address { + return common.BytesToAddress([]byte{11}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bls12381G1Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G1MulGas @@ -688,6 +745,10 @@ func (c *bls12381G1Mul) Run(ctx context.Context, statedb StateDB, input []byte, // bls12381G1MultiExp implements EIP-2537 G1MultiExp precompile. type bls12381G1MultiExp struct{} +func (c *bls12381G1MultiExp) RegistryKey() common.Address { + return common.BytesToAddress([]byte{12}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bls12381G1MultiExp) RequiredGas(input []byte) uint64 { // Calculate G1 point, scalar value pair length @@ -745,6 +806,10 @@ func (c *bls12381G1MultiExp) Run(ctx context.Context, statedb StateDB, input []b // bls12381G2Add implements EIP-2537 G2Add precompile. type bls12381G2Add struct{} +func (c *bls12381G2Add) RegistryKey() common.Address { + return common.BytesToAddress([]byte{13}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bls12381G2Add) RequiredGas(input []byte) uint64 { return params.Bls12381G2AddGas @@ -783,6 +848,10 @@ func (c *bls12381G2Add) Run(ctx context.Context, statedb StateDB, input []byte, // bls12381G2Mul implements EIP-2537 G2Mul precompile. type bls12381G2Mul struct{} +func (c *bls12381G2Mul) RegistryKey() common.Address { + return common.BytesToAddress([]byte{14}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bls12381G2Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G2MulGas @@ -819,6 +888,10 @@ func (c *bls12381G2Mul) Run(ctx context.Context, statedb StateDB, input []byte, // bls12381G2MultiExp implements EIP-2537 G2MultiExp precompile. type bls12381G2MultiExp struct{} +func (c *bls12381G2MultiExp) RegistryKey() common.Address { + return common.BytesToAddress([]byte{15}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bls12381G2MultiExp) RequiredGas(input []byte) uint64 { // Calculate G2 point, scalar value pair length @@ -876,6 +949,10 @@ func (c *bls12381G2MultiExp) Run(ctx context.Context, statedb StateDB, input []b // bls12381Pairing implements EIP-2537 Pairing precompile. type bls12381Pairing struct{} +func (c *bls12381Pairing) RegistryKey() common.Address { + return common.BytesToAddress([]byte{16}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bls12381Pairing) RequiredGas(input []byte) uint64 { return params.Bls12381PairingBaseGas + uint64(len(input)/384)*params.Bls12381PairingPerPairGas @@ -955,6 +1032,10 @@ func decodeBLS12381FieldElement(in []byte) ([]byte, error) { // bls12381MapG1 implements EIP-2537 MapG1 precompile. type bls12381MapG1 struct{} +func (c *bls12381MapG1) RegistryKey() common.Address { + return common.BytesToAddress([]byte{17}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bls12381MapG1) RequiredGas(input []byte) uint64 { return params.Bls12381MapG1Gas @@ -990,6 +1071,10 @@ func (c *bls12381MapG1) Run(ctx context.Context, statedb StateDB, input []byte, // bls12381MapG2 implements EIP-2537 MapG2 precompile. type bls12381MapG2 struct{} +func (c *bls12381MapG2) RegistryKey() common.Address { + return common.BytesToAddress([]byte{18}) +} + // RequiredGas returns the gas required to execute the pre-compiled contract. func (c *bls12381MapG2) RequiredGas(input []byte) uint64 { return params.Bls12381MapG2Gas From 2ad2464693dd71f004dd567444e0c67279af3d99 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Thu, 2 Feb 2023 12:39:39 -0500 Subject: [PATCH 30/51] has and get --- core/vm/evm.go | 32 ++++++++++++++++++++++---------- 1 file changed, 22 insertions(+), 10 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 7ac8351b6705..fcef413cb72c 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -47,8 +47,12 @@ type PrecompileController interface { // before beginning a state transition. PrepareForStateTransition(statedb StateDB) error - // `Exists` returns if a precompiled contract was found at `addr`. - Exists(addr common.Address) (p PrecompiledContract, found bool) + // `Has` returns if a precompiled contract was found at `addr`. + Has(addr common.Address) bool + + // `Get` returns the precompiled contract at `addr`. Returns nil if no + // contract is found at `addr`. + Get(addr common.Address) PrecompiledContract // `Run` runs a precompiled contract and returns the remaining gas. Run(p PrecompiledContract, input []byte, caller common.Address, @@ -185,7 +189,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - p, isPrecompile := evm.PrecompileController.Exists(addr) + isPrecompile := evm.PrecompileController.Has(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -222,7 +226,9 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.PrecompileController.Run(p, input, caller.Address(), value, gas, false) + ret, gas, err = evm.PrecompileController.Run( + evm.PrecompileController.Get(addr), input, caller.Address(), value, gas, false, + ) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -284,8 +290,10 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.PrecompileController.Exists(addr); isPrecompile { - ret, gas, err = evm.PrecompileController.Run(p, input, caller.Address(), value, gas, true) + if isPrecompile := evm.PrecompileController.Has(addr); isPrecompile { + ret, gas, err = evm.PrecompileController.Run( + evm.PrecompileController.Get(addr), input, caller.Address(), value, gas, true, + ) } else { addrCopy := addr // Initialise a new contract and set the code that is to be used by the EVM. @@ -325,9 +333,11 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if p, isPrecompile := evm.PrecompileController.Exists(addr); isPrecompile { + if isPrecompile := evm.PrecompileController.Has(addr); isPrecompile { parent := caller.(*Contract) - ret, gas, err = evm.PrecompileController.Run(p, input, parent.CallerAddress, parent.value, gas, false) + ret, gas, err = evm.PrecompileController.Run( + evm.PrecompileController.Get(addr), input, parent.CallerAddress, parent.value, gas, false, + ) } else { addrCopy := addr // Initialise a new contract and make initialise the delegate values @@ -375,8 +385,10 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if p, isPrecompile := evm.PrecompileController.Exists(addr); isPrecompile { - ret, gas, err = evm.PrecompileController.Run(p, input, caller.Address(), new(big.Int), gas, true) + if isPrecompile := evm.PrecompileController.Has(addr); isPrecompile { + ret, gas, err = evm.PrecompileController.Run( + evm.PrecompileController.Get(addr), input, caller.Address(), new(big.Int), gas, true, + ) } else { // At this point, we use a copy of address. If we don't, the go compiler will // leak the 'contract' to the outer scope, and make allocation for 'contract' From d6fbbb73a2d90e041f3ec37b27f18fb247a58873 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Thu, 2 Feb 2023 12:47:36 -0500 Subject: [PATCH 31/51] controller > manager --- core/vm/evm.go | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index fcef413cb72c..f2219d3db018 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -41,8 +41,8 @@ type ( GetHashFunc func(uint64) common.Hash ) -// `PrecompileController` allows the EVM to execute a precompiled contract. -type PrecompileController interface { +// `PrecompileManager` allows the EVM to execute a precompiled contract. +type PrecompileManager interface { // `PrepareForStateTransition` holds the precompile native statedb // before beginning a state transition. PrepareForStateTransition(statedb StateDB) error @@ -104,8 +104,8 @@ type EVM struct { TxContext // StateDB gives access to the underlying state StateDB StateDB - // PrecompileController finds and runs precompiled contracts - PrecompileController PrecompileController + // PrecompileManager finds and runs precompiled contracts + PrecompileManager PrecompileManager // Depth is the current call stack depth int @@ -145,10 +145,10 @@ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig func NewEVMWithPrecompiles( blockCtx BlockContext, txCtx TxContext, statedb StateDB, - chainConfig *params.ChainConfig, config Config, precompileController PrecompileController, + chainConfig *params.ChainConfig, config Config, precompileController PrecompileManager, ) *EVM { evm := NewEVM(blockCtx, txCtx, statedb, chainConfig, config) - evm.PrecompileController = precompileController + evm.PrecompileManager = precompileController return evm } @@ -189,7 +189,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() - isPrecompile := evm.PrecompileController.Has(addr) + isPrecompile := evm.PrecompileManager.Has(addr) if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 { @@ -226,8 +226,8 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.PrecompileController.Run( - evm.PrecompileController.Get(addr), input, caller.Address(), value, gas, false, + ret, gas, err = evm.PrecompileManager.Run( + evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, false, ) } else { // Initialise a new contract and set the code that is to be used by the EVM. @@ -290,9 +290,9 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, } // It is allowed to call precompiles, even via delegatecall - if isPrecompile := evm.PrecompileController.Has(addr); isPrecompile { - ret, gas, err = evm.PrecompileController.Run( - evm.PrecompileController.Get(addr), input, caller.Address(), value, gas, true, + if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { + ret, gas, err = evm.PrecompileManager.Run( + evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, true, ) } else { addrCopy := addr @@ -333,10 +333,10 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by } // It is allowed to call precompiles, even via delegatecall - if isPrecompile := evm.PrecompileController.Has(addr); isPrecompile { + if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { parent := caller.(*Contract) - ret, gas, err = evm.PrecompileController.Run( - evm.PrecompileController.Get(addr), input, parent.CallerAddress, parent.value, gas, false, + ret, gas, err = evm.PrecompileManager.Run( + evm.PrecompileManager.Get(addr), input, parent.CallerAddress, parent.value, gas, false, ) } else { addrCopy := addr @@ -385,9 +385,9 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte }(gas) } - if isPrecompile := evm.PrecompileController.Has(addr); isPrecompile { - ret, gas, err = evm.PrecompileController.Run( - evm.PrecompileController.Get(addr), input, caller.Address(), new(big.Int), gas, true, + if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { + ret, gas, err = evm.PrecompileManager.Run( + evm.PrecompileManager.Get(addr), input, caller.Address(), new(big.Int), gas, true, ) } else { // At this point, we use a copy of address. If we don't, the go compiler will From e4d555f4ce0cb9cc77034478f7940c61d86e4b39 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Thu, 2 Feb 2023 20:21:37 -0500 Subject: [PATCH 32/51] with statedb --- core/vm/contracts.go | 93 +++++++++++++++++++++++++++++++++----------- core/vm/evm.go | 8 ++-- 2 files changed, 74 insertions(+), 27 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 5420d261df38..bd27b6308a9f 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -37,9 +37,14 @@ import ( // requires a deterministic gas count based on the input size of the Run method of the // contract. type PrecompiledContract interface { + // RegistryKey returns the address at which the contract will be registered. RegistryKey() common.Address - RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use - Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) // Run runs the precompiled contract + // RequiredGas calculates the contract static gas use. + RequiredGas(input []byte) uint64 + // Run runs the precompiled contract with the given context. + Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) + // WithStateDB sets the statedb for the contract to use. + WithStateDB(sdb StateDB) PrecompiledContract } // PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum @@ -153,7 +158,7 @@ func (c *ecrecover) RequiredGas(input []byte) uint64 { return params.EcrecoverGas } -func (c *ecrecover) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *ecrecover) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { const ecRecoverInputLength = 128 input = common.RightPadBytes(input, ecRecoverInputLength) @@ -184,6 +189,8 @@ func (c *ecrecover) Run(ctx context.Context, statedb StateDB, input []byte, call return common.LeftPadBytes(crypto.Keccak256(pubKey[1:])[12:], 32), nil } +func (c *ecrecover) WithStateDB(StateDB) PrecompiledContract { return c } + // SHA256 implemented as a native contract. type sha256hash struct{} @@ -198,11 +205,13 @@ func (c *sha256hash) RegistryKey() common.Address { func (c *sha256hash) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.Sha256PerWordGas + params.Sha256BaseGas } -func (c *sha256hash) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *sha256hash) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { h := sha256.Sum256(input) return h[:], nil } +func (c *sha256hash) WithStateDB(StateDB) PrecompiledContract { return c } + // RIPEMD160 implemented as a native contract. type ripemd160hash struct{} @@ -217,12 +226,14 @@ func (c *ripemd160hash) RegistryKey() common.Address { func (c *ripemd160hash) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.Ripemd160PerWordGas + params.Ripemd160BaseGas } -func (c *ripemd160hash) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *ripemd160hash) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { ripemd := ripemd160.New() ripemd.Write(input) return common.LeftPadBytes(ripemd.Sum(nil), 32), nil } +func (c *ripemd160hash) WithStateDB(StateDB) PrecompiledContract { return c } + // data copy implemented as a native contract. type dataCopy struct{} @@ -237,10 +248,12 @@ func (c *dataCopy) RegistryKey() common.Address { func (c *dataCopy) RequiredGas(input []byte) uint64 { return uint64(len(input)+31)/32*params.IdentityPerWordGas + params.IdentityBaseGas } -func (c *dataCopy) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *dataCopy) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return input, nil } +func (c *dataCopy) WithStateDB(StateDB) PrecompiledContract { return c } + // bigModExp implements a native big integer exponential modular operation. type bigModExp struct { eip2565 bool @@ -368,7 +381,7 @@ func (c *bigModExp) RequiredGas(input []byte) uint64 { return gas.Uint64() } -func (c *bigModExp) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bigModExp) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { var ( baseLen = new(big.Int).SetBytes(getData(input, 0, 32)).Uint64() expLen = new(big.Int).SetBytes(getData(input, 32, 32)).Uint64() @@ -396,6 +409,8 @@ func (c *bigModExp) Run(ctx context.Context, statedb StateDB, input []byte, call return common.LeftPadBytes(base.Exp(base, exp, mod).Bytes(), int(modLen)), nil } +func (c *bigModExp) WithStateDB(StateDB) PrecompiledContract { return c } + // newCurvePoint unmarshals a binary blob into a bn256 elliptic curve point, // returning it, or an error if the point is invalid. func newCurvePoint(blob []byte) (*bn256.G1, error) { @@ -445,10 +460,12 @@ func (c *bn256AddIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256AddGasIstanbul } -func (c *bn256AddIstanbul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256AddIstanbul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Add(input) } +func (c *bn256AddIstanbul) WithStateDB(StateDB) PrecompiledContract { return c } + // bn256AddByzantium implements a native elliptic curve point addition // conforming to Byzantium consensus rules. type bn256AddByzantium struct{} @@ -462,10 +479,12 @@ func (c *bn256AddByzantium) RequiredGas(input []byte) uint64 { return params.Bn256AddGasByzantium } -func (c *bn256AddByzantium) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256AddByzantium) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Add(input) } +func (c *bn256AddByzantium) WithStateDB(StateDB) PrecompiledContract { return c } + // runBn256ScalarMul implements the Bn256ScalarMul precompile, referenced by // both Byzantium and Istanbul operations. func runBn256ScalarMul(input []byte) ([]byte, error) { @@ -491,10 +510,12 @@ func (c *bn256ScalarMulIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasIstanbul } -func (c *bn256ScalarMulIstanbul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256ScalarMulIstanbul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256ScalarMul(input) } +func (c *bn256ScalarMulIstanbul) WithStateDB(StateDB) PrecompiledContract { return c } + // bn256ScalarMulByzantium implements a native elliptic curve scalar // multiplication conforming to Byzantium consensus rules. type bn256ScalarMulByzantium struct{} @@ -508,10 +529,12 @@ func (c *bn256ScalarMulByzantium) RequiredGas(input []byte) uint64 { return params.Bn256ScalarMulGasByzantium } -func (c *bn256ScalarMulByzantium) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256ScalarMulByzantium) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256ScalarMul(input) } +func (c *bn256ScalarMulByzantium) WithStateDB(StateDB) PrecompiledContract { return c } + var ( // true32Byte is returned if the bn256 pairing check succeeds. true32Byte = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1} @@ -567,10 +590,12 @@ func (c *bn256PairingIstanbul) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasIstanbul + uint64(len(input)/192)*params.Bn256PairingPerPointGasIstanbul } -func (c *bn256PairingIstanbul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256PairingIstanbul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Pairing(input) } +func (c *bn256PairingIstanbul) WithStateDB(StateDB) PrecompiledContract { return c } + // bn256PairingByzantium implements a pairing pre-compile for the bn256 curve // conforming to Byzantium consensus rules. type bn256PairingByzantium struct{} @@ -584,10 +609,12 @@ func (c *bn256PairingByzantium) RequiredGas(input []byte) uint64 { return params.Bn256PairingBaseGasByzantium + uint64(len(input)/192)*params.Bn256PairingPerPointGasByzantium } -func (c *bn256PairingByzantium) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bn256PairingByzantium) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { return runBn256Pairing(input) } +func (c *bn256PairingByzantium) WithStateDB(StateDB) PrecompiledContract { return c } + type blake2F struct{} func (c *blake2F) RegistryKey() common.Address { @@ -614,7 +641,7 @@ var ( errBlake2FInvalidFinalFlag = errors.New("invalid final flag") ) -func (c *blake2F) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *blake2F) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Make sure the input is valid (correct length and final flag) if len(input) != blake2FInputLength { return nil, errBlake2FInvalidInputLength @@ -653,6 +680,8 @@ func (c *blake2F) Run(ctx context.Context, statedb StateDB, input []byte, caller return output, nil } +func (c *blake2F) WithStateDB(StateDB) PrecompiledContract { return c } + var ( errBLS12381InvalidInputLength = errors.New("invalid input length") errBLS12381InvalidFieldElementTopBytes = errors.New("invalid field element top bytes") @@ -672,7 +701,7 @@ func (c *bls12381G1Add) RequiredGas(input []byte) uint64 { return params.Bls12381G1AddGas } -func (c *bls12381G1Add) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G1Add) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1Add precompile. // > G1 addition call expects `256` bytes as an input that is interpreted as byte concatenation of two G1 points (`128` bytes each). // > Output is an encoding of addition operation result - single G1 point (`128` bytes). @@ -702,6 +731,8 @@ func (c *bls12381G1Add) Run(ctx context.Context, statedb StateDB, input []byte, return g.EncodePoint(r), nil } +func (c *bls12381G1Add) WithStateDB(StateDB) PrecompiledContract { return c } + // bls12381G1Mul implements EIP-2537 G1Mul precompile. type bls12381G1Mul struct{} @@ -714,7 +745,7 @@ func (c *bls12381G1Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G1MulGas } -func (c *bls12381G1Mul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G1Mul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1Mul precompile. // > G1 multiplication call expects `160` bytes as an input that is interpreted as byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiplication operation result - single G1 point (`128` bytes). @@ -742,6 +773,8 @@ func (c *bls12381G1Mul) Run(ctx context.Context, statedb StateDB, input []byte, return g.EncodePoint(r), nil } +func (c *bls12381G1Mul) WithStateDB(StateDB) PrecompiledContract { return c } + // bls12381G1MultiExp implements EIP-2537 G1MultiExp precompile. type bls12381G1MultiExp struct{} @@ -768,7 +801,7 @@ func (c *bls12381G1MultiExp) RequiredGas(input []byte) uint64 { return (uint64(k) * params.Bls12381G1MulGas * discount) / 1000 } -func (c *bls12381G1MultiExp) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G1MultiExp) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G1MultiExp precompile. // G1 multiplication call expects `160*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes). // Output is an encoding of multiexponentiation operation result - single G1 point (`128` bytes). @@ -803,6 +836,8 @@ func (c *bls12381G1MultiExp) Run(ctx context.Context, statedb StateDB, input []b return g.EncodePoint(r), nil } +func (c *bls12381G1MultiExp) WithStateDB(StateDB) PrecompiledContract { return c } + // bls12381G2Add implements EIP-2537 G2Add precompile. type bls12381G2Add struct{} @@ -815,7 +850,7 @@ func (c *bls12381G2Add) RequiredGas(input []byte) uint64 { return params.Bls12381G2AddGas } -func (c *bls12381G2Add) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G2Add) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2Add precompile. // > G2 addition call expects `512` bytes as an input that is interpreted as byte concatenation of two G2 points (`256` bytes each). // > Output is an encoding of addition operation result - single G2 point (`256` bytes). @@ -845,6 +880,8 @@ func (c *bls12381G2Add) Run(ctx context.Context, statedb StateDB, input []byte, return g.EncodePoint(r), nil } +func (c *bls12381G2Add) WithStateDB(StateDB) PrecompiledContract { return c } + // bls12381G2Mul implements EIP-2537 G2Mul precompile. type bls12381G2Mul struct{} @@ -857,7 +894,7 @@ func (c *bls12381G2Mul) RequiredGas(input []byte) uint64 { return params.Bls12381G2MulGas } -func (c *bls12381G2Mul) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G2Mul) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2MUL precompile logic. // > G2 multiplication call expects `288` bytes as an input that is interpreted as byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiplication operation result - single G2 point (`256` bytes). @@ -885,6 +922,8 @@ func (c *bls12381G2Mul) Run(ctx context.Context, statedb StateDB, input []byte, return g.EncodePoint(r), nil } +func (c *bls12381G2Mul) WithStateDB(StateDB) PrecompiledContract { return c } + // bls12381G2MultiExp implements EIP-2537 G2MultiExp precompile. type bls12381G2MultiExp struct{} @@ -911,7 +950,7 @@ func (c *bls12381G2MultiExp) RequiredGas(input []byte) uint64 { return (uint64(k) * params.Bls12381G2MulGas * discount) / 1000 } -func (c *bls12381G2MultiExp) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381G2MultiExp) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 G2MultiExp precompile logic // > G2 multiplication call expects `288*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes). // > Output is an encoding of multiexponentiation operation result - single G2 point (`256` bytes). @@ -946,6 +985,8 @@ func (c *bls12381G2MultiExp) Run(ctx context.Context, statedb StateDB, input []b return g.EncodePoint(r), nil } +func (c *bls12381G2MultiExp) WithStateDB(StateDB) PrecompiledContract { return c } + // bls12381Pairing implements EIP-2537 Pairing precompile. type bls12381Pairing struct{} @@ -958,7 +999,7 @@ func (c *bls12381Pairing) RequiredGas(input []byte) uint64 { return params.Bls12381PairingBaseGas + uint64(len(input)/384)*params.Bls12381PairingPerPairGas } -func (c *bls12381Pairing) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381Pairing) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Pairing precompile logic. // > Pairing call expects `384*k` bytes as an inputs that is interpreted as byte concatenation of `k` slices. Each slice has the following structure: // > - `128` bytes of G1 point encoding @@ -1012,6 +1053,8 @@ func (c *bls12381Pairing) Run(ctx context.Context, statedb StateDB, input []byte return out, nil } +func (c *bls12381Pairing) WithStateDB(StateDB) PrecompiledContract { return c } + // decodeBLS12381FieldElement decodes BLS12-381 elliptic curve field element. // Removes top 16 bytes of 64 byte input. func decodeBLS12381FieldElement(in []byte) ([]byte, error) { @@ -1041,7 +1084,7 @@ func (c *bls12381MapG1) RequiredGas(input []byte) uint64 { return params.Bls12381MapG1Gas } -func (c *bls12381MapG1) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381MapG1) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Map_To_G1 precompile. // > Field-to-curve call expects `64` bytes an an input that is interpreted as a an element of the base field. // > Output of this call is `128` bytes and is G1 point following respective encoding rules. @@ -1068,6 +1111,8 @@ func (c *bls12381MapG1) Run(ctx context.Context, statedb StateDB, input []byte, return g.EncodePoint(r), nil } +func (c *bls12381MapG1) WithStateDB(StateDB) PrecompiledContract { return c } + // bls12381MapG2 implements EIP-2537 MapG2 precompile. type bls12381MapG2 struct{} @@ -1080,7 +1125,7 @@ func (c *bls12381MapG2) RequiredGas(input []byte) uint64 { return params.Bls12381MapG2Gas } -func (c *bls12381MapG2) Run(ctx context.Context, statedb StateDB, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { +func (c *bls12381MapG2) Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) { // Implements EIP-2537 Map_FP2_TO_G2 precompile logic. // > Field-to-curve call expects `128` bytes an an input that is interpreted as a an element of the quadratic extension field. // > Output of this call is `256` bytes and is G2 point following respective encoding rules. @@ -1113,3 +1158,5 @@ func (c *bls12381MapG2) Run(ctx context.Context, statedb StateDB, input []byte, // Encode the G2 point to 256 bytes return g.EncodePoint(r), nil } + +func (c *bls12381MapG2) WithStateDB(StateDB) PrecompiledContract { return c } diff --git a/core/vm/evm.go b/core/vm/evm.go index f2219d3db018..6d3d400df8e2 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -227,7 +227,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas if isPrecompile { ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, false, + evm.PrecompileManager.Get(addr).WithStateDB(evm.StateDB), input, caller.Address(), value, gas, false, ) } else { // Initialise a new contract and set the code that is to be used by the EVM. @@ -292,7 +292,7 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, // It is allowed to call precompiles, even via delegatecall if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, true, + evm.PrecompileManager.Get(addr).WithStateDB(evm.StateDB), input, caller.Address(), value, gas, true, ) } else { addrCopy := addr @@ -336,7 +336,7 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { parent := caller.(*Contract) ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr), input, parent.CallerAddress, parent.value, gas, false, + evm.PrecompileManager.Get(addr).WithStateDB(evm.StateDB), input, parent.CallerAddress, parent.value, gas, false, ) } else { addrCopy := addr @@ -387,7 +387,7 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr), input, caller.Address(), new(big.Int), gas, true, + evm.PrecompileManager.Get(addr).WithStateDB(evm.StateDB), input, caller.Address(), new(big.Int), gas, true, ) } else { // At this point, we use a copy of address. If we don't, the go compiler will From fe0db7703f9312aa2f0661135a995af871f3d954 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Thu, 2 Feb 2023 20:34:16 -0500 Subject: [PATCH 33/51] with ctx --- core/vm/evm.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 6d3d400df8e2..ffeb3bae9810 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -17,6 +17,7 @@ package vm import ( + "context" "math/big" "sync/atomic" "time" @@ -43,9 +44,9 @@ type ( // `PrecompileManager` allows the EVM to execute a precompiled contract. type PrecompileManager interface { - // `PrepareForStateTransition` holds the precompile native statedb + // `PrepareForStateTransition` sets the native precompile context // before beginning a state transition. - PrepareForStateTransition(statedb StateDB) error + PrepareForStateTransition(ctx context.Context) error // `Has` returns if a precompiled contract was found at `addr`. Has(addr common.Address) bool From 0d5324b7a63011afa0b522df636e6237f2dd6bf3 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Mon, 6 Feb 2023 18:19:37 -0500 Subject: [PATCH 34/51] simple precompile manager --- core/vm/contracts.go | 44 -------------------------------------------- core/vm/evm.go | 15 ++++++++------- 2 files changed, 8 insertions(+), 51 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index bd27b6308a9f..3f7c92d9514e 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -43,8 +43,6 @@ type PrecompiledContract interface { RequiredGas(input []byte) uint64 // Run runs the precompiled contract with the given context. Run(ctx context.Context, input []byte, caller common.Address, value *big.Int, readonly bool) ([]byte, error) - // WithStateDB sets the statedb for the contract to use. - WithStateDB(sdb StateDB) PrecompiledContract } // PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum @@ -189,8 +187,6 @@ func (c *ecrecover) Run(ctx context.Context, input []byte, caller common.Address return common.LeftPadBytes(crypto.Keccak256(pubKey[1:])[12:], 32), nil } -func (c *ecrecover) WithStateDB(StateDB) PrecompiledContract { return c } - // SHA256 implemented as a native contract. type sha256hash struct{} @@ -210,8 +206,6 @@ func (c *sha256hash) Run(ctx context.Context, input []byte, caller common.Addres return h[:], nil } -func (c *sha256hash) WithStateDB(StateDB) PrecompiledContract { return c } - // RIPEMD160 implemented as a native contract. type ripemd160hash struct{} @@ -232,8 +226,6 @@ func (c *ripemd160hash) Run(ctx context.Context, input []byte, caller common.Add return common.LeftPadBytes(ripemd.Sum(nil), 32), nil } -func (c *ripemd160hash) WithStateDB(StateDB) PrecompiledContract { return c } - // data copy implemented as a native contract. type dataCopy struct{} @@ -252,8 +244,6 @@ func (c *dataCopy) Run(ctx context.Context, input []byte, caller common.Address, return input, nil } -func (c *dataCopy) WithStateDB(StateDB) PrecompiledContract { return c } - // bigModExp implements a native big integer exponential modular operation. type bigModExp struct { eip2565 bool @@ -409,8 +399,6 @@ func (c *bigModExp) Run(ctx context.Context, input []byte, caller common.Address return common.LeftPadBytes(base.Exp(base, exp, mod).Bytes(), int(modLen)), nil } -func (c *bigModExp) WithStateDB(StateDB) PrecompiledContract { return c } - // newCurvePoint unmarshals a binary blob into a bn256 elliptic curve point, // returning it, or an error if the point is invalid. func newCurvePoint(blob []byte) (*bn256.G1, error) { @@ -464,8 +452,6 @@ func (c *bn256AddIstanbul) Run(ctx context.Context, input []byte, caller common. return runBn256Add(input) } -func (c *bn256AddIstanbul) WithStateDB(StateDB) PrecompiledContract { return c } - // bn256AddByzantium implements a native elliptic curve point addition // conforming to Byzantium consensus rules. type bn256AddByzantium struct{} @@ -483,8 +469,6 @@ func (c *bn256AddByzantium) Run(ctx context.Context, input []byte, caller common return runBn256Add(input) } -func (c *bn256AddByzantium) WithStateDB(StateDB) PrecompiledContract { return c } - // runBn256ScalarMul implements the Bn256ScalarMul precompile, referenced by // both Byzantium and Istanbul operations. func runBn256ScalarMul(input []byte) ([]byte, error) { @@ -514,8 +498,6 @@ func (c *bn256ScalarMulIstanbul) Run(ctx context.Context, input []byte, caller c return runBn256ScalarMul(input) } -func (c *bn256ScalarMulIstanbul) WithStateDB(StateDB) PrecompiledContract { return c } - // bn256ScalarMulByzantium implements a native elliptic curve scalar // multiplication conforming to Byzantium consensus rules. type bn256ScalarMulByzantium struct{} @@ -533,8 +515,6 @@ func (c *bn256ScalarMulByzantium) Run(ctx context.Context, input []byte, caller return runBn256ScalarMul(input) } -func (c *bn256ScalarMulByzantium) WithStateDB(StateDB) PrecompiledContract { return c } - var ( // true32Byte is returned if the bn256 pairing check succeeds. true32Byte = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1} @@ -594,8 +574,6 @@ func (c *bn256PairingIstanbul) Run(ctx context.Context, input []byte, caller com return runBn256Pairing(input) } -func (c *bn256PairingIstanbul) WithStateDB(StateDB) PrecompiledContract { return c } - // bn256PairingByzantium implements a pairing pre-compile for the bn256 curve // conforming to Byzantium consensus rules. type bn256PairingByzantium struct{} @@ -613,8 +591,6 @@ func (c *bn256PairingByzantium) Run(ctx context.Context, input []byte, caller co return runBn256Pairing(input) } -func (c *bn256PairingByzantium) WithStateDB(StateDB) PrecompiledContract { return c } - type blake2F struct{} func (c *blake2F) RegistryKey() common.Address { @@ -680,8 +656,6 @@ func (c *blake2F) Run(ctx context.Context, input []byte, caller common.Address, return output, nil } -func (c *blake2F) WithStateDB(StateDB) PrecompiledContract { return c } - var ( errBLS12381InvalidInputLength = errors.New("invalid input length") errBLS12381InvalidFieldElementTopBytes = errors.New("invalid field element top bytes") @@ -731,8 +705,6 @@ func (c *bls12381G1Add) Run(ctx context.Context, input []byte, caller common.Add return g.EncodePoint(r), nil } -func (c *bls12381G1Add) WithStateDB(StateDB) PrecompiledContract { return c } - // bls12381G1Mul implements EIP-2537 G1Mul precompile. type bls12381G1Mul struct{} @@ -773,8 +745,6 @@ func (c *bls12381G1Mul) Run(ctx context.Context, input []byte, caller common.Add return g.EncodePoint(r), nil } -func (c *bls12381G1Mul) WithStateDB(StateDB) PrecompiledContract { return c } - // bls12381G1MultiExp implements EIP-2537 G1MultiExp precompile. type bls12381G1MultiExp struct{} @@ -836,8 +806,6 @@ func (c *bls12381G1MultiExp) Run(ctx context.Context, input []byte, caller commo return g.EncodePoint(r), nil } -func (c *bls12381G1MultiExp) WithStateDB(StateDB) PrecompiledContract { return c } - // bls12381G2Add implements EIP-2537 G2Add precompile. type bls12381G2Add struct{} @@ -880,8 +848,6 @@ func (c *bls12381G2Add) Run(ctx context.Context, input []byte, caller common.Add return g.EncodePoint(r), nil } -func (c *bls12381G2Add) WithStateDB(StateDB) PrecompiledContract { return c } - // bls12381G2Mul implements EIP-2537 G2Mul precompile. type bls12381G2Mul struct{} @@ -922,8 +888,6 @@ func (c *bls12381G2Mul) Run(ctx context.Context, input []byte, caller common.Add return g.EncodePoint(r), nil } -func (c *bls12381G2Mul) WithStateDB(StateDB) PrecompiledContract { return c } - // bls12381G2MultiExp implements EIP-2537 G2MultiExp precompile. type bls12381G2MultiExp struct{} @@ -985,8 +949,6 @@ func (c *bls12381G2MultiExp) Run(ctx context.Context, input []byte, caller commo return g.EncodePoint(r), nil } -func (c *bls12381G2MultiExp) WithStateDB(StateDB) PrecompiledContract { return c } - // bls12381Pairing implements EIP-2537 Pairing precompile. type bls12381Pairing struct{} @@ -1053,8 +1015,6 @@ func (c *bls12381Pairing) Run(ctx context.Context, input []byte, caller common.A return out, nil } -func (c *bls12381Pairing) WithStateDB(StateDB) PrecompiledContract { return c } - // decodeBLS12381FieldElement decodes BLS12-381 elliptic curve field element. // Removes top 16 bytes of 64 byte input. func decodeBLS12381FieldElement(in []byte) ([]byte, error) { @@ -1111,8 +1071,6 @@ func (c *bls12381MapG1) Run(ctx context.Context, input []byte, caller common.Add return g.EncodePoint(r), nil } -func (c *bls12381MapG1) WithStateDB(StateDB) PrecompiledContract { return c } - // bls12381MapG2 implements EIP-2537 MapG2 precompile. type bls12381MapG2 struct{} @@ -1158,5 +1116,3 @@ func (c *bls12381MapG2) Run(ctx context.Context, input []byte, caller common.Add // Encode the G2 point to 256 bytes return g.EncodePoint(r), nil } - -func (c *bls12381MapG2) WithStateDB(StateDB) PrecompiledContract { return c } diff --git a/core/vm/evm.go b/core/vm/evm.go index ffeb3bae9810..3a2e5abeca78 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -44,9 +44,9 @@ type ( // `PrecompileManager` allows the EVM to execute a precompiled contract. type PrecompileManager interface { - // `PrepareForStateTransition` sets the native precompile context - // before beginning a state transition. - PrepareForStateTransition(ctx context.Context) error + // `Reset` sets the native precompile context before beginning a state + // transition. + Reset(ctx context.Context) // `Has` returns if a precompiled contract was found at `addr`. Has(addr common.Address) bool @@ -227,8 +227,9 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { + ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr).WithStateDB(evm.StateDB), input, caller.Address(), value, gas, false, + evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, false, ) } else { // Initialise a new contract and set the code that is to be used by the EVM. @@ -293,7 +294,7 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, // It is allowed to call precompiles, even via delegatecall if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr).WithStateDB(evm.StateDB), input, caller.Address(), value, gas, true, + evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, true, ) } else { addrCopy := addr @@ -337,7 +338,7 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { parent := caller.(*Contract) ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr).WithStateDB(evm.StateDB), input, parent.CallerAddress, parent.value, gas, false, + evm.PrecompileManager.Get(addr), input, parent.CallerAddress, parent.value, gas, false, ) } else { addrCopy := addr @@ -388,7 +389,7 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr).WithStateDB(evm.StateDB), input, caller.Address(), new(big.Int), gas, true, + evm.PrecompileManager.Get(addr), input, caller.Address(), new(big.Int), gas, true, ) } else { // At this point, we use a copy of address. If we don't, the go compiler will From 561d4bc00bc4cd3c02ed8579d2bcaa0fb9168980 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Fri, 10 Feb 2023 11:16:16 -0500 Subject: [PATCH 35/51] allow setting block context to evm --- core/vm/contracts_test.go | 12 ++++++++++++ core/vm/evm.go | 7 +++++++ 2 files changed, 19 insertions(+) diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go index b22d999e6cd9..4ed94d93a950 100644 --- a/core/vm/contracts_test.go +++ b/core/vm/contracts_test.go @@ -18,8 +18,10 @@ package vm import ( "bytes" + "context" "encoding/json" "fmt" + "math/big" "os" "testing" "time" @@ -91,6 +93,16 @@ var blake2FMalformedInputTests = []precompiledFailureTest{ }, } +func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error) { + gasCost := p.RequiredGas(input) + if suppliedGas < gasCost { + return nil, 0, ErrOutOfGas + } + suppliedGas -= gasCost + output, err := p.Run(context.Background(), input, common.Address{}, new(big.Int), true) + return output, suppliedGas, err +} + func testPrecompiled(addr string, test precompiledTest, t *testing.T) { p := allPrecompiles[common.HexToAddress(addr)] in := common.Hex2Bytes(test.Input) diff --git a/core/vm/evm.go b/core/vm/evm.go index 3a2e5abeca78..f2dd8ff78bf3 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -176,6 +176,13 @@ func (evm *EVM) Interpreter() *EVMInterpreter { return evm.interpreter } +// SetBlockContext updates the block context of the EVM. +func (evm *EVM) SetBlockContext(blockCtx BlockContext) { + evm.Context = blockCtx + num := blockCtx.BlockNumber + evm.chainRules = evm.chainConfig.Rules(num, blockCtx.Random != nil) +} + // Call executes the contract associated with the addr with the given input as // parameters. It also handles any necessary value transfer required and takes // the necessary steps to create accounts and reverses the state in case of an From 62f77548da9a285c1b1ff0c71f0c24eaa1bb4cf5 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Fri, 10 Feb 2023 12:34:29 -0500 Subject: [PATCH 36/51] remove unneded evm funcs --- core/vm/evm.go | 7 ------- 1 file changed, 7 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index f2dd8ff78bf3..3a2e5abeca78 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -176,13 +176,6 @@ func (evm *EVM) Interpreter() *EVMInterpreter { return evm.interpreter } -// SetBlockContext updates the block context of the EVM. -func (evm *EVM) SetBlockContext(blockCtx BlockContext) { - evm.Context = blockCtx - num := blockCtx.BlockNumber - evm.chainRules = evm.chainConfig.Rules(num, blockCtx.Random != nil) -} - // Call executes the contract associated with the addr with the given input as // parameters. It also handles any necessary value transfer required and takes // the necessary steps to create accounts and reverses the state in case of an From 6096143235f047b0946d5d0d95eba7145c1aa516 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Wed, 15 Feb 2023 19:28:51 -0500 Subject: [PATCH 37/51] simplify precompile manager --- core/vm/evm.go | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 3a2e5abeca78..838dc199e7f6 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -44,8 +44,6 @@ type ( // `PrecompileManager` allows the EVM to execute a precompiled contract. type PrecompileManager interface { - // `Reset` sets the native precompile context before beginning a state - // transition. Reset(ctx context.Context) // `Has` returns if a precompiled contract was found at `addr`. @@ -56,7 +54,7 @@ type PrecompileManager interface { Get(addr common.Address) PrecompiledContract // `Run` runs a precompiled contract and returns the remaining gas. - Run(p PrecompiledContract, input []byte, caller common.Address, + Run(sdb StateDB, p PrecompiledContract, input []byte, caller common.Address, value *big.Int, suppliedGas uint64, readonly bool, ) (ret []byte, remainingGas uint64, err error) } @@ -227,9 +225,8 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } if isPrecompile { - ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, false, + evm.StateDB, evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, false, ) } else { // Initialise a new contract and set the code that is to be used by the EVM. @@ -294,7 +291,7 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, // It is allowed to call precompiles, even via delegatecall if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, true, + evm.StateDB, evm.PrecompileManager.Get(addr), input, caller.Address(), value, gas, true, ) } else { addrCopy := addr @@ -338,7 +335,7 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { parent := caller.(*Contract) ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr), input, parent.CallerAddress, parent.value, gas, false, + evm.StateDB, evm.PrecompileManager.Get(addr), input, parent.CallerAddress, parent.value, gas, false, ) } else { addrCopy := addr @@ -389,7 +386,7 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte if isPrecompile := evm.PrecompileManager.Has(addr); isPrecompile { ret, gas, err = evm.PrecompileManager.Run( - evm.PrecompileManager.Get(addr), input, caller.Address(), new(big.Int), gas, true, + evm.StateDB, evm.PrecompileManager.Get(addr), input, caller.Address(), new(big.Int), gas, true, ) } else { // At this point, we use a copy of address. If we don't, the go compiler will From 633ada9ec5a675f252dd02a8b8d628f93cdda56e Mon Sep 17 00:00:00 2001 From: t12s Date: Thu, 16 Feb 2023 19:32:39 -0500 Subject: [PATCH 38/51] updated go.sum --- go.sum | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/go.sum b/go.sum index 300205bce7be..bf28cd2e24e5 100644 --- a/go.sum +++ b/go.sum @@ -169,7 +169,6 @@ github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlK github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= @@ -660,11 +659,12 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210220033124-5f55cee0dc0d/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210610132358-84b48f89b13b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220607020251-c690dde0001d h1:4SFsTMi4UahlKoloni7L4eYzhFRifURQLw+yv0QDCx8= -golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.4.0 h1:Q5QPcMlvfxFTAPV0+07Xz/MpK9NTXu2VDUuy0FeMfaU= +golang.org/x/net v0.4.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -712,7 +712,6 @@ golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -730,9 +729,6 @@ golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a h1:dGzPydgVsqGcTRVwiLJ1jVbufYwmzD3LfVPLKsKg+0k= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -779,9 +775,12 @@ golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200108203644-89082a384178/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= -golang.org/x/tools v0.1.8-0.20211029000441-d6a9af8af023 h1:0c3L82FDQ5rt1bjTBlchS8t6RQ6299/+5bWMnRLh+uI= -golang.org/x/tools v0.1.8-0.20211029000441-d6a9af8af023/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.2.0 h1:G6AHpWxTMGY1KyEYoAQ5WTtIekUUvDNjan3ugu60JvE= +golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= From bf62ef87d35d12a9514b0b1fd6a3e7d6e7b8d93f Mon Sep 17 00:00:00 2001 From: t12s Date: Thu, 16 Feb 2023 19:50:09 -0500 Subject: [PATCH 39/51] removing extra bits --- accounts/abi/bind/bind.go | 2 +- core/vm/instructions.go | 30 +++++++++----------------- eth/protocols/snap/sync.go | 44 -------------------------------------- 3 files changed, 11 insertions(+), 65 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index c179dbcc925f..05cca8e90b3a 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -187,7 +187,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] } eventIdentifiers[normalizedName] = true normalized.Name = normalizedName - + used := make(map[string]bool) normalized.Inputs = make([]abi.Argument, len(original.Inputs)) copy(normalized.Inputs, original.Inputs) diff --git a/core/vm/instructions.go b/core/vm/instructions.go index 7e0bfb2bb252..77b6e02bfcc7 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -1,4 +1,3 @@ - // Copyright 2015 The go-ethereum Authors // This file is part of the go-ethereum library. // @@ -394,21 +393,14 @@ func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) // There are several cases when the function is called, while we can relay everything // to `state.GetCodeHash` function to ensure the correctness. // -// (1) Caller tries to get the code hash of a normal contract account, state -// -// should return the relative code hash and set it as the result. -// -// (2) Caller tries to get the code hash of a non-existent account, state should -// -// return common.Hash{} and zero will be set as the result. +// 1. Caller tries to get the code hash of a normal contract account, state +// should return the relative code hash and set it as the result. // -// (3) Caller tries to get the code hash for an account without contract code, +// 2. Caller tries to get the code hash of a non-existent account, state should +// return common.Hash{} and zero will be set as the result. // -// state should return emptyCodeHash(0xc5d246...) as the result. -// -// (4) Caller tries to get the code hash of a precompiled account, the result -// -// should be zero or emptyCodeHash. +// 3. Caller tries to get the code hash for an account without contract code, state +// should return emptyCodeHash(0xc5d246...) as the result. // // 4. Caller tries to get the code hash of a precompiled account, the result should be // zero or emptyCodeHash. @@ -418,13 +410,11 @@ func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) // emptyCodeHash. If the precompile account is not transferred any amount on a private or // customized chain, the return value will be zero. // -// (5) Caller tries to get the code hash for an account which is marked as suicided -// -// in the current transaction, the code hash of this account should be returned. -// -// (6) Caller tries to get the code hash for an account which is marked as deleted, +// 5. Caller tries to get the code hash for an account which is marked as suicided +// in the current transaction, the code hash of this account should be returned. // -// this account should be regarded as a non-existent account and zero should be returned. +// 6. Caller tries to get the code hash for an account which is marked as deleted, this +// account should be regarded as a non-existent account and zero should be returned. func opExtCodeHash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) { slot := scope.Stack.peek() address := common.Address(slot.Bytes20()) diff --git a/eth/protocols/snap/sync.go b/eth/protocols/snap/sync.go index 359271db4696..ff20a306d42b 100644 --- a/eth/protocols/snap/sync.go +++ b/eth/protocols/snap/sync.go @@ -2228,50 +2228,6 @@ func (s *Syncer) commitHealer(force bool) { log.Crit("Failed to persist healing data", "err", err) } log.Debug("Persisted set of healing data", "type", "trienodes", "bytes", common.StorageSize(batch.ValueSize())) - - // Calculate the processing rate of one filled trie node - rate := float64(fills) / (float64(time.Since(start)) / float64(time.Second)) - - // Update the currently measured trienode queueing and processing throughput. - // - // The processing rate needs to be updated uniformly independent if we've - // processed 1x100 trie nodes or 100x1 to keep the rate consistent even in - // the face of varying network packets. As such, we cannot just measure the - // time it took to process N trie nodes and update once, we need one update - // per trie node. - // - // Naively, that would be: - // - // for i:=0; i time.Second { - // Periodically adjust the trie node throttler - if float64(pending) > 2*s.trienodeHealRate { - s.trienodeHealThrottle *= trienodeHealThrottleIncrease - } else { - s.trienodeHealThrottle /= trienodeHealThrottleDecrease - } - if s.trienodeHealThrottle > maxTrienodeHealThrottle { - s.trienodeHealThrottle = maxTrienodeHealThrottle - } else if s.trienodeHealThrottle < minTrienodeHealThrottle { - s.trienodeHealThrottle = minTrienodeHealThrottle - } - s.trienodeHealThrottled = time.Now() - - log.Debug("Updated trie node heal throttler", "rate", s.trienodeHealRate, "pending", pending, "throttle", s.trienodeHealThrottle) - } } // processBytecodeHealResponse integrates an already validated bytecode response From 62b39379342b019c96111709adb852d73c456b6e Mon Sep 17 00:00:00 2001 From: t12s Date: Fri, 17 Feb 2023 14:15:48 -0500 Subject: [PATCH 40/51] typo fixes --- eth/protocols/snap/sync.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/eth/protocols/snap/sync.go b/eth/protocols/snap/sync.go index ff20a306d42b..1112afb08c81 100644 --- a/eth/protocols/snap/sync.go +++ b/eth/protocols/snap/sync.go @@ -87,13 +87,13 @@ const ( trienodeHealRateMeasurementImpact = 0.005 // minTrienodeHealThrottle is the minimum divisor for throttling trie node - // heal requests to avoid overloading the local node and exessively expanding - // the state trie bedth wise. + // heal requests to avoid overloading the local node and excessively expanding + // the state trie breadth wise. minTrienodeHealThrottle = 1 // maxTrienodeHealThrottle is the maximum divisor for throttling trie node - // heal requests to avoid overloading the local node and exessively expanding - // the state trie bedth wise. + // heal requests to avoid overloading the local node and excessively expanding + // the state trie breadth wise. maxTrienodeHealThrottle = maxTrieRequestCount // trienodeHealThrottleIncrease is the multiplier for the throttle when the From 98f7bdb37121f4e42d2dfb73a0aec951314aae38 Mon Sep 17 00:00:00 2001 From: Devon Bear Date: Sat, 18 Feb 2023 16:24:58 -0500 Subject: [PATCH 41/51] ethapi --- cmd/clef/main.go | 2 +- cmd/geth/config.go | 2 +- cmd/geth/main.go | 2 +- cmd/utils/flags.go | 2 +- eth/api.go | 2 +- eth/backend.go | 2 +- eth/filters/api.go | 2 +- eth/tracers/api.go | 2 +- eth/tracers/api_test.go | 2 +- {internal/ethapi => ethapi}/addrlock.go | 0 {internal/ethapi => ethapi}/api.go | 0 {internal/ethapi => ethapi}/backend.go | 0 {internal/ethapi => ethapi}/dbapi.go | 0 {internal/ethapi => ethapi}/transaction_args.go | 0 {internal/ethapi => ethapi}/transaction_args_test.go | 0 graphql/graphql.go | 2 +- graphql/service.go | 2 +- les/client.go | 2 +- signer/core/api.go | 2 +- signer/core/api_test.go | 2 +- signer/core/auditlog.go | 2 +- signer/core/cliui.go | 2 +- signer/core/stdioui.go | 2 +- signer/rules/rules.go | 2 +- signer/rules/rules_test.go | 2 +- 25 files changed, 19 insertions(+), 19 deletions(-) rename {internal/ethapi => ethapi}/addrlock.go (100%) rename {internal/ethapi => ethapi}/api.go (100%) rename {internal/ethapi => ethapi}/backend.go (100%) rename {internal/ethapi => ethapi}/dbapi.go (100%) rename {internal/ethapi => ethapi}/transaction_args.go (100%) rename {internal/ethapi => ethapi}/transaction_args_test.go (100%) diff --git a/cmd/clef/main.go b/cmd/clef/main.go index 2788ddc33b9e..e71c2e538edc 100644 --- a/cmd/clef/main.go +++ b/cmd/clef/main.go @@ -41,7 +41,7 @@ import ( "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/internal/flags" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/node" diff --git a/cmd/geth/config.go b/cmd/geth/config.go index 61b7ed5ec1e3..9808ebc95230 100644 --- a/cmd/geth/config.go +++ b/cmd/geth/config.go @@ -33,7 +33,7 @@ import ( "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/eth/downloader" "github.com/ethereum/go-ethereum/eth/ethconfig" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/internal/flags" "github.com/ethereum/go-ethereum/internal/version" "github.com/ethereum/go-ethereum/log" diff --git a/cmd/geth/main.go b/cmd/geth/main.go index 5ba070249897..d7bdfd995d60 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -32,9 +32,9 @@ import ( "github.com/ethereum/go-ethereum/console/prompt" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/eth/downloader" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/internal/debug" - "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/internal/flags" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 08de71ee831b..88a40ffecbda 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -53,11 +53,11 @@ import ( "github.com/ethereum/go-ethereum/eth/filters" "github.com/ethereum/go-ethereum/eth/gasprice" "github.com/ethereum/go-ethereum/eth/tracers" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb/remotedb" "github.com/ethereum/go-ethereum/ethstats" "github.com/ethereum/go-ethereum/graphql" - "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/internal/flags" "github.com/ethereum/go-ethereum/les" lescatalyst "github.com/ethereum/go-ethereum/les/catalyst" diff --git a/eth/api.go b/eth/api.go index ceed85ef576b..c1f73037d7d8 100644 --- a/eth/api.go +++ b/eth/api.go @@ -34,7 +34,7 @@ import ( "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/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rpc" diff --git a/eth/backend.go b/eth/backend.go index 6368c0e03c56..9bde9cd34bd1 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -43,9 +43,9 @@ import ( "github.com/ethereum/go-ethereum/eth/gasprice" "github.com/ethereum/go-ethereum/eth/protocols/eth" "github.com/ethereum/go-ethereum/eth/protocols/snap" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/event" - "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/internal/shutdowncheck" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/miner" diff --git a/eth/filters/api.go b/eth/filters/api.go index a30eb28befd2..9ff205e4d1a4 100644 --- a/eth/filters/api.go +++ b/eth/filters/api.go @@ -29,7 +29,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/rpc" ) diff --git a/eth/tracers/api.go b/eth/tracers/api.go index 55c56b40c9f1..6dca581ed74c 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -37,8 +37,8 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/tracers/logger" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index 29ec80868579..bbcb00a5e763 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -41,8 +41,8 @@ import ( "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/tracers/logger" + "github.com/ethereum/go-ethereum/ethapi" "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" ) diff --git a/internal/ethapi/addrlock.go b/ethapi/addrlock.go similarity index 100% rename from internal/ethapi/addrlock.go rename to ethapi/addrlock.go diff --git a/internal/ethapi/api.go b/ethapi/api.go similarity index 100% rename from internal/ethapi/api.go rename to ethapi/api.go diff --git a/internal/ethapi/backend.go b/ethapi/backend.go similarity index 100% rename from internal/ethapi/backend.go rename to ethapi/backend.go diff --git a/internal/ethapi/dbapi.go b/ethapi/dbapi.go similarity index 100% rename from internal/ethapi/dbapi.go rename to ethapi/dbapi.go diff --git a/internal/ethapi/transaction_args.go b/ethapi/transaction_args.go similarity index 100% rename from internal/ethapi/transaction_args.go rename to ethapi/transaction_args.go diff --git a/internal/ethapi/transaction_args_test.go b/ethapi/transaction_args_test.go similarity index 100% rename from internal/ethapi/transaction_args_test.go rename to ethapi/transaction_args_test.go diff --git a/graphql/graphql.go b/graphql/graphql.go index 356ff669fb16..637778e9d0f7 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -33,7 +33,7 @@ import ( "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth/filters" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rpc" ) diff --git a/graphql/service.go b/graphql/service.go index 4392dd83e688..332a0d6ca71a 100644 --- a/graphql/service.go +++ b/graphql/service.go @@ -25,7 +25,7 @@ import ( "time" "github.com/ethereum/go-ethereum/eth/filters" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/rpc" "github.com/graph-gophers/graphql-go" diff --git a/les/client.go b/les/client.go index 9ac85ecdac6f..60a2a3d2856b 100644 --- a/les/client.go +++ b/les/client.go @@ -33,8 +33,8 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth/ethconfig" "github.com/ethereum/go-ethereum/eth/gasprice" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/event" - "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/internal/shutdowncheck" "github.com/ethereum/go-ethereum/les/downloader" "github.com/ethereum/go-ethereum/les/vflux" diff --git a/signer/core/api.go b/signer/core/api.go index 3c1c94801b11..bdb3f6f7e0a9 100644 --- a/signer/core/api.go +++ b/signer/core/api.go @@ -33,7 +33,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/math" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/signer/core/apitypes" diff --git a/signer/core/api_test.go b/signer/core/api_test.go index 9bb55bddca31..16a9cc59b533 100644 --- a/signer/core/api_test.go +++ b/signer/core/api_test.go @@ -31,7 +31,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/signer/core" "github.com/ethereum/go-ethereum/signer/core/apitypes" diff --git a/signer/core/auditlog.go b/signer/core/auditlog.go index a0b292bf714c..f13a42aa1b8f 100644 --- a/signer/core/auditlog.go +++ b/signer/core/auditlog.go @@ -22,7 +22,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/signer/core/apitypes" ) diff --git a/signer/core/cliui.go b/signer/core/cliui.go index b1bd3206ed3f..4569260bdaf8 100644 --- a/signer/core/cliui.go +++ b/signer/core/cliui.go @@ -27,7 +27,7 @@ import ( "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/console/prompt" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/log" ) diff --git a/signer/core/stdioui.go b/signer/core/stdioui.go index 6963a89122f6..9bd271c1345d 100644 --- a/signer/core/stdioui.go +++ b/signer/core/stdioui.go @@ -19,7 +19,7 @@ package core import ( "context" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rpc" ) diff --git a/signer/rules/rules.go b/signer/rules/rules.go index 5ed4514e0227..6ebe23148e5f 100644 --- a/signer/rules/rules.go +++ b/signer/rules/rules.go @@ -23,7 +23,7 @@ import ( "strings" "github.com/dop251/goja" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/internal/jsre/deps" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/signer/core" diff --git a/signer/rules/rules_test.go b/signer/rules/rules_test.go index c35da8ecc188..a8dea13131d7 100644 --- a/signer/rules/rules_test.go +++ b/signer/rules/rules_test.go @@ -26,7 +26,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/ethapi" "github.com/ethereum/go-ethereum/signer/core" "github.com/ethereum/go-ethereum/signer/core/apitypes" "github.com/ethereum/go-ethereum/signer/storage" From 52883710e99db18bdac0e982b28bc82ac6205339 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Sun, 19 Feb 2023 16:56:13 -0500 Subject: [PATCH 42/51] cleanup precomp manager --- core/vm/evm.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/core/vm/evm.go b/core/vm/evm.go index 19330c9c4a90..51a1f720689e 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -17,7 +17,6 @@ package vm import ( - "context" "math/big" "sync/atomic" @@ -43,8 +42,6 @@ type ( // `PrecompileManager` allows the EVM to execute a precompiled contract. type PrecompileManager interface { - Reset(ctx context.Context) - // `Has` returns if a precompiled contract was found at `addr`. Has(addr common.Address) bool From 88e2f3d8a4d153e0a5ce0b8d2b2d740a7a788e99 Mon Sep 17 00:00:00 2001 From: Devon Bear Date: Tue, 21 Feb 2023 22:21:41 -0500 Subject: [PATCH 43/51] add get chain id --- core/types/transaction.go | 1 + core/types/tx_access_list.go | 1 + core/types/tx_dynamic_fee.go | 1 + core/types/tx_legacy.go | 1 + 4 files changed, 4 insertions(+) diff --git a/core/types/transaction.go b/core/types/transaction.go index 353e0e599c68..412a9810dfb7 100644 --- a/core/types/transaction.go +++ b/core/types/transaction.go @@ -85,6 +85,7 @@ type TxData interface { rawSignatureValues() (v, r, s *big.Int) setSignatureValues(chainID, v, r, s *big.Int) + GetChainID() *big.Int } // EncodeRLP implements rlp.Encoder diff --git a/core/types/tx_access_list.go b/core/types/tx_access_list.go index 620848fe624a..79692bb4206e 100644 --- a/core/types/tx_access_list.go +++ b/core/types/tx_access_list.go @@ -96,6 +96,7 @@ func (tx *AccessListTx) copy() TxData { // accessors for innerTx. func (tx *AccessListTx) txType() byte { return AccessListTxType } func (tx *AccessListTx) chainID() *big.Int { return tx.ChainID } +func (tx *AccessListTx) GetChainID() *big.Int { return tx.ChainID } func (tx *AccessListTx) accessList() AccessList { return tx.AccessList } func (tx *AccessListTx) data() []byte { return tx.Data } func (tx *AccessListTx) gas() uint64 { return tx.Gas } diff --git a/core/types/tx_dynamic_fee.go b/core/types/tx_dynamic_fee.go index 53f246ea1fad..6e1329854adb 100644 --- a/core/types/tx_dynamic_fee.go +++ b/core/types/tx_dynamic_fee.go @@ -84,6 +84,7 @@ func (tx *DynamicFeeTx) copy() TxData { // accessors for innerTx. func (tx *DynamicFeeTx) txType() byte { return DynamicFeeTxType } func (tx *DynamicFeeTx) chainID() *big.Int { return tx.ChainID } +func (tx *DynamicFeeTx) GetChainID() *big.Int { return tx.ChainID } func (tx *DynamicFeeTx) accessList() AccessList { return tx.AccessList } func (tx *DynamicFeeTx) data() []byte { return tx.Data } func (tx *DynamicFeeTx) gas() uint64 { return tx.Gas } diff --git a/core/types/tx_legacy.go b/core/types/tx_legacy.go index 14d307829cc9..0a488431c130 100644 --- a/core/types/tx_legacy.go +++ b/core/types/tx_legacy.go @@ -93,6 +93,7 @@ func (tx *LegacyTx) copy() TxData { // accessors for innerTx. func (tx *LegacyTx) txType() byte { return LegacyTxType } func (tx *LegacyTx) chainID() *big.Int { return deriveChainId(tx.V) } +func (tx *LegacyTx) GetChainID() *big.Int { return deriveChainId(tx.V) } func (tx *LegacyTx) accessList() AccessList { return nil } func (tx *LegacyTx) data() []byte { return tx.Data } func (tx *LegacyTx) gas() uint64 { return tx.Gas } From 594eaa8c58278e268509456c666d8a888b165e87 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Thu, 23 Feb 2023 10:35:50 -0500 Subject: [PATCH 44/51] make access list public --- core/state/access_list.go | 6 +++--- core/state/statedb.go | 4 ++-- core/state/statedb_test.go | 2 +- eth/tracers/logger/access_list_tracer.go | 6 +++--- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/core/state/access_list.go b/core/state/access_list.go index 419469134595..ef42e2303631 100644 --- a/core/state/access_list.go +++ b/core/state/access_list.go @@ -47,8 +47,8 @@ func (al *accessList) Contains(address common.Address, slot common.Hash) (addres return true, slotPresent } -// newAccessList creates a new accessList. -func newAccessList() *accessList { +// NewAccessList creates a new accessList. +func NewAccessList() *accessList { return &accessList{ addresses: make(map[common.Address]int), } @@ -56,7 +56,7 @@ func newAccessList() *accessList { // Copy creates an independent copy of an accessList. func (a *accessList) Copy() *accessList { - cp := newAccessList() + cp := NewAccessList() for k, v := range a.addresses { cp.addresses[k] = v } diff --git a/core/state/statedb.go b/core/state/statedb.go index 3f4bec2392dc..5c204cbe28b5 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -150,7 +150,7 @@ func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error) logs: make(map[common.Hash][]*types.Log), preimages: make(map[common.Hash][]byte), journal: newJournal(), - accessList: newAccessList(), + accessList: NewAccessList(), transientStorage: newTransientStorage(), hasher: crypto.NewKeccakState(), } @@ -1101,7 +1101,7 @@ func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) { func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, dst *common.Address, precompiles []common.Address, list types.AccessList) { if rules.IsBerlin { // Clear out any leftover from previous executions - al := newAccessList() + al := NewAccessList() s.accessList = al al.AddAddress(sender) diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index 8aa59e3ee592..f8fc4ac20a22 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -763,7 +763,7 @@ func TestStateDBAccessList(t *testing.T) { memDb := rawdb.NewMemoryDatabase() db := NewDatabase(memDb) state, _ := New(common.Hash{}, db, nil) - state.accessList = newAccessList() + state.accessList = NewAccessList() verifyAddrs := func(astrings ...string) { t.Helper() diff --git a/eth/tracers/logger/access_list_tracer.go b/eth/tracers/logger/access_list_tracer.go index 766ee4e4b95c..e4829bf5bba4 100644 --- a/eth/tracers/logger/access_list_tracer.go +++ b/eth/tracers/logger/access_list_tracer.go @@ -32,8 +32,8 @@ type accessList map[common.Address]accessListSlots // contract that an EVM contract execution touches. type accessListSlots map[common.Hash]struct{} -// newAccessList creates a new accessList. -func newAccessList() accessList { +// NewAccessList creates a new accessList. +func NewAccessList() accessList { return make(map[common.Address]accessListSlots) } @@ -117,7 +117,7 @@ func NewAccessListTracer(acl types.AccessList, from, to common.Address, precompi for _, addr := range precompiles { excl[addr] = struct{}{} } - list := newAccessList() + list := NewAccessList() for _, al := range acl { if _, ok := excl[al.Address]; !ok { list.addAddress(al.Address) From 8ff008313185ef08ff3d1a7998299690f172e61d Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Thu, 23 Feb 2023 10:52:48 -0500 Subject: [PATCH 45/51] make access list struct public --- core/state/access_list.go | 24 ++++++++++++------------ core/state/journal.go | 4 ++-- core/state/statedb.go | 24 ++++++++++++------------ core/state/statedb_test.go | 16 ++++++++-------- 4 files changed, 34 insertions(+), 34 deletions(-) diff --git a/core/state/access_list.go b/core/state/access_list.go index ef42e2303631..0a61223b4b75 100644 --- a/core/state/access_list.go +++ b/core/state/access_list.go @@ -20,20 +20,20 @@ import ( "github.com/ethereum/go-ethereum/common" ) -type accessList struct { +type AccessList struct { addresses map[common.Address]int slots []map[common.Hash]struct{} } // ContainsAddress returns true if the address is in the access list. -func (al *accessList) ContainsAddress(address common.Address) bool { +func (al *AccessList) ContainsAddress(address common.Address) bool { _, ok := al.addresses[address] return ok } // Contains checks if a slot within an account is present in the access list, returning // separate flags for the presence of the account and the slot respectively. -func (al *accessList) Contains(address common.Address, slot common.Hash) (addressPresent bool, slotPresent bool) { +func (al *AccessList) Contains(address common.Address, slot common.Hash) (addressPresent bool, slotPresent bool) { idx, ok := al.addresses[address] if !ok { // no such address (and hence zero slots) @@ -47,15 +47,15 @@ func (al *accessList) Contains(address common.Address, slot common.Hash) (addres return true, slotPresent } -// NewAccessList creates a new accessList. -func NewAccessList() *accessList { - return &accessList{ +// NewAccessList creates a new AccessList. +func NewAccessList() *AccessList { + return &AccessList{ addresses: make(map[common.Address]int), } } -// Copy creates an independent copy of an accessList. -func (a *accessList) Copy() *accessList { +// Copy creates an independent copy of an AccessList. +func (a *AccessList) Copy() *AccessList { cp := NewAccessList() for k, v := range a.addresses { cp.addresses[k] = v @@ -73,7 +73,7 @@ func (a *accessList) Copy() *accessList { // AddAddress adds an address to the access list, and returns 'true' if the operation // caused a change (addr was not previously in the list). -func (al *accessList) AddAddress(address common.Address) bool { +func (al *AccessList) AddAddress(address common.Address) bool { if _, present := al.addresses[address]; present { return false } @@ -86,7 +86,7 @@ func (al *accessList) AddAddress(address common.Address) bool { // - address added // - slot added // For any 'true' value returned, a corresponding journal entry must be made. -func (al *accessList) AddSlot(address common.Address, slot common.Hash) (addrChange bool, slotChange bool) { +func (al *AccessList) AddSlot(address common.Address, slot common.Hash) (addrChange bool, slotChange bool) { idx, addrPresent := al.addresses[address] if !addrPresent || idx == -1 { // Address not present, or addr present but no slots there @@ -110,7 +110,7 @@ func (al *accessList) AddSlot(address common.Address, slot common.Hash) (addrCha // This operation needs to be performed in the same order as the addition happened. // This method is meant to be used by the journal, which maintains ordering of // operations. -func (al *accessList) DeleteSlot(address common.Address, slot common.Hash) { +func (al *AccessList) DeleteSlot(address common.Address, slot common.Hash) { idx, addrOk := al.addresses[address] // There are two ways this can fail if !addrOk { @@ -131,6 +131,6 @@ func (al *accessList) DeleteSlot(address common.Address, slot common.Hash) { // needs to be performed in the same order as the addition happened. // This method is meant to be used by the journal, which maintains ordering of // operations. -func (al *accessList) DeleteAddress(address common.Address) { +func (al *AccessList) DeleteAddress(address common.Address) { delete(al.addresses, address) } diff --git a/core/state/journal.go b/core/state/journal.go index 1722fb4c02e1..4e15f9da2b9e 100644 --- a/core/state/journal.go +++ b/core/state/journal.go @@ -266,7 +266,7 @@ func (ch accessListAddAccountChange) revert(s *StateDB) { (addr) at this point, since no storage adds can remain when come upon a single (addr) change. */ - s.accessList.DeleteAddress(*ch.address) + s.AccessList.DeleteAddress(*ch.address) } func (ch accessListAddAccountChange) dirtied() *common.Address { @@ -274,7 +274,7 @@ func (ch accessListAddAccountChange) dirtied() *common.Address { } func (ch accessListAddSlotChange) revert(s *StateDB) { - s.accessList.DeleteSlot(*ch.address, *ch.slot) + s.AccessList.DeleteSlot(*ch.address, *ch.slot) } func (ch accessListAddSlotChange) dirtied() *common.Address { diff --git a/core/state/statedb.go b/core/state/statedb.go index 5c204cbe28b5..9d9654aa94f6 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -101,7 +101,7 @@ type StateDB struct { preimages map[common.Hash][]byte // Per-transaction access list - accessList *accessList + accessList *AccessList // Transient storage transientStorage transientStorage @@ -150,7 +150,7 @@ func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error) logs: make(map[common.Hash][]*types.Log), preimages: make(map[common.Hash][]byte), journal: newJournal(), - accessList: NewAccessList(), + accessList: NewaccessList(), transientStorage: newTransientStorage(), hasher: crypto.NewKeccakState(), } @@ -1098,10 +1098,10 @@ func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) { // - Reset access list (Berlin) // - Add coinbase to access list (EIP-3651) // - Reset transient storage (EIP-1153) -func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, dst *common.Address, precompiles []common.Address, list types.AccessList) { +func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, dst *common.Address, precompiles []common.Address, list types.accessList) { if rules.IsBerlin { // Clear out any leftover from previous executions - al := NewAccessList() + al := NewaccessList() s.accessList = al al.AddAddress(sender) @@ -1126,15 +1126,15 @@ func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, d s.transientStorage = newTransientStorage() } -// AddAddressToAccessList adds the given address to the access list -func (s *StateDB) AddAddressToAccessList(addr common.Address) { +// AddAddressToaccessList adds the given address to the access list +func (s *StateDB) AddAddressToaccessList(addr common.Address) { if s.accessList.AddAddress(addr) { s.journal.append(accessListAddAccountChange{&addr}) } } -// AddSlotToAccessList adds the given (address, slot)-tuple to the access list -func (s *StateDB) AddSlotToAccessList(addr common.Address, slot common.Hash) { +// AddSlotToaccessList adds the given (address, slot)-tuple to the access list +func (s *StateDB) AddSlotToaccessList(addr common.Address, slot common.Hash) { addrMod, slotMod := s.accessList.AddSlot(addr, slot) if addrMod { // In practice, this should not happen, since there is no way to enter the @@ -1151,13 +1151,13 @@ func (s *StateDB) AddSlotToAccessList(addr common.Address, slot common.Hash) { } } -// AddressInAccessList returns true if the given address is in the access list. -func (s *StateDB) AddressInAccessList(addr common.Address) bool { +// AddressInaccessList returns true if the given address is in the access list. +func (s *StateDB) AddressInaccessList(addr common.Address) bool { return s.accessList.ContainsAddress(addr) } -// SlotInAccessList returns true if the given (address, slot)-tuple is in the access list. -func (s *StateDB) SlotInAccessList(addr common.Address, slot common.Hash) (addressPresent bool, slotPresent bool) { +// SlotInaccessList returns true if the given (address, slot)-tuple is in the access list. +func (s *StateDB) SlotInaccessList(addr common.Address, slot common.Hash) (addressPresent bool, slotPresent bool) { return s.accessList.Contains(addr, slot) } diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index f8fc4ac20a22..eaf2c4dc9912 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -763,7 +763,7 @@ func TestStateDBAccessList(t *testing.T) { memDb := rawdb.NewMemoryDatabase() db := NewDatabase(memDb) state, _ := New(common.Hash{}, db, nil) - state.accessList = NewAccessList() + state.AccessList = NewAccessList() verifyAddrs := func(astrings ...string) { t.Helper() @@ -782,7 +782,7 @@ func TestStateDBAccessList(t *testing.T) { } } // Check that only the expected addresses are present in the access list - for address := range state.accessList.addresses { + for address := range state.AccessList.addresses { if _, exist := addressMap[address]; !exist { t.Fatalf("extra address %x in access list", address) } @@ -808,9 +808,9 @@ func TestStateDBAccessList(t *testing.T) { } } // Check that no extra elements are in the access list - index := state.accessList.addresses[address] + index := state.AccessList.addresses[address] if index >= 0 { - stateSlots := state.accessList.slots[index] + stateSlots := state.AccessList.slots[index] for s := range stateSlots { if _, slotPresent := slotMap[s]; !slotPresent { t.Fatalf("scope has extra slot %v (address %v)", s, addrString) @@ -906,10 +906,10 @@ func TestStateDBAccessList(t *testing.T) { if state.AddressInAccessList(addr("aa")) { t.Fatalf("addr present, expected missing") } - if got, exp := len(state.accessList.addresses), 0; got != exp { + if got, exp := len(state.AccessList.addresses), 0; got != exp { t.Fatalf("expected empty, got %d", got) } - if got, exp := len(state.accessList.slots), 0; got != exp { + if got, exp := len(state.AccessList.slots), 0; got != exp { t.Fatalf("expected empty, got %d", got) } // Check the copy @@ -917,10 +917,10 @@ func TestStateDBAccessList(t *testing.T) { state = stateCopy1 verifyAddrs("aa", "bb") verifySlots("bb", "01", "02") - if got, exp := len(state.accessList.addresses), 2; got != exp { + if got, exp := len(state.AccessList.addresses), 2; got != exp { t.Fatalf("expected empty, got %d", got) } - if got, exp := len(state.accessList.slots), 1; got != exp { + if got, exp := len(state.AccessList.slots), 1; got != exp { t.Fatalf("expected empty, got %d", got) } } From 367abc363d28e0d737120169d0e4726b296f3925 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Thu, 23 Feb 2023 11:24:42 -0500 Subject: [PATCH 46/51] fix typos --- core/state/journal.go | 4 ++-- core/state/statedb.go | 22 +++++++++++----------- core/state/statedb_test.go | 16 ++++++++-------- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/core/state/journal.go b/core/state/journal.go index 4e15f9da2b9e..1722fb4c02e1 100644 --- a/core/state/journal.go +++ b/core/state/journal.go @@ -266,7 +266,7 @@ func (ch accessListAddAccountChange) revert(s *StateDB) { (addr) at this point, since no storage adds can remain when come upon a single (addr) change. */ - s.AccessList.DeleteAddress(*ch.address) + s.accessList.DeleteAddress(*ch.address) } func (ch accessListAddAccountChange) dirtied() *common.Address { @@ -274,7 +274,7 @@ func (ch accessListAddAccountChange) dirtied() *common.Address { } func (ch accessListAddSlotChange) revert(s *StateDB) { - s.AccessList.DeleteSlot(*ch.address, *ch.slot) + s.accessList.DeleteSlot(*ch.address, *ch.slot) } func (ch accessListAddSlotChange) dirtied() *common.Address { diff --git a/core/state/statedb.go b/core/state/statedb.go index 9d9654aa94f6..58445a5baa45 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -150,7 +150,7 @@ func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error) logs: make(map[common.Hash][]*types.Log), preimages: make(map[common.Hash][]byte), journal: newJournal(), - accessList: NewaccessList(), + accessList: NewAccessList(), transientStorage: newTransientStorage(), hasher: crypto.NewKeccakState(), } @@ -1098,10 +1098,10 @@ func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) { // - Reset access list (Berlin) // - Add coinbase to access list (EIP-3651) // - Reset transient storage (EIP-1153) -func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, dst *common.Address, precompiles []common.Address, list types.accessList) { +func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, dst *common.Address, precompiles []common.Address, list types.AccessList) { if rules.IsBerlin { // Clear out any leftover from previous executions - al := NewaccessList() + al := NewAccessList() s.accessList = al al.AddAddress(sender) @@ -1126,15 +1126,15 @@ func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, d s.transientStorage = newTransientStorage() } -// AddAddressToaccessList adds the given address to the access list -func (s *StateDB) AddAddressToaccessList(addr common.Address) { +// AddAddressToAccessList adds the given address to the access list +func (s *StateDB) AddAddressToAccessList(addr common.Address) { if s.accessList.AddAddress(addr) { s.journal.append(accessListAddAccountChange{&addr}) } } -// AddSlotToaccessList adds the given (address, slot)-tuple to the access list -func (s *StateDB) AddSlotToaccessList(addr common.Address, slot common.Hash) { +// AddSlotToAccessList adds the given (address, slot)-tuple to the access list +func (s *StateDB) AddSlotToAccessList(addr common.Address, slot common.Hash) { addrMod, slotMod := s.accessList.AddSlot(addr, slot) if addrMod { // In practice, this should not happen, since there is no way to enter the @@ -1151,13 +1151,13 @@ func (s *StateDB) AddSlotToaccessList(addr common.Address, slot common.Hash) { } } -// AddressInaccessList returns true if the given address is in the access list. -func (s *StateDB) AddressInaccessList(addr common.Address) bool { +// AddressInAccessList returns true if the given address is in the access list. +func (s *StateDB) AddressInAccessList(addr common.Address) bool { return s.accessList.ContainsAddress(addr) } -// SlotInaccessList returns true if the given (address, slot)-tuple is in the access list. -func (s *StateDB) SlotInaccessList(addr common.Address, slot common.Hash) (addressPresent bool, slotPresent bool) { +// SlotInAccessList returns true if the given (address, slot)-tuple is in the access list. +func (s *StateDB) SlotInAccessList(addr common.Address, slot common.Hash) (addressPresent bool, slotPresent bool) { return s.accessList.Contains(addr, slot) } diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index eaf2c4dc9912..f8fc4ac20a22 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -763,7 +763,7 @@ func TestStateDBAccessList(t *testing.T) { memDb := rawdb.NewMemoryDatabase() db := NewDatabase(memDb) state, _ := New(common.Hash{}, db, nil) - state.AccessList = NewAccessList() + state.accessList = NewAccessList() verifyAddrs := func(astrings ...string) { t.Helper() @@ -782,7 +782,7 @@ func TestStateDBAccessList(t *testing.T) { } } // Check that only the expected addresses are present in the access list - for address := range state.AccessList.addresses { + for address := range state.accessList.addresses { if _, exist := addressMap[address]; !exist { t.Fatalf("extra address %x in access list", address) } @@ -808,9 +808,9 @@ func TestStateDBAccessList(t *testing.T) { } } // Check that no extra elements are in the access list - index := state.AccessList.addresses[address] + index := state.accessList.addresses[address] if index >= 0 { - stateSlots := state.AccessList.slots[index] + stateSlots := state.accessList.slots[index] for s := range stateSlots { if _, slotPresent := slotMap[s]; !slotPresent { t.Fatalf("scope has extra slot %v (address %v)", s, addrString) @@ -906,10 +906,10 @@ func TestStateDBAccessList(t *testing.T) { if state.AddressInAccessList(addr("aa")) { t.Fatalf("addr present, expected missing") } - if got, exp := len(state.AccessList.addresses), 0; got != exp { + if got, exp := len(state.accessList.addresses), 0; got != exp { t.Fatalf("expected empty, got %d", got) } - if got, exp := len(state.AccessList.slots), 0; got != exp { + if got, exp := len(state.accessList.slots), 0; got != exp { t.Fatalf("expected empty, got %d", got) } // Check the copy @@ -917,10 +917,10 @@ func TestStateDBAccessList(t *testing.T) { state = stateCopy1 verifyAddrs("aa", "bb") verifySlots("bb", "01", "02") - if got, exp := len(state.AccessList.addresses), 2; got != exp { + if got, exp := len(state.accessList.addresses), 2; got != exp { t.Fatalf("expected empty, got %d", got) } - if got, exp := len(state.AccessList.slots), 1; got != exp { + if got, exp := len(state.accessList.slots), 1; got != exp { t.Fatalf("expected empty, got %d", got) } } From 4f5848e91105163fa3c6b23644577359e78fb813 Mon Sep 17 00:00:00 2001 From: Devon Bear Date: Thu, 23 Feb 2023 14:08:04 -0500 Subject: [PATCH 47/51] ethpub --- core/types/transaction_signing.go | 81 +++++++++++++++++++++++++++++-- ethclient/signer.go | 5 ++ 2 files changed, 81 insertions(+), 5 deletions(-) diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go index 87f0390a6f9c..3e232fd84a66 100644 --- a/core/types/transaction_signing.go +++ b/core/types/transaction_signing.go @@ -157,6 +157,9 @@ type Signer interface { // Sender returns the sender address of the transaction. Sender(tx *Transaction) (common.Address, error) + // PubKey returns the public key of the sender. + PubKey(tx *Transaction) ([]byte, error) + // SignatureValues returns the raw R, S, V values corresponding to the // given signature. SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error) @@ -195,6 +198,20 @@ func (s londonSigner) Sender(tx *Transaction) (common.Address, error) { return recoverPlain(s.Hash(tx), R, S, V, true) } +func (s londonSigner) PubKey(tx *Transaction) ([]byte, error) { + if tx.Type() != DynamicFeeTxType { + return s.eip2930Signer.PubKey(tx) + } + V, R, S := tx.RawSignatureValues() + // DynamicFee txs are defined to use 0 and 1 as their recovery + // id, add 27 to become equivalent to unprotected Homestead signatures. + V = new(big.Int).Add(V, big.NewInt(27)) + if tx.ChainId().Cmp(s.chainId) != 0 { + return nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId) + } + return recoverPub(s.Hash(tx), R, S, V, true) +} + func (s londonSigner) Equal(s2 Signer) bool { x, ok := s2.(londonSigner) return ok && x.chainId.Cmp(s.chainId) == 0 @@ -275,6 +292,28 @@ func (s eip2930Signer) Sender(tx *Transaction) (common.Address, error) { return recoverPlain(s.Hash(tx), R, S, V, true) } +func (s eip2930Signer) PubKey(tx *Transaction) ([]byte, error) { + V, R, S := tx.RawSignatureValues() + switch tx.Type() { + case LegacyTxType: + if !tx.Protected() { + return HomesteadSigner{}.PubKey(tx) + } + V = new(big.Int).Sub(V, s.chainIdMul) + V.Sub(V, big8) + case AccessListTxType: + // AL txs are defined to use 0 and 1 as their recovery + // id, add 27 to become equivalent to unprotected Homestead signatures. + V = new(big.Int).Add(V, big.NewInt(27)) + default: + return nil, ErrTxTypeNotSupported + } + if tx.ChainId().Cmp(s.chainId) != 0 { + return nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId) + } + return recoverPub(s.Hash(tx), R, S, V, true) +} + func (s eip2930Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) { switch txdata := tx.inner.(type) { case *LegacyTx: @@ -372,6 +411,22 @@ func (s EIP155Signer) Sender(tx *Transaction) (common.Address, error) { return recoverPlain(s.Hash(tx), R, S, V, true) } +func (s EIP155Signer) PubKey(tx *Transaction) ([]byte, error) { + if tx.Type() != LegacyTxType { + return nil, ErrTxTypeNotSupported + } + if !tx.Protected() { + return HomesteadSigner{}.PubKey(tx) + } + if tx.ChainId().Cmp(s.chainId) != 0 { + return nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId) + } + V, R, S := tx.RawSignatureValues() + V = new(big.Int).Sub(V, s.chainIdMul) + V.Sub(V, big8) + return recoverPub(s.Hash(tx), R, S, V, true) +} + // SignatureValues returns signature values. This signature // needs to be in the [R || S || V] format where V is 0 or 1. func (s EIP155Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) { @@ -448,6 +503,14 @@ func (fs FrontierSigner) Sender(tx *Transaction) (common.Address, error) { return recoverPlain(fs.Hash(tx), r, s, v, false) } +func (fs FrontierSigner) PubKey(tx *Transaction) ([]byte, error) { + if tx.Type() != LegacyTxType { + return nil, ErrTxTypeNotSupported + } + v, r, s := tx.RawSignatureValues() + return recoverPub(fs.Hash(tx), r, s, v, false) +} + // SignatureValues returns signature values. This signature // needs to be in the [R || S || V] format where V is 0 or 1. func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error) { @@ -481,13 +544,13 @@ func decodeSignature(sig []byte) (r, s, v *big.Int) { return r, s, v } -func recoverPlain(sighash common.Hash, R, S, Vb *big.Int, homestead bool) (common.Address, error) { +func recoverPub(sighash common.Hash, R, S, Vb *big.Int, homestead bool) ([]byte, error) { if Vb.BitLen() > 8 { - return common.Address{}, ErrInvalidSig + return nil, ErrInvalidSig } V := byte(Vb.Uint64() - 27) if !crypto.ValidateSignatureValues(V, R, S, homestead) { - return common.Address{}, ErrInvalidSig + return nil, ErrInvalidSig } // encode the signature in uncompressed format r, s := R.Bytes(), S.Bytes() @@ -498,10 +561,18 @@ func recoverPlain(sighash common.Hash, R, S, Vb *big.Int, homestead bool) (commo // recover the public key from the signature pub, err := crypto.Ecrecover(sighash[:], sig) if err != nil { - return common.Address{}, err + return nil, err } if len(pub) == 0 || pub[0] != 4 { - return common.Address{}, errors.New("invalid public key") + return nil, errors.New("invalid public key") + } + return pub, nil +} + +func recoverPlain(sighash common.Hash, R, S, Vb *big.Int, homestead bool) (common.Address, error) { + pub, err := recoverPub(sighash, R, S, Vb, homestead) + if err != nil { + return common.Address{}, err } var addr common.Address copy(addr[:], crypto.Keccak256(pub[1:])[12:]) diff --git a/ethclient/signer.go b/ethclient/signer.go index f827d4eb56f4..8df14a5755de 100644 --- a/ethclient/signer.go +++ b/ethclient/signer.go @@ -51,6 +51,11 @@ func (s *senderFromServer) Sender(tx *types.Transaction) (common.Address, error) return s.addr, nil } +func (s *senderFromServer) PubKey(tx *types.Transaction) ([]byte, error) { + // not implemented + return nil, nil +} + func (s *senderFromServer) ChainID() *big.Int { panic("can't sign with senderFromServer") } From 18bf66da80d79077f44b6cb703d4935686bd2f52 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Thu, 23 Feb 2023 16:48:05 -0500 Subject: [PATCH 48/51] use the StateDB interface in the API --- core/state/interface.go | 93 +++++++++++++++++++++++++++++++++ core/state/statedb.go | 2 +- core/state/statedb_test.go | 10 ++-- core/vm/interface.go | 58 +------------------- eth/tracers/api.go | 6 +-- ethapi/api.go | 3 +- ethapi/backend.go | 7 ++- ethapi/transaction_args_test.go | 6 +-- 8 files changed, 111 insertions(+), 74 deletions(-) create mode 100644 core/state/interface.go diff --git a/core/state/interface.go b/core/state/interface.go new file mode 100644 index 000000000000..2b04a2f747e6 --- /dev/null +++ b/core/state/interface.go @@ -0,0 +1,93 @@ +// Copyright 2014 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 . + +// Package state provides a caching layer atop the Ethereum state trie. + +package state + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/params" +) + +// StateDBI is an EVM database for full state querying. +type StateDBI interface { + CreateAccount(common.Address) + + SubBalance(common.Address, *big.Int) + AddBalance(common.Address, *big.Int) + GetBalance(common.Address) *big.Int + + GetNonce(common.Address) uint64 + SetNonce(common.Address, uint64) + + GetCodeHash(common.Address) common.Hash + GetCode(common.Address) []byte + SetCode(common.Address, []byte) + GetCodeSize(common.Address) int + + AddRefund(uint64) + SubRefund(uint64) + GetRefund() uint64 + + GetCommittedState(common.Address, common.Hash) common.Hash + GetState(common.Address, common.Hash) common.Hash + SetState(common.Address, common.Hash, common.Hash) + + GetTransientState(addr common.Address, key common.Hash) common.Hash + SetTransientState(addr common.Address, key, value common.Hash) + + Suicide(common.Address) bool + HasSuicided(common.Address) bool + + // Exist reports whether the given account exists in state. + // Notably this should also return true for suicided accounts. + Exist(common.Address) bool + // Empty returns whether the given account is empty. Empty + // is defined according to EIP161 (balance = nonce = code = 0). + Empty(common.Address) bool + + AddressInAccessList(addr common.Address) bool + SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool) + // AddAddressToAccessList adds the given address to the access list. This operation is safe to perform + // even if the feature/fork is not active yet + AddAddressToAccessList(addr common.Address) + // AddSlotToAccessList adds the given (address,slot) to the access list. This operation is safe to perform + // even if the feature/fork is not active yet + AddSlotToAccessList(addr common.Address, slot common.Hash) + Prepare(rules params.Rules, sender, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList) + + RevertToSnapshot(int) + Snapshot() int + + AddLog(*types.Log) + AddPreimage(common.Hash, []byte) + + ForEachStorage(common.Address, func(common.Hash, common.Hash) bool) error + + StorageTrie(addr common.Address) (Trie, error) + Error() error + GetStorageProof(a common.Address, key common.Hash) ([][]byte, error) + GetProof(addr common.Address) ([][]byte, error) + SetBalance(addr common.Address, amount *big.Int) + SetStorage(addr common.Address, storage map[common.Hash]common.Hash) + Finalise(deleteEmptyObjects bool) + Copy() StateDBI + SetTxContext(thash common.Hash, ti int) +} diff --git a/core/state/statedb.go b/core/state/statedb.go index 58445a5baa45..18432bd70b6a 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -699,7 +699,7 @@ func (db *StateDB) ForEachStorage(addr common.Address, cb func(key, value common // Copy creates a deep, independent copy of the state. // Snapshots of the copied state cannot be applied to the copy. -func (s *StateDB) Copy() *StateDB { +func (s *StateDB) Copy() StateDBI { // Copy all the basic fields, initialize the memory ones state := &StateDB{ db: s.db, diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index f8fc4ac20a22..b25976815a22 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -159,10 +159,10 @@ func TestCopy(t *testing.T) { orig.Finalise(false) // Copy the state - copy := orig.Copy() + copy := orig.Copy().(*StateDB) // Copy the copy state - ccopy := copy.Copy() + ccopy := copy.Copy().(*StateDB) // modify all in memory for i := byte(0); i < 255; i++ { @@ -542,7 +542,7 @@ func TestCopyCommitCopy(t *testing.T) { t.Fatalf("initial committed storage slot mismatch: have %x, want %x", val, common.Hash{}) } // Copy the non-committed state database and check pre/post commit balance - copyOne := state.Copy() + copyOne := state.Copy().(*StateDB) if balance := copyOne.GetBalance(addr); balance.Cmp(big.NewInt(42)) != 0 { t.Fatalf("first copy pre-commit balance mismatch: have %v, want %v", balance, 42) } @@ -628,7 +628,7 @@ func TestCopyCopyCommitCopy(t *testing.T) { t.Fatalf("first copy committed storage slot mismatch: have %x, want %x", val, common.Hash{}) } // Copy the copy and check the balance once more - copyTwo := copyOne.Copy() + copyTwo := copyOne.Copy().(*StateDB) if balance := copyTwo.GetBalance(addr); balance.Cmp(big.NewInt(42)) != 0 { t.Fatalf("second copy pre-commit balance mismatch: have %v, want %v", balance, 42) } @@ -914,7 +914,7 @@ func TestStateDBAccessList(t *testing.T) { } // Check the copy // Make a copy - state = stateCopy1 + state = stateCopy1.(*StateDB) verifyAddrs("aa", "bb") verifySlots("bb", "01", "02") if got, exp := len(state.accessList.addresses), 2; got != exp { diff --git a/core/vm/interface.go b/core/vm/interface.go index 0ee32b1dd510..24ee2c04ffbd 100644 --- a/core/vm/interface.go +++ b/core/vm/interface.go @@ -20,65 +20,11 @@ import ( "math/big" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/core/state" ) // StateDB is an EVM database for full state querying. -type StateDB interface { - CreateAccount(common.Address) - - SubBalance(common.Address, *big.Int) - AddBalance(common.Address, *big.Int) - GetBalance(common.Address) *big.Int - - GetNonce(common.Address) uint64 - SetNonce(common.Address, uint64) - - GetCodeHash(common.Address) common.Hash - GetCode(common.Address) []byte - SetCode(common.Address, []byte) - GetCodeSize(common.Address) int - - AddRefund(uint64) - SubRefund(uint64) - GetRefund() uint64 - - GetCommittedState(common.Address, common.Hash) common.Hash - GetState(common.Address, common.Hash) common.Hash - SetState(common.Address, common.Hash, common.Hash) - - GetTransientState(addr common.Address, key common.Hash) common.Hash - SetTransientState(addr common.Address, key, value common.Hash) - - Suicide(common.Address) bool - HasSuicided(common.Address) bool - - // Exist reports whether the given account exists in state. - // Notably this should also return true for suicided accounts. - Exist(common.Address) bool - // Empty returns whether the given account is empty. Empty - // is defined according to EIP161 (balance = nonce = code = 0). - Empty(common.Address) bool - - AddressInAccessList(addr common.Address) bool - SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool) - // AddAddressToAccessList adds the given address to the access list. This operation is safe to perform - // even if the feature/fork is not active yet - AddAddressToAccessList(addr common.Address) - // AddSlotToAccessList adds the given (address,slot) to the access list. This operation is safe to perform - // even if the feature/fork is not active yet - AddSlotToAccessList(addr common.Address, slot common.Hash) - Prepare(rules params.Rules, sender, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList) - - RevertToSnapshot(int) - Snapshot() int - - AddLog(*types.Log) - AddPreimage(common.Hash, []byte) - - ForEachStorage(common.Address, func(common.Hash, common.Hash) bool) error -} +type StateDB = state.StateDBI // CallContext provides a basic interface for the EVM calling conventions. The EVM // depends on this context being implemented for doing subcalls and initialising new EVM contracts. diff --git a/eth/tracers/api.go b/eth/tracers/api.go index 6dca581ed74c..4814b0066663 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -207,7 +207,7 @@ type txTraceResult struct { // blockTraceTask represents a single block trace task when an entire chain is // being traced. type blockTraceTask struct { - statedb *state.StateDB // Intermediate state prepped for tracing + statedb state.StateDBI // Intermediate state prepped for tracing block *types.Block // Block to trace the transactions from release StateReleaseFunc // The function to release the held resource for this task results []*txTraceResult // Trace results produced by the task @@ -224,7 +224,7 @@ type blockTraceResult struct { // txTraceTask represents a single transaction trace task when an entire block // is being traced. type txTraceTask struct { - statedb *state.StateDB // Intermediate state prepped for tracing + statedb state.StateDBI // Intermediate state prepped for tracing index int // Transaction offset in the block } @@ -943,7 +943,7 @@ func (api *API) TraceCall(ctx context.Context, args ethapi.TransactionArgs, bloc // traceTx configures a new tracer according to the provided configuration, and // executes the given message in the provided environment. The return value will // be tracer dependent. -func (api *API) traceTx(ctx context.Context, message core.Message, txctx *Context, vmctx vm.BlockContext, statedb *state.StateDB, config *TraceConfig) (interface{}, error) { +func (api *API) traceTx(ctx context.Context, message core.Message, txctx *Context, vmctx vm.BlockContext, statedb state.StateDBI, config *TraceConfig) (interface{}, error) { var ( tracer Tracer err error diff --git a/ethapi/api.go b/ethapi/api.go index 58f65f86d794..904f776393b5 100644 --- a/ethapi/api.go +++ b/ethapi/api.go @@ -36,7 +36,6 @@ import ( "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/consensus/misc" "github.com/ethereum/go-ethereum/core" - "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" @@ -878,7 +877,7 @@ type OverrideAccount struct { type StateOverride map[common.Address]OverrideAccount // Apply overrides the fields of specified accounts into the given state. -func (diff *StateOverride) Apply(state *state.StateDB) error { +func (diff *StateOverride) Apply(state vm.StateDB) error { if diff == nil { return nil } diff --git a/ethapi/backend.go b/ethapi/backend.go index 0c1763472f2d..d7e4f7e48a03 100644 --- a/ethapi/backend.go +++ b/ethapi/backend.go @@ -28,7 +28,6 @@ import ( "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/bloombits" - "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/ethdb" @@ -63,12 +62,12 @@ type Backend interface { BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error) - StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) - StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) + StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (vm.StateDB, *types.Header, error) + StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (vm.StateDB, *types.Header, error) PendingBlockAndReceipts() (*types.Block, types.Receipts) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) GetTd(ctx context.Context, hash common.Hash) *big.Int - GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error) + GetEVM(ctx context.Context, msg core.Message, state vm.StateDB, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription diff --git a/ethapi/transaction_args_test.go b/ethapi/transaction_args_test.go index a8f2d5214889..773b0377bde0 100644 --- a/ethapi/transaction_args_test.go +++ b/ethapi/transaction_args_test.go @@ -291,10 +291,10 @@ func (b *backendMock) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc func (b *backendMock) GetBody(ctx context.Context, hash common.Hash, number rpc.BlockNumber) (*types.Body, error) { return nil, nil } -func (b *backendMock) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) { +func (b *backendMock) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (state.StateDBI, *types.Header, error) { return nil, nil, nil } -func (b *backendMock) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) { +func (b *backendMock) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (state.StateDBI, *types.Header, error) { return nil, nil, nil } func (b *backendMock) PendingBlockAndReceipts() (*types.Block, types.Receipts) { return nil, nil } @@ -305,7 +305,7 @@ func (b *backendMock) GetLogs(ctx context.Context, blockHash common.Hash, number return nil, nil } func (b *backendMock) GetTd(ctx context.Context, hash common.Hash) *big.Int { return nil } -func (b *backendMock) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error) { +func (b *backendMock) GetEVM(ctx context.Context, msg core.Message, state state.StateDBI, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error) { return nil, nil, nil } func (b *backendMock) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription { return nil } From e133c763c3c9b2aa93eb861a57dc0d9976f2ea00 Mon Sep 17 00:00:00 2001 From: Cal Bera Date: Fri, 24 Feb 2023 12:00:58 -0500 Subject: [PATCH 49/51] make compatible --- accounts/abi/bind/backends/simulated.go | 6 +- cmd/evm/internal/t8ntool/execution.go | 4 +- cmd/evm/runner.go | 2 +- consensus/beacon/consensus.go | 4 +- consensus/clique/clique.go | 4 +- consensus/consensus.go | 4 +- consensus/ethash/consensus.go | 6 +- consensus/misc/dao.go | 2 +- core/block_validator.go | 2 +- core/blockchain.go | 10 +- core/blockchain_reader.go | 4 +- core/chain_makers.go | 6 +- core/state/interface.go | 15 +++ core/state/journal.go | 2 +- core/state/state_object.go | 92 +++++++------- core/state/state_test.go | 2 +- core/state/statedb.go | 134 ++++++++++---------- core/state_prefetcher.go | 4 +- core/state_processor.go | 6 +- core/txpool/noncer.go | 4 +- core/txpool/txpool.go | 4 +- core/txpool/txpool_test.go | 6 +- core/types.go | 6 +- core/vm/instructions_test.go | 2 +- core/vm/runtime/runtime.go | 4 +- eth/api.go | 2 +- eth/api_backend.go | 10 +- eth/api_test.go | 2 +- eth/state_accessor.go | 4 +- eth/tracers/api.go | 8 +- eth/tracers/api_test.go | 4 +- graphql/graphql.go | 2 +- les/api_backend.go | 10 +- les/odr_test.go | 2 +- les/state_accessor.go | 4 +- light/odr_test.go | 4 +- light/trie.go | 2 +- light/txpool.go | 2 +- miner/miner.go | 2 +- miner/miner_test.go | 6 +- miner/worker.go | 8 +- miner/worker_test.go | 2 +- tests/block_test_util.go | 2 +- tests/fuzzers/bls12381/precompile_fuzzer.go | 3 +- tests/state_test_util.go | 6 +- 45 files changed, 218 insertions(+), 202 deletions(-) diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go index 008c71feaa7a..91709100c412 100644 --- a/accounts/abi/bind/backends/simulated.go +++ b/accounts/abi/bind/backends/simulated.go @@ -65,7 +65,7 @@ type SimulatedBackend struct { mu sync.Mutex pendingBlock *types.Block // Currently pending block that will be imported on request - pendingState *state.StateDB // Currently pending state that will be the active on request + pendingState state.StateDBI // Currently pending state that will be the active on request pendingReceipts types.Receipts // Currently receipts for the pending block events *filters.EventSystem // for filtering log events live @@ -173,7 +173,7 @@ func (b *SimulatedBackend) Fork(ctx context.Context, parent common.Hash) error { } // stateByBlockNumber retrieves a state by a given blocknumber. -func (b *SimulatedBackend) stateByBlockNumber(ctx context.Context, blockNumber *big.Int) (*state.StateDB, error) { +func (b *SimulatedBackend) stateByBlockNumber(ctx context.Context, blockNumber *big.Int) (state.StateDBI, error) { if blockNumber == nil || blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) == 0 { return b.blockchain.State() } @@ -599,7 +599,7 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs // callContract implements common code between normal and pending contract calls. // state is modified during execution, make sure to copy it if necessary. -func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, stateDB *state.StateDB) (*core.ExecutionResult, error) { +func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, stateDB state.StateDBI) (*core.ExecutionResult, error) { // Gas prices post 1559 need to be initialized if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) { return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified") diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go index 2c68659945eb..66dc65c566bf 100644 --- a/cmd/evm/internal/t8ntool/execution.go +++ b/cmd/evm/internal/t8ntool/execution.go @@ -108,7 +108,7 @@ type rejectedTx struct { // Apply applies a set of transactions to a pre-state func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, txs types.Transactions, miningReward int64, - getTracerFn func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error)) (*state.StateDB, *ExecutionResult, error) { + getTracerFn func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error)) (state.StateDBI, *ExecutionResult, error) { // Capture errors for BLOCKHASH operation, if we haven't been supplied the // required blockhashes var hashError error @@ -287,7 +287,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, return statedb, execRs, nil } -func MakePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB { +func MakePreState(db ethdb.Database, accounts core.GenesisAlloc) state.StateDBI { sdb := state.NewDatabaseWithConfig(db, &trie.Config{Preimages: true}) statedb, _ := state.New(common.Hash{}, sdb, nil) for addr, a := range accounts { diff --git a/cmd/evm/runner.go b/cmd/evm/runner.go index 3a010da9f2dc..ce84f0cc28de 100644 --- a/cmd/evm/runner.go +++ b/cmd/evm/runner.go @@ -120,7 +120,7 @@ func runCmd(ctx *cli.Context) error { var ( tracer vm.EVMLogger debugLogger *logger.StructLogger - statedb *state.StateDB + statedb state.StateDBI chainConfig *params.ChainConfig sender = common.BytesToAddress([]byte("sender")) receiver = common.BytesToAddress([]byte("receiver")) diff --git a/consensus/beacon/consensus.go b/consensus/beacon/consensus.go index eb5aa58ca887..0a59c296dd8a 100644 --- a/consensus/beacon/consensus.go +++ b/consensus/beacon/consensus.go @@ -327,7 +327,7 @@ func (beacon *Beacon) Prepare(chain consensus.ChainHeaderReader, header *types.H } // Finalize implements consensus.Engine, setting the final state on the header -func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) { +func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state state.StateDBI, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) { // Finalize is different with Prepare, it can be used in both block generation // and verification. So determine the consensus rules by header type. if !beacon.IsPoSHeader(header) { @@ -348,7 +348,7 @@ func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types. // FinalizeAndAssemble implements consensus.Engine, setting the final state and // assembling the block. -func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) { +func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state state.StateDBI, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) { // FinalizeAndAssemble is different with Prepare, it can be used in both block // generation and verification. So determine the consensus rules by header type. if !beacon.IsPoSHeader(header) { diff --git a/consensus/clique/clique.go b/consensus/clique/clique.go index 4706bbac1ca9..e25fa2d869c4 100644 --- a/consensus/clique/clique.go +++ b/consensus/clique/clique.go @@ -567,7 +567,7 @@ func (c *Clique) Prepare(chain consensus.ChainHeaderReader, header *types.Header // Finalize implements consensus.Engine, ensuring no uncles are set, nor block // rewards given. -func (c *Clique) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) { +func (c *Clique) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state state.StateDBI, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) { // No block rewards in PoA, so the state remains as is and uncles are dropped header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) header.UncleHash = types.CalcUncleHash(nil) @@ -575,7 +575,7 @@ func (c *Clique) Finalize(chain consensus.ChainHeaderReader, header *types.Heade // FinalizeAndAssemble implements consensus.Engine, ensuring no uncles are set, // nor block rewards given, and returns the final block. -func (c *Clique) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) { +func (c *Clique) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state state.StateDBI, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) { if len(withdrawals) > 0 { return nil, errors.New("clique does not support withdrawals") } diff --git a/consensus/consensus.go b/consensus/consensus.go index 190d5ae12c8a..31cf037aaf36 100644 --- a/consensus/consensus.go +++ b/consensus/consensus.go @@ -89,7 +89,7 @@ type Engine interface { // // Note: The block header and state database might be updated to reflect any // consensus rules that happen at finalization (e.g. block rewards). - Finalize(chain ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, + Finalize(chain ChainHeaderReader, header *types.Header, state state.StateDBI, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) // FinalizeAndAssemble runs any post-transaction state modifications (e.g. block @@ -97,7 +97,7 @@ type Engine interface { // // Note: The block header and state database might be updated to reflect any // consensus rules that happen at finalization (e.g. block rewards). - FinalizeAndAssemble(chain ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, + FinalizeAndAssemble(chain ChainHeaderReader, header *types.Header, state state.StateDBI, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) // Seal generates a new sealing request for the given input block and pushes diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go index da29e16597b6..705756a9f617 100644 --- a/consensus/ethash/consensus.go +++ b/consensus/ethash/consensus.go @@ -600,7 +600,7 @@ func (ethash *Ethash) Prepare(chain consensus.ChainHeaderReader, header *types.H // Finalize implements consensus.Engine, accumulating the block and uncle rewards, // setting the final state on the header -func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) { +func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state state.StateDBI, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) { // Accumulate any block and uncle rewards and commit the final state root accumulateRewards(chain.Config(), state, header, uncles) header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) @@ -608,7 +608,7 @@ func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types. // FinalizeAndAssemble implements consensus.Engine, accumulating the block and // uncle rewards, setting the final state and assembling the block. -func (ethash *Ethash) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) { +func (ethash *Ethash) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state state.StateDBI, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) { if len(withdrawals) > 0 { return nil, errors.New("ethash does not support withdrawals") } @@ -658,7 +658,7 @@ var ( // AccumulateRewards credits the coinbase of the given block with the mining // reward. The total reward consists of the static block reward and rewards for // included uncles. The coinbase of each uncle block is also rewarded. -func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) { +func accumulateRewards(config *params.ChainConfig, state state.StateDBI, header *types.Header, uncles []*types.Header) { // Select the correct block reward based on chain progression blockReward := FrontierBlockReward if config.IsByzantium(header.Number) { diff --git a/consensus/misc/dao.go b/consensus/misc/dao.go index 96995616de56..d436303c983e 100644 --- a/consensus/misc/dao.go +++ b/consensus/misc/dao.go @@ -72,7 +72,7 @@ func VerifyDAOHeaderExtraData(config *params.ChainConfig, header *types.Header) // ApplyDAOHardFork modifies the state database according to the DAO hard-fork // rules, transferring all balances of a set of DAO accounts to a single refund // contract. -func ApplyDAOHardFork(statedb *state.StateDB) { +func ApplyDAOHardFork(statedb state.StateDBI) { // Retrieve the contract to refund balances into if !statedb.Exist(params.DAORefundContract) { statedb.CreateAccount(params.DAORefundContract) diff --git a/core/block_validator.go b/core/block_validator.go index db7ea3568723..a79d1db978cf 100644 --- a/core/block_validator.go +++ b/core/block_validator.go @@ -94,7 +94,7 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error { // transition, such as amount of used gas, the receipt roots and the state root // itself. ValidateState returns a database batch if the validation was a success // otherwise nil and an error is returned. -func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas uint64) error { +func (v *BlockValidator) ValidateState(block *types.Block, statedb state.StateDBI, receipts types.Receipts, usedGas uint64) error { header := block.Header() if block.GasUsed() != usedGas { return fmt.Errorf("invalid gas used (remote: %d local: %d)", block.GasUsed(), usedGas) diff --git a/core/blockchain.go b/core/blockchain.go index 98d2e7a774ad..ca607f2bd012 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -1315,7 +1315,7 @@ func (bc *BlockChain) writeKnownBlock(block *types.Block) error { // writeBlockWithState writes block, metadata and corresponding state data to the // database. -func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) error { +func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, state state.StateDBI) error { // Calculate the total difficulty of the block ptd := bc.GetTd(block.ParentHash(), block.NumberU64()-1) if ptd == nil { @@ -1398,7 +1398,7 @@ func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types. // WriteBlockAndSetHead writes the given block and all associated state to the database, // and applies the block as the new chain head. -func (bc *BlockChain) WriteBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) { +func (bc *BlockChain) WriteBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state state.StateDBI, emitHeadEvent bool) (status WriteStatus, err error) { if !bc.chainmu.TryLock() { return NonStatTy, errChainStopped } @@ -1409,7 +1409,7 @@ func (bc *BlockChain) WriteBlockAndSetHead(block *types.Block, receipts []*types // writeBlockAndSetHead is the internal implementation of WriteBlockAndSetHead. // This function expects the chain mutex to be held. -func (bc *BlockChain) writeBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) { +func (bc *BlockChain) writeBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state state.StateDBI, emitHeadEvent bool) (status WriteStatus, err error) { if err := bc.writeBlockWithState(block, receipts, state); err != nil { return NonStatTy, err } @@ -1638,7 +1638,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals, setHead bool) return it.index, err } // No validation errors for the first block (or chain prefix skipped) - var activeState *state.StateDB + var activeState state.StateDBI defer func() { // The chain importer is starting and stopping trie prefetchers. If a bad // block or other error is hit however, an early return may not properly @@ -1722,7 +1722,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals, setHead bool) if followup, err := it.peek(); followup != nil && err == nil { throwaway, _ := state.New(parent.Root, bc.stateCache, bc.snaps) - go func(start time.Time, followup *types.Block, throwaway *state.StateDB, interrupt *uint32) { + go func(start time.Time, followup *types.Block, throwaway state.StateDBI, interrupt *uint32) { bc.prefetcher.Prefetch(followup, throwaway, bc.vmConfig, &followupInterrupt) blockPrefetchExecuteTimer.Update(time.Since(start)) diff --git a/core/blockchain_reader.go b/core/blockchain_reader.go index e8a5d952a240..0d8000ac125a 100644 --- a/core/blockchain_reader.go +++ b/core/blockchain_reader.go @@ -314,12 +314,12 @@ func (bc *BlockChain) ContractCodeWithPrefix(hash common.Hash) ([]byte, error) { } // State returns a new mutable state based on the current HEAD block. -func (bc *BlockChain) State() (*state.StateDB, error) { +func (bc *BlockChain) State() (state.StateDBI, error) { return bc.StateAt(bc.CurrentBlock().Root()) } // StateAt returns a new mutable state based on a particular point in time. -func (bc *BlockChain) StateAt(root common.Hash) (*state.StateDB, error) { +func (bc *BlockChain) StateAt(root common.Hash) (state.StateDBI, error) { return state.New(root, bc.stateCache, bc.snaps) } diff --git a/core/chain_makers.go b/core/chain_makers.go index 3518929f8e71..5e71b28111d9 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -39,7 +39,7 @@ type BlockGen struct { parent *types.Block chain []*types.Block header *types.Header - statedb *state.StateDB + statedb state.StateDBI gasPool *GasPool txs []*types.Transaction @@ -269,7 +269,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse } blocks, receipts := make(types.Blocks, n), make([]types.Receipts, n) chainreader := &fakeChainReader{config: config} - genblock := func(i int, parent *types.Block, statedb *state.StateDB) (*types.Block, types.Receipts) { + genblock := func(i int, parent *types.Block, statedb state.StateDBI) (*types.Block, types.Receipts) { b := &BlockGen{i: i, chain: blocks, parent: parent, statedb: statedb, config: config, engine: engine} b.header = makeHeader(chainreader, parent, statedb, b.engine) @@ -345,7 +345,7 @@ func GenerateChainWithGenesis(genesis *Genesis, engine consensus.Engine, n int, return db, blocks, receipts } -func makeHeader(chain consensus.ChainReader, parent *types.Block, state *state.StateDB, engine consensus.Engine) *types.Header { +func makeHeader(chain consensus.ChainReader, parent *types.Block, state state.StateDBI, engine consensus.Engine) *types.Header { var time uint64 if parent.Time() == 0 { time = 10 diff --git a/core/state/interface.go b/core/state/interface.go index 2b04a2f747e6..0f8b797344d2 100644 --- a/core/state/interface.go +++ b/core/state/interface.go @@ -77,10 +77,21 @@ type StateDBI interface { Snapshot() int AddLog(*types.Log) + Logs() []*types.Log + GetLogs(hash common.Hash, blockNumber uint64, blockHash common.Hash) []*types.Log + TxIndex() int AddPreimage(common.Hash, []byte) + Preimages() map[common.Hash][]byte ForEachStorage(common.Address, func(common.Hash, common.Hash) bool) error + GetOrNewStateObject(addr common.Address) *StateObject + + DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey []byte) + Dump(opts *DumpConfig) []byte + RawDump(opts *DumpConfig) Dump + IteratorDump(opts *DumpConfig) IteratorDump + Database() Database StorageTrie(addr common.Address) (Trie, error) Error() error GetStorageProof(a common.Address, key common.Hash) ([][]byte, error) @@ -88,6 +99,10 @@ type StateDBI interface { SetBalance(addr common.Address, amount *big.Int) SetStorage(addr common.Address, storage map[common.Hash]common.Hash) Finalise(deleteEmptyObjects bool) + Commit(deleteEmptyObjects bool) (common.Hash, error) Copy() StateDBI SetTxContext(thash common.Hash, ti int) + StopPrefetcher() + StartPrefetcher(namespace string) + IntermediateRoot(deleteEmptyObjects bool) common.Hash } diff --git a/core/state/journal.go b/core/state/journal.go index 1722fb4c02e1..5feb6bb05c61 100644 --- a/core/state/journal.go +++ b/core/state/journal.go @@ -90,7 +90,7 @@ type ( account *common.Address } resetObjectChange struct { - prev *stateObject + prev *StateObject prevdestruct bool } suicideChange struct { diff --git a/core/state/state_object.go b/core/state/state_object.go index 1550926d3a62..2f32e243a65b 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -58,13 +58,13 @@ func (s Storage) Copy() Storage { return cpy } -// stateObject represents an Ethereum account which is being modified. +// StateObject represents an Ethereum account which is being modified. // // The usage pattern is as follows: // First you need to obtain a state object. // Account values can be accessed and modified through the object. // Finally, call commitTrie to write the modified storage trie into a database. -type stateObject struct { +type StateObject struct { address common.Address addrHash common.Hash // hash of ethereum address of the account data types.StateAccount @@ -94,12 +94,12 @@ type stateObject struct { } // empty returns whether the account is considered empty. -func (s *stateObject) empty() bool { +func (s *StateObject) empty() bool { return s.data.Nonce == 0 && s.data.Balance.Sign() == 0 && bytes.Equal(s.data.CodeHash, emptyCodeHash) } // newObject creates a state object. -func newObject(db *StateDB, address common.Address, data types.StateAccount) *stateObject { +func newObject(db *StateDB, address common.Address, data types.StateAccount) *StateObject { if data.Balance == nil { data.Balance = new(big.Int) } @@ -109,7 +109,7 @@ func newObject(db *StateDB, address common.Address, data types.StateAccount) *st if data.Root == (common.Hash{}) { data.Root = emptyRoot } - return &stateObject{ + return &StateObject{ db: db, address: address, addrHash: crypto.Keccak256Hash(address[:]), @@ -121,22 +121,22 @@ func newObject(db *StateDB, address common.Address, data types.StateAccount) *st } // EncodeRLP implements rlp.Encoder. -func (s *stateObject) EncodeRLP(w io.Writer) error { +func (s *StateObject) EncodeRLP(w io.Writer) error { return rlp.Encode(w, &s.data) } // setError remembers the first non-nil error it is called with. -func (s *stateObject) setError(err error) { +func (s *StateObject) setError(err error) { if s.dbErr == nil { s.dbErr = err } } -func (s *stateObject) markSuicided() { +func (s *StateObject) markSuicided() { s.suicided = true } -func (s *stateObject) touch() { +func (s *StateObject) touch() { s.db.journal.append(touchChange{ account: &s.address, }) @@ -150,7 +150,7 @@ func (s *stateObject) touch() { // getTrie returns the associated storage trie. The trie will be opened // if it's not loaded previously. An error will be returned if trie can't // be loaded. -func (s *stateObject) getTrie(db Database) (Trie, error) { +func (s *StateObject) getTrie(db Database) (Trie, error) { if s.trie == nil { // Try fetching from prefetcher first // We don't prefetch empty tries @@ -171,7 +171,7 @@ func (s *stateObject) getTrie(db Database) (Trie, error) { } // GetState retrieves a value from the account storage trie. -func (s *stateObject) GetState(db Database, key common.Hash) common.Hash { +func (s *StateObject) GetState(db Database, key common.Hash) common.Hash { // If we have a dirty value for this state entry, return it value, dirty := s.dirtyStorage[key] if dirty { @@ -182,7 +182,7 @@ func (s *stateObject) GetState(db Database, key common.Hash) common.Hash { } // GetCommittedState retrieves a value from the committed account storage trie. -func (s *stateObject) GetCommittedState(db Database, key common.Hash) common.Hash { +func (s *StateObject) GetCommittedState(db Database, key common.Hash) common.Hash { // If we have a pending write or clean cached, return that if value, pending := s.pendingStorage[key]; pending { return value @@ -241,7 +241,7 @@ func (s *stateObject) GetCommittedState(db Database, key common.Hash) common.Has } // SetState updates a value in account storage. -func (s *stateObject) SetState(db Database, key, value common.Hash) { +func (s *StateObject) SetState(db Database, key, value common.Hash) { // If the new value is the same as old, don't set prev := s.GetState(db, key) if prev == value { @@ -256,13 +256,13 @@ func (s *stateObject) SetState(db Database, key, value common.Hash) { s.setState(key, value) } -func (s *stateObject) setState(key, value common.Hash) { +func (s *StateObject) setState(key, value common.Hash) { s.dirtyStorage[key] = value } // finalise moves all dirty storage slots into the pending area to be hashed or // committed later. It is invoked at the end of every transaction. -func (s *stateObject) finalise(prefetch bool) { +func (s *StateObject) finalise(prefetch bool) { slotsToPrefetch := make([][]byte, 0, len(s.dirtyStorage)) for key, value := range s.dirtyStorage { s.pendingStorage[key] = value @@ -281,7 +281,7 @@ func (s *stateObject) finalise(prefetch bool) { // updateTrie writes cached storage modifications into the object's storage trie. // It will return nil if the trie has not been loaded and no changes have been // made. An error will be returned if the trie can't be loaded/updated correctly. -func (s *stateObject) updateTrie(db Database) (Trie, error) { +func (s *StateObject) updateTrie(db Database) (Trie, error) { // Make sure all dirty slots are finalized into the pending storage area s.finalise(false) // Don't prefetch anymore, pull directly if need be if len(s.pendingStorage) == 0 { @@ -350,7 +350,7 @@ func (s *stateObject) updateTrie(db Database) (Trie, error) { // UpdateRoot sets the trie root to the current root hash of. An error // will be returned if trie root hash is not computed correctly. -func (s *stateObject) updateRoot(db Database) { +func (s *StateObject) updateRoot(db Database) { tr, err := s.updateTrie(db) if err != nil { s.setError(fmt.Errorf("updateRoot (%x) error: %w", s.address, err)) @@ -369,7 +369,7 @@ func (s *stateObject) updateRoot(db Database) { // commitTrie submits the storage changes into the storage trie and re-computes // the root. Besides, all trie changes will be collected in a nodeset and returned. -func (s *stateObject) commitTrie(db Database) (*trie.NodeSet, error) { +func (s *StateObject) commitTrie(db Database) (*trie.NodeSet, error) { tr, err := s.updateTrie(db) if err != nil { return nil, err @@ -392,7 +392,7 @@ func (s *stateObject) commitTrie(db Database) (*trie.NodeSet, error) { // AddBalance adds amount to s's balance. // It is used to add funds to the destination account of a transfer. -func (s *stateObject) AddBalance(amount *big.Int) { +func (s *StateObject) AddBalance(amount *big.Int) { // EIP161: We must check emptiness for the objects such that the account // clearing (0,0,0 objects) can take effect. if amount.Sign() == 0 { @@ -406,14 +406,14 @@ func (s *stateObject) AddBalance(amount *big.Int) { // SubBalance removes amount from s's balance. // It is used to remove funds from the origin account of a transfer. -func (s *stateObject) SubBalance(amount *big.Int) { +func (s *StateObject) SubBalance(amount *big.Int) { if amount.Sign() == 0 { return } s.SetBalance(new(big.Int).Sub(s.Balance(), amount)) } -func (s *stateObject) SetBalance(amount *big.Int) { +func (s *StateObject) SetBalance(amount *big.Int) { s.db.journal.append(balanceChange{ account: &s.address, prev: new(big.Int).Set(s.data.Balance), @@ -421,23 +421,23 @@ func (s *stateObject) SetBalance(amount *big.Int) { s.setBalance(amount) } -func (s *stateObject) setBalance(amount *big.Int) { +func (s *StateObject) setBalance(amount *big.Int) { s.data.Balance = amount } -func (s *stateObject) deepCopy(db *StateDB) *stateObject { - stateObject := newObject(db, s.address, s.data) +func (s *StateObject) deepCopy(db *StateDB) *StateObject { + StateObject := newObject(db, s.address, s.data) if s.trie != nil { - stateObject.trie = db.db.CopyTrie(s.trie) + StateObject.trie = db.db.CopyTrie(s.trie) } - stateObject.code = s.code - stateObject.dirtyStorage = s.dirtyStorage.Copy() - stateObject.originStorage = s.originStorage.Copy() - stateObject.pendingStorage = s.pendingStorage.Copy() - stateObject.suicided = s.suicided - stateObject.dirtyCode = s.dirtyCode - stateObject.deleted = s.deleted - return stateObject + StateObject.code = s.code + StateObject.dirtyStorage = s.dirtyStorage.Copy() + StateObject.originStorage = s.originStorage.Copy() + StateObject.pendingStorage = s.pendingStorage.Copy() + StateObject.suicided = s.suicided + StateObject.dirtyCode = s.dirtyCode + StateObject.deleted = s.deleted + return StateObject } // @@ -445,12 +445,12 @@ func (s *stateObject) deepCopy(db *StateDB) *stateObject { // // Address returns the address of the contract/account -func (s *stateObject) Address() common.Address { +func (s *StateObject) Address() common.Address { return s.address } // Code returns the contract code associated with this object, if any. -func (s *stateObject) Code(db Database) []byte { +func (s *StateObject) Code(db Database) []byte { if s.code != nil { return s.code } @@ -468,7 +468,7 @@ func (s *stateObject) Code(db Database) []byte { // CodeSize returns the size of the contract code associated with this object, // or zero if none. This method is an almost mirror of Code, but uses a cache // inside the database to avoid loading codes seen recently. -func (s *stateObject) CodeSize(db Database) int { +func (s *StateObject) CodeSize(db Database) int { if s.code != nil { return len(s.code) } @@ -482,7 +482,7 @@ func (s *stateObject) CodeSize(db Database) int { return size } -func (s *stateObject) SetCode(codeHash common.Hash, code []byte) { +func (s *StateObject) SetCode(codeHash common.Hash, code []byte) { prevcode := s.Code(s.db.db) s.db.journal.append(codeChange{ account: &s.address, @@ -492,13 +492,13 @@ func (s *stateObject) SetCode(codeHash common.Hash, code []byte) { s.setCode(codeHash, code) } -func (s *stateObject) setCode(codeHash common.Hash, code []byte) { +func (s *StateObject) setCode(codeHash common.Hash, code []byte) { s.code = code s.data.CodeHash = codeHash[:] s.dirtyCode = true } -func (s *stateObject) SetNonce(nonce uint64) { +func (s *StateObject) SetNonce(nonce uint64) { s.db.journal.append(nonceChange{ account: &s.address, prev: s.data.Nonce, @@ -506,25 +506,25 @@ func (s *stateObject) SetNonce(nonce uint64) { s.setNonce(nonce) } -func (s *stateObject) setNonce(nonce uint64) { +func (s *StateObject) setNonce(nonce uint64) { s.data.Nonce = nonce } -func (s *stateObject) CodeHash() []byte { +func (s *StateObject) CodeHash() []byte { return s.data.CodeHash } -func (s *stateObject) Balance() *big.Int { +func (s *StateObject) Balance() *big.Int { return s.data.Balance } -func (s *stateObject) Nonce() uint64 { +func (s *StateObject) Nonce() uint64 { return s.data.Nonce } -// Value is never called, but must be present to allow stateObject to be used +// Value is never called, but must be present to allow StateObject to be used // as a vm.Account interface that also satisfies the vm.ContractRef // interface. Interfaces are awesome. -func (s *stateObject) Value() *big.Int { - panic("Value on stateObject should never be called") +func (s *StateObject) Value() *big.Int { + panic("Value on StateObject should never be called") } diff --git a/core/state/state_test.go b/core/state/state_test.go index b6b46e446fba..3f48fdd13fd5 100644 --- a/core/state/state_test.go +++ b/core/state/state_test.go @@ -205,7 +205,7 @@ func TestSnapshot2(t *testing.T) { } } -func compareStateObjects(so0, so1 *stateObject, t *testing.T) { +func compareStateObjects(so0, so1 *StateObject, t *testing.T) { if so0.Address() != so1.Address() { t.Fatalf("Address mismatch: have %v, want %v", so0.address, so1.address) } diff --git a/core/state/statedb.go b/core/state/statedb.go index 18432bd70b6a..fd8f6078f21a 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -78,7 +78,7 @@ type StateDB struct { snapStorage map[common.Hash]map[common.Hash][]byte // This map holds 'live' objects, which will get modified while processing a state transition. - stateObjects map[common.Address]*stateObject + stateObjects map[common.Address]*StateObject stateObjectsPending map[common.Address]struct{} // State objects finalized but not yet written to the trie stateObjectsDirty map[common.Address]struct{} // State objects modified in the current execution stateObjectsDestruct map[common.Address]struct{} // State objects destructed in the block @@ -143,7 +143,7 @@ func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error) trie: tr, originalRoot: root, snaps: snaps, - stateObjects: make(map[common.Address]*stateObject), + stateObjects: make(map[common.Address]*StateObject), stateObjectsPending: make(map[common.Address]struct{}), stateObjectsDirty: make(map[common.Address]struct{}), stateObjectsDestruct: make(map[common.Address]struct{}), @@ -271,17 +271,17 @@ func (s *StateDB) Empty(addr common.Address) bool { // GetBalance retrieves the balance from the given address or 0 if object not found func (s *StateDB) GetBalance(addr common.Address) *big.Int { - stateObject := s.getStateObject(addr) - if stateObject != nil { - return stateObject.Balance() + StateObject := s.getStateObject(addr) + if StateObject != nil { + return StateObject.Balance() } return common.Big0 } func (s *StateDB) GetNonce(addr common.Address) uint64 { - stateObject := s.getStateObject(addr) - if stateObject != nil { - return stateObject.Nonce() + StateObject := s.getStateObject(addr) + if StateObject != nil { + return StateObject.Nonce() } return 0 @@ -293,34 +293,34 @@ func (s *StateDB) TxIndex() int { } func (s *StateDB) GetCode(addr common.Address) []byte { - stateObject := s.getStateObject(addr) - if stateObject != nil { - return stateObject.Code(s.db) + StateObject := s.getStateObject(addr) + if StateObject != nil { + return StateObject.Code(s.db) } return nil } func (s *StateDB) GetCodeSize(addr common.Address) int { - stateObject := s.getStateObject(addr) - if stateObject != nil { - return stateObject.CodeSize(s.db) + StateObject := s.getStateObject(addr) + if StateObject != nil { + return StateObject.CodeSize(s.db) } return 0 } func (s *StateDB) GetCodeHash(addr common.Address) common.Hash { - stateObject := s.getStateObject(addr) - if stateObject == nil { + StateObject := s.getStateObject(addr) + if StateObject == nil { return common.Hash{} } - return common.BytesToHash(stateObject.CodeHash()) + return common.BytesToHash(StateObject.CodeHash()) } // GetState retrieves a value from the given account's storage trie. func (s *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash { - stateObject := s.getStateObject(addr) - if stateObject != nil { - return stateObject.GetState(s.db, hash) + StateObject := s.getStateObject(addr) + if StateObject != nil { + return StateObject.GetState(s.db, hash) } return common.Hash{} } @@ -356,9 +356,9 @@ func (s *StateDB) GetStorageProof(a common.Address, key common.Hash) ([][]byte, // GetCommittedState retrieves a value from the given account's committed storage trie. func (s *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash { - stateObject := s.getStateObject(addr) - if stateObject != nil { - return stateObject.GetCommittedState(s.db, hash) + StateObject := s.getStateObject(addr) + if StateObject != nil { + return StateObject.GetCommittedState(s.db, hash) } return common.Hash{} } @@ -372,11 +372,11 @@ func (s *StateDB) Database() Database { // and is nil for non-existent accounts. An error will be returned if storage trie // is existent but can't be loaded correctly. func (s *StateDB) StorageTrie(addr common.Address) (Trie, error) { - stateObject := s.getStateObject(addr) - if stateObject == nil { + StateObject := s.getStateObject(addr) + if StateObject == nil { return nil, nil } - cpy := stateObject.deepCopy(s) + cpy := StateObject.deepCopy(s) if _, err := cpy.updateTrie(s.db); err != nil { return nil, err } @@ -384,9 +384,9 @@ func (s *StateDB) StorageTrie(addr common.Address) (Trie, error) { } func (s *StateDB) HasSuicided(addr common.Address) bool { - stateObject := s.getStateObject(addr) - if stateObject != nil { - return stateObject.suicided + StateObject := s.getStateObject(addr) + if StateObject != nil { + return StateObject.suicided } return false } @@ -397,45 +397,45 @@ func (s *StateDB) HasSuicided(addr common.Address) bool { // AddBalance adds amount to the account associated with addr. func (s *StateDB) AddBalance(addr common.Address, amount *big.Int) { - stateObject := s.GetOrNewStateObject(addr) - if stateObject != nil { - stateObject.AddBalance(amount) + StateObject := s.GetOrNewStateObject(addr) + if StateObject != nil { + StateObject.AddBalance(amount) } } // SubBalance subtracts amount from the account associated with addr. func (s *StateDB) SubBalance(addr common.Address, amount *big.Int) { - stateObject := s.GetOrNewStateObject(addr) - if stateObject != nil { - stateObject.SubBalance(amount) + StateObject := s.GetOrNewStateObject(addr) + if StateObject != nil { + StateObject.SubBalance(amount) } } func (s *StateDB) SetBalance(addr common.Address, amount *big.Int) { - stateObject := s.GetOrNewStateObject(addr) - if stateObject != nil { - stateObject.SetBalance(amount) + StateObject := s.GetOrNewStateObject(addr) + if StateObject != nil { + StateObject.SetBalance(amount) } } func (s *StateDB) SetNonce(addr common.Address, nonce uint64) { - stateObject := s.GetOrNewStateObject(addr) - if stateObject != nil { - stateObject.SetNonce(nonce) + StateObject := s.GetOrNewStateObject(addr) + if StateObject != nil { + StateObject.SetNonce(nonce) } } func (s *StateDB) SetCode(addr common.Address, code []byte) { - stateObject := s.GetOrNewStateObject(addr) - if stateObject != nil { - stateObject.SetCode(crypto.Keccak256Hash(code), code) + StateObject := s.GetOrNewStateObject(addr) + if StateObject != nil { + StateObject.SetCode(crypto.Keccak256Hash(code), code) } } func (s *StateDB) SetState(addr common.Address, key, value common.Hash) { - stateObject := s.GetOrNewStateObject(addr) - if stateObject != nil { - stateObject.SetState(s.db, key, value) + StateObject := s.GetOrNewStateObject(addr) + if StateObject != nil { + StateObject.SetState(s.db, key, value) } } @@ -448,9 +448,9 @@ func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common // will not hit disk, since it is assumed that the disk-data is belonging // to a previous incarnation of the object. s.stateObjectsDestruct[addr] = struct{}{} - stateObject := s.GetOrNewStateObject(addr) + StateObject := s.GetOrNewStateObject(addr) for k, v := range storage { - stateObject.SetState(s.db, k, v) + StateObject.SetState(s.db, k, v) } } @@ -460,17 +460,17 @@ func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common // The account's state object is still available until the state is committed, // getStateObject will return a non-nil account after Suicide. func (s *StateDB) Suicide(addr common.Address) bool { - stateObject := s.getStateObject(addr) - if stateObject == nil { + StateObject := s.getStateObject(addr) + if StateObject == nil { return false } s.journal.append(suicideChange{ account: &addr, - prev: stateObject.suicided, - prevbalance: new(big.Int).Set(stateObject.Balance()), + prev: StateObject.suicided, + prevbalance: new(big.Int).Set(StateObject.Balance()), }) - stateObject.markSuicided() - stateObject.data.Balance = new(big.Int) + StateObject.markSuicided() + StateObject.data.Balance = new(big.Int) return true } @@ -509,7 +509,7 @@ func (s *StateDB) GetTransientState(addr common.Address, key common.Hash) common // // updateStateObject writes the given object to the trie. -func (s *StateDB) updateStateObject(obj *stateObject) { +func (s *StateDB) updateStateObject(obj *StateObject) { // Track the amount of time wasted on updating the account from the trie if metrics.EnabledExpensive { defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now()) @@ -530,7 +530,7 @@ func (s *StateDB) updateStateObject(obj *stateObject) { } // deleteStateObject removes the given object from the state trie. -func (s *StateDB) deleteStateObject(obj *stateObject) { +func (s *StateDB) deleteStateObject(obj *StateObject) { // Track the amount of time wasted on deleting the account from the trie if metrics.EnabledExpensive { defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now()) @@ -545,7 +545,7 @@ func (s *StateDB) deleteStateObject(obj *stateObject) { // getStateObject retrieves a state object given by the address, returning nil if // the object is not found or was deleted in this execution context. If you need // to differentiate between non-existent/just-deleted, use getDeletedStateObject. -func (s *StateDB) getStateObject(addr common.Address) *stateObject { +func (s *StateDB) getStateObject(addr common.Address) *StateObject { if obj := s.getDeletedStateObject(addr); obj != nil && !obj.deleted { return obj } @@ -556,7 +556,7 @@ func (s *StateDB) getStateObject(addr common.Address) *stateObject { // nil for a deleted state object, it returns the actual object with the deleted // flag set. This is needed by the state journal to revert to the correct s- // destructed object instead of wiping all knowledge about the state object. -func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject { +func (s *StateDB) getDeletedStateObject(addr common.Address) *StateObject { // Prefer live objects if any is available if obj := s.stateObjects[addr]; obj != nil { return obj @@ -609,22 +609,22 @@ func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject { return obj } -func (s *StateDB) setStateObject(object *stateObject) { +func (s *StateDB) setStateObject(object *StateObject) { s.stateObjects[object.Address()] = object } // GetOrNewStateObject retrieves a state object or create a new state object if nil. -func (s *StateDB) GetOrNewStateObject(addr common.Address) *stateObject { - stateObject := s.getStateObject(addr) - if stateObject == nil { - stateObject, _ = s.createObject(addr) +func (s *StateDB) GetOrNewStateObject(addr common.Address) *StateObject { + StateObject := s.getStateObject(addr) + if StateObject == nil { + StateObject, _ = s.createObject(addr) } - return stateObject + return StateObject } // createObject creates a new state object. If there is an existing account with // the given address, it is overwritten and returned as the second return value. -func (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) { +func (s *StateDB) createObject(addr common.Address) (newobj, prev *StateObject) { prev = s.getDeletedStateObject(addr) // Note, prev might have been deleted, we need that! var prevdestruct bool @@ -705,7 +705,7 @@ func (s *StateDB) Copy() StateDBI { db: s.db, trie: s.db.CopyTrie(s.trie), originalRoot: s.originalRoot, - stateObjects: make(map[common.Address]*stateObject, len(s.journal.dirties)), + stateObjects: make(map[common.Address]*StateObject, len(s.journal.dirties)), stateObjectsPending: make(map[common.Address]struct{}, len(s.stateObjectsPending)), stateObjectsDirty: make(map[common.Address]struct{}, len(s.journal.dirties)), stateObjectsDestruct: make(map[common.Address]struct{}, len(s.stateObjectsDestruct)), diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go index 867b47db5319..3a9e388739d8 100644 --- a/core/state_prefetcher.go +++ b/core/state_prefetcher.go @@ -47,7 +47,7 @@ func newStatePrefetcher(config *params.ChainConfig, bc *BlockChain, engine conse // Prefetch processes the state changes according to the Ethereum rules by running // the transaction messages using the statedb, but any changes are discarded. The // only goal is to pre-cache transaction signatures and state trie nodes. -func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, cfg vm.Config, interrupt *uint32) { +func (p *statePrefetcher) Prefetch(block *types.Block, statedb state.StateDBI, cfg vm.Config, interrupt *uint32) { var ( header = block.Header() gaspool = new(GasPool).AddGas(block.GasLimit()) @@ -85,7 +85,7 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c // precacheTransaction attempts to apply a transaction to the given state database // and uses the input parameters for its environment. The goal is not to execute // the transaction successfully, rather to warm up touched data slots. -func precacheTransaction(msg types.Message, config *params.ChainConfig, gaspool *GasPool, statedb *state.StateDB, header *types.Header, evm *vm.EVM) error { +func precacheTransaction(msg types.Message, config *params.ChainConfig, gaspool *GasPool, statedb state.StateDBI, header *types.Header, evm *vm.EVM) error { // Update the evm with the new transaction context. evm.Reset(NewEVMTxContext(msg), statedb) // Add addresses to access list if applicable diff --git a/core/state_processor.go b/core/state_processor.go index 163ea0a0200a..952c434eba68 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -56,7 +56,7 @@ func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consen // Process returns the receipts and logs accumulated during the process and // returns the amount of gas that was used in the process. If any of the // transactions failed to execute due to insufficient gas it will return an error. -func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) { +func (p *StateProcessor) Process(block *types.Block, statedb state.StateDBI, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) { var ( receipts types.Receipts usedGas = new(uint64) @@ -97,7 +97,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg return receipts, allLogs, *usedGas, nil } -func applyTransaction(msg types.Message, config *params.ChainConfig, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM) (*types.Receipt, error) { +func applyTransaction(msg types.Message, config *params.ChainConfig, gp *GasPool, statedb state.StateDBI, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM) (*types.Receipt, error) { // Create a new context to be used in the EVM environment. txContext := NewEVMTxContext(msg) evm.Reset(txContext, statedb) @@ -146,7 +146,7 @@ func applyTransaction(msg types.Message, config *params.ChainConfig, gp *GasPool // and uses the input parameters for its environment. It returns the receipt // for the transaction, gas used and an error if the transaction failed, // indicating the block was invalid. -func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, error) { +func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb state.StateDBI, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, error) { msg, err := tx.AsMessage(types.MakeSigner(config, header.Number), header.BaseFee) if err != nil { return nil, err diff --git a/core/txpool/noncer.go b/core/txpool/noncer.go index ba7fbedad568..a355d1f82c21 100644 --- a/core/txpool/noncer.go +++ b/core/txpool/noncer.go @@ -27,13 +27,13 @@ import ( // accounts in the pool, falling back to reading from a real state database if // an account is unknown. type noncer struct { - fallback *state.StateDB + fallback state.StateDBI nonces map[common.Address]uint64 lock sync.Mutex } // newNoncer creates a new virtual state database to track the pool nonces. -func newNoncer(statedb *state.StateDB) *noncer { +func newNoncer(statedb state.StateDBI) *noncer { return &noncer{ fallback: statedb.Copy(), nonces: make(map[common.Address]uint64), diff --git a/core/txpool/txpool.go b/core/txpool/txpool.go index c80520186627..8d941dd5db09 100644 --- a/core/txpool/txpool.go +++ b/core/txpool/txpool.go @@ -147,7 +147,7 @@ const ( type blockChain interface { CurrentBlock() *types.Block GetBlock(hash common.Hash, number uint64) *types.Block - StateAt(root common.Hash) (*state.StateDB, error) + StateAt(root common.Hash) (state.StateDBI, error) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription } @@ -248,7 +248,7 @@ type TxPool struct { eip1559 bool // Fork indicator whether we are using EIP-1559 type transactions. shanghai bool // Fork indicator whether we are in the Shanghai stage. - currentState *state.StateDB // Current state in the blockchain head + currentState state.StateDBI // Current state in the blockchain head pendingNonces *noncer // Pending state tracking virtual nonces currentMaxGas uint64 // Current gas limit for transaction caps diff --git a/core/txpool/txpool_test.go b/core/txpool/txpool_test.go index bd82622f8de6..46bb08b3e14c 100644 --- a/core/txpool/txpool_test.go +++ b/core/txpool/txpool_test.go @@ -60,7 +60,7 @@ func init() { type testBlockChain struct { gasLimit uint64 // must be first field for 64 bit alignment (atomic access) - statedb *state.StateDB + statedb state.StateDBI chainHeadFeed *event.Feed } @@ -74,7 +74,7 @@ func (bc *testBlockChain) GetBlock(hash common.Hash, number uint64) *types.Block return bc.CurrentBlock() } -func (bc *testBlockChain) StateAt(common.Hash) (*state.StateDB, error) { +func (bc *testBlockChain) StateAt(common.Hash) (state.StateDBI, error) { return bc.statedb, nil } @@ -202,7 +202,7 @@ type testChain struct { // testChain.State() is used multiple times to reset the pending state. // when simulate is true it will create a state that indicates // that tx0 and tx1 are included in the chain. -func (c *testChain) State() (*state.StateDB, error) { +func (c *testChain) State() (state.StateDBI, error) { // delay "state change" by one. The tx pool fetches the // state multiple times and by delaying it a bit we simulate // a state change between those fetches. diff --git a/core/types.go b/core/types.go index 4c5b74a49865..0a8fa9da2f61 100644 --- a/core/types.go +++ b/core/types.go @@ -31,7 +31,7 @@ type Validator interface { // ValidateState validates the given statedb and optionally the receipts and // gas used. - ValidateState(block *types.Block, state *state.StateDB, receipts types.Receipts, usedGas uint64) error + ValidateState(block *types.Block, state state.StateDBI, receipts types.Receipts, usedGas uint64) error } // Prefetcher is an interface for pre-caching transaction signatures and state. @@ -39,7 +39,7 @@ type Prefetcher interface { // Prefetch processes the state changes according to the Ethereum rules by running // the transaction messages using the statedb, but any changes are discarded. The // only goal is to pre-cache transaction signatures and state trie nodes. - Prefetch(block *types.Block, statedb *state.StateDB, cfg vm.Config, interrupt *uint32) + Prefetch(block *types.Block, statedb state.StateDBI, cfg vm.Config, interrupt *uint32) } // Processor is an interface for processing blocks using a given initial state. @@ -47,5 +47,5 @@ type Processor interface { // Process processes the state changes according to the Ethereum rules by running // the transaction messages using the statedb and applying any rewards to both // the processor (coinbase) and any included uncles. - Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) + Process(block *types.Block, statedb state.StateDBI, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) } diff --git a/core/vm/instructions_test.go b/core/vm/instructions_test.go index 61f001a692c3..1554a603ff0c 100644 --- a/core/vm/instructions_test.go +++ b/core/vm/instructions_test.go @@ -592,7 +592,7 @@ func TestOpTstore(t *testing.T) { value = common.Hex2Bytes("abcdef00000000000000abba000000000deaf000000c0de00100000000133700") ) - // Add a stateObject for the caller and the contract being called + // Add a StateObject for the caller and the contract being called statedb.CreateAccount(caller) statedb.CreateAccount(to) diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go index 56ff5eeabe33..18ae0f697ef8 100644 --- a/core/vm/runtime/runtime.go +++ b/core/vm/runtime/runtime.go @@ -44,7 +44,7 @@ type Config struct { EVMConfig vm.Config BaseFee *big.Int - State *state.StateDB + State state.StateDBI GetHashFn func(n uint64) common.Hash } @@ -100,7 +100,7 @@ func setDefaults(cfg *Config) { // // Execute sets up an in-memory, temporary, environment for the execution of // the given code. It makes sure that it's restored to its original state afterwards. -func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) { +func Execute(code, input []byte, cfg *Config) ([]byte, state.StateDBI, error) { if cfg == nil { cfg = new(Config) } diff --git a/eth/api.go b/eth/api.go index c1f73037d7d8..42b413a246f9 100644 --- a/eth/api.go +++ b/eth/api.go @@ -337,7 +337,7 @@ const AccountRangeMaxResults = 256 // AccountRange enumerates all accounts in the given block and start point in paging request func (api *DebugAPI) AccountRange(blockNrOrHash rpc.BlockNumberOrHash, start hexutil.Bytes, maxResults int, nocode, nostorage, incompletes bool) (state.IteratorDump, error) { - var stateDb *state.StateDB + var stateDb state.StateDBI var err error if number, ok := blockNrOrHash.Number(); ok { diff --git a/eth/api_backend.go b/eth/api_backend.go index 8fd3e43300d3..4a6e9b05122d 100644 --- a/eth/api_backend.go +++ b/eth/api_backend.go @@ -171,7 +171,7 @@ func (b *EthAPIBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) return b.eth.miner.PendingBlockAndReceipts() } -func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) { +func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (vm.StateDB, *types.Header, error) { // Pending state is only known by the miner if number == rpc.PendingBlockNumber { block, state := b.eth.miner.Pending() @@ -189,7 +189,7 @@ func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.B return stateDb, header, err } -func (b *EthAPIBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) { +func (b *EthAPIBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (vm.StateDB, *types.Header, error) { if blockNr, ok := blockNrOrHash.Number(); ok { return b.StateAndHeaderByNumber(ctx, blockNr) } @@ -225,7 +225,7 @@ func (b *EthAPIBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int { return nil } -func (b *EthAPIBackend) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error) { +func (b *EthAPIBackend) GetEVM(ctx context.Context, msg core.Message, state vm.StateDB, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error) { if vmConfig == nil { vmConfig = b.eth.blockchain.GetVMConfig() } @@ -375,10 +375,10 @@ func (b *EthAPIBackend) StartMining(threads int) error { return b.eth.StartMining(threads) } -func (b *EthAPIBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, tracers.StateReleaseFunc, error) { +func (b *EthAPIBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base state.StateDBI, readOnly bool, preferDisk bool) (state.StateDBI, tracers.StateReleaseFunc, error) { return b.eth.StateAtBlock(ctx, block, reexec, base, readOnly, preferDisk) } -func (b *EthAPIBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) { +func (b *EthAPIBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, state.StateDBI, tracers.StateReleaseFunc, error) { return b.eth.stateAtTransaction(ctx, block, txIndex, reexec) } diff --git a/eth/api_test.go b/eth/api_test.go index fca17f12171b..465dfcc6c27d 100644 --- a/eth/api_test.go +++ b/eth/api_test.go @@ -34,7 +34,7 @@ import ( var dumper = spew.ConfigState{Indent: " "} -func accountRangeTest(t *testing.T, trie *state.Trie, statedb *state.StateDB, start common.Hash, requestedNum int, expectedNum int) state.IteratorDump { +func accountRangeTest(t *testing.T, trie *state.Trie, statedb state.StateDBI, start common.Hash, requestedNum int, expectedNum int) state.IteratorDump { result := statedb.IteratorDump(&state.DumpConfig{ SkipCode: true, SkipStorage: true, diff --git a/eth/state_accessor.go b/eth/state_accessor.go index 3bb1464952a0..d892b5e8ef8f 100644 --- a/eth/state_accessor.go +++ b/eth/state_accessor.go @@ -57,7 +57,7 @@ var noopReleaser = tracers.StateReleaseFunc(func() {}) // - preferDisk: this arg can be used by the caller to signal that even though the 'base' is // provided, it would be preferable to start from a fresh state, if we have it // on disk. -func (eth *Ethereum) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (statedb *state.StateDB, release tracers.StateReleaseFunc, err error) { +func (eth *Ethereum) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base state.StateDBI, readOnly bool, preferDisk bool) (statedb state.StateDBI, release tracers.StateReleaseFunc, err error) { var ( current *types.Block database state.Database @@ -189,7 +189,7 @@ func (eth *Ethereum) StateAtBlock(ctx context.Context, block *types.Block, reexe } // stateAtTransaction returns the execution environment of a certain transaction. -func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) { +func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, state.StateDBI, tracers.StateReleaseFunc, error) { // Short circuit if it's genesis block. if block.NumberU64() == 0 { return nil, vm.BlockContext{}, nil, nil, errors.New("no transaction in genesis") diff --git a/eth/tracers/api.go b/eth/tracers/api.go index 4814b0066663..5ea408832ff9 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -86,8 +86,8 @@ type Backend interface { ChainConfig() *params.ChainConfig Engine() consensus.Engine ChainDb() ethdb.Database - StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, StateReleaseFunc, error) - StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, StateReleaseFunc, error) + StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base state.StateDBI, readOnly bool, preferDisk bool) (state.StateDBI, StateReleaseFunc, error) + StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, state.StateDBI, StateReleaseFunc, error) } // API is the collection of tracing APIs exposed over the private debugging endpoint. @@ -331,7 +331,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed number uint64 traced uint64 failed error - statedb *state.StateDB + statedb state.StateDBI release StateReleaseFunc ) // Ensure everything is properly cleaned up on any exit path @@ -648,7 +648,7 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac // traceBlockParallel is for tracers that have a high overhead (read JS tracers). One thread // runs along and executes txes without tracing enabled to generate their prestate. // Worker threads take the tasks and the prestate and trace them. -func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, statedb *state.StateDB, config *TraceConfig) ([]*txTraceResult, error) { +func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, statedb state.StateDBI, config *TraceConfig) ([]*txTraceResult, error) { // Execute all the transaction contained within the block concurrently var ( txs = block.Transactions() diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index bbcb00a5e763..46593be31445 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -140,7 +140,7 @@ func (b *testBackend) teardown() { b.chain.Stop() } -func (b *testBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, StateReleaseFunc, error) { +func (b *testBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base state.StateDBI, readOnly bool, preferDisk bool) (state.StateDBI, StateReleaseFunc, error) { statedb, err := b.chain.StateAt(block.Root()) if err != nil { return nil, nil, errStateNotFound @@ -156,7 +156,7 @@ func (b *testBackend) StateAtBlock(ctx context.Context, block *types.Block, reex return statedb, release, nil } -func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, StateReleaseFunc, error) { +func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, state.StateDBI, StateReleaseFunc, error) { parent := b.chain.GetBlock(block.ParentHash(), block.NumberU64()-1) if parent == nil { return nil, vm.BlockContext{}, nil, nil, errBlockNotFound diff --git a/graphql/graphql.go b/graphql/graphql.go index 637778e9d0f7..04445e35abc2 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -83,7 +83,7 @@ type Account struct { } // getState fetches the StateDB object for an account. -func (a *Account) getState(ctx context.Context) (*state.StateDB, error) { +func (a *Account) getState(ctx context.Context) (state.StateDBI, error) { state, _, err := a.r.backend.StateAndHeaderByNumberOrHash(ctx, a.blockNrOrHash) return state, err } diff --git a/les/api_backend.go b/les/api_backend.go index 422ac74b8668..3f9f44765184 100644 --- a/les/api_backend.go +++ b/les/api_backend.go @@ -138,7 +138,7 @@ func (b *LesApiBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) return nil, nil } -func (b *LesApiBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) { +func (b *LesApiBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (state.StateDBI, *types.Header, error) { header, err := b.HeaderByNumber(ctx, number) if err != nil { return nil, nil, err @@ -149,7 +149,7 @@ func (b *LesApiBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.B return light.NewState(ctx, header, b.eth.odr), header, nil } -func (b *LesApiBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) { +func (b *LesApiBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (state.StateDBI, *types.Header, error) { if blockNr, ok := blockNrOrHash.Number(); ok { return b.StateAndHeaderByNumber(ctx, blockNr) } @@ -184,7 +184,7 @@ func (b *LesApiBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int { return nil } -func (b *LesApiBackend) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error) { +func (b *LesApiBackend) GetEVM(ctx context.Context, msg core.Message, state state.StateDBI, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error) { if vmConfig == nil { vmConfig = new(vm.Config) } @@ -326,10 +326,10 @@ func (b *LesApiBackend) CurrentHeader() *types.Header { return b.eth.blockchain.CurrentHeader() } -func (b *LesApiBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, tracers.StateReleaseFunc, error) { +func (b *LesApiBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base state.StateDBI, readOnly bool, preferDisk bool) (state.StateDBI, tracers.StateReleaseFunc, error) { return b.eth.stateAtBlock(ctx, block, reexec) } -func (b *LesApiBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) { +func (b *LesApiBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, state.StateDBI, tracers.StateReleaseFunc, error) { return b.eth.stateAtTransaction(ctx, block, txIndex, reexec) } diff --git a/les/odr_test.go b/les/odr_test.go index e028d35e639c..d7886423dda0 100644 --- a/les/odr_test.go +++ b/les/odr_test.go @@ -92,7 +92,7 @@ func odrAccounts(ctx context.Context, db ethdb.Database, config *params.ChainCon var ( res []byte - st *state.StateDB + st state.StateDBI err error ) for _, addr := range acc { diff --git a/les/state_accessor.go b/les/state_accessor.go index 091ec8871eee..9ba8f9c8d2b1 100644 --- a/les/state_accessor.go +++ b/les/state_accessor.go @@ -34,12 +34,12 @@ import ( var noopReleaser = tracers.StateReleaseFunc(func() {}) // stateAtBlock retrieves the state database associated with a certain block. -func (leth *LightEthereum) stateAtBlock(ctx context.Context, block *types.Block, reexec uint64) (*state.StateDB, tracers.StateReleaseFunc, error) { +func (leth *LightEthereum) stateAtBlock(ctx context.Context, block *types.Block, reexec uint64) (state.StateDBI, tracers.StateReleaseFunc, error) { return light.NewState(ctx, block.Header(), leth.odr), noopReleaser, nil } // stateAtTransaction returns the execution environment of a certain transaction. -func (leth *LightEthereum) stateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) { +func (leth *LightEthereum) stateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, state.StateDBI, tracers.StateReleaseFunc, error) { // Short circuit if it's genesis block. if block.NumberU64() == 0 { return nil, vm.BlockContext{}, nil, nil, errors.New("no transaction in genesis") diff --git a/light/odr_test.go b/light/odr_test.go index 903c7f6f90a6..99e396862067 100644 --- a/light/odr_test.go +++ b/light/odr_test.go @@ -154,7 +154,7 @@ func odrAccounts(ctx context.Context, db ethdb.Database, bc *core.BlockChain, lc dummyAddr := common.HexToAddress("1234567812345678123456781234567812345678") acc := []common.Address{testBankAddress, acc1Addr, acc2Addr, dummyAddr} - var st *state.StateDB + var st state.StateDBI if bc == nil { header := lc.GetHeaderByHash(bhash) st = NewState(ctx, header, lc.Odr()) @@ -189,7 +189,7 @@ func odrContractCall(ctx context.Context, db ethdb.Database, bc *core.BlockChain data[35] = byte(i) var ( - st *state.StateDB + st state.StateDBI header *types.Header chain core.ChainContext ) diff --git a/light/trie.go b/light/trie.go index 0ccab1588d3d..137b98654ba0 100644 --- a/light/trie.go +++ b/light/trie.go @@ -35,7 +35,7 @@ var ( sha3Nil = crypto.Keccak256Hash(nil) ) -func NewState(ctx context.Context, head *types.Header, odr OdrBackend) *state.StateDB { +func NewState(ctx context.Context, head *types.Header, odr OdrBackend) state.StateDBI { state, _ := state.New(head.Root, NewStateDatabase(ctx, head, odr), nil) return state } diff --git a/light/txpool.go b/light/txpool.go index e59dc3e77434..79f4dab391fe 100644 --- a/light/txpool.go +++ b/light/txpool.go @@ -114,7 +114,7 @@ func NewTxPool(config *params.ChainConfig, chain *LightChain, relay TxRelayBacke } // currentState returns the light state of the current head header -func (pool *TxPool) currentState(ctx context.Context) *state.StateDB { +func (pool *TxPool) currentState(ctx context.Context) state.StateDBI { return NewState(ctx, pool.chain.CurrentHeader(), pool.odr) } diff --git a/miner/miner.go b/miner/miner.go index c969aec73546..3b95b6620ef0 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -200,7 +200,7 @@ func (miner *Miner) SetRecommitInterval(interval time.Duration) { } // Pending returns the currently pending block and associated state. -func (miner *Miner) Pending() (*types.Block, *state.StateDB) { +func (miner *Miner) Pending() (*types.Block, state.StateDBI) { return miner.worker.pending() } diff --git a/miner/miner_test.go b/miner/miner_test.go index 2e7682acd331..163ff38b8ff2 100644 --- a/miner/miner_test.go +++ b/miner/miner_test.go @@ -55,12 +55,12 @@ func (m *mockBackend) TxPool() *txpool.TxPool { return m.txPool } -func (m *mockBackend) StateAtBlock(block *types.Block, reexec uint64, base *state.StateDB, checkLive bool, preferDisk bool) (statedb *state.StateDB, err error) { +func (m *mockBackend) StateAtBlock(block *types.Block, reexec uint64, base state.StateDBI, checkLive bool, preferDisk bool) (statedb state.StateDBI, err error) { return nil, errors.New("not supported") } type testBlockChain struct { - statedb *state.StateDB + statedb state.StateDBI gasLimit uint64 chainHeadFeed *event.Feed } @@ -75,7 +75,7 @@ func (bc *testBlockChain) GetBlock(hash common.Hash, number uint64) *types.Block return bc.CurrentBlock() } -func (bc *testBlockChain) StateAt(common.Hash) (*state.StateDB, error) { +func (bc *testBlockChain) StateAt(common.Hash) (state.StateDBI, error) { return bc.statedb, nil } diff --git a/miner/worker.go b/miner/worker.go index 49204f71a076..c9685c701e40 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -88,7 +88,7 @@ var ( type environment struct { signer types.Signer - state *state.StateDB // apply state changes here + state state.StateDBI // apply state changes here ancestors mapset.Set[common.Hash] // ancestor set (used for checking uncle parent validity) family mapset.Set[common.Hash] // family set (used for checking uncle invalidity) tcount int // tx count in cycle @@ -150,7 +150,7 @@ func (env *environment) discard() { // task contains all information for consensus engine sealing and result submitting. type task struct { receipts []*types.Receipt - state *state.StateDB + state state.StateDBI block *types.Block createdAt time.Time } @@ -236,7 +236,7 @@ type worker struct { snapshotMu sync.RWMutex // The lock used to protect the snapshots below snapshotBlock *types.Block snapshotReceipts types.Receipts - snapshotState *state.StateDB + snapshotState state.StateDBI // atomic status counters running int32 // The indicator whether the consensus engine is running or not. @@ -381,7 +381,7 @@ func (w *worker) enablePreseal() { } // pending returns the pending state and corresponding block. -func (w *worker) pending() (*types.Block, *state.StateDB) { +func (w *worker) pending() (*types.Block, state.StateDBI) { // return a snapshot to avoid contention on currentMu mutex w.snapshotMu.RLock() defer w.snapshotMu.RUnlock() diff --git a/miner/worker_test.go b/miner/worker_test.go index ba929d293d8a..40045a42d26e 100644 --- a/miner/worker_test.go +++ b/miner/worker_test.go @@ -169,7 +169,7 @@ func newTestWorkerBackend(t *testing.T, chainConfig *params.ChainConfig, engine func (b *testWorkerBackend) BlockChain() *core.BlockChain { return b.chain } func (b *testWorkerBackend) TxPool() *txpool.TxPool { return b.txPool } -func (b *testWorkerBackend) StateAtBlock(block *types.Block, reexec uint64, base *state.StateDB, checkLive bool, preferDisk bool) (statedb *state.StateDB, err error) { +func (b *testWorkerBackend) StateAtBlock(block *types.Block, reexec uint64, base state.StateDBI, checkLive bool, preferDisk bool) (statedb state.StateDBI, err error) { return nil, errors.New("not supported") } diff --git a/tests/block_test_util.go b/tests/block_test_util.go index 8da95a640a10..ea7eea2b74ee 100644 --- a/tests/block_test_util.go +++ b/tests/block_test_util.go @@ -286,7 +286,7 @@ func validateHeader(h *btHeader, h2 *types.Header) error { return nil } -func (t *BlockTest) validatePostState(statedb *state.StateDB) error { +func (t *BlockTest) validatePostState(statedb state.StateDBI) error { // validate post state accounts in test file against what we have in state db for addr, acct := range t.json.Post { // address is indirectly verified by the other fields, as it's the db key diff --git a/tests/fuzzers/bls12381/precompile_fuzzer.go b/tests/fuzzers/bls12381/precompile_fuzzer.go index cab2bcba3863..ccdc60156850 100644 --- a/tests/fuzzers/bls12381/precompile_fuzzer.go +++ b/tests/fuzzers/bls12381/precompile_fuzzer.go @@ -18,6 +18,7 @@ package bls import ( "bytes" + "context" "fmt" "github.com/ethereum/go-ethereum/common" @@ -92,7 +93,7 @@ func fuzz(id byte, data []byte) int { } cpy := make([]byte, len(data)) copy(cpy, data) - _, err := precompile.Run(cpy) + _, err := precompile.Run(context.Background(), cpy, common.Address{}, nil, true) if !bytes.Equal(cpy, data) { panic(fmt.Sprintf("input data modified, precompile %d: %x %x", id, data, cpy)) } diff --git a/tests/state_test_util.go b/tests/state_test_util.go index b2e87fb004b9..26adc0c791d7 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -182,7 +182,7 @@ func (t *StateTest) checkError(subtest StateSubtest, err error) error { } // Run executes a specific subtest and verifies the post-state and logs -func (t *StateTest) Run(subtest StateSubtest, vmconfig vm.Config, snapshotter bool) (*snapshot.Tree, *state.StateDB, error) { +func (t *StateTest) Run(subtest StateSubtest, vmconfig vm.Config, snapshotter bool) (*snapshot.Tree, state.StateDBI, error) { snaps, statedb, root, err := t.RunNoVerify(subtest, vmconfig, snapshotter) if checkedErr := t.checkError(subtest, err); checkedErr != nil { return snaps, statedb, checkedErr @@ -206,7 +206,7 @@ func (t *StateTest) Run(subtest StateSubtest, vmconfig vm.Config, snapshotter bo } // RunNoVerify runs a specific subtest and returns the statedb and post-state root -func (t *StateTest) RunNoVerify(subtest StateSubtest, vmconfig vm.Config, snapshotter bool) (*snapshot.Tree, *state.StateDB, common.Hash, error) { +func (t *StateTest) RunNoVerify(subtest StateSubtest, vmconfig vm.Config, snapshotter bool) (*snapshot.Tree, state.StateDBI, common.Hash, error) { config, eips, err := GetChainConfig(subtest.Fork) if err != nil { return nil, nil, common.Hash{}, UnsupportedForkError{subtest.Fork} @@ -283,7 +283,7 @@ func (t *StateTest) gasLimit(subtest StateSubtest) uint64 { return t.json.Tx.GasLimit[t.json.Post[subtest.Fork][subtest.Index].Indexes.Gas] } -func MakePreState(db ethdb.Database, accounts core.GenesisAlloc, snapshotter bool) (*snapshot.Tree, *state.StateDB) { +func MakePreState(db ethdb.Database, accounts core.GenesisAlloc, snapshotter bool) (*snapshot.Tree, state.StateDBI) { sdb := state.NewDatabase(db) statedb, _ := state.New(common.Hash{}, sdb, nil) for addr, a := range accounts { From d03cab1e9817782d03fd91e6d11654179106b5bb Mon Sep 17 00:00:00 2001 From: Devon Bear Date: Sun, 5 Mar 2023 14:44:05 -0500 Subject: [PATCH 50/51] add get raw signature as an array to signer --- common/math/big.go | 11 +++++ common/math/integer.go | 11 +++++ core/types/transaction_signing.go | 82 ++++++++++++++++++++++++++++++- 3 files changed, 103 insertions(+), 1 deletion(-) diff --git a/common/math/big.go b/common/math/big.go index 48427810e1ce..25ca6a08d158 100644 --- a/common/math/big.go +++ b/common/math/big.go @@ -67,6 +67,17 @@ func (i *HexOrDecimal256) MarshalText() ([]byte, error) { return []byte(fmt.Sprintf("%#x", (*big.Int)(i))), nil } +// UnmarshalJSON implements json.Unmarshaler. +// +// It is similar to UnmarshalText, but allows parsing real decimals too, not just +// quoted decimal strings. +func (i *HexOrDecimal256) UnmarshalJSON(input []byte) error { + if len(input) > 0 && input[0] == '"' { + input = input[1 : len(input)-1] + } + return i.UnmarshalText(input) +} + // Decimal256 unmarshals big.Int as a decimal string. When unmarshalling, // it however accepts either "0x"-prefixed (hex encoded) or non-prefixed (decimal) type Decimal256 big.Int diff --git a/common/math/integer.go b/common/math/integer.go index 50d3eba1f579..ee52ccdc0d67 100644 --- a/common/math/integer.go +++ b/common/math/integer.go @@ -96,3 +96,14 @@ func SafeMul(x, y uint64) (uint64, bool) { hi, lo := bits.Mul64(x, y) return lo, hi != 0 } + +// UnmarshalJSON implements json.Unmarshaler. +// +// It is similar to UnmarshalText, but allows parsing real decimals too, not just +// quoted decimal strings. +func (i *HexOrDecimal64) UnmarshalJSON(input []byte) error { + if len(input) > 0 && input[0] == '"' { + input = input[1 : len(input)-1] + } + return i.UnmarshalText(input) +} diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go index 3e232fd84a66..5d9dcf1d3995 100644 --- a/core/types/transaction_signing.go +++ b/core/types/transaction_signing.go @@ -160,9 +160,13 @@ type Signer interface { // PubKey returns the public key of the sender. PubKey(tx *Transaction) ([]byte, error) + // Signature returns the raw signature of the transaction. + Signature(tx *Transaction) ([]byte, error) + // SignatureValues returns the raw R, S, V values corresponding to the // given signature. SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error) + ChainID() *big.Int // Hash returns 'signature hash', i.e. the transaction hash that is signed by the @@ -212,6 +216,20 @@ func (s londonSigner) PubKey(tx *Transaction) ([]byte, error) { return recoverPub(s.Hash(tx), R, S, V, true) } +func (s londonSigner) Signature(tx *Transaction) ([]byte, error) { + if tx.Type() != DynamicFeeTxType { + return s.eip2930Signer.PubKey(tx) + } + V, R, S := tx.RawSignatureValues() + // DynamicFee txs are defined to use 0 and 1 as their recovery + // id, add 27 to become equivalent to unprotected Homestead signatures. + V = new(big.Int).Add(V, big.NewInt(27)) + if tx.ChainId().Cmp(s.chainId) != 0 { + return nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId) + } + return recoverSig(s.Hash(tx), R, S, V, true) +} + func (s londonSigner) Equal(s2 Signer) bool { x, ok := s2.(londonSigner) return ok && x.chainId.Cmp(s.chainId) == 0 @@ -314,6 +332,28 @@ func (s eip2930Signer) PubKey(tx *Transaction) ([]byte, error) { return recoverPub(s.Hash(tx), R, S, V, true) } +func (s eip2930Signer) Signature(tx *Transaction) ([]byte, error) { + V, R, S := tx.RawSignatureValues() + switch tx.Type() { + case LegacyTxType: + if !tx.Protected() { + return HomesteadSigner{}.PubKey(tx) + } + V = new(big.Int).Sub(V, s.chainIdMul) + V.Sub(V, big8) + case AccessListTxType: + // AL txs are defined to use 0 and 1 as their recovery + // id, add 27 to become equivalent to unprotected Homestead signatures. + V = new(big.Int).Add(V, big.NewInt(27)) + default: + return nil, ErrTxTypeNotSupported + } + if tx.ChainId().Cmp(s.chainId) != 0 { + return nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId) + } + return recoverSig(s.Hash(tx), R, S, V, true) +} + func (s eip2930Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) { switch txdata := tx.inner.(type) { case *LegacyTx: @@ -427,6 +467,22 @@ func (s EIP155Signer) PubKey(tx *Transaction) ([]byte, error) { return recoverPub(s.Hash(tx), R, S, V, true) } +func (s EIP155Signer) Signature(tx *Transaction) ([]byte, error) { + if tx.Type() != LegacyTxType { + return nil, ErrTxTypeNotSupported + } + if !tx.Protected() { + return HomesteadSigner{}.Signature(tx) + } + if tx.ChainId().Cmp(s.chainId) != 0 { + return nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId) + } + V, R, S := tx.RawSignatureValues() + V = new(big.Int).Sub(V, s.chainIdMul) + V.Sub(V, big8) + return recoverSig(s.Hash(tx), R, S, V, true) +} + // SignatureValues returns signature values. This signature // needs to be in the [R || S || V] format where V is 0 or 1. func (s EIP155Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) { @@ -482,6 +538,14 @@ func (hs HomesteadSigner) Sender(tx *Transaction) (common.Address, error) { return recoverPlain(hs.Hash(tx), r, s, v, true) } +func (hs HomesteadSigner) Signature(tx *Transaction) ([]byte, error) { + if tx.Type() != LegacyTxType { + return nil, ErrTxTypeNotSupported + } + v, r, s := tx.RawSignatureValues() + return recoverSig(hs.Hash(tx), r, s, v, true) +} + // FrontierSigner implements Signer interface using the // frontier rules. type FrontierSigner struct{} @@ -511,6 +575,14 @@ func (fs FrontierSigner) PubKey(tx *Transaction) ([]byte, error) { return recoverPub(fs.Hash(tx), r, s, v, false) } +func (fs FrontierSigner) Signature(tx *Transaction) ([]byte, error) { + if tx.Type() != LegacyTxType { + return nil, ErrTxTypeNotSupported + } + v, r, s := tx.RawSignatureValues() + return recoverSig(fs.Hash(tx), r, s, v, false) +} + // SignatureValues returns signature values. This signature // needs to be in the [R || S || V] format where V is 0 or 1. func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error) { @@ -544,7 +616,7 @@ func decodeSignature(sig []byte) (r, s, v *big.Int) { return r, s, v } -func recoverPub(sighash common.Hash, R, S, Vb *big.Int, homestead bool) ([]byte, error) { +func recoverSig(sighash common.Hash, R, S, Vb *big.Int, homestead bool) ([]byte, error) { if Vb.BitLen() > 8 { return nil, ErrInvalidSig } @@ -558,7 +630,15 @@ func recoverPub(sighash common.Hash, R, S, Vb *big.Int, homestead bool) ([]byte, copy(sig[32-len(r):32], r) copy(sig[64-len(s):64], s) sig[64] = V + return sig, nil +} + +func recoverPub(sighash common.Hash, R, S, Vb *big.Int, homestead bool) ([]byte, error) { // recover the public key from the signature + sig, err := recoverSig(sighash, R, S, Vb, homestead) + if err != nil { + return nil, err + } pub, err := crypto.Ecrecover(sighash[:], sig) if err != nil { return nil, err From 204c08f519968b0f7d12b5dbacf67261484dbe62 Mon Sep 17 00:00:00 2001 From: Devon Bear Date: Sun, 5 Mar 2023 14:54:41 -0500 Subject: [PATCH 51/51] fix build --- ethclient/signer.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ethclient/signer.go b/ethclient/signer.go index 8df14a5755de..9f1c247632eb 100644 --- a/ethclient/signer.go +++ b/ethclient/signer.go @@ -56,6 +56,11 @@ func (s *senderFromServer) PubKey(tx *types.Transaction) ([]byte, error) { return nil, nil } +func (s *senderFromServer) Signature(tx *types.Transaction) ([]byte, error) { + // not implemented + return nil, nil +} + func (s *senderFromServer) ChainID() *big.Int { panic("can't sign with senderFromServer") }