Add unmarshal to types (#528)

* Add unmarshal to types

Author: bamzedev

internal/block/assurance.go

@@ -1,8 +1,11 @@
 package block
 
 import (
+	"io"
+
 	"github.com/eigerco/strawberry/internal/constants"
 	"github.com/eigerco/strawberry/internal/crypto"
+	"github.com/eigerco/strawberry/pkg/serialization/codec/jam"
 )
 
 const AvailBitfieldBytes = (constants.TotalNumberOfCores + 7) / 8 // (cores-count + 7) / 8
@@ -23,6 +26,23 @@ type Assurance struct {
 	Signature      crypto.Ed25519Signature  // Ed25519 signature (s ∈ V̄)
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (a *Assurance) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, a.Anchor[:]); err != nil {
+		return err
+	}
+	if _, err := io.ReadFull(r, a.Bitfield[:]); err != nil {
+		return err
+	}
+	buf := make([]byte, 2)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return err
+	}
+	a.ValidatorIndex = jam.DecodeUint16(buf)
+	_, err := io.ReadFull(r, a.Signature[:])
+	return err
+}
+
 type AssurancesExtrinsic []Assurance
 
 // IsForCore checks if the validator has assured availability for a specific core.

internal/block/dispute.go

@@ -1,10 +1,13 @@
 package block
 
 import (
+	"io"
+
 	"github.com/eigerco/strawberry/internal/constants"
 	"github.com/eigerco/strawberry/internal/crypto"
 	"github.com/eigerco/strawberry/internal/crypto/ed25519"
 	"github.com/eigerco/strawberry/internal/jamtime"
+	"github.com/eigerco/strawberry/pkg/serialization/codec/jam"
 )
 
 // DisputeExtrinsic represents the structured input for submitting disputes.
@@ -37,13 +40,44 @@ type Verdict struct {
 	Judgements [constants.ValidatorsSuperMajority]Judgement // ⟦{{⊺,⊥}, NV, V̄}⟧⌊2/3V⌋+1
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (v *Verdict) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, v.ReportHash[:]); err != nil {
+		return err
+	}
+	buf := make([]byte, 4)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return err
+	}
+	v.EpochIndex = jamtime.Epoch(jam.DecodeUint32(buf))
+	for i := range v.Judgements {
+		if err := v.Judgements[i].UnmarshalJAM(r); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // Culprit represents misbehaving guarantor who guaranteed an invalid work-report
 type Culprit struct {
 	ReportHash                crypto.Hash             // H, hash of the work report
 	ValidatorEd25519PublicKey ed25519.PublicKey       // H̄
 	Signature                 crypto.Ed25519Signature // V̄
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (c *Culprit) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, c.ReportHash[:]); err != nil {
+		return err
+	}
+	c.ValidatorEd25519PublicKey = make([]byte, crypto.Ed25519PublicSize)
+	if _, err := io.ReadFull(r, c.ValidatorEd25519PublicKey); err != nil {
+		return err
+	}
+	_, err := io.ReadFull(r, c.Signature[:])
+	return err
+}
+
 // Fault is an Auditor who made incorrect judgment
 type Fault struct {
 	ReportHash                crypto.Hash             // H, hash of the work report
@@ -52,17 +86,60 @@ type Fault struct {
 	Signature                 crypto.Ed25519Signature // V̄
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (f *Fault) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, f.ReportHash[:]); err != nil {
+		return err
+	}
+	b := make([]byte, 1)
+	if _, err := io.ReadFull(r, b); err != nil {
+		return err
+	}
+	f.IsValid = b[0] != 0
+	f.ValidatorEd25519PublicKey = make([]byte, crypto.Ed25519PublicSize)
+	if _, err := io.ReadFull(r, f.ValidatorEd25519PublicKey); err != nil {
+		return err
+	}
+	_, err := io.ReadFull(r, f.Signature[:])
+	return err
+}
+
 // Judgement is a statement from an auditor that declares whether a given work-report is valid or invalid
 type Judgement struct {
 	IsValid        bool                    // {⊺,⊥}
 	ValidatorIndex uint16                  // NV
 	Signature      crypto.Ed25519Signature // V̄
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (j *Judgement) UnmarshalJAM(r io.Reader) error {
+	buf := make([]byte, 3)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return err
+	}
+	j.IsValid = buf[0] != 0
+	j.ValidatorIndex = jam.DecodeUint16(buf[1:3])
+	_, err := io.ReadFull(r, j.Signature[:])
+	return err
+}
+
 // VerdictSummary V is a sequence of (report_hash, vote_count) pairs
 // where vote_count must be exactly one of: 0, ⌊V/3⌋, or ⌊2V/3⌋+1
 // V ∈ ⟦⟨H, {0, ⌊1/3V⌋, ⌊2/3V⌋ + 1}⟩⟧ (eq. 10.11 v0.7.0)
 type VerdictSummary struct {
 	ReportHash crypto.Hash // H
 	VoteCount  uint16      // Must be 0, V/3, or 2V/3+1
 }
