From 5c2f1e00148f16655d3fb63b93920b1108165c56 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@users.noreply.github.com>
Date: Mon, 8 Jan 2018 13:15:57 +0100
Subject: all: update generated code (#15808)

* core/types, core/vm, eth, tests: regenerate gencodec files

* Makefile: update devtools target

Install protoc-gen-go and print reminders about npm, solc and protoc.
Also switch to github.com/kevinburke/go-bindata because it's more
maintained.

* contracts/ens: update contracts and regenerate with solidity v0.4.19

The newer upstream version of the FIFSRegistrar contract doesn't set the
resolver anymore. The resolver is now deployed separately.

* contracts/release: regenerate with solidity v0.4.19

* contracts/chequebook: fix fallback and regenerate with solidity v0.4.19

The contract didn't have a fallback function, payments would be rejected
when compiled with newer solidity. References to 'mortal' and 'owned'
use the local file system so we can compile without network access.

* p2p/discv5: regenerate with recent stringer

* cmd/faucet: regenerate

* dashboard: regenerate

* eth/tracers: regenerate

* internal/jsre/deps: regenerate

* dashboard: avoid sed -i because it's not portable

* accounts/usbwallet/internal/trezor: fix go generate warnings
---
 core/vm/gen_structlog.go | 30 +++++++++++++++++-------------
 core/vm/logger.go        | 20 ++++++++++++++------
 2 files changed, 31 insertions(+), 19 deletions(-)

(limited to 'core/vm')

diff --git a/core/vm/gen_structlog.go b/core/vm/gen_structlog.go
index 88df942dc..890c6624d 100644
--- a/core/vm/gen_structlog.go
+++ b/core/vm/gen_structlog.go
@@ -11,19 +11,22 @@ import (
 	"github.com/ethereum/go-ethereum/common/math"
 )
 
+var _ = (*structLogMarshaling)(nil)
+
 func (s StructLog) MarshalJSON() ([]byte, error) {
 	type StructLog struct {
-		Pc         uint64                      `json:"pc"`
-		Op         OpCode                      `json:"op"`
-		Gas        math.HexOrDecimal64         `json:"gas"`
-		GasCost    math.HexOrDecimal64         `json:"gasCost"`
-		Memory     hexutil.Bytes               `json:"memory"`
-		MemorySize int                         `json:"memSize"`
-		Stack      []*math.HexOrDecimal256     `json:"stack"`
-		Storage    map[common.Hash]common.Hash `json:"-"`
-		Depth      int                         `json:"depth"`
-		Err        error                       `json:"error"`
-		OpName     string                      `json:"opName"`
+		Pc          uint64                      `json:"pc"`
+		Op          OpCode                      `json:"op"`
+		Gas         math.HexOrDecimal64         `json:"gas"`
+		GasCost     math.HexOrDecimal64         `json:"gasCost"`
+		Memory      hexutil.Bytes               `json:"memory"`
+		MemorySize  int                         `json:"memSize"`
+		Stack       []*math.HexOrDecimal256     `json:"stack"`
+		Storage     map[common.Hash]common.Hash `json:"-"`
+		Depth       int                         `json:"depth"`
+		Err         error                       `json:"-"`
+		OpName      string                      `json:"opName"`
+		ErrorString string                      `json:"error"`
 	}
 	var enc StructLog
 	enc.Pc = s.Pc
@@ -42,6 +45,7 @@ func (s StructLog) MarshalJSON() ([]byte, error) {
 	enc.Depth = s.Depth
 	enc.Err = s.Err
 	enc.OpName = s.OpName()
+	enc.ErrorString = s.ErrorString()
 	return json.Marshal(&enc)
 }
 
@@ -56,7 +60,7 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 		Stack      []*math.HexOrDecimal256     `json:"stack"`
 		Storage    map[common.Hash]common.Hash `json:"-"`
 		Depth      *int                        `json:"depth"`
-		Err        *error                      `json:"error"`
+		Err        error                       `json:"-"`
 	}
 	var dec StructLog
 	if err := json.Unmarshal(input, &dec); err != nil {
@@ -93,7 +97,7 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 		s.Depth = *dec.Depth
 	}
 	if dec.Err != nil {
-		s.Err = *dec.Err
+		s.Err = dec.Err
 	}
 	return nil
 }
diff --git a/core/vm/logger.go b/core/vm/logger.go
index 119181433..4c820d8b5 100644
--- a/core/vm/logger.go
+++ b/core/vm/logger.go
@@ -62,22 +62,30 @@ type StructLog struct {
 	Stack      []*big.Int                  `json:"stack"`
 	Storage    map[common.Hash]common.Hash `json:"-"`
 	Depth      int                         `json:"depth"`
-	Err        error                       `json:"error"`
+	Err        error                       `json:"-"`
 }
 
 // overrides for gencodec
 type structLogMarshaling struct {
-	Stack   []*math.HexOrDecimal256
-	Gas     math.HexOrDecimal64
-	GasCost math.HexOrDecimal64
-	Memory  hexutil.Bytes
-	OpName  string `json:"opName"`
+	Stack       []*math.HexOrDecimal256
+	Gas         math.HexOrDecimal64
+	GasCost     math.HexOrDecimal64
+	Memory      hexutil.Bytes
+	OpName      string `json:"opName"` // adds call to OpName() in MarshalJSON
+	ErrorString string `json:"error"`  // adds call to ErrorString() in MarshalJSON
 }
 
 func (s *StructLog) OpName() string {
 	return s.Op.String()
 }
 
+func (s *StructLog) ErrorString() string {
+	if s.Err != nil {
+		return s.Err.Error()
+	}
+	return ""
+}
+
 // Tracer is used to collect execution traces from an EVM transaction
 // execution. CaptureState is called for each step of the VM with the
 // current VM state.
-- 
cgit