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