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

Merge branch 'shyft/greg' into shyftBlockExp

Browse source
This commit is contained in:
Tim Williams 2018-04-16 16:36:58 -04:00
commit dfa0d2a18e
17 changed files with 310 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
cmd/utils/flags.go
View file

@ -28,6 +28,8 @@ import (
"strconv"
"strings"
"github.com/syndtr/goleveldb/leveldb"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/accounts/keystore"
"github.com/ethereum/go-ethereum/common"
@ -1250,8 +1252,9 @@ func MakeChain(ctx *cli.Context, stack *node.Node) (chain *core.BlockChain, chai
cache.TrieNodeLimit = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheGCFlag.Name) / 100
}
vmcfg := vm.Config{EnablePreimageRecording: ctx.GlobalBool(VMEnableDebugFlag.Name)}
blockExplorerDb, _ := leveldb.OpenFile("./foo_data/", nil)
fmt.Println("Calling NewBlock CHAIN in flags.go ******************************")
chain, err = core.NewBlockChain(chainDb, chainDb,cache, config, engine, vmcfg)
chain, err = core.NewBlockChain(chainDb, blockExplorerDb,cache, config, engine, vmcfg)
if err != nil {
Fatalf("Can't create BlockChain: %v", err)
}

34
core/blockchain.go
View file

