Fix xingu

.github/workflows/ci.yaml

@@ -16,26 +16,20 @@ env:
 jobs:
   ci:
     name: ci flow
-    runs-on: self-hosted
-    container:
-      image: ubuntu:latest
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
         # with:
         #   submodules: recursive
 
-      - name: Install build tools
-        run: |
-          apt-get update
-          apt-get install -y build-essential ca-certificates
       - name: Set up Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         with:
           go-version: 1.23.0
           cache: false
-          
+
       - name: Build Go
-        run:  CGO_ENABLED=1 go build ./...
+        run: go build ./...
 
       - name: Run Test
         id: unittest

Makefile

@@ -256,7 +256,7 @@ recover:
 
 .PHONY: ioctl
 ioctl:
-	$(GOBUILD) -ldflags "$(PackageFlags)" -o ./bin/$(BUILD_TARGET_IOCTL) -v ./tools/ioctl
+	$(GOBUILD) -tags $(BUILD_TAGS) -ldflags "$(PackageFlags)" -o ./bin/$(BUILD_TARGET_IOCTL) -v ./tools/ioctl
 
 .PHONY: newioctl
 newioctl:

action/candidate_register.go

@@ -373,18 +373,18 @@ func PackCandidateRegisteredEvent(
 	blsPubKey []byte,
 ) (Topics, []byte, error) {
 	data, err := _candidateRegisteredEvent.Inputs.NonIndexed().Pack(
-		operatorAddress.Bytes(),
+		common.BytesToAddress(operatorAddress.Bytes()),
 		name,
-		rewardAddress.Bytes(),
+		common.BytesToAddress(rewardAddress.Bytes()),
 		blsPubKey,
 	)
 	if err != nil {
 		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())
+	topics[1] = hash.BytesToHash256(candidate.Bytes())
+	topics[2] = hash.BytesToHash256(ownerAddress.Bytes())
 	return topics, data, nil
 }
 
@@ -406,8 +406,8 @@ func PackStakedEvent(
 	}
 	topics := make(Topics, 3)
 	topics[0] = hash.Hash256(_stakedEvent.ID)
-	topics[1] = hash.Hash256(voter.Bytes())
-	topics[2] = hash.Hash256(candidate.Bytes())
+	topics[1] = hash.BytesToHash256(voter.Bytes())
+	topics[2] = hash.BytesToHash256(candidate.Bytes())
 	return topics, data, nil
 }
 
@@ -422,7 +422,7 @@ func PackCandidateActivatedEvent(
 	}
 	topics := make(Topics, 2)
 	topics[0] = hash.Hash256(_candidateActivatedEvent.ID)
-	topics[1] = hash.Hash256(candidate.Bytes())
+	topics[1] = hash.BytesToHash256(candidate.Bytes())
 	return topics, data, nil
 }
 

action/candidate_update.go

@@ -292,7 +292,7 @@ func PackCandidateUpdatedEvent(
 	blsPubKey []byte,
 ) (Topics, []byte, error) {
 	data, err := _candidateUpdateWithBLSEvent.Inputs.NonIndexed().Pack(
-		rewardAddress.Bytes(),
+		common.BytesToAddress(rewardAddress.Bytes()),
 		name,
 		common.BytesToAddress(operatorAddress.Bytes()),
 		blsPubKey,
@@ -302,7 +302,7 @@ func PackCandidateUpdatedEvent(
 	}
 	topics := make(Topics, 3)
 	topics[0] = hash.Hash256(_candidateUpdateWithBLSEvent.ID)
-	topics[1] = hash.Hash256(candidate.Bytes())
-	topics[2] = hash.Hash256(ownerAddress.Bytes())
+	topics[1] = hash.BytesToHash256(candidate.Bytes())
+	topics[2] = hash.BytesToHash256(ownerAddress.Bytes())
 	return topics, data, nil
 }

action/candidateregister_test.go

@@ -9,11 +9,14 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/proto"
 
 	"github.com/iotexproject/go-pkgs/crypto"
+	"github.com/iotexproject/go-pkgs/hash"
+	"github.com/iotexproject/iotex-address/address"
 
 	"github.com/iotexproject/iotex-core/v2/test/identityset"
 )
@@ -239,3 +242,102 @@ func TestIsValidCandidateName(t *testing.T) {
 		require.Equal(tt.output, output)
 	}
 }
