Candidate Register & Update with BLS pubkey (#4686)

Author: envestcc

Makefile

@@ -11,7 +11,7 @@ GOVET=$(GOCMD) vet
 GOBUILD=$(GOCMD) build
 GOINSTALL=$(GOCMD) install
 GOCLEAN=$(GOCMD) clean
-GOTEST=GOARCH=amd64 CGO_ENABLED=1 $(GOCMD) test
+GOTEST=CGO_ENABLED=1 $(GOCMD) test
 GOGET=$(GOCMD) get
 GOPATH=$(shell go env GOPATH)
 BUILD_TARGET_SERVER=server

action/builder.go

@@ -259,7 +259,7 @@ func (b *EnvelopeBuilder) BuildStakingAction(tx *types.Transaction) (Envelope, e
 	if err := b.setEnvelopeCommonFields(tx); err != nil {
 		return nil, err
 	}
-	act, err := newStakingActionFromABIBinary(tx.Data())
+	act, err := newStakingActionFromABIBinary(tx.Data(), tx.Value())
 	if err != nil {
 		return nil, err
 	}
@@ -283,7 +283,7 @@ func (b *EnvelopeBuilder) BuildRewardingAction(tx *types.Transaction) (Envelope,
 	return b.build(), nil
 }
 
-func newStakingActionFromABIBinary(data []byte) (actionPayload, error) {
+func newStakingActionFromABIBinary(data []byte, value *big.Int) (actionPayload, error) {
 	if len(data) <= 4 {
 		return nil, ErrInvalidABI
 	}
@@ -308,7 +308,7 @@ func newStakingActionFromABIBinary(data []byte) (actionPayload, error) {
 	if act, err := NewTransferStakeFromABIBinary(data); err == nil {
 		return act, nil
 	}
-	if act, err := NewCandidateRegisterFromABIBinary(data); err == nil {
+	if act, err := NewCandidateRegisterFromABIBinary(data, value); err == nil {
 		return act, nil
 	}
 	if act, err := NewCandidateUpdateFromABIBinary(data); err == nil {

action/candidate_register.go

@@ -11,6 +11,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/iotexproject/go-pkgs/crypto"
+	"github.com/iotexproject/go-pkgs/hash"
 	"github.com/iotexproject/iotex-address/address"
 	"github.com/iotexproject/iotex-proto/golang/iotextypes"
 	"github.com/pkg/errors"
@@ -28,7 +30,11 @@ const (
 
 var (
 	// _candidateRegisterInterface is the interface of the abi encoding of stake action
-	_candidateRegisterMethod abi.Method
+	_candidateRegisterMethod        abi.Method
+	_candidateRegisterWithBLSMethod abi.Method
+	_candidateRegisteredEvent       abi.Event
+	_stakedEvent                    abi.Event
+	_candidateActivatedEvent        abi.Event
 
 	// ErrInvalidAmount represents that amount is 0 or negative
 	ErrInvalidAmount = errors.New("invalid amount")
@@ -39,6 +45,9 @@ var (
 	// ErrInvalidOwner represents that owner address is invalid
 	ErrInvalidOwner = errors.New("invalid owner address")
 
+	// ErrInvalidBLSPubKey represents that BLS public key is invalid
+	ErrInvalidBLSPubKey = errors.New("invalid BLS public key")
+
 	_ EthCompatibleAction = (*CandidateRegister)(nil)
 	_ amountForCost       = (*CandidateRegister)(nil)
 )
@@ -54,6 +63,7 @@ type CandidateRegister struct {
 	duration        uint32
 	autoStake       bool
 	payload         []byte
+	pubKey          []byte // BLS public key
 }
 
 func init() {
@@ -62,6 +72,22 @@ func init() {
 	if !ok {
 		panic("fail to load the method")
 	}
+	_candidateRegisterWithBLSMethod, ok = NativeStakingContractABI().Methods["candidateRegisterWithBLS"]
+	if !ok {
+		panic("fail to load the method")
+	}
+	_candidateRegisteredEvent, ok = NativeStakingContractABI().Events["CandidateRegistered"]
+	if !ok {
+		panic("fail to load the event")
+	}
+	_stakedEvent, ok = NativeStakingContractABI().Events["Staked"]
+	if !ok {
+		panic("fail to load the event")
+	}
+	_candidateActivatedEvent, ok = NativeStakingContractABI().Events["CandidateActivated"]
+	if !ok {
+		panic("fail to load the event")
+	}
 }
 
 // NewCandidateRegister creates a CandidateRegister instance
@@ -106,8 +132,18 @@ func NewCandidateRegister(
 	return cr, nil
 }
 
+// LegacyAmount returns the legacy amount
+func (cr *CandidateRegister) LegacyAmount() *big.Int {
+	return cr.amount
+}
+
 // Amount returns the amount
-func (cr *CandidateRegister) Amount() *big.Int { return cr.amount }
+func (cr *CandidateRegister) Amount() *big.Int {
+	if cr.WithBLS() {
+		return cr.value
+	}
+	return cr.amount
+}
 
 // Payload returns the payload bytes
 func (cr *CandidateRegister) Payload() []byte { return cr.payload }
@@ -130,6 +166,16 @@ func (cr *CandidateRegister) RewardAddress() address.Address { return cr.rewardA
 // OwnerAddress returns candidate ownerAddress to register
 func (cr *CandidateRegister) OwnerAddress() address.Address { return cr.ownerAddress }
 
+// WithBLS returns true if the candidate register action is with BLS public key
+func (cr *CandidateRegister) WithBLS() bool {
+	return len(cr.pubKey) > 0
+}
+
+// PubKey returns the BLS public key if the candidate register action is with BLS public key
+func (cr *CandidateRegister) PubKey() []byte {
+	return cr.pubKey
+}
+
 // Serialize returns a raw byte stream of the CandidateRegister struct
 func (cr *CandidateRegister) Serialize() []byte {
 	return byteutil.Must(proto.Marshal(cr.Proto()))
@@ -151,10 +197,6 @@ func (cr *CandidateRegister) Proto() *iotextypes.CandidateRegister {
 		AutoStake:      cr.autoStake,
 	}
 
-	if cr.amount != nil {
-		act.StakedAmount = cr.amount.String()
-	}
-
 	if cr.ownerAddress != nil {
 		act.OwnerAddress = cr.ownerAddress.String()
 	}
@@ -163,6 +205,20 @@ func (cr *CandidateRegister) Proto() *iotextypes.CandidateRegister {
 		act.Payload = make([]byte, len(cr.payload))
 		copy(act.Payload, cr.payload)
 	}
+
+	switch {
+	case cr.WithBLS():
+		act.Candidate.PubKey = make([]byte, len(cr.pubKey))
+		copy(act.Candidate.PubKey, cr.pubKey)
+		if cr.value != nil {
+			act.StakedAmount = cr.value.String()
+		}
+	default:
+		if cr.amount != nil {
+			act.StakedAmount = cr.amount.String()
+		}
+	}
+
 	return &act
 }
 
@@ -189,11 +245,21 @@ func (cr *CandidateRegister) LoadProto(pbAct *iotextypes.CandidateRegister) erro
 	cr.duration = pbAct.GetStakedDuration()
 	cr.autoStake = pbAct.GetAutoStake()
 
+	withBLS := len(pbAct.Candidate.GetPubKey()) > 0
+	if withBLS {
+		cr.pubKey = make([]byte, len(pbAct.Candidate.GetPubKey()))
+		copy(cr.pubKey, pbAct.Candidate.GetPubKey())
+	}
 	if len(pbAct.GetStakedAmount()) > 0 {
-		var ok bool
-		if cr.amount, ok = new(big.Int).SetString(pbAct.GetStakedAmount(), 10); !ok {
+		amount, ok := new(big.Int).SetString(pbAct.GetStakedAmount(), 10)
+		if !ok {
 			return errors.Errorf("invalid amount %s", pbAct.GetStakedAmount())
 		}
+		if withBLS {
+			cr.value = amount
+		} else {
+			cr.amount = amount
+		}
 	}
 
 	cr.payload = nil
@@ -209,6 +275,7 @@ func (cr *CandidateRegister) LoadProto(pbAct *iotextypes.CandidateRegister) erro
 		}
 		cr.ownerAddress = ownerAddr
 	}
+
 	return nil
 }
 
@@ -240,34 +307,127 @@ func (cr *CandidateRegister) EthData() ([]byte, error) {
 	if cr.ownerAddress == nil {
 		return nil, ErrAddress
 	}
-	data, err := _candidateRegisterMethod.Inputs.Pack(
-		cr.name,
-		common.BytesToAddress(cr.operatorAddress.Bytes()),
-		common.BytesToAddress(cr.rewardAddress.Bytes()),
-		common.BytesToAddress(cr.ownerAddress.Bytes()),
-		cr.amount,
-		cr.duration,
-		cr.autoStake,
-		cr.payload)
+	switch {
+	case cr.WithBLS():
+		data, err := _candidateRegisterWithBLSMethod.Inputs.Pack(
+			cr.name,
+			common.BytesToAddress(cr.operatorAddress.Bytes()),
+			common.BytesToAddress(cr.rewardAddress.Bytes()),
+			common.BytesToAddress(cr.ownerAddress.Bytes()),
+			cr.amount,
+			cr.duration,
+			cr.autoStake,
+			cr.pubKey,
+			cr.payload)
+		if err != nil {
+			return nil, err
+		}
+		return append(_candidateRegisterMethod.ID, data...), nil
+	default:
+		data, err := _candidateRegisterMethod.Inputs.Pack(
+			cr.name,
+			common.BytesToAddress(cr.operatorAddress.Bytes()),
+			common.BytesToAddress(cr.rewardAddress.Bytes()),
+			common.BytesToAddress(cr.ownerAddress.Bytes()),
+			cr.amount,
+			cr.duration,
+			cr.autoStake,
+			cr.payload)
+		if err != nil {
+			return nil, err
+		}
+		return append(_candidateRegisterMethod.ID, data...), nil
+	}
+}
+
+// PackCandidateRegisteredEvent packs the CandidateRegisterWithBLS event
+func PackCandidateRegisteredEvent(
+	candidate,
+	operatorAddress,
+	ownerAddress address.Address,
+	name string,
+	rewardAddress address.Address,
+	blsPublicKey []byte,
+) (Topics, []byte, error) {
+	data, err := _candidateRegisteredEvent.Inputs.NonIndexed().Pack(
+		operatorAddress.Bytes(),
+		name,
+		rewardAddress.Bytes(),
+		blsPublicKey,
+	)
 	if err != nil {
-		return nil, err
+		return nil, nil, errors.Wrap(err, "failed to pack CandidateRegisterWithBLS event")
+	}
+	topics := make(Topics, 3)
+	topics[0] = hash.Hash256(_candidateRegisteredEvent.ID)
+	topics[1] = hash.Hash256(candidate.Bytes())
+	topics[2] = hash.Hash256(ownerAddress.Bytes())
+	return topics, data, nil
+}
+
+func PackStakedEvent(
+	voter,
+	candidate address.Address,
+	bucketIndex uint64,
+	amount *big.Int,
+	duration uint32,
+	autoStake bool) (Topics, []byte, error) {
+	data, err := _stakedEvent.Inputs.NonIndexed().Pack(
+		bucketIndex,
+		amount,
+		duration,
+		autoStake,
+	)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to pack Staked event")
+	}
+	topics := make(Topics, 3)
+	topics[0] = hash.Hash256(_stakedEvent.ID)
+	topics[1] = hash.Hash256(voter.Bytes())
+	topics[2] = hash.Hash256(candidate.Bytes())
+	return topics, data, nil
+}
+
+func PackCandidateActivatedEvent(
+	candidate address.Address, bucketIndex uint64,
+) (Topics, []byte, error) {
+	data, err := _candidateActivatedEvent.Inputs.NonIndexed().Pack(
+		bucketIndex,
+	)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to pack CandidateActivated event")
 	}
-	return append(_candidateRegisterMethod.ID, data...), nil
+	topics := make(Topics, 2)
+	topics[0] = hash.Hash256(_candidateActivatedEvent.ID)
+	topics[1] = hash.Hash256(candidate.Bytes())
+	return topics, data, nil
 }
 
 // NewCandidateRegisterFromABIBinary decodes data into CandidateRegister action
-func NewCandidateRegisterFromABIBinary(data []byte) (*CandidateRegister, error) {
+func NewCandidateRegisterFromABIBinary(data []byte, value *big.Int) (*CandidateRegister, error) {
 	var (
 		paramsMap = map[string]interface{}{}
 		ok        bool
 		err       error
 		cr        CandidateRegister
+		method    abi.Method
+		withBLS   bool
 	)
 	// sanity check
-	if len(data) <= 4 || !bytes.Equal(_candidateRegisterMethod.ID, data[:4]) {
+	if len(data) <= 4 {
 		return nil, errDecodeFailure
 	}
-	if err := _candidateRegisterMethod.Inputs.UnpackIntoMap(paramsMap, data[4:]); err != nil {
+	switch {
+	case bytes.Equal(_candidateRegisterMethod.ID, data[:4]):
+		method = _candidateRegisterMethod
+	case bytes.Equal(_candidateRegisterWithBLSMethod.ID, data[:4]):
+		method = _candidateRegisterWithBLSMethod
+		withBLS = true
+	default:
+		return nil, errDecodeFailure
+	}
+	// common fields parsing
+	if err := method.Inputs.UnpackIntoMap(paramsMap, data[4:]); err != nil {
 		return nil, err
 	}
 	if cr.name, ok = paramsMap["name"].(string); !ok {
@@ -282,9 +442,6 @@ func NewCandidateRegisterFromABIBinary(data []byte) (*CandidateRegister, error)
 	if cr.ownerAddress, err = ethAddrToNativeAddr(paramsMap["ownerAddress"]); err != nil {
 		return nil, err
 	}
-	if cr.amount, ok = paramsMap["amount"].(*big.Int); !ok {
-		return nil, errDecodeFailure
-	}
 	if cr.duration, ok = paramsMap["duration"].(uint32); !ok {
 		return nil, errDecodeFailure
 	}
@@ -294,6 +451,26 @@ func NewCandidateRegisterFromABIBinary(data []byte) (*CandidateRegister, error)
 	if cr.payload, ok = paramsMap["data"].([]byte); !ok {
 		return nil, errDecodeFailure
 	}
+	// specific fields parsing for methods
+	if withBLS {
+		if value != nil {
+			cr.value.Set(value)
+		}
+		if cr.pubKey, ok = paramsMap["pubKey"].([]byte); !ok {
+			return nil, errors.Wrapf(errDecodeFailure, "invalid pubKey %+v", paramsMap["pubKey"])
+		}
+		if len(cr.pubKey) == 0 {
+			return nil, errors.Wrap(errDecodeFailure, "pubKey is empty")
+		}
+		_, err := crypto.BLS12381PublicKeyFromBytes(cr.pubKey)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to parse BLS public key")
+		}
+	} else {
+		if cr.amount, ok = paramsMap["amount"].(*big.Int); !ok {
+			return nil, errDecodeFailure
+		}
+	}
 	return &cr, nil
 }