mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

PoC7 Net

Browse Source
pull/150/head
obscuren 10 years ago
parent 10b252dd05
commit 520fdfe346
7 changed files with 38 additions and 411 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 6
      ethchain/block.go
  2. 3
      ethchain/genesis.go
  3. 6
      ethereum.go
  4. 311
      ethrpc/packages.go
  5. 67
      ethrpc/server.go
  6. 24
      ethwire/messaging.go
  7. 32
      peer.go

6
ethchain/block.go
Unescape View File

@ -130,7 +130,7 @@ func CreateBlock(root interface{},
Nonce: Nonce, Nonce: Nonce,
Time: time.Now().Unix(), Time: time.Now().Unix(),
Extra: extra, Extra: extra,
UncleSha: EmptyShaList, UncleSha: EmptyShaList, //nil,
GasUsed: new(big.Int), GasUsed: new(big.Int),
MinGasPrice: new(big.Int), MinGasPrice: new(big.Int),
GasLimit: new(big.Int), GasLimit: new(big.Int),
@ -237,7 +237,9 @@ func (block *Block) SetUncles(uncles []*Block) {
block.Uncles = uncles block.Uncles = uncles
// Sha of the concatenated uncles // Sha of the concatenated uncles
block.UncleSha = ethcrypto.Sha3(ethutil.Encode(block.rlpUncles())) //if len(uncles) > 0 {
// block.UncleSha = ethcrypto.Sha3(ethutil.Encode(block.rlpUncles()))
//}
} }
func (self *Block) SetReceipts(receipts []*Receipt, txs []*Transaction) { func (self *Block) SetReceipts(receipts []*Receipt, txs []*Transaction) {

3
ethchain/genesis.go
Unescape View File

@ -18,8 +18,9 @@ var EmptyShaList = ethcrypto.Sha3(ethutil.Encode([]interface{}{}))
var GenesisHeader = []interface{}{ var GenesisHeader = []interface{}{
// Previous hash (none) // Previous hash (none)
ZeroHash256, ZeroHash256,
// Sha of uncles
ethcrypto.Sha3(ethutil.Encode([]interface{}{})), ethcrypto.Sha3(ethutil.Encode([]interface{}{})),
// Empty uncles
//"",
// Coinbase // Coinbase
ZeroHash160, ZeroHash160,
// Root state // Root state

6
ethereum.go
Unescape View File

@ -17,16 +17,16 @@ import (
"github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethchain"
"github.com/ethereum/eth-go/ethcrypto" "github.com/ethereum/eth-go/ethcrypto"
"github.com/ethereum/eth-go/ethlog" "github.com/ethereum/eth-go/ethlog"
"github.com/ethereum/eth-go/ethrpc"
"github.com/ethereum/eth-go/ethstate" "github.com/ethereum/eth-go/ethstate"
"github.com/ethereum/eth-go/ethutil" "github.com/ethereum/eth-go/ethutil"
"github.com/ethereum/eth-go/ethwire" "github.com/ethereum/eth-go/ethwire"
"github.com/ethereum/eth-go/event" "github.com/ethereum/eth-go/event"
"github.com/ethereum/eth-go/rpc"
) )
const ( const (
seedTextFileUri string = "http://www.ethereum.org/servers.poc3.txt" seedTextFileUri string = "http://www.ethereum.org/servers.poc3.txt"
seedNodeAddress = "poc-6.ethdev.com:30303" seedNodeAddress = "poc-7.ethdev.com:30303"
) )
var ethlogger = ethlog.NewLogger("SERV") var ethlogger = ethlog.NewLogger("SERV")
@ -84,7 +84,7 @@ type Ethereum struct {
listening bool listening bool
RpcServer *ethrpc.JsonRpcServer RpcServer *rpc.JsonRpcServer
keyManager *ethcrypto.KeyManager keyManager *ethcrypto.KeyManager

311
ethrpc/packages.go
Unescape View File

@ -1,311 +0,0 @@
package ethrpc
import (
"encoding/json"
"errors"
"math/big"
"strings"
"github.com/ethereum/eth-go/ethpipe"
"github.com/ethereum/eth-go/ethutil"
)
type EthereumApi struct {
pipe *ethpipe.JSPipe
}
type JsonArgs interface {
requirements() error
}
type BlockResponse struct {
JsonResponse
}
type GetBlockArgs struct {
BlockNumber int
Hash string
}
type ErrorResponse struct {
Error bool `json:"error"`
ErrorText string `json:"errorText"`
}
type JsonResponse interface {
}
type SuccessRes struct {
Error bool `json:"error"`
Result JsonResponse `json:"result"`
}
func NewSuccessRes(object JsonResponse) string {
e := SuccessRes{Error: false, Result: object}
res, err := json.Marshal(e)
if err != nil {
// This should never happen
panic("Creating json error response failed, help")
}
success := string(res)
return success
}
func NewErrorResponse(msg string) error {
e := ErrorResponse{Error: true, ErrorText: msg}
res, err := json.Marshal(e)
if err != nil {
// This should never happen
panic("Creating json error response failed, help")
}
newErr := errors.New(string(res))
return newErr
}
func (b *GetBlockArgs) requirements() error {
if b.BlockNumber == 0 && b.Hash == "" {
return NewErrorResponse("GetBlock requires either a block 'number' or a block 'hash' as argument")
}
return nil
}
func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *string) error {
err := args.requirements()
if err != nil {
return err
}
block := p.pipe.BlockByHash(args.Hash)
*reply = NewSuccessRes(block)
return nil
}
type NewTxArgs struct {
Sec string
Recipient string
Value string
Gas string
GasPrice string
Init string
Body string
}
type TxResponse struct {
Hash string
}
func (a *NewTxArgs) requirements() error {
if a.Recipient == "" {
return NewErrorResponse("Transact requires a 'recipient' address as argument")
}
if a.Value == "" {
return NewErrorResponse("Transact requires a 'value' as argument")
}
if a.Gas == "" {
return NewErrorResponse("Transact requires a 'gas' value as argument")
}
if a.GasPrice == "" {
return NewErrorResponse("Transact requires a 'gasprice' value as argument")
}
return nil
}
func (a *NewTxArgs) requirementsContract() error {
if a.Value == "" {
return NewErrorResponse("Create requires a 'value' as argument")
}
if a.Gas == "" {
return NewErrorResponse("Create requires a 'gas' value as argument")
}
if a.GasPrice == "" {
return NewErrorResponse("Create requires a 'gasprice' value as argument")
}
if a.Body == "" {
return NewErrorResponse("Create requires a 'body' value as argument")
}
return nil
}
func (p *EthereumApi) Transact(args *NewTxArgs, reply *string) error {
err := args.requirements()
if err != nil {
return err
}
result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
*reply = NewSuccessRes(result)
return nil
}
func (p *EthereumApi) Create(args *NewTxArgs, reply *string) error {
err := args.requirementsContract()
if err != nil {
return err
}
result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, "", args.Value, args.Gas, args.GasPrice, args.Body)
*reply = NewSuccessRes(result)
return nil
}
type PushTxArgs struct {
Tx string
}
func (a *PushTxArgs) requirementsPushTx() error {
if a.Tx == "" {
return NewErrorResponse("PushTx requires a 'tx' as argument")
}
return nil
}
func (p *EthereumApi) PushTx(args *PushTxArgs, reply *string) error {
err := args.requirementsPushTx()
if err != nil {
return err
}
result, _ := p.pipe.PushTx(args.Tx)
*reply = NewSuccessRes(result)
return nil
}
func (p *EthereumApi) GetKey(args interface{}, reply *string) error {
*reply = NewSuccessRes(p.pipe.Key())
return nil
}
type GetStorageArgs struct {
Address string
Key string
}
func (a *GetStorageArgs) requirements() error {
if a.Address == "" {
return NewErrorResponse("GetStorageAt requires an 'address' value as argument")
}
if a.Key == "" {
return NewErrorResponse("GetStorageAt requires an 'key' value as argument")
}
return nil
}
type GetStorageAtRes struct {
Key string `json:"key"`
Value string `json:"value"`
Address string `json:"address"`
}
func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *string) error {
err := args.requirements()
if err != nil {
return err
}
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
var hx string
if strings.Index(args.Key, "0x") == 0 {
hx = string([]byte(args.Key)[2:])
} else {
// Convert the incoming string (which is a bigint) into hex
i, _ := new(big.Int).SetString(args.Key, 10)
hx = ethutil.Bytes2Hex(i.Bytes())
}
logger.Debugf("GetStorageAt(%s, %s)\n", args.Address, hx)
value := state.Storage(ethutil.Hex2Bytes(hx))
*reply = NewSuccessRes(GetStorageAtRes{Address: args.Address, Key: args.Key, Value: value.Str()})
return nil
}
type GetTxCountArgs struct {
Address string `json:"address"`
}
type GetTxCountRes struct {
Nonce int `json:"nonce"`
}
func (a *GetTxCountArgs) requirements() error {
if a.Address == "" {
return NewErrorResponse("GetTxCountAt requires an 'address' value as argument")
}
return nil
}
type GetPeerCountRes struct {
PeerCount int `json:"peerCount"`
}
func (p *EthereumApi) GetPeerCount(args *interface{}, reply *string) error {
*reply = NewSuccessRes(GetPeerCountRes{PeerCount: p.pipe.PeerCount()})
return nil
}
type GetListeningRes struct {
IsListening bool `json:"isListening"`
}
func (p *EthereumApi) GetIsListening(args *interface{}, reply *string) error {
*reply = NewSuccessRes(GetListeningRes{IsListening: p.pipe.IsListening()})
return nil
}
type GetCoinbaseRes struct {
Coinbase string `json:"coinbase"`
}
func (p *EthereumApi) GetCoinbase(args *interface{}, reply *string) error {
*reply = NewSuccessRes(GetCoinbaseRes{Coinbase: p.pipe.CoinBase()})
return nil
}
type GetMiningRes struct {
IsMining bool `json:"isMining"`
}
func (p *EthereumApi) GetIsMining(args *interface{}, reply *string) error {
*reply = NewSuccessRes(GetMiningRes{IsMining: p.pipe.IsMining()})
return nil
}
func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *string) error {
err := args.requirements()
if err != nil {
return err
}
state := p.pipe.TxCountAt(args.Address)
*reply = NewSuccessRes(GetTxCountRes{Nonce: state})
return nil
}
type GetBalanceArgs struct {
Address string
}
func (a *GetBalanceArgs) requirements() error {
if a.Address == "" {
return NewErrorResponse("GetBalanceAt requires an 'address' value as argument")
}
return nil
}
type BalanceRes struct {
Balance string `json:"balance"`
Address string `json:"address"`
}
func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *string) error {
err := args.requirements()
if err != nil {
return err
}
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
*reply = NewSuccessRes(BalanceRes{Balance: state.Balance.String(), Address: args.Address})
return nil
}
type TestRes struct {
JsonResponse `json:"-"`
Answer int `json:"answer"`
}
func (p *EthereumApi) Test(args *GetBlockArgs, reply *string) error {
*reply = NewSuccessRes(TestRes{Answer: 15})
return nil
}

