github.com/linapex/ethereum-dpos-chinese@v0.0.0-20190316121959-b78b3a4a1ece/eth/api.go

//<developer>
//    <name>linapex 曹一峰</name>
//    <email>linapex@163.com</email>
//    <wx>superexc</wx>
//    <qqgroup>128148617</qqgroup>
//    <url>https://jsq.ink</url>
//    <role>pku engineer</role>
//    <date>2019-03-16 12:09:38</date>
//</624342632717357056>


package eth

import (
	"compress/gzip"
	"context"
	"errors"
	"fmt"
	"io"
	"math/big"
	"os"
	"strings"
//“时间”

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/common/hexutil"
	"github.com/ethereum/go-ethereum/core"
	"github.com/ethereum/go-ethereum/core/rawdb"
	"github.com/ethereum/go-ethereum/core/state"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/internal/ethapi"
	"github.com/ethereum/go-ethereum/log"
	"github.com/ethereum/go-ethereum/params"
	"github.com/ethereum/go-ethereum/rlp"
	"github.com/ethereum/go-ethereum/rpc"
	"github.com/ethereum/go-ethereum/trie"
)

//PublicEthereumAPI提供了一个API，用于访问与Ethereum完整节点相关的
//信息。
type PublicEthereumAPI struct {
	e *Ethereum
}

//NewPublicEthereumAPI为完整节点创建新的Ethereum协议API。
func NewPublicEthereumAPI(e *Ethereum) *PublicEthereumAPI {
	return &PublicEthereumAPI{e}
}

//EtherBase是采矿奖励将发送到的地址
/*
func（api*publicethereumpi）etherbase（）（common.address，错误）
 返回api.e.etherbase（）。
*/


//validator是挖掘签名者的地址
func (api *PublicEthereumAPI) Validator() (common.Address, error) {
	return api.e.Validator()
}

//CoinBase是采矿奖励将发送到的地址
func (api *PublicEthereumAPI) Coinbase() (common.Address, error) {
	return api.e.Coinbase()
}
//CoinBase是采矿奖励将发送到的地址（EtherBase的别名）
/*
func（api*publicethereumpi）coinbase（）（common.address，错误）
 返回api.etherbase（）。
*/


//hashRate返回pow hashRate
func (api *PublicEthereumAPI) Hashrate() hexutil.Uint64 {
	return hexutil.Uint64(api.e.Miner().HashRate())
}

//publicMinerapi提供了一个API来控制矿工。
//它只提供对数据进行操作的方法，这些数据在公开访问时不会带来安全风险。
type PublicMinerAPI struct {
	e *Ethereum
}

//NewPublicMinerapi创建新的PublicMinerapi实例。
func NewPublicMinerAPI(e *Ethereum) *PublicMinerAPI {
	return &PublicMinerAPI{e}
}

//挖掘返回当前是否正在挖掘此节点的指示。
func (api *PublicMinerAPI) Mining() bool {
	return api.e.IsMining()
}

//privateminerapi提供私有的RPC方法来控制矿工。
//这些方法可能会被外部用户滥用，并且必须被认为不受信任的用户使用是不安全的。
type PrivateMinerAPI struct {
	e *Ethereum
}

//newprivateminerapi创建一个新的RPC服务，该服务控制此节点的矿工。
func NewPrivateMinerAPI(e *Ethereum) *PrivateMinerAPI {
	return &PrivateMinerAPI{e: e}
}

//用给定数量的线程启动矿工。如果线程为零，则为数字
//启动的工作线程数等于
//这个过程。如果挖掘已在运行，则此方法将调整
//允许使用和更新事务所需的最低价格的线程
//池。
func (api *PrivateMinerAPI) Start(threads *int) error {
//如果密封发动机支持，设置螺纹数
	if threads == nil {
		threads = new(int)
	} else if *threads == 0 {
*threads = -1 //从内部禁用矿工
	}
	type threaded interface {
		SetThreads(threads int)
	}
	if th, ok := api.e.engine.(threaded); ok {
		log.Info("Updated mining threads", "threads", *threads)
		th.SetThreads(*threads)
	}
//启动矿工并返回
	if !api.e.IsMining() {
//将初始价格点传播到交易池
		api.e.lock.RLock()
		price := api.e.gasPrice
		api.e.lock.RUnlock()
		api.e.txPool.SetGasPrice(price)
		return api.e.StartMining(true)
	}
	return nil
}

