ERC-7806: 极简的意图中心 EOA 智能账户

interface IStandard {
    /**
     * 验证用户的意图
     *
     * @dev 返回验证结果，该类型使用 bytes4 以实现可扩展性
     * @return result 表示验证结果的值
     */
    function validateUserIntent(bytes calldata intent) external view returns (bytes4 result);

    /**
     * 解包用户的意图，建议在解包时验证意图以节省 gas
     *
     * @dev 返回解包后的结果，该类型使用 bytes 以实现可扩展性
     * @return result 解包后的结果状态
     * @return operations 可以由 IAccount 执行的解包后的操作，不需要与 UserIntent.instructions 匹配
     */
    function unpackOperations(bytes calldata intent) external view returns (bytes4 result, bytes[] memory operations);
}

interface IAccount {
    /**
     * 执行用户的意图
     * 
     * @dev 返回执行结果，该类型使用 bytes 以实现可扩展性
     * @return result 表示执行结果的值
     */
    function executeUserIntent(bytes calldata intent) external returns (bytes memory);
}

struct UserIntent {
    address sender;
    address standard;
    bytes header;
    bytes[] instructions;
    bytes[] signatures;
}

/// @title PackedIntent
/// @notice 这是一个将意图的元数据（发送者、标准、长度）打包到字节中的库
/// @dev 打包的意图数据模式定义如下：
/// @dev 1. sender: address, 20 字节
/// @dev 2. standard: address, 20 字节
/// @dev 3. headerLength: uint16, 2 字节
/// @dev 4. instructionLength: uint16, 2 字节
/// @dev 5. signatureLength: uint16, 2 字节
library PackedIntent {
    /// @notice getSenderAndStandard 是一个从意图中获取发送者和标准的函数
    /// @param intent 要从中获取发送者和标准的意图
    /// @return sender 意图的发送者
    /// @return standard 意图的标准
    function getSenderAndStandard(bytes calldata intent) external pure returns (address, address) {
        require(intent.length >= 40, "Intent 太短");
        return (address(bytes20(intent[: 20])), address(bytes20(intent[20 : 40])));
    }

    /// @notice getLengths 是一个从意图中获取长度的函数
    /// @param intent 用于获取长度的意图
    /// @return headerLength header 的长度
    /// @return instructionLength 指令的长度
    /// @return signatureLength 签名的长度
    function getLengths(bytes calldata intent) external pure returns (uint256, uint256, uint256) {
        require(intent.length >= 46, "缺少长度部分");
        return (
        uint256(uint16(bytes2(intent[40 : 42]))),
        uint256(uint16(bytes2(intent[42 : 44]))),
        uint256(uint16(bytes2(intent[44 : 46])))
        );
    }

    /// @notice getSignatureLength 是一个从意图中获取签名长度的函数
    /// @param intent 用于获取签名长度的意图
    /// @return signatureLength 签名的长度
    function getSignatureLength(bytes calldata intent) external pure returns (uint256) {
        require(intent.length >= 46, "缺少长度部分");
        return uint256(uint16(bytes2(intent[44 : 46])));
    }

    /// @notice getIntentLength 是一个从意图中获取意图长度的函数
    /// @param intent 用于获取意图长度的意图
    /// @return result header、instruction 和 signature 长度之和
    function getIntentLength(bytes calldata intent) external pure returns (uint256) {
        require(intent.length >= 46, "缺少长度部分");
        uint256 headerLength = uint256(uint16(bytes2(intent[40 : 42])));
        uint256 instructionLength = uint256(uint16(bytes2(intent[42 : 44])));
        uint256 signatureLength = uint256(uint16(bytes2(intent[44 : 46])));
        return headerLength + instructionLength + signatureLength + 46;
    }

    /// @notice getIntentLengthFromSection 是一个从长度部分获取意图长度的函数
    /// @param lengthSection 要从其中获取意图长度的长度部分
    /// @return result header、instruction 和 signature 长度之和
    function getIntentLengthFromSection(bytes6 lengthSection) external pure returns (uint16 result) {
        assembly {
            let value := lengthSection
            let a := shr(240, value) // 提取前 2 个字节
            let b := and(shr(224, value), 0xFFFF) // 提取接下来的 2 个字节
            let c := and(shr(208, value), 0xFFFF) // 提取最后 2 个字节
            result := add(add(add(a, b), c), 46)
        }
    }
}

