diff --git a/console/console_test.go b/console/console_test.go index 7b1629c032..8ff19c5ea1 100644 --- a/console/console_test.go +++ b/console/console_test.go @@ -34,10 +34,10 @@ import ( "github.com/ethereum/go-ethereum/node" ) -const ( - testInstance = "console-tester" - testAddress = "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182" -) + const ( + testInstance = "console-tester" + testAddress = "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182" + ) // hookedPrompter implements UserPrompter to simulate use input via channels. type hookedPrompter struct { diff --git a/core/db.go b/core/db.go index 3fedb09b18..ff63e3ee9e 100644 --- a/core/db.go +++ b/core/db.go @@ -3,18 +3,25 @@ package core import ( "fmt" "database/sql" - "os" ) var blockExplorerDb *sql.DB func InitDB() (*sql.DB, error){ - var connStr string - if "test" == os.Getenv("SHYFT_ENV") { - connStr = "user=postgres dbname=shyftdbtest sslmode=disable" + var connStr = "user=postgres dbname=shyftdb sslmode=disable" + db, err := sql.Open("postgres", connStr) + if err != nil { + fmt.Println("ERROR OPENING DB, NOT INITIALIZING") + fmt.Println(err) + return nil, err } else { - connStr = "user=postgres dbname=shyftdb sslmode=disable" + blockExplorerDb = db + return blockExplorerDb, nil } +} + +func InitDBTest() (*sql.DB, error){ + var connStr = "user=postgres dbname=shyftdbtest sslmode=disable" db, err := sql.Open("postgres", connStr) if err != nil { fmt.Println("ERROR OPENING DB, NOT INITIALIZING") diff --git a/core/shyft_database_util.go b/core/shyft_database_util.go index 0c63f5e35d..52aa7e16e6 100644 --- a/core/shyft_database_util.go +++ b/core/shyft_database_util.go @@ -114,7 +114,7 @@ type SendAndReceive struct { func SWriteBlock(block *types.Block, receipts []*types.Receipt) error { sqldb, err := DBConnection() - if (err != nil) { + if err != nil { panic(err) } @@ -204,7 +204,6 @@ func SwriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.H 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) } @@ -228,7 +227,6 @@ func SwriteTransactions(sqldb *sql.DB, tx *types.Transaction, blockHash common.H panic(qerr) } } - IShyftTracer.GetTracerToRun(hash) return nil diff --git a/eth/api_tracer.go b/eth/api_tracer.go index 7a77907b58..89de3293b7 100644 --- a/eth/api_tracer.go +++ b/eth/api_tracer.go @@ -561,10 +561,12 @@ func (api *PrivateDebugAPI) STraceTransaction(ctx context.Context, hash common.H if config != nil && config.Reexec != nil { reexec = *config.Reexec } + fmt.Println("+++++++++++++++++++++++++++ Middle") msg, vmctx, statedb, err := api.computeTxEnv(blockHash, int(index), reexec) if err != nil { return nil, err } + fmt.Println("+++++++++++++++++++++++++++ BOTTOM") return api.StraceTx(ctx, msg, vmctx, statedb, config, hash) } @@ -581,7 +583,7 @@ func (api *PrivateDebugAPI) StraceTx(ctx context.Context, message core.Message, switch { case config != nil && config.Tracer != nil: // Define a meaningful timeout of a single transaction trace - + fmt.Println("STRACETX") _ = defaultTraceTimeout if config.Timeout != nil { @@ -701,6 +703,7 @@ func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, v // computeTxEnv returns the execution environment of a certain transaction. func (api *PrivateDebugAPI) computeTxEnv(blockHash common.Hash, txIndex int, reexec uint64) (core.Message, vm.Context, *state.StateDB, error) { // Create the parent state database + fmt.Println("COMPUTETXENV") block := api.eth.blockchain.GetBlockByHash(blockHash) if block == nil { return nil, vm.Context{}, nil, fmt.Errorf("block %x not found", blockHash) @@ -730,5 +733,6 @@ func (api *PrivateDebugAPI) computeTxEnv(blockHash common.Hash, txIndex int, ree } statedb.DeleteSuicides() } + fmt.Println("+++++++++++++++++ BOTTOM COMPUTETXENV") return nil, vm.Context{}, nil, fmt.Errorf("tx index %d out of range for block %x", txIndex, blockHash) } diff --git a/eth/backend.go b/eth/backend.go index 7d705ab0e6..94b94f157e 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -103,9 +103,10 @@ func (s *Ethereum) AddLesServer(ls LesServer) { } func SNew(config *Config) (*Ethereum, error) { + fmt.Println("SNEW FROM SHYFTREACER") stopDbUpgrade := upgradeDeduplicateData(Chaindb_global) + fmt.Println("ChainGlobal v+%", Chaindb_global) chainConfig, _, _ := core.SetupGenesisBlock(Chaindb_global, config.Genesis) - eth := &Ethereum{ config: config, chainDb: Chaindb_global, @@ -139,10 +140,9 @@ func SNew(config *Config) (*Ethereum, error) { // New creates a new Ethereum object (including the // initialisation of the common Ethereum object) func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) { - shyft_tracer := new(ShyftTracer) core.SetIShyftTracer(shyft_tracer) - setGlobalConfig(config) + SetGlobalConfig(config) _, file, no, ok := runtime.Caller(1) if ok { diff --git a/eth/chaindb.go b/eth/chaindb.go index 6b00bc13f8..4ff89683fb 100644 --- a/eth/chaindb.go +++ b/eth/chaindb.go @@ -3,6 +3,7 @@ package eth import ( "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/node" + "fmt" ) var Chaindb_global ethdb.Database @@ -12,6 +13,7 @@ func SetChainDB(db ethdb.Database){ } func chaindb(ctx *node.ServiceContext, config *Config) (ethdb.Database, error) { + fmt.Printf("CTX v+%", ctx) if Chaindb_global != nil { return Chaindb_global, nil } diff --git a/eth/shyft_tracer.go b/eth/shyft_tracer.go index bd1b1baeec..5fa2eb392f 100644 --- a/eth/shyft_tracer.go +++ b/eth/shyft_tracer.go @@ -5,19 +5,17 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/params" "context" + "fmt" ) var EthereumObject interface{} type ShyftTracer struct {} -//( + func (st ShyftTracer) GetTracerToRun (hash common.Hash) (interface{}, error) { config2 := params.ShyftNetworkChainConfig jsTracer := "callTracer" - - // - //var cfg *Config var ctx2 context.Context config := &TraceConfig{ LogConfig: nil, @@ -25,9 +23,11 @@ func (st ShyftTracer) GetTracerToRun (hash common.Hash) (interface{}, error) { Timeout: nil, Reexec: nil, } - //var fullNode *Ethereum + fmt.Println("+++++++++++++++++++++++++++ before FULLNODE", Global_config) fullNode, _ := SNew(Global_config) + fmt.Println("+++++++++++++++++++++++++++ after FULLNODE") privateAPI := NewPrivateDebugAPI(config2, fullNode) + fmt.Println("+++++++++++++++++++++++++++ after privateAPI") return privateAPI.STraceTransaction(ctx2, hash, config) } @@ -37,6 +37,7 @@ func setEthObject(ethobj interface{}){ var Global_config *Config -func setGlobalConfig(c *Config) { +func SetGlobalConfig(c *Config) { + fmt.Println("SETGLOBAL") Global_config = c } \ No newline at end of file diff --git a/eth/tracers/tracer.go b/eth/tracers/tracer.go index 76d359e558..807886708b 100644 --- a/eth/tracers/tracer.go +++ b/eth/tracers/tracer.go @@ -27,11 +27,11 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" "gopkg.in/olebedev/go-duktape.v3" - "database/sql" ) // bigIntegerJS is the minified version of https://github.com/peterolson/BigInteger.js. @@ -592,10 +592,10 @@ type Internals struct { //@NOTE:SHYFT func (i *Internals) SWriteInteralTxs(hash common.Hash) { - connStr := "user=postgres dbname=shyftdb sslmode=disable" - sqldb, err := sql.Open("postgres", connStr) + fmt.Println("WRITE INTERNAL") + sqldb, err := core.DBConnection() if err != nil { - return + panic(err) } gas, _ := hexutil.DecodeUint64(i.Gas) @@ -612,6 +612,7 @@ func (i *Internals) SWriteInteralTxs(hash common.Hash) { } //@NOTE:SHYFT func (i *Internals) InternalRecursive(hash common.Hash) { + fmt.Println("internal recursive") i.SWriteInteralTxs(hash) lengthOfCalls := len(i.Calls) if lengthOfCalls == 0 { @@ -670,6 +671,7 @@ func (jst *Tracer) GetResult() (json.RawMessage, error) { //@NOTE:SHYFT func (jst *Tracer) SGetResult(hash common.Hash) (json.RawMessage, error) { + fmt.Println("SGETRESULT") // Transform the context into a JavaScript object and inject into the state obj := jst.vm.PushObject() diff --git a/shyftDb/shyft_database_util_test.go b/shyftDb/shyft_database_util_test.go index ac24de22a3..4875f656d9 100644 --- a/shyftDb/shyft_database_util_test.go +++ b/shyftDb/shyft_database_util_test.go @@ -5,455 +5,684 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/eth" "math/big" //"time" "encoding/json" "github.com/ethereum/go-ethereum/crypto" - "strconv" + "github.com/ethereum/go-ethereum/consensus/ethash" ) -func TestBlockToReturnBlock(t *testing.T) { - key, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") - signer := types.NewEIP155Signer(big.NewInt(2147483647)) +type ShyftTracer struct {} - //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) - 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) - 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) - txs := []*types.Transaction{mytx, mytx2, mytx3} +//Config Below +//&{Genesis: NetworkId:1 SyncMode:fast NoPruning:false LightServ:0 LightPeers:100 SkipBcVersionCheck:false DatabaseHandles:1024 DatabaseCache:768 TrieCache:256 TrieTimeout:5m0s Etherbase:[67 236 109 9 66 247 250 239 6 159 127 99 208 56 74 39 245 41 176 98] MinerThreads:4 ExtraData:[] GasPrice:+18000000000 Ethash:{CacheDir:ethash CachesInMem:2 CachesOnDisk:3 DatasetDir:$HOME/.ethash DatasetsInMem:1 DatasetsOnDisk:2 PowMode:0} TxPool:{NoLocals:false Journal:transactions.rlp Rejournal:1h0m0s PriceLimit:1 PriceBump:10 AccountSlots:16 GlobalSlots:4096 AccountQueue:64 GlobalQueue:1024 Lifetime:3h0m0s} GPO:{Blocks:20 Percentile:60 Default:} EnablePreimageRecording:false DocRoot:}SETGLOBAL +//called from /Users/dustinbrickwood/go/src/github.com/ethereum/go-ethereum/build/_workspace/src/github.com/ethereum/go-ethereum/cmd/utils/flags.go#1132 +// - receipt := &types.Receipt{ - Status: types.ReceiptStatusSuccessful, - CumulativeGasUsed: 1, - Logs: []*types.Log{ - {Address: common.BytesToAddress([]byte{0x11})}, - {Address: common.BytesToAddress([]byte{0x01, 0x11})}, +//CTX +// !(NOVERB)%!(EXTRA *node.ServiceContext=&{0xc4200326c0 map[] 0xc4201dc6c0 0xc42026f2b0}) + +const ( + testInstance = "console-tester" + testAddress = "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182" +) + +func TestBlock(t *testing.T) { + core.InitDBTest() + shyft_tracer := new(eth.ShyftTracer) + core.SetIShyftTracer(shyft_tracer) + + //workspace, err := ioutil.TempDir("", "console-tester-") + //if err != nil { + // t.Fatalf("failed to create temporary keystore: %v", err) + //} + + //stack, err := node.New(&node.Config{DataDir: workspace, UseLightweightKDF: true, Name: testInstance}) + //if err != nil { + // t.Fatalf("failed to create node: %v", err) + //} + ethConf := ð.Config{ + Genesis: core.DeveloperGenesisBlock(15, common.Address{}), + Etherbase: common.HexToAddress(testAddress), + Ethash: ethash.Config{ + PowMode: ethash.ModeTest, }, - TxHash: common.BytesToHash([]byte{0x11, 0x11}), - ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), - GasUsed: 111111, } + //if err = stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { return eth.New(ctx, ethConf) }); err != nil { + // t.Fatalf("failed to register Ethereum protocol: %v", err) + //} - receipts := []*types.Receipt{receipt} - block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts) + eth.SetGlobalConfig(ethConf) - // 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) - } + t.Run("TestBlockToReturnBlock", func(t *testing.T) { + key, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + signer := types.NewEIP155Signer(big.NewInt(2147483647)) - sqldb, err := core.DBConnection() - if err != nil { - panic(err) - } + //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) + 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) + 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) + txs := []*types.Transaction{mytx, mytx2, mytx3} - entry := core.SGetBlock(sqldb, block.Number().String()) - byt := []byte(entry) - var data core.SBlock - json.Unmarshal(byt, &data) + receipt := &types.Receipt{ + Status: types.ReceiptStatusSuccessful, + CumulativeGasUsed: 1, + Logs: []*types.Log{ + {Address: common.BytesToAddress([]byte{0x11})}, + {Address: common.BytesToAddress([]byte{0x01, 0x11})}, + }, + TxHash: common.BytesToHash([]byte{0x11, 0x11}), + ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), + GasUsed: 111111, + } - //TODO Difficulty, rewards, age - if block.Hash().String() != data.Hash { - t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) - } - if block.Coinbase().String() != data.Coinbase { - t.Fatalf("Block coinbase [%v]: Block coinbase not found", block.Coinbase().String()) - } - if block.Number().String() != data.Number { - t.Fatalf("Block number [%v]: Block number not found", block.Number().String()) - } - if block.GasUsed() != data.GasUsed { - t.Fatalf("Gas Used [%v]: Gas used not found", block.GasUsed()) - } - if block.GasLimit() != data.GasLimit { - t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) - } - if block.Transactions().Len() != data.TxCount { - t.Fatalf("Tx Count [%v]: Tx Count not found", block.Transactions().Len()) - } - if len(block.Uncles()) != data.UncleCount { - t.Fatalf("Uncle count [%v]: Uncle count not found", len(block.Uncles())) - } - if block.ParentHash().String() != data.ParentHash { - t.Fatalf("Parent hash [%v]: Parent hash not found", block.ParentHash().String()) - } - if block.UncleHash().String() != data.UncleHash { - t.Fatalf("Uncle hash [%v]: Uncle hash not found", block.UncleHash().String()) - } - if block.Size().String() != data.Size { - t.Fatalf("Size [%v]: Size not found", block.Size().String()) - } - if block.Nonce() != data.Nonce { - t.Fatalf("Block nonce [%v]: Block nonce not found", block.Nonce()) - } + receipts := []*types.Receipt{receipt} + block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts) - if getAllBlocks := core.SGetAllBlocks(sqldb); len(getAllBlocks) == 0 { - t.Fatalf("GetAllBlocks [%v]: GetAllBlocks did not return correctly", getAllBlocks) - } - - if getAllBlocksMinedByAddress := core.SGetAllBlocksMinedByAddress(sqldb, block.Coinbase().String()); len(getAllBlocksMinedByAddress) == 0 { - t.Fatalf("GetAllBlocksMinedByAddress [%v]: GetAllBlocksMinedByAddress did not return correctly", getAllBlocksMinedByAddress) - } - - ClearTables() -} - -func TestGetRecentBlock(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) - 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) - 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) - txs := []*types.Transaction{mytx, mytx2} - txs1 := []*types.Transaction{mytx3} - - receipt1 := &types.Receipt{ - Status: types.ReceiptStatusSuccessful, - CumulativeGasUsed: 1, - Logs: []*types.Log{ - {Address: common.BytesToAddress([]byte{0x11})}, - {Address: common.BytesToAddress([]byte{0x01, 0x11})}, - }, - TxHash: common.BytesToHash([]byte{0x11, 0x11}), - ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), - GasUsed: 111111, - } - - receipts := []*types.Receipt{receipt1} - block := types.NewBlock(&types.Header{Number: big.NewInt(322)}, txs, nil, receipts) - block2 := types.NewBlock(&types.Header{Number: big.NewInt(320)}, txs1, nil, receipts) - blocks := []*types.Block{block, block2} - - for _, bc := range blocks { // Write and verify the block in the database - if err := core.SWriteBlock(bc, receipts); err != nil { - t.Fatalf("Failed to write block into database: %v", err) - } - } - - sqldb, err := core.DBConnection() - if (err != nil) { - panic(err) - } - - response := core.SGetRecentBlock(sqldb) - byteRes := []byte(response) - var recentBlock core.SBlock - json.Unmarshal(byteRes, &recentBlock) - - if block.Hash().String() != recentBlock.Hash { - t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) - } - if block.Coinbase().String() != recentBlock.Coinbase { - t.Fatalf("Block coinbase [%v]: Block coinbase not found", block.Coinbase().String()) - } - if block.Number().String() != recentBlock.Number { - t.Fatalf("Block number [%v]: Block number not found", block.Number().String()) - } - if block.GasUsed() != recentBlock.GasUsed { - t.Fatalf("Gas Used [%v]: Gas used not found", block.GasUsed()) - } - if block.GasLimit() != recentBlock.GasLimit { - t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) - } - if block.Transactions().Len() != recentBlock.TxCount { - t.Fatalf("Tx Count [%v]: Tx Count not found", block.Transactions().Len()) - } - if len(block.Uncles()) != recentBlock.UncleCount { - t.Fatalf("Uncle count [%v]: Uncle count not found", len(block.Uncles())) - } - if block.ParentHash().String() != recentBlock.ParentHash { - t.Fatalf("Parent hash [%v]: Parent hash not found", block.ParentHash().String()) - } - if block.UncleHash().String() != recentBlock.UncleHash { - t.Fatalf("Uncle hash [%v]: Uncle hash not found", block.UncleHash().String()) - } - if block.Size().String() != recentBlock.Size { - t.Fatalf("Size [%v]: Size not found", block.Size().String()) - } - if block.Nonce() != recentBlock.Nonce { - t.Fatalf("Block nonce [%v]: Block nonce not found", block.Nonce()) - } - - if allTxsFromBlock:= core.SGetAllTransactionsFromBlock(sqldb, block2.Number().String()); len(allTxsFromBlock) == 0 { - t.Fatalf("GetAllTransactionsFromBlock [%v]: GetAllTransactionsFromBlock did not return correctly", allTxsFromBlock) - } - ClearTables() -} - -func TestContractCreationTx(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) - txs := []*types.Transaction{mytx} - - receipt2 := &types.Receipt{ - Status: types.ReceiptStatusSuccessful, - CumulativeGasUsed: 1, - Logs: []*types.Log{ - {Address: common.BytesToAddress([]byte{0x11})}, - {Address: common.BytesToAddress([]byte{0x01, 0x11})}, - }, - TxHash: common.BytesToHash([]byte{0x11, 0x11}), - ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), - GasUsed: 111111, - } - - receipts := []*types.Receipt{receipt2} - block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, receipts) - - if err := core.SWriteBlock(block, receipts); err != nil { - t.Fatalf("Failed to write block into database: %v", err) - } - - var contractAddressFromReciept string - for _, receipt := range receipts { - contractAddressFromReciept = (*types.ReceiptForStorage)(receipt).ContractAddress.String() - } - - sqldb, err := core.DBConnection() - if (err != nil) { - panic(err) - } - - for _, tx := range txs { - txn := core.SGetTransaction(sqldb, tx.Hash().String()) - byt := []byte(txn) - var data core.ShyftTxEntryPretty - json.Unmarshal(byt, &data) - - if tx.Hash().String() != data.TxHash { - t.Fatalf("txHash [%v]: tx Hash not found", tx.Hash().String()) - } - if contractAddressFromReciept != data.To { - t.Fatalf("Contract Addr [%v]: Contract addr not found", contractAddressFromReciept) - } - if tx.From().String() != data.From { - t.Fatalf("From Addr [%v]: From addr not found", tx.From().String()) - } - if tx.Nonce() != data.Nonce { - t.Fatalf("Nonce [%v]: Nonce not found", tx.Nonce()) - } - if tx.Gas() != data.Gas { - t.Fatalf("Gas [%v]: Gas not found", tx.Gas()) - } - if tx.GasPrice().Uint64() != data.GasPrice { - t.Fatalf("Gas Price [%v]: Gas price not found", tx.GasPrice().String()) - } - if block.GasLimit() != data.GasLimit { - t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) - } - if block.Hash().String() != data.BlockHash { - t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) - } - if block.Number().String() != data.BlockNumber { - t.Fatalf("Block Number [%v]: Block number not found", block.Number().String()) - } - if tx.Value().String() != data.Amount { - t.Fatalf("Amount [%v]: Amount not found", tx.Value().String()) - } - if tx.Cost().Uint64() != data.Cost { - t.Fatalf("Cost [%v]: Cost not found", tx.Cost().String()) - } - var status string - if receipt2.Status == 1 { - status = "SUCCESS" - } - if receipt2.Status == 0 { - status = "FAIL" - } - if status != data.Status { - t.Fatalf("Receipt status [%v]: Receipt status not found", status) - } - var isContract bool - if tx.To() != nil { - isContract = false - } else { - isContract = true - } - if isContract != data.IsContract { - t.Fatalf("isContract [%v]: isContract bool is incorrect", isContract) - } - } - ClearTables() -} - -func TestTransactionsToReturnTransactions(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) - 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) - 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) - txs := []*types.Transaction{mytx, mytx2, mytx3} - - receipt1 := &types.Receipt{ - Status: types.ReceiptStatusSuccessful, - CumulativeGasUsed: 1, - Logs: []*types.Log{ - {Address: common.BytesToAddress([]byte{0x11})}, - {Address: common.BytesToAddress([]byte{0x01, 0x11})}, - }, - TxHash: common.BytesToHash([]byte{0x11, 0x11}), - ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), - GasUsed: 111111, - } - - receipts := []*types.Receipt{receipt1} - block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, receipts) - - if err := core.SWriteBlock(block, receipts); err != nil { - t.Fatalf("Failed to write block into database: %v", err) - } - sqldb, err := core.DBConnection() - if (err != nil) { - panic(err) - } - - for _, tx := range txs { - txn := core.SGetTransaction(sqldb, tx.Hash().String()) - byt := []byte(txn) - var data core.ShyftTxEntryPretty - json.Unmarshal(byt, &data) - - //TODO age, data - if tx.Hash().String() != data.TxHash { - t.Fatalf("txHash [%v]: tx Hash not found", tx.Hash().String()) - } - if tx.From().String() != data.From { - t.Fatalf("From Addr [%v]: From addr not found", tx.From().String()) - } - if tx.To().String() != data.To { - t.Fatalf("To Addr [%v]: To addr not found", tx.To().String()) - } - if tx.Nonce() != data.Nonce { - t.Fatalf("Nonce [%v]: Nonce not found", tx.Nonce()) - } - if tx.Gas() != data.Gas { - t.Fatalf("Gas [%v]: Gas not found", tx.Gas()) - } - if tx.GasPrice().Uint64() != data.GasPrice { - t.Fatalf("Gas Price [%v]: Gas price not found", tx.GasPrice().String()) - } - if block.GasLimit() != data.GasLimit { - t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) - } - if block.Hash().String() != data.BlockHash { - t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) - } - if block.Number().String() != data.BlockNumber { - t.Fatalf("Block Number [%v]: Block number not found", block.Number().String()) - } - if tx.Value().String() != data.Amount { - t.Fatalf("Amount [%v]: Amount not found", tx.Value().String()) - } - if tx.Cost().Uint64() != data.Cost { - t.Fatalf("Cost [%v]: Cost not found", tx.Cost().String()) - } - var status string - if receipt1.Status == 1 { - status = "SUCCESS" - } - if receipt1.Status == 0 { - status = "FAIL" - } - if status != data.Status { - t.Fatalf("Receipt status [%v]: Receipt status not found", status) - } - var isContract bool - if tx.To() != nil { - isContract = false - } else { - isContract = true - } - if isContract != data.IsContract { - t.Fatalf("isContract [%v]: isContract bool is incorrect", isContract) - } - } - - if getAllTx := core.SGetAllTransactions(sqldb); len(getAllTx) == 0 { - t.Fatalf("GetAllTransactions [%v]: GetAllTransactions did not return correctly", getAllTx) - } - ClearTables() -} - -func TestAccountsToReturnAccounts(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) - 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) - 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) - txs := []*types.Transaction{mytx, mytx2, mytx3} - - receipt1 := &types.Receipt{ - Status: types.ReceiptStatusSuccessful, - CumulativeGasUsed: 1, - Logs: []*types.Log{ - {Address: common.BytesToAddress([]byte{0x11})}, - {Address: common.BytesToAddress([]byte{0x01, 0x11})}, - }, - TxHash: common.BytesToHash([]byte{0x11, 0x11}), - ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), - GasUsed: 111111, - } - - receipts := []*types.Receipt{receipt1} - block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts) if err := core.SWriteBlock(block, receipts); err != nil { t.Fatalf("Failed to write block into database: %v", err) } - sqldb, err := core.DBConnection() - if (err != nil) { - panic(err) - } - - - 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) + sqldb, err := core.DBConnection() + if err != nil { + panic(err) } - 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 getAllAccountTxs := core.SGetAccountTxs(sqldb, tx.To().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) - } + entry := core.SGetBlock(sqldb, block.Number().String()) + byt := []byte(entry) + var data core.SBlock + json.Unmarshal(byt, &data) + + //TODO Difficulty, rewards, age + if block.Hash().String() != data.Hash { + t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) + } + if block.Coinbase().String() != data.Coinbase { + t.Fatalf("Block coinbase [%v]: Block coinbase not found", block.Coinbase().String()) + } + if block.Number().String() != data.Number { + t.Fatalf("Block number [%v]: Block number not found", block.Number().String()) + } + if block.GasUsed() != data.GasUsed { + t.Fatalf("Gas Used [%v]: Gas used not found", block.GasUsed()) + } + if block.GasLimit() != data.GasLimit { + t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) + } + if block.Transactions().Len() != data.TxCount { + t.Fatalf("Tx Count [%v]: Tx Count not found", block.Transactions().Len()) + } + if len(block.Uncles()) != data.UncleCount { + t.Fatalf("Uncle count [%v]: Uncle count not found", len(block.Uncles())) + } + if block.ParentHash().String() != data.ParentHash { + t.Fatalf("Parent hash [%v]: Parent hash not found", block.ParentHash().String()) + } + if block.UncleHash().String() != data.UncleHash { + t.Fatalf("Uncle hash [%v]: Uncle hash not found", block.UncleHash().String()) + } + if block.Size().String() != data.Size { + t.Fatalf("Size [%v]: Size not found", block.Size().String()) + } + if block.Nonce() != data.Nonce { + t.Fatalf("Block nonce [%v]: Block nonce not found", block.Nonce()) + } + + if getAllBlocks := core.SGetAllBlocks(sqldb); len(getAllBlocks) == 0 { + t.Fatalf("GetAllBlocks [%v]: GetAllBlocks did not return correctly", getAllBlocks) + } + + if getAllBlocksMinedByAddress := core.SGetAllBlocksMinedByAddress(sqldb, block.Coinbase().String()); len(getAllBlocksMinedByAddress) == 0 { + t.Fatalf("GetAllBlocksMinedByAddress [%v]: GetAllBlocksMinedByAddress did not return correctly", getAllBlocksMinedByAddress) + } + + ClearTables() + }) + + t.Run("TestGetRecentBlock", 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) + 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) + 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) + txs := []*types.Transaction{mytx, mytx2} + txs1 := []*types.Transaction{mytx3} + + receipt1 := &types.Receipt{ + Status: types.ReceiptStatusSuccessful, + CumulativeGasUsed: 1, + Logs: []*types.Log{ + {Address: common.BytesToAddress([]byte{0x11})}, + {Address: common.BytesToAddress([]byte{0x01, 0x11})}, + }, + TxHash: common.BytesToHash([]byte{0x11, 0x11}), + ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), + GasUsed: 111111, + } + + receipts := []*types.Receipt{receipt1} + block := types.NewBlock(&types.Header{Number: big.NewInt(322)}, txs, nil, receipts) + block2 := types.NewBlock(&types.Header{Number: big.NewInt(320)}, txs1, nil, receipts) + blocks := []*types.Block{block, block2} + + for _, bc := range blocks { + // Write and verify the block in the database + if err := core.SWriteBlock(bc, receipts); err != nil { + t.Fatalf("Failed to write block into database: %v", err) + } + } + + sqldb, err := core.DBConnection() + if (err != nil) { + panic(err) + } + + response := core.SGetRecentBlock(sqldb) + byteRes := []byte(response) + var recentBlock core.SBlock + json.Unmarshal(byteRes, &recentBlock) + + if block.Hash().String() != recentBlock.Hash { + t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) + } + if block.Coinbase().String() != recentBlock.Coinbase { + t.Fatalf("Block coinbase [%v]: Block coinbase not found", block.Coinbase().String()) + } + if block.Number().String() != recentBlock.Number { + t.Fatalf("Block number [%v]: Block number not found", block.Number().String()) + } + if block.GasUsed() != recentBlock.GasUsed { + t.Fatalf("Gas Used [%v]: Gas used not found", block.GasUsed()) + } + if block.GasLimit() != recentBlock.GasLimit { + t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) + } + if block.Transactions().Len() != recentBlock.TxCount { + t.Fatalf("Tx Count [%v]: Tx Count not found", block.Transactions().Len()) + } + if len(block.Uncles()) != recentBlock.UncleCount { + t.Fatalf("Uncle count [%v]: Uncle count not found", len(block.Uncles())) + } + if block.ParentHash().String() != recentBlock.ParentHash { + t.Fatalf("Parent hash [%v]: Parent hash not found", block.ParentHash().String()) + } + if block.UncleHash().String() != recentBlock.UncleHash { + t.Fatalf("Uncle hash [%v]: Uncle hash not found", block.UncleHash().String()) + } + if block.Size().String() != recentBlock.Size { + t.Fatalf("Size [%v]: Size not found", block.Size().String()) + } + if block.Nonce() != recentBlock.Nonce { + t.Fatalf("Block nonce [%v]: Block nonce not found", block.Nonce()) + } + + if allTxsFromBlock:= core.SGetAllTransactionsFromBlock(sqldb, block2.Number().String()); len(allTxsFromBlock) == 0 { + t.Fatalf("GetAllTransactionsFromBlock [%v]: GetAllTransactionsFromBlock did not return correctly", allTxsFromBlock) + } + ClearTables() + }) + ClearTables() } + + +//func TestBlockToReturnBlock(t *testing.T) { +// core.InitDBTest() +// +// 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) +// 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) +// 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) +// txs := []*types.Transaction{mytx, mytx2, mytx3} +// +// receipt := &types.Receipt{ +// Status: types.ReceiptStatusSuccessful, +// CumulativeGasUsed: 1, +// Logs: []*types.Log{ +// {Address: common.BytesToAddress([]byte{0x11})}, +// {Address: common.BytesToAddress([]byte{0x01, 0x11})}, +// }, +// TxHash: common.BytesToHash([]byte{0x11, 0x11}), +// ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), +// GasUsed: 111111, +// } +// +// receipts := []*types.Receipt{receipt} +// block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts) +// +// // 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) +// } +// +// sqldb, err := core.DBConnection() +// if err != nil { +// panic(err) +// } +// +// entry := core.SGetBlock(sqldb, block.Number().String()) +// byt := []byte(entry) +// var data core.SBlock +// json.Unmarshal(byt, &data) +// +// //TODO Difficulty, rewards, age +// if block.Hash().String() != data.Hash { +// t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) +// } +// if block.Coinbase().String() != data.Coinbase { +// t.Fatalf("Block coinbase [%v]: Block coinbase not found", block.Coinbase().String()) +// } +// if block.Number().String() != data.Number { +// t.Fatalf("Block number [%v]: Block number not found", block.Number().String()) +// } +// if block.GasUsed() != data.GasUsed { +// t.Fatalf("Gas Used [%v]: Gas used not found", block.GasUsed()) +// } +// if block.GasLimit() != data.GasLimit { +// t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) +// } +// if block.Transactions().Len() != data.TxCount { +// t.Fatalf("Tx Count [%v]: Tx Count not found", block.Transactions().Len()) +// } +// if len(block.Uncles()) != data.UncleCount { +// t.Fatalf("Uncle count [%v]: Uncle count not found", len(block.Uncles())) +// } +// if block.ParentHash().String() != data.ParentHash { +// t.Fatalf("Parent hash [%v]: Parent hash not found", block.ParentHash().String()) +// } +// if block.UncleHash().String() != data.UncleHash { +// t.Fatalf("Uncle hash [%v]: Uncle hash not found", block.UncleHash().String()) +// } +// if block.Size().String() != data.Size { +// t.Fatalf("Size [%v]: Size not found", block.Size().String()) +// } +// if block.Nonce() != data.Nonce { +// t.Fatalf("Block nonce [%v]: Block nonce not found", block.Nonce()) +// } +// +// if getAllBlocks := core.SGetAllBlocks(sqldb); len(getAllBlocks) == 0 { +// t.Fatalf("GetAllBlocks [%v]: GetAllBlocks did not return correctly", getAllBlocks) +// } +// +// if getAllBlocksMinedByAddress := core.SGetAllBlocksMinedByAddress(sqldb, block.Coinbase().String()); len(getAllBlocksMinedByAddress) == 0 { +// t.Fatalf("GetAllBlocksMinedByAddress [%v]: GetAllBlocksMinedByAddress did not return correctly", getAllBlocksMinedByAddress) +// } +// +// ClearTables() +//} +// +//func TestGetRecentBlock(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) +// 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) +// 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) +// txs := []*types.Transaction{mytx, mytx2} +// txs1 := []*types.Transaction{mytx3} +// +// receipt1 := &types.Receipt{ +// Status: types.ReceiptStatusSuccessful, +// CumulativeGasUsed: 1, +// Logs: []*types.Log{ +// {Address: common.BytesToAddress([]byte{0x11})}, +// {Address: common.BytesToAddress([]byte{0x01, 0x11})}, +// }, +// TxHash: common.BytesToHash([]byte{0x11, 0x11}), +// ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), +// GasUsed: 111111, +// } +// +// receipts := []*types.Receipt{receipt1} +// block := types.NewBlock(&types.Header{Number: big.NewInt(322)}, txs, nil, receipts) +// block2 := types.NewBlock(&types.Header{Number: big.NewInt(320)}, txs1, nil, receipts) +// blocks := []*types.Block{block, block2} +// +// for _, bc := range blocks { +// // Write and verify the block in the database +// if err := core.SWriteBlock(bc, receipts); err != nil { +// t.Fatalf("Failed to write block into database: %v", err) +// } +// } +// +// sqldb, err := core.DBConnection() +// if (err != nil) { +// panic(err) +// } +// +// response := core.SGetRecentBlock(sqldb) +// byteRes := []byte(response) +// var recentBlock core.SBlock +// json.Unmarshal(byteRes, &recentBlock) +// +// if block.Hash().String() != recentBlock.Hash { +// t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) +// } +// if block.Coinbase().String() != recentBlock.Coinbase { +// t.Fatalf("Block coinbase [%v]: Block coinbase not found", block.Coinbase().String()) +// } +// if block.Number().String() != recentBlock.Number { +// t.Fatalf("Block number [%v]: Block number not found", block.Number().String()) +// } +// if block.GasUsed() != recentBlock.GasUsed { +// t.Fatalf("Gas Used [%v]: Gas used not found", block.GasUsed()) +// } +// if block.GasLimit() != recentBlock.GasLimit { +// t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) +// } +// if block.Transactions().Len() != recentBlock.TxCount { +// t.Fatalf("Tx Count [%v]: Tx Count not found", block.Transactions().Len()) +// } +// if len(block.Uncles()) != recentBlock.UncleCount { +// t.Fatalf("Uncle count [%v]: Uncle count not found", len(block.Uncles())) +// } +// if block.ParentHash().String() != recentBlock.ParentHash { +// t.Fatalf("Parent hash [%v]: Parent hash not found", block.ParentHash().String()) +// } +// if block.UncleHash().String() != recentBlock.UncleHash { +// t.Fatalf("Uncle hash [%v]: Uncle hash not found", block.UncleHash().String()) +// } +// if block.Size().String() != recentBlock.Size { +// t.Fatalf("Size [%v]: Size not found", block.Size().String()) +// } +// if block.Nonce() != recentBlock.Nonce { +// t.Fatalf("Block nonce [%v]: Block nonce not found", block.Nonce()) +// } +// +// if allTxsFromBlock:= core.SGetAllTransactionsFromBlock(sqldb, block2.Number().String()); len(allTxsFromBlock) == 0 { +// t.Fatalf("GetAllTransactionsFromBlock [%v]: GetAllTransactionsFromBlock did not return correctly", allTxsFromBlock) +// } +// ClearTables() +//} +// +//func TestContractCreationTx(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) +// txs := []*types.Transaction{mytx} +// +// receipt2 := &types.Receipt{ +// Status: types.ReceiptStatusSuccessful, +// CumulativeGasUsed: 1, +// Logs: []*types.Log{ +// {Address: common.BytesToAddress([]byte{0x11})}, +// {Address: common.BytesToAddress([]byte{0x01, 0x11})}, +// }, +// TxHash: common.BytesToHash([]byte{0x11, 0x11}), +// ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), +// GasUsed: 111111, +// } +// +// receipts := []*types.Receipt{receipt2} +// block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, receipts) +// +// if err := core.SWriteBlock(block, receipts); err != nil { +// t.Fatalf("Failed to write block into database: %v", err) +// } +// +// var contractAddressFromReciept string +// for _, receipt := range receipts { +// contractAddressFromReciept = (*types.ReceiptForStorage)(receipt).ContractAddress.String() +// } +// +// sqldb, err := core.DBConnection() +// if (err != nil) { +// panic(err) +// } +// +// for _, tx := range txs { +// txn := core.SGetTransaction(sqldb, tx.Hash().String()) +// byt := []byte(txn) +// var data core.ShyftTxEntryPretty +// json.Unmarshal(byt, &data) +// +// if tx.Hash().String() != data.TxHash { +// t.Fatalf("txHash [%v]: tx Hash not found", tx.Hash().String()) +// } +// if contractAddressFromReciept != data.To { +// t.Fatalf("Contract Addr [%v]: Contract addr not found", contractAddressFromReciept) +// } +// if tx.From().String() != data.From { +// t.Fatalf("From Addr [%v]: From addr not found", tx.From().String()) +// } +// if tx.Nonce() != data.Nonce { +// t.Fatalf("Nonce [%v]: Nonce not found", tx.Nonce()) +// } +// if tx.Gas() != data.Gas { +// t.Fatalf("Gas [%v]: Gas not found", tx.Gas()) +// } +// if tx.GasPrice().Uint64() != data.GasPrice { +// t.Fatalf("Gas Price [%v]: Gas price not found", tx.GasPrice().String()) +// } +// if block.GasLimit() != data.GasLimit { +// t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) +// } +// if block.Hash().String() != data.BlockHash { +// t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) +// } +// if block.Number().String() != data.BlockNumber { +// t.Fatalf("Block Number [%v]: Block number not found", block.Number().String()) +// } +// if tx.Value().String() != data.Amount { +// t.Fatalf("Amount [%v]: Amount not found", tx.Value().String()) +// } +// if tx.Cost().Uint64() != data.Cost { +// t.Fatalf("Cost [%v]: Cost not found", tx.Cost().String()) +// } +// var status string +// if receipt2.Status == 1 { +// status = "SUCCESS" +// } +// if receipt2.Status == 0 { +// status = "FAIL" +// } +// if status != data.Status { +// t.Fatalf("Receipt status [%v]: Receipt status not found", status) +// } +// var isContract bool +// if tx.To() != nil { +// isContract = false +// } else { +// isContract = true +// } +// if isContract != data.IsContract { +// t.Fatalf("isContract [%v]: isContract bool is incorrect", isContract) +// } +// } +// ClearTables() +//} +// +//func TestTransactionsToReturnTransactions(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) +// 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) +// 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) +// txs := []*types.Transaction{mytx, mytx2, mytx3} +// +// receipt1 := &types.Receipt{ +// Status: types.ReceiptStatusSuccessful, +// CumulativeGasUsed: 1, +// Logs: []*types.Log{ +// {Address: common.BytesToAddress([]byte{0x11})}, +// {Address: common.BytesToAddress([]byte{0x01, 0x11})}, +// }, +// TxHash: common.BytesToHash([]byte{0x11, 0x11}), +// ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), +// GasUsed: 111111, +// } +// +// receipts := []*types.Receipt{receipt1} +// block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, receipts) +// +// if err := core.SWriteBlock(block, receipts); err != nil { +// t.Fatalf("Failed to write block into database: %v", err) +// } +// sqldb, err := core.DBConnection() +// if (err != nil) { +// panic(err) +// } +// +// for _, tx := range txs { +// txn := core.SGetTransaction(sqldb, tx.Hash().String()) +// byt := []byte(txn) +// var data core.ShyftTxEntryPretty +// json.Unmarshal(byt, &data) +// +// //TODO age, data +// if tx.Hash().String() != data.TxHash { +// t.Fatalf("txHash [%v]: tx Hash not found", tx.Hash().String()) +// } +// if tx.From().String() != data.From { +// t.Fatalf("From Addr [%v]: From addr not found", tx.From().String()) +// } +// if tx.To().String() != data.To { +// t.Fatalf("To Addr [%v]: To addr not found", tx.To().String()) +// } +// if tx.Nonce() != data.Nonce { +// t.Fatalf("Nonce [%v]: Nonce not found", tx.Nonce()) +// } +// if tx.Gas() != data.Gas { +// t.Fatalf("Gas [%v]: Gas not found", tx.Gas()) +// } +// if tx.GasPrice().Uint64() != data.GasPrice { +// t.Fatalf("Gas Price [%v]: Gas price not found", tx.GasPrice().String()) +// } +// if block.GasLimit() != data.GasLimit { +// t.Fatalf("Gas Limit [%v]: Gas limit not found", block.GasLimit()) +// } +// if block.Hash().String() != data.BlockHash { +// t.Fatalf("Block Hash [%v]: Block hash not found", block.Hash().String()) +// } +// if block.Number().String() != data.BlockNumber { +// t.Fatalf("Block Number [%v]: Block number not found", block.Number().String()) +// } +// if tx.Value().String() != data.Amount { +// t.Fatalf("Amount [%v]: Amount not found", tx.Value().String()) +// } +// if tx.Cost().Uint64() != data.Cost { +// t.Fatalf("Cost [%v]: Cost not found", tx.Cost().String()) +// } +// var status string +// if receipt1.Status == 1 { +// status = "SUCCESS" +// } +// if receipt1.Status == 0 { +// status = "FAIL" +// } +// if status != data.Status { +// t.Fatalf("Receipt status [%v]: Receipt status not found", status) +// } +// var isContract bool +// if tx.To() != nil { +// isContract = false +// } else { +// isContract = true +// } +// if isContract != data.IsContract { +// t.Fatalf("isContract [%v]: isContract bool is incorrect", isContract) +// } +// } +// +// if getAllTx := core.SGetAllTransactions(sqldb); len(getAllTx) == 0 { +// t.Fatalf("GetAllTransactions [%v]: GetAllTransactions did not return correctly", getAllTx) +// } +// ClearTables() +//} +// +//func TestAccountsToReturnAccounts(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) +// 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) +// 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) +// txs := []*types.Transaction{mytx, mytx2, mytx3} +// +// receipt1 := &types.Receipt{ +// Status: types.ReceiptStatusSuccessful, +// CumulativeGasUsed: 1, +// Logs: []*types.Log{ +// {Address: common.BytesToAddress([]byte{0x11})}, +// {Address: common.BytesToAddress([]byte{0x01, 0x11})}, +// }, +// TxHash: common.BytesToHash([]byte{0x11, 0x11}), +// ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), +// GasUsed: 111111, +// } +// +// receipts := []*types.Receipt{receipt1} +// block := types.NewBlock(&types.Header{Number: big.NewInt(315)}, txs, nil, receipts) +// if err := core.SWriteBlock(block, receipts); err != nil { +// t.Fatalf("Failed to write block into database: %v", err) +// } +// +// sqldb, err := core.DBConnection() +// if (err != nil) { +// panic(err) +// } +// +// +// 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.TxCountAccount { +// t.Fatalf("To account nonce [%v]: To account nonce not found", accountDataTo.TxCountAccount) +// } +// if getAllAccountTxs := core.SGetAccountTxs(sqldb, tx.To().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() +//} + + + diff --git a/shyfttracerinterface/tracer_interface.go b/shyfttracerinterface/tracer_interface.go index dbadf1e39b..43fd883788 100644 --- a/shyfttracerinterface/tracer_interface.go +++ b/shyfttracerinterface/tracer_interface.go @@ -8,7 +8,3 @@ type IShyftTracer interface { GetTracerToRun(hash common.Hash) (interface{}, error) } -//type IShyftTracer interface { -// MyTraceTransaction(hash string) (interface{}) -//} -