Merge pull request #53 from ShyftNetwork/api/internaltx

Api/internaltx

core/sTypes/stypes.go

@@ -27,8 +27,9 @@ type SBlock struct {
 }
 
 type InteralWrite struct {
+	ID      int
 	Hash    string
-	Type    string
+	Action  string
 	From    string
 	To      string
 	Value   string
@@ -39,6 +40,10 @@ type InteralWrite struct {
 	Time    string
 }
 
+type InternalArray struct {
+	InternalEntry []InteralWrite
+}
+
 //blockRes struct
 type BlockRes struct {
 	hash     string

core/shyft_database_util.go

@@ -372,8 +372,8 @@ func InsertTx(sqldb *sql.DB, txData stypes.ShyftTxEntryPretty) {
 //InsertInternalTx writes internal tx to Postgres Db
 func InsertInternalTx(sqldb *sql.DB, i stypes.InteralWrite) {
 	var returnValue string
-	sqlStatement := `INSERT INTO internaltxs(type, txhash, from_addr, to_addr, amount, gas, gasUsed, time, input, output) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10)) RETURNING txHash`
+	sqlStatement := `INSERT INTO internaltxs(action, txhash, from_addr, to_addr, amount, gas, gasUsed, time, input, output) VALUES(($1), ($2), ($3), ($4), ($5), ($6), ($7), ($8), ($9), ($10)) RETURNING txHash`
-	qerr := sqldb.QueryRow(sqlStatement, i.Type, strings.ToLower(i.Hash), strings.ToLower(i.From), strings.ToLower(i.To), i.Value, i.Gas, i.GasUsed, i.Time, i.Input, i.Output).Scan(&returnValue)
+	qerr := sqldb.QueryRow(sqlStatement, i.Action, strings.ToLower(i.Hash), strings.ToLower(i.From), strings.ToLower(i.To), i.Value, i.Gas, i.GasUsed, i.Time, i.Input, i.Output).Scan(&returnValue)
 	if qerr != nil {
 		fmt.Println(qerr)
 		panic(qerr)

core/shyft_get_utils.go

@@ -386,3 +386,86 @@ func SGetAccountTxs(sqldb *sql.DB, address string) string {
 	}
 	return txx
 }
+
+//GetAllInternalTransactions getter fn for API
+func SGetAllInternalTransactions(sqldb *sql.DB) string {
+	var arr stypes.InternalArray
+	var internaltx string
+	rows, err := sqldb.Query(`SELECT * FROM internaltxs`)
+	if err != nil {
+		fmt.Println("err")
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var txhash, action, to_addr, from_addr, amount, input, output string
+		var gas, gasUsed uint64
+		var id int
+		var age string
+
+		err = rows.Scan(
+			&id, &txhash, &action, &to_addr, &from_addr, &amount, &gas, &gasUsed, &age, &input, &output,
+		)
+
+		arr.InternalEntry = append(arr.InternalEntry, stypes.InteralWrite{
+			ID:      id,
+			Hash:    txhash,
+			Action:  action,
+			To:      to_addr,
+			From:    from_addr,
+			Value:   amount,
+			Gas:     gas,
+			GasUsed: gasUsed,
+			Time:    age,
+			Input:   input,
+			Output:  output,
+		})
+
+		tx, _ := json.Marshal(arr.InternalEntry)
+		newtx := string(tx)
+		internaltx = newtx
+	}
+	return internaltx
+}
+
+//GetInternalTransaction fn returns single tx
+func SGetInternalTransaction(sqldb *sql.DB, txHash string) string {
+	var arr stypes.InternalArray
+	var internaltx string
+
+	sqlStatement := `SELECT * FROM internaltxs WHERE txhash=$1;`
+	rows, err := sqldb.Query(sqlStatement, txHash)
+	if err != nil {
+		fmt.Println("err")
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var txhash, action, to_addr, from_addr, amount, input, output string
+		var id int
+		var gas, gasUsed uint64
+		var age string
+
+		err = rows.Scan(
+			&id, &txhash, &action, &to_addr, &from_addr, &amount, &gas, &gasUsed, &age, &input, &output,
+		)
+
+		arr.InternalEntry = append(arr.InternalEntry, stypes.InteralWrite{
+			ID:      id,
+			Hash:    txhash,
+			Action:  action,
+			To:      to_addr,
+			From:    from_addr,
+			Value:   amount,
+			Gas:     gas,
+			GasUsed: gasUsed,
+			Time:    age,
+			Input:   input,
+			Output:  output,
+		})
+
+		tx, _ := json.Marshal(arr.InternalEntry)
+		newtx := string(tx)
+		internaltx = newtx
+	}
+	return internaltx
+}

eth/shyft_tracer.go

@@ -2,7 +2,6 @@ package eth
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/ShyftNetwork/go-empyrean/common"
 	"github.com/ShyftNetwork/go-empyrean/params"

eth/tracers/tracer.go

@@ -607,7 +607,7 @@ func (i *Internals) SWriteInteralTxs(hash common.Hash) {
 
 	iTx := stypes.InteralWrite{
 		Hash:    hash.Hex(),
-		Type:    i.Type,
+		Action:  i.Type,
 		From:    i.From,
 		To:      i.To,
 		Value:   amount,

shyft-cli/postgres_setup/create_tables.psql

@@ -46,7 +46,7 @@ CREATE TABLE IF NOT EXISTS contracts (
 CREATE TABLE IF NOT EXISTS internalTxs (
   id SERIAL PRIMARY KEY,
   txHash text references txs(txHash),
-  type text,
+  action text,
   to_addr text,
   from_addr text,
   amount text,

shyft-cli/postgres_setup/drop_tables.psql

@@ -1,5 +1,4 @@
-\connect
+\connect shyftdb;
-shyftdb;
 DROP TABLE internalTxs;
 DROP TABLE txs;
 DROP TABLE blocks;

shyftBlockExplorerApi/handler.go

@@ -195,25 +195,37 @@ func GetRecentBlock(w http.ResponseWriter, r *http.Request) {
 }
 
 //GetInternalTransactions gets internal txs
-func GetInternalTransactions(w http.ResponseWriter, r *http.Request) {
+func GetInternalTransactionsByHash(w http.ResponseWriter, r *http.Request) {
+	sqldb, err := core.DBConnection()
+
 	vars := mux.Vars(r)
-	address := vars["address"]
+	txHash := vars["txHash"]
+
+	internalTxs := core.SGetInternalTransaction(sqldb, txHash)
+	if err != nil {
+		http.Error(w, err.Error(), 500)
+		return
+	}
 
 	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
 	w.WriteHeader(http.StatusOK)
 
-	fmt.Fprintln(w, "Get InternalTransactions", address)
+	fmt.Fprintln(w, internalTxs)
 }
 
 //GetInternalTransactionsHash gets internal txs hash
-func GetInternalTransactionsHash(w http.ResponseWriter, r *http.Request) {
+func GetInternalTransactions(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
+	sqldb, err := core.DBConnection()
-	transactionHash := vars["transaction_hash"]
 
+	internalTxs := core.SGetAllInternalTransactions(sqldb)
+	if err != nil {
+		http.Error(w, err.Error(), 500)
+		return
+	}
 	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
 	w.WriteHeader(http.StatusOK)
 
-	fmt.Fprintln(w, "Get Internal Transaction Hash", transactionHash)
+	fmt.Fprintln(w, internalTxs)
 }
 
 func BroadcastTx(w http.ResponseWriter, r *http.Request) {

shyftBlockExplorerApi/routes.go

@@ -58,34 +58,34 @@ var routes = Routes{
 		GetTransaction,
 	},
 	Route{
-		Name: "GetRecentBlock",
+		Name:        "GetRecentBlock",
-		Method: "GET",
+		Method:      "GET",
-		Pattern: "/api/get_recent_block",
+		Pattern:     "/api/get_recent_block",
 		HandlerFunc: GetRecentBlock,
 	},
 	Route{
-		Name: "GetAllTransactionsFromBlock",
+		Name:        "GetAllTransactionsFromBlock",
-		Method: "GET",
+		Method:      "GET",
-		Pattern: "/api/get_all_transactions_from_block/{blockNumber}",
+		Pattern:     "/api/get_all_transactions_from_block/{blockNumber}",
 		HandlerFunc: GetAllTransactionsFromBlock,
 	},
 	Route{
-		Name: "GetAllBlocksMinedByAddress",
+		Name:        "GetAllBlocksMinedByAddress",
-		Method: "GET",
+		Method:      "GET",
-		Pattern: "/api/get_blocks_mined/{coinbase}",
+		Pattern:     "/api/get_blocks_mined/{coinbase}",
 		HandlerFunc: GetAllBlocksMinedByAddress,
 	},
 	Route{
 		"GetInternalTransactions",
 		"GET",
-		"/api/get_internal_transactions/{address}",
+		"/api/get_internal_transactions/",
 		GetInternalTransactions,
 	},
 	Route{
-		"GetInternalTransactionsHash",
+		"GetInternalTransactionsByHash",
 		"GET",
-		"/api/get_internal_transactions_hash/{transactions_hash}",
+		"/api/get_internal_transactions/{txHash}",
-		GetInternalTransactionsHash,
+		GetInternalTransactionsByHash,
 	},
 	Route{
 		"BroadcastTx",