From 3f6bdfc0e4e403093a82b1b2da4005fe59765d0d Mon Sep 17 00:00:00 2001 From: Dustin Brickwood Date: Thu, 26 Jul 2018 15:46:48 -0400 Subject: [PATCH] refactored gen write functions for internals --- core/genesis.go | 133 +++++++++++++++++------------------- core/shyft_database_util.go | 119 +++++++++++++++----------------- 2 files changed, 120 insertions(+), 132 deletions(-) diff --git a/core/genesis.go b/core/genesis.go index d13fe558c1..84a449b971 100644 --- a/core/genesis.go +++ b/core/genesis.go @@ -24,7 +24,6 @@ import ( "fmt" "math/big" "strings" - "database/sql" "github.com/ShyftNetwork/go-empyrean/common" "github.com/ShyftNetwork/go-empyrean/common/hexutil" @@ -143,92 +142,88 @@ func (e *GenesisMismatchError) Error() string { //WriteShyftGen writes the genesis block to Shyft db //@NOTE:SHYFT func WriteShyftGen(gen *Genesis, block *types.Block) { - fmt.Println("IN WRITE GEN") sqldb, _ := DBConnection() - for k, v := range gen.Alloc { - addr := k.String() - - //var response string - //sqlExistsStatement := `SELECT balance from accounts WHERE addr = ($1)` - //err := sqldb.QueryRow(sqlExistsStatement, addr).Scan(&response) - fmt.Println("[GENESIS]", strings.ToLower(addr)) - _, _, err := AccountExists(sqldb, addr) - fmt.Println("[]ACCOUNT EXISTS ERR", err) + _, _, err := AccountExists(sqldb, k.String()) switch { case err == sql.ErrNoRows: - //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) + 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) - //sqlStatement := `INSERT INTO accounts(addr, balance, accountnonce) VALUES(($1), ($2), ($3)) RETURNING addr` - //insertErr := sqldb.QueryRow(sqlStatement, strings.ToLower(addr), v.Balance.String(), accountNonce).Scan(&addr) - //if insertErr != nil { - // panic(insertErr) - //} + i, err := strconv.ParseInt(block.Time().String(), 10, 64) + if err != nil { + panic(err) + } + age := time.Unix(i, 0) - accountNoncee := strconv.FormatUint(accountNonce, 10) - CreateAccount(sqldb, addr, v.Balance.String(), accountNoncee) + txData := ShyftTxEntryPretty { + TxHash: txHash, + From: GENESIS, + 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 - //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, accountNonce, txStatus, isContract, age, data).Scan(&retNonce) - //if insertError != nil { - // panic(insertError) - //} default: - log.Info("Found Genesis Block") - } - } + log.Info("Found Genesis Block") + }} } func WriteShyftBlockZero(block *types.Block, gen *Genesis) error { - sqldb, _ := DBConnection() - coinbase := block.Header().Coinbase.String() - number := block.Header().Number.String() - gasUsed := block.Header().GasUsed - 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) + i, error := strconv.ParseInt(block.Time().String(), 10, 64) + if error != nil { + panic(error) } age := time.Unix(i, 0) - var response string - sqlExistsStatement := `SELECT hash from blocks WHERE hash= ($1)` - err = sqldb.QueryRow(sqlExistsStatement, block.Header().Hash().Hex()).Scan(&response) + 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: 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` - 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) - } + InsertBlock(sqldb, blockData) case err != nil: panic(err) default: diff --git a/core/shyft_database_util.go b/core/shyft_database_util.go index 011318c3c9..6f5c5484be 100644 --- a/core/shyft_database_util.go +++ b/core/shyft_database_util.go @@ -11,7 +11,6 @@ import ( "github.com/ShyftNetwork/go-empyrean/core/types" Rewards "github.com/ShyftNetwork/go-empyrean/consensus/ethash" "github.com/ShyftNetwork/go-empyrean/shyfttracerinterface" - "fmt" "strings" ) @@ -100,7 +99,14 @@ func SWriteBlock(block *types.Block, receipts []*types.Receipt) error { panic(err) } + //Get miner rewards rewards := swriteMinerRewards(sqldb,block) + //Format block time to be stored + i, err := strconv.ParseInt(block.Time().String(), 10, 64) + if err != nil { + panic(err) + } + age := time.Unix(i, 0) blockData := SBlock{ Hash: block.Header().Hash().Hex(), @@ -116,20 +122,12 @@ func SWriteBlock(block *types.Block, receipts []*types.Receipt) error { Size: block.Size().String(), Nonce: block.Nonce(), Rewards: rewards, + Age: age, } - i, err := strconv.ParseInt(block.Time().String(), 10, 64) - if err != nil { - panic(err) - } - age := time.Unix(i, 0) - - blockAge := SBlock { - Age: age, - } //Inserts block data into DB - InsertBlock(sqldb, blockData, blockAge) + InsertBlock(sqldb, blockData) if block.Transactions().Len() > 0 { for _, tx := range block.Transactions() { @@ -149,24 +147,9 @@ func SWriteBlock(block *types.Block, receipts []*types.Receipt) 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 @@ -179,13 +162,7 @@ func swriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.H } } isContract = true - contractData := ShyftTxEntryPretty{ - Status: statusFromReciept, - IsContract: isContract, - To: &contractAddressFromReciept, - } - //Insert Tx into DB - InsertTx(sqldb, txData, contractData) + toAddr = &contractAddressFromReciept } else { isContract = false for _, receipt := range receipts { @@ -197,14 +174,28 @@ func swriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.H statusFromReciept = "SUCCESS" } } - data := ShyftTxEntryPretty{ - Status: statusFromReciept, - IsContract: isContract, - To: tx.To(), - } - //Insert Tx into DB - InsertTx(sqldb, txData, data) + toAddr = tx.To() } + + txData := 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()) @@ -309,16 +300,9 @@ func SWriteInternalTxBalances(sqldb *sql.DB, toAddr string, fromAddr string, amo log.Fatal(err) default: fromAddressBalance, fromAccountNonce, err := AccountExists(sqldb, sendAndReceiveData.From) - if err == sql.ErrNoRows { - fmt.Println("NOT IN ACCOUNTS TABLE", sendAndReceiveData.From) - fmt.Println("THIS RAN NO ERR FROM ADDR") - //accountNonce := "1" - //CreateAccount(sqldb, sendAndReceiveData.From, sendAndReceiveData.Amount, accountNonce) - } if err != nil { log.Fatal(err) } - var newBalanceReceiver, newBalanceSender, newAccountNonceReceiver, newAccountNonceSender big.Int var nonceIncrement = big.NewInt(1) @@ -404,7 +388,6 @@ func sstoreReward(sqldb *sql.DB, address string, reward *big.Int) { addressBalance, accountNonce, err := AccountExists(sqldb, address) if err == sql.ErrNoRows { - fmt.Println("this ran", address) // Addr does not exist, thus create new entry // We convert totalReward into a string and postgres converts into number CreateAccount(sqldb, address, reward.String(), "1") @@ -440,19 +423,17 @@ func sstoreReward(sqldb *sql.DB, address string, reward *big.Int) { //DB Utility functions ////////////////////// func CreateAccount (sqldb *sql.DB, addr string, balance string, accountNonce string) { - fmt.Println("[CREATE ACCOUNT]", strings.ToLower(addr)) - //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 { - // panic(insertErr) - //} + 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 { + panic(insertErr) + } } func AccountExists (sqldb *sql.DB, addr string) (string, string, error) { var addressBalance, accountNonce string sqlExistsStatement := `SELECT balance, accountNonce from accounts WHERE addr = ($1)` - err := sqldb.QueryRow(sqlExistsStatement, addr).Scan(&addressBalance, &accountNonce) - + err := sqldb.QueryRow(sqlExistsStatement, strings.ToLower(addr)).Scan(&addressBalance, &accountNonce) switch { case err == sql.ErrNoRows: return addressBalance, accountNonce, err @@ -463,27 +444,39 @@ func AccountExists (sqldb *sql.DB, addr string) (string, 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) + switch { + case err == sql.ErrNoRows: + return err + panic(err) + default: + return err + } +} + func UpdateAccount(sqldb *sql.DB, addr string, balance string, accountNonce string) { updateSQLStatement := `UPDATE accounts SET balance = ($2), accountNonce = ($3) WHERE addr = ($1)` - _, updateErr := sqldb.Exec(updateSQLStatement, addr, balance, accountNonce) + _, updateErr := sqldb.Exec(updateSQLStatement, strings.ToLower(addr), balance, accountNonce) if updateErr != nil { panic(updateErr) } } -func InsertBlock(sqldb *sql.DB, blockData SBlock, blockAge SBlock) { +func InsertBlock(sqldb *sql.DB, blockData 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) } } - -func InsertTx (sqldb *sql.DB, txData ShyftTxEntryPretty, data 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, 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), txData.From, 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) }