+
+func TestStakingEvent(t *testing.T) {
+	require := require.New(t)
+	cand := identityset.Address(0)
+	owner := identityset.Address(1)
+	operator := identityset.Address(2)
+	reward := identityset.Address(3)
+	voter := identityset.Address(4)
+	blsPrivKey, err := crypto.GenerateBLS12381PrivateKey(identityset.PrivateKey(0).Bytes())
+	require.NoError(err)
+	blsPubKey := blsPrivKey.PublicKey().Bytes()
+	name := "test"
+
+	t.Run("register", func(t *testing.T) {
+		topics, data, err := PackCandidateRegisteredEvent(cand, operator, owner, name, reward, blsPubKey)
+		require.NoError(err)
+		checkCandidateRegisterEvent(require, topics, data, owner, cand, operator, reward, name, blsPubKey)
+	})
+	t.Run("staked", func(t *testing.T) {
+		bktIdx := uint64(1)
+		amount := big.NewInt(100)
+		duration := uint32(3600)
+		autoStake := true
+		topics, data, err := PackStakedEvent(voter, cand, bktIdx, amount, duration, autoStake)
+		require.NoError(err)
+		checkStakedEvent(require, topics, data, voter, cand, bktIdx, amount, duration, autoStake)
+	})
+	t.Run("activate", func(t *testing.T) {
+		bktIdx := uint64(1)
+		topics, data, err := PackCandidateActivatedEvent(cand, bktIdx)
+		require.NoError(err)
+		checkActivatedEvent(require, topics, data, cand, bktIdx)
+	})
+	t.Run("update", func(t *testing.T) {
+		topics, data, err := PackCandidateUpdatedEvent(cand, operator, owner, name, reward, blsPubKey)
+		require.NoError(err)
+		checkCandidateUpdateEvent(require, topics, data, owner, cand, operator, reward, name, blsPubKey)
+	})
+}
+
+func checkCandidateRegisterEvent(require *require.Assertions, topics Topics, data []byte,
+	owner, cand, operator, reward address.Address, name string, blsPubKey []byte,
+) {
+	paramsNonIndexed, err := _candidateRegisteredEvent.Inputs.Unpack(data)
+	require.NoError(err)
+	require.Equal(4, len(paramsNonIndexed))
+	require.Equal(operator.Bytes(), paramsNonIndexed[0].(common.Address).Bytes())
+	require.Equal(name, paramsNonIndexed[1].(string))
+	require.Equal(reward.Bytes(), paramsNonIndexed[2].(common.Address).Bytes())
+	require.Equal(blsPubKey, paramsNonIndexed[3].([]byte))
+	require.Equal(3, len(topics))
+	require.Equal(hash.Hash256(_candidateRegisteredEvent.ID), topics[0])
+	require.Equal(hash.BytesToHash256(cand.Bytes()), topics[1])
+	require.Equal(hash.BytesToHash256(owner.Bytes()), topics[2])
+}
+
+func checkStakedEvent(require *require.Assertions, topics Topics, data []byte,
+	voter, cand address.Address, bktIdx uint64, amount *big.Int, duration uint32, autoStake bool,
+) {
+	paramsNonIndexed, err := _stakedEvent.Inputs.Unpack(data)
+	require.NoError(err)
+	require.Equal(4, len(paramsNonIndexed))
+	require.Equal(bktIdx, paramsNonIndexed[0].(uint64))
+	require.Equal(amount, paramsNonIndexed[1].(*big.Int))
+	require.Equal(duration, paramsNonIndexed[2].(uint32))
+	require.Equal(autoStake, paramsNonIndexed[3].(bool))
+	require.Equal(3, len(topics))
+	require.Equal(hash.Hash256(_stakedEvent.ID), topics[0])
+	require.Equal(hash.BytesToHash256(voter.Bytes()), topics[1])
+	require.Equal(hash.BytesToHash256(cand.Bytes()), topics[2])
+}
+
+func checkActivatedEvent(require *require.Assertions, topics Topics, data []byte,
+	cand address.Address, bktIdx uint64,
+) {
+	paramsNonIndexed, err := _candidateActivatedEvent.Inputs.Unpack(data)
+	require.NoError(err)
+	require.Equal(1, len(paramsNonIndexed))
+	require.Equal(bktIdx, paramsNonIndexed[0].(uint64))
+	require.Equal(2, len(topics))
+	require.Equal(hash.Hash256(_candidateActivatedEvent.ID), topics[0])
+	require.Equal(hash.BytesToHash256(cand.Bytes()), topics[1])
+}
+
+func checkCandidateUpdateEvent(require *require.Assertions, topics Topics, data []byte,
+	owner, cand, operator, reward address.Address, name string, blsPubKey []byte,
+) {
+	paramsNonIndexed, err := _candidateUpdateWithBLSEvent.Inputs.Unpack(data)
+	require.NoError(err)
+	require.Equal(4, len(paramsNonIndexed))
+	require.Equal(reward.Bytes(), paramsNonIndexed[0].(common.Address).Bytes())
+	require.Equal(name, paramsNonIndexed[1].(string))
+	require.Equal(operator.Bytes(), paramsNonIndexed[2].(common.Address).Bytes())
+	require.Equal(blsPubKey, paramsNonIndexed[3].([]byte))
+	require.Equal(3, len(topics))
+	require.Equal(hash.Hash256(_candidateUpdateWithBLSEvent.ID), topics[0])
+	require.Equal(hash.BytesToHash256(cand.Bytes()), topics[1])
+	require.Equal(hash.BytesToHash256(owner.Bytes()), topics[2])
+}

