SimpleENSBid

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IERC20 {
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
}

interface IENS {
    function owner(bytes32 node) external view returns (address);
    function setOwner(bytes32 node, address owner) external;
}

interface IBaseRegistrar {
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
    function ownerOf(uint256 tokenId) external view returns (address);
}

interface INameWrapper {
    function ownerOf(uint256 tokenId) external view returns (address);
    function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes calldata data) external;
}

contract SimpleENSBid {
    address public constant ENS = 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e;
    address public constant NAME_WRAPPER = 0xD4416b13d2b3a9aBae7AcD5D6C2BbDBE25686401;
    address public constant BASE_REGISTRAR = 0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85;
    
    string public ensName;
    bytes32 public ensNode;        // For wrapped ENS (full namehash)
    bytes32 public ensTokenId;     // For unwrapped ENS (label hash only)
    address public buyer;
    address public token;
    uint256 public amount;
    bool public executed;
    
    event OfferCreated(string indexed ensName, address indexed buyer, address indexed token, uint256 amount);
    event OfferAccepted(address indexed seller, address indexed buyer, string ensName, uint256 amount);
    
    constructor(
        string memory _ensName,
        bytes32 _ensNode,
        bytes32 _ensTokenId,
        address _buyer,
        address _token,
        uint256 _amount
    ) {
        ensName = _ensName;
        ensNode = _ensNode;        // Full namehash for wrapped ENS
        ensTokenId = _ensTokenId;  // Label hash for unwrapped ENS
        buyer = _buyer;
        token = _token;
        amount = _amount;
        
        emit OfferCreated(_ensName, _buyer, _token, _amount);
    }
    
    function accept() external {
        require(!executed, "Already executed");
        require(isENSOwner(msg.sender), "Not ENS owner");
        
        uint256 allowance = IERC20(token).allowance(buyer, address(this));
        require(allowance >= amount, "Insufficient allowance");
        
        require(IERC20(token).transferFrom(buyer, msg.sender, amount), "Token transfer failed");
        
        address registryOwner = IENS(ENS).owner(ensNode);
        if (registryOwner == NAME_WRAPPER) {
            // Wrapped ENS - transfer as ERC1155 using full namehash
            INameWrapper(NAME_WRAPPER).safeTransferFrom(msg.sender, buyer, uint256(ensNode), 1, "");
        } else {
            // Unwrapped ENS - transfer as ERC721 using label hash through BaseRegistrar
            IBaseRegistrar(BASE_REGISTRAR).safeTransferFrom(msg.sender, buyer, uint256(ensTokenId), "");
        }
        
        executed = true;
        emit OfferAccepted(msg.sender, buyer, ensName, amount);
    }
    
    function isENSOwner(address user) public view returns (bool) {
        address registryOwner = IENS(ENS).owner(ensNode);
        
        if (registryOwner == NAME_WRAPPER) {
            // Check wrapped ownership using full namehash
            try INameWrapper(NAME_WRAPPER).ownerOf(uint256(ensNode)) returns (address wrappedOwner) {
                return wrappedOwner == user;
            } catch {
                return false;
            }
        } else {
            // Check unwrapped ownership using label hash through BaseRegistrar
            try IBaseRegistrar(BASE_REGISTRAR).ownerOf(uint256(ensTokenId)) returns (address registrarOwner) {
                return registrarOwner == user;
            } catch {
                return false;
            }
        }
    }
    
    function getStatus() external view returns (string memory) {
        if (executed) return "EXECUTED";
        return "ACTIVE";
    }
}