From 6ad756ce3c2afd5a3286735fec6f136906779f6c Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Mon, 25 Jun 2018 13:42:15 -0400
Subject: [PATCH 01/27] add tcp port

---
 shyftRingWalletConn/app.go | 56 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 shyftRingWalletConn/app.go

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
new file mode 100644
index 0000000000..6394bd2bc3
--- /dev/null
+++ b/shyftRingWalletConn/app.go
@@ -0,0 +1,56 @@
+package main
+
+//@NOTE SHYFT main func for api, sets up router and spins up a server
+//to run server 'go run shyftBlockExplorerApi/*.go'
+import (
+"net"
+"fmt"
+"os"
+)
+
+const (
+	CONN_HOST = "localhost"
+	CONN_PORT = "3333"
+	CONN_TYPE = "tcp"
+)
+
+func main() {
+
+	l, err := net.Listen(CONN_TYPE, CONN_HOST+":"+CONN_PORT)
+	if err != nil {
+		fmt.Println("Error listening:", err.Error())
+		os.Exit(1)
+	}
+	defer l.Close()
+
+	for {
+		// Listen for an incoming connection.
+		conn, err := l.Accept()
+		if err != nil {
+			fmt.Println("Error accepting: ", err.Error())
+			os.Exit(1)
+		}
+		// Handle connections in a new goroutine.
+		go handleRequest(conn)
+	}
+}
+
+// Handles incoming requests.
+func handleRequest(conn net.Conn) {
+	// Make a buffer to hold incoming data.
+	buf := make([]byte, 1024)
+	// Read the incoming connection into the buffer.
+	msg, err := conn.Read(buf)
+
+	if err == nil {
+		fmt.Println("Message is ", string(buf[:msg]))
+		fmt.Println("Message is ", msg)
+	}
+	if err != nil {
+		fmt.Println("Error reading:", err.Error())
+	}
+	// Send a response back to person contacting us.
+	conn.Write([]byte("Message received."))
+	// Close the connection when you're done with it.
+	conn.Close()
+}

From 6d2dcc0f90f7ab6b96b238c1f78093dff27d1272 Mon Sep 17 00:00:00 2001
From: Dustin Brickwood <dustinbrickwood204@gmail.com>
Date: Mon, 25 Jun 2018 14:35:58 -0400
Subject: [PATCH 02/27] changed server command prompt

---
 shyftRingWalletConn/app.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 6394bd2bc3..2390bfb997 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -1,7 +1,7 @@
 package main
 
 //@NOTE SHYFT main func for api, sets up router and spins up a server
