Skip to content
⚡ Tact Documentation ⚡ Tact Documentation ⚡ Tact Documentation

@stdlib/dns

Provides means for resolving DNS names.

To use this library, import @stdlib/dns:

import "@stdlib/dns";

Structs

DNSResolveResult

struct DNSResolveResult {
    prefix: Int;
    record: Cell?;
}

Functions

dnsStringToInternal

@name(dns_string_to_internal)
native dnsStringToInternal(str: String): Slice?;

Converts a DNS string to a Slice or null if conversion is impossible.

Source code (FunC): dns.fc#L1

dnsInternalNormalize

@name(dns_internal_normalize)
native dnsInternalNormalize(src: Slice): Slice;

Normalizes the internal DNS representation of the Slice. The provided Slice must not have any references; otherwise, an exception with exit code 134 will be thrown: Invalid argument.

Source code (FunC): dns.fc#L125

dnsInternalVerify

@name(dns_internal_verify)
native dnsInternalVerify(subdomain: Slice): Bool;

Verifies the internal DNS representation of the subdomain Slice.

Source code (FunC): dns.fc#L81

dnsExtractTopDomainLength

fun dnsExtractTopDomainLength(subdomain: Slice): Int;

Calculates the length of the top domain in the subdomain Slice.

Source code:

fun dnsExtractTopDomainLength(subdomain: Slice): Int {
    let i: Int = 0;
    let needBreak: Bool = false;
    do {
        let char: Int = subdomain.loadUint(8); // We do not check domain.length because it MUST contain a \0 character
        needBreak = char == 0;
        if (!needBreak) {
            i += 8;
        }
    } until (needBreak);
    require(i != 0, "Invalid DNS name");
    return i;
}

dnsExtractTopDomain

fun dnsExtractTopDomain(subdomain: Slice): Slice;

Extracts the top domain from a subdomain Slice.

Source code:

fun dnsExtractTopDomain(subdomain: Slice): Slice {
    let len: Int = dnsExtractTopDomainLength(subdomain);
    return subdomain.loadBits(len);
}

dnsResolveNext

fun dnsResolveNext(address: Address): Cell;

Resolves an address Address into a Cell.

Source code:

fun dnsResolveNext(address: Address): Cell {
    return beginCell()
        .storeUint(0xba93, 16)
        .storeAddress(address)
        .endCell();
}

dnsResolveWallet

fun dnsResolveWallet(address: Address): Cell;

Resolves a wallet address Address into a Cell.

Source code:

fun dnsResolveWallet(address: Address): Cell {
    return beginCell()
        .storeUint(0x9fd3, 16)
        .storeAddress(address)
        .storeUint(0, 8)
        .endCell();
}

Traits

DNSResolver

The trait DNSResolver provides two helper functions for DNS resolution:

  1. A getter function dnsresolve(), which corresponds to its FunC variant.
  2. A virtual function doResolveDNS(), which creates a struct DNSResolveResult from subdomain Slice bits.

Source code:

trait DNSResolver {
    get fun dnsresolve(subdomain: Slice, category: Int): DNSResolveResult {
        // Normalize
        let delta: Int = 0;
        if (subdomain.preloadUint(8) == 0) {
            subdomain.loadUint(8); // Skip first byte
            delta += 8;
        }


        // Check correctness
        require(dnsInternalVerify(subdomain), "Invalid DNS name");


        // Resolve
        let res: DNSResolveResult = self.doResolveDNS(subdomain, category);
        return DNSResolveResult{prefix: res.prefix + delta, record: res.record};
    }
    virtual fun doResolveDNS(subdomain: Slice, category: Int): DNSResolveResult {
        return DNSResolveResult{prefix: subdomain.bits(), record: null};
    }
}

Usage example:

import "@stdlib/dns";


contract ExampleContract with DNSResolver {
    // Now, this contract has:
    // 1. A dnsresolve getter function.
    // 2. A doResolveDNS virtual function.
}

Sources