On-chain resolution

nsNode   = sha256( 0x00 × 32  ||  sha256(label) )     # a namespace
nameNode = sha256( nsNode     ||  sha256(label) )     # a name under it

import { hash } from "@stellar/stellar-sdk";
const sha     = (b) => Buffer.from(hash(b));
const nsNode  = (label) => sha(Buffer.concat([Buffer.alloc(32), sha(Buffer.from(label, "utf8"))]));
const subNode = (parent, label) => sha(Buffer.concat([parent, sha(Buffer.from(label, "utf8"))]));

// worked example — nova, and alice.nova
nsNode("nova").toString("hex");
// 857f994cc3975eda4e373f51c9f5b0f7940451a5eb3ff225edc5cd468228b430
subNode(nsNode("nova"), "alice").toString("hex");
// 537d927ab5b2547c543ece8459c6971d873559ec43de2a8d43cdad118d68916e

import {
  rpc, Contract, Account, TransactionBuilder, BASE_FEE,
  scValToNative, nativeToScVal,
} from "@stellar/stellar-sdk";

const server   = new rpc.Server("https://soroban-testnet.stellar.org");
const PASS     = "Test SDF Network ; September 2015";
const REGISTRY = "CAUEHYVLLNNDZ4H5QWCPBDWEONRI44SI3XYSEACB4U3HYILIVQGQAMNI";
// Any account works — simulation never signs and never submits.
const SIM = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";

async function view(contractId, fn, ...args) {
  const tx = new TransactionBuilder(new Account(SIM, "0"), { fee: BASE_FEE, networkPassphrase: PASS })
    .addOperation(new Contract(contractId).call(fn, ...args))
    .setTimeout(30).build();
  const sim = await server.simulateTransaction(tx);
  return rpc.Api.isSimulationSuccess(sim) && sim.result?.retval
    ? scValToNative(sim.result.retval) : null;
}

async function resolve(namespace, label) {
  const bytes = (b) => nativeToScVal(b, { type: "bytes" });
  const ns   = nsNode(namespace);
  const node = subNode(ns, label);

  const resolver = await view(REGISTRY, "resolver_of", bytes(ns));   // the namespace's resolver pointer
  if (resolver) {
    const addr = await view(resolver, "addr", bytes(node));          // PRIMARY: generation-gated forward record
    if (addr) return addr;
  }
  const registrar = await view(REGISTRY, "registrar_of", bytes(ns)); // FALLBACK: built-in, expiry-gated
  return view(registrar, "resolve", bytes(Buffer.from(label, "utf8")));
}

await resolve("nova", "alice");
// GDHNO4WKFQJJAPX6YLQTGWFR5QCKZXKJBHKRFCSNRRFSTEJIQZ4Y5UBU

import { rpc, xdr, Address, scValToNative } from "@stellar/stellar-sdk";
const server = new rpc.Server("https://soroban-testnet.stellar.org");

// A DataKey enum → ScVal. A tuple variant is scvVec([symbol, ...payload]); a
// unit variant is a single-element vec scvVec([symbol]) — but the only unit
// keys (Config, the Resolver's Provenance) are instance storage, not read here.
const dataKey = (variant, ...payload) => xdr.ScVal.scvVec([xdr.ScVal.scvSymbol(variant), ...payload]);
const B = (bytes) => xdr.ScVal.scvBytes(bytes);

function key(contractId, keyScVal) {
  return xdr.LedgerKey.contractData(new xdr.LedgerKeyContractData({
    contract: new Address(contractId).toScAddress(),
    key: keyScVal,
    durability: xdr.ContractDataDurability.persistent,
  }));
}

async function readEntry(contractId, keyScVal) {
  const { entries, latestLedger } = await server.getLedgerEntries(key(contractId, keyScVal));
  if (!entries?.length) return null;                        // empty ⇒ never written (no such name)
  const e = entries[0];
  if (e.liveUntilLedgerSeq && e.liveUntilLedgerSeq < latestLedger) return null; // archived → stale
  return scValToNative(e.val.contractData.val);             // Soroban struct → object keyed by field name
}

const live = (name) => name && (name.expires_at === 0n || name.expires_at > BigInt(Math.floor(Date.now() / 1000)));

async function resolveRaw(namespace, label) {
  const ns   = nsNode(namespace);
  const node = subNode(ns, label);

  const record    = await readEntry(REGISTRY, dataKey("Node", B(ns)));       // Record{ owner, resolver, … }
  const registrar = await readEntry(REGISTRY, dataKey("Registrar", B(ns)));  // the namespace's registrar
  const name      = await readEntry(registrar, dataKey("Name", B(node)));    // Name{ holder, address, expires_at, generation }
  if (!live(name)) return null;

  // PRIMARY: the resolver POINTER lives in the Node record's `resolver` field
  // (the owner-set pointer, NOT the attested Resolver(nsNode) key). null ⇒ the
  // namespace runs closed — skip the resolver and use the built-in Name.address.
  const resolver = record?.resolver;
  if (resolver) {
    const rec = await readEntry(resolver, dataKey("Addr", B(node)));         // AddrRec{ addr, generation }
    if (rec && rec.generation === name.generation) return rec.addr;          // gate: generation must match
  }
  return name.address;                                                       // FALLBACK: built-in target
}

await resolveRaw("nova", "alice");
// GDHNO4WKFQJJAPX6YLQTGWFR5QCKZXKJBHKRFCSNRRFSTEJIQZ4Y5UBU