wip: start using version

Author: rootulp

pkg/prove/proof.go

@@ -13,12 +13,12 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-// TxInclusion uses the provided block data to progressively generate rows
-// of a data square, and then using those shares to creates nmt inclusion proofs
-// It is possible that a transaction spans more than one row. In that case, we
-// have to return two proofs.
+// TxInclusion uses the provided block data to progressively generate rows of a
+// data square, and then uses those shares to creates nmt inclusion proofs. It
+// is possible that a transaction spans more than one row. In that case, we have
+// to return two proofs.
 func TxInclusion(codec rsmt2d.Codec, data types.Data, txIndex uint64) (types.TxProof, error) {
-	// calculate the index of the shares that contain the tx
+	// calculate the positions of the shares that contain this tx
 	startPos, endPos, err := txSharePosition(data.Txs, txIndex)
 	if err != nil {
 		return types.TxProof{}, err
@@ -90,8 +90,9 @@ func TxInclusion(codec rsmt2d.Codec, data types.Data, txIndex uint64) (types.TxP
 	}, nil
 }
 
-// txSharePosition returns the share that a given transaction is included in.
-// returns an error if index is greater than that of the provided txs.
+// txSharePosition returns the start and end positions for the shares that
+// include the given transaction. Returns an error if txIndex is greater than
+// the number of transactions.
 func txSharePosition(txs types.Txs, txIndex uint64) (startSharePos, endSharePos uint64, err error) {
 	if txIndex >= uint64(len(txs)) {
 		return startSharePos, endSharePos, errors.New("transaction index is greater than the number of txs")
@@ -144,8 +145,8 @@ func genRowShares(codec rsmt2d.Codec, data types.Data, startRow, endRow uint64)
 }
 
 // genOrigRowShares progressively generates data square rows for the original
-// data square, meaning the rows only half the full square length, as there is
-// not erasure data
+// data square, meaning the rows only fill half the full square length, as there
+// is no erasure data.
 func genOrigRowShares(data types.Data, startRow, endRow uint64) [][]byte {
 	wantLen := (endRow + 1) * data.OriginalSquareSize
 	startPos := startRow * data.OriginalSquareSize
@@ -168,7 +169,7 @@ func genOrigRowShares(data types.Data, startRow, endRow uint64) [][]byte {
 		if err != nil {
 			panic(fmt.Sprintf("app accepted a Message that can not be encoded %#v", m))
 		}
-		shares = types.AppendToShares(shares, m.NamespaceID, rawData)
+		shares = types.AppendToShares(shares, m.NamespaceID, m.Version, rawData)
 
 		// return if we have enough shares
 		if uint64(len(shares)) >= wantLen {

types/block.go

@@ -1189,7 +1189,7 @@ func (msgs Messages) SplitIntoShares() NamespacedShares {
 		if err != nil {
 			panic(fmt.Sprintf("app accepted a Message that can not be encoded %#v", m))
 		}
-		shares = AppendToShares(shares, m.NamespaceID, rawData)
+		shares = AppendToShares(shares, m.NamespaceID, m.Version, rawData)
 	}
 	return shares
 }
@@ -1215,6 +1215,10 @@ type Message struct {
 	// Data is the actual data contained in the message
 	// (e.g. a block of a virtual sidechain).
 	Data []byte
+
+	// Version defines the the message format specification version of this
+	// message. Version is a number between 0 and 127 (inclusive).
+	Version uint8
 }
 
 var (
@@ -1226,9 +1230,14 @@ func MessageFromProto(p *tmproto.Message) Message {
 	if p == nil {
 		return MessageEmpty
 	}
+	if p.Version > 127 {
+		// TODO (throw an error here)
+		return MessageEmpty
+	}
 	return Message{
 		NamespaceID: p.NamespaceId,
 		Data:        p.Data,
+		Version:     uint8(p.Version),
 	}
 }
 
@@ -1288,6 +1297,7 @@ func (data *Data) ToProto() tmproto.Data {
 		protoMsgs[i] = &tmproto.Message{
 			NamespaceId: msg.NamespaceID,
 			Data:        msg.Data,
+			Version:     uint32(msg.Version),
 		}
 	}
 	tp.Messages = tmproto.Messages{MessagesList: protoMsgs}
@@ -1319,7 +1329,7 @@ func DataFromProto(dp *tmproto.Data) (Data, error) {
 	if len(dp.Messages.MessagesList) > 0 {
 		msgs := make([]Message, len(dp.Messages.MessagesList))
 		for i, m := range dp.Messages.MessagesList {
-			msgs[i] = Message{NamespaceID: m.NamespaceId, Data: m.Data}
+			msgs[i] = Message{NamespaceID: m.NamespaceId, Data: m.Data, Version: uint8(m.Version)}
 		}
 		data.Messages = Messages{MessagesList: msgs}
 	} else {

types/block_test.go

@@ -682,10 +682,12 @@ func TestBlockDataProtobuf(t *testing.T) {
 				{
 					NamespaceID: []byte{8, 7, 6, 5, 4, 3, 2, 1},
 					Data:        stdbytes.Repeat([]byte{3, 2, 1, 0}, 100),
+					Version:     uint8(0),
 				},
 				{
 					NamespaceID: []byte{1, 2, 3, 4, 5, 6, 7, 8},
 					Data:        stdbytes.Repeat([]byte{1, 2, 3}, 100),
+					Version:     uint8(0),
 				},
 			},
 		},

types/share_splitting.go

@@ -28,7 +28,7 @@ func (msw *MessageShareWriter) Write(msg Message) {
 		panic(fmt.Sprintf("app accepted a Message that can not be encoded %#v", msg))
 	}
 	newShares := make([]NamespacedShare, 0)
-	newShares = AppendToShares(newShares, msg.NamespaceID, rawMsg)
+	newShares = AppendToShares(newShares, msg.NamespaceID, msg.Version, rawMsg)
 	msw.shares = append(msw.shares, newShares)
 	msw.count += len(newShares)
 }
@@ -58,27 +58,33 @@ func (msw *MessageShareWriter) Count() int {
 	return msw.count
 }
 
-// appendToShares appends raw data as shares.
-// Used for messages.
-func AppendToShares(shares []NamespacedShare, nid namespace.ID, rawData []byte) []NamespacedShare {
+// AppendToShares appends raw data as shares. Used for messages.
+func AppendToShares(shares []NamespacedShare, nid namespace.ID, version uint8, rawData []byte) []NamespacedShare {
 	if len(rawData) <= consts.MsgShareSize {
-		rawShare := append(append(
-			make([]byte, 0, len(nid)+len(rawData)),
+		isMessageStart := true
+		infoReservedByte, err := NewInfoReservedByte(version, isMessageStart)
+		if err != nil {
+			// TODO (propogate this error?)
+			panic(err)
+		}
+		rawShare := append(append(append(
+			make([]byte, 0, len(nid)+consts.InfoReservedBytes+len(rawData)),
 			nid...),
+			byte(infoReservedByte)),
 			rawData...,
 		)
 		paddedShare := zeroPadIfNecessary(rawShare, consts.ShareSize)
 		share := NamespacedShare{paddedShare, nid}
 		shares = append(shares, share)
 	} else { // len(rawData) > MsgShareSize
-		shares = append(shares, splitMessage(rawData, nid)...)
+		shares = append(shares, splitMessage(rawData, nid, version)...)
 	}
 	return shares
 }
 
 // splitMessage breaks the data in a message into the minimum number of
 // namespaced shares
-func splitMessage(rawData []byte, nid namespace.ID) NamespacedShares {
+func splitMessage(rawData []byte, nid namespace.ID, version uint8) NamespacedShares {
 	shares := make([]NamespacedShare, 0)
 	firstRawShare := append(append(
 		make([]byte, 0, consts.ShareSize),

types/shares.go

@@ -15,6 +15,11 @@ type NamespacedShare struct {
 	ID namespace.ID
 }
 
+type MessageShare struct {
+	NamespacedShare
+	Info byte
+}
+
 func (n NamespacedShare) NamespaceID() namespace.ID {
 	return n.ID
 }
@@ -24,7 +29,7 @@ func (n NamespacedShare) Data() []byte {
 }
 
 // NamespacedShares is just a list of NamespacedShare elements.
-// It can be used to extract the raw raw shares.
+// It can be used to extract the raw shares.
 type NamespacedShares []NamespacedShare
 
 // RawShares returns the raw shares that can be fed into the erasure coding