bulletin-deploy 0.7.21 → 0.7.22-rc.1

package/dist/chunk-T7EEVWNU.js

@@ -0,0 +1,32 @@
+// src/personhood/constants.ts
+import { Binary } from "polkadot-api";
+var DOTNS_CONTEXT_HEX = "0x646f746e73000000000000000000000000000000000000000000000000000000";
+var DOTNS_CONTEXT_BYTES = Binary.fromHex(DOTNS_CONTEXT_HEX);
+var PGAS_ASSET_ID = 2e9;
+var PGAS_ASSET_LOCATION = {
+  parents: 0,
+  interior: {
+    type: "X2",
+    value: [
+      { type: "PalletInstance", value: 50 },
+      { type: "GeneralIndex", value: BigInt(PGAS_ASSET_ID) }
+    ]
+  }
+};
+var PROOF_BYTES = 788;
+var BANDERSNATCH_SIGNATURE_BYTES = 96;
+var PEOPLE_MEMBER_IDENTIFIER_HEX = "0x70656f706c652020202020202020202020202020202020202020202020202020";
+var MEMBER_ENTROPY_KEY = new TextEncoder().encode("candidate");
+var PAID_PROOF_TAG = new TextEncoder().encode("alias-accounts:paid");
+
+export {
+  DOTNS_CONTEXT_HEX,
+  DOTNS_CONTEXT_BYTES,
+  PGAS_ASSET_ID,
+  PGAS_ASSET_LOCATION,
+  PROOF_BYTES,
+  BANDERSNATCH_SIGNATURE_BYTES,
+  PEOPLE_MEMBER_IDENTIFIER_HEX,
+  MEMBER_ENTROPY_KEY,
+  PAID_PROOF_TAG
+};

package/dist/chunk-UPWEOGLQ.js

@@ -0,0 +1,37 @@
+// src/personhood/hashing.ts
+import { blake2b } from "@noble/hashes/blake2b";
+import { Binary } from "polkadot-api";
+var hexToBytes = (hex) => {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+};
+function blake2b256(data) {
+  let payload;
+  if (typeof data === "string") {
+    if (data.startsWith("0x")) {
+      payload = hexToBytes(data);
+    } else {
+      payload = Binary.fromText(data);
+    }
+  } else {
+    if (data[0] === 48 && data[1] === 120) {
+      const hexString = new TextDecoder().decode(data);
+      payload = hexToBytes(hexString);
+    } else {
+      payload = data;
+    }
+  }
+  return blake2b(payload, { dkLen: 32 });
+}
+function blake2b256Keyed(data, key) {
+  return blake2b(data, { key, dkLen: 32 });
+}
+
+export {
+  blake2b256,
+  blake2b256Keyed
+};

package/dist/{chunk-SA37SLYF.js → chunk-V5NUBOEX.js}

@@ -2,11 +2,11 @@ import {
   classifyErrorArea,
   isInteractive,
   promptYesNo
-} from "./chunk-RJAFD4LO.js";
+} from "./chunk-FSSKFXTZ.js";
 import {
   VERSION,
   getCurrentSentryTraceId
-} from "./chunk-2VNGK2MU.js";
+} from "./chunk-WNUWAA6F.js";
 
 // src/bug-report.ts
 import { execSync, execFileSync } from "child_process";

package/dist/{chunk-2VNGK2MU.js → chunk-WNUWAA6F.js}

@@ -1,7 +1,7 @@
 import {
   package_default,
   writeRunState
-} from "./chunk-G2P5UIPX.js";
+} from "./chunk-XWA3NPMX.js";
 
 // src/memory-report.ts
 import * as fs2 from "fs";
@@ -246,13 +246,26 @@ function computeDeployOutcome(errorCategory, isSad, sadReason) {
   if (isSad) return `sad_${sadReason}`;
   return "clean";
 }
