feat: setup initial test bases

Author: livingrockrises

.gas-snapshot

@@ -0,0 +1,12 @@
+IntegrationGreeter:test_Greet() (gas: 27808)
+TestAccountConfig_AccountId:test_WhenCheckingTheAccountID() (gas: 10039)
+TestAccountConfig_SupportsExecutionMode:test_RevertIf_UnsupportedExecutionMode() (gas: 14687)
+TestAccountConfig_SupportsExecutionMode:test_SupportsBatchExecutionMode_Success() (gas: 14463)
+TestAccountConfig_SupportsExecutionMode:test_SupportsSingleExecutionMode_Success() (gas: 14552)
+UnitGreeter:test_ConstructorWhenPassingAnEmptyGreetingString() (gas: 68737)
+UnitGreeter:test_ConstructorWhenPassingValidGreetingString() (gas: 500951)
+UnitGreeter:test_EmptyTestExample() (gas: 0)
+UnitGreeter:test_GreetWhenCalled() (gas: 23509)
+UnitGreeter:test_SetGreetingWhenCalledByANon_owner(address) (runs: 1000, μ: 11815, ~: 11815)
+UnitGreeter:test_SetGreetingWhenPassingAValidGreetingString() (gas: 23570)
+UnitGreeter:test_SetGreetingWhenPassingAnEmptyGreetingString() (gas: 11763)

src/factory/StartaleAccountFactory.sol

@@ -1,4 +1,50 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.28;
 
-// Generic Account Factory which can deploy SA with more modules (multiple validation schemes, executors, hooks etc upon deployment itself)
+import {IStartaleAccountFactory} from '../interfaces/IStartaleAccountFactory.sol';
+import {ProxyLib} from '../lib/ProxyLib.sol';
+import {Stakeable} from '../utils/Stakeable.sol';
+
+/// @title Startale Account Factory
+/// @dev Generic Account Factory which can deploy SA with more modules (multiple validation schemes, executors, hooks etc upon deployment itself)
+/// @notice Manages the creation of Modular Smart Accounts compliant with ERC-7579 and ERC-4337 using a factory pattern.
+/// @author Startale labs
+contract StartaleAccountFactory is Stakeable, IStartaleAccountFactory {
+  /// @notice Address of the implementation contract used to create new Startale Account instances.
+  /// @dev This address is immutable and set upon deployment, ensuring the implementation cannot be changed.
+  address public immutable ACCOUNT_IMPLEMENTATION;
+
+  /// @notice Constructor to set the smart account implementation address and the factory owner.
+  /// @param implementation_ The address of the Startale Account implementation to be used for all deployments.
+  /// @param owner_ The address of the owner of the factory.
+  constructor(address implementation_, address owner_) Stakeable(owner_) {
+    require(implementation_ != address(0), ImplementationAddressCanNotBeZero());
+    require(owner_ != address(0), ZeroAddressNotAllowed());
+    ACCOUNT_IMPLEMENTATION = implementation_;
+  }
+
+  /// @notice Creates a new Startale Account with the provided initialization data.
+  /// @param initData Initialization data to be called on the new Smart Account.
+  /// @param salt Unique salt for the Smart Account creation.
+  /// @return The address of the newly created Startale Account.
+  function createAccount(bytes calldata initData, bytes32 salt) external payable override returns (address payable) {
+    // Deploy the Startale Account using the ProxyLib
+    (bool alreadyDeployed, address payable account) = ProxyLib.deployProxy(ACCOUNT_IMPLEMENTATION, salt, initData);
+    if (!alreadyDeployed) {
+      emit AccountCreated(account, initData, salt);
+    }
+    return account;
+  }
+
+  /// @notice Computes the expected address of a Startale Account using the factory's deterministic deployment algorithm.
+  /// @param initData - Initialization data to be called on the new Smart Account.
+  /// @param salt - Unique salt for the Smart Account creation.
+  /// @return expectedAddress The expected address at which the Startale Account will be deployed if the provided parameters are used.
+  function computeAccountAddress(
+    bytes calldata initData,
+    bytes32 salt
+  ) external view override returns (address payable expectedAddress) {
+    // Return the expected address of the Startale Account using the provided initialization data and salt
+    return ProxyLib.predictProxyAddress(ACCOUNT_IMPLEMENTATION, salt, initData);
+  }
+}

