forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-19 02:12:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

unit testing for account balances

Browse source
This commit is contained in:
Dustin Brickwood 2018-08-01 15:17:38 -04:00
parent f066a8e461
commit d299d2baeb
3 changed files with 439 additions and 419 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
core/db.go
View file

@ -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)
}
}

64
core/shyft_database_util.go
View file

@ -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(),
}
toAddressBalance, toAccountNonce, err := AccountExists(sqldb, sendAndReceiveData.To)
value := tx.Value()
_, _, 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())
newBalanceSender.Sub(fromBalance, tx.Value())
newBalanceReceiver.Add(toBalance, 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, sendAndReceiveData.From, newBalanceSender.String(), newAccountNonceSender.String())
}
return nil
UpdateAccount(sqldb, s.To, newBalanceReceiver.String(), newAccountNonceReceiver.String())
UpdateAccount(sqldb, s.From, newBalanceSender.String(), newAccountNonceSender.String())
}
//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)
}
}

175
shyftDb/shyft_database_util_test.go
View file

@ -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"
"strconv"
"github.com/ShyftNetwork/go-empyrean/eth"
)
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)
core.SetIShyftTracer(shyft_tracer)
shyftTracer := new(eth.ShyftTracer)
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)
}
ClearTables()
fmt.Println("passed")
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()
})
t.Run("TestTransactionsToReturnTransactions", func(t *testing.T) {
fmt.Println("Passed 3")
core.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)
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()
})
t.Run("TestAccountsToReturnAccounts",func(t *testing.T) {
fmt.Println("Passed 4")
core.ClearTables()
})
//
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")
core.CreateAccount(sqldb, toAddr2.Hex(), "423798729847", "1")
core.CreateAccount(sqldb, toAddr3.Hex(), "0", "1")
core.CreateAccount(sqldb, "0x71562b71999873DB5b286dF957af199Ec94617F7", "3968686868", "1")
fromAddr := "0x71562b71999873db5b286df957af199ec94617f7"
core.CreateAccount(sqldb, fromAddr, "50", "1")
toAddr := common.BytesToAddress([]byte{0x11})
//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)
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)
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{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() {
t.Fatalf("To address [%v]: To address not found", toAddr1.String())
for _, tx := range txs {
accountAddrTo := core.SGetAccount(sqldb, tx.To().String())
byts := []byte(accountAddrTo)
var accountDataTo core.SAccounts
json.Unmarshal(byts, &accountDataTo)
if strings.ToLower(tx.To().String()) != accountDataTo.Addr {
t.Fatalf("To address [%v]: To address not found", accountDataTo.Addr)
}
accountAddrTo, _ := core.InnerSGetAccount(sqldb, toAddr1.String())
//ewAccountNonceReceiver.Add(accountR, nonceIncrement)
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 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)
}
}
accountAddrFrom := core.SGetAccount(sqldb, fromAddr)
byts := []byte(accountAddrFrom)
var accountDataFrom core.SAccounts
json.Unmarshal(byts, &accountDataFrom)
//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)
// }
//}
fmt.Println("FROM", accountDataFrom)
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()
}