@parity/product-deploy 0.11.0 → 0.12.0-rc.1

package/dist/{chunk-UUJFLJKY.js → chunk-OOGXTHVQ.js}

@@ -1,6 +1,6 @@
 import {
   preflightSssAllowance
-} from "./chunk-7RYEYWYO.js";
+} from "./chunk-BH7DJ5IW.js";
 import {
   statementSigningAccount
 } from "./chunk-GRPLHUYC.js";
@@ -31,16 +31,18 @@ import {
 } from "./chunk-S7EM5VMW.js";
 import {
   setDeployContext
-} from "./chunk-HTZGBUZA.js";
+} from "./chunk-W2OSH4GD.js";
 import {
-  probeChunks
-} from "./chunk-HLXRVFKL.js";
+  getBestBlockNumber,
+  probeChunks,
+  probeFinalityGap
+} from "./chunk-FVPRBTHT.js";
 import {
   packSection
 } from "./chunk-C2TS5MER.js";
 import {
   resolveStorageSigner
-} from "./chunk-QDHLTSEO.js";
+} from "./chunk-PXEFWMJP.js";
 import {
   createSlotAccountSigner,
   requestResourceAllocation
@@ -49,7 +51,7 @@ import {
   STALE_SESSION_MESSAGE,
   getPeopleChainEndpoints,
   hasPersistedSession
-} from "./chunk-JWMHCW74.js";
+} from "./chunk-2NF6QIDF.js";
 import {
   CLI_NAME
 } from "./chunk-TSPERKUS.js";
@@ -62,7 +64,7 @@ import {
   parseDomainName,
   popStatusName,
   verifyNonceAdvanced
-} from "./chunk-O4I37F5K.js";
+} from "./chunk-5BE5PQH6.js";
 import {
   derivePoolAccounts,
   detectTestnet,
@@ -70,7 +72,7 @@ import {
   fetchPoolAuthorizations,
   isAuthorizationSufficient,
   selectAccount
-} from "./chunk-MRQPJLPS.js";
+} from "./chunk-XVQICFTB.js";
 import {
   VERSION,
   captureWarning,
@@ -84,7 +86,7 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-53BU4X2R.js";
+} from "./chunk-52F2ETEG.js";
 import {
   DEFAULT_ENV_ID,
   getPopSelfServeConfig,
@@ -339,27 +341,58 @@ async function waitForBulletinAuthorization(ss58, opts = {}) {
     client.destroy();
   }
 }