src/interfaces/IStartaleAccountFactory.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/// @title Interface for Generic Startale Account Factory
+/// @notice Interface that provides the essential structure for account factories.
+/// @author Startale labs
+interface IStartaleAccountFactory {
+  /// @notice Emitted when a new Smart Account is created.
+  /// @param account The address of the newly created account.
+  /// @param initData Initialization data used for the new Smart Account.
+  /// @param salt Unique salt used during the creation of the Smart Account.
+  event AccountCreated(address indexed account, bytes indexed initData, bytes32 indexed salt);
+
+  /// @notice Error indicating that the account is already deployed
+  /// @param account The address of the account that is already deployed
+  error AccountAlreadyDeployed(address account);
+
+  /// @notice Error thrown when the owner address is zero.
+  error ZeroAddressNotAllowed();
+
+  /// @notice Error thrown when the implementation address is zero.
+  error ImplementationAddressCanNotBeZero();
+
+  /// @notice Creates a new Startale Account with initialization data.
+  /// @param initData Initialization data to be called on the new Smart Account.
+  /// @param salt Unique salt for the Smart Account creation.
+  /// @return The address of the newly created Startale Account.
+  function createAccount(bytes calldata initData, bytes32 salt) external payable returns (address payable);
+
+  /// @notice Computes the expected address of a Startale Account using the factory's deterministic deployment algorithm.
+  /// @param initData Initialization data to be called on the new Smart Account.
+  /// @param salt Unique salt for the Smart Account creation.
+  /// @return expectedAddress The expected address at which the Startale Account will be deployed if the provided parameters are used.
+  function computeAccountAddress(
+    bytes calldata initData,
+    bytes32 salt
+  ) external view returns (address payable expectedAddress);
+}

src/lib/ModuleTypeLib.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+type EncodedModuleTypes is uint256;
+
+type ModuleType is uint8;
+
+/// @title ModuleTypeLib
+/// @notice A library for handling module types and encoding them as bits
+library ModuleTypeLib {
+  /// @notice Checks if the given EncodedModuleTypes contains a specific module type
+  /// @param self The encoded module types
+  /// @param moduleTypeId The module type to check for
+  /// @return True if the module type is present, false otherwise
+  function isType(EncodedModuleTypes self, ModuleType moduleTypeId) internal pure returns (bool) {
+    // Check if the specific bit for the moduleTypeId is set in the encoded value using bitwise shift
+    return (EncodedModuleTypes.unwrap(self) & (uint256(1) << ModuleType.unwrap(moduleTypeId))) != 0;
+  }
+
+  /// @notice Encodes an array of ModuleType into a single EncodedModuleTypes bitmask
+  /// @param moduleTypes An array of ModuleType to encode
+  /// @return The encoded module types
+  // example for bitEncode, similar adjustments should be done for isType, bitEncodeCalldata
+  function bitEncode(ModuleType[] memory moduleTypes) internal pure returns (EncodedModuleTypes) {
+    uint256 result;
+
+    // Iterate through the moduleTypes array and set the corresponding bits in the result
+    for (uint256 i; i < moduleTypes.length; i++) {
+      result |= uint256(1) << ModuleType.unwrap(moduleTypes[i]);
+    }
+
+    return EncodedModuleTypes.wrap(result);
+  }
+
+  /// @notice Encodes a calldata array of ModuleType into a single EncodedModuleTypes bitmask
+  /// @param moduleTypes A calldata array of ModuleType to encode
+  /// @return The encoded module types
+  function bitEncodeCalldata(ModuleType[] calldata moduleTypes) internal pure returns (EncodedModuleTypes) {
+    uint256 result;
+
+    // Iterate through the moduleTypes array and set the corresponding bits in the result
+    for (uint256 i; i < moduleTypes.length; i++) {
+      result |= uint256(1) << ModuleType.unwrap(moduleTypes[i]);
+    }
+
+    return EncodedModuleTypes.wrap(result);
+  }
+}

test/foundry/mocks/MockDelegateTarget.sol

@@ -0,0 +1 @@
+

test/foundry/mocks/MockExecutor.sol

@@ -0,0 +1 @@
+

test/foundry/mocks/MockHandler.sol

@@ -0,0 +1 @@
+

test/foundry/mocks/MockHook.sol

@@ -0,0 +1 @@
+

test/foundry/mocks/MockPaymaster.sol

@@ -0,0 +1 @@
+

test/foundry/mocks/MockTarget.sol

@@ -0,0 +1 @@
+