ERC-7994 - Purpose-Bound ERC-20 with Conditional Unlock

pragma solidity 0.8.23;

interface IPurposeBoundERC20 {
    struct UnlockCondition {
        bytes32 conditionType; // e.g., "TIME", "KYC", "WHITELIST"
        bytes conditionData;   // e.g., timestamp, Merkle root, etc.
    }

    function bindPurpose(
        address recipient,
        uint256 amount,
        UnlockCondition[] calldata conditions,
        uint256 expiry
    ) external returns (bytes32 bindingId);

    function claim(bytes32 bindingId) external;

    function isUnlocked(bytes32 bindingId) external view returns (bool);
}

pragma solidity 0.8.23;

/// @title Reference Implementation - Purpose-Bound ERC20 with Multi-Condition Unlocking
/// @notice Implements IPurposeBoundERC20 with conditionType mapping to on-chain checkers.

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./IPurposeBoundERC20.sol";

/// @dev Interface for pluggable condition checker contracts
interface IConditionChecker {
    function isConditionMet(address recipient, bytes calldata conditionData) external view returns (bool);
}

/// @title PurposeBoundERC20 Implementation
contract PurposeBoundERC20 is ERC20, IPurposeBoundERC20 {
    struct StoredBinding {
        address recipient;
        uint256 amount;
        UnlockCondition[] conditions;
        bool claimed;
        uint256 expiry;
    }

    /// @dev Maps conditionType → on-chain checker contract
    mapping(bytes32 => address) public conditionResolvers;

    /// @dev Maps bindingId → locked transfer
    mapping(bytes32 => StoredBinding) public boundTransfers;

    event PurposeBound(bytes32 indexed bindingId, address indexed from, address indexed to, uint256 amount);
    event Claimed(bytes32 indexed bindingId, address indexed recipient);

    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) {
        _mint(msg.sender, 1_000_000 ether); // for demo purposes
    }

    /// @notice Admin can register or update condition checkers for condition types
    function setConditionResolver(bytes32 conditionType, address checker) external {
        // For demo purposes: public function. In production: onlyOwner or AccessControl.
        conditionResolvers[conditionType] = checker;
    }

    /// @inheritdoc IPurposeBoundERC20
    function bindPurpose(
        address recipient,
        uint256 amount,
        UnlockCondition[] calldata conditions,
        uint256 expiry
    ) external override returns (bytes32 bindingId) {
        require(recipient != address(0), "Invalid recipient");
        require(amount > 0, "Invalid amount");

        bindingId = keccak256(abi.encodePacked(msg.sender, recipient, amount, conditions, expiry, block.timestamp));
        StoredBinding storage stored = boundTransfers[bindingId];
        require(stored.amount == 0, "Binding exists");

        _transfer(msg.sender, address(this), amount);

        for (uint i = 0; i < conditions.length; i++) {
            stored.conditions.push(conditions[i]);
        }

        stored.recipient = recipient;
        stored.amount = amount;
        stored.expiry = expiry;

        emit PurposeBound(bindingId, msg.sender, recipient, amount);
    }

    /// @inheritdoc IPurposeBoundERC20
    function isUnlocked(bytes32 bindingId) public view override returns (bool) {
        StoredBinding storage binding = boundTransfers[bindingId];
        if (binding.claimed) return false;
        if (binding.expiry > 0 && block.timestamp > binding.expiry) return false;

        for (uint i = 0; i < binding.conditions.length; i++) {
            UnlockCondition storage cond = binding.conditions[i];
            address checker = conditionResolvers[cond.conditionType];
            require(checker != address(0), "Checker not set");
            if (!IConditionChecker(checker).isConditionMet(binding.recipient, cond.conditionData)) {
                return false;
            }
        }

        return true;
    }

    /// @inheritdoc IPurposeBoundERC20
    function claim(bytes32 bindingId) external override {
        StoredBinding storage binding = boundTransfers[bindingId];
        require(msg.sender == binding.recipient, "Not recipient");
        require(!binding.claimed, "Already claimed");
        require(isUnlocked(bindingId), "Conditions not met");

        binding.claimed = true;
        _transfer(address(this), binding.recipient, binding.amount);

        emit Claimed(bindingId, binding.recipient);
    }
}

/// @dev Example of Time-Based Condition Checker
contract TimeConditionChecker is IConditionChecker {
    function isConditionMet(address, bytes calldata conditionData) external view override returns (bool) {
        uint256 unlockTime = abi.decode(conditionData, (uint256));
        return block.timestamp >= unlockTime;
    }
}