chore (pkg/scale) integrate scale into dot/network and dot/digest

dot/digest/digest.go

@@ -23,8 +23,8 @@ import (
 	"math/big"
 
 	"github.com/ChainSafe/gossamer/dot/types"
-	"github.com/ChainSafe/gossamer/lib/scale"
 	"github.com/ChainSafe/gossamer/lib/services"
+	"github.com/ChainSafe/gossamer/pkg/scale"
 
 	log "github.com/ChainSafe/log15"
 )
@@ -298,12 +298,11 @@ func (h *Handler) handleScheduledChange(d *types.ConsensusDigest, header *types.
 		return nil
 	}
 
-	sc := &types.GrandpaScheduledChange{}
-	dec, err := scale.Decode(d.Data[1:], sc)
+	var sc *types.GrandpaScheduledChange
+	err = scale.Unmarshal(d.Data[1:], &sc)
 	if err != nil {
 		return err
 	}
-	sc = dec.(*types.GrandpaScheduledChange)
 
 	logger.Debug("handling GrandpaScheduledChange", "data", sc)
 
@@ -339,12 +338,11 @@ func (h *Handler) handleForcedChange(d *types.ConsensusDigest, header *types.Hea
 		return errors.New("already have forced change scheduled")
 	}
 
-	fc := &types.GrandpaForcedChange{}
-	dec, err := scale.Decode(d.Data[1:], fc)
+	var fc *types.GrandpaForcedChange
+	err := scale.Unmarshal(d.Data[1:], &fc)
 	if err != nil {
 		return err
 	}
-	fc = dec.(*types.GrandpaForcedChange)
 
 	logger.Debug("handling GrandpaForcedChange", "data", fc)
 
@@ -373,12 +371,11 @@ func (h *Handler) handlePause(d *types.ConsensusDigest) error {
 		return err
 	}
 
-	p := &types.GrandpaPause{}
-	dec, err := scale.Decode(d.Data[1:], p)
+	var p *types.GrandpaPause
+	err = scale.Unmarshal(d.Data[1:], &p)
 	if err != nil {
 		return err
 	}
-	p = dec.(*types.GrandpaPause)
 
 	delay := big.NewInt(int64(p.Delay))
 
@@ -395,12 +392,11 @@ func (h *Handler) handleResume(d *types.ConsensusDigest) error {
 		return err
 	}
 
-	p := &types.GrandpaResume{}
-	dec, err := scale.Decode(d.Data[1:], p)
+	var p *types.GrandpaResume
+	err = scale.Unmarshal(d.Data[1:], &p)
 	if err != nil {
 		return err
 	}
-	p = dec.(*types.GrandpaResume)
 
 	delay := big.NewInt(int64(p.Delay))
 
