Merge pull request #48 from ShyftNetwork/update/accountBalances

Update/account balances

core/blockchain.go

@@ -29,7 +29,6 @@ import (
 	"sync/atomic"
 	"time"
 
-
 	"github.com/ShyftNetwork/go-empyrean/common"
 	"github.com/ShyftNetwork/go-empyrean/common/mclock"
 	"github.com/ShyftNetwork/go-empyrean/consensus"
@@ -92,10 +91,10 @@ type BlockChain struct {
 	chainConfig *params.ChainConfig // Chain & network configuration
 	cacheConfig *CacheConfig        // Cache configuration for pruning
 
-	db     ethdb.Database // Low level persistent database to store final content in
+	db ethdb.Database // Low level persistent database to store final content in
 
-	triegc *prque.Prque   // Priority queue mapping block numbers to tries to gc
+	triegc *prque.Prque  // Priority queue mapping block numbers to tries to gc
-	gcproc time.Duration  // Accumulates canonical block processing for trie dumping
+	gcproc time.Duration // Accumulates canonical block processing for trie dumping
 
 	hc            *HeaderChain
 	rmLogsFeed    event.Feed

core/database_util.go

@@ -21,8 +21,8 @@ import (
 	"encoding/binary"
 	"encoding/json"
 	"errors"
-	"math/big"
 	"fmt"
+	"math/big"
 
 	"github.com/ShyftNetwork/go-empyrean/common"
 	"github.com/ShyftNetwork/go-empyrean/core/types"
@@ -283,14 +283,7 @@ func GetTxLookupEntry(db DatabaseReader, hash common.Hash) (common.Hash, uint64,
 // its added positional metadata.
 func GetTransaction(db DatabaseReader, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {
 	// Retrieve the lookup metadata and resolve the transaction from the body
-	//fmt.Println("INSIDE GET TRANSACTION ++++++++")
-	//fmt.Println("The hash and db reader are")
-	//fmt.Println(hash)
-	//fmt.Println(db)
 	blockHash, blockNumber, txIndex := GetTxLookupEntry(db, hash)
-	//fmt.Println(blockHash)
-	//fmt.Println(blockNumber)
-
 	if blockHash != (common.Hash{}) {
 		body := GetBody(db, blockHash, blockNumber)
 		if body == nil || len(body.Transactions) <= int(txIndex) {

core/db.go

@@ -62,3 +62,28 @@ func DBConnection() (*sql.DB, error) {
 	}
 	return blockExplorerDb, nil
 }
+
+func ClearTables() {
+	sqldb, err := DBConnection()
+	if err != nil {
+		panic(err)
+	}
+
+	sqlStatementTx:= `DELETE FROM txs`
+	_, err = sqldb.Exec(sqlStatementTx)
+	if err != nil {
+		panic(err)
+	}
+
+	sqlStatementAcc:= `DELETE FROM accounts`
+	_, err = sqldb.Exec(sqlStatementAcc)
+	if err != nil {
+		panic(err)
+	}
+
+	sqlStatement := `DELETE FROM blocks`
+	_, err = sqldb.Exec(sqlStatement)
+	if err != nil {
+		panic(err)
+	}
+}

core/genesis.go

@@ -18,26 +18,27 @@ package core
 
 import (
 	"bytes"
+	"database/sql"
 	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"math/big"
+	"strconv"
 	"strings"
+	"time"
 
-	_ "github.com/lib/pq"
 	"github.com/ShyftNetwork/go-empyrean/common"
 	"github.com/ShyftNetwork/go-empyrean/common/hexutil"
 	"github.com/ShyftNetwork/go-empyrean/common/math"
+	stypes "github.com/ShyftNetwork/go-empyrean/core/sTypes"
 	"github.com/ShyftNetwork/go-empyrean/core/state"
 	"github.com/ShyftNetwork/go-empyrean/core/types"
 	"github.com/ShyftNetwork/go-empyrean/ethdb"
 	"github.com/ShyftNetwork/go-empyrean/log"
 	"github.com/ShyftNetwork/go-empyrean/params"
 	"github.com/ShyftNetwork/go-empyrean/rlp"
-	"database/sql"
+	_ "github.com/lib/pq"
-	"strconv"
-	"time"
 )
 
 //go:generate gencodec -type Genesis -field-override genesisSpecMarshaling -out gen_genesis.go
@@ -143,85 +144,90 @@ func (e *GenesisMismatchError) Error() string {
 //WriteShyftGen writes the genesis block to Shyft db
 //@NOTE:SHYFT
 func WriteShyftGen(gen *Genesis, block *types.Block) {
-
 	sqldb, _ := DBConnection()
+	for k, v := range gen.Alloc {
+		_, _, err := AccountExists(sqldb, k.String())
+		switch {
+		case err == sql.ErrNoRows:
+			var toAddr *common.Address
+			var data []byte
+			var cost, gasPrice uint64
+			//Initializing proper types for tx struct
+			toAddr = &k
+			cost = 0
+			gasPrice = 0
+			//Appending GENESIS to address stored as txHash and From Addr
+			Genesis := []string{"GENESIS_", k.String()}
+			GENESIS := "GENESIS"
+			txHash := strings.Join(Genesis, k.String())
+			//Create the accountNonce, set to 1 (1 incoming tx), format type
+			accountNonce := v.Nonce + 1
+			accountNoncee := strconv.FormatUint(accountNonce, 10)
 
-	for k := range gen.Alloc {
-		addr := k.String()
-		var response string
-		sqlExistsStatement := `SELECT balance from accounts WHERE addr = ($1)`
-		err := sqldb.QueryRow(sqlExistsStatement, addr).Scan(&response)
-	switch {
-	case err == sql.ErrNoRows:
-		for k, v := range gen.Alloc {
-			number := block.Header().Number.String()
-			gasUsed := block.Header().GasUsed
-			gasLimit := block.Header().GasLimit
-			gasPrice := 0
-			txFee := 0
-			txStatus := ""
-			isContract := false
-			data:= ""
-			addr := k.String()
-			accountNonce := v.Nonce +1
 			i, err := strconv.ParseInt(block.Time().String(), 10, 64)
 			if err != nil {
 				panic(err)
 			}
 			age := time.Unix(i, 0)
-			Genesis := []string{"GENESIS_", addr}
-			GENESIS := "GENESIS"
-			txHash := strings.Join(Genesis, addr)
 
-			sqlStatement := `INSERT INTO accounts(addr, balance, accountnonce) VALUES(($1), ($2), ($3)) RETURNING addr`
+			txData := stypes.ShyftTxEntryPretty{
-			insertErr := sqldb.QueryRow(sqlStatement, addr, v.Balance.String(), accountNonce).Scan(&addr)
+				TxHash:      txHash,
-			if insertErr != nil {
+				From:        GENESIS,
-				panic(insertErr)
+				To:          toAddr,
+				BlockHash:   block.Header().Hash().Hex(),
+				BlockNumber: block.Header().Number.String(),
+				Amount:      v.Balance.String(),
+				Cost:        cost,
+				GasPrice:    gasPrice,
+				GasLimit:    block.GasLimit(),
+				Gas:         block.GasUsed(),
+				Nonce:       accountNonce,
+				Age:         age,
+				Data:        data,
+				Status:      "SUCCESS",
+				IsContract:  false,
 			}
+			//Create account and store tx
+			CreateAccount(sqldb, k.String(), v.Balance.String(), accountNoncee)
+			InsertTx(sqldb, txData)
 
-			var retNonce string
+		default:
-			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`
+			log.Info("Found Genesis Block")
-			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)
-			}
 		}
-	default:
+	}
-		log.Info("Found Genesis Block")
+}
-}}}
 
+//WriteShyftBlockZero writes block 0 to postgres db
 func WriteShyftBlockZero(block *types.Block, gen *Genesis) error {
-	
 	sqldb, _ := DBConnection()
 
-	coinbase := block.Header().Coinbase.String()
+	i, error := strconv.ParseInt(block.Time().String(), 10, 64)
-	number := block.Header().Number.String()
+	if error != nil {
-	gasUsed := block.Header().GasUsed
+		panic(error)
-	gasLimit := block.Header().GasLimit
-	uncleCount := len(block.Uncles())
-	parentHash := block.ParentHash().String()
-	uncleHash := block.UncleHash().String()
-	blockDifficulty := block.Difficulty().String()
-	blockSize := block.Size().String()
-	blockNonce := block.Nonce()
-	genesisTxCount := len(gen.Alloc)
-
-	i, err := strconv.ParseInt(block.Time().String(), 10, 64)
-	if err != nil {
-		panic(err)
 	}
 	age := time.Unix(i, 0)
 
-	var response string
+	blockData := stypes.SBlock{
-	sqlExistsStatement := `SELECT hash from blocks WHERE hash= ($1)`
+		Hash:       block.Header().Hash().Hex(),
-	err = sqldb.QueryRow(sqlExistsStatement, block.Header().Hash().Hex()).Scan(&response)
+		Coinbase:   block.Header().Coinbase.String(),
+		Number:     block.Header().Number.String(),
+		GasUsed:    block.Header().GasUsed,
+		GasLimit:   block.Header().GasLimit,
+		TxCount:    len(gen.Alloc),
+		UncleCount: len(block.Uncles()),
+		Age:        age,
+		ParentHash: block.ParentHash().String(),
+		UncleHash:  block.UncleHash().String(),
+		Difficulty: block.Difficulty().String(),
+		Size:       block.Size().String(),
+		Nonce:      block.Nonce(),
+		Rewards:    "0",
+	}
+
+	err := BlockExists(sqldb, blockData.Hash)
 	switch {
 	case err == sql.ErrNoRows:
-		sqlStatement := `INSERT INTO blocks(hash, coinbase, number, gasUsed, gasLimit, txCount, uncleCount, age, parentHash, uncleHash, difficulty, size, nonce) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11), ($12),($13)) RETURNING number`
+		InsertBlock(sqldb, blockData)
-		qerr := sqldb.QueryRow(sqlStatement, block.Header().Hash().Hex(), coinbase, number, gasUsed, gasLimit, genesisTxCount, uncleCount, age, parentHash, uncleHash, blockDifficulty, blockSize, blockNonce).Scan(&number)
-		if qerr != nil {
-			panic(qerr)
-		}
 	case err != nil:
 		panic(err)
 	default:
@@ -229,6 +235,7 @@ func WriteShyftBlockZero(block *types.Block, gen *Genesis) error {
 	}
 	return nil
 }
+
 // SetupGenesisBlock writes or updates the genesis block in db.
 // The block that will be used is:
 //
@@ -256,11 +263,20 @@ func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig
 			log.Info("Writing custom genesis block")
 		}
 		block, err := genesis.Commit(db)
-		//@NOTE:SHYFT WRITE TO BLOCK ZERO DB
+		//@NOTE:SHYFT SWITCH CASE ENSURES SHYFT GENESIS FUNCTIONS ARE ONLY CALLED ONCE
-		WriteShyftBlockZero(block, genesis)
+		sqldb, _ := DBConnection()
-		//@NOTE:SHYFT WRITE TO DB
+		serror := BlockExists(sqldb, block.Hash().String())
-		WriteShyftGen(genesis, block)
+		switch {
-
+		case serror == sql.ErrNoRows:
+			//@NOTE:SHYFT WRITE TO BLOCK ZERO DB
+			WriteShyftBlockZero(block, genesis)
+			//@NOTE:SHYFT WRITE TO DB
+			WriteShyftGen(genesis, block)
+		case serror != nil:
+			panic(serror)
+		default:
+			log.Info("Genesis Block Written")
+		}
 		return genesis.Config, block.Hash(), err
 	}
 
@@ -315,6 +331,7 @@ func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig {
 		return params.AllEthashProtocolChanges
 	}
 }
+
 // ToBlock creates the genesis block and writes state of a genesis specification
 // to the given database (or discards it if nil).
 func (g *Genesis) ToBlock(db ethdb.Database) *types.Block {
@@ -439,6 +456,7 @@ func DefaultRinkebyGenesisBlock() *Genesis {
 		Alloc:      decodePrealloc(rinkebyAllocData),
 	}
 }
+
 // DeveloperGenesisBlock returns the 'geth --dev' genesis block. Note, this must
 // be seeded with the
 func DeveloperGenesisBlock(period uint64, faucet common.Address) *Genesis {

core/sTypes/stypes.go

@@ -0,0 +1,92 @@
+package stypes
+
+import (
+	"time"
+
+	"github.com/ShyftNetwork/go-empyrean/common"
+)
+
+//SBlock type
+type SBlock struct {
+	Hash       string
+	Coinbase   string
+	AgeGet     string
+	Age        time.Time
+	ParentHash string
+	UncleHash  string
+	Difficulty string
+	Size       string
+	Rewards    string
+	Number     string
+	GasUsed    uint64
+	GasLimit   uint64
+	Nonce      uint64
+	TxCount    int
+	UncleCount int
+	Blocks     []SBlock
+}
+
+type InteralWrite struct {
+	Hash    string
+	Type    string
+	From    string
+	To      string
+	Value   string
+	Gas     uint64
+	GasUsed uint64
+	Input   string
+	Output  string
+	Time    string
+}
+
+//blockRes struct
+type BlockRes struct {
+	hash     string
+	coinbase string
+	number   string
+	Blocks   []SBlock
+}
+
+type SAccounts struct {
+	Addr         string
+	Balance      string
+	AccountNonce string
+}
+
+type AccountRes struct {
+	addr        string
+	balance     string
+	AllAccounts []SAccounts
+}
+
+type TxRes struct {
+	TxEntry []ShyftTxEntryPretty
+}
+
+type ShyftTxEntryPretty struct {
+	TxHash      string
+	To          *common.Address
+	ToGet       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
+	AccountNonce uint64 `json:",string"`
+}

core/shyft_database_util.go

@@ -1,170 +1,81 @@
 package core
 
 import (
-	"math/big"
-	"time"
-	"strconv"
 	"database/sql"
+	"fmt"
 	"log"
-	_ "github.com/lib/pq"
+	"math/big"
+	"strconv"
+	"strings"
+	"time"
+
 	"github.com/ShyftNetwork/go-empyrean/common"
-	"github.com/ShyftNetwork/go-empyrean/core/types"
 	Rewards "github.com/ShyftNetwork/go-empyrean/consensus/ethash"
+	stypes "github.com/ShyftNetwork/go-empyrean/core/sTypes"
+	"github.com/ShyftNetwork/go-empyrean/core/types"
 	"github.com/ShyftNetwork/go-empyrean/shyfttracerinterface"
+	_ "github.com/lib/pq"
 )
 
+//IShyftTracer Used to initialize ShyftTracer
 var IShyftTracer shyfttracerinterface.IShyftTracer
 
+//SetIShyftTracer sets tracer type
 func SetIShyftTracer(st shyfttracerinterface.IShyftTracer) {
 	IShyftTracer = st
 }
 
-//SBlock type
+//SWriteBlock writes to block info to sql db
-type SBlock struct {
-	Hash     	string
-	Coinbase 	string
-	AgeGet      string
-	Age 		time.Time
-	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
-type blockRes struct {
-	hash     string
-	coinbase string
-	number   string
-	Blocks   []SBlock
-}
-
-type SAccounts struct {
-	Addr    		string
-	Balance 		string
-	AccountNonce	string
-}
-
-type accountRes struct {
-	addr        string
-	balance     string
-	AllAccounts []SAccounts
-}
-
-type txRes struct {
-	TxEntry []ShyftTxEntryPretty
-}
-
-type ShyftTxEntryPretty struct {
-	TxHash    		string
-	To				*common.Address
-	ToGet			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
-	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)
+	//Get miner rewards
-
+	rewards := swriteMinerRewards(sqldb, block)
-	blockData := SBlock{
+	//Format block time to be stored
-		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(),
-		Rewards:        rewards,
-	}
-
 	i, err := strconv.ParseInt(block.Time().String(), 10, 64)
 	if err != nil {
 		panic(err)
 	}
 	age := time.Unix(i, 0)
 
-	blockAge := SBlock {
+	blockData := stypes.SBlock{
-		Age:   age,
+		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(),
+		Rewards:    rewards,
+		Age:        age,
 	}
 
 	//Inserts block data into DB
-	InsertBlock(sqldb, blockData, blockAge)
+	InsertBlock(sqldb, blockData)
 
 	if block.Transactions().Len() > 0 {
 		for _, tx := range block.Transactions() {
 			swriteTransactions(sqldb, tx, block.Header().Hash(), blockData.Number, receipts, age, blockData.GasLimit)
-			if block.Transactions()[0].To() != nil {
-				swriteFromBalance(sqldb, tx)
-			}
-			if block.Transactions()[0].To() == nil {
-				swriteContractBalance(sqldb, tx)
-			}
 		}
 	}
 	return nil
 }
 
 //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 {
+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 string
+	var toAddr *common.Address
 	var contractAddressFromReciept common.Address
 
-	txData := ShyftTxEntryPretty{
-		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
@@ -177,13 +88,7 @@ func swriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.H
 			}
 		}
 		isContract = true
-		contractData := ShyftTxEntryPretty{
+		toAddr = &contractAddressFromReciept
-			Status: 	statusFromReciept,
-			IsContract: isContract,
-			To:         &contractAddressFromReciept,
-		}
-		//Insert Tx into DB
-		InsertTx(sqldb, txData, contractData)
 	} else {
 		isContract = false
 		for _, receipt := range receipts {
@@ -195,99 +100,118 @@ func swriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.H
 				statusFromReciept = "SUCCESS"
 			}
 		}
-		data := ShyftTxEntryPretty{
+		toAddr = tx.To()
-			Status: 	statusFromReciept,
-			IsContract: isContract,
-			To:			tx.To(),
-		}
-		//Insert Tx into DB
-		InsertTx(sqldb, txData, data)
 	}
+
+	txData := stypes.ShyftTxEntryPretty{
+		TxHash:      tx.Hash().Hex(),
+		From:        tx.From().Hex(),
+		To:          toAddr,
+		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(),
+		Status:      statusFromReciept,
+		IsContract:  isContract,
+	}
+	//Inserts Tx into DB
+	InsertTx(sqldb, txData)
 	//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 {
+//SWriteInternalTxBalances Writes internal txs and updates balances
-	sendAndReceiveData := SendAndReceive{
+func SWriteInternalTxBalances(sqldb *sql.DB, toAddr string, fromAddr string, amount string) error {
-		From:   		tx.From().Hex(),
+	sendAndReceiveData := stypes.SendAndReceive{
-		Amount: 		tx.Value().String(),
+		To:     toAddr,
-		AccountNonce: 	tx.Nonce(),
+		From:   fromAddr,
+		Amount: amount,
 	}
-
+	_, _, err := AccountExists(sqldb, sendAndReceiveData.To)
-	fromAddressBalance, fromAccountNonce, err := AccountExists(sqldb, sendAndReceiveData.From)
+	value := new(big.Int)
-
+	value, _ = value.SetString(amount, 10)
 	switch {
 	case err == sql.ErrNoRows:
-		accountNonce := strconv.FormatUint(tx.Nonce(), 10)
+		accountNonce := "1"
-		CreateAccount(sqldb, sendAndReceiveData.From, sendAndReceiveData.Amount, accountNonce)
+		CreateAccount(sqldb, sendAndReceiveData.To, sendAndReceiveData.Amount, accountNonce)
+		adjustBalanceFromAddr(sqldb, sendAndReceiveData, value)
+	case err != nil:
+		log.Fatal(err)
 	default:
-		var newBalanceSender,newAccountNonceSender  big.Int
+		balanceHelper(sqldb, sendAndReceiveData, amount)
-		var nonceIncrement = big.NewInt(1)
-
-		fromBalance := new(big.Int)
-		fromBalance, _ = fromBalance.SetString(fromAddressBalance, 10)
-
-		fromNonce := new(big.Int)
-		fromNonce, _ = fromNonce.SetString(fromAccountNonce, 10)
-
-		newBalanceSender.Sub(fromBalance, tx.Value())
-		newAccountNonceSender.Add(fromNonce, nonceIncrement)
-
-		UpdateAccount(sqldb, sendAndReceiveData.From, newBalanceSender.String(), newAccountNonceSender.String())
 	}
 	return nil
 }
 
-//writeFromBalance writes senders balance to accounts db
+func adjustBalanceFromAddr(sqldb *sql.DB, s stypes.SendAndReceive, value *big.Int) {
-func swriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
+	fromAddressBalance, fromAccountNonce, err := AccountExists(sqldb, s.From)
-	sendAndReceiveData := SendAndReceive{
-		To: tx.To().Hex(),
-		From: tx.From().Hex(),
-		Amount: tx.Value().String(),
-	}
-
-	toAddressBalance, toAccountNonce, err := AccountExists(sqldb, sendAndReceiveData.To)
-
 	switch {
 	case err == sql.ErrNoRows:
-		accountNonce := strconv.FormatUint(tx.Nonce(), 10)
+		CreateAccount(sqldb, s.From, "0", "1")
-		CreateAccount(sqldb, sendAndReceiveData.To, sendAndReceiveData.Amount, accountNonce)
+		fmt.Println("New From account created")
-	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())
 	}
-	return nil
+	if err != nil {
+		log.Fatal(err)
+	}
+	var newBalanceSender, newAccountNonceSender big.Int
+	var nonceIncrement = big.NewInt(1)
+
+	fromBalance := new(big.Int)
+	fromBalance, _ = fromBalance.SetString(fromAddressBalance, 10)
+
+	fromNonce := new(big.Int)
+	fromNonce, _ = fromNonce.SetString(fromAccountNonce, 10)
+
+	newBalanceSender.Sub(fromBalance, value)
+	newAccountNonceSender.Add(fromNonce, nonceIncrement)
+
+	UpdateAccount(sqldb, s.From, newBalanceSender.String(), newAccountNonceSender.String())
+}
+
+func balanceHelper(sqldb *sql.DB, s stypes.SendAndReceive, amount string) {
+	fromAddressBalance, fromAccountNonce, err := AccountExists(sqldb, s.From)
+	toAddressBalance, toAccountNonce, err := AccountExists(sqldb, s.To)
+	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)
+
+	amountValue := new(big.Int)
+	amountValue, _ = amountValue.SetString(amount, 10)
+
+	//ACCOUNT NONCES
+	toNonce := new(big.Int)
+	toNonce, _ = toNonce.SetString(toAccountNonce, 10)
+
+	fromNonce := new(big.Int)
+	fromNonce, _ = fromNonce.SetString(fromAccountNonce, 10)
+
+	newBalanceReceiver.Add(toBalance, amountValue)
+	newBalanceSender.Sub(fromBalance, amountValue)
+
+	newAccountNonceReceiver.Add(toNonce, nonceIncrement)
+	newAccountNonceSender.Add(fromNonce, nonceIncrement)
+
+	//UPDATE ACCOUNTS BASED ON NEW BALANCES AND ACCOUNT NONCES
+	UpdateAccount(sqldb, s.To, newBalanceReceiver.String(), newAccountNonceReceiver.String())
+	UpdateAccount(sqldb, s.From, newBalanceSender.String(), newAccountNonceSender.String())
 }
 
 // @NOTE: This function is extremely complex and requires heavy testing and knowdlege of edge cases:
@@ -309,7 +233,7 @@ func swriteMinerRewards(sqldb *sql.DB, block *types.Block) string {
 	// https://ethereum.stackexchange.com/questions/27172/different-uncles-reward
 	// line 551 in consensus.go (shyft_go-ethereum/consensus/ethash/consensus.go)
 	// Some weird constants to avoid constant memory allocs for them.
-	var big8   = big.NewInt(8)
+	var big8 = big.NewInt(8)
 	var uncleRewards []*big.Int
 	var uncleAddrs []string
 
@@ -378,19 +302,21 @@ func sstoreReward(sqldb *sql.DB, address string, reward *big.Int) {
 ///////////////////////
 //DB Utility functions
 //////////////////////
-func CreateAccount (sqldb *sql.DB, addr string, balance string, accountNonce string) {
+
+//CreateAccount writes new account to Postgres Db
+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, balance, accountNonce).Scan(&addr)
+	insertErr := sqldb.QueryRow(sqlStatement, strings.ToLower(addr), balance, accountNonce).Scan(&addr)
 	if insertErr != nil {
 		panic(insertErr)
 	}
 }
 
-func AccountExists (sqldb *sql.DB, addr string) (string, string, error) {
+//AccountExists checks if account exists in Postgres Db
+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)
+	err := sqldb.QueryRow(sqlExistsStatement, strings.ToLower(addr)).Scan(&addressBalance, &accountNonce)
-
 	switch {
 	case err == sql.ErrNoRows:
 		return addressBalance, accountNonce, err
@@ -401,30 +327,55 @@ func AccountExists (sqldb *sql.DB, addr string) (string, string, error) {
 	}
 }
 
+//BlockExists checks if block exists in Postgres Db
+func BlockExists(sqldb *sql.DB, hash string) error {
+	var res string
+	sqlExistsStatement := `SELECT hash from blocks WHERE hash= ($1)`
+	err := sqldb.QueryRow(sqlExistsStatement, strings.ToLower(hash)).Scan(&res)
+	switch {
+	case err == sql.ErrNoRows:
+		return err
+		panic(err)
+	default:
+		return err
+	}
+}
+
+//UpdateAccount updates account in Postgres Db
 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)
+	_, updateErr := sqldb.Exec(updateSQLStatement, strings.ToLower(addr), balance, accountNonce)
 	if updateErr != nil {
 		panic(updateErr)
 	}
 }
 
-func InsertBlock(sqldb *sql.DB, blockData SBlock, blockAge SBlock) {
+//InsertBlock writes block to Postgres Db
+func InsertBlock(sqldb *sql.DB, blockData stypes.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)
+	qerr := sqldb.QueryRow(sqlStatement, strings.ToLower(blockData.Hash), blockData.Coinbase, blockData.Number, blockData.GasUsed, blockData.GasLimit, blockData.TxCount, blockData.UncleCount, blockData.Age, blockData.ParentHash, blockData.UncleHash, blockData.Difficulty, blockData.Size, blockData.Rewards, blockData.Nonce).Scan(&blockData.Number)
 	if qerr != nil {
 		panic(qerr)
 	}
 }
 
-
+//InsertTx writes tx to Postgres Db
-func InsertTx (sqldb *sql.DB, txData ShyftTxEntryPretty, data ShyftTxEntryPretty) {
+func InsertTx(sqldb *sql.DB, txData stypes.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)
+	err := sqldb.QueryRow(sqlStatement, strings.ToLower(txData.TxHash), strings.ToLower(txData.From), strings.ToLower(txData.To.String()), strings.ToLower(txData.BlockHash), txData.BlockNumber, txData.Amount, txData.GasPrice, txData.Gas, txData.GasLimit, txData.Cost, txData.Nonce, txData.IsContract, txData.Status, txData.Age, txData.Data).Scan(&retNonce)
 	if err != nil {
 		panic(err)
 	}
 }
 
-
+//InsertInternalTx writes internal tx to Postgres Db
+func InsertInternalTx(sqldb *sql.DB, i stypes.InteralWrite) {
+	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, strings.ToLower(i.Hash), strings.ToLower(i.From), strings.ToLower(i.To), i.Value, i.Gas, i.GasUsed, i.Time, i.Input, i.Output).Scan(&returnValue)
+	if qerr != nil {
+		fmt.Println(qerr)
+		panic(qerr)
+	}
+}

core/shyft_get_utils.go

@@ -1,17 +1,19 @@
 package core
 
 import (
-	"encoding/json"
 	"database/sql"
+	"encoding/json"
 	"fmt"
 	"time"
+
+	stypes "github.com/ShyftNetwork/go-empyrean/core/sTypes"
 )
 
 ///////////
 // Getters
 //////////
 func SGetAllBlocks(sqldb *sql.DB) string {
-	var arr blockRes
+	var arr stypes.BlockRes
 	var blockArr string
 	rows, err := sqldb.Query(`SELECT * FROM blocks`)
 	if err != nil {
@@ -25,23 +27,23 @@ func SGetAllBlocks(sqldb *sql.DB) string {
 		var txCount, uncleCount int
 
 		err = rows.Scan(
-			&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num,)
+			&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num)
 
-		arr.Blocks = append(arr.Blocks, SBlock{
+		arr.Blocks = append(arr.Blocks, stypes.SBlock{
-			Hash:     		hash,
+			Hash:       hash,
-			Coinbase: 		coinbase,
+			Coinbase:   coinbase,
-			GasUsed: 		gasUsed,
+			GasUsed:    gasUsed,
-			GasLimit: 		gasLimit,
+			GasLimit:   gasLimit,
-			TxCount: 		txCount,
+			TxCount:    txCount,
-			UncleCount: 	uncleCount,
+			UncleCount: uncleCount,
-			AgeGet: 		age,
+			AgeGet:     age,
-			ParentHash:		parentHash,
+			ParentHash: parentHash,
-			UncleHash:		uncleHash,
+			UncleHash:  uncleHash,
-			Difficulty:		difficulty,
+			Difficulty: difficulty,
-			Size: 			size,
+			Size:       size,
-			Nonce:			nonce,
+			Nonce:      nonce,
-			Rewards: 		rewards,
+			Rewards:    rewards,
-			Number:   		num,
+			Number:     num,
 		})
 
 		blocks, _ := json.Marshal(arr.Blocks)
@@ -61,23 +63,23 @@ func SGetBlock(sqldb *sql.DB, blockNumber string) string {
 	var txCount, uncleCount int
 
 	row.Scan(
-		&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num,)
+		&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num)
 
-	block := SBlock{
+	block := stypes.SBlock{
-		Hash:     	hash,
+		Hash:       hash,
-		Coinbase: 	coinbase,
+		Coinbase:   coinbase,
-		GasUsed: 	gasUsed,
+		GasUsed:    gasUsed,
-		GasLimit: 	gasLimit,
+		GasLimit:   gasLimit,
-		TxCount: 	txCount,
+		TxCount:    txCount,
 		UncleCount: uncleCount,
-		AgeGet: 	age,
+		AgeGet:     age,
-		ParentHash:	parentHash,
+		ParentHash: parentHash,
-		UncleHash:	uncleHash,
+		UncleHash:  uncleHash,
-		Difficulty:	difficulty,
+		Difficulty: difficulty,
-		Size: 		size,
+		Size:       size,
-		Nonce:		nonce,
+		Nonce:      nonce,
-		Rewards: 	rewards,
+		Rewards:    rewards,
-		Number:   	num,
+		Number:     num,
 	}
 	json, _ := json.Marshal(block)
 	return string(json)
@@ -91,30 +93,30 @@ func SGetRecentBlock(sqldb *sql.DB) string {
 	var txCount, uncleCount int
 
 	row.Scan(
-		&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num,)
+		&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num)
 
-	block := SBlock{
+	block := stypes.SBlock{
-		Hash:     	hash,
+		Hash:       hash,
-		Coinbase: 	coinbase,
+		Coinbase:   coinbase,
-		GasUsed: 	gasUsed,
+		GasUsed:    gasUsed,
-		GasLimit: 	gasLimit,
+		GasLimit:   gasLimit,
-		TxCount: 	txCount,
+		TxCount:    txCount,
 		UncleCount: uncleCount,
-		AgeGet: 	age,
+		AgeGet:     age,
-		ParentHash:	parentHash,
+		ParentHash: parentHash,
-		UncleHash:	uncleHash,
+		UncleHash:  uncleHash,
-		Difficulty:	difficulty,
+		Difficulty: difficulty,
-		Size: 		size,
+		Size:       size,
-		Nonce:		nonce,
+		Nonce:      nonce,
-		Rewards: 	rewards,
+		Rewards:    rewards,
-		Number:   	num,
+		Number:     num,
 	}
 	json, _ := json.Marshal(block)
 	return string(json)
 }
 
 func SGetAllTransactionsFromBlock(sqldb *sql.DB, blockNumber string) string {
-	var arr txRes
+	var arr stypes.TxRes
 	var txx string
 	sqlStatement := `SELECT * FROM txs WHERE blocknumber=$1`
 	rows, err := sqldb.Query(sqlStatement, blockNumber)
@@ -133,22 +135,22 @@ func SGetAllTransactionsFromBlock(sqldb *sql.DB, blockNumber string) string {
 			&txhash, &to_addr, &from_addr, &blockhash, &blocknumber, &amount, &gasprice, &gas, &gasLimit, &txfee, &nonce, &status, &isContract, &age, &data,
 		)
 
-		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
+		arr.TxEntry = append(arr.TxEntry, stypes.ShyftTxEntryPretty{
-			TxHash:    	 txhash,
+			TxHash:      txhash,
 			ToGet:       to_addr,
-			From:      	 from_addr,
+			From:        from_addr,
-			BlockHash: 	 blockhash,
+			BlockHash:   blockhash,
 			BlockNumber: blocknumber,
-			Amount:    	 amount,
+			Amount:      amount,
-			GasPrice:  	 gasprice,
+			GasPrice:    gasprice,
-			Gas:       	 gas,
+			Gas:         gas,
-			GasLimit: 	 gasLimit,
+			GasLimit:    gasLimit,
-			Cost:      	 txfee,
+			Cost:        txfee,
-			Nonce:     	 nonce,
+			Nonce:       nonce,
-			Status:    	 status,
+			Status:      status,
 			IsContract:  isContract,
-			Age:		 age,
+			Age:         age,
-			Data: 		 data,
+			Data:        data,
 		})
 
 		tx, _ := json.Marshal(arr.TxEntry)
@@ -159,7 +161,7 @@ func SGetAllTransactionsFromBlock(sqldb *sql.DB, blockNumber string) string {
 }
 
 func SGetAllBlocksMinedByAddress(sqldb *sql.DB, coinbase string) string {
-	var arr blockRes
+	var arr stypes.BlockRes
 	var blockArr string
 	sqlStatement := `SELECT * FROM blocks WHERE coinbase=$1`
 	rows, err := sqldb.Query(sqlStatement, coinbase)
@@ -174,23 +176,23 @@ func SGetAllBlocksMinedByAddress(sqldb *sql.DB, coinbase string) string {
 		var txCount, uncleCount int
 
 		err = rows.Scan(
-			&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num,)
+			&hash, &coinbase, &gasUsed, &gasLimit, &txCount, &uncleCount, &age, &parentHash, &uncleHash, &difficulty, &size, &nonce, &rewards, &num)
 
-		arr.Blocks = append(arr.Blocks, SBlock{
+		arr.Blocks = append(arr.Blocks, stypes.SBlock{
-			Hash:     	hash,
+			Hash:       hash,
-			Coinbase: 	coinbase,
+			Coinbase:   coinbase,
-			GasUsed: 	gasUsed,
+			GasUsed:    gasUsed,
-			GasLimit: 	gasLimit,
+			GasLimit:   gasLimit,
-			TxCount: 	txCount,
+			TxCount:    txCount,
 			UncleCount: uncleCount,
-			AgeGet: 	age,
+			AgeGet:     age,
-			ParentHash:	parentHash,
+			ParentHash: parentHash,
-			UncleHash:	uncleHash,
+			UncleHash:  uncleHash,
-			Difficulty:	difficulty,
+			Difficulty: difficulty,
-			Size: 		size,
+			Size:       size,
-			Nonce:		nonce,
+			Nonce:      nonce,
-			Rewards: 	rewards,
+			Rewards:    rewards,
-			Number:   	num,
+			Number:     num,
 		})
 
 		blocks, _ := json.Marshal(arr.Blocks)
@@ -202,7 +204,7 @@ func SGetAllBlocksMinedByAddress(sqldb *sql.DB, coinbase string) string {
 
 //GetAllTransactions getter fn for API
 func SGetAllTransactions(sqldb *sql.DB) string {
-	var arr txRes
+	var arr stypes.TxRes
 	var txx string
 	rows, err := sqldb.Query(`SELECT * FROM txs`)
 	if err != nil {
@@ -220,22 +222,22 @@ func SGetAllTransactions(sqldb *sql.DB) string {
 			&txhash, &to_addr, &from_addr, &blockhash, &blocknumber, &amount, &gasprice, &gas, &gasLimit, &txfee, &nonce, &status, &isContract, &age, &data,
 		)
 
-		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
+		arr.TxEntry = append(arr.TxEntry, stypes.ShyftTxEntryPretty{
-			TxHash:    	 txhash,
+			TxHash:      txhash,
 			ToGet:       to_addr,
-			From:      	 from_addr,
+			From:        from_addr,
-			BlockHash: 	 blockhash,
+			BlockHash:   blockhash,
 			BlockNumber: blocknumber,
-			Amount:    	 amount,
+			Amount:      amount,
-			GasPrice:  	 gasprice,
+			GasPrice:    gasprice,
-			Gas:       	 gas,
+			Gas:         gas,
-			GasLimit: 	 gasLimit,
+			GasLimit:    gasLimit,
-			Cost:      	 txfee,
+			Cost:        txfee,
-			Nonce:     	 nonce,
+			Nonce:       nonce,
-			Status:    	 status,
+			Status:      status,
 			IsContract:  isContract,
-			Age:		 age,
+			Age:         age,
-			Data: 		 data,
+			Data:        data,
 		})
 
 		tx, _ := json.Marshal(arr.TxEntry)
@@ -258,39 +260,39 @@ func SGetTransaction(sqldb *sql.DB, txHash string) string {
 	row.Scan(
 		&txhash, &to_addr, &from_addr, &blockhash, &blocknumber, &amount, &gasprice, &gas, &gasLimit, &txfee, &nonce, &status, &isContract, &age, &data)
 
-	tx := ShyftTxEntryPretty{
+	tx := stypes.ShyftTxEntryPretty{
 		TxHash:      txhash,
 		ToGet:       to_addr,
-		From:      	 from_addr,
+		From:        from_addr,
-		BlockHash: 	 blockhash,
+		BlockHash:   blockhash,
 		BlockNumber: blocknumber,
 		Amount:      amount,
 		GasPrice:    gasprice,
 		Gas:         gas,
-		GasLimit:	 gasLimit,
+		GasLimit:    gasLimit,
-		Cost:      	 txfee,
+		Cost:        txfee,
-		Nonce:     	 nonce,
+		Nonce:       nonce,
-		Status:    	 status,
+		Status:      status,
 		IsContract:  isContract,
-		Age:		 age,
+		Age:         age,
-		Data:	     data,
+		Data:        data,
 	}
 	json, _ := json.Marshal(tx)
 
 	return string(json)
 }
 
-func InnerSGetAccount(sqldb *sql.DB, address string) (SAccounts, bool) {
+func InnerSGetAccount(sqldb *sql.DB, address string) (stypes.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
+		return stypes.SAccounts{}, false
 	} else {
-		account := SAccounts{
+		account := stypes.SAccounts{
-			Addr:    		addr,
+			Addr:         addr,
-			Balance: 		balance,
+			Balance:      balance,
-			AccountNonce: 	accountNonce,
+			AccountNonce: accountNonce,
 		}
 		return account, true
 	}
@@ -305,7 +307,7 @@ func SGetAccount(sqldb *sql.DB, address string) string {
 
 //GetAllAccounts returns all accounts and balances
 func SGetAllAccounts(sqldb *sql.DB) string {
-	var array accountRes
+	var array stypes.AccountRes
 	var accountsArr, accountNonce string
 
 	accs, err := sqldb.Query(`
@@ -326,10 +328,10 @@ func SGetAllAccounts(sqldb *sql.DB) string {
 			&addr, &balance, &accountNonce,
 		)
 
-		array.AllAccounts = append(array.AllAccounts, SAccounts{
+		array.AllAccounts = append(array.AllAccounts, stypes.SAccounts{
-			Addr:    		addr,
+			Addr:         addr,
-			Balance: 		balance,
+			Balance:      balance,
-			AccountNonce: 	accountNonce,
+			AccountNonce: accountNonce,
 		})
 
 		accounts, _ := json.Marshal(array.AllAccounts)
@@ -341,7 +343,7 @@ func SGetAllAccounts(sqldb *sql.DB) string {
 
 //GetAccount returns account balances
 func SGetAccountTxs(sqldb *sql.DB, address string) string {
-	var arr txRes
+	var arr stypes.TxRes
 	var txx string
 	sqlStatement := `SELECT * FROM txs WHERE to_addr=$1 OR from_addr=$1;`
 	rows, err := sqldb.Query(sqlStatement, address)
@@ -360,22 +362,22 @@ func SGetAccountTxs(sqldb *sql.DB, address string) string {
 			&txhash, &to_addr, &from_addr, &blockhash, &blocknumber, &amount, &gasprice, &gas, &gasLimit, &txfee, &nonce, &status, &isContract, &age, &data,
 		)
 
-		arr.TxEntry = append(arr.TxEntry, ShyftTxEntryPretty{
+		arr.TxEntry = append(arr.TxEntry, stypes.ShyftTxEntryPretty{
-			TxHash:    	 txhash,
+			TxHash:      txhash,
 			ToGet:       to_addr,
-			From:      	 from_addr,
+			From:        from_addr,
 			BlockHash:   blockhash,
 			BlockNumber: blocknumber,
-			Amount:    	 amount,
+			Amount:      amount,
-			GasPrice:  	 gasprice,
+			GasPrice:    gasprice,
-			Gas:       	 gas,
+			Gas:         gas,
-			GasLimit: 	 gasLimit,
+			GasLimit:    gasLimit,
-			Cost:      	 txfee,
+			Cost:        txfee,
-			Nonce:     	 nonce,
+			Nonce:       nonce,
-			Status:    	 status,
+			Status:      status,
 			IsContract:  isContract,
-			Age:		 age,
+			Age:         age,
-			Data: 		 data,
+			Data:        data,
 		})
 
 		tx, _ := json.Marshal(arr.TxEntry)

eth/api_tracer.go

@@ -631,8 +631,6 @@ func (api *PrivateDebugAPI) StraceTx(ctx context.Context, message core.Message,
 	}
 }
 
-
-
 // traceTx configures a new tracer according to the provided configuration, and
 // executes the given message in the provided environment. The return value will
 // be tracer dependent.
@@ -646,7 +644,7 @@ func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, v
 	case config != nil && config.Tracer != nil:
 		// Define a meaningful timeout of a single transaction trace
 
-		 timeout := defaultTraceTimeout
+		timeout := defaultTraceTimeout
 
 		if config.Timeout != nil {
 			if timeout, err = time.ParseDuration(*config.Timeout); err != nil {

eth/shyft_tracer.go

@@ -1,15 +1,16 @@
 package eth
 
-
 import (
+	"context"
+	"fmt"
+
 	"github.com/ShyftNetwork/go-empyrean/common"
 	"github.com/ShyftNetwork/go-empyrean/params"
-	"context"
 )
 
 var EthereumObject interface{}
 
-type ShyftTracer struct {}
+type ShyftTracer struct{}
 
 var PrivateAPI *PrivateDebugAPI
 var Context context.Context
@@ -23,9 +24,9 @@ func InitTracerEnv() {
 	Context = ctx2
 	config := &TraceConfig{
 		LogConfig: nil,
-		Tracer: &jsTracer,  // needs to be non-nil
+		Tracer:    &jsTracer, // needs to be non-nil
-		Timeout: nil,
+		Timeout:   nil,
-		Reexec: nil,
+		Reexec:    nil,
 	}
 	TracerConfig = config
 	fullNode, _ := SNew(Global_config)
@@ -33,11 +34,11 @@ func InitTracerEnv() {
 	PrivateAPI = privateAPI
 }
 
-func (st ShyftTracer) GetTracerToRun (hash common.Hash) (interface{}, error) {
+func (st ShyftTracer) GetTracerToRun(hash common.Hash) (interface{}, error) {
 	return PrivateAPI.STraceTransaction(Context, hash, TracerConfig)
 }
 
-func setEthObject(ethobj interface{}){
+func setEthObject(ethobj interface{}) {
 	EthereumObject = ethobj
 }
 

eth/tracers/tracer.go

@@ -25,14 +25,16 @@ import (
 	"time"
 	"unsafe"
 
+	"strconv"
+
 	"github.com/ShyftNetwork/go-empyrean/common"
 	"github.com/ShyftNetwork/go-empyrean/common/hexutil"
 	"github.com/ShyftNetwork/go-empyrean/core"
+	stypes "github.com/ShyftNetwork/go-empyrean/core/sTypes"
 	"github.com/ShyftNetwork/go-empyrean/core/vm"
 	"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.
@@ -603,14 +605,21 @@ func (i *Internals) SWriteInteralTxs(hash common.Hash) {
 	value, _ := hexutil.DecodeUint64(i.Value)
 	amount := strconv.FormatUint(value, 10)
 
-	var returnValue string
+	iTx := stypes.InteralWrite{
-	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`
+		Hash:    hash.Hex(),
-	qerr := sqldb.QueryRow(sqlStatement, i.Type, hash.Hex(), i.From, i.To, amount, gas, gasUsed, i.Time, i.Input, i.Output).Scan(&returnValue)
+		Type:    i.Type,
-
+		From:    i.From,
-	if qerr != nil {
+		To:      i.To,
-		fmt.Println(qerr)
+		Value:   amount,
-		panic(qerr)
+		Gas:     gas,
+		GasUsed: gasUsed,
+		Input:   i.Input,
+		Output:  i.Output,
+		Time:    i.Time,
 	}
+	//@TODO WRITE OVER TRANSACTION STRUCT
+	core.SWriteInternalTxBalances(sqldb, i.To, i.From, amount)
+	core.InsertInternalTx(sqldb, iTx)
 }
 
 //@NOTE:SHYFT

shyftBlockExplorerApi/handler.go

@@ -7,11 +7,12 @@ import (
 
 	_ "github.com/lib/pq"
 
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+
 	"github.com/ShyftNetwork/go-empyrean/core"
 	"github.com/gorilla/mux"
-	"bytes"
-	"io/ioutil"
-	"encoding/json"
 )
 
 // GetTransaction gets txs
@@ -239,7 +240,7 @@ func BroadcastTx(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintln(w, "ERROR parsing json")
 	}
 	tx_hash := dat["result"]
-	if(tx_hash == nil) {
+	if tx_hash == nil {
 		errMap := dat["error"].(map[string]interface{})
 		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
 		w.WriteHeader(http.StatusOK)

shyftBlockExplorerUI/src/components/table/accounts/accountRows.js

@@ -21,7 +21,6 @@ class AccountTable extends Component {
     }
 
     render() {
-
         let startNum = 1;
         const sorted = [...this.state.data];
             sorted.sort((a, b) => Number(a.Balance) > Number(b.Balance));
@@ -38,7 +37,7 @@ class AccountTable extends Component {
                 Percentage={percentage.toFixed(2)}
                 Addr={data.Addr}
                 Balance={conversion}
-                AcountNonce={data.AccountNonce}
+                AccountNonce={data.AccountNonce}
                 detailAccountHandler={this.props.detailAccountHandler}
             />
         });

shyftBlockExplorerUI/src/components/table/accounts/detailAccountsRow.js

@@ -17,7 +17,7 @@ class AccountTransactionTable extends Component {
                     age={data.Age}
                     txHash={data.TxHash}
                     blockNumber={data.BlockNumber}
-                    to={data.To}
+                    to={data.ToGet}
                     from={data.From}
                     value={amountConversion}
                     cost={costConversion}

shyftBlockExplorerUI/src/components/table/blocks/blockRows.js

@@ -30,7 +30,7 @@ class BlocksTable extends Component {
                 Hash={data.Hash}
                 Number={data.Number}
                 Coinbase={data.Coinbase}
-                Age={data.Age}
+                AgeGet={data.AgeGet}
                 GasUsed={data.GasUsed}
                 GasLimit={data.GasLimit}
                 UncleCount={data.UncleCount}

shyftBlockExplorerUI/src/components/table/blocks/blockTable.js

@@ -10,7 +10,7 @@ const BlockTable = (props) => {
                     {props.Number}
                 </Link></td>
                 <td className={classes.addressTag}>{props.Hash}</td>
-                <td>{props.Age}</td>
+                <td>{props.AgeGet}</td>
                 <td>{props.TxCount}</td>
                 <td>{props.UncleCount}</td>
                 <td className={classes.addressTag}><Link to="/mined/blocks" onClick={() => props.getBlocksMined(props.Coinbase)}>{props.Coinbase}</Link></td>

shyftBlockExplorerUI/src/components/table/blocks/blocksDetailsRow.js

@@ -16,7 +16,7 @@ class DetailBlockTable extends Component {
                 </tr>
                 <tr>
                     <th scope="col">Age:</th>
-                    <td>{data.Age}</td>
+                    <td>{data.AgeGet}</td>
                 </tr>
                 <tr>
                     <th scope="col">Txn:</th>

shyftBlockExplorerUI/src/components/table/blocks/blocksMined.js

@@ -19,7 +19,7 @@ class BlocksMinedTable extends Component {
                 Hash={data.Hash}
                 Number={data.Number}
                 Coinbase={data.Coinbase}
-                Age={data.Age}
+                AgeGet={data.AgeGet}
                 GasUsed={data.GasUsed}
                 GasLimit={data.GasLimit}
                 UncleCount={data.UncleCount}

shyftBlockExplorerUI/src/components/table/blocks/blocksMinedTable.js

@@ -10,7 +10,7 @@ const MinedBlockTable = (props) => {
                 {props.Number}
             </Link></td>
             <td className={classes.addressTag}>{props.Hash}</td>
-            <td>{props.Age}</td>
+            <td>{props.AgeGet}</td>
             <td>{props.TxCount}</td>
             <td>{props.UncleCount}</td>
             <td className={classes.addressTag}>{props.Coinbase}</td>

shyftBlockExplorerUI/src/components/table/transactions/transactionDetailsRow.js

@@ -32,7 +32,7 @@ class DetailTransactionTable extends Component {
                 </tr>
                 <tr>
                     <th scope="col">To:</th>
-                    <td>{ `${data.IsContract}` ? `${data.To} (Contract)` : `${data.To}` }</td>
+                    <td>{ `${data.IsContract}` ? `${data.ToGet} (Contract)` : `${data.ToGet}` }</td>
                 </tr>
                 <tr>
                     <th scope="col">Value:</th>

shyftBlockExplorerUI/src/components/table/transactions/transactionRow.js

@@ -31,7 +31,7 @@ class TransactionTable extends Component {
                 age={data.Age}
                 txHash={data.TxHash}
                 blockNumber={data.BlockNumber}
-                to={data.To}
+                to={data.ToGet}
                 from={data.From}
                 value={data.Amount}
                 cost={conversion}

shyftDb/postgres_setup_test/create_tables_test.psql

@@ -16,7 +16,7 @@ CREATE TABLE IF NOT EXISTS blocks (
 );
 
 CREATE TABLE IF NOT EXISTS txs (
-  txHash text,
+  txHash text primary key unique,
   to_addr text,
   from_addr text,
   blockhash text references blocks(hash),
@@ -36,5 +36,19 @@ CREATE TABLE IF NOT EXISTS txs (
 CREATE TABLE IF NOT EXISTS accounts (
   addr text primary key unique,
   balance numeric,
-  accountnonce numeric
+  accountNonce numeric
 );
+
+CREATE TABLE IF NOT EXISTS internalTxs (
+  id SERIAL PRIMARY KEY,
+  txHash text references txs(txHash),
+  type text,
+  to_addr text,
+  from_addr text,
+  amount text,
+  gas numeric,
+  gasUsed numeric,
+  time text,
+  input text,
+  output text
+)

shyftDb/postgres_setup_test/drop_tables_test.psql

@@ -1,3 +1,4 @@
+DROP TABLE internalTxs;
 DROP TABLE txs;
 DROP TABLE blocks;
 DROP TABLE accounts;

shyftDb/shyft_database_util_test.go

@@ -1,30 +1,33 @@
 package shyftdb
 
 import (
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"strconv"
+	"strings"
 	"testing"
+
 	"github.com/ShyftNetwork/go-empyrean/common"
+	"github.com/ShyftNetwork/go-empyrean/consensus/ethash"
 	"github.com/ShyftNetwork/go-empyrean/core"
 	"github.com/ShyftNetwork/go-empyrean/core/types"
-	"github.com/ShyftNetwork/go-empyrean/eth"
-	"math/big"
-	//"time"
-	"encoding/json"
 	"github.com/ShyftNetwork/go-empyrean/crypto"
-	"github.com/ShyftNetwork/go-empyrean/consensus/ethash"
+	"github.com/ShyftNetwork/go-empyrean/eth"
-	"strconv"
 )
 
-type ShyftTracer struct {}
+type ShyftTracer struct{}
 
 const (
-	testAddress  = "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"
+	testAddress = "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"
 )
 
 func TestBlock(t *testing.T) {
+	//SET UP FOR TEST FUNCTIONS
 	eth.NewShyftTestLDB()
 	core.InitDBTest()
-	shyft_tracer := new(eth.ShyftTracer)
+	shyftTracer := new(eth.ShyftTracer)
-	core.SetIShyftTracer(shyft_tracer)
+	core.SetIShyftTracer(shyftTracer)
 
 	ethConf := &eth.Config{
 		Genesis:   core.DeveloperGenesisBlock(15, common.Address{}),
@@ -37,127 +40,56 @@ func TestBlock(t *testing.T) {
 	eth.SetGlobalConfig(ethConf)
 
 	eth.InitTracerEnv()
+	core.ClearTables()
+
+	key, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+	signer := types.NewEIP155Signer(big.NewInt(2147483647))
+
+	//Nonce, To Address,Value, GasLimit, Gasprice, data
+	tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), big.NewInt(5), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
+	mytx1, _ := types.SignTx(tx1, signer, key)
+	tx2 := types.NewTransaction(2, common.BytesToAddress([]byte{0x22}), big.NewInt(5), 2222, big.NewInt(22222), []byte{0x22, 0x22, 0x22})
+	mytx2, _ := types.SignTx(tx2, signer, key)
+	tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), big.NewInt(5), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
+	mytx3, _ := types.SignTx(tx3, signer, key)
+	txs := []*types.Transaction{mytx1, mytx2}
+	txs1 := []*types.Transaction{mytx3}
+
+	//Nonce,Value, GasLimit, Gasprice, data
+	contractCreation := types.NewContractCreation(1, big.NewInt(111), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
+	mytx4, _ := types.SignTx(contractCreation, signer, key)
+	txs2 := []*types.Transaction{mytx4}
+
+	receipt := &types.Receipt{
+		Status:            types.ReceiptStatusSuccessful,
+		CumulativeGasUsed: 1,
+		Logs: []*types.Log{
+			{Address: common.BytesToAddress([]byte{0x11})},
+			{Address: common.BytesToAddress([]byte{0x01, 0x11})},
+		},
+		TxHash:          common.BytesToHash([]byte{0x11, 0x11}),
+		ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
+		GasUsed:         111111,
+	}
+	receipts := []*types.Receipt{receipt}
+
+	block1 := types.NewBlock(&types.Header{Number: big.NewInt(323)}, txs, nil, receipts)
+	block2 := types.NewBlock(&types.Header{Number: big.NewInt(320)}, txs1, nil, receipts)
+	block3 := types.NewBlock(&types.Header{Number: big.NewInt(322)}, txs2, nil, receipts)
+	blocks := []*types.Block{block1, block2, block3}
+
+	sqldb, err := core.DBConnection()
+	if err != nil {
+		panic(err)
+	}
+
+	fromAddr := "0x71562b71999873db5b286df957af199ec94617f7"
+	fromAddrEndBalance := "75"
+	fromAddrEndNonce := "5"
+	toAddr := common.BytesToAddress([]byte{0x11})
+	core.CreateAccount(sqldb, fromAddr, "201", "1")
 
 	t.Run("TestBlockToReturnBlock", func(t *testing.T) {
-		key, _   := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-		signer  := types.NewEIP155Signer(big.NewInt(2147483647))
-
-		//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})
-		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})
-		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})
-		mytx3,_ := types.SignTx(tx3, signer, key)
-		txs := []*types.Transaction{mytx, mytx2, mytx3}
-
-		receipt := &types.Receipt{
-			Status:            types.ReceiptStatusSuccessful,
-			CumulativeGasUsed: 1,
-			Logs: []*types.Log{
-				{Address: common.BytesToAddress([]byte{0x11})},
-				{Address: common.BytesToAddress([]byte{0x01, 0x11})},
-			},
-			TxHash:          common.BytesToHash([]byte{0x11, 0x11}),
-			ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
-			GasUsed:         111111,
-		}
-
-		receipts := []*types.Receipt{receipt}
-		block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts)
-
-		// 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)
-		}
-
-		sqldb, err := core.DBConnection()
-		if err != nil {
-			panic(err)
-		}
-
-		entry := core.SGetBlock(sqldb, block.Number().String())
-		byt := []byte(entry)
-		var data core.SBlock
-		json.Unmarshal(byt, &data)
-
-		//TODO Difficulty, rewards, age
-		if block.Hash().String() != data.Hash {
-			t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String())
-		}
-		if block.Coinbase().String() != data.Coinbase {
-			t.Fatalf("Block coinbase [%v]: Block coinbase not found", block.Coinbase().String())
-		}
-		if block.Number().String() != data.Number {
-			t.Fatalf("Block number [%v]: Block number not found", block.Number().String())
-		}
-		if block.GasUsed() != data.GasUsed {
-			t.Fatalf("Gas Used [%v]: Gas used not found", block.GasUsed())
-		}
-		if block.GasLimit() != data.GasLimit {
-			t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit())
-		}
-		if block.Transactions().Len() != data.TxCount {
-			t.Fatalf("Tx Count [%v]: Tx Count not found", block.Transactions().Len())
-		}
-		if len(block.Uncles()) != data.UncleCount {
-			t.Fatalf("Uncle count [%v]: Uncle count not found", len(block.Uncles()))
-		}
-		if block.ParentHash().String() != data.ParentHash {
-			t.Fatalf("Parent hash [%v]: Parent hash not found", block.ParentHash().String())
-		}
-		if block.UncleHash().String() != data.UncleHash {
-			t.Fatalf("Uncle hash [%v]: Uncle hash not found", block.UncleHash().String())
-		}
-		if block.Size().String() != data.Size {
-			t.Fatalf("Size [%v]: Size not found", block.Size().String())
-		}
-		if block.Nonce() != data.Nonce {
-			t.Fatalf("Block nonce [%v]: Block nonce not found", block.Nonce())
-		}
-
-		if getAllBlocks := core.SGetAllBlocks(sqldb); len(getAllBlocks) == 0 {
-			t.Fatalf("GetAllBlocks [%v]: GetAllBlocks did not return correctly", getAllBlocks)
-		}
-
-		if getAllBlocksMinedByAddress := core.SGetAllBlocksMinedByAddress(sqldb, block.Coinbase().String()); len(getAllBlocksMinedByAddress) == 0 {
-			t.Fatalf("GetAllBlocksMinedByAddress [%v]: GetAllBlocksMinedByAddress did not return correctly", getAllBlocksMinedByAddress)
-		}
-
-		ClearTables()
-	})
-
-	t.Run("TestGetRecentBlock", func(t *testing.T) {
-		key, _   := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-		signer   := types.NewEIP155Signer(big.NewInt(2147483647))
-
-		//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})
-		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})
-		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})
-		mytx3,_ := types.SignTx(tx3, signer, key)
-		txs  := []*types.Transaction{mytx, mytx2}
-		txs1 := []*types.Transaction{mytx3}
-
-		receipt1 := &types.Receipt{
-			Status:            types.ReceiptStatusSuccessful,
-			CumulativeGasUsed: 1,
-			Logs: []*types.Log{
-				{Address: common.BytesToAddress([]byte{0x11})},
-				{Address: common.BytesToAddress([]byte{0x01, 0x11})},
-			},
-			TxHash:          common.BytesToHash([]byte{0x11, 0x11}),
-			ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
-			GasUsed:         111111,
-		}
-
-		receipts := []*types.Receipt{receipt1}
-		block := types.NewBlock(&types.Header{Number: big.NewInt(322)}, txs, nil, receipts)
-		block2 := types.NewBlock(&types.Header{Number: big.NewInt(320)}, txs1, nil, receipts)
-		blocks := []*types.Block{block, block2}
-
 		for _, bc := range blocks {
 			// Write and verify the block in the database
 			if err := core.SWriteBlock(bc, receipts); err != nil {
@@ -165,351 +97,269 @@ func TestBlock(t *testing.T) {
 			}
 		}
 
-		sqldb, err := core.DBConnection()
+		entry := core.SGetBlock(sqldb, block1.Number().String())
-		if (err != nil) {
+		byt := []byte(entry)
-			panic(err)
+		var data core.SBlock
+		json.Unmarshal(byt, &data)
+
+		//TODO Difficulty, rewards, age
+		if block1.Hash().String() != data.Hash {
+			t.Fatalf("Block Hash [%v]: Block hash not found", block1.Hash().String())
+		}
+		if block1.Coinbase().String() != data.Coinbase {
+			t.Fatalf("Block coinbase [%v]: Block coinbase not found", block1.Coinbase().String())
+		}
+		if block1.Number().String() != data.Number {
+			t.Fatalf("Block number [%v]: Block number not found", block1.Number().String())
+		}
+		if block1.GasUsed() != data.GasUsed {
+			t.Fatalf("Gas Used [%v]: Gas used not found", block1.GasUsed())
+		}
+		if block1.GasLimit() != data.GasLimit {
+			t.Fatalf("Gas Limit [%v]: Gas limit not found", block1.GasLimit())
+		}
+		if block1.Transactions().Len() != data.TxCount {
+			t.Fatalf("Tx Count [%v]: Tx Count not found", block1.Transactions().Len())
+		}
+		if len(block1.Uncles()) != data.UncleCount {
+			t.Fatalf("Uncle count [%v]: Uncle count not found", len(block1.Uncles()))
+		}
+		if block1.ParentHash().String() != data.ParentHash {
+			t.Fatalf("Parent hash [%v]: Parent hash not found", block1.ParentHash().String())
+		}
+		if block1.UncleHash().String() != data.UncleHash {
+			t.Fatalf("Uncle hash [%v]: Uncle hash not found", block1.UncleHash().String())
+		}
+		if block1.Size().String() != data.Size {
+			t.Fatalf("Size [%v]: Size not found", block1.Size().String())
+		}
+		if block1.Nonce() != data.Nonce {
+			t.Fatalf("Block nonce [%v]: Block nonce not found", block1.Nonce())
 		}
 
+		if getAllBlocks := core.SGetAllBlocks(sqldb); len(getAllBlocks) == 0 {
+			t.Fatalf("GetAllBlocks [%v]: GetAllBlocks did not return correctly", getAllBlocks)
+		}
+
+		if getAllBlocksMinedByAddress := core.SGetAllBlocksMinedByAddress(sqldb, block1.Coinbase().String()); len(getAllBlocksMinedByAddress) == 0 {
+			t.Fatalf("GetAllBlocksMinedByAddress [%v]: GetAllBlocksMinedByAddress did not return correctly", getAllBlocksMinedByAddress)
+		}
+	})
+
+	t.Run("TestGetRecentBlock", func(t *testing.T) {
 		response := core.SGetRecentBlock(sqldb)
 		byteRes := []byte(response)
 		var recentBlock core.SBlock
 		json.Unmarshal(byteRes, &recentBlock)
 
-		if block.Hash().String() != recentBlock.Hash {
+		if block1.Hash().String() != recentBlock.Hash {
-			t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String())
+			t.Fatalf("Block Hash [%v]: Block hash not found", block1.Hash().String())
 		}
-		if block.Coinbase().String() != recentBlock.Coinbase {
+		if block1.Coinbase().String() != recentBlock.Coinbase {
-			t.Fatalf("Block coinbase [%v]: Block coinbase not found", block.Coinbase().String())
+			t.Fatalf("Block coinbase [%v]: Block coinbase not found", block1.Coinbase().String())
 		}
-		if block.Number().String() != recentBlock.Number {
+		if block1.Number().String() != recentBlock.Number {
-			t.Fatalf("Block number [%v]: Block number not found", block.Number().String())
+			t.Fatalf("Block number [%v]: Block number not found", block1.Number().String())
 		}
-		if block.GasUsed() != recentBlock.GasUsed {
+		if block1.GasUsed() != recentBlock.GasUsed {
-			t.Fatalf("Gas Used [%v]: Gas used not found", block.GasUsed())
+			t.Fatalf("Gas Used [%v]: Gas used not found", block1.GasUsed())
 		}
-		if block.GasLimit() != recentBlock.GasLimit {
+		if block1.GasLimit() != recentBlock.GasLimit {
-			t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit())
+			t.Fatalf("Gas Limit [%v]: Gas limit not found", block1.GasLimit())
 		}
-		if block.Transactions().Len() != recentBlock.TxCount {
+		if block1.Transactions().Len() != recentBlock.TxCount {
-			t.Fatalf("Tx Count [%v]: Tx Count not found", block.Transactions().Len())
+			t.Fatalf("Tx Count [%v]: Tx Count not found", block1.Transactions().Len())
 		}
-		if len(block.Uncles()) != recentBlock.UncleCount {
+		if len(block1.Uncles()) != recentBlock.UncleCount {
-			t.Fatalf("Uncle count [%v]: Uncle count not found", len(block.Uncles()))
+			t.Fatalf("Uncle count [%v]: Uncle count not found", len(block1.Uncles()))
 		}
-		if block.ParentHash().String() != recentBlock.ParentHash {
+		if block1.ParentHash().String() != recentBlock.ParentHash {
-			t.Fatalf("Parent hash [%v]: Parent hash not found", block.ParentHash().String())
+			t.Fatalf("Parent hash [%v]: Parent hash not found", block1.ParentHash().String())
 		}
-		if block.UncleHash().String() != recentBlock.UncleHash {
+		if block1.UncleHash().String() != recentBlock.UncleHash {
-			t.Fatalf("Uncle hash [%v]: Uncle hash not found", block.UncleHash().String())
+			t.Fatalf("Uncle hash [%v]: Uncle hash not found", block1.UncleHash().String())
 		}
-		if block.Size().String() != recentBlock.Size {
+		if block1.Size().String() != recentBlock.Size {
-			t.Fatalf("Size [%v]: Size not found", block.Size().String())
+			t.Fatalf("Size [%v]: Size not found", block1.Size().String())
 		}
-		if block.Nonce() != recentBlock.Nonce {
+		if block1.Nonce() != recentBlock.Nonce {
-			t.Fatalf("Block nonce [%v]: Block nonce not found", block.Nonce())
+			t.Fatalf("Block nonce [%v]: Block nonce not found", block1.Nonce())
 		}
 
-		if allTxsFromBlock:= core.SGetAllTransactionsFromBlock(sqldb, block2.Number().String()); len(allTxsFromBlock) == 0 {
+		if allTxsFromBlock := core.SGetAllTransactionsFromBlock(sqldb, block2.Number().String()); len(allTxsFromBlock) == 0 {
 			t.Fatalf("GetAllTransactionsFromBlock [%v]: GetAllTransactionsFromBlock did not return correctly", allTxsFromBlock)
 		}
-		ClearTables()
 	})
 
-//
+	t.Run("TestContractCreationTx", func(t *testing.T) {
-t.Run("TestContractCreationTx", func (t *testing.T) {
+		var contractAddressFromReciept string
-	key, _   := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+		for _, receipt := range receipts {
-	signer  := types.NewEIP155Signer(big.NewInt(2147483647))
+			contractAddressFromReciept = (*types.ReceiptForStorage)(receipt).ContractAddress.String()
+		}
 
-	//Nonce,Value, GasLimit, Gasprice, data
+		for _, tx := range txs2 {
-	contractCreation := types.NewContractCreation(1, big.NewInt(111), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
+			txn := core.SGetTransaction(sqldb, tx.Hash().String())
-	mytx,_ := types.SignTx(contractCreation, signer, key)
+			byt := []byte(txn)
-	txs := []*types.Transaction{mytx}
+			var data core.ShyftTxEntryPretty
+			json.Unmarshal(byt, &data)
 
-	receipt2 := &types.Receipt{
+			if tx.Hash().String() != data.TxHash {
-		Status:            types.ReceiptStatusSuccessful,
+				t.Fatalf("txHash [%v]: tx Hash not found", tx.Hash().String())
-		CumulativeGasUsed: 1,
+			}
-		Logs: []*types.Log{
+			if contractAddressFromReciept != data.ToGet {
-			{Address: common.BytesToAddress([]byte{0x11})},
+				t.Fatalf("Contract Addr [%v]: Contract addr not found", contractAddressFromReciept)
-			{Address: common.BytesToAddress([]byte{0x01, 0x11})},
+			}
-		},
+			if strings.ToLower(tx.From().String()) != data.From {
-		TxHash:          common.BytesToHash([]byte{0x11, 0x11}),
+				t.Fatalf("From Addr [%v]: From addr not found", tx.From().String())
-		ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
+			}
-		GasUsed:         111111,
+			if tx.Nonce() != data.Nonce {
-	}
+				t.Fatalf("Nonce [%v]: Nonce not found", tx.Nonce())
+			}
+			if tx.Gas() != data.Gas {
+				t.Fatalf("Gas [%v]: Gas not found", tx.Gas())
+			}
+			if tx.GasPrice().Uint64() != data.GasPrice {
+				t.Fatalf("Gas Price [%v]: Gas price not found", tx.GasPrice().String())
+			}
+			if block1.GasLimit() != data.GasLimit {
+				t.Fatalf("Gas Limit [%v]: Gas limit not found", block1.GasLimit())
+			}
+			if block3.Hash().String() != data.BlockHash {
+				t.Fatalf("Block Hash [%v]: Block hash not found", block1.Hash().String())
+			}
+			if block3.Number().String() != data.BlockNumber {
+				t.Fatalf("Block Number [%v]: Block number not found", block1.Number().String())
+			}
+			if tx.Value().String() != data.Amount {
+				t.Fatalf("Amount [%v]: Amount not found", tx.Value().String())
+			}
+			if tx.Cost().Uint64() != data.Cost {
+				t.Fatalf("Cost [%v]: Cost not found", tx.Cost().String())
+			}
+			var status string
+			if receipt.Status == 1 {
+				status = "SUCCESS"
+			}
+			if receipt.Status == 0 {
+				status = "FAIL"
+			}
+			if status != data.Status {
+				t.Fatalf("Receipt status [%v]: Receipt status not found", status)
+			}
+			var isContract bool
+			if tx.To() != nil {
+				isContract = false
+			} else {
+				isContract = true
+			}
+			if isContract != data.IsContract {
+				t.Fatalf("isContract [%v]: isContract bool is incorrect", isContract)
+			}
+		}
+	})
 
-	receipts := []*types.Receipt{receipt2}
+	t.Run("TestTransactionsToReturnTransactions", func(t *testing.T) {
-	block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, receipts)
+		for _, tx := range txs {
-
+			txn := core.SGetTransaction(sqldb, tx.Hash().String())
-	if err := core.SWriteBlock(block, receipts); err != nil {
-		t.Fatalf("Failed to write block into database: %v", err)
-	}
-
-	var contractAddressFromReciept string
-	for _, receipt := range receipts {
-		contractAddressFromReciept = (*types.ReceiptForStorage)(receipt).ContractAddress.String()
-	}
-
-	sqldb, err := core.DBConnection()
-	if (err != nil) {
-		panic(err)
-	}
-
-	for _, tx := range txs {
-		txn := core.SGetTransaction(sqldb, tx.Hash().String())
-		byt := []byte(txn)
-		var data core.ShyftTxEntryPretty
-		json.Unmarshal(byt, &data)
-
-		if tx.Hash().String() != data.TxHash {
-			t.Fatalf("txHash [%v]: tx Hash not found", tx.Hash().String())
-		}
-		if contractAddressFromReciept != data.ToGet {
-			t.Fatalf("Contract Addr [%v]: Contract addr not found", contractAddressFromReciept)
-		}
-		if tx.From().String() != data.From {
-			t.Fatalf("From Addr [%v]: From addr not found", tx.From().String())
-		}
-		if tx.Nonce() != data.Nonce {
-			t.Fatalf("Nonce [%v]: Nonce not found", tx.Nonce())
-		}
-		if tx.Gas() != data.Gas {
-			t.Fatalf("Gas [%v]: Gas not found", tx.Gas())
-		}
-		if tx.GasPrice().Uint64() != data.GasPrice {
-			t.Fatalf("Gas Price [%v]: Gas price not found", tx.GasPrice().String())
-		}
-		if block.GasLimit() != data.GasLimit {
-			t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit())
-		}
-		if block.Hash().String() != data.BlockHash {
-			t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String())
-		}
-		if block.Number().String() != data.BlockNumber {
-			t.Fatalf("Block Number [%v]: Block number not found", block.Number().String())
-		}
-		if tx.Value().String() != data.Amount {
-			t.Fatalf("Amount [%v]: Amount not found", tx.Value().String())
-		}
-		if tx.Cost().Uint64() != data.Cost {
-			t.Fatalf("Cost [%v]: Cost not found", tx.Cost().String())
-		}
-		var status string
-		if receipt2.Status == 1 {
-			status = "SUCCESS"
-		}
-		if receipt2.Status == 0 {
-			status = "FAIL"
-		}
-		if status != data.Status {
-			t.Fatalf("Receipt status [%v]: Receipt status not found", status)
-		}
-		var isContract bool
-		if tx.To() != nil {
-			isContract = false
-		} else {
-			isContract = true
-		}
-		if isContract != data.IsContract {
-			t.Fatalf("isContract [%v]: isContract bool is incorrect", isContract)
-		}
-	}
-	ClearTables()
-})
-
-t.Run("TestTransactionsToReturnTransactions", func(t *testing.T) {
-	key, _   := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-	signer  := types.NewEIP155Signer(big.NewInt(2147483647))
-
-	//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})
-	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})
-	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})
-	mytx3,_ := types.SignTx(tx3, signer, key)
-	txs := []*types.Transaction{mytx, mytx2, mytx3}
-
-	receipt1 := &types.Receipt{
-		Status:            types.ReceiptStatusSuccessful,
-		CumulativeGasUsed: 1,
-		Logs: []*types.Log{
-			{Address: common.BytesToAddress([]byte{0x11})},
-			{Address: common.BytesToAddress([]byte{0x01, 0x11})},
-		},
-		TxHash:          common.BytesToHash([]byte{0x11, 0x11}),
-		ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
-		GasUsed:         111111,
-	}
-
-	receipts := []*types.Receipt{receipt1}
-	block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, receipts)
-
-	if err := core.SWriteBlock(block, receipts); err != nil {
-		t.Fatalf("Failed to write block into database: %v", err)
-	}
-	sqldb, err := core.DBConnection()
-	if (err != nil) {
-		panic(err)
-	}
-
-	for _, tx := range txs {
-		txn := core.SGetTransaction(sqldb, tx.Hash().String())
 			byt := []byte(txn)
 			var data core.ShyftTxEntryPretty
 			json.Unmarshal(byt, &data)
 
 			//TODO age, data
-		if tx.Hash().String() != data.TxHash {
+			if strings.ToLower(tx.Hash().String()) != data.TxHash {
-			t.Fatalf("txHash [%v]: tx Hash not found", tx.Hash().String())
+				t.Fatalf("txHash [%v]: tx Hash not found", tx.Hash().String())
+			}
+			if strings.ToLower(tx.From().String()) != data.From {
+				t.Fatalf("From Addr [%v]: From addr not found", tx.From().String())
+			}
+			if strings.ToLower(tx.To().String()) != data.ToGet {
+				t.Fatalf("To Addr [%v]: To addr not found", tx.To().String())
+			}
+			if tx.Nonce() != data.Nonce {
+				t.Fatalf("Nonce [%v]: Nonce not found", tx.Nonce())
+			}
+			if tx.Gas() != data.Gas {
+				t.Fatalf("Gas [%v]: Gas not found", tx.Gas())
+			}
+			if tx.GasPrice().Uint64() != data.GasPrice {
+				t.Fatalf("Gas Price [%v]: Gas price not found", tx.GasPrice().String())
+			}
+			if block1.GasLimit() != data.GasLimit {
+				t.Fatalf("Gas Limit [%v]: Gas limit not found", block1.GasLimit())
+			}
+			if block1.Hash().String() != data.BlockHash {
+				t.Fatalf("Block Hash [%v]: Block hash not found", block1.Hash().String())
+			}
+			if block1.Number().String() != data.BlockNumber {
+				t.Fatalf("Block Number [%v]: Block number not found", block1.Number().String())
+			}
+			if tx.Value().String() != data.Amount {
+				t.Fatalf("Amount [%v]: Amount not found", tx.Value().String())
+			}
+			if tx.Cost().Uint64() != data.Cost {
+				t.Fatalf("Cost [%v]: Cost not found", tx.Cost().String())
+			}
+			var status string
+			if receipt.Status == 1 {
+				status = "SUCCESS"
+			}
+			if receipt.Status == 0 {
+				status = "FAIL"
+			}
+			if status != data.Status {
+				t.Fatalf("Receipt status [%v]: Receipt status not found", status)
+			}
+			var isContract bool
+			if tx.To() != nil {
+				isContract = false
+			} else {
+				isContract = true
+			}
+			if isContract != data.IsContract {
+				t.Fatalf("isContract [%v]: isContract bool is incorrect", isContract)
+			}
 		}
-		if tx.From().String() != data.From {
+		if getAllTx := core.SGetAllTransactions(sqldb); len(getAllTx) == 0 {
-			t.Fatalf("From Addr [%v]: From addr not found", tx.From().String())
+			t.Fatalf("GetAllTransactions [%v]: GetAllTransactions did not return correctly", getAllTx)
 		}
-		if tx.To().String() != data.ToGet {
+	})
-			t.Fatalf("To Addr [%v]: To addr not found", tx.To().String())
+	t.Run("TestAccountsToReturnAccounts", func(t *testing.T) {
-		}
+		for _, tx := range txs {
-		if tx.Nonce() != data.Nonce {
+			fmt.Println("test account", tx.To().String())
-			t.Fatalf("Nonce [%v]: Nonce not found", tx.Nonce())
+			accountAddrTo := core.SGetAccount(sqldb, tx.To().String())
-		}
+			byts := []byte(accountAddrTo)
-		if tx.Gas() != data.Gas {
+			var accountDataTo core.SAccounts
-			t.Fatalf("Gas [%v]: Gas not found", tx.Gas())
+			json.Unmarshal(byts, &accountDataTo)
-		}
-		if tx.GasPrice().Uint64() != data.GasPrice {
-			t.Fatalf("Gas Price [%v]: Gas price not found", tx.GasPrice().String())
-		}
-		if block.GasLimit() != data.GasLimit {
-			t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit())
-		}
-		if block.Hash().String() != data.BlockHash {
-			t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String())
-		}
-		if block.Number().String() != data.BlockNumber {
-			t.Fatalf("Block Number [%v]: Block number not found", block.Number().String())
-		}
-		if tx.Value().String() != data.Amount {
-			t.Fatalf("Amount [%v]: Amount not found", tx.Value().String())
-		}
-		if tx.Cost().Uint64() != data.Cost {
-			t.Fatalf("Cost [%v]: Cost not found", tx.Cost().String())
-		}
-		var status string
-		if receipt1.Status == 1 {
-			status = "SUCCESS"
-		}
-		if receipt1.Status == 0 {
-			status = "FAIL"
-		}
-		if status != data.Status {
-			t.Fatalf("Receipt status [%v]: Receipt status not found", status)
-		}
-		var isContract bool
-		if tx.To() != nil {
-			isContract = false
-		} else {
-			isContract = true
-		}
-		if isContract != data.IsContract {
-			t.Fatalf("isContract [%v]: isContract bool is incorrect", isContract)
-		}
-	}
 
-	if getAllTx := core.SGetAllTransactions(sqldb); len(getAllTx) == 0 {
+			if strings.ToLower(tx.To().String()) != accountDataTo.Addr {
-		t.Fatalf("GetAllTransactions [%v]: GetAllTransactions did not return correctly", getAllTx)
+				t.Fatalf("To address [%v]: To address not found", accountDataTo.Addr)
-	}
+			}
-	ClearTables()
+			if tx.Value().String() != accountDataTo.Balance {
-})
+				t.Fatalf("To address balance [%v]: To address balance not found", accountDataTo.Balance)
-
+			}
-t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
+			if strconv.FormatUint(tx.Nonce(), 10) != accountDataTo.AccountNonce {
-	key, _   := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+				t.Fatalf("To account nonce [%v]: To account nonce not found", accountDataTo.AccountNonce)
-	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 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")
-
-	//Nonce, To Address,Value, GasLimit, Gasprice, data
-	tx1 := types.NewTransaction(1, toAddr1, toAmount1, 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
-	mytx,_ := types.SignTx(tx1, signer, key)
-	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, toAddr3, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
-	mytx3,_ := types.SignTx(tx3, signer, key)
-	txs := []*types.Transaction{mytx, mytx2, mytx3}
-
-	receipt1 := &types.Receipt{
-		Status:            types.ReceiptStatusSuccessful,
-		CumulativeGasUsed: 1,
-		Logs: []*types.Log{
-			{Address: common.BytesToAddress([]byte{0x11})},
-			{Address: common.BytesToAddress([]byte{0x01, 0x11})},
-		},
-		TxHash:          common.BytesToHash([]byte{0x11, 0x11}),
-		ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
-		GasUsed:         111111,
-	}
-
-	receipts := []*types.Receipt{receipt1}
-	block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts)
-		if err := core.SWriteBlock(block, receipts); err != nil {
-			t.Fatalf("Failed to write block into database: %v", err)
 		}
+		accountAddrFrom := core.SGetAccount(sqldb, fromAddr)
+		byts := []byte(accountAddrFrom)
+		var accountDataFrom core.SAccounts
+		json.Unmarshal(byts, &accountDataFrom)
 
-	if toAddr1.String() != tx1.To().String() {
+		if fromAddr != accountDataFrom.Addr {
-		t.Fatalf("To address [%v]: To address not found", toAddr1.String())
+			t.Fatalf("To address [%v]: To address not found", accountDataFrom.Addr)
-	}
+		}
-	accountAddrTo, _ := core.InnerSGetAccount(sqldb, toAddr1.String())
+		if fromAddrEndBalance != accountDataFrom.Balance {
-	//ewAccountNonceReceiver.Add(accountR, nonceIncrement)
+			t.Fatalf("To address balance [%v]: To address balance not found", accountDataFrom.Balance)
-	addedAmount := new(big.Int)
+		}
-	toAmountPrevious1, _ := strconv.ParseUint(toAmountPrev1, 10, 64)
+		if fromAddrEndNonce != accountDataFrom.AccountNonce {
-	b := new(big.Int).SetUint64(toAmountPrevious1)
+			t.Fatalf("To account nonce [%v]: To account nonce not found", accountDataFrom.AccountNonce)
-	addedAmount.Add(toAmount1, b)
+		}
-	toBalance := new(big.Int)
+		if getAllAccountTxs := core.SGetAccountTxs(sqldb, toAddr.String()); len(getAllAccountTxs) == 0 {
-	toBalance, _ = toBalance.SetString(accountAddrTo.Balance, 10)
+			t.Fatalf("GetAccountTxs [%v]: GetAccountTxs did not return correctly", getAllAccountTxs)
-
+		}
-	if toBalance.Cmp(addedAmount) != 0 {
+		if getAllAccounts := core.SGetAllAccounts(sqldb); len(getAllAccounts) == 0 {
-		t.Fatalf("To address balance [%v]: To address balance not correct FFO", toBalance)
+			t.Fatalf("GetAllAccounts [%v]: GetAllAccounts did not return correctly", getAllAccounts)
-	}
+		}
-
+	})
-	//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, 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()
 }
-