Merge pull request #158 from getamis/feature/cyclic_import

define casper interface to avoid cyclic import

Author: markya0616

contracts/casper.go

@@ -0,0 +1,31 @@
+// Copyright 2014 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 contracts
+
+import (
+	"math/big"
+)
+
+// Casper defines the casper contract interface
+type Casper interface {
+	// GetLastJustifiedEpoch returns the last justified epoch
+	GetLastJustifiedEpoch() (*big.Int, error)
+	// GetLastFinalizedEpoch returns the last finalized epoch
+	GetLastFinalizedEpoch() (*big.Int, error)
+	// GetCheckpointHashes returns the checkpoint hashes
+	GetCheckpointHashes(*big.Int) ([32]byte, error)
+}

contracts/casper/contract.go

@@ -27,9 +27,11 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/mclock"
 	"github.com/ethereum/go-ethereum/consensus"
+	"github.com/ethereum/go-ethereum/contracts"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
@@ -127,7 +129,8 @@ type BlockChain struct {
 	validator Validator // block and state validator interface
 	vmConfig  vm.Config
 
-	badBlocks *lru.Cache // Bad block cache
+	badBlocks *lru.Cache                                           // Bad block cache
+	casperGen func(bind.ContractBackend) (contracts.Casper, error) // casperGen generates the casper instance at specific state
 }
 
 // NewBlockChain returns a fully initialised block chain using information

core/blockchain.go

@@ -17,16 +17,24 @@
 package core
 
 import (
+	"errors"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/contracts/casper"
+	"github.com/ethereum/go-ethereum/contracts"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
 )
 
+var ErrNilCasperGen = errors.New("nil casper generator")
+
+// SetCasperGen sets casperGen
+func (bc *BlockChain) SetCasperGen(casperGen func(bind.ContractBackend) (contracts.Casper, error)) {
+	bc.casperGen = casperGen
+}
+
 func (bc *BlockChain) acceptNewCasperBlock(currentBlock *types.Block, newBlock *types.Block, newState *state.StateDB) (bool, error) {
 	currentScore, err := bc.getScore(currentBlock)
 	if err != nil {
@@ -62,17 +70,21 @@ func (bc *BlockChain) getScore(block *types.Block) (*big.Int, error) {
 
 // getLastJustifiedEpoch returns the last justified epoch for a given block
 func (bc *BlockChain) getLastJustifiedEpoch(block *types.Block) (*big.Int, error) {
+	if bc.casperGen == nil {
+		log.Warn("Casper generator is not initialized")
+		return nil, ErrNilCasperGen
+	}
 	state, err := bc.StateAt(block.Root())
 	if err != nil {
 		return nil, err
 	}
 	stateBackend := NewStateBackend(block, state, bc)
-	contract, err := casper.New(stateBackend)
+	contract, err := bc.casperGen(stateBackend)
 	if err != nil {
 		log.Warn("Failed to get Casper contract", "err", err)
 		return nil, err
 	}
-	justified, err := contract.GetLastJustifiedEpoch(&bind.CallOpts{})
+	justified, err := contract.GetLastJustifiedEpoch()
 	if err != nil {
 		log.Warn("Failed to get current chain status from Casper", "err", err)
 		return nil, err
@@ -82,18 +94,22 @@ func (bc *BlockChain) getLastJustifiedEpoch(block *types.Block) (*big.Int, error
 
 // safeForLastFinalizedBlock returns true if the new head will NOT revert the last finalized block
 func (bc *BlockChain) safeForLastFinalizedBlock(newBlock *types.Block, newState *state.StateDB) (bool, error) {
+	if bc.casperGen == nil {
+		log.Warn("Casper generator is not initialized")
+		return false, ErrNilCasperGen
+	}
 	stateBackend := NewStateBackend(newBlock, newState, bc)
-	contract, err := casper.New(stateBackend)
+	contract, err := bc.casperGen(stateBackend)
 	if err != nil {
 		log.Warn("Failed to get Casper contract", "err", err)
 		return false, err
 	}
-	blockNumber, err := contract.GetLastFinalizedEpoch(&bind.CallOpts{})
+	blockNumber, err := contract.GetLastFinalizedEpoch()
 	if err != nil {
 		log.Warn("Failed to get current chain status from Casper", "err", err)
 		return false, err
 	}
-	hashBytes, err := contract.GetCheckpointHashes(&bind.CallOpts{}, blockNumber)
+	hashBytes, err := contract.GetCheckpointHashes(blockNumber)
 	if err != nil {
 		log.Warn("Failed to get current chain status from Casper", "err", err)
 		return false, err

core/casper_util.go

@@ -152,6 +152,10 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
 	if err != nil {
 		return nil, err
 	}
+	// TODO: Intialize the casper gen only when the casper address is specified in genesis config
+	// Set casper gen
+	eth.blockchain.SetCasperGen(NewCasperGen(common.HexToAddress("0xbd832b0cd3291c39ef67691858f35c71dfb3bf21")))
+
 	// 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)

eth/backend.go

@@ -0,0 +1,61 @@
+// Copyright 2014 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 eth implements the Ethereum protocol.
+package eth
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/contracts"
+	casperContract "github.com/ethereum/go-ethereum/contracts/casper"
+)
+
+type casper struct {
+	contract *casperContract.Casper
+}
+
+// NewCasperGen returns a func which can generate capser instance at specific state and given address
+func NewCasperGen(address common.Address) func(bind.ContractBackend) (contracts.Casper, error) {
+	return func(backend bind.ContractBackend) (contracts.Casper, error) {
+		return NewCasper(address, backend)
+	}
+}
+
+// NewCasper returns casper instance at specific state and address
+func NewCasper(address common.Address, backend bind.ContractBackend) (contracts.Casper, error) {
+	contract, err := casperContract.NewCasper(address, backend)
+	return &casper{
+		contract: contract,
+	}, err
+}
+
+// GetLastJustifiedEpoch returns the last justified epoch in specific backend
+func (c *casper) GetLastJustifiedEpoch() (*big.Int, error) {
+	return c.contract.GetLastJustifiedEpoch(&bind.CallOpts{})
+}
+
+// GetLastFinalizedEpoch returns the last finalized epoch in specific backend
+func (c *casper) GetLastFinalizedEpoch() (*big.Int, error) {
+	return c.contract.GetLastFinalizedEpoch(&bind.CallOpts{})
+}
+
+// GetCheckpointHashes returns the checkpoint hashes in specific backend
+func (c *casper) GetCheckpointHashes(number *big.Int) ([32]byte, error) {
+	return c.contract.GetCheckpointHashes(&bind.CallOpts{}, number)
+}