From 74e9908926fe3eca56c905b325ff111aa316fb36 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Tue, 2 Nov 2021 00:37:53 +0100 Subject: [PATCH 01/26] cmd/evm: add b11r tool --- cmd/evm/internal/t8ntool/block.go | 213 +++++++++++++++++++++++++ cmd/evm/internal/t8ntool/flags.go | 25 ++- cmd/evm/internal/t8ntool/transition.go | 32 ++-- cmd/evm/main.go | 16 ++ 4 files changed, 273 insertions(+), 13 deletions(-) create mode 100644 cmd/evm/internal/t8ntool/block.go diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go new file mode 100644 index 000000000000..d0d21925aaa5 --- /dev/null +++ b/cmd/evm/internal/t8ntool/block.go @@ -0,0 +1,213 @@ +// Copyright 2020 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum 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 General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package t8ntool + +import ( + "encoding/json" + "fmt" + "os" + + "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/log" + "github.com/ethereum/go-ethereum/rlp" + "gopkg.in/urfave/cli.v1" +) + +type blockInput struct { + Header *types.Header `json:"header,omitempty"` + Uncles []*types.Header `json:"uncles,omitempty"` + TxRlp string `json:"txsRlp,omitempty"` + Txs []*types.Transaction +} + +func BuildBlock(ctx *cli.Context) error { + // Configure the go-ethereum logger + glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false))) + glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name))) + log.Root().SetHandler(glogger) + + baseDir, err := createBasedir(ctx) + if err != nil { + return NewError(ErrorIO, fmt.Errorf("failed creating output basedir: %v", err)) + } + + inputData, err := readInput(ctx) + if err != nil { + fmt.Println("bad error") + return err + } + + block := types.NewBlockWithHeader(inputData.Header) + block.WithBody(inputData.Txs, inputData.Uncles) + + return dispatchBlock(ctx, baseDir, block) +} + +func readInput(ctx *cli.Context) (*blockInput, error) { + var ( + headerStr = ctx.String(InputHeaderFlag.Name) + unclesStr = ctx.String(InputUnclesFlag.Name) + txsStr = ctx.String(InputTxsRlpFlag.Name) + inputData = &blockInput{} + ) + + if headerStr == stdinSelector || unclesStr == stdinSelector || txsStr == stdinSelector { + decoder := json.NewDecoder(os.Stdin) + if err := decoder.Decode(inputData); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling stdin: %v", err)) + } + } + + if headerStr != stdinSelector { + header, err := readHeader(headerStr) + if err != nil { + return nil, err + } + inputData.Header = header + } + + if unclesStr != stdinSelector { + uncles, err := readUncles(unclesStr) + if err != nil { + return nil, err + } + inputData.Uncles = uncles + } + + if txsStr != stdinSelector { + txs, err := readTxsRlp(txsStr) + if err != nil { + return nil, err + } + inputData.TxRlp = txs + } + + txs := []*types.Transaction{} + raw := common.FromHex(inputData.TxRlp) + err := rlp.DecodeBytes(raw, &txs) + if err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("unable to decode transaction from rlp data: %v", err)) + } + + return inputData, nil +} + +func readHeader(path string) (*types.Header, error) { + header := &types.Header{} + + if path == stdinSelector { + decoder := json.NewDecoder(os.Stdin) + if err := decoder.Decode(header); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling header from stdin: %v", err)) + } + } else { + inFile, err := os.Open(path) + if err != nil { + return nil, NewError(ErrorIO, fmt.Errorf("failed reading header file: %v", err)) + } + defer inFile.Close() + decoder := json.NewDecoder(inFile) + if err := decoder.Decode(&header); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling header file: %v", err)) + } + } + + return header, nil +} + +func readUncles(path string) ([]*types.Header, error) { + uncles := []*types.Header{} + + if path == stdinSelector { + decoder := json.NewDecoder(os.Stdin) + if err := decoder.Decode(uncles); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling uncles from stdin: %v", err)) + } + } else { + inFile, err := os.Open(path) + if err != nil { + return nil, NewError(ErrorIO, fmt.Errorf("failed reading uncles file: %v", err)) + } + defer inFile.Close() + decoder := json.NewDecoder(inFile) + if err := decoder.Decode(&uncles); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling uncles file: %v", err)) + } + } + + return uncles, nil +} + +func readTxsRlp(path string) (string, error) { + txsRlp := "" + + if path == stdinSelector { + decoder := json.NewDecoder(os.Stdin) + if err := decoder.Decode(txsRlp); err != nil { + return "", NewError(ErrorJson, fmt.Errorf("failed unmarshaling txs from stdin: %v", err)) + } + } else { + inFile, err := os.Open(path) + if err != nil { + return "", NewError(ErrorIO, fmt.Errorf("failed reading txs file: %v", err)) + } + defer inFile.Close() + decoder := json.NewDecoder(inFile) + if err := decoder.Decode(&txsRlp); err != nil { + return "", NewError(ErrorJson, fmt.Errorf("failed unmarshaling txs file: %v", err)) + } + } + + return txsRlp, nil +} + +// dispatchOutput writes the output data to either stderr or stdout, or to the specified +// files +func dispatchBlock(ctx *cli.Context, baseDir string, block *types.Block) error { + raw, _ := rlp.EncodeToBytes(block) + + type BlockInfo struct { + Rlp hexutil.Bytes `json:"rlp"` + Hash common.Hash `json:"hash"` + } + + var enc BlockInfo + enc.Rlp = raw + enc.Hash = block.Hash() + + b, err := json.MarshalIndent(enc, "", " ") + if err != nil { + return NewError(ErrorJson, fmt.Errorf("failed marshalling output: %v", err)) + } + + dest := ctx.String(OutputBlockFlag.Name) + if dest == "stdout" { + os.Stdout.Write(b) + os.Stdout.WriteString("\n") + } else if dest == "stderr" { + os.Stderr.Write(b) + os.Stderr.WriteString("\n") + } else { + if err := saveFile(baseDir, dest, enc); err != nil { + return err + } + } + + return nil +} diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go index 05b6ed16477e..b4bc90ea26a7 100644 --- a/cmd/evm/internal/t8ntool/flags.go +++ b/cmd/evm/internal/t8ntool/flags.go @@ -68,6 +68,14 @@ var ( "\t - into the file ", Value: "result.json", } + OutputBlockFlag = cli.StringFlag{ + Name: "output.block", + Usage: "Determines where to put the `block` after building.\n" + + "\t`stdout` - into the stdout output\n" + + "\t`stderr` - into the stderr output\n" + + "\t - into the file ", + Value: "block.json", + } InputAllocFlag = cli.StringFlag{ Name: "input.alloc", Usage: "`stdin` or file name of where to find the prestate alloc to use.", @@ -81,10 +89,25 @@ var ( InputTxsFlag = cli.StringFlag{ Name: "input.txs", Usage: "`stdin` or file name of where to find the transactions to apply. " + - "If the file prefix is '.rlp', then the data is interpreted as an RLP list of signed transactions." + + "If the file extension is '.rlp', then the data is interpreted as an RLP list of signed transactions." + "The '.rlp' format is identical to the output.body format.", Value: "txs.json", } + InputHeaderFlag = cli.StringFlag{ + Name: "input.header", + Usage: "`stdin` or file name of where to find the block header to use.", + Value: "header.json", + } + InputUnclesFlag = cli.StringFlag{ + Name: "input.uncles", + Usage: "`stdin` or file name of where to find the uncle headers to use.", + Value: "uncles.json", + } + InputTxsRlpFlag = cli.StringFlag{ + Name: "input.txsRlp", + Usage: "`stdin` or file name of where to find the transactions list in RLP form.", + Value: "txs.rlp", + } RewardFlag = cli.Int64Flag{ Name: "state.reward", Usage: "Mining reward. Set to -1 to disable", diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go index 0aff715eb25d..0ff4b944d154 100644 --- a/cmd/evm/internal/t8ntool/transition.go +++ b/cmd/evm/internal/t8ntool/transition.go @@ -88,21 +88,14 @@ func Transition(ctx *cli.Context) error { log.Root().SetHandler(glogger) var ( - err error - tracer vm.EVMLogger - baseDir = "" + err error + tracer vm.EVMLogger ) var getTracer func(txIndex int, txHash common.Hash) (vm.EVMLogger, error) - // If user specified a basedir, make sure it exists - if ctx.IsSet(OutputBasedir.Name) { - if base := ctx.String(OutputBasedir.Name); len(base) > 0 { - err := os.MkdirAll(base, 0755) // //rw-r--r-- - if err != nil { - return NewError(ErrorIO, fmt.Errorf("failed creating output basedir: %v", err)) - } - baseDir = base - } + baseDir, err := createBasedir(ctx) + if err != nil { + return NewError(ErrorIO, fmt.Errorf("failed creating output basedir: %v", err)) } if ctx.Bool(TraceFlag.Name) { // Configure the EVM logger @@ -431,3 +424,18 @@ func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, a } return nil } + +// If user specified a basedir, make sure it exists +func createBasedir(ctx *cli.Context) (string, error) { + baseDir := "" + if ctx.IsSet(OutputBasedir.Name) { + if base := ctx.String(OutputBasedir.Name); len(base) > 0 { + err := os.MkdirAll(base, 0755) // //rw-r--r-- + if err != nil { + return "", err + } + baseDir = base + } + } + return baseDir, nil +} diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 26064efc3ce6..47711b0175b9 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -167,6 +167,21 @@ var transactionCommand = cli.Command{ }, } +var blockBuilderCommand = cli.Command{ + Name: "block-builder", + Aliases: []string{"b11r"}, + Usage: "builds a block", + Action: t8ntool.BuildBlock, + Flags: []cli.Flag{ + t8ntool.OutputBasedir, + t8ntool.OutputBlockFlag, + t8ntool.InputHeaderFlag, + t8ntool.InputUnclesFlag, + t8ntool.InputTxsRlpFlag, + t8ntool.VerbosityFlag, + }, +} + func init() { app.Flags = []cli.Flag{ BenchFlag, @@ -200,6 +215,7 @@ func init() { stateTestCommand, stateTransitionCommand, transactionCommand, + blockBuilderCommand, } cli.CommandHelpTemplate = flags.OriginCommandHelpTemplate } From 3548ec94ad8268017c2df25b2b6a659eecdaf470 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Tue, 2 Nov 2021 00:42:25 +0100 Subject: [PATCH 02/26] cmd/evm: add simple test for b11r --- cmd/evm/testdata/20/header.json | 17 +++++++++++++++++ cmd/evm/testdata/20/readme.md | 12 ++++++++++++ cmd/evm/testdata/20/txs.rlp | 1 + cmd/evm/testdata/20/uncles.json | 1 + 4 files changed, 31 insertions(+) create mode 100644 cmd/evm/testdata/20/header.json create mode 100644 cmd/evm/testdata/20/readme.md create mode 100644 cmd/evm/testdata/20/txs.rlp create mode 100644 cmd/evm/testdata/20/uncles.json diff --git a/cmd/evm/testdata/20/header.json b/cmd/evm/testdata/20/header.json new file mode 100644 index 000000000000..04fad320c30a --- /dev/null +++ b/cmd/evm/testdata/20/header.json @@ -0,0 +1,17 @@ +{ + "parentHash": "0xd6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34e", + "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", + "miner": "0xe997a23b159e2e2a5ce72333262972374b15425c", + "stateRoot": "0x325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2e", + "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "difficulty": "0x15fafff0c91", + "number": "0xc3be", + "gasLimit": "0x50785", + "gasUsed": "0x0", + "timestamp": "0x55c5277e", + "extraData": "0x476574682f76312e302e312f6c696e75782f676f312e342e32", + "mixHash": "0x5865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf", + "nonce": "0x97435673d874f7c8" + } diff --git a/cmd/evm/testdata/20/readme.md b/cmd/evm/testdata/20/readme.md new file mode 100644 index 000000000000..d519a1fa21e4 --- /dev/null +++ b/cmd/evm/testdata/20/readme.md @@ -0,0 +1,12 @@ +# Block building + +This test shows how `b11r` can be used to assemble an unsealed block. + + +```console +$ go run . b11r --input.header=testdata/20/header.json --input.txsRlp=testdata/20/txs.rlp --input.uncles=testdata/20/uncles.json --output.block=stdout +{ + "rlp": "0xf9021af90215a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794e997a23b159e2e2a5ce72333262972374b15425ca0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000086015fafff0c9182c3be83050785808455c5277e99476574682f76312e302e312f6c696e75782f676f312e342e32a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf8897435673d874f7c8c0c0", + "hash": "0x263ef16f9d26696f43d6274e3a22947844ab80201fb469cdf5da4451509be234" +} +``` diff --git a/cmd/evm/testdata/20/txs.rlp b/cmd/evm/testdata/20/txs.rlp new file mode 100644 index 000000000000..3599ff06542b --- /dev/null +++ b/cmd/evm/testdata/20/txs.rlp @@ -0,0 +1 @@ +"0xf8c2f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600" \ No newline at end of file diff --git a/cmd/evm/testdata/20/uncles.json b/cmd/evm/testdata/20/uncles.json new file mode 100644 index 000000000000..fe51488c7066 --- /dev/null +++ b/cmd/evm/testdata/20/uncles.json @@ -0,0 +1 @@ +[] From 0a34f57fabe843d36475f4c692cbdc666b0f74ea Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Mon, 8 Nov 2021 22:37:49 +0100 Subject: [PATCH 03/26] cmd/evm: add env object to control b11r and accept uncles as rlp --- cmd/evm/internal/t8ntool/block.go | 119 +++++++++++++++++++---- cmd/evm/internal/t8ntool/gen_bbenv.go | 135 ++++++++++++++++++++++++++ cmd/evm/testdata/20/header.json | 5 +- 3 files changed, 236 insertions(+), 23 deletions(-) create mode 100644 cmd/evm/internal/t8ntool/gen_bbenv.go diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index d0d21925aaa5..e9b70da6dc2d 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -19,23 +19,97 @@ package t8ntool import ( "encoding/json" "fmt" + "math/big" "os" "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/core/types" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" "gopkg.in/urfave/cli.v1" ) +//go:generate gencodec -type bbEnv -field-override bbEnvMarshaling -out gen_bbenv.go +type bbEnv struct { + ParentHash common.Hash `json:"parentHash"` + UncleHash common.Hash `json:"sha3Uncles"` + Coinbase common.Address `json:"miner" gencode:"required"` + Root common.Hash `json:"stateRoot" gencodec:"required"` + TxHash common.Hash `json:"transactionsRoot"` + ReceiptHash common.Hash `json:"receiptsRoot"` + Bloom types.Bloom `json:"logsBloom"` + Difficulty *big.Int `json:"difficulty"` + Number *big.Int `json:"number" gencodec:"required"` + GasLimit uint64 `json:"gasLimit" gencodec:"required"` + GasUsed uint64 `json:"gasUsed"` + Time uint64 `json:"timestamp" gencodec:"required"` + Extra []byte `json:"extraData"` + MixDigest common.Hash `json:"mixHash"` + Nonce types.BlockNonce `json:"nonce"` + BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"` +} + +type bbEnvMarshaling struct { + Difficulty *math.HexOrDecimal256 + Number *math.HexOrDecimal256 + GasLimit math.HexOrDecimal64 + GasUsed math.HexOrDecimal64 + Time math.HexOrDecimal64 + Extra hexutil.Bytes + BaseFee *math.HexOrDecimal256 +} + type blockInput struct { - Header *types.Header `json:"header,omitempty"` - Uncles []*types.Header `json:"uncles,omitempty"` - TxRlp string `json:"txsRlp,omitempty"` + Env *bbEnv `json:"header,omitempty"` + UnclesRlp []string `json:"uncles,omitempty"` + TxRlp string `json:"txsRlp,omitempty"` + + Uncles []*types.Header Txs []*types.Transaction } +func (i *blockInput) toBlock() *types.Block { + header := &types.Header{ + ParentHash: i.Env.ParentHash, + UncleHash: i.Env.UncleHash, + Coinbase: i.Env.Coinbase, + Root: i.Env.Root, + TxHash: i.Env.TxHash, + ReceiptHash: i.Env.ReceiptHash, + Bloom: i.Env.Bloom, + Difficulty: i.Env.Difficulty, + Number: i.Env.Number, + GasLimit: i.Env.GasLimit, + GasUsed: i.Env.GasUsed, + Time: i.Env.Time, + Extra: i.Env.Extra, + MixDigest: i.Env.MixDigest, + Nonce: i.Env.Nonce, + BaseFee: i.Env.BaseFee, + } + + none := common.Hash{} + if header.UncleHash == none { + header.UncleHash = types.EmptyUncleHash + } + if header.TxHash == none { + header.TxHash = types.EmptyRootHash + } + if header.ReceiptHash == none { + header.ReceiptHash = types.EmptyRootHash + } + if header.Difficulty == nil { + header.Difficulty = common.Big0 + } + + block := types.NewBlockWithHeader(header) + block.WithBody(i.Txs, i.Uncles) + + return block +} + func BuildBlock(ctx *cli.Context) error { // Configure the go-ethereum logger glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false))) @@ -49,14 +123,10 @@ func BuildBlock(ctx *cli.Context) error { inputData, err := readInput(ctx) if err != nil { - fmt.Println("bad error") return err } - block := types.NewBlockWithHeader(inputData.Header) - block.WithBody(inputData.Txs, inputData.Uncles) - - return dispatchBlock(ctx, baseDir, block) + return dispatchBlock(ctx, baseDir, inputData.toBlock()) } func readInput(ctx *cli.Context) (*blockInput, error) { @@ -75,11 +145,11 @@ func readInput(ctx *cli.Context) (*blockInput, error) { } if headerStr != stdinSelector { - header, err := readHeader(headerStr) + env, err := readEnv(headerStr) if err != nil { return nil, err } - inputData.Header = header + inputData.Env = env } if unclesStr != stdinSelector { @@ -87,7 +157,18 @@ func readInput(ctx *cli.Context) (*blockInput, error) { if err != nil { return nil, err } - inputData.Uncles = uncles + inputData.UnclesRlp = uncles + } + + uncles := []*types.Header{} + for _, str := range inputData.UnclesRlp { + var uncle *types.Header + raw := common.FromHex(str) + err := rlp.DecodeBytes(raw, &uncle) + if err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("unable to decode uncle from rlp data: %v", err)) + } + uncles = append(uncles, uncle) } if txsStr != stdinSelector { @@ -108,13 +189,13 @@ func readInput(ctx *cli.Context) (*blockInput, error) { return inputData, nil } -func readHeader(path string) (*types.Header, error) { - header := &types.Header{} +func readEnv(path string) (*bbEnv, error) { + env := &bbEnv{} if path == stdinSelector { decoder := json.NewDecoder(os.Stdin) - if err := decoder.Decode(header); err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling header from stdin: %v", err)) + if err := decoder.Decode(env); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling env from stdin: %v", err)) } } else { inFile, err := os.Open(path) @@ -123,16 +204,16 @@ func readHeader(path string) (*types.Header, error) { } defer inFile.Close() decoder := json.NewDecoder(inFile) - if err := decoder.Decode(&header); err != nil { + if err := decoder.Decode(&env); err != nil { return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling header file: %v", err)) } } - return header, nil + return env, nil } -func readUncles(path string) ([]*types.Header, error) { - uncles := []*types.Header{} +func readUncles(path string) ([]string, error) { + uncles := []string{} if path == stdinSelector { decoder := json.NewDecoder(os.Stdin) diff --git a/cmd/evm/internal/t8ntool/gen_bbenv.go b/cmd/evm/internal/t8ntool/gen_bbenv.go new file mode 100644 index 000000000000..ad38def310e1 --- /dev/null +++ b/cmd/evm/internal/t8ntool/gen_bbenv.go @@ -0,0 +1,135 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package t8ntool + +import ( + "encoding/json" + "errors" + "math/big" + + "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/core/types" +) + +var _ = (*bbEnvMarshaling)(nil) + +// MarshalJSON marshals as JSON. +func (b bbEnv) MarshalJSON() ([]byte, error) { + type bbEnv struct { + ParentHash common.Hash `json:"parentHash"` + UncleHash common.Hash `json:"sha3Uncles"` + Coinbase common.Address `json:"miner" gencode:"required"` + Root common.Hash `json:"stateRoot" gencodec:"required"` + TxHash common.Hash `json:"transactionsRoot"` + ReceiptHash common.Hash `json:"receiptsRoot"` + Bloom types.Bloom `json:"logsBloom"` + Difficulty *math.HexOrDecimal256 `json:"difficulty"` + Number *math.HexOrDecimal256 `json:"number" gencodec:"required"` + GasLimit math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"` + GasUsed math.HexOrDecimal64 `json:"gasUsed"` + Time math.HexOrDecimal64 `json:"timestamp" gencodec:"required"` + Extra hexutil.Bytes `json:"extraData"` + MixDigest common.Hash `json:"mixHash"` + Nonce types.BlockNonce `json:"nonce"` + BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"` + } + var enc bbEnv + enc.ParentHash = b.ParentHash + enc.UncleHash = b.UncleHash + enc.Coinbase = b.Coinbase + enc.Root = b.Root + enc.TxHash = b.TxHash + enc.ReceiptHash = b.ReceiptHash + enc.Bloom = b.Bloom + enc.Difficulty = (*math.HexOrDecimal256)(b.Difficulty) + enc.Number = (*math.HexOrDecimal256)(b.Number) + enc.GasLimit = math.HexOrDecimal64(b.GasLimit) + enc.GasUsed = math.HexOrDecimal64(b.GasUsed) + enc.Time = math.HexOrDecimal64(b.Time) + enc.Extra = b.Extra + enc.MixDigest = b.MixDigest + enc.Nonce = b.Nonce + enc.BaseFee = (*math.HexOrDecimal256)(b.BaseFee) + return json.Marshal(&enc) +} + +// UnmarshalJSON unmarshals from JSON. +func (b *bbEnv) UnmarshalJSON(input []byte) error { + type bbEnv struct { + ParentHash *common.Hash `json:"parentHash"` + UncleHash *common.Hash `json:"sha3Uncles"` + Coinbase *common.Address `json:"miner" gencode:"required"` + Root *common.Hash `json:"stateRoot" gencodec:"required"` + TxHash *common.Hash `json:"transactionsRoot"` + ReceiptHash *common.Hash `json:"receiptsRoot"` + Bloom *types.Bloom `json:"logsBloom"` + Difficulty *math.HexOrDecimal256 `json:"difficulty"` + Number *math.HexOrDecimal256 `json:"number" gencodec:"required"` + GasLimit *math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"` + GasUsed *math.HexOrDecimal64 `json:"gasUsed"` + Time *math.HexOrDecimal64 `json:"timestamp" gencodec:"required"` + Extra *hexutil.Bytes `json:"extraData"` + MixDigest *common.Hash `json:"mixHash"` + Nonce *types.BlockNonce `json:"nonce"` + BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"` + } + var dec bbEnv + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.ParentHash != nil { + b.ParentHash = *dec.ParentHash + } + if dec.UncleHash != nil { + b.UncleHash = *dec.UncleHash + } + if dec.Coinbase != nil { + b.Coinbase = *dec.Coinbase + } + if dec.Root == nil { + return errors.New("missing required field 'stateRoot' for bbEnv") + } + b.Root = *dec.Root + if dec.TxHash != nil { + b.TxHash = *dec.TxHash + } + if dec.ReceiptHash != nil { + b.ReceiptHash = *dec.ReceiptHash + } + if dec.Bloom != nil { + b.Bloom = *dec.Bloom + } + if dec.Difficulty != nil { + b.Difficulty = (*big.Int)(dec.Difficulty) + } + if dec.Number == nil { + return errors.New("missing required field 'number' for bbEnv") + } + b.Number = (*big.Int)(dec.Number) + if dec.GasLimit == nil { + return errors.New("missing required field 'gasLimit' for bbEnv") + } + b.GasLimit = uint64(*dec.GasLimit) + if dec.GasUsed != nil { + b.GasUsed = uint64(*dec.GasUsed) + } + if dec.Time == nil { + return errors.New("missing required field 'timestamp' for bbEnv") + } + b.Time = uint64(*dec.Time) + if dec.Extra != nil { + b.Extra = *dec.Extra + } + if dec.MixDigest != nil { + b.MixDigest = *dec.MixDigest + } + if dec.Nonce != nil { + b.Nonce = *dec.Nonce + } + if dec.BaseFee != nil { + b.BaseFee = (*big.Int)(dec.BaseFee) + } + return nil +} diff --git a/cmd/evm/testdata/20/header.json b/cmd/evm/testdata/20/header.json index 04fad320c30a..7577393ef335 100644 --- a/cmd/evm/testdata/20/header.json +++ b/cmd/evm/testdata/20/header.json @@ -1,10 +1,7 @@ { "parentHash": "0xd6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34e", - "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "miner": "0xe997a23b159e2e2a5ce72333262972374b15425c", "stateRoot": "0x325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2e", - "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "difficulty": "0x15fafff0c91", "number": "0xc3be", @@ -14,4 +11,4 @@ "extraData": "0x476574682f76312e302e312f6c696e75782f676f312e342e32", "mixHash": "0x5865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf", "nonce": "0x97435673d874f7c8" - } +} From 531ce6ce44e5d993ddfecd65812ecc7b2581b4bb Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Wed, 10 Nov 2021 23:05:59 +0100 Subject: [PATCH 04/26] cmd/evm: add support for ethash and clique sealing --- cmd/evm/internal/t8ntool/block.go | 235 +++++++++++++++++++++----- cmd/evm/internal/t8ntool/flags.go | 13 ++ cmd/evm/internal/t8ntool/gen_bbenv.go | 26 +-- cmd/evm/main.go | 3 + cmd/evm/testdata/20/header.json | 2 +- cmd/evm/testdata/21/clique.json | 6 + cmd/evm/testdata/21/header.json | 11 ++ cmd/evm/testdata/21/readme.md | 12 ++ cmd/evm/testdata/21/txs.rlp | 1 + cmd/evm/testdata/21/uncles.json | 1 + 10 files changed, 258 insertions(+), 52 deletions(-) create mode 100644 cmd/evm/testdata/21/clique.json create mode 100644 cmd/evm/testdata/21/header.json create mode 100644 cmd/evm/testdata/21/readme.md create mode 100644 cmd/evm/testdata/21/txs.rlp create mode 100644 cmd/evm/testdata/21/uncles.json diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index e9b70da6dc2d..510987134ea9 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -17,7 +17,9 @@ package t8ntool import ( + "crypto/ecdsa" "encoding/json" + "errors" "fmt" "math/big" "os" @@ -25,7 +27,10 @@ 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/consensus/clique" + "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" "gopkg.in/urfave/cli.v1" @@ -33,22 +38,22 @@ import ( //go:generate gencodec -type bbEnv -field-override bbEnvMarshaling -out gen_bbenv.go type bbEnv struct { - ParentHash common.Hash `json:"parentHash"` - UncleHash common.Hash `json:"sha3Uncles"` - Coinbase common.Address `json:"miner" gencode:"required"` - Root common.Hash `json:"stateRoot" gencodec:"required"` - TxHash common.Hash `json:"transactionsRoot"` - ReceiptHash common.Hash `json:"receiptsRoot"` - Bloom types.Bloom `json:"logsBloom"` - Difficulty *big.Int `json:"difficulty"` - Number *big.Int `json:"number" gencodec:"required"` - GasLimit uint64 `json:"gasLimit" gencodec:"required"` - GasUsed uint64 `json:"gasUsed"` - Time uint64 `json:"timestamp" gencodec:"required"` - Extra []byte `json:"extraData"` - MixDigest common.Hash `json:"mixHash"` - Nonce types.BlockNonce `json:"nonce"` - BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"` + ParentHash common.Hash `json:"parentHash"` + UncleHash *common.Hash `json:"sha3Uncles"` + Coinbase *common.Address `json:"miner"` + Root common.Hash `json:"stateRoot" gencodec:"required"` + TxHash *common.Hash `json:"transactionsRoot"` + ReceiptHash *common.Hash `json:"receiptsRoot"` + Bloom types.Bloom `json:"logsBloom"` + Difficulty *big.Int `json:"difficulty"` + Number *big.Int `json:"number" gencodec:"required"` + GasLimit uint64 `json:"gasLimit" gencodec:"required"` + GasUsed uint64 `json:"gasUsed"` + Time uint64 `json:"timestamp" gencodec:"required"` + Extra []byte `json:"extraData"` + MixDigest common.Hash `json:"mixHash"` + Nonce *types.BlockNonce `json:"nonce"` + BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"` } type bbEnvMarshaling struct { @@ -62,52 +67,160 @@ type bbEnvMarshaling struct { } type blockInput struct { - Env *bbEnv `json:"header,omitempty"` - UnclesRlp []string `json:"uncles,omitempty"` - TxRlp string `json:"txsRlp,omitempty"` + Env *bbEnv `json:"header,omitempty"` + UnclesRlp []string `json:"uncles,omitempty"` + TxRlp string `json:"txsRlp,omitempty"` + Clique *cliqueInput `json:"clique,omitempty"` + EthashDir string Uncles []*types.Header Txs []*types.Transaction } -func (i *blockInput) toBlock() *types.Block { +type cliqueInput struct { + Key *ecdsa.PrivateKey + Voted *common.Address + Authorized bool + Vanity common.Hash +} + +func (c *cliqueInput) UnmarshalJSON(input []byte) error { + // Read the secretKey, if present + type sKey struct { + Key *common.Hash `json:"secretKey"` + } + var key sKey + if err := json.Unmarshal(input, &key); err != nil { + return err + } + if key.Key == nil { + return errors.New("missing required field 'secretKey' for cliqueInput") + } + k := key.Key.Hex()[2:] + if ecdsaKey, err := crypto.HexToECDSA(k); err != nil { + return err + } else { + c.Key = ecdsaKey + } + + // Now, read the rest of object + type others struct { + Voted *common.Address `json:"voted"` + Authorized bool `json:"authorized"` + Vanity common.Hash `json:"vanity"` + } + var x others + if err := json.Unmarshal(input, &x); err != nil { + return err + } + c.Voted = x.Voted + c.Authorized = x.Authorized + c.Vanity = x.Vanity + + return nil +} + +func (i *blockInput) toBlock() (*types.Block, error) { header := &types.Header{ ParentHash: i.Env.ParentHash, - UncleHash: i.Env.UncleHash, - Coinbase: i.Env.Coinbase, + UncleHash: types.EmptyUncleHash, + Coinbase: common.Address{}, Root: i.Env.Root, - TxHash: i.Env.TxHash, - ReceiptHash: i.Env.ReceiptHash, + TxHash: types.EmptyRootHash, + ReceiptHash: types.EmptyRootHash, Bloom: i.Env.Bloom, - Difficulty: i.Env.Difficulty, + Difficulty: common.Big0, Number: i.Env.Number, GasLimit: i.Env.GasLimit, GasUsed: i.Env.GasUsed, Time: i.Env.Time, Extra: i.Env.Extra, MixDigest: i.Env.MixDigest, - Nonce: i.Env.Nonce, BaseFee: i.Env.BaseFee, } - none := common.Hash{} - if header.UncleHash == none { - header.UncleHash = types.EmptyUncleHash + // Set optional values to specified values. + if i.Env.UncleHash != nil { + header.UncleHash = *i.Env.UncleHash + } + if i.Env.Coinbase != nil { + header.Coinbase = *i.Env.Coinbase } - if header.TxHash == none { - header.TxHash = types.EmptyRootHash + if i.Env.TxHash != nil { + header.TxHash = *i.Env.TxHash } - if header.ReceiptHash == none { - header.ReceiptHash = types.EmptyRootHash + if i.Env.ReceiptHash != nil { + header.ReceiptHash = *i.Env.ReceiptHash } - if header.Difficulty == nil { - header.Difficulty = common.Big0 + if i.Env.Nonce != nil { + header.Nonce = *i.Env.Nonce + } + if header.Difficulty != nil { + header.Difficulty = i.Env.Difficulty } block := types.NewBlockWithHeader(header) block.WithBody(i.Txs, i.Uncles) - return block + if i.EthashDir != "" { + if i.Env.Nonce != nil { + return nil, NewError(ErrorJson, fmt.Errorf("Sealing with ethash will overwrite specified nonce")) + } + ethashConfig := ethash.Config{ + PowMode: ethash.ModeNormal, + DatasetDir: i.EthashDir, + CacheDir: i.EthashDir, + DatasetsInMem: 1, + DatasetsOnDisk: 2, + CachesInMem: 2, + CachesOnDisk: 3, + } + engine := ethash.New(ethashConfig, nil, false) + defer engine.Close() + + results := make(chan *types.Block) + if err := engine.Seal(nil, block, results, nil); err != nil { + panic(fmt.Sprintf("failed to seal block: %v", err)) + } + select { + case found := <-results: + block.WithSeal(found.Header()) + } + } else if i.Clique != nil { + header = block.Header() + + if i.Env.Extra != nil { + return nil, NewError(ErrorJson, fmt.Errorf("Sealing with clique will overwrite specified extra data")) + } + if i.Clique.Voted != nil { + if i.Env.Coinbase != nil { + return nil, NewError(ErrorJson, fmt.Errorf("Sealing with clique and voting will overwrite specified coinbase")) + } + if i.Env.Nonce != nil { + return nil, NewError(ErrorJson, fmt.Errorf("Sealing with clique and voting will overwrite specified nonce")) + } + + header.Coinbase = *i.Clique.Voted + if i.Clique.Authorized { + header.Nonce = [8]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} + } else { + header.Nonce = [8]byte{} + } + } + + header.Extra = make([]byte, 97) + copy(header.Extra[0:32], i.Clique.Vanity.Bytes()[:]) + h := clique.SealHash(header) + + sighash, err := crypto.Sign(h[:], i.Clique.Key) + if err != nil { + return nil, err + } + copy(header.Extra[32:], sighash) + block = block.WithSeal(header) + } + + return block, nil } func BuildBlock(ctx *cli.Context) error { @@ -125,8 +238,12 @@ func BuildBlock(ctx *cli.Context) error { if err != nil { return err } + block, err := inputData.toBlock() + if err != nil { + return err + } - return dispatchBlock(ctx, baseDir, inputData.toBlock()) + return dispatchBlock(ctx, baseDir, block) } func readInput(ctx *cli.Context) (*blockInput, error) { @@ -134,16 +251,35 @@ func readInput(ctx *cli.Context) (*blockInput, error) { headerStr = ctx.String(InputHeaderFlag.Name) unclesStr = ctx.String(InputUnclesFlag.Name) txsStr = ctx.String(InputTxsRlpFlag.Name) + cliqueStr = ctx.String(InputCliqueFlag.Name) + ethash = ctx.Bool(InputEthashFlag.Name) + ethashDir = ctx.String(InputEthashDirFlag.Name) inputData = &blockInput{} ) - if headerStr == stdinSelector || unclesStr == stdinSelector || txsStr == stdinSelector { + if ethash && cliqueStr != "" { + return nil, NewError(ErrorJson, fmt.Errorf("both ethash and clique sealing specified, only one may be chosen")) + } + + if ethash && ethashDir != "" { + inputData.EthashDir = ethashDir + } + + if headerStr == stdinSelector || unclesStr == stdinSelector || txsStr == stdinSelector || cliqueStr == stdinSelector { decoder := json.NewDecoder(os.Stdin) if err := decoder.Decode(inputData); err != nil { return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling stdin: %v", err)) } } + if cliqueStr != stdinSelector && cliqueStr != "" { + clique, err := readClique(cliqueStr) + if err != nil { + return nil, err + } + inputData.Clique = clique + } + if headerStr != stdinSelector { env, err := readEnv(headerStr) if err != nil { @@ -258,6 +394,29 @@ func readTxsRlp(path string) (string, error) { return txsRlp, nil } +func readClique(path string) (*cliqueInput, error) { + clique := &cliqueInput{} + + if path == stdinSelector { + decoder := json.NewDecoder(os.Stdin) + if err := decoder.Decode(clique); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling env from stdin: %v", err)) + } + } else { + inFile, err := os.Open(path) + if err != nil { + return nil, NewError(ErrorIO, fmt.Errorf("failed reading clique file: %v", err)) + } + defer inFile.Close() + decoder := json.NewDecoder(inFile) + if err := decoder.Decode(&clique); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling clique file: %v", err)) + } + } + + return clique, nil +} + // dispatchOutput writes the output data to either stderr or stdout, or to the specified // files func dispatchBlock(ctx *cli.Context, baseDir string, block *types.Block) error { diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go index b4bc90ea26a7..474d53aa0920 100644 --- a/cmd/evm/internal/t8ntool/flags.go +++ b/cmd/evm/internal/t8ntool/flags.go @@ -108,6 +108,19 @@ var ( Usage: "`stdin` or file name of where to find the transactions list in RLP form.", Value: "txs.rlp", } + InputCliqueFlag = cli.StringFlag{ + Name: "input.clique", + Usage: "`stdin` or file name of where to find the Clique sealing data.", + } + InputEthashFlag = cli.BoolFlag{ + Name: "input.ethash", + Usage: "Flag denoting whether a proof-of-work seal should be mined.", + } + InputEthashDirFlag = cli.StringFlag{ + Name: "ethash.dir", + Usage: "Location of ethash DAG. If none exists at the destination, a new DAG will be generated.", + Value: "ethash", + } RewardFlag = cli.Int64Flag{ Name: "state.reward", Usage: "Mining reward. Set to -1 to disable", diff --git a/cmd/evm/internal/t8ntool/gen_bbenv.go b/cmd/evm/internal/t8ntool/gen_bbenv.go index ad38def310e1..105f4075faeb 100644 --- a/cmd/evm/internal/t8ntool/gen_bbenv.go +++ b/cmd/evm/internal/t8ntool/gen_bbenv.go @@ -19,11 +19,11 @@ var _ = (*bbEnvMarshaling)(nil) func (b bbEnv) MarshalJSON() ([]byte, error) { type bbEnv struct { ParentHash common.Hash `json:"parentHash"` - UncleHash common.Hash `json:"sha3Uncles"` - Coinbase common.Address `json:"miner" gencode:"required"` + UncleHash *common.Hash `json:"sha3Uncles"` + Coinbase *common.Address `json:"miner"` Root common.Hash `json:"stateRoot" gencodec:"required"` - TxHash common.Hash `json:"transactionsRoot"` - ReceiptHash common.Hash `json:"receiptsRoot"` + TxHash *common.Hash `json:"transactionsRoot"` + ReceiptHash *common.Hash `json:"receiptsRoot"` Bloom types.Bloom `json:"logsBloom"` Difficulty *math.HexOrDecimal256 `json:"difficulty"` Number *math.HexOrDecimal256 `json:"number" gencodec:"required"` @@ -32,8 +32,8 @@ func (b bbEnv) MarshalJSON() ([]byte, error) { Time math.HexOrDecimal64 `json:"timestamp" gencodec:"required"` Extra hexutil.Bytes `json:"extraData"` MixDigest common.Hash `json:"mixHash"` - Nonce types.BlockNonce `json:"nonce"` - BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"` + Nonce *types.BlockNonce `json:"nonce"` + BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas" rlp:"optional"` } var enc bbEnv enc.ParentHash = b.ParentHash @@ -60,7 +60,7 @@ func (b *bbEnv) UnmarshalJSON(input []byte) error { type bbEnv struct { ParentHash *common.Hash `json:"parentHash"` UncleHash *common.Hash `json:"sha3Uncles"` - Coinbase *common.Address `json:"miner" gencode:"required"` + Coinbase *common.Address `json:"miner"` Root *common.Hash `json:"stateRoot" gencodec:"required"` TxHash *common.Hash `json:"transactionsRoot"` ReceiptHash *common.Hash `json:"receiptsRoot"` @@ -73,7 +73,7 @@ func (b *bbEnv) UnmarshalJSON(input []byte) error { Extra *hexutil.Bytes `json:"extraData"` MixDigest *common.Hash `json:"mixHash"` Nonce *types.BlockNonce `json:"nonce"` - BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"` + BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas" rlp:"optional"` } var dec bbEnv if err := json.Unmarshal(input, &dec); err != nil { @@ -83,20 +83,20 @@ func (b *bbEnv) UnmarshalJSON(input []byte) error { b.ParentHash = *dec.ParentHash } if dec.UncleHash != nil { - b.UncleHash = *dec.UncleHash + b.UncleHash = dec.UncleHash } if dec.Coinbase != nil { - b.Coinbase = *dec.Coinbase + b.Coinbase = dec.Coinbase } if dec.Root == nil { return errors.New("missing required field 'stateRoot' for bbEnv") } b.Root = *dec.Root if dec.TxHash != nil { - b.TxHash = *dec.TxHash + b.TxHash = dec.TxHash } if dec.ReceiptHash != nil { - b.ReceiptHash = *dec.ReceiptHash + b.ReceiptHash = dec.ReceiptHash } if dec.Bloom != nil { b.Bloom = *dec.Bloom @@ -126,7 +126,7 @@ func (b *bbEnv) UnmarshalJSON(input []byte) error { b.MixDigest = *dec.MixDigest } if dec.Nonce != nil { - b.Nonce = *dec.Nonce + b.Nonce = dec.Nonce } if dec.BaseFee != nil { b.BaseFee = (*big.Int)(dec.BaseFee) diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 47711b0175b9..3e2bb9fc7948 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -178,6 +178,9 @@ var blockBuilderCommand = cli.Command{ t8ntool.InputHeaderFlag, t8ntool.InputUnclesFlag, t8ntool.InputTxsRlpFlag, + t8ntool.InputCliqueFlag, + t8ntool.InputEthashFlag, + t8ntool.InputEthashDirFlag, t8ntool.VerbosityFlag, }, } diff --git a/cmd/evm/testdata/20/header.json b/cmd/evm/testdata/20/header.json index 7577393ef335..fb9b7fc5639c 100644 --- a/cmd/evm/testdata/20/header.json +++ b/cmd/evm/testdata/20/header.json @@ -3,7 +3,7 @@ "miner": "0xe997a23b159e2e2a5ce72333262972374b15425c", "stateRoot": "0x325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "difficulty": "0x15fafff0c91", + "difficulty": "0x1000", "number": "0xc3be", "gasLimit": "0x50785", "gasUsed": "0x0", diff --git a/cmd/evm/testdata/21/clique.json b/cmd/evm/testdata/21/clique.json new file mode 100644 index 000000000000..a9f25639fc9b --- /dev/null +++ b/cmd/evm/testdata/21/clique.json @@ -0,0 +1,6 @@ +{ + "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8", + "voted": "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba", + "authorized": false, + "vanity": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +} diff --git a/cmd/evm/testdata/21/header.json b/cmd/evm/testdata/21/header.json new file mode 100644 index 000000000000..62abe3cc2cc5 --- /dev/null +++ b/cmd/evm/testdata/21/header.json @@ -0,0 +1,11 @@ +{ + "parentHash": "0xd6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34e", + "stateRoot": "0x325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2e", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "difficulty": "0x1000", + "number": "0xc3be", + "gasLimit": "0x50785", + "gasUsed": "0x0", + "timestamp": "0x55c5277e", + "mixHash": "0x5865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf" +} diff --git a/cmd/evm/testdata/21/readme.md b/cmd/evm/testdata/21/readme.md new file mode 100644 index 000000000000..d519a1fa21e4 --- /dev/null +++ b/cmd/evm/testdata/21/readme.md @@ -0,0 +1,12 @@ +# Block building + +This test shows how `b11r` can be used to assemble an unsealed block. + + +```console +$ go run . b11r --input.header=testdata/20/header.json --input.txsRlp=testdata/20/txs.rlp --input.uncles=testdata/20/uncles.json --output.block=stdout +{ + "rlp": "0xf9021af90215a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794e997a23b159e2e2a5ce72333262972374b15425ca0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000086015fafff0c9182c3be83050785808455c5277e99476574682f76312e302e312f6c696e75782f676f312e342e32a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf8897435673d874f7c8c0c0", + "hash": "0x263ef16f9d26696f43d6274e3a22947844ab80201fb469cdf5da4451509be234" +} +``` diff --git a/cmd/evm/testdata/21/txs.rlp b/cmd/evm/testdata/21/txs.rlp new file mode 100644 index 000000000000..3599ff06542b --- /dev/null +++ b/cmd/evm/testdata/21/txs.rlp @@ -0,0 +1 @@ +"0xf8c2f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600" \ No newline at end of file diff --git a/cmd/evm/testdata/21/uncles.json b/cmd/evm/testdata/21/uncles.json new file mode 100644 index 000000000000..fe51488c7066 --- /dev/null +++ b/cmd/evm/testdata/21/uncles.json @@ -0,0 +1 @@ +[] From 5fa774c782f8c45d521c162421c18e647f75ff27 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Thu, 11 Nov 2021 04:18:22 +0100 Subject: [PATCH 05/26] cmd/evm: add test to t8n test runner --- cmd/evm/internal/t8ntool/block.go | 6 +-- cmd/evm/internal/t8ntool/flags.go | 2 +- cmd/evm/t8n_test.go | 87 +++++++++++++++++++++++++++++++ cmd/evm/testdata/20/exp.json | 4 ++ cmd/evm/testdata/20/readme.md | 6 +-- 5 files changed, 98 insertions(+), 7 deletions(-) create mode 100644 cmd/evm/testdata/20/exp.json diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 510987134ea9..6cd019489fb1 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -71,10 +71,10 @@ type blockInput struct { UnclesRlp []string `json:"uncles,omitempty"` TxRlp string `json:"txsRlp,omitempty"` Clique *cliqueInput `json:"clique,omitempty"` - EthashDir string - Uncles []*types.Header - Txs []*types.Transaction + EthashDir string + Uncles []*types.Header + Txs []*types.Transaction } type cliqueInput struct { diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go index 474d53aa0920..c923e1a9888d 100644 --- a/cmd/evm/internal/t8ntool/flags.go +++ b/cmd/evm/internal/t8ntool/flags.go @@ -104,7 +104,7 @@ var ( Value: "uncles.json", } InputTxsRlpFlag = cli.StringFlag{ - Name: "input.txsRlp", + Name: "input.txs", Usage: "`stdin` or file name of where to find the transactions list in RLP form.", Value: "txs.rlp", } diff --git a/cmd/evm/t8n_test.go b/cmd/evm/t8n_test.go index b4b816f57a25..afdae01cc7ce 100644 --- a/cmd/evm/t8n_test.go +++ b/cmd/evm/t8n_test.go @@ -336,6 +336,93 @@ func TestT9n(t *testing.T) { } } +type b11rInput struct { + inEnv string + inUnclesRlp string + inTxsRlp string + inClique string + ethash bool + ethashDir string +} + +func (args *b11rInput) get(base string) []string { + var out []string + if opt := args.inEnv; opt != "" { + out = append(out, "--input.header") + out = append(out, fmt.Sprintf("%v/%v", base, opt)) + } + if opt := args.inUnclesRlp; opt != "" { + out = append(out, "--input.uncles") + out = append(out, fmt.Sprintf("%v/%v", base, opt)) + } + if opt := args.inTxsRlp; opt != "" { + out = append(out, "--input.txs") + out = append(out, fmt.Sprintf("%v/%v", base, opt)) + } + if opt := args.inClique; opt != "" { + out = append(out, "--input.clique") + out = append(out, fmt.Sprintf("%v/%v", base, opt)) + } + if args.ethash { + out = append(out, "--input.ethash") + } + if opt := args.ethashDir; opt != "" { + out = append(out, "--ethash.dir") + out = append(out, fmt.Sprintf("%v/%v", base, opt)) + } + out = append(out, "--output.block") + out = append(out, "stdout") + return out +} + +func TestB11r(t *testing.T) { + tt := new(testT8n) + tt.TestCmd = cmdtest.NewTestCmd(t, tt) + for i, tc := range []struct { + base string + input b11rInput + expExitCode int + expOut string + }{ + { // TODO description + base: "./testdata/20", + input: b11rInput{ + inEnv: "header.json", + inUnclesRlp: "uncles.json", + inTxsRlp: "txs.rlp", + }, + expOut: "exp.json", + }, + } { + + args := []string{"b11r"} + args = append(args, tc.input.get(tc.base)...) + + tt.Run("evm-test", args...) + tt.Logf("args:\n go run . %v\n", strings.Join(args, " ")) + // Compare the expected output, if provided + if tc.expOut != "" { + want, err := os.ReadFile(fmt.Sprintf("%v/%v", tc.base, tc.expOut)) + if err != nil { + t.Fatalf("test %d: could not read expected output: %v", i, err) + } + have := tt.Output() + ok, err := cmpJson(have, want) + switch { + case err != nil: + t.Logf(string(have)) + t.Fatalf("test %d, json parsing failed: %v", i, err) + case !ok: + t.Fatalf("test %d: output wrong, have \n%v\nwant\n%v\n", i, string(have), string(want)) + } + } + tt.WaitExit() + if have, want := tt.ExitStatus(), tc.expExitCode; have != want { + t.Fatalf("test %d: wrong exit code, have %d, want %d", i, have, want) + } + } +} + // cmpJson compares the JSON in two byte slices. func cmpJson(a, b []byte) (bool, error) { var j, j2 interface{} diff --git a/cmd/evm/testdata/20/exp.json b/cmd/evm/testdata/20/exp.json new file mode 100644 index 000000000000..30cc3950ec51 --- /dev/null +++ b/cmd/evm/testdata/20/exp.json @@ -0,0 +1,4 @@ +{ + "rlp": "0xf90216f90211a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794e997a23b159e2e2a5ce72333262972374b15425ca0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e99476574682f76312e302e312f6c696e75782f676f312e342e32a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf8897435673d874f7c8c0c0", + "hash": "0xaba9a3b6a4e96e9ecffcadaa5a2ae0589359455617535cd86589fe1dd26fe899" +} diff --git a/cmd/evm/testdata/20/readme.md b/cmd/evm/testdata/20/readme.md index d519a1fa21e4..6acadb8f9555 100644 --- a/cmd/evm/testdata/20/readme.md +++ b/cmd/evm/testdata/20/readme.md @@ -4,9 +4,9 @@ This test shows how `b11r` can be used to assemble an unsealed block. ```console -$ go run . b11r --input.header=testdata/20/header.json --input.txsRlp=testdata/20/txs.rlp --input.uncles=testdata/20/uncles.json --output.block=stdout +$ go run . b11r --input.header=testdata/20/header.json --input.txs=testdata/20/txs.rlp --input.uncles=testdata/20/uncles.json --output.block=stdout { - "rlp": "0xf9021af90215a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794e997a23b159e2e2a5ce72333262972374b15425ca0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000086015fafff0c9182c3be83050785808455c5277e99476574682f76312e302e312f6c696e75782f676f312e342e32a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf8897435673d874f7c8c0c0", - "hash": "0x263ef16f9d26696f43d6274e3a22947844ab80201fb469cdf5da4451509be234" + "rlp": "0xf90216f90211a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794e997a23b159e2e2a5ce72333262972374b15425ca0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e99476574682f76312e302e312f6c696e75782f676f312e342e32a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf8897435673d874f7c8c0c0", + "hash": "0xaba9a3b6a4e96e9ecffcadaa5a2ae0589359455617535cd86589fe1dd26fe899" } ``` From baca6d58add83df4058e3e47ee623adf9fbb782a Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Thu, 11 Nov 2021 04:34:57 +0100 Subject: [PATCH 06/26] cmd/evm: cleanup b11r cli interface --- cmd/evm/internal/t8ntool/block.go | 9 ++++----- cmd/evm/internal/t8ntool/flags.go | 19 +++++++------------ cmd/evm/main.go | 5 ++--- 3 files changed, 13 insertions(+), 20 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 6cd019489fb1..f991897e9936 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -251,17 +251,16 @@ func readInput(ctx *cli.Context) (*blockInput, error) { headerStr = ctx.String(InputHeaderFlag.Name) unclesStr = ctx.String(InputUnclesFlag.Name) txsStr = ctx.String(InputTxsRlpFlag.Name) - cliqueStr = ctx.String(InputCliqueFlag.Name) - ethash = ctx.Bool(InputEthashFlag.Name) - ethashDir = ctx.String(InputEthashDirFlag.Name) + cliqueStr = ctx.String(SealerCliqueFlag.Name) + ethashDir = ctx.String(SealerEthashDirFlag.Name) inputData = &blockInput{} ) - if ethash && cliqueStr != "" { + if ethashDir != "" && cliqueStr != "" { return nil, NewError(ErrorJson, fmt.Errorf("both ethash and clique sealing specified, only one may be chosen")) } - if ethash && ethashDir != "" { + if ethashDir != "" { inputData.EthashDir = ethashDir } diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go index c923e1a9888d..9e10861af735 100644 --- a/cmd/evm/internal/t8ntool/flags.go +++ b/cmd/evm/internal/t8ntool/flags.go @@ -100,7 +100,7 @@ var ( } InputUnclesFlag = cli.StringFlag{ Name: "input.uncles", - Usage: "`stdin` or file name of where to find the uncle headers to use.", + Usage: "`stdin` or file name of where to find the list of uncle header RLPs to use.", Value: "uncles.json", } InputTxsRlpFlag = cli.StringFlag{ @@ -108,18 +108,13 @@ var ( Usage: "`stdin` or file name of where to find the transactions list in RLP form.", Value: "txs.rlp", } - InputCliqueFlag = cli.StringFlag{ - Name: "input.clique", - Usage: "`stdin` or file name of where to find the Clique sealing data.", + SealerCliqueFlag = cli.StringFlag{ + Name: "sealer.clique", + Usage: "Seal block with Clique. `stdin` or file name of where to find the Clique sealing data.", } - InputEthashFlag = cli.BoolFlag{ - Name: "input.ethash", - Usage: "Flag denoting whether a proof-of-work seal should be mined.", - } - InputEthashDirFlag = cli.StringFlag{ - Name: "ethash.dir", - Usage: "Location of ethash DAG. If none exists at the destination, a new DAG will be generated.", - Value: "ethash", + SealerEthashDirFlag = cli.StringFlag{ + Name: "sealer.ethash", + Usage: "Seal block with ethash. Path to ethash DAG. If none exists, a new DAG will be generated.", } RewardFlag = cli.Int64Flag{ Name: "state.reward", diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 3e2bb9fc7948..7fa58dbe9f31 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -178,9 +178,8 @@ var blockBuilderCommand = cli.Command{ t8ntool.InputHeaderFlag, t8ntool.InputUnclesFlag, t8ntool.InputTxsRlpFlag, - t8ntool.InputCliqueFlag, - t8ntool.InputEthashFlag, - t8ntool.InputEthashDirFlag, + t8ntool.SealerCliqueFlag, + t8ntool.SealerEthashDirFlag, t8ntool.VerbosityFlag, }, } From b8a3661d876015e432370f43d930b552bb3274aa Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Thu, 11 Nov 2021 16:18:31 +0100 Subject: [PATCH 07/26] cmd/evm: add pow mode option to b11r --- cmd/evm/internal/t8ntool/block.go | 32 +++++++++++++++++++++---------- cmd/evm/internal/t8ntool/flags.go | 13 +++++++++++-- cmd/evm/main.go | 2 ++ 3 files changed, 35 insertions(+), 12 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index f991897e9936..56fd1e917c3b 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -73,8 +73,9 @@ type blockInput struct { Clique *cliqueInput `json:"clique,omitempty"` EthashDir string - Uncles []*types.Header + PowMode ethash.Mode Txs []*types.Transaction + Uncles []*types.Header } type cliqueInput struct { @@ -167,7 +168,7 @@ func (i *blockInput) toBlock() (*types.Block, error) { return nil, NewError(ErrorJson, fmt.Errorf("Sealing with ethash will overwrite specified nonce")) } ethashConfig := ethash.Config{ - PowMode: ethash.ModeNormal, + PowMode: i.PowMode, DatasetDir: i.EthashDir, CacheDir: i.EthashDir, DatasetsInMem: 1, @@ -248,20 +249,31 @@ func BuildBlock(ctx *cli.Context) error { func readInput(ctx *cli.Context) (*blockInput, error) { var ( - headerStr = ctx.String(InputHeaderFlag.Name) - unclesStr = ctx.String(InputUnclesFlag.Name) - txsStr = ctx.String(InputTxsRlpFlag.Name) - cliqueStr = ctx.String(SealerCliqueFlag.Name) - ethashDir = ctx.String(SealerEthashDirFlag.Name) - inputData = &blockInput{} + headerStr = ctx.String(InputHeaderFlag.Name) + unclesStr = ctx.String(InputUnclesFlag.Name) + txsStr = ctx.String(InputTxsRlpFlag.Name) + cliqueStr = ctx.String(SealerCliqueFlag.Name) + ethashOn = ctx.Bool(SealerEthashFlag.Name) + ethashDir = ctx.String(SealerEthashDirFlag.Name) + ethashMode = ctx.String(SealerEthashModeFlag.Name) + inputData = &blockInput{} ) - if ethashDir != "" && cliqueStr != "" { + if ethashOn && cliqueStr != "" { return nil, NewError(ErrorJson, fmt.Errorf("both ethash and clique sealing specified, only one may be chosen")) } - if ethashDir != "" { + if ethashOn { inputData.EthashDir = ethashDir + switch ethashMode { + case "normal": + inputData.PowMode = ethash.ModeNormal + case "test": + inputData.PowMode = ethash.ModeTest + default: + return nil, NewError(ErrorJson, fmt.Errorf("unknown pow mode: %s", ethashMode)) + + } } if headerStr == stdinSelector || unclesStr == stdinSelector || txsStr == stdinSelector || cliqueStr == stdinSelector { diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go index 9e10861af735..f5c38431e316 100644 --- a/cmd/evm/internal/t8ntool/flags.go +++ b/cmd/evm/internal/t8ntool/flags.go @@ -112,9 +112,18 @@ var ( Name: "sealer.clique", Usage: "Seal block with Clique. `stdin` or file name of where to find the Clique sealing data.", } - SealerEthashDirFlag = cli.StringFlag{ + SealerEthashFlag = cli.BoolFlag{ Name: "sealer.ethash", - Usage: "Seal block with ethash. Path to ethash DAG. If none exists, a new DAG will be generated.", + Usage: "Seal block with ethash.", + } + SealerEthashDirFlag = cli.StringFlag{ + Name: "sealer.ethash.dir", + Usage: "Path to ethash DAG. If none exists, a new DAG will be generated.", + } + SealerEthashModeFlag = cli.StringFlag{ + Name: "sealer.ethash.mode", + Usage: "Defines the type and amount of PoW verification an ethash engine makes.", + Value: "normal", } RewardFlag = cli.Int64Flag{ Name: "state.reward", diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 7fa58dbe9f31..b95b9d7d8b0c 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -179,7 +179,9 @@ var blockBuilderCommand = cli.Command{ t8ntool.InputUnclesFlag, t8ntool.InputTxsRlpFlag, t8ntool.SealerCliqueFlag, + t8ntool.SealerEthashFlag, t8ntool.SealerEthashDirFlag, + t8ntool.SealerEthashModeFlag, t8ntool.VerbosityFlag, }, } From a81ff0d60b58aa059dbe2ce8c5d7c6be0e10e35c Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Thu, 11 Nov 2021 16:34:13 +0100 Subject: [PATCH 08/26] cmd/evm: transactions weren't being included in block encoding --- cmd/evm/internal/t8ntool/block.go | 5 +++-- cmd/evm/testdata/20/exp.json | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 56fd1e917c3b..3d3741a4777d 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -161,7 +161,7 @@ func (i *blockInput) toBlock() (*types.Block, error) { } block := types.NewBlockWithHeader(header) - block.WithBody(i.Txs, i.Uncles) + block = block.WithBody(i.Txs, i.Uncles) if i.EthashDir != "" { if i.Env.Nonce != nil { @@ -332,6 +332,7 @@ func readInput(ctx *cli.Context) (*blockInput, error) { if err != nil { return nil, NewError(ErrorJson, fmt.Errorf("unable to decode transaction from rlp data: %v", err)) } + inputData.Txs = txs return inputData, nil } @@ -387,7 +388,7 @@ func readTxsRlp(path string) (string, error) { if path == stdinSelector { decoder := json.NewDecoder(os.Stdin) - if err := decoder.Decode(txsRlp); err != nil { + if err := decoder.Decode(&txsRlp); err != nil { return "", NewError(ErrorJson, fmt.Errorf("failed unmarshaling txs from stdin: %v", err)) } } else { diff --git a/cmd/evm/testdata/20/exp.json b/cmd/evm/testdata/20/exp.json index 30cc3950ec51..7bec6cefd695 100644 --- a/cmd/evm/testdata/20/exp.json +++ b/cmd/evm/testdata/20/exp.json @@ -1,4 +1,4 @@ { - "rlp": "0xf90216f90211a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794e997a23b159e2e2a5ce72333262972374b15425ca0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e99476574682f76312e302e312f6c696e75782f676f312e342e32a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf8897435673d874f7c8c0c0", + "rlp": "0xf902d9f90211a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794e997a23b159e2e2a5ce72333262972374b15425ca0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e99476574682f76312e302e312f6c696e75782f676f312e342e32a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf8897435673d874f7c8f8c2f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600c0", "hash": "0xaba9a3b6a4e96e9ecffcadaa5a2ae0589359455617535cd86589fe1dd26fe899" } From 4df13752e1c2e83b1a98a4249aa944d34dea8668 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Fri, 12 Nov 2021 22:17:00 +0100 Subject: [PATCH 09/26] cmd/evm: add ethash and clique sealer tests --- cmd/evm/internal/t8ntool/block.go | 19 ++++++++++------- cmd/evm/t8n_test.go | 32 +++++++++++++++++++++++++---- cmd/evm/testdata/21/exp-clique.json | 4 ++++ cmd/evm/testdata/21/exp.json | 4 ++++ 4 files changed, 48 insertions(+), 11 deletions(-) create mode 100644 cmd/evm/testdata/21/exp-clique.json create mode 100644 cmd/evm/testdata/21/exp.json diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 3d3741a4777d..fba88f94ac60 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -72,6 +72,7 @@ type blockInput struct { TxRlp string `json:"txsRlp,omitempty"` Clique *cliqueInput `json:"clique,omitempty"` + Ethash bool EthashDir string PowMode ethash.Mode Txs []*types.Transaction @@ -81,7 +82,7 @@ type blockInput struct { type cliqueInput struct { Key *ecdsa.PrivateKey Voted *common.Address - Authorized bool + Authorized *bool Vanity common.Hash } @@ -107,7 +108,7 @@ func (c *cliqueInput) UnmarshalJSON(input []byte) error { // Now, read the rest of object type others struct { Voted *common.Address `json:"voted"` - Authorized bool `json:"authorized"` + Authorized *bool `json:"authorized"` Vanity common.Hash `json:"vanity"` } var x others @@ -163,7 +164,7 @@ func (i *blockInput) toBlock() (*types.Block, error) { block := types.NewBlockWithHeader(header) block = block.WithBody(i.Txs, i.Uncles) - if i.EthashDir != "" { + if i.Ethash { if i.Env.Nonce != nil { return nil, NewError(ErrorJson, fmt.Errorf("Sealing with ethash will overwrite specified nonce")) } @@ -197,15 +198,18 @@ func (i *blockInput) toBlock() (*types.Block, error) { if i.Env.Coinbase != nil { return nil, NewError(ErrorJson, fmt.Errorf("Sealing with clique and voting will overwrite specified coinbase")) } + header.Coinbase = *i.Clique.Voted + } + + if i.Clique.Authorized != nil { if i.Env.Nonce != nil { return nil, NewError(ErrorJson, fmt.Errorf("Sealing with clique and voting will overwrite specified nonce")) } - header.Coinbase = *i.Clique.Voted - if i.Clique.Authorized { - header.Nonce = [8]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} - } else { + if *i.Clique.Authorized { header.Nonce = [8]byte{} + } else { + header.Nonce = [8]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} } } @@ -264,6 +268,7 @@ func readInput(ctx *cli.Context) (*blockInput, error) { } if ethashOn { + inputData.Ethash = ethashOn inputData.EthashDir = ethashDir switch ethashMode { case "normal": diff --git a/cmd/evm/t8n_test.go b/cmd/evm/t8n_test.go index afdae01cc7ce..c9b31a557c8b 100644 --- a/cmd/evm/t8n_test.go +++ b/cmd/evm/t8n_test.go @@ -342,6 +342,7 @@ type b11rInput struct { inTxsRlp string inClique string ethash bool + ethashMode string ethashDir string } @@ -360,14 +361,18 @@ func (args *b11rInput) get(base string) []string { out = append(out, fmt.Sprintf("%v/%v", base, opt)) } if opt := args.inClique; opt != "" { - out = append(out, "--input.clique") + out = append(out, "--sealer.clique") out = append(out, fmt.Sprintf("%v/%v", base, opt)) } if args.ethash { - out = append(out, "--input.ethash") + out = append(out, "--sealer.ethash") + } + if opt := args.ethashMode; opt != "" { + out = append(out, "--sealer.ethash.mode") + out = append(out, fmt.Sprintf("%v/%v", base, opt)) } if opt := args.ethashDir; opt != "" { - out = append(out, "--ethash.dir") + out = append(out, "--sealer.ethash.dir") out = append(out, fmt.Sprintf("%v/%v", base, opt)) } out = append(out, "--output.block") @@ -384,7 +389,7 @@ func TestB11r(t *testing.T) { expExitCode int expOut string }{ - { // TODO description + { // unsealed block base: "./testdata/20", input: b11rInput{ inEnv: "header.json", @@ -393,6 +398,25 @@ func TestB11r(t *testing.T) { }, expOut: "exp.json", }, + { // ethash test seal + base: "./testdata/21", + input: b11rInput{ + inEnv: "header.json", + inUnclesRlp: "uncles.json", + inTxsRlp: "txs.rlp", + }, + expOut: "exp.json", + }, + { // clique test seal + base: "./testdata/21", + input: b11rInput{ + inEnv: "header.json", + inUnclesRlp: "uncles.json", + inTxsRlp: "txs.rlp", + inClique: "clique.json", + }, + expOut: "exp-clique.json", + }, } { args := []string{"b11r"} diff --git a/cmd/evm/testdata/21/exp-clique.json b/cmd/evm/testdata/21/exp-clique.json new file mode 100644 index 000000000000..72b7a130903a --- /dev/null +++ b/cmd/evm/testdata/21/exp-clique.json @@ -0,0 +1,4 @@ +{ + "rlp": "0xf90322f9025aa0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277eb861aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac540a67aaee364005841da84f488f6b6d0116dfb5103d091402c81a163d5f66666595e37f56f196d8c5c98da714dbfae68d6b7e1790cc734a20ec6ce52213ad800a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf88fffffffffffffffff8c2f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600c0", + "hash": "0x71c59102cc805dbe8741e1210ebe229a321eff144ac7276006fefe39e8357dc7" +} diff --git a/cmd/evm/testdata/21/exp.json b/cmd/evm/testdata/21/exp.json new file mode 100644 index 000000000000..9226fa501412 --- /dev/null +++ b/cmd/evm/testdata/21/exp.json @@ -0,0 +1,4 @@ +{ + "rlp": "0xf902c0f901f8a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e80a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf880000000000000000f8c2f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600c0", + "hash": "0x801411e9f6609a659825690d13e4f75a3cfe9143952fa2d9573f3b0a5eb9ebbb" +} From e15ac911822a811024335159fdc3a29b4694bc61 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Sat, 13 Nov 2021 05:29:01 +0100 Subject: [PATCH 10/26] cmd/evm: simpler sealing flag, add readme for sealing test case --- cmd/evm/internal/t8ntool/block.go | 8 ++++---- cmd/evm/internal/t8ntool/flags.go | 16 ++++++++-------- cmd/evm/main.go | 8 ++++---- cmd/evm/t8n_test.go | 8 ++++---- cmd/evm/testdata/20/readme.md | 1 - cmd/evm/testdata/21/exp-clique.json | 2 +- cmd/evm/testdata/21/exp.json | 2 +- cmd/evm/testdata/21/readme.md | 21 ++++++++++++++++----- cmd/evm/testdata/21/txs.rlp | 2 +- 9 files changed, 39 insertions(+), 29 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index fba88f94ac60..566e40b9caf4 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -256,10 +256,10 @@ func readInput(ctx *cli.Context) (*blockInput, error) { headerStr = ctx.String(InputHeaderFlag.Name) unclesStr = ctx.String(InputUnclesFlag.Name) txsStr = ctx.String(InputTxsRlpFlag.Name) - cliqueStr = ctx.String(SealerCliqueFlag.Name) - ethashOn = ctx.Bool(SealerEthashFlag.Name) - ethashDir = ctx.String(SealerEthashDirFlag.Name) - ethashMode = ctx.String(SealerEthashModeFlag.Name) + cliqueStr = ctx.String(SealCliqueFlag.Name) + ethashOn = ctx.Bool(SealEthashFlag.Name) + ethashDir = ctx.String(SealEthashDirFlag.Name) + ethashMode = ctx.String(SealEthashModeFlag.Name) inputData = &blockInput{} ) diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go index f5c38431e316..5add9d3baa1c 100644 --- a/cmd/evm/internal/t8ntool/flags.go +++ b/cmd/evm/internal/t8ntool/flags.go @@ -108,20 +108,20 @@ var ( Usage: "`stdin` or file name of where to find the transactions list in RLP form.", Value: "txs.rlp", } - SealerCliqueFlag = cli.StringFlag{ - Name: "sealer.clique", + SealCliqueFlag = cli.StringFlag{ + Name: "seal.clique", Usage: "Seal block with Clique. `stdin` or file name of where to find the Clique sealing data.", } - SealerEthashFlag = cli.BoolFlag{ - Name: "sealer.ethash", + SealEthashFlag = cli.BoolFlag{ + Name: "seal.ethash", Usage: "Seal block with ethash.", } - SealerEthashDirFlag = cli.StringFlag{ - Name: "sealer.ethash.dir", + SealEthashDirFlag = cli.StringFlag{ + Name: "seal.ethash.dir", Usage: "Path to ethash DAG. If none exists, a new DAG will be generated.", } - SealerEthashModeFlag = cli.StringFlag{ - Name: "sealer.ethash.mode", + SealEthashModeFlag = cli.StringFlag{ + Name: "seal.ethash.mode", Usage: "Defines the type and amount of PoW verification an ethash engine makes.", Value: "normal", } diff --git a/cmd/evm/main.go b/cmd/evm/main.go index b95b9d7d8b0c..636437a28a99 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -178,10 +178,10 @@ var blockBuilderCommand = cli.Command{ t8ntool.InputHeaderFlag, t8ntool.InputUnclesFlag, t8ntool.InputTxsRlpFlag, - t8ntool.SealerCliqueFlag, - t8ntool.SealerEthashFlag, - t8ntool.SealerEthashDirFlag, - t8ntool.SealerEthashModeFlag, + t8ntool.SealCliqueFlag, + t8ntool.SealEthashFlag, + t8ntool.SealEthashDirFlag, + t8ntool.SealEthashModeFlag, t8ntool.VerbosityFlag, }, } diff --git a/cmd/evm/t8n_test.go b/cmd/evm/t8n_test.go index c9b31a557c8b..656557c762f6 100644 --- a/cmd/evm/t8n_test.go +++ b/cmd/evm/t8n_test.go @@ -361,18 +361,18 @@ func (args *b11rInput) get(base string) []string { out = append(out, fmt.Sprintf("%v/%v", base, opt)) } if opt := args.inClique; opt != "" { - out = append(out, "--sealer.clique") + out = append(out, "--seal.clique") out = append(out, fmt.Sprintf("%v/%v", base, opt)) } if args.ethash { - out = append(out, "--sealer.ethash") + out = append(out, "--seal.ethash") } if opt := args.ethashMode; opt != "" { - out = append(out, "--sealer.ethash.mode") + out = append(out, "--seal.ethash.mode") out = append(out, fmt.Sprintf("%v/%v", base, opt)) } if opt := args.ethashDir; opt != "" { - out = append(out, "--sealer.ethash.dir") + out = append(out, "--seal.ethash.dir") out = append(out, fmt.Sprintf("%v/%v", base, opt)) } out = append(out, "--output.block") diff --git a/cmd/evm/testdata/20/readme.md b/cmd/evm/testdata/20/readme.md index 6acadb8f9555..261d9adae505 100644 --- a/cmd/evm/testdata/20/readme.md +++ b/cmd/evm/testdata/20/readme.md @@ -2,7 +2,6 @@ This test shows how `b11r` can be used to assemble an unsealed block. - ```console $ go run . b11r --input.header=testdata/20/header.json --input.txs=testdata/20/txs.rlp --input.uncles=testdata/20/uncles.json --output.block=stdout { diff --git a/cmd/evm/testdata/21/exp-clique.json b/cmd/evm/testdata/21/exp-clique.json index 72b7a130903a..c990ba8aa6ba 100644 --- a/cmd/evm/testdata/21/exp-clique.json +++ b/cmd/evm/testdata/21/exp-clique.json @@ -1,4 +1,4 @@ { - "rlp": "0xf90322f9025aa0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277eb861aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac540a67aaee364005841da84f488f6b6d0116dfb5103d091402c81a163d5f66666595e37f56f196d8c5c98da714dbfae68d6b7e1790cc734a20ec6ce52213ad800a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf88fffffffffffffffff8c2f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600c0", + "rlp": "0xf9025ff9025aa0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277eb861aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac540a67aaee364005841da84f488f6b6d0116dfb5103d091402c81a163d5f66666595e37f56f196d8c5c98da714dbfae68d6b7e1790cc734a20ec6ce52213ad800a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf88ffffffffffffffffc0c0", "hash": "0x71c59102cc805dbe8741e1210ebe229a321eff144ac7276006fefe39e8357dc7" } diff --git a/cmd/evm/testdata/21/exp.json b/cmd/evm/testdata/21/exp.json index 9226fa501412..b3e5e7a83118 100644 --- a/cmd/evm/testdata/21/exp.json +++ b/cmd/evm/testdata/21/exp.json @@ -1,4 +1,4 @@ { - "rlp": "0xf902c0f901f8a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e80a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf880000000000000000f8c2f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600c0", + "rlp": "0xf901fdf901f8a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e80a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf880000000000000000c0c0", "hash": "0x801411e9f6609a659825690d13e4f75a3cfe9143952fa2d9573f3b0a5eb9ebbb" } diff --git a/cmd/evm/testdata/21/readme.md b/cmd/evm/testdata/21/readme.md index d519a1fa21e4..cbf23f4a8375 100644 --- a/cmd/evm/testdata/21/readme.md +++ b/cmd/evm/testdata/21/readme.md @@ -1,12 +1,23 @@ -# Block building +# Sealed block building -This test shows how `b11r` can be used to assemble an unsealed block. +This test shows how `b11r` can be used to assemble a sealed block. +## Ethash ```console -$ go run . b11r --input.header=testdata/20/header.json --input.txsRlp=testdata/20/txs.rlp --input.uncles=testdata/20/uncles.json --output.block=stdout +$ go run . b11r --input.header=testdata/21/header.json --input.txs=testdata/21/txs.rlp --input.uncles=testdata/21/uncles.json --seal.ethash --seal.ethash.mode=test --output.block=stdout { - "rlp": "0xf9021af90215a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794e997a23b159e2e2a5ce72333262972374b15425ca0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000086015fafff0c9182c3be83050785808455c5277e99476574682f76312e302e312f6c696e75782f676f312e342e32a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf8897435673d874f7c8c0c0", - "hash": "0x263ef16f9d26696f43d6274e3a22947844ab80201fb469cdf5da4451509be234" + "rlp": "0xf901fdf901f8a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e80a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf880000000000000000c0c0", + "hash": "0x801411e9f6609a659825690d13e4f75a3cfe9143952fa2d9573f3b0a5eb9ebbb" +} +``` + +## Clique + +```console +$ go run . b11r --input.header=testdata/21/header.json --input.txs=testdata/21/txs.rlp --input.uncles=testdata/21/uncles.json --seal.clique=testdata/21/clique.json --output.block=stdout +{ + "rlp": "0xf9025ff9025aa0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277eb861aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac540a67aaee364005841da84f488f6b6d0116dfb5103d091402c81a163d5f66666595e37f56f196d8c5c98da714dbfae68d6b7e1790cc734a20ec6ce52213ad800a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf88ffffffffffffffffc0c0", + "hash": "0x71c59102cc805dbe8741e1210ebe229a321eff144ac7276006fefe39e8357dc7" } ``` diff --git a/cmd/evm/testdata/21/txs.rlp b/cmd/evm/testdata/21/txs.rlp index 3599ff06542b..e815397b333b 100644 --- a/cmd/evm/testdata/21/txs.rlp +++ b/cmd/evm/testdata/21/txs.rlp @@ -1 +1 @@ -"0xf8c2f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600f85f8002825208948a8eafb1cf62bfbeb1741769dae1a9dd4799619201801ba09500e8ba27d3c33ca7764e107410f44cbd8c19794bde214d694683a7aa998cdba07235ae07e4bd6e0206d102b1f8979d6adab280466b6a82d2208ee08951f1f600" \ No newline at end of file +"c0" From 52a2e164f730e07c2de80df07b206df3b55ee4d9 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Sat, 13 Nov 2021 05:43:02 +0100 Subject: [PATCH 11/26] cmd/evm: use correct error codes --- cmd/evm/internal/t8ntool/block.go | 16 ++++++++-------- cmd/evm/internal/t8ntool/transition.go | 13 +++++++------ 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 566e40b9caf4..dbef5cc7e34b 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -166,7 +166,7 @@ func (i *blockInput) toBlock() (*types.Block, error) { if i.Ethash { if i.Env.Nonce != nil { - return nil, NewError(ErrorJson, fmt.Errorf("Sealing with ethash will overwrite specified nonce")) + return nil, NewError(ErrorConfig, fmt.Errorf("sealing with ethash will overwrite provided nonce")) } ethashConfig := ethash.Config{ PowMode: i.PowMode, @@ -192,18 +192,18 @@ func (i *blockInput) toBlock() (*types.Block, error) { header = block.Header() if i.Env.Extra != nil { - return nil, NewError(ErrorJson, fmt.Errorf("Sealing with clique will overwrite specified extra data")) + return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique will overwrite provided extra data")) } if i.Clique.Voted != nil { if i.Env.Coinbase != nil { - return nil, NewError(ErrorJson, fmt.Errorf("Sealing with clique and voting will overwrite specified coinbase")) + return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided coinbase")) } header.Coinbase = *i.Clique.Voted } if i.Clique.Authorized != nil { if i.Env.Nonce != nil { - return nil, NewError(ErrorJson, fmt.Errorf("Sealing with clique and voting will overwrite specified nonce")) + return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided nonce")) } if *i.Clique.Authorized { @@ -264,7 +264,7 @@ func readInput(ctx *cli.Context) (*blockInput, error) { ) if ethashOn && cliqueStr != "" { - return nil, NewError(ErrorJson, fmt.Errorf("both ethash and clique sealing specified, only one may be chosen")) + return nil, NewError(ErrorConfig, fmt.Errorf("both ethash and clique sealing specified, only one may be chosen")) } if ethashOn { @@ -276,7 +276,7 @@ func readInput(ctx *cli.Context) (*blockInput, error) { case "test": inputData.PowMode = ethash.ModeTest default: - return nil, NewError(ErrorJson, fmt.Errorf("unknown pow mode: %s", ethashMode)) + return nil, NewError(ErrorConfig, fmt.Errorf("unknown pow mode: %s", ethashMode)) } } @@ -318,7 +318,7 @@ func readInput(ctx *cli.Context) (*blockInput, error) { raw := common.FromHex(str) err := rlp.DecodeBytes(raw, &uncle) if err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("unable to decode uncle from rlp data: %v", err)) + return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode uncle from rlp data: %v", err)) } uncles = append(uncles, uncle) } @@ -335,7 +335,7 @@ func readInput(ctx *cli.Context) (*blockInput, error) { raw := common.FromHex(inputData.TxRlp) err := rlp.DecodeBytes(raw, &txs) if err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("unable to decode transaction from rlp data: %v", err)) + return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode transaction from rlp data: %v", err)) } inputData.Txs = txs diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go index 0ff4b944d154..2a3e58664f29 100644 --- a/cmd/evm/internal/t8ntool/transition.go +++ b/cmd/evm/internal/t8ntool/transition.go @@ -43,11 +43,12 @@ import ( const ( ErrorEVM = 2 - ErrorVMConfig = 3 + ErrorConfig = 3 ErrorMissingBlockhash = 4 ErrorJson = 10 ErrorIO = 11 + ErrorRlp = 12 stdinSelector = "stdin" ) @@ -183,7 +184,7 @@ func Transition(ctx *cli.Context) error { // Construct the chainconfig var chainConfig *params.ChainConfig if cConf, extraEips, err := tests.GetChainConfig(ctx.String(ForknameFlag.Name)); err != nil { - return NewError(ErrorVMConfig, fmt.Errorf("failed constructing chain configuration: %v", err)) + return NewError(ErrorConfig, fmt.Errorf("failed constructing chain configuration: %v", err)) } else { chainConfig = cConf vmConfig.ExtraEips = extraEips @@ -247,18 +248,18 @@ func Transition(ctx *cli.Context) error { // Sanity check, to not `panic` in state_transition if chainConfig.IsLondon(big.NewInt(int64(prestate.Env.Number))) { if prestate.Env.BaseFee == nil { - return NewError(ErrorVMConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section")) + return NewError(ErrorConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section")) } } if env := prestate.Env; env.Difficulty == nil { // If difficulty was not provided by caller, we need to calculate it. switch { case env.ParentDifficulty == nil: - return NewError(ErrorVMConfig, errors.New("currentDifficulty was not provided, and cannot be calculated due to missing parentDifficulty")) + return NewError(ErrorConfig, errors.New("currentDifficulty was not provided, and cannot be calculated due to missing parentDifficulty")) case env.Number == 0: - return NewError(ErrorVMConfig, errors.New("currentDifficulty needs to be provided for block number 0")) + return NewError(ErrorConfig, errors.New("currentDifficulty needs to be provided for block number 0")) case env.Timestamp <= env.ParentTimestamp: - return NewError(ErrorVMConfig, fmt.Errorf("currentDifficulty cannot be calculated -- currentTime (%d) needs to be after parent time (%d)", + return NewError(ErrorConfig, fmt.Errorf("currentDifficulty cannot be calculated -- currentTime (%d) needs to be after parent time (%d)", env.Timestamp, env.ParentTimestamp)) } prestate.Env.Difficulty = calcDifficulty(chainConfig, env.Number, env.Timestamp, From 692da9bdc65ea6c05cbf7315107e8cfe826f97be Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Sat, 13 Nov 2021 07:22:41 +0100 Subject: [PATCH 12/26] cmd/evm: fix bugs building block with ommer, some reorganization --- cmd/evm/internal/t8ntool/block.go | 33 +++++++++++++++++++------ cmd/evm/internal/t8ntool/transaction.go | 2 +- cmd/evm/t8n_test.go | 9 +++++++ cmd/evm/testdata/22/clique.json | 6 +++++ cmd/evm/testdata/22/exp-clique.json | 4 +++ cmd/evm/testdata/22/exp.json | 4 +++ cmd/evm/testdata/22/header.json | 11 +++++++++ cmd/evm/testdata/22/readme.md | 11 +++++++++ cmd/evm/testdata/22/txs.rlp | 1 + cmd/evm/testdata/22/uncles-empty.json | 1 + cmd/evm/testdata/22/uncles.json | 1 + 11 files changed, 75 insertions(+), 8 deletions(-) create mode 100644 cmd/evm/testdata/22/clique.json create mode 100644 cmd/evm/testdata/22/exp-clique.json create mode 100644 cmd/evm/testdata/22/exp.json create mode 100644 cmd/evm/testdata/22/header.json create mode 100644 cmd/evm/testdata/22/readme.md create mode 100644 cmd/evm/testdata/22/txs.rlp create mode 100644 cmd/evm/testdata/22/uncles-empty.json create mode 100644 cmd/evm/testdata/22/uncles.json diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index dbef5cc7e34b..5359cc396343 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -33,6 +33,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" + "golang.org/x/crypto/sha3" "gopkg.in/urfave/cli.v1" ) @@ -122,7 +123,7 @@ func (c *cliqueInput) UnmarshalJSON(input []byte) error { return nil } -func (i *blockInput) toBlock() (*types.Block, error) { +func (i *blockInput) ToBlock() *types.Block { header := &types.Header{ ParentHash: i.Env.ParentHash, UncleHash: types.EmptyUncleHash, @@ -141,9 +142,16 @@ func (i *blockInput) toBlock() (*types.Block, error) { BaseFee: i.Env.BaseFee, } - // Set optional values to specified values. + // Fill optional values. if i.Env.UncleHash != nil { header.UncleHash = *i.Env.UncleHash + } else if len(i.Uncles) != 0 { + // Calculate the ommer hash if none is provided and there are ommers to hash + sha := sha3.NewLegacyKeccak256().(crypto.KeccakState) + rlp.Encode(sha, i.Uncles) + h := make([]byte, 32) + sha.Read(h[:]) + header.UncleHash = common.BytesToHash(h) } if i.Env.Coinbase != nil { header.Coinbase = *i.Env.Coinbase @@ -164,6 +172,10 @@ func (i *blockInput) toBlock() (*types.Block, error) { block := types.NewBlockWithHeader(header) block = block.WithBody(i.Txs, i.Uncles) + return block +} + +func (i *blockInput) SealBlock(block *types.Block) (*types.Block, error) { if i.Ethash { if i.Env.Nonce != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with ethash will overwrite provided nonce")) @@ -189,7 +201,7 @@ func (i *blockInput) toBlock() (*types.Block, error) { block.WithSeal(found.Header()) } } else if i.Clique != nil { - header = block.Header() + header := block.Header() if i.Env.Extra != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique will overwrite provided extra data")) @@ -243,7 +255,8 @@ func BuildBlock(ctx *cli.Context) error { if err != nil { return err } - block, err := inputData.toBlock() + block := inputData.ToBlock() + block, err = inputData.SealBlock(block) if err != nil { return err } @@ -314,14 +327,20 @@ func readInput(ctx *cli.Context) (*blockInput, error) { uncles := []*types.Header{} for _, str := range inputData.UnclesRlp { - var uncle *types.Header + type extblock struct { + Header *types.Header + Txs []*types.Transaction + Uncles []*types.Header + } + var uncle *extblock raw := common.FromHex(str) err := rlp.DecodeBytes(raw, &uncle) if err != nil { return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode uncle from rlp data: %v", err)) } - uncles = append(uncles, uncle) + uncles = append(uncles, uncle.Header) } + inputData.Uncles = uncles if txsStr != stdinSelector { txs, err := readTxsRlp(txsStr) @@ -370,7 +389,7 @@ func readUncles(path string) ([]string, error) { if path == stdinSelector { decoder := json.NewDecoder(os.Stdin) - if err := decoder.Decode(uncles); err != nil { + if err := decoder.Decode(&uncles); err != nil { return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling uncles from stdin: %v", err)) } } else { diff --git a/cmd/evm/internal/t8ntool/transaction.go b/cmd/evm/internal/t8ntool/transaction.go index e4fe241084da..6f1c964ada02 100644 --- a/cmd/evm/internal/t8ntool/transaction.go +++ b/cmd/evm/internal/t8ntool/transaction.go @@ -82,7 +82,7 @@ func Transaction(ctx *cli.Context) error { ) // Construct the chainconfig if cConf, _, err := tests.GetChainConfig(ctx.String(ForknameFlag.Name)); err != nil { - return NewError(ErrorVMConfig, fmt.Errorf("failed constructing chain configuration: %v", err)) + return NewError(ErrorConfig, fmt.Errorf("failed constructing chain configuration: %v", err)) } else { chainConfig = cConf } diff --git a/cmd/evm/t8n_test.go b/cmd/evm/t8n_test.go index 656557c762f6..2f45f2afafc6 100644 --- a/cmd/evm/t8n_test.go +++ b/cmd/evm/t8n_test.go @@ -417,6 +417,15 @@ func TestB11r(t *testing.T) { }, expOut: "exp-clique.json", }, + { // block with ommers + base: "./testdata/22", + input: b11rInput{ + inEnv: "header.json", + inUnclesRlp: "uncles.json", + inTxsRlp: "txs.rlp", + }, + expOut: "exp.json", + }, } { args := []string{"b11r"} diff --git a/cmd/evm/testdata/22/clique.json b/cmd/evm/testdata/22/clique.json new file mode 100644 index 000000000000..a9f25639fc9b --- /dev/null +++ b/cmd/evm/testdata/22/clique.json @@ -0,0 +1,6 @@ +{ + "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8", + "voted": "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba", + "authorized": false, + "vanity": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +} diff --git a/cmd/evm/testdata/22/exp-clique.json b/cmd/evm/testdata/22/exp-clique.json new file mode 100644 index 000000000000..c990ba8aa6ba --- /dev/null +++ b/cmd/evm/testdata/22/exp-clique.json @@ -0,0 +1,4 @@ +{ + "rlp": "0xf9025ff9025aa0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277eb861aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac540a67aaee364005841da84f488f6b6d0116dfb5103d091402c81a163d5f66666595e37f56f196d8c5c98da714dbfae68d6b7e1790cc734a20ec6ce52213ad800a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf88ffffffffffffffffc0c0", + "hash": "0x71c59102cc805dbe8741e1210ebe229a321eff144ac7276006fefe39e8357dc7" +} diff --git a/cmd/evm/testdata/22/exp.json b/cmd/evm/testdata/22/exp.json new file mode 100644 index 000000000000..14fd81997d56 --- /dev/null +++ b/cmd/evm/testdata/22/exp.json @@ -0,0 +1,4 @@ +{ + "rlp": "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", + "hash": "0xd9a81c8fcd57a7f2a0d2c375eff6ad192c30c3729a271303f0a9a7e1b357e755" +} diff --git a/cmd/evm/testdata/22/header.json b/cmd/evm/testdata/22/header.json new file mode 100644 index 000000000000..62abe3cc2cc5 --- /dev/null +++ b/cmd/evm/testdata/22/header.json @@ -0,0 +1,11 @@ +{ + "parentHash": "0xd6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34e", + "stateRoot": "0x325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2e", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "difficulty": "0x1000", + "number": "0xc3be", + "gasLimit": "0x50785", + "gasUsed": "0x0", + "timestamp": "0x55c5277e", + "mixHash": "0x5865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf" +} diff --git a/cmd/evm/testdata/22/readme.md b/cmd/evm/testdata/22/readme.md new file mode 100644 index 000000000000..87db6095ffc3 --- /dev/null +++ b/cmd/evm/testdata/22/readme.md @@ -0,0 +1,11 @@ +# Building blocks with ommers + +This test shows how `b11r` can chain together ommer assembles into a canonical block. + +```console +$ echo "{ \"uncles\": [`go run . b11r --input.header=testdata/22/header.json --input.txs=testdata/22/txs.rlp --input.uncles=testdata/22/uncles.json --output.block=stdout | jq '.[\"rlp\"]'`,`go run . b11r --input.header=testdata/22/header.json --input.txs=testdata/22/txs.rlp --input.uncles=testdata/22/uncles.json --output.block=stdout | jq '.[\"rlp\"]'`]}" | go run . b11r --input.header=testdata/22/header.json --input.txs=testdata/22/txs.rlp --input.uncles=stdin --output.block=stdout +{ + "rlp": "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", + "hash": "0xd9a81c8fcd57a7f2a0d2c375eff6ad192c30c3729a271303f0a9a7e1b357e755" +} +``` diff --git a/cmd/evm/testdata/22/txs.rlp b/cmd/evm/testdata/22/txs.rlp new file mode 100644 index 000000000000..e815397b333b --- /dev/null +++ b/cmd/evm/testdata/22/txs.rlp @@ -0,0 +1 @@ +"c0" diff --git a/cmd/evm/testdata/22/uncles-empty.json b/cmd/evm/testdata/22/uncles-empty.json new file mode 100644 index 000000000000..fe51488c7066 --- /dev/null +++ b/cmd/evm/testdata/22/uncles-empty.json @@ -0,0 +1 @@ +[] diff --git a/cmd/evm/testdata/22/uncles.json b/cmd/evm/testdata/22/uncles.json new file mode 100644 index 000000000000..997015b3cedf --- /dev/null +++ b/cmd/evm/testdata/22/uncles.json @@ -0,0 +1 @@ +["0xf901fdf901f8a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e80a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf880000000000000000c0c0","0xf901fdf901f8a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e80a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf880000000000000000c0c0"] From ffd5c1880cceda5fd6301162445e147e933b5b9b Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Sat, 13 Nov 2021 07:53:02 +0100 Subject: [PATCH 13/26] cmd/evm: rename uncles to ommers --- cmd/evm/internal/t8ntool/block.go | 58 +++++++++---------- cmd/evm/internal/t8ntool/flags.go | 8 +-- cmd/evm/internal/t8ntool/gen_bbenv.go | 10 ++-- cmd/evm/main.go | 2 +- cmd/evm/t8n_test.go | 18 +++--- .../testdata/20/{uncles.json => ommers.json} | 0 .../testdata/21/{uncles.json => ommers.json} | 0 .../testdata/22/{uncles.json => ommers.json} | 0 8 files changed, 48 insertions(+), 48 deletions(-) rename cmd/evm/testdata/20/{uncles.json => ommers.json} (100%) rename cmd/evm/testdata/21/{uncles.json => ommers.json} (100%) rename cmd/evm/testdata/22/{uncles.json => ommers.json} (100%) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 5359cc396343..845aac12bc93 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -40,7 +40,7 @@ import ( //go:generate gencodec -type bbEnv -field-override bbEnvMarshaling -out gen_bbenv.go type bbEnv struct { ParentHash common.Hash `json:"parentHash"` - UncleHash *common.Hash `json:"sha3Uncles"` + OmmerHash *common.Hash `json:"sha3Ommers"` Coinbase *common.Address `json:"miner"` Root common.Hash `json:"stateRoot" gencodec:"required"` TxHash *common.Hash `json:"transactionsRoot"` @@ -69,7 +69,7 @@ type bbEnvMarshaling struct { type blockInput struct { Env *bbEnv `json:"header,omitempty"` - UnclesRlp []string `json:"uncles,omitempty"` + OmmersRlp []string `json:"ommers,omitempty"` TxRlp string `json:"txsRlp,omitempty"` Clique *cliqueInput `json:"clique,omitempty"` @@ -77,7 +77,7 @@ type blockInput struct { EthashDir string PowMode ethash.Mode Txs []*types.Transaction - Uncles []*types.Header + Ommers []*types.Header } type cliqueInput struct { @@ -143,12 +143,12 @@ func (i *blockInput) ToBlock() *types.Block { } // Fill optional values. - if i.Env.UncleHash != nil { - header.UncleHash = *i.Env.UncleHash - } else if len(i.Uncles) != 0 { + if i.Env.OmmerHash != nil { + header.UncleHash = *i.Env.OmmerHash + } else if len(i.Ommers) != 0 { // Calculate the ommer hash if none is provided and there are ommers to hash sha := sha3.NewLegacyKeccak256().(crypto.KeccakState) - rlp.Encode(sha, i.Uncles) + rlp.Encode(sha, i.Ommers) h := make([]byte, 32) sha.Read(h[:]) header.UncleHash = common.BytesToHash(h) @@ -170,7 +170,7 @@ func (i *blockInput) ToBlock() *types.Block { } block := types.NewBlockWithHeader(header) - block = block.WithBody(i.Txs, i.Uncles) + block = block.WithBody(i.Txs, i.Ommers) return block } @@ -267,7 +267,7 @@ func BuildBlock(ctx *cli.Context) error { func readInput(ctx *cli.Context) (*blockInput, error) { var ( headerStr = ctx.String(InputHeaderFlag.Name) - unclesStr = ctx.String(InputUnclesFlag.Name) + ommersStr = ctx.String(InputOmmersFlag.Name) txsStr = ctx.String(InputTxsRlpFlag.Name) cliqueStr = ctx.String(SealCliqueFlag.Name) ethashOn = ctx.Bool(SealEthashFlag.Name) @@ -294,7 +294,7 @@ func readInput(ctx *cli.Context) (*blockInput, error) { } } - if headerStr == stdinSelector || unclesStr == stdinSelector || txsStr == stdinSelector || cliqueStr == stdinSelector { + if headerStr == stdinSelector || ommersStr == stdinSelector || txsStr == stdinSelector || cliqueStr == stdinSelector { decoder := json.NewDecoder(os.Stdin) if err := decoder.Decode(inputData); err != nil { return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling stdin: %v", err)) @@ -317,30 +317,30 @@ func readInput(ctx *cli.Context) (*blockInput, error) { inputData.Env = env } - if unclesStr != stdinSelector { - uncles, err := readUncles(unclesStr) + if ommersStr != stdinSelector { + ommers, err := readOmmers(ommersStr) if err != nil { return nil, err } - inputData.UnclesRlp = uncles + inputData.OmmersRlp = ommers } - uncles := []*types.Header{} - for _, str := range inputData.UnclesRlp { + ommers := []*types.Header{} + for _, str := range inputData.OmmersRlp { type extblock struct { Header *types.Header Txs []*types.Transaction - Uncles []*types.Header + Ommers []*types.Header } - var uncle *extblock + var ommer *extblock raw := common.FromHex(str) - err := rlp.DecodeBytes(raw, &uncle) + err := rlp.DecodeBytes(raw, &ommer) if err != nil { - return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode uncle from rlp data: %v", err)) + return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode ommer from rlp data: %v", err)) } - uncles = append(uncles, uncle.Header) + ommers = append(ommers, ommer.Header) } - inputData.Uncles = uncles + inputData.Ommers = ommers if txsStr != stdinSelector { txs, err := readTxsRlp(txsStr) @@ -384,27 +384,27 @@ func readEnv(path string) (*bbEnv, error) { return env, nil } -func readUncles(path string) ([]string, error) { - uncles := []string{} +func readOmmers(path string) ([]string, error) { + ommers := []string{} if path == stdinSelector { decoder := json.NewDecoder(os.Stdin) - if err := decoder.Decode(&uncles); err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling uncles from stdin: %v", err)) + if err := decoder.Decode(&ommers); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling ommers from stdin: %v", err)) } } else { inFile, err := os.Open(path) if err != nil { - return nil, NewError(ErrorIO, fmt.Errorf("failed reading uncles file: %v", err)) + return nil, NewError(ErrorIO, fmt.Errorf("failed reading ommers file: %v", err)) } defer inFile.Close() decoder := json.NewDecoder(inFile) - if err := decoder.Decode(&uncles); err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling uncles file: %v", err)) + if err := decoder.Decode(&ommers); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling ommers file: %v", err)) } } - return uncles, nil + return ommers, nil } func readTxsRlp(path string) (string, error) { diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go index 5add9d3baa1c..790ca7b35604 100644 --- a/cmd/evm/internal/t8ntool/flags.go +++ b/cmd/evm/internal/t8ntool/flags.go @@ -98,10 +98,10 @@ var ( Usage: "`stdin` or file name of where to find the block header to use.", Value: "header.json", } - InputUnclesFlag = cli.StringFlag{ - Name: "input.uncles", - Usage: "`stdin` or file name of where to find the list of uncle header RLPs to use.", - Value: "uncles.json", + InputOmmersFlag = cli.StringFlag{ + Name: "input.ommers", + Usage: "`stdin` or file name of where to find the list of ommer header RLPs to use.", + Value: "ommers.json", } InputTxsRlpFlag = cli.StringFlag{ Name: "input.txs", diff --git a/cmd/evm/internal/t8ntool/gen_bbenv.go b/cmd/evm/internal/t8ntool/gen_bbenv.go index 105f4075faeb..f5dece602d8a 100644 --- a/cmd/evm/internal/t8ntool/gen_bbenv.go +++ b/cmd/evm/internal/t8ntool/gen_bbenv.go @@ -19,7 +19,7 @@ var _ = (*bbEnvMarshaling)(nil) func (b bbEnv) MarshalJSON() ([]byte, error) { type bbEnv struct { ParentHash common.Hash `json:"parentHash"` - UncleHash *common.Hash `json:"sha3Uncles"` + OmmerHash *common.Hash `json:"sha3Ommers"` Coinbase *common.Address `json:"miner"` Root common.Hash `json:"stateRoot" gencodec:"required"` TxHash *common.Hash `json:"transactionsRoot"` @@ -37,7 +37,7 @@ func (b bbEnv) MarshalJSON() ([]byte, error) { } var enc bbEnv enc.ParentHash = b.ParentHash - enc.UncleHash = b.UncleHash + enc.OmmerHash = b.OmmerHash enc.Coinbase = b.Coinbase enc.Root = b.Root enc.TxHash = b.TxHash @@ -59,7 +59,7 @@ func (b bbEnv) MarshalJSON() ([]byte, error) { func (b *bbEnv) UnmarshalJSON(input []byte) error { type bbEnv struct { ParentHash *common.Hash `json:"parentHash"` - UncleHash *common.Hash `json:"sha3Uncles"` + OmmerHash *common.Hash `json:"sha3Ommers"` Coinbase *common.Address `json:"miner"` Root *common.Hash `json:"stateRoot" gencodec:"required"` TxHash *common.Hash `json:"transactionsRoot"` @@ -82,8 +82,8 @@ func (b *bbEnv) UnmarshalJSON(input []byte) error { if dec.ParentHash != nil { b.ParentHash = *dec.ParentHash } - if dec.UncleHash != nil { - b.UncleHash = dec.UncleHash + if dec.OmmerHash != nil { + b.OmmerHash = dec.OmmerHash } if dec.Coinbase != nil { b.Coinbase = dec.Coinbase diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 636437a28a99..66d221a702e8 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -176,7 +176,7 @@ var blockBuilderCommand = cli.Command{ t8ntool.OutputBasedir, t8ntool.OutputBlockFlag, t8ntool.InputHeaderFlag, - t8ntool.InputUnclesFlag, + t8ntool.InputOmmersFlag, t8ntool.InputTxsRlpFlag, t8ntool.SealCliqueFlag, t8ntool.SealEthashFlag, diff --git a/cmd/evm/t8n_test.go b/cmd/evm/t8n_test.go index 2f45f2afafc6..3c759570f7a0 100644 --- a/cmd/evm/t8n_test.go +++ b/cmd/evm/t8n_test.go @@ -131,7 +131,7 @@ func TestT8n(t *testing.T) { output: t8nOutput{alloc: true, result: true}, expExitCode: 4, }, - { // Ommer test + { // Uncle test base: "./testdata/5", input: t8nInput{ "alloc.json", "txs.json", "env.json", "Byzantium", "0x80", @@ -171,7 +171,7 @@ func TestT8n(t *testing.T) { output: t8nOutput{result: true}, expOut: "exp2.json", }, - { // Difficulty calculation - with uncles + Berlin + { // Difficulty calculation - with ommers + Berlin base: "./testdata/14", input: t8nInput{ "alloc.json", "txs.json", "env.uncles.json", "Berlin", "", @@ -338,7 +338,7 @@ func TestT9n(t *testing.T) { type b11rInput struct { inEnv string - inUnclesRlp string + inOmmersRlp string inTxsRlp string inClique string ethash bool @@ -352,8 +352,8 @@ func (args *b11rInput) get(base string) []string { out = append(out, "--input.header") out = append(out, fmt.Sprintf("%v/%v", base, opt)) } - if opt := args.inUnclesRlp; opt != "" { - out = append(out, "--input.uncles") + if opt := args.inOmmersRlp; opt != "" { + out = append(out, "--input.ommers") out = append(out, fmt.Sprintf("%v/%v", base, opt)) } if opt := args.inTxsRlp; opt != "" { @@ -393,7 +393,7 @@ func TestB11r(t *testing.T) { base: "./testdata/20", input: b11rInput{ inEnv: "header.json", - inUnclesRlp: "uncles.json", + inOmmersRlp: "ommers.json", inTxsRlp: "txs.rlp", }, expOut: "exp.json", @@ -402,7 +402,7 @@ func TestB11r(t *testing.T) { base: "./testdata/21", input: b11rInput{ inEnv: "header.json", - inUnclesRlp: "uncles.json", + inOmmersRlp: "ommers.json", inTxsRlp: "txs.rlp", }, expOut: "exp.json", @@ -411,7 +411,7 @@ func TestB11r(t *testing.T) { base: "./testdata/21", input: b11rInput{ inEnv: "header.json", - inUnclesRlp: "uncles.json", + inOmmersRlp: "ommers.json", inTxsRlp: "txs.rlp", inClique: "clique.json", }, @@ -421,7 +421,7 @@ func TestB11r(t *testing.T) { base: "./testdata/22", input: b11rInput{ inEnv: "header.json", - inUnclesRlp: "uncles.json", + inOmmersRlp: "ommers.json", inTxsRlp: "txs.rlp", }, expOut: "exp.json", diff --git a/cmd/evm/testdata/20/uncles.json b/cmd/evm/testdata/20/ommers.json similarity index 100% rename from cmd/evm/testdata/20/uncles.json rename to cmd/evm/testdata/20/ommers.json diff --git a/cmd/evm/testdata/21/uncles.json b/cmd/evm/testdata/21/ommers.json similarity index 100% rename from cmd/evm/testdata/21/uncles.json rename to cmd/evm/testdata/21/ommers.json diff --git a/cmd/evm/testdata/22/uncles.json b/cmd/evm/testdata/22/ommers.json similarity index 100% rename from cmd/evm/testdata/22/uncles.json rename to cmd/evm/testdata/22/ommers.json From 49fe3fc748a1cfcaed13acf59dc1a5eaca71338c Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Sat, 13 Nov 2021 16:54:07 +0100 Subject: [PATCH 14/26] cmd/evm: appease gosimple --- cmd/evm/internal/t8ntool/block.go | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 845aac12bc93..4c06482b08c8 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -196,10 +196,8 @@ func (i *blockInput) SealBlock(block *types.Block) (*types.Block, error) { if err := engine.Seal(nil, block, results, nil); err != nil { panic(fmt.Sprintf("failed to seal block: %v", err)) } - select { - case found := <-results: - block.WithSeal(found.Header()) - } + found := <-results + block.WithSeal(found.Header()) } else if i.Clique != nil { header := block.Header() @@ -227,8 +225,8 @@ func (i *blockInput) SealBlock(block *types.Block) (*types.Block, error) { header.Extra = make([]byte, 97) copy(header.Extra[0:32], i.Clique.Vanity.Bytes()[:]) - h := clique.SealHash(header) + h := clique.SealHash(header) sighash, err := crypto.Sign(h[:], i.Clique.Key) if err != nil { return nil, err From 4dd0f839b99f65207f782316e5830feb5d04ca68 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Mon, 15 Nov 2021 21:47:10 +0100 Subject: [PATCH 15/26] cmd/evm: simplify input reader --- cmd/evm/internal/t8ntool/block.go | 111 +++++------------------------- 1 file changed, 19 insertions(+), 92 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 4c06482b08c8..81cc7281f73e 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -300,23 +300,26 @@ func readInput(ctx *cli.Context) (*blockInput, error) { } if cliqueStr != stdinSelector && cliqueStr != "" { - clique, err := readClique(cliqueStr) + var clique cliqueInput + err := readFile(cliqueStr, "clique", &clique) if err != nil { return nil, err } - inputData.Clique = clique + inputData.Clique = &clique } if headerStr != stdinSelector { - env, err := readEnv(headerStr) + var env bbEnv + err := readFile(headerStr, "header", &env) if err != nil { return nil, err } - inputData.Env = env + inputData.Env = &env } if ommersStr != stdinSelector { - ommers, err := readOmmers(ommersStr) + var ommers []string + err := readFile(ommersStr, "ommers", &ommers) if err != nil { return nil, err } @@ -341,7 +344,8 @@ func readInput(ctx *cli.Context) (*blockInput, error) { inputData.Ommers = ommers if txsStr != stdinSelector { - txs, err := readTxsRlp(txsStr) + var txs string + err := readFile(txsStr, "txs", &txs) if err != nil { return nil, err } @@ -359,96 +363,19 @@ func readInput(ctx *cli.Context) (*blockInput, error) { return inputData, nil } -func readEnv(path string) (*bbEnv, error) { - env := &bbEnv{} - - if path == stdinSelector { - decoder := json.NewDecoder(os.Stdin) - if err := decoder.Decode(env); err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling env from stdin: %v", err)) - } - } else { - inFile, err := os.Open(path) - if err != nil { - return nil, NewError(ErrorIO, fmt.Errorf("failed reading header file: %v", err)) - } - defer inFile.Close() - decoder := json.NewDecoder(inFile) - if err := decoder.Decode(&env); err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling header file: %v", err)) - } - } - - return env, nil -} - -func readOmmers(path string) ([]string, error) { - ommers := []string{} - - if path == stdinSelector { - decoder := json.NewDecoder(os.Stdin) - if err := decoder.Decode(&ommers); err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling ommers from stdin: %v", err)) - } - } else { - inFile, err := os.Open(path) - if err != nil { - return nil, NewError(ErrorIO, fmt.Errorf("failed reading ommers file: %v", err)) - } - defer inFile.Close() - decoder := json.NewDecoder(inFile) - if err := decoder.Decode(&ommers); err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling ommers file: %v", err)) - } - } - - return ommers, nil -} - -func readTxsRlp(path string) (string, error) { - txsRlp := "" - - if path == stdinSelector { - decoder := json.NewDecoder(os.Stdin) - if err := decoder.Decode(&txsRlp); err != nil { - return "", NewError(ErrorJson, fmt.Errorf("failed unmarshaling txs from stdin: %v", err)) - } - } else { - inFile, err := os.Open(path) - if err != nil { - return "", NewError(ErrorIO, fmt.Errorf("failed reading txs file: %v", err)) - } - defer inFile.Close() - decoder := json.NewDecoder(inFile) - if err := decoder.Decode(&txsRlp); err != nil { - return "", NewError(ErrorJson, fmt.Errorf("failed unmarshaling txs file: %v", err)) - } +func readFile(path, desc string, dest interface{}) error { + inFile, err := os.Open(path) + if err != nil { + return NewError(ErrorIO, fmt.Errorf("failed reading %s file: %v", desc, err)) } + defer inFile.Close() - return txsRlp, nil -} - -func readClique(path string) (*cliqueInput, error) { - clique := &cliqueInput{} - - if path == stdinSelector { - decoder := json.NewDecoder(os.Stdin) - if err := decoder.Decode(clique); err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling env from stdin: %v", err)) - } - } else { - inFile, err := os.Open(path) - if err != nil { - return nil, NewError(ErrorIO, fmt.Errorf("failed reading clique file: %v", err)) - } - defer inFile.Close() - decoder := json.NewDecoder(inFile) - if err := decoder.Decode(&clique); err != nil { - return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling clique file: %v", err)) - } + decoder := json.NewDecoder(inFile) + if err := decoder.Decode(dest); err != nil { + return NewError(ErrorJson, fmt.Errorf("failed unmarshaling %s file: %v", desc, err)) } - return clique, nil + return nil } // dispatchOutput writes the output data to either stderr or stdout, or to the specified From aabb0565f6db3279932a9efbe628d57b646ec332 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Mon, 15 Nov 2021 22:56:56 +0100 Subject: [PATCH 16/26] cmd/evm: make ommers input optional for b11r, cleanup uncle refs --- cmd/evm/internal/t8ntool/block.go | 3 +-- cmd/evm/internal/t8ntool/flags.go | 1 - cmd/evm/testdata/20/readme.md | 2 +- cmd/evm/testdata/21/readme.md | 4 ++-- cmd/evm/testdata/22/readme.md | 2 +- cmd/evm/testdata/22/uncles-empty.json | 1 - 6 files changed, 5 insertions(+), 8 deletions(-) delete mode 100644 cmd/evm/testdata/22/uncles-empty.json diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 81cc7281f73e..84a509081a93 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -210,7 +210,6 @@ func (i *blockInput) SealBlock(block *types.Block) (*types.Block, error) { } header.Coinbase = *i.Clique.Voted } - if i.Clique.Authorized != nil { if i.Env.Nonce != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided nonce")) @@ -317,7 +316,7 @@ func readInput(ctx *cli.Context) (*blockInput, error) { inputData.Env = &env } - if ommersStr != stdinSelector { + if ommersStr != stdinSelector && ommersStr != "" { var ommers []string err := readFile(ommersStr, "ommers", &ommers) if err != nil { diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go index 790ca7b35604..7db39479cbb2 100644 --- a/cmd/evm/internal/t8ntool/flags.go +++ b/cmd/evm/internal/t8ntool/flags.go @@ -101,7 +101,6 @@ var ( InputOmmersFlag = cli.StringFlag{ Name: "input.ommers", Usage: "`stdin` or file name of where to find the list of ommer header RLPs to use.", - Value: "ommers.json", } InputTxsRlpFlag = cli.StringFlag{ Name: "input.txs", diff --git a/cmd/evm/testdata/20/readme.md b/cmd/evm/testdata/20/readme.md index 261d9adae505..2c448a96e6e7 100644 --- a/cmd/evm/testdata/20/readme.md +++ b/cmd/evm/testdata/20/readme.md @@ -3,7 +3,7 @@ This test shows how `b11r` can be used to assemble an unsealed block. ```console -$ go run . b11r --input.header=testdata/20/header.json --input.txs=testdata/20/txs.rlp --input.uncles=testdata/20/uncles.json --output.block=stdout +$ go run . b11r --input.header=testdata/20/header.json --input.txs=testdata/20/txs.rlp --input.ommers=testdata/20/ommers.json --output.block=stdout { "rlp": "0xf90216f90211a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794e997a23b159e2e2a5ce72333262972374b15425ca0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e99476574682f76312e302e312f6c696e75782f676f312e342e32a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf8897435673d874f7c8c0c0", "hash": "0xaba9a3b6a4e96e9ecffcadaa5a2ae0589359455617535cd86589fe1dd26fe899" diff --git a/cmd/evm/testdata/21/readme.md b/cmd/evm/testdata/21/readme.md index cbf23f4a8375..b70f106ffcd6 100644 --- a/cmd/evm/testdata/21/readme.md +++ b/cmd/evm/testdata/21/readme.md @@ -5,7 +5,7 @@ This test shows how `b11r` can be used to assemble a sealed block. ## Ethash ```console -$ go run . b11r --input.header=testdata/21/header.json --input.txs=testdata/21/txs.rlp --input.uncles=testdata/21/uncles.json --seal.ethash --seal.ethash.mode=test --output.block=stdout +$ go run . b11r --input.header=testdata/21/header.json --input.txs=testdata/21/txs.rlp --input.ommers=testdata/21/ommers.json --seal.ethash --seal.ethash.mode=test --output.block=stdout { "rlp": "0xf901fdf901f8a0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277e80a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf880000000000000000c0c0", "hash": "0x801411e9f6609a659825690d13e4f75a3cfe9143952fa2d9573f3b0a5eb9ebbb" @@ -15,7 +15,7 @@ $ go run . b11r --input.header=testdata/21/header.json --input.txs=testdata/21/t ## Clique ```console -$ go run . b11r --input.header=testdata/21/header.json --input.txs=testdata/21/txs.rlp --input.uncles=testdata/21/uncles.json --seal.clique=testdata/21/clique.json --output.block=stdout +$ go run . b11r --input.header=testdata/21/header.json --input.txs=testdata/21/txs.rlp --input.ommers=testdata/21/ommers.json --seal.clique=testdata/21/clique.json --output.block=stdout { "rlp": "0xf9025ff9025aa0d6d785d33cbecf30f30d07e00e226af58f72efdf385d46bc3e6326c23b11e34ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa0325aea6db48e9d737cddf59034843e99f05bec269453be83c9b9a981a232cc2ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082100082c3be83050785808455c5277eb861aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac540a67aaee364005841da84f488f6b6d0116dfb5103d091402c81a163d5f66666595e37f56f196d8c5c98da714dbfae68d6b7e1790cc734a20ec6ce52213ad800a05865e417635a26db6d1d39ac70d1abf373e5398b3c6fd506acd038fa1334eedf88ffffffffffffffffc0c0", "hash": "0x71c59102cc805dbe8741e1210ebe229a321eff144ac7276006fefe39e8357dc7" diff --git a/cmd/evm/testdata/22/readme.md b/cmd/evm/testdata/22/readme.md index 87db6095ffc3..2cac8a2434a6 100644 --- a/cmd/evm/testdata/22/readme.md +++ b/cmd/evm/testdata/22/readme.md @@ -3,7 +3,7 @@ This test shows how `b11r` can chain together ommer assembles into a canonical block. ```console -$ echo "{ \"uncles\": [`go run . b11r --input.header=testdata/22/header.json --input.txs=testdata/22/txs.rlp --input.uncles=testdata/22/uncles.json --output.block=stdout | jq '.[\"rlp\"]'`,`go run . b11r --input.header=testdata/22/header.json --input.txs=testdata/22/txs.rlp --input.uncles=testdata/22/uncles.json --output.block=stdout | jq '.[\"rlp\"]'`]}" | go run . b11r --input.header=testdata/22/header.json --input.txs=testdata/22/txs.rlp --input.uncles=stdin --output.block=stdout +$ echo "{ \"ommers\": [`go run . b11r --input.header=testdata/22/header.json --input.txs=testdata/22/txs.rlp --output.block=stdout | jq '.[\"rlp\"]'`,`go run . b11r --input.header=testdata/22/header.json --input.txs=testdata/22/txs.rlp --output.block=stdout | jq '.[\"rlp\"]'`]}" | go run . b11r --input.header=testdata/22/header.json --input.txs=testdata/22/txs.rlp --input.ommers=stdin --output.block=stdout { "rlp": "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", "hash": "0xd9a81c8fcd57a7f2a0d2c375eff6ad192c30c3729a271303f0a9a7e1b357e755" diff --git a/cmd/evm/testdata/22/uncles-empty.json b/cmd/evm/testdata/22/uncles-empty.json deleted file mode 100644 index fe51488c7066..000000000000 --- a/cmd/evm/testdata/22/uncles-empty.json +++ /dev/null @@ -1 +0,0 @@ -[] From 74bfe0a45b5f53c089bb7f3881a2b5759cf2f2a3 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Mon, 15 Nov 2021 23:55:35 +0100 Subject: [PATCH 17/26] cmd/evm: rename b11r env to header for clarity --- cmd/evm/internal/t8ntool/block.go | 72 ++++++++-------- .../t8ntool/{gen_bbenv.go => gen_header.go} | 86 +++++++++---------- 2 files changed, 79 insertions(+), 79 deletions(-) rename cmd/evm/internal/t8ntool/{gen_bbenv.go => gen_header.go} (66%) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 84a509081a93..b0691e2133be 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -37,8 +37,8 @@ import ( "gopkg.in/urfave/cli.v1" ) -//go:generate gencodec -type bbEnv -field-override bbEnvMarshaling -out gen_bbenv.go -type bbEnv struct { +//go:generate gencodec -type header -field-override headerMarshaling -out gen_header.go +type header struct { ParentHash common.Hash `json:"parentHash"` OmmerHash *common.Hash `json:"sha3Ommers"` Coinbase *common.Address `json:"miner"` @@ -57,7 +57,7 @@ type bbEnv struct { BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"` } -type bbEnvMarshaling struct { +type headerMarshaling struct { Difficulty *math.HexOrDecimal256 Number *math.HexOrDecimal256 GasLimit math.HexOrDecimal64 @@ -67,8 +67,8 @@ type bbEnvMarshaling struct { BaseFee *math.HexOrDecimal256 } -type blockInput struct { - Env *bbEnv `json:"header,omitempty"` +type bbInput struct { + Header *header `json:"header,omitempty"` OmmersRlp []string `json:"ommers,omitempty"` TxRlp string `json:"txsRlp,omitempty"` Clique *cliqueInput `json:"clique,omitempty"` @@ -123,28 +123,28 @@ func (c *cliqueInput) UnmarshalJSON(input []byte) error { return nil } -func (i *blockInput) ToBlock() *types.Block { +func (i *bbInput) ToBlock() *types.Block { header := &types.Header{ - ParentHash: i.Env.ParentHash, + ParentHash: i.Header.ParentHash, UncleHash: types.EmptyUncleHash, Coinbase: common.Address{}, - Root: i.Env.Root, + Root: i.Header.Root, TxHash: types.EmptyRootHash, ReceiptHash: types.EmptyRootHash, - Bloom: i.Env.Bloom, + Bloom: i.Header.Bloom, Difficulty: common.Big0, - Number: i.Env.Number, - GasLimit: i.Env.GasLimit, - GasUsed: i.Env.GasUsed, - Time: i.Env.Time, - Extra: i.Env.Extra, - MixDigest: i.Env.MixDigest, - BaseFee: i.Env.BaseFee, + Number: i.Header.Number, + GasLimit: i.Header.GasLimit, + GasUsed: i.Header.GasUsed, + Time: i.Header.Time, + Extra: i.Header.Extra, + MixDigest: i.Header.MixDigest, + BaseFee: i.Header.BaseFee, } // Fill optional values. - if i.Env.OmmerHash != nil { - header.UncleHash = *i.Env.OmmerHash + if i.Header.OmmerHash != nil { + header.UncleHash = *i.Header.OmmerHash } else if len(i.Ommers) != 0 { // Calculate the ommer hash if none is provided and there are ommers to hash sha := sha3.NewLegacyKeccak256().(crypto.KeccakState) @@ -153,20 +153,20 @@ func (i *blockInput) ToBlock() *types.Block { sha.Read(h[:]) header.UncleHash = common.BytesToHash(h) } - if i.Env.Coinbase != nil { - header.Coinbase = *i.Env.Coinbase + if i.Header.Coinbase != nil { + header.Coinbase = *i.Header.Coinbase } - if i.Env.TxHash != nil { - header.TxHash = *i.Env.TxHash + if i.Header.TxHash != nil { + header.TxHash = *i.Header.TxHash } - if i.Env.ReceiptHash != nil { - header.ReceiptHash = *i.Env.ReceiptHash + if i.Header.ReceiptHash != nil { + header.ReceiptHash = *i.Header.ReceiptHash } - if i.Env.Nonce != nil { - header.Nonce = *i.Env.Nonce + if i.Header.Nonce != nil { + header.Nonce = *i.Header.Nonce } if header.Difficulty != nil { - header.Difficulty = i.Env.Difficulty + header.Difficulty = i.Header.Difficulty } block := types.NewBlockWithHeader(header) @@ -175,9 +175,9 @@ func (i *blockInput) ToBlock() *types.Block { return block } -func (i *blockInput) SealBlock(block *types.Block) (*types.Block, error) { +func (i *bbInput) SealBlock(block *types.Block) (*types.Block, error) { if i.Ethash { - if i.Env.Nonce != nil { + if i.Header.Nonce != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with ethash will overwrite provided nonce")) } ethashConfig := ethash.Config{ @@ -201,17 +201,17 @@ func (i *blockInput) SealBlock(block *types.Block) (*types.Block, error) { } else if i.Clique != nil { header := block.Header() - if i.Env.Extra != nil { + if i.Header.Extra != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique will overwrite provided extra data")) } if i.Clique.Voted != nil { - if i.Env.Coinbase != nil { + if i.Header.Coinbase != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided coinbase")) } header.Coinbase = *i.Clique.Voted } if i.Clique.Authorized != nil { - if i.Env.Nonce != nil { + if i.Header.Nonce != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided nonce")) } @@ -261,7 +261,7 @@ func BuildBlock(ctx *cli.Context) error { return dispatchBlock(ctx, baseDir, block) } -func readInput(ctx *cli.Context) (*blockInput, error) { +func readInput(ctx *cli.Context) (*bbInput, error) { var ( headerStr = ctx.String(InputHeaderFlag.Name) ommersStr = ctx.String(InputOmmersFlag.Name) @@ -270,7 +270,7 @@ func readInput(ctx *cli.Context) (*blockInput, error) { ethashOn = ctx.Bool(SealEthashFlag.Name) ethashDir = ctx.String(SealEthashDirFlag.Name) ethashMode = ctx.String(SealEthashModeFlag.Name) - inputData = &blockInput{} + inputData = &bbInput{} ) if ethashOn && cliqueStr != "" { @@ -308,12 +308,12 @@ func readInput(ctx *cli.Context) (*blockInput, error) { } if headerStr != stdinSelector { - var env bbEnv + var env header err := readFile(headerStr, "header", &env) if err != nil { return nil, err } - inputData.Env = &env + inputData.Header = &env } if ommersStr != stdinSelector && ommersStr != "" { diff --git a/cmd/evm/internal/t8ntool/gen_bbenv.go b/cmd/evm/internal/t8ntool/gen_header.go similarity index 66% rename from cmd/evm/internal/t8ntool/gen_bbenv.go rename to cmd/evm/internal/t8ntool/gen_header.go index f5dece602d8a..dde792910415 100644 --- a/cmd/evm/internal/t8ntool/gen_bbenv.go +++ b/cmd/evm/internal/t8ntool/gen_header.go @@ -13,11 +13,11 @@ import ( "github.com/ethereum/go-ethereum/core/types" ) -var _ = (*bbEnvMarshaling)(nil) +var _ = (*headerMarshaling)(nil) // MarshalJSON marshals as JSON. -func (b bbEnv) MarshalJSON() ([]byte, error) { - type bbEnv struct { +func (h header) MarshalJSON() ([]byte, error) { + type header struct { ParentHash common.Hash `json:"parentHash"` OmmerHash *common.Hash `json:"sha3Ommers"` Coinbase *common.Address `json:"miner"` @@ -35,29 +35,29 @@ func (b bbEnv) MarshalJSON() ([]byte, error) { Nonce *types.BlockNonce `json:"nonce"` BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas" rlp:"optional"` } - var enc bbEnv - enc.ParentHash = b.ParentHash - enc.OmmerHash = b.OmmerHash - enc.Coinbase = b.Coinbase - enc.Root = b.Root - enc.TxHash = b.TxHash - enc.ReceiptHash = b.ReceiptHash - enc.Bloom = b.Bloom - enc.Difficulty = (*math.HexOrDecimal256)(b.Difficulty) - enc.Number = (*math.HexOrDecimal256)(b.Number) - enc.GasLimit = math.HexOrDecimal64(b.GasLimit) - enc.GasUsed = math.HexOrDecimal64(b.GasUsed) - enc.Time = math.HexOrDecimal64(b.Time) - enc.Extra = b.Extra - enc.MixDigest = b.MixDigest - enc.Nonce = b.Nonce - enc.BaseFee = (*math.HexOrDecimal256)(b.BaseFee) + var enc header + enc.ParentHash = h.ParentHash + enc.OmmerHash = h.OmmerHash + enc.Coinbase = h.Coinbase + enc.Root = h.Root + enc.TxHash = h.TxHash + enc.ReceiptHash = h.ReceiptHash + enc.Bloom = h.Bloom + enc.Difficulty = (*math.HexOrDecimal256)(h.Difficulty) + enc.Number = (*math.HexOrDecimal256)(h.Number) + enc.GasLimit = math.HexOrDecimal64(h.GasLimit) + enc.GasUsed = math.HexOrDecimal64(h.GasUsed) + enc.Time = math.HexOrDecimal64(h.Time) + enc.Extra = h.Extra + enc.MixDigest = h.MixDigest + enc.Nonce = h.Nonce + enc.BaseFee = (*math.HexOrDecimal256)(h.BaseFee) return json.Marshal(&enc) } // UnmarshalJSON unmarshals from JSON. -func (b *bbEnv) UnmarshalJSON(input []byte) error { - type bbEnv struct { +func (h *header) UnmarshalJSON(input []byte) error { + type header struct { ParentHash *common.Hash `json:"parentHash"` OmmerHash *common.Hash `json:"sha3Ommers"` Coinbase *common.Address `json:"miner"` @@ -75,61 +75,61 @@ func (b *bbEnv) UnmarshalJSON(input []byte) error { Nonce *types.BlockNonce `json:"nonce"` BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas" rlp:"optional"` } - var dec bbEnv + var dec header if err := json.Unmarshal(input, &dec); err != nil { return err } if dec.ParentHash != nil { - b.ParentHash = *dec.ParentHash + h.ParentHash = *dec.ParentHash } if dec.OmmerHash != nil { - b.OmmerHash = dec.OmmerHash + h.OmmerHash = dec.OmmerHash } if dec.Coinbase != nil { - b.Coinbase = dec.Coinbase + h.Coinbase = dec.Coinbase } if dec.Root == nil { - return errors.New("missing required field 'stateRoot' for bbEnv") + return errors.New("missing required field 'stateRoot' for header") } - b.Root = *dec.Root + h.Root = *dec.Root if dec.TxHash != nil { - b.TxHash = dec.TxHash + h.TxHash = dec.TxHash } if dec.ReceiptHash != nil { - b.ReceiptHash = dec.ReceiptHash + h.ReceiptHash = dec.ReceiptHash } if dec.Bloom != nil { - b.Bloom = *dec.Bloom + h.Bloom = *dec.Bloom } if dec.Difficulty != nil { - b.Difficulty = (*big.Int)(dec.Difficulty) + h.Difficulty = (*big.Int)(dec.Difficulty) } if dec.Number == nil { - return errors.New("missing required field 'number' for bbEnv") + return errors.New("missing required field 'number' for header") } - b.Number = (*big.Int)(dec.Number) + h.Number = (*big.Int)(dec.Number) if dec.GasLimit == nil { - return errors.New("missing required field 'gasLimit' for bbEnv") + return errors.New("missing required field 'gasLimit' for header") } - b.GasLimit = uint64(*dec.GasLimit) + h.GasLimit = uint64(*dec.GasLimit) if dec.GasUsed != nil { - b.GasUsed = uint64(*dec.GasUsed) + h.GasUsed = uint64(*dec.GasUsed) } if dec.Time == nil { - return errors.New("missing required field 'timestamp' for bbEnv") + return errors.New("missing required field 'timestamp' for header") } - b.Time = uint64(*dec.Time) + h.Time = uint64(*dec.Time) if dec.Extra != nil { - b.Extra = *dec.Extra + h.Extra = *dec.Extra } if dec.MixDigest != nil { - b.MixDigest = *dec.MixDigest + h.MixDigest = *dec.MixDigest } if dec.Nonce != nil { - b.Nonce = dec.Nonce + h.Nonce = dec.Nonce } if dec.BaseFee != nil { - b.BaseFee = (*big.Int)(dec.BaseFee) + h.BaseFee = (*big.Int)(dec.BaseFee) } return nil } From fc4d71a2c92972714925c84b063c2f534b07201d Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Tue, 16 Nov 2021 00:29:43 +0100 Subject: [PATCH 18/26] cmd/evm: add some more comments, refactor code a little --- cmd/evm/internal/t8ntool/block.go | 61 +++++++++++++++---------------- 1 file changed, 29 insertions(+), 32 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index b0691e2133be..10e6584b01f8 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -191,7 +191,6 @@ func (i *bbInput) SealBlock(block *types.Block) (*types.Block, error) { } engine := ethash.New(ethashConfig, nil, false) defer engine.Close() - results := make(chan *types.Block) if err := engine.Seal(nil, block, results, nil); err != nil { panic(fmt.Sprintf("failed to seal block: %v", err)) @@ -199,11 +198,12 @@ func (i *bbInput) SealBlock(block *types.Block) (*types.Block, error) { found := <-results block.WithSeal(found.Header()) } else if i.Clique != nil { - header := block.Header() - + // If any clique value overwrites an explicit header value, fail + // to avoid silently building a block with unexpected values. if i.Header.Extra != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique will overwrite provided extra data")) } + header := block.Header() if i.Clique.Voted != nil { if i.Header.Coinbase != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided coinbase")) @@ -214,17 +214,17 @@ func (i *bbInput) SealBlock(block *types.Block) (*types.Block, error) { if i.Header.Nonce != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided nonce")) } - if *i.Clique.Authorized { header.Nonce = [8]byte{} } else { header.Nonce = [8]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} } } - - header.Extra = make([]byte, 97) + // Extra is fixed 32 byte vanity and 65 byte signature + header.Extra = make([]byte, 32+65) copy(header.Extra[0:32], i.Clique.Vanity.Bytes()[:]) + // Sign the seal hash and fill in the rest of the extra data h := clique.SealHash(header) sighash, err := crypto.Sign(h[:], i.Clique.Key) if err != nil { @@ -252,6 +252,7 @@ func BuildBlock(ctx *cli.Context) error { if err != nil { return err } + block := inputData.ToBlock() block, err = inputData.SealBlock(block) if err != nil { @@ -297,7 +298,6 @@ func readInput(ctx *cli.Context) (*bbInput, error) { return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling stdin: %v", err)) } } - if cliqueStr != stdinSelector && cliqueStr != "" { var clique cliqueInput err := readFile(cliqueStr, "clique", &clique) @@ -306,7 +306,6 @@ func readInput(ctx *cli.Context) (*bbInput, error) { } inputData.Clique = &clique } - if headerStr != stdinSelector { var env header err := readFile(headerStr, "header", &env) @@ -315,7 +314,6 @@ func readInput(ctx *cli.Context) (*bbInput, error) { } inputData.Header = &env } - if ommersStr != stdinSelector && ommersStr != "" { var ommers []string err := readFile(ommersStr, "ommers", &ommers) @@ -324,8 +322,26 @@ func readInput(ctx *cli.Context) (*bbInput, error) { } inputData.OmmersRlp = ommers } + if txsStr != stdinSelector { + var txs string + err := readFile(txsStr, "txs", &txs) + if err != nil { + return nil, err + } + inputData.TxRlp = txs + } + + // Deserialize rlp txs and ommers + var ( + ommers = []*types.Header{} + txs = []*types.Transaction{} + ) + + if err := rlp.DecodeBytes(common.FromHex(inputData.TxRlp), &txs); err != nil { + return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode transaction from rlp data: %v", err)) + } + inputData.Txs = txs - ommers := []*types.Header{} for _, str := range inputData.OmmersRlp { type extblock struct { Header *types.Header @@ -333,32 +349,13 @@ func readInput(ctx *cli.Context) (*bbInput, error) { Ommers []*types.Header } var ommer *extblock - raw := common.FromHex(str) - err := rlp.DecodeBytes(raw, &ommer) - if err != nil { + if err := rlp.DecodeBytes(common.FromHex(str), &ommer); err != nil { return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode ommer from rlp data: %v", err)) } ommers = append(ommers, ommer.Header) } inputData.Ommers = ommers - if txsStr != stdinSelector { - var txs string - err := readFile(txsStr, "txs", &txs) - if err != nil { - return nil, err - } - inputData.TxRlp = txs - } - - txs := []*types.Transaction{} - raw := common.FromHex(inputData.TxRlp) - err := rlp.DecodeBytes(raw, &txs) - if err != nil { - return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode transaction from rlp data: %v", err)) - } - inputData.Txs = txs - return inputData, nil } @@ -382,12 +379,12 @@ func readFile(path, desc string, dest interface{}) error { func dispatchBlock(ctx *cli.Context, baseDir string, block *types.Block) error { raw, _ := rlp.EncodeToBytes(block) - type BlockInfo struct { + type blockInfo struct { Rlp hexutil.Bytes `json:"rlp"` Hash common.Hash `json:"hash"` } - var enc BlockInfo + var enc blockInfo enc.Rlp = raw enc.Hash = block.Hash() From 248de65b758222a652b8a81f1a4a0a82f7b31acc Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Tue, 16 Nov 2021 00:56:20 +0100 Subject: [PATCH 19/26] cmd/evm: fix issue deserializing values from stdin --- cmd/evm/internal/t8ntool/block.go | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 10e6584b01f8..6f6e2260d5c9 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -70,14 +70,14 @@ type headerMarshaling struct { type bbInput struct { Header *header `json:"header,omitempty"` OmmersRlp []string `json:"ommers,omitempty"` - TxRlp string `json:"txsRlp,omitempty"` + TxRlp string `json:"txs,omitempty"` Clique *cliqueInput `json:"clique,omitempty"` - Ethash bool - EthashDir string - PowMode ethash.Mode - Txs []*types.Transaction - Ommers []*types.Header + Ethash bool `json:"-"` + EthashDir string `json:"-"` + PowMode ethash.Mode `json:"-"` + Txs []*types.Transaction `json:"-"` + Ommers []*types.Header `json:"-"` } type cliqueInput struct { @@ -337,10 +337,12 @@ func readInput(ctx *cli.Context) (*bbInput, error) { txs = []*types.Transaction{} ) - if err := rlp.DecodeBytes(common.FromHex(inputData.TxRlp), &txs); err != nil { - return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode transaction from rlp data: %v", err)) + if inputData.TxRlp != "" { + if err := rlp.DecodeBytes(common.FromHex(inputData.TxRlp), &txs); err != nil { + return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode transaction from rlp data: %v", err)) + } + inputData.Txs = txs } - inputData.Txs = txs for _, str := range inputData.OmmersRlp { type extblock struct { From ba4b08cdd630da9df0d3a1281657e8ba4fd228ca Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Tue, 16 Nov 2021 09:29:42 +0100 Subject: [PATCH 20/26] cmd/evm: minor changes in block-builder --- cmd/evm/internal/t8ntool/block.go | 172 ++++++++++++------------- cmd/evm/internal/t8ntool/transition.go | 35 +---- cmd/evm/internal/t8ntool/utils.go | 54 ++++++++ 3 files changed, 140 insertions(+), 121 deletions(-) create mode 100644 cmd/evm/internal/t8ntool/utils.go diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 6f6e2260d5c9..a7980a8c977f 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -1,4 +1,4 @@ -// Copyright 2020 The go-ethereum Authors +// Copyright 2021 The go-ethereum Authors // This file is part of go-ethereum. // // go-ethereum is free software: you can redistribute it and/or modify @@ -168,72 +168,85 @@ func (i *bbInput) ToBlock() *types.Block { if header.Difficulty != nil { header.Difficulty = i.Header.Difficulty } + return types.NewBlockWithHeader(header).WithBody(i.Txs, i.Ommers) +} - block := types.NewBlockWithHeader(header) - block = block.WithBody(i.Txs, i.Ommers) +// SealBlock seals the given block using the configured engine. +func (i *bbInput) SealBlock(block *types.Block) (*types.Block, error) { + switch { + case i.Ethash: + return i.sealEthash(block) + case i.Clique != nil: + return i.sealClique(block) + default: + return block, nil + } +} - return block +// sealEthash seals the given block using ethash. +func (i *bbInput) sealEthash(block *types.Block) (*types.Block, error) { + if i.Header.Nonce != nil { + return nil, NewError(ErrorConfig, fmt.Errorf("sealing with ethash will overwrite provided nonce")) + } + ethashConfig := ethash.Config{ + PowMode: i.PowMode, + DatasetDir: i.EthashDir, + CacheDir: i.EthashDir, + DatasetsInMem: 1, + DatasetsOnDisk: 2, + CachesInMem: 2, + CachesOnDisk: 3, + } + engine := ethash.New(ethashConfig, nil, true) + defer engine.Close() + // Use a buffered chan for results. + // If the testmode is used, the sealer will return quickly, and complain + // "Sealing result is not read by miner" if it cannot write the result. + results := make(chan *types.Block, 1) + if err := engine.Seal(nil, block, results, nil); err != nil { + panic(fmt.Sprintf("failed to seal block: %v", err)) + } + found := <-results + return block.WithSeal(found.Header()), nil } -func (i *bbInput) SealBlock(block *types.Block) (*types.Block, error) { - if i.Ethash { - if i.Header.Nonce != nil { - return nil, NewError(ErrorConfig, fmt.Errorf("sealing with ethash will overwrite provided nonce")) - } - ethashConfig := ethash.Config{ - PowMode: i.PowMode, - DatasetDir: i.EthashDir, - CacheDir: i.EthashDir, - DatasetsInMem: 1, - DatasetsOnDisk: 2, - CachesInMem: 2, - CachesOnDisk: 3, - } - engine := ethash.New(ethashConfig, nil, false) - defer engine.Close() - results := make(chan *types.Block) - if err := engine.Seal(nil, block, results, nil); err != nil { - panic(fmt.Sprintf("failed to seal block: %v", err)) - } - found := <-results - block.WithSeal(found.Header()) - } else if i.Clique != nil { - // If any clique value overwrites an explicit header value, fail - // to avoid silently building a block with unexpected values. - if i.Header.Extra != nil { - return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique will overwrite provided extra data")) - } - header := block.Header() - if i.Clique.Voted != nil { - if i.Header.Coinbase != nil { - return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided coinbase")) - } - header.Coinbase = *i.Clique.Voted +// sealClique seals the given block using clique. +func (i *bbInput) sealClique(block *types.Block) (*types.Block, error) { + + // If any clique value overwrites an explicit header value, fail + // to avoid silently building a block with unexpected values. + if i.Header.Extra != nil { + return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique will overwrite provided extra data")) + } + header := block.Header() + if i.Clique.Voted != nil { + if i.Header.Coinbase != nil { + return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided coinbase")) } - if i.Clique.Authorized != nil { - if i.Header.Nonce != nil { - return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided nonce")) - } - if *i.Clique.Authorized { - header.Nonce = [8]byte{} - } else { - header.Nonce = [8]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} - } + header.Coinbase = *i.Clique.Voted + } + if i.Clique.Authorized != nil { + if i.Header.Nonce != nil { + return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided nonce")) } - // Extra is fixed 32 byte vanity and 65 byte signature - header.Extra = make([]byte, 32+65) - copy(header.Extra[0:32], i.Clique.Vanity.Bytes()[:]) - - // Sign the seal hash and fill in the rest of the extra data - h := clique.SealHash(header) - sighash, err := crypto.Sign(h[:], i.Clique.Key) - if err != nil { - return nil, err + if *i.Clique.Authorized { + header.Nonce = [8]byte{} + } else { + header.Nonce = [8]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} } - copy(header.Extra[32:], sighash) - block = block.WithSeal(header) } + // Extra is fixed 32 byte vanity and 65 byte signature + header.Extra = make([]byte, 32+65) + copy(header.Extra[0:32], i.Clique.Vanity.Bytes()[:]) + // Sign the seal hash and fill in the rest of the extra data + h := clique.SealHash(header) + sighash, err := crypto.Sign(h[:], i.Clique.Key) + if err != nil { + return nil, err + } + copy(header.Extra[32:], sighash) + block = block.WithSeal(header) return block, nil } @@ -286,9 +299,10 @@ func readInput(ctx *cli.Context) (*bbInput, error) { inputData.PowMode = ethash.ModeNormal case "test": inputData.PowMode = ethash.ModeTest + case "fake": + inputData.PowMode = ethash.ModeFake default: - return nil, NewError(ErrorConfig, fmt.Errorf("unknown pow mode: %s", ethashMode)) - + return nil, NewError(ErrorConfig, fmt.Errorf("unknown pow mode: %s, supported modes: test, normal", ethashMode)) } } @@ -300,37 +314,32 @@ func readInput(ctx *cli.Context) (*bbInput, error) { } if cliqueStr != stdinSelector && cliqueStr != "" { var clique cliqueInput - err := readFile(cliqueStr, "clique", &clique) - if err != nil { + if err := readFile(cliqueStr, "clique", &clique); err != nil { return nil, err } inputData.Clique = &clique } if headerStr != stdinSelector { var env header - err := readFile(headerStr, "header", &env) - if err != nil { + if err := readFile(headerStr, "header", &env); err != nil { return nil, err } inputData.Header = &env } if ommersStr != stdinSelector && ommersStr != "" { var ommers []string - err := readFile(ommersStr, "ommers", &ommers) - if err != nil { + if err := readFile(ommersStr, "ommers", &ommers); err != nil { return nil, err } inputData.OmmersRlp = ommers } if txsStr != stdinSelector { var txs string - err := readFile(txsStr, "txs", &txs) - if err != nil { + if err := readFile(txsStr, "txs", &txs); err != nil { return nil, err } inputData.TxRlp = txs } - // Deserialize rlp txs and ommers var ( ommers = []*types.Header{} @@ -361,21 +370,6 @@ func readInput(ctx *cli.Context) (*bbInput, error) { return inputData, nil } -func readFile(path, desc string, dest interface{}) error { - inFile, err := os.Open(path) - if err != nil { - return NewError(ErrorIO, fmt.Errorf("failed reading %s file: %v", desc, err)) - } - defer inFile.Close() - - decoder := json.NewDecoder(inFile) - if err := decoder.Decode(dest); err != nil { - return NewError(ErrorJson, fmt.Errorf("failed unmarshaling %s file: %v", desc, err)) - } - - return nil -} - // dispatchOutput writes the output data to either stderr or stdout, or to the specified // files func dispatchBlock(ctx *cli.Context, baseDir string, block *types.Block) error { @@ -394,19 +388,17 @@ func dispatchBlock(ctx *cli.Context, baseDir string, block *types.Block) error { if err != nil { return NewError(ErrorJson, fmt.Errorf("failed marshalling output: %v", err)) } - - dest := ctx.String(OutputBlockFlag.Name) - if dest == "stdout" { + switch dest := ctx.String(OutputBlockFlag.Name); dest { + case "stdout": os.Stdout.Write(b) os.Stdout.WriteString("\n") - } else if dest == "stderr" { + case "stderr": os.Stderr.Write(b) os.Stderr.WriteString("\n") - } else { + default: if err := saveFile(baseDir, dest, enc); err != nil { return err } } - return nil } diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go index 2a3e58664f29..8f203b0eda39 100644 --- a/cmd/evm/internal/t8ntool/transition.go +++ b/cmd/evm/internal/t8ntool/transition.go @@ -149,29 +149,17 @@ func Transition(ctx *cli.Context) error { } } if allocStr != stdinSelector { - inFile, err := os.Open(allocStr) - if err != nil { - return NewError(ErrorIO, fmt.Errorf("failed reading alloc file: %v", err)) - } - defer inFile.Close() - decoder := json.NewDecoder(inFile) - if err := decoder.Decode(&inputData.Alloc); err != nil { - return NewError(ErrorJson, fmt.Errorf("failed unmarshaling alloc-file: %v", err)) + if err := readFile(allocStr, "alloc", &inputData.Alloc); err != nil { + return err } } prestate.Pre = inputData.Alloc // Set the block environment if envStr != stdinSelector { - inFile, err := os.Open(envStr) - if err != nil { - return NewError(ErrorIO, fmt.Errorf("failed reading env file: %v", err)) - } - defer inFile.Close() - decoder := json.NewDecoder(inFile) var env stEnv - if err := decoder.Decode(&env); err != nil { - return NewError(ErrorJson, fmt.Errorf("failed unmarshaling env-file: %v", err)) + if err := readFile(envStr, "env", &env); err != nil { + return err } inputData.Env = &env } @@ -425,18 +413,3 @@ func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, a } return nil } - -// If user specified a basedir, make sure it exists -func createBasedir(ctx *cli.Context) (string, error) { - baseDir := "" - if ctx.IsSet(OutputBasedir.Name) { - if base := ctx.String(OutputBasedir.Name); len(base) > 0 { - err := os.MkdirAll(base, 0755) // //rw-r--r-- - if err != nil { - return "", err - } - baseDir = base - } - } - return baseDir, nil -} diff --git a/cmd/evm/internal/t8ntool/utils.go b/cmd/evm/internal/t8ntool/utils.go new file mode 100644 index 000000000000..1c54f09bf417 --- /dev/null +++ b/cmd/evm/internal/t8ntool/utils.go @@ -0,0 +1,54 @@ +// Copyright 2021 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum 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 General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package t8ntool + +import ( + "encoding/json" + "fmt" + "os" + + "gopkg.in/urfave/cli.v1" +) + +// readFile reads the json-data in the provided path and marshals into dest. +func readFile(path, desc string, dest interface{}) error { + inFile, err := os.Open(path) + if err != nil { + return NewError(ErrorIO, fmt.Errorf("failed reading %s file: %v", desc, err)) + } + defer inFile.Close() + decoder := json.NewDecoder(inFile) + if err := decoder.Decode(dest); err != nil { + return NewError(ErrorJson, fmt.Errorf("failed unmarshaling %s file: %v", desc, err)) + } + return nil +} + +// createBasedir makes sure the basedir exists, if user specified one. +func createBasedir(ctx *cli.Context) (string, error) { + baseDir := "" + if ctx.IsSet(OutputBasedir.Name) { + if base := ctx.String(OutputBasedir.Name); len(base) > 0 { + err := os.MkdirAll(base, 0755) // //rw-r--r-- + if err != nil { + return "", err + } + baseDir = base + } + } + return baseDir, nil +} From 9b8feeec802dd7b54bfda0e8e2fdc0de2562e9f3 Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Tue, 16 Nov 2021 09:52:53 +0100 Subject: [PATCH 21/26] cmd/evm: simpler ommerhash calculation --- cmd/evm/internal/t8ntool/block.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index a7980a8c977f..75d6b273d927 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -33,7 +33,6 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" - "golang.org/x/crypto/sha3" "gopkg.in/urfave/cli.v1" ) @@ -147,11 +146,7 @@ func (i *bbInput) ToBlock() *types.Block { header.UncleHash = *i.Header.OmmerHash } else if len(i.Ommers) != 0 { // Calculate the ommer hash if none is provided and there are ommers to hash - sha := sha3.NewLegacyKeccak256().(crypto.KeccakState) - rlp.Encode(sha, i.Ommers) - h := make([]byte, 32) - sha.Read(h[:]) - header.UncleHash = common.BytesToHash(h) + header.UncleHash = types.CalcUncleHash(i.Ommers) } if i.Header.Coinbase != nil { header.Coinbase = *i.Header.Coinbase From 8292b57a47112052dc2eb9042be73a00552d609b Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Tue, 16 Nov 2021 10:10:59 +0100 Subject: [PATCH 22/26] cmd/evm: b11r - simplify unmarshalling --- cmd/evm/internal/t8ntool/block.go | 28 ++++++++-------------------- 1 file changed, 8 insertions(+), 20 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 75d6b273d927..bd32a0770963 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -87,38 +87,26 @@ type cliqueInput struct { } func (c *cliqueInput) UnmarshalJSON(input []byte) error { - // Read the secretKey, if present - type sKey struct { - Key *common.Hash `json:"secretKey"` + var x struct { + Key *common.Hash `json:"secretKey"` + Voted *common.Address `json:"voted"` + Authorized *bool `json:"authorized"` + Vanity common.Hash `json:"vanity"` } - var key sKey - if err := json.Unmarshal(input, &key); err != nil { + if err := json.Unmarshal(input, &x); err != nil { return err } - if key.Key == nil { + if x.Key == nil { return errors.New("missing required field 'secretKey' for cliqueInput") } - k := key.Key.Hex()[2:] - if ecdsaKey, err := crypto.HexToECDSA(k); err != nil { + if ecdsaKey, err := crypto.ToECDSA(x.Key[:]); err != nil { return err } else { c.Key = ecdsaKey } - - // Now, read the rest of object - type others struct { - Voted *common.Address `json:"voted"` - Authorized *bool `json:"authorized"` - Vanity common.Hash `json:"vanity"` - } - var x others - if err := json.Unmarshal(input, &x); err != nil { - return err - } c.Voted = x.Voted c.Authorized = x.Authorized c.Vanity = x.Vanity - return nil } From 6927e97c1dc85165e59cb6aa60f50b789f70a40d Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Tue, 16 Nov 2021 10:20:28 +0100 Subject: [PATCH 23/26] cmd/evm: minor nits in block builder --- cmd/evm/internal/t8ntool/block.go | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index bd32a0770963..12857f0ee856 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -195,7 +195,6 @@ func (i *bbInput) sealEthash(block *types.Block) (*types.Block, error) { // sealClique seals the given block using clique. func (i *bbInput) sealClique(block *types.Block) (*types.Block, error) { - // If any clique value overwrites an explicit header value, fail // to avoid silently building a block with unexpected values. if i.Header.Extra != nil { @@ -243,18 +242,15 @@ func BuildBlock(ctx *cli.Context) error { if err != nil { return NewError(ErrorIO, fmt.Errorf("failed creating output basedir: %v", err)) } - inputData, err := readInput(ctx) if err != nil { return err } - block := inputData.ToBlock() block, err = inputData.SealBlock(block) if err != nil { return err } - return dispatchBlock(ctx, baseDir, block) } @@ -269,11 +265,9 @@ func readInput(ctx *cli.Context) (*bbInput, error) { ethashMode = ctx.String(SealEthashModeFlag.Name) inputData = &bbInput{} ) - if ethashOn && cliqueStr != "" { return nil, NewError(ErrorConfig, fmt.Errorf("both ethash and clique sealing specified, only one may be chosen")) } - if ethashOn { inputData.Ethash = ethashOn inputData.EthashDir = ethashDir @@ -285,10 +279,9 @@ func readInput(ctx *cli.Context) (*bbInput, error) { case "fake": inputData.PowMode = ethash.ModeFake default: - return nil, NewError(ErrorConfig, fmt.Errorf("unknown pow mode: %s, supported modes: test, normal", ethashMode)) + return nil, NewError(ErrorConfig, fmt.Errorf("unknown pow mode: %s, supported modes: test, fake, normal", ethashMode)) } } - if headerStr == stdinSelector || ommersStr == stdinSelector || txsStr == stdinSelector || cliqueStr == stdinSelector { decoder := json.NewDecoder(os.Stdin) if err := decoder.Decode(inputData); err != nil { @@ -328,14 +321,12 @@ func readInput(ctx *cli.Context) (*bbInput, error) { ommers = []*types.Header{} txs = []*types.Transaction{} ) - if inputData.TxRlp != "" { if err := rlp.DecodeBytes(common.FromHex(inputData.TxRlp), &txs); err != nil { return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode transaction from rlp data: %v", err)) } inputData.Txs = txs } - for _, str := range inputData.OmmersRlp { type extblock struct { Header *types.Header From 1d9e4e434f5e775e16f960d5f2fbfb8d17836066 Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Tue, 16 Nov 2021 10:30:10 +0100 Subject: [PATCH 24/26] cmd/evm: make b11r header use same json-names as core/types --- cmd/evm/internal/t8ntool/block.go | 2 +- cmd/evm/internal/t8ntool/gen_header.go | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 12857f0ee856..4d3fcc67114a 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -39,7 +39,7 @@ import ( //go:generate gencodec -type header -field-override headerMarshaling -out gen_header.go type header struct { ParentHash common.Hash `json:"parentHash"` - OmmerHash *common.Hash `json:"sha3Ommers"` + OmmerHash *common.Hash `json:"sha3Uncles"` Coinbase *common.Address `json:"miner"` Root common.Hash `json:"stateRoot" gencodec:"required"` TxHash *common.Hash `json:"transactionsRoot"` diff --git a/cmd/evm/internal/t8ntool/gen_header.go b/cmd/evm/internal/t8ntool/gen_header.go index dde792910415..196e49dd716f 100644 --- a/cmd/evm/internal/t8ntool/gen_header.go +++ b/cmd/evm/internal/t8ntool/gen_header.go @@ -19,7 +19,7 @@ var _ = (*headerMarshaling)(nil) func (h header) MarshalJSON() ([]byte, error) { type header struct { ParentHash common.Hash `json:"parentHash"` - OmmerHash *common.Hash `json:"sha3Ommers"` + OmmerHash *common.Hash `json:"sha3Uncles"` Coinbase *common.Address `json:"miner"` Root common.Hash `json:"stateRoot" gencodec:"required"` TxHash *common.Hash `json:"transactionsRoot"` @@ -59,7 +59,7 @@ func (h header) MarshalJSON() ([]byte, error) { func (h *header) UnmarshalJSON(input []byte) error { type header struct { ParentHash *common.Hash `json:"parentHash"` - OmmerHash *common.Hash `json:"sha3Ommers"` + OmmerHash *common.Hash `json:"sha3Uncles"` Coinbase *common.Address `json:"miner"` Root *common.Hash `json:"stateRoot" gencodec:"required"` TxHash *common.Hash `json:"transactionsRoot"` From 15048ffb5c4d0b62bf652f693c2bcba4eefd78eb Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Fri, 19 Nov 2021 09:52:12 +0100 Subject: [PATCH 25/26] cmd/evm: documentation --- cmd/evm/internal/t8ntool/block.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 4d3fcc67114a..e8868eb1f039 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -86,6 +86,7 @@ type cliqueInput struct { Vanity common.Hash } +// UnmarshalJSON implements json.Unmarshaler interface. func (c *cliqueInput) UnmarshalJSON(input []byte) error { var x struct { Key *common.Hash `json:"secretKey"` @@ -110,6 +111,7 @@ func (c *cliqueInput) UnmarshalJSON(input []byte) error { return nil } +// ToBlock converts i into a *types.Block func (i *bbInput) ToBlock() *types.Block { header := &types.Header{ ParentHash: i.Header.ParentHash, @@ -232,6 +234,7 @@ func (i *bbInput) sealClique(block *types.Block) (*types.Block, error) { return block, nil } +// BuildBlock constructs a block from the given inputs. func BuildBlock(ctx *cli.Context) error { // Configure the go-ethereum logger glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false))) @@ -353,7 +356,6 @@ func dispatchBlock(ctx *cli.Context, baseDir string, block *types.Block) error { Rlp hexutil.Bytes `json:"rlp"` Hash common.Hash `json:"hash"` } - var enc blockInfo enc.Rlp = raw enc.Hash = block.Hash() From 10b9fd7f4ea5c85e09ab82c089c993cdd70e64a7 Mon Sep 17 00:00:00 2001 From: "lightclient@protonmail.com" Date: Fri, 19 Nov 2021 16:31:50 +0100 Subject: [PATCH 26/26] cmd/evm: rename b11r object clique.Authorized to clique.Authorize --- cmd/evm/internal/t8ntool/block.go | 22 +++++++++++----------- cmd/evm/testdata/21/clique.json | 2 +- cmd/evm/testdata/22/clique.json | 6 ------ 3 files changed, 12 insertions(+), 18 deletions(-) delete mode 100644 cmd/evm/testdata/22/clique.json diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index e8868eb1f039..d4edd33bdeb7 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -80,19 +80,19 @@ type bbInput struct { } type cliqueInput struct { - Key *ecdsa.PrivateKey - Voted *common.Address - Authorized *bool - Vanity common.Hash + Key *ecdsa.PrivateKey + Voted *common.Address + Authorize *bool + Vanity common.Hash } // UnmarshalJSON implements json.Unmarshaler interface. func (c *cliqueInput) UnmarshalJSON(input []byte) error { var x struct { - Key *common.Hash `json:"secretKey"` - Voted *common.Address `json:"voted"` - Authorized *bool `json:"authorized"` - Vanity common.Hash `json:"vanity"` + Key *common.Hash `json:"secretKey"` + Voted *common.Address `json:"voted"` + Authorize *bool `json:"authorize"` + Vanity common.Hash `json:"vanity"` } if err := json.Unmarshal(input, &x); err != nil { return err @@ -106,7 +106,7 @@ func (c *cliqueInput) UnmarshalJSON(input []byte) error { c.Key = ecdsaKey } c.Voted = x.Voted - c.Authorized = x.Authorized + c.Authorize = x.Authorize c.Vanity = x.Vanity return nil } @@ -209,11 +209,11 @@ func (i *bbInput) sealClique(block *types.Block) (*types.Block, error) { } header.Coinbase = *i.Clique.Voted } - if i.Clique.Authorized != nil { + if i.Clique.Authorize != nil { if i.Header.Nonce != nil { return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided nonce")) } - if *i.Clique.Authorized { + if *i.Clique.Authorize { header.Nonce = [8]byte{} } else { header.Nonce = [8]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} diff --git a/cmd/evm/testdata/21/clique.json b/cmd/evm/testdata/21/clique.json index a9f25639fc9b..84fa259a0d65 100644 --- a/cmd/evm/testdata/21/clique.json +++ b/cmd/evm/testdata/21/clique.json @@ -1,6 +1,6 @@ { "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8", "voted": "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba", - "authorized": false, + "authorize": false, "vanity": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" } diff --git a/cmd/evm/testdata/22/clique.json b/cmd/evm/testdata/22/clique.json deleted file mode 100644 index a9f25639fc9b..000000000000 --- a/cmd/evm/testdata/22/clique.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8", - "voted": "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba", - "authorized": false, - "vanity": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" -}