From 8d9752a557e33341a5fb73239dbae664b2f8aaa0 Mon Sep 17 00:00:00 2001
From: Gustav Simonsson <gustav.simonsson@gmail.com>
Date: Wed, 28 Jan 2015 05:12:57 +0100
Subject: Address pull request comments

* Use crypto.Sign instead of directly calling secp256k1 lib
* Rename UserAccount to Account and Addr to Address (for consistency)
* Change AccountManager.Sign to take ptr to Account instead of
  address byte array
* Simplify copying of Accounts in Accounts()
* PubkeyToAddress and GetEntropyCSPRNG now exported
---
 accounts/account_manager.go | 28 ++++++++++++----------------
 accounts/accounts_test.go   |  5 ++---
 2 files changed, 14 insertions(+), 19 deletions(-)

(limited to 'accounts')

diff --git a/accounts/account_manager.go b/accounts/account_manager.go
index b5a0c4f87..da0bd8900 100644
--- a/accounts/account_manager.go
+++ b/accounts/account_manager.go
@@ -35,12 +35,11 @@ package accounts
 import (
 	crand "crypto/rand"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/crypto/secp256k1"
 )
 
 // TODO: better name for this struct?
-type UserAccount struct {
-	Addr []byte
+type Account struct {
+	Address []byte
 }
 
 type AccountManager struct {
@@ -57,43 +56,40 @@ func NewAccountManager(keyStore crypto.KeyStore2) AccountManager {
 	return *am
 }
 
-func (am *AccountManager) Sign(fromAddr []byte, keyAuth string, toSign []byte) (signature []byte, err error) {
-	key, err := am.keyStore.GetKey(fromAddr, keyAuth)
+func (am *AccountManager) Sign(fromAccount *Account, keyAuth string, toSign []byte) (signature []byte, err error) {
+	key, err := am.keyStore.GetKey(fromAccount.Address, keyAuth)
 	if err != nil {
 		return nil, err
 	}
-	privKey := crypto.FromECDSA(key.PrivateKey)
-	// TODO: what is second value?
-	signature, err = secp256k1.Sign(toSign, privKey)
+	signature, err = crypto.Sign(toSign, key.PrivateKey)
 	return signature, err
 }
 
-func (am AccountManager) NewAccount(auth string) (*UserAccount, error) {
+func (am AccountManager) NewAccount(auth string) (*Account, error) {
 	key, err := am.keyStore.GenerateNewKey(crand.Reader, auth)
 	if err != nil {
 		return nil, err
 	}
-	ua := &UserAccount{
-		Addr: key.Address,
+	ua := &Account{
+		Address: key.Address,
 	}
 	return ua, err
 }
 
 // set of accounts == set of keys in given key store
 // TODO: do we need persistence of accounts as well?
-func (am *AccountManager) Accounts() ([]UserAccount, error) {
+func (am *AccountManager) Accounts() ([]Account, error) {
 	addresses, err := am.keyStore.GetKeyAddresses()
 	if err != nil {
 		return nil, err
 	}
 
-	accounts := make([]UserAccount, len(addresses))
+	accounts := make([]Account, len(addresses))
 
 	for i, addr := range addresses {
-		ua := &UserAccount{
-			Addr: addr,
+		accounts[i] = Account{
+			Address: addr,
 		}
-		accounts[i] = *ua
 	}
 	return accounts, err
 }
diff --git a/accounts/accounts_test.go b/accounts/accounts_test.go
index 381657718..da9406ebe 100644
--- a/accounts/accounts_test.go
+++ b/accounts/accounts_test.go
@@ -10,9 +10,8 @@ func TestAccountManager(t *testing.T) {
 	am := NewAccountManager(ks)
 	pass := "" // not used but required by API
 	a1, err := am.NewAccount(pass)
-	toSign := make([]byte, 4, 4)
-	toSign = []byte{0, 1, 2, 3}
-	_, err = am.Sign(a1.Addr, pass, toSign)
+	toSign := crypto.GetEntropyCSPRNG(32)
+	_, err = am.Sign(a1, pass, toSign)
 	if err != nil {
 		t.Fatal(err)
 	}
-- 
cgit