From 4d987624867fc02a079d8355c28bad620db85f06 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Wed, 28 May 2014 23:16:54 +0200
Subject: [PATCH] Fixed state object gas return

---
 ethchain/closure.go |  8 ++++----
 ethchain/vm.go      | 12 +++++++++---
 ethpub/pub.go       | 13 ++++++++++++-
 ethutil/bytes.go    | 18 ++++++++++++++++++
 4 files changed, 43 insertions(+), 8 deletions(-)

diff --git a/ethchain/closure.go b/ethchain/closure.go
index 01fd5d794..5c9c3e47c 100644
--- a/ethchain/closure.go
+++ b/ethchain/closure.go
@@ -11,13 +11,13 @@ type ClosureRef interface {
 	ReturnGas(*big.Int, *big.Int, *State)
 	Address() []byte
 	GetMem(*big.Int) *ethutil.Value
-	SetStore(*big.Int, *ethutil.Value)
+	SetStorage(*big.Int, *ethutil.Value)
 	N() *big.Int
 }
 
 // Basic inline closure object which implement the 'closure' interface
 type Closure struct {
-	callee *StateObject
+	callee ClosureRef
 	object *StateObject
 	Script []byte
 	State  *State
@@ -28,7 +28,7 @@ type Closure struct {
 }
 
 // Create a new closure for the given data items
-func NewClosure(callee, object *StateObject, script []byte, state *State, gas, price *big.Int) *Closure {
+func NewClosure(callee ClosureRef, object *StateObject, script []byte, state *State, gas, price *big.Int) *Closure {
 	c := &Closure{callee: callee, object: object, Script: script, State: state, Args: nil}
 
 	// In most cases gas, price and value are pointers to transaction objects
@@ -118,7 +118,7 @@ func (c *Closure) Object() *StateObject {
 	return c.object
 }
 
-func (c *Closure) Callee() *StateObject {
+func (c *Closure) Callee() ClosureRef {
 	return c.callee
 }
 
diff --git a/ethchain/vm.go b/ethchain/vm.go
index 85136e435..9720d8be1 100644
--- a/ethchain/vm.go
+++ b/ethchain/vm.go
@@ -326,9 +326,15 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
 		case CALLDATALOAD:
 			require(1)
 			offset := stack.Pop().Int64()
-			val := closure.Args[offset : offset+32]
 
-			stack.Push(ethutil.BigD(val))
+			var data []byte
+			if len(closure.Args) >= int(offset+32) {
+				data = closure.Args[offset : offset+32]
+			} else {
+				data = []byte{0}
+			}
+
+			stack.Push(ethutil.BigD(data))
 		case CALLDATASIZE:
 			stack.Push(big.NewInt(int64(len(closure.Args))))
 		case GASPRICE:
@@ -498,7 +504,7 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
 				contract.AddAmount(value)
 
 				// Create a new callable closure
-				closure := NewClosure(closure.Object(), contract, contract.script, vm.state, gas, closure.Price)
+				closure := NewClosure(closure, contract, contract.script, vm.state, gas, closure.Price)
 				// Executer the closure and get the return value (if any)
 				ret, _, err := closure.Call(vm, args, hook)
 				if err != nil {
diff --git a/ethpub/pub.go b/ethpub/pub.go
index b75d3abc8..5a9401d0d 100644
--- a/ethpub/pub.go
+++ b/ethpub/pub.go
@@ -4,6 +4,7 @@ import (
 	"encoding/hex"
 	"github.com/ethereum/eth-go/ethchain"
 	"github.com/ethereum/eth-go/ethutil"
+	"strings"
 )
 
 type PEthereum struct {
@@ -161,7 +162,17 @@ func (lib *PEthereum) createTx(key, recipient, valueStr, gasStr, gasPriceStr, sc
 		if len(scriptStr) > 0 && scriptStr[0:2] == "0x" {
 			scriptStr = scriptStr[2:len(scriptStr)]
 		}
-		tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, ethutil.FromHex(scriptStr))
+
+		data := ethutil.StringToByteFunc(scriptStr, func(s string) (ret []byte) {
+			slice := strings.Split(s, "\n")
+			for _, dataItem := range slice {
+				d := ethutil.FormatData(dataItem)
+				ret = append(ret, d...)
+			}
+			return
+		})
+
+		tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, data)
 	}
 
 	acc := lib.stateManager.TransState().GetStateObject(keyPair.Address())
diff --git a/ethutil/bytes.go b/ethutil/bytes.go
index 1c7a43af8..bd0df68ec 100644
--- a/ethutil/bytes.go
+++ b/ethutil/bytes.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
+	"math/big"
 )
 
 // Number to bytes
@@ -98,3 +99,20 @@ func StringToByteFunc(str string, cb func(str string) []byte) (ret []byte) {
 
 	return
 }
+
+func FormatData(data string) []byte {
+	if len(data) == 0 {
+		return nil
+	}
+	// Simple stupid
+	d := new(big.Int)
+	if data[0:1] == "\"" && data[len(data)-1:] == "\"" {
+		d.SetBytes([]byte(data[1 : len(data)-1]))
+	} else if len(data) > 1 && data[:2] == "0x" {
+		d.SetBytes(FromHex(data[2:]))
+	} else {
+		d.SetString(data, 0)
+	}
+
+	return BigToBytes(d, 256)
+}