update bsm to receive and return []byte

Author: David Case

compat/bsm/sign.go

@@ -2,7 +2,6 @@ package compat
 
 import (
 	"bytes"
-	"encoding/base64"
 	"errors"
 
 	ec "github.com/bitcoin-sv/go-sdk/primitives/ec"
@@ -15,17 +14,12 @@ const hBSV = "Bitcoin Signed Message:\n"
 // SignMessage signs a string with the provided PrivateKey using Bitcoin Signed Message encoding
 // sigRefCompressedKey bool determines whether the signature will reference a compressed or uncompresed key
 // Spec: https://github.com/bitcoin/bitcoin/pull/524
-func SignMessage(privateKey *ec.PrivateKey, message string, sigRefCompressedKey bool) (string, error) {
+func SignMessage(privateKey *ec.PrivateKey, message []byte, sigRefCompressedKey bool) ([]byte, error) {
 	if privateKey == nil {
-		return "", errors.New("private key is required")
-	}
-
-	if len(message) == 0 {
-		return "", errors.New("message is required")
+		return nil, errors.New("private key is required")
 	}
 
 	b := new(bytes.Buffer)
-	var err error
 
 	varInt := transaction.VarInt(len(hBSV))
 	b.Write(varInt.Bytes())
@@ -37,16 +31,11 @@ func SignMessage(privateKey *ec.PrivateKey, message string, sigRefCompressedKey
 	b.Write(varInt.Bytes())
 
 	// append the data to buff
-	b.WriteString(message)
+	b.Write(message)
 
 	// Create the hash
 	messageHash := crypto.Sha256d(b.Bytes())
 
 	// Sign
-	var sigBytes []byte
-	if sigBytes, err = ec.SignCompact(ec.S256(), privateKey, messageHash, sigRefCompressedKey); err != nil {
-		return "", err
-	}
-
-	return base64.StdEncoding.EncodeToString(sigBytes), nil
+	return ec.SignCompact(ec.S256(), privateKey, messageHash, sigRefCompressedKey)
 }

compat/bsm/sign_test.go

@@ -1,6 +1,7 @@
 package compat_test
 
 import (
+	"encoding/base64"
 	"fmt"
 	"testing"
 
@@ -11,7 +12,7 @@ import (
 
 func TestSigningCompression(t *testing.T) {
 	testKey, _ := ec.PrivateKeyFromHex("0499f8239bfe10eb0f5e53d543635a423c96529dd85fa4bad42049a0b435ebdd")
-	testData := "test message"
+	testData := []byte("test message")
 
 	// Test sign compressed
 	address, err := script.NewAddressFromPublicKey(testKey.PubKey(), true)
@@ -113,11 +114,11 @@ func TestSignMessage(t *testing.T) {
 
 		testPk, errKey := ec.PrivateKeyFromHex(test.inputKey)
 
-		if signature, err := compat.SignMessage(testPk, test.inputMessage, false); err != nil && !test.expectedError {
+		if signature, err := compat.SignMessage(testPk, []byte(test.inputMessage), false); err != nil && !test.expectedError {
 			t.Fatalf("%d %s Failed: [%s] [%s] inputted and error not expected but got: %s", idx, t.Name(), test.inputKey, test.inputMessage, err.Error())
 		} else if err == nil && errKey == nil && test.expectedError {
 			t.Fatalf("%d %s Failed: [%s] [%s] inputted and error was expected", idx, t.Name(), test.inputKey, test.inputMessage)
-		} else if signature != test.expectedSignature {
+		} else if base64.StdEncoding.EncodeToString(signature) != test.expectedSignature {
 			t.Fatalf("%d %s Failed: [%s] [%s] inputted [%s] expected but got: %s", idx, t.Name(), test.inputKey, test.inputMessage, test.expectedSignature, signature)
 		}
 
@@ -127,19 +128,19 @@ func TestSignMessage(t *testing.T) {
 // ExampleSignMessage example using SignMessage()
 func ExampleSignMessage() {
 	pk, _ := ec.PrivateKeyFromHex("ef0b8bad0be285099534277fde328f8f19b3be9cadcd4c08e6ac0b5f863745ac")
-	signature, err := compat.SignMessage(pk, "This is a test message", false)
+	signature, err := compat.SignMessage(pk, []byte("This is a test message"), false)
 	if err != nil {
 		fmt.Printf("error occurred: %s", err.Error())
 		return
 	}
-	fmt.Printf("signature created: %s", signature)
+	fmt.Printf("signature created: %s", base64.StdEncoding.EncodeToString(signature))
 	// Output:signature created: G+zZagsyz7ioC/ZOa5EwsaKice0vs2BvZ0ljgkFHxD3vGsMlGeD4sXHEcfbI4h8lP29VitSBdf4A+nHXih7svf4=
 }
 
 // BenchmarkSignMessage benchmarks the method SignMessage()
 func BenchmarkSignMessage(b *testing.B) {
 	key, _ := ec.NewPrivateKey()
 	for i := 0; i < b.N; i++ {
-		_, _ = compat.SignMessage(key, "This is a test message", false)
+		_, _ = compat.SignMessage(key, []byte("This is a test message"), false)
 	}
 }

compat/bsm/verify.go

@@ -2,7 +2,6 @@ package compat
 
 import (
 	"bytes"
-	"encoding/base64"
 	"encoding/hex"
 	"fmt"
 
@@ -13,12 +12,7 @@ import (
 )
 
 // PubKeyFromSignature gets a publickey for a signature and tells you whether is was compressed
-func PubKeyFromSignature(sig, data string) (pubKey *ec.PublicKey, wasCompressed bool, err error) {
-
-	var decodedSig []byte
-	if decodedSig, err = base64.StdEncoding.DecodeString(sig); err != nil {
-		return nil, false, err
-	}
+func PubKeyFromSignature(sig, data []byte) (pubKey *ec.PublicKey, wasCompressed bool, err error) {
 
 	// Validate the signature - this just shows that it was valid at all
 	// we will compare it with the key next
@@ -32,11 +26,11 @@ func PubKeyFromSignature(sig, data string) (pubKey *ec.PublicKey, wasCompressed
 	varInt = transaction.VarInt(len(data))
 	buf.Write(varInt.Bytes())
 	// append the data to buff
-	buf.WriteString(data)
+	buf.Write(data)
 
 	// Create the hash
 	expectedMessageHash := crypto.Sha256d(buf.Bytes())
-	return ec.RecoverCompact(decodedSig, expectedMessageHash)
+	return ec.RecoverCompact(sig, expectedMessageHash)
 }
 
 // VerifyMessage verifies a string and address against the provided
@@ -47,8 +41,7 @@ func PubKeyFromSignature(sig, data string) (pubKey *ec.PublicKey, wasCompressed
 //
 // Error will occur if verify fails or verification is not successful (no bool)
 // Spec: https://github.com/bitcoin/bitcoin/pull/524
-func VerifyMessage(address, sig, data string) error {
-
+func VerifyMessage(address string, sig, data []byte) error {
 	// Reconstruct the pubkey
 	publicKey, wasCompressed, err := PubKeyFromSignature(sig, data)
 	if err != nil {