Merge 8ba2ffc into f77b9aa

src/coin/skycoin/models/account.go

@@ -25,7 +25,7 @@ func (addr *SkycoinAddress) GetBalance(ticker string) (uint64, error) {
 	}
 	defer ReturnSkycoinClient(c)
 	log.Info("POST /api/v1/balance?addrs=xxx")
-	bl, err := c.Balance([]string{addr.address})
+	bl, err := c.Balance([]string{addr.address.String()})
 	if err != nil {
 		log.WithError(err).WithField("addrs", "addr.address").Error("Couldn't POST /api/v1/balance?addrs=xxx")
 		return 0, err

src/coin/skycoin/models/account_test.go

@@ -1,6 +1,7 @@
 package skycoin
 
 import (
+	"github.com/stretchr/testify/assert"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -13,28 +14,28 @@ import (
 func TestWalletListPendingTransactions(t *testing.T) {
 	response := &api.UnconfirmedTxnsVerboseResponse{
 		Transactions: []readable.UnconfirmedTransactionVerbose{
-			readable.UnconfirmedTransactionVerbose{
+			{
 				Transaction: readable.BlockTransactionVerbose{
 					Out: []readable.TransactionOutput{
-						readable.TransactionOutput{
+						{
 							Coins: "1",
 							Hours: 2000,
 						},
-						readable.TransactionOutput{
+						{
 							Coins: "1",
 							Hours: 2000,
 						},
 					},
 				},
 			},
-			readable.UnconfirmedTransactionVerbose{
+			{
 				Transaction: readable.BlockTransactionVerbose{
 					Out: []readable.TransactionOutput{
-						readable.TransactionOutput{
+						{
 							Coins: "1",
 							Hours: 2000,
 						},
-						readable.TransactionOutput{
+						{
 							Coins: "1",
 							Hours: 2000,
 						},
@@ -73,17 +74,18 @@ func TestWalletListPendingTransactions(t *testing.T) {
 
 func TestSkycoinAddressGetBalance(t *testing.T) {
 	response := new(api.BalanceResponse)
+	addr, err := NewSkycoinAddress("2kvLEyXwAYvHfJuFCkjnYNRTUfHPyWgVwKt")
+	assert.NoError(t, err)
 	response.Confirmed = readable.Balance{Coins: uint64(42000000), Hours: uint64(200)}
-	global_mock.On("Balance", []string{"addr1"}).Return(response, nil)
-
-	addr := &SkycoinAddress{address: "addr1"}
-	val, err := addr.GetBalance(Sky)
+	global_mock.On("Balance", []string{addr.String()}).Return(response, nil)
+	skyAddrs := addr.GetCryptoAccount()
+	val, err := skyAddrs.GetBalance(Sky)
 	require.NoError(t, err)
 	require.Equal(t, val, uint64(42000000))
-	val, err = addr.GetBalance(CoinHour)
+	val, err = skyAddrs.GetBalance(CoinHour)
 	require.NoError(t, err)
 	require.Equal(t, val, uint64(200))
-	val, err = addr.GetBalance("INVALID_TICKER")
+	val, err = skyAddrs.GetBalance("INVALID_TICKER")
 	require.Error(t, err)
 	require.Equal(t, val, uint64(0))
 }
@@ -94,21 +96,23 @@ func TestSkycoinAddressScanUnspentOutputs(t *testing.T) {
 		Coins:           "42",
 		Hours:           uint64(42),
 		CalculatedHours: uint64(42),
-		Address:         "addr1",
+		Address:         "2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8",
 	}
 	response := &readable.UnspentOutputsSummary{
 		HeadOutputs: readable.UnspentOutputs{usOut, usOut},
 	}
 
-	global_mock.On("OutputsForAddresses", []string{"addr1"}).Return(response, nil)
+	global_mock.On("OutputsForAddresses", []string{"2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8"}).Return(response, nil)
 
-	addr := &SkycoinAddress{address: "addr1"}
-	it := addr.ScanUnspentOutputs()
+	addrs, err := NewSkycoinAddress("2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8")
+	assert.NoError(t, err)
+	skyAddrs := addrs.GetCryptoAccount()
+	it := skyAddrs.ScanUnspentOutputs()
 
 	for it.Next() {
 		output := it.Value()
 		require.Equal(t, output.GetId(), "hash1")
-		require.Equal(t, output.GetAddress().String(), "addr1")
+		require.Equal(t, output.GetAddress().String(), "2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8")
 		val, err := output.GetCoins(Sky)
 		require.NoError(t, err)
 		require.Equal(t, val, uint64(42000000))
@@ -126,9 +130,9 @@ func TestSkycoinAddressListTransactions(t *testing.T) {
 		},
 	}
 	response.Transaction.Hash = "hash1"
-	global_mock.On("TransactionsVerbose", []string{"addr1"}).Return(
+	global_mock.On("TransactionsVerbose", []string{"2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8"}).Return(
 		[]readable.TransactionWithStatusVerbose{
-			readable.TransactionWithStatusVerbose{
+			{
 				Status: readable.TransactionStatus{
 					Confirmed: true,
 				},
@@ -141,8 +145,10 @@ func TestSkycoinAddressListTransactions(t *testing.T) {
 		&readable.TransactionWithStatus{Status: response.Status},
 		nil,
 	)
-	addr := &SkycoinAddress{address: "addr1"}
-	it := addr.ListTransactions()
+	addr, err := NewSkycoinAddress("2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8")
+	assert.NoError(t, err)
+	skyAddr := addr.GetCryptoAccount()
+	it := skyAddr.ListTransactions()
 	it.Next()
 	thx := it.Value()
 	require.Equal(t, thx.GetStatus(), core.TXN_STATUS_CONFIRMED)
@@ -209,7 +215,6 @@ func TestRemoteWalletGetBalance(t *testing.T) {
 
 func TestRemoteWalletScanUnspentOutputs(t *testing.T) {
 	CleanGlobalMock()
-
 	global_mock.On("Wallet", "wallet").Return(
 		&api.WalletResponse{
 			Meta: readable.WalletMeta{
@@ -219,7 +224,7 @@ func TestRemoteWalletScanUnspentOutputs(t *testing.T) {
 				Encrypted: true,
 			},
 			Entries: []readable.WalletEntry{
-				readable.WalletEntry{Address: "addr"},
+				{Address: "2kvLEyXwAYvHfJuFCkjnYNRTUfHPyWgVwKt"},
 			},
 		},
 		nil)
@@ -240,15 +245,16 @@ func TestRemoteWalletScanUnspentOutputs(t *testing.T) {
 		Coins:           "42",
 		Hours:           uint64(42),
 		CalculatedHours: uint64(42),
-		Address:         "addr",
+		Address:         "2kvLEyXwAYvHfJuFCkjnYNRTUfHPyWgVwKt",
 	}
 	response := &readable.UnspentOutputsSummary{
 		HeadOutputs: readable.UnspentOutputs{usOut},
 	}
 
-	global_mock.On("OutputsForAddresses", []string{"addr"}).Return(response, nil)
-
-	global_mock.On("OutputsForAddresses", []string{"no_outputs"}).Return(&readable.UnspentOutputsSummary{}, nil)
+	// addrs
+	global_mock.On("OutputsForAddresses", []string{"2kvLEyXwAYvHfJuFCkjnYNRTUfHPyWgVwKt"}).Return(response, nil)
+	// no_output
+	global_mock.On("OutputsForAddresses", []string{"2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8"}).Return(&readable.UnspentOutputsSummary{}, nil)
 
 	wlt := &RemoteWallet{
 		Id:          "wallet",
@@ -259,11 +265,11 @@ func TestRemoteWalletScanUnspentOutputs(t *testing.T) {
 	for iter.Next() {
 		to := iter.Value()
 		items++
-		require.Equal(t, "addr", to.GetAddress().String())
+		require.Equal(t, "2kvLEyXwAYvHfJuFCkjnYNRTUfHPyWgVwKt", to.GetAddress().String())
 	}
 	require.Equal(t, 1, items)
 
-	//No outputs
+	// No outputs
 	wlt = &RemoteWallet{
 		Id:          "wallet_no_outputs",
 		poolSection: PoolSection,
@@ -288,7 +294,7 @@ func TestRemoteWalletListTransactions(t *testing.T) {
 	}
 	response.Transaction.Hash = "hash1"
 
-	global_mock.On("TransactionsVerbose", []string{"addr"}).Return(
+	global_mock.On("TransactionsVerbose", []string{"2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8"}).Return(
 		[]readable.TransactionWithStatusVerbose{
 			response,
 		},
@@ -304,7 +310,7 @@ func TestRemoteWalletListTransactions(t *testing.T) {
 				Encrypted: true,
 			},
 			Entries: []readable.WalletEntry{
-				readable.WalletEntry{Address: "addr"},
+				{Address: "2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8"},
 			},
 		},
 		nil)
@@ -335,7 +341,7 @@ func TestLocalWalletScanUnspentOutputs(t *testing.T) {
 				Encrypted: true,
 			},
 			Entries: []readable.WalletEntry{
-				readable.WalletEntry{Address: "addr"},
+				{Address: "2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8"},
 			},
 		},
 		nil)
@@ -373,7 +379,7 @@ func TestLocalWalletListTransactions(t *testing.T) {
 				Encrypted: true,
 			},
 			Entries: []readable.WalletEntry{
-				readable.WalletEntry{Address: "addr"},
+				{Address: "2JJ8pgq8EDAnrzf9xxBJapE2qkYLefW4uF8"},
 			},
 		},
 		nil)

src/coin/skycoin/models/cipher.go

@@ -5,7 +5,7 @@ import (
 	"github.com/skycoin/skycoin/src/cipher"
 )
 
-type SkycoinAddressIterator struct { //Implements AddressIterator interfaces
+type SkycoinAddressIterator struct { // Implements AddressIterator interfaces
 	current   int
 	addresses []core.Address
 }
@@ -30,29 +30,145 @@ func NewSkycoinAddressIterator(addresses []core.Address) *SkycoinAddressIterator
 	return &SkycoinAddressIterator{addresses: addresses, current: -1}
 }
 
-type SkycoinAddress struct { //Implements Address and CryptoAccount interfaces
-	address     string
+func NewSkycoinAddress(addrStr string) (SkycoinAddress, error) {
+	var skyAddr cipher.Address
+	var err error
+	if skyAddr, err = cipher.DecodeBase58Address(addrStr); err != nil {
+		return SkycoinAddress{}, err
+	}
+
+	return SkycoinAddress{
+		isBip32:     false,
+		address:     skyAddr,
+		poolSection: PoolSection,
+	}, nil
+}
+
+type SkycoinAddress struct { // Implements Address and CryptoAccount interfaces
+	isBip32     bool
+	address     cipher.Address
 	poolSection string
 }
 
 func (addr *SkycoinAddress) IsBip32() bool {
-	return false
+	return addr.isBip32
 }
 
 func (addr *SkycoinAddress) String() string {
-	return addr.address
+	return addr.address.String()
 }
 
 func (addr *SkycoinAddress) GetCryptoAccount() core.CryptoAccount {
 	return addr
 }
 
-func (addr SkycoinAddress) ToSkycoinCipherAddress() (*cipher.Address, error) {
-	pubkey, err := cipher.PubKeyFromHex(addr.String())
+func (addr *SkycoinAddress) ToSkycoinCipherAddress() (cipher.Address, error) {
+	return cipher.AddressFromBytes(addr.Bytes())
+}
+
+// Bytes binary representation for address
+func (addr *SkycoinAddress) Bytes() []byte {
+	return addr.address.Bytes()
+}
+
+// Checksum computes address consistency token
+func (addr *SkycoinAddress) Checksum() core.Checksum {
+	checksum := addr.address.Checksum()
+	return checksum[:]
+}
+
+func toSkycoinPubKey(pk core.PubKey) (cipher.PubKey, error) {
+	if pk1, isSkyPK := pk.(*SkycoinPubKey); isSkyPK {
+		return pk1.pubkey, nil
+	}
+	return cipher.NewPubKey(pk.Bytes())
+}
+
+func toSkycoinSecKey(sk core.SecKey) (cipher.SecKey, error) {
+	if sk1, isSkySK := sk.(*SkycoinSecKey); isSkySK {
+		return sk1.seckey, nil
+	}
+	return cipher.NewSecKey(sk.Bytes())
+}
+
+// Verify checks that the address appears valid for the public key
+func (addr *SkycoinAddress) Verify(pk core.PubKey) error {
+
+	skyPK, err := toSkycoinPubKey(pk)
+	if err != nil {
+		return err
+	}
+	return addr.address.Verify(skyPK)
+}
+
+// Null returns true if the address is null
+func (addr *SkycoinAddress) Null() bool {
+	return addr.address.Null()
+}
+
+// SkycoinSecKey Skycoin private key wrapper
+type SkycoinSecKey struct {
+	seckey cipher.SecKey
+}
+
+// Verify checks that the private key appears valid
+func (sk *SkycoinSecKey) Verify() error {
+	return sk.seckey.Verify()
+}
+
+// Null returns true if the private key is null
+func (sk *SkycoinSecKey) Null() bool {
+	return sk.seckey.Null()
+}
+
+// Bytes binary representation for private key
+func (sk *SkycoinSecKey) Bytes() []byte {
+	return sk.seckey[:]
+}
+
+func skySecKeyFromBytes(b []byte) (*SkycoinSecKey, error) {
+	sk, err := cipher.NewSecKey(b)
 	if err != nil {
 		return nil, err
 	}
-	sAddr := cipher.AddressFromPubKey(pubkey)
+	return &SkycoinSecKey{
+		seckey: sk,
+	}, nil
+}
 
-	return &sAddr, nil
+func skyPubKeyFromBytes(b []byte) (*SkycoinPubKey, error) {
+	pk, err := cipher.NewPubKey(b)
+	if err != nil {
+		return nil, err
+	}
+	return &SkycoinPubKey{
+		pubkey: pk,
+	}, nil
+}
+
+// SkycoinPubKey Skycoin public key wrapper
+type SkycoinPubKey struct {
+	pubkey cipher.PubKey
 }
+
+// Verify checks that the public key appears valid
+func (pk *SkycoinPubKey) Verify() error {
+	return pk.pubkey.Verify()
+}
+
+// Null returns true if the public key is null
+func (pk *SkycoinPubKey) Null() bool {
+	return pk.pubkey.Null()
+}
+
+// Bytes binary representation for public key
+func (pk *SkycoinPubKey) Bytes() []byte {
+	return pk.pubkey[:]
+}
+
+// Type assertions
+var (
+	_ core.Address = &SkycoinAddress{}
+	_ core.PubKey  = &SkycoinPubKey{}
+	_ core.SecKey  = &SkycoinSecKey{}
+)