build(deps): bump @openzeppelin/contracts-upgradeable from 4.9.1 to 4.9.2

.gitignore

@@ -1,6 +1,7 @@
 node_modules
 log/
 .vscode/
+.openzeppelin/
 #Hardhat files
 cache
 artifacts

README.md

@@ -1,21 +1,49 @@
 # BloctoAccount & BloctoAccountFactory
 
-## Test & Deploy
+## Test
 
 test
 ```
-npx hardhat test test/entrypoint.test.ts  
+yarn test
 ```
 
-deploy BloctoAccountFactory
+Schnorr Multi Sign Test
 
 ```
-yarn deploy-accountfactory --network mumbai
+npx hardhat test test/schnorrMultiSign.test.ts 
 ```
 
-verify BloctoAccountFactory
+## Deploy & Verify
+
+deploy BloctoAccountCloneableWallet, BloctoAccountFactory, and addStake to BloctoAccountFactory
+
+```
+yarn deploy_verify --network goerli
+```
+
+create a test account and verify
+```
+npx hardhat run deploy/2_createSchnorrAccount_verify.ts --network goerli
+```
+
+
+## Tool
+
+check storage layout
+```
+npx hardhat check
+```
+
+## Testnet chain info
+
+goerli, arbitrum goerli, op goerli, mumbai, bsc testnet, avax testnet
 ```
-yarn verify-accountfactory --network mumbai
+BloctoAccountCloneableWallet
+0x490B5ED8A17224a553c34fAA642161c8472118dd
+BloctoAccountFactory
+0x285cc5232236D227FCb23E6640f87934C948a028
+VerifyingPaymaster
+0x9C58dF1BB61a3f68C66Ef5fC7D8Ab4bd1DaEC9Ac
 ```
 
 

contracts/BloctoAccount.sol

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+/* solhint-disable avoid-low-level-calls */
+/* solhint-disable no-inline-assembly */
+/* solhint-disable reason-string */
+
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@account-abstraction/contracts/core/BaseAccount.sol";
+
+import "./TokenCallbackHandler.sol";
+import "./CoreWallet/CoreWallet.sol";
+
+/**
+ * Blocto account.
+ *  compatibility for EIP-4337 and smart contract wallet with cosigner functionality (CoreWallet)
+ */
+contract BloctoAccount is UUPSUpgradeable, TokenCallbackHandler, CoreWallet, BaseAccount {
+    /**
+     *  This is the version of this contract.
+     */
+    string public constant VERSION = "1.4.0";
+
+    /// @notice etnrypoint from 4337 official
+    IEntryPoint private immutable _entryPoint;
+
+    /// @notice initialized _IMPLEMENTATION_SLOT
+    bool public initializedImplementation = false;
+
+    /**
+     * constructor for BloctoAccount
+     * @param anEntryPoint entrypoint address
+     */
+    constructor(IEntryPoint anEntryPoint) {
+        _entryPoint = anEntryPoint;
+    }
+
+    /**
+     * override from UUPSUpgradeable
+     * @param newImplementation implementation address
+     */
+    function _authorizeUpgrade(address newImplementation) internal view override onlyInvoked {
+        (newImplementation);
+    }
+
+    /**
+     * return entrypoint
+     */
+    function entryPoint() public view virtual override returns (IEntryPoint) {
+        return _entryPoint;
+    }
+
+    /**
+     * execute a transaction (called directly by entryPoint)
+     * @param dest dest call address
+     * @param value value to send
+     * @param func the func containing the transaction to be called
+     */
+    function execute(address dest, uint256 value, bytes calldata func) external {
+        _requireFromEntryPoint();
+        _call(dest, value, func);
+    }
+
+    /**
+     * execute a sequence of transactions (called directly by entryPoint)
+     * @param dest sequence of dest call address
+     * @param value sequence of value to send
+     * @param func sequence of the func containing transactions to be called
+     */
+    function executeBatch(address[] calldata dest, uint256[] calldata value, bytes[] calldata func) external {
+        _requireFromEntryPoint();
+        require(dest.length == func.length, "wrong array lengths");
+        for (uint256 i = 0; i < dest.length; i++) {
+            _call(dest[i], value[i], func[i]);
+        }
+    }
+
+    /**
+     * internal call for execute and executeBatch
+     * @param target target call address
+     * @param value value to send
+     * @param data the data containing the transaction to be called
+     */
+    function _call(address target, uint256 value, bytes memory data) internal {
+        (bool success, bytes memory result) = target.call{value: value}(data);
+        if (!success) {
+            assembly {
+                revert(add(result, 32), mload(result))
+            }
+        }
+    }
+
+    /**
+     * implement validate signature method of BaseAccount from etnrypoint
+     * @param userOp user operation including signature for validating
+     * @param userOpHash user operation hash
+     */
+    function _validateSignature(UserOperation calldata userOp, bytes32 userOpHash)
+        internal
+        virtual
+        override
+        returns (uint256 validationData)
+    {
+        bytes4 result = this.isValidSignature(userOpHash, userOp.signature);
+        if (result != IERC1271.isValidSignature.selector) {
+            return SIG_VALIDATION_FAILED;
+        }
+
+        return 0;
+    }
+
+    /**
+     * check current account deposit in the entryPoint StakeManager
+     */
+    function getDeposit() public view returns (uint256) {
+        return entryPoint().balanceOf(address(this));
+    }
+
+    /**
+     * deposit more funds for this account in the entryPoint StakeManager
+     */
+    function addDeposit() public payable {
+        entryPoint().depositTo{value: msg.value}(address(this));
+    }
+
+    /**
+     * withdraw deposit to withdrawAddress from entryPoint StakeManager
+     * @param withdrawAddress target to send to
+     * @param amount to withdraw
+     */
+    function withdrawDepositTo(address payable withdrawAddress, uint256 amount) external onlyInvoked {
+        entryPoint().withdrawTo(withdrawAddress, amount);
+    }
+
+    /// @notice Used to decorate the `init` function so this can only be called one time. Necessary
+    ///  since this contract will often be used as a "clone". (See above.)
+    modifier onlyOnceInitImplementation() {
+        require(!initializedImplementation, "must not already be initialized");
+        initializedImplementation = true;
+        _;
+    }
+
+    /// @notice initialize BloctoAccountProxy for adding the implementation address
+    /// @param implementation implementation address
+    function initImplementation(address implementation) public onlyOnceInitImplementation {
+        require(Address.isContract(implementation), "ERC1967: new implementation is not a contract");
+        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = implementation;
+    }
+
+    function disableInitImplementation() public {
+        initializedImplementation = true;
+    }
+}