+
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (vs *VerdictSummary) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, vs.ReportHash[:]); err != nil {
+		return err
+	}
+	buf := make([]byte, 2)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return err
+	}
+	vs.VoteCount = jam.DecodeUint16(buf)
+	return nil
+}

internal/block/guarantee.go

@@ -2,6 +2,7 @@ package block
 
 import (
 	"fmt"
+	"io"
 
 	"github.com/eigerco/strawberry/internal/constants"
 	"github.com/eigerco/strawberry/internal/crypto"
@@ -30,6 +31,17 @@ type CredentialSignature struct {
 	Signature      crypto.Ed25519Signature // The Ed25519 signature
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (cs *CredentialSignature) UnmarshalJAM(r io.Reader) error {
+	buf := make([]byte, 2)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return err
+	}
+	cs.ValidatorIndex = jam.DecodeUint16(buf)
+	_, err := io.ReadFull(r, cs.Signature[:])
+	return err
+}
+
 // WorkReport represents a work report in the JAM state
 // R ≡ {s ∈ Y, c ∈ C, c ∈ NC, a ∈ H, t ∈ B, l ∈ ⟦H → H⟧, d ∈ ⟦D⟧1:I, g ∈ NG} (eq. 11.2 v 0.7.0)
 // E(rs, rc, rc, ra, rg , ↕rt, ↕rl, ↕rd)
@@ -53,6 +65,30 @@ type AvailabilitySpecification struct {
 	SegmentCount              uint16      // Segment count (n)
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (as *AvailabilitySpecification) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, as.WorkPackageHash[:]); err != nil {
+		return err
+	}
+	buf := make([]byte, 4)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return err
+	}
+	as.AuditableWorkBundleLength = jam.DecodeUint32(buf)
+	if _, err := io.ReadFull(r, as.ErasureRoot[:]); err != nil {
+		return err
+	}
+	if _, err := io.ReadFull(r, as.SegmentRoot[:]); err != nil {
+		return err
+	}
+	buf2 := make([]byte, 2)
+	if _, err := io.ReadFull(r, buf2); err != nil {
+		return err
+	}
+	as.SegmentCount = jam.DecodeUint16(buf2)
+	return nil
+}
+
 // RefinementContext describes the context of the chain at the point that the report's corresponding work-package was evaluated.
 //
 //	C ≡ {a ∈ H, s ∈ H, b ∈ H, l ∈ H, t ∈ NT, p ∈ {[H]}} (eq. 11.4 v 0.7.0)
