sharding/utils : Adding RLP encoding (ethereum#92)

sharding/collation.go

@@ -115,15 +115,41 @@ func (c *Collation) CalculateChunkRoot() {
 	c.header.data.ChunkRoot = &chunkRoot
 }
 
+func (c *Collation) CreateRawBlobs() ([]*utils.RawBlob, error) {
+
+	// It does not skip evm execution by default
+
+	blobs := make([]*utils.RawBlob, len(c.transactions))
+	for i, v := range c.transactions {
+
+		err := error(nil)
+		blobs[i], err = utils.NewRawBlob(v, false)
+
+		if err != nil {
+			return nil, fmt.Errorf("Creation of raw blobs from transactions failed %v", err)
+		}
+
+	}
+
+	return blobs, nil
+
+}
+
 // Serialize method  serializes the collation body
 func (c *Collation) Serialize() ([]byte, error) {
 
-	blob, err := utils.ConvertToRawBlob(c.transactions)
+	/*blob, err := utils.ConvertToRawBlob(c.transactions)
+	if err != nil {
+		return nil, fmt.Errorf("%v", err)
+	}**/
+
+	blobs, err := c.CreateRawBlobs()
+
 	if err != nil {
 		return nil, fmt.Errorf("%v", err)
 	}
 
-	serializedtx, err := utils.Serialize(blob)
+	serializedtx, err := utils.Serialize(blobs)
 
 	if err != nil {
 		return nil, fmt.Errorf("%v", err)
@@ -137,3 +163,12 @@ func (c *Collation) Serialize() ([]byte, error) {
 	return serializedtx, nil
 
 }
+
+func (c *Collation) Deserialize(serialisedblob []byte) error {
+	var blobs []utils.RawBlob
+
+	deserializedblobs, err := utils.Deserialize(serialisedblob)
+	if err != nil {
+		return fmt.Errorf("%v", err)
+	}
+}

sharding/collation_test.go

@@ -2,6 +2,8 @@ package sharding
 
 import (
 	"math/big"
+	//"github.com/ethereum/go-ethereum/rlp"
+	//"reflect"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -52,8 +54,25 @@ func TestSerialize(t *testing.T) {
 			c.AddTransaction(tx)
 		}
 
-		results, err := c.Serialize()
+		/*var tests *types.Transaction
+		yadd := reflect.ValueOf(*c.transactions[3])
+		d := yadd.FieldByName("data").FieldByName("Hash")
+
+		test, err := rlp.EncodeToBytes(c.transactions[3])
 		if err != nil {
+			t.Fatalf("%v\n %v\n %v", err, test, *(c.transactions[0]))
+		}
+		erx := rlp.DecodeBytes(test, &tests)
+
+		dd := reflect.ValueOf(*tests)
+		cv := dd.FieldByName("data").FieldByName("Hash")
+
+		if cv != d {
+			t.Fatalf("%v\n %v\n %v", erx, cv, d)
+		} */
+
+		results, err := c.Serialize()
+		if err == nil {
 			t.Fatalf("%v\n %v\n %v", err, results, c.transactions)
 		}
 

sharding/utils/marshal.go

@@ -2,6 +2,7 @@ package utils
 
 import (
 	"fmt"
+	"github.com/ethereum/go-ethereum/rlp"
 )
 
 var (
@@ -21,27 +22,22 @@ type RawBlob struct {
 	data  []byte
 }
 
-/*
-* Might be needed in part 2 of serialisation
-* ConvertInterface converts inputted interface to the required type of interface, ex: slice.
-func ConvertInterfacetoBytes(arg interface{}) ([]byte, error) {
-	val := reflect.ValueOf(arg)
-	if val.Kind() == reflect.Slice {
-
-		length := val.Len()
-		newtype := make([]byte, length)
-		for i := 0; i < length; i++ {
-			newtype[i] = val.Index(i).Interface().(byte)
-		}
-
-		return newtype, nil
+func NewRawBlob(i interface{}, skipevm bool) (*RawBlob, error) {
+	data, err := rlp.EncodeToBytes(i)
+	if err != nil {
+		return nil, fmt.Errorf("RLP encoding was a failure:%v", err)
+	}
+	return &RawBlob{data: data, flags: Flags{skipEvmExecution: skipevm}}, nil
+}
 
+func ConvertfromRawBlob(blob RawBlob, i interface{}) error {
+	err := rlp.DecodeBytes(blob.data, i)
+	if err != nil {
+		return fmt.Errorf("RLP decoding was a failure:%v", err)
 	}
-	err := errors.New("Interface Conversion a failure")
-	return nil, err
 
+	return nil
 }
-*/
 
 // ConvertToRawBlob will convert any supported type into a the RawBlob type.
 func ConvertToRawBlob(arg interface{}) ([]RawBlob, error) {
@@ -50,7 +46,7 @@ func ConvertToRawBlob(arg interface{}) ([]RawBlob, error) {
 }
 
 // serializeBlob parses the blob and serializes it appropriately.
-func serializeBlob(cb RawBlob) ([]byte, error) {
+func SerializeBlob(cb RawBlob) ([]byte, error) {
 
 	length := int64(len(cb.data))
 	terminalLength := length % chunkDataSize
@@ -133,7 +129,7 @@ func serializeBlob(cb RawBlob) ([]byte, error) {
 }
 
 // Serialize takes a set of blobs and converts them to a single byte array.
-func Serialize(rawblobs []RawBlob) ([]byte, error) {
+func Serialize(rawblobs []*RawBlob) ([]byte, error) {
 	length := int64(len(rawblobs))
 
 	serialisedData := []byte{}
@@ -142,7 +138,7 @@ func Serialize(rawblobs []RawBlob) ([]byte, error) {
 	for i := int64(0); i < length; i++ {
 
 		data := rawblobs[i]
-		refinedData, err := serializeBlob(data)
+		refinedData, err := SerializeBlob(*data)
 		if err != nil {
 			return nil, fmt.Errorf("Index %v :  %v", i, err)
 		}

sharding/utils/marshal_test.go

@@ -36,17 +36,6 @@ func buildblob(size int64) []byte {
 
 }
 
-/*
-Might be required in the future for part 2 of serialization
-
-func TestConvertInterface(t *testing.T) {
-	slice := []interface{}{0, 1, 2, 3, 4, 5}
-	convertedValue, err := ConvertInterface(slice, reflect.Slice)
-	if err != nil {
-		t.Fatalf("Error: %v %v", err, convertedValue)
-	}
-
-} */
 func TestSize(t *testing.T) {
 	for i := 0; i < 300; i++ {
 		size := int64(i)