feat: bootstrap and eoa onboarding factory

Author: livingrockrises

.gitmodules

@@ -22,3 +22,6 @@
 [submodule "lib/ExcessivelySafeCall"]
 	path = lib/ExcessivelySafeCall
 	url = https://github.com/nomad-xyz/ExcessivelySafeCall
+[submodule "lib/erc7739Validator"]
+	path = lib/erc7739Validator
+	url = https://github.com/erc7579/erc7739Validator

lib/erc7739Validator

@@ -7,4 +7,5 @@ solady/=lib/solady/src/
 openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/
 openzeppelin-contracts/=lib/openzeppelin-contracts/
 sentinellist=lib/sentinellist/src/
-excessively-safe-call=lib/ExcessivelySafeCall/src/
+excessively-safe-call=lib/ExcessivelySafeCall/src/
+erc7739Validator/=lib/erc7739Validator/src/

remappings.txt

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {BootstrapLib} from '../lib/BootstrapLib.sol';
+
+import {ProxyLib} from '../lib/ProxyLib.sol';
+import {Bootstrap, BootstrapConfig} from '../utils/Bootstrap.sol';
+import {Stakeable} from '../utils/Stakeable.sol';
+
+/// @title EOAOnboardingFactory for Startale Smart Account
+/// @notice Manages the creation of Modular Smart Accounts compliant with ERC-7579 and ERC-4337 using an ECDSA validator.
+/// @author Startale
+/// Special thanks to the Biconomy team for https://github.com/bcnmy/nexus/ on which this factory implementation is highly based on.
+/// Special thanks to the Solady team for foundational contributions: https://github.com/Vectorized/solady
+contract EOAOnboardingFactory is Stakeable {
+  /// @notice Stores the implementation contract address used to create new Nexus instances.
+  /// @dev This address is set once upon deployment and cannot be changed afterwards.
+  address public immutable ACCOUNT_IMPLEMENTATION;
+
+  /// @notice Stores the ECDSA Validator module address.
+  /// @dev This address is set once upon deployment and cannot be changed afterwards.
+  address public immutable ECDSA_VALIDATOR;
+
+  /// @notice Stores the Bootstrapper module address.
+  /// @dev This address is set once upon deployment and cannot be changed afterwards.
+  Bootstrap public immutable BOOTSTRAPPER;
+
+  /// @notice Emitted when a new Smart Account is created, capturing the account details and associated module configurations.
+  event AccountCreated(address indexed account, address indexed owner, uint256 indexed index);
+
+  /// @notice Error thrown when a zero address is provided for the implementation, ECDSA validator, or bootstrapper.
+  error ZeroAddressNotAllowed();
+
+  /// @notice Constructor to set the immutable variables.
+  /// @param implementation The address of the Nexus implementation to be used for all deployments.
+  /// @param factoryOwner The address of the factory owner.
+  /// @param ecdsaValidator The address of the K1 Validator module to be used for all deployments.
+  /// @param bootstrapper The address of the Bootstrapper module to be used for all deployments.
+  constructor(
+    address implementation,
+    address factoryOwner,
+    address ecdsaValidator,
+    Bootstrap bootstrapper
+  ) Stakeable(factoryOwner) {
+    require(
+      !(
+        implementation == address(0) || ecdsaValidator == address(0) || address(bootstrapper) == address(0)
+          || factoryOwner == address(0)
+      ),
+      ZeroAddressNotAllowed()
+    );
+    ACCOUNT_IMPLEMENTATION = implementation;
+    ECDSA_VALIDATOR = ecdsaValidator;
+    BOOTSTRAPPER = bootstrapper;
+  }
+
+  /// @notice Creates a new Startale Smart Acount with a specific validator and initialization data.
+  /// @param eoaOwner The address of the EOA owner.
+  /// @param index The index of the Account(to deploy multiple with same auth config).
+  /// @return The address of the newly created account.
+  function createAccount(address eoaOwner, uint256 index) external payable returns (address payable) {
+    // Compute the salt for deterministic deployment
+    bytes32 salt = keccak256(abi.encodePacked(eoaOwner, index));
+
+    // Create the validator configuration using the NexusBootstrap library
+    BootstrapConfig memory validator = BootstrapLib.createSingleConfig(ECDSA_VALIDATOR, abi.encodePacked(eoaOwner));
+    bytes memory initData = BOOTSTRAPPER.getInitWithSingleValidatorCalldata(validator);
+
+    // Deploy the Smart account using the ProxyLib
+    (bool alreadyDeployed, address payable account) = ProxyLib.deployProxy(ACCOUNT_IMPLEMENTATION, salt, initData);
+    if (!alreadyDeployed) {
+      emit AccountCreated(account, eoaOwner, index);
+    }
+    return account;
+  }
+
+  /// @notice Computes the expected address of a Startale smart account contract using the factory's deterministic deployment algorithm.
+  /// @param eoaOwner The address of the EOA owner.
+  /// @param index The index of the the Account(to deploy multiple with same auth config).
+  /// @return expectedAddress The expected address at which the smart account contract will be deployed if the provided parameters are used.
+  function computeAccountAddress(
+    address eoaOwner,
+    uint256 index
+  ) external view returns (address payable expectedAddress) {
+    // Compute the salt for deterministic deployment
+    bytes32 salt = keccak256(abi.encodePacked(eoaOwner, index));
+
+    // Create the validator configuration using the NexusBootstrap library
+    BootstrapConfig memory validator = BootstrapLib.createSingleConfig(ECDSA_VALIDATOR, abi.encodePacked(eoaOwner));
+
+    // Get the initialization data for the Nexus account
+    bytes memory initData = BOOTSTRAPPER.getInitWithSingleValidatorCalldata(validator);
+
+    // Compute the predicted address using the ProxyLib
+    return ProxyLib.predictProxyAddress(ACCOUNT_IMPLEMENTATION, salt, initData);
+  }
+}

