Feat/slashing

core/sliceUtil/sliceUtil.go

@@ -9,3 +9,39 @@ func TrimSliceSliceByte(in [][]byte) [][]byte {
 	copy(ret, in)
 	return ret
 }
+
+// IsIndexSetInBitmap - checks if a bit is set(1) in the given bitmap
+func IsIndexSetInBitmap(index uint32, bitmap []byte) bool {
+	if isIndexOutOfBounds(index, bitmap) {
+		return false
+	}
+
+	byteInMap := getByteAtIndex(index, bitmap)
+	mask := calcByteMask(index)
+	return (*byteInMap & mask) != 0
+}
+
+func SetIndexInBitmap(index uint32, bitmap []byte) {
+	if isIndexOutOfBounds(index, bitmap) {
+		return
+	}
+
+	byteInMap := getByteAtIndex(index, bitmap)
+	mask := calcByteMask(index)
+	*byteInMap |= mask
+}
+
+// Could panic. Do not call this unless you check before if isIndexOutOfBounds == false
+func getByteAtIndex(index uint32, bitmap []byte) *byte {
+	bytePos := index / 8
+	return &bitmap[bytePos]
+}
+
+func calcByteMask(index uint32) byte {
+	bitPos := index % 8
+	return 1 << bitPos
+}
+
+func isIndexOutOfBounds(index uint32, bitmap []byte) bool {
+	return index >= uint32(len(bitmap))*8
+}

core/sliceUtil/sliceUtil_test.go

