Fixed inconsistencies

ethchain/state_manager.go

@@ -104,18 +104,21 @@ func (self *StateManager) Stop() {
 }
 
 func (self *StateManager) updateThread() {
-	blockChan := self.eth.Eventer().Register("block")
+	blockChan := self.eth.Eventer().Register("blocks")
 
 out:
 	for {
 		select {
 		case event := <-blockChan:
-			block := event.Data.(*Block)
+			blocks := event.Data.(Blocks)
+			for _, block := range blocks {
 				err := self.Process(block, false)
 				if err != nil {
 					statelogger.Infoln(err)
 					statelogger.Debugf("Block #%v failed (%x...)\n", block.Number, block.Hash()[0:4])
 					statelogger.Debugln(block)
+					break
+				}
 			}
 
 		case <-self.quit:

ethchain/state_transition.go

@@ -292,9 +292,9 @@ func (self *StateTransition) Eval(msg *ethstate.Message, script []byte, context
 func MakeContract(tx *Transaction, state *ethstate.State) *ethstate.StateObject {
 	// Create contract if there's no recipient
 	if tx.IsContract() {
-		addr := tx.CreationAddress()
+		addr := tx.CreationAddress(state)
 
-		contract := state.NewStateObject(addr)
+		contract := state.GetOrNewStateObject(addr)
 		contract.InitCode = tx.Data
 		contract.State = ethstate.New(ethtrie.New(ethutil.Config.Db, ""))
 

ethchain/transaction.go

@@ -6,6 +6,7 @@ import (
 	"math/big"
 
 	"github.com/ethereum/eth-go/ethcrypto"
+	"github.com/ethereum/eth-go/ethstate"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/obscuren/secp256k1-go"
 )
@@ -77,8 +78,14 @@ func (tx *Transaction) IsContract() bool {
 	return tx.CreatesContract()
 }
 
-func (tx *Transaction) CreationAddress() []byte {
+func (tx *Transaction) CreationAddress(state *ethstate.State) []byte {
-	return ethcrypto.Sha3Bin(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce}).Encode())[12:]
+	// Generate a new address
+	addr := ethcrypto.Sha3Bin(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce}).Encode())[12:]
+	//for i := uint64(0); state.GetStateObject(addr) != nil; i++ {
+	//	addr = ethcrypto.Sha3Bin(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce + i}).Encode())[12:]
+	//}
+
+	return addr
 }
 
 func (tx *Transaction) Signature(key []byte) []byte {

ethpipe/js_pipe.go

@@ -233,16 +233,16 @@ func (self *JSPipe) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr
 	self.obj.TxPool().QueueTransaction(tx)
 
 	if contractCreation {
-		logger.Infof("Contract addr %x", tx.CreationAddress())
+		logger.Infof("Contract addr %x", tx.CreationAddress(self.World().State()))
 	}
 
-	return NewJSReciept(contractCreation, tx.CreationAddress(), tx.Hash(), keyPair.Address()), nil
+	return NewJSReciept(contractCreation, tx.CreationAddress(self.World().State()), tx.Hash(), keyPair.Address()), nil
 }
 
 func (self *JSPipe) PushTx(txStr string) (*JSReceipt, error) {
 	tx := ethchain.NewTransactionFromBytes(ethutil.Hex2Bytes(txStr))
 	self.obj.TxPool().QueueTransaction(tx)
-	return NewJSReciept(tx.CreatesContract(), tx.CreationAddress(), tx.Hash(), tx.Sender()), nil
+	return NewJSReciept(tx.CreatesContract(), tx.CreationAddress(self.World().State()), tx.Hash(), tx.Sender()), nil
 }
 
 func (self *JSPipe) CompileMutan(code string) string {

ethpipe/js_types.go

@@ -35,7 +35,7 @@ func NewJSBlock(block *ethchain.Block) *JSBlock {
 
 	var ptxs []JSTransaction
 	for _, tx := range block.Transactions() {
-		ptxs = append(ptxs, *NewJSTx(tx))
+		ptxs = append(ptxs, *NewJSTx(tx, block.State()))
 	}
 
 	list := ethutil.NewList(ptxs)
@@ -64,7 +64,7 @@ func (self *JSBlock) GetTransaction(hash string) *JSTransaction {
 		return nil
 	}
 
-	return NewJSTx(tx)
+	return NewJSTx(tx, self.ref.State())
 }
 
 type JSTransaction struct {
@@ -83,11 +83,11 @@ type JSTransaction struct {
 	Confirmations   int    `json:"confirmations"`
 }
 
-func NewJSTx(tx *ethchain.Transaction) *JSTransaction {
+func NewJSTx(tx *ethchain.Transaction, state *ethstate.State) *JSTransaction {
 	hash := ethutil.Bytes2Hex(tx.Hash())
 	receiver := ethutil.Bytes2Hex(tx.Recipient)
 	if receiver == "0000000000000000000000000000000000000000" {
-		receiver = ethutil.Bytes2Hex(tx.CreationAddress())
+		receiver = ethutil.Bytes2Hex(tx.CreationAddress(state))
 	}
 	sender := ethutil.Bytes2Hex(tx.Sender())
 	createsContract := tx.CreatesContract()

ethpipe/pipe.go

@@ -143,9 +143,10 @@ func (self *Pipe) Transact(key *ethcrypto.KeyPair, rec []byte, value, gas, price
 	self.obj.TxPool().QueueTransaction(tx)
 
 	if contractCreation {
-		logger.Infof("Contract addr %x", tx.CreationAddress())
+		addr := tx.CreationAddress(self.World().State())
+		logger.Infof("Contract addr %x\n", addr)
 
-		return tx.CreationAddress(), nil
+		return addr, nil
 	}
 
 	return tx.Hash(), nil
@@ -154,8 +155,9 @@ func (self *Pipe) Transact(key *ethcrypto.KeyPair, rec []byte, value, gas, price
 func (self *Pipe) PushTx(tx *ethchain.Transaction) ([]byte, error) {
 	self.obj.TxPool().QueueTransaction(tx)
 	if tx.Recipient == nil {
-		logger.Infof("Contract addr %x", tx.CreationAddress())
+		addr := tx.CreationAddress(self.World().State())
-		return tx.CreationAddress(), nil
+		logger.Infof("Contract addr %x\n", addr)
+		return addr, nil
 	}
 	return tx.Hash(), nil
 }

ethvm/vm.go

@@ -763,9 +763,9 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
 
 			// Generate a new address
 			addr := ethcrypto.CreateAddress(closure.Address(), closure.object.Nonce)
-			for i := uint64(0); self.env.State().GetStateObject(addr) != nil; i++ {
+			//for i := uint64(0); self.env.State().GetStateObject(addr) != nil; i++ {
-				ethcrypto.CreateAddress(closure.Address(), closure.object.Nonce+i)
+			//	ethcrypto.CreateAddress(closure.Address(), closure.object.Nonce+i)
-			}
+			//}
 			closure.object.Nonce++
 
 			self.Printf(" (*) %x", addr).Endl()