Contract Address Details

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "./IEVMFSRegistry.sol";

/**
 * @title EVMFSRegistry
 * @notice On-chain name→CID registry for the evmfs.app subdomain gateway.
 *
 * Users pay a one-time fee (based on name length) to claim a name.
 * The owner of a name can update its CID at any time (enabling site updates)
 * and transfer ownership to another address.
 *
 * Pricing follows a linear-scarcity curve by UTF-8 byte length:
 *   1 char  →  10   ETH
 *   2 chars →   3   ETH
 *   3 chars →   1   ETH
 *   4 chars →   0.3  ETH
 *   5 chars →   0.1  ETH
 *   6 chars →   0.03 ETH
 *   7+ chars→   0.015 ETH
 *
 * On testnets these are testnet ETH — same ratios for integration testing.
 */
contract EVMFSRegistry is Ownable, IEVMFSRegistry {
    // ─────────────────────────────────────────────────────
    //  Storage
    // ─────────────────────────────────────────────────────

    /// @dev name hash → 32-byte EVMFS CID (raw sha256)
    mapping(bytes32 => bytes) private _nameToCid;

    /// @dev name hash → owner address
    mapping(bytes32 => address) private _nameOwner;

    /// @dev name hash → original plaintext name (for enumeration / display)
    mapping(bytes32 => string) private _nameLabel;

    uint256 private _nameCount;

    // ─────────────────────────────────────────────────────
    //  Events
    // ─────────────────────────────────────────────────────

    event NameRegistered(string indexed nameHash, string name, address indexed owner, bytes cid);
    event CidUpdated(string indexed nameHash, string name, bytes oldCid, bytes newCid);
    event NameTransferred(string indexed nameHash, string name, address indexed from, address indexed to);

    // ─────────────────────────────────────────────────────
    //  Errors
    // ─────────────────────────────────────────────────────

    error NameAlreadyTaken();
    error NameNotRegistered();
    error NotNameOwner();
    error InsufficientFee();
    error EmptyName();
    error EmptyCid();
    error InvalidCidLength();
    error TransferToZero();

    // ─────────────────────────────────────────────────────
    //  Constructor
    // ─────────────────────────────────────────────────────

    constructor() Ownable(msg.sender) {}

    // ─────────────────────────────────────────────────────
    //  Write — Registration
    // ─────────────────────────────────────────────────────

    /**
     * @notice Register a name and bind it to an EVMFS CID.
     * @param name  Plaintext name (e.g. "myapp"). Must be non-empty.
     * @param cid   32-byte EVMFS CID (rolling SHA-256 hash).
     */
    function registerApp(string calldata name, bytes calldata cid) external payable {
        if (bytes(name).length == 0) revert EmptyName();
        if (cid.length == 0) revert EmptyCid();
        if (cid.length != 32) revert InvalidCidLength();

        bytes32 key = _nameKey(name);
        if (_nameOwner[key] != address(0)) revert NameAlreadyTaken();

        uint256 price = getPrice(name);
        if (msg.value < price) revert InsufficientFee();

        _nameOwner[key] = msg.sender;
        _nameToCid[key] = cid;
        _nameLabel[key] = name;
        _nameCount++;

        // Refund overpayment
        uint256 excess = msg.value - price;
        if (excess > 0) {
            (bool ok, ) = msg.sender.call{value: excess}("");
            require(ok, "Refund failed");
        }

        emit NameRegistered(name, name, msg.sender, cid);
    }

    // ─────────────────────────────────────────────────────
    //  Write — Update CID
    // ─────────────────────────────────────────────────────

    /**
     * @notice Update the CID for a name you own (deploy a new version).
     * @param name  The registered name.
     * @param cid   New 32-byte EVMFS CID.
     */
    function updateCid(string calldata name, bytes calldata cid) external {
        if (cid.length == 0) revert EmptyCid();
        if (cid.length != 32) revert InvalidCidLength();

        bytes32 key = _nameKey(name);
        if (_nameOwner[key] == address(0)) revert NameNotRegistered();
        if (_nameOwner[key] != msg.sender) revert NotNameOwner();

        bytes memory oldCid = _nameToCid[key];
        _nameToCid[key] = cid;

        emit CidUpdated(name, name, oldCid, cid);
    }

    // ─────────────────────────────────────────────────────
    //  Write — Transfer ownership
    // ─────────────────────────────────────────────────────

    /**
     * @notice Transfer ownership of a name to a new address.
     * @param name      The registered name.
     * @param newOwner  The new owner. Cannot be address(0).
     */
    function transferName(string calldata name, address newOwner) external {
        if (newOwner == address(0)) revert TransferToZero();

        bytes32 key = _nameKey(name);
        if (_nameOwner[key] == address(0)) revert NameNotRegistered();
        if (_nameOwner[key] != msg.sender) revert NotNameOwner();

        address oldOwner = _nameOwner[key];
        _nameOwner[key] = newOwner;

        emit NameTransferred(name, name, oldOwner, newOwner);
    }

    // ─────────────────────────────────────────────────────
    //  Write — Admin
    // ─────────────────────────────────────────────────────

    /**
     * @notice Withdraw accumulated registration fees.
     */
    function withdraw() external onlyOwner {
        uint256 bal = address(this).balance;
        require(bal > 0, "Nothing to withdraw");
        (bool ok, ) = owner().call{value: bal}("");
        require(ok, "Withdraw failed");
    }

    // ─────────────────────────────────────────────────────
    //  Read — IEVMFSRegistry
    // ─────────────────────────────────────────────────────

    /// @inheritdoc IEVMFSRegistry
    function getCid(string calldata name) external view returns (bytes memory) {
        return _nameToCid[_nameKey(name)];
    }

    /// @inheritdoc IEVMFSRegistry
    function nameOwner(string calldata name) external view returns (address) {
        return _nameOwner[_nameKey(name)];
    }

    /// @inheritdoc IEVMFSRegistry
    function isRegistered(string calldata name) external view returns (bool) {
        return _nameOwner[_nameKey(name)] != address(0);
    }

    /**
     * @inheritdoc IEVMFSRegistry
     * @notice Pricing by UTF-8 byte length (linear scarcity):
     *   1 →  10 ether    |  2 →  3 ether     |  3 →  1 ether
     *   4 →  0.3 ether   |  5 →  0.1 ether   |  6 →  0.03 ether
     *   7+ → 0.015 ether
     */
    function getPrice(string calldata name) public pure returns (uint256) {
        uint256 L = bytes(name).length;
        if (L == 0) return type(uint256).max; // Unreachable for valid calls
        if (L == 1) return 10 ether;
        if (L == 2) return 3 ether;
        if (L == 3) return 1 ether;
        if (L == 4) return 0.3 ether;
        if (L == 5) return 0.1 ether;
        if (L == 6) return 0.03 ether;
        return 0.015 ether;
    }

    /// @notice Total number of registered names.
    function nameCount() external view returns (uint256) {
        return _nameCount;
    }

    // ─────────────────────────────────────────────────────
    //  Internal
    // ─────────────────────────────────────────────────────

    /// @dev Convert a plaintext name to a storage key via keccak256.
    function _nameKey(string calldata name) internal pure returns (bytes32) {
        return keccak256(bytes(name));
    }
}
        

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}
          

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

/**
 * @title IEVMFSRegistry
 * @notice Interface for the EVMFS name registry.
 *         Maps human-readable names to EVMFS CIDs for subdomain resolution
 *         on evmfs.app (contract registry) and evmfs.link (ENS mirror).
 */
interface IEVMFSRegistry {
    /// @notice Returns the 32-byte CID bound to a name, or empty bytes if unregistered.
    function getCid(string calldata name) external view returns (bytes memory);

    /// @notice Returns the owner address of a registered name.
    function nameOwner(string calldata name) external view returns (address);

    /// @notice Returns the registration fee for a name based on its UTF-8 byte length.
    function getPrice(string calldata name) external pure returns (uint256);

    /// @notice Returns true if the name has been claimed.
    function isRegistered(string calldata name) external view returns (bool);
}