//阻止矿工
func (api *PrivateMinerAPI) Stop() bool {
	type threaded interface {
		SetThreads(threads int)
	}
	if th, ok := api.e.engine.(threaded); ok {
		th.SetThreads(-1)
	}
	api.e.StopMining()
	return true
}

//setextra设置此矿工挖掘块时包含的额外数据字符串。
func (api *PrivateMinerAPI) SetExtra(extra string) (bool, error) {
	if err := api.e.Miner().SetExtra([]byte(extra)); err != nil {
		return false, err
	}
	return true, nil
}

//setgasprice为矿工设定了最低可接受的天然气价格。
func (api *PrivateMinerAPI) SetGasPrice(gasPrice hexutil.Big) bool {
	api.e.lock.Lock()
	api.e.gasPrice = (*big.Int)(&gasPrice)
	api.e.lock.Unlock()

	api.e.txPool.SetGasPrice((*big.Int)(&gasPrice))
	return true
}

//setetherbase设置矿工的etherbase
/*
func（api*privateminerapi）setetherbase（etherbase common.address）bool_
 api.e.setetherbase（以太网）
 返回真
*/


//setrecommittinterval更新矿工密封工作重新投入的时间间隔。
func (api *PrivateMinerAPI) SetRecommitInterval(interval int) {
//api.e.miner（）.setRecommitInterval（time.duration（interval）*time.millisecond）
	return
}

//GetHashrate返回矿工的当前哈希率。
func (api *PrivateMinerAPI) GetHashrate() uint64 {
	return api.e.miner.HashRate()
}

//privateAdminAPI是以太坊完整节点相关API的集合。
//在私有管理终结点上公开。
type PrivateAdminAPI struct {
	eth *Ethereum
}

//newprivateadminapi为完整节点private创建新的api定义
//EAUTHUM服务的管理方法。
func NewPrivateAdminAPI(eth *Ethereum) *PrivateAdminAPI {
	return &PrivateAdminAPI{eth: eth}
}

//exportchain将当前区块链导出到本地文件中。
func (api *PrivateAdminAPI) ExportChain(file string) (bool, error) {
//确保我们可以创建要导出到的文件
	out, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
	if err != nil {
		return false, err
	}
	defer out.Close()

	var writer io.Writer = out
	if strings.HasSuffix(file, ".gz") {
		writer = gzip.NewWriter(writer)
		defer writer.(*gzip.Writer).Close()
	}

//导出区块链
	if err := api.eth.BlockChain().Export(writer); err != nil {
		return false, err
	}
	return true, nil
}

func hasAllBlocks(chain *core.BlockChain, bs []*types.Block) bool {
	for _, b := range bs {
		if !chain.HasBlock(b.Hash(), b.NumberU64()) {
			return false
		}
	}

	return true
}

//importchain从本地文件导入区块链。
func (api *PrivateAdminAPI) ImportChain(file string) (bool, error) {
//确保可以访问要导入的文件
	in, err := os.Open(file)
	if err != nil {
		return false, err
	}
	defer in.Close()

	var reader io.Reader = in
	if strings.HasSuffix(file, ".gz") {
		if reader, err = gzip.NewReader(reader); err != nil {
			return false, err
		}
	}

//在预配置的批中实际运行导入
	stream := rlp.NewStream(reader, 0)

	blocks, index := make([]*types.Block, 0, 2500), 0
	for batch := 0; ; batch++ {
//从输入文件加载一批块
		for len(blocks) < cap(blocks) {
			block := new(types.Block)
			if err := stream.Decode(block); err == io.EOF {
				break
			} else if err != nil {
				return false, fmt.Errorf("block %d: failed to parse: %v", index, err)
			}
			blocks = append(blocks, block)
			index++
		}
		if len(blocks) == 0 {
			break
		}

		if hasAllBlocks(api.eth.BlockChain(), blocks) {
			blocks = blocks[:0]
			continue
		}
//导入批并重置缓冲区
		if _, err := api.eth.BlockChain().InsertChain(blocks); err != nil {
			return false, fmt.Errorf("batch %d: failed to insert: %v", batch, err)
		}
		blocks = blocks[:0]
	}
	return true, nil
}

//publicDebugAPI是公开的以太坊完整节点API的集合
//在公共调试终结点上。
type PublicDebugAPI struct {
	eth *Ethereum
}

