@parity/dotns-cli 0.6.4 → 0.6.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Parity Technologies (UK) Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -118,6 +118,40 @@ dotns --password test-password register domain --account default --name coolname
 
 # With reverse record
 dotns --password test-password register domain --account default --name coolname42 --reverse
+
+# Auto-retry on failure, resuming from the cached commitment (here, up to 3 times)
+dotns --password test-password register domain --account default --name coolname42 --retry 3
+```
+
+### Resume and manage commitments
+
+Registration is a two-step commit-reveal: the commit lands on-chain, then after the
+minimum commitment age the reveal completes the mint. If the reveal is interrupted
+(crash, network drop, closed terminal), the commitment is cached locally so it can be
+resumed rather than restarted. The reveal secret is encrypted at rest with your
+credential (keystore password, mnemonic, or key URI); the rest of the record is
+plaintext so it can be listed and cleared without unlocking.
+
+Records live under `~/.dotns/registrations/` (override with `DOTNS_REGISTRATION_DIR`).
+
+```bash
+# Resume the most recent interrupted registration
+dotns --password test-password register retry --account default
+
+# Resume a specific cached commitment by name
+dotns --password test-password register retry coolname42 --account default
+
+# List cached commitments and their on-chain status
+dotns register list
+
+# Review cached commitments: purges completed ones, then prompts for any pending
+dotns --password test-password register clear --account default
+
+# Non-interactively discard pending commitments
+dotns register clear --discard
+
+# Non-interactively complete pending commitments
+dotns --password test-password register clear --register --account default
 ```
 
 ### Register Subnames

package/dist/cli.js

@@ -267174,6 +267174,30 @@ async function waitForMinimumCommitmentAge(clientWrapper, originSubstrateAddress
   waitSpinner.fail("Commitment age verification timed out");
   throw new Error(`Commitment still too new after ${waitSeconds + COMMITMENT_POLL_TIMEOUT_MS / 1000}s. The chain's block timestamps may be advancing slower than expected. Try increasing --commitment-buffer or DOTNS_COMMITMENT_BUFFER.`);
 }
