# Managing Names

## Transferring a Name

Each name in PNS has an owner. This account or contract is the only one that may make changes to the name in the PNS registry. The owner of a name can transfer ownership to any other account.

{% tabs %}
{% tab title="pnsjs" %}

```javascript
await pns.name('alice.pls').setOwner('0x1234...');
```

{% endtab %}

{% tab title="go-pns" %}

```go
// opts are go-ethereum's bind.TransactOpts
err := registry.SetOwner(opts, "alice.pls", common.HexToAddress("0x1234..."))
```

{% endtab %}
{% endtabs %}

## Creating Subdomains

The owner of any domain can configure subdomains as desired. This is achieved by creating a subdomain and setting its owner to the desired address - this can be the same as the owner of the parent domain, or any other address.

{% tabs %}
{% tab title="pnsjs" %}

```javascript
await pns.name('alice.pls').createSubdomain('iam');
```

{% endtab %}

{% tab title="go-pns" %}

```go
// opts are go-ethereum's bind.TransactOpts
err := registry.SetSubdomainOwner(opts, "alice.pls", "iam", common.HexToAddress("0x1234..."))
```

{% endtab %}
{% endtabs %}

## Setting a Resolver

Before a newly created domain or subdomain can be used, a resolver address must be set. You may also want to do this if an updated resolver implementation is available that supports features that you want to make use of.

Most commonly, names are set to use a 'standard' resolver called the public resolver, which provides commonly-used functionality, but anyone may write and deploy their own special-purpose resolver; see the resolver interface definition for details.

{% tabs %}
{% tab title="pnsjs" %}

```javascript
await pns.name('iam.alice.pls').setResolver('0x1234');
```

On mainnet and the testnet (v3) network, 'resolver.pls' is configured to point to the latest deployed version of the public resolver, making it possible to easily configure a name to use the public resolver:

```javascript
const resolver = await pns.resolver('resolver.pls').addr();
await pns.setResolver('iam.alice.pls', resolver, {from: ...});
```

{% endtab %}

{% tab title="go-pns" %}

```go
// opts are go-ethereum's bind.TransactOpts
err := registry.SetResolver(opts, "iam.alice.eth", common.HexToAddress("0x1234..."))
```

{% endtab %}
{% endtabs %}

Note that changing the resolver for a name will not automatically migrate records from the old resolver over; to do this you will need to follow the process outlined below for updating records.

## Updating Records

To change the resources an address resolves to, it's necessary to update that name's records in its resolver.

Each resolver may specify its own mechanism for updating records, but a standard method is implemented by the public resolver and many others. Some libraries provide functionality for updating a resolver's records using this interface.

### Updating the Address Record

{% tabs %}
{% tab title="pnsjs" %}

```javascript
await pns.name('iam.alice.pls').setAddr('PLS', '0x1234...');
```

{% endtab %}

{% tab title="go-pns" %}

```go
resolver, err := pns.NewResolver(client, "iam.alice.pls")
// opts are go-ethereum's bind.TransactOpts
err := resolver.SetAddress(opts, common.HexToAddress("0x1234..."))
```

{% endtab %}
{% endtabs %}

### Updating Other Records

Some libraries - presently only pns-sdk and go-ens - support updating other record types, such as content hashes and text records, using the same pattern. For example, to set or update a text record:

{% tabs %}
{% tab title="pnsjs" %}

```javascript
pns.name('iam.alice.pls').setText('test', 'Test record');
```

{% endtab %}

{% tab title="go-pns" %}

```go
// opts are go-ethereum's bind.TransactOpts
err := resolver.SetContenthash(opts, []byte{0x12, 0x34...})
err := resolver.SetAbi(opts, "Sample", `[{"constant":true,"inputs":...}]`, big.NewInt(1))
err := resolver.SetText(opts, "Sample", `Hello, world`)
```

{% endtab %}
{% endtabs %}

### Updating multiple records in one transaction

Public Resolver has `multicall` that permits users to set multiple records in a single operation. Read [PublicResolver](https://docs.pulse.domains/contract-api-reference/publicresolver#multicall) section for more detail.

## Configuring Reverse Resolution

While 'regular' resolution involves mapping from a name to an address, reverse resolution maps from an address back to a name - or other metadata. PNS supports reverse resolution to allow applications to display PNS names in place of hexadecimal addresses.

Before this can be done, the owner of the address has to configure reverse resolution for their address. This is done by calling the `claim()` method on the reverse resolver, found at the special name 'addr.reverse'.

Most commonly this is accomplished via a user-interface such as the [PNS Manager DApp](https://app.pulse.domains). go-ens also provide functionality for this:

{% tabs %}
{% tab title="go-pns" %}

```go
reverseRegistrar, err := pns.NewReverseRegistrar(client)
// opts are go-ethereum's bind.TransactOpts
err := reverseRegistrar.SetName(opts, "iam.alice.pls")
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.pulse.domains/dapp-developer-guide/getting-started/managing-names.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.