@parity/product-sdk 0.22.0 → 0.23.0

package/dist/identity/index.js

@@ -1,45 +1,813 @@
-export { accountIdHexToBytes, isDotNsAvailable, isValidDotNsName, normalizeDotNsName, resolveDotNs, resolvePeopleUsernameOwner, reverseDotNs } from '../chunk-BIKT6X54.js';
+import { normalizeDotNsName, isResolvableDotNsName, namehash, isValidDotNsName, stripSuffix, isConsistentDotNsTld, DOT_TLD, dotNsTld } from '../chunk-BRZNHTLQ.js';
+export { DOT_NODE, DOT_TLD, accountIdHexToBytes, accountIdToHex, dotNsTld, isConsistentDotNsTld, isResolvableDotNsName, isValidDotNsName, namehash, normalizeDotNsName, resolvePeopleUsernameOwner, stripSuffix } from '../chunk-BRZNHTLQ.js';
+import { ok, err } from '@parity/result';
+import { bytesToHex, randomBytes } from '@parity/product-sdk-crypto';
+import { ss58ToH160 } from '@parity/product-sdk-address';
 import { createLogger } from '@parity/product-sdk-logger';
-import { blake2b256 } from '@parity/product-sdk-crypto';
-import { ss58Decode, ss58Encode, deriveH160 } from '@parity/product-sdk-address';
+import { QUERY_FALLBACK_ORIGIN, createContract } from '@parity/product-sdk-contracts';
 
