Merge pull request #9 from tokenized/develop

Release

Author: KarlTheProgrammer

bitcoin/encode.go

@@ -4,6 +4,7 @@ import (
 	"encoding/base64"
 	"encoding/hex"
 	"fmt"
+	"io"
 	"strings"
 
 	"github.com/btcsuite/btcutil/base58"
@@ -195,3 +196,42 @@ func BIP0276Decode58(url string) (Network, string, []byte, error) {
 
 	return net, parts[0], b, nil
 }
+
+func ReadBase128VarInt(r io.Reader) (uint64, error) {
+	value := uint64(0)
+	done := false
+	bitOffset := uint64(0)
+	for !done {
+		var subValue [1]byte
+		if _, err := io.ReadFull(r, subValue[:]); err != nil {
+			return value, err
+		}
+
+		done = (subValue[0] & 0x80) == 0 // High bit not set
+		subValue[0] = subValue[0] & 0x7f // Remove high bit
+
+		value += uint64(subValue[0]) << bitOffset
+		bitOffset += 7
+	}
+
+	return value, nil
+}
+
+func WriteBase128VarInt(w io.Writer, value uint64) error {
+	v := value
+	for {
+		if v < 128 {
+			var b [1]byte
+			b[0] = byte(v)
+			_, err := w.Write(b[:])
+			return err
+		}
+
+		var subValue [1]byte
+		subValue[0] = (byte(v&0x7f) | 0x80) // Get last 7 bits and set high bit
+		if _, err := w.Write(subValue[:]); err != nil {
+			return err
+		}
+		v = v >> 7
+	}
+}

bitcoin/encode_test.go

@@ -0,0 +1,62 @@
+package bitcoin
+
+import (
+	"bytes"
+	"encoding/hex"
+	"testing"
+)
+
+func TestBase128(t *testing.T) {
+	tests := []struct {
+		hex   string
+		value uint64
+	}{
+		{
+			hex:   "b0b8d0a2a4b081a316",
+			value: 1604976374254410800,
+		},
+		{
+			hex:   "00",
+			value: 0,
+		},
+		{
+			hex:   "01",
+			value: 1,
+		},
+		{
+			hex:   "0f",
+			value: 15,
+		},
+		{
+			hex:   "ff01",
+			value: 255,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.hex, func(t *testing.T) {
+			b, err := hex.DecodeString(tt.hex)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			value, err := ReadBase128VarInt(bytes.NewReader(b))
+			if err != nil {
+				t.Fatalf("Failed to read : %s", err)
+			}
+
+			if value != tt.value {
+				t.Errorf("Wrong value : got %d, want %d", value, tt.value)
+			}
+
+			var w bytes.Buffer
+			if err := WriteBase128VarInt(&w, value); err != nil {
+				t.Fatalf("Failed to write : %s", err)
+			}
+
+			if !bytes.Equal(w.Bytes(), b) {
+				t.Errorf("Wrong hex : got %x, want %x", w.Bytes(), b)
+			}
+		})
+	}
+}

bitcoin/encryptor.go

@@ -149,7 +149,7 @@ func NewDecryptor(key []byte, r io.Reader) (*Decryptor, error) {
 
 	// Read initialization vector (IV)
 	iv := make([]byte, aes.BlockSize)
-	if _, err = r.Read(iv); err != nil {
+	if _, err = io.ReadFull(r, iv); err != nil {
 		return nil, errors.Wrap(err, "read iv")
 	}
 

bitcoin/extended_key.go

@@ -106,13 +106,13 @@ func ExtendedKeyFromBytes(b []byte) (ExtendedKey, error) {
 // ExtendedKeyFromBytes creates a key from bytes.
 func (k *ExtendedKey) Deserialize(r io.Reader) error {
 	var header [1]byte
-	if _, err := r.Read(header[:]); err != nil {
+	if _, err := io.ReadFull(r, header[:]); err != nil {
 		return errors.Wrap(err, "read header")
 	}
 	if header[0] != ExtendedKeyHeader {
 		// Fall back to BIP-0032 format
 		b := make([]byte, 82)
-		if _, err := r.Read(b); err != nil {
+		if _, err := io.ReadFull(r, b); err != nil {
 			return err
 		}
 		bip32Key, err := bip32.Deserialize(b)
@@ -529,24 +529,24 @@ func (k *ExtendedKey) setFromBIP32(old *bip32.Key) error {
 // read reads just the basic data of the extended key.
 func (k *ExtendedKey) read(r io.Reader) error {
 	var b [1]byte
-	if _, err := r.Read(b[:]); err != nil {
+	if _, err := io.ReadFull(r, b[:]); err != nil {
 		return errors.Wrap(err, "reading xkey depth")
 	}
 	k.Depth = b[0]
 
-	if _, err := r.Read(k.FingerPrint[:]); err != nil {
+	if _, err := io.ReadFull(r, k.FingerPrint[:]); err != nil {
 		return errors.Wrap(err, "reading xkey fingerprint")
 	}
 
 	if err := binary.Read(r, binary.BigEndian, &k.Index); err != nil {
 		return errors.Wrap(err, "reading xkey index")
 	}
 
-	if _, err := r.Read(k.ChainCode[:]); err != nil {
+	if _, err := io.ReadFull(r, k.ChainCode[:]); err != nil {
 		return errors.Wrap(err, "reading xkey chaincode")
 	}
 
-	if _, err := r.Read(k.KeyValue[:]); err != nil {
+	if _, err := io.ReadFull(r, k.KeyValue[:]); err != nil {
 		return errors.Wrap(err, "reading xkey key")
 	}
 

bitcoin/extended_keys.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/hex"
 	"fmt"
-	"io"
 
 	"github.com/pkg/errors"
 	bip32 "github.com/tyler-smith/go-bip32"
@@ -49,7 +48,7 @@ func ExtendedKeysFromBytes(b []byte) (ExtendedKeys, error) {
 	}
 
 	result := make(ExtendedKeys, 0, count)
-	for i := 0; i < count; i++ {
+	for i := uint64(0); i < count; i++ {
 		var ek ExtendedKey
 		if err := ek.read(buf); err != nil {
 			return nil, errors.Wrap(err, "read xkey base")
@@ -145,7 +144,7 @@ func (k ExtendedKeys) Bytes() []byte {
 		return nil
 	}
 
-	if err := WriteBase128VarInt(&buf, len(k)); err != nil {
+	if err := WriteBase128VarInt(&buf, uint64(len(k))); err != nil {
 		return nil
 	}
 
@@ -314,42 +313,3 @@ func (k *ExtendedKeys) Scan(data interface{}) error {
 	copy(c, b)
 	return k.SetBytes(c)
 }
-
-func ReadBase128VarInt(r io.Reader) (int, error) {
-	value := uint32(0)
-	done := false
-	bitOffset := uint32(0)
-	for !done {
-		var subValue [1]byte
-		if _, err := r.Read(subValue[:]); err != nil {
-			return int(value), err
-		}
-
-		done = (subValue[0] & 0x80) == 0 // High bit not set
-		subValue[0] = subValue[0] & 0x7f // Remove high bit
-
-		value += uint32(subValue[0]) << bitOffset
-		bitOffset += 7
-	}
-
-	return int(value), nil
-}
-
-func WriteBase128VarInt(w io.Writer, value int) error {
-	v := uint32(value)
-	for {
-		if v < 128 {
-			var b [1]byte
-			b[0] = byte(v)
-			_, err := w.Write(b[:])
-			return err
-		}
-
-		var subValue [1]byte
-		subValue[0] = (byte(v&0x7f) | 0x80) // Get last 7 bits and set high bit
-		if _, err := w.Write(subValue[:]); err != nil {
-			return err
-		}
-		v = v >> 7
-	}
-}

bitcoin/hash20.go

@@ -83,7 +83,7 @@ func (h Hash20) Serialize(w io.Writer) error {
 }
 
 func (h *Hash20) Deserialize(r io.Reader) error {
-	if _, err := r.Read(h[:]); err != nil {
+	if _, err := io.ReadFull(r, h[:]); err != nil {
 		return err
 	}
 	return nil
@@ -92,7 +92,7 @@ func (h *Hash20) Deserialize(r io.Reader) error {
 // Deserialize reads a hash from a reader.
 func DeserializeHash20(r io.Reader) (*Hash20, error) {
 	result := Hash20{}
-	_, err := r.Read(result[:])
+	_, err := io.ReadFull(r, result[:])
 	if err != nil {
 		return nil, err
 	}

bitcoin/hash32.go

@@ -90,7 +90,7 @@ func (h Hash32) Serialize(w io.Writer) error {
 }
 
 func (h *Hash32) Deserialize(r io.Reader) error {
-	if _, err := r.Read(h[:]); err != nil {
+	if _, err := io.ReadFull(r, h[:]); err != nil {
 		return err
 	}
 	return nil
@@ -99,7 +99,7 @@ func (h *Hash32) Deserialize(r io.Reader) error {
 // Deserialize reads a hash from a reader.
 func DeserializeHash32(r io.Reader) (*Hash32, error) {
 	result := Hash32{}
-	_, err := r.Read(result[:])
+	_, err := io.ReadFull(r, result[:])
 	if err != nil {
 		return nil, err
 	}

bitcoin/key.go

@@ -70,6 +70,38 @@ func KeyFromStr(s string) (Key, error) {
 	return Key{}, fmt.Errorf("Key unknown format length %d", len(b))
 }
 
+func (k *Key) DecodeString(s string) error {
+	b, err := decodeAddress(s)
+	if err != nil {
+		return err
+	}
+
+	switch b[0] {
+	case typeMainPrivKey:
+		k.net = MainNet
+	case typeTestPrivKey:
+		k.net = TestNet
+	default:
+		return ErrBadKeyType
+	}
+
+	if len(b) == 34 {
+		if b[len(b)-1] != 0x01 {
+			return fmt.Errorf("Key not for compressed public : %x", b[len(b)-1:])
+		}
+		b = b[1:33]
+	} else if len(b) == 33 {
+		b = b[1:]
+	}
+
+	if err := privateKeyIsValid(b); err != nil {
+		return err
+	}
+
+	k.value.SetBytes(b)
+	return nil
+}
+
 // KeyFromBytes decodes a binary bitcoin key. It returns the key and an error if there was an
 //   issue.
 func KeyFromBytes(b []byte, net Network) (Key, error) {
@@ -130,13 +162,7 @@ func (k Key) Network() Network {
 
 // SetString decodes a key from hex text.
 func (k *Key) SetString(s string) error {
-	nk, err := KeyFromStr(s)
-	if err != nil {
-		return err
-	}
-
-	*k = nk
-	return nil
+	return k.DecodeString(s)
 }
 
 // SetBytes decodes the key from bytes.
@@ -163,7 +189,7 @@ func (k Key) Bytes() []byte {
 
 func (k *Key) Deserialize(r io.Reader) error {
 	b := make([]byte, 33)
-	if _, err := r.Read(b); err != nil {
+	if _, err := io.ReadFull(r, b); err != nil {
 		return errors.Wrap(err, "key")
 	}
 
@@ -213,7 +239,7 @@ func (k Key) MarshalJSON() ([]byte, error) {
 
 // UnmarshalJSON converts from json.
 func (k *Key) UnmarshalJSON(data []byte) error {
-	return k.SetString(string(data[1 : len(data)-1]))
+	return k.DecodeString(string(data[1 : len(data)-1]))
 }
 
 // MarshalText returns the text encoding of the key.
@@ -228,13 +254,7 @@ func (k Key) MarshalText() ([]byte, error) {
 // UnmarshalText parses a text encoded key and sets the value of this object.
 // Implements encoding.TextUnmarshaler interface.
 func (k *Key) 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.DecodeString(string(text))
 }
 
 // MarshalBinary returns the binary encoding of the key.

bitcoin/lock_script.go

@@ -243,21 +243,21 @@ func RawAddressFromLockingScript(lockingScript []byte) (RawAddress, error) {
 			return RawAddress{}, ErrUnknownScriptTemplate
 		}
 
-		// Parse required signature count
-		required, length, err := ParsePushNumberScript(script)
-		if err != nil {
+		if script[0] != OP_FROMALTSTACK {
 			return RawAddress{}, ErrUnknownScriptTemplate
 		}
-		script = script[length:]
+		script = script[1:]
 
-		if len(script) != 2 {
+		if len(script) < 2 {
 			return RawAddress{}, ErrUnknownScriptTemplate
 		}
 
-		if script[0] != OP_FROMALTSTACK {
+		// Parse required signature count
+		required, length, err := ParsePushNumberScript(script)
+		if err != nil {
 			return RawAddress{}, ErrUnknownScriptTemplate
 		}
-		script = script[1:]
+		script = script[length:]
 
 		if script[0] != OP_GREATERTHANOREQUAL {
 			return RawAddress{}, ErrUnknownScriptTemplate
@@ -381,8 +381,8 @@ func (ra RawAddress) LockingScript() ([]byte, error) {
 		}
 
 		// Check required signature count
-		result = append(result, PushNumberScript(int64(required))...)
 		result = append(result, OP_FROMALTSTACK)
+		result = append(result, PushNumberScript(int64(required))...)
 		result = append(result, OP_GREATERTHANOREQUAL)
 		return result, nil
 	}