feat:add support for delegate calltype

.solhint.json

@@ -18,9 +18,9 @@
     "imports-on-top": "error",
     "ordering": "error",
     "visibility-modifier-order": "error",
-    "code-complexity": ["error", 9],
+    "code-complexity": ["error", 11],
     "function-max-lines": ["error", 80],
-    "max-line-length": ["error", 150],
+    "max-line-length": ["error", 170],
     "no-empty-blocks": "off",
     "no-unused-vars": "error",
     "payable-fallback": "off",

contracts/Nexus.sol

@@ -25,7 +25,7 @@
 import { ExecutionHelper } from "./base/ExecutionHelper.sol";
 import { IValidator } from "./interfaces/modules/IValidator.sol";
 import { MODULE_TYPE_VALIDATOR, MODULE_TYPE_EXECUTOR, MODULE_TYPE_FALLBACK, MODULE_TYPE_HOOK, VALIDATION_FAILED } from "./types/Constants.sol";
-import { ModeLib, ExecutionMode, ExecType, CallType, CALLTYPE_BATCH, CALLTYPE_SINGLE, EXECTYPE_DEFAULT, EXECTYPE_TRY } from "./lib/ModeLib.sol";
+import { ModeLib, ExecutionMode, ExecType, CallType, CALLTYPE_BATCH, CALLTYPE_SINGLE, CALLTYPE_DELEGATECALL, EXECTYPE_DEFAULT, EXECTYPE_TRY } from "./lib/ModeLib.sol";
 
 /// @title Nexus - Smart Account
 /// @notice This contract integrates various functionalities to handle modular smart accounts compliant with ERC-7579 and ERC-4337 standards.
@@ -102,6 +102,8 @@
             _handleSingleExecution(executionCalldata, execType);
         } else if (callType == CALLTYPE_BATCH) {
             _handleBatchExecution(executionCalldata, execType);
+        } else if (callType == CALLTYPE_DELEGATECALL) {
+            _handleDelegateCallExecution(executionCalldata, execType);
         } else {
             revert UnsupportedCallType(callType);
         }
@@ -140,6 +142,14 @@
             if (execType == EXECTYPE_DEFAULT) returnData = _executeBatch(executions);
             else if (execType == EXECTYPE_TRY) returnData = _tryExecuteBatch(executions);
             else revert UnsupportedExecType(execType);
+        } else if (callType == CALLTYPE_DELEGATECALL) {
+            // destructure executionCallData according to single exec
+            address delegate = address(uint160(bytes20(executionCalldata[0:20])));
+            bytes calldata callData = executionCalldata[20:];
+            // check if execType is revert or try
+            if (execType == EXECTYPE_DEFAULT) _executeDelegatecall(delegate, callData);
+            else if (execType == EXECTYPE_TRY) _tryExecuteDelegatecall(delegate, callData);
+            else revert UnsupportedExecType(execType);
         } else {
             revert UnsupportedCallType(callType);
         }
@@ -282,7 +292,9 @@
         (CallType callType, ExecType execType) = mode.decodeBasic();
 
         // Return true if both the call type and execution type are supported.
-        return (callType == CALLTYPE_SINGLE || callType == CALLTYPE_BATCH) && (execType == EXECTYPE_DEFAULT || execType == EXECTYPE_TRY);
+        return
+            (callType == CALLTYPE_SINGLE || callType == CALLTYPE_BATCH || callType == CALLTYPE_DELEGATECALL) &&
+            (execType == EXECTYPE_DEFAULT || execType == EXECTYPE_TRY);
     }
 
     /// @notice Determines whether a module is installed on the smart account.
@@ -551,6 +563,17 @@
         else revert UnsupportedExecType(execType);
     }
 
+    /// @dev Executes a single transaction based on the specified execution type.
+    /// @param executionCalldata The calldata containing the transaction details (target address, value, and data).
+    /// @param execType The execution type, which can be DEFAULT (revert on failure) or TRY (return on failure).
+    function _handleDelegateCallExecution(bytes calldata executionCalldata, ExecType execType) private {
+        address delegate = address(uint160(bytes20(executionCalldata[0:20])));
+        bytes calldata callData = executionCalldata[20:];
+        if (execType == EXECTYPE_DEFAULT) _executeDelegatecall(delegate, callData);
+        else if (execType == EXECTYPE_TRY) _tryExecuteDelegatecall(delegate, callData);
+        else revert UnsupportedExecType(execType);
+    }
+
     /// @notice Checks if a module is installed on the smart account.
     /// @param moduleTypeId The module type ID.
     /// @param module The module address.

contracts/base/ExecutionHelper.sol

@@ -95,4 +95,38 @@
             if (!success) emit TryExecuteUnsuccessful(i, result[i]);
         }
     }
