Merge branch 'peter-testing' into develop

common/factoid/fblock_test.go

@@ -69,18 +69,82 @@ func TestMarshalUnmarshal(t *testing.T) {
 	}
 }
 
-func TestMerkleTrees(t *testing.T) {
+func TestGetEntryHashes(t *testing.T) {
+	f := GetDeterministicFBlock(t)
+	hashes := f.GetEntryHashes()
+	txs := f.Transactions
+
+	if len(txs) == 0 {
+		t.Errorf("No transactions found")
+	}
+	if len(hashes) != len(txs) {
+		t.Errorf("Returned wrong amount of hashes")
+		t.FailNow()
+	}
+
+	for i := range txs {
+		if txs[i].GetHash().IsSameAs(hashes[i]) == false {
+			t.Errorf("Hashes are not identical")
+		}
+	}
+}
+
+func TestGetEntrySigHashes(t *testing.T) {
+	f := GetDeterministicFBlock(t)
+	hashes := f.GetEntrySigHashes()
+	txs := f.Transactions
+	if len(txs) == 0 {
+		t.Errorf("No transactions found")
+	}
+
+	if len(hashes) != len(txs) {
+		t.Errorf("Returned wrong amount of hashes")
+		t.FailNow()
+	}
+
+	for i := range txs {
+		if txs[i].GetSigHash().IsSameAs(hashes[i]) == false {
+			t.Errorf("Hashes are not identical")
+		}
+	}
+}
+
+func TestGetTransactionByHash(t *testing.T) {
+	f := GetDeterministicFBlock(t)
+	txs := f.Transactions
+
+	if len(txs) == 0 {
+		t.Errorf("No transactions found")
+	}
+
+	for _, v := range txs {
+		tx := f.GetTransactionByHash(v.GetHash())
+		if tx == nil {
+			t.Errorf("Could not find transaction %v", v.GetHash())
+		} else {
+			if v.IsSameAs(tx) == false {
+				t.Errorf("Transactions are not the same")
+			}
+		}
+	}
+}
+
+func GetDeterministicFBlock(t *testing.T) *FBlock {
 	rawStr := "000000000000000000000000000000000000000000000000000000000000000f16a82932aa64e6ad45b2749f2abb871fcf3353ab9d4e163c9bd90e5bbd745b59a164ccbb77a21904edc4f2bb753aa60635fb2b60279c06ae01aa211f375417362fb170f73c3961d4218ff806dd75e6e348ca1798a5fc7a99d443fbe2ff939d9900000000000a2be8000000010000000002000000c702014f8a7fcd1b00000002014f8a851657010001e397a1607d4f56c528ab09da5bbf7b37b0b453f43db303730e28e9ebe02657dff431d4f7dfaf840017ef7a21d1a616d65e6b73f3c6a7ad5c49340a6c2592872020ec60767ff00d7d01a5be79b6ada79c0af4d6b7f91234ff321f3b647ed01e02ccbbc0fe9dcc63293482f22455b9756ee4b4db411a5d00e31b689c1bd1abe1d1e887cf4c52e67fc51fe4d9594c24643a91009c6ea91701b5b6df240248c2f39453162b61d71b98270100000000000000000000"
 	raw, err := hex.DecodeString(rawStr)
 	if err != nil {
 		t.Errorf("%v", err)
 	}
 
-	f := new(FBlock)
-	_, err = f.UnmarshalBinaryData(raw)
+	f, err := UnmarshalFBlock(raw)
 	if err != nil {
 		t.Errorf("%v", err)
 	}
+	return f.(*FBlock)
+}
+
+func TestMerkleTrees(t *testing.T) {
+	f := GetDeterministicFBlock(t)
 
 	if f.GetKeyMR().String() != "aa100f203f159e4369081bb366f6816b302387ec19a4f8b9c98495d97fbe3527" {
 		t.Errorf("Invalid GetKeyMR")

common/factoid/transaction_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/FactomProject/factomd/common/constants"
 	. "github.com/FactomProject/factomd/common/factoid"
 	"github.com/FactomProject/factomd/common/interfaces"
+	"github.com/FactomProject/factomd/testHelper"
 )
 
 // Random first "address".  It isn't a real one, but one we are using for now.
@@ -88,6 +89,37 @@ func nextAuth2() interfaces.IRCD {
 	return rcd
 }
 
+func getDeterministicTransaction() interfaces.ITransaction {
+	tx := new(Transaction)
+
+	for i := 0; i < 5; i++ {
+		tx.AddInput(testHelper.NewFactoidAddress(uint64(i)), uint64(100*(i+1)))
+	}
+
+	for i := 0; i < 3; i++ {
+		tx.AddOutput(testHelper.NewFactoidAddress(uint64(i+5)), uint64(100*(i+1)))
+	}
+
+	for i := 0; i < 2; i++ {
+		tx.AddECOutput(testHelper.NewECAddress(uint64(i+8)), uint64(100*(i+1)))
+	}
+
+	for i := 0; i < 5; i++ {
+		tx.AddAuthorization(testHelper.NewFactoidRCDAddress(uint64(i)))
+	}
+
+	data, err := tx.MarshalBinarySig()
+	if err != nil {
+		panic(err)
+	}
+	for i := 0; i < 5; i++ {
+		sig := NewSingleSignatureBlock(testHelper.NewPrivKey(uint64(i)), data)
+		tx.SetSignatureBlock(i, sig)
+	}
+
+	return tx
+}
+
 var nb interfaces.ITransaction
 
 func getSignedTrans() interfaces.ITransaction {
@@ -244,3 +276,33 @@ func TestUnmarshalTransaction(t *testing.T) {
 		t.Errorf("Invalid FullHash - %v vs %v", tr.GetFullHash().String(), "")
 	}
 }
+
+func TestHasUserAddress(t *testing.T) {
+	tx := getDeterministicTransaction()
+	t.Logf("%v", tx.String())
+
+	for i := 0; i < 5; i++ {
+		_, _, str := testHelper.NewFactoidAddressStrings(uint64(i))
+		if tx.HasUserAddress(str) == false {
+			t.Errorf("Did not found user address %v", str)
+		}
+	}
+
+	for i := 0; i < 3; i++ {
+		_, _, str := testHelper.NewFactoidAddressStrings(uint64(i))
+		if tx.HasUserAddress(str) == false {
+			t.Errorf("Did not found user address %v", str)
+		}
+	}
+
+	for i := 0; i < 2; i++ {
+		add := testHelper.NewECAddress(uint64(i + 8))
+		str, err := PublicKeyStringToECAddressString(add.String())
+		if err != nil {
+			t.Errorf("Error converting - %v", err)
+		}
+		if tx.HasUserAddress(str) == false {
+			t.Errorf("Did not found user address %v", str)
+		}
+	}
+}

common/interfaces/transaction.go

@@ -83,6 +83,8 @@ type ITransaction interface {
 
 	// is this user address associated with the inputs and outputs of this transaction
 	HasUserAddress(userAddr string) bool
+
+	IsSameAs(ITransaction) bool
 }
 
 type IPendingTransaction struct {

common/primitives/util.go

@@ -213,6 +213,9 @@ func ConvertAddressToUser(prefix []byte, addr interfaces.IAddress) []byte {
 
 // Convert Factoid Addresses
 func ConvertFctAddressToUserStr(addr interfaces.IAddress) string {
+	//NOTE: This converts the final hash into user-readable string, NOT the public key!
+	//In practical terms, you'll need to convert the public key into RCD,
+	//then hash it before using this function!
 	userd := ConvertAddressToUser(FactoidPrefix, addr)
 	return base58.Encode(userd)
 }

common/primitives/util_test.go

@@ -9,6 +9,7 @@ import (
 	"math/rand"
 	"testing"
 
+	"github.com/FactomProject/factomd/common/factoid"
 	. "github.com/FactomProject/factomd/common/primitives"
 	"github.com/FactomProject/factomd/testHelper"
 )
@@ -183,3 +184,61 @@ func TestValidateUserStr(t *testing.T) {
 		}
 	}
 }
+
+func TestAddressConversions(t *testing.T) {
+	//https://github.com/FactomProject/FactomDocs/blob/master/factomDataStructureDetails.md#factoid-address
+	pub := "0000000000000000000000000000000000000000000000000000000000000000"
+	user := "FA1y5ZGuHSLmf2TqNf6hVMkPiNGyQpQDTFJvDLRkKQaoPo4bmbgu"
+
+	h, err := NewShaHashFromStr(pub)
+	if err != nil {
+		t.Errorf("%v", err)
+	}
+	add := factoid.CreateAddress(h)
+
+	converted := ConvertFctAddressToUserStr(add)
+	if converted != user {
+		t.Errorf("Wrong conversion - %v vs %v", converted, user)
+	}
+
+	//https://github.com/FactomProject/FactomDocs/blob/master/factomDataStructureDetails.md#entry-credit-address
+	pub = "0000000000000000000000000000000000000000000000000000000000000000"
+	user = "EC1m9mouvUQeEidmqpUYpYtXg8fvTYi6GNHaKg8KMLbdMBrFfmUa"
+
+	h, err = NewShaHashFromStr(pub)
+	if err != nil {
+		t.Errorf("%v", err)
+	}
+	add = factoid.CreateAddress(h)
+
+	converted = ConvertECAddressToUserStr(add)
+	if converted != user {
+		t.Errorf("Wrong conversion - %v vs %v", converted, user)
+	}
+
+	//https://github.com/FactomProject/FactomDocs/blob/master/factomDataStructureDetails.md#factoid-private-keys
+	priv := "0000000000000000000000000000000000000000000000000000000000000000"
+	user = "Fs1KWJrpLdfucvmYwN2nWrwepLn8ercpMbzXshd1g8zyhKXLVLWj"
+	h, err = NewShaHashFromStr(priv)
+	if err != nil {
+		t.Errorf("%v", err)
+	}
+	add = factoid.CreateAddress(h)
+	converted = ConvertFctPrivateToUserStr(add)
+	if converted != user {
+		t.Errorf("Wrong conversion - %v vs %v", converted, user)
+	}
+
+	//https://github.com/FactomProject/FactomDocs/blob/master/factomDataStructureDetails.md#entry-credit-private-keys
+	priv = "0000000000000000000000000000000000000000000000000000000000000000"
+	user = "Es2Rf7iM6PdsqfYCo3D1tnAR65SkLENyWJG1deUzpRMQmbh9F3eG"
+	h, err = NewShaHashFromStr(priv)
+	if err != nil {
+		t.Errorf("%v", err)
+	}
+	add = factoid.CreateAddress(h)
+	converted = ConvertECPrivateToUserStr(add)
+	if converted != user {
+		t.Errorf("Wrong conversion - %v vs %v", converted, user)
+	}
+}