github.com/n1ghtfa1l/go-vnt@v0.6.4-alpha.6/les/backend.go

// Copyright 2016 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// 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
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

// Package les implements the Light VNT Subprotocol.
package les

import (
	"fmt"
	"sync"
	"time"

	"github.com/vntchain/go-vnt/accounts"
	"github.com/vntchain/go-vnt/common"
	"github.com/vntchain/go-vnt/consensus"
	"github.com/vntchain/go-vnt/core"
	"github.com/vntchain/go-vnt/core/bloombits"
	"github.com/vntchain/go-vnt/core/rawdb"
	"github.com/vntchain/go-vnt/core/types"
	"github.com/vntchain/go-vnt/event"
	"github.com/vntchain/go-vnt/internal/vntapi"
	"github.com/vntchain/go-vnt/light"
	"github.com/vntchain/go-vnt/log"
	"github.com/vntchain/go-vnt/node"
	"github.com/vntchain/go-vnt/params"
	"github.com/vntchain/go-vnt/rpc"
	"github.com/vntchain/go-vnt/vnt"
	"github.com/vntchain/go-vnt/vnt/downloader"
	"github.com/vntchain/go-vnt/vnt/filters"
	"github.com/vntchain/go-vnt/vnt/gasprice"
	"github.com/vntchain/go-vnt/vntdb"
	"github.com/vntchain/go-vnt/vntp2p"
)

type LightVnt struct {
	config *vnt.Config

	odr         *LesOdr
	relay       *LesTxRelay
	chainConfig *params.ChainConfig
	// Channel for shutting down the service
	shutdownChan chan bool
	// Handlers
	peers           *peerSet
	txPool          *light.TxPool
	blockchain      *light.LightChain
	protocolManager *ProtocolManager
	serverPool      *serverPool
	reqDist         *requestDistributor
	retriever       *retrieveManager
	// DB interfaces
	chainDb vntdb.Database // Block chain database

	bloomRequests                              chan chan *bloombits.Retrieval // Channel receiving bloom data retrieval requests
	bloomIndexer, chtIndexer, bloomTrieIndexer *core.ChainIndexer

	ApiBackend *LesApiBackend

	eventMux       *event.TypeMux
	engine         consensus.Engine
	accountManager *accounts.Manager

	networkId     uint64
	netRPCService *vntapi.PublicNetAPI

	wg sync.WaitGroup
}

func New(ctx *node.ServiceContext, config *vnt.Config) (*LightVnt, error) {
	chainDb, err := vnt.CreateDB(ctx, config, "lightchaindata")
	if err != nil {
		return nil, err
	}
	chainConfig, genesisHash, genesisErr := core.SetupGenesisBlock(chainDb, config.Genesis)
	if _, isCompat := genesisErr.(*params.ConfigCompatError); genesisErr != nil && !isCompat {
		return nil, genesisErr
	}
	log.Info("Initialised chain configuration", "config", chainConfig)

	peers := newPeerSet()
	quitSync := make(chan struct{})

	lvnt := &LightVnt{
		config:           config,
		chainConfig:      chainConfig,
		chainDb:          chainDb,
		eventMux:         ctx.EventMux,
		peers:            peers,
		reqDist:          newRequestDistributor(peers, quitSync),
		accountManager:   ctx.AccountManager,
		engine:           vnt.CreateConsensusEngine(ctx, chainConfig, chainDb),
		shutdownChan:     make(chan bool),
		networkId:        config.NetworkId,
		bloomRequests:    make(chan chan *bloombits.Retrieval),
		bloomIndexer:     vnt.NewBloomIndexer(chainDb, light.BloomTrieFrequency),
		chtIndexer:       light.NewChtIndexer(chainDb, true),
		bloomTrieIndexer: light.NewBloomTrieIndexer(chainDb, true),
	}

	lvnt.relay = NewLesTxRelay(peers, lvnt.reqDist)
	lvnt.serverPool = newServerPool(chainDb, quitSync, &lvnt.wg)
	lvnt.retriever = newRetrieveManager(peers, lvnt.reqDist, lvnt.serverPool)
	lvnt.odr = NewLesOdr(chainDb, lvnt.chtIndexer, lvnt.bloomTrieIndexer, lvnt.bloomIndexer, lvnt.retriever)
	if lvnt.blockchain, err = light.NewLightChain(lvnt.odr, lvnt.chainConfig, lvnt.engine); err != nil {
		return nil, err
	}
	lvnt.bloomIndexer.Start(lvnt.blockchain)
	// Rewind the chain in case of an incompatible config upgrade.
	if compat, ok := genesisErr.(*params.ConfigCompatError); ok {
		log.Warn("Rewinding chain to upgrade configuration", "err", compat)
		lvnt.blockchain.SetHead(compat.RewindTo)
		rawdb.WriteChainConfig(chainDb, genesisHash, chainConfig)
	}

	lvnt.txPool = light.NewTxPool(lvnt.chainConfig, lvnt.blockchain, lvnt.relay)
	if lvnt.protocolManager, err = NewProtocolManager(lvnt.chainConfig, true, ClientProtocolVersions, config.NetworkId, lvnt.eventMux, lvnt.engine, lvnt.peers, lvnt.blockchain, nil, chainDb, lvnt.odr, lvnt.relay, lvnt.serverPool, quitSync, &lvnt.wg); err != nil {
		return nil, err
	}
	lvnt.ApiBackend = &LesApiBackend{lvnt, nil}
	gpoParams := config.GPO
	if gpoParams.Default == nil {
		gpoParams.Default = config.GasPrice
	}
	lvnt.ApiBackend.gpo = gasprice.NewOracle(lvnt.ApiBackend, gpoParams)
	return lvnt, nil
}

