diff --git a/ethereal/assets/qml/newTransaction/_new_contract.qml b/ethereal/assets/qml/newTransaction/_new_contract.qml
index 0794d3dcd..f6ed77fb6 100644
--- a/ethereal/assets/qml/newTransaction/_new_contract.qml
+++ b/ethereal/assets/qml/newTransaction/_new_contract.qml
@@ -150,7 +150,7 @@ Component {
 			text: "Send"
 			onClicked: {
 				//this.enabled = false
-				var res = eth.createTx(txFuelRecipient.text, txValue.text, txGas.text, txGasPrice.text, codeView.text)
+				var res = eth.create(txFuelRecipient.text, txValue.text, txGas.text, txGasPrice.text, codeView.text)
 				if(res[1]) {
 					txResult.text = "Your contract <b>could not</b> be send over the network:\n<b>"
 					txResult.text += res[1].error()
diff --git a/ethereal/assets/qml/newTransaction/_simple_send.qml b/ethereal/assets/qml/newTransaction/_simple_send.qml
index d460797ea..12420c15a 100644
--- a/ethereal/assets/qml/newTransaction/_simple_send.qml
+++ b/ethereal/assets/qml/newTransaction/_simple_send.qml
@@ -77,12 +77,12 @@ Component {
 			text: "Send"
 			onClicked: {
 				//this.enabled = false
-				var res = eth.createTx(txSimpleRecipient.text, txSimpleValue.text,"","","")
+				var res = eth.transact(txSimpleRecipient.text, txSimpleValue.text,"","","")
 				if(res[1]) {
 					txSimpleResult.text = "There has been an error broadcasting your transaction:" + res[1].error()
 				} else {
 					txSimpleResult.text = "Your transaction has been broadcasted over the network.\nYour transaction id is:"
-					txSimpleOutput.text = res[0]
+					txSimpleOutput.text = res[0].hash
 					this.visible = false
 					simpleSendColumn.state = "DONE"
 				}
diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go
index 522c081a3..39da5f246 100644
--- a/ethereal/ui/gui.go
+++ b/ethereal/ui/gui.go
@@ -28,6 +28,8 @@ type Gui struct {
 	txDb *ethdb.LDBDatabase
 
 	addr []byte
+
+	pub *ethpub.PEthereum
 }
 
 // Create GUI, but doesn't start it
@@ -46,14 +48,16 @@ func New(ethereum *eth.Ethereum) *Gui {
 		key := ethutil.Config.Db.GetKeys()[0]
 		addr = key.Address()
 
-		ethereum.StateManager().WatchAddr(addr)
+		//ethereum.StateManager().WatchAddr(addr)
 	}
 
-	return &Gui{eth: ethereum, lib: lib, txDb: db, addr: addr}
+	pub := ethpub.NewPEthereum(ethereum.StateManager(), ethereum.BlockChain(), ethereum.TxPool())
+
+	return &Gui{eth: ethereum, lib: lib, txDb: db, addr: addr, pub: pub}
 }
 
-func (ui *Gui) Start(assetPath string) {
-	defer ui.txDb.Close()
+func (gui *Gui) Start(assetPath string) {
+	defer gui.txDb.Close()
 
 	// Register ethereum functions
 	qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{
@@ -65,12 +69,12 @@ func (ui *Gui) Start(assetPath string) {
 	ethutil.Config.SetClientString(fmt.Sprintf("/Ethereal v%s", "0.2"))
 	ethutil.Config.Log.Infoln("[GUI] Starting GUI")
 	// Create a new QML engine
-	ui.engine = qml.NewEngine()
-	context := ui.engine.Context()
+	gui.engine = qml.NewEngine()
+	context := gui.engine.Context()
 
 	// Expose the eth library and the ui library to QML
-	context.SetVar("eth", ui.lib)
-	uiLib := NewUiLib(ui.engine, ui.eth, assetPath)
+	context.SetVar("eth", gui)
+	uiLib := NewUiLib(gui.engine, gui.eth, assetPath)
 	context.SetVar("ui", uiLib)
 
 	// Load the main QML interface
@@ -80,9 +84,9 @@ func (ui *Gui) Start(assetPath string) {
 	firstRun := len(data) == 0
 
 	if firstRun {
-		component, err = ui.engine.LoadFile(uiLib.AssetPath("qml/first_run.qml"))
+		component, err = gui.engine.LoadFile(uiLib.AssetPath("qml/first_run.qml"))
 	} else {
-		component, err = ui.engine.LoadFile(uiLib.AssetPath("qml/wallet.qml"))
+		component, err = gui.engine.LoadFile(uiLib.AssetPath("qml/wallet.qml"))
 	}
 	if err != nil {
 		ethutil.Config.Log.Infoln("FATAL: asset not found: you can set an alternative asset path on on the command line using option 'asset_path'")
@@ -90,65 +94,60 @@ func (ui *Gui) Start(assetPath string) {
 		panic(err)
 	}
 
-	ui.win = component.CreateWindow(nil)
-	uiLib.win = ui.win
-	db := &Debugger{ui.win, make(chan bool)}
-	ui.lib.Db = db
+	gui.win = component.CreateWindow(nil)
+	uiLib.win = gui.win
+	db := &Debugger{gui.win, make(chan bool)}
+	gui.lib.Db = db
 	uiLib.Db = db
 
-	// Register the ui as a block processor
-	//ui.eth.BlockManager.SecondaryBlockProcessor = ui
-	//ui.eth.TxPool.SecondaryProcessor = ui
-
 	// Add the ui as a log system so we can log directly to the UGI
-	ethutil.Config.Log.AddLogSystem(ui)
+	ethutil.Config.Log.AddLogSystem(gui)
 
 	// Loads previous blocks
 	if firstRun == false {
-		go ui.setInitialBlockChain()
-		go ui.readPreviousTransactions()
-		go ui.update()
+		go gui.setInitialBlockChain()
+		go gui.readPreviousTransactions()
+		go gui.update()
 	}
 
-	ui.win.Show()
-	ui.win.Wait()
+	gui.win.Show()
+	gui.win.Wait()
 
-	ui.eth.Stop()
+	gui.eth.Stop()
 }
 
-func (ui *Gui) setInitialBlockChain() {
+func (gui *Gui) setInitialBlockChain() {
 	// Load previous 10 blocks
-	chain := ui.eth.BlockChain().GetChain(ui.eth.BlockChain().CurrentBlock.Hash(), 10)
+	chain := gui.eth.BlockChain().GetChain(gui.eth.BlockChain().CurrentBlock.Hash(), 10)
 	for _, block := range chain {
-		ui.ProcessBlock(block)
+		gui.processBlock(block)
 	}
 
 }
 
-func (ui *Gui) readPreviousTransactions() {
-	it := ui.txDb.Db().NewIterator(nil, nil)
+func (gui *Gui) readPreviousTransactions() {
+	it := gui.txDb.Db().NewIterator(nil, nil)
 	for it.Next() {
 		tx := ethchain.NewTransactionFromBytes(it.Value())
 
-		ui.win.Root().Call("addTx", ethpub.NewPTx(tx))
+		gui.win.Root().Call("addTx", ethpub.NewPTx(tx))
 	}
 	it.Release()
 }
 
-func (ui *Gui) ProcessBlock(block *ethchain.Block) {
-	ui.win.Root().Call("addBlock", ethpub.NewPBlock(block))
+func (gui *Gui) processBlock(block *ethchain.Block) {
+	gui.win.Root().Call("addBlock", ethpub.NewPBlock(block))
 }
 
 // Simple go routine function that updates the list of peers in the GUI
-func (ui *Gui) update() {
+func (gui *Gui) update() {
 	txChan := make(chan ethchain.TxMsg, 1)
-	ui.eth.TxPool().Subscribe(txChan)
+	gui.eth.TxPool().Subscribe(txChan)
 
-	account := ui.eth.StateManager().GetAddrState(ui.addr).Object
-	unconfirmedFunds := new(big.Int)
-	ui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(account.Amount)))
+	state := gui.eth.StateManager().TransState()
 
-	addrState := ui.eth.StateManager().GetAddrState(ui.addr)
+	unconfirmedFunds := new(big.Int)
+	gui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(state.GetStateObject(gui.addr).Amount)))
 
 	for {
 		select {
@@ -156,15 +155,19 @@ func (ui *Gui) update() {
 			tx := txMsg.Tx
 
 			if txMsg.Type == ethchain.TxPre {
-				if bytes.Compare(tx.Sender(), ui.addr) == 0 && addrState.Nonce <= tx.Nonce {
-					ui.win.Root().Call("addTx", ethpub.NewPTx(tx))
-					ui.txDb.Put(tx.Hash(), tx.RlpEncode())
+				object := state.GetStateObject(gui.addr)
+
+				if bytes.Compare(tx.Sender(), gui.addr) == 0 && object.Nonce <= tx.Nonce {
+					gui.win.Root().Call("addTx", ethpub.NewPTx(tx))
+					gui.txDb.Put(tx.Hash(), tx.RlpEncode())
+
+					object.Nonce += 1
+					state.SetStateObject(object)
 
-					addrState.Nonce += 1
 					unconfirmedFunds.Sub(unconfirmedFunds, tx.Value)
-				} else if bytes.Compare(tx.Recipient, ui.addr) == 0 {
-					ui.win.Root().Call("addTx", ethpub.NewPTx(tx))
-					ui.txDb.Put(tx.Hash(), tx.RlpEncode())
+				} else if bytes.Compare(tx.Recipient, gui.addr) == 0 {
+					gui.win.Root().Call("addTx", ethpub.NewPTx(tx))
+					gui.txDb.Put(tx.Hash(), tx.RlpEncode())
 
 					unconfirmedFunds.Add(unconfirmedFunds, tx.Value)
 				}
@@ -174,46 +177,48 @@ func (ui *Gui) update() {
 					pos = "-"
 				}
 				val := ethutil.CurrencyToString(new(big.Int).Abs(ethutil.BigCopy(unconfirmedFunds)))
-				str := fmt.Sprintf("%v (%s %v)", ethutil.CurrencyToString(account.Amount), pos, val)
+				str := fmt.Sprintf("%v (%s %v)", ethutil.CurrencyToString(object.Amount), pos, val)
 
-				ui.win.Root().Call("setWalletValue", str)
+				gui.win.Root().Call("setWalletValue", str)
 			} else {
-				amount := account.Amount
-				if bytes.Compare(tx.Sender(), ui.addr) == 0 {
-					amount.Sub(account.Amount, tx.Value)
-				} else if bytes.Compare(tx.Recipient, ui.addr) == 0 {
-					amount.Add(account.Amount, tx.Value)
+				object := state.GetStateObject(gui.addr)
+				if bytes.Compare(tx.Sender(), gui.addr) == 0 {
+					object.SubAmount(tx.Value)
+				} else if bytes.Compare(tx.Recipient, gui.addr) == 0 {
+					object.AddAmount(tx.Value)
 				}
 
-				ui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(amount)))
+				gui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(object.Amount)))
+
+				state.SetStateObject(object)
 			}
 		}
-
-		/*
-			accountAmount := ui.eth.BlockManager.GetAddrState(ui.addr).Account.Amount
-			ui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", accountAmount))
-
-			ui.win.Root().Call("setPeers", fmt.Sprintf("%d / %d", ui.eth.Peers().Len(), ui.eth.MaxPeers))
-
-			time.Sleep(1 * time.Second)
-		*/
-
 	}
 }
 
 // Logging functions that log directly to the GUI interface
-func (ui *Gui) Println(v ...interface{}) {
+func (gui *Gui) Println(v ...interface{}) {
 	str := strings.TrimRight(fmt.Sprintln(v...), "\n")
 	lines := strings.Split(str, "\n")
 	for _, line := range lines {
-		ui.win.Root().Call("addLog", line)
+		gui.win.Root().Call("addLog", line)
 	}
 }
 
-func (ui *Gui) Printf(format string, v ...interface{}) {
+func (gui *Gui) Printf(format string, v ...interface{}) {
 	str := strings.TrimRight(fmt.Sprintf(format, v...), "\n")
 	lines := strings.Split(str, "\n")
 	for _, line := range lines {
-		ui.win.Root().Call("addLog", line)
+		gui.win.Root().Call("addLog", line)
 	}
 }
+
+func (gui *Gui) Transact(recipient, value, gas, gasPrice, data string) (*ethpub.PReceipt, error) {
+	keyPair := ethutil.Config.Db.GetKeys()[0]
+
+	return gui.pub.Transact(ethutil.Hex(keyPair.PrivateKey), recipient, value, gas, gasPrice, data)
+}
+
+func (gui *Gui) Create(recipient, value, gas, gasPrice, data string) (*ethpub.PReceipt, error) {
+	return gui.Transact(recipient, value, gas, gasPrice, data)
+}
diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go
index 1328cd6b7..c889efb45 100644
--- a/ethereal/ui/library.go
+++ b/ethereal/ui/library.go
@@ -1,10 +1,8 @@
 package ethui
 
 import (
-	"encoding/hex"
 	"fmt"
 	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethpub"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/go-ethereum/utils"
 	"github.com/obscuren/secp256k1-go"
@@ -43,86 +41,3 @@ func (lib *EthLib) CreateAndSetPrivKey() (string, string, string, string) {
 	mnemonicString := strings.Join(mne, " ")
 	return mnemonicString, fmt.Sprintf("%x", pair.Address()), fmt.Sprintf("%x", prv), fmt.Sprintf("%x", pub)
 }
-
-func (lib *EthLib) GetKey() string {
-	return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address())
-}
-
-func (lib *EthLib) GetStateObject(address string) *ethpub.PStateObject {
-	stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address))
-	if stateObject != nil {
-		return ethpub.NewPStateObject(stateObject)
-	}
-
-	// See GetStorage for explanation on "nil"
-	return ethpub.NewPStateObject(nil)
-}
-
-func (lib *EthLib) Watch(addr, storageAddr string) {
-	//	lib.stateManager.Watch(ethutil.FromHex(addr), ethutil.FromHex(storageAddr))
-}
-
-func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
-	return lib.Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr)
-}
-
-func (lib *EthLib) Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
-	var hash []byte
-	var contractCreation bool
-	if len(recipient) == 0 {
-		contractCreation = true
-	} else {
-		var err error
-		hash, err = hex.DecodeString(recipient)
-		if err != nil {
-			return "", err
-		}
-	}
-
-	keyPair := ethutil.Config.Db.GetKeys()[0]
-	value := ethutil.Big(valueStr)
-	gas := ethutil.Big(gasStr)
-	gasPrice := ethutil.Big(gasPriceStr)
-	var tx *ethchain.Transaction
-	// Compile and assemble the given data
-	if contractCreation {
-		// Compile script
-		mainScript, initScript, err := utils.CompileScript(dataStr)
-		if err != nil {
-			return "", err
-		}
-
-		tx = ethchain.NewContractCreationTx(value, gas, gasPrice, mainScript, initScript)
-	} else {
-		lines := strings.Split(dataStr, "\n")
-		var data []byte
-		for _, line := range lines {
-			data = append(data, ethutil.BigToBytes(ethutil.Big(line), 256)...)
-		}
-
-		tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, data)
-	}
-	acc := lib.stateManager.GetAddrState(keyPair.Address())
-	tx.Nonce = acc.Nonce
-	tx.Sign(keyPair.PrivateKey)
-	lib.txPool.QueueTransaction(tx)
-
-	if contractCreation {
-		ethutil.Config.Log.Infof("Contract addr %x", tx.Hash()[12:])
-	} else {
-		ethutil.Config.Log.Infof("Tx hash %x", tx.Hash())
-	}
-
-	return ethutil.Hex(tx.Hash()), nil
-}
-
-func (lib *EthLib) GetBlock(hexHash string) *ethpub.PBlock {
-	hash, err := hex.DecodeString(hexHash)
-	if err != nil {
-		return nil
-	}
-
-	block := lib.blockChain.GetBlock(hash)
-
-	return &ethpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())}
-}
diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go
index 855ed4af3..0e7992b4a 100644
--- a/ethereal/ui/ui_lib.go
+++ b/ethereal/ui/ui_lib.go
@@ -149,7 +149,7 @@ func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string)
 
 	// Contract addr as test address
 	keyPair := ethutil.Config.Db.GetKeys()[0]
-	account := ui.eth.StateManager().GetAddrState(keyPair.Address()).Object
+	account := ui.eth.StateManager().TransState().GetStateObject(keyPair.Address())
 	c := ethchain.MakeContract(callerTx, state)
 	callerClosure := ethchain.NewClosure(account, c, c.Script(), state, ethutil.Big(gasStr), ethutil.Big(gasPriceStr))