@@ -69,12 +105,37 @@ type RefinementContextAnchor struct {
 	PosteriorBeefyRoot crypto.Hash // Posterior beefy root (b)
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (rca *RefinementContextAnchor) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, rca.HeaderHash[:]); err != nil {
+		return err
+	}
+	if _, err := io.ReadFull(r, rca.PosteriorStateRoot[:]); err != nil {
+		return err
+	}
+	_, err := io.ReadFull(r, rca.PosteriorBeefyRoot[:])
+	return err
+}
+
 // l ∈ H, t ∈ N_T
 type RefinementContextLookupAnchor struct {
 	HeaderHash crypto.Hash      // HeaderHash of the anchor (l)
 	Timeslot   jamtime.Timeslot // Timeslot (t)
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (rcla *RefinementContextLookupAnchor) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, rcla.HeaderHash[:]); err != nil {
+		return err
+	}
+	buf := make([]byte, 4)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return err
+	}
+	rcla.Timeslot = jamtime.Timeslot(jam.DecodeUint32(buf))
+	return nil
+}
+
 // GuarantorAssignments represents the mapping of validators to cores and their keys
 // M ∈ {⟦NC⟧V, ⟦H̄⟧V} (eq. 11.18 v 0.7.0)
 type GuarantorAssignments struct {

internal/block/header.go

@@ -2,6 +2,7 @@ package block
 
 import (
 	"fmt"
+	"io"
 
 	"github.com/eigerco/strawberry/internal/crypto/ed25519"
 
@@ -30,6 +31,16 @@ type ValidatorKeys struct {
 	Ed25519      ed25519.PublicKey
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (vk *ValidatorKeys) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, vk.Bandersnatch[:]); err != nil {
+		return err
+	}
+	vk.Ed25519 = make([]byte, crypto.Ed25519PublicSize)
+	_, err := io.ReadFull(r, vk.Ed25519)
+	return err
+}
+
 // EpochMarker consists of epoch randomness and a sequence of
 // Bandersnatch keys defining the Bandersnatch validator keys (kb) beginning in the next epoch.
 type EpochMarker struct {
@@ -38,8 +49,34 @@ type EpochMarker struct {
 	Keys           [constants.NumberOfValidators]ValidatorKeys
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (em *EpochMarker) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, em.Entropy[:]); err != nil {
+		return err
+	}
+	if _, err := io.ReadFull(r, em.TicketsEntropy[:]); err != nil {
+		return err
+	}
+	for i := range em.Keys {
+		if err := em.Keys[i].UnmarshalJAM(r); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 type WinningTicketMarker [constants.TimeslotsPerEpoch]Ticket
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (wtm *WinningTicketMarker) UnmarshalJAM(r io.Reader) error {
+	for i := range wtm {
+		if err := wtm[i].UnmarshalJAM(r); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // Hash returns the hash of the header
 func (h Header) Hash() (crypto.Hash, error) {
 	jamBytes, err := jam.Marshal(h)

internal/block/ticket.go

@@ -1,6 +1,10 @@
 package block
 
-import "github.com/eigerco/strawberry/internal/crypto"
+import (
+	"io"
+
+	"github.com/eigerco/strawberry/internal/crypto"
+)
 
 const (
 	TicketProofSize = 784 // Size of F̄[]γz⟨XT ⌢ η′2 r⟩
@@ -12,6 +16,19 @@ type Ticket struct {
 	EntryIndex uint8                         // r ∈ Nn (0, 1)
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (t *Ticket) UnmarshalJAM(r io.Reader) error {
+	if _, err := io.ReadFull(r, t.Identifier[:]); err != nil {
+		return err
+	}
+	b := make([]byte, 1)
+	if _, err := io.ReadFull(r, b); err != nil {
+		return err
+	}
+	t.EntryIndex = b[0]
+	return nil
+}
+
 func (t Ticket) TicketOrKeyType() {}
 
 // TicketProof represents a proof of a valid ticket
@@ -20,6 +37,17 @@ type TicketProof struct {
 	Proof      [TicketProofSize]byte // RingVRF proof
 }
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (tp *TicketProof) UnmarshalJAM(r io.Reader) error {
+	b := make([]byte, 1)
+	if _, err := io.ReadFull(r, b); err != nil {
+		return err
+	}
+	tp.EntryIndex = b[0]
+	_, err := io.ReadFull(r, tp.Proof[:])
+	return err
+}
+
 // TicketExtrinsic represents the E_T extrinsic
 type TicketExtrinsic struct {
 	TicketProofs []TicketProof

internal/crypto/hash.go

@@ -2,14 +2,22 @@ package crypto
 
 import (
 	"encoding/hex"
-	"golang.org/x/crypto/blake2b"
-	"golang.org/x/crypto/sha3"
+	"io"
 	"log"
 	"strings"
+
+	"golang.org/x/crypto/blake2b"
+	"golang.org/x/crypto/sha3"
 )
 
 type Hash [HashSize]byte
 
+// UnmarshalJAM implements the JAM codec Unmarshaler interface.
+func (h *Hash) UnmarshalJAM(r io.Reader) error {
+	_, err := io.ReadFull(r, h[:])
+	return err
+}
+
 func HashData(data []byte) Hash {
 	hash := blake2b.Sum256(data)
 	return hash