action/protocol/context.go

@@ -163,6 +163,8 @@ type (
 		CandidateBLSPublicKey                   bool
 		NotUseMinSelfStakeToBeActive            bool
 		StoreVoteOfNFTBucketIntoView            bool
+		CandidateSlashByOwner                   bool
+		CandidateBLSPublicKeyNotCopied          bool
 	}
 
 	// FeatureWithHeightCtx provides feature check functions.
@@ -325,10 +327,12 @@ func WithFeatureCtx(ctx context.Context) context.Context {
 			TimestampedStakingContract:              g.IsWake(height),
 			PreStateSystemAction:                    !g.IsWake(height),
 			CreatePostActionStates:                  g.IsWake(height),
-			NotSlashUnproductiveDelegates:           !g.IsToBeEnabled(height),
-			CandidateBLSPublicKey:                   g.IsToBeEnabled(height),
-			NotUseMinSelfStakeToBeActive:            !g.IsToBeEnabled(height),
-			StoreVoteOfNFTBucketIntoView:            !g.IsToBeEnabled(height),
+			NotSlashUnproductiveDelegates:           !g.IsXingu(height),
+			CandidateBLSPublicKey:                   g.IsXingu(height),
+			NotUseMinSelfStakeToBeActive:            !g.IsXingu(height),
+			StoreVoteOfNFTBucketIntoView:            !g.IsXingu(height),
+			CandidateSlashByOwner:                   !g.IsXinguBeta(height),
+			CandidateBLSPublicKeyNotCopied:          !g.IsXinguBeta(height),
 		},
 	)
 }
@@ -351,7 +355,7 @@ func GetFeatureCtx(ctx context.Context) (FeatureCtx, bool) {
 func MustGetFeatureCtx(ctx context.Context) FeatureCtx {
 	fc, ok := ctx.Value(featureContextKey{}).(FeatureCtx)
 	if !ok {
-		log.S().Panic("Miss feature context")
+		log.L().Panic("Miss feature context")
 	}
 	return fc
 }

action/protocol/execution/evm/evmstatedbadapter.go

@@ -1092,7 +1092,7 @@ func (stateDB *StateDBAdapter) CommitContracts() error {
 	sort.Slice(contractAddrs, func(i, j int) bool { return bytes.Compare(contractAddrs[i][:], contractAddrs[j][:]) < 0 })
 
 	for _, addr := range contractAddrs {
-		_, err := stateDB.sm.DelState(protocol.KeyOption(addr[:]))
+		_, err := stateDB.sm.DelState(protocol.KeyOption(addr[:]), protocol.ObjectOption(&state.Account{}))
 		if stateDB.assertError(err, "failed to delete SelfDestruct account/contract", zap.Error(err), zap.String("address", addr.Hex())) {
 			return errors.Wrapf(err, "failed to delete SelfDestruct account/contract %x", addr[:])
 		}

action/protocol/managers.go

@@ -62,13 +62,22 @@ func ObjectOption(obj any) StateOption {
 	}
 }
 
+// ErigonStoreOnlyOption sets the option to only read/write from/to erigon store
+func ErigonStoreOnlyOption() StateOption {
+	return func(cfg *StateConfig) error {
+		cfg.ErigonStoreOnly = true
+		return nil
+	}
+}
+
 type (
 	// StateConfig is the config for accessing stateDB
 	StateConfig struct {
-		Namespace string // namespace used by state's storage
-		Key       []byte
-		Keys      [][]byte
-		Object    any // object used by state's storage
+		Namespace       string // namespace used by state's storage
+		Key             []byte
+		Keys            [][]byte
+		Object          any  // object used by state's storage
+		ErigonStoreOnly bool // whether only read/write from/to erigon store
 	}
 
 	// StateOption sets parameter for access state

action/protocol/poll/util.go

@@ -96,9 +96,9 @@ func validate(ctx context.Context, sr protocol.StateReader, p Protocol, act acti
 	}
 	for i, d := range ds {
 		if !proposedDelegates[i].Equal(d) {
-			msg := fmt.Sprintf(", %v vs %v (expected)",
-				proposedDelegates,
-				ds)
+			msg := fmt.Sprintf(", %+v vs %+v (expected)",
+				proposedDelegates[i],
+				d)
 			return errors.Wrap(ErrDelegatesNotAsExpected, msg)
 		}
 	}

action/protocol/rewarding/protocol_test.go

@@ -73,7 +73,7 @@ func testProtocol(t *testing.T, test func(*testing.T, context.Context, protocol.
 	g.Rewarding.NumDelegatesForFoundationBonus = 5
 	g.Rewarding.FoundationBonusLastEpoch = 365
 	g.Rewarding.ProductivityThreshold = 50
-	g.ToBeEnabledBlockHeight = slashHeight
+	g.XinguBlockHeight = slashHeight
 	// Initialize the protocol
 	if withExempt {
 		g.Rewarding.ExemptAddrStrsFromEpochReward = []string{