// func lesTopic(genesisHash common.Hash, protocolVersion uint) discv5.Topic {
// 	var name string
// 	switch protocolVersion {
// 	case lpv1:
// 		name = "LES"
// 	case lpv2:
// 		name = "LES2"
// 	default:
// 		panic(nil)
// 	}
// 	return discv5.Topic(name + "@" + common.Bytes2Hex(genesisHash.Bytes()[0:8]))
// }

type LightDummyAPI struct{}

// Coinbase is the address that block producing rewards will be send to
func (s *LightDummyAPI) Coinbase() (common.Address, error) {
	return common.Address{}, fmt.Errorf("not supported")
}

// Producing returns an indication if this node is currently producing block.
func (s *LightDummyAPI) Producing() bool {
	return false
}

// APIs returns the collection of RPC services the hubble package offers.
// NOTE, some of these services probably need to be moved to somewhere else.
func (s *LightVnt) APIs() []rpc.API {
	return append(vntapi.GetAPIs(s.ApiBackend), []rpc.API{
		{
			Namespace: "core",
			Version:   "1.0",
			Service:   &LightDummyAPI{},
			Public:    true,
		}, {
			Namespace: "core",
			Version:   "1.0",
			Service:   downloader.NewPublicDownloaderAPI(s.protocolManager.downloader, s.eventMux),
			Public:    true,
		}, {
			Namespace: "core",
			Version:   "1.0",
			Service:   filters.NewPublicFilterAPI(s.ApiBackend, true),
			Public:    true,
		}, {
			Namespace: "net",
			Version:   "1.0",
			Service:   s.netRPCService,
			Public:    true,
		},
	}...)
}

func (s *LightVnt) ResetWithGenesisBlock(gb *types.Block) {
	s.blockchain.ResetWithGenesisBlock(gb)
}

func (s *LightVnt) BlockChain() *light.LightChain      { return s.blockchain }
func (s *LightVnt) TxPool() *light.TxPool              { return s.txPool }
func (s *LightVnt) Engine() consensus.Engine           { return s.engine }
func (s *LightVnt) LesVersion() int                    { return int(s.protocolManager.SubProtocols[0].Version) }
func (s *LightVnt) Downloader() *downloader.Downloader { return s.protocolManager.downloader }
func (s *LightVnt) EventMux() *event.TypeMux           { return s.eventMux }

// Protocols implements node.Service, returning all the currently configured
// network protocols to start.
func (s *LightVnt) Protocols() []vntp2p.Protocol {
	return s.protocolManager.SubProtocols
}

// Start implements node.Service, starting all internal goroutines needed by the
// VNT protocol implementation.
func (s *LightVnt) Start(srvr *vntp2p.Server) error {
	s.startBloomHandlers()
	log.Warn("Light client mode is an experimental feature")
	s.netRPCService = vntapi.NewPublicNetAPI(srvr, s.networkId)
	// clients are searching for the first advertised protocol in the list
	protocolVersion := AdvertiseProtocolVersions[0]
	fmt.Println(protocolVersion)
	s.serverPool.start(srvr)
	// s.serverPool.start(srvr, lesTopic(s.blockchain.Genesis().Hash(), protocolVersion))
	s.protocolManager.Start(s.config.LightPeers)
	return nil
}

// Stop implements node.Service, terminating all internal goroutines used by the
// VNT protocol.
func (s *LightVnt) Stop() error {
	s.odr.Stop()
	if s.bloomIndexer != nil {
		s.bloomIndexer.Close()
	}
	if s.chtIndexer != nil {
		s.chtIndexer.Close()
	}
	if s.bloomTrieIndexer != nil {
		s.bloomTrieIndexer.Close()
	}
	s.blockchain.Stop()
	s.protocolManager.Stop()
	s.txPool.Stop()

	s.eventMux.Stop()

	time.Sleep(time.Millisecond * 200)
	s.chainDb.Close()
	close(s.shutdownChan)

	return nil
}