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

package/bin/bulletin-bootstrap

@@ -4,7 +4,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_BULLETIN_RPC, DEFAULT_POOL_SIZE } from "../dist/deploy.js";
-import { bootstrapPool } from "../dist/pool.js";
+import { bootstrapPool, BULLETIN_BLOCKS_PER_DAY, isAutoReauthorizeAllowed } from "../dist/pool.js";
 import { VERSION } from "../dist/telemetry.js";
 
 const args = process.argv.slice(2);
@@ -16,6 +16,7 @@ for (let i = 0; i < args.length; i++) {
   else if (args[i] === "--authorizer") { flags.authorizer = args[++i]; }
   else if (args[i] === "--rpc") { flags.rpc = args[++i]; }
   else if (args[i] === "--env") { flags.env = args[++i]; }
+  else if (args[i] === "--pre-check") { flags.preCheck = true; }
   else if (args[i] === "--version" || args[i] === "-V") { flags.version = true; }
   else if (args[i] === "--help" || args[i] === "-h") { flags.help = true; }
   else {
@@ -52,11 +53,22 @@ Options:
   --rpc wss://...     Bulletin RPC endpoint (or set BULLETIN_RPC env var)
   --env <id>          Load environment by id from environments.json
   --pool-size N       Number of pool accounts to check/initialize (default: 10)
+  --pre-check         E2E pre-flight mode (#1059): renew any account expiring
+                      within 24h, not just already-expired ones. Requires
+                      --env, and is hard-gated to environments where
+                      environments.json has network != "mainnet" and
+                      bulletinAutoAuthorize: true — refuses to write
+                      otherwise, even with --authorizer supplied.
   --version           Show version
   --help              Show this help`);
   process.exit(0);
 }
 
+if (flags.preCheck && !flags.env) {
+  console.error("Error: --pre-check requires --env <id>");
+  process.exit(1);
+}
+
 let rpc = flags.rpc ?? process.env.BULLETIN_RPC ?? DEFAULT_BULLETIN_RPC;
 const poolSize = flags.poolSize ?? parseInt(process.env.BULLETIN_POOL_SIZE ?? String(DEFAULT_POOL_SIZE), 10);
 const mnemonic = flags.mnemonic ?? process.env.BULLETIN_POOL_MNEMONIC ?? process.env.MNEMONIC;
@@ -94,6 +106,16 @@ if (flags.env) {
   }
 
   bootstrapOpts.bulletinAuthorizeV2 = envEntry.bulletinAuthorizeV2 ?? false;
+
+  if (flags.preCheck) {
+    // #1059: widen the "needs authorization" threshold to 24h-before-expiry,
+    // and hard-gate the actual write to environments cleared for it. This is
+    // a config-driven (environments.json) gate, not a CLI flag override —
+    // --pre-check can never itself grant write access on an env that isn't
+    // eligible.
+    bootstrapOpts.reauthBufferBlocks = BULLETIN_BLOCKS_PER_DAY;
+    bootstrapOpts.allowAutoReauthorize = isAutoReauthorizeAllowed(envEntry);
+  }
 }
 
 await bootstrapPool(rpc, poolSize, mnemonic, bootstrapOpts);

package/dist/auth-config.js

@@ -9,10 +9,10 @@ import {
   getPeopleChainEndpoints,
   hasPersistedSession,
   resolveBulletinEndpoints
-} from "./chunk-JWMHCW74.js";
+} from "./chunk-NRSIBGBP.js";
 import "./chunk-TSPERKUS.js";
-import "./chunk-53BU4X2R.js";
-import "./chunk-SES7CGNY.js";
+import "./chunk-LRJTODL2.js";
+import "./chunk-DDC6NKE3.js";
 import "./chunk-JSYQ3JQS.js";
 import "./chunk-ZOC4GITL.js";
 export {

package/dist/bug-report.js

@@ -10,10 +10,10 @@ import {
   offerBugReport,
   scrubSecrets,
   setDeployContext
-} from "./chunk-HTZGBUZA.js";
-import "./chunk-7E33R3OQ.js";
-import "./chunk-53BU4X2R.js";
-import "./chunk-SES7CGNY.js";
+} from "./chunk-IR5BHZ2S.js";
+import "./chunk-UPA5PEQA.js";
+import "./chunk-LRJTODL2.js";
+import "./chunk-DDC6NKE3.js";
 export {
   buildCliFlagsSummary,
   buildLabels,

package/dist/{chunk-SES7CGNY.js → chunk-DDC6NKE3.js}

@@ -6,7 +6,7 @@ import * as path from "path";
 // package.json
 var package_default = {
   name: "@parity/product-deploy",
-  version: "0.11.0",
+  version: "0.12.0-rc.2",
   private: false,
   repository: {
     type: "git",

package/dist/{chunk-TE2YKRYY.js → chunk-F4O42MUQ.js}

@@ -7,10 +7,10 @@ import {
   resolveDotnsConnectOptions,
   storeDirectory,
   storeFile
-} from "./chunk-UUJFLJKY.js";
+} from "./chunk-N7KXNIH4.js";
 import {
   DotNS
-} from "./chunk-O4I37F5K.js";
+} from "./chunk-S62H6TWE.js";
 import {
   getPopSelfServeConfig,
   loadEnvironments,

package/dist/{chunk-HLXRVFKL.js → chunk-FGCBIUMT.js}

@@ -1,6 +1,6 @@
 import {
   captureWarning
-} from "./chunk-53BU4X2R.js";
+} from "./chunk-LRJTODL2.js";
 
 // src/chunk-probe.ts
 import { Twox128, Blake2128Concat, decAnyMetadata, unifyMetadata } from "@polkadot-api/substrate-bindings";
@@ -166,6 +166,40 @@ async function probeChunks(cids, options) {
   }
   return results;
 }
+function classifyFinalityGap(missingAtFinalized, bestBlockResults) {
+  const presentAtBest = new Set(
+    bestBlockResults.filter((r) => r.present === true).map((r) => r.cid)
+  );
+  const lagging = [];
+  const reallyMissing = [];
+  for (const cid of missingAtFinalized) {
+    if (presentAtBest.has(cid)) lagging.push(cid);
+    else reallyMissing.push(cid);
+  }
+  return { reallyMissing, lagging };
+}
+async function probeFinalityGap(missingAtFinalized, options) {
+  if (missingAtFinalized.length === 0) return { reallyMissing: [], lagging: [] };
+  let bestBlockResults = await probeChunks(missingAtFinalized, { ...options, atFinalized: false });
+  const indeterminate = bestBlockResults.filter((r) => r.present === null).map((r) => r.cid);
+  if (indeterminate.length > 0) {
+    const retry = await probeChunks(indeterminate, { ...options, atFinalized: false });
+    const retryByCid = new Map(retry.map((r) => [r.cid, r]));
+    bestBlockResults = bestBlockResults.map((r) => r.present === null ? retryByCid.get(r.cid) ?? r : r);
+  }
+  return classifyFinalityGap(missingAtFinalized, bestBlockResults);
+}
+async function getBestBlockNumber(client) {
+  try {
+    const header = await client._request("chain_getHeader", []);
+    const hex = header?.number;
+    if (typeof hex !== "string") return null;
+    const n = parseInt(hex, 16);
+    return Number.isFinite(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
 function _resetProbeSession() {
   _metadataChecked = false;
   _crossValidated = false;
@@ -180,6 +214,9 @@ export {
   ChainProbeCrossValidationError,
   _decodeStorageValue,
   probeChunks,
+  classifyFinalityGap,
+  probeFinalityGap,
+  getBestBlockNumber,
   _resetProbeSession,
   _bypassMetadataCheckForTest
 };

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

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

package/dist/{chunk-7RYEYWYO.js → chunk-JGS6QR5X.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GRPLHUYC.js";
 import {
   DOT_DAPP_ID
-} from "./chunk-JWMHCW74.js";
+} from "./chunk-NRSIBGBP.js";
 
 // src/sss-allowance-cache.ts
 import { mkdir, readFile, writeFile, unlink } from "fs/promises";

package/dist/{chunk-53BU4X2R.js → chunk-LRJTODL2.js}

@@ -1,7 +1,7 @@
 import {
   package_default,
   writeRunState
-} from "./chunk-SES7CGNY.js";
+} from "./chunk-DDC6NKE3.js";
 
 // src/memory-report.ts
 import * as fs2 from "fs";
@@ -241,7 +241,11 @@ var DEPLOY_SEED_STORAGE = {
 };
 var DEPLOY_SEED_PROBE = {
   "deploy.probe.finality_miss_count": 0,
-  "deploy.probe.finality_miss_reupload_count": 0
+  "deploy.probe.finality_miss_reupload_count": 0,
+  // #1049: chunks present at best-block but not yet at finalised head.
+  // These are NEVER re-uploaded — only tracked so we can see finality lag
+  // without conflating it with genuinely-dropped (re-uploaded) chunks.
+  "deploy.probe.finality_lagging_count": 0
 };
 var DEPLOY_SEED_POOL = {
   "deploy.pool.eligible_count": 0,
@@ -337,6 +341,12 @@ var ERROR_KIND_RULES = [
   [/requires ProofOfPersonhood(?:Full|Lite|Light),\s*but this signer is NoStatus/i, "naming.pop_required"],
   [/requires NoStatus,\s*but this signer is ProofOfPersonhood/i, "naming.nostatus_required"],
   [/Cannot decode zero data.*with ABI parameters/i, "naming.contract_unavailable"],
+  // Issue #1060: contractCall's own empty-`0x`-data guard (src/dotns.ts, #729) throws
+  // an actionable wrapper instead of letting the raw viem message above reach a
+  // caller. Same failure family (a DotNS contract read came back empty) — classify
+  // it the same way instead of letting it fall into 'unknown'.
+  [/No contract deployed at .+ returned empty success data/i, "naming.contract_unavailable"],
+  [/Contract call returned empty data — contract=/i, "naming.contract_unavailable"],
   [/Domain\s+\S+\.dot\s+is already owned by\s+0x[a-fA-F0-9]+/i, "naming.already_owned"],
   [/Cannot deploy\s+[\w.-]+\.dot:\s*parent\s+[\w.-]+\.dot\s+is owned by/i, "naming.subdomain_orphan"],
   [/Post-deploy verification failed for .+: on-chain contenthash is /i, "verify.contenthash_mismatch"],

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

@@ -1,6 +1,6 @@
 import {
   preflightSssAllowance
-} from "./chunk-7RYEYWYO.js";
+} from "./chunk-JGS6QR5X.js";
 import {
   statementSigningAccount
 } from "./chunk-GRPLHUYC.js";
@@ -31,16 +31,18 @@ import {
 } from "./chunk-S7EM5VMW.js";
 import {
   setDeployContext
-} from "./chunk-HTZGBUZA.js";
+} from "./chunk-IR5BHZ2S.js";
 import {
-  probeChunks
-} from "./chunk-HLXRVFKL.js";
+  getBestBlockNumber,
+  probeChunks,
+  probeFinalityGap
+} from "./chunk-FGCBIUMT.js";
 import {
   packSection
 } from "./chunk-C2TS5MER.js";
 import {
   resolveStorageSigner
-} from "./chunk-QDHLTSEO.js";
+} from "./chunk-WVVRMGKN.js";
 import {
   createSlotAccountSigner,
   requestResourceAllocation
@@ -49,7 +51,7 @@ import {
   STALE_SESSION_MESSAGE,
   getPeopleChainEndpoints,
   hasPersistedSession
-} from "./chunk-JWMHCW74.js";
+} from "./chunk-NRSIBGBP.js";
 import {
   CLI_NAME
 } from "./chunk-TSPERKUS.js";
@@ -62,7 +64,7 @@ import {
   parseDomainName,
   popStatusName,
   verifyNonceAdvanced
-} from "./chunk-O4I37F5K.js";
+} from "./chunk-S62H6TWE.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-LRJTODL2.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-JWMHCW74.js → chunk-NRSIBGBP.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-TSPERKUS.js";
 import {
   VERSION
-} from "./chunk-53BU4X2R.js";
+} from "./chunk-LRJTODL2.js";
 import {
   loadEnvironments
 } from "./chunk-JSYQ3JQS.js";