src/factory/EOAOnboardingFactory.sol

@@ -0,0 +1,4 @@
+// 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)

src/factory/StartaleAccountFactory.sol

@@ -0,0 +1,276 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+library AssociatedArrayLib {
+  using AssociatedArrayLib for *;
+
+  struct Array {
+    uint256 _spacer;
+  }
+
+  struct Bytes32Array {
+    Array _inner;
+  }
+
+  struct AddressArray {
+    Array _inner;
+  }
+
+  struct UintArray {
+    Array _inner;
+  }
+
+  error AssociatedArray_OutOfBounds(uint256 index);
+
+  function add(Bytes32Array storage s, address account, bytes32 value) internal {
+    if (!_contains(s._inner, account, value)) {
+      _push(s._inner, account, value);
+    }
+  }
+
+  function set(Bytes32Array storage s, address account, uint256 index, bytes32 value) internal {
+    _set(s._inner, account, index, value);
+  }
+
+  function push(Bytes32Array storage s, address account, bytes32 value) internal {
+    _push(s._inner, account, value);
+  }
+
+  function pop(Bytes32Array storage s, address account) internal {
+    _pop(s._inner, account);
+  }
+
+  function remove(Bytes32Array storage s, address account, uint256 index) internal {
+    _remove(s._inner, account, index);
+  }
+
+  function add(UintArray storage s, address account, uint256 value) internal {
+    if (!_contains(s._inner, account, bytes32(value))) {
+      _push(s._inner, account, bytes32(value));
+    }
+  }
+
+  function set(UintArray storage s, address account, uint256 index, uint256 value) internal {
+    _set(s._inner, account, index, bytes32(value));
+  }
+
+  function push(UintArray storage s, address account, uint256 value) internal {
+    _push(s._inner, account, bytes32(value));
+  }
+
+  function pop(UintArray storage s, address account) internal {
+    _pop(s._inner, account);
+  }
+
+  function remove(UintArray storage s, address account, uint256 index) internal {
+    _remove(s._inner, account, index);
+  }
+
+  function add(AddressArray storage s, address account, address value) internal {
+    if (!_contains(s._inner, account, bytes32(uint256(uint160(value))))) {
+      _push(s._inner, account, bytes32(uint256(uint160(value))));
+    }
+  }
+
+  function set(AddressArray storage s, address account, uint256 index, address value) internal {
+    _set(s._inner, account, index, bytes32(uint256(uint160(value))));
+  }
+
+  function push(AddressArray storage s, address account, address value) internal {
+    _push(s._inner, account, bytes32(uint256(uint160(value))));
+  }
+
+  function pop(AddressArray storage s, address account) internal {
+    _pop(s._inner, account);
+  }
+
+  function remove(AddressArray storage s, address account, uint256 index) internal {
+    _remove(s._inner, account, index);
+  }
+
+  function length(Bytes32Array storage s, address account) internal view returns (uint256) {
+    return _length(s._inner, account);
+  }
+
+  function get(Bytes32Array storage s, address account, uint256 index) internal view returns (bytes32) {
+    return _get(s._inner, account, index);
+  }
+
+  function getAll(Bytes32Array storage s, address account) internal view returns (bytes32[] memory) {
+    return _getAll(s._inner, account);
+  }
+
+  function contains(Bytes32Array storage s, address account, bytes32 value) internal view returns (bool) {
+    return _contains(s._inner, account, value);
+  }
+
+  function length(AddressArray storage s, address account) internal view returns (uint256) {
+    return _length(s._inner, account);
+  }
+
+  function get(AddressArray storage s, address account, uint256 index) internal view returns (address) {
+    return address(uint160(uint256(_get(s._inner, account, index))));
+  }
+
+  function getAll(AddressArray storage s, address account) internal view returns (address[] memory) {
+    bytes32[] memory bytes32Array = _getAll(s._inner, account);
+    address[] memory addressArray;
+
+    /// @solidity memory-safe-assembly
+    assembly {
+      addressArray := bytes32Array
+    }
+    return addressArray;
+  }
+
+  function contains(AddressArray storage s, address account, address value) internal view returns (bool) {
+    return _contains(s._inner, account, bytes32(uint256(uint160(value))));
+  }
+
+  function length(UintArray storage s, address account) internal view returns (uint256) {
+    return _length(s._inner, account);
+  }
+
+  function get(UintArray storage s, address account, uint256 index) internal view returns (uint256) {
+    return uint256(_get(s._inner, account, index));
+  }
+
+  function getAll(UintArray storage s, address account) internal view returns (uint256[] memory) {
+    bytes32[] memory bytes32Array = _getAll(s._inner, account);
+    uint256[] memory uintArray;
+
+    /// @solidity memory-safe-assembly
+    assembly {
+      uintArray := bytes32Array
+    }
+    return uintArray;
+  }
+
+  function contains(UintArray storage s, address account, uint256 value) internal view returns (bool) {
+    return _contains(s._inner, account, bytes32(value));
+  }
+
+  function _set(Array storage s, address account, uint256 index, bytes32 value) private {
+    _set(_slot(s, account), index, value);
+  }
+
+  function _set(bytes32 slot, uint256 index, bytes32 value) private {
+    assembly {
+      //if (index >= _length(s, account)) revert AssociatedArray_OutOfBounds(index);
+      if iszero(lt(index, sload(slot))) {
+        mstore(0, 0x8277484f) // `AssociatedArray_OutOfBounds(uint256)`
+        mstore(0x20, index)
+        revert(0x1c, 0x24)
+      }
+      sstore(add(slot, mul(0x20, add(index, 1))), value)
+    }
+  }
+
+  function _push(Array storage s, address account, bytes32 value) private {
+    bytes32 slot = _slot(s, account);
+    assembly {
+      // load length (stored @ slot), add 1 to it => index.
+      // mul index by 0x20 and add it to orig slot to get the next free slot
+      let index := add(sload(slot), 1)
+      sstore(add(slot, mul(0x20, index)), value)
+      sstore(slot, index) //increment length by 1
+    }
+  }
+
+  function _pop(Array storage s, address account) private {
+    bytes32 slot = _slot(s, account);
+    uint256 __length;
+    assembly {
+      __length := sload(slot)
+    }
+    if (__length == 0) return;
+    _set(slot, __length - 1, 0);
+    assembly {
+      sstore(slot, sub(__length, 1))
+    }
+  }
+
+  function _remove(Array storage s, address account, uint256 index) private {
+    bytes32 slot = _slot(s, account);
+    uint256 __length;
+    assembly {
+      __length := sload(slot)
+      if iszero(lt(index, __length)) {
+        mstore(0, 0x8277484f) // `AssociatedArray_OutOfBounds(uint256)`
+        mstore(0x20, index)
+        revert(0x1c, 0x24)
+      }
+    }
+    _set(slot, index, _get(s, account, __length - 1));
+
+    assembly {
+      // clear the last slot
+      // this is the 'unchecked' version of _set(slot, __length - 1, 0)
+      // as we use length-1 as index, so the check is excessive.
+      // also removes extra -1 and +1 operations
+      sstore(add(slot, mul(0x20, __length)), 0)
+      // store new length
+      sstore(slot, sub(__length, 1))
+    }
+  }
+
+  function _length(Array storage s, address account) private view returns (uint256 __length) {
+    bytes32 slot = _slot(s, account);
+    assembly {
+      __length := sload(slot)
+    }
+  }
+
+  function _get(Array storage s, address account, uint256 index) private view returns (bytes32 value) {
+    return _get(_slot(s, account), index);
+  }
+
+  function _get(bytes32 slot, uint256 index) private view returns (bytes32 value) {
+    assembly {
+      //if (index >= _length(s, account)) revert AssociatedArray_OutOfBounds(index);
+      if iszero(lt(index, sload(slot))) {
+        mstore(0, 0x8277484f) // `AssociatedArray_OutOfBounds(uint256)`
+        mstore(0x20, index)
+        revert(0x1c, 0x24)
+      }
+      value := sload(add(slot, mul(0x20, add(index, 1))))
+    }
+  }
+
+  function _getAll(Array storage s, address account) private view returns (bytes32[] memory values) {
+    bytes32 slot = _slot(s, account);
+    uint256 __length;
+    assembly {
+      __length := sload(slot)
+    }
+    values = new bytes32[](__length);
+    for (uint256 i; i < __length; i++) {
+      values[i] = _get(slot, i);
+    }
+  }
+
+  // inefficient. complexity = O(n)
+  // use with caution
+  // in case of large arrays, consider using EnumerableSet4337 instead
+  function _contains(Array storage s, address account, bytes32 value) private view returns (bool) {
+    bytes32 slot = _slot(s, account);
+    uint256 __length;
+    assembly {
+      __length := sload(slot)
+    }
+    for (uint256 i; i < __length; i++) {
+      if (_get(slot, i) == value) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function _slot(Array storage s, address account) private pure returns (bytes32 __slot) {
+    assembly {
+      mstore(0x00, account)
+      mstore(0x20, s.slot)
+      __slot := keccak256(0x00, 0x40)
+    }
+  }
+}