contracts/BloctoAccountCloneableWallet.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+import "./BloctoAccount.sol";
+
+/// @title BloctoAccountCloneableWallet Wallet
+/// @notice This contract represents a complete but non working wallet.
+contract BloctoAccountCloneableWallet is BloctoAccount {
+    /// @notice  constructor that deploys a NON-FUNCTIONAL version of `BloctoAccount`
+    /// @param anEntryPoint entrypoint address
+    constructor(IEntryPoint anEntryPoint) BloctoAccount(anEntryPoint) {
+        initialized = true;
+        initializedImplementation = true;
+    }
+}

contracts/BloctoAccountFactory.sol

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+import "@openzeppelin/contracts/utils/Create2.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
+import "./BloctoAccountProxy.sol";
+import "./BloctoAccount.sol";
+
+// BloctoAccountFactory for creating BloctoAccountProxy
+contract BloctoAccountFactory is Initializable, OwnableUpgradeable {
+    /// @notice this is the version of this contract.
+    string public constant VERSION = "1.4.0";
+    /// @notice the init implementation address of BloctoAccountCloneableWallet, never change for cosistent address
+    address public initImplementation;
+    /// @notice the implementation address of BloctoAccountCloneableWallet
+    address public bloctoAccountImplementation;
+    /// @notice the address from EIP-4337 official implementation
+    IEntryPoint public entryPoint;
+
+    event WalletCreated(address wallet, address authorizedAddress, bool full);
+
+    /// @notice initialize
+    /// @param _bloctoAccountImplementation the implementation address for BloctoAccountCloneableWallet
+    /// @param _entryPoint the entrypoint address from EIP-4337 official implementation
+    function initialize(address _bloctoAccountImplementation, IEntryPoint _entryPoint) public initializer {
+        __Ownable_init_unchained();
+        initImplementation = _bloctoAccountImplementation;
+        bloctoAccountImplementation = _bloctoAccountImplementation;
+        entryPoint = _entryPoint;
+    }
+
+    /// @notice create an account, and return its BloctoAccount.
+    ///     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
+    /// @param _authorizedAddress the initial authorized address, must not be zero!
+    /// @param _cosigner the initial cosigning address for `_authorizedAddress`, can be equal to `_authorizedAddress`
+    /// @param _recoveryAddress the initial recovery address for the wallet, can be address(0)
+    /// @param _salt salt for create account (used for address calculation in create2)
+    /// @param _mergedKeyIndexWithParity the corresponding index of mergedKeys = authVersion + _mergedIndex
+    /// @param _mergedKey the corresponding mergedKey (using Schnorr merged key)
+    function createAccount(
+        address _authorizedAddress,
+        address _cosigner,
+        address _recoveryAddress,
+        uint256 _salt,
+        uint8 _mergedKeyIndexWithParity,
+        bytes32 _mergedKey
+    ) public onlyOwner returns (BloctoAccount ret) {
+        bytes32 salt = keccak256(abi.encodePacked(_salt, _cosigner, _recoveryAddress));
+        // to be consistent address
+        BloctoAccountProxy newProxy = new BloctoAccountProxy{salt: salt}(initImplementation);
+        ret = BloctoAccount(payable(address(newProxy)));
+        // to save gas, first deploy using disableInitImplementation()
+        // to be consistent address, (after) first upgrade need to call initImplementation
+        ret.disableInitImplementation();
+        ret.init(
+            _authorizedAddress, uint256(uint160(_cosigner)), _recoveryAddress, _mergedKeyIndexWithParity, _mergedKey
+        );
+        emit WalletCreated(address(ret), _authorizedAddress, false);
+    }
+
+    /// @notice create an account with multiple authorized addresses, and return its BloctoAccount.
+    ///     returns the address even if the account is already deployed.
+    /// @param _authorizedAddresses the initial authorized addresses, must not be zero!
+    /// @param _cosigner the initial cosigning address for `_authorizedAddress`, can be equal to `_authorizedAddress`
+    /// @param _recoveryAddress the initial recovery address for the wallet, can be address(0)
+    /// @param _salt salt for create account (used for address calculation in create2)
+    /// @param _mergedKeyIndexWithParitys the corresponding index of mergedKeys = authVersion + _mergedIndex
+    /// @param _mergedKeys the corresponding mergedKey
+    function createAccount2(
+        address[] calldata _authorizedAddresses,
+        address _cosigner,
+        address _recoveryAddress,
+        uint256 _salt,
+        uint8[] calldata _mergedKeyIndexWithParitys,
+        bytes32[] calldata _mergedKeys
+    ) public onlyOwner returns (BloctoAccount ret) {
+        bytes32 salt = keccak256(abi.encodePacked(_salt, _cosigner, _recoveryAddress));
+        // to be consistent address
+        BloctoAccountProxy newProxy = new BloctoAccountProxy{salt: salt}(initImplementation);
+
+        ret = BloctoAccount(payable(address(newProxy)));
+        // to save gas, first deploy use disableInitImplementation()
+        // to be consistent address, (after) first upgrade need to call initImplementation()
+        // ret.initImplementation(bloctoAccountImplementation);
+        ret.disableInitImplementation();
+        ret.init2(
+            _authorizedAddresses, uint256(uint160(_cosigner)), _recoveryAddress, _mergedKeyIndexWithParitys, _mergedKeys
+        );
+        // emit event only with _authorizedAddresses[0]
+        emit WalletCreated(address(ret), _authorizedAddresses[0], true);
+    }
+
+    /// @notice calculate the counterfactual address of this account as it would be returned by createAccount()
+    /// @param _cosigner the initial cosigning address
+    /// @param _recoveryAddress the initial recovery address for the wallet
+    /// @param _salt salt for create account (used for address calculation in create2)
+    function getAddress(address _cosigner, address _recoveryAddress, uint256 _salt) public view returns (address) {
+        bytes32 salt = keccak256(abi.encodePacked(_salt, _cosigner, _recoveryAddress));
+        return Create2.computeAddress(
+            bytes32(salt),
+            keccak256(abi.encodePacked(type(BloctoAccountProxy).creationCode, abi.encode(address(initImplementation))))
+        );
+    }
+
+    /// @notice set the implementation
+    /// @param _bloctoAccountImplementation update the implementation address of BloctoAccountCloneableWallet for createAccount and createAccount2
+    function setImplementation(address _bloctoAccountImplementation) public onlyOwner {
+        bloctoAccountImplementation = _bloctoAccountImplementation;
+    }
+
+    /// @notice set the entrypoint
+    /// @param _entrypoint target entrypoint
+    function setEntrypoint(IEntryPoint _entrypoint) public onlyOwner {
+        entryPoint = _entrypoint;
+    }
+
+    /// @notice withdraw value from the deposit
+    /// @param withdrawAddress target to send to
+    /// @param amount to withdraw
+    function withdrawTo(address payable withdrawAddress, uint256 amount) public onlyOwner {
+        entryPoint.withdrawTo(withdrawAddress, amount);
+    }
+
+    /// @notice add stake in etnrypoint for this factory to avoid bundler reject
+    /// @param unstakeDelaySec - the unstake delay for this factory. Can only be increased.
+    function addStake(uint32 unstakeDelaySec) external payable onlyOwner {
+        entryPoint.addStake{value: msg.value}(unstakeDelaySec);
+    }
+}