import {MessageHashUtils}
import {ECDSA}
import {IERC20}
import {IStandard}
import {IAccount}
import {PackedIntent}

/// @title ERC7806Constants
/// @notice 这是一个定义 ERC7806 标准常量的库
library ERC7806Constants {
/// @notice VALIDATION_DENIED 是拒绝意图的魔术值
bytes4 public constant VALIDATION_DENIED = 0x00000000;

/// @notice VALIDATION_APPROVED 是已验证意图的魔术值
bytes4 public constant VALIDATION_APPROVED = 0x00000001;
}

abstract contract HashGatedStandard is IStandard {
    event HashUsed(address sender, uint256 hash);

    mapping(bytes32 => bool) internal _hashes;

    function checkHash(address sender, uint256 hash) external view returns (bool) {
        bytes32 compositeKey = keccak256(abi.encode(sender, hash));
        return _hashes[compositeKey];
    }

    function markHash(uint256 hash) external {
        bytes32 compositeKey = keccak256(abi.encode(msg.sender, hash));
        _hashes[compositeKey] = true;

        emit HashUsed(msg.sender, hash);
    }
}

/*
RelayedExecutionStandard

此标准允许发送者定义一系列执行指令，并要求中继器代表发送者在链上执行。它是哈希和时间门控的，意味着意图只能在时间戳之前执行，并且只能执行一次。

`intent` 的前 20 个字节是发送者地址。
`intent` 的接下来的 20 个字节是标准地址，应该等于此标准的地址。
以下是长度部分，其中包含 3 个 uint16，分别定义 header 长度、instructions 长度和 signature 长度。

header 的长度为 8 字节或 28 字节。
8 字节部分是以纪元秒为单位的时间戳。
可选的 20 字节定义了分配的中继器地址，如果发送者只希望特定的中继器执行。

instructions 包含 2 个主要部分。
前 36 个字节是一个打包编码的 (address, uint128) 对，表示发送者将支付给中继器的 'payment'。它应该是 ERC20 代币。
接下来的 1 字节是一个 uint8，定义要执行的指令数。
这些指令连接在一起，前 2 个字节 (uint16) 定义每个指令的长度，后面是指令体。指令应该是 abi.encode(address, uint256, bytes)，可以直接由发送者帐户执行。

签名字段始终为 65 字节长。它包含签名的 bytes.concat(header, instructions)。
*/
contract RelayedExecutionStandard is HashGatedStandard {
    using ECDSA for bytes32;

    string public constant ICS_NUMBER = "ICS1";
    string public constant DESCRIPTION = "定时哈希中继执行标准";
    string public constant VERSION = "0.0.0";
    string public constant AUTHOR = "hellohanchen";

    function validateUserIntent(bytes calldata intent) external view returns (bytes4) {
        (address sender, address standard) = PackedIntent.getSenderAndStandard(intent);
        require(standard == address(this), "不是这个标准");
        (uint256 headerLength, uint256 instructionsLength, uint256 signatureLength) = PackedIntent.getLengths(intent);
        require(headerLength == 28 || headerLength == 8, "无效的 header 长度");
        require(instructionsLength >= 36, "指令太短");
        require(signatureLength == 65, "无效的签名长度");
        // 指令结束
        uint256 instructionsEndIndex = 46 + headerLength + instructionsLength;
        require(instructionsLength + signatureLength == intent.length, "无效的意图长度");

        // 验证签名
        uint256 hash = _validateSignatures(sender, intent, instructionsEndIndex);
        require(!this.checkHash(sender, hash), "哈希已执行");

        // header 包含过期时间戳和分配的中继器（可选）
        require(uint256(uint64(bytes8(intent[46 : 54]))) >= block.timestamp, "意图已过期");
        // assignedRelayerAddress = address(intent[54:74]) [可选]

        // header 部分结束 / instruction 部分开始
        uint256 headerEndIndex = 46 + headerLength;
        // 指令的前 20 个字节是 out token 地址
        address outTokenAddress = address(bytes20(intent[headerEndIndex : headerEndIndex + 20]));
        // out token 数量，使用 uint128 来缩短意图
        uint256 outTokenAmount = uint256(uint128(bytes16(intent[headerEndIndex + 20 : headerEndIndex + 36])));
        if (outTokenAddress != address(0)) {
            (bool success, bytes memory data) = outTokenAddress.staticcall(
                abi.encodeWithSelector(IERC20.balanceOf.selector, sender)
            );
            if (!success || data.length != 32) {
                revert("Not ERC20 token");
            }
            require(abi.decode(data, (uint256)) >= outTokenAmount, "代币余额不足");
        } else {
            require(sender.balance >= outTokenAmount, "eth 余额不足");
        }

        // outToken 指令结束
        uint256 numExecutions = uint256(uint8(bytes1(intent[headerEndIndex + 36 : headerEndIndex + 37])));
        // 指令索引
        uint256 instructionIndex = 0;
        // 第一个指令的开始
        uint256 instructionStart;
        uint256 instructionEnd = headerEndIndex + 37;

        while (instructionIndex < numExecutions) {
            instructionStart = instructionEnd;
            require(instructionStart + 2 <= instructionsEndIndex, "意图太短：指令长度");
            // 此执行指令结束
            instructionEnd = instructionStart + 2 + uint256(uint16(bytes2(intent[instructionStart : instructionStart + 2])));
            require(instructionEnd <= instructionsEndIndex, "意图太短：单个指令");

            instructionIndex += 1;
        }
        require(instructionEnd == instructionsEndIndex, "意图长度不匹配");

        return ERC7806Constants.VALIDATION_APPROVED;
    }

    function unpackOperations(bytes calldata intent) external view returns (bytes4 code, bytes[] memory unpackedInstructions) {
        (address sender, address standard) = PackedIntent.getSenderAndStandard(intent);
        require(standard == address(this), "不是这个标准");
        (uint256 headerLength, uint256 instructionsLength, uint256 signatureLength) = PackedIntent.getLengths(intent);
        require(headerLength == 28 || headerLength == 8, "无效的 header 长度");
        require(instructionsLength >= 36, "指令太短");
        require(signatureLength == 65, "无效的签名长度");
        // 指令结束
        uint256 instructionsEndIndex = 46 + headerLength + instructionsLength;
        require(instructionsLength + signatureLength == intent.length, "无效的意图长度");

        // 获取 header 内容（时间戳、中继器地址 [可选]）
        require(uint256(uint64(bytes8(intent[46 : 54]))) >= block.timestamp, "意图已过期");
        if (headerLength == 28) {
            // 分配的中继器
            require(tx.origin == address(bytes20(intent[54 : 74])), "无效的中继器");
        }

        uint256 intentHash = _validateSignatures(sender, intent, instructionsEndIndex);
        require(!this.checkHash(sender, intentHash), "哈希已执行");

        // 指令开始
        uint256 headerEndIndex = headerLength + 46;
        // 总指令 = 标记哈希 + 将代币转移到中继器 + 执行
        // 前 36 个字节定义了支付给中继器的金额
        // 接下来的 1 个字节定义了执行指令的数量
        unpackedInstructions = new bytes[](2 + uint8(bytes1(intent[headerEndIndex + 36 : headerEndIndex + 37])));
        // 第一个指令是标记哈希以防止重入攻击
        unpackedInstructions[0] = abi.encode(
            address(this), 0, abi.encodeWithSelector(this.markHash.selector, intentHash));

        // 指令的前 20 个字节是 out token 地址
        address outTokenAddress = address(bytes20(intent[headerEndIndex : headerEndIndex + 20]));
        // 数量
        uint256 outTokenAmount = uint256(uint128(bytes16(intent[headerEndIndex + 20 : headerEndIndex + 36])));
        // out token 指令
        if (outTokenAddress == address(0)) {
            unpackedInstructions[1] = abi.encode(address(tx.origin), outTokenAmount, "");
        } else {
            unpackedInstructions[1] = abi.encode(
                outTokenAddress,
                uint256(0),
                abi.encodeWithSelector(IERC20.transfer.selector, address(tx.origin), outTokenAmount));
        }

        // 指令索引
        uint256 instructionIndex = 2;
        uint256 instructionEndIndex = headerEndIndex + 37;
        uint256 instructionStartIndex;
        while (instructionIndex < unpackedInstructions.length) {
            // 下一个执行指令的开始
            instructionStartIndex = instructionEndIndex;
            require(instructionStartIndex + 2 <= instructionEndIndex, "意图太短：指令长度");
            // 下一个执行指令结束
            instructionEndIndex = instructionStartIndex + 2 + uint256(uint16(bytes2(intent[instructionStartIndex : instructionStartIndex + 2])));
            require(instructionEndIndex <= instructionEndIndex, "意图太短：单个指令");

            unpackedInstructions[instructionIndex] = intent[instructionStartIndex + 2 : instructionEndIndex];

            instructionIndex += 1;
        }
        require(instructionEndIndex == instructionEndIndex, "意图长度不匹配");

        return (ERC7806Constants.VALIDATION_APPROVED, unpackedInstructions);
    }

    function _validateSignatures(
        address sender, bytes calldata intent, uint256 sigStartIndex
    ) internal view returns (uint256) {
        bytes32 intentHash = keccak256(abi.encode(intent[46 : sigStartIndex], address(this), block.chainid));
        bytes32 messageHash = MessageHashUtils.toEthSignedMessageHash(intentHash);
        require(sender == messageHash.recover(intent[sigStartIndex : sigStartIndex + 65]), "无效的发送者签名");

        return uint256(intentHash);
    }

    // -------------
    // 以下方法将在测试后删除
    // -------------
    function sampleIntent(
        address sender, address relayer,
        address outTokenAddress, uint128 outAmount,
        bytes[] memory executions
    ) external view returns (
        bytes memory intent, bytes32 intentHash
    ) {
        bytes memory header = relayer == address(0) ?
        abi.encodePacked(uint64((block.timestamp + 31536000) & 0xFFFFFFFFFFFFFFFF)) :
        abi.encodePacked(uint64((block.timestamp + 31536000) & 0xFFFFFFFFFFFFFFFF), relayer);

        bytes memory instructions = bytes.concat(bytes20(outTokenAddress), bytes16(outAmount), bytes1(uint8(executions.length)));
        for (uint256 i = 0; i < executions.length; i++) {
            uint16 length = uint16(executions[i].length);
            instructions = bytes.concat(instructions, bytes2(length), executions[i]);
        }

        bytes memory toSign = bytes.concat(header, instructions);
        intentHash = keccak256(abi.encode(toSign, address(this), block.chainid));

        intent = bytes.concat(bytes20(sender), bytes20(address(this)), bytes2(uint16(header.length)), bytes2(uint16(instructions.length)), bytes2(uint16(65)), toSign);

        return (intent, intentHash);
    }

    function sampleERC20Execution(
        address token, address receiver, uint256 amount
    ) external pure returns (bytes memory) {
        if (token == address(0)) {
            return abi.encode(receiver, amount, "");
        }

        return abi.encode(token, uint256(0), abi.encodeWithSelector(IERC20.transfer.selector, address(receiver), amount));
    }

    function executeUserIntent(bytes calldata intent) external returns (bytes memory) {
        (address sender,) = PackedIntent.getSenderAndStandard(intent);
        bytes memory executeCallData = abi.encodeWithSelector(IAccount.executeUserIntent.selector, intent);

        (, bytes memory result) = sender.call{value : 0, gas : gasleft()}(executeCallData);
        return result;
    }
}