67
ethrpc/server.go
Unescape View File

@ -1,67 +0,0 @@
package ethrpc
import (
"fmt"
"net"
"net/rpc"
"net/rpc/jsonrpc"
"github.com/ethereum/eth-go/ethlog"
"github.com/ethereum/eth-go/ethpipe"
)
var logger = ethlog.NewLogger("JSON")
type JsonRpcServer struct {
quit chan bool
listener net.Listener
pipe *ethpipe.JSPipe
}
func (s *JsonRpcServer) exitHandler() {
out:
for {
select {
case <-s.quit:
s.listener.Close()
break out
}
}
logger.Infoln("Shutdown JSON-RPC server")
}
func (s *JsonRpcServer) Stop() {
close(s.quit)
}
func (s *JsonRpcServer) Start() {
logger.Infoln("Starting JSON-RPC server")
go s.exitHandler()
rpc.Register(&EthereumApi{pipe: s.pipe})
rpc.HandleHTTP()
for {
conn, err := s.listener.Accept()
if err != nil {
logger.Infoln("Error starting JSON-RPC:", err)
break
}
logger.Debugln("Incoming request.")
go jsonrpc.ServeConn(conn)
}
}
func NewJsonRpcServer(pipe *ethpipe.JSPipe, port int) (*JsonRpcServer, error) {
sport := fmt.Sprintf(":%d", port)
l, err := net.Listen("tcp", sport)
if err != nil {
return nil, err
}
return &JsonRpcServer{
listener: l,
quit: make(chan bool),
pipe: pipe,
}, nil
}

