init EnsoWalletV2 and EnsoWalletV2Factory

Author: Brenzee

src/wallet/EnsoWalletV2.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.20;
+
+import { AbstractEnsoShortcuts } from "../AbstractEnsoShortcuts.sol";
+import { AbstractMultiSend } from "../AbstractMultiSend.sol";
+import { Withdrawable } from "../utils/Withdrawable.sol";
+
+import { Initializable } from "openzeppelin-contracts/proxy/utils/Initializable.sol";
+
+contract EnsoWalletV2 is AbstractMultiSend, AbstractEnsoShortcuts, Initializable, Withdrawable {
+    string public constant VERSION = "1.0.0";
+    address public factory;
+    address private _owner;
+
+    error InvalidSender(address sender);
+
+    modifier onlyOwner() {
+        _checkOwner();
+        _;
+    }
+
+    /**
+     * @notice Initializes the wallet with an owner address
+     * @param owner_ The address that will own this wallet
+     */
+    function initialize(address owner_) external initializer {
+        _owner = owner_;
+        // sender has to be the factory
+        factory = msg.sender;
+    }
+
+    /**
+     * @notice Executes an arbitrary call to a target contract
+     * @param target The address of the contract to call
+     * @param value The amount of native token to send with the call
+     * @param data The calldata to send to the target contract
+     * @return success Whether the call succeeded
+     */
+    function execute(
+        address target,
+        uint256 value,
+        bytes memory data
+    )
+        external
+        payable
+        onlyOwner
+        returns (bool success)
+    {
+        assembly {
+            success := call(gas(), target, value, add(data, 0x20), mload(data), 0, 0)
+        }
+    }
+
+    /**
+     * @notice Executes a shortcut
+     * @dev Can be called by owner or factory
+     * @param accountId The bytes32 value representing an API user
+     * @param requestId The bytes32 value representing an API request
+     * @param commands An array of bytes32 values that encode calls
+     * @param state An array of bytes that are used to generate call data for each command
+     * @return response Array of response data from each executed command
+     */
+    function executeShortcut(
+        bytes32 accountId,
+        bytes32 requestId,
+        bytes32[] calldata commands,
+        bytes[] calldata state
+    )
+        public
+        payable
+        override
+        returns (bytes[] memory response)
+    {
+        return super.executeShortcut(accountId, requestId, commands, state);
+    }
+
+    /// @notice Abstract override function to return owner
+    function owner() public view override returns (address) {
+        return _owner;
+    }
+
+    /// @notice Abstract override function to validate msg.sender
+    function _checkMsgSender() internal view override(AbstractEnsoShortcuts, AbstractMultiSend) {
+        if (msg.sender != factory && msg.sender != owner()) revert InvalidSender(msg.sender);
+    }
+
+    /// @notice Abstract override function to validate if sender is the owner
+    function _checkOwner() internal view override {
+        if (msg.sender != owner()) revert InvalidSender(msg.sender);
+    }
+}

src/wallet/EnsoWalletV2Factory.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.20;
+
+import { Token, TokenType } from "../interfaces/IEnsoRouter.sol";
+
+import { IEnsoWalletV2 } from "./interfaces/IEnsoWalletV2.sol";
+
+import { IERC1155 } from "openzeppelin-contracts/token/ERC1155/IERC1155.sol";
+import { IERC20, SafeERC20 } from "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol";
+import { IERC721 } from "openzeppelin-contracts/token/ERC721/IERC721.sol";
+import { LibClone } from "solady/utils/LibClone.sol";
+
+contract EnsoWalletV2Factory {
+    using LibClone for address;
+    using SafeERC20 for IERC20;
+
+    address public immutable implementation;
+
+    event EnsoWalletV2Deployed(address wallet, address indexed account);
+
+    error WrongMsgValue(uint256 value, uint256 expectedAmount);
+    error UnsupportedTokenType(TokenType tokenType);
+
+    constructor(address implementation_) {
+        implementation = implementation_;
+    }
+
+    function deploy(address account) external returns (address) {
+        return _deploy(account);
+    }
+
+    function deployAndExecute(Token calldata tokenIn, bytes calldata data) external payable returns (address, bool) {
+        return _deployAndExecute(tokenIn, data);
+    }
+
+    function getAddress(address account) external view returns (address) {
+        bytes32 salt = _getSalt(account);
+        return implementation.predictDeterministicAddress(salt, address(this));
+    }
+
+    function _deployAndExecute(
+        Token calldata tokenIn,
+        bytes calldata data
+    )
+        private
+        returns (address wallet, bool success)
+    {
+        // strictly only msg.sender can deploy and execute
+        wallet = _deploy(msg.sender);
+        bool isNativeAsset = _transfer(tokenIn, wallet);
+        if (!isNativeAsset && msg.value != 0) revert WrongMsgValue(msg.value, 0);
+        (success,) = wallet.call{ value: msg.value }(data);
+    }
+
+    function _deploy(address account) private returns (address wallet) {
+        bytes32 salt = _getSalt(account);
+        wallet = implementation.predictDeterministicAddress(salt, address(this));
+        if (wallet.code.length == 0) {
+            implementation.cloneDeterministic(salt);
+            IEnsoWalletV2(wallet).initialize(account);
+            emit EnsoWalletV2Deployed(wallet, account);
+        }
+    }
+
+    function _transfer(Token calldata token, address receiver) private returns (bool isNativeAsset) {
+        TokenType tokenType = token.tokenType;
+
+        if (tokenType == TokenType.ERC20) {
+            (IERC20 erc20, uint256 amount) = abi.decode(token.data, (IERC20, uint256));
+            erc20.safeTransferFrom(msg.sender, receiver, amount);
+        } else if (tokenType == TokenType.Native) {
+            // no need to get amount, it will come from msg.value
+            isNativeAsset = true;
+        } else if (tokenType == TokenType.ERC721) {
+            (IERC721 erc721, uint256 tokenId) = abi.decode(token.data, (IERC721, uint256));
+            erc721.safeTransferFrom(msg.sender, receiver, tokenId);
+        } else if (tokenType == TokenType.ERC1155) {
+            (IERC1155 erc1155, uint256 tokenId, uint256 amount) = abi.decode(token.data, (IERC1155, uint256, uint256));
+            erc1155.safeTransferFrom(msg.sender, receiver, tokenId, amount, "0x");
+        } else {
+            revert UnsupportedTokenType(tokenType);
+        }
+    }
+
+    function _getSalt(address account) internal pure returns (bytes32) {
+        return keccak256(abi.encode(account));
+    }
+}

src/wallet/interfaces/IEnsoWalletV2.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.20;
+
+interface IEnsoWalletV2 {
+    error InvalidSender(address sender);
+
+    function initialize(address owner_) external;
+
+    function executeShortcut(
+        bytes32 accountId,
+        bytes32 requestId,
+        bytes32[] calldata commands,
+        bytes[] calldata state
+    )
+        external
+        payable
+        returns (bytes[] memory response);
+}
+