@@ -1,10 +1,12 @@
 package sliceUtil_test
 
 import (
+	"strconv"
 	"testing"
 
 	"github.com/ElrondNetwork/elrond-go-core/core/sliceUtil"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestTrimSliceSliceByte_EmptyInputShouldDoNothing(t *testing.T) {
@@ -49,3 +51,49 @@ func TestTrimSliceSliceByte_SliceAlreadyOkShouldDoNothing(t *testing.T) {
 	assert.Equal(t, 2, len(input))
 	assert.Equal(t, 2, cap(input))
 }
+
+func TestIsIndexSetInBitmap(t *testing.T) {
+	byte1Map, _ := strconv.ParseInt("11001101", 2, 9)
+	byte2Map, _ := strconv.ParseInt("00000101", 2, 9)
+	bitmap := []byte{byte(byte1Map), byte(byte2Map)}
+
+	//Byte 1
+	require.True(t, sliceUtil.IsIndexSetInBitmap(0, bitmap))
+	require.False(t, sliceUtil.IsIndexSetInBitmap(1, bitmap))
+	require.True(t, sliceUtil.IsIndexSetInBitmap(2, bitmap))
+	require.True(t, sliceUtil.IsIndexSetInBitmap(3, bitmap))
+	require.False(t, sliceUtil.IsIndexSetInBitmap(4, bitmap))
+	require.False(t, sliceUtil.IsIndexSetInBitmap(5, bitmap))
+	require.True(t, sliceUtil.IsIndexSetInBitmap(6, bitmap))
+	require.True(t, sliceUtil.IsIndexSetInBitmap(7, bitmap))
+	// Byte 2
+	require.True(t, sliceUtil.IsIndexSetInBitmap(8, bitmap))
+	require.False(t, sliceUtil.IsIndexSetInBitmap(9, bitmap))
+	require.True(t, sliceUtil.IsIndexSetInBitmap(10, bitmap))
+
+	for i := uint32(11); i <= 100; i++ {
+		require.False(t, sliceUtil.IsIndexSetInBitmap(i, bitmap))
+	}
+}
+
+func TestSetIndexInBitmap(t *testing.T) {
+	byte1Map, _ := strconv.ParseInt("11001101", 2, 9)
+	byte2Map, _ := strconv.ParseInt("00000101", 2, 9)
+	expectedBitMap := []byte{byte(byte1Map), byte(byte2Map)}
+
+	bitMap := make([]byte, 2)
+
+	sliceUtil.SetIndexInBitmap(0, bitMap)
+	sliceUtil.SetIndexInBitmap(2, bitMap)
+	sliceUtil.SetIndexInBitmap(3, bitMap)
+	sliceUtil.SetIndexInBitmap(6, bitMap)
+	sliceUtil.SetIndexInBitmap(7, bitMap)
+	sliceUtil.SetIndexInBitmap(8, bitMap)
+	sliceUtil.SetIndexInBitmap(10, bitMap)
+
+	for i := uint32(16); i <= 100; i++ {
+		sliceUtil.SetIndexInBitmap(i, bitMap)
+	}
+
+	require.Equal(t, expectedBitMap, bitMap)
+}

data/errors.go

@@ -78,3 +78,27 @@ var ErrScheduledRootHashNotSupported = errors.New("scheduled root hash is not su
 
 // ErrWrongTransactionsTypeSize signals that size of transactions type buffer from mini block reserved field is wrong
 var ErrWrongTransactionsTypeSize = errors.New("wrong transactions type size")
+
+// ErrNilSlashResult signals that a nil slash result has been provided
+var ErrNilSlashResult = errors.New("slash result is nil")
+
+// ErrNilHeaderHandler signals that a nil header handler has been provided
+var ErrNilHeaderHandler = errors.New("nil header handler")
+
+// ErrEmptyHeaderInfoList signals that an empty header info list has been provided
+var ErrEmptyHeaderInfoList = errors.New("empty header info list")
+
+// ErrNilHeaderInfo signals that a nil header info has been provided
+var ErrNilHeaderInfo = errors.New("nil header info")
+
+// ErrNilHash signals that a nil hash has been provided
+var ErrNilHash = errors.New("nil hash provided")
+
+// ErrHeadersSameHash signals that headers have the same hash in a multiple header proof
+var ErrHeadersSameHash = errors.New("headers have the same hash in a multiple header proof")
+
+// ErrNotEnoughHeadersProvided signals that not enough headers have been provided for a multiple header proof
+var ErrNotEnoughHeadersProvided = errors.New("not enough headers have been provided for a multiple header proof")
+
+// ErrNotEnoughPublicKeysProvided signals that not enough public keys have been provided for a multiple header proof
+var ErrNotEnoughPublicKeysProvided = errors.New("not enough public keys have been provided for a multiple header proof")

data/interface.go

@@ -84,6 +84,12 @@ type HeaderHandler interface {
 	IsInterfaceNil() bool
 }
 
+// HeaderInfoHandler defines a HeaderHandler and its corresponding hash
+type HeaderInfoHandler interface {
+	GetHeaderHandler() HeaderHandler
+	GetHash() []byte
+}
+
 // ShardHeaderHandler defines getters and setters for the shard block header
 type ShardHeaderHandler interface {
 	HeaderHandler
@@ -193,7 +199,7 @@ type EpochStartShardDataHandler interface {
 	SetPendingMiniBlockHeaders([]MiniBlockHeaderHandler) error
 }
 
-// EconomicHandler defines setters and getters for Economics
+// EconomicsHandler defines setters and getters for Economics
 type EconomicsHandler interface {
 	GetTotalSupply() *big.Int
 	GetTotalToDistribute() *big.Int

data/mock/headerInfoStub.go

@@ -0,0 +1,19 @@
+package mock
+
+import "github.com/ElrondNetwork/elrond-go-core/data"
+
+// HeaderInfoStub -
+type HeaderInfoStub struct {
+	Header data.HeaderHandler
+	Hash   []byte
+}
+
+// GetHeaderHandler -
+func (his *HeaderInfoStub) GetHeaderHandler() data.HeaderHandler {
+	return his.Header
+}
+
+// GetHash -
+func (his *HeaderInfoStub) GetHash() []byte {
+	return his.Hash
+}

data/slash/common.go

@@ -0,0 +1,125 @@
+package slash
+
+import (
+	"encoding/hex"
+	"fmt"
+	"sort"
+
+	"github.com/ElrondNetwork/elrond-go-core/core/check"
+	"github.com/ElrondNetwork/elrond-go-core/data"
+)
+
+// MinSlashableNoOfHeaders represents the min number of headers required for a
+// multiple proposal/signing proof to be considered slashable
+const MinSlashableNoOfHeaders = 2
+
+// SlashingResult contains the slashable data as well as the severity(slashing level)
+// for a possible malicious validator
+type SlashingResult struct {
+	SlashingLevel ThreatLevel
+	Headers       []data.HeaderInfoHandler
+}
+
+// ProofTxData represents necessary data to be used in a slashing commitment proof tx by a slashing notifier.
+// Each field is required to be added in a transaction.data field
+type ProofTxData struct {
+	Round   uint64
+	ShardID uint32
+	ProofID byte
+}
+
+// Used by slashing notifier to create a slashing transaction
+// from a proof. Each transaction identifies a different
+// slashing event based on this ID
+const (
+	// MultipleProposalProofID = MultipleProposal's ID
+	MultipleProposalProofID byte = 0x1
+	// MultipleSigningProofID = MultipleSigning's ID
+	MultipleSigningProofID byte = 0x2
+)
+
+const byteSize = 8
+
+// CalcBitmapSize returns the min required bitmap size, which
+// can hold a noOfBits
+func CalcBitmapSize(noOfBits int) uint32 {
+	bitmapSize := noOfBits / byteSize
+	if noOfBits%byteSize != 0 {
+		bitmapSize++
+	}
+	return uint32(bitmapSize)
+}
+
+func getSortedHeadersV2(headersInfo []data.HeaderInfoHandler) (*HeadersV2, error) {
+	sortedHeaders, err := sortHeaders(headersInfo)
+	if err != nil {
+		return nil, err
+	}
+
+	headersV2 := &HeadersV2{}
+	err = headersV2.SetHeaders(sortedHeaders)
+	if err != nil {
+		return nil, err
+	}
+
+	return headersV2, nil
+}
+
+func getHeaderHashIfUnique(headerInfo data.HeaderInfoHandler, hashes map[string]struct{}) (string, error) {
+	if headerInfo == nil {
+		return "", data.ErrNilHeaderInfo
+	}
+
+	hash := headerInfo.GetHash()
+	if hash == nil {
+		return "", data.ErrNilHash
+	}
+
+	headerHandler := headerInfo.GetHeaderHandler()
+	if check.IfNil(headerHandler) {
+		return "", fmt.Errorf("%w in header info for hash: %s", data.ErrNilHeaderHandler, hex.EncodeToString(hash))
+	}
+
+	hashStr := string(hash)
+	_, exists := hashes[hashStr]
+	if exists {
+		return "", fmt.Errorf("%w, duplicated hash: %s", data.ErrHeadersSameHash, hex.EncodeToString(hash))
+	}
+
+	return hashStr, nil
+}
+
+func sortHeaders(headersInfo []data.HeaderInfoHandler) ([]data.HeaderHandler, error) {
+	if len(headersInfo) == 0 {
+		return nil, data.ErrEmptyHeaderInfoList
+	}
+
+	sortHeadersByHash(headersInfo)
+	headers := make([]data.HeaderHandler, 0, len(headersInfo))
+	hashes := make(map[string]struct{})
+	for idx, headerInfo := range headersInfo {
+		hash, err := getHeaderHashIfUnique(headerInfo, hashes)
+		if err != nil {
+			return nil, fmt.Errorf("%w in sorted header list at index: %d", err, idx)
+		}
+
+		headers = append(headers, headerInfo.GetHeaderHandler())
+		hashes[hash] = struct{}{}
+	}
+
+	return headers, nil
+}
+
+func sortHeadersByHash(headersInfo []data.HeaderInfoHandler) {
+	sortFunc := func(i, j int) bool {
+		if headersInfo[i] == nil || headersInfo[j] == nil {
+			return false
+		}
+		hash1 := string(headersInfo[i].GetHash())
+		hash2 := string(headersInfo[j].GetHash())
+
+		return hash1 < hash2
+	}
+
+	sort.Slice(headersInfo, sortFunc)
+}