eth/filters,rpc,core,internal/ethapi: Fixed formating, linting, vet issues.

accounts/abi/bind/backends/simulated.go

@@ -461,6 +461,10 @@ func (fb *filterBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscr
 	return fb.bc.SubscribeLogsEvent(ch)
 }
 
+func (fb *filterBackend) SubscribeTransactionEvent(ch chan<- *core.TransactionEvent) event.Subscription {
+	return fb.bc.SubscribeTransactionEvent(ch)
+}
+
 func (fb *filterBackend) BloomStatus() (uint64, uint64) { return 4096, 0 }
 func (fb *filterBackend) ServiceFilter(ctx context.Context, ms *bloombits.MatcherSession) {
 	panic("not supported")

core/events.go

@@ -36,7 +36,7 @@ type PendingStateEvent struct{}
 type NewMinedBlockEvent struct{ Block *types.Block }
 
 // TransactionEvent is posted when a transaction completes execution
-type TransactionEvent struct{
+type TransactionEvent struct {
 	TxHash  common.Hash
 	RetData types.ReturnData
 }

core/state_processor.go

@@ -124,8 +124,8 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common
 	receipt.Logs = statedb.GetLogs(tx.Hash())
 	receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
 
-    retData := types.ReturnData{receipt.TxHash,data,false}
+	retData := types.ReturnData{TxHash: receipt.TxHash, Data: data, Removed: false}
-    txPostEvent := TransactionEvent{receipt.TxHash,retData}
+	txPostEvent := TransactionEvent{TxHash: receipt.TxHash, RetData: retData}
 	go bc.txPostFeed.Send(&txPostEvent)
 
 	return receipt, gas, err

eth/filters/api.go

@@ -22,17 +22,17 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"reflect"
 	"sync"
 	"time"
-    "reflect"
 
 	ethereum "github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/event"
+	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
@@ -282,11 +282,11 @@ func (api *PublicFilterAPI) ReturnData(ctx context.Context) (*rpc.Subscription,
 			select {
 			case msg := <-rpcSub.Update():
 				// client submitted new tx, save hash for later
-                hash,ishash := msg.(common.Hash)
+				hash, ishash := msg.(common.Hash)
 				if ishash {
 					txListen[hash] = true
 				} else {
-                    log.Warn(fmt.Sprintf("Received update msg of invalid type %s for ReturnData subscription",reflect.TypeOf(msg).String()))
+					log.Warn(fmt.Sprintf("Received update msg of invalid type %s for ReturnData subscription", reflect.TypeOf(msg).String()))
 				}
 			case retdata := <-retCh:
 				if txListen[retdata.TxHash] {
@@ -306,7 +306,6 @@ func (api *PublicFilterAPI) ReturnData(ctx context.Context) (*rpc.Subscription,
 	return rpcSub, nil
 }
 
-
 // Logs creates a subscription that fires for all new log that match the given filter criteria.
 func (api *PublicFilterAPI) Logs(ctx context.Context, crit FilterCriteria) (*rpc.Subscription, error) {
 	notifier, supported := rpc.NotifierFromContext(ctx)
@@ -530,7 +529,7 @@ func returnRetData(rdata []types.ReturnData) []types.ReturnData {
 	if rdata == nil {
 		return []types.ReturnData{}
 	} else {
-        for _,r := range rdata {
+		for _, r := range rdata {
 			r.Data = []byte{}
 		}
 	}

eth/filters/bench_test.go

@@ -130,7 +130,7 @@ func benchmarkBloomBits(b *testing.B, sectionSize uint64) {
 		if i%20 == 0 {
 			db.Close()
 			db, _ = ethdb.NewLDBDatabase(benchDataDir, 128, 1024)
-			backend = &testBackend{mux, db, cnt, new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed)}
+			backend = &testBackend{mux, db, cnt, new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed)}
 		}
 		var addr common.Address
 		addr[0] = byte(i)
@@ -191,7 +191,7 @@ func BenchmarkNoBloomBits(b *testing.B) {
 	fmt.Println("Running filter benchmarks...")
 	start := time.Now()
 	mux := new(event.TypeMux)
-	backend := &testBackend{mux, db, 0, new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed)}
+	backend := &testBackend{mux, db, 0, new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed)}
 	filter := New(backend, 0, int64(headNum), []common.Address{{}}, nil)
 	filter.Logs(context.Background())
 	d := time.Since(start)

eth/filters/filter_system_test.go

@@ -42,6 +42,7 @@ type testBackend struct {
 	db         ethdb.Database
 	sections   uint64
 	txFeed     *event.Feed
+	txPostFeed *event.Feed
 	rmLogsFeed *event.Feed
 	logsFeed   *event.Feed
 	chainFeed  *event.Feed
@@ -100,6 +101,10 @@ func (b *testBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subsc
 	return b.chainFeed.Subscribe(ch)
 }
 
+func (b *testBackend) SubscribeTransactionEvent(ch chan<- *core.TransactionEvent) event.Subscription {
+	return b.txPostFeed.Subscribe(ch)
+}
+
 func (b *testBackend) BloomStatus() (uint64, uint64) {
 	return params.BloomBitsBlocks, b.sections
 }
@@ -143,10 +148,11 @@ func TestBlockSubscription(t *testing.T) {
 		mux         = new(event.TypeMux)
 		db, _       = ethdb.NewMemDatabase()
 		txFeed      = new(event.Feed)
+		txPostFeed  = new(event.Feed)
 		rmLogsFeed  = new(event.Feed)
 		logsFeed    = new(event.Feed)
 		chainFeed   = new(event.Feed)
-		backend     = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
+		backend     = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
 		api         = NewPublicFilterAPI(backend, false)
 		genesis     = new(core.Genesis).MustCommit(db)
 		chain, _    = core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 10, func(i int, gen *core.BlockGen) {})
@@ -200,10 +206,11 @@ func TestPendingTxFilter(t *testing.T) {
 		mux        = new(event.TypeMux)
 		db, _      = ethdb.NewMemDatabase()
 		txFeed     = new(event.Feed)
+		txPostFeed = new(event.Feed)
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
+		backend    = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
 		api        = NewPublicFilterAPI(backend, false)
 
 		transactions = []*types.Transaction{
@@ -263,10 +270,11 @@ func TestLogFilterCreation(t *testing.T) {
 		mux        = new(event.TypeMux)
 		db, _      = ethdb.NewMemDatabase()
 		txFeed     = new(event.Feed)
+		txPostFeed = new(event.Feed)
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
+		backend    = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
 		api        = NewPublicFilterAPI(backend, false)
 
 		testCases = []struct {
@@ -312,10 +320,11 @@ func TestInvalidLogFilterCreation(t *testing.T) {
 		mux        = new(event.TypeMux)
 		db, _      = ethdb.NewMemDatabase()
 		txFeed     = new(event.Feed)
+		txPostFeed = new(event.Feed)
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
+		backend    = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
 		api        = NewPublicFilterAPI(backend, false)
 	)
 
@@ -342,10 +351,11 @@ func TestLogFilter(t *testing.T) {
 		mux        = new(event.TypeMux)
 		db, _      = ethdb.NewMemDatabase()
 		txFeed     = new(event.Feed)
+		txPostFeed = new(event.Feed)
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
+		backend    = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
 		api        = NewPublicFilterAPI(backend, false)
 
 		firstAddr      = common.HexToAddress("0x1111111111111111111111111111111111111111")
@@ -461,10 +471,11 @@ func TestPendingLogsSubscription(t *testing.T) {
 		mux        = new(event.TypeMux)
 		db, _      = ethdb.NewMemDatabase()
 		txFeed     = new(event.Feed)
+		txPostFeed = new(event.Feed)
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
+		backend    = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
 		api        = NewPublicFilterAPI(backend, false)
 
 		firstAddr      = common.HexToAddress("0x1111111111111111111111111111111111111111")

eth/filters/filter_test.go

@@ -53,10 +53,11 @@ func BenchmarkFilters(b *testing.B) {
 		db, _      = ethdb.NewLDBDatabase(dir, 0, 0)
 		mux        = new(event.TypeMux)
 		txFeed     = new(event.Feed)
+		txPostFeed = new(event.Feed)
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
+		backend    = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
 		key1, _    = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		addr1      = crypto.PubkeyToAddress(key1.PublicKey)
 		addr2      = common.BytesToAddress([]byte("jeff"))
@@ -118,10 +119,11 @@ func TestFilters(t *testing.T) {
 		db, _      = ethdb.NewLDBDatabase(dir, 0, 0)
 		mux        = new(event.TypeMux)
 		txFeed     = new(event.Feed)
+		txPostFeed = new(event.Feed)
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
+		backend    = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
 		key1, _    = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		addr       = crypto.PubkeyToAddress(key1.PublicKey)
 

internal/ethapi/api.go

@@ -1185,12 +1185,12 @@ func submitTransaction(ctx context.Context, b Backend, tx *types.Transaction) (c
 		log.Info("Submitted transaction", "fullhash", tx.Hash().Hex(), "recipient", tx.To())
 	}
 
-    notifier,supported := rpc.NotifierFromContext(ctx)
+	notifier, supported := rpc.NotifierFromContext(ctx)
 	if supported {
 		// If this client has a returnData subscription, add tx hash to set of transactions
 		//   whose return data should be sent back to rpc subscriber after transaction
 		//   is sealed in a new block.
-        go notifier.UpdateSubscriptions(rpc.ReturnDataSubscription,tx.Hash())
+		go notifier.UpdateSubscriptions(rpc.ReturnDataSubscription, tx.Hash())
 	}
 
 	return tx.Hash(), nil

light/lightchain.go

@@ -494,7 +494,6 @@ func (self *LightChain) SubscribeTransactionEvent(ch chan<- *core.TransactionEve
 	return self.scope.Track(self.txPostFeed.Subscribe(ch))
 }
 
-
 // SubscribeLogsEvent implements the interface of filters.Backend
 // LightChain does not send logs events, so return an empty subscription.
 func (self *LightChain) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {

rpc/subscription.go

@@ -60,8 +60,6 @@ const (
 	LastIndexSubscription
 )
 
-
-
 // a Subscription is created by a notifier and tied to that notifier. The client can use
 // this subscription to wait for an unsubscribe request for the client, see Err().
 type Subscription struct {
@@ -118,7 +116,7 @@ func NotifierFromContext(ctx context.Context) (*Notifier, bool) {
 // are dropped until the subscription is marked as active. This is done
 // by the RPC server after the subscription ID is send to the client.
 func (n *Notifier) CreateSubscription() *Subscription {
-    s := &Subscription{ID: NewID(), update: make(chan interface{}),err: make(chan error)}
+	s := &Subscription{ID: NewID(), update: make(chan interface{}), err: make(chan error)}
 	n.subMu.Lock()
 	n.inactive[s.ID] = s
 	n.subMu.Unlock()
@@ -172,7 +170,7 @@ func (n *Notifier) UpdateSubscription(id ID, message interface{}) error {
 func (n *Notifier) UpdateSubscriptions(subType SubscriptionType, message interface{}) error {
 	n.subMu.RLock()
 	defer n.subMu.RUnlock()
-    for _,sub := range n.active {
+	for _, sub := range n.active {
 		if sub.Type == subType {
 			sub.update <- message
 			return nil