Deactivate process

Author: CoderZhi

action/action.go

@@ -114,7 +114,7 @@ func CalculateIntrinsicGas(baseIntrinsicGas uint64, payloadGas uint64, payloadSi
 // IsSystemAction determine whether input action belongs to system action
 func IsSystemAction(act *SealedEnvelope) bool {
 	switch act.Action().(type) {
-	case *GrantReward, *PutPollResult:
+	case *GrantReward, *PutPollResult, *ScheduleCandidateDeactivation:
 		return true
 	default:
 		return false

action/candidate_activate.go

@@ -17,7 +17,7 @@ var (
 	_                       EthCompatibleAction = (*CandidateActivate)(nil)
 )
 
-// CandidateActivate is the action to update a candidate's bucket
+// CandidateActivate is the action to activate a candidate
 type CandidateActivate struct {
 	stake_common
 	// bucketID is the bucket index want to be changed to
@@ -42,7 +42,7 @@ func NewCandidateActivate(bucketID uint64) *CandidateActivate {
 // BucketID returns the bucket index want to be changed to
 func (cr *CandidateActivate) BucketID() uint64 { return cr.bucketID }
 
-// IntrinsicGas returns the intrinsic gas of a CandidateRegister
+// IntrinsicGas returns the intrinsic gas of a CandidateActivate
 func (cr *CandidateActivate) IntrinsicGas() (uint64, error) {
 	return CandidateActivateBaseIntrinsicGas, nil
 }

action/candidate_deactivate.go

@@ -0,0 +1,129 @@
+package action
+
+import (
+	"bytes"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/iotexproject/iotex-proto/golang/iotextypes"
+	"github.com/pkg/errors"
+)
+
+const (
+	// CandidateDeactivateBaseIntrinsicGas represents the base intrinsic gas for CandidateActivate
+	CandidateDeactivateBaseIntrinsicGas = uint64(10000)
+
+	// CandidateDeactivateOpRequest is an operation to request deactivation
+	CandidateDeactivateOpRequest = iota
+	// CandidateDeactivateOpCancel is an operation to cancel deactivation
+	CandidateDeactivateOpCancel
+	// CandidateDeactivateOpConfirm is an operation to confirm deactivation
+	CandidateDeactivateOpConfirm
+)
+
+var (
+	requestCandidateDeactivationMethod abi.Method
+	cancelCandidateDeactivationMethod  abi.Method
+	confirmCandidateDeactivationMethod abi.Method
+	_                                  EthCompatibleAction = (*CandidateDeactivate)(nil)
+)
+
+type (
+	// CandidateDeactivateOp is operation type of candidate deactivation
+	CandidateDeactivateOp uint8
+	// CandidateDeactivate is the action to deactivate a candidate
+	CandidateDeactivate struct {
+		stake_common
+		op CandidateDeactivateOp
+	}
+)
+
+func init() {
+	var ok bool
+	methods := NativeStakingContractABI().Methods
+	requestCandidateDeactivationMethod, ok = methods["requestCandidateDeactivation"]
+	if !ok {
+		panic("fail to load the requestCandidateDeactivation method")
+	}
+	cancelCandidateDeactivationMethod, ok = methods["cancelCandidateDeactivation"]
+	if !ok {
+		panic("fail to load the cancelCandidateDeactivation method")
+	}
+}
+
+// NewCandidateDeactivate returns a CandidateDeactivate action
+func NewCandidateDeactivate() *CandidateDeactivate {
+	return &CandidateDeactivate{}
+}
+
+// IntrinsicGas returns the intrinsic gas of a CandidateDeactivate
+func (cd *CandidateDeactivate) IntrinsicGas() (uint64, error) {
+	return CandidateActivateBaseIntrinsicGas, nil
+}
+
+func (cd *CandidateDeactivate) SanityCheck() error {
+	return nil
+}
+
+func (cd *CandidateDeactivate) FillAction(act *iotextypes.ActionCore) {
+	act.Action = &iotextypes.ActionCore_CandidateDeactivate{CandidateDeactivate: cd.Proto()}
+}
+
+func (cd *CandidateDeactivate) Op() CandidateDeactivateOp {
+	return cd.op
+}
+
+// Proto converts CandidateDeactivate to protobuf's Action
+func (cd *CandidateDeactivate) Proto() *iotextypes.CandidateDeactivate {
+	return &iotextypes.CandidateDeactivate{
+		Op: uint32(cd.op),
+	}
+}
+
+// LoadProto converts a protobuf's Action to CandidateDeactivate
+func (cd *CandidateDeactivate) LoadProto(pbAct *iotextypes.CandidateDeactivate) error {
+	if pbAct == nil {
+		return ErrNilProto
+	}
+	cd.op = CandidateDeactivateOp(pbAct.GetOp())
+	return nil
+}
+
+// EthData returns the ABI-encoded data for converting to eth tx
+func (cd *CandidateDeactivate) EthData() ([]byte, error) {
+	var method abi.Method
+	switch cd.op {
+	case CandidateDeactivateOpCancel:
+		method = requestCandidateDeactivationMethod
+	case CandidateDeactivateOpRequest:
+		method = cancelCandidateDeactivationMethod
+	case CandidateDeactivateOpConfirm:
+		method = confirmCandidateDeactivationMethod
+	default:
+		return nil, errors.New("invalid operation")
+	}
+	data, err := method.Inputs.Pack()
+	if err != nil {
+		return nil, err
+	}
+	return append(method.ID, data...), nil
+}
+
+// NewCandidateDeactivateFromABIBinary parses the smart contract input and creates an action
+func NewCandidateDeactivateFromABIBinary(data []byte) (*CandidateDeactivate, error) {
+	var cd CandidateDeactivate
+	// sanity check
+	switch {
+	case len(data) <= 4:
+		return nil, errDecodeFailure
+	case bytes.Equal(requestCandidateDeactivationMethod.ID, data[:4]):
+		cd.op = CandidateDeactivateOpRequest
+	case bytes.Equal(cancelCandidateDeactivationMethod.ID, data[:4]):
+		cd.op = CandidateDeactivateOpCancel
+	case bytes.Equal(confirmCandidateDeactivationMethod.ID, data[:4]):
+		cd.op = CandidateDeactivateOpConfirm
+	default:
+		return nil, errDecodeFailure
+	}
+
+	return &cd, nil
+}

action/candidate_register.go

@@ -30,11 +30,15 @@ const (
 
 var (
 	// _candidateRegisterInterface is the interface of the abi encoding of stake action
-	_candidateRegisterMethod        abi.Method
-	_candidateRegisterWithBLSMethod abi.Method
-	_candidateRegisteredEvent       abi.Event
-	_stakedEvent                    abi.Event
-	_candidateActivatedEvent        abi.Event
+	_candidateRegisterMethod             abi.Method
+	_candidateRegisterWithBLSMethod      abi.Method
+	_candidateRegisteredEvent            abi.Event
+	_stakedEvent                         abi.Event
+	_candidateActivatedEvent             abi.Event
+	_candidateDeactivationRequestedEvent abi.Event
+	_candidateDeactivationCanceledEvent  abi.Event
+	_candidateDeactivationScheduledEvent abi.Event
+	_candidateDeactivatedEvent           abi.Event
 
 	// ErrInvalidAmount represents that amount is 0 or negative
 	ErrInvalidAmount = errors.New("invalid amount")
@@ -89,6 +93,22 @@ func init() {
 	if !ok {
 		panic("fail to load the event")
 	}
+	_candidateDeactivationRequestedEvent, ok = abi.Events["CandidateDeactivationRequested"]
+	if !ok {
+		panic("fail to load the event")
+	}
+	_candidateDeactivationCanceledEvent, ok = abi.Events["CandidateDeactivationCanceled"]
+	if !ok {
+		panic("fail to load the event")
+	}
+	_candidateDeactivationScheduledEvent, ok = abi.Events["CandidateDeactivationScheduled"]
+	if !ok {
+		panic("fail to load the event")
+	}
+	_candidateDeactivatedEvent, ok = abi.Events["CandidateDeactivated"]
+	if !ok {
+		panic("fail to load the event")
+	}
 }
 
 // NewCandidateRegister creates a CandidateRegister instance
@@ -426,6 +446,54 @@ func PackCandidateActivatedEvent(
 	return topics, data, nil
 }
 
+// PackCandidateDeactivationRequestedEvent packs the CandidateDeactivationRequested event
+func PackCandidateDeactivationRequestedEvent(candidate address.Address) (Topics, []byte, error) {
+	data, err := _candidateDeactivationRequestedEvent.Inputs.NonIndexed().Pack()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to pack CandidateDeactivationRequested event")
+	}
+	topics := make(Topics, 2)
+	topics[0] = hash.Hash256(_candidateDeactivationRequestedEvent.ID)
+	topics[1] = hash.BytesToHash256(candidate.Bytes())
+	return topics, data, nil
+}
+
+// PackCandidateDeactivationCanceledEvent packs the CandidateDeactivationCanceled event
+func PackCandidateDeactivationCanceledEvent(candidate address.Address) (Topics, []byte, error) {
+	data, err := _candidateDeactivationCanceledEvent.Inputs.NonIndexed().Pack()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to pack CandidateDeactivationCanceled event")
+	}
+	topics := make(Topics, 2)
+	topics[0] = hash.Hash256(_candidateDeactivationCanceledEvent.ID)
+	topics[1] = hash.BytesToHash256(candidate.Bytes())
+	return topics, data, nil
+}
+
+// PackCandidateDeactivationScheduledEvent packs the CandidateDeactivationScheduled event
+func PackCandidateDeactivationScheduledEvent(candidate address.Address, blkHeight uint64) (Topics, []byte, error) {
+	data, err := _candidateDeactivationScheduledEvent.Inputs.NonIndexed().Pack(blkHeight)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to pack ScheduleCandidateDeactivation event")
+	}
+	topics := make(Topics, 2)
+	topics[0] = hash.Hash256(_candidateDeactivationScheduledEvent.ID)
+	topics[1] = hash.BytesToHash256(candidate.Bytes())
+	return topics, data, nil
+}
+
+// PackCandidateDeactivatedEvent packs the CandidateDeactivated event
+func PackCandidateDeactivatedEvent(candidate address.Address) (Topics, []byte, error) {
+	data, err := _candidateDeactivatedEvent.Inputs.NonIndexed().Pack()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to pack CandidateDeactivated event")
+	}
+	topics := make(Topics, 2)
+	topics[0] = hash.Hash256(_candidateDeactivatedEvent.ID)
+	topics[1] = hash.BytesToHash256(candidate.Bytes())
+	return topics, data, nil
+}
+
 // NewCandidateRegisterFromABIBinary decodes data into CandidateRegister action
 func NewCandidateRegisterFromABIBinary(data []byte, value *big.Int) (*CandidateRegister, error) {
 	var (

action/candidateregister_test.go

@@ -275,6 +275,16 @@ func TestStakingEvent(t *testing.T) {
 		require.NoError(err)
 		checkActivatedEvent(require, topics, data, cand, bktIdx)
 	})
+	t.Run("deactivate", func(t *testing.T) {
+		topics, data, err := PackCandidateDeactivationRequestedEvent(cand)
+		require.NoError(err)
+		paramsNonIndexed, err := _candidateDeactivationRequestedEvent.Inputs.Unpack(data)
+		require.NoError(err)
+		require.Equal(0, len(paramsNonIndexed))
+		require.Equal(2, len(topics))
+		require.Equal(hash.Hash256(_candidateDeactivationRequestedEvent.ID), topics[0])
+		require.Equal(hash.BytesToHash256(cand.Bytes()), topics[1])
+	})
 	t.Run("update", func(t *testing.T) {
 		topics, data, err := PackCandidateUpdatedEvent(cand, operator, owner, name, reward, blsPubKey)
 		require.NoError(err)

action/native_staking_contract_abi.json

@@ -18,6 +18,64 @@
     "name": "CandidateActivated",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "candidate",
+        "type": "address"
+      }
+    ],
+    "name": "CandidateDeactivationRequested",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "candidate",
+        "type": "address"
+      }
+    ],
+    "name": "CandidateDeactivationCanceled",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "candidate",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint64",
+        "name": "blockNumber",
+        "type": "uint64"
+      }
+    ],
+    "name": "CandidateDeactivationScheduled",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "candidate",
+        "type": "address"
+      }
+    ],
+    "name": "CandidateDeactivated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -160,6 +218,20 @@
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "requestCandidateDeactivation",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "cancelCandidateDeactivation",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {

action/protocol/context.go

@@ -166,6 +166,7 @@ type (
 		CandidateSlashByOwner                   bool
 		CandidateBLSPublicKeyNotCopied          bool
 		OnlyOwnerCanUpdateBLSPublicKey          bool
+		NoCandidateExitQueue                    bool
 	}
 
 	// FeatureWithHeightCtx provides feature check functions.
@@ -335,6 +336,7 @@ func WithFeatureCtx(ctx context.Context) context.Context {
 			CandidateSlashByOwner:                   !g.IsXinguBeta(height),
 			CandidateBLSPublicKeyNotCopied:          !g.IsXinguBeta(height),
 			OnlyOwnerCanUpdateBLSPublicKey:          !g.IsToBeEnabled(height),
+			NoCandidateExitQueue:                    !g.IsToBeEnabled(height),
 		},
 	)
 }