Tests compile

keys/keybase_test.go

@@ -1,7 +1,6 @@
 package keys_test
 
 import (
-	"bytes"
 	"fmt"
 	"os"
 	"testing"
@@ -111,18 +110,21 @@ func TestSignVerify(t *testing.T) {
 	d2 := []byte("some other important info!")
 
 	// try signing both data with both keys...
-	s11 := keys.NewMockSignable(d1)
+	s11, pub1, err := cstore.Sign(n1, p1, d1)
-	err = cstore.Sign(n1, p1, s11)
 	require.Nil(err)
-	s12 := keys.NewMockSignable(d2)
+	require.Equal(i1.PubKey, pub1)
-	err = cstore.Sign(n1, p1, s12)
+
+	s12, pub1, err := cstore.Sign(n1, p1, d2)
 	require.Nil(err)
-	s21 := keys.NewMockSignable(d1)
+	require.Equal(i1.PubKey, pub1)
-	err = cstore.Sign(n2, p2, s21)
+
+	s21, pub2, err := cstore.Sign(n2, p2, d1)
 	require.Nil(err)
-	s22 := keys.NewMockSignable(d2)
+	require.Equal(i2.PubKey, pub2)
-	err = cstore.Sign(n2, p2, s22)
+
+	s22, pub2, err := cstore.Sign(n2, p2, d2)
 	require.Nil(err)
+	require.Equal(i2.PubKey, pub2)
 
 	// let's try to validate and make sure it only works when everything is proper
 	cases := []struct {
@@ -132,15 +134,15 @@ func TestSignVerify(t *testing.T) {
 		valid bool
 	}{
 		// proper matches
-		{i1.PubKey, d1, s11.Signature, true},
+		{i1.PubKey, d1, s11, true},
 		// change data, pubkey, or signature leads to fail
-		{i1.PubKey, d2, s11.Signature, false},
+		{i1.PubKey, d2, s11, false},
-		{i2.PubKey, d1, s11.Signature, false},
+		{i2.PubKey, d1, s11, false},
-		{i1.PubKey, d1, s21.Signature, false},
+		{i1.PubKey, d1, s21, false},
 		// make sure other successes
-		{i1.PubKey, d2, s12.Signature, true},
+		{i1.PubKey, d2, s12, true},
-		{i2.PubKey, d1, s21.Signature, true},
+		{i2.PubKey, d1, s21, true},
-		{i2.PubKey, d2, s22.Signature, true},
+		{i2.PubKey, d2, s22, true},
 	}
 
 	for i, tc := range cases {
@@ -188,21 +190,22 @@ func TestSignWithLedger(t *testing.T) {
 	d2 := []byte("please turn on the app")
 
 	// try signing both data with the ledger...
-	s1 := keys.NewMockSignable(d1)
+	s1, pub, err := cstore.Sign(n, p, d1)
-	err = cstore.Sign(n, p, s1)
 	require.Nil(err)
-	s2 := keys.NewMockSignable(d2)
+	require.Equal(info.PubKey, pub)
-	err = cstore.Sign(n, p, s2)
+
+	s2, pub, err := cstore.Sign(n, p, d2)
 	require.Nil(err)
+	require.Equal(info.PubKey, pub)
 
 	// now, let's check those signatures work
-	assert.True(key.VerifyBytes(d1, s1.Signature))
+	assert.True(key.VerifyBytes(d1, s1))
-	assert.True(key.VerifyBytes(d2, s2.Signature))
+	assert.True(key.VerifyBytes(d2, s2))
 	// and mismatched signatures don't
-	assert.False(key.VerifyBytes(d1, s2.Signature))
+	assert.False(key.VerifyBytes(d1, s2))
 }
 
-func assertPassword(assert *assert.Assertions, cstore keys.KeyBase, name, pass, badpass string) {
+func assertPassword(assert *assert.Assertions, cstore keys.Keybase, name, pass, badpass string) {
 	err := cstore.Update(name, badpass, pass)
 	assert.NotNil(err)
 	err = cstore.Update(name, pass, pass)
@@ -219,21 +222,20 @@ func TestImportUnencrypted(t *testing.T) {
 		keys.MustLoadCodec("english"),
 	)
 
-	key, err := keys.GenEd25519.Generate(cmn.RandBytes(16))
+	key := crypto.GenPrivKeyEd25519FromSecret(cmn.RandBytes(16)).Wrap()
-	require.NoError(err)
 
 	addr := key.PubKey().Address()
 	name := "john"
 	pass := "top-secret"
 
 	// import raw bytes
-	err = cstore.Import(name, pass, "", key.Bytes())
+	err := cstore.Import(name, pass, "", key.Bytes())
 	require.Nil(err, "%+v", err)
 
 	// make sure the address matches
 	info, err := cstore.Get(name)
 	require.Nil(err, "%+v", err)
-	require.EqualValues(addr, info.Address)
+	require.EqualValues(addr, info.Address())
 }
 
 // TestAdvancedKeyManagement verifies update, import, export functionality
@@ -309,7 +311,7 @@ func TestSeedPhrase(t *testing.T) {
 	newInfo, err := cstore.Recover(n2, p2, seed)
 	require.Nil(err, "%+v", err)
 	assert.Equal(n2, newInfo.Name)
-	assert.Equal(info.Address, newInfo.Address)
+	assert.Equal(info.Address(), newInfo.Address())
 	assert.Equal(info.PubKey, newInfo.PubKey)
 }
 
@@ -339,8 +341,8 @@ func ExampleNew() {
 	}
 
 	// We need to use passphrase to generate a signature
-	tx := keys.NewMockSignable([]byte("deadbeef"))
+	tx := []byte("deadbeef")
-	err = cstore.Sign("Bob", "friend", tx)
+	sig, pub, err := cstore.Sign("Bob", "friend", tx)
 	if err != nil {
 		fmt.Println("don't accept real passphrase")
 	}
@@ -351,13 +353,11 @@ func ExampleNew() {
 		fmt.Println("Get and Create return different keys")
 	}
 
-	sigs, err := tx.Signers()
+	if pub.Equals(binfo.PubKey) {
-	if err != nil {
-		fmt.Println("badly signed")
-	} else if bytes.Equal(sigs[0].Bytes(), binfo.PubKey.Bytes()) {
 		fmt.Println("signed by Bob")
-	} else {
+	}
-		fmt.Println("signed by someone else")
+	if !pub.VerifyBytes(tx, sig) {
+		fmt.Println("invalid signature")
 	}
 
 	// Output:

keys/types.go

@@ -12,6 +12,11 @@ type Info struct {
 	PubKey crypto.PubKey `json:"pubkey"`
 }
 
+// Address is a helper function to calculate the address from the pubkey
+func (i Info) Address() []byte {
+	return i.PubKey.Address()
+}
+
 func (i Info) bytes() []byte {
 	return wire.BinaryBytes(i)
 }