poanetwork
/
quorum
mirror of https://github.com/poanetwork/quorum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fixed inconsistencies

This commit is contained in:
obscuren 2014-10-02 17:03:15 +02:00
parent a34a971b50
commit 82be305496
7 changed files with 37 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
ethchain/state_manager.go
View File

@ -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)
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)
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:

4
ethchain/state_transition.go
View File

@ -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, ""))

11
ethchain/transaction.go
View File

@ -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 {
return ethcrypto.Sha3Bin(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce}).Encode())[12:]
func (tx *Transaction) CreationAddress(state *ethstate.State) []byte {
// 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 {

6
ethpipe/js_pipe.go
View File

@ -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 {

8
ethpipe/js_types.go
View File

@ -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()

10
ethpipe/pipe.go
View File

@ -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())
return tx.CreationAddress(), nil
addr := tx.CreationAddress(self.World().State())
logger.Infof("Contract addr %x\n", addr)
return addr, nil
}
return tx.Hash(), nil
}

6
ethvm/vm.go
View File

@ -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++ {
ethcrypto.CreateAddress(closure.Address(), closure.object.Nonce+i)
}
//for i := uint64(0); self.env.State().GetStateObject(addr) != nil; i++ {
// ethcrypto.CreateAddress(closure.Address(), closure.object.Nonce+i)
//}
closure.object.Nonce++
self.Printf(" (*) %x", addr).Endl()