Add manual execution to offramp

contracts/contracts/ccip/merkle_root/contract.tolk

@@ -85,7 +85,24 @@ fun _validateAndExecute(msg: MerkleRoot_Validate, sender: address) {
     var st = MerkleRoot_Storage.load();
 
     assert(sender == st.owner, Error.NotOwner);
-    assert(st.state == STATE_UNTOUCHED, Error.StateIsNotUntouched);
+    assert(st.state == STATE_UNTOUCHED || st.state == STATE_EXECUTE_FAILED, Error.SkippedAlreadyExecutedMessage);
+
+    val isManualExecute = msg.gasOverride != null; 
+    if (isManualExecute) {
+        val permissionlessExecutionThreshold = 1; // TODO: read this from offramp
+        // TODO: validate limits
+        val isOldCommitReport = (blockchain.now() - st.timestamp < permissionlessExecutionThreshold);
+
+        // Manual execution is fine if we previously failed or if the commit report is just too old.
+        assert(isOldCommitReport && st.state == STATE_EXECUTE_FAILED, Error.ManualExecutionNotYetEnabled);
+
+        if (msg.gasOverride! != 0) {
+            // TODO: specify this as gas value on execution
+        }
+    } else {
+        // DON can only execute a message once.
+        assert(st.state == STATE_UNTOUCHED, Error.AlreadyAttempted);
+    }
 
     val ccipMessage = msg.message;
 

contracts/contracts/ccip/merkle_root/errors.tolk

@@ -1,10 +1,11 @@
 import "../../lib/utils"
 
 enum Error {
-    StateIsNotUntouched = 47900; // Facility ID * 100
+    AlreadyAttempted = 47900; // Facility ID * 100
     UpdatingStateOfNonExecutedMessage;
     NotificationFromInvalidReceiver;
     NotOwner;
+    ManualExecutionNotYetEnabled;
+    SkippedAlreadyExecutedMessage;
 }
 
-

contracts/contracts/ccip/merkle_root/messages.tolk

@@ -6,6 +6,7 @@ type MerkleRoot_InMessage = MerkleRoot_Validate | MerkleRoot_CCIPReceiveBounced
 struct (0x38ede91) MerkleRoot_Validate {
     message: Any2TVMRampMessage,
     //TODO: token data
+    gasOverride: coins?,
 }
 
 //crc32('MerkleRoot_CCIPReceiveConfirm')

contracts/contracts/ccip/merkle_root/storage.tolk

@@ -4,6 +4,7 @@ import "../common/types";
 struct MerkleRoot_Storage {
     rootId: uint224;
     owner: address;
+    timestamp: uint64;
     state: uint8 = 0;
     executionState: uint8 = 0; 
     tokenBalance: TokenBalance = TokenBalance{};

contracts/contracts/ccip/offramp/contract.tolk

@@ -27,6 +27,9 @@ fun onInternalMessage(in:InMessage) {
         OffRamp_Execute => {
             _execute(msg, in.senderAddress)
         }
+        OffRamp_ManuallyExecute => {
+            _manually_execute(msg, in.senderAddress)
+        }
         OCR3Base_SetOCR3Config => { 
             _setOCR3Config(msg, in.senderAddress)
         }
@@ -262,6 +265,7 @@ fun _commit(msg: OffRamp_Commit, sender: address) {
                     data: MerkleRoot_Storage {
                         rootId: rootId.endCell().beginParse().loadUint(224), 
                         owner: contract.getAddress(),
+                        timestamp: blockchain.now(),
                         state: 0,
                         executionState: 0,
                         tokenBalance: TokenBalance{}
@@ -295,14 +299,38 @@ fun _commit(msg: OffRamp_Commit, sender: address) {
     );
 }
 
+fun _manually_execute(msg:OffRamp_ManuallyExecute, sender: address) {
+    var st = Storage.load();
+
+    val report = msg.report;
+
+    // when_chain_not_forked assert
+
+    _execute_single_report(msg.report, msg.gasOverride, sender);
+
+}
+
 fun _execute(msg: OffRamp_Execute, sender: address) {
+    _execute_single_report(msg.report, null, sender);
+
+    var st = Storage.load();
+
+    st.ocr3Base.load().transmit(
+        sender,
+        OCR_PLUGIN_TYPE_EXECUTE,
+        msg.reportContext,
+        msg.report.toCell(),
+        beginCell().endCell(),
+    );
+
+}
+
+fun _execute_single_report(report: ExecutionReport, gasOverride: coins?, sender: address) {
     var st = Storage.load();
 
     // TODO: manual execution flag
     // TODO: check if chain was cursed by RMNRemote
 
-    val report = msg.report;
-
     var sourceChainConfigResult = st.sourceChainConfigs.get(report.sourceChainSelector);
     assert(sourceChainConfigResult.isFound, Error.SourceChainNotEnabled);
 
@@ -352,20 +380,11 @@ fun _execute(msg: OffRamp_Execute, sender: address) {
 
          body: MerkleRoot_Validate {
             message: Any2TVMRampMessage.fromCell(report.messages),
+            gasOverride,
          },
      });
      executeMsg.send(SEND_MODE_REGULAR);
-
     // TODO: how do we handle incrementing the nonce? since execution is async this might take a while
-
-    st.ocr3Base.load().transmit(
-        sender,
-        OCR_PLUGIN_TYPE_EXECUTE,
-        msg.reportContext,
-        msg.report.toCell(),
-        beginCell().endCell(),
-    );
-
 }
 
 //todo: maybe it should be chainConfigs and take an array?

contracts/contracts/ccip/offramp/errors.tolk

@@ -9,5 +9,3 @@ enum Error {
     InvalidOnRampUpdate
 }
 
-
-

contracts/contracts/ccip/offramp/messages.tolk

@@ -7,6 +7,7 @@ import "../common/types.tolk"
 type OffRamp_InMessage =
     | OffRamp_Commit
     | OffRamp_Execute
+    | OffRamp_ManuallyExecute
     | OffRamp_DispatchValidated
     | OffRamp_UpdateSourceChainConfig
     | OCR3Base_SetOCR3Config
@@ -33,6 +34,13 @@ struct (0x27bdac33) OffRamp_Execute {
     report: ExecutionReport;
 }
 
+//crc32('OffRamp_ManuallyExecute')
+struct (0xa00785cf) OffRamp_ManuallyExecute {
+    queryId: uint64;
+    report: ExecutionReport;
+    gasOverride: coins; // TODO: should this just be part of the added gas value passed into the call?
+}
+
 //crc32('OffRamp_UpdateSourceChainConfig')
 struct (0xb98c95e3) OffRamp_UpdateSourceChainConfig {
     queryId: uint64;

contracts/contracts/ccip/test/receiver/contract.tolk

@@ -18,7 +18,11 @@ struct CCIPMessageReceived {
     message: Any2TVMMessage
 }
 
-type Msg = Receiver_CCIPReceive;
+struct (0x00000001) SetRejectAll {
+    rejectAll: bool;
+}
+
+type Msg = Receiver_CCIPReceive | SetRejectAll;
 
 fun onInternalMessage(in: InMessage) {
     val msg = lazy Msg.fromSlice(in.body);
@@ -27,8 +31,9 @@ fun onInternalMessage(in: InMessage) {
             // Standard for every receiver to implement:
             // - Check CCIPReceive only comes from offRamp/ router
             // - Send CCIPReceiveConfirm to msg.callback
-            assert(in.senderAddress == Storage.load().offRamp, Error.Unauthorized);
-
+            val st = Storage.load();
+            assert(in.senderAddress == st.offRamp, Error.Unauthorized);
+            assert(!st.rejectAll, Error.Rejected);
             val receiveConfirm = createMessage({
                 bounce: true,
                 value: ton("0.05"), //TODO how much do we need to send
@@ -43,6 +48,11 @@ fun onInternalMessage(in: InMessage) {
                 message: msg.message,
             });
         }
+        SetRejectAll => {
+            var st = Storage.load();
+            st.rejectAll = msg.rejectAll;
+            st.store();
+        }
         else => {
             // ignore empty messages, "wrong opcode" for others
             assert (in.body.isEmpty()) throw 0xFFFF

contracts/contracts/ccip/test/receiver/errors.tolk

@@ -2,5 +2,6 @@ import "../../../lib/utils"
 
 enum Error {
     Unauthorized = 34600; // Facility ID * 100
+    Rejected;
 }
 

contracts/contracts/ccip/test/receiver/storage.tolk

@@ -1,6 +1,7 @@
 struct Storage {
     id: uint32;
     offRamp: address; // TODO: should be router?
+    rejectAll: bool;
 }
 
 fun Storage.load(): Storage {

contracts/tests/ccip/OffRamp.spec.ts

@@ -290,6 +290,24 @@ describe('OffRamp', () => {
     return result
   }
 
+  const manualExecuteReport = async (
+    report: ExecutionReport,
+    gasOverride: bigint | undefined = undefined,
+    expectSuccess = true,
+  ) => {
+    const result = await offRamp.sendManualExecute(transmitters[0].getSender(), {
+      value: toNano('0.5'),
+      report,
+      gasOverride,
+    })
+
+    if (expectSuccess) {
+      expectSuccessfulTransaction(result, transmitters[0].address, offRamp.address)
+    }
+
+    return result
+  }
+
   const executeReportExpectingFailure = async (
     report: ExecutionReport,
     expectedErrorCode: number,
@@ -397,7 +415,7 @@ describe('OffRamp', () => {
     {
       let code = await compile('ccip.test.receiver')
       receiver = blockchain.openContract(
-        Receiver.createFromConfig({ id: 1, offramp: offRamp.address }, code),
+        Receiver.createFromConfig({ id: 1, offramp: offRamp.address, rejectAll: false }, code),
       )
       const result = await receiver.sendDeploy(deployer.getSender(), toNano('10'))
       expect(result.transactions).toHaveTransaction({
@@ -689,7 +707,7 @@ describe('OffRamp', () => {
     // There should be a failed transaction with the specific error code from offRamp to MerkleRoot
     expect(secondExecuteResult.transactions).toHaveTransaction({
       from: offRamp.address,
-      exitCode: MerkleRootError.StateIsNotUntouched,
+      exitCode: MerkleRootError.SkippedAlreadyExecutedMessage,
       success: false,
     })
   })
@@ -1047,7 +1065,7 @@ describe('OffRamp', () => {
     let code = await compile('ccip.test.receiver')
     const wrongOffRampAddress = generateMockTonAddress() // Use a different address
     const badReceiver = blockchain.openContract(
-      Receiver.createFromConfig({ id: 1, offramp: wrongOffRampAddress }, code),
+      Receiver.createFromConfig({ id: 1, offramp: wrongOffRampAddress, rejectAll: false }, code),
     )
     const result = await badReceiver.sendDeploy(deployer.getSender(), toNano('10'))
     expect(result.transactions).toHaveTransaction({
@@ -1104,6 +1122,67 @@ describe('OffRamp', () => {
     )
   })
 
+  it('Manual execute: receiver fails, then succeeds', async () => {
+    const message = createTestMessage(1n, 1n, receiver.address) // empty data (Cell.EMPTY)
+    await setupAndCommitMessage(message)
+    const report = createExecuteReport([message])
+
+    const result = await receiver.sendSetRejectAll(deployer.getSender(), toNano('0.1'), true);
+    expect(result.transactions).toHaveTransaction({
+      from: deployer.address,
+      to: receiver.address,
+      success: true,
+    })
+
+    const result2 = await executeReport(report)
+
+    // TODO: expect fail
+
+    const result3 = await receiver.sendSetRejectAll(deployer.getSender(), toNano('0.1'), false);
+    expect(result.transactions).toHaveTransaction({
+      from: deployer.address,
+      to: receiver.address,
+      success: true,
+    })
+
+    //
+    const result4 = await manualExecuteReport(report, undefined, true)
+
+    expect(result4.transactions).toHaveTransaction({
+      from: offRamp.address,
+      to: receiver.address,
+      success: true,
+    })
+
+    assertLog(result4.transactions, offRamp.address, CCIPLogs.LogTypes.ExecutionStateChanged, {
+      sourceChainSelector: CHAINSEL_EVM_TEST_90000001,
+      sequenceNumber: 1n,
+      messageId: 1n,
+      state: EXECUTION_STATE_IN_PROGRESS,
+    })
+
+    assertLog(result4.transactions, offRamp.address, CCIPLogs.LogTypes.ExecutionStateChanged, {
+      sourceChainSelector: CHAINSEL_EVM_TEST_90000001,
+      sequenceNumber: 1n,
+      messageId: 1n,
+      state: EXECUTION_STATE_SUCCESS,
+    })
+
+    assertLog(
+      result4.transactions,
+      receiver.address,
+      CCIPLogs.LogTypes.ReceiverCCIPMessageReceived,
+      {
+        message: {
+          messageId: message.header.messageId,
+          sourceChainSelector: CHAINSEL_EVM_TEST_90000001,
+          sender: message.sender,
+          data: message.data,
+        },
+      },
+    )
+  })
+
   it('Test facilityId matches facility name', () => {
     expect(MERKLE_ROOT_FACILITY_ID).toEqual(facilityId(crc32(MERKLE_ROOT_FACILITY_NAME)))
     expect(OFFRAMP_FACILITY_ID).toEqual(facilityId(crc32(OFFRAMP_FACILITY_NAME)))

contracts/tests/ccip/Receiver.spec.ts

@@ -41,6 +41,7 @@ describe('Receiver', () => {
       let data: ReceiverStorage = {
         id: generateSecureRandomId(),
         offramp: deployer.address,
+        rejectAll: false,
       }
 
       receiver = blockchain.openContract(Receiver.createFromConfig(data, code))