@parity/product-sdk 0.0.0-dev.312.0 → 0.0.0-dev.329.1

package/dist/identity/index.js

@@ -1,10 +1,10 @@
-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 { normalizeDotNsName, isResolvableDotNsName, namehash, isValidDotNsName, stripSuffix, isConsistentDotNsTld, DOT_TLD, dotNsTld } from '../chunk-7GM3HUZF.js';
+export { DOT_NODE, DOT_TLD, accountIdHexToBytes, accountIdToHex, dotNsTld, isConsistentDotNsTld, isResolvableDotNsName, isValidDotNsName, namehash, normalizeDotNsName, resolvePeopleUsernameOwner, stripSuffix } from '../chunk-7GM3HUZF.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 { QUERY_FALLBACK_ORIGIN, createContract } from '@parity/product-sdk-contracts';
 
 // src/identity/dotns-abis.ts
 var DOTNS_REGISTRY_ABI = [
@@ -194,6 +194,31 @@ var DOTNS_PROTOCOL_REGISTRY_ABI = [
     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 };
@@ -217,22 +242,159 @@ var DotNsError = class extends Error {
     this.reason = reason;
   }
 };
-
-// src/identity/dotns-registry.ts
-var log = createLogger("identity:dotns");
+var DOTNS_REGISTRY_KEYS = {
+  registry: "0x7265676973747279000000000000000000000000000000000000000000000000",
+  registrarController: "0x636f6e74726f6c6c657200000000000000000000000000000000000000000000",
+  reverseResolver: "0x726576657273655265736f6c7665720000000000000000000000000000000000",
+  resolver: "0x7265736f6c766572000000000000000000000000000000000000000000000000",
+  popRules: "0x706f7052756c6573000000000000000000000000000000000000000000000000"
+};
 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 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 {
+    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
+  };
+}
+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;
 }
-function sameAddress(a, b) {
-  return typeof a === "string" && typeof b === "string" && a.toLowerCase() === b.toLowerCase();
+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";
@@ -246,20 +408,10 @@ async function resolveTld(opts) {
       )
     );
   }
-  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;
+  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 {
@@ -329,7 +481,9 @@ async function resolveDotNs(name, opts) {
     return err(nameError(name, normalized, tld));
   }
   const node = namehash(normalized, tld);
-  const registryAddr = opts.registryAddress ?? DOTNS_ADDRESSES.registry;
+  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 {
@@ -355,7 +509,7 @@ async function resolveDotNs(name, opts) {
     const owner = ownerRes.value;
     if (isZero(owner)) return ok(null);
     const resolverAddr = resolverRes.value;
-    const forwardAddr = opts.resolverAddress ?? DOTNS_ADDRESSES.resolver;
+    const forwardAddr = addrs.value.resolver;
     if (!sameAddress(resolverAddr, forwardAddr)) {
       return ok({ name: normalized, owner });
     }
@@ -378,7 +532,9 @@ async function resolveDotNs(name, opts) {
   }
 }
 async function reverseDotNs(address, opts) {
-  const reverseAddr = opts.reverseResolverAddress ?? DOTNS_ADDRESSES.reverseResolver;
+  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(
@@ -411,7 +567,9 @@ async function isDotNsAvailable(name, opts) {
     return err(nameError(name, normalized, tld));
   }
   const label = stripSuffix(normalized, tld.suffix);
-  const controllerAddr = opts.registrarControllerAddress ?? DOTNS_ADDRESSES.registrarController;
+  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(
@@ -419,11 +577,7 @@ async function isDotNsAvailable(name, opts) {
       controllerAddr,
       DOTNS_REGISTRAR_CONTROLLER_ABI
     );
-    const popRules = contractOf(
-      opts.runtime,
-      opts.popRulesAddress ?? DOTNS_ADDRESSES.popRules,
-      DOTNS_POP_RULES_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 }),
@@ -467,8 +621,10 @@ async function setDotNsRecord(args, opts) {
     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;
+  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 });
@@ -559,8 +715,10 @@ async function prepareDotNsRegistration(args, opts) {
     );
   }
   const label = stripSuffix(normalized, tld.suffix);
-  const controllerAddr = opts.registrarControllerAddress ?? DOTNS_ADDRESSES.registrarController;
-  const popRulesAddr = opts.popRulesAddress ?? DOTNS_ADDRESSES.popRules;
+  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;
@@ -649,43 +807,7 @@ async function prepareDotNsRegistration(args, opts) {
     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 };
+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