Don't process scheduled transactions during epoch transitions

contracts/FlowTransactionScheduler.cdc

@@ -3,6 +3,7 @@ import "FlowToken"
 import "FlowFees"
 import "FlowStorageFees"
 import "ViewResolver"
+import "FlowEpoch"
 
 /// FlowTransactionScheduler enables smart contracts to schedule autonomous execution in the future.
 ///
@@ -1284,6 +1285,14 @@ access(all) contract FlowTransactionScheduler {
                 return
             }
 
+            // Skip processing if the epoch is in one of the phase transitions
+            // or expensive operations
+            // We don't skip if it is running in a test environment,
+            // so we check automaticRewardsEnabled() because it is only true on testnet and mainnet.
+            if FlowEpoch.isPhaseTransition() && FlowEpoch.automaticRewardsEnabled() {
+                return
+            }
+
             self.removeExecutedTransactions(currentTimestamp)
 
             let pendingTransactions = self.pendingQueue()

contracts/epochs/FlowEpoch.cdc

@@ -1296,6 +1296,41 @@ access(all) contract FlowEpoch {
                 ?? 0.0
     }
 
+    /// Checks if the current epoch is in a phase transition
+    /// so that other system contracts can skip computation-heavy operations
+    /// during the phase transition.
+    access(all) fun isPhaseTransition(): Bool {
+        switch self.currentEpochPhase {
+            case EpochPhase.STAKINGAUCTION:
+                if let previousEpochMetadata = self.getEpochMetadata(FlowEpoch.currentEpochCounter.saturatingSubtract(1)) {
+                    // Paying rewards for the previous epoch
+                    if self.currentEpochCounter > 0 && !previousEpochMetadata.rewardsPaid {
+                        return true
+                    }
+                }
+                let currentBlock = getCurrentBlock()
+                let currentEpochMetadata = self.getEpochMetadata(self.currentEpochCounter)!
+                // Staking auction is ending
+                if currentBlock.view >= currentEpochMetadata.stakingEndView {
+                    return true
+                }
+            case EpochPhase.EPOCHSETUP:
+                // QC and DKG are completed and will be cleaned up
+                if FlowClusterQC.votingCompleted() && (FlowDKG.dkgCompleted() != nil) {
+                    return true
+                }
+            case EpochPhase.EPOCHCOMMIT:
+                let currentBlock = getCurrentBlock()
+                let currentEpochMetadata = FlowEpoch.getEpochMetadata(FlowEpoch.currentEpochCounter)!
+                // Epoch is ending
+                if currentBlock.view >= currentEpochMetadata.endView {
+                    return true
+                }
+        }
+
+        return false
+    }
+
     init (currentEpochCounter: UInt64,
           numViewsInEpoch: UInt64,
           numViewsInStakingAuction: UInt64,

flow.json

@@ -45,7 +45,7 @@
 			"aliases": {
 				"emulator": "f8d6e0586b0a20c7",
 				"mainnet": "8624b52f9ddcd04a",
-				"testing": "0000000000000007",
+				"testing": "0000000000000001",
 				"testnet": "9eca2b38b18b5dfe"
 			}
 		},

lib/go/templates/epoch_templates.go

@@ -39,6 +39,7 @@ const (
 	getCurrentViewFilename           = "epoch/scripts/get_current_view.cdc"
 	getFlowTotalSupplyFilename       = "flowToken/scripts/get_supply.cdc"
 	getFlowBonusTokensFilename       = "epoch/scripts/get_bonus_tokens.cdc"
+	isPhaseTransitionFilename        = "epoch/scripts/is_phase_transition.cdc"
 
 	// test scripts
 	getRandomizeFilename      = "epoch/scripts/get_randomize.cdc"
@@ -238,3 +239,9 @@ func GenerateGetBonusTokensScript(env Environment) []byte {
 
 	return []byte(ReplaceAddresses(code, env))
 }
+
+func GenerateIsPhaseTransitionScript(env Environment) []byte {
+	code := assets.MustAssetString(isPhaseTransitionFilename)
+
+	return []byte(ReplaceAddresses(code, env))
+}

lib/go/test/flow_epoch_test.go

@@ -89,6 +89,9 @@ func TestEpochDeployment(t *testing.T) {
 			clusterQCs:               nil,
 			dkgKeys:                  nil})
 