24
ethwire/messaging.go
Unescape View File

@ -33,8 +33,8 @@ const (
MsgGetPeersTy = 0x04 MsgGetPeersTy = 0x04
MsgPeersTy = 0x05 MsgPeersTy = 0x05
MsgStatusTy = 0x10 MsgStatusTy = 0x10
MsgGetTxsTy = 0x11 //MsgGetTxsTy = 0x11
MsgTxTy = 0x12 MsgTxTy = 0x12
MsgGetBlockHashesTy = 0x13 MsgGetBlockHashesTy = 0x13
MsgBlockHashesTy = 0x14 MsgBlockHashesTy = 0x14
@ -44,16 +44,16 @@ const (
) )
var msgTypeToString = map[MsgType]string{ var msgTypeToString = map[MsgType]string{
MsgHandshakeTy: "Handshake", MsgHandshakeTy: "Handshake",
MsgDiscTy: "Disconnect", MsgDiscTy: "Disconnect",
MsgPingTy: "Ping", MsgPingTy: "Ping",
MsgPongTy: "Pong", MsgPongTy: "Pong",
MsgGetPeersTy: "Get peers", MsgGetPeersTy: "Get peers",
MsgStatusTy: "Status", MsgStatusTy: "Status",
MsgPeersTy: "Peers", MsgPeersTy: "Peers",
MsgTxTy: "Transactions", MsgTxTy: "Transactions",
MsgBlockTy: "Blocks", MsgBlockTy: "Blocks",
MsgGetTxsTy: "Get Txs", //MsgGetTxsTy: "Get Txs",
MsgGetBlockHashesTy: "Get block hashes", MsgGetBlockHashesTy: "Get block hashes",
MsgBlockHashesTy: "Block hashes", MsgBlockHashesTy: "Block hashes",
MsgGetBlocksTy: "Get blocks", MsgGetBlocksTy: "Get blocks",

32
peer.go
Unescape View File

@ -322,7 +322,7 @@ out:
case msg := <-p.outputQueue: case msg := <-p.outputQueue:
if !p.statusKnown { if !p.statusKnown {
switch msg.Type { switch msg.Type {
case ethwire.MsgGetTxsTy, ethwire.MsgTxTy, ethwire.MsgGetBlockHashesTy, ethwire.MsgBlockHashesTy, ethwire.MsgGetBlocksTy, ethwire.MsgBlockTy: case ethwire.MsgTxTy, ethwire.MsgGetBlockHashesTy, ethwire.MsgBlockHashesTy, ethwire.MsgGetBlocksTy, ethwire.MsgBlockTy:
break skip break skip
} }
} }
@ -457,16 +457,18 @@ func (p *Peer) HandleInbound() {
// TMP // TMP
if p.statusKnown { if p.statusKnown {
switch msg.Type { switch msg.Type {
case ethwire.MsgGetTxsTy: /*
// Get the current transactions of the pool case ethwire.MsgGetTxsTy:
txs := p.ethereum.TxPool().CurrentTransactions() // Get the current transactions of the pool
// Get the RlpData values from the txs txs := p.ethereum.TxPool().CurrentTransactions()
txsInterface := make([]interface{}, len(txs)) // Get the RlpData values from the txs
for i, tx := range txs { txsInterface := make([]interface{}, len(txs))
txsInterface[i] = tx.RlpData() for i, tx := range txs {
} txsInterface[i] = tx.RlpData()
// Broadcast it back to the peer }
p.QueueMessage(ethwire.NewMessage(ethwire.MsgTxTy, txsInterface)) // Broadcast it back to the peer
p.QueueMessage(ethwire.NewMessage(ethwire.MsgTxTy, txsInterface))
*/
case ethwire.MsgGetBlockHashesTy: case ethwire.MsgGetBlockHashesTy:
if msg.Data.Len() < 2 { if msg.Data.Len() < 2 {
@ -687,10 +689,10 @@ func (self *Peer) handleStatus(msg *ethwire.Msg) {
var ( var (
//protoVersion = c.Get(0).Uint() //protoVersion = c.Get(0).Uint()
netVersion = c.Get(0).Uint() netVersion = c.Get(1).Uint()
td = c.Get(1).BigInt() td = c.Get(2).BigInt()
bestHash = c.Get(2).Bytes() bestHash = c.Get(3).Bytes()
genesis = c.Get(3).Bytes() genesis = c.Get(4).Bytes()
) )
if bytes.Compare(self.ethereum.ChainManager().Genesis().Hash(), genesis) != 0 { if bytes.Compare(self.ethereum.ChainManager().Genesis().Hash(), genesis) != 0 {

Write Preview
Loading…
Cancel
Save