func (self *CpuAgent) mine(work *Work, stop <-chan struct{}) {
	if result, err := self.engine.GenBlockWithSig(self.chain, work.Block, stop); result != nil {
		log.Info("Successfully sealed new block", "number -> ", result.Number(), "hash -> ", result.Hash(),"difficulty -> ",result.Difficulty())
		self.returnCh <- &Result{work, result}
	} else {
		if err != nil {
			log.Warn("Block sealing failed", "err", err)
		}
		self.returnCh <- nil
	}
}

// Work is the workers current environment and holds
// all of the current state information
type Work struct {
	config *config.ChainConfig
	signer types.Signer

	state     *state.StateDB // apply state changes here
	ancestors *set.Set       // ancestor set (used for checking uncle parent validity)
	family    *set.Set       // family set (used for checking uncle invalidity)
	uncles    *set.Set       // uncle set
	tcount    int            // tx count in cycle

	Block *types.Block // the new block

	header   *types.Header
	txs      []*types.Transaction
	receipts []*types.Receipt

	createdAt time.Time
}

func init() {
	// Initialize the CLI app and start Geth
	app.Action = ghpb
	app.HideVersion = true // we have a command to print the version
	app.Copyright = "Copyright 2013-2018 The go-hpb Authors "
	app.Commands = []cli.Command{
  ...省略...

// ghpb is the main entry point into the system if no special subcommand is ran.
// It creates a default node based on the command line arguments and runs it in
// blocking mode, waiting for it to be shut down.
func ghpb(ctx *cli.Context) error {
	cfg := MakeConfigNode(ctx)
	hpbnode, err := createNode(cfg)
	if err != nil {
		utils.Fatalf("Failed to create node")
		return err
	}
	startNode(ctx, hpbnode, cfg)
	hpbnode.Wait()
	return nil
}

if len(passwords) > 0 {
		if i < len(passwords) {
			return passwords[i]
		}
		return passwords[len(passwords)-1]
	}

// BlockChain represents the canonical chain given a database with a genesis
// block. The Blockchain manages chain imports, reverts, chain reorganisations.
//
// Importing blocks in to the block chain happens according to the set of rules
// defined by the two stage Validator. Processing of blocks is done using the
// Processor which processes the included transaction. The validation of the state
// is done in the second part of the Validator. Failing results in aborting of
// the import.
//
// The BlockChain also helps in returning blocks from **any** chain included
// in the database as well as blocks that represents the canonical chain. It's
// important to note that GetBlock can return any block and does not need to be
// included in the canonical one where as GetBlockByNumber always represents the
// canonical chain.

<!-- more -->

type BlockChain struct {
	config *config.ChainConfig // chain & network configuration
	hc            *HeaderChain
	chainDb       hpbdb.Database
	rmLogsFeed    sub.Feed
	chainFeed     sub.Feed
	chainSideFeed sub.Feed
	chainHeadFeed sub.Feed
	logsFeed      sub.Feed
	scope         sub.SubscriptionScope
	genesisBlock  *types.Block
	mu               sync.RWMutex // global mutex for locking chain operations
	chainmu          sync.RWMutex // blockchain insertion lock
	procmu           sync.RWMutex // block processor lock
	checkpoint       int          // checkpoint counts towards the new checkpoint
	currentBlock     *types.Block // Current head of the block chain
	currentFastBlock *types.Block // Current head of the fast-sync chain (may be above the block chain!)
	stateCache   state.Database // State database to reuse between imports (contains state cache)
	bodyCache    *lru.Cache     // Cache for the most recent block bodies
	bodyRLPCache *lru.Cache     // Cache for the most recent block bodies in RLP encoded format
	blockCache   *lru.Cache     // Cache for the most recent entire blocks
	futureBlocks *lru.Cache     // future blocks are blocks added for later processing
	quit    chan struct{} // blockchain quit channel
	running int32         // running must be called atomically
	// procInterrupt must be atomically called
	procInterrupt int32          // interrupt signaler for block processing
	wg            sync.WaitGroup // chain processing wait group for shutting down
	engine    consensus.Engine
	processor Processor // block processor interface
	validator Validator // block and state validator interface
	badBlocks *lru.Cache // Bad block cache
}

// Block represents an entire block in the Hpb blockchain.
type Block struct {
	header       *Header
	uncles       []*Header
	transactions Transactions

	// caches
	hash atomic.Value
	size atomic.Value

	// Td is used by package core to store the total difficulty
	// of the chain up to and including the block.
	td *big.Int

	// These fields are used by package eth to track
	// inter-peer block relay.
	ReceivedAt   time.Time
	ReceivedFrom interface{}
}

// Header represents a block header in the Hpb blockchain.
type Header struct {
	ParentHash     common.Hash    `json:"parentHash"       `
	UncleHash      common.Hash    `json:"sha3Uncles"       `
	Coinbase       common.Address `json:"miner"            `
	CandAddress    common.Address `json:"candAddress"      `
	ComdAddress    common.Address `json:"comdAddress"      `
	VoteIndex      *big.Int       `json:"voteIndex"        `
	Root           common.Hash    `json:"stateRoot"        `
	TxHash         common.Hash    `json:"transactionsRoot" `
	ReceiptHash    common.Hash    `json:"receiptsRoot"     `
	Bloom          Bloom          `json:"logsBloom"        `
	Difficulty     *big.Int       `json:"difficulty"       `
	Number         *big.Int       `json:"number"           `
	GasLimit       *big.Int       `json:"gasLimit"         `
	GasUsed        *big.Int       `json:"gasUsed"          `
	Time           *big.Int       `json:"timestamp"        `
	Extra          []byte         `json:"extraData"        `
	MixDigest      common.Hash    `json:"mixHash"          `
	Nonce          BlockNonce     `json:"nonce"            `
	HardwareRandom []byte         `json:"hardwareRandom"   `
}

type Body struct {
	Transactions []*Transaction
	Uncles       []*Header
}

type Transaction struct {
	data txdata
	// caches
	hash    atomic.Value
	size    atomic.Value
	from    atomic.Value
	fromP2P bool
}