path: root/core/types/dkg/dkg.go

// Copyright 2018 The dexon-consensus Authors
// This file is part of the dexon-consensus library.
//
// The dexon-consensus library is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// The dexon-consensus library is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
// General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the dexon-consensus library. If not, see
// <http://www.gnu.org/licenses/>.

package dkg

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"

    "github.com/dexon-foundation/dexon/rlp"

    "github.com/dexon-foundation/dexon-consensus/common"
    "github.com/dexon-foundation/dexon-consensus/core/crypto"
    cryptoDKG "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg"
    "github.com/dexon-foundation/dexon-consensus/core/types"
)

// PrivateShare describe a secret share in DKG protocol.
type PrivateShare struct {
    ProposerID   types.NodeID         `json:"proposer_id"`
    ReceiverID   types.NodeID         `json:"receiver_id"`
    Round        uint64               `json:"round"`
    PrivateShare cryptoDKG.PrivateKey `json:"private_share"`
    Signature    crypto.Signature     `json:"signature"`
}

// Equal checks equality between two PrivateShare instances.
func (p *PrivateShare) Equal(other *PrivateShare) bool {
    return p.ProposerID.Equal(other.ProposerID) &&
        p.ReceiverID.Equal(other.ReceiverID) &&
        p.Round == other.Round &&
        p.Signature.Type == other.Signature.Type &&
        bytes.Compare(p.Signature.Signature, other.Signature.Signature) == 0 &&
        bytes.Compare(
            p.PrivateShare.Bytes(), other.PrivateShare.Bytes()) == 0
}

// MasterPublicKey decrtibe a master public key in DKG protocol.
type MasterPublicKey struct {
    ProposerID      types.NodeID              `json:"proposer_id"`
    Round           uint64                    `json:"round"`
    DKGID           cryptoDKG.ID              `json:"dkg_id"`
    PublicKeyShares cryptoDKG.PublicKeyShares `json:"public_key_shares"`
    Signature       crypto.Signature          `json:"signature"`
}

func (d *MasterPublicKey) String() string {
    return fmt.Sprintf("MasterPublicKey{KP:%s Round:%d}",
        d.ProposerID.String()[:6],
        d.Round)
}

// Equal check equality of two DKG master public keys.
func (d *MasterPublicKey) Equal(other *MasterPublicKey) bool {
    return d.ProposerID.Equal(other.ProposerID) &&
        d.Round == other.Round &&
        d.DKGID.GetHexString() == other.DKGID.GetHexString() &&
        d.PublicKeyShares.Equal(&other.PublicKeyShares) &&
        d.Signature.Type == other.Signature.Type &&
        bytes.Compare(d.Signature.Signature, other.Signature.Signature) == 0
}

type rlpMasterPublicKey struct {
    ProposerID      types.NodeID
    Round           uint64
    DKGID           []byte
    PublicKeyShares *cryptoDKG.PublicKeyShares
    Signature       crypto.Signature
}

// EncodeRLP implements rlp.Encoder
func (d *MasterPublicKey) EncodeRLP(w io.Writer) error {
    return rlp.Encode(w, rlpMasterPublicKey{
        ProposerID:      d.ProposerID,
        Round:           d.Round,
        DKGID:           d.DKGID.GetLittleEndian(),
        PublicKeyShares: &d.PublicKeyShares,
        Signature:       d.Signature,
    })
}

// DecodeRLP implements rlp.Decoder
func (d *MasterPublicKey) DecodeRLP(s *rlp.Stream) error {
    var dec rlpMasterPublicKey
    if err := s.Decode(&dec); err != nil {
        return err
    }

    id, err := cryptoDKG.BytesID(dec.DKGID)
    if err != nil {
        return err
    }

    *d = MasterPublicKey{
        ProposerID:      dec.ProposerID,
        Round:           dec.Round,
        DKGID:           id,
        PublicKeyShares: *dec.PublicKeyShares,
        Signature:       dec.Signature,
    }
    return err
}