@@ -432,12 +428,11 @@ func (h *Handler) handleBABEOnDisabled(d *types.ConsensusDigest, _ *types.Header
 }
 
 func (h *Handler) handleNextEpochData(d *types.ConsensusDigest, header *types.Header) error {
-	od := &types.NextEpochData{}
-	dec, err := scale.Decode(d.Data[1:], od)
+	var od *types.NextEpochData
+	err := scale.Unmarshal(d.Data[1:], &od)
 	if err != nil {
 		return err
 	}
-	od = dec.(*types.NextEpochData)
 
 	logger.Debug("handling BABENextEpochData", "data", od)
 
@@ -457,12 +452,11 @@ func (h *Handler) handleNextEpochData(d *types.ConsensusDigest, header *types.He
 }
 
 func (h *Handler) handleNextConfigData(d *types.ConsensusDigest, header *types.Header) error {
-	od := &types.NextConfigData{}
-	dec, err := scale.Decode(d.Data[1:], od)
+	var od *types.NextConfigData
+	err := scale.Unmarshal(d.Data[1:], &od)
 	if err != nil {
 		return err
 	}
-	od = dec.(*types.NextConfigData)
 
 	logger.Debug("handling BABENextConfigData", "data", od)
 

dot/network/block_announce.go

@@ -17,14 +17,13 @@
 package network
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"math/big"
 
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/common"
-	"github.com/ChainSafe/gossamer/lib/scale"
+	"github.com/ChainSafe/gossamer/pkg/scale"
 
 	"github.com/libp2p/go-libp2p-core/peer"
 )
@@ -66,7 +65,7 @@ func (bm *BlockAnnounceMessage) String() string {
 
 // Encode a BlockAnnounce Msg Type containing the BlockAnnounceMessage using scale.Encode
 func (bm *BlockAnnounceMessage) Encode() ([]byte, error) {
-	enc, err := scale.Encode(bm)
+	enc, err := scale.Marshal(*bm)
 	if err != nil {
 		return enc, err
 	}
@@ -75,31 +74,16 @@ func (bm *BlockAnnounceMessage) Encode() ([]byte, error) {
 
 // Decode the message into a BlockAnnounceMessage
 func (bm *BlockAnnounceMessage) Decode(in []byte) error {
-	r := &bytes.Buffer{}
-	_, _ = r.Write(in)
-	h, err := types.NewEmptyHeader().Decode(r)
+	err := scale.Unmarshal(in, bm)
 	if err != nil {
 		return err
 	}
-
-	bm.ParentHash = h.ParentHash
-	bm.Number = h.Number
-	bm.StateRoot = h.StateRoot
-	bm.ExtrinsicsRoot = h.ExtrinsicsRoot
-	bm.Digest = h.Digest
-	bestBlock, err := common.ReadByte(r)
-	if err != nil {
-		return err
-	}
-
-	bm.BestBlock = bestBlock == 1
 	return nil
 }
 
 // Hash returns the hash of the BlockAnnounceMessage
 func (bm *BlockAnnounceMessage) Hash() common.Hash {
-	// scale encode each extrinsic
-	encMsg, _ := bm.Encode()
+	encMsg, _ := scale.Marshal(*bm)
 	hash, _ := common.Blake2bHash(encMsg)
 	return hash
 }
@@ -110,22 +94,23 @@ func (bm *BlockAnnounceMessage) IsHandshake() bool {
 }
 
 func decodeBlockAnnounceHandshake(in []byte) (Handshake, error) {
-	hs, err := scale.Decode(in, new(BlockAnnounceHandshake))
+	var hs BlockAnnounceHandshake
+	err := scale.Unmarshal(in, &hs)
 	if err != nil {
 		return nil, err
 	}
 
-	return hs.(*BlockAnnounceHandshake), err
+	return &hs, err
 }
 
 func decodeBlockAnnounceMessage(in []byte) (NotificationsMessage, error) {
-	msg := new(BlockAnnounceMessage)
-	err := msg.Decode(in)
+	var msg BlockAnnounceMessage
+	err := scale.Unmarshal(in, &msg)
 	if err != nil {
 		return nil, err
 	}
 
-	return msg, nil
+	return &msg, nil
 }
 
 // BlockAnnounceHandshake is exchanged by nodes that are beginning the BlockAnnounce protocol
@@ -152,20 +137,15 @@ func (hs *BlockAnnounceHandshake) String() string {
 
 // Encode encodes a BlockAnnounceHandshake message using SCALE
 func (hs *BlockAnnounceHandshake) Encode() ([]byte, error) {
-	return scale.Encode(hs)
+	return scale.Marshal(*hs)
 }
 
 // Decode the message into a BlockAnnounceHandshake
 func (hs *BlockAnnounceHandshake) Decode(in []byte) error {
-	msg, err := scale.Decode(in, hs)
+	err := scale.Unmarshal(in, hs)
 	if err != nil {
 		return err
 	}
-
-	hs.Roles = msg.(*BlockAnnounceHandshake).Roles
-	hs.BestBlockNumber = msg.(*BlockAnnounceHandshake).BestBlockNumber
-	hs.BestBlockHash = msg.(*BlockAnnounceHandshake).BestBlockHash
-	hs.GenesisHash = msg.(*BlockAnnounceHandshake).GenesisHash
 	return nil
 }
 

dot/network/block_announce_test.go

@@ -35,19 +35,22 @@ func TestBlockAnnounce_Encode(t *testing.T) {
 		Number:         big.NewInt(77),
 		StateRoot:      common.Hash{2},
 		ExtrinsicsRoot: common.Hash{3},
-		Digest:         types.Digest{},
+		Digest:         types.Digest(nil),
 	}
 
 	enc, err := testBlockAnnounce.Encode()
 	require.NoError(t, err)
 
-	res := &BlockAnnounceMessage{
-		Number: big.NewInt(0),
-		Digest: types.Digest{},
-	}
+	enc2 := enc
+
+	res := new(BlockAnnounceMessage)
 	err = res.Decode(enc)
 	require.NoError(t, err)
 	require.Equal(t, testBlockAnnounce, res)
+
+	res2, err := decodeBlockAnnounceMessage(enc2)
+	require.NoError(t, err)
+	require.Equal(t, res2, res)
 }
 
 func TestDecodeBlockAnnounceHandshake(t *testing.T) {
@@ -72,7 +75,7 @@ func TestDecodeBlockAnnounceMessage(t *testing.T) {
 		Number:         big.NewInt(77),
 		StateRoot:      common.Hash{2},
 		ExtrinsicsRoot: common.Hash{3},
-		Digest:         types.Digest{},
+		Digest:         types.Digest(nil),
 	}
 
 	enc, err := testBlockAnnounce.Encode()

dot/network/light.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/ChainSafe/gossamer/lib/common"
 	"github.com/ChainSafe/gossamer/lib/common/optional"
-	"github.com/ChainSafe/gossamer/lib/scale"
+	"github.com/ChainSafe/gossamer/pkg/scale"
 )
 
 // Pair is a pair of arbitrary bytes.
@@ -40,22 +40,17 @@ func (l *LightRequest) SubProtocol() string {
 }
 
 // Encode encodes a LightRequest message using SCALE and appends the type byte to the start
+// TODO Remove encode/decode receiver functions
 func (l *LightRequest) Encode() ([]byte, error) {
-	return scale.Encode(l)
+	return scale.Marshal(*l)
 }
 
 // Decode the message into a LightRequest, it assumes the type byte has been removed
 func (l *LightRequest) Decode(in []byte) error {
-	msg, err := scale.Decode(in, l)
+	err := scale.Unmarshal(in, l)
 	if err != nil {
 		return err
 	}
-
-	l.RmtCallRequest = msg.(*LightRequest).RmtCallRequest
-	l.RmtReadRequest = msg.(*LightRequest).RmtReadRequest
-	l.RmtHeaderRequest = msg.(*LightRequest).RmtHeaderRequest
-	l.RmtReadChildRequest = msg.(*LightRequest).RmtReadChildRequest
-	l.RmtChangesRequest = msg.(*LightRequest).RmtChangesRequest
 	return nil
 }
 
@@ -92,20 +87,15 @@ func (l *LightResponse) SubProtocol() string {
 
 // Encode encodes a LightResponse message using SCALE and appends the type byte to the start
 func (l *LightResponse) Encode() ([]byte, error) {
-	return scale.Encode(l)
+	return scale.Marshal(*l)
 }
 
 // Decode the message into a LightResponse, it assumes the type byte has been removed
 func (l *LightResponse) Decode(in []byte) error {
-	msg, err := scale.Decode(in, l)
+	err := scale.Unmarshal(in, l)
 	if err != nil {
 		return err
 	}
-
-	l.RmtCallResponse = msg.(*LightResponse).RmtCallResponse
-	l.RmtReadResponse = msg.(*LightResponse).RmtReadResponse
-	l.RmtHeaderResponse = msg.(*LightResponse).RmtHeaderResponse
-	l.RmtChangeResponse = msg.(*LightResponse).RmtChangeResponse
 	return nil
 }
 

dot/network/message.go

@@ -26,7 +26,7 @@ import (
 	"github.com/ChainSafe/gossamer/lib/common"
 	"github.com/ChainSafe/gossamer/lib/common/optional"
 	"github.com/ChainSafe/gossamer/lib/common/variadic"
-	"github.com/ChainSafe/gossamer/lib/scale"
+	"github.com/ChainSafe/gossamer/pkg/scale"
 
 	"google.golang.org/protobuf/proto"
 )
@@ -311,12 +311,13 @@ func protobufToBlockData(pbd *pb.BlockData) (*types.BlockData, error) {
 	}
 
 	if pbd.Header != nil {
-		header, err := scale.Decode(pbd.Header, types.NewEmptyHeader())
+		var header types.Header
+		err := scale.Unmarshal(pbd.Header, &header)
 		if err != nil {
 			return nil, err
 		}
 
-		bd.Header = header.(*types.Header).AsOptional()
+		bd.Header = header.AsOptional()
 	}
 
 	if pbd.Body != nil {

dot/network/message_test.go

@@ -98,13 +98,14 @@ func TestEncodeBlockRequestMessage_NoOptionals(t *testing.T) {
 func TestEncodeBlockResponseMessage_WithHeader(t *testing.T) {
 	hash := common.NewHash([]byte{0})
 	testHash := common.NewHash([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf})
+	d := types.Digest(nil)
 
 	header := &optional.CoreHeader{
 		ParentHash:     testHash,
 		Number:         big.NewInt(1),
 		StateRoot:      testHash,
 		ExtrinsicsRoot: testHash,
-		Digest:         &types.Digest{},
+		Digest:         &d,
 	}
 
 	bd := &types.BlockData{
@@ -132,13 +133,14 @@ func TestEncodeBlockResponseMessage_WithHeader(t *testing.T) {
 func TestEncodeBlockResponseMessage_WithBody(t *testing.T) {
 	hash := common.NewHash([]byte{0})
 	testHash := common.NewHash([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf})
+	d := types.Digest(nil)
 
 	header := &optional.CoreHeader{
 		ParentHash:     testHash,
 		Number:         big.NewInt(1),
 		StateRoot:      testHash,
 		ExtrinsicsRoot: testHash,
-		Digest:         &types.Digest{},
+		Digest:         &d,
 	}
 
 	exts := [][]byte{{1, 3, 5, 7}, {9, 1, 2}, {3, 4, 5}}
@@ -170,13 +172,14 @@ func TestEncodeBlockResponseMessage_WithBody(t *testing.T) {
 func TestEncodeBlockResponseMessage_WithAll(t *testing.T) {
 	hash := common.NewHash([]byte{0})
 	testHash := common.NewHash([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf})
+	d := types.Digest(nil)
 
 	header := &optional.CoreHeader{
 		ParentHash:     testHash,
 		Number:         big.NewInt(1),
 		StateRoot:      testHash,
 		ExtrinsicsRoot: testHash,
-		Digest:         &types.Digest{},
+		Digest:         &d,
 	}
 
 	exts := [][]byte{{16, 1, 3, 5, 7}, {12, 9, 1, 2}, {12, 3, 4, 5}}
@@ -231,7 +234,7 @@ func TestEncodeBlockAnnounceMessage(t *testing.T) {
 		Number:         big.NewInt(1),
 		StateRoot:      stateRoot,
 		ExtrinsicsRoot: extrinsicsRoot,
-		Digest:         types.Digest{},
+		Digest:         types.Digest(nil),
 	}
 	encMsg, err := bhm.Encode()
 	require.Nil(t, err)
@@ -262,7 +265,7 @@ func TestDecode_BlockAnnounceMessage(t *testing.T) {
 		Number:         big.NewInt(1),
 		StateRoot:      stateRoot,
 		ExtrinsicsRoot: extrinsicsRoot,
-		Digest:         types.Digest{},
+		Digest:         types.Digest(nil),
 	}
 
 	require.Equal(t, expected, bhm)