unit testing for account balances

core/db.go

@@ -37,11 +37,36 @@ func InitDBTest() (*sql.DB, error){
 }
 
 func DBConnection() (*sql.DB, error) {
-	if (blockExplorerDb == nil) {
+	if blockExplorerDb == nil {
 		_, err := InitDB()
-		if(err != nil) {
+		if err != nil {
 			return nil, err
 		}
 	}
 	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/shyft_database_util.go

@@ -1,18 +1,19 @@
 package core
 
 import (
-	"math/big"
-	"time"
-	"strconv"
 	"database/sql"
-	"log"
-	_ "github.com/lib/pq"
-	"github.com/ShyftNetwork/go-empyrean/common"
-	"github.com/ShyftNetwork/go-empyrean/core/types"
-	Rewards "github.com/ShyftNetwork/go-empyrean/consensus/ethash"
-	"github.com/ShyftNetwork/go-empyrean/shyfttracerinterface"
-	"strings"
 	"fmt"
+	"log"
+	"math/big"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/ShyftNetwork/go-empyrean/common"
+	Rewards "github.com/ShyftNetwork/go-empyrean/consensus/ethash"
+	"github.com/ShyftNetwork/go-empyrean/core/types"
+	"github.com/ShyftNetwork/go-empyrean/shyfttracerinterface"
+	_ "github.com/lib/pq"
 )
 
 var IShyftTracer shyfttracerinterface.IShyftTracer
@@ -114,7 +115,7 @@ func SWriteBlock(block *types.Block, receipts []*types.Receipt) error {
 	}
 
 	//Get miner rewards
-	rewards := swriteMinerRewards(sqldb,block)
+	rewards := swriteMinerRewards(sqldb, block)
 	//Format block time to be stored
 	i, err := strconv.ParseInt(block.Time().String(), 10, 64)
 	if err != nil {
@@ -229,7 +230,7 @@ func swriteContractBalance(sqldb *sql.DB, tx *types.Transaction) error {
 		accountNonce := strconv.FormatUint(tx.Nonce(), 10)
 		CreateAccount(sqldb, sendAndReceiveData.From, sendAndReceiveData.Amount, accountNonce)
 	default:
-		var newBalanceSender,newAccountNonceSender  big.Int
+		var newBalanceSender, newAccountNonceSender big.Int
 		var nonceIncrement = big.NewInt(1)
 
 		fromBalance := new(big.Int)
@@ -253,27 +254,35 @@ func swriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
 		From:   tx.From().Hex(),
 		Amount: tx.Value().String(),
 	}
-
+	value := tx.Value()
-	toAddressBalance, toAccountNonce, err := AccountExists(sqldb, sendAndReceiveData.To)
+	_, _, err := AccountExists(sqldb, sendAndReceiveData.To)
-
 	switch {
 	case err == sql.ErrNoRows:
 		accountNonce := strconv.FormatUint(tx.Nonce(), 10)
 		CreateAccount(sqldb, sendAndReceiveData.To, sendAndReceiveData.Amount, accountNonce)
+		balanceHelper(sqldb, sendAndReceiveData, value)
 	case err != nil:
 		log.Fatal(err)
 	default:
-		fromAddressBalance, fromAccountNonce, err := AccountExists(sqldb, sendAndReceiveData.From)
+		balanceHelper(sqldb, sendAndReceiveData, value)
+	}
+	return nil
+}
+
+func balanceHelper(sqldb *sql.DB, s SendAndReceive, value *big.Int) {
+	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)
-
+	fmt.Println(toAddressBalance)
 	//STRING TO BIG INT
 	//BALANCES TO AND FROM ADDR
 	toBalance := new(big.Int)
 	toBalance, _ = toBalance.SetString(toAddressBalance, 10)
+	fmt.Println(toBalance)
 	fromBalance := new(big.Int)
 	fromBalance, _ = fromBalance.SetString(fromAddressBalance, 10)
 
@@ -283,19 +292,18 @@ func swriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
 	fromNonce := new(big.Int)
 	fromNonce, _ = fromNonce.SetString(fromAccountNonce, 10)
 
-		newBalanceReceiver.Add(toBalance, tx.Value())
+	newBalanceReceiver.Add(toBalance, value)
-		newBalanceSender.Sub(fromBalance, tx.Value())
+	newBalanceSender.Sub(fromBalance, 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, s.To, newBalanceReceiver.String(), newAccountNonceReceiver.String())
-		UpdateAccount(sqldb, sendAndReceiveData.From, newBalanceSender.String(),   newAccountNonceSender.String())
+	UpdateAccount(sqldb, s.From, newBalanceSender.String(), newAccountNonceSender.String())
-	}
-	return nil
 }
 
+//SWriteInternalTxBalances Writes internal txs and updates balances
 func SWriteInternalTxBalances(sqldb *sql.DB, toAddr string, fromAddr string, amount string) error {
 	sendAndReceiveData := SendAndReceive{
 		To:     toAddr,
@@ -435,7 +443,7 @@ func sstoreReward(sqldb *sql.DB, address string, reward *big.Int) {
 ///////////////////////
 //DB Utility functions
 //////////////////////
-func CreateAccount (sqldb *sql.DB, addr string, balance string, accountNonce string) {
+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, strings.ToLower(addr), balance, accountNonce).Scan(&addr)
 	if insertErr != nil {
@@ -443,7 +451,7 @@ func CreateAccount (sqldb *sql.DB, addr string, balance string, accountNonce str
 	}
 }
 
-func AccountExists (sqldb *sql.DB, addr string) (string, string, error) {
+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, strings.ToLower(addr)).Scan(&addressBalance, &accountNonce)
@@ -457,7 +465,7 @@ func AccountExists (sqldb *sql.DB, addr string) (string, string, error) {
 	}
 }
 
-func BlockExists (sqldb *sql.DB, hash string) (error) {
+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)
@@ -486,7 +494,7 @@ func InsertBlock(sqldb *sql.DB, blockData SBlock) {
 	}
 }
 
-func InsertTx (sqldb *sql.DB, txData ShyftTxEntryPretty) {
+func InsertTx(sqldb *sql.DB, txData 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, 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)
@@ -504,5 +512,3 @@ func InsertInternalTx(sqldb *sql.DB, i InteralWrite) {
 		panic(qerr)
 	}
 }
-
-

shyftDb/shyft_database_util_test.go

@@ -1,20 +1,22 @@
 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"
@@ -23,8 +25,8 @@ const (
 func TestBlock(t *testing.T) {
 	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,6 +39,7 @@ func TestBlock(t *testing.T) {
 	eth.SetGlobalConfig(ethConf)
 
 	eth.InitTracerEnv()
+	core.ClearTables()
 
 	t.Run("TestBlockToReturnBlock", func(t *testing.T) {
 		key, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
@@ -44,11 +47,11 @@ func TestBlock(t *testing.T) {
 
 		//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)
+		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)
+		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)
+		mytx3, _ := types.SignTx(tx3, signer, key)
 		txs := []*types.Transaction{mytx, mytx2, mytx3}
 
 		receipt := &types.Receipt{
@@ -123,8 +126,8 @@ func TestBlock(t *testing.T) {
 		if getAllBlocksMinedByAddress := core.SGetAllBlocksMinedByAddress(sqldb, block.Coinbase().String()); len(getAllBlocksMinedByAddress) == 0 {
 			t.Fatalf("GetAllBlocksMinedByAddress [%v]: GetAllBlocksMinedByAddress did not return correctly", getAllBlocksMinedByAddress)
 		}
-
+		fmt.Println("passed")
-		ClearTables()
+		core.ClearTables()
 	})
 
 	t.Run("TestGetRecentBlock", func(t *testing.T) {
@@ -133,11 +136,11 @@ func TestBlock(t *testing.T) {
 
 		//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)
+		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)
+		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)
+		mytx3, _ := types.SignTx(tx3, signer, key)
 		txs := []*types.Transaction{mytx, mytx2}
 		txs1 := []*types.Transaction{mytx3}
 
@@ -166,7 +169,7 @@ func TestBlock(t *testing.T) {
 		}
 
 		sqldb, err := core.DBConnection()
-		if (err != nil) {
+		if err != nil {
 			panic(err)
 		}
 
@@ -209,20 +212,20 @@ func TestBlock(t *testing.T) {
 			t.Fatalf("Block nonce [%v]: Block nonce not found", block.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()
+		fmt.Println("Passed 2")
+		core.ClearTables()
 	})
 
-//
+	t.Run("TestContractCreationTx", func(t *testing.T) {
-t.Run("TestContractCreationTx", func (t *testing.T) {
 		key, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		signer := types.NewEIP155Signer(big.NewInt(2147483647))
 
 		//Nonce,Value, GasLimit, Gasprice, data
 		contractCreation := types.NewContractCreation(1, big.NewInt(111), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
-	mytx,_ := types.SignTx(contractCreation, signer, key)
+		mytx, _ := types.SignTx(contractCreation, signer, key)
 		txs := []*types.Transaction{mytx}
 
 		receipt2 := &types.Receipt{
@@ -250,7 +253,7 @@ t.Run("TestContractCreationTx", func (t *testing.T) {
 		}
 
 		sqldb, err := core.DBConnection()
-	if (err != nil) {
+		if err != nil {
 			panic(err)
 		}
 
@@ -266,7 +269,7 @@ t.Run("TestContractCreationTx", func (t *testing.T) {
 			if contractAddressFromReciept != data.ToGet {
 				t.Fatalf("Contract Addr [%v]: Contract addr not found", contractAddressFromReciept)
 			}
-		if tx.From().String() != data.From {
+			if strings.ToLower(tx.From().String()) != data.From {
 				t.Fatalf("From Addr [%v]: From addr not found", tx.From().String())
 			}
 			if tx.Nonce() != data.Nonce {
@@ -313,20 +316,21 @@ t.Run("TestContractCreationTx", func (t *testing.T) {
 				t.Fatalf("isContract [%v]: isContract bool is incorrect", isContract)
 			}
 		}
-	ClearTables()
+		fmt.Println("Passed 3")
-})
+		core.ClearTables()
-
+	})
-t.Run("TestTransactionsToReturnTransactions", func(t *testing.T) {
+	//
+	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)
+		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)
+		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)
+		mytx3, _ := types.SignTx(tx3, signer, key)
 		txs := []*types.Transaction{mytx, mytx2, mytx3}
 
 		receipt1 := &types.Receipt{
@@ -348,7 +352,7 @@ t.Run("TestTransactionsToReturnTransactions", func(t *testing.T) {
 			t.Fatalf("Failed to write block into database: %v", err)
 		}
 		sqldb, err := core.DBConnection()
-	if (err != nil) {
+		if err != nil {
 			panic(err)
 		}
 
@@ -359,13 +363,13 @@ t.Run("TestTransactionsToReturnTransactions", func(t *testing.T) {
 			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())
 			}
-		if tx.From().String() != data.From {
+			if strings.ToLower(tx.From().String()) != data.From {
 				t.Fatalf("From Addr [%v]: From addr not found", tx.From().String())
 			}
-		if tx.To().String() != data.ToGet {
+			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 {
@@ -416,37 +420,30 @@ t.Run("TestTransactionsToReturnTransactions", func(t *testing.T) {
 		if getAllTx := core.SGetAllTransactions(sqldb); len(getAllTx) == 0 {
 			t.Fatalf("GetAllTransactions [%v]: GetAllTransactions did not return correctly", getAllTx)
 		}
-	ClearTables()
+		fmt.Println("Passed 4")
-})
+		core.ClearTables()
-
+	})
-t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
+	//
+	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 string = "3968686868"
-
 		sqldb, err := core.DBConnection()
-	if (err != nil) {
+		if err != nil {
 			panic(err)
 		}
 
-	core.CreateAccount(sqldb, toAddr1.Hex(), toAmountPrev1, "1")
+		fromAddr := "0x71562b71999873db5b286df957af199ec94617f7"
-	core.CreateAccount(sqldb, toAddr2.Hex(), "423798729847", "1")
+		core.CreateAccount(sqldb, fromAddr, "50", "1")
-	core.CreateAccount(sqldb, toAddr3.Hex(), "0", "1")
+		toAddr := common.BytesToAddress([]byte{0x11})
-	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})
+		tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), big.NewInt(5), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
-	mytx,_ := types.SignTx(tx1, signer, key)
+		mytx, _ := types.SignTx(tx1, signer, key)
-	tx2 := types.NewTransaction(2, toAddr2, big.NewInt(222), 2222, big.NewInt(22222), []byte{0x22, 0x22, 0x22})
+		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)
+		mytx2, _ := types.SignTx(tx2, signer, key)
-	tx3 := types.NewTransaction(3, toAddr3, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
+		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)
+		mytx3, _ := types.SignTx(tx3, signer, key)
 		txs := []*types.Transaction{mytx, mytx2, mytx3}
 
 		receipt1 := &types.Receipt{
@@ -462,54 +459,46 @@ t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
 		}
 
 		receipts := []*types.Receipt{receipt1}
-	block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts)
+		block := types.NewBlock(&types.Header{Number: big.NewInt(319)}, txs, nil, receipts)
+
 		if err := core.SWriteBlock(block, receipts); err != nil {
 			t.Fatalf("Failed to write block into database: %v", err)
 		}
 
-	if toAddr1.String() != tx1.To().String() {
+		for _, tx := range txs {
-		t.Fatalf("To address [%v]: To address not found", toAddr1.String())
+			accountAddrTo := core.SGetAccount(sqldb, tx.To().String())
+			byts := []byte(accountAddrTo)
+			var accountDataTo core.SAccounts
+			json.Unmarshal(byts, &accountDataTo)
+
+			if strings.ToLower(tx.To().String()) != accountDataTo.Addr {
+				t.Fatalf("To address [%v]: To address not found", accountDataTo.Addr)
 			}
-	accountAddrTo, _ := core.InnerSGetAccount(sqldb, toAddr1.String())
+			if tx.Value().String() != accountDataTo.Balance {
-	//ewAccountNonceReceiver.Add(accountR, nonceIncrement)
+				t.Fatalf("To address balance [%v]: To address balance not found", accountDataTo.Balance)
-	addedAmount := new(big.Int)
-	toAmountPrevious1, _ := strconv.ParseUint(toAmountPrev1, 10, 64)
-	b := new(big.Int).SetUint64(toAmountPrevious1)
-	addedAmount.Add(toAmount1, b)
-	toBalance := new(big.Int)
-	toBalance, _ = toBalance.SetString(accountAddrTo.Balance, 10)
-
-	if toBalance.Cmp(addedAmount) != 0 {
-		t.Fatalf("To address balance [%v]: To address balance not correct FFO", toBalance)
 			}
+			if strconv.FormatUint(tx.Nonce(), 10) != accountDataTo.AccountNonce {
+				t.Fatalf("To account nonce [%v]: To account nonce not found", accountDataTo.AccountNonce)
+			}
+		}
+		accountAddrFrom := core.SGetAccount(sqldb, fromAddr)
+		byts := []byte(accountAddrFrom)
+		var accountDataFrom core.SAccounts
+		json.Unmarshal(byts, &accountDataFrom)
 
-	//for _, tx := range txs {
+		fmt.Println("FROM", accountDataFrom)
-	//	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 {
+		if getAllAccountTxs := core.SGetAccountTxs(sqldb, toAddr.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()
+		fmt.Println("Passed 5")
+		core.ClearTables()
+	})
+
+	core.ClearTables()
 }
-