bulletin-deploy 0.7.3 → 0.7.4

package/dist/chunk-M3H3F4FY.js

@@ -1,1048 +0,0 @@
-import {
-  captureWarning,
-  withSpan
-} from "./chunk-BYIVK52G.js";
-import {
-  isTestnetSpecName
-} from "./chunk-JHNW2EKY.js";
-
-// src/dotns.ts
-import crypto from "crypto";
-import { createClient } from "polkadot-api";
-import { getPolkadotSigner } from "polkadot-api/signer";
-import { getWsProvider } from "polkadot-api/ws-provider";
-import { Keyring } from "@polkadot/keyring";
-import { cryptoWaitReady } from "@polkadot/util-crypto";
-import { Binary } from "polkadot-api";
-import {
-  encodeFunctionData,
-  decodeFunctionResult,
-  keccak256,
-  toBytes,
-  formatEther,
-  isAddress,
-  bytesToHex,
-  isHex,
-  toHex,
-  zeroAddress,
-  namehash,
-  concatHex
-} from "viem";
-import { CID } from "multiformats/cid";
-var RPC_ENDPOINTS = [
-  "wss://asset-hub-paseo.dotters.network",
-  "wss://sys.ibp.network/asset-hub-paseo",
-  "wss://pas-rpc.stakeworld.io/assethub"
-];
-var CONTRACTS = {
-  DOTNS_REGISTRAR: "0x329aAA5b6bEa94E750b2dacBa74Bf41291E6c2BD",
-  DOTNS_REGISTRAR_CONTROLLER: "0xd09e0F1c1E6CE8Cf40df929ef4FC778629573651",
-  DOTNS_REGISTRY: "0x4Da0d37aBe96C06ab19963F31ca2DC0412057a6f",
-  DOTNS_RESOLVER: "0x95645C7fD0fF38790647FE13F87Eb11c1DCc8514",
-  DOTNS_CONTENT_RESOLVER: "0x7756DF72CBc7f062e7403cD59e45fBc78bed1cD7",
-  DOTNS_REVERSE_RESOLVER: "0x95D57363B491CF743970c640fe419541386ac8BF",
-  STORE_FACTORY: "0x030296782F4d3046B080BcB017f01837561D9702",
-  POP_RULES: "0x4e8920B1E69d0cEA9b23CBFC87A17Ee6fE02d2d3"
-};
-var DECIMALS = 12n;
-var NATIVE_TO_ETH_RATIO = 1000000n;
-var CONNECTION_TIMEOUT_MS = 3e4;
-var OPERATION_TIMEOUT_MS = 3e5;
-var TX_TIMEOUT_MS = 9e4;
-var TX_CHAIN_TIME_BUDGET_MS = 18e4;
-var TX_WALL_CLOCK_CEILING_MS = 10 * 60 * 1e3;
-var WS_HEARTBEAT_TIMEOUT_MS = 3e5;
-var DOTNS_TX_MAX_ATTEMPTS = 3;
-function classifyTxRetryDecision(err) {
-  const msg = err instanceof Error ? err.message : String(err);
-  const lower = msg.toLowerCase();
-  if (/\bstale\b/.test(lower)) return "retry";
-  if (/"type"\s*:\s*"future"|\binvalid::future\b/.test(lower)) return "retry";
-  if (lower.includes("websocket") || lower.includes("connection") || lower.includes("socket closed") || lower.includes("disconnect")) return "retry";
-  if (lower.includes("timed out") || lower.includes("timeout")) return "retry";
-  return "abort";
-}
-var DEFAULT_MNEMONIC = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
-var _rpcIdCounter = 0;
-async function fetchNonce(rpc, ss58Address) {
-  const WS = globalThis.WebSocket ?? (await import("./wrapper-IFSKR7DG.js")).default;
-  return new Promise((resolve, reject) => {
-    let done = false;
-    const settle = (fn, ...args) => {
-      if (done) return;
-      done = true;
-      clearTimeout(timer);
-      try {
-        ws.close();
-      } catch {
-      }
-      fn(...args);
-    };
-    const timer = setTimeout(() => settle(reject, new Error(`fetchNonce timed out after 8s for ${rpc}`)), 8e3);
-    const ws = new WS(rpc);
-    const id = ++_rpcIdCounter;
-    ws.onopen = () => ws.send(JSON.stringify({ jsonrpc: "2.0", id, method: "system_accountNextIndex", params: [ss58Address] }));
-    ws.onmessage = (e) => {
-      const d = typeof e.data === "string" ? e.data : e.data.toString();
-      const r = JSON.parse(d);
-      if (r.id === id) {
-        r.error ? settle(reject, new Error(r.error.message)) : settle(resolve, r.result);
-      }
-    };
-    ws.onerror = () => settle(reject, new Error(`WebSocket to ${rpc} failed`));
-    ws.onclose = () => settle(reject, new Error(`WebSocket to ${rpc} closed before response`));
-  });
-}
-var ProofOfPersonhoodStatus = {
-  NoStatus: 0,
-  ProofOfPersonhoodLite: 1,
-  ProofOfPersonhoodFull: 2,
-  Reserved: 3
-};
-var DOTNS_REGISTRAR_CONTROLLER_ABI = [
-  { inputs: [{ name: "registration", type: "tuple", components: [{ name: "label", type: "string" }, { name: "owner", type: "address" }, { name: "secret", type: "bytes32" }, { name: "reserved", type: "bool" }] }], name: "makeCommitment", outputs: [{ name: "", type: "bytes32" }], stateMutability: "view", type: "function" },
-  { inputs: [{ name: "commitment", type: "bytes32" }], name: "commit", outputs: [], stateMutability: "nonpayable", type: "function" },
-  { inputs: [], name: "minCommitmentAge", outputs: [{ name: "", type: "uint256" }], stateMutability: "view", type: "function" },
-  { inputs: [{ name: "commitment", type: "bytes32" }], name: "commitments", outputs: [{ name: "", type: "uint256" }], stateMutability: "view", type: "function" },
-  { inputs: [{ name: "registration", type: "tuple", components: [{ name: "label", type: "string" }, { name: "owner", type: "address" }, { name: "secret", type: "bytes32" }, { name: "reserved", type: "bool" }] }], name: "register", outputs: [], stateMutability: "payable", type: "function" }
-];
-var DOTNS_REGISTRAR_ABI = [
-  { inputs: [{ name: "tokenId", type: "uint256" }], name: "ownerOf", outputs: [{ name: "", type: "address" }], stateMutability: "view", type: "function" }
-];
-var POP_RULES_ABI = [
-  { inputs: [{ name: "name", type: "string" }], name: "classifyName", outputs: [{ name: "requirement", type: "uint8" }, { name: "message", type: "string" }], stateMutability: "pure", type: "function" },
-  { inputs: [{ name: "name", type: "string" }], name: "price", outputs: [{ name: "", type: "uint256" }], stateMutability: "view", type: "function" },
-  { inputs: [{ name: "", type: "address" }], name: "userPopStatus", outputs: [{ name: "", type: "uint8" }], stateMutability: "view", type: "function" },
-  { inputs: [{ name: "status", type: "uint8" }], name: "setUserPopStatus", outputs: [], stateMutability: "nonpayable", type: "function" },
-  { inputs: [{ name: "baseName", type: "string" }], name: "isBaseNameReserved", outputs: [{ name: "isReserved", type: "bool" }, { name: "reservationOwner", type: "address" }, { name: "expiryTimestamp", type: "uint64" }], stateMutability: "view", type: "function" }
-];
-var DOTNS_REGISTRY_ABI = [
-  { inputs: [{ name: "record", type: "tuple", components: [{ name: "parentNode", type: "bytes32" }, { name: "subLabel", type: "string" }, { name: "parentLabel", type: "string" }, { name: "owner", type: "address" }] }], name: "setSubnodeOwner", outputs: [{ name: "subnode", type: "bytes32" }], stateMutability: "nonpayable", type: "function" },
-  { inputs: [{ name: "node", type: "bytes32" }, { name: "newResolver", type: "address" }], name: "setResolver", outputs: [], stateMutability: "nonpayable", type: "function" },
-  { inputs: [{ name: "node", type: "bytes32" }], name: "owner", outputs: [{ name: "", type: "address" }], stateMutability: "view", type: "function" }
-];
-var DOTNS_CONTENT_RESOLVER_ABI = [
-  { inputs: [{ name: "node", type: "bytes32" }, { name: "hash", type: "bytes" }], name: "setContenthash", outputs: [], stateMutability: "nonpayable", type: "function" },
-  { inputs: [{ name: "node", type: "bytes32" }], name: "contenthash", outputs: [{ name: "", type: "bytes" }], stateMutability: "view", type: "function" }
-];
-function convertToHexString(value) {
-  if (!value) return "0x";
-  if (typeof value?.asHex === "function") return value.asHex();
-  if (typeof value?.toHex === "function") return value.toHex();
-  if (typeof value === "string" && isHex(value)) return value;
-  if (value instanceof Uint8Array) return bytesToHex(value);
-  try {
-    return toHex(value);
-  } catch {
-    return "0x";
-  }
-}
-function convertToBigInt(value, fallback = 0n) {
-  try {
-    if (typeof value === "bigint") return value;
-    if (typeof value === "number") return BigInt(value);
-    if (typeof value === "string") return BigInt(value);
-    if (value && typeof value.toString === "function") return BigInt(value.toString());
-    return fallback;
-  } catch {
-    return fallback;
-  }
-}
-function normalizeWeight(weight) {
-  const referenceTime = weight?.ref_time ?? weight?.refTime ?? 0;
-  const proofSize = weight?.proof_size ?? weight?.proofSize ?? 0;
-  return { referenceTime: convertToBigInt(referenceTime, 0n), proofSize: convertToBigInt(proofSize, 0n) };
-}
-function extractStorageDepositCharge(rawStorageDeposit) {
-  if (!rawStorageDeposit) return 0n;
-  if (typeof rawStorageDeposit?.isCharge === "boolean") {
-    if (rawStorageDeposit.isCharge && rawStorageDeposit.asCharge != null) return convertToBigInt(rawStorageDeposit.asCharge, 0n);
-    return 0n;
-  }
-  if (rawStorageDeposit.charge != null) return convertToBigInt(rawStorageDeposit.charge, 0n);
-  if (rawStorageDeposit.Charge != null) return convertToBigInt(rawStorageDeposit.Charge, 0n);
-  if (rawStorageDeposit.value != null) return convertToBigInt(rawStorageDeposit.value, 0n);
-  return 0n;
-}
-function unwrapExecutionResult(rawResult) {
-  if (!rawResult) return { ok: null, err: null, successFlag: null };
-  if (typeof rawResult.success === "boolean") {
-    return rawResult.success ? { ok: rawResult.value ?? null, err: null, successFlag: true } : { ok: null, err: rawResult.error ?? rawResult.value ?? null, successFlag: false };
-  }
-  if (typeof rawResult.isOk === "boolean") {
-    return rawResult.isOk ? { ok: rawResult.value ?? null, err: null, successFlag: true } : { ok: null, err: rawResult.value ?? null, successFlag: false };
-  }
-  if (rawResult.ok != null) return { ok: rawResult.ok, err: null, successFlag: true };
-  if (rawResult.err != null) return { ok: null, err: rawResult.err, successFlag: false };
-  return { ok: null, err: rawResult, successFlag: null };
-}
-function withTimeout(promise, timeoutMs, operationName) {
-  let timer;
-  const timeoutPromise = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error(`${operationName} timed out after ${timeoutMs}ms`)), timeoutMs);
-  });
-  return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timer));
-}
-var DOT_NODE = "0x3fce7d1364a893e213bc4212792b517ffc88f5b13b86c8ef9c8d390c3a1370ce";
-function convertWeiToNative(weiValue) {
-  return weiValue / NATIVE_TO_ETH_RATIO;
-}
-function computeDomainTokenId(label) {
-  const labelhash = keccak256(toBytes(label));
-  const node = keccak256(concatHex([DOT_NODE, labelhash]));
-  return BigInt(node);
-}
-function countTrailingDigits(label) {
-  let count = 0;
-  for (let i = label.length - 1; i >= 0; i--) {
-    const code = label.charCodeAt(i);
-    if (code >= 48 && code <= 57) count++;
-    else break;
-  }
-  return count;
-}
-function stripTrailingDigits(label) {
-  return label.replace(/\d+$/, "").replace(/-$/, "");
-}
-function sanitizeDomainLabel(label) {
-  const trailingDigitCount = countTrailingDigits(label);
-  if (trailingDigitCount > 2) {
-    const sanitized = stripTrailingDigits(label) + label.slice(-2);
-    console.log(`   Domain label sanitized: "${label}" \u2192 "${sanitized}" (stripped excess trailing digits)`);
-    return sanitized;
-  }
-  return label;
-}
-function validateDomainLabel(label) {
-  if (!/^[a-z0-9-]{3,}$/.test(label)) throw new Error("Invalid domain label: must contain only lowercase letters, digits, and hyphens, min 3 chars");
-  if (label.startsWith("-") || label.endsWith("-")) throw new Error("Invalid domain label: cannot start or end with hyphen");
-  return sanitizeDomainLabel(label);
-}
-function isCommitmentMature(chainNowSeconds, commitTimestampSeconds, minimumAgeSeconds) {
-  return chainNowSeconds > commitTimestampSeconds + minimumAgeSeconds;
-}
-function classifyDotnsLabel(label) {
-  const totalLength = label.length;
-  const trailingDigits = countTrailingDigits(label);
-  if (trailingDigits > 2) {
-    return {
-      status: ProofOfPersonhoodStatus.Reserved,
-      message: `Name has ${trailingDigits} trailing digits; DotNS allows at most 2 trailing digits. Use a base name with 0-2 trailing digits.`
-    };
-  }
-  const baselength = totalLength - trailingDigits;
-  if (baselength <= 5) {
-    return {
-      status: ProofOfPersonhoodStatus.Reserved,
-      message: `Base name is ${baselength} char${baselength === 1 ? "" : "s"}; DotNS reserves base names of 5 chars or fewer for governance (PopRules). Use a base name of 6+ chars \u2014 role prefixes like 'rc<N>pool' / 'rc<N>dir' / 'nightly-<role>' work well.`
-    };
-  }
-  if (baselength >= 6 && baselength <= 8) {
-    if (trailingDigits === 2) return { status: ProofOfPersonhoodStatus.ProofOfPersonhoodLite, message: "Requires Light personhood verification" };
-    return { status: ProofOfPersonhoodStatus.ProofOfPersonhoodFull, message: "Requires Full personhood verification" };
-  }
-  if (trailingDigits === 2) return { status: ProofOfPersonhoodStatus.NoStatus, message: "Available to all" };
-  return { status: ProofOfPersonhoodStatus.ProofOfPersonhoodFull, message: "Requires Full personhood verification" };
-}
-function canRegister(requiredStatus, userStatus, trailingDigits) {
-  if (requiredStatus === ProofOfPersonhoodStatus.Reserved) return false;
-  if (requiredStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodFull) {
-    return userStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodFull;
-  }
-  if (requiredStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodLite) {
-    return userStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodLite || userStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodFull;
-  }
-  return trailingDigits !== 0 && userStatus !== ProofOfPersonhoodStatus.ProofOfPersonhoodLite;
-}
-function simulateUserStatus(currentStatus, requiredStatus, options) {
-  const max = (a, b) => a > b ? a : b;
-  if (options.explicitStatus !== void 0) {
-    return max(currentStatus, options.explicitStatus);
-  }
-  if (requiredStatus === ProofOfPersonhoodStatus.NoStatus && currentStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodLite && options.isTestnet) {
-    return ProofOfPersonhoodStatus.ProofOfPersonhoodFull;
-  }
-  if (requiredStatus !== ProofOfPersonhoodStatus.NoStatus) {
-    return max(currentStatus, requiredStatus);
-  }
-  return currentStatus;
-}
-function parseDomainName(input) {
-  const name = input.replace(/\.dot$/, "");
-  const parts = name.split(".");
-  if (parts.length === 1) {
-    validateDomainLabel(parts[0]);
-    return { isSubdomain: false, label: parts[0], sublabel: null, parentLabel: null, fullName: `${parts[0]}.dot` };
-  }
-  if (parts.length === 2) {
-    validateDomainLabel(parts[0]);
-    validateDomainLabel(parts[1]);
-    return { isSubdomain: true, label: name, sublabel: parts[0], parentLabel: parts[1], fullName: `${name}.dot` };
-  }
-  throw new Error(`Invalid domain: only one level of subdomains supported (got ${parts.length} labels)`);
-}
-function parseProofOfPersonhoodStatus(status) {
-  const s = (status ?? "none").toLowerCase();
-  if (s === "none" || s === "nostatus") return ProofOfPersonhoodStatus.NoStatus;
-  if (s === "lite" || s === "poplite") return ProofOfPersonhoodStatus.ProofOfPersonhoodLite;
-  if (s === "full" || s === "popfull") return ProofOfPersonhoodStatus.ProofOfPersonhoodFull;
-  throw new Error("Invalid status. Use none, lite, or full");
-}
-function popStatusName(status) {
-  return Object.keys(ProofOfPersonhoodStatus).find((k) => ProofOfPersonhoodStatus[k] === status) ?? String(status);
-}
-var ReviveClientWrapper = class _ReviveClientWrapper {
-  static DRY_RUN_STORAGE_LIMIT = 18446744073709551615n;
-  static DRY_RUN_WEIGHT_LIMIT = { ref_time: 18446744073709551615n, proof_size: 18446744073709551615n };
-  client;
-  mappedAccounts;
-  constructor(client) {
-    this.client = client;
-    this.mappedAccounts = /* @__PURE__ */ new Set();
-  }
-  async getEvmAddress(substrateAddress) {
-    if (isAddress(substrateAddress)) return substrateAddress;
-    const address = await this.client.apis.ReviveApi.address(substrateAddress);
-    return address.asHex();
-  }
-  async performDryRunCall(originSubstrateAddress, contractAddress, value, encodedData) {
-    if (isAddress(originSubstrateAddress)) throw new Error("performDryRunCall requires SS58 Substrate address, not EVM H160 address");
-    const executionResults = await this.client.apis.ReviveApi.call(originSubstrateAddress, Binary.fromHex(contractAddress), value, _ReviveClientWrapper.DRY_RUN_WEIGHT_LIMIT, _ReviveClientWrapper.DRY_RUN_STORAGE_LIMIT, Binary.fromHex(encodedData));
-    const { ok, err, successFlag } = unwrapExecutionResult(executionResults.result);
-    const flags = ok?.flags ? convertToBigInt(ok.flags, 0n) : 0n;
-    const returnData = convertToHexString(ok?.data);
-    const didRevert = ok ? (flags & 1n) === 1n : true;
-    const gasConsumed = normalizeWeight(executionResults.weight_consumed);
-    const gasRequired = normalizeWeight(executionResults.weight_required ?? executionResults.weight_consumed);
-    const storageDepositValue = extractStorageDepositCharge(executionResults.storage_deposit);
-    const isOk = !!ok && !didRevert;
-    const isErr = !ok || didRevert || !!err || (typeof successFlag === "boolean" ? !successFlag : false);
-    return { gasConsumed, gasRequired, storageDeposit: { value: storageDepositValue }, result: { isOk, isErr, value: { data: ok ? returnData : "0x", flags: ok ? flags : 1n } } };
-  }
-  async estimateGasForCall(originSubstrateAddress, contractAddress, value, encodedData) {
-    const result = await this.performDryRunCall(originSubstrateAddress, contractAddress, value, encodedData);
-    if (!result.result.isOk) return { success: false, gasConsumed: result.gasConsumed, storageDeposit: result.storageDeposit.value, gasRequired: result.gasRequired, revertData: result.result.value.data, revertFlags: result.result.value.flags };
-    return { success: true, gasConsumed: result.gasConsumed, storageDeposit: result.storageDeposit.value, gasRequired: result.gasRequired };
-  }
-  async checkIfAccountMapped(substrateAddress) {
-    try {
-      const evmAddress = await this.getEvmAddress(substrateAddress);
-      const key = Binary.fromHex(evmAddress);
-      const mappedAccount = await this.client.query.Revive.OriginalAccount.getValue(key);
-      return mappedAccount !== null && mappedAccount !== void 0;
-    } catch {
-      return false;
-    }
-  }
-  async ensureAccountMapped(substrateAddress, signer) {
-    if (isAddress(substrateAddress)) throw new Error("ensureAccountMapped requires SS58 Substrate address, not EVM H160 address");
-    if (this.mappedAccounts.has(substrateAddress)) return;
-    const isMapped = await this.checkIfAccountMapped(substrateAddress);
-    if (isMapped) {
-      this.mappedAccounts.add(substrateAddress);
-      return;
-    }
-    try {
-      await this.signAndSubmitWithRetry(() => this.client.tx.Revive.map_account(), signer, () => {
-      }, "Revive.map_account");
-      this.mappedAccounts.add(substrateAddress);
-    } catch (error) {
-      const errorMessage = error?.message || String(error);
-      if (errorMessage.includes("AccountAlreadyMapped")) {
-        this.mappedAccounts.add(substrateAddress);
-        return;
-      }
-      throw error;
-    }
-  }
-  // `nonceFallback` is accepted for call-site compatibility but no longer
-  // used: a nonce-increment shortcut can't distinguish our tx from a
-  // concurrent/zombie tx on the same account (Alice's default mnemonic is
-  // widely shared on testnets), producing false-positive resolution. The
-  // chain-time deadline below is the reliability knob instead.
-  signAndSubmitExtrinsic(extrinsic, signer, statusCallback, _opts = {}) {
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      let deadlinePoller = null;
-      let sub;
-      const finish = (fn) => (...args) => {
-        if (!settled) {
-          settled = true;
-          if (deadlinePoller) clearInterval(deadlinePoller);
-          try {
-            sub?.unsubscribe();
-          } catch {
-          }
-          fn(...args);
-        }
-      };
-      const startWallClockMs = Date.now();
-      let startChainTimeMs = null;
-      deadlinePoller = setInterval(async () => {
-        if (settled) return;
-        try {
-          if (Date.now() - startWallClockMs > TX_WALL_CLOCK_CEILING_MS) {
-            statusCallback("failed");
-            finish(reject)(new Error(`Transaction did not settle within ${TX_WALL_CLOCK_CEILING_MS / 1e3}s wall-clock (chain may be stalled)`));
-            return;
-          }
-          const chainNowMs = Number(await this.client.query.Timestamp.Now.getValue());
-          if (startChainTimeMs === null) startChainTimeMs = chainNowMs;
-          const chainElapsedMs = chainNowMs - startChainTimeMs;
-          if (chainElapsedMs > TX_CHAIN_TIME_BUDGET_MS) {
-            statusCallback("failed");
-            finish(reject)(new Error(`Transaction not included after ${Math.floor(chainElapsedMs / 1e3)}s of chain progress (budget=${TX_CHAIN_TIME_BUDGET_MS / 1e3}s)`));
-            return;
-          }
-        } catch {
-        }
-      }, 6e3);
-      try {
-        sub = extrinsic.signSubmitAndWatch(signer, { mortality: { mortal: true, period: 256 } }).subscribe({
-          next: (event) => {
-            const transactionHash = event.txHash?.toString();
-            switch (event.type) {
-              case "signed":
-                statusCallback("signing");
-                break;
-              case "broadcasted":
-                statusCallback("broadcasting");
-                break;
-              case "txBestBlocksState":
-                if (event.found) statusCallback("included");
-                break;
-              case "finalized":
-                if (event.dispatchError) {
-                  statusCallback("failed");
-                  finish(reject)(new Error(`Transaction failed: ${event.dispatchError.toString()}`));
-                  return;
-                }
-                statusCallback("finalized");
-                finish(resolve)(transactionHash);
-                return;
-              case "invalid":
-              case "dropped":
-                statusCallback("failed");
-                finish(reject)(new Error(`Transaction ${event.type}`));
-                return;
-            }
-          },
-          error: (error) => {
-            statusCallback("failed");
-            finish(reject)(error);
-          }
-        });
-      } catch (error) {
-        statusCallback("failed");
-        finish(reject)(error);
-      }
-    });
-  }
-  // Wrapper around signAndSubmitExtrinsic that retries on transient errors
-  // (Stale, Future, connection, timeout — see classifyTxRetryDecision). The
-  // extrinsic is rebuilt per attempt via `buildExtrinsic` so polkadot-api
-  // assigns a fresh nonce + mortality window — same pattern as
-  // pool.ts:submitAliceTxWithRetry. `label` is the human-readable op name
-  // used in retry log lines.
-  async signAndSubmitWithRetry(buildExtrinsic, signer, statusCallback, label, opts = {}) {
-    let lastError;
-    for (let attempt = 1; attempt <= DOTNS_TX_MAX_ATTEMPTS; attempt++) {
-      try {
-        return await this.signAndSubmitExtrinsic(buildExtrinsic(), signer, statusCallback, opts);
-      } catch (e) {
-        lastError = e;
-        const decision = classifyTxRetryDecision(e);
-        if (decision === "abort" || attempt === DOTNS_TX_MAX_ATTEMPTS) break;
-        const short = (e?.message ?? String(e)).slice(0, 80);
-        console.log(`   ${label}: attempt ${attempt}/${DOTNS_TX_MAX_ATTEMPTS} failed (${short}), retrying...`);
-      }
-    }
-    throw lastError instanceof Error ? lastError : new Error(String(lastError));
-  }
-  async submitTransaction(contractAddress, value, encodedData, signerSubstrateAddress, signer, statusCallback, { rpc, useNoncePolling } = {}) {
-    await this.ensureAccountMapped(signerSubstrateAddress, signer);
-    const gasEstimate = await this.estimateGasForCall(signerSubstrateAddress, contractAddress, value, encodedData);
-    if (!gasEstimate.success) throw new Error(`Contract execution would revert: ${gasEstimate.revertData ?? "0x"}`);
-    const weightLimit = { proof_size: gasEstimate.gasRequired.proofSize, ref_time: gasEstimate.gasRequired.referenceTime };
-    const minimumStorageDeposit = 2000000000000n;
-    let storageDepositLimit = gasEstimate.storageDeposit === 0n ? minimumStorageDeposit : gasEstimate.storageDeposit * 120n / 100n;
-    if (storageDepositLimit < minimumStorageDeposit) storageDepositLimit = minimumStorageDeposit;
-    const buildExtrinsic = () => this.client.tx.Revive.call({ dest: Binary.fromHex(contractAddress), value, weight_limit: weightLimit, storage_deposit_limit: storageDepositLimit, data: Binary.fromHex(encodedData) });
-    let nonceFallback;
-    if (useNoncePolling && rpc) {
-      try {
-        const nonce = await fetchNonce(rpc, signerSubstrateAddress);
-        nonceFallback = { rpc, senderSS58: signerSubstrateAddress, expectedNonce: nonce };
-      } catch {
-      }
-    }
-    return await this.signAndSubmitWithRetry(buildExtrinsic, signer, statusCallback, "Revive.call", { nonceFallback });
-  }
-};
-var DotNS = class {
-  client;
-  clientWrapper;
-  rpc;
-  substrateAddress;
-  evmAddress;
-  signer;
-  connected;
-  constructor() {
-    this.client = null;
-    this.clientWrapper = null;
-    this.rpc = null;
-    this.substrateAddress = null;
-    this.evmAddress = null;
-    this.signer = null;
-    this.connected = false;
-  }
-  async connect(options = {}) {
-    const endpoints = options.rpc ? [options.rpc] : process.env.DOTNS_RPC ? [process.env.DOTNS_RPC] : RPC_ENDPOINTS;
-    let lastError;
-    for (const rpc of endpoints) {
-      try {
-        console.log(`   Connecting to: ${rpc}`);
-        this.rpc = rpc;
-        this.client = createClient(getWsProvider(rpc, { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS }));
-        const unsafeApi = this.client.getUnsafeApi();
-        this.clientWrapper = new ReviveClientWrapper(unsafeApi);
-        if (options.signer && options.signerAddress) {
-          this.signer = options.signer;
-          this.substrateAddress = options.signerAddress;
-        } else {
-          const source = options.keyUri || options.mnemonic || process.env.DOTNS_KEY_URI || process.env.DOTNS_MNEMONIC || process.env.MNEMONIC || DEFAULT_MNEMONIC;
-          const isKeyUri = Boolean(options.keyUri || process.env.DOTNS_KEY_URI);
-          await cryptoWaitReady();
-          const keyring = new Keyring({ type: "sr25519" });
-          const uri = options.derivationPath && !isKeyUri ? `${source}${options.derivationPath}` : source;
-          const account = isKeyUri || options.derivationPath ? keyring.addFromUri(uri) : keyring.addFromMnemonic(source);
-          this.substrateAddress = account.address;
-          this.signer = getPolkadotSigner(account.publicKey, "Sr25519", async (input) => account.sign(input));
-        }
-        this.evmAddress = await withTimeout(
-          this.clientWrapper.getEvmAddress(this.substrateAddress),
-          CONNECTION_TIMEOUT_MS,
-          `Connect to ${rpc}`
-        );
-        console.log(`   SS58 Address: ${this.substrateAddress}`);
-        console.log(`   H160 Address: ${this.evmAddress}`);
-        await this.clientWrapper.ensureAccountMapped(this.substrateAddress, this.signer);
-        this.connected = true;
-        return this;
-      } catch (e) {
-        lastError = e;
-        captureWarning("DotNS RPC endpoint failed, trying next", { endpoint: rpc, error: e.message?.slice(0, 200), remainingEndpoints: endpoints.length - endpoints.indexOf(rpc) - 1 });
-        console.log(`   Failed to connect to ${rpc}: ${e.message}`);
-        if (this.client) {
-          try {
-            this.client.destroy();
-          } catch {
-          }
-          this.client = null;
-        }
-      }
-    }
-    throw new Error(`All RPC endpoints failed. Last error: ${lastError?.message}`);
-  }
-  ensureConnected() {
-    if (!this.connected) throw new Error("Not connected. Call connect() first.");
-  }
-  // Returns true when the DotNS chain (Asset Hub) reports a testnet spec_name.
-  // Used to gate test-only behaviors like self-granting Full PoP on a Lite
-  // signer for a NoStatus label. Mainnet must never self-grant — Personhood
-  // is attested, not self-declared, there.
-  _testnetCache = null;
-  async isTestnet() {
-    if (this._testnetCache !== null) return this._testnetCache;
-    this.ensureConnected();
-    try {
-      const version = await this.clientWrapper.client.constants.System.Version();
-      const raw = version?.spec_name ?? version?.specName;
-      const specName = typeof raw === "string" ? raw : raw?.asText?.() ?? String(raw ?? "");
-      this._testnetCache = isTestnetSpecName(specName);
-    } catch {
-      this._testnetCache = false;
-    }
-    return this._testnetCache;
-  }
-  async contractCall(contractAddress, contractAbi, functionName, args = []) {
-    this.ensureConnected();
-    const encodedCallData = encodeFunctionData({ abi: contractAbi, functionName, args });
-    const callResult = await this.clientWrapper.performDryRunCall(this.substrateAddress, contractAddress, 0n, encodedCallData);
-    if (!callResult.result.isOk) {
-      const errorData = callResult.result.value;
-      const flags = errorData?.flags ?? 0n;
-      const revertData = errorData?.data ?? "0x";
-      const isRevert = (flags & 1n) === 1n;
-      if (isRevert) throw new Error(`Contract reverted (flags=${flags}) with data: ${revertData}`);
-      throw new Error(`Contract call failed (flags=${flags}) with data: ${revertData}`);
-    }
-    return decodeFunctionResult({ abi: contractAbi, functionName, data: callResult.result.value.data });
-  }
-  async contractTransaction(contractAddress, value, contractAbi, functionName, args = [], statusCallback = () => {
-  }, { useNoncePolling } = {}) {
-    this.ensureConnected();
-    const encodedCallData = encodeFunctionData({ abi: contractAbi, functionName, args });
-    return await withTimeout(this.clientWrapper.submitTransaction(contractAddress, value, encodedCallData, this.substrateAddress, this.signer, statusCallback, { rpc: this.rpc, useNoncePolling }), OPERATION_TIMEOUT_MS, functionName);
-  }
-  async checkOwnership(label, ownerAddress = null) {
-    this.ensureConnected();
-    const checkAddress = ownerAddress || this.evmAddress;
-    const tokenId = computeDomainTokenId(label);
-    try {
-      const owner = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR, DOTNS_REGISTRAR_ABI, "ownerOf", [tokenId]), 3e4, "ownerOf");
-      const owned = owner.toLowerCase() === checkAddress.toLowerCase();
-      return { owned, owner };
-    } catch {
-      return { owned: false, owner: null };
-    }
-  }
-  async classifyName(label) {
-    this.ensureConnected();
-    console.log(`
-   Classifying name via PopOracle...`);
-    const result = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "classifyName", [label]), 3e4, "classifyName");
-    const requiredStatus = typeof result[0] === "bigint" ? Number(result[0]) : result[0];
-    const message = result[1];
-    console.log(`   Required status: ${popStatusName(requiredStatus)}`);
-    console.log(`   Message: ${message}`);
-    return { requiredStatus, message };
-  }
-  async getUserPopStatus(ownerAddress = null) {
-    this.ensureConnected();
-    const checkAddress = ownerAddress || this.evmAddress;
-    const result = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "userPopStatus", [checkAddress]), 3e4, "userPopStatus");
-    return typeof result === "bigint" ? Number(result) : result;
-  }
-  async setUserPopStatus(status) {
-    this.ensureConnected();
-    console.log(`
-   Checking current PoP status...`);
-    const currentStatus = await this.getUserPopStatus();
-    const currentStatusName = popStatusName(currentStatus);
-    const desiredStatusName = popStatusName(status);
-    console.log(`   Current: ${currentStatusName}`);
-    console.log(`   Desired: ${desiredStatusName}`);
-    if (currentStatus === status) {
-      console.log(`   Status already set, skipping update`);
-      return;
-    }
-    if (currentStatus > status) {
-      console.log(`   Current status already satisfies desired, skipping downgrade`);
-      return;
-    }
-    console.log(`   Setting PoP status to ${desiredStatusName}...`);
-    const txHash = await this.contractTransaction(CONTRACTS.POP_RULES, 0n, POP_RULES_ABI, "setUserPopStatus", [status], (s) => console.log(`      ${s}`));
-    console.log(`   Tx: ${txHash}`);
-  }
-  async ensureNotRegistered(label) {
-    this.ensureConnected();
-    console.log(`
-   Checking availability of ${label}.dot...`);
-    const tokenId = computeDomainTokenId(label);
-    try {
-      const owner = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR, DOTNS_REGISTRAR_ABI, "ownerOf", [tokenId]), 3e4, "Availability check");
-      if (owner !== zeroAddress) throw new Error(`Domain ${label}.dot already owned by ${owner}`);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (errorMessage.includes("already owned")) throw error;
-    }
-    console.log(`   ${label}.dot is available`);
-  }
-  async generateCommitment(label, includeReverse = false) {
-    this.ensureConnected();
-    console.log(`
-   Generating commitment hash...`);
-    label = validateDomainLabel(label);
-    const secret = `0x${crypto.randomBytes(32).toString("hex")}`;
-    const registration = { label, owner: this.evmAddress, secret, reserved: includeReverse };
-    const commitment = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "makeCommitment", [registration]), 3e4, "Commitment generation");
-    console.log(`   Commitment: ${commitment}`);
-    return { commitment, registration };
-  }
-  async submitCommitment(commitment) {
-    this.ensureConnected();
-    console.log(`
-   Submitting commitment...`);
-    const txHash = await this.contractTransaction(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, 0n, DOTNS_REGISTRAR_CONTROLLER_ABI, "commit", [commitment], (s) => console.log(`      ${s}`));
-    console.log(`   Tx: ${txHash}`);
-    console.log(`   Committed at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
-  }
-  async waitForCommitmentAge(commitment) {
-    this.ensureConnected();
-    const POLL_TIMEOUT_MS = 9e4;
-    const POLL_INTERVAL_MS = 3e3;
-    console.log(`
-   Reading minimum commitment age...`);
-    const [minimumAge, initialCommitTimestamp] = await Promise.all([
-      withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "minCommitmentAge", []), 3e4, "minCommitmentAge"),
-      withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "commitments", [commitment]), 3e4, "commitments")
-    ]);
-    const minimumAgeSeconds = typeof minimumAge === "bigint" ? Number(minimumAge) : minimumAge;
-    const commitTimestamp = typeof initialCommitTimestamp === "bigint" ? Number(initialCommitTimestamp) : initialCommitTimestamp;
-    if (commitTimestamp === 0) {
-      throw new Error("Commitment not found on-chain. It may not have been included in a block yet.");
-    }
-    console.log(`   Minimum commitment age: ${minimumAgeSeconds}s`);
-    console.log(`   Commitment stored on-chain (timestamp: ${commitTimestamp})`);
-    console.log(`   Waiting for on-chain block.timestamp > ${commitTimestamp + minimumAgeSeconds}...`);
-    const pollDeadline = Date.now() + POLL_TIMEOUT_MS;
-    while (Date.now() < pollDeadline) {
-      const nowMs = await this.clientWrapper.client.query.Timestamp.Now.getValue();
-      const chainNowSeconds = Math.floor(Number(nowMs) / 1e3);
-      if (isCommitmentMature(chainNowSeconds, commitTimestamp, minimumAgeSeconds)) {
-        console.log(`   Commitment age requirement met (chain.now=${chainNowSeconds}, target>${commitTimestamp + minimumAgeSeconds})`);
-        return;
-      }
-      const remaining = Math.ceil((pollDeadline - Date.now()) / 1e3);
-      console.log(`   Chain time ${chainNowSeconds}, waiting for > ${commitTimestamp + minimumAgeSeconds} (${remaining}s left)...`);
-      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-    }
-    throw new Error(`Commitment still too new after ${POLL_TIMEOUT_MS / 1e3}s of polling chain time. The chain may be stalled.`);
-  }
-  async getPriceAndValidate(label) {
-    this.ensureConnected();
-    console.log(`
-   Checking price and eligibility...`);
-    label = validateDomainLabel(label);
-    const baseName = stripTrailingDigits(label);
-    const reservationInfo = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "isBaseNameReserved", [baseName]), 3e4, "isBaseNameReserved");
-    const [isReserved, reservationOwner] = reservationInfo;
-    if (isReserved && reservationOwner.toLowerCase() !== this.evmAddress.toLowerCase()) throw new Error("Base name reserved for original Lite registrant");
-    const classificationResult = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "classifyName", [label]), 3e4, "classifyName");
-    const requiredStatus = typeof classificationResult[0] === "bigint" ? Number(classificationResult[0]) : classificationResult[0];
-    const message = classificationResult[1];
-    const userStatus = await this.getUserPopStatus();
-    if (requiredStatus === ProofOfPersonhoodStatus.Reserved) throw new Error(message);
-    if (requiredStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodFull) {
-      if (userStatus !== ProofOfPersonhoodStatus.ProofOfPersonhoodFull) throw new Error("Requires Full Personhood verification");
-    } else if (requiredStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodLite) {
-      if (userStatus !== ProofOfPersonhoodStatus.ProofOfPersonhoodLite && userStatus !== ProofOfPersonhoodStatus.ProofOfPersonhoodFull) throw new Error("Requires Personhood Lite verification");
-    } else {
-      const trailingDigitCount = countTrailingDigits(label);
-      if (trailingDigitCount === 0 || userStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodLite) {
-        throw new Error("Personhood Lite cannot register base names \u2014 this name class requires a Full or NoStatus signer");
-      }
-    }
-    const priceRaw = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "price", [label]), 3e4, "price");
-    const priceWei = typeof priceRaw === "bigint" ? priceRaw : BigInt(priceRaw);
-    const requiredStatusName = popStatusName(requiredStatus);
-    const userStatusName = popStatusName(userStatus);
-    console.log(`   Required status: ${requiredStatusName}`);
-    console.log(`   User status: ${userStatusName}`);
-    console.log(`   Price: ${formatEther(priceWei)} PAS`);
-    return { priceWei, requiredStatus, userStatus, message };
-  }
-  async finalizeRegistration(registration, priceWei) {
-    this.ensureConnected();
-    console.log(`
-   Finalizing registration for ${registration.label}.dot...`);
-    const bufferedPaymentWei = priceWei * 110n / 100n;
-    const bufferedPaymentNative = convertWeiToNative(bufferedPaymentWei);
-    console.log(`   Oracle price: ${formatEther(priceWei)} PAS`);
-    console.log(`   Paying: ${formatEther(bufferedPaymentWei)} PAS`);
-    const txHash = await this.contractTransaction(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, bufferedPaymentNative, DOTNS_REGISTRAR_CONTROLLER_ABI, "register", [registration], (s) => console.log(`      ${s}`));
-    console.log(`   Tx: ${txHash}`);
-  }
-  async verifyOwnership(label) {
-    this.ensureConnected();
-    console.log(`
-   Verifying ownership...`);
-    const tokenId = computeDomainTokenId(label);
-    const actualOwner = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR, DOTNS_REGISTRAR_ABI, "ownerOf", [tokenId]), 3e4, "ownerOf");
-    if (actualOwner.toLowerCase() !== this.evmAddress.toLowerCase()) {
-      console.log(`   Expected: ${this.evmAddress}`);
-      console.log(`   Actual: ${actualOwner}`);
-      throw new Error(`Owner mismatch for ${label}.dot`);
-    }
-    console.log(`   Owner: ${actualOwner}`);
-  }
-  async getContenthash(domainName) {
-    this.ensureConnected();
-    const node = namehash(`${domainName}.dot`);
-    const result = await withTimeout(
-      this.contractCall(CONTRACTS.DOTNS_CONTENT_RESOLVER, DOTNS_CONTENT_RESOLVER_ABI, "contenthash", [node]),
-      3e4,
-      "contenthash"
-    );
-    return typeof result === "string" ? result : result?.toString?.() ?? String(result);
-  }
-  async checkSubdomainOwnership(sublabel, parentLabel) {
-    this.ensureConnected();
-    const node = namehash(`${sublabel}.${parentLabel}.dot`);
-    try {
-      const owner = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRY, DOTNS_REGISTRY_ABI, "owner", [node]), 3e4, "owner");
-      if (!owner || owner === zeroAddress) return { owned: false, owner: null };
-      const owned = owner.toLowerCase() === this.evmAddress.toLowerCase();
-      return { owned, owner };
-    } catch {
-      return { owned: false, owner: null };
-    }
-  }
-  async registerSubdomain(sublabel, parentLabel) {
-    return withSpan("deploy.dotns.register-subdomain", `2a. register ${sublabel}.${parentLabel}.dot`, {}, async () => {
-      this.ensureConnected();
-      console.log(`
-   Registering subdomain ${sublabel}.${parentLabel}.dot...`);
-      const parentNode = namehash(`${parentLabel}.dot`);
-      const subnodeRecord = { parentNode, subLabel: sublabel, parentLabel, owner: this.evmAddress };
-      const txHash = await this.contractTransaction(CONTRACTS.DOTNS_REGISTRY, 0n, DOTNS_REGISTRY_ABI, "setSubnodeOwner", [subnodeRecord], (s) => console.log(`      ${s}`), { useNoncePolling: true });
-      console.log(`   Tx: ${txHash}`);
-      console.log(`   Setting resolver...`);
-      const subnodeNode = namehash(`${sublabel}.${parentLabel}.dot`);
-      const resolverTxHash = await this.contractTransaction(CONTRACTS.DOTNS_REGISTRY, 0n, DOTNS_REGISTRY_ABI, "setResolver", [subnodeNode, CONTRACTS.DOTNS_CONTENT_RESOLVER], (s) => console.log(`      ${s}`), { useNoncePolling: true });
-      console.log(`   Tx: ${resolverTxHash}`);
-      console.log(`   Subdomain registered!`);
-      return { sublabel, parentLabel, owner: this.evmAddress };
-    });
-  }
-  async setContenthash(domainName, contenthashHex) {
-    return withSpan("deploy.dotns.set-contenthash", "2b. set-contenthash", {}, async () => {
-      this.ensureConnected();
-      const node = namehash(`${domainName}.dot`);
-      let ipfsCid = null;
-      if (contenthashHex && contenthashHex !== "0x") {
-        const bytes = Buffer.from(contenthashHex.slice(2), "hex");
-        if (bytes[0] === 227 && bytes.length >= 4) {
-          const cidBytes = bytes.slice(2);
-          ipfsCid = CID.decode(cidBytes).toString();
-        }
-      }
-      console.log(`   Setting contenthash: ${ipfsCid || contenthashHex}`);
-      const txHash = await this.contractTransaction(CONTRACTS.DOTNS_CONTENT_RESOLVER, 0n, DOTNS_CONTENT_RESOLVER_ABI, "setContenthash", [node, contenthashHex], (s) => console.log(`      ${s}`), { useNoncePolling: true });
-      console.log(`   Tx: ${txHash}`);
-      const onChainRaw = await this.getContenthash(domainName);
-      const onChain = (onChainRaw || "0x").toLowerCase();
-      const expected = contenthashHex.toLowerCase();
-      if (onChain !== expected) {
-        throw new Error(
-          `Post-deploy verification failed for ${domainName}.dot: on-chain contenthash is ${onChain}, not the ${expected} we just wrote. The setContenthash tx may have silently failed, or another party overwrote the domain. Re-run the deploy to retry.`
-        );
-      }
-      console.log(`   Verified on-chain: ${ipfsCid || contenthashHex}
-`);
-      return { node };
-    });
-  }
-  // View-only readiness check. Runs every chain read needed to predict whether
-  // `register(label)` will succeed, so the caller can fail-fast BEFORE the
-  // Bulletin chunk upload. Never writes to chain. See issue #100.
-  async preflight(label, explicitStatusOverride) {
-    return withSpan("deploy.dotns.preflight", `preflight ${label}.dot`, {}, async () => {
-      this.ensureConnected();
-      const validated = validateDomainLabel(label);
-      const trailingDigits = countTrailingDigits(validated);
-      const baselength = validated.length - trailingDigits;
-      const classification = classifyDotnsLabel(validated);
-      if (classification.status === ProofOfPersonhoodStatus.Reserved) {
-        const sanitizeTrail = label !== validated ? `Input "${label}" was sanitized to "${validated}" (excess trailing digits trimmed). ` : "";
-        return {
-          label: validated,
-          classification,
-          userStatus: 0,
-          trailingDigits,
-          baselength,
-          isAvailable: false,
-          existingOwner: null,
-          isBaseNameReserved: false,
-          reservationOwner: null,
-          isTestnet: false,
-          canProceed: false,
-          reason: `${sanitizeTrail}${classification.message}`,
-          plannedAction: "abort",
-          needsPopUpgrade: false
-        };
-      }
-      const baseName = stripTrailingDigits(validated);
-      const [userStatus, baseReservation, ownership, isTestnet] = await Promise.all([
-        this.getUserPopStatus(),
-        withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "isBaseNameReserved", [baseName]), 3e4, "isBaseNameReserved"),
-        this.checkOwnership(validated),
-        this.isTestnet()
-      ]);
-      const [isReserved, reservationOwnerRaw] = baseReservation;
-      const reservationOwner = isReserved ? reservationOwnerRaw.toLowerCase() : null;
-      const ownerRaw = ownership.owner?.toLowerCase() ?? null;
-      const existingOwner = ownerRaw && ownerRaw !== zeroAddress ? ownerRaw : null;
-      const selfAddress = this.evmAddress.toLowerCase();
-      if (existingOwner !== null && existingOwner !== selfAddress) {
-        return {
-          label: validated,
-          classification,
-          userStatus,
-          trailingDigits,
-          baselength,
-          isAvailable: false,
-          existingOwner,
-          isBaseNameReserved: isReserved,
-          reservationOwner,
-          isTestnet,
-          canProceed: false,
-          reason: `Domain ${validated}.dot is already owned by ${existingOwner}.`,
-          plannedAction: "abort",
-          needsPopUpgrade: false
-        };
-      }
-      if (existingOwner !== null && existingOwner === selfAddress) {
-        return {
-          label: validated,
-          classification,
-          userStatus,
-          trailingDigits,
-          baselength,
-          isAvailable: true,
-          existingOwner,
-          isBaseNameReserved: isReserved,
-          reservationOwner,
-          isTestnet,
-          canProceed: true,
-          plannedAction: "already-owned-by-us",
-          needsPopUpgrade: false
-        };
-      }
-      if (isReserved && reservationOwner !== selfAddress) {
-        return {
-          label: validated,
-          classification,
-          userStatus,
-          trailingDigits,
-          baselength,
-          isAvailable: true,
-          existingOwner: null,
-          isBaseNameReserved: true,
-          reservationOwner,
-          isTestnet,
-          canProceed: false,
-          reason: `Base name ${baseName} is reserved for ${reservationOwner}.`,
-          plannedAction: "abort",
-          needsPopUpgrade: false
-        };
-      }
-      const explicitStatus = explicitStatusOverride ?? process.env.DOTNS_STATUS;
-      const explicitStatusNum = explicitStatus ? parseProofOfPersonhoodStatus(explicitStatus) : void 0;
-      const targetPopStatus = simulateUserStatus(userStatus, classification.status, { explicitStatus: explicitStatusNum, isTestnet });
-      if (!canRegister(classification.status, targetPopStatus, trailingDigits)) {
-        const className = popStatusName(classification.status);
-        return {
-          label: validated,
-          classification,
-          userStatus,
-          trailingDigits,
-          baselength,
-          isAvailable: true,
-          existingOwner: null,
-          isBaseNameReserved: isReserved,
-          reservationOwner,
-          isTestnet,
-          canProceed: false,
-          reason: `${validated}.dot classifies as ${className}; this signer cannot register it (PopRules.priceWithCheck gate). Remediations: use a signer with Full PoP, or pick a base name of 6-8 chars + trailing 00 (which classifies as PopLite).`,
-          plannedAction: "abort",
-          needsPopUpgrade: false,
-          targetPopStatus
-        };
-      }
-      return {
-        label: validated,
-        classification,
-        userStatus,
-        trailingDigits,
-        baselength,
-        isAvailable: true,
-        existingOwner: null,
-        isBaseNameReserved: isReserved,
-        reservationOwner,
-        isTestnet,
-        canProceed: true,
-        plannedAction: "register",
-        needsPopUpgrade: targetPopStatus !== userStatus,
-        targetPopStatus
-      };
-    });
-  }
-  async register(label, options = {}) {
-    return withSpan("deploy.dotns.register", `2a. register ${label}.dot`, {}, async () => {
-      const explicitStatus = options.status || process.env.DOTNS_STATUS;
-      const reverse = options.reverse ?? (process.env.DOTNS_REVERSE ?? "false").toLowerCase() === "true";
-      if (!this.connected) await this.connect(options);
-      label = validateDomainLabel(label);
-      const [classification] = await Promise.all([
-        this.classifyName(label),
-        this.ensureNotRegistered(label)
-      ]);
-      const requiredStatus = classification.requiredStatus;
-      if (requiredStatus === ProofOfPersonhoodStatus.Reserved) {
-        throw new Error(classification.message);
-      }
-      const initialUserStatus = await this.getUserPopStatus();
-      const isTestnet = await this.isTestnet();
-      const explicitStatusNum = explicitStatus ? parseProofOfPersonhoodStatus(explicitStatus) : void 0;
-      const targetUserStatus = simulateUserStatus(initialUserStatus, requiredStatus, { explicitStatus: explicitStatusNum, isTestnet });
-      if (!canRegister(requiredStatus, targetUserStatus, countTrailingDigits(label))) {
-        throw new Error(
-          `This label classifies as ${popStatusName(requiredStatus)}; the registrar will reject this signer (PopRules.priceWithCheck). Remediations: use a signer with Full PoP, or pick a shorter base name (6-8 chars + trailing 00) that classifies as PopLite.`
-        );
-      }
-      if (targetUserStatus !== initialUserStatus && targetUserStatus !== ProofOfPersonhoodStatus.NoStatus) {
-        await this.setUserPopStatus(targetUserStatus);
-        const userStatus = await this.getUserPopStatus();
-        if (userStatus !== targetUserStatus) {
-          throw new Error(
-            "setUserPopStatus did not land as expected (wanted " + targetUserStatus + ", got " + userStatus + "). Check RPC connectivity and POP_RULES contract."
-          );
-        }
-      }
-      const { commitment, registration } = await this.generateCommitment(label, reverse);
-      await withSpan("deploy.dotns.submit-commitment", "2a-i. submit-commitment", {}, () => this.submitCommitment(commitment));
-      await withSpan("deploy.dotns.wait-commitment-age", "2a-ii. wait-commitment-age", {}, () => this.waitForCommitmentAge(commitment));
-      const pricing = await withSpan("deploy.dotns.price-validation", "2a-iii. price-validation", {}, () => this.getPriceAndValidate(label));
-      await withSpan("deploy.dotns.finalize-registration", "2a-iv. finalize-registration", {}, () => this.finalizeRegistration(registration, pricing.priceWei));
-      await this.verifyOwnership(label);
-      console.log(`
-   Registration complete!`);
-      return { label, owner: this.evmAddress };
-    });
-  }
-  disconnect() {
-    if (this.client) {
-      this.client.destroy();
-      this.client = null;
-      this.clientWrapper = null;
-      this.connected = false;
-    }
-  }
-};
-var dotns = new DotNS();
-
-export {
-  RPC_ENDPOINTS,
-  CONTRACTS,
-  DECIMALS,
-  NATIVE_TO_ETH_RATIO,
-  CONNECTION_TIMEOUT_MS,
-  OPERATION_TIMEOUT_MS,
-  TX_TIMEOUT_MS,
-  TX_CHAIN_TIME_BUDGET_MS,
-  TX_WALL_CLOCK_CEILING_MS,
-  WS_HEARTBEAT_TIMEOUT_MS,
-  DOTNS_TX_MAX_ATTEMPTS,
-  classifyTxRetryDecision,
-  DEFAULT_MNEMONIC,
-  fetchNonce,
-  ProofOfPersonhoodStatus,
-  DOT_NODE,
-  convertWeiToNative,
-  computeDomainTokenId,
-  countTrailingDigits,
-  stripTrailingDigits,
-  sanitizeDomainLabel,
-  validateDomainLabel,
-  isCommitmentMature,
-  classifyDotnsLabel,
-  canRegister,
-  simulateUserStatus,
-  parseDomainName,
-  parseProofOfPersonhoodStatus,
-  popStatusName,
-  DotNS,
-  dotns
-};