+
+    /// @dev Execute a delegatecall with `delegate` on this account.
+    function _executeDelegatecall(address delegate, bytes calldata callData) internal returns (bytes memory result) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            result := mload(0x40)
+            calldatacopy(result, callData.offset, callData.length)
+            // Forwards the `data` to `delegate` via delegatecall.
+            if iszero(delegatecall(gas(), delegate, result, callData.length, codesize(), 0x00)) {
+                // Bubble up the revert if the call reverts.
+                returndatacopy(result, 0x00, returndatasize())
+                revert(result, returndatasize())
+            }
+            mstore(result, returndatasize()) // Store the length.
+            let o := add(result, 0x20)
+            returndatacopy(o, 0x00, returndatasize()) // Copy the returndata.
+            mstore(0x40, add(o, returndatasize())) // Allocate the memory.
+        }
+    }
+
+    /// @dev Execute a delegatecall with `delegate` on this account and catch reverts.
+    function _tryExecuteDelegatecall(address delegate, bytes calldata callData) internal returns (bool success, bytes memory result) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            result := mload(0x40)
+            calldatacopy(result, callData.offset, callData.length)
+            // Forwards the `data` to `delegate` via delegatecall.
+            success := delegatecall(gas(), delegate, result, callData.length, codesize(), 0x00)
+            mstore(result, returndatasize()) // Store the length.
+            let o := add(result, 0x20)
+            returndatacopy(o, 0x00, returndatasize()) // Copy the returndata.
+            mstore(0x40, add(o, returndatasize())) // Allocate the memory.
+        }
+    }
 }

test/foundry/unit/concrete/accountexecution/TestAccountExecution_ExecuteFromExecutor.t.sol

@@ -150,26 +150,6 @@ contract TestAccountExecution_ExecuteFromExecutor is TestAccountExecution_Base {
         assertEq(balanceRecipient, amount, "Recipient should have received 0 tokens");
     }
 
-    /// @notice Tests execution with an unsupported call type via MockExecutor
-    function test_RevertIf_ExecuteFromExecutor_UnsupportedCallType() public {
-        ExecutionMode unsupportedMode = ExecutionMode.wrap(bytes32(abi.encodePacked(bytes1(0xff), bytes1(0x00), bytes4(0), bytes22(0))));
-        bytes memory executionCalldata = abi.encodePacked(address(counter), uint256(0), abi.encodeWithSelector(Counter.incrementNumber.selector));
-
-        (CallType callType, , , ) = ModeLib.decode(unsupportedMode);
-        Execution[] memory execution = new Execution[](1);
-        execution[0] = Execution(address(mockExecutor), 0, executionCalldata);
-
-        vm.expectRevert(abi.encodeWithSelector(UnsupportedCallType.selector, callType));
-
-        mockExecutor.customExecuteViaAccount(
-            unsupportedMode,
-            BOB_ACCOUNT,
-            address(counter),
-            0,
-            abi.encodeWithSelector(Counter.incrementNumber.selector)
-        );
-    }
-
     /// @notice Tests single execution with an unsupported execution type via MockExecutor
     function test_RevertIf_ExecuteFromExecutor_UnsupportedExecType_Single() public {
         // Create an unsupported execution mode with an invalid execution type

test/hardhat/smart-account/Nexus.Basics.specs.ts

@@ -31,7 +31,7 @@ import {
   CALLTYPE_BATCH,
   CALLTYPE_SINGLE,
   EXECTYPE_DEFAULT,
-  EXECTYPE_DELEGATE,
+  CALLTYPE_DELEGATE,
   EXECTYPE_TRY,
   MODE_DEFAULT,
   MODE_PAYLOAD,
@@ -247,29 +247,29 @@ describe("Nexus Basic Specs", function () {
       expect(
         await smartAccount.supportsExecutionMode(
           ethers.concat([
-            ethers.zeroPadValue(toBeHex(EXECTYPE_DELEGATE), 1),
-            ethers.zeroPadValue(toBeHex(CALLTYPE_SINGLE), 1),
+            ethers.zeroPadValue(toBeHex(CALLTYPE_DELEGATE), 1),
+            ethers.zeroPadValue(toBeHex(EXECTYPE_DEFAULT), 1),
             ethers.zeroPadValue(toBeHex(UNUSED), 4),
             ethers.zeroPadValue(toBeHex(MODE_DEFAULT), 4),
             ethers.zeroPadValue(toBeHex(MODE_PAYLOAD), 22),
           ]),
         ),
-      ).to.be.false;
+      ).to.be.true;
     });
 
     it("Should verify unsupported execution modes", async function () {
       // Checks support for predefined module types (e.g., Validation, Execution)
       expect(
         await smartAccount.supportsExecutionMode(
           ethers.concat([
-            ethers.zeroPadValue(toBeHex(EXECTYPE_DELEGATE), 1),
-            ethers.zeroPadValue(toBeHex(CALLTYPE_SINGLE), 1),
+            ethers.zeroPadValue(toBeHex(CALLTYPE_DELEGATE), 1),
+            ethers.zeroPadValue(toBeHex(EXECTYPE_DEFAULT), 1),
             ethers.zeroPadValue(toBeHex(UNUSED), 4),
             ethers.zeroPadValue(toBeHex("0x00"), 4),
             ethers.zeroPadValue(toBeHex(MODE_PAYLOAD), 22),
           ]),
         ),
-      ).to.be.false;
+      ).to.be.true;
     });
 
     it("Should return false for unsupported execution mode", async function () {

test/hardhat/utils/erc7579Utils.ts

@@ -7,7 +7,7 @@ export const CALLTYPE_SINGLE = "0x00"; // 1 byte
 export const CALLTYPE_BATCH = "0x01"; // 1 byte
 export const EXECTYPE_DEFAULT = "0x00"; // 1 byte
 export const EXECTYPE_TRY = "0x01"; // 1 byte
-export const EXECTYPE_DELEGATE = "0xFF"; // 1 byte
+export const CALLTYPE_DELEGATE = "0xFF"; // 1 byte
 export const MODE_DEFAULT = "0x00000000"; // 4 bytes
 export const UNUSED = "0x00000000"; // 4 bytes
 export const MODE_PAYLOAD = "0x00000000000000000000000000000000000000000000"; // 22 bytes