style: revert some formatting (#294)

Revert "style: remove blank line & white space formatting"

This reverts commit 349def8d5d78f83c19e899d5d80b1d9f6a5d18c6.

accounts/abi/abi_test.go

@@ -165,7 +165,6 @@ func TestInvalidABI(t *testing.T) {
 
 // TestConstructor tests a constructor function.
 // The test is based on the following contract:
-//
 // 	contract TestConstructor {
 // 		constructor(uint256 a, uint256 b) public{}
 //	}
@@ -725,7 +724,6 @@ func TestBareEvents(t *testing.T) {
 }
 
 // TestUnpackEvent is based on this contract:
-//
 //    contract T {
 //      event received(address sender, uint amount, bytes memo);
 //      event receivedAddr(address sender);
@@ -734,9 +732,7 @@ func TestBareEvents(t *testing.T) {
 //        receivedAddr(msg.sender);
 //      }
 //    }
-//
 // When receive("X") is called with sender 0x00... and value 1, it produces this tx receipt:
-//
 //   receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]}
 func TestUnpackEvent(t *testing.T) {
 	const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
@@ -1084,7 +1080,6 @@ func TestDoubleDuplicateMethodNames(t *testing.T) {
 // TestDoubleDuplicateEventNames checks that if send0 already exists, there won't be a name
 // conflict and that the second send event will be renamed send1.
 // The test runs the abi of the following contract.
-//
 // 	contract DuplicateEvent {
 // 		event send(uint256 a);
 //		event send0();
@@ -1113,7 +1108,6 @@ func TestDoubleDuplicateEventNames(t *testing.T) {
 // TestUnnamedEventParam checks that an event with unnamed parameters is
 // correctly handled.
 // The test runs the abi of the following contract.
-//
 // 	contract TestEvent {
 //		event send(uint256, uint256);
 //	}

accounts/abi/bind/backends/simulated_test.go

@@ -1015,7 +1015,6 @@ func TestCodeAt(t *testing.T) {
 }
 
 // When receive("X") is called with sender 0x00... and value 1, it produces this tx receipt:
-//
 //   receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]}
 func TestPendingAndCallContract(t *testing.T) {
 	testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
@@ -1227,7 +1226,6 @@ func TestFork(t *testing.T) {
 Example contract to test event emission:
 
 pragma solidity >=0.7.0 <0.9.0;
-
 contract Callable {
     event Called();
     function Call() public { emit Called(); }
@@ -1249,7 +1247,6 @@ const callableBin = "6080604052348015600f57600080fd5b5060998061001e6000396000f3f
 //  7. Mine two blocks to trigger a reorg.
 //  8. Check that the event was removed.
 //  9. Re-send the transaction and mine a block.
-//
 // 10. Check that the event was reborn.
 func TestForkLogsReborn(t *testing.T) {
 	testAddr := crypto.PubkeyToAddress(testKey.PublicKey)

accounts/abi/reflect.go

@@ -28,13 +28,11 @@ 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" + "\""),
 // }
-//
 // into
 // type TupleT struct { X *big.Int }
 func ConvertType(in interface{}, proto interface{}) interface{} {
@@ -173,14 +171,10 @@ 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.
-//
 // 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.
-//
 // 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()

accounts/accounts.go

@@ -178,7 +178,6 @@ type Backend interface {
 // safely used to calculate a signature from.
 //
 // The hash is calulcated as
-//
 //   keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
 //
 // This gives context to the signed message and prevents signing of transactions.
@@ -191,7 +190,6 @@ func TextHash(data []byte) []byte {
 // safely used to calculate a signature from.
 //
 // The hash is calulcated as
-//
 //   keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
 //
 // This gives context to the signed message and prevents signing of transactions.

accounts/scwallet/wallet.go

@@ -880,7 +880,6 @@ func (s *Session) walletStatus() (*walletStatus, error) {
 }
 
 // derivationPath fetches the wallet's current derivation path from the card.
-//
 //lint:ignore U1000 needs to be added to the console interface
 func (s *Session) derivationPath() (accounts.DerivationPath, error) {
 	response, err := s.Channel.transmitEncrypted(claSCWallet, insStatus, statusP1Path, 0, nil)
@@ -996,7 +995,6 @@ func (s *Session) derive(path accounts.DerivationPath) (accounts.Account, error)
 }
 
 // keyExport contains information on an exported keypair.
-//
 //lint:ignore U1000 needs to be added to the console interface
 type keyExport struct {
 	PublicKey  []byte `asn1:"tag:0"`
@@ -1004,7 +1002,6 @@ type keyExport struct {
 }
 
 // publicKey returns the public key for the current derivation path.
-//
 //lint:ignore U1000 needs to be added to the console interface
 func (s *Session) publicKey() ([]byte, error) {
 	response, err := s.Channel.transmitEncrypted(claSCWallet, insExportKey, exportP1Any, exportP2Pubkey, nil)

accounts/url.go

@@ -95,6 +95,7 @@ func (u *URL) UnmarshalJSON(input []byte) error {
 //   -1 if x <  y
 //    0 if x == y
 //   +1 if x >  y
+//
 func (u URL) Cmp(url URL) int {
 	if u.Scheme == url.Scheme {
 		return strings.Compare(u.Path, url.Path)

accounts/usbwallet/ledger.go

@@ -407,6 +407,8 @@ func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction
 //   domain hash                                      | 32 bytes
 //   message hash                                     | 32 bytes
 //
+//
+//
 // And the output data is:
 //
 //   Description | Length

accounts/usbwallet/trezor.go

@@ -85,14 +85,14 @@ func (w *trezorDriver) Status() (string, error) {
 
 // Open implements usbwallet.driver, attempting to initialize the connection to
 // the Trezor hardware wallet. Initializing the Trezor is a two or three phase operation:
-//   - The first phase is to initialize the connection and read the wallet's
+//  * The first phase is to initialize the connection and read the wallet's
 //    features. This phase is invoked if the provided passphrase is empty. The
 //    device will display the pinpad as a result and will return an appropriate
 //    error to notify the user that a second open phase is needed.
-//   - The second phase is to unlock access to the Trezor, which is done by the
+//  * The second phase is to unlock access to the Trezor, which is done by the
 //    user actually providing a passphrase mapping a keyboard keypad to the pin
 //    number of the user (shuffled according to the pinpad displayed).
-//   - If needed the device will ask for passphrase which will require calling
+//  * If needed the device will ask for passphrase which will require calling
 //    open again with the actual passphrase (3rd phase)
 func (w *trezorDriver) Open(device io.ReadWriter, passphrase string) error {
 	w.device, w.failure = device, nil

build/ci.go

@@ -36,6 +36,7 @@ Available commands are:
    purge      [ -store blobstore ] [ -days threshold ]                                         -- purges old archives from the blobstore
 
 For all commands, -n prevents execution of external programs (dry run mode).
+
 */
 package main
 

cmd/ethkey/utils.go

@@ -51,7 +51,6 @@ func getPassphrase(ctx *cli.Context, confirmation bool) string {
 // that can be safely used to calculate a signature from.
 //
 // The hash is calulcated as
-//
 //   keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
 //
 // This gives context to the signed message and prevents signing of transactions.

cmd/evm/internal/t8ntool/transition.go

@@ -323,7 +323,6 @@ func (t *txWithKey) UnmarshalJSON(input []byte) error {
 // The transactions can have two forms, either
 //   1. unsigned or
 //   2. signed
-//
 // For (1), r, s, v, need so be zero, and the `secretKey` needs to be set.
 // If so, we sign it here and now, with the given `secretKey`
 // If the condition above is not met, then it's considered a signed transaction.

cmd/faucet/website.go

@@ -187,13 +187,11 @@ var _bindata = map[string]func() (*asset, error){
 // directory embedded in the file by go-bindata.
 // For example if you run go-bindata on data/... and data contains the
 // following hierarchy:
-//
 //     data/
 //       foo.txt
 //       img/
 //         a.png
 //         b.png
-//
 // then AssetDir("data") would return []string{"foo.txt", "img"},
 // AssetDir("data/img") would return []string{"a.png", "b.png"},
 // AssetDir("foo.txt") and AssetDir("notexist") would return an error, and

cmd/p2psim/main.go

@@ -33,6 +33,7 @@
 //
 //     $ p2psim node connect node01 node02
 //     Connected node01 to node02
+//
 package main
 
 import (

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".
 

common/prque/lazyqueue.go

@@ -29,7 +29,6 @@ import (
 // - 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 {

consensus/ethash/api.go

@@ -34,7 +34,6 @@ 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

consensus/ethash/sealer.go

@@ -339,7 +339,6 @@ 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 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

consensus/misc/dao.go

@@ -40,7 +40,6 @@ var (
 // ensure it conforms to DAO hard-fork rules.
 //
 // DAO hard-fork extension to the header validity:
-//
 //   a) if the node is no-fork, do not accept blocks in the [fork, fork+10) range
 //      with the fork specific extra-data set
 //   b) if the node is pro-fork, require blocks in the specific range to have the

core/blockchain_test.go

@@ -1867,7 +1867,6 @@ func testSideImport(t *testing.T, numCanonBlocksInSidechain, blocksBetweenCommon
 // That is: the sidechain for import contains some blocks already present in canon chain.
 // So the blocks are
 // [ Cn, Cn+1, Cc, Sn+3 ... Sm]
-//
 //   ^    ^    ^  pruned
 func TestPrunedImportSide(t *testing.T) {
 	//glogger := log.NewGlogHandler(log.StreamHandler(os.Stdout, log.TerminalFormat(false)))
@@ -2650,6 +2649,7 @@ func TestDeleteCreateRevert(t *testing.T) {
 // to the destructset in case something is created "onto" an existing item.
 // We need to either roll back the snapDestructs, or not place it into snapDestructs
 // in the first place.
+//
 func TestInitThenFailCreateContract(t *testing.T) {
 	var (
 		// Generate a canonical chain to act as the main dataset

core/mkalloc.go

@@ -18,10 +18,12 @@
 // +build none
 
 /*
+
    The mkalloc tool creates the genesis allocation constants in genesis_alloc.go
    It outputs a const declaration that contains an RLP-encoded list of (address, balance) tuples.
 
        go run mkalloc.go genesis.json
+
 */
 package main
 

core/state/snapshot/generate_test.go

@@ -235,12 +235,10 @@ func (t *testHelper) Generate() (common.Hash, *diskLayer) {
 //   - miss in the beginning
 //   - miss in the middle
 //   - miss in the end
-//
 // - the contract(non-empty storage) has wrong storage slots
 //   - wrong slots in the beginning
 //   - wrong slots in the middle
 //   - wrong slots in the end
-//
 // - the contract(non-empty storage) has extra storage slots
 //   - extra slots in the beginning
 //   - extra slots in the middle

core/state_transition.go

@@ -44,10 +44,8 @@ The state transitioning model does all the necessary work to work out a valid ne
 3) Create a new state object if the recipient is \0*32
 4) Value transfer
 == If contract creation ==
-
   4a) Attempt to run transaction data
   4b) If valid, use result as code for the new state object
-
 == end ==
 5) Run Script section
 6) Derive new state root

core/vm/contracts.go

@@ -266,7 +266,6 @@ var (
 // modexpMultComplexity implements bigModexp multComplexity formula, as defined in EIP-198
 //
 // def mult_complexity(x):
-//
 //    if x <= 64: return x ** 2
 //    elif x <= 1024: return x ** 2 // 4 + 96 * x - 3072
 //    else: return x ** 2 // 16 + 480 * x - 199680

core/vm/instructions.go

@@ -391,21 +391,16 @@ func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext)
 // opExtCodeHash returns the code hash of a specified account.
 // There are several cases when the function is called, while we can relay everything
 // to `state.GetCodeHash` function to ensure the correctness.
-//
 //   (1) Caller tries to get the code hash of a normal contract account, state
-//
 // should return the relative code hash and set it as the result.
 //
 //   (2) Caller tries to get the code hash of a non-existent account, state should
-//
 // return common.Hash{} and zero will be set as the result.
 //
 //   (3) Caller tries to get the code hash for an account without contract code,
-//
 // state should return emptyCodeHash(0xc5d246...) as the result.
 //
 //   (4) Caller tries to get the code hash of a precompiled account, the result
-//
 // should be zero or emptyCodeHash.
 //
 // It is worth noting that in order to avoid unnecessary create and clean,
@@ -415,11 +410,9 @@ func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext)
 // customized chain, the return value will be zero.
 //
 //   (5) Caller tries to get the code hash for an account which is marked as suicided
-//
 // in the current transaction, the code hash of this account should be returned.
 //
 //   (6) Caller tries to get the code hash for an account which is marked as deleted,
-//
 // this account should be regarded as a non-existent account and zero should be returned.
 func opExtCodeHash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
 	slot := scope.Stack.peek()

eth/downloader/downloader.go

@@ -702,11 +702,9 @@ func (d *Downloader) fetchHead(p *peerConnection) (head *types.Header, pivot *ty
 // calculateRequestSpan calculates what headers to request from a peer when trying to determine the
 // common ancestor.
 // It returns parameters to be used for peer.RequestHeadersByNumber:
-//
 //  from - starting block number
 //  count - number of headers to request
 //  skip - number of headers to skip
-//
 // and also returns 'max', the last block which is expected to be returned by the remote peers,
 // given the (from,count,skip)
 func calculateRequestSpan(remoteHeight, localHeight uint64) (int64, int, int, uint64) {

eth/downloader/queue.go

@@ -477,7 +477,6 @@ func (q *queue) ReserveReceipts(p *peerConnection, count int) (*fetchRequest, bo
 // to access the queue, so they already need a lock anyway.
 //
 // Returns:
-//
 //   item     - the fetchRequest
 //   progress - whether any progress was made
 //   throttle - if the caller should throttle for a while

eth/downloader/resultstore.go

@@ -71,7 +71,6 @@ func (r *resultStore) SetThrottleThreshold(threshold uint64) uint64 {
 // wants to reserve headers for fetching.
 //
 // It returns the following:
-//
 //   stale     - if true, this item is already passed, and should not be requested again
 //   throttled - if true, the store is at capacity, this particular header is not prio now
 //   item      - the result to store data into

eth/gasprice/feehistory.go

@@ -188,7 +188,6 @@ func (oracle *Oracle) resolveBlockRange(ctx context.Context, lastBlock rpc.Block
 //   block, sorted in ascending order and weighted by gas used.
 // - baseFee: base fee per gas in the given block
 // - gasUsedRatio: gasUsed/gasLimit in the given block
-//
 // Note: baseFee includes the next block after the newest of the returned range, because this
 // value can be derived from the newest block.
 func (oracle *Oracle) FeeHistory(ctx context.Context, blocks int, unresolvedLastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {

eth/protocols/snap/sync_test.go

@@ -370,7 +370,6 @@ func createStorageRequestResponse(t *testPeer, root common.Hash, accounts []comm
 }
 
 //  the createStorageRequestResponseAlwaysProve tests a cornercase, where it always
-//
 // supplies the proof for the last account, even if it is 'complete'.h
 func createStorageRequestResponseAlwaysProve(t *testPeer, root common.Hash, accounts []common.Hash, bOrigin, bLimit []byte, max uint64) (hashes [][]common.Hash, slots [][][]byte, proofs [][]byte) {
 	var size uint64

eth/tracers/js/internal/tracers/assets.go

@@ -388,13 +388,11 @@ const AssetDebug = false
 // directory embedded in the file by go-bindata.
 // For example if you run go-bindata on data/... and data contains the
 // following hierarchy:
-//
 //     data/
 //       foo.txt
 //       img/
 //         a.png
 //         b.png
-//
 // then AssetDir("data") would return []string{"foo.txt", "img"},
 // AssetDir("data/img") would return []string{"a.png", "b.png"},
 // AssetDir("foo.txt") and AssetDir("notexist") would return an error, and

eth/tracers/native/4byte.go

@@ -37,7 +37,6 @@ func init() {
 // a reversed signature can be matched against the size of the data.
 //
 // Example:
-//
 //   > debug.traceTransaction( "0x214e597e35da083692f5386141e69f47e973b2c56e7a8073b1ea08fd7571e9de", {tracer: "4byteTracer"})
 //   {
 //     0x27dc297e-128: 1,

eth/tracers/native/tracer.go

@@ -27,11 +27,9 @@ Aside from implementing the tracer, it also needs to register itself, using the
 Example:
 
 ```golang
-
 func init() {
 	register("noopTracerNative", newNoopTracer)
 }
-
 ```
 */
 package native

ethdb/leveldb/leveldb.go

@@ -246,7 +246,6 @@ 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)
 //   -------+------------+---------------+---------------+---------------+---------------

ethstats/ethstats.go

@@ -103,7 +103,6 @@ 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

internal/ethapi/api.go

@@ -741,9 +741,9 @@ 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 -1 the chain head is returned.
-//   - When blockNr is -2 the pending 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
+// * 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)

internal/jsre/deps/bindata.go

@@ -212,13 +212,11 @@ const AssetDebug = false
 // directory embedded in the file by go-bindata.
 // For example if you run go-bindata on data/... and data contains the
 // following hierarchy:
-//
 //     data/
 //       foo.txt
 //       img/
 //         a.png
 //         b.png
-//
 // then AssetDir("data") would return []string{"foo.txt", "img"},
 // AssetDir("data/img") would return []string{"a.png", "b.png"},
 // AssetDir("foo.txt") and AssetDir("notexist") would return an error, and

les/api.go

@@ -366,7 +366,6 @@ func NewPrivateLightAPI(backend *lesCommons) *PrivateLightAPI {
 // LatestCheckpoint returns the latest local checkpoint package.
 //
 // The checkpoint package consists of 4 strings:
-//
 //   result[0], hex encoded latest section index
 //   result[1], 32 bytes hex encoded latest section head hash
 //   result[2], 32 bytes hex encoded latest section canonical hash trie root hash
@@ -385,7 +384,6 @@ func (api *PrivateLightAPI) LatestCheckpoint() ([4]string, error) {
 // GetLocalCheckpoint returns the specific local checkpoint package.
 //
 // The checkpoint package consists of 3 strings:
-//
 //   result[0], 32 bytes hex encoded latest section head hash
 //   result[1], 32 bytes hex encoded latest section canonical hash trie root hash
 //   result[2], 32 bytes hex encoded latest section bloom trie root hash

les/downloader/downloader.go

@@ -705,11 +705,9 @@ func (d *Downloader) fetchHead(p *peerConnection) (head *types.Header, pivot *ty
 // calculateRequestSpan calculates what headers to request from a peer when trying to determine the
 // common ancestor.
 // It returns parameters to be used for peer.RequestHeadersByNumber:
-//
 //  from - starting block number
 //  count - number of headers to request
 //  skip - number of headers to skip
-//
 // and also returns 'max', the last block which is expected to be returned by the remote peers,
 // given the (from,count,skip)
 func calculateRequestSpan(remoteHeight, localHeight uint64) (int64, int, int, uint64) {

les/downloader/queue.go

@@ -477,7 +477,6 @@ func (q *queue) ReserveReceipts(p *peerConnection, count int) (*fetchRequest, bo
 // to access the queue, so they already need a lock anyway.
 //
 // Returns:
-//
 //   item     - the fetchRequest
 //   progress - whether any progress was made
 //   throttle - if the caller should throttle for a while

les/downloader/resultstore.go

@@ -71,7 +71,6 @@ func (r *resultStore) SetThrottleThreshold(threshold uint64) uint64 {
 // wants to reserve headers for fetching.
 //
 // It returns the following:
-//
 //   stale     - if true, this item is already passed, and should not be requested again
 //   throttled - if true, the store is at capacity, this particular header is not prio now
 //   item      - the result to store data into

les/fetcher.go

@@ -242,7 +242,6 @@ func (f *lightFetcher) forEachPeer(check func(id enode.ID, p *fetcherPeer) bool)
 }
 
 // mainloop is the main event loop of the light fetcher, which is responsible for
-//
 // - announcement maintenance(ulc)
 //   If we are running in ultra light client mode, then all announcements from
 //   the trusted servers are maintained. If the same announcements from trusted

light/txpool.go

@@ -77,11 +77,8 @@ type TxPool struct {
 //
 // Send instructs backend to forward new transactions
 // NewHead notifies backend about a new head after processed by the tx pool,
-//
 //  including  mined and rolled back transactions since the last event
-//
 // Discard notifies backend about transactions that should be discarded either
-//
 //  because they have been replaced by a re-send or because they have been mined
 //  long ago and no rollback is expected
 type TxRelayBackend interface {

log/doc.go

@@ -13,19 +13,21 @@ 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
 
-# Getting Started
+Getting Started
 
 To get started, you'll want to import the library:
 
     import log "github.com/inconshreveable/log15"
 
+
 Now you're ready to start logging:
 
     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'.
@@ -44,7 +46,8 @@ If you really do favor your type-safety, you may choose to pass a log.Ctx instea
 
     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
@@ -59,7 +62,8 @@ This will output a log line that includes the path context that is attached to t
 
     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:
@@ -68,6 +72,7 @@ single interface that is inspired by net/http's 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
 easily composed to create flexible, custom logging structures.
@@ -85,7 +90,7 @@ or above in JSON formatted output to the file /var/log/service.json
         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
@@ -116,7 +121,7 @@ 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
@@ -141,7 +146,7 @@ fails you want to log those records to a file on disk.
 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.
@@ -159,7 +164,7 @@ filters it out. Just wrap any function which takes no arguments with the log.Laz
 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
@@ -186,14 +191,14 @@ current state no matter when the log message is written:
     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
@@ -211,7 +216,7 @@ 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
@@ -237,7 +242,7 @@ Users of your library may then enable it if they like:
         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
@@ -293,7 +298,7 @@ Tab example, we would prefer to set up our Logger like so:
 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
@@ -302,7 +307,7 @@ on the Must object. For example:
     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:
 
@@ -320,8 +325,9 @@ github.com/spacemonkeygo/spacelog
 
 golang's stdlib, notably io and net/http
 
-# The Name
+The Name
 
 https://xkcd.com/927/
+
 */
 package log

log/format.go

@@ -84,6 +84,7 @@ type TerminalStringer interface {
 // Example:
 //
 //     [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
@@ -148,6 +149,7 @@ 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}

log/handler.go

@@ -143,6 +143,7 @@ func CallerStackHandler(format string, h Handler) Handler {
 //        }
 //        return false
 //    }, h))
+//
 func FilterHandler(fn func(r *Record) bool, h Handler) Handler {
 	return FuncHandler(func(r *Record) error {
 		if fn(r) {
@@ -158,6 +159,7 @@ func FilterHandler(fn func(r *Record) bool, h Handler) Handler {
 // from your ui package:
 //
 //    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 {
@@ -184,6 +186,7 @@ func MatchFilterHandler(key string, value interface{}, h Handler) Handler {
 // log Error/Crit records:
 //
 //     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,6 +201,7 @@ func LvlFilterHandler(maxLvl Lvl, h Handler) Handler {
 //     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 {

metrics/influxdb/influxdbv2.go

@@ -1,3 +1,4 @@
+//
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

mobile/big.go

@@ -77,6 +77,7 @@ func (bi *BigInt) SetInt64(x int64) {
 //	-1 if x <  0
 //	 0 if x == 0
 //	+1 if x >  0
+//
 func (bi *BigInt) Sign() int {
 	return bi.bigint.Sign()
 }

mobile/doc.go

@@ -20,7 +20,7 @@
 // with pieces plucked from go-ethereum, rather to allow writing native dapps on
 // mobile platforms. Keep this in mind when using or extending this package!
 //
-// # API limitations
+// API limitations
 //
 // Since gomobile cannot bridge arbitrary types between Go and Android/iOS, the
 // exposed APIs need to be manually wrapped into simplified types, with custom

node/doc.go

@@ -21,11 +21,13 @@ In the model exposed by this package, a node is a collection of services which u
 resources to provide RPC APIs. Services can also offer devp2p protocols, which are wired
 up to the devp2p network when the node instance is started.
 
-# Node Lifecycle
+
+Node Lifecycle
 
 The Node object has a lifecycle consisting of three basic states, INITIALIZING, RUNNING
 and CLOSED.
 
+
     ●───────┐
          New()
             │
@@ -38,6 +40,7 @@ and CLOSED.
             ▼                  │
          CLOSED ◀──────Close()─┘
 
+
 Creating a Node allocates basic resources such as the data directory and returns the node
 in its INITIALIZING state. Lifecycle objects, RPC APIs and peer-to-peer networking
 protocols can be registered in this state. Basic operations such as opening a key-value
@@ -55,7 +58,8 @@ objects and shuts down RPC and peer-to-peer networking.
 
 You must always call Close on Node, even if the node was not started.
 
-# Resources Managed By Node
+
+Resources Managed By Node
 
 All file-system resources used by a node instance are located in a directory called the
 data directory. The location of each resource can be overridden through additional node
@@ -79,7 +83,8 @@ without a data directory, databases are opened in memory instead.
 Node also creates the shared store of encrypted Ethereum account keys. Services can access
 the account manager through the service context.
 
-# Sharing Data Directory Among Instances
+
+Sharing Data Directory Among Instances
 
 Multiple node instances can share a single data directory if they have distinct instance
 names (set through the Name config option). Sharing behaviour depends on the type of
@@ -97,7 +102,8 @@ create one database for each instance.
 The account key store is shared among all node instances using the same data directory
 unless its location is changed through the KeyStoreDir configuration option.
 
-# Data Directory Sharing Example
+
+Data Directory Sharing Example
 
 In this example, two node instances named A and B are started with the same data
 directory. Node instance A opens the database "db", node instance B opens the databases

p2p/dial.go

@@ -90,6 +90,7 @@ var (
 //  - dynamic dials are created from node discovery results. The dialer
 //    continuously reads candidate nodes from its input iterator and attempts
 //    to create peer connections to nodes arriving through the iterator.
+//
 type dialScheduler struct {
 	dialConfig
 	setupFunc   dialSetupFunc

p2p/discover/v5wire/encoding_test.go

@@ -41,6 +41,7 @@ import (
 // To regenerate discv5 test vectors, run
 //
 //     go test -run TestVectors -write-test-vectors
+//
 var writeTestVectorsFlag = flag.Bool("write-test-vectors", false, "Overwrite discv5 test vectors in testdata/")
 
 var (

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.
 //

p2p/message.go

@@ -113,6 +113,7 @@ func Send(w MsgWriter, msgcode uint64, data interface{}) error {
 // the message payload will be an RLP list containing the items:
 //
 //    [e1, e2, e3]
+//
 func SendItems(w MsgWriter, msgcode uint64, elems ...interface{}) error {
 	return Send(w, msgcode, elems)
 }

p2p/simulations/adapters/types.go

@@ -43,6 +43,7 @@ import (
 // * SimNode    - An in-memory node
 // * ExecNode   - A child process node
 // * DockerNode - A Docker container node
+//
 type Node interface {
 	// Addr returns the node's address (e.g. an Enode URL)
 	Addr() []byte

params/denomination.go

@@ -20,6 +20,7 @@ package params
 // Example: To get the wei value of an amount in 'gwei', use
 //
 //    new(big.Int).Mul(value, big.NewInt(params.GWei))
+//
 const (
 	Wei   = 1
 	GWei  = 1e9

params/version.go

@@ -44,7 +44,6 @@ 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
 func ArchiveVersion(gitCommit string) string {
 	vsn := Version

rlp/doc.go

@@ -27,7 +27,8 @@ 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.
 
@@ -57,7 +58,8 @@ 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:
 
@@ -97,7 +99,8 @@ To decode into an interface value, one of these types is stored in the value:
 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.
 

rpc/doc.go

@@ -15,6 +15,7 @@
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
 /*
+
 Package rpc implements bi-directional JSON-RPC 2.0 on multiple transports.
 
 It provides access to the exported methods of an object across a network or other I/O
@@ -22,7 +23,7 @@ connection. After creating a server or client instance, objects can be registere
 them visible as 'services'. Exported methods that follow specific conventions can be
 called remotely. It also has support for the publish/subscribe pattern.
 
-# RPC Methods
+RPC Methods
 
 Methods that satisfy the following criteria are made available for remote access:
 
@@ -74,7 +75,7 @@ An example server which uses the JSON codec:
  l, _ := net.ListenUnix("unix", &net.UnixAddr{Net: "unix", Name: "/tmp/calculator.sock"})
  server.ServeListener(l)
 
-# Subscriptions
+Subscriptions
 
 The package also supports the publish subscribe pattern through the use of subscriptions.
 A method that is considered eligible for notifications must satisfy the following
@@ -100,7 +101,7 @@ the client and server. The server will close the connection for any write error.
 
 For more information about subscriptions, see https://github.com/scroll-tech/go-ethereum/wiki/RPC-PUB-SUB.
 
-# Reverse Calls
+Reverse Calls
 
 In any method handler, an instance of rpc.Client can be accessed through the
 ClientFromContext method. Using this client instance, server-to-client method calls can be

rpc/handler.go

@@ -48,6 +48,7 @@ import (
 //    if err := op.wait(...); err != nil {
 //        h.removeRequestOp(op) // timeout, etc.
 //    }
+//
 type handler struct {
 	reg            *serviceRegistry
 	unsubscribeCb  *callback

signer/fourbyte/4byte.go

@@ -147004,13 +147004,11 @@ var _bindata = map[string]func() (*asset, error){
 // directory embedded in the file by go-bindata.
 // For example if you run go-bindata on data/... and data contains the
 // following hierarchy:
-//
 //     data/
 //       foo.txt
 //       img/
 //         a.png
 //         b.png
-//
 // then AssetDir("data") would return []string{"foo.txt", "img"},
 // AssetDir("data/img") would return []string{"a.png", "b.png"},
 // AssetDir("foo.txt") and AssetDir("notexist") would return an error, and

tests/block_test_util.go

@@ -174,8 +174,7 @@ func (t *BlockTest) genesis(config *params.ChainConfig) *core.Genesis {
 	}
 }
 
-/*
+/* See https://github.com/ethereum/tests/wiki/Blockchain-Tests-II
-See https://github.com/ethereum/tests/wiki/Blockchain-Tests-II
 
    Whether a block is valid or not is a bit subtle, it's defined by presence of
    blockHeader, transactions and uncleHeaders fields. If they are missing, the block is

tests/fuzzers/bls12381/precompile_fuzzer.go

@@ -72,10 +72,8 @@ func checkInput(id byte, inputLen int) bool {
 
 // The fuzzer functions must return
 // 1 if the fuzzer should increase priority of the
-//
 //    given input during subsequent fuzzing (for example, the input is lexically
 //    correct and was parsed successfully);
-//
 // -1 if the input must not be added to corpus even if gives new coverage; and
 // 0  otherwise
 // other values are reserved for future use.

tests/fuzzers/difficulty/difficulty-fuzz.go

@@ -69,10 +69,8 @@ func (f *fuzzer) readBool() bool {
 
 // The function must return
 // 1 if the fuzzer should increase priority of the
-//
 //    given input during subsequent fuzzing (for example, the input is lexically
 //    correct and was parsed successfully);
-//
 // -1 if the input must not be added to corpus even if gives new coverage; and
 // 0  otherwise
 // other values are reserved for future use.

tests/fuzzers/rangeproof/rangeproof-fuzzer.go

@@ -182,10 +182,8 @@ func (f *fuzzer) fuzz() int {
 
 // The function must return
 // 1 if the fuzzer should increase priority of the
-//
 //   given input during subsequent fuzzing (for example, the input is lexically
 //   correct and was parsed successfully);
-//
 // -1 if the input must not be added to corpus even if gives new coverage; and
 // 0 otherwise; other values are reserved for future use.
 func Fuzz(input []byte) int {

tests/fuzzers/stacktrie/trie_fuzzer.go

@@ -115,10 +115,8 @@ func (k kvs) Swap(i, j int) {
 
 // The function must return
 // 1 if the fuzzer should increase priority of the
-//
 //    given input during subsequent fuzzing (for example, the input is lexically
 //    correct and was parsed successfully);
-//
 // -1 if the input must not be added to corpus even if gives new coverage; and
 // 0  otherwise
 // other values are reserved for future use.

tests/fuzzers/trie/trie-fuzzer.go

@@ -124,10 +124,8 @@ func Generate(input []byte) randTest {
 
 // The function must return
 // 1 if the fuzzer should increase priority of the
-//
 //    given input during subsequent fuzzing (for example, the input is lexically
 //    correct and was parsed successfully);
-//
 // -1 if the input must not be added to corpus even if gives new coverage; and
 // 0  otherwise
 // other values are reserved for future use.

trie/stacktrie.go

@@ -365,7 +365,6 @@ func (st *StackTrie) insert(key, value []byte) {
 // 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'
-//
 // 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