address process PR comment

Author: joshuahannan

contracts/FlowCallbackScheduler.cdc

@@ -233,6 +233,14 @@ access(all) contract FlowCallbackScheduler {
             self.description = handlerRef.description
         }
 
+        access(all) view fun getHandlerType(): Type? {
+            return self.handler.getType()
+        }
+
+        access(all) view fun getHandlerAddress(): Address {
+            return self.handler.address
+        }
+
         /// setStatus updates the status of the callback.
         /// It panics if the callback status is already finalized.
         access(contract) fun setStatus(newStatus: Status) {
@@ -1224,19 +1232,21 @@ access(all) contract FlowCallbackScheduler {
             }
 
             for callback in pendingCallbacks {
-                let callbackHandler = callback.handler.borrow()
-                    ?? panic("Invalid callback handler: Could not borrow a reference to the callback handler")
-
-                emit PendingExecution(
-                    id: callback.id,
-                    priority: callback.priority.rawValue,
-                    executionEffort: callback.executionEffort,
-                    fees: callback.fees,
-                    callbackOwner: callback.handler.address,
-                    callbackHandlerTypeIdentifier: callbackHandler.getType().identifier,
-                    callbackName: callbackHandler.name,
-                    callbackDescription: callbackHandler.description
-                )
+                // Only emit the pending execution event if the callback handler capability is borrowable
+                // This is to prevent a situation where the callback handler is not available
+                // In that case, the callback is no longer valid because it cannot be executed
+                if let callbackHandler = callback.handler.borrow() {
+                    emit PendingExecution(
+                        id: callback.id,
+                        priority: callback.priority.rawValue,
+                        executionEffort: callback.executionEffort,
+                        fees: callback.fees,
+                        callbackOwner: callback.handler.address,
+                        callbackHandlerTypeIdentifier: callbackHandler.getType().identifier,
+                        callbackName: callbackHandler.name,
+                        callbackDescription: callbackHandler.description
+                    )
+                }
 
                 // after pending execution event is emitted we set the callback as executed because we 
                 // must rely on execution node to actually execute it. Execution of the callback is 

lib/go/contracts/internal/assets/assets.go

@@ -332,7 +332,7 @@ access(all) fun testCallbackScheduleAnotherCallback() {
     }
 
     let currentTime = getTimestamp()
-    var timeInFuture = currentTime + futureDelta*10.0
+    var timeInFuture = currentTime + futureDelta*5.0
 
     // Schedule a medium callback
     scheduleCallback(
@@ -353,7 +353,7 @@ access(all) fun testCallbackScheduleAnotherCallback() {
     Test.assertEqual(callbackData!.executionEffort, mediumEffort)
     Test.assertEqual(callbackData!.status.rawValue, statusScheduled)
 
-    Test.moveTime(by: Fix64(futureDelta*11.0))
+    Test.moveTime(by: Fix64(futureDelta*6.0))
 
     processCallbacks()
 
@@ -367,4 +367,52 @@ access(all) fun testCallbackScheduleAnotherCallback() {
     var status = getStatus(id: 2)
     Test.assertEqual(statusScheduled, status!)
 
+}
+
+
+access(all) fun testCallbackDestroyHandler() {
+
+    if startingHeight < getCurrentBlockHeight() {
+        Test.reset(to: startingHeight)
+    }
+
+    let currentTime = getTimestamp()
+    var timeInFuture = currentTime + futureDelta*10.0
+
+    // Schedule a medium callback
+    scheduleCallback(
+        timestamp: timeInFuture,
+        fee: feeAmount,
+        effort: mediumEffort,
+        priority: mediumPriority,
+        data: testData,
+        testName: "Destroy Handler: Scheduled",
+        failWithErr: nil
+    )
+
+    // Destroy the handler for the callback
+    let executeCallbackCode = Test.readFile("./transactions/destroy_handler.cdc")
+    let executeTx = Test.Transaction(
+        code: executeCallbackCode,
+        authorizers: [serviceAccount.address],
+        signers: [serviceAccount],
+        arguments: []
+    )
+    var result = Test.executeTransaction(executeTx)
+    Test.expect(result, Test.beSucceeded())
+
+    Test.moveTime(by: Fix64(futureDelta*11.0))
+
+    processCallbacks()
+
+    // The callback with the handler should not have emitted an event because the handler was destroyed
+    let pendingExecutionEvents = Test.eventsOfType(Type<FlowCallbackScheduler.PendingExecution>())
+    Test.assertEqual(pendingExecutionEvents.length, 0)
+
+    executeCallback(
+        id: 1,
+        testName: "Destroy Handler: Execute",
+        failWithErr: "Invalid callback handler: Could not borrow a reference to the callback handler"
+    )
+    
 }

tests/callbackScheduler_events_test.cdc

@@ -0,0 +1,11 @@
+import "TestFlowCallbackHandler"
+import "FlowCallbackScheduler"
+
+transaction {
+    prepare(account: auth(BorrowValue, LoadValue) &Account) {
+        let handler <- account.storage.load<@TestFlowCallbackHandler.Handler>(from: TestFlowCallbackHandler.HandlerStoragePath)
+            ?? panic("Could not load TestFlowCallbackHandler")
+        destroy handler
+    }
+}
+