Revert "EpochRecover service event and transaction"

.github/workflows/ci.yml

@@ -19,4 +19,4 @@ jobs:
       - name: Update PATH
         run: echo "/root/.local/bin" >> $GITHUB_PATH
       - name: Run tests
-        run: export GOPATH=$HOME/go && make ci
+        run: export GOPATH=$HOME/go && make ci

contracts/epochs/FlowClusterQC.cdc

@@ -258,21 +258,6 @@ access(all) contract FlowClusterQC {
         }
     }
 
-    /// Represents the quorum certificate vote data for a signer 
-    /// of the certificate.
-    access(all) struct ClusterQCVoteData {
-        /// The aggregated signature, hex-encoded, encompasses all individual vote signatures contributed by nodes across the cluster
-        access(all) let aggregatedSignature: String
-
-        /// The node IDs that contributed their vote to the aggregated signature
-        access(all) let voterIDs: [String]
-
-        init(aggregatedSignature: String, voterIDs: [String]) {
-            self.aggregatedSignature = aggregatedSignature
-            self.voterIDs = voterIDs
-        }
-    }
-
     /// The Voter resource is generated for each collection node after they register.
     /// Each resource instance is good for all future potential epochs, but will
     /// only be valid if the node operator has been confirmed as a collector node for the next epoch.

lib/go/templates/epoch_templates.go

