Merge branch 'develop'

cmd/geth/main.go

@@ -50,11 +50,11 @@ import (
 
 const (
 	ClientIdentifier = "Geth"
-	Version          = "1.0.3"
+	Version          = "1.0.1"
 )
 
 var (
-	gitCommit       string // set via linker flag
+	gitCommit       string // set via linker flagg
 	nodeNameVersion string
 	app             *cli.App
 )

core/block_processor.go

@@ -57,18 +57,6 @@ type BlockProcessor struct {
 	eventMux *event.TypeMux
 }
 
-// TODO: type GasPool big.Int
-//
-// GasPool is implemented by state.StateObject. This is a historical
-// coincidence. Gas tracking should move out of StateObject.
-
-// GasPool tracks the amount of gas available during
-// execution of the transactions in a block.
-type GasPool interface {
-	AddGas(gas, price *big.Int)
-	SubGas(gas, price *big.Int) error
-}
-
 func NewBlockProcessor(db, extra common.Database, pow pow.PoW, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor {
 	sm := &BlockProcessor{
 		db:       db,
@@ -78,15 +66,16 @@ func NewBlockProcessor(db, extra common.Database, pow pow.PoW, chainManager *Cha
 		bc:       chainManager,
 		eventMux: eventMux,
 	}
+
 	return sm
 }
 
 func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block *types.Block, transientProcess bool) (receipts types.Receipts, err error) {
-	gp := statedb.GetOrNewStateObject(block.Coinbase())
-	gp.SetGasLimit(block.GasLimit())
+	coinbase := statedb.GetOrNewStateObject(block.Coinbase())
+	coinbase.SetGasLimit(block.GasLimit())
 
 	// Process the transactions on to parent state
-	receipts, err = sm.ApplyTransactions(gp, statedb, block, block.Transactions(), transientProcess)
+	receipts, err = sm.ApplyTransactions(coinbase, statedb, block, block.Transactions(), transientProcess)
 	if err != nil {
 		return nil, err
 	}
@@ -94,8 +83,11 @@ func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block
 	return receipts, nil
 }
 
-func (self *BlockProcessor) ApplyTransaction(gp GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, transientProcess bool) (*types.Receipt, *big.Int, error) {
-	_, gas, err := ApplyMessage(NewEnv(statedb, self.bc, tx, header), tx, gp)
+func (self *BlockProcessor) ApplyTransaction(coinbase *state.StateObject, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, transientProcess bool) (*types.Receipt, *big.Int, error) {
+	// If we are mining this block and validating we want to set the logs back to 0
+
+	cb := statedb.GetStateObject(coinbase.Address())
+	_, gas, err := ApplyMessage(NewEnv(statedb, self.bc, tx, header), tx, cb)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -130,7 +122,7 @@ func (self *BlockProcessor) ChainManager() *ChainManager {
 	return self.bc
 }
 
-func (self *BlockProcessor) ApplyTransactions(gp GasPool, statedb *state.StateDB, block *types.Block, txs types.Transactions, transientProcess bool) (types.Receipts, error) {
+func (self *BlockProcessor) ApplyTransactions(coinbase *state.StateObject, statedb *state.StateDB, block *types.Block, txs types.Transactions, transientProcess bool) (types.Receipts, error) {
 	var (
 		receipts      types.Receipts
 		totalUsedGas  = big.NewInt(0)
@@ -142,7 +134,7 @@ func (self *BlockProcessor) ApplyTransactions(gp GasPool, statedb *state.StateDB
 	for i, tx := range txs {
 		statedb.StartRecord(tx.Hash(), block.Hash(), i)
 
-		receipt, txGas, err := self.ApplyTransaction(gp, statedb, header, tx, totalUsedGas, transientProcess)
+		receipt, txGas, err := self.ApplyTransaction(coinbase, statedb, header, tx, totalUsedGas, transientProcess)
 		if err != nil {
 			return nil, err
 		}

core/blocks.go

@@ -20,5 +20,8 @@ import "github.com/ethereum/go-ethereum/common"
 
 // Set of manually tracked bad hashes (usually hard forks)
 var BadHashes = map[common.Hash]bool{
-	common.HexToHash("05bef30ef572270f654746da22639a7a0c97dd97a7050b9e252391996aaeb689"): true,
+	common.HexToHash("f269c503aed286caaa0d114d6a5320e70abbc2febe37953207e76a2873f2ba79"): true,
+	common.HexToHash("38f5bbbffd74804820ffa4bab0cd540e9de229725afb98c1a7e57936f4a714bc"): true,
+	common.HexToHash("7064455b364775a16afbdecd75370e912c6e2879f202eda85b9beae547fff3ac"): true,
+	common.HexToHash("5b7c80070a6eff35f3eb3181edb023465c776d40af2885571e1bc4689f3a44d8"): true,
 }

core/canary.go

@@ -24,10 +24,10 @@ import (
 )
 
 var (
-	jeff      = common.HexToAddress("959c33de5961820567930eccce51ea715c496f85")
-	vitalik   = common.HexToAddress("c8158da0b567a8cc898991c2c2a073af67dc03a9")
-	christoph = common.HexToAddress("7a19a893f91d5b6e2cdf941b6acbba2cbcf431ee")
-	gav       = common.HexToAddress("539dd9aaf45c3feb03f9c004f4098bd3268fef6b")
+	jeff      = common.HexToAddress("a8edb1ac2c86d3d9d78f96cd18001f60df29e52c")
+	vitalik   = common.HexToAddress("1baf27b88c48dd02b744999cf3522766929d2b2a")
+	christoph = common.HexToAddress("60d11b58744784dc97f878f7e3749c0f1381a004")
+	gav       = common.HexToAddress("4bb7e8ae99b645c2b7860b8f3a2328aae28bd80a")
 )
 
 // Canary will check the 0'd address of the 4 contracts above.

core/state/state_object.go

@@ -82,9 +82,8 @@ type StateObject struct {
 	// Mark for deletion
 	// When an object is marked for deletion it will be delete from the trie
 	// during the "update" phase of the state transition
-	remove  bool
-	deleted bool
-	dirty   bool
+	remove bool
+	dirty  bool
 }
 
 func (self *StateObject) Reset() {

core/state/statedb.go

@@ -203,20 +203,18 @@ func (self *StateDB) UpdateStateObject(stateObject *StateObject) {
 
 // Delete the given state object and delete it from the state trie
 func (self *StateDB) DeleteStateObject(stateObject *StateObject) {
-	stateObject.deleted = true
-
 	addr := stateObject.Address()
 	self.trie.Delete(addr[:])
+
+	//delete(self.stateObjects, addr.Str())
 }
 
 // Retrieve a state object given my the address. Nil if not found
-func (self *StateDB) GetStateObject(addr common.Address) (stateObject *StateObject) {
-	stateObject = self.stateObjects[addr.Str()]
-	if stateObject != nil {
-		if stateObject.deleted {
-			stateObject = nil
-		}
+func (self *StateDB) GetStateObject(addr common.Address) *StateObject {
+	//addr = common.Address(addr)
 
+	stateObject := self.stateObjects[addr.Str()]
+	if stateObject != nil {
 		return stateObject
 	}
 
@@ -238,7 +236,7 @@ func (self *StateDB) SetStateObject(object *StateObject) {
 // Retrieve a state object or create a new state object if nil
 func (self *StateDB) GetOrNewStateObject(addr common.Address) *StateObject {
 	stateObject := self.GetStateObject(addr)
-	if stateObject == nil || stateObject.deleted {
+	if stateObject == nil {
 		stateObject = self.CreateAccount(addr)
 	}
 

core/state_transition.go

@@ -45,7 +45,7 @@ import (
  * 6) Derive new state root
  */
 type StateTransition struct {
-	gp            GasPool
+	coinbase      common.Address
 	msg           Message
 	gas, gasPrice *big.Int
 	initialGas    *big.Int
@@ -53,6 +53,8 @@ type StateTransition struct {
 	data          []byte
 	state         *state.StateDB
 
+	cb, rec, sen *state.StateObject
+
 	env vm.Environment
 }
 
@@ -94,13 +96,13 @@ func IntrinsicGas(data []byte) *big.Int {
 	return igas
 }
 
-func ApplyMessage(env vm.Environment, msg Message, gp GasPool) ([]byte, *big.Int, error) {
-	return NewStateTransition(env, msg, gp).transitionState()
+func ApplyMessage(env vm.Environment, msg Message, coinbase *state.StateObject) ([]byte, *big.Int, error) {
+	return NewStateTransition(env, msg, coinbase).transitionState()
 }
 
-func NewStateTransition(env vm.Environment, msg Message, gp GasPool) *StateTransition {
+func NewStateTransition(env vm.Environment, msg Message, coinbase *state.StateObject) *StateTransition {
 	return &StateTransition{
-		gp:         gp,
+		coinbase:   coinbase.Address(),
 		env:        env,
 		msg:        msg,
 		gas:        new(big.Int),
@@ -109,9 +111,13 @@ func NewStateTransition(env vm.Environment, msg Message, gp GasPool) *StateTrans
 		value:      msg.Value(),
 		data:       msg.Data(),
 		state:      env.State(),
+		cb:         coinbase,
 	}
 }
 
+func (self *StateTransition) Coinbase() *state.StateObject {
+	return self.state.GetOrNewStateObject(self.coinbase)
+}
 func (self *StateTransition) From() (*state.StateObject, error) {
 	f, err := self.msg.From()
 	if err != nil {
@@ -154,7 +160,7 @@ func (self *StateTransition) BuyGas() error {
 	if sender.Balance().Cmp(mgval) < 0 {
 		return fmt.Errorf("insufficient ETH for gas (%x). Req %v, has %v", sender.Address().Bytes()[:4], mgval, sender.Balance())
 	}
-	if err = self.gp.SubGas(mgas, self.gasPrice); err != nil {
+	if err = self.Coinbase().SubGas(mgas, self.gasPrice); err != nil {
 		return err
 	}
 	self.AddGas(mgas)
@@ -235,12 +241,13 @@ func (self *StateTransition) transitionState() (ret []byte, usedGas *big.Int, er
 	}
 
 	self.refundGas()
-	self.state.AddBalance(self.env.Coinbase(), new(big.Int).Mul(self.gasUsed(), self.gasPrice))
+	self.state.AddBalance(self.coinbase, new(big.Int).Mul(self.gasUsed(), self.gasPrice))
 
 	return ret, self.gasUsed(), err
 }
 
 func (self *StateTransition) refundGas() {
+	coinbase := self.Coinbase()
 	sender, _ := self.From() // err already checked
 	// Return remaining gas
 	remaining := new(big.Int).Mul(self.gas, self.gasPrice)
@@ -251,7 +258,7 @@ func (self *StateTransition) refundGas() {
 	self.gas.Add(self.gas, refund)
 	self.state.AddBalance(sender.Address(), refund.Mul(refund, self.gasPrice))
 
-	self.gp.AddGas(self.gas, self.gasPrice)
+	coinbase.AddGas(self.gas, self.gasPrice)
 }
 
 func (self *StateTransition) gasUsed() *big.Int {

tests/block_test_util.go

@@ -150,7 +150,7 @@ func runBlockTests(bt map[string]*BlockTest, skipTests []string) error {
 
 		// test the block
 		if err := runBlockTest(test); err != nil {
-			return fmt.Errorf("%s: %v", name, err)
+			return err
 		}
 		glog.Infoln("Block test passed: ", name)
 

xeth/xeth.go

@@ -20,10 +20,8 @@ package xeth
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"math/big"
-	"regexp"
 	"sync"
 	"time"
 
@@ -47,7 +45,6 @@ var (
 	defaultGasPrice  = big.NewInt(10000000000000) //150000000000
 	defaultGas       = big.NewInt(90000)          //500000
 	dappStorePre     = []byte("dapp-")
-	addrReg          = regexp.MustCompile(`^(0x)?[a-fA-F0-9]{40}$`)
 )
 
 // byte will be inferred
@@ -881,10 +878,6 @@ func (self *XEth) Sign(fromStr, hashStr string, didUnlock bool) (string, error)
 	return common.ToHex(sig), nil
 }
 
-func isAddress(addr string) bool {
-	return addrReg.MatchString(addr)
-}
-
 func (self *XEth) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
 
 	// this minimalistic recoding is enough (works for natspec.js)
@@ -894,10 +887,6 @@ func (self *XEth) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceS
 		return "", err
 	}
 
-	if len(toStr) > 0 && toStr != "0x" && !isAddress(toStr) {
-		return "", errors.New("Invalid address")
-	}
-
 	var (
 		from             = common.HexToAddress(fromStr)
 		to               = common.HexToAddress(toStr)

xeth/xeth_test.go

@@ -1,26 +0,0 @@
-package xeth
-
-import "testing"
-
-func TestIsAddress(t *testing.T) {
-	for _, invalid := range []string{
-		"0x00",
-		"0xNN",
-		"0x00000000000000000000000000000000000000NN",
-		"0xAAar000000000000000000000000000000000000",
-	} {
-		if isAddress(invalid) {
-			t.Error("Expected", invalid, "to be invalid")
-		}
-	}
-
-	for _, valid := range []string{
-		"0x0000000000000000000000000000000000000000",
-		"0xAABBbbCCccff9900000000000000000000000000",
-		"AABBbbCCccff9900000000000000000000000000",
-	} {
-		if !isAddress(valid) {
-			t.Error("Expected", valid, "to be valid")
-		}
-	}
-}