reverseRegistrar.claim(msg.sender)

function name(bytes32 node) constant returns (string);

pragma solidity ^0.4.10;

import "./AbstractENS.sol";

contract Resolver {
    function setName(bytes32 node, string name) public;
}

/**
 * @dev Provides a default implementation of a resolver for reverse records,
 * 为反向记录提供解析器的默认实现，
 * which permits only the owner to update it.
 * 它只允许所有者更新它。
 */
contract DefaultReverseResolver is Resolver {
    AbstractENS public ens;
    mapping(bytes32=>string) public name;

    /**
     * @dev Constructor
     * @dev 构造函数
     * @param ensAddr The address of the ENS registry.
     * @param ensAddr ENS 注册表的地址。
     */
    function DefaultReverseResolver(AbstractENS ensAddr) {
        ens = ensAddr;
    }

    /**
     * @dev Only permits calls by the reverse registrar.
     * @dev 仅允许反向注册器调用。
     * @param node The node permission is required for.
     * @param node 需要节点权限。
     */
    modifier owner_only(bytes32 node) {
        require(msg.sender == ens.owner(node));
        _;
    }

    /**
     * @dev Sets the name for a node.
     * @dev 设置节点的名称。
     * @param node The node to update.
     * @param node 要更新的节点。
     * @param _name The name to set.
     * @param _name 要设置的名称。
     */
    function setName(bytes32 node, string _name) public owner_only(node) {
        name[node] = _name;
    }
}

contract ReverseRegistrar {
    // namehash('addr.reverse')
    bytes32 constant ADDR_REVERSE_NODE = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;

    AbstractENS public ens;
    Resolver public defaultResolver;

    /**
     * @dev Constructor
     * @dev 构造函数
     * @param ensAddr The address of the ENS registry.
     * @param ensAddr ENS 注册表的地址。
     * @param resolverAddr The address of the default reverse resolver.
     * @param resolverAddr 默认反向解析器的地址。
     */
    function ReverseRegistrar(AbstractENS ensAddr, Resolver resolverAddr) {
        ens = ensAddr;
        defaultResolver = resolverAddr;
    }

    /**
     * @dev Transfers ownership of the reverse ENS record associated with the
     * @dev 转移与调用帐户关联的反向 ENS 记录的所有权。
     *      calling account.
     *      调用帐户。
     * @param owner The address to set as the owner of the reverse record in ENS.
     * @param owner 要设置为 ENS 中反向记录所有者的地址。
     * @return The ENS node hash of the reverse record.
     * @return 反向记录的 ENS 节点哈希。
     */
    function claim(address owner) returns (bytes32 node) {
        return claimWithResolver(owner, 0);
    }

    /**
     * @dev Transfers ownership of the reverse ENS record associated with the
     * @dev 转移与调用帐户关联的反向 ENS 记录的所有权。
     *      calling account.
     *      调用帐户。
     * @param owner The address to set as the owner of the reverse record in ENS.
     * @param owner 要设置为 ENS 中反向记录所有者的地址。
     * @param resolver The address of the resolver to set; 0 to leave unchanged.
     * @param resolver 要设置的解析器的地址；0 表示不更改。
     * @return The ENS node hash of the reverse record.
     * @return 反向记录的 ENS 节点哈希。
     */
    function claimWithResolver(address owner, address resolver) returns (bytes32 node) {
        var label = sha3HexAddress(msg.sender);
        node = sha3(ADDR_REVERSE_NODE, label);
        var currentOwner = ens.owner(node);

        // Update the resolver if required
        // 如果需要，更新解析器
        if(resolver != 0 && resolver != ens.resolver(node)) {
            // Transfer the name to us first if it's not already
            // 如果名称尚未转移给我们，则先转移给我们
            if(currentOwner != address(this)) {
                ens.setSubnodeOwner(ADDR_REVERSE_NODE, label, this);
                currentOwner = address(this);
            }
            ens.setResolver(node, resolver);
        }

        // Update the owner if required
        // 如果需要，更新所有者
        if(currentOwner != owner) {
            ens.setSubnodeOwner(ADDR_REVERSE_NODE, label, owner);
        }

        return node;
    }

    /**
     * @dev Sets the `name()` record for the reverse ENS record associated with
     * @dev 设置与调用帐户关联的反向 ENS 记录的 `name()` 记录。
     * the calling account. First updates the resolver to the default reverse
     * 调用帐户。 如果需要，首先将解析器更新为默认反向解析器。
     * resolver if necessary.
     * @param name The name to set for this address.
     * @param name 要为此地址设置的名称。
     * @return The ENS node hash of the reverse record.
     * @return 反向记录的 ENS 节点哈希。
     */
    function setName(string name) returns (bytes32 node) {
        node = claimWithResolver(this, defaultResolver);
        defaultResolver.setName(node, name);
        return node;
    }

    /**
     * @dev Returns the node hash for a given account's reverse records.
     * @dev 返回给定帐户的反向记录的节点哈希。
     * @param addr The address to hash
     * @param addr 要哈希的地址
     * @return The ENS node hash.
     * @return ENS 节点哈希。
     */
    function node(address addr) constant returns (bytes32 ret) {
        return sha3(ADDR_REVERSE_NODE, sha3HexAddress(addr));
    }

    /**
     * @dev An optimised function to compute the sha3 of the lower-case
     * @dev 一个优化函数，用于计算以太坊地址的小写
     *      hexadecimal representation of an Ethereum address.
     *      十六进制表示的 sha3。
     * @param addr The address to hash
     * @param addr 要哈希的地址
     * @return The SHA3 hash of the lower-case hexadecimal encoding of the
     * @return 输入地址的小写十六进制编码的 SHA3 哈希。
     *         input address.
     */
    function sha3HexAddress(address addr) private returns (bytes32 ret) {
        addr; ret; // Stop warning us about unused variables
        // 停止警告我们关于未使用的变量
        assembly {
            let lookup := 0x3031323334353637383961626364656600000000000000000000000000000000
            let i := 40
        loop:
            i := sub(i, 1)
            mstore8(i, byte(and(addr, 0xf), lookup))
            addr := div(addr, 0x10)
            i := sub(i, 1)
            mstore8(i, byte(and(addr, 0xf), lookup))
            addr := div(addr, 0x10)
            jumpi(loop, i)
            ret := sha3(0, 40)
        }
    }
}