Merge pull request #13 from tokenized/develop

Develop

Author: KarlTheProgrammer

Makefile

@@ -11,8 +11,11 @@ tools:
 	go get golang.org/x/tools/cmd/goimports
 	go get github.com/golang/lint/golint
 
-test:
-	go test ./...
+prepare:
+	mkdir -p tmp
+
+test: prepare
+	go test -coverprofile=tmp/coverage.out ./...
 
 test-race:
 	go test -race ./...

bitcoin/address.go

@@ -17,17 +17,20 @@ var (
 )
 
 const (
-	AddressTypeMainPKH      = 0x00 // Public Key Hash (starts with 1)
-	AddressTypeMainSH       = 0x05 // Script Hash (starts with 3)
-	AddressTypeMainMultiPKH = 0x76 // Multi-PKH (starts with p) - Experimental value. Not standard
-	AddressTypeMainRPH      = 0x7b // RPH (starts with r) - Experimental value. Not standard
-	AddressTypeMainPK       = 0x06 // Public Key - Experimental value. Not standard
-
-	AddressTypeTestPKH      = 0x6f // Testnet Public Key Hash (starts with m or n)
-	AddressTypeTestSH       = 0xc4 // Testnet Script Hash (starts with 2)
-	AddressTypeTestMultiPKH = 0x78 // Multi-PKH (starts with q) - Experimental value. Not standard
-	AddressTypeTestRPH      = 0x7d // RPH (starts with s) - Experimental value. Not standard
-	AddressTypeTestPK       = 0x07 // Public Key - Experimental value. Not standard
+	AddressTypeMainPKH         = 0x00 // Public Key Hash (starts with 1)
+	AddressTypeMainSH          = 0x05 // Script Hash (starts with 3)
+	AddressTypeMainMultiPKH    = 0x76 // Multi-PKH (starts with p) - Experimental value. Not standard
+	AddressTypeMainRPH         = 0x7b // RPH (starts with r) - Experimental value. Not standard
+	AddressTypeMainPK          = 0x06 // Public Key - Experimental value. Not standard
+	AddressTypeMainNonStandard = 0x08 // Unknown, but possibly spendable locking script
+
+	AddressTypeTestPKH         = 0x6f // Testnet Public Key Hash (starts with m or n)
+	AddressTypeTestSH          = 0xc4 // Testnet Script Hash (starts with 2)
+	AddressTypeTestMultiPKH    = 0x78 // Multi-PKH (starts with q) - Experimental value. Not standard
+	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 {
@@ -94,6 +97,8 @@ func (a *Address) decodeBytes(b []byte) error {
 		return nil
 	case AddressTypeMainRPH:
 		return a.SetRPH(b[1:], MainNet)
+	case AddressTypeMainNonStandard:
+		return a.SetNonStandard(b[1:], MainNet)
 
 	// TestNet
 	case AddressTypeTestPKH:
@@ -129,6 +134,8 @@ func (a *Address) decodeBytes(b []byte) error {
 		return nil
 	case AddressTypeTestRPH:
 		return a.SetRPH(b[1:], TestNet)
+	case AddressTypeTestNonStandard:
+		return a.SetNonStandard(b[1:], TestNet)
 	}
 
 	return ErrBadType
@@ -182,6 +189,12 @@ func NewAddressFromRawAddress(ra RawAddress, net Network) Address {
 		} else {
 			result.addressType = AddressTypeTestRPH
 		}
+	case ScriptTypeNonStandard:
+		if net == MainNet {
+			result.addressType = AddressTypeMainNonStandard
+		} else {
+			result.addressType = AddressTypeTestNonStandard
+		}
 	}
 
 	return result
@@ -351,6 +364,28 @@ func (a *Address) SetRPH(rph []byte, net Network) error {
 	return nil
 }
 
+/**************************************** Non-Standard ********************************************/
+
+// NewAddressNonStandard creates an address from a script that is non-standard but possibly
+// spendable.
+func NewAddressNonStandard(script []byte, net Network) (Address, error) {
+	var result Address
+	err := result.SetNonStandard(script, net)
+	return result, err
+}
+
+// SetNonStandard sets the R Puzzle Hash and script type of the address.
+func (a *Address) SetNonStandard(script []byte, net Network) error {
+	if net == MainNet {
+		a.addressType = AddressTypeMainNonStandard
+	} else {
+		a.addressType = AddressTypeTestNonStandard
+	}
+
+	a.data = script
+	return nil
+}
+
 /***************************************** Common *************************************************/
 
 func (a Address) Type() byte {
@@ -365,13 +400,8 @@ func (a Address) String() string {
 // Network returns the network id for the address.
 func (a Address) Network() Network {
 	switch a.addressType {
-	case AddressTypeMainPKH:
-		fallthrough
-	case AddressTypeMainSH:
-		fallthrough
-	case AddressTypeMainMultiPKH:
-		fallthrough
-	case AddressTypeMainRPH:
+	case AddressTypeMainPKH, AddressTypeMainSH, AddressTypeMainMultiPKH, AddressTypeMainRPH,
+		AddressTypeMainNonStandard:
 		return MainNet
 	}
 	return TestNet
@@ -385,25 +415,11 @@ func (a Address) IsEmpty() bool {
 // Hash returns the hash corresponding to the address.
 func (a Address) Hash() (*Hash20, error) {
 	switch a.addressType {
-	case AddressTypeMainPKH:
-		fallthrough
-	case AddressTypeTestPKH:
-		fallthrough
-	case AddressTypeMainSH:
-		fallthrough
-	case AddressTypeTestSH:
-		fallthrough
-	case AddressTypeMainRPH:
-		fallthrough
-	case AddressTypeTestRPH:
+	case AddressTypeMainPKH, AddressTypeTestPKH, AddressTypeMainSH, AddressTypeTestSH,
+		AddressTypeMainRPH, AddressTypeTestRPH:
 		return NewHash20(a.data)
-	case AddressTypeMainPK:
-		fallthrough
-	case AddressTypeTestPK:
-		fallthrough
-	case AddressTypeMainMultiPKH:
-		fallthrough
-	case AddressTypeTestMultiPKH:
+	case AddressTypeMainPK, AddressTypeTestPK, AddressTypeMainMultiPKH, AddressTypeTestMultiPKH,
+		AddressTypeMainNonStandard, AddressTypeTestNonStandard:
 		return NewHash20(Hash160(a.data))
 	}
 	return nil, ErrUnknownScriptTemplate

bitcoin/encode.go

@@ -217,21 +217,31 @@ func ReadBase128VarInt(r io.Reader) (uint64, error) {
 	return value, nil
 }
 
+const bitLeast7EmptyMask = 0xffffff80
+const bit8thMask = 0x80
+const bitLeast7Mask = 0x0000007f
+
 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[:])
+		if value&bitLeast7EmptyMask == 0 {
+			b := []byte{byte(value)}
+			_, 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 {
+		subValue := []byte{(byte(value&bitLeast7Mask) | bit8thMask)} // Get last 7 bits and set high bit
+		if _, err := w.Write(subValue); err != nil {
 			return err
 		}
-		v = v >> 7
+		value = value >> 7
 	}
 }
+
+func ReadBase128VarSignedInt(r io.Reader) (int64, error) {
+	result, err := ReadBase128VarInt(r)
+	return int64(result), err
+}
+
+func WriteBase128VarSignedInt(w io.Writer, value int64) error {
+	return WriteBase128VarInt(w, uint64(value))
+}

bitcoin/encode_test.go

@@ -3,6 +3,7 @@ package bitcoin
 import (
 	"bytes"
 	"encoding/hex"
+	"fmt"
 	"testing"
 )
 
@@ -31,6 +32,10 @@ func TestBase128(t *testing.T) {
 			hex:   "ff01",
 			value: 255,
 		},
+		{
+			hex:   "AC02",
+			value: 300,
+		},
 	}
 
 	for _, tt := range tests {
@@ -60,3 +65,61 @@ func TestBase128(t *testing.T) {
 		})
 	}
 }
+
+func TestBase128Signed(t *testing.T) {
+	tests := []struct {
+		hex   string
+		value int64
+	}{
+		{
+			hex:   "b0b8d0a2a4b081a316",
+			value: 1604976374254410800,
+		},
+		{
+			hex:   "00",
+			value: 0,
+		},
+		{
+			hex:   "01",
+			value: 1,
+		},
+		{
+			hex:   "0f",
+			value: 15,
+		},
+		{
+			hex:   "ff01",
+			value: 255,
+		},
+		{
+			hex:   "ac02",
+			value: 300,
+		},
+		{
+			hex:   "ac02",
+			value: -300,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.hex, func(t *testing.T) {
+			var w bytes.Buffer
+			if err := WriteBase128VarSignedInt(&w, tt.value); err != nil {
+				t.Fatalf("Failed to write : %s", err)
+			}
+
+			fmt.Printf("Bytes : %x\n", w.Bytes())
+
+			value, err := ReadBase128VarSignedInt(&w)
+			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)
+			}
+
+			t.Logf("Value : %d", value)
+		})
+	}
+}

bitcoin/hash20.go

@@ -3,9 +3,14 @@ package bitcoin
 import (
 	"bytes"
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"io"
+
+	"github.com/pkg/errors"
+)
+
+var (
+	ErrWrongSize = errors.New("Wrong size")
 )
 
 const Hash20Size = 20
@@ -15,7 +20,7 @@ type Hash20 [Hash20Size]byte
 
 func NewHash20(b []byte) (*Hash20, error) {
 	if len(b) != Hash20Size {
-		return nil, errors.New("Wrong byte length")
+		return nil, errors.Wrapf(ErrWrongSize, "got %d, want %d", len(b), Hash20Size)
 	}
 	result := Hash20{}
 	copy(result[:], b)
@@ -25,7 +30,7 @@ func NewHash20(b []byte) (*Hash20, error) {
 // NewHash20FromStr creates a little endian hash from a big endian string.
 func NewHash20FromStr(s string) (*Hash20, error) {
 	if len(s) != 2*Hash20Size {
-		return nil, fmt.Errorf("Wrong size hex for Hash20 : %d", len(s))
+		return nil, errors.Wrapf(ErrWrongSize, "hex: got %d, want %d", len(s), Hash20Size*2)
 	}
 
 	b := make([]byte, Hash20Size)
@@ -52,7 +57,7 @@ func (h Hash20) Bytes() []byte {
 // SetBytes sets the value of the hash.
 func (h *Hash20) SetBytes(b []byte) error {
 	if len(b) != Hash20Size {
-		return errors.New("Wrong byte length")
+		return errors.Wrapf(ErrWrongSize, "got %d, want %d", len(b), Hash20Size)
 	}
 	copy(h[:], b)
 	return nil
@@ -76,6 +81,11 @@ func (h *Hash20) Equal(o *Hash20) bool {
 	return bytes.Equal(h[:], o[:])
 }
 
+func (h Hash20) IsZero() bool {
+	var zero Hash20 // automatically initializes to zero
+	return h.Equal(&zero)
+}
+
 // Serialize writes the hash into a writer.
 func (h Hash20) Serialize(w io.Writer) error {
 	_, err := w.Write(h[:])

bitcoin/hash32.go

@@ -3,9 +3,10 @@ package bitcoin
 import (
 	"bytes"
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"io"
+
+	"github.com/pkg/errors"
 )
 
 const Hash32Size = 32
@@ -15,7 +16,7 @@ type Hash32 [Hash32Size]byte
 
 func NewHash32(b []byte) (*Hash32, error) {
 	if len(b) != Hash32Size {
-		return nil, errors.New("Wrong byte length")
+		return nil, errors.Wrapf(ErrWrongSize, "got %d, want %d", len(b), Hash32Size)
 	}
 	result := Hash32{}
 	copy(result[:], b)
@@ -25,7 +26,7 @@ func NewHash32(b []byte) (*Hash32, error) {
 // NewHash32FromStr creates a little endian hash from a big endian string.
 func NewHash32FromStr(s string) (*Hash32, error) {
 	if len(s) != 2*Hash32Size {
-		return nil, fmt.Errorf("Wrong size hex for Hash32 : %d", len(s))
+		return nil, errors.Wrapf(ErrWrongSize, "hex: got %d, want %d", len(s), Hash32Size*2)
 	}
 
 	b := make([]byte, Hash32Size)
@@ -59,7 +60,7 @@ func (h Hash32) Bytes() []byte {
 // SetBytes sets the value of the hash.
 func (h *Hash32) SetBytes(b []byte) error {
 	if len(b) != Hash32Size {
-		return errors.New("Wrong byte length")
+		return errors.Wrapf(ErrWrongSize, "got %d, want %d", len(b), Hash32Size)
 	}
 	copy(h[:], b)
 	return nil
@@ -83,6 +84,11 @@ func (h *Hash32) Equal(o *Hash32) bool {
 	return bytes.Equal(h[:], o[:])
 }
 
+func (h Hash32) IsZero() bool {
+	var zero Hash32 // automatically initializes to zero
+	return h.Equal(&zero)
+}
+
 // Serialize writes the hash into a writer.
 func (h Hash32) Serialize(w io.Writer) error {
 	_, err := w.Write(h[:])

bitcoin/key.go

@@ -137,6 +137,14 @@ func GenerateKey(net Network) (Key, error) {
 	return Key{net: net, value: *key.D}, nil
 }
 
+func (k Key) Equal(other Key) bool {
+	if k.net != other.net {
+		return false
+	}
+
+	return k.value.Cmp(&other.value) == 0
+}
+
 // String returns the type followed by the key data with a checksum, encoded with Base58.
 func (k Key) String() string {
 	var keyType byte