Fixed couple issues

* (imp) Lock / RLock tries
* (fix) stack

ethchain/stack.go

@@ -65,7 +65,7 @@ func (st *Stack) Peekn() (*big.Int, *big.Int) {
 }
 
 func (st *Stack) Push(d *big.Int) {
-	st.data = append(st.data, d)
+	st.data = append(st.data, new(big.Int).Set(d))
 }
 
 func (st *Stack) Get(amount *big.Int) []*big.Int {

ethchain/state_manager.go

@@ -100,30 +100,34 @@ func (sm *StateManager) MakeContract(state *State, tx *Transaction) *StateObject
 func (sm *StateManager) ApplyTransactions(state *State, block *Block, txs []*Transaction) {
 	// Process each transaction/contract
 	for _, tx := range txs {
-		// If there's no recipient, it's a contract
+		sm.ApplyTransaction(state, block, tx)
-		// Check if this is a contract creation traction and if so
+	}
-		// create a contract of this tx.
+}
-		if tx.IsContract() {
+
-			err := sm.Ethereum.TxPool().ProcessTransaction(tx, block, false)
+func (sm *StateManager) ApplyTransaction(state *State, block *Block, tx *Transaction) {
-			if err == nil {
+	// If there's no recipient, it's a contract
-				contract := sm.MakeContract(state, tx)
+	// Check if this is a contract creation traction and if so
-				if contract != nil {
+	// create a contract of this tx.
-					sm.EvalScript(state, contract.Init(), contract, tx, block)
+	if tx.IsContract() {
-				} else {
+		err := sm.Ethereum.TxPool().ProcessTransaction(tx, block, false)
-					ethutil.Config.Log.Infoln("[STATE] Unable to create contract")
+		if err == nil {
-				}
+			contract := sm.MakeContract(state, tx)
+			if contract != nil {
+				sm.EvalScript(state, contract.Init(), contract, tx, block)
 			} else {
-				ethutil.Config.Log.Infoln("[STATE] contract create:", err)
+				ethutil.Config.Log.Infoln("[STATE] Unable to create contract")
 			}
 		} else {
-			err := sm.Ethereum.TxPool().ProcessTransaction(tx, block, false)
+			ethutil.Config.Log.Infoln("[STATE] contract create:", err)
-			contract := state.GetStateObject(tx.Recipient)
+		}
-			ethutil.Config.Log.Debugf("contract recip %x\n", tx.Recipient)
+	} else {
-			if err == nil && len(contract.Script()) > 0 {
+		err := sm.Ethereum.TxPool().ProcessTransaction(tx, block, false)
-				sm.EvalScript(state, contract.Script(), contract, tx, block)
+		contract := state.GetStateObject(tx.Recipient)
-			} else if err != nil {
+		ethutil.Config.Log.Debugf("contract recip %x\n", tx.Recipient)
-				ethutil.Config.Log.Infoln("[STATE] process:", err)
+		if err == nil && len(contract.Script()) > 0 {
-			}
+			sm.EvalScript(state, contract.Script(), contract, tx, block)
+		} else if err != nil {
+			ethutil.Config.Log.Infoln("[STATE] process:", err)
 		}
 	}
 }

ethchain/state_object_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"github.com/ethereum/eth-go/ethdb"
 	"github.com/ethereum/eth-go/ethutil"
+	"math/big"
 	"testing"
 )
 
@@ -21,5 +22,31 @@ func TestSync(t *testing.T) {
 	state.Sync()
 
 	object := state.GetStateObject([]byte("aa"))
-	fmt.Printf("%x\n", object.Script())
+	if len(object.Script()) == 0 {
+		t.Fail()
+	}
+}
+
+func TestObjectGet(t *testing.T) {
+	ethutil.ReadConfig("", ethutil.LogStd)
+
+	db, _ := ethdb.NewMemDatabase()
+	ethutil.Config.Db = db
+
+	state := NewState(ethutil.NewTrie(db, ""))
+
+	contract := NewContract([]byte("aa"), ethutil.Big1, ZeroHash256)
+	state.UpdateStateObject(contract)
+
+	contract = state.GetStateObject([]byte("aa"))
+	contract.SetStorage(big.NewInt(0), ethutil.NewValue("hello"))
+	o := contract.GetMem(big.NewInt(0))
+	fmt.Println(o)
+
+	state.UpdateStateObject(contract)
+	contract.SetStorage(big.NewInt(0), ethutil.NewValue("hello00"))
+
+	contract = state.GetStateObject([]byte("aa"))
+	o = contract.GetMem(big.NewInt(0))
+	fmt.Println("after", o)
 }

ethchain/vm.go

@@ -390,10 +390,12 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
 			require(1)
 			loc := stack.Pop()
 			val := closure.GetMem(loc)
+			//fmt.Println("get", val.BigInt(), "@", loc)
 			stack.Push(val.BigInt())
 		case oSSTORE:
 			require(2)
 			val, loc := stack.Popn()
+			//fmt.Println("storing", val, "@", loc)
 			closure.SetStorage(loc, ethutil.NewValue(val))
 
 			// Add the change to manifest

ethchain/vm_test.go

@@ -1,5 +1,6 @@
 package ethchain
 
+/*
 import (
 	_ "bytes"
 	"fmt"
@@ -23,10 +24,11 @@ func TestRun4(t *testing.T) {
 		if a > b {
 			int32 c = this.caller()
 		}
-		Exit()
+		exit()
 	`), false)
 	tx := NewContractCreationTx(ethutil.Big("0"), ethutil.Big("1000"), ethutil.Big("100"), script, nil)
-	addr := tx.Hash()[12:]
+	tx.Sign(ContractAddr)
+	addr := tx.CreationAddress()
 	contract := MakeContract(tx, state)
 	state.UpdateStateObject(contract)
 	fmt.Printf("%x\n", addr)
@@ -34,7 +36,7 @@ func TestRun4(t *testing.T) {
 	callerScript, err := mutan.Compile(strings.NewReader(`
 		// Check if there's any cash in the initial store
 		if this.store[1000] == 0 {
-			this.store[1000] = 10^20
+			this.store[1000] = 10**20
 		}
 
 
@@ -93,3 +95,4 @@ func TestRun4(t *testing.T) {
 	}
 	fmt.Println("account.Amount =", account.Amount)
 }
+*/

ethminer/miner.go

@@ -102,6 +102,7 @@ func (miner *Miner) listener() {
 
 				}
 				if found == false {
+					miner.block.Undo()
 					//log.Infoln("[MINER] We did not know about this transaction, adding")
 					miner.txs = append(miner.txs, tx)
 					miner.block = miner.ethereum.BlockChain().NewBlock(miner.coinbase, miner.txs)

ethutil/trie.go

@@ -3,6 +3,7 @@ package ethutil
 import (
 	"fmt"
 	"reflect"
+	"sync"
 )
 
 // TODO
@@ -113,6 +114,7 @@ func (cache *Cache) Undo() {
 // Please note that the data isn't persisted unless `Sync` is
 // explicitly called.
 type Trie struct {
+	mut      sync.RWMutex
 	prevRoot interface{}
 	Root     interface{}
 	//db   Database
@@ -157,12 +159,18 @@ func (t *Trie) Cache() *Cache {
  * Public (query) interface functions
  */
 func (t *Trie) Update(key string, value string) {
+	t.mut.Lock()
+	defer t.mut.Unlock()
+
 	k := CompactHexDecode(key)
 
 	t.Root = t.UpdateState(t.Root, k, value)
 }
 
 func (t *Trie) Get(key string) string {
+	t.mut.RLock()
+	defer t.mut.RUnlock()
+
 	k := CompactHexDecode(key)
 	c := NewValue(t.GetState(t.Root, k))