diff --git a/cmd/go-quai/test_cmd.go b/cmd/go-quai/test_cmd.go
index 708f4f2915..2bfa011a45 100644
--- a/cmd/go-quai/test_cmd.go
+++ b/cmd/go-quai/test_cmd.go
@@ -84,7 +84,7 @@ func (tt *TestCmd) Run(name string, args ...string) {
// InputLine writes the given text to the child's stdin.
// This method can also be called from an expect template, e.g.:
//
-// geth.expect(`Passphrase: {{.InputLine "password"}}`)
+// geth.expect(`Passphrase: {{.InputLine "password"}}`)
func (tt *TestCmd) InputLine(s string) string {
io.WriteString(tt.stdin, s+"\n")
return ""
diff --git a/cmd/utils/diskusage.go b/cmd/utils/diskusage.go
index c3d51765f8..349b4e6608 100644
--- a/cmd/utils/diskusage.go
+++ b/cmd/utils/diskusage.go
@@ -14,6 +14,7 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
+//go:build !windows && !openbsd
// +build !windows,!openbsd
package utils
@@ -32,6 +33,7 @@ func getFreeDiskSpace(path string) (uint64, error) {
// Available blocks * size per block = available space in bytes
var bavail = stat.Bavail
+ // nolint:staticcheck
if stat.Bavail < 0 {
// FreeBSD can have a negative number of blocks available
// because of the grace limit.
diff --git a/common/hexutil/hexutil.go b/common/hexutil/hexutil.go
index 46223a2815..304a6801b6 100644
--- a/common/hexutil/hexutil.go
+++ b/common/hexutil/hexutil.go
@@ -18,7 +18,7 @@
Package hexutil implements hex encoding with 0x prefix.
This encoding is used by the Ethereum RPC API to transport binary data in JSON payloads.
-Encoding Rules
+# Encoding Rules
All hex data must have prefix "0x".
diff --git a/common/math/big.go b/common/math/big.go
index 1af5b4d879..48427810e1 100644
--- a/common/math/big.go
+++ b/common/math/big.go
@@ -227,10 +227,10 @@ func U256Bytes(n *big.Int) []byte {
// S256 interprets x as a two's complement number.
// x must not exceed 256 bits (the result is undefined if it does) and is not modified.
//
-// S256(0) = 0
-// S256(1) = 1
-// S256(2**255) = -2**255
-// S256(2**256-1) = -1
+// S256(0) = 0
+// S256(1) = 1
+// S256(2**255) = -2**255
+// S256(2**256-1) = -1
func S256(x *big.Int) *big.Int {
if x.Cmp(tt255) < 0 {
return x
diff --git a/common/prque/lazyqueue.go b/common/prque/lazyqueue.go
index a75f17b385..2d4af55997 100644
--- a/common/prque/lazyqueue.go
+++ b/common/prque/lazyqueue.go
@@ -26,9 +26,10 @@ import (
// LazyQueue is a priority queue data structure where priorities can change over
// time and are only evaluated on demand.
// Two callbacks are required:
-// - priority evaluates the actual priority of an item
-// - maxPriority gives an upper estimate for the priority in any moment between
-// now and the given absolute time
+// - priority evaluates the actual priority of an item
+// - maxPriority gives an upper estimate for the priority in any moment between
+// now and the given absolute time
+//
// If the upper estimate is exceeded then Update should be called for that item.
// A global Refresh function should also be called periodically.
type LazyQueue struct {
diff --git a/consensus/blake3pow/api.go b/consensus/blake3pow/api.go
index 646c0b2115..622fe78621 100644
--- a/consensus/blake3pow/api.go
+++ b/consensus/blake3pow/api.go
@@ -34,10 +34,11 @@ type API struct {
// GetWork returns a work package for external miner.
//
// The work package consists of 3 strings:
-// result[0] - 32 bytes hex encoded current block header pow-hash
-// result[1] - 32 bytes hex encoded seed hash used for DAG
-// result[2] - 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty
-// result[3] - hex encoded block number
+//
+// result[0] - 32 bytes hex encoded current block header pow-hash
+// result[1] - 32 bytes hex encoded seed hash used for DAG
+// result[2] - 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty
+// result[3] - hex encoded block number
func (api *API) GetWork() ([4]string, error) {
if api.blake3pow.remote == nil {
return [4]string{}, errors.New("not supported")
diff --git a/consensus/blake3pow/sealer.go b/consensus/blake3pow/sealer.go
index a65621a578..9309f6c305 100644
--- a/consensus/blake3pow/sealer.go
+++ b/consensus/blake3pow/sealer.go
@@ -312,10 +312,11 @@ func (s *remoteSealer) loop() {
// makeWork creates a work package for external miner.
//
// The work package consists of 3 strings:
-// result[0], 32 bytes hex encoded current header pow-hash
-// result[1], 32 bytes hex encoded seed hash used for DAG
-// result[2], 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty
-// result[3], hex encoded header number
+//
+// result[0], 32 bytes hex encoded current header pow-hash
+// result[1], 32 bytes hex encoded seed hash used for DAG
+// result[2], 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty
+// result[3], hex encoded header number
func (s *remoteSealer) makeWork(header *types.Header) {
hash := s.blake3pow.SealHash(header)
s.currentWork[0] = hash.Hex()
diff --git a/core/state/pruner/pruner.go b/core/state/pruner/pruner.go
index aa952a4278..a932b87c45 100644
--- a/core/state/pruner/pruner.go
+++ b/core/state/pruner/pruner.go
@@ -67,9 +67,9 @@ var (
// Pruner is an offline tool to prune the stale state with the
// help of the snapshot. The workflow of pruner is very simple:
//
-// - iterate the snapshot, reconstruct the relevant state
-// - iterate the database, delete all other state entries which
-// don't belong to the target state and the genesis state
+// - iterate the snapshot, reconstruct the relevant state
+// - iterate the database, delete all other state entries which
+// don't belong to the target state and the genesis state
//
// It can take several hours(around 2 hours for mainnet) to finish
// the whole pruning work. It's recommended to run this offline tool
diff --git a/core/state/snapshot/snapshot.go b/core/state/snapshot/snapshot.go
index 30fe53e32a..c16d82867d 100644
--- a/core/state/snapshot/snapshot.go
+++ b/core/state/snapshot/snapshot.go
@@ -176,10 +176,10 @@ type Tree struct {
// If the memory layers in the journal do not match the disk layer (e.g. there is
// a gap) or the journal is missing, there are two repair cases:
//
-// - if the 'recovery' parameter is true, all memory diff-layers will be discarded.
-// This case happens when the snapshot is 'ahead' of the state trie.
-// - otherwise, the entire snapshot is considered invalid and will be recreated on
-// a background thread.
+// - if the 'recovery' parameter is true, all memory diff-layers will be discarded.
+// This case happens when the snapshot is 'ahead' of the state trie.
+// - otherwise, the entire snapshot is considered invalid and will be recreated on
+// a background thread.
func New(diskdb ethdb.KeyValueStore, triedb *trie.Database, cache int, root common.Hash, async bool, rebuild bool, recovery bool) (*Tree, error) {
// Create a new, empty snapshot tree
snap := &Tree{
diff --git a/core/state/statedb.go b/core/state/statedb.go
index 89db140fb3..915f78f21e 100644
--- a/core/state/statedb.go
+++ b/core/state/statedb.go
@@ -602,8 +602,8 @@ func (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject)
// CreateAccount is called during the EVM CREATE operation. The situation might arise that
// a contract does the following:
//
-// 1. sends funds to sha(account ++ (nonce + 1))
-// 2. tx_create(sha(account ++ nonce)) (note that this gets the address of 1)
+// 1. sends funds to sha(account ++ (nonce + 1))
+// 2. tx_create(sha(account ++ nonce)) (note that this gets the address of 1)
//
// Carrying over the balance ensures that Ether doesn't disappear.
func (s *StateDB) CreateAccount(addr common.Address) {
diff --git a/crypto/blake2b/blake2b.go b/crypto/blake2b/blake2b.go
index 5da50cab6f..8e81a55870 100644
--- a/crypto/blake2b/blake2b.go
+++ b/crypto/blake2b/blake2b.go
@@ -302,18 +302,7 @@ func appendUint64(b []byte, x uint64) []byte {
return append(b, a[:]...)
}
-func appendUint32(b []byte, x uint32) []byte {
- var a [4]byte
- binary.BigEndian.PutUint32(a[:], x)
- return append(b, a[:]...)
-}
-
func consumeUint64(b []byte) ([]byte, uint64) {
x := binary.BigEndian.Uint64(b)
return b[8:], x
}
-
-func consumeUint32(b []byte) ([]byte, uint32) {
- x := binary.BigEndian.Uint32(b)
- return b[4:], x
-}
diff --git a/crypto/blake2b/blake2b_generic.go b/crypto/blake2b/blake2b_generic.go
index 35c40cc924..b506e30c1a 100644
--- a/crypto/blake2b/blake2b_generic.go
+++ b/crypto/blake2b/blake2b_generic.go
@@ -5,7 +5,6 @@
package blake2b
import (
- "encoding/binary"
"math/bits"
)
@@ -25,24 +24,6 @@ var precomputed = [10][16]byte{
{10, 8, 7, 1, 2, 4, 6, 5, 15, 9, 3, 13, 11, 14, 12, 0},
}
-func hashBlocksGeneric(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) {
- var m [16]uint64
- c0, c1 := c[0], c[1]
-
- for i := 0; i < len(blocks); {
- c0 += BlockSize
- if c0 < BlockSize {
- c1++
- }
- for j := range m {
- m[j] = binary.LittleEndian.Uint64(blocks[i:])
- i += 8
- }
- fGeneric(h, &m, c0, c1, flag, 12)
- }
- c[0], c[1] = c0, c1
-}
-
func fGeneric(h *[8]uint64, m *[16]uint64, c0, c1 uint64, flag uint64, rounds uint64) {
v0, v1, v2, v3, v4, v5, v6, v7 := h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
v8, v9, v10, v11, v12, v13, v14, v15 := iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]
diff --git a/crypto/blake2b/blake2b_ref.go b/crypto/blake2b/blake2b_ref.go
index 9d0ade473a..095c71a648 100644
--- a/crypto/blake2b/blake2b_ref.go
+++ b/crypto/blake2b/blake2b_ref.go
@@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
+//go:build !amd64 || appengine || gccgo
// +build !amd64 appengine gccgo
package blake2b
diff --git a/crypto/blake2b/register.go b/crypto/blake2b/register.go
index efd689af4b..9d8633963c 100644
--- a/crypto/blake2b/register.go
+++ b/crypto/blake2b/register.go
@@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
+//go:build go1.9
// +build go1.9
package blake2b
diff --git a/crypto/crypto.go b/crypto/crypto.go
index 910d1d9a8c..26b53d90f6 100644
--- a/crypto/crypto.go
+++ b/crypto/crypto.go
@@ -36,7 +36,7 @@ import (
"golang.org/x/crypto/sha3"
)
-//SignatureLength indicates the byte length required to carry a signature with recovery id.
+// SignatureLength indicates the byte length required to carry a signature with recovery id.
const SignatureLength = 64 + 1 // 64 bytes ECDSA signature + 1 byte recovery id
// RecoveryIDOffset points to the byte offset within the signature that contains the recovery id.
diff --git a/eth/abi/reflect.go b/eth/abi/reflect.go
index 11248e0730..0f4948ac82 100644
--- a/eth/abi/reflect.go
+++ b/eth/abi/reflect.go
@@ -28,11 +28,13 @@ import (
// given type
// e.g. turn
// var fields []reflect.StructField
-// fields = append(fields, reflect.StructField{
-// Name: "X",
-// Type: reflect.TypeOf(new(big.Int)),
-// Tag: reflect.StructTag("json:\"" + "x" + "\""),
-// }
+//
+// fields = append(fields, reflect.StructField{
+// Name: "X",
+// Type: reflect.TypeOf(new(big.Int)),
+// Tag: reflect.StructTag("json:\"" + "x" + "\""),
+// }
+//
// into
// type TupleT struct { X *big.Int }
func ConvertType(in interface{}, proto interface{}) interface{} {
@@ -178,10 +180,14 @@ func setStruct(dst, src reflect.Value) error {
// mapArgNamesToStructFields maps a slice of argument names to struct fields.
// first round: for each Exportable field that contains a `abi:""` tag
-// and this field name exists in the given argument name list, pair them together.
+//
+// and this field name exists in the given argument name list, pair them together.
+//
// second round: for each argument name that has not been already linked,
-// find what variable is expected to be mapped into, if it exists and has not been
-// used, pair them.
+//
+// find what variable is expected to be mapped into, if it exists and has not been
+// used, pair them.
+//
// Note this function assumes the given value is a struct value.
func mapArgNamesToStructFields(argNames []string, value reflect.Value) (map[string]string, error) {
typ := value.Type()
diff --git a/eth/ethconfig/config.go b/eth/ethconfig/config.go
index a78fc6b305..e64c597839 100644
--- a/eth/ethconfig/config.go
+++ b/eth/ethconfig/config.go
@@ -19,8 +19,6 @@ package ethconfig
import (
"math/big"
- "os"
- "os/user"
"time"
"github.com/dominant-strategies/go-quai/common"
@@ -81,15 +79,6 @@ var Defaults = Config{
SubUrls: []string{"ws://127.0.0.1:8546", "ws://127.0.0.1:8546", "ws://127.0.0.1:8546"},
}
-func init() {
- home := os.Getenv("HOME")
- if home == "" {
- if user, err := user.Current(); err == nil {
- home = user.HomeDir
- }
- }
-}
-
//go:generate gencodec -type Config -formats toml -out gen_config.go
// Config contains configuration options for of the ETH and LES protocols.
diff --git a/ethdb/leveldb/leveldb.go b/ethdb/leveldb/leveldb.go
index 8d83a09755..e38f71c1ea 100644
--- a/ethdb/leveldb/leveldb.go
+++ b/ethdb/leveldb/leveldb.go
@@ -14,6 +14,7 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
+//go:build !js
// +build !js
// Package leveldb implements the key-value database layer based on LevelDB.
@@ -244,13 +245,14 @@ func (db *Database) Path() string {
// the metrics subsystem.
//
// This is how a LevelDB stats table looks like (currently):
-// Compactions
-// Level | Tables | Size(MB) | Time(sec) | Read(MB) | Write(MB)
-// -------+------------+---------------+---------------+---------------+---------------
-// 0 | 0 | 0.00000 | 1.27969 | 0.00000 | 12.31098
-// 1 | 85 | 109.27913 | 28.09293 | 213.92493 | 214.26294
-// 2 | 523 | 1000.37159 | 7.26059 | 66.86342 | 66.77884
-// 3 | 570 | 1113.18458 | 0.00000 | 0.00000 | 0.00000
+//
+// Compactions
+// Level | Tables | Size(MB) | Time(sec) | Read(MB) | Write(MB)
+// -------+------------+---------------+---------------+---------------+---------------
+// 0 | 0 | 0.00000 | 1.27969 | 0.00000 | 12.31098
+// 1 | 85 | 109.27913 | 28.09293 | 213.92493 | 214.26294
+// 2 | 523 | 1000.37159 | 7.26059 | 66.86342 | 66.77884
+// 3 | 570 | 1113.18458 | 0.00000 | 0.00000 | 0.00000
//
// This is how the write delay look like (currently):
// DelayN:5 Delay:406.604657ms Paused: false
diff --git a/ethstats/ethstats.go b/ethstats/ethstats.go
index 48d23160d1..62ecf73708 100644
--- a/ethstats/ethstats.go
+++ b/ethstats/ethstats.go
@@ -100,13 +100,14 @@ type Service struct {
// websocket.
//
// From Gorilla websocket docs:
-// Connections support one concurrent reader and one concurrent writer.
-// Applications are responsible for ensuring that no more than one goroutine calls the write methods
-// - NextWriter, SetWriteDeadline, WriteMessage, WriteJSON, EnableWriteCompression, SetCompressionLevel
-// concurrently and that no more than one goroutine calls the read methods
-// - NextReader, SetReadDeadline, ReadMessage, ReadJSON, SetPongHandler, SetPingHandler
-// concurrently.
-// The Close and WriteControl methods can be called concurrently with all other methods.
+//
+// Connections support one concurrent reader and one concurrent writer.
+// Applications are responsible for ensuring that no more than one goroutine calls the write methods
+// - NextWriter, SetWriteDeadline, WriteMessage, WriteJSON, EnableWriteCompression, SetCompressionLevel
+// concurrently and that no more than one goroutine calls the read methods
+// - NextReader, SetReadDeadline, ReadMessage, ReadJSON, SetPongHandler, SetPingHandler
+// concurrently.
+// The Close and WriteControl methods can be called concurrently with all other methods.
type connWrapper struct {
conn *websocket.Conn
diff --git a/internal/debug/loudpanic.go b/internal/debug/loudpanic.go
index 572ebcefa1..86e6bc88f8 100644
--- a/internal/debug/loudpanic.go
+++ b/internal/debug/loudpanic.go
@@ -14,6 +14,7 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
+//go:build go1.6
// +build go1.6
package debug
diff --git a/internal/debug/trace.go b/internal/debug/trace.go
index 5a1f8227e6..be724cdb0f 100644
--- a/internal/debug/trace.go
+++ b/internal/debug/trace.go
@@ -14,7 +14,8 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
-//+build go1.5
+//go:build go1.5
+// +build go1.5
package debug
diff --git a/internal/quaiapi/api.go b/internal/quaiapi/api.go
index abbcf39041..e8737c9613 100644
--- a/internal/quaiapi/api.go
+++ b/internal/quaiapi/api.go
@@ -368,10 +368,10 @@ func (s *PublicBlockChainAPI) GetHeaderByHash(ctx context.Context, hash common.H
}
// GetBlockByNumber returns the requested canonical block.
-// * When blockNr is -1 the chain head is returned.
-// * When blockNr is -2 the pending chain head is returned.
-// * When fullTx is true all transactions in the block are returned, otherwise
-// only the transaction hash is returned.
+// - When blockNr is -1 the chain head is returned.
+// - When blockNr is -2 the pending chain head is returned.
+// - When fullTx is true all transactions in the block are returned, otherwise
+// only the transaction hash is returned.
func (s *PublicBlockChainAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) {
block, err := s.b.BlockByNumber(ctx, number)
if block != nil && err == nil {
diff --git a/internal/quaiapi/quai_api.go b/internal/quaiapi/quai_api.go
index 1a8edc201e..e53cbc06f1 100644
--- a/internal/quaiapi/quai_api.go
+++ b/internal/quaiapi/quai_api.go
@@ -50,7 +50,7 @@ func (s *PublicQuaiAPI) GasPrice(ctx context.Context) (*hexutil.Big, error) {
if err != nil {
return nil, err
}
- if head := s.b.CurrentHeader(); head.BaseFee != nil {
+ if head := s.b.CurrentHeader(); head.BaseFee() != nil {
tipcap.Add(tipcap, head.BaseFee())
}
return (*hexutil.Big)(tipcap), err
@@ -223,10 +223,10 @@ func (s *PublicBlockChainQuaiAPI) GetHeaderByHash(ctx context.Context, hash comm
}
// GetBlockByNumber returns the requested canonical block.
-// * When blockNr is -1 the chain head is returned.
-// * When blockNr is -2 the pending chain head is returned.
-// * When fullTx is true all transactions in the block are returned, otherwise
-// only the transaction hash is returned.
+// - When blockNr is -1 the chain head is returned.
+// - When blockNr is -2 the pending chain head is returned.
+// - When fullTx is true all transactions in the block are returned, otherwise
+// only the transaction hash is returned.
func (s *PublicBlockChainQuaiAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) {
block, err := s.b.BlockByNumber(ctx, number)
if block != nil && err == nil {
diff --git a/log/doc.go b/log/doc.go
index 993743c0fd..d2e15140e4 100644
--- a/log/doc.go
+++ b/log/doc.go
@@ -7,27 +7,25 @@ This package enforces you to only log key/value pairs. Keys must be strings. Val
any type that you like. The default output format is logfmt, but you may also choose to use
JSON instead if that suits you. Here's how you log:
- log.Info("page accessed", "path", r.URL.Path, "user_id", user.id)
+ log.Info("page accessed", "path", r.URL.Path, "user_id", user.id)
This will output a line that looks like:
- lvl=info t=2014-05-02T16:07:23-0700 msg="page accessed" path=/org/71/profile user_id=9
+ lvl=info t=2014-05-02T16:07:23-0700 msg="page accessed" path=/org/71/profile user_id=9
-Getting Started
+# Getting Started
To get started, you'll want to import the library:
- import log "github.com/inconshreveable/log15"
-
+ import log "github.com/inconshreveable/log15"
Now you're ready to start logging:
- func main() {
- log.Info("Program starting", "args", os.Args())
- }
-
+ func main() {
+ log.Info("Program starting", "args", os.Args())
+ }
-Convention
+# Convention
Because recording a human-meaningful message is common and good practice, the first argument to every
logging method is the value to the *implicit* key 'msg'.
@@ -40,38 +38,35 @@ you to favor terseness, ordering, and speed over safety. This is a reasonable tr
logging functions. You don't need to explicitly state keys/values, log15 understands that they alternate
in the variadic argument list:
- log.Warn("size out of bounds", "low", lowBound, "high", highBound, "val", val)
+ log.Warn("size out of bounds", "low", lowBound, "high", highBound, "val", val)
If you really do favor your type-safety, you may choose to pass a log.Ctx instead:
- log.Warn("size out of bounds", log.Ctx{"low": lowBound, "high": highBound, "val": val})
-
+ log.Warn("size out of bounds", log.Ctx{"low": lowBound, "high": highBound, "val": val})
-Context loggers
+# Context loggers
Frequently, you want to add context to a logger so that you can track actions associated with it. An http
request is a good example. You can easily create new loggers that have context that is automatically included
with each log line:
- requestlogger := log.New("path", r.URL.Path)
+ requestlogger := log.New("path", r.URL.Path)
- // later
- requestlogger.Debug("db txn commit", "duration", txnTimer.Finish())
+ // later
+ requestlogger.Debug("db txn commit", "duration", txnTimer.Finish())
This will output a log line that includes the path context that is attached to the logger:
- lvl=dbug t=2014-05-02T16:07:23-0700 path=/repo/12/add_hook msg="db txn commit" duration=0.12
+ lvl=dbug t=2014-05-02T16:07:23-0700 path=/repo/12/add_hook msg="db txn commit" duration=0.12
-
-Handlers
+# Handlers
The Handler interface defines where log lines are printed to and how they are formatted. Handler is a
single interface that is inspired by net/http's handler interface:
- type Handler interface {
- Log(r *Record) error
- }
-
+ type Handler interface {
+ Log(r *Record) error
+ }
Handlers can filter records, format them, or dispatch to multiple other Handlers.
This package implements a number of Handlers for common logging patterns that are
@@ -79,49 +74,49 @@ easily composed to create flexible, custom logging structures.
Here's an example handler that prints logfmt output to Stdout:
- handler := log.StreamHandler(os.Stdout, log.LogfmtFormat())
+ handler := log.StreamHandler(os.Stdout, log.LogfmtFormat())
Here's an example handler that defers to two other handlers. One handler only prints records
from the rpc package in logfmt to standard out. The other prints records at Error level
or above in JSON formatted output to the file /var/log/service.json
- handler := log.MultiHandler(
- log.LvlFilterHandler(log.LvlError, log.Must.FileHandler("/var/log/service.json", log.JSONFormat())),
- log.MatchFilterHandler("pkg", "app/rpc" log.StdoutHandler())
- )
+ handler := log.MultiHandler(
+ log.LvlFilterHandler(log.LvlError, log.Must.FileHandler("/var/log/service.json", log.JSONFormat())),
+ log.MatchFilterHandler("pkg", "app/rpc" log.StdoutHandler())
+ )
-Logging File Names and Line Numbers
+# Logging File Names and Line Numbers
This package implements three Handlers that add debugging information to the
context, CallerFileHandler, CallerFuncHandler and CallerStackHandler. Here's
an example that adds the source file and line number of each logging call to
the context.
- h := log.CallerFileHandler(log.StdoutHandler)
- log.Root().SetHandler(h)
- ...
- log.Error("open file", "err", err)
+ h := log.CallerFileHandler(log.StdoutHandler)
+ log.Root().SetHandler(h)
+ ...
+ log.Error("open file", "err", err)
This will output a line that looks like:
- lvl=eror t=2014-05-02T16:07:23-0700 msg="open file" err="file not found" caller=data.go:42
+ lvl=eror t=2014-05-02T16:07:23-0700 msg="open file" err="file not found" caller=data.go:42
Here's an example that logs the call stack rather than just the call site.
- h := log.CallerStackHandler("%+v", log.StdoutHandler)
- log.Root().SetHandler(h)
- ...
- log.Error("open file", "err", err)
+ h := log.CallerStackHandler("%+v", log.StdoutHandler)
+ log.Root().SetHandler(h)
+ ...
+ log.Error("open file", "err", err)
This will output a line that looks like:
- lvl=eror t=2014-05-02T16:07:23-0700 msg="open file" err="file not found" stack="[pkg/data.go:42 pkg/cmd/main.go]"
+ lvl=eror t=2014-05-02T16:07:23-0700 msg="open file" err="file not found" stack="[pkg/data.go:42 pkg/cmd/main.go]"
The "%+v" format instructs the handler to include the path of the source file
relative to the compile time GOPATH. The github.com/go-stack/stack package
documents the full list of formatting verbs and modifiers available.
-Custom Handlers
+# Custom Handlers
The Handler interface is so simple that it's also trivial to write your own. Let's create an
example handler which tries to write to one handler, but if that fails it falls back to
@@ -129,24 +124,24 @@ writing to another handler and includes the error that it encountered when tryin
to the primary. This might be useful when trying to log over a network socket, but if that
fails you want to log those records to a file on disk.
- type BackupHandler struct {
- Primary Handler
- Secondary Handler
- }
+ type BackupHandler struct {
+ Primary Handler
+ Secondary Handler
+ }
- func (h *BackupHandler) Log (r *Record) error {
- err := h.Primary.Log(r)
- if err != nil {
- r.Ctx = append(ctx, "primary_err", err)
- return h.Secondary.Log(r)
- }
- return nil
- }
+ func (h *BackupHandler) Log (r *Record) error {
+ err := h.Primary.Log(r)
+ if err != nil {
+ r.Ctx = append(ctx, "primary_err", err)
+ return h.Secondary.Log(r)
+ }
+ return nil
+ }
This pattern is so useful that a generic version that handles an arbitrary number of Handlers
is included as part of this library called FailoverHandler.
-Logging Expensive Operations
+# Logging Expensive Operations
Sometimes, you want to log values that are extremely expensive to compute, but you don't want to pay
the price of computing them if you haven't turned up your logging level to a high level of detail.
@@ -155,50 +150,50 @@ This package provides a simple type to annotate a logging operation that you wan
lazily, just when it is about to be logged, so that it would not be evaluated if an upstream Handler
filters it out. Just wrap any function which takes no arguments with the log.Lazy type. For example:
- func factorRSAKey() (factors []int) {
- // return the factors of a very large number
- }
+ func factorRSAKey() (factors []int) {
+ // return the factors of a very large number
+ }
- log.Debug("factors", log.Lazy{factorRSAKey})
+ log.Debug("factors", log.Lazy{factorRSAKey})
If this message is not logged for any reason (like logging at the Error level), then
factorRSAKey is never evaluated.
-Dynamic context values
+# Dynamic context values
The same log.Lazy mechanism can be used to attach context to a logger which you want to be
evaluated when the message is logged, but not when the logger is created. For example, let's imagine
a game where you have Player objects:
- type Player struct {
- name string
- alive bool
- log.Logger
- }
+ type Player struct {
+ name string
+ alive bool
+ log.Logger
+ }
You always want to log a player's name and whether they're alive or dead, so when you create the player
object, you might do:
- p := &Player{name: name, alive: true}
- p.Logger = log.New("name", p.name, "alive", p.alive)
+ p := &Player{name: name, alive: true}
+ p.Logger = log.New("name", p.name, "alive", p.alive)
Only now, even after a player has died, the logger will still report they are alive because the logging
context is evaluated when the logger was created. By using the Lazy wrapper, we can defer the evaluation
of whether the player is alive or not to each log message, so that the log records will reflect the player's
current state no matter when the log message is written:
- p := &Player{name: name, alive: true}
- isAlive := func() bool { return p.alive }
- player.Logger = log.New("name", p.name, "alive", log.Lazy{isAlive})
+ p := &Player{name: name, alive: true}
+ isAlive := func() bool { return p.alive }
+ player.Logger = log.New("name", p.name, "alive", log.Lazy{isAlive})
-Terminal Format
+# Terminal Format
If log15 detects that stdout is a terminal, it will configure the default
handler for it (which is log.StdoutHandler) to use TerminalFormat. This format
logs records nicely for your terminal, including color-coded output based
on log level.
-Error Handling
+# Error Handling
Becasuse log15 allows you to step around the type system, there are a few ways you can specify
invalid arguments to the logging functions. You could, for example, wrap something that is not
@@ -216,61 +211,61 @@ are encouraged to return errors only if they fail to write their log records out
syslog daemon is not responding. This allows the construction of useful handlers which cope with those failures
like the FailoverHandler.
-Library Use
+# Library Use
log15 is intended to be useful for library authors as a way to provide configurable logging to
users of their library. Best practice for use in a library is to always disable all output for your logger
by default and to provide a public Logger instance that consumers of your library can configure. Like so:
- package yourlib
+ package yourlib
- import "github.com/inconshreveable/log15"
+ import "github.com/inconshreveable/log15"
- var Log = log.New()
+ var Log = log.New()
- func init() {
- Log.SetHandler(log.DiscardHandler())
- }
+ func init() {
+ Log.SetHandler(log.DiscardHandler())
+ }
Users of your library may then enable it if they like:
- import "github.com/inconshreveable/log15"
- import "example.com/yourlib"
+ import "github.com/inconshreveable/log15"
+ import "example.com/yourlib"
- func main() {
- handler := // custom handler setup
- yourlib.Log.SetHandler(handler)
- }
+ func main() {
+ handler := // custom handler setup
+ yourlib.Log.SetHandler(handler)
+ }
-Best practices attaching logger context
+# Best practices attaching logger context
The ability to attach context to a logger is a powerful one. Where should you do it and why?
I favor embedding a Logger directly into any persistent object in my application and adding
unique, tracing context keys to it. For instance, imagine I am writing a web browser:
- type Tab struct {
- url string
- render *RenderingContext
- // ...
+ type Tab struct {
+ url string
+ render *RenderingContext
+ // ...
- Logger
- }
+ Logger
+ }
- func NewTab(url string) *Tab {
- return &Tab {
- // ...
- url: url,
+ func NewTab(url string) *Tab {
+ return &Tab {
+ // ...
+ url: url,
- Logger: log.New("url", url),
- }
- }
+ Logger: log.New("url", url),
+ }
+ }
When a new tab is created, I assign a logger to it with the url of
the tab as context so it can easily be traced through the logs.
Now, whenever we perform any operation with the tab, we'll log with its
embedded logger and it will include the tab title automatically:
- tab.Debug("moved position", "idx", tab.idx)
+ tab.Debug("moved position", "idx", tab.idx)
There's only one problem. What if the tab url changes? We could
use log.Lazy to make sure the current url is always written, but that
@@ -285,29 +280,29 @@ function to let you generate what you might call "surrogate keys"
They're just random hex identifiers to use for tracing. Back to our
Tab example, we would prefer to set up our Logger like so:
- import logext "github.com/inconshreveable/log15/ext"
+ import logext "github.com/inconshreveable/log15/ext"
- t := &Tab {
- // ...
- url: url,
- }
+ t := &Tab {
+ // ...
+ url: url,
+ }
- t.Logger = log.New("id", logext.RandId(8), "url", log.Lazy{t.getUrl})
- return t
+ t.Logger = log.New("id", logext.RandId(8), "url", log.Lazy{t.getUrl})
+ return t
Now we'll have a unique traceable identifier even across loading new urls, but
we'll still be able to see the tab's current url in the log messages.
-Must
+# Must
For all Handler functions which can return an error, there is a version of that
function which will return no error but panics on failure. They are all available
on the Must object. For example:
- log.Must.FileHandler("/path", log.JSONFormat)
- log.Must.NetHandler("tcp", ":1234", log.JSONFormat)
+ log.Must.FileHandler("/path", log.JSONFormat)
+ log.Must.NetHandler("tcp", ":1234", log.JSONFormat)
-Inspiration and Credit
+# Inspiration and Credit
All of the following excellent projects inspired the design of this library:
@@ -325,9 +320,8 @@ github.com/spacemonkeygo/spacelog
golang's stdlib, notably io and net/http
-The Name
+# The Name
https://xkcd.com/927/
-
*/
package log
diff --git a/log/format.go b/log/format.go
index baf8fddac0..613dc33be7 100644
--- a/log/format.go
+++ b/log/format.go
@@ -79,12 +79,11 @@ type TerminalStringer interface {
// a terminal with color-coded level output and terser human friendly timestamp.
// This format should only be used for interactive programs or while developing.
//
-// [LEVEL] [TIME] MESSAGE key=value key=value ...
+// [LEVEL] [TIME] MESSAGE key=value key=value ...
//
// Example:
//
-// [DBUG] [May 16 20:58:45] remove route ns=haproxy addr=127.0.0.1:50002
-//
+// [DBUG] [May 16 20:58:45] remove route ns=haproxy addr=127.0.0.1:50002
func TerminalFormat(usecolor bool) Format {
return FormatFunc(func(r *Record) []byte {
var color = 0
@@ -149,7 +148,6 @@ func TerminalFormat(usecolor bool) Format {
// format for key/value pairs.
//
// For more details see: http://godoc.org/github.com/kr/logfmt
-//
func LogfmtFormat() Format {
return FormatFunc(func(r *Record) []byte {
common := []interface{}{r.KeyNames.Time, r.Time, r.KeyNames.Lvl, r.Lvl, r.KeyNames.Msg, r.Msg}
diff --git a/log/handler.go b/log/handler.go
index 4ad433334e..5fc727d02e 100644
--- a/log/handler.go
+++ b/log/handler.go
@@ -135,15 +135,14 @@ func CallerStackHandler(format string, h Handler) Handler {
// wrapped Handler if the given function evaluates true. For example,
// to only log records where the 'err' key is not nil:
//
-// logger.SetHandler(FilterHandler(func(r *Record) bool {
-// for i := 0; i < len(r.Ctx); i += 2 {
-// if r.Ctx[i] == "err" {
-// return r.Ctx[i+1] != nil
-// }
-// }
-// return false
-// }, h))
-//
+// logger.SetHandler(FilterHandler(func(r *Record) bool {
+// for i := 0; i < len(r.Ctx); i += 2 {
+// if r.Ctx[i] == "err" {
+// return r.Ctx[i+1] != nil
+// }
+// }
+// return false
+// }, h))
func FilterHandler(fn func(r *Record) bool, h Handler) Handler {
return FuncHandler(func(r *Record) error {
if fn(r) {
@@ -158,8 +157,7 @@ func FilterHandler(fn func(r *Record) bool, h Handler) Handler {
// context matches the value. For example, to only log records
// from your ui package:
//
-// log.MatchFilterHandler("pkg", "app/ui", log.StdoutHandler)
-//
+// log.MatchFilterHandler("pkg", "app/ui", log.StdoutHandler)
func MatchFilterHandler(key string, value interface{}, h Handler) Handler {
return FilterHandler(func(r *Record) (pass bool) {
switch key {
@@ -185,8 +183,7 @@ func MatchFilterHandler(key string, value interface{}, h Handler) Handler {
// level to the wrapped Handler. For example, to only
// log Error/Crit records:
//
-// log.LvlFilterHandler(log.LvlError, log.StdoutHandler)
-//
+// log.LvlFilterHandler(log.LvlError, log.StdoutHandler)
func LvlFilterHandler(maxLvl Lvl, h Handler) Handler {
return FilterHandler(func(r *Record) (pass bool) {
return r.Lvl <= maxLvl
@@ -198,10 +195,9 @@ func LvlFilterHandler(maxLvl Lvl, h Handler) Handler {
// to different locations. For example, to log to a file and
// standard error:
//
-// log.MultiHandler(
-// log.Must.FileHandler("/var/log/app.log", log.LogfmtFormat()),
-// log.StderrHandler)
-//
+// log.MultiHandler(
+// log.Must.FileHandler("/var/log/app.log", log.LogfmtFormat()),
+// log.StderrHandler)
func MultiHandler(hs ...Handler) Handler {
return FuncHandler(func(r *Record) error {
for _, h := range hs {
@@ -219,10 +215,10 @@ func MultiHandler(hs ...Handler) Handler {
// to writing to a file if the network fails, and then to
// standard out if the file write fails:
//
-// log.FailoverHandler(
-// log.Must.NetHandler("tcp", ":9090", log.JSONFormat()),
-// log.Must.FileHandler("/var/log/app.log", log.LogfmtFormat()),
-// log.StdoutHandler)
+// log.FailoverHandler(
+// log.Must.NetHandler("tcp", ":9090", log.JSONFormat()),
+// log.Must.FileHandler("/var/log/app.log", log.LogfmtFormat()),
+// log.StdoutHandler)
//
// All writes that do not go to the first handler will add context with keys of
// the form "failover_err_{idx}" which explain the error encountered while
diff --git a/log/handler_glog.go b/log/handler_glog.go
index 9b1d4efaf4..b5186d4b27 100644
--- a/log/handler_glog.go
+++ b/log/handler_glog.go
@@ -82,14 +82,14 @@ func (h *GlogHandler) Verbosity(level Lvl) {
//
// For instance:
//
-// pattern="gopher.go=3"
-// sets the V level to 3 in all Go files named "gopher.go"
+// pattern="gopher.go=3"
+// sets the V level to 3 in all Go files named "gopher.go"
//
-// pattern="foo=3"
-// sets V to 3 in all files of any packages whose import path ends in "foo"
+// pattern="foo=3"
+// sets V to 3 in all files of any packages whose import path ends in "foo"
//
-// pattern="foo/*=3"
-// sets V to 3 in all files of any packages whose import path contains "foo"
+// pattern="foo/*=3"
+// sets V to 3 in all files of any packages whose import path contains "foo"
func (h *GlogHandler) Vmodule(ruleset string) error {
var filter []pattern
for _, rule := range strings.Split(ruleset, ",") {
diff --git a/log/handler_go14.go b/log/handler_go14.go
index 05dedbf2a7..d0cb14aa06 100644
--- a/log/handler_go14.go
+++ b/log/handler_go14.go
@@ -1,3 +1,4 @@
+//go:build go1.4
// +build go1.4
package log
diff --git a/log/syslog.go b/log/syslog.go
index 71a17b30b3..451d831b6d 100644
--- a/log/syslog.go
+++ b/log/syslog.go
@@ -1,3 +1,4 @@
+//go:build !windows && !plan9
// +build !windows,!plan9
package log
diff --git a/metrics/cpu_enabled.go b/metrics/cpu_enabled.go
index a91f45d57c..3a272c54cf 100644
--- a/metrics/cpu_enabled.go
+++ b/metrics/cpu_enabled.go
@@ -14,6 +14,7 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
+//go:build !ios
// +build !ios
package metrics
diff --git a/metrics/cpu_syscall.go b/metrics/cpu_syscall.go
index 9ad6e85d5c..6c69c5fd41 100644
--- a/metrics/cpu_syscall.go
+++ b/metrics/cpu_syscall.go
@@ -14,6 +14,7 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
+//go:build !windows
// +build !windows
package metrics
diff --git a/metrics/disk_nop.go b/metrics/disk_nop.go
index 4319f8b277..58fa4e02f8 100644
--- a/metrics/disk_nop.go
+++ b/metrics/disk_nop.go
@@ -14,6 +14,7 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
+//go:build !linux
// +build !linux
package metrics
diff --git a/metrics/influxdb/influxdb.go b/metrics/influxdb/influxdb.go
index 7628475508..4217bca5ba 100644
--- a/metrics/influxdb/influxdb.go
+++ b/metrics/influxdb/influxdb.go
@@ -98,16 +98,16 @@ func (r *reporter) makeClient() (err error) {
}
func (r *reporter) run() {
- intervalTicker := time.Tick(r.interval)
- pingTicker := time.Tick(time.Second * 5)
+ intervalTicker := time.NewTicker(r.interval)
+ pingTicker := time.NewTicker(time.Second * 5)
for {
select {
- case <-intervalTicker:
+ case <-intervalTicker.C:
if err := r.send(); err != nil {
log.Warn("Unable to send to InfluxDB", "err", err)
}
- case <-pingTicker:
+ case <-pingTicker.C:
_, _, err := r.client.Ping()
if err != nil {
log.Warn("Got error while sending a ping to InfluxDB, trying to recreate client", "err", err)
diff --git a/metrics/runtime_cgo.go b/metrics/runtime_cgo.go
index e3391f4e89..7d0af4f7e4 100644
--- a/metrics/runtime_cgo.go
+++ b/metrics/runtime_cgo.go
@@ -1,5 +1,5 @@
-// +build cgo
-// +build !appengine
+//go:build cgo && !appengine
+// +build cgo,!appengine
package metrics
diff --git a/metrics/runtime_gccpufraction.go b/metrics/runtime_gccpufraction.go
index ca12c05bac..28cd44752b 100644
--- a/metrics/runtime_gccpufraction.go
+++ b/metrics/runtime_gccpufraction.go
@@ -1,3 +1,4 @@
+//go:build go1.5
// +build go1.5
package metrics
diff --git a/metrics/syslog.go b/metrics/syslog.go
index a0ed4b1b23..551a2bd0f0 100644
--- a/metrics/syslog.go
+++ b/metrics/syslog.go
@@ -1,3 +1,4 @@
+//go:build !windows
// +build !windows
package metrics
diff --git a/p2p/dnsdisc/tree.go b/p2p/dnsdisc/tree.go
index bdb5eaa9ac..34c90d36a6 100644
--- a/p2p/dnsdisc/tree.go
+++ b/p2p/dnsdisc/tree.go
@@ -117,21 +117,21 @@ func (t *Tree) Nodes() []*enode.Node {
We want to keep the UDP size below 512 bytes. The UDP size is roughly:
UDP length = 8 + UDP payload length ( 229 )
UPD Payload length:
- - dns.id 2
- - dns.flags 2
- - dns.count.queries 2
- - dns.count.answers 2
- - dns.count.auth_rr 2
- - dns.count.add_rr 2
- - queries (query-size + 6)
- - answers :
- - dns.resp.name 2
- - dns.resp.type 2
- - dns.resp.class 2
- - dns.resp.ttl 4
- - dns.resp.len 2
- - dns.txt.length 1
- - dns.txt resp_data_size
+ - dns.id 2
+ - dns.flags 2
+ - dns.count.queries 2
+ - dns.count.answers 2
+ - dns.count.auth_rr 2
+ - dns.count.add_rr 2
+ - queries (query-size + 6)
+ - answers :
+ - dns.resp.name 2
+ - dns.resp.type 2
+ - dns.resp.class 2
+ - dns.resp.ttl 4
+ - dns.resp.len 2
+ - dns.txt.length 1
+ - dns.txt resp_data_size
So the total size is roughly a fixed overhead of `39`, and the size of the
query (domain name) and response.
diff --git a/p2p/enode/urlv4.go b/p2p/enode/urlv4.go
index 48998f59b2..1f9fc05faa 100644
--- a/p2p/enode/urlv4.go
+++ b/p2p/enode/urlv4.go
@@ -54,8 +54,8 @@ func MustParseV4(rawurl string) *Node {
//
// For incomplete nodes, the designator must look like one of these
//
-// enode://
-//
+// enode://
+//
//
// For complete nodes, the node ID is encoded in the username portion
// of the URL, separated from the host by an @ sign. The hostname can
@@ -68,7 +68,7 @@ func MustParseV4(rawurl string) *Node {
// a node with IP address 10.3.58.6, TCP listening port 30303
// and UDP discovery port 30301.
//
-// enode://@10.3.58.6:30303?discport=30301
+// enode://@10.3.58.6:30303?discport=30301
func ParseV4(rawurl string) (*Node, error) {
if m := incompleteNodeURL.FindStringSubmatch(rawurl); m != nil {
id, err := parsePubkey(m[1])
diff --git a/p2p/enr/enr.go b/p2p/enr/enr.go
index 82985ff533..a0be50fa5d 100644
--- a/p2p/enr/enr.go
+++ b/p2p/enr/enr.go
@@ -19,7 +19,7 @@
// stored in key/value pairs. To store and retrieve key/values in a record, use the Entry
// interface.
//
-// Signature Handling
+// # Signature Handling
//
// Records must be signed before transmitting them to another node.
//
diff --git a/p2p/nat/nat.go b/p2p/nat/nat.go
index db60689b5f..69f1aa3b0c 100644
--- a/p2p/nat/nat.go
+++ b/p2p/nat/nat.go
@@ -53,12 +53,12 @@ type Interface interface {
// The following formats are currently accepted.
// Note that mechanism names are not case-sensitive.
//
-// "" or "none" return nil
-// "extip:77.12.33.4" will assume the local machine is reachable on the given IP
-// "any" uses the first auto-detected mechanism
-// "upnp" uses the Universal Plug and Play protocol
-// "pmp" uses NAT-PMP with an auto-detected gateway address
-// "pmp:192.168.0.1" uses NAT-PMP with the given gateway address
+// "" or "none" return nil
+// "extip:77.12.33.4" will assume the local machine is reachable on the given IP
+// "any" uses the first auto-detected mechanism
+// "upnp" uses the Universal Plug and Play protocol
+// "pmp" uses NAT-PMP with an auto-detected gateway address
+// "pmp:192.168.0.1" uses NAT-PMP with the given gateway address
func Parse(spec string) (Interface, error) {
var (
parts = strings.SplitN(spec, ":", 2)
diff --git a/p2p/netutil/toobig_notwindows.go b/p2p/netutil/toobig_notwindows.go
index 47b6438572..f9f936ae56 100644
--- a/p2p/netutil/toobig_notwindows.go
+++ b/p2p/netutil/toobig_notwindows.go
@@ -14,7 +14,8 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
-//+build !windows
+//go:build !windows
+// +build !windows
package netutil
diff --git a/params/denomination.go b/params/denomination.go
index fb4da7f412..bcedd271e0 100644
--- a/params/denomination.go
+++ b/params/denomination.go
@@ -19,8 +19,7 @@ package params
// These are the multipliers for ether denominations.
// Example: To get the wei value of an amount in 'gwei', use
//
-// new(big.Int).Mul(value, big.NewInt(params.GWei))
-//
+// new(big.Int).Mul(value, big.NewInt(params.GWei))
const (
Wei = 1
GWei = 1e9
diff --git a/params/version.go b/params/version.go
index 2d3155d35e..2f37bc43d8 100644
--- a/params/version.go
+++ b/params/version.go
@@ -43,7 +43,8 @@ var VersionWithMeta = func() string {
// ArchiveVersion holds the textual version string used for Geth archives.
// e.g. "1.8.11-dea1ce05" for stable releases, or
-// "1.8.13-unstable-21c059b6" for unstable releases
+//
+// "1.8.13-unstable-21c059b6" for unstable releases
func ArchiveVersion(gitCommit string) string {
vsn := Version
if VersionMeta != "stable" {
diff --git a/rlp/decode.go b/rlp/decode.go
index ac04d5d569..6a6d210034 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -74,7 +74,7 @@ type Decoder interface {
// Note that Decode does not set an input limit for all readers and may be vulnerable to
// panics cause by huge value sizes. If you need an input limit, use
//
-// NewStream(r, limit).Decode(val)
+// NewStream(r, limit).Decode(val)
func Decode(r io.Reader, val interface{}) error {
stream := streamPool.Get().(*Stream)
defer streamPool.Put(stream)
diff --git a/rlp/doc.go b/rlp/doc.go
index 113828e39b..8dd5c89b8e 100644
--- a/rlp/doc.go
+++ b/rlp/doc.go
@@ -27,8 +27,7 @@ value zero equivalent to the empty string).
RLP values are distinguished by a type tag. The type tag precedes the value in the input
stream and defines the size and kind of the bytes that follow.
-
-Encoding Rules
+# Encoding Rules
Package rlp uses reflection and encodes RLP based on the Go type of the value.
@@ -58,8 +57,7 @@ An interface value encodes as the value contained in the interface.
Floating point numbers, maps, channels and functions are not supported.
-
-Decoding Rules
+# Decoding Rules
Decoding uses the following type-dependent rules:
@@ -93,30 +91,29 @@ or one (true).
To decode into an interface value, one of these types is stored in the value:
- []interface{}, for RLP lists
- []byte, for RLP strings
+ []interface{}, for RLP lists
+ []byte, for RLP strings
Non-empty interface types are not supported when decoding.
Signed integers, floating point numbers, maps, channels and functions cannot be decoded into.
-
-Struct Tags
+# Struct Tags
As with other encoding packages, the "-" tag ignores fields.
- type StructWithIgnoredField struct{
- Ignored uint `rlp:"-"`
- Field uint
- }
+ type StructWithIgnoredField struct{
+ Ignored uint `rlp:"-"`
+ Field uint
+ }
Go struct values encode/decode as RLP lists. There are two ways of influencing the mapping
of fields to list elements. The "tail" tag, which may only be used on the last exported
struct field, allows slurping up any excess list elements into a slice.
- type StructWithTail struct{
- Field uint
- Tail []string `rlp:"tail"`
- }
+ type StructWithTail struct{
+ Field uint
+ Tail []string `rlp:"tail"`
+ }
The "optional" tag says that the field may be omitted if it is zero-valued. If this tag is
used on a struct field, all subsequent public fields must also be declared optional.
@@ -128,11 +125,11 @@ When decoding into a struct, optional fields may be omitted from the end of the
list. For the example below, this means input lists of one, two, or three elements are
accepted.
- type StructWithOptionalFields struct{
- Required uint
- Optional1 uint `rlp:"optional"`
- Optional2 uint `rlp:"optional"`
- }
+ type StructWithOptionalFields struct{
+ Required uint
+ Optional1 uint `rlp:"optional"`
+ Optional2 uint `rlp:"optional"`
+ }
The "nil", "nilList" and "nilString" tags apply to pointer-typed fields only, and change
the decoding rules for the field type. For regular pointer fields without the "nil" tag,
@@ -140,9 +137,9 @@ input values must always match the required input length exactly and the decoder
produce nil values. When the "nil" tag is set, input values of size zero decode as a nil
pointer. This is especially useful for recursive types.
- type StructWithNilField struct {
- Field *[3]byte `rlp:"nil"`
- }
+ type StructWithNilField struct {
+ Field *[3]byte `rlp:"nil"`
+ }
In the example above, Field allows two possible input sizes. For input 0xC180 (a list
containing an empty string) Field is set to nil after decoding. For input 0xC483000000 (a
diff --git a/rlp/unsafe.go b/rlp/unsafe.go
index 94ed5405a8..30bb9a6595 100644
--- a/rlp/unsafe.go
+++ b/rlp/unsafe.go
@@ -14,6 +14,7 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
+//go:build !nacl && !js && cgo
// +build !nacl,!js,cgo
package rlp
diff --git a/trie/committer.go b/trie/committer.go
index 4745d424ef..f0f707d1d1 100644
--- a/trie/committer.go
+++ b/trie/committer.go
@@ -233,14 +233,6 @@ func (c *committer) commitLoop(db *Database) {
}
}
-func (c *committer) makeHashNode(data []byte) hashNode {
- n := make(hashNode, c.sha.Size())
- c.sha.Reset()
- c.sha.Write(data)
- c.sha.Read(n)
- return n
-}
-
// estimateSize estimates the size of an rlp-encoded node, without actually
// rlp-encoding it (zero allocs). This method has been experimentally tried, and with a trie
// with 1000 leafs, the only errors above 1% are on small shortnodes, where this
diff --git a/trie/proof.go b/trie/proof.go
index a3d8f5309e..f3621377ed 100644
--- a/trie/proof.go
+++ b/trie/proof.go
@@ -335,9 +335,9 @@ findFork:
// unset removes all internal node references either the left most or right most.
// It can meet these scenarios:
//
-// - The given path is existent in the trie, unset the associated nodes with the
-// specific direction
-// - The given path is non-existent in the trie
+// - The given path is existent in the trie, unset the associated nodes with the
+// specific direction
+// - The given path is non-existent in the trie
// - the fork point is a fullnode, the corresponding child pointed by path
// is nil, return
// - the fork point is a shortnode, the shortnode is included in the range,
@@ -369,10 +369,6 @@ func unset(parent node, child node, key []byte, pos int, removeLeft bool) error
// branch. The parent must be a fullnode.
fn := parent.(*fullNode)
fn.Children[key[pos-1]] = nil
- } else {
- // The key of fork shortnode is greater than the
- // path(it doesn't belong to the range), keep
- // it with the cached hash available.
}
} else {
if bytes.Compare(cld.Key, key[pos:]) > 0 {
@@ -381,10 +377,6 @@ func unset(parent node, child node, key []byte, pos int, removeLeft bool) error
// branch. The parent must be a fullnode.
fn := parent.(*fullNode)
fn.Children[key[pos-1]] = nil
- } else {
- // The key of fork shortnode is less than the
- // path(it doesn't belong to the range), keep
- // it with the cached hash available.
}
}
return nil
@@ -452,15 +444,15 @@ func hasRightElement(node node, key []byte) bool {
// Expect the normal case, this function can also be used to verify the following
// range proofs:
//
-// - All elements proof. In this case the proof can be nil, but the range should
-// be all the leaves in the trie.
+// - All elements proof. In this case the proof can be nil, but the range should
+// be all the leaves in the trie.
//
-// - One element proof. In this case no matter the edge proof is a non-existent
-// proof or not, we can always verify the correctness of the proof.
+// - One element proof. In this case no matter the edge proof is a non-existent
+// proof or not, we can always verify the correctness of the proof.
//
-// - Zero element proof. In this case a single non-existent proof is enough to prove.
-// Besides, if there are still some other leaves available on the right side, then
-// an error will be returned.
+// - Zero element proof. In this case a single non-existent proof is enough to prove.
+// Besides, if there are still some other leaves available on the right side, then
+// an error will be returned.
//
// Except returning the error to indicate the proof is valid or not, the function will
// also return a flag to indicate whether there exists more accounts/slots in the trie.
diff --git a/trie/stacktrie.go b/trie/stacktrie.go
index e2c210fb92..1b1c565d76 100644
--- a/trie/stacktrie.go
+++ b/trie/stacktrie.go
@@ -363,11 +363,12 @@ func (st *StackTrie) insert(key, value []byte) {
// hash() hashes the node 'st' and converts it into 'hashedNode', if possible.
// Possible outcomes:
// 1. The rlp-encoded value was >= 32 bytes:
-// - Then the 32-byte `hash` will be accessible in `st.val`.
-// - And the 'st.type' will be 'hashedNode'
+// - Then the 32-byte `hash` will be accessible in `st.val`.
+// - And the 'st.type' will be 'hashedNode'
+//
// 2. The rlp-encoded value was < 32 bytes
-// - Then the <32 byte rlp-encoded value will be accessible in 'st.val'.
-// - And the 'st.type' will be 'hashedNode' AGAIN
+// - Then the <32 byte rlp-encoded value will be accessible in 'st.val'.
+// - And the 'st.type' will be 'hashedNode' AGAIN
//
// This method will also:
// set 'st.type' to hashedNode