More boilerplate

address/address.go

@@ -22,6 +22,7 @@ import (
 	"crypto/rand"
 	"crypto/sha512"
 	"errors"
+	"strings"
 
 	"bitmessage-go/base58"
 	"bitmessage-go/bitecdsa"
@@ -53,14 +54,14 @@ func New(addressVersion, stream uint64, eighteenByteRipe bool) (*address, error)
 			return nil, errors.New("address.New: Error generating ecdsa encryption keys")
 		}
 
-		var keyMerge []byte
-		keyMerge = append(keyMerge, addr.SigningKey.PublicKey.X.Bytes()...)
-		keyMerge = append(keyMerge, addr.SigningKey.PublicKey.Y.Bytes()...)
-		keyMerge = append(keyMerge, addr.EncryptionKey.PublicKey.X.Bytes()...)
-		keyMerge = append(keyMerge, addr.EncryptionKey.PublicKey.Y.Bytes()...)
+		var keyMerge bytes.Buffer
+		keyMerge.Write(addr.SigningKey.PublicKey.X.Bytes())
+		keyMerge.Write(addr.SigningKey.PublicKey.Y.Bytes())
+		keyMerge.Write(addr.EncryptionKey.PublicKey.X.Bytes())
+		keyMerge.Write(addr.EncryptionKey.PublicKey.Y.Bytes())
 
 		sha := sha512.New()
-		sha.Write(keyMerge)
+		sha.Write(keyMerge.Bytes())
 
 		ripemd := ripemd160.New()
 		ripemd.Write(sha.Sum(nil))
@@ -79,57 +80,75 @@ func New(addressVersion, stream uint64, eighteenByteRipe bool) (*address, error)
 		}
 	}
 
-	bmAddr := varint.Encode(addressVersion)
-	bmAddr = append(bmAddr, varint.Encode(stream)...)
-	bmAddr = append(bmAddr, ripe...)
+	var bmAddr bytes.Buffer
+	bmAddr.Write(varint.Encode(addressVersion))
+	bmAddr.Write(varint.Encode(stream))
+	bmAddr.Write(ripe)
 
 	sha1, sha2 := sha512.New(), sha512.New()
-	sha1.Write(bmAddr)
+	sha1.Write(bmAddr.Bytes())
 	sha2.Write(sha1.Sum(nil))
 	checksum := sha2.Sum(nil)[:4]
-	bmAddr = append(bmAddr, checksum...)
+	bmAddr.Write(checksum)
 
-	encoded, err := base58.Encode(bmAddr)
+	encoded, err := base58.Encode(bmAddr.Bytes())
 	if err != nil {
 		return nil, err
 	}
 	addr.Identifier = "BM-" + encoded
+
 	return addr, nil
 }
 