//newpublicDebugAPI为完整节点创建新的API定义-
//以太坊服务的相关公共调试方法。
func NewPublicDebugAPI(eth *Ethereum) *PublicDebugAPI {
	return &PublicDebugAPI{eth: eth}
}

//dumpblock在给定的块中检索数据库的整个状态。
func (api *PublicDebugAPI) DumpBlock(blockNr rpc.BlockNumber) (state.Dump, error) {
	if blockNr == rpc.PendingBlockNumber {
//如果我们要抛弃这个悬而未决的国家，我们需要请求
//挂起块和来自的挂起状态
//矿工和操作这些
		_, stateDb := api.eth.miner.Pending()
		return stateDb.RawDump(), nil
	}
	var block *types.Block
	if blockNr == rpc.LatestBlockNumber {
		block = api.eth.blockchain.CurrentBlock()
	} else {
		block = api.eth.blockchain.GetBlockByNumber(uint64(blockNr))
	}
	if block == nil {
		return state.Dump{}, fmt.Errorf("block #%d not found", blockNr)
	}
	stateDb, err := api.eth.BlockChain().StateAt(block.Root())
	if err != nil {
		return state.Dump{}, err
	}
	return stateDb.RawDump(), nil
}

//privatedebugapi是通过
//专用调试终结点。
type PrivateDebugAPI struct {
	config *params.ChainConfig
	eth    *Ethereum
}

//NealPrimeDebug GAPI为完整的节点创建一个新的API定义
//以太坊服务的专用调试方法。
func NewPrivateDebugAPI(config *params.ChainConfig, eth *Ethereum) *PrivateDebugAPI {
	return &PrivateDebugAPI{config: config, eth: eth}
}

//PrimI图是一个调试API函数，它返回Sh3哈希的预图像，如果已知的话。
func (api *PrivateDebugAPI) Preimage(ctx context.Context, hash common.Hash) (hexutil.Bytes, error) {
	if preimage := rawdb.ReadPreimage(api.eth.ChainDb(), hash); preimage != nil {
		return preimage, nil
	}
	return nil, errors.New("unknown preimage")
}

//badblockargs表示查询坏块时返回的列表中的条目。
type BadBlockArgs struct {
	Hash  common.Hash            `json:"hash"`
	Block map[string]interface{} `json:"block"`
	RLP   string                 `json:"rlp"`
}

//GetBadBlocks返回客户端在网络上看到的最后一个“坏块”的列表
//并将其作为块哈希的JSON列表返回
func (api *PrivateDebugAPI) GetBadBlocks(ctx context.Context) ([]*BadBlockArgs, error) {
	blocks := api.eth.BlockChain().BadBlocks()
	results := make([]*BadBlockArgs, len(blocks))

	var err error
	for i, block := range blocks {
		results[i] = &BadBlockArgs{
			Hash: block.Hash(),
		}
		if rlpBytes, err := rlp.EncodeToBytes(block); err != nil {
results[i].RLP = err.Error() //哈奇，但是嘿，它起作用了
		} else {
			results[i].RLP = fmt.Sprintf("0x%x", rlpBytes)
		}
		if results[i].Block, err = ethapi.RPCMarshalBlock(block, true, true); err != nil {
			results[i].Block = map[string]interface{}{"error": err.Error()}
		}
	}
	return results, nil
}

//StestAgRangeReSurt是Debug的StasgStAgReangRangeAPI调用的结果。
type StorageRangeResult struct {
	Storage storageMap   `json:"storage"`
NextKey *common.Hash `json:"nextKey"` //如果存储包含trie中的最后一个密钥，则为nil。
}

type storageMap map[common.Hash]storageEntry

type storageEntry struct {
	Key   *common.Hash `json:"key"`
	Value common.Hash  `json:"value"`
}

//storagerangeat返回给定块高度和事务索引下的存储。
func (api *PrivateDebugAPI) StorageRangeAt(ctx context.Context, blockHash common.Hash, txIndex int, contractAddress common.Address, keyStart hexutil.Bytes, maxResult int) (StorageRangeResult, error) {
	_, _, statedb, err := api.computeTxEnv(blockHash, txIndex, 0)
	if err != nil {
		return StorageRangeResult{}, err
	}
	st := statedb.StorageTrie(contractAddress)
	if st == nil {
		return StorageRangeResult{}, fmt.Errorf("account %x doesn't exist", contractAddress)
	}
	return storageRangeAt(st, keyStart, maxResult)
}

