change all modified calls to ethtrie, ethutil and ethcrypto functions

2 files changed, 35 insertions, 39 deletions

diff --git a/ethpub/pub.go b/ethpub/pub.go
index 1bc9e0ce7..cd30d0260 100644
--- a/ethpub/pub.go
+++ b/ethpub/pub.go
@@ -2,9 +2,9 @@ package ethpub
 
 import (
 	"bytes"
-	"encoding/hex"
 	"encoding/json"
 	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethcrypto"
 	"github.com/ethereum/eth-go/ethlog"
 	"github.com/ethereum/eth-go/ethutil"
 	"math/big"
@@ -19,6 +19,7 @@ type PEthereum struct {
 	stateManager *ethchain.StateManager
 	blockChain   *ethchain.BlockChain
 	txPool       *ethchain.TxPool
+	keyManager   *ethcrypto.KeyManager
 }
 
 func NewPEthereum(manager ethchain.EthManager) *PEthereum {
@@ -27,24 +28,23 @@ func NewPEthereum(manager ethchain.EthManager) *PEthereum {
 		manager.StateManager(),
 		manager.BlockChain(),
 		manager.TxPool(),
+		manager.KeyManager(),
 	}
 }
 
 func (lib *PEthereum) GetBlock(hexHash string) *PBlock {
-	hash := ethutil.FromHex(hexHash)
+	hash := ethutil.Hex2Bytes(hexHash)
 	block := lib.blockChain.GetBlock(hash)
 
 	return NewPBlock(block)
 }
 
 func (lib *PEthereum) GetKey() *PKey {
-	keyPair := ethutil.GetKeyRing().Get(0)
-
-	return NewPKey(keyPair)
+	return NewPKey(lib.keyManager.KeyPair())
 }
 
 func (lib *PEthereum) GetStateObject(address string) *PStateObject {
-	stateObject := lib.stateManager.CurrentState().GetStateObject(ethutil.FromHex(address))
+	stateObject := lib.stateManager.CurrentState().GetStateObject(ethutil.Hex2Bytes(address))
 	if stateObject != nil {
 		return NewPStateObject(stateObject)
 	}
@@ -79,17 +79,13 @@ func (lib *PEthereum) GetIsListening() bool {
 }
 
 func (lib *PEthereum) GetCoinBase() string {
-	data, _ := ethutil.Config.Db.Get([]byte("KeyRing"))
-	keyRing := ethutil.NewValueFromBytes(data)
-	key := keyRing.Get(0).Bytes()
-
-	return lib.SecretToAddress(hex.EncodeToString(key))
+	return ethutil.Bytes2Hex(lib.keyManager.Address())
 }
 
 func (lib *PEthereum) GetTransactionsFor(address string, asJson bool) interface{} {
 	sBlk := lib.manager.BlockChain().LastBlockHash
 	blk := lib.manager.BlockChain().GetBlock(sBlk)
-	addr := []byte(ethutil.FromHex(address))
+	addr := []byte(ethutil.Hex2Bytes(address))
 
 	var txs []*PTx
 
@@ -129,12 +125,12 @@ func (lib *PEthereum) IsContract(address string) bool {
 }
 
 func (lib *PEthereum) SecretToAddress(key string) string {
-	pair, err := ethutil.NewKeyPairFromSec(ethutil.FromHex(key))
+	pair, err := ethcrypto.NewKeyPairFromSec(ethutil.Hex2Bytes(key))
 	if err != nil {
 		return ""
 	}
 
-	return ethutil.Hex(pair.Address())
+	return ethutil.Bytes2Hex(pair.Address())
 }
 
 func (lib *PEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) (*PReceipt, error) {
@@ -145,7 +141,7 @@ func (lib *PEthereum) Create(key, valueStr, gasStr, gasPriceStr, script string)
 	return lib.createTx(key, "", valueStr, gasStr, gasPriceStr, script)
 }
 
-var namereg = ethutil.FromHex("bb5f186604d057c1c5240ca2ae0f6430138ac010")
+var namereg = ethutil.Hex2Bytes("bb5f186604d057c1c5240ca2ae0f6430138ac010")
 
 func GetAddressFromNameReg(stateManager *ethchain.StateManager, name string) []byte {
 	recp := new(big.Int).SetBytes([]byte(name))
@@ -169,16 +165,16 @@ func (lib *PEthereum) createTx(key, recipient, valueStr, gasStr, gasPriceStr, sc
 		if len(addr) > 0 {
 			hash = addr
 		} else {
-			hash = ethutil.FromHex(recipient)
+			hash = ethutil.Hex2Bytes(recipient)
 		}
 	}
 
-	var keyPair *ethutil.KeyPair
+	var keyPair *ethcrypto.KeyPair
 	var err error
 	if key[0:2] == "0x" {
-		keyPair, err = ethutil.NewKeyPairFromSec([]byte(ethutil.FromHex(key[2:])))
+		keyPair, err = ethcrypto.NewKeyPairFromSec([]byte(ethutil.Hex2Bytes(key[2:])))
 	} else {
-		keyPair, err = ethutil.NewKeyPairFromSec([]byte(ethutil.FromHex(key)))
+		keyPair, err = ethcrypto.NewKeyPairFromSec([]byte(ethutil.Hex2Bytes(key)))
 	}
 
 	if err != nil {
@@ -194,7 +190,7 @@ func (lib *PEthereum) createTx(key, recipient, valueStr, gasStr, gasPriceStr, sc
 		var script []byte
 		var err error
 		if ethutil.IsHex(scriptStr) {
-			script = ethutil.FromHex(scriptStr)
+			script = ethutil.Hex2Bytes(scriptStr[2:])
 		} else {
 			script, err = ethutil.Compile(scriptStr)
 			if err != nil {
diff --git a/ethpub/types.go b/ethpub/types.go
index 0ced68ad1..05031dea2 100644
--- a/ethpub/types.go
+++ b/ethpub/types.go
@@ -1,10 +1,10 @@
 package ethpub
 
 import (
-	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethcrypto"
 	"github.com/ethereum/eth-go/ethutil"
 	"strings"
 )
@@ -66,7 +66,7 @@ func NewPBlock(block *ethchain.Block) *PBlock {
 		return nil
 	}
 
-	return &PBlock{ref: block, Number: int(block.Number.Uint64()), GasUsed: block.GasUsed.String(), GasLimit: block.GasLimit.String(), Hash: ethutil.Hex(block.Hash()), Transactions: string(txJson), Time: block.Time, Coinbase: ethutil.Hex(block.Coinbase)}
+	return &PBlock{ref: block, Number: int(block.Number.Uint64()), GasUsed: block.GasUsed.String(), GasLimit: block.GasLimit.String(), Hash: ethutil.Bytes2Hex(block.Hash()), Transactions: string(txJson), Time: block.Time, Coinbase: ethutil.Bytes2Hex(block.Coinbase)}
 }
 
 func (self *PBlock) ToString() string {
@@ -78,7 +78,7 @@ func (self *PBlock) ToString() string {
 }
 
 func (self *PBlock) GetTransaction(hash string) *PTx {
-	tx := self.ref.GetTransaction(ethutil.FromHex(hash))
+	tx := self.ref.GetTransaction(ethutil.Hex2Bytes(hash))
 	if tx == nil {
 		return nil
 	}
@@ -103,22 +103,22 @@ type PTx struct {
 }
 
 func NewPTx(tx *ethchain.Transaction) *PTx {
-	hash := hex.EncodeToString(tx.Hash())
-	receiver := hex.EncodeToString(tx.Recipient)
+	hash := ethutil.Bytes2Hex(tx.Hash())
+	receiver := ethutil.Bytes2Hex(tx.Recipient)
 	if receiver == "0000000000000000000000000000000000000000" {
-		receiver = hex.EncodeToString(tx.CreationAddress())
+		receiver = ethutil.Bytes2Hex(tx.CreationAddress())
 	}
-	sender := hex.EncodeToString(tx.Sender())
+	sender := ethutil.Bytes2Hex(tx.Sender())
 	createsContract := tx.CreatesContract()
 
 	var data string
 	if tx.CreatesContract() {
 		data = strings.Join(ethchain.Disassemble(tx.Data), "\n")
 	} else {
-		data = hex.EncodeToString(tx.Data)
+		data = ethutil.Bytes2Hex(tx.Data)
 	}
 
-	return &PTx{ref: tx, Hash: hash, Value: ethutil.CurrencyToString(tx.Value), Address: receiver, Contract: tx.CreatesContract(), Gas: tx.Gas.String(), GasPrice: tx.GasPrice.String(), Data: data, Sender: sender, CreatesContract: createsContract, RawData: hex.EncodeToString(tx.Data)}
+	return &PTx{ref: tx, Hash: hash, Value: ethutil.CurrencyToString(tx.Value), Address: receiver, Contract: tx.CreatesContract(), Gas: tx.Gas.String(), GasPrice: tx.GasPrice.String(), Data: data, Sender: sender, CreatesContract: createsContract, RawData: ethutil.Bytes2Hex(tx.Data)}
 }
 
 func (self *PTx) ToString() string {
@@ -131,8 +131,8 @@ type PKey struct {
 	PublicKey  string `json:"publicKey"`
 }
 
-func NewPKey(key *ethutil.KeyPair) *PKey {
-	return &PKey{ethutil.Hex(key.Address()), ethutil.Hex(key.PrivateKey), ethutil.Hex(key.PublicKey)}
+func NewPKey(key *ethcrypto.KeyPair) *PKey {
+	return &PKey{ethutil.Bytes2Hex(key.Address()), ethutil.Bytes2Hex(key.PrivateKey), ethutil.Bytes2Hex(key.PublicKey)}
 }
 
 type PReceipt struct {
@@ -145,9 +145,9 @@ type PReceipt struct {
 func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) *PReceipt {
 	return &PReceipt{
 		contractCreation,
-		ethutil.Hex(creationAddress),
-		ethutil.Hex(hash),
-		ethutil.Hex(address),
+		ethutil.Bytes2Hex(creationAddress),
+		ethutil.Bytes2Hex(hash),
+		ethutil.Bytes2Hex(address),
 	}
 }
 
@@ -182,7 +182,7 @@ func (c *PStateObject) Value() string {
 
 func (c *PStateObject) Address() string {
 	if c.object != nil {
-		return ethutil.Hex(c.object.Address())
+		return ethutil.Bytes2Hex(c.object.Address())
 	}
 
 	return ""
@@ -198,7 +198,7 @@ func (c *PStateObject) Nonce() int {
 
 func (c *PStateObject) Root() string {
 	if c.object != nil {
-		return ethutil.Hex(ethutil.NewValue(c.object.State().Root()).Bytes())
+		return ethutil.Bytes2Hex(ethutil.NewValue(c.object.State().Root()).Bytes())
 	}
 
 	return "<err>"
@@ -221,7 +221,7 @@ func (c *PStateObject) StateKeyVal(asJson bool) interface{} {
 	var values []KeyVal
 	if c.object != nil {
 		c.object.State().EachStorage(func(name string, value *ethutil.Value) {
-			values = append(values, KeyVal{name, ethutil.Hex(value.Bytes())})
+			values = append(values, KeyVal{name, ethutil.Bytes2Hex(value.Bytes())})
 		})
 	}
 
@@ -247,7 +247,7 @@ func (c *PStateObject) Script() string {
 
 func (c *PStateObject) HexScript() string {
 	if c.object != nil {
-		return ethutil.Hex(c.object.Script())
+		return ethutil.Bytes2Hex(c.object.Script())
 	}
 
 	return ""
@@ -260,5 +260,5 @@ type PStorageState struct {
 }
 
 func NewPStorageState(storageObject *ethchain.StorageState) *PStorageState {
-	return &PStorageState{ethutil.Hex(storageObject.StateAddress), ethutil.Hex(storageObject.Address), storageObject.Value.String()}
+	return &PStorageState{ethutil.Bytes2Hex(storageObject.StateAddress), ethutil.Bytes2Hex(storageObject.Address), storageObject.Value.String()}
 }