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

account nonce, txfee successfully writing to db

Browse source
This commit is contained in:
Dustin Brickwood 2018-05-11 16:26:36 -04:00
parent 5c59ac75a1
commit 1e2df20db6
4 changed files with 74 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
core/genesis.go
View file

@ -157,9 +157,9 @@ func WriteShyftGen(sqldb *sql.DB, gen *Genesis) {
case err == sql.ErrNoRows: case err == sql.ErrNoRows:
for k, v := range gen.Alloc { for k, v := range gen.Alloc {
addr := k.String() addr := k.String()
txCountAccount := v.Nonce +1
sqlStatement := `INSERT INTO accounts(addr, balance) VALUES(($1), ($2)) RETURNING addr` sqlStatement := `INSERT INTO accounts(addr, balance, txCountAccount) VALUES(($1), ($2), ($3)) RETURNING addr`
insertErr := sqldb.QueryRow(sqlStatement, addr, v.Balance.String()).Scan(&addr) insertErr := sqldb.QueryRow(sqlStatement, addr, v.Balance.String(), txCountAccount).Scan(&addr)
if insertErr != nil { if insertErr != nil {
panic(insertErr) panic(insertErr)
} }

5
shyftDb/postgres_setup/create_tables.psql
View file

@ -14,14 +14,17 @@ CREATE TABLE IF NOT EXISTS txs (
to_addr text, to_addr text,
from_addr text, from_addr text,
blockhash text references blocks(hash), blockhash text references blocks(hash),
blocknumber text,
amount numeric, amount numeric,
gasprice numeric, gasprice numeric,
gas numeric, gas numeric,
txFee numeric,
nonce numeric, nonce numeric,
data bytea data bytea
); );
CREATE TABLE IF NOT EXISTS accounts ( CREATE TABLE IF NOT EXISTS accounts (
addr text primary key unique, addr text primary key unique,
balance numeric balance numeric,
txCountAccount numeric
); );

70
shyftdb/shyft_database_util.go
View file

@ -38,6 +38,7 @@ type blockRes struct {
type SAccounts struct { type SAccounts struct {
Addr string Addr string
Balance string Balance string
TxCountAccount string
} }
type accountRes struct { type accountRes struct {
@ -55,6 +56,7 @@ type ShyftTxEntry struct {
Amount *big.Int Amount *big.Int
GasPrice *big.Int GasPrice *big.Int
Gas uint64 Gas uint64
Cost *big.Int
Nonce uint64 Nonce uint64
Data []byte Data []byte
} }
@ -86,6 +88,7 @@ type SendAndReceive struct {
Amount string Amount string
Address string Address string
Balance string Balance string
TxCountAccount string
} }
//WriteBlock writes to block info to sql db //WriteBlock writes to block info to sql db
@ -112,7 +115,7 @@ func WriteBlock(sqldb *sql.DB, block *types.Block) error {
if block.Transactions().Len() > 0 && block.Transactions()[0].To() != nil { if block.Transactions().Len() > 0 && block.Transactions()[0].To() != nil {
for _, tx := range block.Transactions() { for _, tx := range block.Transactions() {
//WriteMinerRewards(sqldb, block) //WriteMinerRewards(sqldb, block)
WriteTransactions(sqldb, tx, block.Header().Hash()) WriteTransactions(sqldb, tx, block.Header().Hash(), block.Header().Number.String())
WriteFromBalance(sqldb, tx) WriteFromBalance(sqldb, tx)
} }
} }
@ -120,13 +123,14 @@ func WriteBlock(sqldb *sql.DB, block *types.Block) error {
} }
//WriteTransactions writes to sqldb //WriteTransactions writes to sqldb
func WriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.Hash) error { func WriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.Hash, blockNumber string) error {
txData := ShyftTxEntry{ txData := ShyftTxEntry{
TxHash: tx.Hash(), TxHash: tx.Hash(),
From: tx.From(), From: tx.From(),
To: tx.To(), To: tx.To(),
BlockHash: blockHash.Hex(), BlockHash: blockHash.Hex(),
Amount: tx.Value(), Amount: tx.Value(),
Cost: tx.Cost(),
GasPrice: tx.GasPrice(), GasPrice: tx.GasPrice(),
Gas: tx.Gas(), Gas: tx.Gas(),
Nonce: tx.Nonce(), Nonce: tx.Nonce(),
@ -138,22 +142,23 @@ func WriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.Ha
blockHasher := txData.BlockHash blockHasher := txData.BlockHash
amount := txData.Amount.String() amount := txData.Amount.String()
gasPrice := txData.GasPrice.String() gasPrice := txData.GasPrice.String()
txFee := txData.Cost.String()
nonce := txData.Nonce nonce := txData.Nonce
gas := txData.Gas gas := txData.Gas
data := txData.Data data := txData.Data
to := txData.To to := txData.To
if (to == nil){ if (to == nil){
var retNonce string var retNonce string
sqlStatement := `INSERT INTO txs(txhash, from_addr, blockhash, amount, gasprice, gas, nonce, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8)) RETURNING nonce` sqlStatement := `INSERT INTO txs(txhash, from_addr, blockhash, blockNumber, amount, gasprice, gas, txfee nonce, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10)) RETURNING nonce`
qerr := sqldb.QueryRow(sqlStatement, txHash, from, blockHasher, amount, gasPrice, gas, nonce, data).Scan(&retNonce) qerr := sqldb.QueryRow(sqlStatement, txHash, from, blockHasher, blockNumber, amount, gasPrice, gas, txFee, data).Scan(&retNonce)
if qerr != nil { if qerr != nil {
panic(qerr) panic(qerr)
} }
} else { } else {
var retNonce string var retNonce string
sqlStatement := `INSERT INTO txs(txhash, from_addr, to_addr, blockhash, amount, gasprice, gas, nonce, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9)) RETURNING nonce` sqlStatement := `INSERT INTO txs(txhash, from_addr, to_addr, blockhash, blockNumber, amount, gasprice, gas, txfee, nonce, data) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10), ($11)) RETURNING nonce`
qerr := sqldb.QueryRow(sqlStatement, txHash, from, to.Hex(), blockHasher, amount, gasPrice, gas, nonce, data).Scan(&retNonce) qerr := sqldb.QueryRow(sqlStatement, txHash, from, to.Hex(), blockHasher, blockNumber, amount, gasPrice, gas, txFee, nonce, data).Scan(&retNonce)
if qerr != nil { if qerr != nil {
panic(qerr) panic(qerr)
@ -165,7 +170,7 @@ func WriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.Ha
//WriteFromBalance writes senders balance to accounts db //WriteFromBalance writes senders balance to accounts db
func WriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error { func WriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
sendAndReceiveData, balanceRec, balanceSen := WriteBalanceHelper(sqldb, tx) sendAndReceiveData, balanceRec, balanceSen, accountNonceRec, accountNonceSen := WriteBalanceHelper(sqldb, tx)
toAddr := sendAndReceiveData.To toAddr := sendAndReceiveData.To
fromAddr := sendAndReceiveData.From fromAddr := sendAndReceiveData.From
amount := sendAndReceiveData.Amount amount := sendAndReceiveData.Amount
@ -177,19 +182,20 @@ func WriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
err := sqldb.QueryRow(sqlExistsStatement, toAddr).Scan(&response) err := sqldb.QueryRow(sqlExistsStatement, toAddr).Scan(&response)
switch { switch {
case err == sql.ErrNoRows: case err == sql.ErrNoRows:
sqlStatement := `INSERT INTO accounts(addr, balance, txCountAccount) VALUES(($1), ($2), ($3)) RETURNING addr`
sqlStatement := `INSERT INTO accounts(addr, balance) VALUES(($1), ($2)) RETURNING addr` insertErr := sqldb.QueryRow(sqlStatement, toAddr, amount, accountNonceRec).Scan(&toAddr)
insertErr := sqldb.QueryRow(sqlStatement, toAddr, amount).Scan(&toAddr)
if insertErr != nil { if insertErr != nil {
panic(insertErr) panic(insertErr)
} }
case err != nil: case err != nil:
log.Fatal(err) log.Fatal(err)
default: default:
var newBalanceReceiver big.Int var newBalanceReceiver big.Int
var newBalanceSender big.Int var newBalanceSender big.Int
updateSQLStatement := `UPDATE accounts SET balance = ($2) WHERE addr = ($1)` var newAccountNonceReceiver big.Int
var newAccountNonceSender big.Int
var nonceIncrement = big.NewInt(1)
updateSQLStatement := `UPDATE accounts SET balance = ($2), txCountAccount = ($3) WHERE addr = ($1)`
r := new(big.Int) r := new(big.Int)
_, err := fmt.Sscan(balanceReceiver, r) _, err := fmt.Sscan(balanceReceiver, r)
@ -203,15 +209,30 @@ func WriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
log.Println("error scanning value:", error) log.Println("error scanning value:", error)
} }
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()) newBalanceReceiver.Add(r, tx.Value())
newBalanceSender.Sub(s, tx.Value()) newBalanceSender.Sub(s, tx.Value())
_, err = sqldb.Exec(updateSQLStatement, toAddr, newBalanceReceiver.String()) newAccountNonceReceiver.Add(accountR, nonceIncrement)
newAccountNonceSender.Add(accountS, nonceIncrement)
_, err = sqldb.Exec(updateSQLStatement, toAddr, newBalanceReceiver.String(), newAccountNonceReceiver.String())
if err != nil { if err != nil {
panic(err) panic(err)
} }
_, err = sqldb.Exec(updateSQLStatement, fromAddr, newBalanceSender.String()) _, err = sqldb.Exec(updateSQLStatement, fromAddr, newBalanceSender.String(), newAccountNonceSender.String())
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -219,7 +240,7 @@ func WriteFromBalance(sqldb *sql.DB, tx *types.Transaction) error {
return nil return nil
} }
func WriteBalanceHelper(sqldb *sql.DB, tx *types.Transaction) (SendAndReceive, string, string) { func WriteBalanceHelper(sqldb *sql.DB, tx *types.Transaction) (SendAndReceive, string, string, string, string) {
sendAndReceiveData := SendAndReceive{ sendAndReceiveData := SendAndReceive{
To: tx.To().Hex(), To: tx.To().Hex(),
From: tx.From().Hex(), From: tx.From().Hex(),
@ -245,7 +266,10 @@ func WriteBalanceHelper(sqldb *sql.DB, tx *types.Transaction) (SendAndReceive, s
balanceReceiver := receiverBalance.Balance balanceReceiver := receiverBalance.Balance
balanceSender := senderBalance.Balance balanceSender := senderBalance.Balance
return sendAndReceiveData, balanceReceiver, balanceSender accountNonceReceiver := receiverBalance.TxCountAccount
accountNonceSender := senderBalance.TxCountAccount
return sendAndReceiveData, balanceReceiver, balanceSender, accountNonceReceiver, accountNonceSender
} }
//func WriteMinerRewards(sqldb *sql.DB, block *types.Block) { //func WriteMinerRewards(sqldb *sql.DB, block *types.Block) {
@ -523,12 +547,16 @@ func GetAccount(sqldb *sql.DB, address string) string {
row := sqldb.QueryRow(sqlStatement, address) row := sqldb.QueryRow(sqlStatement, address)
var addr string var addr string
var balance string var balance string
var txCountAccount string
row.Scan(&addr, &balance) row.Scan(
&addr,
&balance,
&txCountAccount)
account := SAccounts{ account := SAccounts{
Addr: addr, Addr: addr,
Balance: balance, Balance: balance,
TxCountAccount: txCountAccount,
} }
json, _ := json.Marshal(account) json, _ := json.Marshal(account)
return string(json) return string(json)
@ -538,10 +566,12 @@ func GetAccount(sqldb *sql.DB, address string) string {
func GetAllAccounts(sqldb *sql.DB) string { func GetAllAccounts(sqldb *sql.DB) string {
var array accountRes var array accountRes
var accountsArr string var accountsArr string
var txCountAccount string
accs, err := sqldb.Query(` accs, err := sqldb.Query(`
SELECT SELECT
addr, addr,
balance balance,
txCountAccount
FROM accounts`) FROM accounts`)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
@ -555,11 +585,13 @@ func GetAllAccounts(sqldb *sql.DB) string {
err = accs.Scan( err = accs.Scan(
&addr, &addr,
&balance, &balance,
&txCountAccount,
) )
array.AllAccounts = append(array.AllAccounts, SAccounts{ array.AllAccounts = append(array.AllAccounts, SAccounts{
Addr: addr, Addr: addr,
Balance: balance, Balance: balance,
TxCountAccount: txCountAccount,
}) })
accounts, _ := json.Marshal(array.AllAccounts) accounts, _ := json.Marshal(array.AllAccounts)

32
simulations/sendTransactions.js
View file

@ -2,7 +2,7 @@ var firstAccount = web3.eth.accounts[0]
var secondAccount = web3.eth.accounts[1] var secondAccount = web3.eth.accounts[1]
var thirdAccount = web3.eth.accounts[2] var thirdAccount = web3.eth.accounts[2]
for (var i = 0; i < 10; i++) { for (var i = 0; i < 1; i++) {
console.log('\t\t' + (i + 1) + ' - Transactions') console.log('\t\t' + (i + 1) + ' - Transactions')
web3.eth.sendTransaction({ web3.eth.sendTransaction({
from: web3.eth.accounts[1], from: web3.eth.accounts[1],
@ -11,19 +11,19 @@ for (var i = 0; i < 10; i++) {
gas: 50000, gas: 50000,
gasPrice: 20 gasPrice: 20
}); });
web3.eth.sendTransaction({ // web3.eth.sendTransaction({
from: web3.eth.accounts[0], // from: web3.eth.accounts[0],
to: web3.eth.accounts[2], // to: web3.eth.accounts[2],
value: 291, // value: 291,
gas: 50000, // gas: 50000,
gasPrice: 20 // gasPrice: 20
}); // });
//
web3.eth.sendTransaction({ // web3.eth.sendTransaction({
from: web3.eth.accounts[0], // from: web3.eth.accounts[0],
to: web3.eth.accounts[1], // to: web3.eth.accounts[1],
value: 53039, // value: 53039,
gas: 50000, // gas: 50000,
gasPrice: 20 // gasPrice: 20
}); // });
} }