# Registrar

**Source**

This contract implements the core functionality of the permanent registrar, with the following features:

* The owner of the registrar may add and remove 'controllers'.
* Controllers may register new domains and extend the expiry of (renew) existing domains. They can not change the ownership or reduce the expiration time of existing domains.
* Name owners may transfer ownership to another address.
* Name owners may reclaim ownership in the Domains registry if they have lost it.
* Owners of names in the legacy registrar may transfer them to the new registrar, during the 1 year transition period. When they do so, their deposit is returned to them in its entirety.

This section documents the parts of the registrar interface relevant to implementers of tools that interact with it. Functionality exclusive to the registrar owner or to controllers is omitted for brevity.

**Names and Registrations**

All names inside Domains have an owner. The owner of a name can transfer the name to a new owner, set a resolver, and create and reassign subdomains. This functionality is all contained in the Domains registry.

Allocation of names directly under .Domains (eg, second-level domains ending with .Domains , such as xyz.tomi) is governed by the .tomi Permanent Registrar, described here. While buying a name from the registrar grants ownership of it in Domains, the registrar itself keeps independent track of who owns the registration. The concept of a registrant - the owner of a registration - is unique to the .Domains permanent registrar.

The registrant of a name can transfer the registration to another account, and they can recover ownership of the name by calling reclaim, which resets ownership of the Domains name to the registrant's account.

Separating the concept of owning a name from owning a registration makes it possible to more easily build systems that make automated updates to Domains. The registrant can transfer ownership of the name to another account or to a smart contract that manages records, subdomains, etc, while still retaining the ability to recover ownership for upgrades, or in the case of a compromise.

When thinking about ownership, it's important to be clear whether you're considering ownership of the name or the registration.

**Read Operations**

**Get Name Expiry**

```javascript
function nameExpires(uint256 label) external view returns(uint);
```

Returns the unix timestamp at which a registration currently expires. Names that do not exist or are not yet migrated from the legacy registrar will return 0.

**Check Name Availability**

```javascript
function available(uint256 label) public view returns(bool);
```

Returns `true` if a name is available for registration. Takes into account not-yet-migrated registrations from the legacy registrar. Registrar controllers may impose more restrictions on registrations than this contract (for example, a minimum name length), so this function should not be used to check if a name can be registered by a user. To check if a name can be registered by a user, check name availability via the controller.\
\
**Get Transfer Period End**

```
uint public transferPeriodEnds;
```

`transferPeriodEnds` documents the unix timestamp at which it is no longer possible to migrate over registrations from the legacy registrar, and any non-migrated registrations become available for registration by anyone.

**Get Controller Status**[\
](https://tomi-domain-name-service.gitbook.io/titled/.tomi-permanent-registrar)

```javascript
mapping(address=>bool) public controllers;
```

`controllers` allows callers to check if the supplied address is authorised as a registrar controller.

**Check Token Approval**

```javascript
function getApproved(uint256 tokenId) public view returns (address operator);
```

Returns the address of the approved operator for this name.

This function is part of ERC721.

**Check All Tokens Approval**

```javascript
function isApprovedForAll(address owner, address operator) public view returns (bool);
```

Returns true if the `operator` is authorised to transfer all tokens for the  `owner`.

This function is part of ERC721.

**Get Name Owner**

```javascript
function ownerOf(uint256 label) external view returns(address);
```

`ownerO`f returns the address that owns the registration identified by the label hash, or reverts if the registration does not exist. Registrations that have not yet been migrated from the legacy registrar are treated the same as registrations that do not exist.

This function is part of[ <mark style="color:red;">ERC721</mark>](https://github.com/ensdomains/ens/blob/master/docs/ethregistrar.rst#id7).

**Write Operations**

**Transfer a Name**

```javascript
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
```

These functions transfer the registration.

They behave as specified in[ <mark style="color:red;">ERC721</mark>](https://github.com/ensdomains/ens/blob/master/docs/ethregistrar.rst#id9)<mark style="color:red;">.</mark>

Emits the following event on a successful transfer:

```javascript
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
```

**Approve Operator**

```javascript
function approve(address to, uint256 tokenId) public;

function setApprovalForAll(address operator, bool _approved) public;
```

These functions manage approvals as documented in[ <mark style="color:red;">ERC721</mark>](https://github.com/ensdomains/ens/blob/master/docs/ethregistrar.rst#id11)<mark style="color:red;">.</mark>

**Reclaim DNS Record**

```javascript
function reclaim(uint256 label) external;
```

Sets the owner record of the name in the DNS registry to match the owner of the registration in this registry. May only be called by the owner of the registration.

***Events***

**Name Migrated**

```javascript
event NameMigrated(uint256 indexed hash, address indexed owner, uint expires);
```

This event is emitted when a name is migrated from the legacy registrar.

**Name Registered**

```
event NameRegistered(uint256 indexed hash, address indexed owner, uint expires);
```

This event is emitted when a controller registers a new name.

**Name Renewed**

```
event NameRenewed(uint256 indexed hash, uint expires);
```

This event is emitted when a controller renews (extends the registration of) a name.

**Transfer**

```
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
```

This event is emitted when registration is transferred to a new owner. This is distinct from the DNS Registry's Transfer event, which records transfers of ownership of the DNS record.