-async function getSlotSignerProvider(signer, ss58) {
-  const primary = BULLETIN_ENDPOINTS[0];
-  console.log(`   Connecting to Bulletin (slot signer): ${primary}`);
-  const client = createPolkadotClient(getWsProvider(
-    BULLETIN_ENDPOINTS,
-    { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS, onStatusChanged: makeBulletinStatusHandler(primary) }
-  ));
-  const unsafeApi = client.getUnsafeApi();
-  const [auth, currentBlock] = await Promise.all([
-    unsafeApi.query.TransactionStorage.Authorizations.getValue(Enum("Account", ss58)),
-    client.getFinalizedBlock()
-  ]);
-  const result = isBulletinAuthActive(auth, currentBlock.number);
-  if (!result.active) {
-    client.destroy();
-    throw new BulletinSlotAuthError(result.reason, ss58, result.expiration);
+async function withTransientRetry(attempt, opts = {}) {
+  const { retries = 2, delayMs = 1e3 } = opts;
+  const debug = Boolean(process.env.DOT_DEBUG);
+  let lastErr;
+  for (let i = 0; i <= retries; i++) {
+    try {
+      return await attempt();
+    } catch (e) {
+      if (e instanceof BulletinSlotAuthError) throw e;
+      lastErr = e;
+      if (i < retries) {
+        if (debug) {
+          console.error(
+            `[slot-signer] transient error (attempt ${i + 1}/${retries + 1}): ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+        await new Promise((r) => setTimeout(r, delayMs));
+      }
+    }
   }
-  console.log(`   Using slot signer: ${ss58} (authorized until block ${result.expiration})`);
-  setDeployAttribute("deploy.signer.mode", "slot");
-  setDeployAttribute("deploy.signer.address", truncateAddress(ss58));
-  return { client, unsafeApi, signer, ss58 };
+  throw lastErr;
+}
+async function getSlotSignerProvider(signer, ss58) {
+  return withTransientRetry(async () => {
+    const primary = BULLETIN_ENDPOINTS[0];
+    console.log(`   Connecting to Bulletin (slot signer): ${primary}`);
+    const client = createPolkadotClient(getWsProvider(
+      BULLETIN_ENDPOINTS,
+      { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS, onStatusChanged: makeBulletinStatusHandler(primary) }
+    ));
+    const unsafeApi = client.getUnsafeApi();
+    let auth;
+    let currentBlock;
+    try {
+      [auth, currentBlock] = await Promise.all([
+        unsafeApi.query.TransactionStorage.Authorizations.getValue(Enum("Account", ss58)),
+        client.getFinalizedBlock()
+      ]);
+    } catch (e) {
+      client.destroy();
+      throw e;
+    }
+    const result = isBulletinAuthActive(auth, currentBlock.number);
+    if (!result.active) {
+      client.destroy();
+      throw new BulletinSlotAuthError(result.reason, ss58, result.expiration);
+    }
+    console.log(`   Using slot signer: ${ss58} (authorized until block ${result.expiration})`);
+    setDeployAttribute("deploy.signer.mode", "slot");
+    setDeployAttribute("deploy.signer.address", truncateAddress(ss58));
+    return { client, unsafeApi, signer, ss58 };
+  });
 }
 
 // src/deploy.ts
@@ -400,15 +433,28 @@ var MAX_RECONNECTIONS = parseInt(process.env.BULLETIN_MAX_RECONNECTIONS ?? "3",
 var CHUNK_TIMEOUT_MS = parseInt(process.env.BULLETIN_CHUNK_TIMEOUT_MS ?? "180000", 10);
 var CHUNK_MORTALITY_PERIOD = (() => {
   const v = parseInt(process.env.BULLETIN_CHUNK_MORTALITY_PERIOD ?? "", 10);
-  return Number.isFinite(v) && v > 0 ? v : 16;
+  return Number.isFinite(v) && v > 0 ? v : 64;
 })();
+var CHUNK_LIVENESS_MAX_WAIT_MS = parseInt(process.env.BULLETIN_CHUNK_LIVENESS_MAX_WAIT_MS ?? "60000", 10);
+var CHUNK_LIVENESS_POLL_MS = 5e3;
 var RETRY_BASE_DELAY_MS = 2e3;
 var RETRY_MAX_DELAY_MS = 15e3;
 var WS_HEARTBEAT_TIMEOUT_MS = 3e5;
-var GRANDPA_NATURAL_WAIT_MS = parseInt(process.env.BULLETIN_GRANDPA_NATURAL_WAIT_MS ?? "90000", 10);
+var GRANDPA_NATURAL_WAIT_MS = parseInt(process.env.BULLETIN_GRANDPA_NATURAL_WAIT_MS ?? "210000", 10);
 var GRANDPA_REUPLOAD_POLL_MS = 5e3;
-var GRANDPA_REUPLOAD_TIMEOUT_MS = 12e4;
+var GRANDPA_REUPLOAD_TIMEOUT_MS = parseInt(process.env.BULLETIN_GRANDPA_REUPLOAD_TIMEOUT_MS ?? "120000", 10);
 var GRANDPA_REUPLOAD_MAX_ROUNDS = 3;
+var GRANDPA_LAGGING_WAIT_MS = parseInt(process.env.BULLETIN_GRANDPA_LAGGING_WAIT_MS ?? "90000", 10);
+async function pollUntilFinalized(cids, timeoutMs, client) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs && cids.size > 0) {
+    await new Promise((r) => setTimeout(r, GRANDPA_REUPLOAD_POLL_MS));
+    const poll = await probeChunks([...cids], { client, atFinalized: true });
+    for (const r of poll) {
+      if (r.present === true) cids.delete(r.cid);
+    }
+  }
+}
 var RETRY_BUDGET_MAX_EVENTS = parseInt(process.env.BULLETIN_RETRY_BUDGET_MAX ?? "5", 10);
 var RETRY_BUDGET_WINDOW_MS = parseInt(process.env.BULLETIN_RETRY_BUDGET_WINDOW_MS ?? "30000", 10);
 function retryBudgetExhausted(history, maxEvents, windowMs, now = Date.now()) {
@@ -621,6 +667,12 @@ function formatTransferModeStorageSignerLine(workerAddress) {
 function formatTransferModeDotnsLine(alreadyOwned, dotName, recipient) {
   return alreadyOwned ? `   DotNS: you already own ${dotName} \u2014 content update needs your phone signature (no transfer)` : `   DotNS: will register ${dotName} and transfer it to your account ${recipient}`;
 }
+function describeSlotFallbackReason(e) {
+  if (e instanceof BulletinSlotAuthError) {
+    return e.reason === "expired" && e.expiration != null ? `expired at block ${e.expiration}` : "no on-chain authorization found";
+  }
+  return e instanceof Error ? e.message : String(e);
+}
 function selectStorageReconnect(options) {
   if (options.storageSigner && options.storageSignerAddress) {
     let useSlot = true;
@@ -631,12 +683,8 @@ function selectStorageReconnect(options) {
       } catch (e) {
         useSlot = false;
         setDeployAttribute("deploy.signer.mode", "pool-fallback");
-        let reason;
-        if (e instanceof BulletinSlotAuthError) {
-          reason = e.reason === "expired" && e.expiration != null ? `expired at block ${e.expiration}` : "no on-chain authorization found";
-        } else {
-          reason = e instanceof Error ? e.message : String(e);
-        }
+        const reason = describeSlotFallbackReason(e);
+        setDeployAttribute("deploy.signer.fallback_reason", reason);
         console.warn(
           `\u26A0  Bulletin allowance slot not usable: ${reason}
    Falling back to the shared pool account for storage (fine on testnet).
@@ -713,6 +761,26 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
     });
   });
 }
+function reconcileTimedOutChunk(opts) {
+  const { originalNonce, currentNonce, nonceHeuristicValid, cidPresentAtBest } = opts;
+  if (cidPresentAtBest === true) return true;
+  if (nonceHeuristicValid && originalNonce !== void 0 && originalNonce < currentNonce) return true;
+  return false;
+}
+async function waitForChainLiveness(client, lastHeight, timeoutMs, pollMs = CHUNK_LIVENESS_POLL_MS) {
+  if (lastHeight == null) return getBestBlockNumber(client);
+  const deadline = Date.now() + timeoutMs;
+  let height = lastHeight;
+  while (Date.now() < deadline) {
+    const h = await getBestBlockNumber(client);
+    if (h == null) return height;
+    height = h;
+    if (height > lastHeight) return height;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return height;
+}
+var __waitForChainLivenessForTest = waitForChainLiveness;
 async function storeChunk(unsafeApi, signer, chunkBytes, nonce, ss58, opts = {}) {
   const cid = createCID(chunkBytes, CID_CONFIG.codec, CID_CONFIG.hashCode);
   const tx = unsafeApi.tx.TransactionStorage.store_with_cid_config({ cid: { codec: BigInt(CID_CONFIG.codec), hashing: toHashingEnum(CID_CONFIG.hashCode) }, data: chunkBytes });
@@ -1062,8 +1130,14 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
           try {
             const currentNonce = await _fetchNonce(BULLETIN_ENDPOINTS, ss58);
             const originalNonce = assignedNonces.get(fail.index);
-            if (!perRetryChanged && originalNonce !== void 0 && originalNonce < currentNonce) {
-              console.log(`   Chunk ${fail.index}: nonce ${originalNonce} consumed (current=${currentNonce}), treating as included`);
+            let cidPresentAtBest = null;
+            try {
+              const [probe] = await probeChunks([failCid.toString()], { client });
+              cidPresentAtBest = probe.present === true ? true : null;
+            } catch {
+            }
+            if (reconcileTimedOutChunk({ originalNonce, currentNonce, nonceHeuristicValid: !perRetryChanged, cidPresentAtBest })) {
+              console.log(`   Chunk ${fail.index}: reconcile found it already included (nonce ${originalNonce}\u2192${currentNonce}${cidPresentAtBest ? ", CID present at best-block" : ""}) \u2014 skipping resubmit`);
               stored[fail.index] = { cid: createCID(fail.chunkData, CID_CONFIG.codec, 18), len: fail.chunkData.length, viaFallback: true };
               nonceAdvanceIndices.add(fail.index);
               assignedNonces.delete(fail.index);
@@ -1071,6 +1145,11 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
               retried = true;
               break;
             }
+            const heightBefore = await getBestBlockNumber(client);
+            const heightAfter = await waitForChainLiveness(client, heightBefore, CHUNK_LIVENESS_MAX_WAIT_MS);
+            if (heightBefore != null && heightAfter != null && heightAfter <= heightBefore) {
+              console.log(`   Chunk ${fail.index}: chain still frozen at block ${heightBefore} after ${(CHUNK_LIVENESS_MAX_WAIT_MS / 1e3).toFixed(0)}s wait \u2014 resubmitting anyway`);
+            }
             const retryNonce = originalNonce ?? currentNonce;
             const result2 = await storeChunk(unsafeApi, signer, fail.chunkData, retryNonce, ss58, { fetchNonce: fetchNonceOverride });
             stored[fail.index] = result2;
@@ -1662,23 +1741,27 @@ async function storeDirectoryV2(directoryPath, opts = {}) {
     let missingCids = new Set(finalityResults.filter((r) => r.present === false).map((r) => r.cid));
     setDeployAttribute("deploy.probe.finality_miss_count", missingCids.size);
     let reuploadCount = 0;
+    let laggingFinalityCount = 0;
     if (missingCids.size === 0) {
       console.log(`   \u2713 All ${grandpaCids.length} chunks finalised`);
     } else {
       console.log(`   ${missingCids.size} chunks not yet finalised \u2014 waiting up to ${GRANDPA_NATURAL_WAIT_MS / 1e3}s for natural finalisation`);
       for (const cid of missingCids) console.log(`      ${cid.slice(0, 20)}\u2026`);
       const waitStart = Date.now();
-      while (Date.now() - waitStart < GRANDPA_NATURAL_WAIT_MS && missingCids.size > 0) {
-        await new Promise((r) => setTimeout(r, GRANDPA_REUPLOAD_POLL_MS));
-        const poll = await probeChunks([...missingCids], { client: phaseALiveProvider.client, atFinalized: true });
-        for (const r of poll) {
-          if (r.present === true) missingCids.delete(r.cid);
-        }
-      }
+      await pollUntilFinalized(missingCids, GRANDPA_NATURAL_WAIT_MS, phaseALiveProvider.client);
       if (missingCids.size === 0) {
         const elapsed = Math.round((Date.now() - waitStart) / 1e3);
         console.log(`   \u2713 All ${grandpaCids.length} chunks finalised (waited ${elapsed}s)`);
       } else {
+        const stillMissing = [...missingCids];
+        const { reallyMissing, lagging } = await probeFinalityGap(stillMissing, { client: phaseALiveProvider.client });
+        const laggingCids = new Set(lagging);
+        laggingFinalityCount = laggingCids.size;
+        missingCids = new Set(reallyMissing);
+        setDeployAttribute("deploy.probe.finality_lagging_count", laggingFinalityCount);
+        if (laggingCids.size > 0) {
+          console.log(`   ${laggingCids.size} chunk(s) present in best-block but finality-lagging \u2014 will NOT re-upload, waiting for GRANDPA (bounded)`);
+        }
         const rootHashCode = 18;
         const rootChunkLinks = phaseB.chunks.map((c) => ({
           cid: createCID(c, CID_CONFIG.codec, rootHashCode),
@@ -1737,14 +1820,7 @@ async function storeDirectoryV2(directoryPath, opts = {}) {
             }
             throw e;
           }
-          const reuploadStart = Date.now();
-          while (Date.now() - reuploadStart < GRANDPA_REUPLOAD_TIMEOUT_MS && missingCids.size > 0) {
-            await new Promise((r) => setTimeout(r, GRANDPA_REUPLOAD_POLL_MS));
-            const poll = await probeChunks([...missingCids], { client: phaseALiveProvider.client, atFinalized: true });
-            for (const r of poll) {
-              if (r.present === true) missingCids.delete(r.cid);
-            }
-          }
+          await pollUntilFinalized(missingCids, GRANDPA_REUPLOAD_TIMEOUT_MS, phaseALiveProvider.client);
         }
         if (missingCids.size > 0) {
           const stuck = [...missingCids][0];
@@ -1752,7 +1828,21 @@ async function storeDirectoryV2(directoryPath, opts = {}) {
             `Deploy verification failed: ${missingCids.size} chunk(s) not finalised after ${GRANDPA_REUPLOAD_MAX_ROUNDS} re-upload round(s) (first: ${stuck.slice(0, 20)}\u2026). The chain may have dropped chunks due to a persistent fork. Re-run deploy.`
           );
         }
-        console.log(`   \u2713 All ${grandpaCids.length} chunks finalised after re-upload`);
+        if (reuploadCount > 0) {
+          console.log(`   \u2713 All ${grandpaCids.length - laggingFinalityCount} chunks finalised after re-upload`);
+        } else {
+          console.log(`   \u2713 No chunks genuinely missing from best-block \u2014 skipped re-upload entirely`);
+        }
+        if (laggingCids.size > 0) {
+          await pollUntilFinalized(laggingCids, GRANDPA_LAGGING_WAIT_MS, phaseALiveProvider.client);
+          if (laggingCids.size === 0) {
+            console.log(`   \u2713 finality-lagging chunk(s) caught up`);
+          } else {
+            console.warn(
+              `   \u26A0 ${laggingCids.size} chunk(s) still not finalised after extended wait, but confirmed present in best-block \u2014 deploy succeeds; finality pending asynchronously`
+            );
+          }
+        }
       }
     }
     setDeployAttribute("deploy.probe.finality_miss_reupload_count", reuploadCount);
@@ -1833,11 +1923,14 @@ async function storeDirectoryV2(directoryPath, opts = {}) {
   console.log(`   Final root check: ${storageCid}`);
   const rootProbe = await probeChunks([storageCid], { client: phaseALiveProvider.client, atFinalized: true });
   if (rootProbe[0]?.present === false) {
-    throw new Error(
-      `Deploy verification failed: DAG-PB root ${storageCid.slice(0, 20)}\u2026 not finalised. The chain may have evicted the root extrinsic. Re-run deploy.`
-    );
-  }
-  if (rootProbe[0]?.present === true) {
+    const { reallyMissing } = await probeFinalityGap([storageCid], { client: phaseALiveProvider.client });
+    if (reallyMissing.length > 0) {
+      throw new Error(
+        `Deploy verification failed: DAG-PB root ${storageCid.slice(0, 20)}\u2026 not finalised and not present in best-block. The chain may have evicted the root extrinsic. Re-run deploy.`
+      );
+    }
+    console.log(`   Root confirmed present in best-block (finality-lagging, #1049) \u2014 treating as success.`);
+  } else if (rootProbe[0]?.present === true) {
     console.log(`   \u2713 Root finalised on chain`);
   } else {
     console.log(`   Root re-check inconclusive (RPC error) \u2014 GRANDPA probe above already verified; continuing.`);
@@ -3008,6 +3101,7 @@ export {
   isBulletinAuthActive,
   pollUntilBulletinAuthorized,
   waitForBulletinAuthorization,
+  withTransientRetry,
   getSlotSignerProvider,
   friendlyChainError,
   DEFAULT_BULLETIN_RPC,
@@ -3039,6 +3133,9 @@ export {
   formatStorageSignerLine,
   formatTransferModeStorageSignerLine,
   formatTransferModeDotnsLine,
+  describeSlotFallbackReason,
+  reconcileTimedOutChunk,
+  __waitForChainLivenessForTest,
   storeFile,
   __assignDenseNoncesForTest,
   storeChunkedContent,

package/dist/{chunk-QDHLTSEO.js → chunk-PXEFWMJP.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-5FLTDWWP.js";
 import {
   DOT_PRODUCT_ID
-} from "./chunk-JWMHCW74.js";
+} from "./chunk-2NF6QIDF.js";
 import {
   DEFAULT_MNEMONIC
-} from "./chunk-O4I37F5K.js";
+} from "./chunk-5BE5PQH6.js";
 
 // src/deploy-actors.ts
 var DEFAULT_WORKER_SURI = DEFAULT_MNEMONIC;

package/dist/{chunk-7E33R3OQ.js → chunk-VIZ6GBQE.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-53BU4X2R.js";
+} from "./chunk-52F2ETEG.js";
 
 // src/version-check.ts
 import { execSync, execFileSync } from "child_process";

package/dist/{chunk-HTZGBUZA.js → chunk-W2OSH4GD.js}

@@ -2,15 +2,15 @@ import {
   classifyErrorArea,
   isInteractive,
   promptYesNo
-} from "./chunk-7E33R3OQ.js";
+} from "./chunk-VIZ6GBQE.js";
 import {
   VERSION,
   getCurrentSentryTraceId,
   resolveIssueRepoSlug
-} from "./chunk-53BU4X2R.js";
+} from "./chunk-52F2ETEG.js";
 import {
   package_default
-} from "./chunk-SES7CGNY.js";
+} from "./chunk-BXW5MBBY.js";
 
 // src/bug-report.ts
 import { execSync, execFileSync } from "child_process";

package/dist/{chunk-MRQPJLPS.js → chunk-XVQICFTB.js}

@@ -37,6 +37,15 @@ function isAuthorizationSufficient(auth, currentBlock) {
 function accountsNeedingAuthorization(auths, currentBlock) {
   return auths.filter((a) => !isAuthorizationSufficient(a, currentBlock));
 }
+var BULLETIN_BLOCK_TIME_SECS = 6;
+var BULLETIN_BLOCKS_PER_DAY = Math.floor(86400 / BULLETIN_BLOCK_TIME_SECS);
+function accountsNeedingReauthorization(auths, currentBlock, bufferBlocks = BULLETIN_BLOCKS_PER_DAY) {
+  const deadline = currentBlock + bufferBlocks;
+  return auths.filter((a) => !isAuthorizationSufficient(a, deadline));
+}
+function isAutoReauthorizeAllowed(env) {
+  return env?.network !== "mainnet" && env?.bulletinAutoAuthorize === true;
+}
 function selectAccount(authorizations, random = Math.random, pinnedIndex) {
   if (pinnedIndex != null) {
     const pinned = authorizations.find((a) => a.index === pinnedIndex);
@@ -164,13 +173,21 @@ async function bootstrapPool(bulletinRpc, poolSize = 10, mnemonic, opts = {}) {
       printAuthStatus(a, currentBlock);
     }
     console.log("");
-    const needsAuth = accountsNeedingAuthorization(auths, currentBlock);
+    const reauthBufferBlocks = opts.reauthBufferBlocks ?? 0;
+    const needsAuth = accountsNeedingReauthorization(auths, currentBlock, reauthBufferBlocks);
     if (needsAuth.length === 0) {
       console.log("All pool accounts are authorized. Nothing to do.");
       return;
     }
     console.log(`${needsAuth.length} account(s) need authorization.
 `);
+    if (reauthBufferBlocks > 0 && !opts.allowAutoReauthorize) {
+      const details = needsAuth.map((a) => `  [${a.index}] ${a.address} \u2014 expires @${a.expiration} (current block ${currentBlock})`).join("\n");
+      throw new Error(
+        `Auto-reauthorize is testnet-only (see isAutoReauthorizeAllowed / environments.json bulletinAutoAuthorize) and this call was not cleared to write. ${needsAuth.length} account(s) need reauthorization within the ${reauthBufferBlocks}-block buffer:
+${details}`
+      );
+    }
     let authorizerSigner;
     const keyring = new Keyring({ type: "sr25519" });
     if (opts.authorizerMnemonic) {
@@ -228,6 +245,10 @@ export {
   derivePoolAccounts,
   isAuthorizationSufficient,
   accountsNeedingAuthorization,
+  BULLETIN_BLOCK_TIME_SECS,
+  BULLETIN_BLOCKS_PER_DAY,
+  accountsNeedingReauthorization,
+  isAutoReauthorizeAllowed,
   selectAccount,
   fetchPoolAuthorizations,
   isTestnetSpecName,

package/dist/chunk-probe.d.ts

@@ -29,9 +29,51 @@ declare function _decodeStorageValue(hex: string | null | undefined): {
     index: number;
 } | null;
 declare function probeChunks(cids: string[], options: ChainProbeOptions): Promise<ChunkProbeResult[]>;
+/**
+ * Splits cids that are missing at finalised head into two buckets, using a
+ * best-block probe result for each cid:
+ *   - `lagging`: present at best-block. GRANDPA just hasn't caught up yet
+ *     (#1049) — these were never lost and must NEVER be re-uploaded.
+ *   - `reallyMissing`: absent at best-block too (or the best-block probe
+ *     itself failed, `present === null`) — genuinely dropped, or we
+ *     couldn't determine presence at all. Either way, re-upload is the
+ *     safe default: treating an indeterminate result as "lagging" risks
+ *     silently skipping a chunk that's actually gone.
+ *
+ * Pure function — no chain I/O — so it's directly unit-testable against a
+ * mocked ChunkProbeResult array without a client.
+ */
+declare function classifyFinalityGap(missingAtFinalized: string[], bestBlockResults: ChunkProbeResult[]): {
+    reallyMissing: string[];
+    lagging: string[];
+};
+/**
+ * Composite, chain-touching version of classifyFinalityGap (#1049): probes
+ * `missingAtFinalized` at best-block, retries once on an indeterminate
+ * result (present === null), then classifies. Any caller that finds cids
+ * missing at finalised head should route through this — not re-implement
+ * the probe/retry/classify sequence inline — so the "finalised-head absence
+ * is not proof of loss" policy stays consistent everywhere it's checked
+ * (the GRANDPA finality-check phase and the pre-setContenthash root
+ * re-check both use it).
+ */
+declare function probeFinalityGap(missingAtFinalized: string[], options: ChainProbeOptions): Promise<{
+    reallyMissing: string[];
+    lagging: string[];
+}>;
+/**
+ * Best (non-finalised) block height, via `chain_getHeader`. Used by the
+ * initial chunk-upload retry loop (#1051) to detect a frozen chain — no new
+ * blocks since the last check — so it can wait instead of resubmitting into
+ * a stall (which just manufactures same-nonce collisions once the chain
+ * resumes). Returns `null` on any RPC failure or malformed response; callers
+ * must treat `null` as "can't tell" and fail open (proceed as if live)
+ * rather than blocking forever on a single bad peer.
+ */
+declare function getBestBlockNumber(client: any): Promise<number | null>;
 /** Reset session-level caches. Used in tests only. */
 declare function _resetProbeSession(): void;
 /** Pre-set metadataChecked so tests don't need a real metadata RPC mock. Used in tests only. */
 declare function _bypassMetadataCheckForTest(): void;
 
-export { ChainProbeCrossValidationError, ChainProbeMetadataError, type ChainProbeOptions, type ChunkProbeFailureReason, type ChunkProbeResult, _bypassMetadataCheckForTest, _decodeStorageValue, _resetProbeSession, probeChunks };
+export { ChainProbeCrossValidationError, ChainProbeMetadataError, type ChainProbeOptions, type ChunkProbeFailureReason, type ChunkProbeResult, _bypassMetadataCheckForTest, _decodeStorageValue, _resetProbeSession, classifyFinalityGap, getBestBlockNumber, probeChunks, probeFinalityGap };

package/dist/chunk-probe.js

@@ -4,15 +4,21 @@ import {
   _bypassMetadataCheckForTest,
   _decodeStorageValue,
   _resetProbeSession,
-  probeChunks
-} from "./chunk-HLXRVFKL.js";
-import "./chunk-53BU4X2R.js";
-import "./chunk-SES7CGNY.js";
+  classifyFinalityGap,
+  getBestBlockNumber,
+  probeChunks,
+  probeFinalityGap
+} from "./chunk-FVPRBTHT.js";
+import "./chunk-52F2ETEG.js";
+import "./chunk-BXW5MBBY.js";
 export {
   ChainProbeCrossValidationError,
   ChainProbeMetadataError,
   _bypassMetadataCheckForTest,
   _decodeStorageValue,
   _resetProbeSession,
-  probeChunks
+  classifyFinalityGap,
+  getBestBlockNumber,
+  probeChunks,
+  probeFinalityGap
 };

package/dist/commands/login.js

@@ -3,10 +3,10 @@ import {
 } from "../chunk-J7CYVTAW.js";
 import {
   waitForBulletinAuthorization
-} from "../chunk-UUJFLJKY.js";
+} from "../chunk-OOGXTHVQ.js";
 import {
   preflightSssAllowance
-} from "../chunk-7RYEYWYO.js";
+} from "../chunk-BH7DJ5IW.js";
 import {
   statementSigningAccount
 } from "../chunk-GRPLHUYC.js";
@@ -15,11 +15,11 @@ import "../chunk-IW3X2MJF.js";
 import "../chunk-KOSF5FDO.js";
 import "../chunk-J3NIXHZZ.js";
 import "../chunk-S7EM5VMW.js";
-import "../chunk-HTZGBUZA.js";
-import "../chunk-7E33R3OQ.js";
-import "../chunk-HLXRVFKL.js";
+import "../chunk-W2OSH4GD.js";
+import "../chunk-VIZ6GBQE.js";
+import "../chunk-FVPRBTHT.js";
 import "../chunk-C2TS5MER.js";
-import "../chunk-QDHLTSEO.js";
+import "../chunk-PXEFWMJP.js";
 import "../chunk-JQKKMUCT.js";
 import {
   BULLETIN_RESOURCE,
@@ -36,15 +36,15 @@ import {
   getAuthClient,
   getPeopleChainEndpoints,
   resolveBulletinEndpoints
-} from "../chunk-JWMHCW74.js";
+} from "../chunk-2NF6QIDF.js";
 import {
   CLI_NAME
 } from "../chunk-TSPERKUS.js";
-import "../chunk-O4I37F5K.js";
+import "../chunk-5BE5PQH6.js";
 import "../chunk-SI2ZUOYD.js";
-import "../chunk-MRQPJLPS.js";
-import "../chunk-53BU4X2R.js";
-import "../chunk-SES7CGNY.js";
+import "../chunk-XVQICFTB.js";
+import "../chunk-52F2ETEG.js";
+import "../chunk-BXW5MBBY.js";
 import {
   loadEnvironments
 } from "../chunk-JSYQ3JQS.js";

package/dist/commands/logout.js

@@ -1,6 +1,6 @@
 import {
   clearSssAllowanceCache
-} from "../chunk-7RYEYWYO.js";
+} from "../chunk-BH7DJ5IW.js";
 import "../chunk-GRPLHUYC.js";
 import "../chunk-JQKKMUCT.js";
 import "../chunk-5FLTDWWP.js";
@@ -9,10 +9,10 @@ import {
 } from "../chunk-RIRDBSBG.js";
 import {
   getAuthClient
-} from "../chunk-JWMHCW74.js";
+} from "../chunk-2NF6QIDF.js";
 import "../chunk-TSPERKUS.js";
-import "../chunk-53BU4X2R.js";
-import "../chunk-SES7CGNY.js";
+import "../chunk-52F2ETEG.js";
+import "../chunk-BXW5MBBY.js";
 import "../chunk-JSYQ3JQS.js";
 import "../chunk-ZOC4GITL.js";
 

package/dist/commands/transfer.js

@@ -4,11 +4,11 @@ import {
 import {
   DEFAULT_MNEMONIC,
   DotNS
-} from "../chunk-O4I37F5K.js";
+} from "../chunk-5BE5PQH6.js";
 import "../chunk-SI2ZUOYD.js";
-import "../chunk-MRQPJLPS.js";
-import "../chunk-53BU4X2R.js";
-import "../chunk-SES7CGNY.js";
+import "../chunk-XVQICFTB.js";
+import "../chunk-52F2ETEG.js";
+import "../chunk-BXW5MBBY.js";
 import {
   getPopSelfServeConfig,
   loadEnvironments,

package/dist/commands/whoami.js

@@ -2,12 +2,12 @@ import {
   STALE_SESSION_MESSAGE,
   getAuthClient,
   hasPersistedSession
-} from "../chunk-JWMHCW74.js";
+} from "../chunk-2NF6QIDF.js";
 import {
   CLI_NAME
 } from "../chunk-TSPERKUS.js";
-import "../chunk-53BU4X2R.js";
-import "../chunk-SES7CGNY.js";
+import "../chunk-52F2ETEG.js";
+import "../chunk-BXW5MBBY.js";
 import "../chunk-JSYQ3JQS.js";
 import "../chunk-ZOC4GITL.js";