+function classifyErrorKind(msg) {
+  if (/Contract reverted|Contract execution would revert|revert(?:ed|ing)?\s*\(flags=[0-9]+\)/i.test(msg)) return "contract-revert";
+  if (/timed out after \d+s waiting for block|Transaction not included after \d+s|Transaction did not settle within/i.test(msg)) return "chain-timeout";
+  if (/\bstale\b.*nonce|nonce.*\bstale\b|"type"\s*:\s*"Future"|Invalid::Future|tx rejected by pool/i.test(msg)) return "nonce-stale";
+  if (/heartbeat timeout|WS halt|Unable to connect|ChainHead disjointed|websocket.*closed|socket closed|disconnect/i.test(msg)) return "connection";
+  return "unknown";
+}
+function sanitizeErrorMessage(msg) {
+  return scrubPaths(msg.slice(0, 500));
+}
 async function withSpan(op, description, attributes, fn) {
   if (!Sentry) return fn();
   return Sentry.startSpan({ op, name: description, attributes }, async (span) => {
     try {
       return await fn();
     } catch (error) {
-      span.setAttribute("error.message", error.message);
+      const msg = error.message ?? String(error);
+      span.setAttribute("error.message", msg);
+      span.setAttribute("deploy.error_kind", classifyErrorKind(msg));
+      span.setAttribute("deploy.error_message", sanitizeErrorMessage(msg));
       span.setStatus({ code: 2, message: "internal_error" });
       throw error;
     }
@@ -345,11 +358,13 @@ async function withDeploySpan(domain, fn) {
         span.setAttribute("deploy.status", "ok");
         return result;
       } catch (error) {
-        const msg = error.message;
+        const msg = error.message ?? String(error);
         span.setAttribute("deploy.status", "error");
         span.setAttribute("deploy.error", msg.slice(0, 500));
         const errorCategory = classifyDeployError(msg);
         span.setAttribute("deploy.error_category", errorCategory);
+        span.setAttribute("deploy.error_kind", classifyErrorKind(msg));
+        span.setAttribute("deploy.error_message", sanitizeErrorMessage(msg));
         currentErrorCategory = errorCategory;
         const isExpected = isExpectedError(msg);
         span.setAttribute("deploy.expected", isExpected ? "true" : "false");
@@ -429,6 +444,11 @@ function setDeployAttribute(key, value) {
 function __setDeployRootSpanForTest(span) {
   deployRootSpan = span;
 }
+function __setSentryForTest(stub) {
+  const prev = Sentry;
+  Sentry = stub;
+  return prev;
+}
 function getCurrentSentryTraceId() {
   if (!Sentry) return void 0;
   const span = Sentry.getActiveSpan();
@@ -603,12 +623,15 @@ export {
   classifyDeployError,
   classifySadReason,
   computeDeployOutcome,
+  classifyErrorKind,
+  sanitizeErrorMessage,
   withSpan,
   sampleMemory,
   withDeploySpan,
   setDeployReportContext,
   setDeployAttribute,
   __setDeployRootSpanForTest,
+  __setSentryForTest,
   getCurrentSentryTraceId,
   setDeploySentryTag,
   captureWarning,

package/dist/{chunk-4TS6R26J.js → chunk-WVCIU6WM.js}

@@ -32,8 +32,16 @@ function derivePoolAccounts(poolSize = 10, mnemonic = DEV_PHRASE) {
 }
 var MIN_TRANSACTIONS = 30n;
 var MIN_BYTES = 20000000n;
-function isAuthorizationActive(auth, currentBlock) {
-  return auth !== void 0 && Number(auth.expiration ?? 0) > currentBlock;
+function isAuthorizationSufficient(auth, currentBlock, check = {}) {
+  if (auth === void 0) return false;
+  if (Number(auth.expiration ?? 0) <= currentBlock) return false;
+  if (check.bulletinAuthorizeV2 && check.needs) {
+    const txsRemaining = BigInt(auth.extent.transactions_allowance) - BigInt(auth.extent.transactions);
+    const bytesRemaining = BigInt(auth.extent.bytes_allowance) - BigInt(auth.extent.bytes);
+    if (txsRemaining < check.needs.txs) return false;
+    if (bytesRemaining < check.needs.bytes) return false;
+  }
+  return true;
 }
 function selectAccount(authorizations, random = Math.random, currentBlock) {
   const eligible = authorizations.filter(
@@ -139,12 +147,12 @@ function clampU32(n, name) {
   if (n > U32_MAX) throw new Error(`${name} (${n}) exceeds u32 max \u2014 split the deploy into smaller batches`);
   return Number(n);
 }
-async function ensureAuthorized(api, address, label, bulletinAuthorizeV2) {
+async function ensureAuthorized(api, address, label, bulletinAuthorizeV2, needs) {
   const [auth, currentBlock] = await Promise.all([
     api.query.TransactionStorage.Authorizations.getValue(Enum("Account", address)),
     api.query.System.Number.getValue()
   ]);
-  if (isAuthorizationActive(auth, currentBlock)) return;
+  if (isAuthorizationSufficient(auth, currentBlock, { needs, bulletinAuthorizeV2 })) return;
   console.log(`   Auto-authorizing ${label ?? "account"} (${address.slice(0, 8)}...)...`);
   const { signer } = aliceKeyring();
   if (bulletinAuthorizeV2) {
@@ -176,12 +184,16 @@ async function topUpBy(api, address, needs, label, bulletinAuthorizeV2) {
     api.query.TransactionStorage.Authorizations.getValue(Enum("Account", address)),
     api.query.System.Number.getValue()
   ]);
-  if (isAuthorizationActive(currentAuth, currentBlock)) {
-    const fmtMB = (b) => (Number(b) / 1e6).toFixed(1);
-    const txsRemaining = BigInt(currentAuth.extent.transactions_allowance) - BigInt(currentAuth.extent.transactions);
-    const bytesRemaining = BigInt(currentAuth.extent.bytes_allowance) - BigInt(currentAuth.extent.bytes);
+  if (isAuthorizationSufficient(currentAuth, currentBlock, { needs, bulletinAuthorizeV2 })) {
     const expiration = Number(currentAuth.expiration);
-    console.log(`   Pre-auth skipped for ${label ?? "account"} (${address.slice(0, 8)}...): authorized until block ${expiration}, ${txsRemaining} txs / ${fmtMB(bytesRemaining)}MB remaining.`);
+    if (currentAuth.extent) {
+      const fmtMB = (b) => (Number(b) / 1e6).toFixed(1);
+      const txsRemaining = BigInt(currentAuth.extent.transactions_allowance) - BigInt(currentAuth.extent.transactions);
+      const bytesRemaining = BigInt(currentAuth.extent.bytes_allowance) - BigInt(currentAuth.extent.bytes);
+      console.log(`   Pre-auth skipped for ${label ?? "account"} (${address.slice(0, 8)}...): authorized until block ${expiration}, ${txsRemaining} txs / ${fmtMB(bytesRemaining)}MB remaining.`);
+    } else {
+      console.log(`   Pre-auth skipped for ${label ?? "account"} (${address.slice(0, 8)}...): authorized until block ${expiration}.`);
+    }
     return;
   }
   const { signer } = aliceKeyring();
@@ -292,6 +304,7 @@ async function bootstrapPool(bulletinRpc, poolSize = 10, mnemonic, opts = {}) {
 export {
   formatPasBalance,
   derivePoolAccounts,
+  isAuthorizationSufficient,
   selectAccount,
   fetchPoolAuthorizations,
   computeTopUpTarget,

package/dist/{chunk-G2P5UIPX.js → chunk-XWA3NPMX.js}

@@ -6,7 +6,7 @@ import * as path from "path";
 // package.json
 var package_default = {
   name: "bulletin-deploy",
-  version: "0.7.21",
+  version: "0.7.22-rc.1",
   private: false,
   repository: {
     type: "git",
@@ -36,11 +36,11 @@ var package_default = {
     "assets"
   ],
   scripts: {
-    build: "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/memory-report.ts src/merkle.ts src/gh-pages-mirror.ts src/version-check.ts src/bug-report.ts src/run-state.ts src/environments.ts src/errors.ts src/manifest.ts src/chunk-probe.ts src/manifest-embed.ts src/manifest-fetch.ts src/manifest-roundtrip.ts src/incremental-stats.ts src/chunker.ts src/mirror.ts --format esm --dts --clean --target node22",
+    build: "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/memory-report.ts src/merkle.ts src/gh-pages-mirror.ts src/version-check.ts src/bug-report.ts src/run-state.ts src/environments.ts src/errors.ts src/manifest.ts src/chunk-probe.ts src/manifest-embed.ts src/manifest-fetch.ts src/manifest-roundtrip.ts src/incremental-stats.ts src/chunker.ts src/mirror.ts src/personhood/encoding.ts src/personhood/hashing.ts src/personhood/constants.ts src/personhood/member-key.ts src/personhood/people-client.ts src/personhood/reprove.ts src/personhood/bind-personal-id.ts src/personhood/claim-pgas.ts src/personhood/bind-paid-alias.ts src/personhood/bootstrap.ts --format esm --dts --clean --target node22",
     "refresh-environments": "node scripts/refresh-environments.mjs",
     "check:watched-dependencies": "node tools/check-watched-dependencies.mjs",
     prepare: "npm run build",
-    test: "npm run build && node --test test/test.js test/cli-help.test.js test/helpers/e2e-helpers.test.js test/environments.test.js test/refresh-environments.test.js test/watched-dependencies.test.js",
+    test: "npm run build && node --test test/test.js test/cli-help.test.js test/helpers/e2e-helpers.test.js test/environments.test.js test/refresh-environments.test.js test/watched-dependencies.test.js test/chunk-sharing-report.test.js",
     "test:e2e": "npm run build && node --test test/e2e.test.js",
     "test:e2e:smoke": "bash scripts/e2e-pass.sh smoke",
     "test:e2e:pr": "bash scripts/e2e-pass.sh pr",
@@ -62,6 +62,7 @@ var package_default = {
     "ipfs-unixfs-importer": "^16.1.4",
     multiformats: "^13.4.1",
     "polkadot-api": "^2.1.3",
+    verifiablejs: "^1.2.0",
     viem: "^2.30.5"
   },
   devDependencies: {

package/dist/chunk-ZYVGHDMU.js

@@ -0,0 +1,117 @@
+// src/personhood/encoding.ts
+import { blake2b } from "@noble/hashes/blake2b";
+var concatBytes = (...arrays) => {
+  let total = 0;
+  for (const a of arrays) total += a.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    out.set(a, offset);
+    offset += a.length;
+  }
+  return out;
+};
+var compactEncode = (n) => {
+  if (n < 0) throw new Error("compactEncode: negative");
+  if (n < 64) return new Uint8Array([n << 2]);
+  if (n < 16384) {
+    const v = n << 2 | 1;
+    return new Uint8Array([v & 255, v >> 8 & 255]);
+  }
+  if (n < 1073741824) {
+    const v = n << 2 | 2;
+    return new Uint8Array([
+      v & 255,
+      v >> 8 & 255,
+      v >> 16 & 255,
+      v >>> 24 & 255
+    ]);
+  }
+  throw new Error("compactEncode: value too large for inline path");
+};
+var blake2_256 = (data) => blake2b(data, { dkLen: 32 });
+var buildImplicationMessage = (callBytes, extensions, excludeIdentifiers) => {
+  const exclude = typeof excludeIdentifiers === "string" ? /* @__PURE__ */ new Set([excludeIdentifiers]) : excludeIdentifiers;
+  const restExplicit = [];
+  const restImplicit = [];
+  for (const id of extensions.order) {
+    if (exclude.has(id)) continue;
+    const ext = extensions.byIdentifier[id];
+    if (!ext) throw new Error(`buildImplication: missing extension '${id}'`);
+    restExplicit.push(ext.value);
+    restImplicit.push(ext.additionalSigned);
+  }
+  const implication = concatBytes(
+    new Uint8Array([0]),
+    callBytes,
+    ...restExplicit,
+    ...restImplicit
+  );
+  return blake2_256(implication);
+};
+var buildV5GeneralExtrinsic = (callBytes, extensions) => {
+  const explicit = extensions.order.map((id) => {
+    const ext = extensions.byIdentifier[id];
+    if (!ext) throw new Error(`buildV5General: missing extension '${id}'`);
+    return ext.value;
+  });
+  const body = concatBytes(
+    new Uint8Array([69]),
+    new Uint8Array([0]),
+    ...explicit,
+    callBytes
+  );
+  return concatBytes(compactEncode(body.length), body);
+};
+var toHex = (bytes) => {
+  let hex = "0x";
+  for (const b of bytes) {
+    hex += b.toString(16).padStart(2, "0");
+  }
+  return hex;
+};
+var hexToBytes = (hex) => {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+};
+var bytesToHex = (b) => "0x" + Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+var readExtensionOrder = async (metadata) => {
+  const { decAnyMetadata, unifyMetadata } = await import("@polkadot-api/substrate-bindings");
+  const meta = unifyMetadata(decAnyMetadata(metadata));
+  const raw = meta.extrinsic.signedExtensions;
+  let list = null;
+  if (Array.isArray(raw) && raw.length > 0 && Array.isArray(raw[0])) {
+    list = raw[0];
+  } else if (Array.isArray(raw)) {
+    list = raw;
+  } else if (typeof raw === "object" && raw !== null && Array.isArray(raw[0])) {
+    list = raw[0];
+  }
+  if (!list || list.length === 0) {
+    throw new Error("metadata has no signed extensions");
+  }
+  return list.map((entry) => entry.identifier);
+};
+var encodeMembers = (members) => {
+  for (const m of members) {
+    if (m.length !== 32) throw new Error("member key must be 32 bytes");
+  }
+  return concatBytes(compactEncode(members.length), ...members);
+};
+
+export {
+  concatBytes,
+  compactEncode,
+  blake2_256,
+  buildImplicationMessage,
+  buildV5GeneralExtrinsic,
+  toHex,
+  hexToBytes,
+  bytesToHex,
+  readExtensionOrder,
+  encodeMembers
+};

package/dist/chunk-probe.js

@@ -5,9 +5,9 @@ import {
   _decodeStorageValue,
   _resetProbeSession,
   probeChunks
-} from "./chunk-ZY6QLNKQ.js";
-import "./chunk-2VNGK2MU.js";
-import "./chunk-G2P5UIPX.js";
+} from "./chunk-KFHGT4A2.js";
+import "./chunk-WNUWAA6F.js";
+import "./chunk-XWA3NPMX.js";
 export {
   ChainProbeCrossValidationError,
   ChainProbeMetadataError,

package/dist/deploy.d.ts

@@ -28,6 +28,7 @@ interface ExistingProvider {
     skipCids?: Set<string>;
     probeFailedCids?: Set<string>;
     gateway?: string;
+    bulletinAuthorizeV2?: boolean;
 }
 interface StoredChunk {
     cid: CID;
@@ -63,7 +64,7 @@ declare function storeFile(contentBytes: Uint8Array, { client: existingClient, u
  */
 declare function assignDenseNonces(stored: (StoredChunk | null)[], startNonce: number): Map<number, number>;
 declare const __assignDenseNoncesForTest: typeof assignDenseNonces;
-declare function storeChunkedContent(chunks: Uint8Array[], { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect, fetchNonce: fetchNonceOverride, skipCids, probeFailedCids, gateway: providerGateway }?: ExistingProvider): Promise<{
+declare function storeChunkedContent(chunks: Uint8Array[], { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect, fetchNonce: fetchNonceOverride, skipCids, probeFailedCids, gateway: providerGateway, bulletinAuthorizeV2 }?: ExistingProvider): Promise<{
     storageCid: string;
     tier2Verified: number;
     tier2Inconclusive: number;
@@ -202,7 +203,7 @@ interface DeployOptions {
     /** When true, marks this as an automated mirror deploy in telemetry. */
     automatedMirror?: boolean;
 }
-declare function resolveDotnsConnectOptions(options: Pick<DeployOptions, "mnemonic" | "derivationPath" | "signer" | "signerAddress">, assetHubEndpoints?: string[], autoAccountMapping?: boolean, contracts?: Record<string, string>, nativeToEthRatio?: bigint): {
+declare function resolveDotnsConnectOptions(options: Pick<DeployOptions, "mnemonic" | "derivationPath" | "signer" | "signerAddress">, assetHubEndpoints?: string[], autoAccountMapping?: boolean, contracts?: Record<string, string>, nativeToEthRatio?: bigint, environmentId?: string): {
     signer?: PolkadotSigner;
     signerAddress?: string;
     mnemonic?: string;
@@ -211,6 +212,7 @@ declare function resolveDotnsConnectOptions(options: Pick<DeployOptions, "mnemon
     autoAccountMapping?: boolean;
     contracts?: Record<string, string>;
     nativeToEthRatio?: bigint;
+    environmentId?: string;
 };
 declare function estimateUploadBytes(content: DeployContent): Promise<number | null>;
 declare function deploy(content: DeployContent, domainName?: string | null, options?: DeployOptions): Promise<DeployResult>;

package/dist/deploy.js

@@ -32,19 +32,19 @@ import {
   storeDirectory,
   storeDirectoryV2,
   storeFile
-} from "./chunk-BFXHVC23.js";
-import "./chunk-MJTQOXBC.js";
+} from "./chunk-SPWQNU3F.js";
+import "./chunk-LEYQOOWC.js";
 import "./chunk-KOSF5FDO.js";
 import "./chunk-5MRZ3V4A.js";
 import "./chunk-S7EM5VMW.js";
-import "./chunk-SA37SLYF.js";
-import "./chunk-RJAFD4LO.js";
-import "./chunk-ZY6QLNKQ.js";
+import "./chunk-V5NUBOEX.js";
+import "./chunk-FSSKFXTZ.js";
+import "./chunk-KFHGT4A2.js";
 import "./chunk-C2TS5MER.js";
-import "./chunk-VTTN4BX7.js";
-import "./chunk-4TS6R26J.js";
-import "./chunk-2VNGK2MU.js";
-import "./chunk-G2P5UIPX.js";
+import "./chunk-CIXT75OF.js";
+import "./chunk-WVCIU6WM.js";
+import "./chunk-WNUWAA6F.js";
+import "./chunk-XWA3NPMX.js";
 import "./chunk-F36C363Y.js";
 import {
   EXIT_CODE_NO_RETRY,

package/dist/dotns.d.ts

@@ -1,4 +1,8 @@
+import { BootstrapResult } from './personhood/bootstrap.js';
 import { PolkadotSigner } from 'polkadot-api';
+import './personhood/bind-personal-id.js';
+import './personhood/claim-pgas.js';
+import './personhood/bind-paid-alias.js';
 
 interface DotNSConnectOptions {
     rpc?: string;
@@ -18,6 +22,8 @@ interface DotNSConnectOptions {
     autoAccountMapping?: boolean;
     nativeToEthRatio?: bigint;
     contracts?: Record<string, string>;
+    /** Optional environment ID (e.g. "paseo-next-v2"). Used to gate environment-specific preflight advice. */
+    environmentId?: string;
 }
 interface OwnershipResult {
     owned: boolean;
@@ -104,6 +110,29 @@ declare const ProofOfPersonhoodStatus: {
     readonly Reserved: 3;
 };
 declare function convertToHexString(value: unknown): string;
+declare function formatContractDryRunFailure(gasEstimate: {
+    revertData?: string;
+    revertFlags?: bigint;
+    gasConsumed?: {
+        referenceTime: bigint;
+        proofSize: bigint;
+    };
+    gasRequired?: {
+        referenceTime: bigint;
+        proofSize: bigint;
+    };
+    storageDeposit?: bigint;
+}, context: {
+    contractAddress: string;
+    functionName?: string;
+    signerSubstrateAddress: string;
+    signerEvmAddress?: string;
+    value: bigint;
+    encodedData: string;
+    args?: unknown[];
+    contracts?: Record<string, string>;
+}): string;
+declare function __formatContractDryRunFailureForTest(gasEstimate: Parameters<typeof formatContractDryRunFailure>[0], context: Parameters<typeof formatContractDryRunFailure>[1]): string;
 declare const DOT_NODE: `0x${string}`;
 declare function convertWeiToNative(weiValue: bigint): bigint;
 declare function computeDomainTokenId(label: string): bigint;
@@ -161,6 +190,21 @@ declare class ReviveClientWrapper {
         contracts?: Record<string, string>;
     }): Promise<string>;
 }
+type AliasAccountState = "not-bound" | "bound-likely-stale" | "wrong-context" | "bound-fresh";
+interface AliasAccountClassification {
+    state: AliasAccountState;
+    storedContextHex?: string;
+    paid?: boolean;
+    revision?: number;
+}
+/**
+ * Format a user-facing remediation message for the "no personhood" preflight failure.
+ * Pure function — unit-testable without a chain connection.
+ *
+ * On paseo-next-v2 testnets we can give actionable advice based on alias state.
+ * On other environments we fall back to the generic "contact DotNS team" message.
+ */
+declare function formatPersonhoodRemediation(state: AliasAccountClassification, environmentId: string | null): string;
 declare class DotNS {
     client: any | null;
     clientWrapper: ReviveClientWrapper | null;
@@ -173,6 +217,7 @@ declare class DotNS {
     private _usesExternalSigner;
     private _contracts;
     private _nativeToEthRatio;
+    private _environmentId;
     constructor();
     connect(options?: DotNSConnectOptions): Promise<this>;
     ensureMappedAccountReady(autoAccountMapping?: boolean): Promise<void>;
@@ -180,6 +225,12 @@ declare class DotNS {
     ensureConnected(): void;
     private _testnetCache;
     isTestnet(): Promise<boolean>;
+    /**
+     * Classify the AliasAccounts state for a substrate address.
+     * Only called on paseo-next-v2 testnets inside the preflight's NoStatus branch.
+     * Returns "not-bound" if the chain is unreachable (safe fallback to generic advice).
+     */
+    private classifyAliasAccountState;
     readFreeBalance(ss58: string): Promise<bigint>;
     attemptTestnetTopUp(recipientSs58: string, targetAmount: bigint): Promise<{
         source: "Alice" | "Bob";
@@ -230,8 +281,30 @@ declare class DotNS {
         label: string;
         owner: string;
     }>;
+    /**
+     * Reprove a stale DotNS alias binding.
+     * Opens a People-chain client internally, builds the ring proof, and submits
+     * reprove_alias_account on AH. Use when the alias exists but the ring root
+     * has advanced past the stored revision.
+     *
+     * Requires a mnemonic — the DotNS instance must have been connected with one.
+     */
+    reprove(mnemonic: string): Promise<{
+        oldRevision: number;
+        newRevision: number;
+        blockHash: string;
+    }>;
+    /**
+     * Run the personhood bootstrap flow for this DotNS signer.
+     * Idempotent: each step is gated on chain state being "still needs doing".
+     * Does NOT auto-run from preflight — call explicitly.
+     *
+     * Throws RecognizeRequiredError if the account hasn't been recognized by the
+     * personhood faucet (https://sudo.personhood.dev/personhood-faucet).
+     */
+    bootstrap(mnemonic: string): Promise<BootstrapResult>;
     disconnect(): void;
 }
 declare const dotns: DotNS;
 
-export { CONNECTION_TIMEOUT_MS, CONTRACTS, DECIMALS, DEFAULT_MNEMONIC, DOTNS_TX_MAX_ATTEMPTS, DOT_NODE, DotNS, type DotNSConnectOptions, type DotnsPreflightResult, type DotnsSuccessAction, NATIVE_TO_ETH_RATIO, OPERATION_TIMEOUT_MS, type OwnershipResult, type ParsedDomainName, type PriceValidationResult, ProofOfPersonhoodStatus, RPC_ENDPOINTS, TX_CHAIN_TIME_BUDGET_MS, TX_TIMEOUT_MS, TX_WALL_CLOCK_CEILING_MS, WS_HEARTBEAT_TIMEOUT_MS, canRegister, classifyDotnsLabel, classifyTxRetryDecision, computeDomainTokenId, convertToHexString, convertWeiToNative, countTrailingDigits, dotns, feeFloorFor, fetchNonce, fmtPas, isCommitmentMature, parseDomainName, parseProofOfPersonhoodStatus, popStatusName, sanitizeDomainLabel, simulateUserStatus, stripTrailingDigits, validateDomainLabel, verifyNonceAdvanced };
+export { type AliasAccountClassification, type AliasAccountState, CONNECTION_TIMEOUT_MS, CONTRACTS, DECIMALS, DEFAULT_MNEMONIC, DOTNS_TX_MAX_ATTEMPTS, DOT_NODE, DotNS, type DotNSConnectOptions, type DotnsPreflightResult, type DotnsSuccessAction, NATIVE_TO_ETH_RATIO, OPERATION_TIMEOUT_MS, type OwnershipResult, type ParsedDomainName, type PriceValidationResult, ProofOfPersonhoodStatus, RPC_ENDPOINTS, TX_CHAIN_TIME_BUDGET_MS, TX_TIMEOUT_MS, TX_WALL_CLOCK_CEILING_MS, WS_HEARTBEAT_TIMEOUT_MS, __formatContractDryRunFailureForTest, canRegister, classifyDotnsLabel, classifyTxRetryDecision, computeDomainTokenId, convertToHexString, convertWeiToNative, countTrailingDigits, dotns, feeFloorFor, fetchNonce, fmtPas, formatPersonhoodRemediation, isCommitmentMature, parseDomainName, parseProofOfPersonhoodStatus, popStatusName, sanitizeDomainLabel, simulateUserStatus, stripTrailingDigits, validateDomainLabel, verifyNonceAdvanced };

package/dist/dotns.js

@@ -14,6 +14,7 @@ import {
   TX_TIMEOUT_MS,
   TX_WALL_CLOCK_CEILING_MS,
   WS_HEARTBEAT_TIMEOUT_MS,
+  __formatContractDryRunFailureForTest,
   canRegister,
   classifyDotnsLabel,
   classifyTxRetryDecision,
@@ -25,6 +26,7 @@ import {
   feeFloorFor,
   fetchNonce,
   fmtPas,
+  formatPersonhoodRemediation,
   isCommitmentMature,
   parseDomainName,
   parseProofOfPersonhoodStatus,
@@ -34,10 +36,10 @@ import {
   stripTrailingDigits,
   validateDomainLabel,
   verifyNonceAdvanced
-} from "./chunk-VTTN4BX7.js";
-import "./chunk-4TS6R26J.js";
-import "./chunk-2VNGK2MU.js";
-import "./chunk-G2P5UIPX.js";
+} from "./chunk-CIXT75OF.js";
+import "./chunk-WVCIU6WM.js";
+import "./chunk-WNUWAA6F.js";
+import "./chunk-XWA3NPMX.js";
 export {
   CONNECTION_TIMEOUT_MS,
   CONTRACTS,
@@ -54,6 +56,7 @@ export {
   TX_TIMEOUT_MS,
   TX_WALL_CLOCK_CEILING_MS,
   WS_HEARTBEAT_TIMEOUT_MS,
+  __formatContractDryRunFailureForTest,
   canRegister,
   classifyDotnsLabel,
   classifyTxRetryDecision,
@@ -65,6 +68,7 @@ export {
   feeFloorFor,
   fetchNonce,
   fmtPas,
+  formatPersonhoodRemediation,
   isCommitmentMature,
   parseDomainName,
   parseProofOfPersonhoodStatus,

package/dist/incremental-stats.d.ts

@@ -18,6 +18,7 @@ interface IncrementalStats {
     probeFailedMetadata: number;
     recycledCids: number;
     retentionPeriodBlocks: number;
+    bytesProbePresent: number;
     bytesSkipped: number;
     bytesUploaded: number;
     chunksTotal: number;
@@ -43,6 +44,7 @@ interface ComputeStatsInput {
     probeResults: ChunkProbeResult[];
     prevChunks: Record<string, ManifestChunkEntry>;
     retentionPeriodBlocks: number;
+    bytesProbePresent: number;
     bytesSkipped: number;
     bytesUploaded: number;
     chunksTotal: number;
@@ -59,7 +61,7 @@ interface ComputeStatsInput {
     tier2FallbackCount: number;
 }
 declare function computeStats(input: ComputeStatsInput): IncrementalStats;
-declare function telemetryAttributes(s: IncrementalStats): Record<string, string>;
+declare function telemetryAttributes(s: IncrementalStats): Record<string, string | number>;
 declare function renderSummary(s: IncrementalStats): string;
 
 export { type ComputeStatsInput, type IncrementalStats, computeStats, renderSummary, telemetryAttributes };

package/dist/incremental-stats.js

@@ -2,7 +2,7 @@ import {
   computeStats,
   renderSummary,
   telemetryAttributes
-} from "./chunk-MJTQOXBC.js";
+} from "./chunk-LEYQOOWC.js";
 export {
   computeStats,
   renderSummary,

package/dist/index.d.ts

@@ -13,3 +13,7 @@ export { shouldMirrorToPaseoNextV2 } from './mirror.js';
 import 'multiformats/cid';
 import 'polkadot-api';
 import './errors.js';
+import './personhood/bootstrap.js';
+import './personhood/bind-personal-id.js';
+import './personhood/claim-pgas.js';
+import './personhood/bind-paid-alias.js';