Resolve a .night domain

This page documents the core query functions exported by @midnames/sdk.

The Result type

All async functions return Promise<Result<T>>. The Result type is a discriminated union:

type Result<T, E = MidnamesError> =
  | { success: true; data: T }
  | { success: false; error: E };

Always check result.success before accessing result.data or result.error:

const result = await resolveDomain("facu.night");

if (result.success) {
  console.log(result.data); // the resolved target
} else {
  console.error(result.error.message);
  console.error(result.error.code); // e.g. "DOMAIN_NOT_FOUND"
}

Provider setup

By default, all functions connect to the Midnight mainnet. You can use the default provider or create a custom one:

import { getDefaultProvider, createDefaultProvider } from "@midnames/sdk";

// Auto-connects to mainnet (lazy-initialized)
const provider = getDefaultProvider();

// Or create with custom config
const customProvider = createDefaultProvider({
  indexerUrl: "https://indexer.preprod.midnight.network/api/v3/graphql",
  indexerWsUrl: "wss://indexer.preprod.midnight.network/api/v3/graphql/ws",
  networkId: "preprod",
});

Pass a custom provider to any function via the options.provider parameter. You can also override the contract address with options.contractAddress.

---

resolveDomain

Resolves a .night domain to its target (wallet or contract address).

function resolveDomain(
  domain: string,
  options?: { provider?: PublicDataProvider; contractAddress?: string }
): Promise<Result<DomainTarget>>

DomainTarget

type DomainTarget =
  | { type: "contract"; address: string }
  | { type: "shielded"; address: string }
  | { type: "unshielded"; address: string }

Parameters

Name	Type	Description
domain	string	The full domain name, e.g. "facu.night"
options.provider	PublicDataProvider	Optional custom provider
options.contractAddress	string	Optional contract address override

Example

import { resolveDomain } from "@midnames/sdk";

const result = await resolveDomain("facu.night");
if (result.success) {
  const target = result.data;
  console.log("Type:", target.type);       // "contract" | "shielded" | "unshielded"
  console.log("Address:", target.address);
}

---

resolveDefault

Like resolveDomain, but returns the value of the domain’s default field if one is set, falling back to the target address.

function resolveDefault(
  domain: string,
  options?: { provider?: PublicDataProvider; contractAddress?: string }
): Promise<Result<string | DomainTarget>>

Example

import { resolveDefault } from "@midnames/sdk";

const result = await resolveDefault("facu.night");
if (result.success) {
  // May be a string (field value) or a DomainTarget
  console.log(result.data);
}

---

getDomainInfo

Returns ownership and target information for a domain.

function getDomainInfo(
  fullDomain: string,
  options?: { provider?: PublicDataProvider; contractAddress?: string }
): Promise<Result<DomainInfo>>

DomainInfo

interface DomainInfo {
  id: bigint;
  owner: string;         // owner public key (hex)
  ownerAddress: string;  // owner unshielded address
  target: DomainTarget;
  targetLocked: boolean;
}

Example

import { getDomainInfo } from "@midnames/sdk";

const result = await getDomainInfo("facu.night");
if (result.success) {
  console.log("Owner address:", result.data.ownerAddress);
  console.log("Target:", result.data.target);
  console.log("Target locked:", result.data.targetLocked);
}

---

getDomainFields

Returns all custom fields (records) set on a domain as a Map<string, string>.

function getDomainFields(
  fullDomain: string,
  options?: { provider?: PublicDataProvider; contractAddress?: string }
): Promise<Result<Map<string, string>>>

Example

import { getDomainFields } from "@midnames/sdk";

const result = await getDomainFields("facu.night");
if (result.success) {
  for (const [key, value] of result.data) {
    console.log(`${key}: ${value}`);
  }
}

---

getDomainSettings

Returns the payment configuration and settings for a domain.

function getDomainSettings(
  fullDomain: string,
  options?: { provider?: PublicDataProvider; contractAddress?: string }
): Promise<Result<DomainSettings>>

DomainSettings

interface DomainSettings {
  coinColor: Uint8Array;
  costs: {
    short: bigint;   // cost for short names (≤ 3 chars)
    medium: bigint;  // cost for medium names (4–6 chars)
    long: bigint;    // cost for long names (≥ 7 chars)
  };
  buyEnabled: boolean;
  defaultField: string | null;
  paymentConfigLocked: boolean;
}

Example

import { getDomainSettings } from "@midnames/sdk";

const result = await getDomainSettings("facu.night");
if (result.success) {
  const { costs, buyEnabled } = result.data;
  console.log("Buy enabled:", buyEnabled);
  console.log("Cost (long name):", costs.long);
}

---

getDomainProfile

Returns a combined profile with domain info, fields, and settings in a single call.

function getDomainProfile(
  fullDomain: string,
  options?: { provider?: PublicDataProvider; contractAddress?: string }
): Promise<Result<DomainProfileData>>

DomainProfileData

interface DomainProfileData {
  fullDomain: string;
  info: DomainInfo | null;
  fields: Map<string, string>;
  settings: DomainSettings | null;
}

Example

import { getDomainProfile } from "@midnames/sdk";

const result = await getDomainProfile("facu.night");
if (result.success) {
  const { info, fields, settings } = result.data;
  console.log("Target:", info?.target);
  console.log("Bio:", fields.get("bio"));
}

---

getSubdomains

Returns all subdomains registered under a given domain.

function getSubdomains(
  fullDomain: string,
  options?: { provider?: PublicDataProvider; contractAddress?: string }
): Promise<Result<Map<string, DomainInfo>>>

Example

import { getSubdomains } from "@midnames/sdk";

const result = await getSubdomains("facu.night");
if (result.success) {
  for (const [name, info] of result.data) {
    console.log(`${name}.facu.night → ${info.target.address}`);
  }
}

---

Error types

All errors extend MidnamesError, which has message, code, and optional details properties.

Error class	Code	Description
MidnamesError	varies	Base error class
NetworkError	NETWORK_ERROR	Network or provider failure
DomainNotFoundError	DOMAIN_NOT_FOUND	Domain does not exist
InvalidDomainError	INVALID_DOMAIN	Domain format is invalid
ContractNotFoundError	CONTRACT_NOT_FOUND	Resolver contract not found

import { DomainNotFoundError } from "@midnames/sdk";

const result = await resolveDomain("nonexistent.night");
if (!result.success) {
  if (result.error instanceof DomainNotFoundError) {
    console.log("Domain not registered");
  }
}