Removed some of that gas pre pay magic

2 files changed, 33 insertions, 31 deletions

diff --git a/core/block_processor.go b/core/block_processor.go
index 395622a8e..9fe74ef0a 100644
--- a/core/block_processor.go
+++ b/core/block_processor.go
@@ -78,21 +78,20 @@ func (self *BlockProcessor) ApplyTransaction(coinbase *state.StateObject, stated
 	// If we are mining this block and validating we want to set the logs back to 0
 	statedb.EmptyLogs()
 
-	txGas := new(big.Int).Set(tx.Gas())
-
 	cb := statedb.GetStateObject(coinbase.Address())
-	st := NewStateTransition(NewEnv(statedb, self.bc, tx, block), tx, cb)
-	_, err := st.TransitionState()
+	/*
+		st := NewStateTransition(NewEnv(statedb, self.bc, tx, block), tx, cb)
+		_, err := st.TransitionState()
+	*/
+	_, gas, err := ApplyMessage(NewEnv(statedb, self.bc, tx, block), tx, cb)
 	if err != nil && (IsNonceErr(err) || state.IsGasLimitErr(err) || IsInvalidTxErr(err)) {
 		return nil, nil, err
 	}
 
-	txGas.Sub(txGas, st.gas)
-
 	// Update the state with pending changes
-	statedb.Update(txGas)
+	statedb.Update(nil)
 
-	cumulative := new(big.Int).Set(usedGas.Add(usedGas, txGas))
+	cumulative := new(big.Int).Set(usedGas.Add(usedGas, gas))
 	receipt := types.NewReceipt(statedb.Root(), cumulative)
 	receipt.SetLogs(statedb.Logs())
 	receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
@@ -105,7 +104,7 @@ func (self *BlockProcessor) ApplyTransaction(coinbase *state.StateObject, stated
 		go self.eventMux.Post(logs)
 	}
 
-	return receipt, txGas, err
+	return receipt, gas, err
 }
 func (self *BlockProcessor) ChainManager() *ChainManager {
 	return self.bc
diff --git a/core/state_transition.go b/core/state_transition.go
index 7659e3d50..ee99ec7aa 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -69,6 +69,10 @@ func MessageGasValue(msg Message) *big.Int {
 	return new(big.Int).Mul(msg.Gas(), msg.GasPrice())
 }
 
+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, coinbase *state.StateObject) *StateTransition {
 	return &StateTransition{
 		coinbase:   coinbase.Address(),
@@ -150,7 +154,7 @@ func (self *StateTransition) preCheck() (err error) {
 	return nil
 }
 
-func (self *StateTransition) TransitionState() (ret []byte, err error) {
+func (self *StateTransition) transitionState() (ret []byte, usedGas *big.Int, err error) {
 	// statelogger.Debugf("(~) %x\n", self.msg.Hash())
 
 	// XXX Transactions after this point are considered valid.
@@ -163,11 +167,9 @@ func (self *StateTransition) TransitionState() (ret []byte, err error) {
 		sender = self.From()
 	)
 
-	defer self.RefundGas()
-
 	// Transaction gas
 	if err = self.UseGas(vm.GasTx); err != nil {
-		return nil, InvalidTxError(err)
+		return nil, nil, InvalidTxError(err)
 	}
 
 	// Increment the nonce for the next transaction
@@ -184,15 +186,13 @@ func (self *StateTransition) TransitionState() (ret []byte, err error) {
 		}
 	}
 	if err = self.UseGas(big.NewInt(dgas)); err != nil {
-		println("2")
-		return nil, InvalidTxError(err)
+		return nil, nil, InvalidTxError(err)
 	}
 
-	//stateCopy := self.env.State().Copy()
 	vmenv := self.env
 	var ref vm.ContextRef
 	if MessageCreatesContract(msg) {
-		contract := MakeContract(msg, self.state)
+		contract := makeContract(msg, self.state)
 		ret, err, ref = vmenv.Create(sender, contract.Address(), self.msg.Data(), self.gas, self.gasPrice, self.value)
 		if err == nil {
 			dataGas := big.NewInt(int64(len(ret)))
@@ -208,29 +208,22 @@ func (self *StateTransition) TransitionState() (ret []byte, err error) {
 	}
 
 	if err != nil && IsValueTransferErr(err) {
-		return nil, InvalidTxError(err)
+		return nil, nil, InvalidTxError(err)
 	}
 
-	return
-}
-
-// Converts an transaction in to a state object
-func MakeContract(msg Message, state *state.StateDB) *state.StateObject {
-	addr := AddressFromMessage(msg)
-
-	contract := state.GetOrNewStateObject(addr)
-	contract.SetInitCode(msg.Data())
+	self.refundGas()
+	self.state.AddBalance(self.coinbase, new(big.Int).Mul(self.gasUsed(), self.gasPrice))
 
-	return contract
+	return ret, self.gasUsed(), err
 }
 
-func (self *StateTransition) RefundGas() {
+func (self *StateTransition) refundGas() {
 	coinbase, sender := self.Coinbase(), self.From()
 	// Return remaining gas
 	remaining := new(big.Int).Mul(self.gas, self.msg.GasPrice())
 	sender.AddBalance(remaining)
 
-	uhalf := new(big.Int).Div(self.GasUsed(), ethutil.Big2)
+	uhalf := new(big.Int).Div(self.gasUsed(), ethutil.Big2)
 	for addr, ref := range self.state.Refunds() {
 		refund := ethutil.BigMin(uhalf, ref)
 		self.gas.Add(self.gas, refund)
@@ -240,6 +233,16 @@ func (self *StateTransition) RefundGas() {
 	coinbase.RefundGas(self.gas, self.msg.GasPrice())
 }
 
-func (self *StateTransition) GasUsed() *big.Int {
+func (self *StateTransition) gasUsed() *big.Int {
 	return new(big.Int).Sub(self.initialGas, self.gas)
 }
+
+// Converts an message in to a state object
+func makeContract(msg Message, state *state.StateDB) *state.StateObject {
+	addr := AddressFromMessage(msg)
+
+	contract := state.GetOrNewStateObject(addr)
+	contract.SetInitCode(msg.Data())
+
+	return contract
+}