@ -20,6 +20,8 @@ package core
import (
"errors"
"fmt"
//"bytes"
//"encoding/gob"
"io"
"math/big"
mrand "math/rand"
@ -27,10 +29,13 @@ import (
"sync/atomic"
"time"
"github.com/syndtr/goleveldb/leveldb"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/mclock"
"github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/shyftdb"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
@ -90,7 +95,7 @@ type BlockChain struct {
cacheConfig *CacheConfig // Cache configuration for pruning
db ethdb.Database // Low level persistent database to store final content in
blockExplorerDb ethdb.Database
blockExplorerDb *leveldb.DB
triegc *prque.Prque // Priority queue mapping block numbers to tries to gc
gcproc time.Duration // Accumulates canonical block processing for trie dumping
@ -135,7 +140,7 @@ type BlockChain struct {
// NewBlockChain returns a fully initialised block chain using information
// available in the database. It initialises the default Ethereum Validator and
// Processor.
func NewBlockChain(db ethdb.Database, blockExplorerDb ethdb.Database, cacheConfig *CacheConfig, chainConfig *params.ChainConfig, engine consensus.Engine, vmConfig vm.Config) (*BlockChain, error) {
func NewBlockChain(db ethdb.Database, blockExplorerDb *leveldb.DB, cacheConfig *CacheConfig, chainConfig *params.ChainConfig, engine consensus.Engine, vmConfig vm.Config) (*BlockChain, error) {
fmt.Printf("+++++++++++++++++core/blockchain.GO+++++++++++++++++++++++++NewBlockChain()")
if cacheConfig == nil {
cacheConfig = &CacheConfig{
@ -876,8 +881,6 @@ func (bc *BlockChain) WriteBlockWithoutState(block *types.Block, td *big.Int) (e
// WriteBlockWithState writes the block and all associated state to the database.
func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
fmt.Println("WriteBlockWithState function. bc.blockexplorerDB")
fmt.Println(bc.blockExplorerDb)
bc.wg.Add(1)
defer bc.wg.Done()
@ -903,6 +906,29 @@ func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.
if err := WriteBlock(batch, block); err != nil {
return NonStatTy, err
}
// @NOTE:SHYFT - Write block data for block explorer
if err := shyftdb.WriteBlock(bc.blockExplorerDb, block); err != nil {
return NonStatTy, err
}
//fmt.Println(shyftdb.GetAllBlocks(bc.blockExplorerDb))
//result := shyftdb.GetBlock(bc.blockExplorerDb, block)
// this is WIP for decoding bytes rather than hex strings
// maybe this will be dropped
/*for i, txhash := range result {
//dst := make([]byte, hex.DecodedLen(len(txhash)))
content := hex.Dump(txhash)
fmt.Printf("%s", content)
}*/
//buf := bytes.NewBuffer(result)
//strs2 := []string{}
//gob.NewDecoder(buf).Decode(&strs2)
//fmt.Println("ALL TRANSACTIONS:")
//
//fmt.Println("the returned array is")
//fmt.Printf("%v", strs2)
root, err := state.Commit(bc.chainConfig.IsEIP158(block.Number()))
if err != nil {
return NonStatTy, err

14
core/chain_makers.go
View file

@ -20,6 +20,8 @@ import (
"fmt"
"math/big"
"github.com/syndtr/goleveldb/leveldb"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/consensus/misc"
@ -166,7 +168,8 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
genblock := func(i int, parent *types.Block, statedb *state.StateDB) (*types.Block, types.Receipts) {
// TODO(karalabe): This is needed for clique, which depends on multiple blocks.
// It's nonetheless ugly to spin up a blockchain here. Get rid of this somehow.
blockchain, _ := NewBlockChain(db, db,nil, config, engine, vm.Config{})
blockExplorerDb, _ := leveldb.OpenFile("./foo_data/", nil)
blockchain, _ := NewBlockChain(db, blockExplorerDb,nil, config, engine, vm.Config{})
defer blockchain.Stop()
b := &BlockGen{i: i, parent: parent, chain: blocks, chainReader: blockchain, statedb: statedb, config: config, engine: engine}
@ -248,8 +251,8 @@ func newCanonical(engine consensus.Engine, n int, full bool) (ethdb.Database, *B
gspec := new(Genesis)
db, _ := ethdb.NewMemDatabase()
genesis := gspec.MustCommit(db)
blockchain, _ := NewBlockChain(db, db, nil, params.AllEthashProtocolChanges, engine, vm.Config{})
blockExplorerDb, err := leveldb.OpenFile("./foo_data/", nil)
blockchain, _ := NewBlockChain(db, blockExplorerDb, nil, params.AllEthashProtocolChanges, engine, vm.Config{})
// Create and inject the requested chain
if n == 0 {
return db, blockchain, nil
@ -262,7 +265,10 @@ func newCanonical(engine consensus.Engine, n int, full bool) (ethdb.Database, *B
}
// Header-only chain requested
headers := makeHeaderChain(genesis.Header(), n, engine, db, canonicalSeed)
_, err := blockchain.InsertHeaderChain(headers, 1)
foo, err := blockchain.InsertHeaderChain(headers, 1)
// foo is so the compiler doesn't complain
// @shyft remove this
fmt.Println(foo)
return db, blockchain, err
}

5
core/database_util.go
View file

@ -21,8 +21,8 @@ import (
"encoding/binary"
"encoding/json"
"errors"
"fmt"
"math/big"
"fmt"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
@ -455,6 +455,7 @@ func WriteBlock(db ethdb.Putter, block *types.Block) error {
if err := WriteHeader(db, block.Header()); err != nil {
return err
}
return nil
}
@ -462,6 +463,7 @@ func WriteBlock(db ethdb.Putter, block *types.Block) error {
// as a single receipt slice. This is used during chain reorganisations for
// rescheduling dropped transactions.
func WriteBlockReceipts(db ethdb.Putter, hash common.Hash, number uint64, receipts types.Receipts) error {
// Convert the receipts into their storage form and serialize them
storageReceipts := make([]*types.ReceiptForStorage, len(receipts))
for i, receipt := range receipts {
@ -473,6 +475,7 @@ func WriteBlockReceipts(db ethdb.Putter, hash common.Hash, number uint64, receip
}
// Store the flattened receipt slice
key := append(append(blockReceiptsPrefix, encodeBlockNumber(number)...), hash.Bytes()...)
if err := db.Put(key, bytes); err != nil {
log.Crit("Failed to store block receipts", "err", err)
}

16
core/types/transaction.go
View file

@ -195,6 +195,22 @@ func (tx *Transaction) To() *common.Address {
return &to
}
//@NOTE:SHYFT - Custom function to require FROM
func (tx *Transaction) From() *common.Address {
if tx.data.V != nil {
// make a best guess about the signer and use that to derive
// the sender.
signer := deriveSigner(tx.data.V)
if from, err := Sender(signer, tx); err != nil { // derive but don't cache
return nil
} else {
return &from
}
} else {
return nil
}
}
// Hash hashes the RLP encoding of tx.
// It uniquely identifies the transaction.
func (tx *Transaction) Hash() common.Hash {

8
eth/backend.go
View file

@ -24,7 +24,7 @@ import (
"runtime"
"sync"
"sync/atomic"
"github.com/syndtr/goleveldb/leveldb"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
@ -74,7 +74,7 @@ type Ethereum struct {
// DB interfaces
chainDb ethdb.Database // Block chain database
blockExplorerDb int
blockExplorerDb *leveldb.DB
eventMux *event.TypeMux
engine consensus.Engine
@ -117,7 +117,7 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
}
// @NOTE:shyft instantiate BlockExplorerDB here?
blockExplorerDb, err := CreateDB(ctx, config, "blockExplorerDb")
blockExplorerDb, err := leveldb.OpenFile("./shyftData/geth/blockExplorerDb/", nil)
if err != nil {
return nil, err
}
@ -131,7 +131,7 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
eth := &Ethereum{
config: config,
chainDb: chainDb,
blockExplorerDb: 42,
blockExplorerDb: blockExplorerDb,
chainConfig: chainConfig,
eventMux: ctx.EventMux,
accountManager: ctx.AccountManager,

1
miner/unconfirmed.go
View file

@ -72,7 +72,6 @@ func (set *unconfirmedBlocks) Insert(index uint64, hash common.Hash) {
// Set as the initial ring or append to the end
set.lock.Lock()
defer set.lock.Unlock()
if set.blocks == nil {
set.blocks = item
} else {

3
miner/worker.go
View file

@ -309,9 +309,6 @@ func (self *worker) wait() {
for _, log := range work.state.Logs() {
log.BlockHash = block.Hash()
}
fmt.Println("+++++++++++++++++miner/worker.GO+++++++++++++++++++++++++wait()")
fmt.Println(work.state)
fmt.Println("+++++++++++++++++miner/worker.GO+++++++++++++++++++++++++selt chain")
stat, err := self.chain.WriteBlockWithState(block, work.receipts, work.state)
if err != nil {
log.Error("Failed writing block to chain", "err", err)

1
node/node.go
View file

@ -642,6 +642,7 @@ func (n *Node) EventMux() *event.TypeMux {
// previous can be found) from within the node's instance directory. If the node is
// ephemeral, a memory database is returned.
func (n *Node) OpenDatabase(name string, cache, handles int) (ethdb.Database, error) {
fmt.Println("DSAhhysagdhkajsndjgasuygdvkhasbdjhs")
if n.config.DataDir == "" {
return ethdb.NewMemDatabase()
}

4
run_js_in_geth.sh Normal file
View file

@ -0,0 +1,4 @@
file=$1
echo $file
runthing="./build/bin/geth --exec 'loadScript(\""$file"\")' attach http://127.0.0.1:8545"
eval $runthing

2
shyftDb/database.go → shyftdb/database.go
View file

@ -14,7 +14,7 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package ethdb
package shyftdb
import (
"strconv"

2
shyftDb/interface.go → shyftdb/interface.go
View file

@ -1,5 +1,5 @@
package ethdb
package shyftdb
// Code using batches should try to add this much data to the batch.
// The value was determined empirically.

167
shyftdb/shyft_database_util.go Normal file
View file

@ -0,0 +1,167 @@
package shyftdb
import (
"fmt"
"bytes"
"encoding/gob"
"math/big"
"github.com/syndtr/goleveldb/leveldb"
"github.com/syndtr/goleveldb/leveldb/util"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/log"
)
type SBlock struct {
hash string
txes []string
}
type ShyftTxEntry struct {
TxHash common.Hash
To *common.Address
From *common.Address
BlockHash common.Hash
Amount *big.Int
GasPrice *big.Int
Gas uint64
Nonce uint64
Data []byte
}
func WriteBlock(db *leveldb.DB, block *types.Block) error {
leng := block.Transactions().Len()
var tx_strs = make([]string, leng)
//var tx_bytes = make([]byte, leng)
hash := block.Header().Hash().Bytes()
if block.Transactions().Len() > 0 {
for i, tx := range block.Transactions() {
tx_strs[i] = WriteTransactions(db, tx, block.Header().Hash())
//tx_bytes[i] = tx.Hash().Bytes()
}
}
fmt.Println("The tx_strs is")
fmt.Println(tx_strs)
//strs := []string{"foo", "bar"}
buf := &bytes.Buffer{}
gob.NewEncoder(buf).Encode(tx_strs)
bs := buf.Bytes()
key := append([]byte("bk-")[:], hash[:]...)
if err := db.Put(key, bs, nil); err != nil {
log.Crit("Failed to store block", "err", err)
return nil // Do we want to force an exit here?
}
return nil
}
func WriteTransactions(db *leveldb.DB, tx *types.Transaction, blockHash common.Hash) string {
txData := ShyftTxEntry{
TxHash: tx.Hash(),
To: tx.To(),
From: tx.From(),
BlockHash: blockHash,
Amount: tx.Value(),
GasPrice: tx.GasPrice(),
Gas: tx.Gas(),
Nonce: tx.Nonce(),
Data: tx.Data(),
}
var encodedData bytes.Buffer
encoder := gob.NewEncoder(&encodedData)
if err := encoder.Encode(txData); err != nil {
log.Crit("Faild to encode TX data", "err", err)
}
key := append([]byte("tx-")[:], tx.Hash().Bytes()[:]...)
if err := db.Put(key, encodedData.Bytes(), nil); err != nil {
log.Crit("Failed to store TX", "err", err)
}
GetTransaction(db, tx)
GetAllTransactions(db)
return tx.Hash().String()
}
// Meant for internal tests
func GetAllBlocks(db *leveldb.DB) []SBlock{
var arr []SBlock
iter := db.NewIterator(util.BytesPrefix([]byte("bk-")), nil)
for iter.Next() {
result := iter.Value()
buf := bytes.NewBuffer(result)
strs2 := []string{}
gob.NewDecoder(buf).Decode(&strs2)
//fmt.Println("the key is")
hash := common.BytesToHash(iter.Key())
hex := hash.Hex()
//fmt.Println(hex)
sblock := SBlock{hex, strs2}
arr = append(arr, sblock)
//fmt.Println("\n ALL BK BK VALUE" + string(result))
}
iter.Release()
return arr
}
func GetBlock(db *leveldb.DB, block *types.Block) []byte {
hash := block.Header().Hash().Bytes()
key := append([]byte("bk-")[:], hash[:]...)
data, err := db.Get(key, nil)
if err != nil {
log.Crit("Could not retrieve block", "err", err)
}
fmt.Println("\nBLOCK Value: " + string(data))
return data
}
func GetAllTransactions(db *leveldb.DB) {
iter := db.NewIterator(util.BytesPrefix([]byte("tx-")), nil)
for iter.Next() {
var txData ShyftTxEntry
d := gob.NewDecoder(bytes.NewBuffer(iter.Value()))
if err := d.Decode(&txData); err != nil {
log.Crit("Failed to decode tx:", "err", err)
}
fmt.Println("DECODED TX")
fmt.Println("Tx Hash: ", txData.TxHash.Hex())
fmt.Println("From: ", txData.From.Hex())
fmt.Println("To: ", txData.To.Hex())
fmt.Println("BlockHash: ", txData.BlockHash.Hex())
fmt.Println("Amount: ", txData.Amount)
fmt.Println("Gas: ", txData.Gas)
fmt.Println("GasPrice: ", txData.GasPrice)
fmt.Println("Nonce: ", txData.Nonce)
fmt.Println("Data: ", txData.Data)
}
iter.Release()
}
func GetTransaction (db *leveldb.DB, tx *types.Transaction) {
key := append([]byte("tx-")[:], tx.Hash().Bytes()[:]...)
data, err := db.Get(key, nil)
if err != nil {
log.Crit("Could not retrieve TX", "err", err)
}
if len(data) > 0 {
var txData ShyftTxEntry
d := gob.NewDecoder(bytes.NewBuffer(data))
if err := d.Decode(&txData); err != nil {
log.Crit("Failed to decode tx:", "err", err)
}
fmt.Println("DECODED TX")
fmt.Println("Tx Hash: ", txData.TxHash.Hex())
fmt.Println("From: ", txData.From.Hex())
fmt.Println("To: ", txData.To.Hex())
fmt.Println("BlockHash: ", txData.BlockHash.Hex())
fmt.Println("Amount: ", txData.Amount)
fmt.Println("Gas: ", txData.Gas)
fmt.Println("GasPrice: ", txData.GasPrice)
fmt.Println("Nonce: ", txData.Nonce)
fmt.Println("Data: ", txData.Data)
}
}

4
simulations/checkbalances.js Normal file
View file

@ -0,0 +1,4 @@
console.log("Checking balances...")
for(i = 0; i < web3.eth.accounts.length; i++){
console.log(web3.eth.accounts[i] + ":" + web3.eth.getBalance(web3.eth.accounts[i]))
}

27
simulations/deployContract.js Normal file
View file

@ -0,0 +1,27 @@
// using contract from https://www.ethereum.org/greeter
// compiled on remix
var _greeting = "Greeter Contract" ;
var greeterContract = web3.eth.contract([{"constant":false,"inputs":[],"name":"kill","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"greet","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_greeting","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"}]);
var greeter = greeterContract.new(
_greeting,
{
from: web3.eth.accounts[0],
data: '0x6060604052341561000f57600080fd5b6040516103a93803806103a983398101604052808051820191905050336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508060019080519060200190610081929190610088565b505061012d565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106100c957805160ff19168380011785556100f7565b828001600101855582156100f7579182015b828111156100f65782518255916020019190600101906100db565b5b5090506101049190610108565b5090565b61012a91905b8082111561012657600081600090555060010161010e565b5090565b90565b61026d8061013c6000396000f30060606040526004361061004c576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806341c0e1b514610051578063cfae321714610066575b600080fd5b341561005c57600080fd5b6100646100f4565b005b341561007157600080fd5b610079610185565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100b957808201518184015260208101905061009e565b50505050905090810190601f1680156100e65780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610183576000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b565b61018d61022d565b60018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156102235780601f106101f857610100808354040283529160200191610223565b820191906000526020600020905b81548152906001019060200180831161020657829003601f168201915b5050505050905090565b6020604051908101604052806000815250905600a165627a7a7230582015882dcaabcda0ebdb1b26a10e36f26a424e148671f4703dde3c1956ebaa67830029',
gas: '4700000'
}, function (e, contract){
if(!e) {
// NOTE: The callback will fire twice!
// Once the contract has the transactionHash property set and once its deployed on an address.
// e.g. check tx hash on the first call (transaction send)
if(!contract.address) {
console.log("TX hash:")
console.log(contract.transactionHash) // The hash of the transaction, which deploys the contract
} else {
console.log("Contract address:")
console.log(contract.address) // the contract address
}
}
})

7
simulations/getGreeting.js Normal file
View file

@ -0,0 +1,7 @@
var abi = [{"constant":false,"inputs":[],"name":"kill","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"greet","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_greeting","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"}]
function getGreeting(address){
var MyContract = web3.eth.contract(abi);
var myContractInstance = MyContract.at(address);
console.log(myContractInstance.greet())
}

30
simulations/sendTransactions.js Normal file
View file

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