chore: SimplePlusAccount init

package.json

@@ -7,7 +7,8 @@
  "url": "https://github.com/jpgonzalezra"
  },
  "dependencies": {
- "@openzeppelin/contracts": "^5.0.1"
+ "@openzeppelin/contracts": "5.0.2",
+ "@account-abstraction/contracts": "0.7.0"
  },
  "devDependencies": {
  "forge-std": "github:foundry-rs/forge-std#v1.8.1",

remappings.txt

@@ -1,2 +1,5 @@
 @openzeppelin/contracts/=node_modules/@openzeppelin/contracts/
+@openzeppelin/contracts-upgradeable/=node_modules/@openzeppelin/contracts-upgradeable/
 forge-std/=node_modules/forge-std/
+@account-abstraction/contracts/=node_modules/@account-abstraction/contracts/
+solady/=solady/src

script/Deploy.s.sol

@@ -1,13 +1,13 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity >=0.8.25 <0.9.0;
+// // SPDX-License-Identifier: UNLICENSED
+// pragma solidity >=0.8.25 <0.9.0;
 
-import { Foo } from "../src/Foo.sol";
+// import { SimplePlusAccount } from "../src/SimplePlusAccount.sol";
 
-import { BaseScript } from "./Base.s.sol";
+// import { BaseScript } from "./Base.s.sol";
 
-/// @dev See the Solidity Scripting tutorial: https://book.getfoundry.sh/tutorials/solidity-scripting
-contract Deploy is BaseScript {
- function run() public broadcast returns (Foo foo) {
- foo = new Foo();
- }
-}
+// /// @dev See the Solidity Scripting tutorial: https://book.getfoundry.sh/tutorials/solidity-scripting
+// contract Deploy is BaseScript {
+//  function run() public broadcast returns (Foo foo) {
+//  foo = new Foo();
+//  }
+// }

src/SimplePlusAccount.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.25;
+
+import { SimpleAccount, IEntryPoint } from "@account-abstraction/contracts/samples/SimpleAccount.sol";
+import { SIG_VALIDATION_SUCCESS, SIG_VALIDATION_FAILED } from "@account-abstraction/contracts/core/Helpers.sol";
+import { PackedUserOperation } from "@account-abstraction/contracts/interfaces/PackedUserOperation.sol";
+import { SignatureChecker } from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
+import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import { IERC1271 } from "@openzeppelin/contracts/interfaces/IERC1271.sol";
+import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+
+contract SimplePlusAccount is SimpleAccount, IERC1271, EIP712 {
+ using ECDSA for bytes32;
+ using MessageHashUtils for bytes32;
+
+ bytes32 internal constant _MESSAGE_TYPEHASH = keccak256("SimplePlusAccount(bytes message)");
+
+ modifier onlyAuthorized() {
+ _onlyAuthorized();
+ _;
+ }
+
+ // @notice Signature types used for user operation validation and ERC-1271 signature validation.
+ enum SignatureType {
+ EOA,
+ CONTRACT,
+ CONTRACT_WITH_ADDR
+ }
+
+ error InvalidOwner(address newOwner);
+ error NotAuthorized();
+ error InvalidSignatureType();
+
+ event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+ constructor(IEntryPoint anEntryPoint) SimpleAccount(anEntryPoint) EIP712("SimplePlusAccount", "1") { }
+
+ /**
+ * @dev The _entryPoint member is immutable, to reduce gas consumption. To upgrade EntryPoint,
+ * a new implementation of SimpleAccount must be deployed with the new EntryPoint address, then upgrading
+ * the implementation by calling `upgradeTo()`
+ */
+ function initialize(address anOwner) public virtual override initializer {
+ _initialize(anOwner);
+ }
+
+ /// @dev Revert if the caller is not any of:
+ /// 1. The entry point
+ /// 2. The account itself (when redirected through `execute`, etc.)
+ /// 3. An owner
+ function _onlyAuthorized() internal view {
+ if (msg.sender != address(entryPoint()) && msg.sender != address(this) && msg.sender != owner) {
+ revert NotAuthorized();
+ }
+ }
+
+ /// @notice Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current
+ /// owner or from the entry point via a user operation signed by the current owner.
+ /// @param newOwner The new owner.
+ function transferOwnership(address newOwner) external onlyAuthorized {
+ if (newOwner == address(0) || newOwner == address(this) || owner == newOwner) {
+ revert InvalidOwner(newOwner);
+ }
+ address oldOwner = owner;
+ owner = newOwner;
+ emit OwnershipTransferred(oldOwner, newOwner);
+ }
+
+ /*
+ * @dev Validates the signature of a user operation.
+ *
+ * The signature is considered valid if:
+ * - It is signed by the owner's private key (when the owner is an EOA), or
+ * - It is a valid ERC-1271 signature from the owner (when the owner is a contract).
+ *
+ * Reverts if the signature is malformed or if the signature type is unrecognized.
+ *
+ * Note:
+ * - This function differs from `validateUserOp` in that it does **not** wrap the hash in an
+ * "Ethereum Signed Message" envelope before checking the signature for the EOA-owner case.
+ */
+ function isValidSignature(bytes32 hash, bytes calldata signature) public view virtual returns (bytes4) {
+ bytes32 structHash = keccak256(abi.encode(_MESSAGE_TYPEHASH, keccak256(abi.encode(hash))));
+ bytes32 replaySafeHash = MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
+ return _validateSignatureType(uint8(signature[0]), replaySafeHash, signature[1:]) == SIG_VALIDATION_SUCCESS
+ ? this.isValidSignature.selector
+  : bytes4(0xffffffff);
+ }
+
+ function _validateSignature(
+ PackedUserOperation calldata userOp,
+ bytes32 userOpHash
+ )
+ internal
+ virtual
+ override
+ returns (uint256 validationData)
+ {
+ return _validateSignatureType(uint8(userOp.signature[0]), userOpHash, userOp.signature[1:]);
+ }
+
+ function _validateSignatureType(
+ uint8 signatureType,
+ bytes32 hash,
+ bytes memory signature
+ )
+ private
+ view
+ returns (uint256)
+ {
+ if (signature.length == 0) {
+ revert InvalidSignatureType();
+ }
+
+ if (signatureType == uint8(SignatureType.EOA)) {
+ return _validateEOASignature(hash, signature);
+ } else if (signatureType == uint8(SignatureType.CONTRACT)) {
+ return _validateContractSignature(hash, signature);
+ }
+
+ revert InvalidSignatureType();
+ }
+
+ function _validateEOASignature(bytes32 userOpHash, bytes memory signature) private view returns (uint256) {
+ bytes32 signedHash = userOpHash.toEthSignedMessageHash();
+ address recovered = signedHash.recover(signature);
+ return recovered == owner ? SIG_VALIDATION_SUCCESS : SIG_VALIDATION_FAILED;
+ }
+
+ function _validateContractSignature(bytes32 userOpHash, bytes memory signature) private view returns (uint256) {
+ return SignatureChecker.isValidERC1271SignatureNow(owner, userOpHash, signature)
+ ? SIG_VALIDATION_SUCCESS
+  : SIG_VALIDATION_FAILED;
+ }
+}

src/SimplePlusAccountFactory.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.25;
+
+import "@openzeppelin/contracts/utils/Create2.sol";
+import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+
+import "./SimplePlusAccount.sol";
+
+/**
+ * A sample factory contract for SimplePlusAccount
+ * A UserOperations "initCode" holds the address of the factory, and a method call (to createAccount, in this sample factory).
+ * The factory's createAccount returns the target account address even if it is already installed.
+ * This way, the entryPoint.getSenderAddress() can be called either before or after the account is created.
+ */
+contract SimplePlusAccountFactory {
+ SimplePlusAccount public immutable accountImplementation;
+
+ constructor(IEntryPoint _entryPoint) {
+ accountImplementation = new SimplePlusAccount(_entryPoint);
+ }
+
+ /**
+ * create an account, and return its address.
+ * returns the address even if the account is already deployed.
+ * Note that during UserOperation execution, this method is called only if the account is not deployed.
+ * This method returns an existing account address so that entryPoint.getSenderAddress() would work even after account creation
+ */
+ function createAccount(address owner,uint256 salt) public returns (SimplePlusAccount ret) {
+ address addr = getAddress(owner, salt);
+ uint256 codeSize = addr.code.length;
+ if (codeSize > 0) {
+ return SimplePlusAccount(payable(addr));
+ }
+ ret = SimplePlusAccount(payable(new ERC1967Proxy{salt : bytes32(salt)}(
+ address(accountImplementation),
+ abi.encodeCall(SimplePlusAccount.initialize, (owner))
+ )));
+ }
+
+ /**
+ * calculate the counterfactual address of this account as it would be returned by createAccount()
+ */
+ function getAddress(address owner,uint256 salt) public view returns (address) {
+ return Create2.computeAddress(bytes32(salt), keccak256(abi.encodePacked(
+ type(ERC1967Proxy).creationCode,
+ abi.encode(
+ address(accountImplementation),
+ abi.encodeCall(SimplePlusAccount.initialize, (owner))
+ )
+ )));
+ }
+}

test/AccountTest.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.25;
+
+import "forge-std/src/Test.sol";
+
+import { PackedUserOperation } from "@account-abstraction/contracts/interfaces/PackedUserOperation.sol";
+import { EntryPoint } from "@account-abstraction/contracts/core/EntryPoint.sol";
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
+
+contract AccountTest is Test {
+ using ECDSA for bytes32;
+ using MessageHashUtils for bytes32;
+
+ function getSignedOp(
+ EntryPoint entryPoint,
+ uint8 sigType,
+ bytes memory callData,
+ uint256 privateKey,
+ address account
+ )
+ internal
+ view
+ returns (PackedUserOperation memory)
+ {
+ PackedUserOperation memory op = getUnsignedOp(callData, account);
+ bytes32 userOpHash = entryPoint.getUserOpHash(op);
+ bytes32 ethSignedMessageHash = userOpHash.toEthSignedMessageHash();
+ bytes memory signature = abi.encodePacked(sigType, sign(privateKey, ethSignedMessageHash));
+ op.signature = signature;
+ return op;
+ }
+
+ function getUnsignedOp(bytes memory callData, address account) internal pure returns (PackedUserOperation memory) {
+ uint128 verificationGasLimit = 1 << 24;
+ uint128 callGasLimit = 1 << 24;
+ uint128 maxPriorityFeePerGas = 1 << 8;
+ uint128 maxFeePerGas = 1 << 8;
+ return PackedUserOperation({
+ sender: account,
+ nonce: 0,
+ initCode: "",
+ callData: callData,
+ accountGasLimits: bytes32(uint256(verificationGasLimit) << 128 | callGasLimit),
+ preVerificationGas: 1 << 24,
+ gasFees: bytes32(uint256(maxPriorityFeePerGas) << 128 | maxFeePerGas),
+ paymasterAndData: "",
+ signature: ""
+ });
+ }
+
+ function sign(uint256 privateKey, bytes32 digest) internal pure returns (bytes memory) {
+ (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
+ return abi.encodePacked(r, s, v);
+ }
+}