func storageRangeAt(st state.Trie, start []byte, maxResult int) (StorageRangeResult, error) {
	it := trie.NewIterator(st.NodeIterator(start))
	result := StorageRangeResult{Storage: storageMap{}}
	for i := 0; i < maxResult && it.Next(); i++ {
		_, content, _, err := rlp.Split(it.Value)
		if err != nil {
			return StorageRangeResult{}, err
		}
		e := storageEntry{Value: common.BytesToHash(content)}
		if preimage := st.GetKey(it.Key); preimage != nil {
			preimage := common.BytesToHash(preimage)
			e.Key = &preimage
		}
		result.Storage[common.BytesToHash(it.Key)] = e
	}
//添加“下一个密钥”，以便客户端可以继续下载。
	if it.Next() {
		next := common.BytesToHash(it.Key)
		result.NextKey = &next
	}
	return result, nil
}

//GetModifiedAccountsByNumber返回在
//指定两个块。变化被定义为非现金、余额和
//代码哈希或存储哈希。
//
//使用一个参数，返回在指定块中修改的帐户列表。
func (api *PrivateDebugAPI) GetModifiedAccountsByNumber(startNum uint64, endNum *uint64) ([]common.Address, error) {
	var startBlock, endBlock *types.Block

	startBlock = api.eth.blockchain.GetBlockByNumber(startNum)
	if startBlock == nil {
		return nil, fmt.Errorf("start block %x not found", startNum)
	}

	if endNum == nil {
		endBlock = startBlock
		startBlock = api.eth.blockchain.GetBlockByHash(startBlock.ParentHash())
		if startBlock == nil {
			return nil, fmt.Errorf("block %x has no parent", endBlock.Number())
		}
	} else {
		endBlock = api.eth.blockchain.GetBlockByNumber(*endNum)
		if endBlock == nil {
			return nil, fmt.Errorf("end block %d not found", *endNum)
		}
	}
	return api.getModifiedAccounts(startBlock, endBlock)
}

//GetModifiedAccountsByHash返回在
//指定两个块。变化被定义为非现金、余额和
//代码哈希或存储哈希。
//
//使用一个参数，返回在指定块中修改的帐户列表。
func (api *PrivateDebugAPI) GetModifiedAccountsByHash(startHash common.Hash, endHash *common.Hash) ([]common.Address, error) {
	var startBlock, endBlock *types.Block
	startBlock = api.eth.blockchain.GetBlockByHash(startHash)
	if startBlock == nil {
		return nil, fmt.Errorf("start block %x not found", startHash)
	}

	if endHash == nil {
		endBlock = startBlock
		startBlock = api.eth.blockchain.GetBlockByHash(startBlock.ParentHash())
		if startBlock == nil {
			return nil, fmt.Errorf("block %x has no parent", endBlock.Number())
		}
	} else {
		endBlock = api.eth.blockchain.GetBlockByHash(*endHash)
		if endBlock == nil {
			return nil, fmt.Errorf("end block %x not found", *endHash)
		}
	}
	return api.getModifiedAccounts(startBlock, endBlock)
}

func (api *PrivateDebugAPI) getModifiedAccounts(startBlock, endBlock *types.Block) ([]common.Address, error) {
	if startBlock.Number().Uint64() >= endBlock.Number().Uint64() {
		return nil, fmt.Errorf("start block height (%d) must be less than end block height (%d)", startBlock.Number().Uint64(), endBlock.Number().Uint64())
	}

	oldTrie, err := trie.NewSecure(startBlock.Root(), trie.NewDatabase(api.eth.chainDb), 0)
	if err != nil {
		return nil, err
	}
	newTrie, err := trie.NewSecure(endBlock.Root(), trie.NewDatabase(api.eth.chainDb), 0)
	if err != nil {
		return nil, err
	}

	diff, _ := trie.NewDifferenceIterator(oldTrie.NodeIterator([]byte{}), newTrie.NodeIterator([]byte{}))
	iter := trie.NewIterator(diff)

	var dirty []common.Address
	for iter.Next() {
		key := newTrie.GetKey(iter.Key)
		if key == nil {
			return nil, fmt.Errorf("no preimage found for hash %x", iter.Key)
		}
		dirty = append(dirty, common.BytesToAddress(key))
	}
	return dirty, nil
}