-var log = createLogger("identity");
-function deriveContextAlias(parentAddress, context, ss58Prefix = 42) {
-  const { publicKey: parentPublicKey } = ss58Decode(parentAddress);
-  const contextBytes = new TextEncoder().encode(context);
-  const combined = new Uint8Array(parentPublicKey.length + contextBytes.length);
-  combined.set(parentPublicKey, 0);
-  combined.set(contextBytes, parentPublicKey.length);
-  const aliasPublicKey = blake2b256(combined);
-  const address = ss58Encode(aliasPublicKey, ss58Prefix);
-  const h160Address = deriveH160(aliasPublicKey);
-  log.debug("Derived context alias", {
-    parentAddress,
-    context,
-    address
+// src/identity/dotns-abis.ts
+var DOTNS_REGISTRY_ABI = [
+  {
+    type: "function",
+    name: "resolver",
+    inputs: [{ name: "node", type: "bytes32" }],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [{ name: "node", type: "bytes32" }],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setResolver",
+    inputs: [
+      { name: "node", type: "bytes32" },
+      { name: "resolverAddr", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+var DOTNS_RESOLVER_ABI = [
+  {
+    type: "function",
+    name: "addressOf",
+    inputs: [{ name: "node", type: "bytes32" }],
+    outputs: [{ name: "value", type: "address" }],
+    stateMutability: "view"
+  }
+];
+var DOTNS_REVERSE_RESOLVER_ABI = [
+  {
+    type: "function",
+    name: "nameOf",
+    inputs: [{ name: "addr", type: "address" }],
+    outputs: [{ name: "name", type: "string" }],
+    stateMutability: "view"
+  }
+];
+var DOTNS_RESOLVER_WRITE_ABI = [
+  {
+    type: "function",
+    name: "setAddress",
+    inputs: [
+      { name: "node", type: "bytes32" },
+      { name: "value", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+var DOTNS_REGISTRAR_CONTROLLER_ABI = [
+  {
+    type: "function",
+    name: "available",
+    inputs: [{ name: "label", type: "string" }],
+    outputs: [{ name: "isAvailable", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "minCommitmentAge",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "maxCommitmentAge",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "makeCommitment",
+    inputs: [
+      {
+        name: "registration",
+        type: "tuple",
+        components: [
+          { name: "label", type: "string" },
+          { name: "owner", type: "address" },
+          { name: "secret", type: "bytes32" },
+          { name: "reserved", type: "bool" }
+        ]
+      }
+    ],
+    outputs: [{ name: "commitment", type: "bytes32" }],
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "commit",
+    inputs: [{ name: "commitment", type: "bytes32" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "register",
+    inputs: [
+      {
+        name: "registration",
+        type: "tuple",
+        components: [
+          { name: "label", type: "string" },
+          { name: "owner", type: "address" },
+          { name: "secret", type: "bytes32" },
+          { name: "reserved", type: "bool" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  }
+];
+var DOTNS_POP_RULES_ABI = [
+  {
+    type: "function",
+    name: "price",
+    inputs: [{ name: "name", type: "string" }],
+    outputs: [{ name: "cost", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "priceWithoutCheck",
+    inputs: [
+      { name: "name", type: "string" },
+      { name: "userAddress", type: "address" }
+    ],
+    outputs: [
+      {
+        name: "metadata",
+        type: "tuple",
+        components: [
+          { name: "price", type: "uint256" },
+          { name: "status", type: "uint8" },
+          { name: "userStatus", type: "uint8" },
+          { name: "message", type: "string" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "classifyName",
+    inputs: [{ name: "name", type: "string" }],
+    outputs: [
+      { name: "requirement", type: "uint8" },
+      { name: "message", type: "string" }
+    ],
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "transferFloor",
+    inputs: [
+      { name: "name", type: "string" },
+      { name: "from", type: "address" },
+      { name: "to", type: "address" }
+    ],
+    outputs: [{ name: "floor", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var DOTNS_PROTOCOL_REGISTRY_ABI = [
+  {
+    type: "function",
+    name: "tld",
+    inputs: [],
+    outputs: [{ name: "suffix", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tldNode",
+    inputs: [],
+    outputs: [{ name: "node", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "get",
+    inputs: [{ name: "key", type: "bytes32" }],
+    outputs: [{ name: "addr", type: "address" }],
+    stateMutability: "view"
+  }
+];
+var DOTNS_ROOT_GATEWAY_DISPATCHER_ABI = [
+  {
+    type: "function",
+    name: "TARGET",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  }
+];
+var DOTNS_POP_CONTROLLER_ABI = [
+  {
+    type: "function",
+    name: "protocolRegistry",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  }
+];
+var POP_STATUS = { NoStatus: 0, PopLite: 1, PopFull: 2, Reserved: 3 };
+var DOTNS_ADDRESSES = {
+  registry: "0xf34054fd76BbF85f216cf9908226D5f0A72E50CA",
+  reverseResolver: "0xee3883d7eB60Ee9BCD7F3bcD8f2f05302A9Cc035",
+  resolver: "0xbd1165E549DF96F083c0A16f61590927bC187009",
+  registrarController: "0xBdaA01bD1bA67d709F2b1fF286Da0d854977EA30",
+  popRules: "0x747B456bE03aec0b42bd85C51513730FBD45DA31",
+  protocolRegistry: "0xD19e3D0C97CF501125a04A97405e3e6592fa846E"
+};
+
+// src/identity/dotns-errors.ts
+var DotNsError = class extends Error {
+  isSdkError = true;
+  source = "dotns";
+  reason;
+  constructor(reason, message, options) {
+    super(message, options);
+    this.name = "DotNsError";
+    this.reason = reason;
+  }
+};
+var DOTNS_REGISTRY_KEYS = {
+  registry: "0x7265676973747279000000000000000000000000000000000000000000000000",
+  registrarController: "0x636f6e74726f6c6c657200000000000000000000000000000000000000000000",
+  reverseResolver: "0x726576657273655265736f6c7665720000000000000000000000000000000000",
+  resolver: "0x7265736f6c766572000000000000000000000000000000000000000000000000",
+  popRules: "0x706f7052756c6573000000000000000000000000000000000000000000000000"
+};
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function isZero(addr) {
+  return typeof addr === "string" && addr.toLowerCase() === ZERO_ADDRESS;
+}
+function sameAddress(a, b) {
+  return typeof a === "string" && typeof b === "string" && a.toLowerCase() === b.toLowerCase();
+}
+function cachedPerRuntime(cache, runtime, key, load) {
+  let byKey = cache.get(runtime);
+  if (!byKey) {
+    byKey = /* @__PURE__ */ new Map();
+    cache.set(runtime, byKey);
+  }
+  const cached = byKey.get(key);
+  if (cached) return cached;
+  const pending = load();
+  byKey.set(key, pending);
+  pending.then((result) => {
+    if (!result.ok) byKey?.delete(key);
   });
+  return pending;
+}
+function withOverrides(base, opts) {
   return {
-    address,
-    h160Address,
-    parentAddress,
-    context
+    registry: opts.registryAddress ?? base.registry,
+    reverseResolver: opts.reverseResolverAddress ?? base.reverseResolver,
+    resolver: opts.resolverAddress ?? base.resolver,
+    registrarController: opts.registrarControllerAddress ?? base.registrarController,
+    popRules: opts.popRulesAddress ?? base.popRules,
+    protocolRegistry: opts.protocolRegistryAddress ?? base.protocolRegistry
   };
 }
-function verifyContextAlias(aliasAddress, parentAddress, context) {
+var walkCache = /* @__PURE__ */ new WeakMap();
+var WALK_KEY = "discovered";
+async function resolveDotNsAddresses(opts) {
+  if (opts.addressSource !== "discovered") return ok(withOverrides(DOTNS_ADDRESSES, opts));
+  const walked = await cachedPerRuntime(
+    walkCache,
+    opts.runtime,
+    WALK_KEY,
+    () => discoverDotNsAddresses(opts)
+  );
+  return walked.ok ? ok(withOverrides(walked.value, opts)) : walked;
+}
+var discoveryFailed = (step, cause) => err(new DotNsError("AddressDiscovery", `DotNS address discovery failed: ${step}`, { cause }));
+function contractOf(runtime, address, abi) {
+  return createContract(runtime, address, abi);
+}
+function readOrigin(opts) {
+  return opts.origin ?? QUERY_FALLBACK_ORIGIN;
+}
+async function readAddress(contract, method, origin) {
+  const res = await contract[method].query({ origin });
+  if (!res.success) return discoveryFailed(`${method}() failed`, res.value);
+  const value = res.value;
+  if (typeof value !== "string" || isZero(value)) {
+    return discoveryFailed(`${method}() returned no address`);
+  }
+  return ok(value);
+}
+function asH160(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value.asHex === "function") {
+    return value.asHex();
+  }
+  return null;
+}
+function gatewayOf(opts) {
+  if (opts.gatewayApi) return opts.gatewayApi;
+  const api = opts.runtime?.api;
+  const getValue = api?.query?.DotnsGateway?.DispatcherAddress?.getValue;
+  return typeof getValue === "function" ? api : null;
+}
+async function discoverDotNsAddresses(opts) {
+  try {
+    const gateway = gatewayOf(opts);
+    if (!gateway) {
+      return discoveryFailed(
+        "no DotnsGateway.DispatcherAddress storage on this runtime; pass opts.gatewayApi"
+      );
+    }
+    const dispatcher = asH160(await gateway.query.DotnsGateway.DispatcherAddress.getValue());
+    if (!dispatcher || isZero(dispatcher)) {
+      return discoveryFailed("DotnsGateway.DispatcherAddress is unset");
+    }
+    const origin = readOrigin(opts);
+    const target = await readAddress(
+      contractOf(opts.runtime, dispatcher, DOTNS_ROOT_GATEWAY_DISPATCHER_ABI),
+      "TARGET",
+      origin
+    );
+    if (!target.ok) return target;
+    const protocolRegistry = await readAddress(
+      contractOf(opts.runtime, target.value, DOTNS_POP_CONTROLLER_ABI),
+      "protocolRegistry",
+      origin
+    );
+    if (!protocolRegistry.ok) return protocolRegistry;
+    const registry = contractOf(
+      opts.runtime,
+      protocolRegistry.value,
+      DOTNS_PROTOCOL_REGISTRY_ABI
+    );
+    const roles = Object.entries(DOTNS_REGISTRY_KEYS);
+    const found = await Promise.all(
+      roles.map(async ([role, key]) => {
+        const res = await registry.get.query(key, { origin });
+        if (!res.success) return discoveryFailed(`get(${role}) failed`, res.value);
+        const value = res.value;
+        if (typeof value !== "string" || isZero(value)) {
+          return discoveryFailed(`${role} is unset on the protocol registry`);
+        }
+        return ok([role, value]);
+      })
+    );
+    const failed = found.find((r) => !r.ok);
+    if (failed && !failed.ok) return failed;
+    const byRole = Object.fromEntries(found.flatMap((r) => r.ok ? [r.value] : []));
+    return ok({ ...byRole, protocolRegistry: protocolRegistry.value });
+  } catch (cause) {
+    return discoveryFailed("unexpected error", cause);
+  }
+}
+async function verifyDotNsAddresses(opts) {
+  const discovered = await cachedPerRuntime(
+    walkCache,
+    opts.runtime,
+    WALK_KEY,
+    () => discoverDotNsAddresses(opts)
+  );
+  if (!discovered.ok) return discovered;
+  const inUse = withOverrides(
+    opts.addressSource === "discovered" ? discovered.value : DOTNS_ADDRESSES,
+    opts
+  );
+  const drift = Object.keys(inUse).filter((role) => !sameAddress(inUse[role], discovered.value[role])).map((role) => `${role}: using ${inUse[role]}, chain says ${discovered.value[role]}`);
+  return drift.length ? err(
+    new DotNsError(
+      "AddressMismatch",
+      `DotNS addresses disagree with the deployment \u2014 ${drift.join("; ")}`
+    )
+  ) : ok(inUse);
+}
+
+// src/identity/dotns-registry.ts
+var log = createLogger("identity:dotns");
+var tldCache = /* @__PURE__ */ new WeakMap();
+function isEmptyRevert(value) {
+  return typeof value === "object" && value !== null && value.type === "ContractRevertedWithPayload" && value.data === "0x";
+}
+async function resolveTld(opts) {
+  if (opts.tld) {
+    return isConsistentDotNsTld(opts.tld) ? ok(opts.tld) : err(
+      new DotNsError(
+        "InvalidTld",
+        `opts.tld is inconsistent: "${opts.tld.suffix}" does not hash to ${opts.tld.node}`
+      )
+    );
+  }
+  const addresses = await resolveDotNsAddresses(opts);
+  if (!addresses.ok) return addresses;
+  const address = addresses.value.protocolRegistry;
+  return cachedPerRuntime(tldCache, opts.runtime, address, () => readTld(opts, address));
+}
+async function readTld(opts, address) {
+  try {
+    const registry = contractOf(opts.runtime, address, DOTNS_PROTOCOL_REGISTRY_ABI);
+    const origin = readOrigin(opts);
+    const suffixRes = await registry.tld.query({ origin });
+    if (!suffixRes.success) {
+      if (isEmptyRevert(suffixRes.value)) {
+        log.warn(
+          "DotNS protocol registry has no tld() getter; treating this as a pre-b4096968 deployment, whose TLD was the compile-time .dot",
+          { protocolRegistry: address }
+        );
+        return ok(DOT_TLD);
+      }
+      return err(
+        new DotNsError("RegistryCall", "protocolRegistry.tld call failed", {
+          cause: suffixRes.value
+        })
+      );
+    }
+    const suffix = suffixRes.value;
+    const tld = dotNsTld(suffix);
+    if (!isConsistentDotNsTld(tld)) {
+      return err(
+        new DotNsError(
+          "InvalidTld",
+          `protocolRegistry.tld returned an unusable TLD: ${JSON.stringify(suffix)}`
+        )
+      );
+    }
+    const nodeRes = await registry.tldNode.query({ origin });
+    if (nodeRes.success && isNode(nodeRes.value) && !sameNode(nodeRes.value, tld.node)) {
+      return err(
+        new DotNsError(
+          "InvalidTld",
+          `protocolRegistry disagrees with itself: tld() ${suffix} derives ${tld.node} but tldNode() reports ${String(nodeRes.value)}`
+        )
+      );
+    }
+    log.debug("resolveTld", { protocolRegistry: address, suffix: tld.suffix, node: tld.node });
+    return ok(tld);
+  } catch (cause) {
+    return err(new DotNsError("RegistryCall", "DotNS TLD read failed", { cause }));
+  }
+}
+function nameError(input, normalized, tld) {
+  if (!normalized.endsWith(tld.suffix)) {
+    return new DotNsError(
+      "TldMismatch",
+      `DotNS name "${input}" is not on this deployment, which uses "${tld.suffix}"`
+    );
+  }
+  return new DotNsError("InvalidName", `Invalid DotNS name: "${input}"`);
+}
+function isNode(value) {
+  return typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value);
+}
+function sameNode(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+async function resolveDotNs(name, opts) {
+  const tldRes = await resolveTld(opts);
+  if (!tldRes.ok) return tldRes;
+  const tld = tldRes.value;
+  const normalized = normalizeDotNsName(name, tld.suffix);
+  if (!isResolvableDotNsName(normalized, tld.suffix)) {
+    return err(nameError(name, normalized, tld));
+  }
+  const node = namehash(normalized, tld);
+  const addrs = await resolveDotNsAddresses(opts);
+  if (!addrs.ok) return addrs;
+  const registryAddr = addrs.value.registry;
+  const origin = readOrigin(opts);
+  log.debug("resolveDotNs", { name: normalized, node, registry: registryAddr });
   try {
-    const derived = deriveContextAlias(parentAddress, context);
-    const { publicKey: aliasKey } = ss58Decode(aliasAddress);
-    const { publicKey: derivedKey } = ss58Decode(derived.address);
-    if (aliasKey.length !== derivedKey.length) return false;
-    for (let i = 0; i < aliasKey.length; i++) {
-      if (aliasKey[i] !== derivedKey[i]) return false;
+    const registry = contractOf(opts.runtime, registryAddr, DOTNS_REGISTRY_ABI);
+    const [ownerRes, resolverRes] = await Promise.all([
+      registry.owner.query(node, { origin }),
+      registry.resolver.query(node, { origin })
+    ]);
+    if (!ownerRes.success) {
+      return err(
+        new DotNsError("RegistryCall", "registry.owner call failed", {
+          cause: ownerRes.value
+        })
+      );
+    }
+    if (!resolverRes.success) {
+      return err(
+        new DotNsError("RegistryCall", "registry.resolver call failed", {
+          cause: resolverRes.value
+        })
+      );
+    }
+    const owner = ownerRes.value;
+    if (isZero(owner)) return ok(null);
+    const resolverAddr = resolverRes.value;
+    const forwardAddr = addrs.value.resolver;
+    if (!sameAddress(resolverAddr, forwardAddr)) {
+      return ok({ name: normalized, owner });
+    }
+    const resolver = contractOf(opts.runtime, resolverAddr, DOTNS_RESOLVER_ABI);
+    const addrRes = await resolver.addressOf.query(node, { origin });
+    if (!addrRes.success) {
+      return err(
+        new DotNsError("RegistryCall", "resolver.addressOf call failed", {
+          cause: addrRes.value
+        })
+      );
+    }
+    const address = addrRes.value;
+    if (isZero(address)) return ok({ name: normalized, owner });
+    return ok({ address, name: normalized, owner });
+  } catch (cause) {
+    return err(
+      new DotNsError("RegistryCall", `DotNS resolve failed for "${normalized}"`, { cause })
+    );
+  }
+}
+async function reverseDotNs(address, opts) {
+  const addrs = await resolveDotNsAddresses(opts);
+  if (!addrs.ok) return addrs;
+  const reverseAddr = addrs.value.reverseResolver;
+  log.debug("reverseDotNs", { address, reverseResolver: reverseAddr });
+  try {
+    const reverse = contractOf(
+      opts.runtime,
+      reverseAddr,
+      DOTNS_REVERSE_RESOLVER_ABI
+    );
+    const res = await reverse.nameOf.query(address, { origin: readOrigin(opts) });
+    if (!res.success) {
+      return err(
+        new DotNsError("RegistryCall", "reverseResolver.nameOf call failed", {
+          cause: res.value
+        })
+      );
+    }
+    const name = res.value;
+    return ok(name && name.length > 0 ? name : null);
+  } catch (cause) {
+    return err(
+      new DotNsError("RegistryCall", `DotNS reverse failed for "${address}"`, { cause })
+    );
+  }
+}
+async function isDotNsAvailable(name, opts) {
+  const tldRes = await resolveTld(opts);
+  if (!tldRes.ok) return tldRes;
+  const tld = tldRes.value;
+  const normalized = normalizeDotNsName(name, tld.suffix);
+  if (!isValidDotNsName(normalized, tld.suffix)) {
+    return err(nameError(name, normalized, tld));
+  }
+  const label = stripSuffix(normalized, tld.suffix);
+  const addrs = await resolveDotNsAddresses(opts);
+  if (!addrs.ok) return addrs;
+  const controllerAddr = addrs.value.registrarController;
+  log.debug("isDotNsAvailable", { name: normalized, label, controller: controllerAddr });
+  try {
+    const controller = contractOf(
+      opts.runtime,
+      controllerAddr,
+      DOTNS_REGISTRAR_CONTROLLER_ABI
+    );
+    const popRules = contractOf(opts.runtime, addrs.value.popRules, DOTNS_POP_RULES_ABI);
+    const origin = readOrigin(opts);
+    const [res, classified] = await Promise.all([
+      controller.available.query(label, { origin }),
+      popRules.classifyName.query(label, { origin })
+    ]);
+    if (!res.success) {
+      return err(
+        new DotNsError("RegistryCall", "registrarController.available call failed", {
+          cause: res.value
+        })
+      );
+    }
+    if (res.value !== true) return ok(false);
+    if (!classified.success) {
+      return err(
+        new DotNsError("RegistryCall", "PopRules.classifyName call failed", {
+          cause: classified.value
+        })
+      );
+    }
+    const { requirement } = classified.value;
+    return ok(requirement !== POP_STATUS.Reserved);
+  } catch (cause) {
+    return err(
+      new DotNsError("RegistryCall", `DotNS availability check failed for "${normalized}"`, {
+        cause
+      })
+    );
+  }
+}
+async function setDotNsRecord(args, opts) {
+  const tldRes = await resolveTld(opts);
+  if (!tldRes.ok) return tldRes;
+  const tld = tldRes.value;
+  const normalized = normalizeDotNsName(args.name, tld.suffix);
+  if (!isResolvableDotNsName(normalized, tld.suffix)) {
+    return err(nameError(args.name, normalized, tld));
+  }
+  const origin = opts.origin;
+  if (!origin) {
+    return err(new DotNsError("MissingOrigin", "setDotNsRecord needs opts.origin (SS58)"));
+  }
+  const node = namehash(normalized, tld);
+  const addrs = await resolveDotNsAddresses(opts);
+  if (!addrs.ok) return addrs;
+  const registryAddr = addrs.value.registry;
+  const resolverAddr = addrs.value.resolver;
+  try {
+    const registry = contractOf(opts.runtime, registryAddr, DOTNS_REGISTRY_ABI);
+    const currentRes = await registry.resolver.query(node, { origin });
+    if (!currentRes.success) {
+      return err(
+        new DotNsError("RegistryCall", "registry.resolver call failed", {
+          cause: currentRes.value
+        })
+      );
+    }
+    const calls = [];
+    if (!sameAddress(currentRes.value, resolverAddr)) {
+      const pointer = await registry.setResolver.prepare(node, resolverAddr, { origin });
+      if (!pointer.ok) {
+        return err(
+          new DotNsError("RegistryCall", "registry.setResolver prepare failed", {
+            cause: pointer.error
+          })
+        );
+      }
+      calls.push(pointer.value);
+    }
+    const resolver = contractOf(
+      opts.runtime,
+      resolverAddr,
+      DOTNS_RESOLVER_WRITE_ABI
+    );
+    const prepared = await resolver.setAddress.prepare(node, args.address, { origin });
+    if (!prepared.ok) {
+      return err(
+        new DotNsError("RegistryCall", "resolver.setAddress prepare failed", {
+          cause: prepared.error
+        })
+      );
+    }
+    calls.push(prepared.value);
+    return ok(calls);
+  } catch (cause) {
+    return err(new DotNsError("RegistryCall", "DotNS setRecord failed", { cause }));
+  }
+}
+async function quoteRegistration(popRules, label, owner, payer, origin) {
+  const quote = await popRules.priceWithoutCheck.query(label, owner, { origin });
+  if (!quote.success) {
+    return err(
+      new DotNsError("RegistryCall", "PopRules.priceWithoutCheck failed", {
+        cause: quote.value
+      })
+    );
+  }
+  const { price, status, userStatus, message } = quote.value;
+  if (status === POP_STATUS.Reserved) {
+    return err(new DotNsError("NameReserved", `"${label}" is reserved: ${message}`));
+  }
+  if (userStatus < status) {
+    return err(
+      new DotNsError(
+        "OwnerStatusInsufficient",
+        `"${label}" requires personhood tier ${status}, owner has ${userStatus}: ${message}`
+      )
+    );
+  }
+  if (sameAddress(payer, owner)) return ok(BigInt(price));
+  const floor = await popRules.transferFloor.query(label, payer, owner, { origin });
+  if (!floor.success) {
+    return err(
+      new DotNsError("RegistryCall", "PopRules.transferFloor failed", {
+        cause: floor.value
+      })
+    );
+  }
+  const friction = BigInt(floor.value);
+  const base = BigInt(price);
+  return ok(base > friction ? base : friction);
+}
+async function prepareDotNsRegistration(args, opts) {
+  const tldRes = await resolveTld(opts);
+  if (!tldRes.ok) return tldRes;
+  const tld = tldRes.value;
+  const normalized = normalizeDotNsName(args.name, tld.suffix);
+  if (!isValidDotNsName(normalized, tld.suffix)) {
+    return err(nameError(args.name, normalized, tld));
+  }
+  const origin = opts.origin;
+  if (!origin) {
+    return err(
+      new DotNsError("MissingOrigin", "prepareDotNsRegistration needs opts.origin (SS58)")
+    );
+  }
+  const label = stripSuffix(normalized, tld.suffix);
+  const addrs = await resolveDotNsAddresses(opts);
+  if (!addrs.ok) return addrs;
+  const controllerAddr = addrs.value.registrarController;
+  const popRulesAddr = addrs.value.popRules;
+  const secret = `0x${bytesToHex(randomBytes(32))}`;
+  const registration = { label, owner: args.owner, secret, reserved: args.reserved ?? false };
+  let payer;
+  try {
+    payer = ss58ToH160(origin);
+  } catch (cause) {
+    return err(
+      new DotNsError("InvalidOrigin", `opts.origin is not a valid SS58 address: ${origin}`, {
+        cause
+      })
+    );
+  }
+  try {
+    const controller = contractOf(
+      opts.runtime,
+      controllerAddr,
+      DOTNS_REGISTRAR_CONTROLLER_ABI
+    );
+    const popRules = contractOf(opts.runtime, popRulesAddr, DOTNS_POP_RULES_ABI);
+    const [commitmentRes, availableRes, quote, minRes, maxRes] = await Promise.all([
+      controller.makeCommitment.query(registration, { origin }),
+      controller.available.query(label, { origin }),
+      quoteRegistration(popRules, label, args.owner, payer, origin),
+      controller.minCommitmentAge.query({ origin }),
+      controller.maxCommitmentAge.query({ origin })
+    ]);
+    if (!availableRes.success) {
+      return err(
+        new DotNsError("RegistryCall", "registrarController.available call failed", {
+          cause: availableRes.value
+        })
+      );
+    }
+    if (availableRes.value !== true) {
+      return err(new DotNsError("NameUnavailable", `"${label}" is already registered`));
+    }
+    if (!commitmentRes.success) {
+      return err(
+        new DotNsError("RegistryCall", "makeCommitment failed", {
+          cause: commitmentRes.value
+        })
+      );
+    }
+    if (!quote.ok) return quote;
+    if (!minRes.success || !maxRes.success) {
+      return err(
+        new DotNsError("RegistryCall", "commitment window read failed", {
+          cause: minRes.success ? maxRes.value : minRes.value
+        })
+      );
+    }
+    const commitment = commitmentRes.value;
+    const commitPrep = await controller.commit.prepare(commitment, { origin });
+    if (!commitPrep.ok) {
+      return err(
+        new DotNsError("RegistryCall", "controller.commit prepare failed", {
+          cause: commitPrep.error
+        })
+      );
     }
-    return true;
-  } catch {
-    return false;
+    return ok({
+      secret,
+      commitment,
+      commitCall: commitPrep.value,
+      minCommitmentAge: BigInt(minRes.value),
+      maxCommitmentAge: BigInt(maxRes.value),
+      price: quote.value,
+      prepareRegisterCall: async () => {
+        const current = await quoteRegistration(popRules, label, args.owner, payer, origin);
+        if (!current.ok) return current;
+        const prep = await controller.register.prepare(registration, {
+          value: current.value,
+          origin
+        });
+        if (!prep.ok) {
+          return err(
+            new DotNsError("RegistryCall", "controller.register prepare failed", {
+              cause: prep.error
+            })
+          );
+        }
+        return ok(prep.value);
+      }
+    });
+  } catch (cause) {
+    return err(new DotNsError("RegistryCall", "DotNS registration prepare failed", { cause }));
   }
 }
 
-export { deriveContextAlias, verifyContextAlias };
+export { DOTNS_ADDRESSES, DOTNS_REGISTRY_KEYS, DotNsError, POP_STATUS, discoverDotNsAddresses, isDotNsAvailable, prepareDotNsRegistration, resolveDotNs, resolveDotNsAddresses, reverseDotNs, setDotNsRecord, verifyDotNsAddresses };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map