ethwire => wire

block_pool.go

@@ -11,8 +11,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/wire"
 )
 
 var poollogger = logger.NewLogger("BPOOL")
@@ -103,7 +103,7 @@ func (self *BlockPool) FetchHashes(peer *Peer) bool {
 
 			const amount = 256
 			peerlogger.Debugf("Fetching hashes (%d) %x...\n", amount, peer.lastReceivedHash[0:4])
-			peer.QueueMessage(ethwire.NewMessage(ethwire.MsgGetBlockHashesTy, []interface{}{peer.lastReceivedHash, uint32(amount)}))
+			peer.QueueMessage(wire.NewMessage(wire.MsgGetBlockHashesTy, []interface{}{peer.lastReceivedHash, uint32(amount)}))
 		}
 
 		return true
@@ -150,7 +150,7 @@ func (self *BlockPool) addBlock(b *chain.Block, peer *Peer, newBlock bool) {
 			fmt.Println("3.", !self.fetchingHashes)
 			if !self.eth.ChainManager().HasBlock(b.PrevHash) && self.pool[string(b.PrevHash)] == nil && !self.fetchingHashes {
 				poollogger.Infof("Unknown chain, requesting (%x...)\n", b.PrevHash[0:4])
-				peer.QueueMessage(ethwire.NewMessage(ethwire.MsgGetBlockHashesTy, []interface{}{b.Hash(), uint32(256)}))
+				peer.QueueMessage(wire.NewMessage(wire.MsgGetBlockHashesTy, []interface{}{b.Hash(), uint32(256)}))
 			}
 		}
 	} else if self.pool[hash] != nil {

chain/state_manager.go

@@ -11,10 +11,10 @@ import (
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/wire"
 )
 
 var statelogger = logger.NewLogger("BLOCK")
@@ -35,13 +35,13 @@ type EthManager interface {
 	StateManager() *StateManager
 	ChainManager() *ChainManager
 	TxPool() *TxPool
-	Broadcast(msgType ethwire.MsgType, data []interface{})
+	Broadcast(msgType wire.MsgType, data []interface{})
 	PeerCount() int
 	IsMining() bool
 	IsListening() bool
 	Peers() *list.List
 	KeyManager() *crypto.KeyManager
-	ClientIdentity() ethwire.ClientIdentity
+	ClientIdentity() wire.ClientIdentity
 	Db() ethutil.Database
 	EventMux() *event.TypeMux
 }

chain/transaction_pool.go

@@ -7,9 +7,9 @@ import (
 	"math/big"
 	"sync"
 
-	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/wire"
 )
 
 var txplogger = logger.NewLogger("TXP")
@@ -93,7 +93,7 @@ func (pool *TxPool) addTransaction(tx *Transaction) {
 	pool.pool.PushBack(tx)
 
 	// Broadcast the transaction to the rest of the peers
-	pool.Ethereum.Broadcast(ethwire.MsgTxTy, []interface{}{tx.RlpData()})
+	pool.Ethereum.Broadcast(wire.MsgTxTy, []interface{}{tx.RlpData()})
 }
 
 func (pool *TxPool) ValidateTransaction(tx *Transaction) error {

cmd/mist/gui.go

@@ -35,8 +35,8 @@ import (
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/ethminer"
 	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/wire"
 	"github.com/ethereum/go-ethereum/xeth"
 	"gopkg.in/qml.v1"
 )
@@ -87,7 +87,7 @@ type Gui struct {
 	pipe *xeth.JSXEth
 
 	Session        string
-	clientIdentity *ethwire.SimpleClientIdentity
+	clientIdentity *wire.SimpleClientIdentity
 	config         *ethutil.ConfigManager
 
 	plugins map[string]plugin
@@ -97,7 +97,7 @@ type Gui struct {
 }
 
 // Create GUI, but doesn't start it
-func NewWindow(ethereum *eth.Ethereum, config *ethutil.ConfigManager, clientIdentity *ethwire.SimpleClientIdentity, session string, logLevel int) *Gui {
+func NewWindow(ethereum *eth.Ethereum, config *ethutil.ConfigManager, clientIdentity *wire.SimpleClientIdentity, session string, logLevel int) *Gui {
 	db, err := ethdb.NewLDBDatabase("tx_database")
 	if err != nil {
 		panic(err)

cmd/utils/cmd.go

@@ -18,9 +18,9 @@ import (
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/ethminer"
 	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/ethereum/go-ethereum/wire"
 	"github.com/ethereum/go-ethereum/xeth"
 )
 
@@ -144,12 +144,12 @@ func NewDatabase() ethutil.Database {
 	return db
 }
 
-func NewClientIdentity(clientIdentifier, version, customIdentifier string) *ethwire.SimpleClientIdentity {
+func NewClientIdentity(clientIdentifier, version, customIdentifier string) *wire.SimpleClientIdentity {
 	clilogger.Infoln("identity created")
-	return ethwire.NewSimpleClientIdentity(clientIdentifier, version, customIdentifier)
+	return wire.NewSimpleClientIdentity(clientIdentifier, version, customIdentifier)
 }
 
-func NewEthereum(db ethutil.Database, clientIdentity ethwire.ClientIdentity, keyManager *crypto.KeyManager, usePnp bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
+func NewEthereum(db ethutil.Database, clientIdentity wire.ClientIdentity, keyManager *crypto.KeyManager, usePnp bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
 	ethereum, err := eth.New(db, clientIdentity, keyManager, eth.CapDefault, usePnp)
 	if err != nil {
 		clilogger.Fatalln("eth start err:", err)

ethereum.go

@@ -17,11 +17,11 @@ import (
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/wire"
 )
 
 const (
@@ -88,7 +88,7 @@ type Ethereum struct {
 
 	keyManager *crypto.KeyManager
 
-	clientIdentity ethwire.ClientIdentity
+	clientIdentity wire.ClientIdentity
 
 	isUpToDate bool
 
@@ -97,7 +97,7 @@ type Ethereum struct {
 	filters  map[int]*chain.Filter
 }
 
-func New(db ethutil.Database, clientIdentity ethwire.ClientIdentity, keyManager *crypto.KeyManager, caps Caps, usePnp bool) (*Ethereum, error) {
+func New(db ethutil.Database, clientIdentity wire.ClientIdentity, keyManager *crypto.KeyManager, caps Caps, usePnp bool) (*Ethereum, error) {
 	var err error
 	var nat NAT
 
@@ -142,7 +142,7 @@ func (s *Ethereum) KeyManager() *crypto.KeyManager {
 	return s.keyManager
 }
 
-func (s *Ethereum) ClientIdentity() ethwire.ClientIdentity {
+func (s *Ethereum) ClientIdentity() wire.ClientIdentity {
 	return s.clientIdentity
 }
 
@@ -338,12 +338,12 @@ func (s *Ethereum) InOutPeers() []*Peer {
 	return inboundPeers[:length]
 }
 
-func (s *Ethereum) Broadcast(msgType ethwire.MsgType, data []interface{}) {
-	msg := ethwire.NewMessage(msgType, data)
+func (s *Ethereum) Broadcast(msgType wire.MsgType, data []interface{}) {
+	msg := wire.NewMessage(msgType, data)
 	s.BroadcastMsg(msg)
 }
 
-func (s *Ethereum) BroadcastMsg(msg *ethwire.Msg) {
+func (s *Ethereum) BroadcastMsg(msg *wire.Msg) {
 	eachPeer(s.peers, func(p *Peer, e *list.Element) {
 		p.QueueMessage(msg)
 	})

ethminer/miner.go

-package ethminer
-
-import (
-	"bytes"
-	"sort"
-
-	"github.com/ethereum/go-ethereum/chain"
-	"github.com/ethereum/go-ethereum/ethwire"
-	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/logger"
-)
-
-var minerlogger = logger.NewLogger("MINER")
-
-type Miner struct {
-	pow      chain.PoW
-	ethereum chain.EthManager
-	coinbase []byte
-	txs      chain.Transactions
-	uncles   []*chain.Block
-	block    *chain.Block
-
-	events      event.Subscription
-	powQuitChan chan struct{}
-	powDone     chan struct{}
-
-	turbo bool
-}
-
-const (
-	Started = iota
-	Stopped
-)
-
-type Event struct {
-	Type  int // Started || Stopped
-	Miner *Miner
-}
-
-func (self *Miner) GetPow() chain.PoW {
-	return self.pow
-}
-
-func NewDefaultMiner(coinbase []byte, ethereum chain.EthManager) *Miner {
-	miner := Miner{
-		pow:      &chain.EasyPow{},
-		ethereum: ethereum,
-		coinbase: coinbase,
-	}
-
-	return &miner
-}
-
-func (self *Miner) ToggleTurbo() {
-	self.turbo = !self.turbo
-
-	self.pow.Turbo(self.turbo)
-}
-
-func (miner *Miner) Start() {
-
-	// Insert initial TXs in our little miner 'pool'
-	miner.txs = miner.ethereum.TxPool().Flush()
-	miner.block = miner.ethereum.ChainManager().NewBlock(miner.coinbase)
-
-	mux := miner.ethereum.EventMux()
-	miner.events = mux.Subscribe(chain.NewBlockEvent{}, chain.TxPreEvent{})
-
-	// Prepare inital block
-	//miner.ethereum.StateManager().Prepare(miner.block.State(), miner.block.State())
-	go miner.listener()
-
-	minerlogger.Infoln("Started")
-	mux.Post(Event{Started, miner})
-}
-
-func (miner *Miner) Stop() {
-	minerlogger.Infoln("Stopping...")
-	miner.events.Unsubscribe()
-	miner.ethereum.EventMux().Post(Event{Stopped, miner})
-}
-
-func (miner *Miner) listener() {
-	miner.startMining()
-
-	for {
-		select {
-		case event := <-miner.events.Chan():
-			switch event := event.(type) {
-			case chain.NewBlockEvent:
-				miner.stopMining()
-
-				block := event.Block
-				//minerlogger.Infoln("Got new block via Reactor")
-				if bytes.Compare(miner.ethereum.ChainManager().CurrentBlock.Hash(), block.Hash()) == 0 {
-					// TODO: Perhaps continue mining to get some uncle rewards
-					//minerlogger.Infoln("New top block found resetting state")
-
-					// Filter out which Transactions we have that were not in this block
-					var newtxs []*chain.Transaction
-					for _, tx := range miner.txs {
-						found := false
-						for _, othertx := range block.Transactions() {
-							if bytes.Compare(tx.Hash(), othertx.Hash()) == 0 {
-								found = true
-							}
-						}
-						if found == false {
-							newtxs = append(newtxs, tx)
-						}
-					}
-					miner.txs = newtxs
-				} else {
-					if bytes.Compare(block.PrevHash, miner.ethereum.ChainManager().CurrentBlock.PrevHash) == 0 {
-						minerlogger.Infoln("Adding uncle block")
-						miner.uncles = append(miner.uncles, block)
-					}
-				}
-				miner.startMining()
-
-			case chain.TxPreEvent:
-				miner.stopMining()
-
-				found := false
-				for _, ctx := range miner.txs {
-					if found = bytes.Compare(ctx.Hash(), event.Tx.Hash()) == 0; found {
-						break
-					}
-
-					miner.startMining()
-				}
-				if found == false {
-					// Undo all previous commits
-					miner.block.Undo()
-					// Apply new transactions
-					miner.txs = append(miner.txs, event.Tx)
-				}
-			}
-
-		case <-miner.powDone:
-			miner.startMining()
-		}
-	}
-}
-
-func (miner *Miner) startMining() {
-	if miner.powDone == nil {
-		miner.powDone = make(chan struct{})
-	}
-	miner.powQuitChan = make(chan struct{})
-	go miner.mineNewBlock()
-}
-
-func (miner *Miner) stopMining() {
-	println("stop mining")
-	_, isopen := <-miner.powQuitChan
-	if isopen {
-		close(miner.powQuitChan)
-	}
-	//<-miner.powDone
-}
-
-func (self *Miner) mineNewBlock() {
-	stateManager := self.ethereum.StateManager()
-
-	self.block = self.ethereum.ChainManager().NewBlock(self.coinbase)
-
-	// Apply uncles
-	if len(self.uncles) > 0 {
-		self.block.SetUncles(self.uncles)
-	}
-
-	// Sort the transactions by nonce in case of odd network propagation
-	sort.Sort(chain.TxByNonce{self.txs})
-
-	// Accumulate all valid transactions and apply them to the new state
-	// Error may be ignored. It's not important during mining
-	parent := self.ethereum.ChainManager().GetBlock(self.block.PrevHash)
-	coinbase := self.block.State().GetOrNewStateObject(self.block.Coinbase)
-	coinbase.SetGasPool(self.block.CalcGasLimit(parent))
-	receipts, txs, unhandledTxs, erroneous, err := stateManager.ProcessTransactions(coinbase, self.block.State(), self.block, self.block, self.txs)
-	if err != nil {
-		minerlogger.Debugln(err)
-	}
-	self.ethereum.TxPool().RemoveSet(erroneous)
-	self.txs = append(txs, unhandledTxs...)
-
-	self.block.SetTransactions(txs)
-	self.block.SetReceipts(receipts)
-
-	// Accumulate the rewards included for this block
-	stateManager.AccumelateRewards(self.block.State(), self.block, parent)
-
-	self.block.State().Update()
-
-	minerlogger.Infof("Mining on block. Includes %v transactions", len(self.txs))
-
-	// Find a valid nonce
-	nonce := self.pow.Search(self.block, self.powQuitChan)
-	if nonce != nil {
-		self.block.Nonce = nonce
-		err := self.ethereum.StateManager().Process(self.block)
-		if err != nil {
-			minerlogger.Infoln(err)
-		} else {
-			self.ethereum.Broadcast(ethwire.MsgBlockTy, []interface{}{self.block.Value().Val})
-			minerlogger.Infof("🔨  Mined block %x\n", self.block.Hash())
-			minerlogger.Infoln(self.block)
-			// Gather the new batch of transactions currently in the tx pool
-			self.txs = self.ethereum.TxPool().CurrentTransactions()
-			self.ethereum.EventMux().Post(chain.NewBlockEvent{self.block})
-		}
-
-		// Continue mining on the next block
-		self.startMining()
-	}
-}

peer.go

@@ -14,8 +14,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/wire"
 )
 
 var peerlogger = logger.NewLogger("PEER")
@@ -112,7 +112,7 @@ type Peer struct {
 	// Net connection
 	conn net.Conn
 	// Output queue which is used to communicate and handle messages
-	outputQueue chan *ethwire.Msg
+	outputQueue chan *wire.Msg
 	// Quit channel
 	quit chan bool
 	// Determines whether it's an inbound or outbound peer
@@ -164,7 +164,7 @@ func NewPeer(conn net.Conn, ethereum *Ethereum, inbound bool) *Peer {
 	pubkey := ethereum.KeyManager().PublicKey()[1:]
 
 	return &Peer{
-		outputQueue:        make(chan *ethwire.Msg, outputBufferSize),
+		outputQueue:        make(chan *wire.Msg, outputBufferSize),
 		quit:               make(chan bool),
 		ethereum:           ethereum,
 		conn:               conn,
@@ -184,7 +184,7 @@ func NewPeer(conn net.Conn, ethereum *Ethereum, inbound bool) *Peer {
 
 func NewOutboundPeer(addr string, ethereum *Ethereum, caps Caps) *Peer {
 	p := &Peer{
-		outputQueue:        make(chan *ethwire.Msg, outputBufferSize),
+		outputQueue:        make(chan *wire.Msg, outputBufferSize),
 		quit:               make(chan bool),
 		ethereum:           ethereum,
 		inbound:            false,
@@ -266,14 +266,14 @@ func (p *Peer) SetVersion(version string) {
 }
 
 // Outputs any RLP encoded data to the peer
-func (p *Peer) QueueMessage(msg *ethwire.Msg) {
+func (p *Peer) QueueMessage(msg *wire.Msg) {
 	if atomic.LoadInt32(&p.connected) != 1 {
 		return
 	}
 	p.outputQueue <- msg
 }
 
-func (p *Peer) writeMessage(msg *ethwire.Msg) {
+func (p *Peer) writeMessage(msg *wire.Msg) {
 	// Ignore the write if we're not connected
 	if atomic.LoadInt32(&p.connected) != 1 {
 		return
@@ -281,7 +281,7 @@ func (p *Peer) writeMessage(msg *ethwire.Msg) {
 
 	if !p.versionKnown {
 		switch msg.Type {
-		case ethwire.MsgHandshakeTy: // Ok
+		case wire.MsgHandshakeTy: // Ok
 		default: // Anything but ack is allowed
 			return
 		}
@@ -289,7 +289,7 @@ func (p *Peer) writeMessage(msg *ethwire.Msg) {
 		/*
 			if !p.statusKnown {
 				switch msg.Type {
-				case ethwire.MsgStatusTy: // Ok
+				case wire.MsgStatusTy: // Ok
 				default: // Anything but ack is allowed
 					return
 				}
@@ -299,7 +299,7 @@ func (p *Peer) writeMessage(msg *ethwire.Msg) {
 
 	peerlogger.DebugDetailf("(%v) <= %v\n", p.conn.RemoteAddr(), formatMessage(msg))
 
-	err := ethwire.WriteMessage(p.conn, msg)
+	err := wire.WriteMessage(p.conn, msg)
 	if err != nil {
 		peerlogger.Debugln(" Can't send message:", err)
 		// Stop the client if there was an error writing to it
@@ -322,7 +322,7 @@ out:
 		case msg := <-p.outputQueue:
 			if !p.statusKnown {
 				switch msg.Type {
-				case ethwire.MsgTxTy, ethwire.MsgGetBlockHashesTy, ethwire.MsgBlockHashesTy, ethwire.MsgGetBlocksTy, ethwire.MsgBlockTy:
+				case wire.MsgTxTy, wire.MsgGetBlockHashesTy, wire.MsgBlockHashesTy, wire.MsgGetBlocksTy, wire.MsgBlockTy:
 					break skip
 				}
 			}
@@ -340,13 +340,13 @@ out:
 					return
 				}
 			*/
-			p.writeMessage(ethwire.NewMessage(ethwire.MsgPingTy, ""))
+			p.writeMessage(wire.NewMessage(wire.MsgPingTy, ""))
 			p.pingStartTime = time.Now()
 
 		// Service timer takes care of peer broadcasting, transaction
 		// posting or block posting
 		case <-serviceTimer.C:
-			p.QueueMessage(ethwire.NewMessage(ethwire.MsgGetPeersTy, ""))
+			p.QueueMessage(wire.NewMessage(wire.MsgGetPeersTy, ""))
 
 		case <-p.quit:
 			// Break out of the for loop if a quit message is posted
@@ -366,7 +366,7 @@ clean:
 	}
 }
 
-func formatMessage(msg *ethwire.Msg) (ret string) {
+func formatMessage(msg *wire.Msg) (ret string) {
 	ret = fmt.Sprintf("%v %v", msg.Type, msg.Data)
 
 	/*
@@ -375,12 +375,12 @@ func formatMessage(msg *ethwire.Msg) (ret string) {
 	*/
 	/*
 		switch msg.Type {
-		case ethwire.MsgPeersTy:
+		case wire.MsgPeersTy:
 			ret += fmt.Sprintf("(%d entries)", msg.Data.Len())
-		case ethwire.MsgBlockTy:
+		case wire.MsgBlockTy:
 			b1, b2 := chain.NewBlockFromRlpValue(msg.Data.Get(0)), ethchain.NewBlockFromRlpValue(msg.Data.Get(msg.Data.Len()-1))
 			ret += fmt.Sprintf("(%d entries) %x - %x", msg.Data.Len(), b1.Hash()[0:4], b2.Hash()[0:4])
-		case ethwire.MsgBlockHashesTy:
+		case wire.MsgBlockHashesTy:
 			h1, h2 := msg.Data.Get(0).Bytes(), msg.Data.Get(msg.Data.Len()-1).Bytes()
 			ret += fmt.Sprintf("(%d entries) %x - %x", msg.Data.Len(), h1, h2)
 		}
@@ -396,7 +396,7 @@ func (p *Peer) HandleInbound() {
 		// HMM?
 		time.Sleep(50 * time.Millisecond)
 		// Wait for a message from the peer
-		msgs, err := ethwire.ReadMessages(p.conn)
+		msgs, err := wire.ReadMessages(p.conn)
 		if err != nil {
 			peerlogger.Debugln(err)
 		}
@@ -404,27 +404,27 @@ func (p *Peer) HandleInbound() {
 			peerlogger.DebugDetailf("(%v) => %v\n", p.conn.RemoteAddr(), formatMessage(msg))
 
 			switch msg.Type {
-			case ethwire.MsgHandshakeTy:
+			case wire.MsgHandshakeTy:
 				// Version message
 				p.handleHandshake(msg)
 
 				//if p.caps.IsCap(CapPeerDiscTy) {
-				p.QueueMessage(ethwire.NewMessage(ethwire.MsgGetPeersTy, ""))
+				p.QueueMessage(wire.NewMessage(wire.MsgGetPeersTy, ""))
 				//}
 
-			case ethwire.MsgDiscTy:
+			case wire.MsgDiscTy:
 				p.Stop()
 				peerlogger.Infoln("Disconnect peer: ", DiscReason(msg.Data.Get(0).Uint()))
-			case ethwire.MsgPingTy:
+			case wire.MsgPingTy:
 				// Respond back with pong
-				p.QueueMessage(ethwire.NewMessage(ethwire.MsgPongTy, ""))
-			case ethwire.MsgPongTy:
+				p.QueueMessage(wire.NewMessage(wire.MsgPongTy, ""))
+			case wire.MsgPongTy:
 				// If we received a pong back from a peer we set the
 				// last pong so the peer handler knows this peer is still
 				// active.
 				p.lastPong = time.Now().Unix()
 				p.pingTime = time.Since(p.pingStartTime)
-			case ethwire.MsgTxTy:
+			case wire.MsgTxTy:
 				// If the message was a transaction queue the transaction
 				// in the TxPool where it will undergo validation and
 				// processing when a new block is found
@@ -432,10 +432,10 @@ func (p *Peer) HandleInbound() {
 					tx := chain.NewTransactionFromValue(msg.Data.Get(i))
 					p.ethereum.TxPool().QueueTransaction(tx)
 				}
-			case ethwire.MsgGetPeersTy:
+			case wire.MsgGetPeersTy:
 				// Peer asked for list of connected peers
 				//p.pushPeers()
-			case ethwire.MsgPeersTy:
+			case wire.MsgPeersTy:
 				// Received a list of peers (probably because MsgGetPeersTy was send)
 				data := msg.Data
 				// Create new list of possible peers for the ethereum to process
@@ -449,7 +449,7 @@ func (p *Peer) HandleInbound() {
 				// Connect to the list of peers
 				p.ethereum.ProcessPeerList(peers)
 
-			case ethwire.MsgStatusTy:
+			case wire.MsgStatusTy:
 				// Handle peer's status msg
 				p.handleStatus(msg)
 			}
@@ -458,7 +458,7 @@ func (p *Peer) HandleInbound() {
 			if p.statusKnown {
 				switch msg.Type {
 				/*
-					case ethwire.MsgGetTxsTy:
+					case wire.MsgGetTxsTy:
 						// Get the current transactions of the pool
 						txs := p.ethereum.TxPool().CurrentTransactions()
 						// Get the RlpData values from the txs
@@ -467,10 +467,10 @@ func (p *Peer) HandleInbound() {
 							txsInterface[i] = tx.RlpData()
 						}
 						// Broadcast it back to the peer
-						p.QueueMessage(ethwire.NewMessage(ethwire.MsgTxTy, txsInterface))
+						p.QueueMessage(wire.NewMessage(wire.MsgTxTy, txsInterface))
 				*/
 
-				case ethwire.MsgGetBlockHashesTy:
+				case wire.MsgGetBlockHashesTy:
 					if msg.Data.Len() < 2 {
 						peerlogger.Debugln("err: argument length invalid ", msg.Data.Len())
 					}
@@ -480,9 +480,9 @@ func (p *Peer) HandleInbound() {
 
 					hashes := p.ethereum.ChainManager().GetChainHashesFromHash(hash, amount)
 
-					p.QueueMessage(ethwire.NewMessage(ethwire.MsgBlockHashesTy, ethutil.ByteSliceToInterface(hashes)))
+					p.QueueMessage(wire.NewMessage(wire.MsgBlockHashesTy, ethutil.ByteSliceToInterface(hashes)))
 
-				case ethwire.MsgGetBlocksTy:
+				case wire.MsgGetBlocksTy:
 					// Limit to max 300 blocks
 					max := int(math.Min(float64(msg.Data.Len()), 300.0))
 					var blocks []interface{}
@@ -495,9 +495,9 @@ func (p *Peer) HandleInbound() {
 						}
 					}
 
-					p.QueueMessage(ethwire.NewMessage(ethwire.MsgBlockTy, blocks))
+					p.QueueMessage(wire.NewMessage(wire.MsgBlockTy, blocks))
 
-				case ethwire.MsgBlockHashesTy:
+				case wire.MsgBlockHashesTy:
 					p.catchingUp = true
 
 					blockPool := p.ethereum.blockPool
@@ -528,7 +528,7 @@ func (p *Peer) HandleInbound() {
 						p.doneFetchingHashes = true
 					}
 
-				case ethwire.MsgBlockTy:
+				case wire.MsgBlockTy:
 					p.catchingUp = true
 
 					blockPool := p.ethereum.blockPool
@@ -540,7 +540,7 @@ func (p *Peer) HandleInbound() {
 
 						p.lastBlockReceived = time.Now()
 					}
-				case ethwire.MsgNewBlockTy:
+				case wire.MsgNewBlockTy:
 					var (
 						blockPool = p.ethereum.blockPool
 						block     = chain.NewBlockFromRlpValue(msg.Data.Get(0))
@@ -563,7 +563,7 @@ func (self *Peer) FetchBlocks(hashes [][]byte) {
 	if len(hashes) > 0 {
 		peerlogger.Debugf("Fetching blocks (%d)\n", len(hashes))
 
-		self.QueueMessage(ethwire.NewMessage(ethwire.MsgGetBlocksTy, ethutil.ByteSliceToInterface(hashes)))
+		self.QueueMessage(wire.NewMessage(wire.MsgGetBlocksTy, ethutil.ByteSliceToInterface(hashes)))
 	}
 }
 
@@ -629,7 +629,7 @@ func (p *Peer) Start() {
 
 	// Wait a few seconds for startup and then ask for an initial ping
 	time.Sleep(2 * time.Second)
-	p.writeMessage(ethwire.NewMessage(ethwire.MsgPingTy, ""))
+	p.writeMessage(wire.NewMessage(wire.MsgPingTy, ""))
 	p.pingStartTime = time.Now()
 
 }
@@ -648,12 +648,12 @@ func (p *Peer) StopWithReason(reason DiscReason) {
 
 	close(p.quit)
 	if atomic.LoadInt32(&p.connected) != 0 {
-		p.writeMessage(ethwire.NewMessage(ethwire.MsgDiscTy, reason))
+		p.writeMessage(wire.NewMessage(wire.MsgDiscTy, reason))
 		p.conn.Close()
 	}
 }
 
-func (p *Peer) peersMessage() *ethwire.Msg {
+func (p *Peer) peersMessage() *wire.Msg {
 	outPeers := make([]interface{}, len(p.ethereum.InOutPeers()))
 	// Serialise each peer
 	for i, peer := range p.ethereum.InOutPeers() {
@@ -664,7 +664,7 @@ func (p *Peer) peersMessage() *ethwire.Msg {
 	}
 
 	// Return the message to the peer with the known list of connected clients
-	return ethwire.NewMessage(ethwire.MsgPeersTy, outPeers)
+	return wire.NewMessage(wire.MsgPeersTy, outPeers)
 }
 
 // Pushes the list of outbound peers to the client when requested
@@ -673,7 +673,7 @@ func (p *Peer) pushPeers() {
 }
 
 func (self *Peer) pushStatus() {
-	msg := ethwire.NewMessage(ethwire.MsgStatusTy, []interface{}{
+	msg := wire.NewMessage(wire.MsgStatusTy, []interface{}{
 		uint32(ProtocolVersion),
 		uint32(NetVersion),
 		self.ethereum.ChainManager().TD,
@@ -684,7 +684,7 @@ func (self *Peer) pushStatus() {
 	self.QueueMessage(msg)
 }
 
-func (self *Peer) handleStatus(msg *ethwire.Msg) {
+func (self *Peer) handleStatus(msg *wire.Msg) {
 	c := msg.Data
 
 	var (
@@ -729,7 +729,7 @@ func (self *Peer) handleStatus(msg *ethwire.Msg) {
 
 func (p *Peer) pushHandshake() error {
 	pubkey := p.ethereum.KeyManager().PublicKey()
-	msg := ethwire.NewMessage(ethwire.MsgHandshakeTy, []interface{}{
+	msg := wire.NewMessage(wire.MsgHandshakeTy, []interface{}{
 		P2PVersion, []byte(p.version), []interface{}{[]interface{}{"eth", ProtocolVersion}}, p.port, pubkey[1:],
 	})
 
@@ -738,7 +738,7 @@ func (p *Peer) pushHandshake() error {
 	return nil
 }
 
-func (p *Peer) handleHandshake(msg *ethwire.Msg) {
+func (p *Peer) handleHandshake(msg *wire.Msg) {
 	c := msg.Data
 
 	var (

ethwire/client_identity.go → wire/client_identity.go

-package ethwire
+package wire
 
 import (
 	"fmt"

ethwire/client_identity_test.go → wire/client_identity_test.go

-package ethwire
+package wire
 
 import (
 	"fmt"

ethwire/messages2.go → wire/messages2.go

-package ethwire
+package wire
 
 import (
 	"bytes"
@@ -113,7 +113,7 @@ func (self *Connection) readMessages() (err error) {
 	// The recovering function in case anything goes horribly wrong
 	defer func() {
 		if r := recover(); r != nil {
-			err = fmt.Errorf("ethwire.ReadMessage error: %v", r)
+			err = fmt.Errorf("wire.ReadMessage error: %v", r)
 		}
 	}()
 

ethwire/messaging.go → wire/messaging.go

-// Package ethwire provides low level access to the Ethereum network and allows
+// Package wire provides low level access to the Ethereum network and allows
 // you to broadcast data over the network.
-package ethwire
+package wire
 
 import (
 	"bytes"
@@ -85,7 +85,7 @@ func ReadMessages(conn net.Conn) (msgs []*Msg, err error) {
 	// The recovering function in case anything goes horribly wrong
 	defer func() {
 		if r := recover(); r != nil {
-			err = fmt.Errorf("ethwire.ReadMessage error: %v", r)
+			err = fmt.Errorf("wire.ReadMessage error: %v", r)
 		}
 	}()