🤖
LNS Documentation
  • Introduction
  • Terminology
  • Frequently Asked Questions
  • Tokenomics
  • LNS Deployments
  • Registrar Frequently Asked Questions
  • Deploying LNS on a Private Chain
  • DNS Registrar guide
  • Bug Bounty Program
  • ENS Improvement Proposals
    • ENSIP-1: ENS
    • ENSIP-2: Initial Hash Registrar
    • ENSIP-3: Reverse Resolution
    • ENSIP-4: Support for contract ABIs
    • ENSIP-5: Text Records
    • ENSIP-6: DNS-in-ENS
    • ENSIP-7: Contenthash field
    • ENSIP-8: Interface Discovery
    • ENSIP-9: Multichain Address Resolution
    • ENSIP-10: Wildcard Resolution
    • ENSIP-11: EVM compatible Chain Address Resolution
    • ENSIP-12: Avatar Text Records
  • Dapp Developer Guide
    • LNS Enabling your DApp
    • LNS Libraries
    • Working with LNS
    • Resolving Names
    • Managing Names
    • Registering & Renewing Names
    • LNS Front-End Design Guidelines
    • LNS as NFT
  • Contract API Reference
    • Name Processing
    • Registry
    • ReverseRegistrar
    • PublicResolver
    • .bch Permanent Registrar
      • Registrar
      • Controller
    • DNS Registrar
  • Contract Developer Guide
    • Resolving Names On-chain
    • Writing a Resolver
    • Writing a Registrar
    • LNS Support Chat
Powered by GitBook
On this page
  • Transferring a Name
  • Creating Subdomains
  • Setting a Resolver
  • Updating Records
  • Updating the Address Record
  • Updating Other Records
  • Updating multiple records in one transaction
  • Configuring Reverse Resolution
Edit on GitHub
  1. Dapp Developer Guide

Managing Names

Transferring a Name

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

await ens.name('alice.bch').setOwner('0x1234...');
// opts are go-ethereum's bind.TransactOpts
err := registry.SetOwner(opts, "alice.bch", common.HexToAddress("0x1234..."))
ns.setup_owner('alice.bch', '0x1234...')

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.

await ens.name('alice.bch').createSubdomain('iam');
// opts are go-ethereum's bind.TransactOpts
err := registry.SetSubdomainOwner(opts, "alice.bch", "iam", common.HexToAddress("0x1234..."))
ns.setup_owner('iam.alice.bch', '0x1234...')

Additionally, web3.py provides a convenience method to create a subdomain, set a resolver, and configure an address record all at once:

ns.setup_address('iam.alice.bch', '0x1234...')

In the common case that the name should be pointed to the owner's address, the second argument is optional.

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.

await ens.name('iam.alice.bch').setResolver('0x1234');

On mainnet and the Kovan test network, 'resolver.bch' 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:

const resolver = await ens.resolver('resolver.bch').addr();
await ens.setResolver('iam.alice.bch', resolver, {from: ...});
// opts are go-ethereum's bind.TransactOpts
err := registry.SetResolver(opts, "iam.alice.bch", common.HexToAddress("0x1234..."))

Not supported. web3.py automatically uses the public resolver when setup_address is called, and does not support setting custom resolvers.

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

await ens.name('iam.alice.bch').setAddr('ETH', '0x1234...');
resolver, err := ens.NewResolver(client, "iam.alice.bch")
// opts are go-ethereum's bind.TransactOpts
err := resolver.SetAddress(opts, common.HexToAddress("0x1234..."))
ens.setAddress('iam.alice.bch, '0x1234...', {from: ...});
ns.setup_address('iam.alice.bch', '0x1234...')

Updating Other Records

Some libraries - presently only ensjs, go-ens and web3.js - 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:

ens.name('iam.alice.bch').setText('test', 'Test record');
// 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`)
ens.setText('iam.alice.bch', 'Test', 'Test record', {from: ...});

Updating multiple records in one transaction

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. LNS supports reverse resolution to allow applications to display LNS 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'.

reverseRegistrar, err := ens.NewReverseRegistrar(client)
// opts are go-ethereum's bind.TransactOpts
err := reverseRegistrar.SetName(opts, "iam.alice.bch")
ns.setup_name('iam.alice.bch', '0x1234...')
PreviousResolving NamesNextRegistering & Renewing Names

Last updated 3 years ago

Public Resolver has multicall that permits users to set multiple records in a single operation. Read section for more detail.

Most commonly this is accomplished via a user-interface such as the . go-ens and web3.py also provide functionality for this:

PublicResolver
LNS Manager DApp