@@ -17,7 +17,6 @@ const (
 	updateRewardPercentageFilename   = "epoch/admin/update_reward.cdc"
 	advanceViewFilename              = "epoch/admin/advance_view.cdc"
 	resetEpochFilename               = "epoch/admin/reset_epoch.cdc"
-	recoverEpochFilename             = "epoch/admin/recover_epoch.cdc"
 	epochCalculateSetRewardsFilename = "epoch/admin/calculate_rewards.cdc"
 	epochPayRewardsFilename          = "epoch/admin/pay_rewards.cdc"
 	epochSetAutoRewardsFilename      = "epoch/admin/set_automatic_rewards.cdc"
@@ -115,12 +114,6 @@ func GenerateResetEpochScript(env Environment) []byte {
 	return []byte(ReplaceAddresses(code, env))
 }
 
-func GenerateRecoverEpochScript(env Environment) []byte {
-	code := assets.MustAssetString(recoverEpochFilename)
-
-	return []byte(ReplaceAddresses(code, env))
-}
-
 func GenerateEpochCalculateSetRewardsScript(env Environment) []byte {
 	code := assets.MustAssetString(epochCalculateSetRewardsFilename)
 

lib/go/test/epoch_test_helpers.go

@@ -7,8 +7,6 @@ import (
 
 	"github.com/onflow/cadence"
 	jsoncdc "github.com/onflow/cadence/encoding/json"
-	"github.com/onflow/cadence/runtime/common"
-	cdcCommon "github.com/onflow/cadence/runtime/common"
 	"github.com/onflow/cadence/runtime/interpreter"
 	"github.com/onflow/flow-core-contracts/lib/go/contracts"
 	"github.com/onflow/flow-core-contracts/lib/go/templates"
@@ -132,82 +130,6 @@ type EpochCommit struct {
 	dkgPubKeys []string
 }
 
-// EpochRecover used to verify EpochRecover event fields in tests.
-type EpochRecover struct {
-	counter                 uint64
-	nodeInfoLength          int
-	firstView               uint64
-	finalView               uint64
-	collectorClusters       []cadence.Value
-	randomSource            string
-	dkgPhase1FinalView      uint64
-	dkgPhase2FinalView      uint64
-	dkgPhase3FinalView      uint64
-	targetDuration          uint64
-	targetEndTime           uint64
-	clusterQCVoteDataLength int
-	dkgPubKeys              []string
-}
-
-type EpochRecoverEvent flow.Event
-
-// Counter returns counter field in EpochRecover event.
-func (evt EpochRecoverEvent) Counter() cadence.UInt64 {
-	return cadence.SearchFieldByName(evt.Value, "counter").(cadence.UInt64)
-}
-
-// NodeInfo returns nodeInfo field in EpochRecover event.
-func (evt EpochRecoverEvent) NodeInfo() cadence.Array {
-	return cadence.SearchFieldByName(evt.Value, "nodeInfo").(cadence.Array)
-}
-
-// FirstView returns firstView field in EpochRecover event.
-func (evt EpochRecoverEvent) FirstView() cadence.UInt64 {
-	return cadence.SearchFieldByName(evt.Value, "firstView").(cadence.UInt64)
-}
-
-// FinalView returns finalView field in EpochRecover event.
-func (evt EpochRecoverEvent) FinalView() cadence.UInt64 {
-	return cadence.SearchFieldByName(evt.Value, "finalView").(cadence.UInt64)
-}
-
-// CollectorClusters returns clusterAssignments field in EpochRecover event.
-func (evt EpochRecoverEvent) CollectorClusters() cadence.Array {
-	return cadence.SearchFieldByName(evt.Value, "clusterAssignments").(cadence.Array)
-}
-
-// RandomSource returns randomSource field in EpochRecover event.
-func (evt EpochRecoverEvent) RandomSource() cadence.String {
-	return cadence.SearchFieldByName(evt.Value, "randomSource").(cadence.String)
-}
-
-// DKGFinalViews returns dkgFinalViews field in EpochRecover event.
-func (evt EpochRecoverEvent) DKGFinalViews() (cadence.UInt64, cadence.UInt64, cadence.UInt64) {
-	return cadence.SearchFieldByName(evt.Value, "DKGPhase1FinalView").(cadence.UInt64),
-		cadence.SearchFieldByName(evt.Value, "DKGPhase2FinalView").(cadence.UInt64),
-		cadence.SearchFieldByName(evt.Value, "DKGPhase3FinalView").(cadence.UInt64)
-}
-
-// TargetDuration returns targetDuration field in EpochRecover event.
-func (evt EpochRecoverEvent) TargetDuration() cadence.UInt64 {
-	return cadence.SearchFieldByName(evt.Value, "targetDuration").(cadence.UInt64)
-}
-
-// TargetEndTime returns targetEndTime field in EpochRecover event.
-func (evt EpochRecoverEvent) TargetEndTime() cadence.UInt64 {
-	return cadence.SearchFieldByName(evt.Value, "targetEndTime").(cadence.UInt64)
-}
-
-// ClusterQCVoteData returns clusterQCVoteData field in EpochRecover event.
-func (evt EpochRecoverEvent) ClusterQCVoteData() cadence.Array {
-	return cadence.SearchFieldByName(evt.Value, "clusterQCVoteData").(cadence.Array)
-}
-
-// DKGPubKeys returns dkgPubKeys field in EpochRecover event.
-func (evt EpochRecoverEvent) DKGPubKeys() cadence.Array {
-	return cadence.SearchFieldByName(evt.Value, "dkgPubKeys").(cadence.Array)
-}
-
 // Go event definitions for the epoch events
 // Can be used with the SDK to retreive and parse epoch events
 
@@ -573,9 +495,10 @@ func verifyEpochMetadata(
 	env templates.Environment,
 	expectedMetadata EpochMetadata) {
 
-	metadataFields := getEpochMetadata(t, b, env, cadence.UInt64(expectedMetadata.counter))
-	counter := metadataFields["counter"]
+	result := executeScriptAndCheck(t, b, templates.GenerateGetEpochMetadataScript(env), [][]byte{jsoncdc.MustEncode(cadence.UInt64(expectedMetadata.counter))})
+	metadataFields := cadence.FieldsMappedByName(result.(cadence.Struct))
 
+	counter := metadataFields["counter"]
 	assertEqual(t, cadence.NewUInt64(expectedMetadata.counter), counter)
 
 	if len(expectedMetadata.seed) != 0 {
@@ -791,15 +714,6 @@ func verifyEpochCommit(
 
 }
 
-// verifyCollectorClusters verifies both collector clusters are equal.
-func verifyCollectorClusters(t *testing.T, expected, got []cadence.Value) {
-	for i, cluster := range got {
-		for j, node := range cluster.(cadence.Array).Values {
-			assertEqual(t, expected[i].(cadence.Array).Values[j], node)
-		}
-	}
-}
-
 // expectedTargetEndTime returns the expected `targetEndTime` for the given target epoch,
 // as a second-precision Unix time.
 func expectedTargetEndTime(timingConfig cadence.Value, targetEpoch uint64) uint64 {
@@ -810,98 +724,3 @@ func expectedTargetEndTime(timingConfig cadence.Value, targetEpoch uint64) uint6
 
 	return refTimestamp + duration*(targetEpoch-refCounter)
 }
-
-// verifyEpochRecover verifies that an emitted EpochRecover event is equal to the provided `expectedRecover`.
-// Assumptions:
-//   - only one `EpochRecover` is emitted (otherwise, only the first is verified)
-//   - the `EpochRecover` is emitted within the first 1000 blocks
-func verifyEpochRecover(
-	t *testing.T,
-	adapter *adapters.SDKAdapter,
-	epochAddress flow.Address,
-	expectedRecover EpochRecover,
-) {
-	var emittedEvent EpochRecoverEvent
-	addrLocation := common.NewAddressLocation(nil, common.Address(epochAddress), "FlowEpoch")
-	evtTypeID := string(addrLocation.TypeID(nil, "FlowEpoch.EpochRecover"))
-	for i := uint64(0); i < 1000; i++ {
-		results, _ := adapter.GetEventsForHeightRange(context.Background(), evtTypeID, i, i)
-
-		for _, result := range results {
-			for _, event := range result.Events {
-
-				if event.Type == evtTypeID {
-					emittedEvent = EpochRecoverEvent(event)
-				}
-			}
-		}
-	}
-
-	assertEqual(t, cadence.NewUInt64(expectedRecover.counter), emittedEvent.Counter())
-	assertEqual(t, expectedRecover.nodeInfoLength, len(emittedEvent.NodeInfo().Values))
-	assertEqual(t, cadence.NewUInt64(expectedRecover.firstView), emittedEvent.FirstView())
-	assertEqual(t, cadence.NewUInt64(expectedRecover.finalView), emittedEvent.FinalView())
-	verifyCollectorClusters(t, expectedRecover.collectorClusters, emittedEvent.CollectorClusters().Values)
-	assertEqual(t, cadence.String(expectedRecover.randomSource), emittedEvent.RandomSource())
-	dkgPhase1FinalView, dkgPhase2FinalView, dkgPhase3FinalView := emittedEvent.DKGFinalViews()
-	assertEqual(t, cadence.NewUInt64(expectedRecover.dkgPhase1FinalView), dkgPhase1FinalView)
-	assertEqual(t, cadence.NewUInt64(expectedRecover.dkgPhase2FinalView), dkgPhase2FinalView)
-	assertEqual(t, cadence.NewUInt64(expectedRecover.dkgPhase3FinalView), dkgPhase3FinalView)
-	assertEqual(t, cadence.NewUInt64(expectedRecover.targetDuration), emittedEvent.TargetDuration())
-	assertEqual(t, cadence.NewUInt64(expectedRecover.targetEndTime), emittedEvent.TargetEndTime())
-	assertEqual(t, expectedRecover.clusterQCVoteDataLength, len(emittedEvent.ClusterQCVoteData().Values))
-	assertEqual(t, len(expectedRecover.dkgPubKeys), len(emittedEvent.DKGPubKeys().Values))
-}
-
-func getEpochMetadata(t *testing.T, b emulator.Emulator, env templates.Environment, counter cadence.Value) map[string]cadence.Value {
-	result := executeScriptAndCheck(t, b, templates.GenerateGetEpochMetadataScript(env), [][]byte{jsoncdc.MustEncode(counter)})
-	return cadence.FieldsMappedByName(result.(cadence.Struct))
-}
-
-func getCurrentEpochCounter(t *testing.T, b emulator.Emulator, env templates.Environment) cadence.UInt64 {
-	result := executeScriptAndCheck(t, b, templates.GenerateGetCurrentEpochCounterScript(env), [][]byte{})
-	return result.(cadence.UInt64)
-}
-
-// newClusterQCVoteDataCdcType returns the FlowClusterQC cadence struct type.
-func newClusterQCVoteDataCdcType(clusterQcAddress string) *cadence.StructType {
-
-	// FlowClusterQC.ClusterQCVoteData
-	address, _ := cdcCommon.HexToAddress(clusterQcAddress)
-	location := cdcCommon.NewAddressLocation(nil, address, "FlowClusterQC")
-
-	return &cadence.StructType{
-		Location:            location,
-		QualifiedIdentifier: "FlowClusterQC.ClusterQCVoteData",
-		Fields: []cadence.Field{
-			{
-				Identifier: "aggregatedSignature",
-				Type:       cadence.StringType,
-			},
-			{
-				Identifier: "voterIDs",
-				Type:       cadence.NewVariableSizedArrayType(cadence.StringType),
-			},
-		},
-	}
-}
-
-func convertClusterQcsCdc(env templates.Environment, clusters []cadence.Value) []cadence.Value {
-	voteDataType := newClusterQCVoteDataCdcType(env.QuorumCertificateAddress)
-	qcVoteData := make([]cadence.Value, len(clusters))
-	for i, cluster := range clusters {
-		clusterCdc := cluster.(cadence.Array)
-		cdcVoterIds := make([]cadence.Value, len(clusterCdc.Values))
-		for i, id := range clusterCdc.Values {
-			cdcVoterIds[i] = cadence.String(id.String())
-		}
-		qcVoteData[i] = cadence.NewStruct([]cadence.Value{
-			// aggregatedSignature
-			cadence.String(fmt.Sprintf("signature_%d", i)),
-			// Node IDs of signers
-			cadence.NewArray(cdcVoterIds).WithType(cadence.NewVariableSizedArrayType(cadence.StringType)),
-		}).WithType(voteDataType)
-	}
-
-	return qcVoteData
-}