Large refactor with more block testing and correctly endianning PoW

address/address_test.go

@@ -1,6 +1,7 @@
 package address
 
 import (
+	"encoding/hex"
 	"github.com/frankh/rai"
 	"testing"
 )
@@ -22,6 +23,15 @@ var invalid_addresses = []rai.Account{
 	"xrb_8nm8t5rimw6h6j7wyokbs8jiygzs7baoha4pqzhfw1k79npyr1km8w6y7r8",
 }
 
+func TestAddressToPub(t *testing.T) {
+	pub, _ := AddressToPub(rai.Account("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3"))
+
+	if hex.EncodeToString(pub) != "e89208dd038fbb269987689621d52292ae9c35941a7484756ecced92a65093ba" {
+		t.Errorf("Address got wrong public key")
+	}
+
+}
+
 func TestValidateAddress(t *testing.T) {
 	for _, addr := range valid_addresses {
 		if !ValidateAddress(addr) {

blocks/blocks.go

@@ -46,6 +46,11 @@ var LiveConfig = Config{
 	LiveGenesisBlock,
 	0xffffffc000000000,
 }
+var TestConfig = Config{
+	":memory:",
+	TestGenesisBlock,
+	0xffffffc000000000,
+}
 
 type BlockType string
 
@@ -133,7 +138,8 @@ func (b *SendBlock) Previous() Block {
 }
 
 func (b *OpenBlock) RootHash() rai.BlockHash {
-	return b.SourceHash
+	pub, _ := address.AddressToPub(b.Account)
+	return rai.BlockHash(hex.EncodeToString(pub))
 }
 
 func (b *ReceiveBlock) RootHash() rai.BlockHash {
@@ -306,6 +312,9 @@ func ValidateWork(block_hash []byte, work []byte) bool {
 	if err != nil {
 		panic("Unable to create hash")
 	}
+	if len(work) != 8 {
+		panic("Bad work length")
+	}
 
 	hash.Write(work)
 	hash.Write(block_hash)
@@ -320,11 +329,12 @@ func ValidateBlockWork(b Block) bool {
 	hash_bytes := b.RootHash().ToBytes()
 	work_bytes, _ := hex.DecodeString(string(b.GetWork()))
 
-	return ValidateWork(hash_bytes, utils.Reversed(work_bytes))
+	res := ValidateWork(hash_bytes, utils.Reversed(work_bytes))
+	return res
 }
 
-func GenerateWork(b Block) rai.Work {
-	block_hash := b.Hash().ToBytes()
+func GenerateWorkForHash(b rai.BlockHash) rai.Work {
+	block_hash := b.ToBytes()
 	work := []byte{0, 0, 0, 0, 0, 0, 0, 0}
 	for {
 		if ValidateWork(block_hash, work) {
@@ -334,6 +344,10 @@ func GenerateWork(b Block) rai.Work {
 	}
 }
 
+func GenerateWork(b Block) rai.Work {
+	return GenerateWorkForHash(b.Hash())
+}
+
 func incrementWork(work []byte) {
 	for i := 0; i < len(work)-1; i++ {
 		if work[i] < 255 {

blocks/blocks_test.go

@@ -62,7 +62,7 @@ func TestValidateWork(t *testing.T) {
 
 	live_block_hash, _ := address.AddressToPub(LiveGenesisBlock.Account)
 	live_work_bytes, _ := hex.DecodeString(string(LiveGenesisBlock.Work))
-	live_bad_work, _ := hex.DecodeString("00")
+	live_bad_work, _ := hex.DecodeString("0000000000000000")
 
 	if !ValidateBlockWork(LiveGenesisBlock) {
 		t.Errorf("Work validation failed for genesis block")

blocks/storage.go

@@ -152,12 +152,12 @@ func (b *ChangeBlock) GetBalance() uint128.Uint128 {
 }
 
 var Conn *sql.DB
-var Conf Config
+var Conf *Config
 
 func Init(config Config) {
 	var err error
 
-	Conf = config
+	Conf = &config
 	Conn, err = sql.Open("sqlite3", config.Path)
 	Conn.SetMaxOpenConns(1)
 	if err != nil {
@@ -170,7 +170,9 @@ func Init(config Config) {
 	}
 
 	if !table_check.Next() {
-		log.Println("Creating database schema")
+		if false {
+			log.Println("Creating database schema")
+		}
 		prep, err := Conn.Prepare(`
       CREATE TABLE 'block' (
         'hash' TEXT PRIMARY KEY,
@@ -205,7 +207,9 @@ func Init(config Config) {
 		panic(err)
 	}
 	if !rows.Next() {
-		log.Println("Storing genesis block")
+		if false {
+			log.Println("Storing genesis block")
+		}
 		StoreBlock(config.GenesisBlock)
 	}
 

node/node.go

@@ -3,13 +3,15 @@ package node
 import (
 	"bytes"
 	"errors"
+	"fmt"
+	"github.com/frankh/rai/blocks"
 )
 
 var MagicNumber = [2]byte{'R', 'C'}
 
 // Non-idiomatic constant names to keep consistent with reference implentation
 const (
-	Message_invalid uint8 = iota
+	Message_invalid byte = iota
 	Message_not_a_type
 	Message_keepalive
 	Message_publish
@@ -21,7 +23,7 @@ const (
 )
 
 const (
-	BlockType_invalid uint8 = iota
+	BlockType_invalid byte = iota
 	BlockType_not_a_block
 	BlockType_send
 	BlockType_receive
@@ -59,6 +61,62 @@ type MessagePublishChange struct {
 	MessageBlockChange
 }
 
+type MessagePublish interface {
+	Read(*bytes.Buffer) error
+	Write(*bytes.Buffer) error
+	ToBlock() blocks.Block
+}
+
+func messagePublishForHeader(header MessageHeader) (MessagePublish, error) {
+	var m MessagePublish
+	switch header.BlockType {
+	case BlockType_send:
+		var message MessagePublishSend
+		message.MessageHeader = header
+		m = &message
+	case BlockType_receive:
+		var message MessagePublishReceive
+		message.MessageHeader = header
+		m = &message
+	case BlockType_open:
+		var message MessagePublishOpen
+		message.MessageHeader = header
+		m = &message
+	case BlockType_change:
+		var message MessagePublishChange
+		message.MessageHeader = header
+		m = &message
+	default:
+		return nil, errors.New("Unknown block type")
+	}
+
+	return m, nil
+}
+
+func readMessagePublish(buf *bytes.Buffer) (MessagePublish, error) {
+	var header MessageHeader
+	err := header.ReadHeader(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	if header.MessageType != Message_publish {
+		return nil, errors.New("Tried to read wrong message type")
+	}
+
+	m, err := messagePublishForHeader(header)
+	if err != nil {
+		return nil, err
+	}
+
+	err = m.Read(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return m, nil
+}
+
 func (m *MessageHeader) WriteHeader(buf *bytes.Buffer) error {
 	var errs []error
 	errs = append(errs,
@@ -110,135 +168,103 @@ func (m *MessageHeader) ReadHeader(buf *bytes.Buffer) error {
 }
 
 func (m *MessagePublishOpen) Read(buf *bytes.Buffer) error {
-	err1 := m.MessageHeader.ReadHeader(buf)
 	if m.MessageHeader.BlockType != BlockType_open {
-		return errors.New("Wrong blocktype")
+		return errors.New(fmt.Sprintf("Wrong blocktype %d", m.MessageHeader.BlockType))
 	}
-	err2 := m.MessageBlockOpen.Read(buf)
+	err := m.MessageBlockOpen.Read(buf)
 
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
+	if err != nil {
+		return err
 	}
 
 	return nil
 }
 
 func (m *MessagePublishOpen) Write(buf *bytes.Buffer) error {
-	err1 := m.MessageHeader.WriteHeader(buf)
 	if m.MessageHeader.BlockType != BlockType_open {
-		return errors.New("Wrong blocktype")
+		return errors.New(fmt.Sprintf("Wrong blocktype %d", m.MessageHeader.BlockType))
 	}
-	err2 := m.MessageBlockOpen.Write(buf)
+	err := m.MessageBlockOpen.Write(buf)
 
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
+	if err != nil {
+		return err
 	}
 
 	return nil
 }
 
 func (m *MessagePublishSend) Read(buf *bytes.Buffer) error {
-	err1 := m.MessageHeader.ReadHeader(buf)
 	if m.MessageHeader.BlockType != BlockType_send {
-		return errors.New("Wrong blocktype")
+		return errors.New(fmt.Sprintf("Wrong blocktype %d", m.MessageHeader.BlockType))
 	}
-	err2 := m.MessageBlockSend.Read(buf)
+	err := m.MessageBlockSend.Read(buf)
 
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
+	if err != nil {
+		return err
 	}
 
 	return nil
 }
 
 func (m *MessagePublishSend) Write(buf *bytes.Buffer) error {
-	err1 := m.MessageHeader.WriteHeader(buf)
 	if m.MessageHeader.BlockType != BlockType_send {
-		return errors.New("Wrong blocktype")
+		return errors.New(fmt.Sprintf("Wrong blocktype %d", m.MessageHeader.BlockType))
 	}
-	err2 := m.MessageBlockSend.Write(buf)
+	err := m.MessageBlockSend.Write(buf)
 
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
+	if err != nil {
+		return err
 	}
 
 	return nil
 }
 func (m *MessagePublishReceive) Read(buf *bytes.Buffer) error {
-	err1 := m.MessageHeader.ReadHeader(buf)
 	if m.MessageHeader.BlockType != BlockType_receive {
-		return errors.New("Wrong blocktype")
+		return errors.New(fmt.Sprintf("Wrong blocktype %d", m.MessageHeader.BlockType))
 	}
-	err2 := m.MessageBlockReceive.Read(buf)
+	err := m.MessageBlockReceive.Read(buf)
 
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
+	if err != nil {
+		return err
 	}
 
 	return nil
 }
 
 func (m *MessagePublishReceive) Write(buf *bytes.Buffer) error {
-	err1 := m.MessageHeader.WriteHeader(buf)
 	if m.MessageHeader.BlockType != BlockType_receive {
-		return errors.New("Wrong blocktype")
+		return errors.New(fmt.Sprintf("Wrong blocktype %d", m.MessageHeader.BlockType))
 	}
-	err2 := m.MessageBlockReceive.Write(buf)
+	err := m.MessageBlockReceive.Write(buf)
 
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
+	if err != nil {
+		return err
 	}
 
 	return nil
 }
 
 func (m *MessagePublishChange) Read(buf *bytes.Buffer) error {
-	err1 := m.MessageHeader.ReadHeader(buf)
 	if m.MessageHeader.BlockType != BlockType_change {
-		return errors.New("Wrong blocktype")
+		return errors.New(fmt.Sprintf("Wrong blocktype %d", m.MessageHeader.BlockType))
 	}
-	err2 := m.MessageBlockChange.Read(buf)
+	err := m.MessageBlockChange.Read(buf)
 
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
+	if err != nil {
+		return err
 	}
 
 	return nil
 }
 
 func (m *MessagePublishChange) Write(buf *bytes.Buffer) error {
-	err1 := m.MessageHeader.WriteHeader(buf)
 	if m.MessageHeader.BlockType != BlockType_change {
-		return errors.New("Wrong blocktype")
+		return errors.New(fmt.Sprintf("Wrong blocktype %d", m.MessageHeader.BlockType))
 	}
-	err2 := m.MessageBlockChange.Write(buf)
+	err := m.MessageBlockChange.Write(buf)
 
-	if err1 != nil {
-		return err1
-	}
-	if err2 != nil {
-		return err2
+	if err != nil {
+		return err
 	}
 
 	return nil