Begin of moving objects to types package

* Block(s)
* Transaction(s)

block_pool.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/wire"
@@ -20,7 +21,7 @@ var poollogger = logger.NewLogger("BPOOL")
 type block struct {
 	from      *Peer
 	peer      *Peer
-	block     *chain.Block
+	block     *types.Block
 	reqAt     time.Time
 	requested int
 }
@@ -73,7 +74,7 @@ func (self *BlockPool) HasCommonHash(hash []byte) bool {
 	return self.eth.ChainManager().GetBlock(hash) != nil
 }
 
-func (self *BlockPool) Blocks() (blocks chain.Blocks) {
+func (self *BlockPool) Blocks() (blocks types.Blocks) {
 	for _, item := range self.pool {
 		if item.block != nil {
 			blocks = append(blocks, item.block)
@@ -123,15 +124,15 @@ func (self *BlockPool) AddHash(hash []byte, peer *Peer) {
 	}
 }
 
-func (self *BlockPool) Add(b *chain.Block, peer *Peer) {
+func (self *BlockPool) Add(b *types.Block, peer *Peer) {
 	self.addBlock(b, peer, false)
 }
 
-func (self *BlockPool) AddNew(b *chain.Block, peer *Peer) {
+func (self *BlockPool) AddNew(b *types.Block, peer *Peer) {
 	self.addBlock(b, peer, true)
 }
 
-func (self *BlockPool) addBlock(b *chain.Block, peer *Peer, newBlock bool) {
+func (self *BlockPool) addBlock(b *types.Block, peer *Peer, newBlock bool) {
 	self.mut.Lock()
 	defer self.mut.Unlock()
 
@@ -283,7 +284,7 @@ out:
 			break out
 		case <-procTimer.C:
 			blocks := self.Blocks()
-			chain.BlockBy(chain.Number).Sort(blocks)
+			types.BlockBy(types.Number).Sort(blocks)
 
 			// Find common block
 			for i, block := range blocks {

chain/block_manager.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/event"
@@ -69,7 +70,7 @@ type BlockManager struct {
 	// The last attempted block is mainly used for debugging purposes
 	// This does not have to be a valid block and will be set during
 	// 'Process' & canonical validation.
-	lastAttemptedBlock *Block
+	lastAttemptedBlock *types.Block
 
 	events event.Subscription
 }
@@ -117,11 +118,11 @@ func (sm *BlockManager) ChainManager() *ChainManager {
 	return sm.bc
 }
 
-func (self *BlockManager) ProcessTransactions(coinbase *state.StateObject, state *state.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, Transactions, error) {
+func (self *BlockManager) ProcessTransactions(coinbase *state.StateObject, state *state.State, block, parent *types.Block, txs types.Transactions) (types.Receipts, types.Transactions, types.Transactions, types.Transactions, error) {
 	var (
-		receipts           Receipts
-		handled, unhandled Transactions
-		erroneous          Transactions
+		receipts           types.Receipts
+		handled, unhandled types.Transactions
+		erroneous          types.Transactions
 		totalUsedGas       = big.NewInt(0)
 		err                error
 	)
@@ -159,8 +160,9 @@ done:
 
 		txGas.Sub(txGas, st.gas)
 		cumulative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, txGas))
-		receipt := &Receipt{ethutil.CopyBytes(state.Root()), cumulative, nil /*bloom*/, state.Logs()}
-		receipt.Bloom = CreateBloom(Receipts{receipt})
+		receipt := types.NewReceipt(state.Root(), cumulative)
+		receipt.SetLogs(state.Logs())
+		receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
 
 		// Notify all subscribers
 		go self.eth.EventMux().Post(TxPostEvent{tx})
@@ -178,7 +180,7 @@ done:
 	return receipts, handled, unhandled, erroneous, err
 }
 
-func (sm *BlockManager) Process(block *Block) (td *big.Int, msgs state.Messages, err error) {
+func (sm *BlockManager) Process(block *types.Block) (td *big.Int, msgs state.Messages, err error) {
 	// Processing a blocks may never happen simultaneously
 	sm.mutex.Lock()
 	defer sm.mutex.Unlock()
@@ -195,7 +197,7 @@ func (sm *BlockManager) Process(block *Block) (td *big.Int, msgs state.Messages,
 	return sm.ProcessWithParent(block, parent)
 }
 
-func (sm *BlockManager) ProcessWithParent(block, parent *Block) (td *big.Int, messages state.Messages, err error) {
+func (sm *BlockManager) ProcessWithParent(block, parent *types.Block) (td *big.Int, messages state.Messages, err error) {
 	sm.lastAttemptedBlock = block
 
 	state := parent.State().Copy()
@@ -215,13 +217,13 @@ func (sm *BlockManager) ProcessWithParent(block, parent *Block) (td *big.Int, me
 		return
 	}
 
-	txSha := DeriveSha(block.transactions)
+	txSha := types.DeriveSha(block.Transactions())
 	if bytes.Compare(txSha, block.TxSha) != 0 {
 		err = fmt.Errorf("validating transaction root. received=%x got=%x", block.TxSha, txSha)
 		return
 	}
 
-	receiptSha := DeriveSha(receipts)
+	receiptSha := types.DeriveSha(receipts)
 	if bytes.Compare(receiptSha, block.ReceiptSha) != 0 {
 		err = fmt.Errorf("validating receipt root. received=%x got=%x", block.ReceiptSha, receiptSha)
 		return
@@ -238,8 +240,8 @@ func (sm *BlockManager) ProcessWithParent(block, parent *Block) (td *big.Int, me
 		return
 	}
 
-	block.receipts = receipts // although this isn't necessary it be in the future
-	rbloom := CreateBloom(receipts)
+	//block.receipts = receipts // although this isn't necessary it be in the future
+	rbloom := types.CreateBloom(receipts)
 	if bytes.Compare(rbloom, block.LogsBloom) != 0 {
 		err = fmt.Errorf("unable to replicate block's bloom=%x", rbloom)
 		return
@@ -272,7 +274,7 @@ func (sm *BlockManager) ProcessWithParent(block, parent *Block) (td *big.Int, me
 	}
 }
 
-func (sm *BlockManager) ApplyDiff(state *state.State, parent, block *Block) (receipts Receipts, err error) {
+func (sm *BlockManager) ApplyDiff(state *state.State, parent, block *types.Block) (receipts types.Receipts, err error) {
 	coinbase := state.GetOrNewStateObject(block.Coinbase)
 	coinbase.SetGasPool(block.CalcGasLimit(parent))
 
@@ -285,7 +287,7 @@ func (sm *BlockManager) ApplyDiff(state *state.State, parent, block *Block) (rec
 	return receipts, nil
 }
 
-func (sm *BlockManager) CalculateTD(block *Block) (*big.Int, bool) {
+func (sm *BlockManager) CalculateTD(block *types.Block) (*big.Int, bool) {
 	uncleDiff := new(big.Int)
 	for _, uncle := range block.Uncles {
 		uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty)
@@ -311,7 +313,7 @@ func (sm *BlockManager) CalculateTD(block *Block) (*big.Int, bool) {
 // Validates the current block. Returns an error if the block was invalid,
 // an uncle or anything that isn't on the current block chain.
 // Validation validates easy over difficult (dagger takes longer time = difficult)
-func (sm *BlockManager) ValidateBlock(block, parent *Block) error {
+func (sm *BlockManager) ValidateBlock(block, parent *types.Block) error {
 	expd := CalcDifficulty(block, parent)
 	if expd.Cmp(block.Difficulty) < 0 {
 		return fmt.Errorf("Difficulty check failed for block %v, %v", block.Difficulty, expd)
@@ -337,7 +339,7 @@ func (sm *BlockManager) ValidateBlock(block, parent *Block) error {
 	return nil
 }
 
-func (sm *BlockManager) AccumelateRewards(state *state.State, block, parent *Block) error {
+func (sm *BlockManager) AccumelateRewards(state *state.State, block, parent *types.Block) error {
 	reward := new(big.Int).Set(BlockReward)
 
 	knownUncles := ethutil.Set(parent.Uncles)
@@ -380,7 +382,7 @@ func (sm *BlockManager) AccumelateRewards(state *state.State, block, parent *Blo
 	return nil
 }
 
-func (sm *BlockManager) GetMessages(block *Block) (messages []*state.Message, err error) {
+func (sm *BlockManager) GetMessages(block *types.Block) (messages []*state.Message, err error) {
 	if !sm.bc.HasBlock(block.PrevHash) {
 		return nil, ParentError(block.PrevHash)
 	}

chain/chain_manager.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/state"
@@ -13,7 +14,7 @@ import (
 
 var chainlogger = logger.NewLogger("CHAIN")
 
-func AddTestNetFunds(block *Block) {
+func AddTestNetFunds(block *types.Block) {
 	for _, addr := range []string{
 		"51ba59315b3a95761d0863b05ccc7a7f54703d99",
 		"e4157b34ea9615cfbde6b4fda419828124b70c78",
@@ -25,13 +26,13 @@ func AddTestNetFunds(block *Block) {
 		"1a26338f0d905e295fccb71fa9ea849ffa12aaf4",
 	} {
 		codedAddr := ethutil.Hex2Bytes(addr)
-		account := block.state.GetAccount(codedAddr)
+		account := block.State().GetAccount(codedAddr)
 		account.SetBalance(ethutil.Big("1606938044258990275541962092341162602522202993782792835301376")) //ethutil.BigPow(2, 200)
-		block.state.UpdateStateObject(account)
+		block.State().UpdateStateObject(account)
 	}
 }
 
-func CalcDifficulty(block, parent *Block) *big.Int {
+func CalcDifficulty(block, parent *types.Block) *big.Int {
 	diff := new(big.Int)
 
 	adjust := new(big.Int).Rsh(parent.Difficulty, 10)
@@ -45,36 +46,41 @@ func CalcDifficulty(block, parent *Block) *big.Int {
 }
 
 type ChainManager struct {
-	eth          EthManager
-	genesisBlock *Block
+	//eth          EthManager
+	processor    types.BlockProcessor
+	genesisBlock *types.Block
 	// Last known total difficulty
 	TD *big.Int
 
 	LastBlockNumber uint64
 
-	CurrentBlock  *Block
+	CurrentBlock  *types.Block
 	LastBlockHash []byte
 
 	workingChain *BlockChain
 }
 
-func NewChainManager(ethereum EthManager) *ChainManager {
+func NewChainManager() *ChainManager {
 	bc := &ChainManager{}
-	bc.genesisBlock = NewBlockFromBytes(ethutil.Encode(Genesis))
-	bc.eth = ethereum
+	bc.genesisBlock = types.NewBlockFromBytes(ethutil.Encode(Genesis))
+	//bc.eth = ethereum
 
 	bc.setLastBlock()
 
 	return bc
 }
 
+func (self *ChainManager) SetProcessor(proc types.BlockProcessor) {
+	self.processor = proc
+}
+
 func (bc *ChainManager) setLastBlock() {
 	data, _ := ethutil.Config.Db.Get([]byte("LastBlock"))
 	if len(data) != 0 {
 		// Prep genesis
 		AddTestNetFunds(bc.genesisBlock)
 
-		block := NewBlockFromBytes(data)
+		block := types.NewBlockFromBytes(data)
 		bc.CurrentBlock = block
 		bc.LastBlockHash = block.Hash()
 		bc.LastBlockNumber = block.Number.Uint64()
@@ -89,7 +95,7 @@ func (bc *ChainManager) setLastBlock() {
 }
 
 // Block creation & chain handling
-func (bc *ChainManager) NewBlock(coinbase []byte) *Block {
+func (bc *ChainManager) NewBlock(coinbase []byte) *types.Block {
 	var root interface{}
 	hash := ZeroHash256
 
@@ -98,7 +104,7 @@ func (bc *ChainManager) NewBlock(coinbase []byte) *Block {
 		hash = bc.LastBlockHash
 	}
 
-	block := CreateBlock(
+	block := types.CreateBlock(
 		root,
 		hash,
 		coinbase,
@@ -122,7 +128,7 @@ func (bc *ChainManager) NewBlock(coinbase []byte) *Block {
 func (bc *ChainManager) Reset() {
 	AddTestNetFunds(bc.genesisBlock)
 
-	bc.genesisBlock.state.Trie.Sync()
+	bc.genesisBlock.Trie().Sync()
 	// Prepare the genesis block
 	bc.add(bc.genesisBlock)
 	bc.CurrentBlock = bc.genesisBlock
@@ -134,7 +140,7 @@ func (bc *ChainManager) Reset() {
 }
 
 // Add a block to the chain and record addition information
-func (bc *ChainManager) add(block *Block) {
+func (bc *ChainManager) add(block *types.Block) {
 	bc.writeBlockInfo(block)
 
 	bc.CurrentBlock = block
@@ -148,7 +154,7 @@ func (bc *ChainManager) add(block *Block) {
 }
 
 // Accessors
-func (bc *ChainManager) Genesis() *Block {
+func (bc *ChainManager) Genesis() *types.Block {
 	return bc.genesisBlock
 }
 
@@ -179,7 +185,7 @@ func (self *ChainManager) GetChainHashesFromHash(hash []byte, max uint64) (chain
 	return
 }
 
-func (self *ChainManager) GetBlock(hash []byte) *Block {
+func (self *ChainManager) GetBlock(hash []byte) *types.Block {
 	data, _ := ethutil.Config.Db.Get(hash)
 	if len(data) == 0 {
 		if self.workingChain != nil {
@@ -194,10 +200,10 @@ func (self *ChainManager) GetBlock(hash []byte) *Block {
 		return nil
 	}
 
-	return NewBlockFromBytes(data)
+	return types.NewBlockFromBytes(data)
 }
 
-func (self *ChainManager) GetBlockByNumber(num uint64) *Block {
+func (self *ChainManager) GetBlockByNumber(num uint64) *types.Block {
 	block := self.CurrentBlock
 	for ; block != nil; block = self.GetBlock(block.PrevHash) {
 		if block.Number.Uint64() == num {
@@ -217,7 +223,7 @@ func (bc *ChainManager) SetTotalDifficulty(td *big.Int) {
 	bc.TD = td
 }
 
-func (self *ChainManager) CalcTotalDiff(block *Block) (*big.Int, error) {
+func (self *ChainManager) CalcTotalDiff(block *types.Block) (*big.Int, error) {
 	parent := self.GetBlock(block.PrevHash)
 	if parent == nil {
 		return nil, fmt.Errorf("Unable to calculate total diff without known parent %x", block.PrevHash)
@@ -237,8 +243,8 @@ func (self *ChainManager) CalcTotalDiff(block *Block) (*big.Int, error) {
 	return td, nil
 }
 
-func (bc *ChainManager) BlockInfo(block *Block) BlockInfo {
-	bi := BlockInfo{}
+func (bc *ChainManager) BlockInfo(block *types.Block) types.BlockInfo {
+	bi := types.BlockInfo{}
 	data, _ := ethutil.Config.Db.Get(append(block.Hash(), []byte("Info")...))
 	bi.RlpDecode(data)
 
@@ -246,9 +252,9 @@ func (bc *ChainManager) BlockInfo(block *Block) BlockInfo {
 }
 
 // Unexported method for writing extra non-essential block info to the db
-func (bc *ChainManager) writeBlockInfo(block *Block) {
+func (bc *ChainManager) writeBlockInfo(block *types.Block) {
 	bc.LastBlockNumber++
-	bi := BlockInfo{Number: bc.LastBlockNumber, Hash: block.Hash(), Parent: block.PrevHash, TD: bc.TD}
+	bi := types.BlockInfo{Number: bc.LastBlockNumber, Hash: block.Hash(), Parent: block.PrevHash, TD: bc.TD}
 
 	// For now we use the block hash with the words "info" appended as key
 	ethutil.Config.Db.Put(append(block.Hash(), []byte("Info")...), bi.RlpEncode())
@@ -271,8 +277,8 @@ func (self *ChainManager) InsertChain(chain *BlockChain) {
 
 		self.add(link.block)
 		self.SetTotalDifficulty(link.td)
-		self.eth.EventMux().Post(NewBlockEvent{link.block})
-		self.eth.EventMux().Post(link.messages)
+		//self.eth.EventMux().Post(NewBlockEvent{link.block})
+		//self.eth.EventMux().Post(link.messages)
 	}
 
 	b, e := chain.Front(), chain.Back()
@@ -299,7 +305,7 @@ func (self *ChainManager) TestChain(chain *BlockChain) (td *big.Int, err error)
 		}
 
 		var messages state.Messages
-		td, messages, err = self.eth.BlockManager().ProcessWithParent(block, parent)
+		td, messages, err = self.processor.ProcessWithParent(block, parent) //self.eth.BlockManager().ProcessWithParent(block, parent)
 		if err != nil {
 			chainlogger.Infoln(err)
 			chainlogger.Debugf("Block #%v failed (%x...)\n", block.Number, block.Hash()[0:4])
@@ -323,7 +329,7 @@ func (self *ChainManager) TestChain(chain *BlockChain) (td *big.Int, err error)
 }
 
 type link struct {
-	block    *Block
+	block    *types.Block
 	messages state.Messages
 	td       *big.Int
 }
@@ -332,7 +338,7 @@ type BlockChain struct {
 	*list.List
 }
 
-func NewChain(blocks Blocks) *BlockChain {
+func NewChain(blocks types.Blocks) *BlockChain {
 	chain := &BlockChain{list.New()}
 
 	for _, block := range blocks {
@@ -353,10 +359,10 @@ func (self *BlockChain) RlpEncode() []byte {
 
 type ChainIterator struct {
 	cm    *ChainManager
-	block *Block // current block in the iterator
+	block *types.Block // current block in the iterator
 }
 
-func (self *ChainIterator) Prev() *Block {
+func (self *ChainIterator) Prev() *types.Block {
 	self.block = self.cm.GetBlock(self.block.PrevHash)
 	return self.block
 }

chain/dagger.go

@@ -6,6 +6,7 @@ import (
 	"math/rand"
 	"time"
 
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
@@ -15,7 +16,7 @@ import (
 var powlogger = logger.NewLogger("POW")
 
 type PoW interface {
-	Search(block *Block, stop <-chan struct{}) []byte
+	Search(block *types.Block, stop <-chan struct{}) []byte
 	Verify(hash []byte, diff *big.Int, nonce []byte) bool
 	GetHashrate() int64
 	Turbo(bool)
@@ -35,7 +36,7 @@ func (pow *EasyPow) Turbo(on bool) {
 	pow.turbo = on
 }
 
-func (pow *EasyPow) Search(block *Block, stop <-chan struct{}) []byte {
+func (pow *EasyPow) Search(block *types.Block, stop <-chan struct{}) []byte {
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	hash := block.HashNoNonce()
 	diff := block.Difficulty

chain/events.go

 package chain
 
+import "github.com/ethereum/go-ethereum/chain/types"
+
 // TxPreEvent is posted when a transaction enters the transaction pool.
-type TxPreEvent struct{ Tx *Transaction }
+type TxPreEvent struct{ Tx *types.Transaction }
 
 // TxPostEvent is posted when a transaction has been processed.
-type TxPostEvent struct{ Tx *Transaction }
+type TxPostEvent struct{ Tx *types.Transaction }
 
 // NewBlockEvent is posted when a block has been imported.
-type NewBlockEvent struct{ Block *Block }
+type NewBlockEvent struct{ Block *types.Block }

chain/filter.go

@@ -5,6 +5,7 @@ import (
 	"math"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/state"
 )
@@ -24,7 +25,7 @@ type Filter struct {
 
 	Altered []AccountChange
 
-	BlockCallback   func(*Block)
+	BlockCallback   func(*types.Block)
 	MessageCallback func(state.Messages)
 }
 
@@ -171,11 +172,11 @@ func (self *Filter) FilterMessages(msgs []*state.Message) []*state.Message {
 	return messages
 }
 
-func (self *Filter) bloomFilter(block *Block) bool {
+func (self *Filter) bloomFilter(block *types.Block) bool {
 	var fromIncluded, toIncluded bool
 	if len(self.from) > 0 {
 		for _, from := range self.from {
-			if BloomLookup(block.LogsBloom, from) {
+			if types.BloomLookup(block.LogsBloom, from) {
 				fromIncluded = true
 				break
 			}
@@ -186,7 +187,7 @@ func (self *Filter) bloomFilter(block *Block) bool {
 
 	if len(self.to) > 0 {
 		for _, to := range self.to {
-			if BloomLookup(block.LogsBloom, ethutil.U256(new(big.Int).Add(ethutil.Big1, ethutil.BigD(to))).Bytes()) {
+			if types.BloomLookup(block.LogsBloom, ethutil.U256(new(big.Int).Add(ethutil.Big1, ethutil.BigD(to))).Bytes()) {
 				toIncluded = true
 				break
 			}

chain/state_transition.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
@@ -26,17 +27,17 @@ import (
  */
 type StateTransition struct {
 	coinbase, receiver []byte
-	tx                 *Transaction
+	tx                 *types.Transaction
 	gas, gasPrice      *big.Int
 	value              *big.Int
 	data               []byte
 	state              *state.State
-	block              *Block
+	block              *types.Block
 
 	cb, rec, sen *state.StateObject
 }
 
-func NewStateTransition(coinbase *state.StateObject, tx *Transaction, state *state.State, block *Block) *StateTransition {
+func NewStateTransition(coinbase *state.StateObject, tx *types.Transaction, state *state.State, block *types.Block) *StateTransition {
 	return &StateTransition{coinbase.Address(), tx.Recipient, tx, new(big.Int), new(big.Int).Set(tx.GasPrice), tx.Value, tx.Data, state, block, coinbase, nil, nil}
 }
 
@@ -203,7 +204,7 @@ func (self *StateTransition) TransitionState() (err error) {
 	})
 
 	// Process the init code and create 'valid' contract
-	if IsContractAddr(self.receiver) {
+	if types.IsContractAddr(self.receiver) {
 		// Evaluate the initialization script
 		// and use the return value as the
 		// script section for the state object.
@@ -280,7 +281,7 @@ func (self *StateTransition) Eval(msg *state.Message, script []byte, context *st
 }
 
 // Converts an transaction in to a state object
-func MakeContract(tx *Transaction, state *state.State) *state.StateObject {
+func MakeContract(tx *types.Transaction, state *state.State) *state.StateObject {
 	addr := tx.CreationAddress(state)
 
 	contract := state.GetOrNewStateObject(addr)

chain/transaction_pool.go

@@ -7,6 +7,7 @@ import (
 	"math/big"
 	"sync"
 
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/wire"
@@ -16,7 +17,7 @@ var txplogger = logger.NewLogger("TXP")
 
 const txPoolQueueSize = 50
 
-type TxPoolHook chan *Transaction
+type TxPoolHook chan *types.Transaction
 type TxMsgTy byte
 
 const (
@@ -26,21 +27,21 @@ const (
 var MinGasPrice = big.NewInt(10000000000000)
 
 type TxMsg struct {
-	Tx   *Transaction
+	Tx   *types.Transaction
 	Type TxMsgTy
 }
 
-func EachTx(pool *list.List, it func(*Transaction, *list.Element) bool) {
+func EachTx(pool *list.List, it func(*types.Transaction, *list.Element) bool) {
 	for e := pool.Front(); e != nil; e = e.Next() {
-		if it(e.Value.(*Transaction), e) {
+		if it(e.Value.(*types.Transaction), e) {
 			break
 		}
 	}
 }
 
-func FindTx(pool *list.List, finder func(*Transaction, *list.Element) bool) *Transaction {
+func FindTx(pool *list.List, finder func(*types.Transaction, *list.Element) bool) *types.Transaction {
 	for e := pool.Front(); e != nil; e = e.Next() {
-		if tx, ok := e.Value.(*Transaction); ok {
+		if tx, ok := e.Value.(*types.Transaction); ok {
 			if finder(tx, e) {
 				return tx
 			}
@@ -51,7 +52,7 @@ func FindTx(pool *list.List, finder func(*Transaction, *list.Element) bool) *Tra
 }
 
 type TxProcessor interface {
-	ProcessTransaction(tx *Transaction)
+	ProcessTransaction(tx *types.Transaction)
 }
 
 // The tx pool a thread safe transaction pool handler. In order to
@@ -65,7 +66,7 @@ type TxPool struct {
 	mutex sync.Mutex
 	// Queueing channel for reading and writing incoming
 	// transactions to
-	queueChan chan *Transaction
+	queueChan chan *types.Transaction
 	// Quiting channel
 	quit chan bool
 	// The actual pool
@@ -79,14 +80,14 @@ type TxPool struct {
 func NewTxPool(ethereum EthManager) *TxPool {
 	return &TxPool{
 		pool:      list.New(),
-		queueChan: make(chan *Transaction, txPoolQueueSize),
+		queueChan: make(chan *types.Transaction, txPoolQueueSize),
 		quit:      make(chan bool),
 		Ethereum:  ethereum,
 	}
 }
 
 // Blocking function. Don't use directly. Use QueueTransaction instead
-func (pool *TxPool) addTransaction(tx *Transaction) {
+func (pool *TxPool) addTransaction(tx *types.Transaction) {
 	pool.mutex.Lock()
 	defer pool.mutex.Unlock()
 
@@ -96,7 +97,7 @@ func (pool *TxPool) addTransaction(tx *Transaction) {
 	pool.Ethereum.Broadcast(wire.MsgTxTy, []interface{}{tx.RlpData()})
 }
 
-func (pool *TxPool) ValidateTransaction(tx *Transaction) error {
+func (pool *TxPool) ValidateTransaction(tx *types.Transaction) error {
 	// Get the last block so we can retrieve the sender and receiver from
 	// the merkle trie
 	block := pool.Ethereum.ChainManager().CurrentBlock
@@ -142,7 +143,7 @@ out:
 		select {
 		case tx := <-pool.queueChan:
 			hash := tx.Hash()
-			foundTx := FindTx(pool.pool, func(tx *Transaction, e *list.Element) bool {
+			foundTx := FindTx(pool.pool, func(tx *types.Transaction, e *list.Element) bool {
 				return bytes.Compare(tx.Hash(), hash) == 0
 			})
 
@@ -172,18 +173,18 @@ out:
 	}
 }
 
-func (pool *TxPool) QueueTransaction(tx *Transaction) {
+func (pool *TxPool) QueueTransaction(tx *types.Transaction) {
 	pool.queueChan <- tx
 }
 
-func (pool *TxPool) CurrentTransactions() []*Transaction {
+func (pool *TxPool) CurrentTransactions() []*types.Transaction {
 	pool.mutex.Lock()
 	defer pool.mutex.Unlock()
 
-	txList := make([]*Transaction, pool.pool.Len())
+	txList := make([]*types.Transaction, pool.pool.Len())
 	i := 0
 	for e := pool.pool.Front(); e != nil; e = e.Next() {
-		tx := e.Value.(*Transaction)
+		tx := e.Value.(*types.Transaction)
 
 		txList[i] = tx
 
@@ -198,7 +199,7 @@ func (pool *TxPool) RemoveInvalid(state *state.State) {
 	defer pool.mutex.Unlock()
 
 	for e := pool.pool.Front(); e != nil; e = e.Next() {
-		tx := e.Value.(*Transaction)
+		tx := e.Value.(*types.Transaction)
 		sender := state.GetAccount(tx.Sender())
 		err := pool.ValidateTransaction(tx)
 		if err != nil || sender.Nonce >= tx.Nonce {
@@ -207,12 +208,12 @@ func (pool *TxPool) RemoveInvalid(state *state.State) {
 	}
 }
 
-func (self *TxPool) RemoveSet(txs Transactions) {
+func (self *TxPool) RemoveSet(txs types.Transactions) {
 	self.mutex.Lock()
 	defer self.mutex.Unlock()
 
 	for _, tx := range txs {
-		EachTx(self.pool, func(t *Transaction, element *list.Element) bool {
+		EachTx(self.pool, func(t *types.Transaction, element *list.Element) bool {
 			if t == tx {
 				self.pool.Remove(element)
 				return true // To stop the loop
@@ -222,7 +223,7 @@ func (self *TxPool) RemoveSet(txs Transactions) {
 	}
 }
 
-func (pool *TxPool) Flush() []*Transaction {
+func (pool *TxPool) Flush() []*types.Transaction {
 	txList := pool.CurrentTransactions()
 
 	// Recreate a new list all together

chain/transaction_test.go

-package chain

chain/block.go → chain/types/block.go

-package chain
+package types
 
 import (
 	"bytes"
@@ -156,7 +156,7 @@ func (block *Block) State() *state.State {
 	return block.state
 }
 
-func (block *Block) Transactions() []*Transaction {
+func (block *Block) Transactions() Transactions {
 	return block.transactions
 }
 

chain/bloom9.go → chain/types/bloom9.go

-package chain
+package types
 
 import (
 	"math/big"

chain/bloom9_test.go → chain/types/bloom9_test.go

-package chain
+package types
 
 import (
 	"testing"
+
 	"github.com/ethereum/go-ethereum/state"
 )
 

chain/types/common.go

+package types
+
+import (
+	"math/big"
+	"github.com/ethereum/go-ethereum/state"
+)
+
+type BlockProcessor interface {
+	ProcessWithParent(*Block, *Block) (*big.Int, state.Messages, error)
+}

chain/derive_sha.go → chain/types/derive_sha.go

-package chain
+package types
 
 import (
 	"github.com/ethereum/go-ethereum/ethutil"

chain/receipt.go → chain/types/receipt.go

-package chain
+package types
 
 import (
 	"bytes"
@@ -16,6 +16,10 @@ type Receipt struct {
 	logs              state.Logs
 }
 
+func NewReceipt(root []byte, cumalativeGasUsed *big.Int) *Receipt {
+	return &Receipt{PostState: ethutil.CopyBytes(root), CumulativeGasUsed: cumalativeGasUsed}
+}
+
 func NewRecieptFromValue(val *ethutil.Value) *Receipt {
 	r := &Receipt{}
 	r.RlpValueDecode(val)
@@ -23,6 +27,10 @@ func NewRecieptFromValue(val *ethutil.Value) *Receipt {
 	return r
 }
 
+func (self *Receipt) SetLogs(logs state.Logs) {
+	self.logs = logs
+}
+
 func (self *Receipt) RlpValueDecode(decoder *ethutil.Value) {
 	self.PostState = decoder.Get(0).Bytes()
 	self.CumulativeGasUsed = decoder.Get(1).BigInt()

chain/transaction.go → chain/types/transaction.go

-package chain
+package types
 
 import (
 	"fmt"

chain/types/transaction_test.go

+package types

chain/vm_env.go

@@ -3,17 +3,18 @@ package chain
 import (
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
 
 type VMEnv struct {
 	state *state.State
-	block *Block
-	tx    *Transaction
+	block *types.Block
+	tx    *types.Transaction
 }
 
-func NewEnv(state *state.State, tx *Transaction, block *Block) *VMEnv {
+func NewEnv(state *state.State, tx *types.Transaction, block *types.Block) *VMEnv {
 	return &VMEnv{
 		state: state,
 		block: block,

cmd/mist/bindings.go

@@ -21,8 +21,7 @@ import (
 	"encoding/json"
 	"os"
 	"strconv"
-
-	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
@@ -106,7 +105,7 @@ func (self *Gui) DumpState(hash, path string) {
 	if len(hash) == 0 {
 		stateDump = self.eth.BlockManager().CurrentState().Dump()
 	} else {
-		var block *chain.Block
+		var block *types.Block
 		if hash[0] == '#' {
 			i, _ := strconv.Atoi(hash[1:])
 			block = self.eth.ChainManager().GetBlockByNumber(uint64(i))

cmd/mist/ext_app.go

@@ -21,6 +21,7 @@ import (
 	"encoding/json"
 
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/javascript"
 	"github.com/ethereum/go-ethereum/state"
@@ -36,7 +37,7 @@ type AppContainer interface {
 	Window() *qml.Window
 	Engine() *qml.Engine
 
-	NewBlock(*chain.Block)
+	NewBlock(*types.Block)
 	NewWatcher(chan bool)
 	Messages(state.Messages, string)
 	Post(string, int)

cmd/mist/gui.go

@@ -32,6 +32,7 @@ import (
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
@@ -290,7 +291,7 @@ func (self *Gui) loadMergedMiningOptions() {
 	}
 }
 
-func (gui *Gui) insertTransaction(window string, tx *chain.Transaction) {
+func (gui *Gui) insertTransaction(window string, tx *types.Transaction) {
 	pipe := xeth.New(gui.eth)
 	nameReg := pipe.World().Config().Get("NameReg")
 	addr := gui.address()
@@ -340,7 +341,7 @@ func (gui *Gui) insertTransaction(window string, tx *chain.Transaction) {
 func (gui *Gui) readPreviousTransactions() {
 	it := gui.txDb.NewIterator()
 	for it.Next() {
-		tx := chain.NewTransactionFromBytes(it.Value())
+		tx := types.NewTransactionFromBytes(it.Value())
 
 		gui.insertTransaction("post", tx)
 
@@ -348,7 +349,7 @@ func (gui *Gui) readPreviousTransactions() {
 	it.Release()
 }
 
-func (gui *Gui) processBlock(block *chain.Block, initial bool) {
+func (gui *Gui) processBlock(block *types.Block, initial bool) {
 	name := strings.Trim(gui.pipe.World().Config().Get("NameReg").Storage(block.Coinbase).Str(), "\x00")
 	b := xeth.NewJSBlock(block)
 	b.Name = name

cmd/mist/html_container.go

@@ -26,8 +26,7 @@ import (
 	"os"
 	"path"
 	"path/filepath"
-
-	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/javascript"
 	"github.com/ethereum/go-ethereum/state"
@@ -138,7 +137,7 @@ func (app *HtmlApplication) Window() *qml.Window {
 	return app.win
 }
 
-func (app *HtmlApplication) NewBlock(block *chain.Block) {
+func (app *HtmlApplication) NewBlock(block *types.Block) {
 	b := &xeth.JSBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
 	app.webView.Call("onNewBlockCb", b)
 }

cmd/mist/qml_container.go

@@ -20,8 +20,7 @@ package main
 import (
 	"fmt"
 	"runtime"
-
-	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/xeth"
@@ -65,7 +64,7 @@ func (app *QmlApplication) NewWatcher(quitChan chan bool) {
 }
 
 // Events
-func (app *QmlApplication) NewBlock(block *chain.Block) {
+func (app *QmlApplication) NewBlock(block *types.Block) {
 	pblock := &xeth.JSBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
 	app.win.Call("onNewBlockCb", pblock)
 }

cmd/mist/ui_lib.go

@@ -26,6 +26,7 @@ import (
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/javascript"
@@ -126,7 +127,7 @@ func (self *UiLib) PastPeers() *ethutil.List {
 }
 
 func (self *UiLib) ImportTx(rlpTx string) {
-	tx := chain.NewTransactionFromBytes(ethutil.Hex2Bytes(rlpTx))
+	tx := types.NewTransactionFromBytes(ethutil.Hex2Bytes(rlpTx))
 	self.eth.TxPool().QueueTransaction(tx)
 }
 
@@ -228,7 +229,7 @@ func (self *UiLib) NewFilter(object map[string]interface{}) (id int) {
 
 func (self *UiLib) NewFilterString(typ string) (id int) {
 	filter := chain.NewFilter(self.eth)
-	filter.BlockCallback = func(block *chain.Block) {
+	filter.BlockCallback = func(block *types.Block) {
 		if self.win != nil && self.win.Root() != nil {
 			self.win.Root().Call("invokeFilterCallback", "{}", id)
 		} else {

cmd/utils/vm_env.go

@@ -2,21 +2,20 @@ package utils
 
 import (
 	"math/big"
-
-	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
 
 type VMEnv struct {
 	state *state.State
-	block *chain.Block
+	block *types.Block
 
 	transactor []byte
 	value      *big.Int
 }
 
-func NewEnv(state *state.State, block *chain.Block, transactor []byte, value *big.Int) *VMEnv {
+func NewEnv(state *state.State, block *types.Block, transactor []byte, value *big.Int) *VMEnv {
 	return &VMEnv{
 		state:      state,
 		block:      block,

ethereum.go

@@ -129,8 +129,9 @@ func New(db ethutil.Database, clientIdentity wire.ClientIdentity, keyManager *cr
 
 	ethereum.blockPool = NewBlockPool(ethereum)
 	ethereum.txPool = chain.NewTxPool(ethereum)
-	ethereum.blockChain = chain.NewChainManager(ethereum)
+	ethereum.blockChain = chain.NewChainManager()
 	ethereum.blockManager = chain.NewBlockManager(ethereum)
+	ethereum.blockChain.SetProcessor(ethereum.blockManager)
 
 	// Start the tx pool
 	ethereum.txPool.Start()

javascript/javascript_runtime.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/event"
@@ -130,7 +131,7 @@ func (self *JSRE) dump(call otto.FunctionCall) otto.Value {
 	var state *state.State
 
 	if len(call.ArgumentList) > 0 {
-		var block *chain.Block
+		var block *types.Block
 		if call.Argument(0).IsNumber() {
 			num, _ := call.Argument(0).ToInteger()
 			block = self.ethereum.ChainManager().GetBlockByNumber(uint64(num))

miner/miner.go

@@ -31,6 +31,7 @@ import (
 	"github.com/ethereum/go-ethereum/ethutil"
 
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/wire"
@@ -44,7 +45,7 @@ type LocalTx struct {
 	Value    string `json:"value"`
 }
 
-func (self *LocalTx) Sign(key []byte) *chain.Transaction {
+func (self *LocalTx) Sign(key []byte) *types.Transaction {
 	return nil
 }
 
@@ -54,7 +55,7 @@ type Miner struct {
 	eth    *eth.Ethereum
 	events event.Subscription
 
-	uncles    chain.Blocks
+	uncles    types.Blocks
 	localTxs  map[int]*LocalTx
 	localTxId int
 
@@ -212,7 +213,7 @@ func (self *Miner) mine() {
 	nonce := self.pow.Search(block, self.powQuitCh)
 	if nonce != nil {
 		block.Nonce = nonce
-		lchain := chain.NewChain(chain.Blocks{block})
+		lchain := chain.NewChain(types.Blocks{block})
 		_, err := chainMan.TestChain(lchain)
 		if err != nil {
 			minerlogger.Infoln(err)
@@ -229,15 +230,15 @@ func (self *Miner) mine() {
 	}
 }
 
-func (self *Miner) finiliseTxs() chain.Transactions {
+func (self *Miner) finiliseTxs() types.Transactions {
 	// Sort the transactions by nonce in case of odd network propagation
-	var txs chain.Transactions
+	var txs types.Transactions
 
 	state := self.eth.BlockManager().TransState()
 	// XXX This has to change. Coinbase is, for new, same as key.
 	key := self.eth.KeyManager()
 	for _, ltx := range self.localTxs {
-		tx := chain.NewTransactionMessage(ltx.To, ethutil.Big(ltx.Value), ethutil.Big(ltx.Gas), ethutil.Big(ltx.GasPrice), ltx.Data)
+		tx := types.NewTransactionMessage(ltx.To, ethutil.Big(ltx.Value), ethutil.Big(ltx.Gas), ethutil.Big(ltx.GasPrice), ltx.Data)
 		tx.Nonce = state.GetNonce(self.Coinbase)
 		state.SetNonce(self.Coinbase, tx.Nonce+1)
 
@@ -247,7 +248,7 @@ func (self *Miner) finiliseTxs() chain.Transactions {
 	}
 
 	txs = append(txs, self.eth.TxPool().CurrentTransactions()...)
-	sort.Sort(chain.TxByNonce{txs})
+	sort.Sort(types.TxByNonce{txs})
 
 	return txs
 }

peer.go

@@ -11,8 +11,7 @@ import (
 	"strings"
 	"sync/atomic"
 	"time"
-
-	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/wire"
@@ -155,7 +154,7 @@ type Peer struct {
 	pingTime      time.Duration
 	pingStartTime time.Time
 
-	lastRequestedBlock *chain.Block
+	lastRequestedBlock *types.Block
 
 	protocolCaps *ethutil.Value
 }
@@ -429,7 +428,7 @@ func (p *Peer) HandleInbound() {
 				// in the TxPool where it will undergo validation and
 				// processing when a new block is found
 				for i := 0; i < msg.Data.Len(); i++ {
-					tx := chain.NewTransactionFromValue(msg.Data.Get(i))
+					tx := types.NewTransactionFromValue(msg.Data.Get(i))
 					p.ethereum.TxPool().QueueTransaction(tx)
 				}
 			case wire.MsgGetPeersTy:
@@ -535,7 +534,7 @@ func (p *Peer) HandleInbound() {
 
 					it := msg.Data.NewIterator()
 					for it.Next() {
-						block := chain.NewBlockFromRlpValue(it.Value())
+						block := types.NewBlockFromRlpValue(it.Value())
 						blockPool.Add(block, p)
 
 						p.lastBlockReceived = time.Now()
@@ -543,7 +542,7 @@ func (p *Peer) HandleInbound() {
 				case wire.MsgNewBlockTy:
 					var (
 						blockPool = p.ethereum.blockPool
-						block     = chain.NewBlockFromRlpValue(msg.Data.Get(0))
+						block     = types.NewBlockFromRlpValue(msg.Data.Get(0))
 						td        = msg.Data.Get(1).BigInt()
 					)
 

xeth/hexface.go

@@ -6,6 +6,7 @@ import (
 	"sync/atomic"
 
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/state"
@@ -209,7 +210,7 @@ func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr
 		gas      = ethutil.Big(gasStr)
 		gasPrice = ethutil.Big(gasPriceStr)
 		data     []byte
-		tx       *chain.Transaction
+		tx       *types.Transaction
 	)
 
 	if ethutil.IsHex(codeStr) {
@@ -219,9 +220,9 @@ func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr
 	}
 
 	if contractCreation {
-		tx = chain.NewContractCreationTx(value, gas, gasPrice, data)
+		tx = types.NewContractCreationTx(value, gas, gasPrice, data)
 	} else {
-		tx = chain.NewTransactionMessage(hash, value, gas, gasPrice, data)
+		tx = types.NewTransactionMessage(hash, value, gas, gasPrice, data)
 	}
 
 	acc := self.obj.BlockManager().TransState().GetOrNewStateObject(keyPair.Address())
@@ -240,7 +241,7 @@ func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr
 }
 
 func (self *JSXEth) PushTx(txStr string) (*JSReceipt, error) {
-	tx := chain.NewTransactionFromBytes(ethutil.Hex2Bytes(txStr))
+	tx := types.NewTransactionFromBytes(ethutil.Hex2Bytes(txStr))
 	self.obj.TxPool().QueueTransaction(tx)
 	return NewJSReciept(tx.CreatesContract(), tx.CreationAddress(self.World().State()), tx.Hash(), tx.Sender()), nil
 }

xeth/js_types.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/state"
@@ -14,7 +15,7 @@ import (
 // Block interface exposed to QML
 type JSBlock struct {
 	//Transactions string `json:"transactions"`
-	ref          *chain.Block
+	ref          *types.Block
 	Size         string        `json:"size"`
 	Number       int           `json:"number"`
 	Hash         string        `json:"hash"`
@@ -31,7 +32,7 @@ type JSBlock struct {
 }
 
 // Creates a new QML Block from a chain block
-func NewJSBlock(block *chain.Block) *JSBlock {
+func NewJSBlock(block *types.Block) *JSBlock {
 	if block == nil {
 		return &JSBlock{}
 	}
@@ -79,7 +80,7 @@ func (self *JSBlock) GetTransaction(hash string) *JSTransaction {
 }
 
 type JSTransaction struct {
-	ref *chain.Transaction
+	ref *types.Transaction
 
 	Value           string `json:"value"`
 	Gas             string `json:"gas"`
@@ -94,7 +95,7 @@ type JSTransaction struct {
 	Confirmations   int    `json:"confirmations"`
 }
 
-func NewJSTx(tx *chain.Transaction, state *state.State) *JSTransaction {
+func NewJSTx(tx *types.Transaction, state *state.State) *JSTransaction {
 	hash := ethutil.Bytes2Hex(tx.Hash())
 	receiver := ethutil.Bytes2Hex(tx.Recipient)
 	if receiver == "0000000000000000000000000000000000000000" {

xeth/pipe.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
@@ -72,7 +73,7 @@ func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *
 	return ret, err
 }
 
-func (self *XEth) Block(hash []byte) *chain.Block {
+func (self *XEth) Block(hash []byte) *types.Block {
 	return self.blockChain.GetBlock(hash)
 }
 
@@ -115,7 +116,7 @@ func (self *XEth) Transact(key *crypto.KeyPair, rec []byte, value, gas, price *e
 		contractCreation = true
 	}
 
-	var tx *chain.Transaction
+	var tx *types.Transaction
 	// Compile and assemble the given data
 	if contractCreation {
 		script, err := ethutil.Compile(string(data), false)
@@ -123,7 +124,7 @@ func (self *XEth) Transact(key *crypto.KeyPair, rec []byte, value, gas, price *e
 			return nil, err
 		}
 
-		tx = chain.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), script)
+		tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), script)
 	} else {
 		data := ethutil.StringToByteFunc(string(data), func(s string) (ret []byte) {
 			slice := strings.Split(s, "\n")
@@ -134,7 +135,7 @@ func (self *XEth) Transact(key *crypto.KeyPair, rec []byte, value, gas, price *e
 			return
 		})
 
-		tx = chain.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data)
+		tx = types.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data)
 	}
 
 	acc := self.blockManager.TransState().GetOrNewStateObject(key.Address())
@@ -155,7 +156,7 @@ func (self *XEth) Transact(key *crypto.KeyPair, rec []byte, value, gas, price *e
 	return tx.Hash(), nil
 }
 
-func (self *XEth) PushTx(tx *chain.Transaction) ([]byte, error) {
+func (self *XEth) PushTx(tx *types.Transaction) ([]byte, error) {
 	self.obj.TxPool().QueueTransaction(tx)
 	if tx.Recipient == nil {
 		addr := tx.CreationAddress(self.World().State())

xeth/vm_env.go

@@ -2,20 +2,19 @@ package xeth
 
 import (
 	"math/big"
-
-	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/chain/types"
 	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
 
 type VMEnv struct {
 	state  *state.State
-	block  *chain.Block
+	block  *types.Block
 	value  *big.Int
 	sender []byte
 }
 
-func NewEnv(state *state.State, block *chain.Block, value *big.Int, sender []byte) *VMEnv {
+func NewEnv(state *state.State, block *types.Block, value *big.Int, sender []byte) *VMEnv {
 	return &VMEnv{
 		state:  state,
 		block:  block,