-//to run server 'go run shyftBlockExplorerApi/*.go'
+//to run server 'go run shyftRingWalletConn/*.go'
 import (
 "net"
 "fmt"

From 0404cbc062cd8b239e4a41bab25df281412ed5cc Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Sat, 30 Jun 2018 15:12:47 -0400
Subject: [PATCH 03/27] decode message from client

---
 shyftRingWalletConn/app.go | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 2390bfb997..41bc953391 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -3,9 +3,10 @@ package main
 //@NOTE SHYFT main func for api, sets up router and spins up a server
 //to run server 'go run shyftRingWalletConn/*.go'
 import (
-"net"
-"fmt"
-"os"
+  "net"
+  "fmt"
+  "os"
+	"encoding/json"
 )
 
 const (
@@ -44,6 +45,19 @@ func handleRequest(conn net.Conn) {
 
 	if err == nil {
 		fmt.Println("Message is ", string(buf[:msg]))
+		var dat map[string]interface{}
+		byt := []byte(string(buf[:msg]))
+		
+		if err := json.Unmarshal(byt, &dat); err != nil {
+			panic(err)
+		}
+		fmt.Println(dat["address"])
+		fmt.Println(dat["msg"])
+		fmt.Println(dat["sig"])
+		//Ecrecover takes 2 args, bytes[] and bytes[]
+		// we need to pass in the hash of the message as bytes
+		// and the bytes array of the signature
+		//crypto.Ecrecover()
 		fmt.Println("Message is ", msg)
 	}
 	if err != nil {

From 278086e5fda3cc516cad96fb2d20c9e1412ea363 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Sat, 30 Jun 2018 15:19:45 -0400
Subject: [PATCH 04/27] rm redundancy

---
 shyftRingWalletConn/app.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 41bc953391..f238331813 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -46,9 +46,8 @@ func handleRequest(conn net.Conn) {
 	if err == nil {
 		fmt.Println("Message is ", string(buf[:msg]))
 		var dat map[string]interface{}
-		byt := []byte(string(buf[:msg]))
-		
-		if err := json.Unmarshal(byt, &dat); err != nil {
+
+		if err := json.Unmarshal(buf[:msg], &dat); err != nil {
 			panic(err)
 		}
 		fmt.Println(dat["address"])

From 9f2d6ee3fc9b8f2206fbd7a82126826931a18e78 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Sat, 30 Jun 2018 15:28:19 -0400
Subject: [PATCH 05/27] log error from Ecrecover

---
 shyftRingWalletConn/app.go | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index f238331813..b03f308b1f 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -6,7 +6,8 @@ import (
   "net"
   "fmt"
   "os"
-	"encoding/json"
+  "encoding/json"
+  "github.com/ethereum/go-ethereum/crypto"
 )
 
 const (
@@ -56,8 +57,18 @@ func handleRequest(conn net.Conn) {
 		//Ecrecover takes 2 args, bytes[] and bytes[]
 		// we need to pass in the hash of the message as bytes
 		// and the bytes array of the signature
-		//crypto.Ecrecover()
-		fmt.Println("Message is ", msg)
+		var msg = []byte(dat["msg"].(string))
+		var sig = []byte(dat["sig"].(string))
+		var address, err = crypto.Ecrecover(msg, sig)
+		if err != nil {
+			fmt.Println("The error is ")
+			fmt.Println(err)
+		}
+		s := string(address[:])
+		fmt.Println("the address is ")
+		fmt.Println(s)
+		//fmt.Println(address)
+		//fmt.Println("Message is ", msg)
 	}
 	if err != nil {
 		fmt.Println("Error reading:", err.Error())

From 0cbeb26f93f34eecbcfad6db126277f365e7b55e Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Sat, 30 Jun 2018 16:45:03 -0400
Subject: [PATCH 06/27] format the msg parameter to Ecrecover so it has 32
 bytes

---
 shyftRingWalletConn/app.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index b03f308b1f..15a5bb8159 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -59,7 +59,8 @@ func handleRequest(conn net.Conn) {
 		// and the bytes array of the signature
 		var msg = []byte(dat["msg"].(string))
 		var sig = []byte(dat["sig"].(string))
-		var address, err = crypto.Ecrecover(msg, sig)
+		new_msg := crypto.Keccak256(msg)
+		var address, err = crypto.Ecrecover(new_msg, sig)
 		if err != nil {
 			fmt.Println("The error is ")
 			fmt.Println(err)

From b09a39289aa5816cf834958b927b65ad0da201f1 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Thu, 5 Jul 2018 13:50:08 -0400
Subject: [PATCH 07/27] more progress in verifying signature with ecrecover

---
 shyftRingWalletConn/app.go | 68 +++++++++++++++++++++++++++++++++-----
 1 file changed, 60 insertions(+), 8 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 15a5bb8159..68c9c7e195 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -7,7 +7,8 @@ import (
   "fmt"
   "os"
   "encoding/json"
-  "github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
 const (
@@ -16,6 +17,12 @@ const (
 	CONN_TYPE = "tcp"
 )
 
+// This gives context to the signed message and prevents signing of transactions.
+func signHash(data []byte) []byte {
+	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data)
+	return crypto.Keccak256([]byte(msg))
+}
+
 func main() {
 
 	l, err := net.Listen(CONN_TYPE, CONN_HOST+":"+CONN_PORT)
@@ -57,17 +64,62 @@ func handleRequest(conn net.Conn) {
 		//Ecrecover takes 2 args, bytes[] and bytes[]
 		// we need to pass in the hash of the message as bytes
 		// and the bytes array of the signature
-		var msg = []byte(dat["msg"].(string))
-		var sig = []byte(dat["sig"].(string))
-		new_msg := crypto.Keccak256(msg)
-		var address, err = crypto.Ecrecover(new_msg, sig)
+		var msg = dat["msg"].(string)
+		var sig = dat["sig"].(string)
+		fmt.Println("the first sig is ")
+		fmt.Println(sig)
+		var new_byte_array, err2 = hexutil.Decode(msg)
+		var new_sig_byte_array, err3 = hexutil.Decode(sig)
+		if err2 != nil {
+			fmt.Println("the err2 is ")
+			fmt.Println(err2)
+		}
+		if err3 != nil {
+			fmt.Println("the err3 is ")
+			fmt.Println(err3)
+		}
+		var fizz = hexutil.Bytes(new_byte_array)
+		var buzz = hexutil.Bytes(new_sig_byte_array)
+		buzz[64] -= 27
+		fmt.Println("that bytes is")
+		fmt.Println(fizz)
+		//var bytes_msg = []byte(msg)
+		//var foo, err = hex.DecodeString(msg)
+		//fmt.Println("msg is ")
+		//fmt.Println(msg)
+		//fmt.Println("bytes_msg is ")
+		//fmt.Println(bytes_msg)
+
+		//var sig = dat["sig"].(string)
+		//fmt.Println("The sig is ")
+		//fmt.Println(sig)
+		//decoded, er := hex.DecodeString(sig)
+		//if er != nil {
+		//	log.Fatal(err)
+		//}
+		new_msg := signHash(fizz)
+		fmt.Println("the new_msg is ")
+		fmt.Println(new_msg)
+		fmt.Println("the buzz is ")
+		fmt.Println(buzz)
+
+		var rpk, err = crypto.Ecrecover(new_msg, buzz)
 		if err != nil {
 			fmt.Println("The error is ")
 			fmt.Println(err)
 		}
-		s := string(address[:])
+
+		pubKey := crypto.ToECDSAPub(rpk)
+		recoveredAddr := crypto.PubkeyToAddress(*pubKey)
 		fmt.Println("the address is ")
-		fmt.Println(s)
+		fmt.Println(recoveredAddr)
+		fmt.Println(recoveredAddr.Hex())
+		//res, _ := new_add.MarshalText()
+		//fmt.Println(hexutil.Encode(address))
+		//s := string(address[:])
+		//
+		//fmt.Println(s)
+
 		//fmt.Println(address)
 		//fmt.Println("Message is ", msg)
 	}
@@ -78,4 +130,4 @@ func handleRequest(conn net.Conn) {
 	conn.Write([]byte("Message received."))
 	// Close the connection when you're done with it.
 	conn.Close()
-}
+}
\ No newline at end of file

From 225b6e9c7d6991d366482031a61f6a3cdc7df87b Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Fri, 6 Jul 2018 14:34:33 -0400
Subject: [PATCH 08/27] ecrecover plain text message

---
 shyftRingWalletConn/app.go | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 68c9c7e195..6a0b353b20 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -67,8 +67,15 @@ func handleRequest(conn net.Conn) {
 		var msg = dat["msg"].(string)
 		var sig = dat["sig"].(string)
 		fmt.Println("the first sig is ")
+		fmt.Println(msg)
 		fmt.Println(sig)
-		var new_byte_array, err2 = hexutil.Decode(msg)
+		//var new_byte_array, err2 = hexutil.Decode(msg)
+		var new_byte_array = []byte(msg)
+		var bazz = hexutil.Encode(new_byte_array)
+		fizz, err2 := hexutil.Decode(bazz)
+		fmt.Println("THE fizz is ")
+		fmt.Println(fizz)
+		//fizz = hexutil.Decode(fizz.String())
 		var new_sig_byte_array, err3 = hexutil.Decode(sig)
 		if err2 != nil {
 			fmt.Println("the err2 is ")
@@ -78,11 +85,13 @@ func handleRequest(conn net.Conn) {
 			fmt.Println("the err3 is ")
 			fmt.Println(err3)
 		}
-		var fizz = hexutil.Bytes(new_byte_array)
+
 		var buzz = hexutil.Bytes(new_sig_byte_array)
 		buzz[64] -= 27
 		fmt.Println("that bytes is")
 		fmt.Println(fizz)
+
+
 		//var bytes_msg = []byte(msg)
 		//var foo, err = hex.DecodeString(msg)
 		//fmt.Println("msg is ")
@@ -97,6 +106,7 @@ func handleRequest(conn net.Conn) {
 		//if er != nil {
 		//	log.Fatal(err)
 		//}
+
 		new_msg := signHash(fizz)
 		fmt.Println("the new_msg is ")
 		fmt.Println(new_msg)
@@ -114,6 +124,8 @@ func handleRequest(conn net.Conn) {
 		fmt.Println("the address is ")
 		fmt.Println(recoveredAddr)
 		fmt.Println(recoveredAddr.Hex())
+
+
 		//res, _ := new_add.MarshalText()
 		//fmt.Println(hexutil.Encode(address))
 		//s := string(address[:])

From 527adcfee36258d8320ef194fffd38d772a76e6b Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Fri, 6 Jul 2018 14:44:51 -0400
Subject: [PATCH 09/27] rm comments and printlns

---
 shyftRingWalletConn/app.go | 34 ++--------------------------------
 1 file changed, 2 insertions(+), 32 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 6a0b353b20..7832ce88c4 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -61,21 +61,16 @@ func handleRequest(conn net.Conn) {
 		fmt.Println(dat["address"])
 		fmt.Println(dat["msg"])
 		fmt.Println(dat["sig"])
-		//Ecrecover takes 2 args, bytes[] and bytes[]
-		// we need to pass in the hash of the message as bytes
-		// and the bytes array of the signature
+
 		var msg = dat["msg"].(string)
 		var sig = dat["sig"].(string)
 		fmt.Println("the first sig is ")
 		fmt.Println(msg)
 		fmt.Println(sig)
-		//var new_byte_array, err2 = hexutil.Decode(msg)
 		var new_byte_array = []byte(msg)
 		var bazz = hexutil.Encode(new_byte_array)
 		fizz, err2 := hexutil.Decode(bazz)
-		fmt.Println("THE fizz is ")
-		fmt.Println(fizz)
-		//fizz = hexutil.Decode(fizz.String())
+
 		var new_sig_byte_array, err3 = hexutil.Decode(sig)
 		if err2 != nil {
 			fmt.Println("the err2 is ")
@@ -91,22 +86,6 @@ func handleRequest(conn net.Conn) {
 		fmt.Println("that bytes is")
 		fmt.Println(fizz)
 
-
-		//var bytes_msg = []byte(msg)
-		//var foo, err = hex.DecodeString(msg)
-		//fmt.Println("msg is ")
-		//fmt.Println(msg)
-		//fmt.Println("bytes_msg is ")
-		//fmt.Println(bytes_msg)
-
-		//var sig = dat["sig"].(string)
-		//fmt.Println("The sig is ")
-		//fmt.Println(sig)
-		//decoded, er := hex.DecodeString(sig)
-		//if er != nil {
-		//	log.Fatal(err)
-		//}
-
 		new_msg := signHash(fizz)
 		fmt.Println("the new_msg is ")
 		fmt.Println(new_msg)
@@ -125,15 +104,6 @@ func handleRequest(conn net.Conn) {
 		fmt.Println(recoveredAddr)
 		fmt.Println(recoveredAddr.Hex())
 
-
-		//res, _ := new_add.MarshalText()
-		//fmt.Println(hexutil.Encode(address))
-		//s := string(address[:])
-		//
-		//fmt.Println(s)
-
-		//fmt.Println(address)
-		//fmt.Println("Message is ", msg)
 	}
 	if err != nil {
 		fmt.Println("Error reading:", err.Error())

From 9a4094f63456d15b1ace8fc45da47b8986581256 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Fri, 6 Jul 2018 15:44:55 -0400
Subject: [PATCH 10/27] rm Printlns

---
 shyftRingWalletConn/app.go | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 7832ce88c4..fa0479b064 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -65,8 +65,6 @@ func handleRequest(conn net.Conn) {
 		var msg = dat["msg"].(string)
 		var sig = dat["sig"].(string)
 		fmt.Println("the first sig is ")
-		fmt.Println(msg)
-		fmt.Println(sig)
 		var new_byte_array = []byte(msg)
 		var bazz = hexutil.Encode(new_byte_array)
 		fizz, err2 := hexutil.Decode(bazz)
@@ -87,10 +85,6 @@ func handleRequest(conn net.Conn) {
 		fmt.Println(fizz)
 
 		new_msg := signHash(fizz)
-		fmt.Println("the new_msg is ")
-		fmt.Println(new_msg)
-		fmt.Println("the buzz is ")
-		fmt.Println(buzz)
 
 		var rpk, err = crypto.Ecrecover(new_msg, buzz)
 		if err != nil {

From cda2a23d6d90b7410e0ec8962dd6967f18dbe338 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Wed, 11 Jul 2018 21:58:48 -0400
Subject: [PATCH 11/27] rm printlns

---
 shyftRingWalletConn/app.go | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index fa0479b064..73637903d6 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -17,6 +17,9 @@ const (
 	CONN_TYPE = "tcp"
 )
 
+var testAddrHex = "970e8128ab834e8eac17ab8e3812f010678cf791"
+var testPrivHex = "289c2857d4598e37fb9647507e47a309d6133539bf21a8b9cb6df88fd5232032"
+
 // This gives context to the signed message and prevents signing of transactions.
 func signHash(data []byte) []byte {
 	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data)
@@ -58,6 +61,8 @@ func handleRequest(conn net.Conn) {
 		if err := json.Unmarshal(buf[:msg], &dat); err != nil {
 			panic(err)
 		}
+
+
 		fmt.Println(dat["address"])
 		fmt.Println(dat["msg"])
 		fmt.Println(dat["sig"])
@@ -81,8 +86,6 @@ func handleRequest(conn net.Conn) {
 
 		var buzz = hexutil.Bytes(new_sig_byte_array)
 		buzz[64] -= 27
-		fmt.Println("that bytes is")
-		fmt.Println(fizz)
 
 		new_msg := signHash(fizz)
 
@@ -95,7 +98,7 @@ func handleRequest(conn net.Conn) {
 		pubKey := crypto.ToECDSAPub(rpk)
 		recoveredAddr := crypto.PubkeyToAddress(*pubKey)
 		fmt.Println("the address is ")
-		fmt.Println(recoveredAddr)
+		//fmt.Println(recoveredAddr)
 		fmt.Println(recoveredAddr.Hex())
 
 	}
@@ -105,5 +108,5 @@ func handleRequest(conn net.Conn) {
 	// Send a response back to person contacting us.
 	conn.Write([]byte("Message received."))
 	// Close the connection when you're done with it.
-	conn.Close()
+	//conn.Close()
 }
\ No newline at end of file

From 06685a7bf0389f60147d22d19e80797b614dfa46 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Wed, 11 Jul 2018 23:25:30 -0400
Subject: [PATCH 12/27] send message back to client

---
 shyftRingWalletConn/app.go | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 73637903d6..149ba188c0 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -7,8 +7,9 @@ import (
   "fmt"
   "os"
   "encoding/json"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 )
 
 const (
@@ -101,12 +102,24 @@ func handleRequest(conn net.Conn) {
 		//fmt.Println(recoveredAddr)
 		fmt.Println(recoveredAddr.Hex())
 
+		conn.Write([]byte("Message received."))
+
+		key, _ := crypto.HexToECDSA(testPrivHex)
+		addr := common.HexToAddress(testAddrHex)
+
+		new_msg2 := crypto.Keccak256([]byte("Message Received"))
+		new_sig , err := crypto.Sign(new_msg2, key)
+
+		conn.Write([]byte("Message Received"))
+		conn.Write(new_msg2)
+		conn.Write(addr[:])
+		conn.Write(new_sig)
 	}
 	if err != nil {
 		fmt.Println("Error reading:", err.Error())
 	}
 	// Send a response back to person contacting us.
-	conn.Write([]byte("Message received."))
+
 	// Close the connection when you're done with it.
 	//conn.Close()
 }
\ No newline at end of file

From 385ea04cf3afd53a60415ae6eefb25c0415d6040 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Fri, 13 Jul 2018 15:41:42 -0400
Subject: [PATCH 13/27] more work

---
 shyftRingWalletConn/app.go | 38 ++++++++++++++++++++++++++++++++------
 1 file changed, 32 insertions(+), 6 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 149ba188c0..a4332bb0f7 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -8,10 +8,18 @@ import (
   "os"
   "encoding/json"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/common"
+	//"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
+	"bytes"
 )
 
+type Msg struct {
+	Message string `json:"message"`
+	HashedMessage string `json:"hashed_message"`
+	Signature string `json:"signature"`
+	Address string `json:"address"`
+}
+
 const (
 	CONN_HOST = "localhost"
 	CONN_PORT = "3333"
@@ -102,18 +110,36 @@ func handleRequest(conn net.Conn) {
 		//fmt.Println(recoveredAddr)
 		fmt.Println(recoveredAddr.Hex())
 
-		conn.Write([]byte("Message received."))
+		//conn.Write([]byte("Message received."))
 
 		key, _ := crypto.HexToECDSA(testPrivHex)
-		addr := common.HexToAddress(testAddrHex)
+		//addr := common.HexToAddress(testAddrHex)
 
-		new_msg2 := crypto.Keccak256([]byte("Message Received"))
+		f_msg := "Message Received"
+		first_message := []byte(f_msg)
+		new_msg2 := crypto.Keccak256(first_message)
+
+		//send_message := append(new_msg2, []byte{byte(10)}...)
 		new_sig , err := crypto.Sign(new_msg2, key)
+		hex_sig := hexutil.Encode(new_sig)
+		fmt.Println("THE hex sig is ", hex_sig)
 
+
+		myNewMsg := Msg{f_msg, string(new_msg2[:]), string(new_sig[:]), testAddrHex}
+		reqBodyBytes := new(bytes.Buffer)
+		json.NewEncoder(reqBodyBytes).Encode(myNewMsg)
+
+		fmt.Println([]byte("Message Received\n"))
 		conn.Write([]byte("Message Received"))
-		conn.Write(new_msg2)
-		conn.Write(addr[:])
+		conn.Write([]byte("\n"))
 		conn.Write(new_sig)
+		conn.Write([]byte("\n"))
+		fmt.Println("PAUSE")
+		//time.Sleep(5 * time.Second)
+		//fmt.Println(send_message)
+		//conn.Write(send_message)
+		//conn.Write(addr[:])
+		//conn.Write(append(reqBodyBytes.Bytes() ,[]byte{byte(10)}...))
 	}
 	if err != nil {
 		fmt.Println("Error reading:", err.Error())

From 6445f3c9abf6e2e4d385445536b19b07822b7868 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Fri, 13 Jul 2018 16:01:05 -0400
Subject: [PATCH 14/27] log out hash of message as hex

---
 shyftRingWalletConn/app.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index a4332bb0f7..8dd8e848b5 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -118,6 +118,7 @@ func handleRequest(conn net.Conn) {
 		f_msg := "Message Received"
 		first_message := []byte(f_msg)
 		new_msg2 := crypto.Keccak256(first_message)
+		fmt.Println("the hash is ", hexutil.Encode(new_msg2))
 
 		//send_message := append(new_msg2, []byte{byte(10)}...)
 		new_sig , err := crypto.Sign(new_msg2, key)

From 90087ff7015b05136ba0530a18353d79bbd36d9d Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Sat, 14 Jul 2018 16:27:43 -0400
Subject: [PATCH 15/27] change test keys and test message

---
 shyftRingWalletConn/app.go | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 8dd8e848b5..26f0cbee32 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -26,8 +26,8 @@ const (
 	CONN_TYPE = "tcp"
 )
 
-var testAddrHex = "970e8128ab834e8eac17ab8e3812f010678cf791"
-var testPrivHex = "289c2857d4598e37fb9647507e47a309d6133539bf21a8b9cb6df88fd5232032"
+var testAddrHex = "14791697260E4c9A71f18484C9f997B308e59325"
+var testPrivHex = "0123456789012345678901234567890123456789012345678901234567890123"
 
 // This gives context to the signed message and prevents signing of transactions.
 func signHash(data []byte) []byte {
@@ -115,7 +115,7 @@ func handleRequest(conn net.Conn) {
 		key, _ := crypto.HexToECDSA(testPrivHex)
 		//addr := common.HexToAddress(testAddrHex)
 
-		f_msg := "Message Received"
+		f_msg := "Hello World"
 		first_message := []byte(f_msg)
 		new_msg2 := crypto.Keccak256(first_message)
 		fmt.Println("the hash is ", hexutil.Encode(new_msg2))
@@ -130,8 +130,7 @@ func handleRequest(conn net.Conn) {
 		reqBodyBytes := new(bytes.Buffer)
 		json.NewEncoder(reqBodyBytes).Encode(myNewMsg)
 
-		fmt.Println([]byte("Message Received\n"))
-		conn.Write([]byte("Message Received"))
+		conn.Write([]byte(f_msg))
 		conn.Write([]byte("\n"))
 		conn.Write(new_sig)
 		conn.Write([]byte("\n"))

From 8e0cfbc1a1f44bdda70a6c46e828068d8539206b Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Sun, 15 Jul 2018 09:32:22 -0400
Subject: [PATCH 16/27] add intArrToByteArr function for testing

---
 shyftRingWalletConn/app.go | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 26f0cbee32..58e79622ad 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -148,4 +148,13 @@ func handleRequest(conn net.Conn) {
 
 	// Close the connection when you're done with it.
 	//conn.Close()
-}
\ No newline at end of file
+}
+
+func intArrToByteArr(foo []int) []byte {
+
+	ret := []byte{}
+	for _, value := range foo {
+		ret = append(ret, byte(value))
+	}
+	return ret
+}

From 89e0479b7ae8c9dbb73c740de7be97ebb40717c3 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Sun, 15 Jul 2018 15:05:29 -0400
Subject: [PATCH 17/27] add in additional message sent over tcp

---
 shyftRingWalletConn/app.go | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 58e79622ad..9c24d6ea0d 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -130,6 +130,21 @@ func handleRequest(conn net.Conn) {
 		reqBodyBytes := new(bytes.Buffer)
 		json.NewEncoder(reqBodyBytes).Encode(myNewMsg)
 
+		//testArr := []byte{0xFF, 0x0a, 0xFE, 0x11, 0x0a, 0x0a, 0x0a, 0xF0, 0x0a, 0x1F, 0x22}
+		//testArr := []byte{0xFF, 0x0a, 0xFE, 0x11, 0x0a, 0x0a, 0xF0, 0x0a, 0x22}
+		//testArr := []byte{0xFF, 0x0a, 0xFE, 0xa, 0x22, 0xF3}
+		//testArr2 := []byte{0xF2, 0x0a, 0x1E}
+		//testArr3 := []byte{0xF1, 0x0a, 0xa0}
+
+		//conn.Write(testArr)
+		//time.Sleep(1 * time.Second)
+		//conn.Write(testArr2)
+		//time.Sleep(1 * time.Second)
+		//conn.Write(testArr3)
+
+
+		conn.Write([]byte("Broadcasting Message"))
+		conn.Write([]byte("\n"))
 		conn.Write([]byte(f_msg))
 		conn.Write([]byte("\n"))
 		conn.Write(new_sig)

From d25c879b59c9c8f13b1cd61bf4b986a5abe454fa Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Mon, 16 Jul 2018 11:09:57 -0400
Subject: [PATCH 18/27] receiving messages from wallet correctly

---
 shyftRingWalletConn/app.go | 199 +++++++++++++++++++------------------
 1 file changed, 102 insertions(+), 97 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 9c24d6ea0d..617767b1ba 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -6,11 +6,10 @@ import (
   "net"
   "fmt"
   "os"
-  "encoding/json"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	//"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"bytes"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
 type Msg struct {
@@ -59,106 +58,112 @@ func main() {
 // Handles incoming requests.
 func handleRequest(conn net.Conn) {
 	// Make a buffer to hold incoming data.
-	buf := make([]byte, 1024)
 	// Read the incoming connection into the buffer.
-	msg, err := conn.Read(buf)
 
-	if err == nil {
-		fmt.Println("Message is ", string(buf[:msg]))
-		var dat map[string]interface{}
+	go func() {
+		buf := make([]byte, 1024)
+		msgBuf := make([]byte, 0)
+		var prevMsg []byte
+		var addressOfClient []byte
+		var signatureFromClient []byte
+		var msgFromClient []byte
 
-		if err := json.Unmarshal(buf[:msg], &dat); err != nil {
-			panic(err)
+		for {
+			//var addressOfClient []byte
+			//var msgFromClient []byte
+			//var sigFromClient []byte
+			msg, err := conn.Read(buf)
+
+			if err == nil {
+				fmt.Println("Message is ", buf[:msg])
+				fmt.Println("The old msg buf is ", msgBuf)
+				msgBuf = append(msgBuf, buf[:msg]...)
+				fmt.Println("THE msgBuf is ")
+				fmt.Println(msgBuf)
+				//fmt.Println("Message is ", string(buf[:msg]))
+			}
+			index := bytes.IndexByte(msgBuf, 0x0a)
+			for index != -1 {
+				newMsg := msgBuf[:index]
+				rest := msgBuf[(index + 1):len(msgBuf)]
+				msgBuf = rest
+				index = bytes.IndexByte(msgBuf, 0x0a)
+				fmt.Println("new msg")
+				fmt.Println(newMsg)
+				fmt.Println(string(newMsg[:]))
+				fmt.Println("prev message ", prevMsg)
+				fmt.Println((prevMsg == nil))
+				if prevMsg != nil {
+					fmt.Println("not nil")
+					s := string(prevMsg[:])
+					if s == "-- ADDRESS --" {
+						fmt.Println("the address should be ")
+						fmt.Println(newMsg)
+						addressOfClient = newMsg
+					}
+					if s == "-- SIGNATURE --" {
+						signatureFromClient = newMsg
+					}
+					if s == "-- MESSAGE --" {
+						msgFromClient = newMsg
+					}
+					prevMsg = nil
+				} else {
+					fmt.Println("nil")
+					prevMsg = newMsg
+					fmt.Println("prev message is in else block ", prevMsg)
+					fmt.Println("index ", index)
+					fmt.Println("msgBuf ", msgBuf)
+					fmt.Println(bytes.IndexByte(msgBuf, 0x0a))
+
+				}
+			}
+
+			if(addressOfClient != nil && signatureFromClient != nil && msgFromClient != nil ){
+				fmt.Println("ALL COMPONENTS RECEIVED")
+				msg := string(msgFromClient[:])
+				//new_msg := signHash(msgFromClient)
+				sig := string(signatureFromClient[:])
+				addr := string(addressOfClient[:])
+				fmt.Println(addr)
+				fmt.Println(msg)
+				fmt.Println(sig)
+
+				var new_byte_array = []byte(msg)
+				var bazz = hexutil.Encode(new_byte_array)
+				fizz, err2 := hexutil.Decode(bazz)
+
+				var new_sig_byte_array, err3 = hexutil.Decode(sig)
+				if err2 != nil {
+					fmt.Println("the err2 is ")
+					fmt.Println(err2)
+				}
+				if err3 != nil {
+					fmt.Println("the err3 is ")
+					fmt.Println(err3)
+				}
+
+				var buzz = hexutil.Bytes(new_sig_byte_array)
+				buzz[64] -= 27
+
+				new_msg := signHash(fizz)
+
+				var rpk, err = crypto.Ecrecover(new_msg, buzz)
+				if err != nil {
+					fmt.Println("The error is ")
+					fmt.Println(err)
+				}
+
+				pubKey := crypto.ToECDSAPub(rpk)
+				recoveredAddr := crypto.PubkeyToAddress(*pubKey)
+				fmt.Println("the address is ")
+				//fmt.Println(recoveredAddr)
+				fmt.Println(recoveredAddr.Hex())
+			}
 		}
+	}()
+	conn.Write([]byte{byte(0x0f)})
 
-
-		fmt.Println(dat["address"])
-		fmt.Println(dat["msg"])
-		fmt.Println(dat["sig"])
-
-		var msg = dat["msg"].(string)
-		var sig = dat["sig"].(string)
-		fmt.Println("the first sig is ")
-		var new_byte_array = []byte(msg)
-		var bazz = hexutil.Encode(new_byte_array)
-		fizz, err2 := hexutil.Decode(bazz)
-
-		var new_sig_byte_array, err3 = hexutil.Decode(sig)
-		if err2 != nil {
-			fmt.Println("the err2 is ")
-			fmt.Println(err2)
-		}
-		if err3 != nil {
-			fmt.Println("the err3 is ")
-			fmt.Println(err3)
-		}
-
-		var buzz = hexutil.Bytes(new_sig_byte_array)
-		buzz[64] -= 27
-
-		new_msg := signHash(fizz)
-
-		var rpk, err = crypto.Ecrecover(new_msg, buzz)
-		if err != nil {
-			fmt.Println("The error is ")
-			fmt.Println(err)
-		}
-
-		pubKey := crypto.ToECDSAPub(rpk)
-		recoveredAddr := crypto.PubkeyToAddress(*pubKey)
-		fmt.Println("the address is ")
-		//fmt.Println(recoveredAddr)
-		fmt.Println(recoveredAddr.Hex())
-
-		//conn.Write([]byte("Message received."))
-
-		key, _ := crypto.HexToECDSA(testPrivHex)
-		//addr := common.HexToAddress(testAddrHex)
-
-		f_msg := "Hello World"
-		first_message := []byte(f_msg)
-		new_msg2 := crypto.Keccak256(first_message)
-		fmt.Println("the hash is ", hexutil.Encode(new_msg2))
-
-		//send_message := append(new_msg2, []byte{byte(10)}...)
-		new_sig , err := crypto.Sign(new_msg2, key)
-		hex_sig := hexutil.Encode(new_sig)
-		fmt.Println("THE hex sig is ", hex_sig)
-
-
-		myNewMsg := Msg{f_msg, string(new_msg2[:]), string(new_sig[:]), testAddrHex}
-		reqBodyBytes := new(bytes.Buffer)
-		json.NewEncoder(reqBodyBytes).Encode(myNewMsg)
-
-		//testArr := []byte{0xFF, 0x0a, 0xFE, 0x11, 0x0a, 0x0a, 0x0a, 0xF0, 0x0a, 0x1F, 0x22}
-		//testArr := []byte{0xFF, 0x0a, 0xFE, 0x11, 0x0a, 0x0a, 0xF0, 0x0a, 0x22}
-		//testArr := []byte{0xFF, 0x0a, 0xFE, 0xa, 0x22, 0xF3}
-		//testArr2 := []byte{0xF2, 0x0a, 0x1E}
-		//testArr3 := []byte{0xF1, 0x0a, 0xa0}
-
-		//conn.Write(testArr)
-		//time.Sleep(1 * time.Second)
-		//conn.Write(testArr2)
-		//time.Sleep(1 * time.Second)
-		//conn.Write(testArr3)
-
-
-		conn.Write([]byte("Broadcasting Message"))
-		conn.Write([]byte("\n"))
-		conn.Write([]byte(f_msg))
-		conn.Write([]byte("\n"))
-		conn.Write(new_sig)
-		conn.Write([]byte("\n"))
-		fmt.Println("PAUSE")
-		//time.Sleep(5 * time.Second)
-		//fmt.Println(send_message)
-		//conn.Write(send_message)
-		//conn.Write(addr[:])
-		//conn.Write(append(reqBodyBytes.Bytes() ,[]byte{byte(10)}...))
-	}
-	if err != nil {
-		fmt.Println("Error reading:", err.Error())
-	}
 	// Send a response back to person contacting us.
 
 	// Close the connection when you're done with it.

From a2a6a57c700b901114debd427d6d58d1d0bf0e63 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Mon, 16 Jul 2018 11:23:42 -0400
Subject: [PATCH 19/27] fix var names

---
 shyftRingWalletConn/app.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 617767b1ba..ced36f78f7 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -129,11 +129,11 @@ func handleRequest(conn net.Conn) {
 				fmt.Println(msg)
 				fmt.Println(sig)
 
-				var new_byte_array = []byte(msg)
-				var bazz = hexutil.Encode(new_byte_array)
-				fizz, err2 := hexutil.Decode(bazz)
+				var msgByteArr = []byte(msg)
+				var hexMsg = hexutil.Encode(msgByteArr)
+				fizz, err2 := hexutil.Decode(hexMsg)
 
-				var new_sig_byte_array, err3 = hexutil.Decode(sig)
+				var sigByteArr, err3 = hexutil.Decode(sig)
 				if err2 != nil {
 					fmt.Println("the err2 is ")
 					fmt.Println(err2)
@@ -143,12 +143,12 @@ func handleRequest(conn net.Conn) {
 					fmt.Println(err3)
 				}
 
-				var buzz = hexutil.Bytes(new_sig_byte_array)
-				buzz[64] -= 27
+				var sigHex = hexutil.Bytes(sigByteArr)
+				sigHex[64] -= 27
 
-				new_msg := signHash(fizz)
+				signedMsgHash := signHash(fizz)
 
-				var rpk, err = crypto.Ecrecover(new_msg, buzz)
+				var rpk, err = crypto.Ecrecover(signedMsgHash, sigHex)
 				if err != nil {
 					fmt.Println("The error is ")
 					fmt.Println(err)

From d7b70c03b95d1e540d0018b08052ab78a677d4c6 Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Mon, 16 Jul 2018 11:38:22 -0400
Subject: [PATCH 20/27] respond back to client with sig

---
 shyftRingWalletConn/app.go | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index ced36f78f7..3ff6175115 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -162,7 +162,31 @@ func handleRequest(conn net.Conn) {
 			}
 		}
 	}()
-	conn.Write([]byte{byte(0x0f)})
+	go func() {
+		key, _ := crypto.HexToECDSA(testPrivHex)
+		//addr := common.HexToAddress(testAddrHex)
+
+		f_msg := "Hello World"
+		first_message := []byte(f_msg)
+		new_msg2 := crypto.Keccak256(first_message)
+		fmt.Println("the hash is ", hexutil.Encode(new_msg2))
+
+		//send_message := append(new_msg2, []byte{byte(10)}...)
+		new_sig , err := crypto.Sign(new_msg2, key)
+		if err != nil {
+			fmt.Println("The crypto.Sign err is ", err)
+		}
+		hex_sig := hexutil.Encode(new_sig)
+		fmt.Println("THE hex sig is ", hex_sig)
+
+		conn.Write([]byte("Broadcasting Message"))
+		conn.Write([]byte("\n"))
+		conn.Write([]byte(f_msg))
+		conn.Write([]byte("\n"))
+		conn.Write(new_sig)
+		conn.Write([]byte("\n"))
+	}()
+	//conn.Write([]byte{byte(0x0f)})
 
 	// Send a response back to person contacting us.
 

From f6fee7e70ae788163416076b3f78d46eb7fa3948 Mon Sep 17 00:00:00 2001
From: Dustin Brickwood <dustinbrickwood204@gmail.com>
Date: Mon, 16 Jul 2018 16:22:43 -0400
Subject: [PATCH 21/27] cleaned up code and removed msg type

---
 shyftRingWalletConn/app.go | 82 +++++---------------------------------
 1 file changed, 9 insertions(+), 73 deletions(-)

diff --git a/shyftRingWalletConn/app.go b/shyftRingWalletConn/app.go
index 3ff6175115..0da4d787e3 100644
--- a/shyftRingWalletConn/app.go
+++ b/shyftRingWalletConn/app.go
@@ -12,13 +12,6 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
-type Msg struct {
-	Message string `json:"message"`
-	HashedMessage string `json:"hashed_message"`
-	Signature string `json:"signature"`
-	Address string `json:"address"`
-}
-
 const (
 	CONN_HOST = "localhost"
 	CONN_PORT = "3333"
@@ -69,18 +62,10 @@ func handleRequest(conn net.Conn) {
 		var msgFromClient []byte
 
 		for {
-			//var addressOfClient []byte
-			//var msgFromClient []byte
-			//var sigFromClient []byte
 			msg, err := conn.Read(buf)
 
 			if err == nil {
-				fmt.Println("Message is ", buf[:msg])
-				fmt.Println("The old msg buf is ", msgBuf)
 				msgBuf = append(msgBuf, buf[:msg]...)
-				fmt.Println("THE msgBuf is ")
-				fmt.Println(msgBuf)
-				//fmt.Println("Message is ", string(buf[:msg]))
 			}
 			index := bytes.IndexByte(msgBuf, 0x0a)
 			for index != -1 {
@@ -88,17 +73,9 @@ func handleRequest(conn net.Conn) {
 				rest := msgBuf[(index + 1):len(msgBuf)]
 				msgBuf = rest
 				index = bytes.IndexByte(msgBuf, 0x0a)
-				fmt.Println("new msg")
-				fmt.Println(newMsg)
-				fmt.Println(string(newMsg[:]))
-				fmt.Println("prev message ", prevMsg)
-				fmt.Println((prevMsg == nil))
 				if prevMsg != nil {
-					fmt.Println("not nil")
 					s := string(prevMsg[:])
 					if s == "-- ADDRESS --" {
-						fmt.Println("the address should be ")
-						fmt.Println(newMsg)
 						addressOfClient = newMsg
 					}
 					if s == "-- SIGNATURE --" {
@@ -109,67 +86,41 @@ func handleRequest(conn net.Conn) {
 					}
 					prevMsg = nil
 				} else {
-					fmt.Println("nil")
 					prevMsg = newMsg
-					fmt.Println("prev message is in else block ", prevMsg)
-					fmt.Println("index ", index)
-					fmt.Println("msgBuf ", msgBuf)
-					fmt.Println(bytes.IndexByte(msgBuf, 0x0a))
-
 				}
 			}
 
-			if(addressOfClient != nil && signatureFromClient != nil && msgFromClient != nil ){
-				fmt.Println("ALL COMPONENTS RECEIVED")
-				msg := string(msgFromClient[:])
-				//new_msg := signHash(msgFromClient)
+			if addressOfClient != nil && signatureFromClient != nil && msgFromClient != nil {
 				sig := string(signatureFromClient[:])
-				addr := string(addressOfClient[:])
-				fmt.Println(addr)
-				fmt.Println(msg)
-				fmt.Println(sig)
+				var sigByteArr, error = hexutil.Decode(sig)
 
-				var msgByteArr = []byte(msg)
-				var hexMsg = hexutil.Encode(msgByteArr)
-				fizz, err2 := hexutil.Decode(hexMsg)
-
-				var sigByteArr, err3 = hexutil.Decode(sig)
-				if err2 != nil {
-					fmt.Println("the err2 is ")
-					fmt.Println(err2)
-				}
-				if err3 != nil {
-					fmt.Println("the err3 is ")
-					fmt.Println(err3)
+				if error != nil {
+					fmt.Println(error)
 				}
 
 				var sigHex = hexutil.Bytes(sigByteArr)
 				sigHex[64] -= 27
 
-				signedMsgHash := signHash(fizz)
+				signedMsgHash := signHash(msgFromClient)
 
 				var rpk, err = crypto.Ecrecover(signedMsgHash, sigHex)
 				if err != nil {
-					fmt.Println("The error is ")
 					fmt.Println(err)
 				}
 
 				pubKey := crypto.ToECDSAPub(rpk)
 				recoveredAddr := crypto.PubkeyToAddress(*pubKey)
-				fmt.Println("the address is ")
-				//fmt.Println(recoveredAddr)
-				fmt.Println(recoveredAddr.Hex())
+				fmt.Println("ADDRESS IS ::", recoveredAddr.Hex())
 			}
 		}
 	}()
 	go func() {
 		key, _ := crypto.HexToECDSA(testPrivHex)
-		//addr := common.HexToAddress(testAddrHex)
 
 		f_msg := "Hello World"
 		first_message := []byte(f_msg)
 		new_msg2 := crypto.Keccak256(first_message)
-		fmt.Println("the hash is ", hexutil.Encode(new_msg2))
+		fmt.Println("HASH IS ::", hexutil.Encode(new_msg2))
 
 		//send_message := append(new_msg2, []byte{byte(10)}...)
 		new_sig , err := crypto.Sign(new_msg2, key)
@@ -177,7 +128,7 @@ func handleRequest(conn net.Conn) {
 			fmt.Println("The crypto.Sign err is ", err)
 		}
 		hex_sig := hexutil.Encode(new_sig)
-		fmt.Println("THE hex sig is ", hex_sig)
+		fmt.Println("HEX SIG ::", hex_sig)
 
 		conn.Write([]byte("Broadcasting Message"))
 		conn.Write([]byte("\n"))
@@ -186,19 +137,4 @@ func handleRequest(conn net.Conn) {
 		conn.Write(new_sig)
 		conn.Write([]byte("\n"))
 	}()
-	//conn.Write([]byte{byte(0x0f)})
-
-	// Send a response back to person contacting us.
-
-	// Close the connection when you're done with it.
-	//conn.Close()
-}
-
-func intArrToByteArr(foo []int) []byte {
-
-	ret := []byte{}
-	for _, value := range foo {
-		ret = append(ret, byte(value))
-	}
-	return ret
-}
+}
\ No newline at end of file

From 71cf9acfd681d9dd9ff249220577ca92e02f7744 Mon Sep 17 00:00:00 2001
From: Dustin Brickwood <dustinbrickwood204@gmail.com>
Date: Thu, 19 Jul 2018 16:24:08 -0400
Subject: [PATCH 22/27] code refactor

---
 core/genesis.go                               |   8 +-
 core/shyft_database_util.go                   | 938 +++---------------
 core/shyft_get_utils.go                       | 381 +++++++
 shyft-cli/postgres_setup/create_tables.psql   |   2 +-
 .../create_tables_test.psql                   |   2 +-
 shyftDb/shyft_database_util_test.go           |   8 +-
 6 files changed, 531 insertions(+), 808 deletions(-)
 create mode 100644 core/shyft_get_utils.go

diff --git a/core/genesis.go b/core/genesis.go
index 9382442449..5ab56da682 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -163,7 +163,7 @@ func WriteShyftGen(gen *Genesis, block *types.Block) {
 			isContract := false
 			data:= ""
 			addr := k.String()
-			txCountAccount := v.Nonce +1
+			accountNonce := v.Nonce +1
 			i, err := strconv.ParseInt(block.Time().String(), 10, 64)
 			if err != nil {
 				panic(err)
@@ -173,15 +173,15 @@ func WriteShyftGen(gen *Genesis, block *types.Block) {
 			GENESIS := "GENESIS"
 			txHash := strings.Join(Genesis, addr)
 
-			sqlStatement := `INSERT INTO accounts(addr, balance, txCountAccount) VALUES(($1), ($2), ($3)) RETURNING addr`
-			insertErr := sqldb.QueryRow(sqlStatement, addr, v.Balance.String(), txCountAccount).Scan(&addr)
+			sqlStatement := `INSERT INTO accounts(addr, balance, accountnonce) VALUES(($1), ($2), ($3)) RETURNING addr`
+			insertErr := sqldb.QueryRow(sqlStatement, addr, v.Balance.String(), accountNonce).Scan(&addr)
 			if insertErr != nil {
 				panic(insertErr)
 			}
 
 			var retNonce string
 			sqlGenTxStatement := `INSERT INTO txs(txhash, from_addr, to_addr, blockhash, blockNumber, amount,gasPrice, gas, gasLimit,txFee,nonce,txstatus, iscontract,age, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12), ($13), ($14), ($15)) RETURNING nonce`
-			insertError := sqldb.QueryRow(sqlGenTxStatement, txHash, GENESIS, addr, block.Header().Hash().Hex(), number, v.Balance.String(), gasPrice, gasUsed, gasLimit, txFee,txCountAccount,txStatus, isContract, age, data).Scan(&retNonce)
+			insertError := sqldb.QueryRow(sqlGenTxStatement, txHash, GENESIS, addr, block.Header().Hash().Hex(), number, v.Balance.String(), gasPrice, gasUsed, gasLimit, txFee,accountNonce,txStatus, isContract, age, data).Scan(&retNonce)
 			if insertError != nil {
 				panic(insertError)
 			}
diff --git a/core/shyft_database_util.go b/core/shyft_database_util.go
index 04f113c99b..3a92ff5df2 100644
--- a/core/shyft_database_util.go
+++ b/core/shyft_database_util.go
@@ -1,14 +1,13 @@
 package core
 
 import (
-"encoding/json"
-"fmt"
-"math/big"
-"time"
-"strconv"
-"database/sql"
-"log"
-_ "github.com/lib/pq"
+	"encoding/json"
+	"math/big"
+	"time"
+	"strconv"
+	"database/sql"
+	"log"
+	_ "github.com/lib/pq"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -24,20 +23,21 @@ func SetIShyftTracer(st shyfttracerinterface.IShyftTracer) {
 
 //SBlock type
 type SBlock struct {
-	Hash     string
-	Coinbase string
-	Number   string
-	GasUsed	 uint64
-	GasLimit uint64
-	TxCount  int
-	UncleCount int
-	Age        string
-	ParentHash string
-	UncleHash string
-	Difficulty string
-	Size string
-	Nonce uint64
-	Rewards string
+	Hash     	string
+	Coinbase 	string
+	Age        	string
+	ParentHash 	string
+	UncleHash 	string
+	Difficulty 	string
+	Size 		string
+	Rewards 	string
+	Number   	string
+	GasUsed	 	uint64
+	GasLimit 	uint64
+	Nonce 		uint64
+	TxCount  	int
+	UncleCount 	int
+	Blocks 		[]SBlock
 }
 
 //blockRes struct
@@ -49,9 +49,9 @@ type blockRes struct {
 }
 
 type SAccounts struct {
-	Addr    string
-	Balance string
-	TxCountAccount string
+	Addr    		string
+	Balance 		string
+	AccountNonce	string
 }
 
 type accountRes struct {
@@ -60,76 +60,60 @@ type accountRes struct {
 	AllAccounts []SAccounts
 }
 
-//ShyftTxEntry structure
-type ShyftTxEntry struct {
-	TxHash    common.Hash
-	To        *common.Address
-	From      *common.Address
-	BlockHash string
-	Amount    *big.Int
-	GasPrice  *big.Int
-	Gas       uint64
-	Cost	  *big.Int
-	Nonce     uint64
-	Data      []byte
-}
-
 type txRes struct {
 	TxEntry []ShyftTxEntryPretty
 }
 
 type ShyftTxEntryPretty struct {
-	TxHash    string
-	To        string
-	From      string
-	BlockHash string
-	BlockNumber string
-	Amount   string
-	GasPrice  uint64
-	Gas       uint64
-	GasLimit  uint64
-	Cost	  uint64
-	Nonce     uint64
-	Status	  string
-	IsContract bool
-	Age        time.Time
-	Data      []byte
-}
-
-type ShyftAccountEntry struct {
-	Balance string
-	Txs     []string
+	TxHash    		string
+	To        		string
+	From      		string
+	BlockHash 		string
+	BlockNumber 	string
+	Amount   		string
+	GasPrice  		uint64
+	Gas       		uint64
+	GasLimit  		uint64
+	Cost	  		uint64
+	Nonce     		uint64
+	Status	  		string
+	IsContract 		bool
+	Age        		time.Time
+	Data      		[]byte
 }
 
 type SendAndReceive struct {
-	To        string
-	From      string
-	Amount    string
-	Address   string
-	Balance   string
-	TxCountAccount string
+	To        	 string
+	From      	 string
+	Amount    	 string
+	Address   	 string
+	Balance   	 string
+	AccountNonce uint64 `json:",string"`
 }
 
 //WriteBlock writes to block info to sql db
 func SWriteBlock(block *types.Block, receipts []*types.Receipt) error {
-
 	sqldb, err := DBConnection()
 	if err != nil {
 		panic(err)
 	}
 
 	rewards := swriteMinerRewards(sqldb,block)
-	coinbase := block.Header().Coinbase.String()
-	number := block.Header().Number.String()
-	gasUsed := block.Header().GasUsed
-	gasLimit := block.Header().GasLimit
-	txCount := block.Transactions().Len()
-	uncleCount := len(block.Uncles())
-	parentHash := block.ParentHash().String()
-	uncleHash := block.UncleHash().String()
-	blockDifficulty := block.Difficulty().String()
-	blockSize := block.Size().String()
-	blockNonce := block.Nonce()
+
+	blockData := SBlock{
+		Hash: 			block.Header().Hash().Hex(),
+		Coinbase: 		block.Header().Coinbase.String(),
+		Number: 		block.Header().Number.String(),
+		GasUsed: 		block.Header().GasUsed,
+		GasLimit: 		block.Header().GasLimit,
+		TxCount: 		block.Transactions().Len(),
+		UncleCount: 	len(block.Uncles()),
+		ParentHash: 	block.ParentHash().String(),
+		UncleHash: 		block.UncleHash().String(),
+		Difficulty: 	block.Difficulty().String(),
+		Size: 			block.Size().String(),
+		Nonce: 			block.Nonce(),
+	}
 
 	i, err := strconv.ParseInt(block.Time().String(), 10, 64)
 	if err != nil {
@@ -138,14 +122,14 @@ func SWriteBlock(block *types.Block, receipts []*types.Receipt) error {
 	age := time.Unix(i, 0)
 
 	sqlStatement := `INSERT INTO blocks(hash, coinbase, number, gasUsed, gasLimit, txCount, uncleCount, age, parentHash, uncleHash, difficulty, size, rewards, nonce) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12),($13), ($14)) RETURNING number`
-	qerr := sqldb.QueryRow(sqlStatement, block.Header().Hash().Hex(), coinbase, number, gasUsed, gasLimit, txCount, uncleCount, age, parentHash, uncleHash, blockDifficulty, blockSize, rewards, blockNonce).Scan(&number)
+	qerr := sqldb.QueryRow(sqlStatement, blockData.Hash, blockData.Coinbase, blockData.Number, blockData.GasUsed, blockData.GasLimit, blockData.TxCount, blockData.UncleCount, age, blockData.ParentHash, blockData.UncleHash, blockData.Difficulty, blockData.Size, rewards, blockData.Nonce).Scan(&blockData.Number)
 	if qerr != nil {
 		panic(qerr)
 	}
 
 	if block.Transactions().Len() > 0 {
 		for _, tx := range block.Transactions() {
-			SwriteTransactions(sqldb, tx, block.Header().Hash(), block.Header().Number.String(), receipts, age, gasLimit)
+			swriteTransactions(sqldb, tx, block.Header().Hash(), blockData.Number, receipts, age, blockData.GasLimit)
 			if block.Transactions()[0].To() != nil {
 				swriteFromBalance(sqldb, tx)
 			}
@@ -157,126 +141,102 @@ func SWriteBlock(block *types.Block, receipts []*types.Receipt) error {
 	return nil
 }
 
-//writeTransactions writes to sqldb
-func SwriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.Hash, blockNumber string,  receipts []*types.Receipt, age time.Time, gasLimit uint64) error {
-	txData := ShyftTxEntry{
-		TxHash:    tx.Hash(),
-		From:      tx.From(),
-		To:        tx.To(),
+//swriteTransactions writes to sqldb, a SHYFT postgres instance
+func swriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.Hash, blockNumber string,  receipts []*types.Receipt, age time.Time, gasLimit uint64) error {
+	var isContract bool
+	var statusFromReciept, contractAddressFromReciept, retNonce string
+
+	txData := ShyftTxEntryPretty{
+		TxHash:    tx.Hash().Hex(),
+		From:      tx.From().Hex(),
+		To:        tx.To().Hex(),
 		BlockHash: blockHash.Hex(),
-		Amount:    tx.Value(),
-		Cost:	   tx.Cost(),
-		GasPrice:  tx.GasPrice(),
+		Amount:    tx.Value().String(),
+		Cost:	   tx.Cost().Uint64(),
+		GasPrice:  tx.GasPrice().Uint64(),
 		Gas:       tx.Gas(),
 		Nonce:     tx.Nonce(),
 		Data:      tx.Data(),
 	}
 
-	hash := txData.TxHash
-	txHash := txData.TxHash.Hex()
-
-	from := txData.From.Hex()
-	blockHasher := txData.BlockHash
-	amount := txData.Amount.String()
-	gasPrice := txData.GasPrice.String()
-	txFee := txData.Cost.String()
-	nonce := txData.Nonce
-	gas := txData.Gas
-	data := txData.Data
-	to := txData.To
-	var isContract bool
-	var statusFromReciept string
-
-	if (to == nil){
-		var contractAddressFromReciept string
+	if tx.To() == nil {
 		for _, receipt := range receipts {
 			statusReciept := (*types.ReceiptForStorage)(receipt).Status
 			contractAddressFromReciept = (*types.ReceiptForStorage)(receipt).ContractAddress.String()
-			if statusReciept == 1 {
+			switch {
+			case statusReciept == 0:
+				statusFromReciept = "FAIL"
+			case statusReciept == 1:
 				statusFromReciept = "SUCCESS"
 			}
-			if statusReciept == 0 {
-				statusFromReciept = "FAIL"
-			}
 		}
-
-		var retNonce string
 		isContract = true
-		sqlStatement := `INSERT INTO txs(txhash, from_addr, to_addr, blockhash, blockNumber, amount, gasprice, gas, gasLimit,txfee, nonce, isContract, txStatus, age, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12), ($13), ($14), ($15)) RETURNING nonce`
-		qerr := sqldb.QueryRow(sqlStatement, txHash, from, contractAddressFromReciept, blockHasher, blockNumber, amount, gasPrice, gas, gasLimit, txFee, nonce, isContract, statusFromReciept, age,data).Scan(&retNonce)
-		if qerr != nil {
-			panic(qerr)
+		sqlStatement := `INSERT INTO txs(txhash, from_addr, to_addr, blockhash, blockNumber, amount, gasprice, gas, gasLimit, txfee, nonce, isContract, txStatus, age, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12), ($13), ($14), ($15)) RETURNING nonce`
+		err := sqldb.QueryRow(sqlStatement, txData.TxHash, txData.From, contractAddressFromReciept, txData.BlockHash, blockNumber, txData.Amount, txData.GasPrice, txData.Gas, gasLimit, txData.Cost, txData.Nonce, isContract, statusFromReciept, age, txData.Data).Scan(&retNonce)
+		if err != nil {
+			panic(err)
 		}
 	} else {
-		var retNonce string
 		isContract = false
 		for _, receipt := range receipts {
 			statusReciept := (*types.ReceiptForStorage)(receipt).Status
-			if statusReciept == 1 {
+			switch {
+			case statusReciept == 0:
+				statusFromReciept = "FAIL"
+			case statusReciept == 1:
 				statusFromReciept = "SUCCESS"
 			}
-			if statusReciept == 0 {
-				statusFromReciept = "FAIL"
-			}
 		}
-
 		sqlStatement := `INSERT INTO txs(txhash, from_addr, to_addr, blockhash, blockNumber, amount, gasprice, gas, gasLimit, txfee, nonce, isContract, txStatus, age, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12), ($13), ($14), ($15)) RETURNING nonce`
-		qerr := sqldb.QueryRow(sqlStatement, txHash, from, to.Hex(), blockHasher, blockNumber, amount, gasPrice, gas, gasLimit, txFee, nonce, isContract, statusFromReciept, age,data).Scan(&retNonce)
-
-		if qerr != nil {
-			panic(qerr)
+		err := sqldb.QueryRow(sqlStatement, txData.TxHash, txData.From, txData.To, txData.BlockHash, blockNumber, txData.Amount, txData.GasPrice, txData.Gas, gasLimit, txData.Cost, txData.Nonce, isContract, statusFromReciept, age, txData.Data).Scan(&retNonce)
+		if err != nil {
+			panic(err)
 		}
 	}
-	IShyftTracer.GetTracerToRun(hash)
+	//Runs necessary functions for tracing internal transactions through tracers.go
+	IShyftTracer.GetTracerToRun(tx.Hash())
 
 	return nil
 }
 
 func swriteContractBalance(sqldb *sql.DB, tx *types.Transaction) error {
 	sendAndReceiveData := SendAndReceive{
-		From:   tx.From().Hex(),
-		Amount: tx.Value().String(),
+		From:   		tx.From().Hex(),
+		Amount: 		tx.Value().String(),
+		AccountNonce: 	tx.Nonce(),
 	}
 
-	fromAddr := sendAndReceiveData.From
-	amount := sendAndReceiveData.Amount
-	accountNonceSen := tx.Nonce()
-
 	var response string
 	sqlExistsStatement := `SELECT balance from accounts WHERE addr = ($1)`
-	err := sqldb.QueryRow(sqlExistsStatement, fromAddr).Scan(&response)
+	err := sqldb.QueryRow(sqlExistsStatement, sendAndReceiveData.From).Scan(&response)
+
 	switch {
 	case err == sql.ErrNoRows:
-		sqlStatement := `INSERT INTO accounts(addr, balance, txCountAccount) VALUES(($1), ($2), ($3)) RETURNING addr`
-		insertErr := sqldb.QueryRow(sqlStatement, fromAddr, amount, accountNonceSen).Scan(&fromAddr)
+		sqlStatement := `INSERT INTO accounts(addr, balance, accountNonce) VALUES(($1), ($2), ($3)) RETURNING addr`
+		insertErr := sqldb.QueryRow(sqlStatement, sendAndReceiveData.From, sendAndReceiveData.Amount, sendAndReceiveData.AccountNonce).Scan(&sendAndReceiveData.From)
 		if insertErr != nil {
 			panic(insertErr)
 		}
 	default:
-		getAccountBalanceSender:= SGetAccount(sqldb, fromAddr)
+		getAccountBalanceSender:= SGetAccount(sqldb, sendAndReceiveData.From)
+		var newBalanceSender,newAccountNonceSender  big.Int
+		var nonceIncrement = big.NewInt(1)
+
 		var senderBalance SendAndReceive
 		if err := json.Unmarshal([]byte(getAccountBalanceSender), &senderBalance); err != nil {
 			log.Fatal(err)
 		}
 
-		balanceSender := senderBalance.Balance
-		var newBalanceSender big.Int
-		var newAccountNonceSender big.Int
-		var nonceIncrement = big.NewInt(1)
-		updateSQLStatement := `UPDATE accounts SET balance = ($2), txCountAccount = ($3) WHERE addr = ($1)`
+		//Converts string to UINT64 > Big.Int for adding and subtraction
+		balanceSender, _ := strconv.ParseUint(senderBalance.Balance, 10, 64)
+		balanceSen := new(big.Int).SetUint64(balanceSender)
+		senderAccountNonce := new(big.Int).SetUint64(sendAndReceiveData.AccountNonce)
 
-		s := new(big.Int)
-		_, error := fmt.Sscan(balanceSender, s)
-		if error != nil {
-			log.Println("error scanning value:", error)
-		}
-
-		senderAccountNonce := new(big.Int).SetUint64(accountNonceSen)
-
-		newBalanceSender.Sub(s, tx.Value())
+		newBalanceSender.Sub(balanceSen, tx.Value())
 		newAccountNonceSender.Add(senderAccountNonce, nonceIncrement)
 
-		_, err := sqldb.Exec(updateSQLStatement, fromAddr, newBalanceSender.String(), newAccountNonceSender.String())
+		updateSQLStatement := `UPDATE accounts SET balance = ($2), accountNonce = ($3) WHERE addr = ($1)`
+		_, err := sqldb.Exec(updateSQLStatement, sendAndReceiveData.From, newBalanceSender.String(), newAccountNonceSender.String())
 		if err != nil {
 			panic(err)
 		}
@@ -284,92 +244,48 @@ func swriteContractBalance(sqldb *sql.DB, tx *types.Transaction) error {
 	return nil
 }
 
-func swriteContractBalanceHelper(sqldb *sql.DB, tx *types.Transaction) (SendAndReceive, string, string) {
-	sendAndReceiveData := SendAndReceive{
-		From: tx.From().Hex(),
-		Amount: tx.Value().String(),
-	}
-
-	fromAddr := sendAndReceiveData.From
-	getAccountBalanceSender:= SGetAccount(sqldb, fromAddr)
-
-	var senderBalance SendAndReceive
-	if err := json.Unmarshal([]byte(getAccountBalanceSender), &senderBalance); err != nil {
-		log.Fatal(err)
-	}
-	balanceSender := senderBalance.Balance
-	accountNonceSender := senderBalance.TxCountAccount
-
-	return sendAndReceiveData, balanceSender, accountNonceSender
-}
-
 //writeFromBalance writes senders balance to accounts db
 func swriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
 	sendAndReceiveData, balanceRec, balanceSen, accountNonceRec, accountNonceSen := swriteBalanceHelper(sqldb, tx)
-	toAddr := sendAndReceiveData.To
-	fromAddr := sendAndReceiveData.From
-	amount := sendAndReceiveData.Amount
-	balanceReceiver := balanceRec
-	balanceSender := balanceSen
 
 	var response string
 	sqlExistsStatement := `SELECT balance from accounts WHERE addr = ($1)`
-	err := sqldb.QueryRow(sqlExistsStatement, toAddr).Scan(&response)
+	err := sqldb.QueryRow(sqlExistsStatement, sendAndReceiveData.To).Scan(&response)
 
 	switch {
 	case err == sql.ErrNoRows:
-		txCountAccount := strconv.FormatUint(tx.Nonce(), 10)
-		sqlStatement := `INSERT INTO accounts(addr, balance, txCountAccount) VALUES(($1), ($2), ($3)) RETURNING addr`
-		insertErr := sqldb.QueryRow(sqlStatement, toAddr, amount, txCountAccount).Scan(&toAddr)
+		accountNonce := strconv.FormatUint(tx.Nonce(), 10)
+		sqlStatement := `INSERT INTO accounts(addr, balance, accountNonce) VALUES(($1), ($2), ($3)) RETURNING addr`
+		insertErr := sqldb.QueryRow(sqlStatement, sendAndReceiveData.To, sendAndReceiveData.Amount, accountNonce).Scan(&sendAndReceiveData.To)
 		if insertErr != nil {
 			panic(insertErr)
 		}
 	case err != nil:
 		log.Fatal(err)
 	default:
-		var newBalanceReceiver big.Int
-		var newBalanceSender big.Int
-		var newAccountNonceReceiver big.Int
-		var newAccountNonceSender big.Int
+		var newBalanceReceiver, newBalanceSender, newAccountNonceReceiver, newAccountNonceSender  big.Int
 		var nonceIncrement = big.NewInt(1)
-		updateSQLStatement := `UPDATE accounts SET balance = ($2), txCountAccount = ($3) WHERE addr = ($1)`
 
-		r := new(big.Int)
-		_, err := fmt.Sscan(balanceReceiver, r)
-		if err != nil {
-			log.Println("error scanning value:", err)
-		}
+		//Convert UINT64 to BIG.INT in order to add and subtract nonces & balances
+		balanceR := new(big.Int).SetUint64(balanceRec)
+		balanceS := new(big.Int).SetUint64(balanceSen)
 
-		s := new(big.Int)
-		_, error := fmt.Sscan(balanceSender, s)
-		if error != nil {
-			log.Println("error scanning value:", error)
-		}
+		accountR := new(big.Int).SetUint64(accountNonceRec)
+		accountS := new(big.Int).SetUint64(accountNonceSen)
 
-		accountR := new(big.Int)
-		_, er := fmt.Sscan(accountNonceRec, accountR)
-		if er != nil {
-			log.Println("error scanning value:", er)
-		}
-
-		accountS := new(big.Int)
-		_, errors := fmt.Sscan(accountNonceSen, accountS)
-		if errors != nil {
-			log.Println("error scanning value:", error)
-		}
-
-		newBalanceReceiver.Add(r, tx.Value())
-		newBalanceSender.Sub(s, tx.Value())
+		newBalanceReceiver.Add(balanceR, tx.Value())
+		newBalanceSender.Sub(balanceS, tx.Value())
 
 		newAccountNonceReceiver.Add(accountR, nonceIncrement)
 		newAccountNonceSender.Add(accountS, nonceIncrement)
 
-		_, err = sqldb.Exec(updateSQLStatement, toAddr, newBalanceReceiver.String(), newAccountNonceReceiver.String())
+		updateSQLStatement := `UPDATE accounts SET balance = ($2), accountNonce = ($3) WHERE addr = ($1)`
+		_, err = sqldb.Exec(updateSQLStatement, sendAndReceiveData.To, newBalanceReceiver.String(), newAccountNonceReceiver.String())
 		if err != nil {
 			panic(err)
 		}
 
-		_, err = sqldb.Exec(updateSQLStatement, fromAddr, newBalanceSender.String(), newAccountNonceSender.String())
+		_, err = sqldb.Exec(updateSQLStatement, sendAndReceiveData.From, newBalanceSender.String(), newAccountNonceSender.String())
 		if err != nil {
 			panic(err)
 		}
@@ -377,35 +293,30 @@ func swriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
 	return nil
 }
 
-func swriteBalanceHelper(sqldb *sql.DB, tx *types.Transaction) (SendAndReceive, string, string, string, string) {
+func swriteBalanceHelper(sqldb *sql.DB, tx *types.Transaction) (SendAndReceive, uint64, uint64, uint64, uint64) {
 	sendAndReceiveData := SendAndReceive{
 		To: tx.To().Hex(),
 		From: tx.From().Hex(),
 		Amount: tx.Value().String(),
 	}
 
-	toAddr := sendAndReceiveData.To
-	fromAddr := sendAndReceiveData.From
+	getAccountBalanceReceiver := SGetAccount(sqldb, sendAndReceiveData.To)
+	getAccountBalanceSender:= SGetAccount(sqldb, sendAndReceiveData.From)
 
-	getAccountBalanceReceiver := SGetAccount(sqldb, toAddr)
-	getAccountBalanceSender:= SGetAccount(sqldb, fromAddr)
-
-	var receiverBalance SendAndReceive
-	if err := json.Unmarshal([]byte(getAccountBalanceReceiver), &receiverBalance); err != nil {
+	var receiverData SendAndReceive
+	if err := json.Unmarshal([]byte(getAccountBalanceReceiver), &receiverData); err != nil {
 		log.Fatal(err)
 	}
 
-	var senderBalance SendAndReceive
-	if err := json.Unmarshal([]byte(getAccountBalanceSender), &senderBalance); err != nil {
+	var senderData SendAndReceive
+	if err := json.Unmarshal([]byte(getAccountBalanceSender), &senderData); err != nil {
 		log.Fatal(err)
 	}
 
-	balanceReceiver := receiverBalance.Balance
-	balanceSender := senderBalance.Balance
-	accountNonceReceiver := receiverBalance.TxCountAccount
-	accountNonceSender := senderBalance.TxCountAccount
+	balanceReceiver, _ := strconv.ParseUint(receiverData.Balance, 10, 64)
+	balanceSender, _ := strconv.ParseUint(senderData.Balance, 10, 64)
 
-	return sendAndReceiveData, balanceReceiver, balanceSender, accountNonceReceiver, accountNonceSender
+	return sendAndReceiveData, balanceReceiver, balanceSender, receiverData.AccountNonce, senderData.AccountNonce
 }
 
 // @NOTE: This function is extremely complex and requires heavy testing and knowdlege of edge cases:
@@ -446,8 +357,7 @@ func swriteMinerRewards(sqldb *sql.DB, block *types.Block) string {
 	sstoreReward(sqldb, shyftConduitAddress, Rewards.ShyftNetworkBlockReward)
 	var uncRewards = new(big.Int)
 	for i := 0; i < len(uncleAddrs); i++ {
-		uncRewards := uncleRewards[i]
-		fmt.Println(uncRewards)
+		_ = uncleRewards[i]
 		sstoreReward(sqldb, uncleAddrs[i], uncleRewards[i])
 	}
 
@@ -466,10 +376,10 @@ func sstoreReward(sqldb *sql.DB, address string, reward *big.Int) {
 
 	if err == sql.ErrNoRows {
 		// Addr does not exist, thus create new entry
-		createAddressSqlStatement := `INSERT INTO accounts(addr, balance, txCountAccount) VALUES(($1), ($2), ($3)) RETURNING addr`
+		createAddressSqlStatement := `INSERT INTO accounts(addr, balance, accountNonce) VALUES(($1), ($2), ($3)) RETURNING addr`
 
 		// We convert totalReward into a string and postgres converts into number
-		_, insertErr := sqldb.Exec(createAddressSqlStatement, address, reward.String(), 0)
+		_, insertErr := sqldb.Exec(createAddressSqlStatement, address, reward.String(), 1)
 		if insertErr != nil {
 			panic(insertErr)
 		}
@@ -499,574 +409,4 @@ func sstoreReward(sqldb *sql.DB, address string, reward *big.Int) {
 	}
 }
 
-///////////
-// Getters
-//////////
-//GetAllBlocks returns []SBlock blocks for API
 
-//Look into postgres functions array_to_json(array_agg(lap))
-//Example select array_to_json(array_agg(lap))
-//from ( select * from blocks)lap;
-func SGetAllBlocks(sqldb *sql.DB) string {
-	var arr blockRes
-	var blockArr string
-	rows, err := sqldb.Query(`
-		SELECT * FROM blocks`)
-	if err != nil {
-		fmt.Println("err")
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var hash string
-		var coinbase string
-		var gasUsed uint64
-		var gasLimit uint64
-		var txCount int
-		var uncleCount int
-		var age string
-		var parentHash string
-		var uncleHash string
-		var difficulty string
-		var size string
-		var nonce uint64
-		var rewards string
-		var num string
-
-		err = rows.Scan(
-			&hash,
-			&coinbase,
-			&gasUsed,
-			&gasLimit,
-			&txCount,
-			&uncleCount,
-			&age,
-			&parentHash,
-			&uncleHash,
-			&difficulty,
-			&size,
-			&nonce,
-			&rewards,
-			&num,)
-
-		arr.Blocks = append(arr.Blocks, SBlock{
-			Hash:     hash,
-			Coinbase: coinbase,
-			GasUsed: gasUsed,
-			GasLimit: gasLimit,
-			TxCount: txCount,
-			UncleCount: uncleCount,
-			Age: age,
-			ParentHash:parentHash,
-			UncleHash:uncleHash,
-			Difficulty:difficulty,
-			Size: size,
-			Nonce:nonce,
-			Rewards: rewards,
-			Number:   num,
-		})
-
-		blocks, _ := json.Marshal(arr.Blocks)
-		blocksFmt := string(blocks)
-		blockArr = blocksFmt
-	}
-	return blockArr
-}
-
-//GetBlock queries to send single block info
-//TODO provide blockHash arg passed from handler.go
-func SGetBlock(sqldb *sql.DB, blockNumber string) string {
-	sqlStatement := `SELECT * FROM blocks WHERE number=$1;`
-	row := sqldb.QueryRow(sqlStatement, blockNumber)
-	var hash string
-	var coinbase string
-	var gasUsed uint64
-	var gasLimit uint64
-	var txCount int
-	var uncleCount int
-	var age string
-	var parentHash string
-	var uncleHash string
-	var difficulty string
-	var size string
-	var nonce uint64
-	var rewards string
-	var num string
-	row.Scan(
-		&hash,
-		&coinbase,
-		&gasUsed,
-		&gasLimit,
-		&txCount,
-		&uncleCount,
-		&age,
-		&parentHash,
-		&uncleHash,
-		&difficulty,
-		&size,
-		&nonce,
-		&rewards,
-		&num,)
-
-	block := SBlock{
-		Hash:     hash,
-		Coinbase: coinbase,
-		GasUsed: gasUsed,
-		GasLimit: gasLimit,
-		TxCount: txCount,
-		UncleCount: uncleCount,
-		Age: age,
-		ParentHash:parentHash,
-		UncleHash:uncleHash,
-		Difficulty:difficulty,
-		Size: size,
-		Nonce:nonce,
-		Rewards: rewards,
-		Number:   num,
-	}
-	json, _ := json.Marshal(block)
-	return string(json)
-}
-
-func SGetRecentBlock(sqldb *sql.DB) string {
-	sqlStatement := `SELECT * FROM blocks WHERE number=(SELECT MAX(number) FROM blocks);`
-	row := sqldb.QueryRow(sqlStatement)
-	var hash string
-	var coinbase string
-	var gasUsed uint64
-	var gasLimit uint64
-	var txCount int
-	var uncleCount int
-	var age string
-	var parentHash string
-	var uncleHash string
-	var difficulty string
-	var size string
-	var nonce uint64
-	var rewards string
-	var num string
-	row.Scan(
-		&hash,
-		&coinbase,
-		&gasUsed,
-		&gasLimit,
-		&txCount,
-		&uncleCount,
-		&age,
-		&parentHash,
-		&uncleHash,
-		&difficulty,
-		&size,
-		&nonce,
-		&rewards,
-		&num,)
-
-	block := SBlock{
-		Hash:     hash,
-		Coinbase: coinbase,
-		GasUsed: gasUsed,
-		GasLimit: gasLimit,
-		TxCount: txCount,
-		UncleCount: uncleCount,
-		Age: age,
-		ParentHash:parentHash,
-		UncleHash:uncleHash,
-		Difficulty:difficulty,
-		Size: size,
-		Nonce:nonce,
-		Rewards: rewards,
-		Number:   num,
-	}
-	json, _ := json.Marshal(block)
-	return string(json)
-}
-
-func SGetAllTransactionsFromBlock(sqldb *sql.DB, blockNumber string) string {
-	var arr txRes
-	var txx string
-	sqlStatement := `SELECT * FROM txs WHERE blocknumber=$1`
-	rows, err := sqldb.Query(sqlStatement, blockNumber)
-	if err != nil {
-		fmt.Println("err")
-	}
-	defer rows.Close()
-	for rows.Next() {
-		var txhash string
-		var to_addr string
-		var from_addr string
-		var blockhash string
-		var blocknumber string
-		var amount string
-		var gasprice uint64
-		var gas uint64
-		var gasLimit uint64
-		var txfee uint64
-		var nonce uint64
-		var status string
-		var isContract bool
-		var age time.Time
-		var data []byte
-		err = rows.Scan(
-			&txhash,
-			&to_addr,
-			&from_addr,
-			&blockhash,
-			&blocknumber,
-			&amount,
-			&gasprice,
-			&gas,
-			&gasLimit,
-			&txfee,
-			&nonce,
-			&status,
-			&isContract,
-			&age,
-			&data,
-		)
-
-		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
-			TxHash:    txhash,
-			To:        to_addr,
-			From:      from_addr,
-			BlockHash: blockhash,
-			BlockNumber: blocknumber,
-			Amount:    amount,
-			GasPrice:  gasprice,
-			Gas:       gas,
-			GasLimit: gasLimit,
-			Cost:      txfee,
-			Nonce:     nonce,
-			Status:    status,
-			IsContract: isContract,
-			Age:		age,
-			Data: 		data,
-		})
-
-		tx, _ := json.Marshal(arr.TxEntry)
-		newtx := string(tx)
-		txx = newtx
-	}
-	return txx
-}
-
-func SGetAllBlocksMinedByAddress(sqldb *sql.DB, coinbase string) string {
-	var arr blockRes
-	var blockArr string
-	sqlStatement := `SELECT * FROM blocks WHERE coinbase=$1`
-	rows, err := sqldb.Query(sqlStatement, coinbase)
-	if err != nil {
-		fmt.Println("err")
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var hash string
-		var coinbase string
-		var gasUsed uint64
-		var gasLimit uint64
-		var txCount int
-		var uncleCount int
-		var age string
-		var parentHash string
-		var uncleHash string
-		var difficulty string
-		var size string
-		var nonce uint64
-		var rewards string
-		var num string
-
-		err = rows.Scan(
-			&hash,
-			&coinbase,
-			&gasUsed,
-			&gasLimit,
-			&txCount,
-			&uncleCount,
-			&age,
-			&parentHash,
-			&uncleHash,
-			&difficulty,
-			&size,
-			&nonce,
-			&rewards,
-			&num,)
-
-		arr.Blocks = append(arr.Blocks, SBlock{
-			Hash:     hash,
-			Coinbase: coinbase,
-			GasUsed: gasUsed,
-			GasLimit: gasLimit,
-			TxCount: txCount,
-			UncleCount: uncleCount,
-			Age: age,
-			ParentHash:parentHash,
-			UncleHash:uncleHash,
-			Difficulty:difficulty,
-			Size: size,
-			Nonce:nonce,
-			Rewards: rewards,
-			Number:   num,
-		})
-
-		blocks, _ := json.Marshal(arr.Blocks)
-		blocksFmt := string(blocks)
-		blockArr = blocksFmt
-	}
-	return blockArr
-}
-
-//GetAllTransactions getter fn for API
-func SGetAllTransactions(sqldb *sql.DB) string {
-	var arr txRes
-	var txx string
-	rows, err := sqldb.Query(`
-		SELECT * FROM txs`)
-	if err != nil {
-		fmt.Println("err")
-	}
-	defer rows.Close()
-	for rows.Next() {
-		var txhash string
-		var to_addr string
-		var from_addr string
-		var blockhash string
-		var blocknumber string
-		var amount string
-		var gasprice uint64
-		var gas uint64
-		var gasLimit uint64
-		var txfee uint64
-		var nonce uint64
-		var status string
-		var isContract bool
-		var age time.Time
-		var data []byte
-		err = rows.Scan(
-			&txhash,
-			&to_addr,
-			&from_addr,
-			&blockhash,
-			&blocknumber,
-			&amount,
-			&gasprice,
-			&gas,
-			&gasLimit,
-			&txfee,
-			&nonce,
-			&status,
-			&isContract,
-			&age,
-			&data,
-		)
-
-		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
-			TxHash:    txhash,
-			To:        to_addr,
-			From:      from_addr,
-			BlockHash: blockhash,
-			BlockNumber: blocknumber,
-			Amount:    amount,
-			GasPrice:  gasprice,
-			Gas:       gas,
-			GasLimit: gasLimit,
-			Cost:      txfee,
-			Nonce:     nonce,
-			Status:    status,
-			IsContract: isContract,
-			Age:		age,
-			Data: 		data,
-		})
-
-		tx, _ := json.Marshal(arr.TxEntry)
-		newtx := string(tx)
-		txx = newtx
-	}
-	return txx
-}
-
-//GetTransaction fn returns single tx
-func SGetTransaction(sqldb *sql.DB, txHash string) string {
-	sqlStatement := `SELECT * FROM txs WHERE txhash=$1;`
-	row := sqldb.QueryRow(sqlStatement, txHash)
-	var txhash string
-	var to_addr string
-	var from_addr string
-	var blockhash string
-	var blocknumber string
-	var amount string
-	var gasprice uint64
-	var gas uint64
-	var gasLimit uint64
-	var txfee uint64
-	var nonce uint64
-	var status string
-	var isContract bool
-	var age time.Time
-	var data []byte
-	row.Scan(
-		&txhash,
-		&to_addr,
-		&from_addr,
-		&blockhash,
-		&blocknumber,
-		&amount,
-		&gasprice,
-		&gas,
-		&gasLimit,
-		&txfee,
-		&nonce,
-		&status,
-		&isContract,
-		&age,
-		&data)
-
-	tx := ShyftTxEntryPretty{
-		TxHash:    txhash,
-		To:        to_addr,
-		From:      from_addr,
-		BlockHash: blockhash,
-		BlockNumber: blocknumber,
-		Amount:    amount,
-		GasPrice:  gasprice,
-		Gas:       gas,
-		GasLimit:	gasLimit,
-		Cost:      txfee,
-		Nonce:     nonce,
-		Status:    status,
-		IsContract: isContract,
-		Age:		age,
-		Data:	   data,
-	}
-	json, _ := json.Marshal(tx)
-
-	return string(json)
-}
-
-//GetAccount returns account balances
-func SGetAccount(sqldb *sql.DB, address string) string {
-	sqlStatement := `SELECT * FROM accounts WHERE addr=$1;`
-	row := sqldb.QueryRow(sqlStatement, address)
-	var addr string
-	var balance string
-	var txCountAccount string
-	row.Scan(
-		&addr,
-		&balance,
-		&txCountAccount)
-
-	account := SAccounts{
-		Addr:    addr,
-		Balance: balance,
-		TxCountAccount: txCountAccount,
-	}
-	json, _ := json.Marshal(account)
-	return string(json)
-}
-
-//GetAllAccounts returns all accounts and balances
-func SGetAllAccounts(sqldb *sql.DB) string {
-	var array accountRes
-	var accountsArr string
-	var txCountAccount string
-	accs, err := sqldb.Query(`
-		SELECT
-			addr,
-			balance,
-			txCountAccount
-		FROM accounts`)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	defer accs.Close()
-
-	for accs.Next() {
-		var addr string
-		var balance string
-		err = accs.Scan(
-			&addr,
-			&balance,
-			&txCountAccount,
-		)
-
-		array.AllAccounts = append(array.AllAccounts, SAccounts{
-			Addr:    addr,
-			Balance: balance,
-			TxCountAccount: txCountAccount,
-		})
-
-		accounts, _ := json.Marshal(array.AllAccounts)
-		accountsFmt := string(accounts)
-		accountsArr = accountsFmt
-	}
-	return accountsArr
-}
-
-//GetAccount returns account balances
-func SGetAccountTxs(sqldb *sql.DB, address string) string {
-	var arr txRes
-	var txx string
-	sqlStatement := `SELECT * FROM txs WHERE to_addr=$1 OR from_addr=$1;`
-	rows, err := sqldb.Query(sqlStatement, address)
-	if err != nil {
-		fmt.Println("err")
-	}
-	defer rows.Close()
-	for rows.Next() {
-		var txhash string
-		var to_addr string
-		var from_addr string
-		var blockhash string
-		var blocknumber string
-		var amount string
-		var gasprice uint64
-		var gas uint64
-		var gasLimit uint64
-		var txfee uint64
-		var nonce uint64
-		var status string
-		var isContract bool
-		var age time.Time
-		var data []byte
-		err = rows.Scan(
-			&txhash,
-			&to_addr,
-			&from_addr,
-			&blockhash,
-			&blocknumber,
-			&amount,
-			&gasprice,
-			&gas,
-			&gasLimit,
-			&txfee,
-			&nonce,
-			&status,
-			&isContract,
-			&age,
-			&data,
-		)
-
-		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
-			TxHash:    txhash,
-			To:        to_addr,
-			From:      from_addr,
-			BlockHash: blockhash,
-			BlockNumber: blocknumber,
-			Amount:    amount,
-			GasPrice:  gasprice,
-			Gas:       gas,
-			GasLimit: gasLimit,
-			Cost:      txfee,
-			Nonce:     nonce,
-			Status:    status,
-			IsContract: isContract,
-			Age:		age,
-			Data: 		data,
-		})
-
-		tx, _ := json.Marshal(arr.TxEntry)
-		newtx := string(tx)
-		txx = newtx
-	}
-	return txx
-}
diff --git a/core/shyft_get_utils.go b/core/shyft_get_utils.go
new file mode 100644
index 0000000000..97f64ee9b9
--- /dev/null
+++ b/core/shyft_get_utils.go
@@ -0,0 +1,381 @@
+package core
+
+import (
+	"encoding/json"
+	"database/sql"
+	"fmt"
+	"time"
+)
+
+///////////
+// Getters
+//////////
+func SGetAllBlocks(sqldb *sql.DB) string {
+	var arr blockRes
+	var blockArr string
+	rows, err := sqldb.Query(`SELECT * FROM blocks`)
+	if err != nil {
+		fmt.Println("err")
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var hash, coinbase, age, parentHash, uncleHash, difficulty, size, rewards, num string
+		var gasUsed, gasLimit, nonce uint64
+		var txCount, uncleCount int
+
+		err = rows.Scan(
+			&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num,)
+
+		arr.Blocks = append(arr.Blocks, SBlock{
+			Hash:     		hash,
+			Coinbase: 		coinbase,
+			GasUsed: 		gasUsed,
+			GasLimit: 		gasLimit,
+			TxCount: 		txCount,
+			UncleCount: 	uncleCount,
+			Age: 			age,
+			ParentHash:		parentHash,
+			UncleHash:		uncleHash,
+			Difficulty:		difficulty,
+			Size: 			size,
+			Nonce:			nonce,
+			Rewards: 		rewards,
+			Number:   		num,
+		})
+
+		blocks, _ := json.Marshal(arr.Blocks)
+		blocksFmt := string(blocks)
+		blockArr = blocksFmt
+	}
+	return blockArr
+}
+
+//GetBlock queries to send single block info
+//TODO provide blockHash arg passed from handler.go
+func SGetBlock(sqldb *sql.DB, blockNumber string) string {
+	sqlStatement := `SELECT * FROM blocks WHERE number=$1;`
+	row := sqldb.QueryRow(sqlStatement, blockNumber)
+	var hash, coinbase, age, parentHash, uncleHash, difficulty, size, rewards, num string
+	var gasUsed, gasLimit, nonce uint64
+	var txCount, uncleCount int
+
+	row.Scan(
+		&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num,)
+
+	block := SBlock{
+		Hash:     	hash,
+		Coinbase: 	coinbase,
+		GasUsed: 	gasUsed,
+		GasLimit: 	gasLimit,
+		TxCount: 	txCount,
+		UncleCount: uncleCount,
+		Age: 		age,
+		ParentHash:	parentHash,
+		UncleHash:	uncleHash,
+		Difficulty:	difficulty,
+		Size: 		size,
+		Nonce:		nonce,
+		Rewards: 	rewards,
+		Number:   	num,
+	}
+	json, _ := json.Marshal(block)
+	return string(json)
+}
+
+func SGetRecentBlock(sqldb *sql.DB) string {
+	sqlStatement := `SELECT * FROM blocks WHERE number=(SELECT MAX(number) FROM blocks);`
+	row := sqldb.QueryRow(sqlStatement)
+	var hash, coinbase, age, parentHash, uncleHash, difficulty, size, rewards, num string
+	var gasUsed, gasLimit, nonce uint64
+	var txCount, uncleCount int
+
+	row.Scan(
+		&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num,)
+
+	block := SBlock{
+		Hash:     	hash,
+		Coinbase: 	coinbase,
+		GasUsed: 	gasUsed,
+		GasLimit: 	gasLimit,
+		TxCount: 	txCount,
+		UncleCount: uncleCount,
+		Age: 		age,
+		ParentHash:	parentHash,
+		UncleHash:	uncleHash,
+		Difficulty:	difficulty,
+		Size: 		size,
+		Nonce:		nonce,
+		Rewards: 	rewards,
+		Number:   	num,
+	}
+	json, _ := json.Marshal(block)
+	return string(json)
+}
+
+func SGetAllTransactionsFromBlock(sqldb *sql.DB, blockNumber string) string {
+	var arr txRes
+	var txx string
+	sqlStatement := `SELECT * FROM txs WHERE blocknumber=$1`
+	rows, err := sqldb.Query(sqlStatement, blockNumber)
+	if err != nil {
+		fmt.Println("err")
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var txhash, to_addr, from_addr, blockhash, blocknumber, amount, status string
+		var gasprice, gas, gasLimit, txfee, nonce uint64
+		var isContract bool
+		var age time.Time
+		var data []byte
+
+		err = rows.Scan(
+			&txhash, &to_addr, &from_addr, &blockhash, &blocknumber, &amount, &gasprice, &gas, &gasLimit, &txfee, &nonce, &status, &isContract, &age, &data,
+		)
+
+		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
+			TxHash:    	 txhash,
+			To:        	 to_addr,
+			From:      	 from_addr,
+			BlockHash: 	 blockhash,
+			BlockNumber: blocknumber,
+			Amount:    	 amount,
+			GasPrice:  	 gasprice,
+			Gas:       	 gas,
+			GasLimit: 	 gasLimit,
+			Cost:      	 txfee,
+			Nonce:     	 nonce,
+			Status:    	 status,
+			IsContract:  isContract,
+			Age:		 age,
+			Data: 		 data,
+		})
+
+		tx, _ := json.Marshal(arr.TxEntry)
+		newtx := string(tx)
+		txx = newtx
+	}
+	return txx
+}
+
+func SGetAllBlocksMinedByAddress(sqldb *sql.DB, coinbase string) string {
+	var arr blockRes
+	var blockArr string
+	sqlStatement := `SELECT * FROM blocks WHERE coinbase=$1`
+	rows, err := sqldb.Query(sqlStatement, coinbase)
+	if err != nil {
+		fmt.Println("err")
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var hash, coinbase, age, parentHash, uncleHash, difficulty, size, rewards, num string
+		var gasUsed, gasLimit, nonce uint64
+		var txCount, uncleCount int
+
+		err = rows.Scan(
+			&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num,)
+
+		arr.Blocks = append(arr.Blocks, SBlock{
+			Hash:     hash,
+			Coinbase: coinbase,
+			GasUsed: gasUsed,
+			GasLimit: gasLimit,
+			TxCount: txCount,
+			UncleCount: uncleCount,
+			Age: age,
+			ParentHash:parentHash,
+			UncleHash:uncleHash,
+			Difficulty:difficulty,
+			Size: size,
+			Nonce:nonce,
+			Rewards: rewards,
+			Number:   num,
+		})
+
+		blocks, _ := json.Marshal(arr.Blocks)
+		blocksFmt := string(blocks)
+		blockArr = blocksFmt
+	}
+	return blockArr
+}
+
+//GetAllTransactions getter fn for API
+func SGetAllTransactions(sqldb *sql.DB) string {
+	var arr txRes
+	var txx string
+	rows, err := sqldb.Query(`SELECT * FROM txs`)
+	if err != nil {
+		fmt.Println("err")
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var txhash, to_addr, from_addr, blockhash, blocknumber, amount, status string
+		var gasprice, gas, gasLimit, txfee, nonce uint64
+		var isContract bool
+		var age time.Time
+		var data []byte
+
+		err = rows.Scan(
+			&txhash, &to_addr, &from_addr, &blockhash, &blocknumber, &amount, &gasprice, &gas, &gasLimit, &txfee, &nonce, &status, &isContract, &age, &data,
+		)
+
+		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
+			TxHash:    	 txhash,
+			To:        	 to_addr,
+			From:      	 from_addr,
+			BlockHash: 	 blockhash,
+			BlockNumber: blocknumber,
+			Amount:    	 amount,
+			GasPrice:  	 gasprice,
+			Gas:       	 gas,
+			GasLimit: 	 gasLimit,
+			Cost:      	 txfee,
+			Nonce:     	 nonce,
+			Status:    	 status,
+			IsContract:  isContract,
+			Age:		 age,
+			Data: 		 data,
+		})
+
+		tx, _ := json.Marshal(arr.TxEntry)
+		newtx := string(tx)
+		txx = newtx
+	}
+	return txx
+}
+
+//GetTransaction fn returns single tx
+func SGetTransaction(sqldb *sql.DB, txHash string) string {
+	sqlStatement := `SELECT * FROM txs WHERE txhash=$1;`
+	row := sqldb.QueryRow(sqlStatement, txHash)
+	var txhash, to_addr, from_addr, blockhash, blocknumber, amount, status string
+	var gasprice, gas, gasLimit, txfee, nonce uint64
+	var isContract bool
+	var age time.Time
+	var data []byte
+
+	row.Scan(
+		&txhash, &to_addr, &from_addr, &blockhash, &blocknumber, &amount, &gasprice, &gas, &gasLimit, &txfee, &nonce, &status, &isContract, &age, &data)
+
+	tx := ShyftTxEntryPretty{
+		TxHash:      txhash,
+		To:        	 to_addr,
+		From:      	 from_addr,
+		BlockHash: 	 blockhash,
+		BlockNumber: blocknumber,
+		Amount:      amount,
+		GasPrice:    gasprice,
+		Gas:         gas,
+		GasLimit:	 gasLimit,
+		Cost:      	 txfee,
+		Nonce:     	 nonce,
+		Status:    	 status,
+		IsContract:  isContract,
+		Age:		 age,
+		Data:	     data,
+	}
+	json, _ := json.Marshal(tx)
+
+	return string(json)
+}
+
+//GetAccount returns account balances
+func SGetAccount(sqldb *sql.DB, address string) string {
+	sqlStatement := `SELECT * FROM accounts WHERE addr=$1;`
+	row := sqldb.QueryRow(sqlStatement, address)
+	var addr, balance, accountNonce string
+
+	row.Scan(
+		&addr, &balance, &accountNonce)
+
+	account := SAccounts{
+		Addr:    		addr,
+		Balance: 		balance,
+		AccountNonce: 	accountNonce,
+	}
+	json, _ := json.Marshal(account)
+	return string(json)
+}
+
+//GetAllAccounts returns all accounts and balances
+func SGetAllAccounts(sqldb *sql.DB) string {
+	var array accountRes
+	var accountsArr, accountNonce string
+
+	accs, err := sqldb.Query(`
+		SELECT
+			addr,
+			balance,
+			accountNonce
+		FROM accounts`)
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	defer accs.Close()
+
+	for accs.Next() {
+		var addr, balance string
+		err = accs.Scan(
+			&addr, &balance, &accountNonce,
+		)
+
+		array.AllAccounts = append(array.AllAccounts, SAccounts{
+			Addr:    		addr,
+			Balance: 		balance,
+			AccountNonce: 	accountNonce,
+		})
+
+		accounts, _ := json.Marshal(array.AllAccounts)
+		accountsFmt := string(accounts)
+		accountsArr = accountsFmt
+	}
+	return accountsArr
+}
+
+//GetAccount returns account balances
+func SGetAccountTxs(sqldb *sql.DB, address string) string {
+	var arr txRes
+	var txx string
+	sqlStatement := `SELECT * FROM txs WHERE to_addr=$1 OR from_addr=$1;`
+	rows, err := sqldb.Query(sqlStatement, address)
+	if err != nil {
+		fmt.Println("err", err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var txhash, to_addr, from_addr, blockhash, blocknumber, amount, status string
+		var gasprice, gas, gasLimit, txfee, nonce uint64
+		var isContract bool
+		var age time.Time
+		var data []byte
+
+		err = rows.Scan(
+			&txhash, &to_addr, &from_addr, &blockhash, &blocknumber, &amount, &gasprice, &gas, &gasLimit, &txfee, &nonce, &status, &isContract, &age, &data,
+		)
+
+		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
+			TxHash:    	 txhash,
+			To:        	 to_addr,
+			From:      	 from_addr,
+			BlockHash:   blockhash,
+			BlockNumber: blocknumber,
+			Amount:    	 amount,
+			GasPrice:  	 gasprice,
+			Gas:       	 gas,
+			GasLimit: 	 gasLimit,
+			Cost:      	 txfee,
+			Nonce:     	 nonce,
+			Status:    	 status,
+			IsContract:  isContract,
+			Age:		 age,
+			Data: 		 data,
+		})
+
+		tx, _ := json.Marshal(arr.TxEntry)
+		newtx := string(tx)
+		txx = newtx
+	}
+	return txx
+}
diff --git a/shyft-cli/postgres_setup/create_tables.psql b/shyft-cli/postgres_setup/create_tables.psql
index 259a95b23e..b913fc4f25 100644
--- a/shyft-cli/postgres_setup/create_tables.psql
+++ b/shyft-cli/postgres_setup/create_tables.psql
@@ -36,7 +36,7 @@ CREATE TABLE IF NOT EXISTS txs (
 CREATE TABLE IF NOT EXISTS accounts (
   addr text primary key unique,
   balance numeric,
-  txCountAccount numeric
+  accountNonce numeric
 );
 
 CREATE TABLE IF NOT EXISTS contracts (
diff --git a/shyftDb/postgres_setup_test/create_tables_test.psql b/shyftDb/postgres_setup_test/create_tables_test.psql
index 2cd9bc5176..9d0a553cbf 100644
--- a/shyftDb/postgres_setup_test/create_tables_test.psql
+++ b/shyftDb/postgres_setup_test/create_tables_test.psql
@@ -36,5 +36,5 @@ CREATE TABLE IF NOT EXISTS txs (
 CREATE TABLE IF NOT EXISTS accounts (
   addr text primary key unique,
   balance numeric,
-  txCountAccount numeric
+  accountnonce numeric
 );
\ No newline at end of file
diff --git a/shyftDb/shyft_database_util_test.go b/shyftDb/shyft_database_util_test.go
index b5f0409e31..c6271af8d1 100644
--- a/shyftDb/shyft_database_util_test.go
+++ b/shyftDb/shyft_database_util_test.go
@@ -12,6 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
 	"strconv"
+	"fmt"
 )
 
 type ShyftTracer struct {}
@@ -66,11 +67,12 @@ func TestBlock(t *testing.T) {
 		receipts := []*types.Receipt{receipt}
 		block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts)
 
+		fmt.Println("++++++HERE")
 		// Write and verify the block in the database
 		if err := core.SWriteBlock(block, receipts); err != nil {
 			t.Fatalf("Failed to write block into database: %v", err)
 		}
-
+		fmt.Println("++++++AND HERE")
 		sqldb, err := core.DBConnection()
 		if err != nil {
 			panic(err)
@@ -467,8 +469,8 @@ t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
 		if tx.Value().String() != accountDataTo.Balance {
 			t.Fatalf("To address balance [%v]: To address balance not found", accountDataTo.Balance)
 		}
-		if strconv.FormatUint(tx.Nonce(), 10) != accountDataTo.TxCountAccount {
-			t.Fatalf("To account nonce [%v]: To account nonce not found", accountDataTo.TxCountAccount)
+		if strconv.FormatUint(tx.Nonce(), 10) != accountDataTo.AccountNonce {
+			t.Fatalf("To account nonce [%v]: To account nonce not found", accountDataTo.AccountNonce)
 		}
 		if getAllAccountTxs := core.SGetAccountTxs(sqldb, tx.To().String()); len(getAllAccountTxs) == 0 {
 			t.Fatalf("GetAccountTxs [%v]: GetAccountTxs did not return correctly", getAllAccountTxs)

From 42183a45800606b213f64f8bd34cd69af7f43b2b Mon Sep 17 00:00:00 2001
From: Dustin Brickwood <dustinbrickwood204@gmail.com>
Date: Fri, 20 Jul 2018 15:39:14 -0400
Subject: [PATCH 23/27] tmp

---
 core/shyft_database_util.go         | 16 ++++++-
 shyftDb/shyft_database_util_test.go | 72 ++++++++++++++++++-----------
 2 files changed, 60 insertions(+), 28 deletions(-)

diff --git a/core/shyft_database_util.go b/core/shyft_database_util.go
index 3a92ff5df2..b40a3f6e54 100644
--- a/core/shyft_database_util.go
+++ b/core/shyft_database_util.go
@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	Rewards "github.com/ethereum/go-ethereum/consensus/ethash"
 	"github.com/ethereum/go-ethereum/shyfttracerinterface"
+	"fmt"
 )
 
 var IShyftTracer shyfttracerinterface.IShyftTracer
@@ -300,9 +301,11 @@ func swriteBalanceHelper(sqldb *sql.DB, tx *types.Transaction) (SendAndReceive,
 		Amount: tx.Value().String(),
 	}
 
+	fmt.Println("TO", sendAndReceiveData.To)
+	fmt.Println("FROM", sendAndReceiveData.From)
 	getAccountBalanceReceiver := SGetAccount(sqldb, sendAndReceiveData.To)
 	getAccountBalanceSender:= SGetAccount(sqldb, sendAndReceiveData.From)
-
+	fmt.Println("HERE", getAccountBalanceReceiver)
 	var receiverData SendAndReceive
 	if err := json.Unmarshal([]byte(getAccountBalanceReceiver), &receiverData); err != nil {
 		log.Fatal(err)
@@ -410,3 +413,14 @@ func sstoreReward(sqldb *sql.DB, address string, reward *big.Int) {
 }
 
 
+func CreateAccount (sqldb *sql.DB, addr string, amount uint64, accountNonce uint64) {
+
+	sqlStatement := `INSERT INTO accounts(addr, balance, accountNonce) VALUES(($1), ($2), ($3)) RETURNING addr`
+	insertErr := sqldb.QueryRow(sqlStatement, addr, amount, accountNonce).Scan(&addr)
+	if insertErr != nil {
+		panic(insertErr)
+	}
+
+}
+
+
diff --git a/shyftDb/shyft_database_util_test.go b/shyftDb/shyft_database_util_test.go
index c6271af8d1..a03e0cb4f8 100644
--- a/shyftDb/shyft_database_util_test.go
+++ b/shyftDb/shyft_database_util_test.go
@@ -11,7 +11,6 @@ import (
 	"encoding/json"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
-	"strconv"
 	"fmt"
 )
 
@@ -425,12 +424,29 @@ t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
 	key, _   := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 	signer  := types.NewEIP155Signer(big.NewInt(2147483647))
 
+	toAddr1 := common.BytesToAddress([]byte{0x11})
+	toAddr2 := common.BytesToAddress([]byte{0x22})
+	toAddr3 := common.BytesToAddress([]byte{0x33})
+
+	toAmount1 := big.NewInt(111)
+	var toAmountPrev1 uint64 = 3968686868
+
+	sqldb, err := core.DBConnection()
+	if (err != nil) {
+		panic(err)
+	}
+
+	core.CreateAccount(sqldb, toAddr1.Hex(), toAmountPrev1, 1)
+	core.CreateAccount(sqldb, toAddr2.Hex(), 423798729847, 1)
+	core.CreateAccount(sqldb, toAddr3.Hex(), 0, 1)
+	core.CreateAccount(sqldb, "0x71562b71999873DB5b286dF957af199Ec94617F7", 3968686868, 1)
+
 	//Nonce, To Address,Value, GasLimit, Gasprice, data
-	tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), big.NewInt(111), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
+	tx1 := types.NewTransaction(1, toAddr1, toAmount1, 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
 	mytx,_ := types.SignTx(tx1, signer, key)
-	tx2 := types.NewTransaction(2, common.BytesToAddress([]byte{0x22}), big.NewInt(222), 2222, big.NewInt(22222), []byte{0x22, 0x22, 0x22})
+	tx2 := types.NewTransaction(2, toAddr2, big.NewInt(222), 2222, big.NewInt(22222), []byte{0x22, 0x22, 0x22})
 	mytx2,_ := types.SignTx(tx2, signer, key)
-	tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
+	tx3 := types.NewTransaction(3, toAddr3, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
 	mytx3,_ := types.SignTx(tx3, signer, key)
 	txs := []*types.Transaction{mytx, mytx2, mytx3}
 
@@ -452,37 +468,39 @@ t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
 			t.Fatalf("Failed to write block into database: %v", err)
 		}
 
-	sqldb, err := core.DBConnection()
-	if (err != nil) {
-		panic(err)
+	if toAddr1.String() != tx1.To().String() {
+		t.Fatalf("To address [%v]: To address not found", toAddr1.String())
 	}
+	accountAddrTo := core.SGetAccount(sqldb, toAddr1.String())
+	
 
-	for _, tx := range txs {
-			accountAddrTo := core.SGetAccount(sqldb, tx.To().String())
-			byts := []byte(accountAddrTo)
-			var accountDataTo core.SAccounts
-			json.Unmarshal(byts, &accountDataTo)
 
-		if tx.To().String() != accountDataTo.Addr {
-			t.Fatalf("To address [%v]: To address not found", accountDataTo.Addr)
-		}
-		if tx.Value().String() != accountDataTo.Balance {
-			t.Fatalf("To address balance [%v]: To address balance not found", accountDataTo.Balance)
-		}
-		if strconv.FormatUint(tx.Nonce(), 10) != accountDataTo.AccountNonce {
-			t.Fatalf("To account nonce [%v]: To account nonce not found", accountDataTo.AccountNonce)
-		}
-		if getAllAccountTxs := core.SGetAccountTxs(sqldb, tx.To().String()); len(getAllAccountTxs) == 0 {
-			t.Fatalf("GetAccountTxs [%v]: GetAccountTxs did not return correctly", getAllAccountTxs)
-		}
-	}
+	//for _, tx := range txs {
+	//	accountAddrTo := core.SGetAccount(sqldb, tx.To().String())
+	//	byts := []byte(accountAddrTo)
+	//	var accountDataTo core.SAccounts
+	//	json.Unmarshal(byts, &accountDataTo)
+	//
+	//	if tx.To().String() != accountDataTo.Addr {
+	//		t.Fatalf("To address [%v]: To address not found", accountDataTo.Addr)
+	//	}
+	//	if tx.Value().String() != accountDataTo.Balance {
+	//		t.Fatalf("To address balance [%v]: To address balance not found", accountDataTo.Balance)
+	//	}
+	//	if strconv.FormatUint(tx.Nonce(), 10) != accountDataTo.AccountNonce {
+	//		t.Fatalf("To account nonce [%v]: To account nonce not found", accountDataTo.AccountNonce)
+	//	}
+	//	if getAllAccountTxs := core.SGetAccountTxs(sqldb, tx.To().String()); len(getAllAccountTxs) == 0 {
+	//		t.Fatalf("GetAccountTxs [%v]: GetAccountTxs did not return correctly", getAllAccountTxs)
+	//	}
+	//}
 
 	if getAllAccounts := core.SGetAllAccounts(sqldb); len(getAllAccounts) == 0 {
 		t.Fatalf("GetAllAccounts [%v]: GetAllAccounts did not return correctly", getAllAccounts)
 	}
-	ClearTables()
+	//ClearTables()
 })
 
-	ClearTables()
+	//ClearTables()
 }
 

From afdefa369087cd91e588080f6b40cc10469e78df Mon Sep 17 00:00:00 2001
From: Dustin Brickwood <dustinbrickwood204@gmail.com>
Date: Fri, 20 Jul 2018 16:24:55 -0400
Subject: [PATCH 24/27] need to pop stash

---
 shyftDb/shyft_database_util_test.go | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/shyftDb/shyft_database_util_test.go b/shyftDb/shyft_database_util_test.go
index a03e0cb4f8..978fd8a619 100644
--- a/shyftDb/shyft_database_util_test.go
+++ b/shyftDb/shyft_database_util_test.go
@@ -471,9 +471,18 @@ t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
 	if toAddr1.String() != tx1.To().String() {
 		t.Fatalf("To address [%v]: To address not found", toAddr1.String())
 	}
-	accountAddrTo := core.SGetAccount(sqldb, toAddr1.String())
+	accountAddrTo, _ := core.InnerSGetAccount(sqldb, toAddr1.String())
+	//ewAccountNonceReceiver.Add(accountR, nonceIncrement)
+	addedAmount := new(big.Int)
+	b := new(big.Int).SetUint64(toAmountPrev1)
+	addedAmount.Add(toAmount1, b)
+	toBalance := new(big.Int)
+	toBalance, l := toBalance.SetString(accountAddrTo.Balance, 10)
+	fmt.Println(l)
 	
-
+	if toBalance.Cmp(addedAmount) != 0 {
+		t.Fatalf("To address balance [%v]: To address balance not correct FFO", toBalance)
+	}
 
 	//for _, tx := range txs {
 	//	accountAddrTo := core.SGetAccount(sqldb, tx.To().String())

From 8a8c886ef16a7c729fbb5560b3d8b8abfcc12c18 Mon Sep 17 00:00:00 2001
From: Dustin Brickwood <dustinbrickwood204@gmail.com>
Date: Tue, 24 Jul 2018 10:36:14 -0400
Subject: [PATCH 25/27] resolving conflicts

---
 core/shyft_database_util.go         |  5 +----
 core/shyft_get_utils.go             | 29 +++++++++++++++++------------
 shyftDb/shyft_database_util_test.go |  2 +-
 3 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/core/shyft_database_util.go b/core/shyft_database_util.go
index 15f6bc20da..236184434e 100644
--- a/core/shyft_database_util.go
+++ b/core/shyft_database_util.go
@@ -8,7 +8,6 @@ import (
 	"database/sql"
 	"log"
 	_ "github.com/lib/pq"
-	"fmt"
 	"github.com/ShyftNetwork/go-empyrean/common"
 	"github.com/ShyftNetwork/go-empyrean/core/types"
 	Rewards "github.com/ShyftNetwork/go-empyrean/consensus/ethash"
@@ -300,11 +299,9 @@ func swriteBalanceHelper(sqldb *sql.DB, tx *types.Transaction) (SendAndReceive,
 		Amount: tx.Value().String(),
 	}
 
-	fmt.Println("TO", sendAndReceiveData.To)
-	fmt.Println("FROM", sendAndReceiveData.From)
 	getAccountBalanceReceiver := SGetAccount(sqldb, sendAndReceiveData.To)
 	getAccountBalanceSender:= SGetAccount(sqldb, sendAndReceiveData.From)
-	fmt.Println("HERE", getAccountBalanceReceiver)
+
 	var receiverData SendAndReceive
 	if err := json.Unmarshal([]byte(getAccountBalanceReceiver), &receiverData); err != nil {
 		log.Fatal(err)
diff --git a/core/shyft_get_utils.go b/core/shyft_get_utils.go
index 97f64ee9b9..ddbc820386 100644
--- a/core/shyft_get_utils.go
+++ b/core/shyft_get_utils.go
@@ -280,20 +280,25 @@ func SGetTransaction(sqldb *sql.DB, txHash string) string {
 	return string(json)
 }
 
+func InnerSGetAccount(sqldb *sql.DB, address string) (SAccounts, bool) {
+	sqlStatement := `SELECT * FROM accounts WHERE addr=$1;`
+	var addr, balance, accountNonce string
+	err := sqldb.QueryRow(sqlStatement, address).Scan(&addr, &balance, &accountNonce)
+	if err == sql.ErrNoRows {
+		return SAccounts{}, false
+	} else {
+		account := SAccounts{
+			Addr:    		addr,
+			Balance: 		balance,
+			AccountNonce: 	accountNonce,
+		}
+		return account, true
+	}
+}
+
 //GetAccount returns account balances
 func SGetAccount(sqldb *sql.DB, address string) string {
-	sqlStatement := `SELECT * FROM accounts WHERE addr=$1;`
-	row := sqldb.QueryRow(sqlStatement, address)
-	var addr, balance, accountNonce string
-
-	row.Scan(
-		&addr, &balance, &accountNonce)
-
-	account := SAccounts{
-		Addr:    		addr,
-		Balance: 		balance,
-		AccountNonce: 	accountNonce,
-	}
+	var account, _ = InnerSGetAccount(sqldb, address)
 	json, _ := json.Marshal(account)
 	return string(json)
 }
diff --git a/shyftDb/shyft_database_util_test.go b/shyftDb/shyft_database_util_test.go
index e27894ad00..a35e6bba5e 100644
--- a/shyftDb/shyft_database_util_test.go
+++ b/shyftDb/shyft_database_util_test.go
@@ -479,7 +479,7 @@ t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
 	toBalance := new(big.Int)
 	toBalance, l := toBalance.SetString(accountAddrTo.Balance, 10)
 	fmt.Println(l)
-	
+
 	if toBalance.Cmp(addedAmount) != 0 {
 		t.Fatalf("To address balance [%v]: To address balance not correct FFO", toBalance)
 	}

From 43dbd77049199610f400f05d7e3f6295008a3d24 Mon Sep 17 00:00:00 2001
From: Dustin Brickwood <dustinbrickwood204@gmail.com>
Date: Tue, 24 Jul 2018 17:30:28 -0400
Subject: [PATCH 26/27] refactored code to minimize lines

---
 core/shyft_database_util.go         | 278 ++++++++++++++--------------
 core/shyft_get_utils.go             |  40 ++--
 eth/tracers/tracer.go               |  23 ++-
 shyftDb/shyft_database_util_test.go |  36 ++--
 4 files changed, 194 insertions(+), 183 deletions(-)

diff --git a/core/shyft_database_util.go b/core/shyft_database_util.go
index 236184434e..8632723615 100644
--- a/core/shyft_database_util.go
+++ b/core/shyft_database_util.go
@@ -1,7 +1,6 @@
 package core
 
 import (
-	"encoding/json"
 	"math/big"
 	"time"
 	"strconv"
@@ -24,7 +23,8 @@ func SetIShyftTracer(st shyfttracerinterface.IShyftTracer) {
 type SBlock struct {
 	Hash     	string
 	Coinbase 	string
-	Age        	string
+	AgeGet      string
+	Age 		time.Time
 	ParentHash 	string
 	UncleHash 	string
 	Difficulty 	string
@@ -65,7 +65,8 @@ type txRes struct {
 
 type ShyftTxEntryPretty struct {
 	TxHash    		string
-	To        		string
+	To				*common.Address
+	ToGet			string
 	From      		string
 	BlockHash 		string
 	BlockNumber 	string
@@ -112,6 +113,7 @@ func SWriteBlock(block *types.Block, receipts []*types.Receipt) error {
 		Difficulty: 	block.Difficulty().String(),
 		Size: 			block.Size().String(),
 		Nonce: 			block.Nonce(),
+		Rewards:        rewards,
 	}
 
 	i, err := strconv.ParseInt(block.Time().String(), 10, 64)
@@ -120,12 +122,13 @@ func SWriteBlock(block *types.Block, receipts []*types.Receipt) error {
 	}
 	age := time.Unix(i, 0)
 
-	sqlStatement := `INSERT INTO blocks(hash, coinbase, number, gasUsed, gasLimit, txCount, uncleCount, age, parentHash, uncleHash, difficulty, size, rewards, nonce) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12),($13), ($14)) RETURNING number`
-	qerr := sqldb.QueryRow(sqlStatement, blockData.Hash, blockData.Coinbase, blockData.Number, blockData.GasUsed, blockData.GasLimit, blockData.TxCount, blockData.UncleCount, age, blockData.ParentHash, blockData.UncleHash, blockData.Difficulty, blockData.Size, rewards, blockData.Nonce).Scan(&blockData.Number)
-	if qerr != nil {
-		panic(qerr)
+	blockAge := SBlock {
+		Age:   age,
 	}
 
+	//Inserts block data into DB
+	InsertBlock(sqldb, blockData, blockAge)
+
 	if block.Transactions().Len() > 0 {
 		for _, tx := range block.Transactions() {
 			swriteTransactions(sqldb, tx, block.Header().Hash(), blockData.Number, receipts, age, blockData.GasLimit)
@@ -143,25 +146,29 @@ func SWriteBlock(block *types.Block, receipts []*types.Receipt) error {
 //swriteTransactions writes to sqldb, a SHYFT postgres instance
 func swriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.Hash, blockNumber string,  receipts []*types.Receipt, age time.Time, gasLimit uint64) error {
 	var isContract bool
-	var statusFromReciept, contractAddressFromReciept, retNonce string
+	var statusFromReciept string
+	var contractAddressFromReciept common.Address
 
 	txData := ShyftTxEntryPretty{
-		TxHash:    tx.Hash().Hex(),
-		From:      tx.From().Hex(),
-		To:        tx.To().Hex(),
-		BlockHash: blockHash.Hex(),
-		Amount:    tx.Value().String(),
-		Cost:	   tx.Cost().Uint64(),
-		GasPrice:  tx.GasPrice().Uint64(),
-		Gas:       tx.Gas(),
-		Nonce:     tx.Nonce(),
-		Data:      tx.Data(),
+		TxHash:    	 tx.Hash().Hex(),
+		From:      	 tx.From().Hex(),
+		To:        	 tx.To(),
+		BlockHash: 	 blockHash.Hex(),
+		BlockNumber: blockNumber,
+		Amount:    	 tx.Value().String(),
+		Cost:	   	 tx.Cost().Uint64(),
+		GasPrice:  	 tx.GasPrice().Uint64(),
+		GasLimit:  	 gasLimit,
+		Gas:       	 tx.Gas(),
+		Nonce:     	 tx.Nonce(),
+		Age: 	   	 age,
+		Data:      	 tx.Data(),
 	}
 
 	if tx.To() == nil {
 		for _, receipt := range receipts {
 			statusReciept := (*types.ReceiptForStorage)(receipt).Status
-			contractAddressFromReciept = (*types.ReceiptForStorage)(receipt).ContractAddress.String()
+			contractAddressFromReciept = (*types.ReceiptForStorage)(receipt).ContractAddress
 			switch {
 			case statusReciept == 0:
 				statusFromReciept = "FAIL"
@@ -170,11 +177,13 @@ func swriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.H
 			}
 		}
 		isContract = true
-		sqlStatement := `INSERT INTO txs(txhash, from_addr, to_addr, blockhash, blockNumber, amount, gasprice, gas, gasLimit, txfee, nonce, isContract, txStatus, age, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12), ($13), ($14), ($15)) RETURNING nonce`
-		err := sqldb.QueryRow(sqlStatement, txData.TxHash, txData.From, contractAddressFromReciept, txData.BlockHash, blockNumber, txData.Amount, txData.GasPrice, txData.Gas, gasLimit, txData.Cost, txData.Nonce, isContract, statusFromReciept, age, txData.Data).Scan(&retNonce)
-		if err != nil {
-			panic(err)
+		contractData := ShyftTxEntryPretty{
+			Status: 	statusFromReciept,
+			IsContract: isContract,
+			To:         &contractAddressFromReciept,
 		}
+		//Insert Tx into DB
+		InsertTx(sqldb, txData, contractData)
 	} else {
 		isContract = false
 		for _, receipt := range receipts {
@@ -186,11 +195,13 @@ func swriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.H
 				statusFromReciept = "SUCCESS"
 			}
 		}
-		sqlStatement := `INSERT INTO txs(txhash, from_addr, to_addr, blockhash, blockNumber, amount, gasprice, gas, gasLimit, txfee, nonce, isContract, txStatus, age, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12), ($13), ($14), ($15)) RETURNING nonce`
-		err := sqldb.QueryRow(sqlStatement, txData.TxHash, txData.From, txData.To, txData.BlockHash, blockNumber, txData.Amount, txData.GasPrice, txData.Gas, gasLimit, txData.Cost, txData.Nonce, isContract, statusFromReciept, age, txData.Data).Scan(&retNonce)
-		if err != nil {
-			panic(err)
+		data := ShyftTxEntryPretty{
+			Status: 	statusFromReciept,
+			IsContract: isContract,
+			To:			tx.To(),
 		}
+		//Insert Tx into DB
+		InsertTx(sqldb, txData, data)
 	}
 	//Runs necessary functions for tracing internal transactions through tracers.go
 	IShyftTracer.GetTracerToRun(tx.Hash())
@@ -205,117 +216,78 @@ func swriteContractBalance(sqldb *sql.DB, tx *types.Transaction) error {
 		AccountNonce: 	tx.Nonce(),
 	}
 
-	var response string
-	sqlExistsStatement := `SELECT balance from accounts WHERE addr = ($1)`
-	err := sqldb.QueryRow(sqlExistsStatement, sendAndReceiveData.From).Scan(&response)
+	fromAddressBalance, fromAccountNonce, err := AccountExists(sqldb, sendAndReceiveData.From)
 
 	switch {
 	case err == sql.ErrNoRows:
-		sqlStatement := `INSERT INTO accounts(addr, balance, accountNonce) VALUES(($1), ($2), ($3)) RETURNING addr`
-		insertErr := sqldb.QueryRow(sqlStatement, sendAndReceiveData.From, sendAndReceiveData.Amount, sendAndReceiveData.AccountNonce).Scan(&sendAndReceiveData.From)
-		if insertErr != nil {
-			panic(insertErr)
-		}
+		accountNonce := strconv.FormatUint(tx.Nonce(), 10)
+		CreateAccount(sqldb, sendAndReceiveData.From, sendAndReceiveData.Amount, accountNonce)
 	default:
-		getAccountBalanceSender:= SGetAccount(sqldb, sendAndReceiveData.From)
 		var newBalanceSender,newAccountNonceSender  big.Int
 		var nonceIncrement = big.NewInt(1)
 
-		var senderBalance SendAndReceive
-		if err := json.Unmarshal([]byte(getAccountBalanceSender), &senderBalance); err != nil {
-			log.Fatal(err)
-		}
+		fromBalance := new(big.Int)
+		fromBalance, _ = fromBalance.SetString(fromAddressBalance, 10)
 
-		//Converts string to UINT64 > Big.Int for adding and subtraction
-		balanceSender, _ := strconv.ParseUint(senderBalance.Balance, 10, 64)
-		balanceSen := new(big.Int).SetUint64(balanceSender)
-		senderAccountNonce := new(big.Int).SetUint64(sendAndReceiveData.AccountNonce)
+		fromNonce := new(big.Int)
+		fromNonce, _ = fromNonce.SetString(fromAccountNonce, 10)
 
-		newBalanceSender.Sub(balanceSen, tx.Value())
-		newAccountNonceSender.Add(senderAccountNonce, nonceIncrement)
+		newBalanceSender.Sub(fromBalance, tx.Value())
+		newAccountNonceSender.Add(fromNonce, nonceIncrement)
 
-		updateSQLStatement := `UPDATE accounts SET balance = ($2), accountNonce = ($3) WHERE addr = ($1)`
-		_, err := sqldb.Exec(updateSQLStatement, sendAndReceiveData.From, newBalanceSender.String(), newAccountNonceSender.String())
-		if err != nil {
-			panic(err)
-		}
+		UpdateAccount(sqldb, sendAndReceiveData.From, newBalanceSender.String(), newAccountNonceSender.String())
 	}
 	return nil
 }
 
 //writeFromBalance writes senders balance to accounts db
 func swriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
-	sendAndReceiveData, balanceRec, balanceSen, accountNonceRec, accountNonceSen := swriteBalanceHelper(sqldb, tx)
-
-	var response string
-	sqlExistsStatement := `SELECT balance from accounts WHERE addr = ($1)`
-	err := sqldb.QueryRow(sqlExistsStatement, sendAndReceiveData.To).Scan(&response)
-
-	switch {
-	case err == sql.ErrNoRows:
-		accountNonce := strconv.FormatUint(tx.Nonce(), 10)
-		sqlStatement := `INSERT INTO accounts(addr, balance, accountNonce) VALUES(($1), ($2), ($3)) RETURNING addr`
-		insertErr := sqldb.QueryRow(sqlStatement, sendAndReceiveData.To, sendAndReceiveData.Amount, accountNonce).Scan(&sendAndReceiveData.To)
-		if insertErr != nil {
-			panic(insertErr)
-		}
-	case err != nil:
-		log.Fatal(err)
-	default:
-		var newBalanceReceiver, newBalanceSender, newAccountNonceReceiver, newAccountNonceSender  big.Int
-		var nonceIncrement = big.NewInt(1)
-
-		//Convert UINT64 to BIG.INT in order to add and subtract nonces & balances
-		balanceR := new(big.Int).SetUint64(balanceRec)
-		balanceS := new(big.Int).SetUint64(balanceSen)
-
-		accountR := new(big.Int).SetUint64(accountNonceRec)
-		accountS := new(big.Int).SetUint64(accountNonceSen)
-
-		newBalanceReceiver.Add(balanceR, tx.Value())
-		newBalanceSender.Sub(balanceS, tx.Value())
-
-		newAccountNonceReceiver.Add(accountR, nonceIncrement)
-		newAccountNonceSender.Add(accountS, nonceIncrement)
-
-		updateSQLStatement := `UPDATE accounts SET balance = ($2), accountNonce = ($3) WHERE addr = ($1)`
-		_, err = sqldb.Exec(updateSQLStatement, sendAndReceiveData.To, newBalanceReceiver.String(), newAccountNonceReceiver.String())
-		if err != nil {
-			panic(err)
-		}
-
-		_, err = sqldb.Exec(updateSQLStatement, sendAndReceiveData.From, newBalanceSender.String(), newAccountNonceSender.String())
-		if err != nil {
-			panic(err)
-		}
-	}
-	return nil
-}
-
-func swriteBalanceHelper(sqldb *sql.DB, tx *types.Transaction) (SendAndReceive, uint64, uint64, uint64, uint64) {
 	sendAndReceiveData := SendAndReceive{
 		To: tx.To().Hex(),
 		From: tx.From().Hex(),
 		Amount: tx.Value().String(),
 	}
 
-	getAccountBalanceReceiver := SGetAccount(sqldb, sendAndReceiveData.To)
-	getAccountBalanceSender:= SGetAccount(sqldb, sendAndReceiveData.From)
+	toAddressBalance, toAccountNonce, err := AccountExists(sqldb, sendAndReceiveData.To)
 
-	var receiverData SendAndReceive
-	if err := json.Unmarshal([]byte(getAccountBalanceReceiver), &receiverData); err != nil {
+	switch {
+	case err == sql.ErrNoRows:
+		accountNonce := strconv.FormatUint(tx.Nonce(), 10)
+		CreateAccount(sqldb, sendAndReceiveData.To, sendAndReceiveData.Amount, accountNonce)
+	case err != nil:
 		log.Fatal(err)
+	default:
+		fromAddressBalance, fromAccountNonce, err := AccountExists(sqldb, sendAndReceiveData.From)
+		if err != nil {
+			log.Fatal(err)
+		}
+		var newBalanceReceiver, newBalanceSender, newAccountNonceReceiver, newAccountNonceSender  big.Int
+		var nonceIncrement = big.NewInt(1)
+
+		//STRING TO BIG INT
+		//BALANCES TO AND FROM ADDR
+		toBalance := new(big.Int)
+		toBalance, _ = toBalance.SetString(toAddressBalance, 10)
+		fromBalance := new(big.Int)
+		fromBalance, _ = fromBalance.SetString(fromAddressBalance, 10)
+
+		//ACCOUNT NONCES
+		toNonce := new(big.Int)
+		toNonce, _ = toNonce.SetString(toAccountNonce, 10)
+		fromNonce := new(big.Int)
+		fromNonce, _ = fromNonce.SetString(fromAccountNonce, 10)
+
+		newBalanceReceiver.Add(toBalance, tx.Value())
+		newBalanceSender.Sub(fromBalance, tx.Value())
+
+		newAccountNonceReceiver.Add(toNonce, nonceIncrement)
+		newAccountNonceSender.Add(fromNonce, nonceIncrement)
+
+		//UPDATE ACCOUNTS BASED ON NEW BALANCES AND ACCOUNT NONCES
+		UpdateAccount(sqldb, sendAndReceiveData.To,   newBalanceReceiver.String(), newAccountNonceReceiver.String())
+		UpdateAccount(sqldb, sendAndReceiveData.From, newBalanceSender.String(),   newAccountNonceSender.String())
 	}
-
-	var senderData SendAndReceive
-	if err := json.Unmarshal([]byte(getAccountBalanceSender), &senderData); err != nil {
-		log.Fatal(err)
-	}
-
-	balanceReceiver, _ := strconv.ParseUint(receiverData.Balance, 10, 64)
-	balanceSender, _ := strconv.ParseUint(senderData.Balance, 10, 64)
-
-	return sendAndReceiveData, balanceReceiver, balanceSender, receiverData.AccountNonce, senderData.AccountNonce
+	return nil
 }
 
 // @NOTE: This function is extremely complex and requires heavy testing and knowdlege of edge cases:
@@ -369,19 +341,12 @@ func swriteMinerRewards(sqldb *sql.DB, block *types.Block) string {
 
 func sstoreReward(sqldb *sql.DB, address string, reward *big.Int) {
 	// Check if address exists
-	var addressBalance string
-	addressExistsStatement := `SELECT balance from accounts WHERE addr = ($1)`
-	err := sqldb.QueryRow(addressExistsStatement, address).Scan(&addressBalance)
+	addressBalance, accountNonce, err := AccountExists(sqldb, address)
 
 	if err == sql.ErrNoRows {
 		// Addr does not exist, thus create new entry
-		createAddressSqlStatement := `INSERT INTO accounts(addr, balance, accountNonce) VALUES(($1), ($2), ($3)) RETURNING addr`
-
 		// We convert totalReward into a string and postgres converts into number
-		_, insertErr := sqldb.Exec(createAddressSqlStatement, address, reward.String(), 1)
-		if insertErr != nil {
-			panic(insertErr)
-		}
+		CreateAccount(sqldb, address, reward.String(), "1")
 		return
 	} else if err != nil {
 		// Something went wrong panic
@@ -389,34 +354,77 @@ func sstoreReward(sqldb *sql.DB, address string, reward *big.Int) {
 	} else {
 		// Addr exists, update existing balance
 		bigBalance := new(big.Int)
-		bigBalance, err := bigBalance.SetString(addressBalance, 0)
+		var nonceIncrement = big.NewInt(1)
+		currentAccountNonce := new(big.Int)
+		currentAccountNonce, errorr := currentAccountNonce.SetString(accountNonce, 10)
+		if !errorr {
+			panic(errorr)
+		}
+		bigBalance, err := bigBalance.SetString(addressBalance, 10)
 		if !err {
 			panic(err)
 		}
 		newBalance := new(big.Int)
+		newAccountNonce := new(big.Int)
 		newBalance.Add(newBalance, bigBalance)
 		newBalance.Add(newBalance, reward)
-
-		updateAddressSQLStatement := `UPDATE accounts SET balance = ($1) WHERE addr = ($2)`
-
-		// We convert totalReward into a string and postgres converts into number
-		_, updateErr := sqldb.Exec(updateAddressSQLStatement, newBalance.String(), address)
-		if updateErr != nil {
-			panic(updateErr)
-		}
+		newAccountNonce.Add(currentAccountNonce, nonceIncrement)
+		//Update the balance and nonce
+		UpdateAccount(sqldb, address, newBalance.String(), newAccountNonce.String())
 		return
 	}
 }
 
-
-func CreateAccount (sqldb *sql.DB, addr string, amount uint64, accountNonce uint64) {
-
+///////////////////////
+//DB Utility functions
+//////////////////////
+func CreateAccount (sqldb *sql.DB, addr string, balance string, accountNonce string) {
 	sqlStatement := `INSERT INTO accounts(addr, balance, accountNonce) VALUES(($1), ($2), ($3)) RETURNING addr`
-	insertErr := sqldb.QueryRow(sqlStatement, addr, amount, accountNonce).Scan(&addr)
+	insertErr := sqldb.QueryRow(sqlStatement, addr, balance, accountNonce).Scan(&addr)
 	if insertErr != nil {
 		panic(insertErr)
 	}
+}
 
+func AccountExists (sqldb *sql.DB, addr string) (string, string, error) {
+	var addressBalance, accountNonce string
+	sqlExistsStatement := `SELECT balance, accountNonce from accounts WHERE addr = ($1)`
+	err := sqldb.QueryRow(sqlExistsStatement, addr).Scan(&addressBalance, &accountNonce)
+
+	switch {
+	case err == sql.ErrNoRows:
+		return addressBalance, accountNonce, err
+	case err != nil:
+		panic(err)
+	default:
+		return addressBalance, accountNonce, err
+	}
+}
+
+func UpdateAccount(sqldb *sql.DB, addr string, balance string, accountNonce string) {
+	updateSQLStatement := `UPDATE accounts SET balance = ($2), accountNonce = ($3) WHERE addr = ($1)`
+	_, updateErr := sqldb.Exec(updateSQLStatement, addr, balance, accountNonce)
+	if updateErr != nil {
+		panic(updateErr)
+	}
+}
+
+func InsertBlock(sqldb *sql.DB, blockData SBlock, blockAge SBlock) {
+	sqlStatement := `INSERT INTO blocks(hash, coinbase, number, gasUsed, gasLimit, txCount, uncleCount, age, parentHash, uncleHash, difficulty, size, rewards, nonce) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12),($13), ($14)) RETURNING number`
+	qerr := sqldb.QueryRow(sqlStatement, blockData.Hash, blockData.Coinbase, blockData.Number, blockData.GasUsed, blockData.GasLimit, blockData.TxCount, blockData.UncleCount, blockAge.Age, blockData.ParentHash, blockData.UncleHash, blockData.Difficulty, blockData.Size, blockData.Rewards, blockData.Nonce).Scan(&blockData.Number)
+	if qerr != nil {
+		panic(qerr)
+	}
+}
+
+
+func InsertTx (sqldb *sql.DB, txData ShyftTxEntryPretty, data ShyftTxEntryPretty) {
+	var retNonce string
+	sqlStatement := `INSERT INTO txs(txhash, from_addr, to_addr, blockhash, blockNumber, amount, gasprice, gas, gasLimit, txfee, nonce, isContract, txStatus, age, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12), ($13), ($14), ($15)) RETURNING nonce`
+	err := sqldb.QueryRow(sqlStatement, txData.TxHash, txData.From, data.To.String(), txData.BlockHash, txData.BlockNumber, txData.Amount, txData.GasPrice, txData.Gas, txData.GasLimit, txData.Cost, txData.Nonce, data.IsContract, data.Status, txData.Age, txData.Data).Scan(&retNonce)
+	if err != nil {
+		panic(err)
+	}
 }
 
 
diff --git a/core/shyft_get_utils.go b/core/shyft_get_utils.go
index ddbc820386..c9fbeac3c3 100644
--- a/core/shyft_get_utils.go
+++ b/core/shyft_get_utils.go
@@ -34,7 +34,7 @@ func SGetAllBlocks(sqldb *sql.DB) string {
 			GasLimit: 		gasLimit,
 			TxCount: 		txCount,
 			UncleCount: 	uncleCount,
-			Age: 			age,
+			AgeGet: 		age,
 			ParentHash:		parentHash,
 			UncleHash:		uncleHash,
 			Difficulty:		difficulty,
@@ -70,7 +70,7 @@ func SGetBlock(sqldb *sql.DB, blockNumber string) string {
 		GasLimit: 	gasLimit,
 		TxCount: 	txCount,
 		UncleCount: uncleCount,
-		Age: 		age,
+		AgeGet: 	age,
 		ParentHash:	parentHash,
 		UncleHash:	uncleHash,
 		Difficulty:	difficulty,
@@ -100,7 +100,7 @@ func SGetRecentBlock(sqldb *sql.DB) string {
 		GasLimit: 	gasLimit,
 		TxCount: 	txCount,
 		UncleCount: uncleCount,
-		Age: 		age,
+		AgeGet: 	age,
 		ParentHash:	parentHash,
 		UncleHash:	uncleHash,
 		Difficulty:	difficulty,
@@ -135,7 +135,7 @@ func SGetAllTransactionsFromBlock(sqldb *sql.DB, blockNumber string) string {
 
 		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
 			TxHash:    	 txhash,
-			To:        	 to_addr,
+			ToGet:       to_addr,
 			From:      	 from_addr,
 			BlockHash: 	 blockhash,
 			BlockNumber: blocknumber,
@@ -177,20 +177,20 @@ func SGetAllBlocksMinedByAddress(sqldb *sql.DB, coinbase string) string {
 			&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num,)
 
 		arr.Blocks = append(arr.Blocks, SBlock{
-			Hash:     hash,
-			Coinbase: coinbase,
-			GasUsed: gasUsed,
-			GasLimit: gasLimit,
-			TxCount: txCount,
+			Hash:     	hash,
+			Coinbase: 	coinbase,
+			GasUsed: 	gasUsed,
+			GasLimit: 	gasLimit,
+			TxCount: 	txCount,
 			UncleCount: uncleCount,
-			Age: age,
-			ParentHash:parentHash,
-			UncleHash:uncleHash,
-			Difficulty:difficulty,
-			Size: size,
-			Nonce:nonce,
-			Rewards: rewards,
-			Number:   num,
+			AgeGet: 	age,
+			ParentHash:	parentHash,
+			UncleHash:	uncleHash,
+			Difficulty:	difficulty,
+			Size: 		size,
+			Nonce:		nonce,
+			Rewards: 	rewards,
+			Number:   	num,
 		})
 
 		blocks, _ := json.Marshal(arr.Blocks)
@@ -222,7 +222,7 @@ func SGetAllTransactions(sqldb *sql.DB) string {
 
 		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
 			TxHash:    	 txhash,
-			To:        	 to_addr,
+			ToGet:       to_addr,
 			From:      	 from_addr,
 			BlockHash: 	 blockhash,
 			BlockNumber: blocknumber,
@@ -260,7 +260,7 @@ func SGetTransaction(sqldb *sql.DB, txHash string) string {
 
 	tx := ShyftTxEntryPretty{
 		TxHash:      txhash,
-		To:        	 to_addr,
+		ToGet:       to_addr,
 		From:      	 from_addr,
 		BlockHash: 	 blockhash,
 		BlockNumber: blocknumber,
@@ -362,7 +362,7 @@ func SGetAccountTxs(sqldb *sql.DB, address string) string {
 
 		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
 			TxHash:    	 txhash,
-			To:        	 to_addr,
+			ToGet:       to_addr,
 			From:      	 from_addr,
 			BlockHash:   blockhash,
 			BlockNumber: blocknumber,
diff --git a/eth/tracers/tracer.go b/eth/tracers/tracer.go
index 934d210d9f..66d8f5806e 100644
--- a/eth/tracers/tracer.go
+++ b/eth/tracers/tracer.go
@@ -32,6 +32,7 @@ import (
 	"github.com/ShyftNetwork/go-empyrean/crypto"
 	"github.com/ShyftNetwork/go-empyrean/log"
 	"gopkg.in/olebedev/go-duktape.v3"
+	"strconv"
 )
 
 // bigIntegerJS is the minified version of https://github.com/peterolson/BigInteger.js.
@@ -578,16 +579,16 @@ func (jst *Tracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, er
 
 //@NOTE:SHYFT
 type Internals struct {
-	Type string
-	From string
-	To string
-	Value string
-	Gas string
+	Type 	string
+	From 	string
+	To 		string
+	Value 	string
+	Gas 	string
 	GasUsed string
-	Input string
-	Output string
-	Time string
-	Calls []*Internals
+	Input 	string
+	Output 	string
+	Time 	string
+	Calls 	[]*Internals
 }
 
 //@NOTE:SHYFT
@@ -599,10 +600,12 @@ func (i *Internals) SWriteInteralTxs(hash common.Hash) {
 
 	gas, _ := hexutil.DecodeUint64(i.Gas)
 	gasUsed, _ := hexutil.DecodeUint64(i.GasUsed)
+	value, _ := hexutil.DecodeUint64(i.Value)
+	amount := strconv.FormatUint(value, 10)
 
 	var returnValue string
 	sqlStatement := `INSERT INTO internaltxs(type, txhash, from_addr, to_addr, amount, gas, gasUsed, time, input, output) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10)) RETURNING txHash`
-	qerr := sqldb.QueryRow(sqlStatement, i.Type, hash.Hex(), i.From, i.To, i.Value, gas, gasUsed, i.Time, i.Input, i.Output).Scan(&returnValue)
+	qerr := sqldb.QueryRow(sqlStatement, i.Type, hash.Hex(), i.From, i.To, amount, gas, gasUsed, i.Time, i.Input, i.Output).Scan(&returnValue)
 
 	if qerr != nil {
 		fmt.Println(qerr)
diff --git a/shyftDb/shyft_database_util_test.go b/shyftDb/shyft_database_util_test.go
index a35e6bba5e..b7aa7092d9 100644
--- a/shyftDb/shyft_database_util_test.go
+++ b/shyftDb/shyft_database_util_test.go
@@ -9,9 +9,9 @@ import (
 	"math/big"
 	//"time"
 	"encoding/json"
-	"fmt"
 	"github.com/ShyftNetwork/go-empyrean/crypto"
 	"github.com/ShyftNetwork/go-empyrean/consensus/ethash"
+	"strconv"
 )
 
 type ShyftTracer struct {}
@@ -66,12 +66,11 @@ func TestBlock(t *testing.T) {
 		receipts := []*types.Receipt{receipt}
 		block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts)
 
-		fmt.Println("++++++HERE")
 		// Write and verify the block in the database
 		if err := core.SWriteBlock(block, receipts); err != nil {
 			t.Fatalf("Failed to write block into database: %v", err)
 		}
-		fmt.Println("++++++AND HERE")
+
 		sqldb, err := core.DBConnection()
 		if err != nil {
 			panic(err)
@@ -264,7 +263,7 @@ t.Run("TestContractCreationTx", func (t *testing.T) {
 		if tx.Hash().String() != data.TxHash {
 			t.Fatalf("txHash [%v]: tx Hash not found", tx.Hash().String())
 		}
-		if contractAddressFromReciept != data.To {
+		if contractAddressFromReciept != data.ToGet {
 			t.Fatalf("Contract Addr [%v]: Contract addr not found", contractAddressFromReciept)
 		}
 		if tx.From().String() != data.From {
@@ -366,7 +365,7 @@ t.Run("TestTransactionsToReturnTransactions", func(t *testing.T) {
 		if tx.From().String() != data.From {
 			t.Fatalf("From Addr [%v]: From addr not found", tx.From().String())
 		}
-		if tx.To().String() != data.To {
+		if tx.To().String() != data.ToGet {
 			t.Fatalf("To Addr [%v]: To addr not found", tx.To().String())
 		}
 		if tx.Nonce() != data.Nonce {
@@ -429,17 +428,17 @@ t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
 	toAddr3 := common.BytesToAddress([]byte{0x33})
 
 	toAmount1 := big.NewInt(111)
-	var toAmountPrev1 uint64 = 3968686868
+	var toAmountPrev1 string = "3968686868"
 
 	sqldb, err := core.DBConnection()
 	if (err != nil) {
 		panic(err)
 	}
 
-	core.CreateAccount(sqldb, toAddr1.Hex(), toAmountPrev1, 1)
-	core.CreateAccount(sqldb, toAddr2.Hex(), 423798729847, 1)
-	core.CreateAccount(sqldb, toAddr3.Hex(), 0, 1)
-	core.CreateAccount(sqldb, "0x71562b71999873DB5b286dF957af199Ec94617F7", 3968686868, 1)
+	core.CreateAccount(sqldb, toAddr1.Hex(), toAmountPrev1, "1")
+	core.CreateAccount(sqldb, toAddr2.Hex(), "423798729847", "1")
+	core.CreateAccount(sqldb, toAddr3.Hex(), "0", "1")
+	core.CreateAccount(sqldb, "0x71562b71999873DB5b286dF957af199Ec94617F7", "3968686868", "1")
 
 	//Nonce, To Address,Value, GasLimit, Gasprice, data
 	tx1 := types.NewTransaction(1, toAddr1, toAmount1, 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
@@ -474,11 +473,11 @@ t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
 	accountAddrTo, _ := core.InnerSGetAccount(sqldb, toAddr1.String())
 	//ewAccountNonceReceiver.Add(accountR, nonceIncrement)
 	addedAmount := new(big.Int)
-	b := new(big.Int).SetUint64(toAmountPrev1)
+	toAmountPrevious1, _ := strconv.ParseUint(toAmountPrev1, 10, 64)
+	b := new(big.Int).SetUint64(toAmountPrevious1)
 	addedAmount.Add(toAmount1, b)
 	toBalance := new(big.Int)
-	toBalance, l := toBalance.SetString(accountAddrTo.Balance, 10)
-	fmt.Println(l)
+	toBalance, _ = toBalance.SetString(accountAddrTo.Balance, 10)
 
 	if toBalance.Cmp(addedAmount) != 0 {
 		t.Fatalf("To address balance [%v]: To address balance not correct FFO", toBalance)
@@ -499,17 +498,18 @@ t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
 	//	if strconv.FormatUint(tx.Nonce(), 10) != accountDataTo.AccountNonce {
 	//		t.Fatalf("To account nonce [%v]: To account nonce not found", accountDataTo.AccountNonce)
 	//	}
-	//	if getAllAccountTxs := core.SGetAccountTxs(sqldb, tx.To().String()); len(getAllAccountTxs) == 0 {
-	//		t.Fatalf("GetAccountTxs [%v]: GetAccountTxs did not return correctly", getAllAccountTxs)
-	//	}
 	//}
 
+	if getAllAccountTxs := core.SGetAccountTxs(sqldb, toAddr1.String()); len(getAllAccountTxs) == 0 {
+		t.Fatalf("GetAccountTxs [%v]: GetAccountTxs did not return correctly", getAllAccountTxs)
+	}
+
 	if getAllAccounts := core.SGetAllAccounts(sqldb); len(getAllAccounts) == 0 {
 		t.Fatalf("GetAllAccounts [%v]: GetAllAccounts did not return correctly", getAllAccounts)
 	}
-	//ClearTables()
+	ClearTables()
 })
 
-	//ClearTables()
+	ClearTables()
 }
 

From 951f936e843ce9dc89fec16df69c628fbd21533b Mon Sep 17 00:00:00 2001
From: Tim Williams <timwilliams@fastmail.com>
Date: Wed, 25 Jul 2018 11:21:46 -0400
Subject: [PATCH 27/27] reformat code

---
 eth/tracers/tracer.go | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/eth/tracers/tracer.go b/eth/tracers/tracer.go
index 66d8f5806e..e674d817ba 100644
--- a/eth/tracers/tracer.go
+++ b/eth/tracers/tracer.go
@@ -579,16 +579,16 @@ func (jst *Tracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, er
 
 //@NOTE:SHYFT
 type Internals struct {
-	Type 	string
-	From 	string
-	To 		string
-	Value 	string
-	Gas 	string
+	Type    string
+	From    string
+	To      string
+	Value   string
+	Gas     string
 	GasUsed string
-	Input 	string
-	Output 	string
-	Time 	string
-	Calls 	[]*Internals
+	Input   string
+	Output  string
+	Time    string
+	Calls   []*Internals
 }
 
 //@NOTE:SHYFT
@@ -612,6 +612,7 @@ func (i *Internals) SWriteInteralTxs(hash common.Hash) {
 		panic(qerr)
 	}
 }
+
 //@NOTE:SHYFT
 func (i *Internals) InternalRecursive(hash common.Hash) {
 	i.SWriteInteralTxs(hash)
@@ -718,4 +719,4 @@ func (jst *Tracer) SGetResult(hash common.Hash) (json.RawMessage, error) {
 	dat.InternalRecursive(hash)
 
 	return result, jst.err
-}
\ No newline at end of file
+}