+	// Should not be in a phase transition since the epoch is just starting
+	result := executeScriptAndCheck(t, b, templates.GenerateIsPhaseTransitionScript(env), nil)
+	assertEqual(t, cadence.NewBool(false), result)
 }
 
 func TestEpochClusters(t *testing.T) {
@@ -586,6 +589,10 @@ func TestEpochAdvance(t *testing.T) {
 		// Advance to epoch Setup and make sure that the epoch cannot be ended
 		advanceView(t, b, env, idTableAddress, IDTableSigner, 1, "EPOCHSETUP", false)
 
+		// Should not be in a phase transition since we already advanced to epoch setup
+		result := executeScriptAndCheck(t, b, templates.GenerateIsPhaseTransitionScript(env), nil)
+		assertEqual(t, cadence.NewBool(false), result)
+
 		verifyConfigMetadata(t, b, env,
 			ConfigMetadata{
 				currentEpochCounter:      startEpochCounter,
@@ -638,7 +645,7 @@ func TestEpochAdvance(t *testing.T) {
 			})
 
 		// QC Contract Checks
-		result := executeScriptAndCheck(t, b, templates.GenerateGetClusterWeightScript(env), [][]byte{jsoncdc.MustEncode(cadence.UInt16(uint16(0)))})
+		result = executeScriptAndCheck(t, b, templates.GenerateGetClusterWeightScript(env), [][]byte{jsoncdc.MustEncode(cadence.UInt16(uint16(0)))})
 		assert.Equal(t, cadence.NewUInt64(100), result)
 
 		result = executeScriptAndCheck(t, b, templates.GenerateGetNodeWeightScript(env), [][]byte{jsoncdc.MustEncode(cadence.UInt16(uint16(1))), jsoncdc.MustEncode(cadence.String(ids[0]))})
@@ -864,6 +871,10 @@ func TestEpochQCDKG(t *testing.T) {
 		false,
 	)
 
+	// Should be in a phase transition since we haven't advanced to epoch setup and view is greater than the staking end view (50)
+	result := executeScriptAndCheck(t, b, templates.GenerateIsPhaseTransitionScript(env), nil)
+	assertEqual(t, cadence.NewBool(true), result)
+
 	// Advance to epoch Setup and make sure that the epoch cannot be ended
 	advanceView(t, b, env, idTableAddress, IDTableSigner, 1, "EPOCHSETUP", false)
 
@@ -1001,6 +1012,10 @@ func TestEpochQCDKG(t *testing.T) {
 		// Advance to epoch commit
 		advanceView(t, b, env, idTableAddress, IDTableSigner, 1, "EPOCHCOMMIT", false)
 
+		// Should be in a phase transition since we advanced to epoch commit and view is greater than the end view (70)
+		result = executeScriptAndCheck(t, b, templates.GenerateIsPhaseTransitionScript(env), nil)
+		assertEqual(t, cadence.NewBool(true), result)
+
 		verifyConfigMetadata(t, b, env,
 			ConfigMetadata{
 				currentEpochCounter:      startEpochCounter,
@@ -1087,6 +1102,10 @@ func TestEpochQCDKG(t *testing.T) {
 				rewards:        "6571204.6775",
 			})
 
+		// Should be in a phase transition since we just ended the epoch but haven't paid rewards
+		result = executeScriptAndCheck(t, b, templates.GenerateIsPhaseTransitionScript(env), nil)
+		assertEqual(t, cadence.NewBool(true), result)
+
 		tx = createTxWithTemplateAndAuthorizer(b, templates.GenerateEpochPayRewardsScript(env), idTableAddress)
 
 		signAndSubmit(

tests/scheduled_transaction_test_helpers.cdc

@@ -499,6 +499,27 @@ access(all) fun upgradeSchedulerUtilsContract() {
     Test.expect(upgradeResult, Test.beSucceeded())
 }
 
+access(all) fun upgradeEpochContract() {
+    var epochCode = Test.readFile("../contracts/epochs/FlowEpoch.cdc")
+    epochCode = epochCode.replaceAll(of: "\"FungibleToken\"", with: "FungibleToken from 0x0000000000000002")
+    epochCode = epochCode.replaceAll(of: "\"FlowToken\"", with: "FlowToken from 0x0000000000000003")
+    epochCode = epochCode.replaceAll(of: "\"FlowFees\"", with: "FlowFees from 0x0000000000000004")
+    epochCode = epochCode.replaceAll(of: "\"FlowIDTableStaking\"", with: "FlowIDTableStaking from 0x0000000000000001")
+    epochCode = epochCode.replaceAll(of: "\"FlowClusterQC\"", with: "FlowClusterQC from 0x0000000000000001")
+    epochCode = epochCode.replaceAll(of: "\"FlowDKG\"", with: "FlowDKG from 0x0000000000000001")
+
+    var upgradeTx = Test.Transaction(
+        code: Test.readFile("./transactions/upgrade_contract.cdc"),
+        authorizers: [serviceAccount.address],
+        signers: [serviceAccount],
+        arguments: ["FlowEpoch", epochCode],
+    )
+    var upgradeResult = Test.executeTransaction(
+        upgradeTx,
+    )
+    Test.expect(upgradeResult, Test.beSucceeded())
+}
+
 access(all) fun getTimestamp(): UFix64 {
     var timestamp = _executeScript(
         "./scripts/get_timestamp.cdc",

tests/transactionScheduler_events_test.cdc

@@ -17,6 +17,9 @@ access(all) var accountBalanceBefore: UFix64 = 0.0
 access(all)
 fun setup() {
 
+    // upgrade the FlowEpoch contract to the latest version
+    upgradeEpochContract()
+
     var err = Test.deployContract(
         name: "FlowTransactionScheduler",
         path: "../contracts/FlowTransactionScheduler.cdc",

tests/transactionScheduler_manager_test.cdc

@@ -17,6 +17,9 @@ access(all) var timeInFuture: UFix64 = 0.0
 access(all)
 fun setup() {
 
+    // upgrade the FlowEpoch contract to the latest version
+    upgradeEpochContract()
+
     var err = Test.deployContract(
         name: "FlowTransactionScheduler",
         path: "../contracts/FlowTransactionScheduler.cdc",

tests/transactionScheduler_misc_test.cdc

@@ -17,6 +17,9 @@ access(all) var accountBalanceBefore: UFix64 = 0.0
 access(all)
 fun setup() {
 
+    // upgrade the FlowEpoch contract to the latest version
+    upgradeEpochContract()
+
     var err = Test.deployContract(
         name: "FlowTransactionScheduler",
         path: "../contracts/FlowTransactionScheduler.cdc",

tests/transactionScheduler_schedule_test.cdc

@@ -9,6 +9,9 @@ import "scheduled_transaction_test_helpers.cdc"
 access(all)
 fun setup() {
 
+    // upgrade the FlowEpoch contract to the latest version
+    upgradeEpochContract()
+
     var err = Test.deployContract(
         name: "FlowTransactionScheduler",
         path: "../contracts/FlowTransactionScheduler.cdc",

tests/transactionScheduler_test.cdc

@@ -9,6 +9,9 @@ import "scheduled_transaction_test_helpers.cdc"
 access(all)
 fun setup() {
 
+    // upgrade the FlowEpoch contract to the latest version
+    upgradeEpochContract()
+
     var err = Test.deployContract(
         name: "FlowTransactionScheduler",
         path: "../contracts/FlowTransactionScheduler.cdc",

transactions/epoch/scripts/is_phase_transition.cdc

@@ -0,0 +1,5 @@
+import "FlowEpoch"
+
+access(all) fun main(): Bool {
+    return FlowEpoch.isPhaseTransition()
+}