+async function readDomainOwner(clientWrapper, originSubstrateAddress, label) {
+  const tokenId = computeDomainTokenId(label);
+  try {
+    return await withTimeout(performContractCall(clientWrapper, originSubstrateAddress, CONTRACTS.DOTNS_REGISTRAR, DOTNS_REGISTRAR_ABI, "ownerOf", [tokenId]), 30000, "ownerOf");
+  } catch {
+    return zeroAddress;
+  }
+}
+async function readCommitmentStatus(clientWrapper, originSubstrateAddress, commitment) {
+  const toNumber = (value3) => typeof value3 === "bigint" ? Number(value3) : value3;
+  const [minAge, maxAge, committedAt] = await Promise.all([
+    withTimeout(performContractCall(clientWrapper, originSubstrateAddress, CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "minCommitmentAge", []), 30000, "minCommitmentAge"),
+    withTimeout(performContractCall(clientWrapper, originSubstrateAddress, CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "maxCommitmentAge", []), 30000, "maxCommitmentAge"),
+    withTimeout(performContractCall(clientWrapper, originSubstrateAddress, CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "commitments", [commitment]), 30000, "commitments")
+  ]);
+  const timestampQuery = clientWrapper.client.query?.Timestamp?.Now;
+  const nowSeconds = timestampQuery?.getValue ? Math.floor(Number(await timestampQuery.getValue()) / 1000) : Math.floor(Date.now() / 1000);
+  return {
+    committedTimestampSeconds: toNumber(committedAt),
+    nowSeconds,
+    minAgeSeconds: toNumber(minAge),
+    maxAgeSeconds: toNumber(maxAge)
+  };
+}
 async function getUserProofOfPersonhoodStatus(clientWrapper, originSubstrateAddress, ownerAddress) {
   const personhoodInfo = await withTimeout(performContractCall(clientWrapper, originSubstrateAddress, PERSONHOOD_PRECOMPILE_ADDRESS, PERSONHOOD_ABI, "personhoodStatus", [ownerAddress, PERSONHOOD_CONTEXT]), 30000, "personhoodStatus");
   return convertToProofOfPersonhoodStatus(getPersonhoodStatusValue(personhoodInfo));
@@ -267456,6 +267480,95 @@ async function transferDomain(clientWrapper, originSubstrateAddress, signer, fro
 // src/cli/commands/register.ts
 init_source();
 init__esm();
+init_formatting();
+
+// src/commands/registrationManifest.ts
+init_source();
+import os12 from "node:os";
+import path10 from "node:path";
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
+init_formatting();
+var MANIFEST_EXTENSION2 = ".json";
+function getManifestDirectory2() {
+  const configured = process.env.DOTNS_REGISTRATION_DIR;
+  if (configured && configured.trim().length > 0) {
+    return path10.resolve(configured);
+  }
+  return path10.join(os12.homedir(), ".dotns", "registrations");
+}
+function recordId(env3, caller, label) {
+  return `${env3}__${caller.toLowerCase()}__${label.toLowerCase()}`;
+}
+function recordPath(id) {
+  return path10.join(getManifestDirectory2(), `${id}${MANIFEST_EXTENSION2}`);
+}
+function belongsTo(record2, env3, caller) {
+  return record2.env === env3 && record2.caller.toLowerCase() === caller.toLowerCase();
+}
+function resolveManifestCredential(options2) {
+  return options2.password || process.env.DOTNS_KEYSTORE_PASSWORD || options2.mnemonic || options2.keyUri || null;
+}
+function saveCommitmentRecord(params2) {
+  const record2 = {
+    env: params2.env,
+    caller: params2.caller,
+    label: params2.label,
+    owner: params2.owner,
+    reserved: params2.reserved,
+    governance: params2.governance,
+    commitmentHash: params2.commitmentHash,
+    commitTxHash: params2.commitTxHash,
+    committedAtIso: params2.committedAtIso,
+    transferDestination: params2.transferDestination,
+    encryptedSecret: encryptKeystorePayload({ secret: params2.secret }, params2.credential)
+  };
+  mkdirSync(getManifestDirectory2(), { recursive: true });
+  writeFileSync(recordPath(recordId(params2.env, params2.caller, params2.label)), JSON.stringify(record2, null, 2), "utf8");
+}
+function loadCommitmentRecords(env3, caller) {
+  const dir = getManifestDirectory2();
+  if (!existsSync(dir))
+    return [];
+  const records = [];
+  for (const file of readdirSync(dir)) {
+    if (!file.endsWith(MANIFEST_EXTENSION2))
+      continue;
+    try {
+      const parsed2 = JSON.parse(readFileSync(path10.join(dir, file), "utf8"));
+      if (parsed2?.label && parsed2?.encryptedSecret && belongsTo(parsed2, env3, caller)) {
+        records.push(parsed2);
+      }
+    } catch (error2) {
+      console.warn(source_default.yellow(`  ⚠ Skipping unreadable registration cache file ${file}: ${formatErrorMessage(error2)}`));
+    }
+  }
+  return records.sort((a2, b) => b.committedAtIso.localeCompare(a2.committedAtIso));
+}
+function findCommitmentRecord(env3, caller, label) {
+  const file = recordPath(recordId(env3, caller, label));
+  if (!existsSync(file))
+    return null;
+  try {
+    const parsed2 = JSON.parse(readFileSync(file, "utf8"));
+    return belongsTo(parsed2, env3, caller) ? parsed2 : null;
+  } catch (error2) {
+    console.warn(source_default.yellow(`  ⚠ Could not read cached commitment for ${label}: ${formatErrorMessage(error2)}`));
+    return null;
+  }
+}
+function latestCommitmentRecord(env3, caller) {
+  return loadCommitmentRecords(env3, caller)[0] ?? null;
+}
+function deleteCommitmentRecord(env3, caller, label) {
+  rmSync(recordPath(recordId(env3, caller, label)), { force: true });
+}
+function decryptCommitmentSecret(record2, credential) {
+  const payload = decryptKeystorePayload(record2.encryptedSecret, credential);
+  if (!payload?.secret) {
+    throw new Error("Stored commitment is missing its secret or the credential is wrong.");
+  }
+  return payload.secret;
+}
 
 // src/cli/labels.ts
 function generateRandomLabel(status) {
@@ -267492,6 +267605,12 @@ function generateRandomLabel(status) {
 }
 
 // src/cli/commands/register.ts
+function requireEnvironment(environment) {
+  if (!environment) {
+    throw new Error("Could not resolve the DotNS environment for this command.");
+  }
+  return environment;
+}
 function resolveTransferDestination(options2) {
   const legacy = options2.transferTo;
   const modern = options2.to;
@@ -267518,6 +267637,34 @@ function isValidTransferDestination(destination) {
   const domainLabelPattern = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
   return domainLabelPattern.test(destination) && destination.length >= 3 && destination.length <= 63;
 }
+async function registerWithRetries(params2) {
+  try {
+    await params2.attempt();
+    return;
+  } catch (error2) {
+    if (params2.retries <= 0)
+      throw error2;
+    const { env: env3, caller, credential } = params2.persistContext;
+    let lastError = error2;
+    for (let attempt = 1;attempt <= params2.retries; attempt++) {
+      console.log(source_default.yellow(`
+↻ Registration failed: ${formatErrorMessage(lastError)}` + `
+  Retry ${attempt}/${params2.retries} (resuming from commitment)…`));
+      try {
+        const record2 = credential ? findCommitmentRecord(env3, caller, params2.label) : null;
+        if (record2 && credential) {
+          await resumeRegistration(params2.context, record2, credential, params2.commitmentBuffer);
+        } else {
+          await params2.attempt();
+        }
+        return;
+      } catch (retryError) {
+        lastError = retryError;
+      }
+    }
+    throw lastError;
+  }
+}
 async function executeRegistration(options2 = {}) {
   if (options2.mnemonic && options2.keyUri) {
     throw new Error("Cannot specify both --mnemonic and --key-uri");
@@ -267558,17 +267705,22 @@ async function executeRegistration(options2 = {}) {
   }
   console.log(source_default.gray("  Transfer:  ") + (transferDestination ? source_default.green("post-mint") : source_default.gray("none")));
   await step("Ensuring account mapped", async () => clientWrapper.ensureAccountMapped(substrateAddress, signer));
-  if (options2.governance) {
-    await executeGovernanceRegistration(clientWrapper, substrateAddress, signer, evmAddress, label, transferDestination, options2.commitmentBuffer, context.nativeTokenDecimals);
-  } else {
-    await executeRegularRegistration(clientWrapper, substrateAddress, signer, evmAddress, ownerEvmAddress, label, context.nativeTokenDecimals, options2.reverse ?? false, transferDestination, options2.commitmentBuffer);
-  }
-  console.log(`
-${source_default.bold.green("═══════════════════════════════════════")}`);
-  console.log(`${source_default.bold.green("         ✓ Operation Complete          ")}`);
-  console.log(`${source_default.bold.green("═══════════════════════════════════════")}
-`);
-  console.log(source_default.gray("  Domain: ") + source_default.cyan(label + ".dot"));
+  const credential = resolveManifestCredential(options2);
+  const persistContext = {
+    env: requireEnvironment(context.environment),
+    caller: evmAddress,
+    credential
+  };
+  const attemptRegistration = () => options2.governance ? executeGovernanceRegistration(clientWrapper, substrateAddress, signer, evmAddress, label, transferDestination, persistContext, options2.commitmentBuffer, context.nativeTokenDecimals) : executeRegularRegistration(clientWrapper, substrateAddress, signer, evmAddress, ownerEvmAddress, label, context.nativeTokenDecimals, options2.reverse ?? false, transferDestination, persistContext, options2.commitmentBuffer);
+  await registerWithRetries({
+    attempt: attemptRegistration,
+    context,
+    persistContext,
+    label,
+    retries: options2.retry ?? 0,
+    commitmentBuffer: options2.commitmentBuffer
+  });
+  printCompletionBanner("✓ Operation Complete", `${label}.dot`);
   return {
     ok: true,
     label,
@@ -267598,12 +267750,7 @@ async function executeSubnameRegistration(options2) {
   console.log(source_default.gray("  Owner:     ") + source_default.white(ownerAddress));
   await step("Ensuring account mapped", async () => clientWrapper.ensureAccountMapped(substrateAddress, signer));
   await registerSubnode(clientWrapper, substrateAddress, signer, sublabel, parentLabel, ownerAddress);
-  console.log(`
-${source_default.bold.green("═══════════════════════════════════════")}`);
-  console.log(`${source_default.bold.green("         ✓ Subname Registered          ")}`);
-  console.log(`${source_default.bold.green("═══════════════════════════════════════")}
-`);
-  console.log(source_default.gray("  Domain: ") + source_default.cyan(fullName));
+  printCompletionBanner("✓ Subname Registered", fullName);
   return {
     ok: true,
     label: sublabel,
@@ -267612,7 +267759,62 @@ ${source_default.bold.green("═════════════════
     owner: ownerAddress
   };
 }
-async function executeGovernanceRegistration(clientWrapper, substrateAddress, signer, evmAddress, label, transferDestination, commitmentBuffer, nativeTokenDecimals) {
+function persistCommitment(persistContext, params2) {
+  if (!persistContext.credential)
+    return;
+  try {
+    saveCommitmentRecord({
+      env: persistContext.env,
+      caller: persistContext.caller,
+      label: params2.label,
+      owner: params2.owner,
+      reserved: params2.reserved,
+      governance: params2.governance,
+      secret: params2.secret,
+      commitmentHash: params2.commitmentHash,
+      committedAtIso: new Date().toISOString(),
+      transferDestination: params2.transferDestination,
+      credential: persistContext.credential
+    });
+  } catch (error2) {
+    console.warn(source_default.yellow(`  ⚠ Could not cache commitment: ${formatErrorMessage(error2)}`));
+  }
+}
+function forgetCommitment(persistContext, label) {
+  try {
+    deleteCommitmentRecord(persistContext.env, persistContext.caller, label);
+  } catch (error2) {
+    console.warn(source_default.yellow(`  ⚠ Could not clear cached commitment: ${formatErrorMessage(error2)}`));
+  }
+}
+var BANNER_RULE = "═══════════════════════════════════════";
+function centerInBanner(title) {
+  const width = BANNER_RULE.length;
+  if (title.length >= width)
+    return title;
+  const left = Math.floor((width - title.length) / 2);
+  return title.padStart(title.length + left).padEnd(width);
+}
+function printCompletionBanner(title, domain) {
+  console.log(`
+${source_default.bold.green(BANNER_RULE)}`);
+  console.log(source_default.bold.green(centerInBanner(title)));
+  console.log(`${source_default.bold.green(BANNER_RULE)}
+`);
+  console.log(source_default.gray("  Domain: ") + source_default.cyan(domain));
+}
+async function replayTransfer(params2) {
+  const recipient = await step("Resolving recipient", async () => resolveTransferRecipient(params2.clientWrapper, params2.substrateAddress, params2.transferDestination));
+  await step("Transferring domain", async () => transferDomain(params2.clientWrapper, params2.substrateAddress, params2.signer, params2.evmAddress, recipient, params2.label, params2.nativeTokenDecimals));
+  await step("Verifying ownership", async () => verifyDomainOwnership(params2.clientWrapper, params2.substrateAddress, params2.label, recipient));
+}
+async function finalizeRegularReveal(params2) {
+  const isCrossPayer = checksumAddress(params2.ownerEvmAddress) !== checksumAddress(params2.evmAddress);
+  const pricing = await step("Pricing and eligibility", async () => getPriceAndValidateEligibility(params2.clientWrapper, params2.substrateAddress, params2.label, params2.ownerEvmAddress));
+  const frictionWei = isCrossPayer ? await step("Quoting cross-payer friction", async () => quoteCrossPayerFriction(params2.clientWrapper, params2.substrateAddress, params2.label, params2.evmAddress, params2.ownerEvmAddress)) : 0n;
+  await step("Finalizing registration", async () => finalizeRegularRegistration(params2.clientWrapper, params2.substrateAddress, params2.signer, params2.registration, pricing.priceWei, params2.nativeTokenDecimals, frictionWei));
+}
+async function executeGovernanceRegistration(clientWrapper, substrateAddress, signer, evmAddress, label, transferDestination, persistContext, commitmentBuffer, nativeTokenDecimals) {
   console.log(source_default.bold(`
 \uD83C\uDFDB Governance registration (commit-reveal)
 `));
@@ -267624,17 +267826,33 @@ async function executeGovernanceRegistration(clientWrapper, substrateAddress, si
   await step("Checking availability", async () => ensureDomainNotRegistered(clientWrapper, substrateAddress, label));
   const { commitment, registration } = await step("Generating commitment", async () => generateCommitment(clientWrapper, substrateAddress, label, evmAddress, true));
   await step("Submitting commitment", async () => submitCommitment(clientWrapper, substrateAddress, signer, commitment));
+  persistCommitment(persistContext, {
+    label,
+    owner: evmAddress,
+    reserved: true,
+    governance: true,
+    secret: registration.secret,
+    commitmentHash: commitment,
+    transferDestination
+  });
   await step("Waiting commitment age", async () => waitForMinimumCommitmentAge(clientWrapper, substrateAddress, commitment, commitmentBuffer));
   await step("Finalizing registration", async () => finalizeGovernanceRegistration(clientWrapper, substrateAddress, signer, registration));
+  forgetCommitment(persistContext, label);
   await step("Verifying ownership", async () => verifyDomainOwnership(clientWrapper, substrateAddress, label, evmAddress));
   await step("Ensuring label store", async () => ensureLabelStoreReady(clientWrapper, substrateAddress, signer, evmAddress));
   if (transferDestination) {
-    const recipient = await step("Resolving recipient", async () => resolveTransferRecipient(clientWrapper, substrateAddress, transferDestination));
-    await step("Transferring domain", async () => transferDomain(clientWrapper, substrateAddress, signer, evmAddress, recipient, label, nativeTokenDecimals));
-    await step("Verifying ownership", async () => verifyDomainOwnership(clientWrapper, substrateAddress, label, recipient));
+    await replayTransfer({
+      clientWrapper,
+      substrateAddress,
+      signer,
+      evmAddress,
+      label,
+      transferDestination,
+      nativeTokenDecimals
+    });
   }
 }
-async function executeRegularRegistration(clientWrapper, substrateAddress, signer, evmAddress, ownerEvmAddress, label, nativeTokenDecimals, enableReverseRecord, transferDestination, commitmentBuffer) {
+async function executeRegularRegistration(clientWrapper, substrateAddress, signer, evmAddress, ownerEvmAddress, label, nativeTokenDecimals, enableReverseRecord, transferDestination, persistContext, commitmentBuffer) {
   console.log(source_default.bold(`
 \uD83E\uDDFE Regular registration (commit-reveal)
 `));
@@ -267644,20 +267862,249 @@ async function executeRegularRegistration(clientWrapper, substrateAddress, signe
   await step("Checking availability", async () => ensureDomainNotRegistered(clientWrapper, substrateAddress, label));
   const { commitment, registration } = await step("Generating commitment", async () => generateCommitment(clientWrapper, substrateAddress, label, ownerEvmAddress, enableReverseRecord));
   await step("Submitting commitment", async () => submitCommitment(clientWrapper, substrateAddress, signer, commitment));
+  persistCommitment(persistContext, {
+    label,
+    owner: ownerEvmAddress,
+    reserved: enableReverseRecord,
+    governance: false,
+    secret: registration.secret,
+    commitmentHash: commitment,
+    transferDestination
+  });
   await step("Waiting commitment age", async () => waitForMinimumCommitmentAge(clientWrapper, substrateAddress, commitment, commitmentBuffer));
-  const pricing = await step("Pricing and eligibility", async () => getPriceAndValidateEligibility(clientWrapper, substrateAddress, label, ownerEvmAddress));
-  const frictionWei = isCrossPayer ? await step("Quoting cross-payer friction", async () => quoteCrossPayerFriction(clientWrapper, substrateAddress, label, evmAddress, ownerEvmAddress)) : 0n;
-  await step("Finalizing registration", async () => finalizeRegularRegistration(clientWrapper, substrateAddress, signer, registration, pricing.priceWei, nativeTokenDecimals, frictionWei));
+  await finalizeRegularReveal({
+    clientWrapper,
+    substrateAddress,
+    signer,
+    evmAddress,
+    ownerEvmAddress,
+    label,
+    registration,
+    nativeTokenDecimals
+  });
+  forgetCommitment(persistContext, label);
   await step("Verifying ownership", async () => verifyDomainOwnership(clientWrapper, substrateAddress, label, ownerEvmAddress));
   if (!isCrossPayer) {
     await step("Ensuring label store", async () => ensureLabelStoreReady(clientWrapper, substrateAddress, signer, evmAddress));
   }
   if (transferDestination) {
-    const recipient = await step("Resolving recipient", async () => resolveTransferRecipient(clientWrapper, substrateAddress, transferDestination));
-    await step("Transferring domain", async () => transferDomain(clientWrapper, substrateAddress, signer, evmAddress, recipient, label, nativeTokenDecimals));
-    await step("Verifying ownership", async () => verifyDomainOwnership(clientWrapper, substrateAddress, label, recipient));
+    await replayTransfer({
+      clientWrapper,
+      substrateAddress,
+      signer,
+      evmAddress,
+      label,
+      transferDestination,
+      nativeTokenDecimals
+    });
   }
 }
+async function isRegisteredTo(clientWrapper, substrateAddress, label, owner) {
+  const actual = await readDomainOwner(clientWrapper, substrateAddress, label);
+  return checksumAddress(actual) === checksumAddress(owner);
+}
+async function resumeRegistration(context, record2, credential, commitmentBuffer) {
+  const { clientWrapper, substrateAddress, signer, evmAddress, nativeTokenDecimals } = context;
+  const { label } = record2;
+  const persistContext = {
+    env: requireEnvironment(context.environment),
+    caller: evmAddress,
+    credential
+  };
+  console.log(source_default.bold(`
+▶ Resuming ${source_default.cyan(label + ".dot")}
+`));
+  const registration = {
+    label,
+    owner: record2.owner,
+    secret: decryptCommitmentSecret(record2, credential),
+    reserved: record2.reserved
+  };
+  const alreadyOwned = await step("Checking on-chain ownership", async () => isRegisteredTo(clientWrapper, substrateAddress, label, record2.owner));
+  if (alreadyOwned) {
+    console.log(source_default.green(`  ✓ ${label}.dot is already registered to ${record2.owner}`));
+    forgetCommitment(persistContext, label);
+    return {
+      ok: true,
+      label,
+      domain: `${label}.dot`,
+      caller: evmAddress,
+      owner: record2.owner
+    };
+  }
+  const status = await step("Reading commitment status", async () => readCommitmentStatus(clientWrapper, substrateAddress, record2.commitmentHash));
+  const commitmentAge = status.nowSeconds - status.committedTimestampSeconds;
+  const needsRecommit = status.committedTimestampSeconds === 0 || commitmentAge > status.maxAgeSeconds;
+  if (needsRecommit) {
+    await step("Re-submitting commitment", async () => submitCommitment(clientWrapper, substrateAddress, signer, record2.commitmentHash));
+  }
+  await step("Waiting commitment age", async () => waitForMinimumCommitmentAge(clientWrapper, substrateAddress, record2.commitmentHash, commitmentBuffer));
+  if (record2.governance) {
+    await step("Finalizing registration", async () => finalizeGovernanceRegistration(clientWrapper, substrateAddress, signer, registration));
+  } else {
+    await finalizeRegularReveal({
+      clientWrapper,
+      substrateAddress,
+      signer,
+      evmAddress,
+      ownerEvmAddress: record2.owner,
+      label,
+      registration,
+      nativeTokenDecimals
+    });
+  }
+  await step("Verifying ownership", async () => verifyDomainOwnership(clientWrapper, substrateAddress, label, record2.owner));
+  forgetCommitment(persistContext, label);
+  if (record2.transferDestination) {
+    await replayTransfer({
+      clientWrapper,
+      substrateAddress,
+      signer,
+      evmAddress,
+      label,
+      transferDestination: record2.transferDestination,
+      nativeTokenDecimals
+    });
+  }
+  printCompletionBanner("✓ Registration Resumed", `${label}.dot`);
+  return {
+    ok: true,
+    label,
+    domain: `${label}.dot`,
+    caller: evmAddress,
+    owner: record2.owner
+  };
+}
+function requireManifestCredential(options2) {
+  const credential = resolveManifestCredential(options2);
+  if (!credential) {
+    throw new Error("A credential is required to decrypt the cached commitment: pass --password, --mnemonic, or --key-uri.");
+  }
+  return credential;
+}
+async function executeRetry(options2 = {}) {
+  const context = await prepareAssetHubContext(options2);
+  const credential = requireManifestCredential(options2);
+  const caller = context.evmAddress;
+  const env3 = requireEnvironment(context.environment);
+  const record2 = options2.name ? findCommitmentRecord(env3, caller, options2.name) : latestCommitmentRecord(env3, caller);
+  if (!record2) {
+    throw new Error("No cached commitment to retry.");
+  }
+  return resumeRegistration(context, record2, credential, options2.commitmentBuffer);
+}
+async function promptPendingAction(pending) {
+  const readline = await import("node:readline/promises");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  console.log(source_default.bold(`
+▶ Pending commitments
+`));
+  for (const record2 of pending) {
+    console.log(source_default.gray("  • ") + source_default.cyan(record2.label + ".dot") + source_default.gray(`  committed ${record2.committedAtIso}`));
+  }
+  try {
+    const answer = (await rl.question(source_default.bold(`
+register / discard / cancel (default cancel): `))).trim().toLowerCase();
+    if (answer === "register" || answer === "r")
+      return "register";
+    if (answer === "discard" || answer === "d")
+      return "discard";
+    return "cancel";
+  } finally {
+    rl.close();
+  }
+}
+async function executeClear(options2 = {}) {
+  const context = await prepareAssetHubContext(options2);
+  const { clientWrapper, substrateAddress } = context;
+  const caller = context.evmAddress;
+  const env3 = requireEnvironment(context.environment);
+  const records = loadCommitmentRecords(env3, caller);
+  const summary = {
+    ok: true,
+    purged: [],
+    discarded: [],
+    resumed: [],
+    cancelled: false
+  };
+  const pending = [];
+  for (const record2 of records) {
+    const registered = await step(`Checking ${record2.label}.dot`, async () => isRegisteredTo(clientWrapper, substrateAddress, record2.label, record2.owner));
+    if (registered) {
+      deleteCommitmentRecord(env3, caller, record2.label);
+      summary.purged.push(record2.label);
+    } else {
+      pending.push(record2);
+    }
+  }
+  if (summary.purged.length > 0) {
+    console.log(source_default.green(`  ✓ Purged ${summary.purged.length} completed`));
+  }
+  if (pending.length === 0) {
+    return summary;
+  }
+  let action;
+  if (options2.discard) {
+    action = "discard";
+  } else if (options2.register) {
+    action = "register";
+  } else if (process.stdin.isTTY) {
+    action = await promptPendingAction(pending);
+  } else {
+    throw new Error(`${pending.length} pending commitment(s) found. Pass --discard to delete them or --register to complete them.`);
+  }
+  if (action === "cancel") {
+    summary.cancelled = true;
+    return summary;
+  }
+  if (action === "discard") {
+    for (const record2 of pending) {
+      deleteCommitmentRecord(env3, caller, record2.label);
+      summary.discarded.push(record2.label);
+    }
+    return summary;
+  }
+  const credential = requireManifestCredential(options2);
+  for (const record2 of pending) {
+    await resumeRegistration(context, record2, credential, options2.commitmentBuffer);
+    summary.resumed.push(record2.label);
+  }
+  return summary;
+}
+async function executeList(options2 = {}) {
+  const context = await prepareReadOnlyContext(options2);
+  const { clientWrapper } = context;
+  const caller = context.evmAddress;
+  const env3 = requireEnvironment(context.environment);
+  const records = loadCommitmentRecords(env3, caller);
+  const rows = [];
+  for (const record2 of records) {
+    const registered = await isRegisteredTo(clientWrapper, context.account.address, record2.label, record2.owner);
+    rows.push({
+      label: record2.label,
+      status: registered ? "registered" : "pending",
+      committedAtIso: record2.committedAtIso,
+      env: record2.env
+    });
+  }
+  if (!options2.json) {
+    if (rows.length === 0) {
+      console.log(source_default.gray(`
+  No cached commitments.
+`));
+    } else {
+      console.log(source_default.bold(`
+▶ Cached commitments
+`));
+      for (const row of rows) {
+        const statusLabel = row.status === "registered" ? source_default.green("registered") : source_default.yellow("pending");
+        console.log(source_default.gray("  • ") + source_default.cyan((row.label + ".dot").padEnd(24)) + statusLabel + source_default.gray(`  ${row.committedAtIso}  ${row.env}`));
+      }
+      console.log();
+    }
+  }
+  return { ok: true, records: rows };
+}
 
 // src/cli/commands/lookup.ts
 async function createReadOnlyChainContext(rpc) {
@@ -268185,14 +268632,24 @@ function resolveCommitmentBuffer(cliValue) {
   }
   return parsed2;
 }
+function resolveRetryCount(cliValue) {
+  if (cliValue == null)
+    return 0;
+  const parsed2 = Number(cliValue);
+  if (!Number.isInteger(parsed2) || parsed2 < 0) {
+    throw new Error(`Invalid --retry "${cliValue}": must be a non-negative integer`);
+  }
+  return parsed2;
+}
 function attachRegisterCommand(root) {
   const registerCommand = root.command("register").description("Domain registration commands");
-  const domainCommand = registerCommand.command("domain").description("Register a new base domain").option("-n, --name <label>", "Domain label to register (without .dot)").option("-r, --reverse", "Enable reverse record registration", false).option("-g, --governance", "Use governance registration path", false).option("-o, --owner <address>", "Register on behalf of another address (EVM, SS58, or .dot label). Caller pays price + transferFloor friction; owner receives the NFT. Mutually exclusive with --transfer, --reverse, --governance.").option("--transfer", "Transfer domain after registration", false).option("--to <destination>", "Transfer destination (EVM address, SS58, or domain label)").option("--cb, --commitment-buffer <seconds>", `Extra seconds to wait after minCommitmentAge (default: ${DEFAULT_COMMITMENT_BUFFER_SECONDS}, env: DOTNS_COMMITMENT_BUFFER)`).option("--json", "Output result as JSON (suppresses all other output)", false).action(async (options2, cmd) => {
+  const domainCommand = registerCommand.command("domain").description("Register a new base domain").option("-n, --name <label>", "Domain label to register (without .dot)").option("-r, --reverse", "Enable reverse record registration", false).option("-g, --governance", "Use governance registration path", false).option("-o, --owner <address>", "Register on behalf of another address (EVM, SS58, or .dot label). Caller pays price + transferFloor friction; owner receives the NFT. Mutually exclusive with --transfer, --reverse, --governance.").option("--transfer", "Transfer domain after registration", false).option("--to <destination>", "Transfer destination (EVM address, SS58, or domain label)").option("--cb, --commitment-buffer <seconds>", `Extra seconds to wait after minCommitmentAge (default: ${DEFAULT_COMMITMENT_BUFFER_SECONDS}, env: DOTNS_COMMITMENT_BUFFER)`).option("--retry <count>", "On failure, resume from the cached commitment up to N times before giving up").option("--json", "Output result as JSON (suppresses all other output)", false).action(async (options2, cmd) => {
     const jsonOutput = getJsonFlag(cmd);
     try {
       const merged = { ...options2, ...getAuthOptions(cmd) };
       const allOpts = typeof cmd.optsWithGlobals === "function" ? cmd.optsWithGlobals() : cmd.opts();
       merged.commitmentBuffer = resolveCommitmentBuffer(allOpts?.commitmentBuffer);
+      merged.retry = resolveRetryCount(allOpts?.retry);
       if (merged.transfer === true && !merged.to) {
         throw new Error("Missing transfer destination: use --to <evm|ss58|label>");
       }
@@ -268216,6 +268673,54 @@ function attachRegisterCommand(root) {
     }
   });
   addAuthOptions(subnameCommand);
+  const retryCommand = registerCommand.command("retry [name]").description("Resume a cached commit-reveal registration").option("--cb, --commitment-buffer <seconds>", `Extra seconds to wait after minCommitmentAge (default: ${DEFAULT_COMMITMENT_BUFFER_SECONDS}, env: DOTNS_COMMITMENT_BUFFER)`).option("--json", "Output result as JSON (suppresses all other output)", false).action(async (name10, options2, cmd) => {
+    const jsonOutput = getJsonFlag(cmd);
+    try {
+      const merged = { ...options2, ...getAuthOptions(cmd) };
+      if (name10)
+        merged.name = name10;
+      const allOpts = typeof cmd.optsWithGlobals === "function" ? cmd.optsWithGlobals() : cmd.opts();
+      merged.commitmentBuffer = resolveCommitmentBuffer(allOpts?.commitmentBuffer);
+      const result = await maybeQuiet(jsonOutput, () => executeRetry(merged));
+      emitJsonResult(jsonOutput, result);
+      process.exit(0);
+    } catch (error2) {
+      handleCommandError(jsonOutput, error2);
+    }
+  });
+  addAuthOptions(retryCommand);
+  const clearCommand = registerCommand.command("clear [name]").description("Review cached commitments, purging completed ones").option("--discard", "Delete pending cached commitments", false).option("--register", "Complete pending cached commitments", false).option("--json", "Output result as JSON (suppresses all other output)", false).action(async (name10, options2, cmd) => {
+    const jsonOutput = getJsonFlag(cmd);
+    try {
+      if (options2.discard && options2.register) {
+        throw new Error("Cannot combine --discard with --register; pick one");
+      }
+      const merged = {
+        ...options2,
+        ...getAuthOptions(cmd)
+      };
+      if (name10)
+        merged.name = name10;
+      const result = await maybeQuiet(jsonOutput, () => executeClear(merged));
+      emitJsonResult(jsonOutput, result);
+      process.exit(0);
+    } catch (error2) {
+      handleCommandError(jsonOutput, error2);
+    }
+  });
+  addAuthOptions(clearCommand);
+  const listCommand = registerCommand.command("list").description("List cached commitments and their on-chain status").option("--json", "Output result as JSON (suppresses all other output)", false).action(async (options2, cmd) => {
+    const jsonOutput = getJsonFlag(cmd);
+    try {
+      const merged = { ...options2, ...getAuthOptions(cmd) };
+      const result = await maybeQuiet(jsonOutput, () => executeList(merged));
+      emitJsonResult(jsonOutput, result);
+      process.exit(0);
+    } catch (error2) {
+      handleCommandError(jsonOutput, error2);
+    }
+  });
+  addAuthOptions(listCommand);
 }
 
 // src/cli/commands/info.ts

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@parity/dotns-cli",
   "module": "index.ts",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "type": "module",
+  "license": "MIT",
   "packageManager": "bun@1.2.6",
   "files": [
     "dist"