Merge pull request #14 from tokenized/develop

Technical Standards Committee Specifications

Implement Miner ID, Merchant API, SPV Channels, and TSC merkle proofs.
Update bitcoin scripts.
Update logger fields including timestamps.

Author: KarlTheProgrammer

.gitignore

@@ -4,3 +4,4 @@
 *.prof
 *.log
 tmp
+*.env

bitcoin/address.go

@@ -30,7 +30,6 @@ const (
 	AddressTypeTestRPH         = 0x7d // RPH (starts with s) - Experimental value. Not standard
 	AddressTypeTestPK          = 0x07 // Public Key - Experimental value. Not standard
 	AddressTypeTestNonStandard = 0x09 // Unknown, but possibly spendable locking script
-
 )
 
 type Address struct {

bitcoin/extended_key.go

@@ -6,7 +6,6 @@ import (
 	"crypto/rand"
 	"crypto/sha512"
 	"encoding/binary"
-	"encoding/hex"
 	"fmt"
 	"io"
 	"strconv"
@@ -133,7 +132,7 @@ func ExtendedKeyFromStr(s string) (ExtendedKey, error) {
 		// Fall back to BIP-0032 format
 		bip32Key, b32err := bip32.B58Deserialize(s)
 		if b32err != nil {
-			return ExtendedKey{}, errors.Wrap(err, "decode xkey hex string")
+			return ExtendedKey{}, errors.Wrap(err, "base58 deserialize")
 		}
 
 		return fromBIP32(bip32Key)
@@ -218,7 +217,9 @@ func (k ExtendedKey) String() string {
 
 // String58 returns the key formatted as base 58 text.
 func (k ExtendedKey) String58() string {
-	return BIP0276Encode58(k.Network, ExtendedKeyURLPrefix, k.Bytes())
+	// return BIP0276Encode58(k.Network, ExtendedKeyURLPrefix, k.Bytes())
+	bip32 := k.ToBIP32()
+	return bip32.String()
 }
 
 // SetString decodes a key from hex text.
@@ -460,22 +461,14 @@ func (k *ExtendedKey) UnmarshalJSON(data []byte) error {
 // MarshalText returns the text encoding of the extended key.
 // Implements encoding.TextMarshaler interface.
 func (k ExtendedKey) MarshalText() ([]byte, error) {
-	b := k.Bytes()
-	result := make([]byte, hex.EncodedLen(len(b)))
-	hex.Encode(result, b)
-	return result, nil
+	s := k.String58()
+	return []byte(s), nil
 }
 
 // UnmarshalText parses a text encoded extended key and sets the value of this object.
 // Implements encoding.TextUnmarshaler interface.
 func (k *ExtendedKey) UnmarshalText(text []byte) error {
-	b := make([]byte, hex.DecodedLen(len(text)))
-	_, err := hex.Decode(b, text)
-	if err != nil {
-		return err
-	}
-
-	return k.SetBytes(b)
+	return k.SetString58(string(text))
 }
 
 // MarshalBinary returns the binary encoding of the extended key.
@@ -526,6 +519,30 @@ func (k *ExtendedKey) setFromBIP32(old *bip32.Key) error {
 	return nil
 }
 
+func (k ExtendedKey) ToBIP32() bip32.Key {
+	var result bip32.Key
+
+	result.FingerPrint = make([]byte, 4)
+	copy(result.FingerPrint, k.FingerPrint[:])
+	result.ChildNumber = make([]byte, 4)
+	binary.BigEndian.PutUint32(result.ChildNumber, k.Index)
+	result.ChainCode = make([]byte, 32)
+	copy(result.ChainCode, k.ChainCode[:])
+	result.Depth = k.Depth
+	if k.KeyValue[0] == 0 {
+		result.IsPrivate = true
+		result.Version = bip32.PrivateWalletVersion
+		result.Key = make([]byte, 32)
+		copy(result.Key, k.KeyValue[1:])
+	} else {
+		result.Version = bip32.PublicWalletVersion
+		result.Key = make([]byte, 33)
+		copy(result.Key, k.KeyValue[:])
+	}
+
+	return result
+}
+
 // read reads just the basic data of the extended key.
 func (k *ExtendedKey) read(r io.Reader) error {
 	var b [1]byte

bitcoin/extended_key_test.go

@@ -143,6 +143,8 @@ func TestExtendedKeyVsBIP0032(t *testing.T) {
 }
 
 func TestExtendedKey(t *testing.T) {
+	t.Skip() // This tests the new encoding format which is currently disabled --ce
+
 	tests := []struct {
 		name     string
 		key      string
@@ -376,6 +378,10 @@ func TestOldExtendedKey(t *testing.T) {
 				t.Fatalf("Failed to deserialize new key : %s", err)
 			}
 
+			if newKey.String58() != bip32Key.String() {
+				t.Fatalf("Wrong string 58 : got %s, want %s", newKey.String58(), bip32Key.String())
+			}
+
 			if !bytes.Equal(newKey.KeyValue[:], bip32Key.Key) {
 				t.Fatalf("Imported keys not equal :\n  got  : %x\n  want : %x", newKey.KeyValue[:],
 					bip32Key.Key)

bitcoin/extended_keys.go

@@ -168,6 +168,11 @@ func (k ExtendedKeys) String() string {
 
 // String58 returns the list of keys formatted as base58 text.
 func (k ExtendedKeys) String58() string {
+	if len(k) == 1 {
+		// Temporarily use singular BIP32 encoding --ce
+		return k[0].String58()
+	}
+
 	var net Network
 	if len(k) > 0 {
 		net = k[0].Network

bitcoin/hash20.go

@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"io"
+	"math/big"
 
 	"github.com/pkg/errors"
 )
@@ -54,6 +55,19 @@ func (h Hash20) Bytes() []byte {
 	return h[:]
 }
 
+// Bytes returns the bytes in reverse order (big endian).
+func (h Hash20) ReverseBytes() []byte {
+	b := make([]byte, Hash20Size)
+	reverse20(b, h[:])
+	return b
+}
+
+func (h Hash20) Value() *big.Int {
+	value := &big.Int{}
+	value.SetBytes(h.ReverseBytes())
+	return value
+}
+
 // SetBytes sets the value of the hash.
 func (h *Hash20) SetBytes(b []byte) error {
 	if len(b) != Hash20Size {
@@ -119,15 +133,20 @@ func (h Hash20) MarshalJSON() ([]byte, error) {
 
 // UnmarshalJSON converts from json.
 func (h *Hash20) UnmarshalJSON(data []byte) error {
-	if len(data) != (2*Hash20Size)+2 {
-		return fmt.Errorf("Wrong size hex for Hash20 : %d", len(data)-2)
+	b, err := ConvertJSONHexToBytes(data)
+	if err != nil {
+		return errors.Wrap(err, "hex")
 	}
 
-	b := make([]byte, Hash20Size)
-	_, err := hex.Decode(b, data[1:len(data)-1])
-	if err != nil {
-		return err
+	if len(b) == 0 {
+		h = nil
+		return nil
+	}
+
+	if len(b) != Hash20Size {
+		return fmt.Errorf("Wrong size hex for Hash20 : %d", len(b)*2)
 	}
+
 	reverse20(h[:], b)
 	return nil
 }

bitcoin/hash32.go

@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"io"
+	"math/big"
 
 	"github.com/pkg/errors"
 )
@@ -57,6 +58,19 @@ func (h Hash32) Bytes() []byte {
 	return h[:]
 }
 
+// Bytes returns the bytes in reverse order (big endian).
+func (h Hash32) ReverseBytes() []byte {
+	b := make([]byte, Hash32Size)
+	reverse32(b, h[:])
+	return b
+}
+
+func (h Hash32) Value() *big.Int {
+	value := &big.Int{}
+	value.SetBytes(h.ReverseBytes())
+	return value
+}
+
 // SetBytes sets the value of the hash.
 func (h *Hash32) SetBytes(b []byte) error {
 	if len(b) != Hash32Size {
@@ -122,15 +136,20 @@ func (h Hash32) MarshalJSON() ([]byte, error) {
 
 // UnmarshalJSON converts from json.
 func (h *Hash32) UnmarshalJSON(data []byte) error {
-	if len(data) != (2*Hash32Size)+2 {
-		return fmt.Errorf("Wrong size hex for Hash32 : %d", len(data)-2)
+	b, err := ConvertJSONHexToBytes(data)
+	if err != nil {
+		return errors.Wrap(err, "hex")
 	}
 
-	b := make([]byte, Hash32Size)
-	_, err := hex.Decode(b, data[1:len(data)-1])
-	if err != nil {
-		return err
+	if len(b) == 0 {
+		h = nil
+		return nil
+	}
+
+	if len(b) != Hash32Size {
+		return fmt.Errorf("Wrong size hex for Hash32 : %d", len(b)*2)
 	}
+
 	reverse32(h[:], b)
 	return nil
 }

bitcoin/hex.go

@@ -0,0 +1,84 @@
+package bitcoin
+
+import (
+	"encoding/hex"
+	"errors"
+)
+
+var (
+	ErrMissingQuotes = errors.New("Must be contained in quotes")
+)
+
+// Hex is used in structures as a byte slice that will marshal as hex instead of base64 like is
+// default for json.
+type Hex []byte
+
+func (b Hex) MarshalJSON() ([]byte, error) {
+	return ConvertBytesToJSONHex(b)
+}
+
+func (b *Hex) UnmarshalJSON(data []byte) error {
+	d, err := ConvertJSONHexToBytes(data)
+	if err != nil {
+		return err
+	}
+
+	*b = d
+	return nil
+}
+
+func (b Hex) MarshalText() ([]byte, error) {
+	result := make([]byte, hex.EncodedLen(len(b)))
+	hex.Encode(result, b)
+	return result, nil
+}
+
+func (b *Hex) UnmarshalText(text []byte) error {
+	d := make([]byte, hex.DecodedLen(len(text)))
+	_, err := hex.Decode(d, text)
+	if err != nil {
+		return err
+	}
+
+	*b = d
+	return nil
+}
+
+func (b Hex) MarshalBinary() ([]byte, error) {
+	return b, nil
+}
+
+func (b *Hex) UnmarshalBinary(data []byte) error {
+	*b = data
+	return nil
+}
+
+func ConvertBytesToJSONHex(b []byte) ([]byte, error) {
+	hexLen := hex.EncodedLen(len(b))
+
+	result := make([]byte, hexLen+2)
+	result[0] = '"'
+	hex.Encode(result[1:], b)
+	result[hexLen+1] = '"'
+
+	return result, nil
+}
+
+func ConvertJSONHexToBytes(js []byte) ([]byte, error) {
+	l := len(js)
+	if l < 2 {
+		return nil, ErrMissingQuotes
+	}
+	if js[0] != '"' || js[l-1] != '"' {
+		return nil, ErrMissingQuotes
+	}
+
+	byteLen := hex.DecodedLen(l - 2)
+	b := make([]byte, byteLen)
+	_, err := hex.Decode(b, js[1:l-1])
+	if err != nil {
+		return nil, err
+	}
+
+	return b, nil
+}