NONEVM-3014 - Unit test for error on manual execution before execution window (#341)

* fix bug

* self review

* self-review

Author: nicolasgnr

contracts/contracts/ccip/merkle_root/contract.tolk

@@ -73,10 +73,10 @@ fun _initExecute(msg: MerkleRoot_Validate, sender: address) {
     val state = st.getMessageState(message.header.sequenceNumber);
     assert(state == ExecutionState.Failure || state == ExecutionState.Untouched, MerkleRoot_Error.SkippedAlreadyExecutedMessage);
 
-    val isManualExecute = msg.gasOverride != null; 
+    val isManualExecute = msg.gasOverride != null;
+
     if (isManualExecute) {
         val isOldCommitReport = (blockchain.now() - st.timestamp > msg.permissionlessExecutionThresholdSeconds);
-
         // Manual execution is fine if we previously failed or if the commit report is just too old.
         // (In that case the report will still be in UNTOUCHED state)
         assert(isOldCommitReport || state == ExecutionState.Failure, MerkleRoot_Error.ManualExecutionNotYetEnabled);
@@ -97,6 +97,7 @@ fun _initExecute(msg: MerkleRoot_Validate, sender: address) {
             root: st.root,
             metadataHash: msg.metadataHash,
             gasOverride: msg.gasOverride,
+            executionState: state,
         }
     });
     executeValidated.send(SEND_MODE_REGULAR);

contracts/contracts/ccip/offramp/contract.tolk

@@ -15,7 +15,6 @@ import "../../lib/ocr/types"
 import "../../lib/utils.tolk"
 import "../fee_quoter/messages"
 import "../merkle_root/messages"
-import "../../lib/receiver/messages"
 import "../merkle_root/storage"
 import "../receive_executor/messages"
 import "../receive_executor/storage"
@@ -502,10 +501,9 @@ fun _updateCursedSubjects(msg: OffRamp_UpdateCursedSubjects, sender: address) {
 fun _executeValidated(msg: OffRamp_ExecuteValidated, sender: address) {
     val st = Storage.load();
 
-    // Validate the message comes from an owned MerkleRoot contract
-
     val message = msg.message.load();
 
+    // Validate the message comes from an owned MerkleRoot contract
     assertSenderIsOwnedContract(st, sender, beginCell().storeUint(msg.root, MERKLE_ROOT_ID_SIZE));
 
     emit(EXECUTION_STATE_CHANGED_TOPIC, ExecutionStateChanged {
@@ -528,44 +526,37 @@ fun _executeValidated(msg: OffRamp_ExecuteValidated, sender: address) {
         }
     };
 
-    if (msg.gasOverride == null) {
-        deployAndInitializeExecutor(st, sender, message, executorAddress, execId);
-    } else {
-        //gasOverride indicates manual exec
-        sendInitExecute(executorAddress, msg.gasOverride);
+    // Check if this is the first time the exec flow is running given that in that case we need to
+    // initialize the executor
+    if (msg.executionState == ExecutionState.Untouched) {
+        val deployMsg = createMessage({
+            bounce: true,
+            value: ton("0.5"), // TODO:
+            dest: executorAddress,
+            // TODO: toShard so it's collocated
+            body: Deployable_Initialize {
+                stateInit: {
+                    code: st.deployables.load().receiveExecutorCode,
+                    data: ReceiveExecutor_Storage {
+                        owner: contract.getAddress(),
+                        message: message.toCell(),
+                        root: sender,
+                        execId: execId,
+                    }.toCell(),
+                }
+            },
+        });
+        deployMsg.send(SEND_MODE_REGULAR);
     }
-}
-
-fun deployAndInitializeExecutor(st: Storage, rootAddress: address, message: Any2TVMRampMessage, executorAddress: AutoDeployAddress, execId: ReceiveExecutorId) {
-    val deployMsg = createMessage({
-        bounce: true, 
-        value: ton("0.5"), // TODO:
-        dest: executorAddress,
-        // TODO: toShard so it's collocated 
-        body: Deployable_Initialize {
-            stateInit: {
-                code: st.deployables.load().receiveExecutorCode,
-                data: ReceiveExecutor_Storage {
-                    owner: contract.getAddress(),
-                    message: message.toCell(), 
-                    root: rootAddress,
-                    execId: execId,
-                }.toCell(),
-            }
-        },
-    });
-    deployMsg.send(SEND_MODE_REGULAR);
 
-    sendInitExecute(executorAddress, null);
-}
-
-fun sendInitExecute(executorAddress: AutoDeployAddress, gasOverride: coins?) {
+    // Initiate the execution in the ReceiveExecutor. 'msg.gasOverride' may be null and that
+    // means that is a manual exec flow
     val initExecMsg = createMessage ({
         bounce: true,
         value: ton("0.05"), // TODO:
         dest: executorAddress,
         body: ReceiveExecutor_InitExecute {
-            gasOverride,
+            gasOverride: msg.gasOverride,
         }
     });
     initExecMsg.send(SEND_MODE_REGULAR);

contracts/contracts/ccip/offramp/messages.tolk

@@ -46,6 +46,7 @@ struct (0xc73d5a8a) OffRamp_ExecuteValidated {
     root: MerkleRootId;
     metadataHash: uint256;
     gasOverride: coins?;
+    executionState: ExecutionState;
 }
 
 //crc32('OffRamp_ManuallyExecute')

contracts/tests/ccip/OffRamp.spec.ts

@@ -1,14 +1,5 @@
 import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox'
-import {
-  Address,
-  beginCell,
-  Cell,
-  contractAddress,
-  Dictionary,
-  fromNano,
-  StateInit,
-  toNano,
-} from '@ton/core'
+import { Address, beginCell, Cell, contractAddress, Dictionary, StateInit, toNano } from '@ton/core'
 import { compile } from '@ton/blueprint'
 import {
   Any2TVMRampMessage,
@@ -26,7 +17,6 @@ import {
   SourceChainConfig,
   OffRamp,
   OffRampError,
-  ReceiveExecutorError,
 } from '../../wrappers/ccip/OffRamp'
 import {
   MerkleRootError,
@@ -75,6 +65,7 @@ const CHAINSEL_TON = 13879075125137744094n
 const EVM_SENDER_ADDRESS_TEST = 0x1a5fdbc891c5d4e6ad68064ae45d43146d4f9f3an
 const EVM_ONRAMP_ADDRESS_TEST = 0x111111c891c5d4e6ad68064ae45d43146d4f9f3an
 const LEAF_DOMAIN_SEPARATOR = beginCell().storeUint(0, 256).asSlice()
+const PERMISSIONLESS_EXECUTION_THRESHOLD_SECONDS = 60
 
 // These have to match the EVM states
 const EXECUTION_STATE_IN_PROGRESS = 1n
@@ -165,7 +156,7 @@ async function deployOffRampContract(
     feeQuoter: ZERO_ADDRESS,
     router: owner.address, // used to determine who can send RMN updates
     chainSelector: CHAINSEL_TON,
-    permissionlessExecutionThresholdSeconds: 60,
+    permissionlessExecutionThresholdSeconds: PERMISSIONLESS_EXECUTION_THRESHOLD_SECONDS,
     latestPriceSequenceNumber: 0n,
   }
 
@@ -1416,6 +1407,79 @@ describe('OffRamp - Unit Tests', () => {
     })
   })
 
+  it('Manual execute after permissionlessExecutionThresholdSeconds', async () => {
+    const message = createTestMessage(1n, 1n, receiver.address) // empty data (Cell.EMPTY)
+    await setupAndCommitMessage(message)
+    const report = createExecuteReport([message])
+
+    // Try manual exec when is not enabled
+    const manualExecFirstAttempt = await manualExecuteReport(report)
+    expect(manualExecFirstAttempt.transactions).toHaveTransaction({
+      from: offRamp.address,
+      success: false,
+      exitCode: MerkleRootError.ManualExecutionNotYetEnabled,
+    })
+
+    // Almost there, still needs to fail
+    warpTime(PERMISSIONLESS_EXECUTION_THRESHOLD_SECONDS)
+
+    const manualExecSecondAttempt = await manualExecuteReport(report)
+    expect(manualExecSecondAttempt.transactions).toHaveTransaction({
+      from: offRamp.address,
+      success: false,
+      exitCode: MerkleRootError.ManualExecutionNotYetEnabled,
+    })
+
+    // One more sec and we are ready to go
+    warpTime(1)
+
+    const manualExecThirdAttempt = await manualExecuteReport(report, undefined, true)
+    expect(manualExecThirdAttempt.transactions).toHaveTransaction({
+      from: router.address,
+      to: receiver.address,
+      value: message.gasLimit,
+      success: true,
+    })
+
+    assertLog(
+      manualExecThirdAttempt.transactions,
+      offRamp.address,
+      CCIPLogs.LogTypes.ExecutionStateChanged,
+      {
+        sourceChainSelector: CHAINSEL_EVM_TEST_90000001,
+        sequenceNumber: 1n,
+        messageId: 1n,
+        state: EXECUTION_STATE_IN_PROGRESS,
+      },
+    )
+
+    assertLog(
+      manualExecThirdAttempt.transactions,
+      offRamp.address,
+      CCIPLogs.LogTypes.ExecutionStateChanged,
+      {
+        sourceChainSelector: CHAINSEL_EVM_TEST_90000001,
+        sequenceNumber: 1n,
+        messageId: 1n,
+        state: EXECUTION_STATE_SUCCESS,
+      },
+    )
+
+    assertLog(
+      manualExecThirdAttempt.transactions,
+      receiver.address,
+      CCIPLogs.LogTypes.ReceiverCCIPMessageReceived,
+      {
+        message: {
+          messageId: message.header.messageId,
+          sourceChainSelector: CHAINSEL_EVM_TEST_90000001,
+          sender: message.sender,
+          data: message.data,
+        },
+      },
+    )
+  })
+
   it('Manual execute: receiver fails, then succeeds', async () => {
     const message = createTestMessage(1n, 1n, receiver.address) // empty data (Cell.EMPTY)
     await setupAndCommitMessage(message)