-func ValidateChecksum(address string) (bool, error) {
+func (addr *address) Version() (uint64, error) {
 
-	b, err := base58.Decode(address[3:])
+	b, err := base58.Decode(addr.Identifier[3:])
 	if err != nil {
-		return false, err
+		return 0, err
 	}
-	raw := b[:len(b)-4]
-	cs1 := b[len(b)-4:]
-
-	sha1, sha2 := sha512.New(), sha512.New()
-	sha1.Write(raw)
-	sha2.Write(sha1.Sum(nil))
-	cs2 := sha2.Sum(nil)[:4]
+	v, _ := varint.Decode(b)
 
-	return bytes.Compare(cs1, cs2) == 0, nil
+	return v, nil
 }
 
-func GetStream(address string) (uint64, error) {
+func (addr *address) Stream() (uint64, error) {
 
-	valid, err := ValidateChecksum(address)
+	b, err := base58.Decode(addr.Identifier[3:])
 	if err != nil {
 		return 0, err
 	}
+	_, nb := varint.Decode(b)
+	s, _ := varint.Decode(b[nb:])
 
-	if !valid {
-		return 0, errors.New("address.GetStream: Invalid address checksum")
+	return s, nil
+}
+
+func ValidateIdentifier(identifier string) bool {
+
+	if !strings.HasPrefix(identifier, "BM-") {
+		return false
 	}
 
+	if len(identifier) < 25 { // prefix + ripe + checksum
+		return false
+	}
+
+	return true
+}
+
+func ValidateChecksum(address string) (bool, error) {
+
 	b, err := base58.Decode(address[3:])
 	if err != nil {
-		return 0, err
+		return false, err
 	}
-	_, nb := varint.Decode(b)
-	s, _ := varint.Decode(b[nb:])
-	return s, nil
+	raw := b[:len(b)-4]
+	cs1 := b[len(b)-4:]
+
+	sha1, sha2 := sha512.New(), sha512.New()
+	sha1.Write(raw)
+	sha2.Write(sha1.Sum(nil))
+	cs2 := sha2.Sum(nil)[:4]
+
+	return bytes.Compare(cs1, cs2) == 0, nil
 }

address/address_test.go

@@ -1,7 +1,6 @@
 package address
 
 import (
-	"strings"
 	"testing"
 )
 
@@ -16,8 +15,8 @@ func TestAddress(t *testing.T) {
 		t.Error(err.Error())
 	}
 
-	if !strings.HasPrefix(addr.Identifier, "BM-2D") {
-		t.Error("Address does not start with correct prefix. Want BM-2D, got %s\n", addr.Identifier[:5])
+	if !ValidateIdentifier(addr.Identifier) {
+		t.Error("Invalid address identifier %s\n", addr.Identifier)
 	}
 
 	valid, err := ValidateChecksum(addr.Identifier)
@@ -29,10 +28,20 @@ func TestAddress(t *testing.T) {
 		t.Error("Address checksum incorrect\n")
 	}
 
-	stream, err := GetStream(addr.Identifier)
+	ver, err := addr.Version()
 	if err != nil {
 		t.Error(err.Error())
 	}
+
+	if ver != 3 {
+		t.Error("Address version incorrect. Want 3, got %d\n", ver)
+	}
+
+	stream, err := addr.Stream()
+	if err != nil {
+		t.Error(err.Error())
+	}
+
 	if stream != 1 {
 		t.Error("Address stream number incorrect. Want 1, got %d\n", stream)
 	}

proto/addr.go

@@ -20,8 +20,21 @@ package proto
 import ()
 
 type addr struct {
+	Count    uint64
+	AddrList *netaddr
 }
 
 func NewAddr() (*addr, error) {
+
+	return nil, nil
+}
+
+func (v *addr) Serialize() ([]byte, error) {
+
 	return nil, nil
 }
+
+func (v *addr) Deserialize(packet []byte) error {
+
+	return nil
+}

proto/broadcast.go

@@ -19,9 +19,50 @@ package proto
 
 import ()
 
-type broadcast struct {
+type broadcast2 struct {
+	Nonce            uint64
+	Time             uint32 // FIXME uint64
+	BroadcastVersion uint64
+	StreamNumber     uint64
+	Encrypted        []byte
 }
 
-func NewBroadcast() (*broadcast, error) {
+func NewBroadcast2() (*broadcast2, error) {
 	return nil, nil
 }
+
+func (v *broadcast2) Serialize() ([]byte, error) {
+	return nil, nil
+}
+
+func (v *broadcast2) Deserialize(packet []byte) error {
+	return nil
+}
+
+type unencryptedBroadcast struct {
+	BroadcastVersion    uint64
+	AddressVersion      uint64
+	StreamNumber        uint64
+	Behavior            uint32
+	PublicSigningKey    []byte
+	PublicEncryptionKey []byte
+	NonceTrialsPerByte  uint64
+	ExtraBytes          uint64
+	Encoding            uint64
+	MessageLength       uint64
+	Message             []byte
+	SignatureLength     uint64
+	Signature           []byte
+}
+
+func NewUnencryptedBroadcast() (*unencryptedBroadcast, error) {
+	return nil, nil
+}
+
+func (v *unencryptedBroadcast) Serialize() ([]byte, error) {
+	return nil, nil
+}
+
+func (v *unencryptedBroadcast) Deserialize(packet []byte) error {
+	return nil
+}

proto/getdata.go

@@ -20,8 +20,18 @@ package proto
 import ()
 
 type getdata struct {
+	Count     uint64
+	Inventory []byte
 }
 
 func NewGetdata() (*getdata, error) {
 	return nil, nil
 }
+
+func (v *getdata) Serialize() ([]byte, error) {
+	return nil, nil
+}
+
+func (v *getdata) Deserialize(packet []byte) error {
+	return nil
+}

proto/getpubkey.go

@@ -20,8 +20,21 @@ package proto
 import ()
 
 type getpubkey struct {
+	Nonce          uint64
+	Time           uint32 // FIXME uint64
+	AddressVersion uint64
+	StreamNumber   uint64
+	PubKeyHash     []byte
 }
 
 func NewGetpubkey() (*getpubkey, error) {
 	return nil, nil
 }
+
+func (v *getpubkey) Serialize() ([]byte, error) {
+	return nil, nil
+}
+
+func (v *getpubkey) Deserialize(packet []byte) error {
+	return nil
+}

proto/inv.go

@@ -20,8 +20,18 @@ package proto
 import ()
 
 type inv struct {
+	Count     uint64
+	Inventory []byte
 }
 
 func NewInv() (*inv, error) {
 	return nil, nil
 }
+
+func (v *inv) Serialize() ([]byte, error) {
+	return nil, nil
+}
+
+func (v *inv) Deserialize(packet []byte) error {
+	return nil
+}

proto/message.go

@@ -32,11 +32,16 @@ type message struct {
 	Payload  []byte
 }
 
-func NewMessage(cmd string, payload []byte) (*message, error) {
+func NewMessage() (*message, error) {
+
+	return new(message), nil
+}
+
+func NewMessageFromCommand(cmd string, payload []byte) (*message, error) {
 
 	m := new(message)
 
-	if len(cmd) >= 12 {
+	if len(cmd) > 11 {
 		return nil, errors.New("msg.NewMessage: Command is too long")
 	}
 
@@ -83,17 +88,15 @@ func (m *message) Serialize() ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
-func Deserialize(packet []byte) (*message, error) {
+func (m *message) Deserialize(packet []byte) error {
 
 	if len(packet) < 25 {
-		return nil, errors.New("msg.Deserialize: Packet length is too small")
+		return errors.New("msg.Deserialize: Packet length is too small")
 	}
 
-	m := new(message)
-
 	m.Magic = binary.BigEndian.Uint32(packet[:4])
 	if m.Magic != 0xe9beb4d9 {
-		return nil, errors.New("msg.Deserialize: Magic number is invalid")
+		return errors.New("msg.Deserialize: Magic number is invalid")
 	}
 
 	var cmd bytes.Buffer
@@ -110,8 +113,8 @@ func Deserialize(packet []byte) (*message, error) {
 	m.Payload = packet[24:]
 
 	if int(m.Length) != len(m.Payload) {
-		return nil, errors.New("msg.Deserialize: Message length is invalid")
+		return errors.New("msg.Deserialize: Message length is invalid")
 	}
 
-	return m, nil
+	return nil
 }

proto/msg.go

@@ -20,8 +20,20 @@ package proto
 import ()
 
 type msg struct {
+	Nonce        uint64
+	Time         uint32 // FIXME uint64
+	StreamNumber uint64
+	Encrypted    []byte
 }
 
 func NewMsg() (*msg, error) {
 	return nil, nil
 }
+
+func (v *msg) Serialize() ([]byte, error) {
+	return nil, nil
+}
+
+func (v *msg) Deserialize(packet []byte) error {
+	return nil
+}