@parity/product-sdk 0.0.0-dev.312.0

package/dist/identity/index.js

@@ -0,0 +1,691 @@
+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 { err, ok } from '@parity/result';
+import { QUERY_FALLBACK_ORIGIN, createContract } from '@parity/product-sdk-contracts';
+import { bytesToHex, randomBytes, blake2b256 } from '@parity/product-sdk-crypto';
+import { ss58ToH160, ss58Decode, ss58Encode, deriveH160 } from '@parity/product-sdk-address';
+import { createLogger } from '@parity/product-sdk-logger';
+
+// 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"
+  }
+];
+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;
+  }
+};
+
+// src/identity/dotns-registry.ts
+var log = createLogger("identity:dotns");
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function contractOf(runtime, address, abi) {
+  return createContract(runtime, address, abi);
+}
+function isZero(addr) {
+  return typeof addr === "string" && addr.toLowerCase() === ZERO_ADDRESS;
+}
+function readOrigin(opts) {
+  return opts.origin ?? QUERY_FALLBACK_ORIGIN;
+}
+function sameAddress(a, b) {
+  return typeof a === "string" && typeof b === "string" && a.toLowerCase() === b.toLowerCase();
+}
+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 address = opts.protocolRegistryAddress ?? DOTNS_ADDRESSES.protocolRegistry;
+  let perAddress = tldCache.get(opts.runtime);
+  if (!perAddress) {
+    perAddress = /* @__PURE__ */ new Map();
+    tldCache.set(opts.runtime, perAddress);
+  }
+  const cached = perAddress.get(address);
+  if (cached) return cached;
+  const pending = readTld(opts, address);
+  perAddress.set(address, pending);
+  pending.then((result) => {
+    if (!result.ok) perAddress?.delete(address);
+  });
+  return pending;
+}
+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 registryAddr = opts.registryAddress ?? DOTNS_ADDRESSES.registry;
+  const origin = readOrigin(opts);
+  log.debug("resolveDotNs", { name: normalized, node, registry: registryAddr });
+  try {
+    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 = opts.resolverAddress ?? DOTNS_ADDRESSES.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 reverseAddr = opts.reverseResolverAddress ?? DOTNS_ADDRESSES.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 controllerAddr = opts.registrarControllerAddress ?? DOTNS_ADDRESSES.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,
+      opts.popRulesAddress ?? DOTNS_ADDRESSES.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 registryAddr = opts.registryAddress ?? DOTNS_ADDRESSES.registry;
+  const resolverAddr = opts.resolverAddress ?? DOTNS_ADDRESSES.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 controllerAddr = opts.registrarControllerAddress ?? DOTNS_ADDRESSES.registrarController;
+  const popRulesAddr = opts.popRulesAddress ?? DOTNS_ADDRESSES.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 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 }));
+  }
+}
+var log2 = 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);
+  log2.debug("Derived context alias", {
+    parentAddress,
+    context,
+    address
+  });
+  return {
+    address,
+    h160Address,
+    parentAddress,
+    context
+  };
+}
+function verifyContextAlias(aliasAddress, parentAddress, context) {
+  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;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { DOTNS_ADDRESSES, DotNsError, POP_STATUS, deriveContextAlias, isDotNsAvailable, prepareDotNsRegistration, resolveDotNs, reverseDotNs, setDotNsRecord, verifyContextAlias };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map