// NewMasterPublicKey returns a new MasterPublicKey instance.
func NewMasterPublicKey() *MasterPublicKey {
    return &MasterPublicKey{
        PublicKeyShares: *cryptoDKG.NewEmptyPublicKeyShares(),
    }
}

// UnmarshalJSON implements json.Unmarshaller.
func (d *MasterPublicKey) UnmarshalJSON(data []byte) error {
    type innertMasterPublicKey MasterPublicKey
    d.PublicKeyShares = *cryptoDKG.NewEmptyPublicKeyShares()
    return json.Unmarshal(data, (*innertMasterPublicKey)(d))
}

// Complaint describe a complaint in DKG protocol.
type Complaint struct {
    ProposerID   types.NodeID     `json:"proposer_id"`
    Round        uint64           `json:"round"`
    PrivateShare PrivateShare     `json:"private_share"`
    Signature    crypto.Signature `json:"signature"`
}

func (c *Complaint) String() string {
    if c.IsNack() {
        return fmt.Sprintf("DKGNackComplaint{CP:%s Round:%d PSP:%s}",
            c.ProposerID.String()[:6], c.Round,
            c.PrivateShare.ProposerID.String()[:6])
    }
    return fmt.Sprintf("DKGComplaint{CP:%s Round:%d PrivateShare:%v}",
        c.ProposerID.String()[:6], c.Round, c.PrivateShare)
}

// Equal checks equality between two Complaint instances.
func (c *Complaint) Equal(other *Complaint) bool {
    return c.ProposerID.Equal(other.ProposerID) &&
        c.Round == other.Round &&
        c.PrivateShare.Equal(&other.PrivateShare) &&
        c.Signature.Type == other.Signature.Type &&
        bytes.Compare(c.Signature.Signature, other.Signature.Signature) == 0
}

// PartialSignature describe a partial signature in DKG protocol.
type PartialSignature struct {
    ProposerID       types.NodeID               `json:"proposer_id"`
    Round            uint64                     `json:"round"`
    Hash             common.Hash                `json:"hash"`
    PartialSignature cryptoDKG.PartialSignature `json:"partial_signature"`
    Signature        crypto.Signature           `json:"signature"`
}

// MPKReady describe a dig ready message in DKG protocol.
type MPKReady struct {
    ProposerID types.NodeID     `json:"proposer_id"`
    Round      uint64           `json:"round"`
    Signature  crypto.Signature `json:"signature"`
}

func (ready *MPKReady) String() string {
    return fmt.Sprintf("DKGMPKReady{RP:%s Round:%d}",
        ready.ProposerID.String()[:6],
        ready.Round)
}

// Equal check equality of two MPKReady instances.
func (ready *MPKReady) Equal(other *MPKReady) bool {
    return ready.ProposerID.Equal(other.ProposerID) &&
        ready.Round == other.Round &&
        ready.Signature.Type == other.Signature.Type &&
        bytes.Compare(ready.Signature.Signature, other.Signature.Signature) == 0
}

// Finalize describe a dig finalize message in DKG protocol.
type Finalize struct {
    ProposerID types.NodeID     `json:"proposer_id"`
    Round      uint64           `json:"round"`
    Signature  crypto.Signature `json:"signature"`
}

func (final *Finalize) String() string {
    return fmt.Sprintf("DKGFinal{FP:%s Round:%d}",
        final.ProposerID.String()[:6],
        final.Round)
}

// Equal check equality of two Finalize instances.
func (final *Finalize) Equal(other *Finalize) bool {
    return final.ProposerID.Equal(other.ProposerID) &&
        final.Round == other.Round &&
        final.Signature.Type == other.Signature.Type &&
        bytes.Compare(final.Signature.Signature, other.Signature.Signature) == 0
}

// IsNack returns true if it's a nack complaint in DKG protocol.
func (c *Complaint) IsNack() bool {
    return len(c.PrivateShare.Signature.Signature) == 0
}