bulletin-deploy 0.7.3 → 0.7.5

package/dist/{chunk-EPNPPAMS.js → chunk-KQ75CSJJ.js}

@@ -1,13 +1,14 @@
 import {
   setDeployContext
-} from "./chunk-4EQERQRG.js";
+} from "./chunk-UXKC7JAM.js";
 import {
   DotNS,
   TX_TIMEOUT_MS,
   fetchNonce,
   parseDomainName,
-  popStatusName
-} from "./chunk-M3H3F4FY.js";
+  popStatusName,
+  verifyNonceAdvanced
+} from "./chunk-SAMH7JFG.js";
 import {
   MirrorSkipped,
   mirrorToGitHubPages,
@@ -26,7 +27,7 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-BYIVK52G.js";
+} from "./chunk-WOJRQCQV.js";
 import {
   merkleizeJS
 } from "./chunk-B7GUYYAN.js";
@@ -48,7 +49,7 @@ import { sha256 } from "@noble/hashes/sha256";
 import { blake2b } from "@noble/hashes/blake2b";
 import { createClient as createPolkadotClient, Enum } from "polkadot-api";
 import { Binary } from "@polkadot-api/substrate-bindings";
-import { getWsProvider } from "polkadot-api/ws-provider";
+import { getWsProvider, WsEvent } from "polkadot-api/ws-provider";
 import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
 import { CID } from "multiformats/cid";
 import { create as createMultihash } from "multiformats/hashes/digest";
@@ -75,12 +76,23 @@ function friendlyChainError(msg) {
 }
 var DEFAULT_BULLETIN_RPC = "wss://paseo-bulletin-rpc.polkadot.io";
 var DEFAULT_POOL_SIZE = 10;
-var BULLETIN_RPC = DEFAULT_BULLETIN_RPC;
+var BULLETIN_ENDPOINTS = [DEFAULT_BULLETIN_RPC];
 var POOL_SIZE = DEFAULT_POOL_SIZE;
+var _deployRpcFailedOver = false;
+function makeBulletinStatusHandler(primary) {
+  return (s) => {
+    if (s.type === WsEvent.CONNECTED && s.uri !== primary) {
+      _deployRpcFailedOver = true;
+      setDeployAttribute("deploy.rpc.failed_over", "true");
+      captureWarning("Bulletin RPC failover", { from: primary, to: s.uri });
+    }
+  };
+}
 var CHUNK_SIZE = 2 * 1024 * 1024;
 var MAX_FILE_SIZE = 8 * 1024 * 1024;
 var MAX_RECONNECTIONS = parseInt(process.env.BULLETIN_MAX_RECONNECTIONS ?? "3", 10);
 var CHUNK_TIMEOUT_MS = parseInt(process.env.BULLETIN_CHUNK_TIMEOUT_MS ?? "180000", 10);
+var CHUNK_MORTALITY_PERIOD = 16;
 var RETRY_BASE_DELAY_MS = 2e3;
 var RETRY_MAX_DELAY_MS = 15e3;
 var WS_HEARTBEAT_TIMEOUT_MS = 3e5;
@@ -147,8 +159,12 @@ function toHashingEnum(mhCode) {
   }
 }
 async function getProvider() {
-  console.log(`   Connecting to Bulletin: ${BULLETIN_RPC}`);
-  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC, { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS })));
+  const primary = BULLETIN_ENDPOINTS[0];
+  console.log(`   Connecting to Bulletin: ${primary}`);
+  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(
+    BULLETIN_ENDPOINTS,
+    { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS, onStatusChanged: makeBulletinStatusHandler(primary) }
+  )));
   const unsafeApi = client.getUnsafeApi();
   try {
     await cryptoWaitReady();
@@ -159,10 +175,10 @@ async function getProvider() {
     if (!selected) {
       const best = authorizations.reduce((a, b) => a.transactions > b.transactions ? a : b);
       console.log(`   All pool accounts low on capacity, auto-authorizing account ${best.index}...`);
-      await ensureAuthorized(unsafeApi, best.address, BULLETIN_RPC, `pool account ${best.index}`);
+      await ensureAuthorized(unsafeApi, best.address, BULLETIN_ENDPOINTS[0], `pool account ${best.index}`);
       selected = best;
     } else {
-      await ensureAuthorized(unsafeApi, selected.address, BULLETIN_RPC, `pool account ${selected.index}`);
+      await ensureAuthorized(unsafeApi, selected.address, BULLETIN_ENDPOINTS[0], `pool account ${selected.index}`);
     }
     console.log(`   Using pool account ${selected.index}: ${selected.address}`);
     setDeployAttribute("deploy.signer.mode", "pool");
@@ -175,8 +191,12 @@ async function getProvider() {
   }
 }
 async function getDirectProvider(mnemonic, derivationPath = "") {
-  console.log(`   Connecting to Bulletin: ${BULLETIN_RPC}`);
-  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC, { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS })));
+  const primary = BULLETIN_ENDPOINTS[0];
+  console.log(`   Connecting to Bulletin: ${primary}`);
+  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(
+    BULLETIN_ENDPOINTS,
+    { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS, onStatusChanged: makeBulletinStatusHandler(primary) }
+  )));
   const unsafeApi = client.getUnsafeApi();
   const { signer, ss58 } = deriveRootSigner(mnemonic, derivationPath);
   console.log(`   Using direct signer: ${ss58}${derivationPath ? ` (path: ${derivationPath})` : ""}`);
@@ -194,13 +214,12 @@ async function getDirectProvider(mnemonic, derivationPath = "") {
   setDeployAttribute("deploy.signer.address", truncateAddress(ss58));
   return { client, unsafeApi, signer, ss58 };
 }
-var MAX_BEST_CHAIN_DROPS = 5;
-function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction", rpc, senderSS58, expectedNonce, timeoutMs } = {}) {
+function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction", rpc, senderSS58, expectedNonce, timeoutMs, fetchNonce: fetchNonceOverride } = {}) {
   const timeout = timeoutMs ?? TX_TIMEOUT_MS;
+  const _fetchNonce = fetchNonceOverride ?? fetchNonce;
   return new Promise((resolve2, reject) => {
     let settled = false;
     let sub;
-    let dropCount = 0;
     const settle = (fn) => (...args) => {
       if (settled) return;
       settled = true;
@@ -214,10 +233,11 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
     const tryNonceFallback = async () => {
       if (!rpc || !senderSS58 || expectedNonce == null) return false;
       try {
-        const currentNonce = await fetchNonce(rpc, senderSS58);
+        const endpoints = Array.isArray(rpc) ? rpc : [rpc];
+        const verified = await verifyNonceAdvanced(endpoints, senderSS58, expectedNonce);
         if (settled) return true;
-        if (currentNonce > expectedNonce) {
-          console.log(`      ${label}: nonce advanced (${expectedNonce} -> ${currentNonce}), tx was included`);
+        if (verified.advanced) {
+          console.log(`      ${label}: nonce advanced past ${expectedNonce} (witnessed by ${verified.witnessRpc}), tx was included`);
           settle(resolve2)({ value: onSuccess(), viaFallback: true });
           return true;
         }
@@ -234,23 +254,16 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
     }, timeout);
     sub = tx.signSubmitAndWatch(signer, txOpts).subscribe({
       next: async (event) => {
-        if (event.type === "txBestBlocksState") {
-          if (event.found) {
-            if (event.ok) {
-              settle(resolve2)({ value: onSuccess(event), viaFallback: false });
-            } else {
-              settle(reject)(new Error(`${label} dispatch error`));
-            }
-          } else {
-            dropCount++;
-            if (dropCount >= MAX_BEST_CHAIN_DROPS) {
-              console.log(`      ${label}: tx dropped ${dropCount} times, checking nonce...`);
-              if (await tryNonceFallback()) return;
-              settle(reject)(new Error(`${label} tx dropped from best chain ${dropCount} times`));
-            } else {
-              console.log(`      ${label}: tx dropped from best chain (${dropCount}/${MAX_BEST_CHAIN_DROPS}), waiting...`);
-            }
-          }
+        if (event.type !== "txBestBlocksState") return;
+        if (event.found) {
+          if (event.ok) settle(resolve2)({ value: onSuccess(event), viaFallback: false });
+          else settle(reject)(new Error(`${label} dispatch error`));
+          return;
+        }
+        if (event.isValid === false) {
+          console.log(`      ${label}: tx rejected by pool (isValid:false), checking nonce fallback...`);
+          if (await tryNonceFallback()) return;
+          settle(reject)(new Error(`${label} tx rejected by pool (isValid:false)`));
         }
       },
       error: (e) => {
@@ -260,15 +273,15 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
     });
   });
 }
-async function storeChunk(unsafeApi, signer, chunkBytes, nonce, ss58) {
+async function storeChunk(unsafeApi, signer, chunkBytes, nonce, ss58, opts = {}) {
   const hashCode = 18;
   const cid = createCID(chunkBytes, CID_CONFIG.codec, hashCode);
   const tx = unsafeApi.tx.TransactionStorage.store_with_cid_config({ cid: { codec: BigInt(CID_CONFIG.codec), hashing: toHashingEnum(hashCode) }, data: Binary.fromBytes(chunkBytes) });
-  const txOpts = { mortality: { mortal: true, period: 256 }, nonce };
+  const txOpts = { mortality: { mortal: true, period: CHUNK_MORTALITY_PERIOD }, nonce };
   const { value, viaFallback } = await watchTransaction(tx, signer, txOpts, () => {
     console.log(`      CID: ${cid.toString()}`);
     return { cid, len: chunkBytes.length };
-  }, { label: `chunk(nonce:${nonce})`, rpc: BULLETIN_RPC, senderSS58: ss58, expectedNonce: nonce, timeoutMs: CHUNK_TIMEOUT_MS });
+  }, { label: `chunk(nonce:${nonce})`, rpc: BULLETIN_ENDPOINTS, senderSS58: ss58, expectedNonce: nonce, timeoutMs: CHUNK_TIMEOUT_MS, fetchNonce: opts.fetchNonce });
   return { ...value, viaFallback };
 }
 async function storeFile(contentBytes, { client: existingClient, unsafeApi: existingApi, signer: existingSigner } = {}) {
@@ -305,7 +318,8 @@ async function storeFile(contentBytes, { client: existingClient, unsafeApi: exis
     throw e;
   }
 }
-async function storeChunkedContent(chunks, { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect } = {}) {
+async function storeChunkedContent(chunks, { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect, fetchNonce: fetchNonceOverride } = {}) {
+  const _fetchNonce = fetchNonceOverride ?? fetchNonce;
   console.log(`
    Chunks: ${chunks.length}`);
   const totalBytes = chunks.reduce((s, c) => s + c.length, 0);
@@ -337,7 +351,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
    Account has insufficient authorization for this upload (need ${requiredTxs} txs / ${(totalBytes / 1e6).toFixed(1)}MB, have ${txsRemaining} txs / ${Number(bytesRemaining) / 1e6}MB)`);
     console.log(`   Attempting to re-authorize with Alice...`);
     try {
-      await ensureAuthorized(unsafeApi, ss58, BULLETIN_RPC, void 0, { txs: requiredTxs, bytes: requiredBytes });
+      await ensureAuthorized(unsafeApi, ss58, BULLETIN_ENDPOINTS[0], void 0, { txs: requiredTxs, bytes: requiredBytes });
       console.log(`   Re-authorization successful`);
     } catch (e) {
       throw new NonRetryableError(`Account ${ss58} has insufficient Bulletin authorization quota and auto-authorization via Alice failed (${e.message}). Authorize the account on-chain.`);
@@ -368,7 +382,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     sampleMemory(`reconnect_${reconnectionsUsed}_after`);
   }
   try {
-    let startNonce = await fetchNonce(BULLETIN_RPC, ss58);
+    let startNonce = await _fetchNonce(BULLETIN_ENDPOINTS, ss58);
     console.log(`   Starting nonce: ${startNonce}`);
     const BATCH_SIZE = 2;
     const MAX_CHUNK_RETRIES = 3;
@@ -394,7 +408,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
         }
         const nonce = assignedNonces.get(i);
         console.log(`   [${i + 1}/${chunks.length}] ${(chunkData.length / 1024 / 1024).toFixed(2)} MB (nonce: ${nonce})`);
-        return storeChunk(unsafeApi, signer, chunkData, nonce, ss58);
+        return storeChunk(unsafeApi, signer, chunkData, nonce, ss58, { fetchNonce: fetchNonceOverride });
       });
       const results = await Promise.allSettled(batchPromises);
       results.forEach((r, j) => {
@@ -404,11 +418,10 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
         }
       });
       const failures = results.map((r, j) => r.status === "rejected" ? { index: batchIndices[j], chunkData: batchChunks[j], error: r.reason } : null).filter(Boolean);
-      const succeededViaFallback = results.some((r) => r.status === "fulfilled" && r.value.viaFallback);
-      const needsReconnect = failures.some((f) => isConnectionError(f.error)) || succeededViaFallback;
+      const needsReconnect = failures.some((f) => isConnectionError(f.error));
       if (needsReconnect && reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
         await doReconnect();
-        const currentNonce = await fetchNonce(BULLETIN_RPC, ss58);
+        const currentNonce = await _fetchNonce(BULLETIN_ENDPOINTS, ss58);
         for (const idx of batchIndices) {
           const chunkNonce = assignedNonces.get(idx);
           if (chunkNonce !== void 0 && chunkNonce < currentNonce && stored[idx] === null) {
@@ -439,7 +452,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
             }
           }
           try {
-            const currentNonce = await fetchNonce(BULLETIN_RPC, ss58);
+            const currentNonce = await _fetchNonce(BULLETIN_ENDPOINTS, ss58);
             const originalNonce = assignedNonces.get(fail.index);
             if (originalNonce !== void 0 && originalNonce < currentNonce) {
               console.log(`   Chunk ${fail.index + 1}: nonce ${originalNonce} consumed (current=${currentNonce}), treating as included`);
@@ -449,7 +462,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
               break;
             }
             const retryNonce = originalNonce ?? currentNonce;
-            const result2 = await storeChunk(unsafeApi, signer, fail.chunkData, retryNonce, ss58);
+            const result2 = await storeChunk(unsafeApi, signer, fail.chunkData, retryNonce, ss58, { fetchNonce: fetchNonceOverride });
             stored[fail.index] = result2;
             assignedNonces.delete(fail.index);
             retried = true;
@@ -495,7 +508,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     const MAX_ROOT_RETRIES = 3;
     let result;
     for (let rootAttempt = 1; rootAttempt <= MAX_ROOT_RETRIES; rootAttempt++) {
-      const rootNonce = await fetchNonce(BULLETIN_RPC, ss58);
+      const rootNonce = await _fetchNonce(BULLETIN_ENDPOINTS, ss58);
       console.log(`   Storing root node (nonce: ${rootNonce})...`);
       const rootTx = unsafeApi.tx.TransactionStorage.store_with_cid_config({ cid: { codec: BigInt(112), hashing: toHashingEnum(hashCode) }, data: Binary.fromBytes(dagBytes) });
       const rootTxOpts = { mortality: { mortal: true, period: 256 }, nonce: rootNonce };
@@ -504,11 +517,8 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
           console.log(`   Root CID: ${rootCid.toString()}
 `);
           return rootCid.toString();
-        }, { label: "root-node", rpc: BULLETIN_RPC, senderSS58: ss58, expectedNonce: rootNonce, timeoutMs: CHUNK_TIMEOUT_MS });
+        }, { label: "root-node", rpc: BULLETIN_ENDPOINTS, senderSS58: ss58, expectedNonce: rootNonce, timeoutMs: CHUNK_TIMEOUT_MS, fetchNonce: fetchNonceOverride });
         result = watchResult.value;
-        if (watchResult.viaFallback && reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
-          await doReconnect();
-        }
         break;
       } catch (e) {
         if (reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
@@ -665,7 +675,9 @@ async function estimateUploadBytes(content) {
   }
 }
 async function deploy(content, domainName = null, options = {}) {
-  BULLETIN_RPC = options.rpc ?? process.env.BULLETIN_RPC ?? DEFAULT_BULLETIN_RPC;
+  const userRpc = options.rpc ?? process.env.BULLETIN_RPC;
+  BULLETIN_ENDPOINTS = userRpc ? [userRpc, ...[DEFAULT_BULLETIN_RPC].filter((e) => e !== userRpc)] : [DEFAULT_BULLETIN_RPC];
+  _deployRpcFailedOver = false;
   POOL_SIZE = options.poolSize ?? parseInt(process.env.BULLETIN_POOL_SIZE ?? String(DEFAULT_POOL_SIZE), 10);
   initTelemetry();
   const randomSuffix = Math.floor(Math.random() * 100).toString().padStart(2, "0");
@@ -698,22 +710,6 @@ async function deploy(content, domainName = null, options = {}) {
       await preflight.connect(
         options.signer && options.signerAddress ? { signer: options.signer, signerAddress: options.signerAddress } : options.mnemonic ? { mnemonic: options.mnemonic, derivationPath: options.derivationPath } : {}
       );
-      const mappingDeadline = Date.now() + 15e3;
-      let mappingConfirmed = false;
-      while (Date.now() < mappingDeadline) {
-        if (await preflight.clientWrapper.checkIfAccountMapped(preflight.substrateAddress)) {
-          mappingConfirmed = true;
-          break;
-        }
-        await new Promise((r) => setTimeout(r, 1500));
-      }
-      if (!mappingConfirmed) {
-        preflight.disconnect();
-        throw new NonRetryableError(
-          `Account mapping did not take effect on-chain for ${preflight.substrateAddress}. The map_account tx may have been dropped or hit a dispatch error \u2014 check the signer's balance for existential deposit + fees.`
-        );
-      }
-      console.log(`   Account: mapped`);
       if (parsed?.isSubdomain) {
         try {
           const { owned: subOwned } = await preflight.checkSubdomainOwnership(parsed.sublabel, parsed.parentLabel);
@@ -762,7 +758,7 @@ async function deploy(content, domainName = null, options = {}) {
         const uploadBytes = Math.ceil(estimated * 1.2);
         const chunksNeeded = Math.max(1, Math.ceil(uploadBytes / CHUNK_SIZE));
         const needs = { txs: BigInt(chunksNeeded + 2), bytes: BigInt(uploadBytes) };
-        await topUpBy(provider.ss58, BULLETIN_RPC, needs, "uploader");
+        await topUpBy(provider.ss58, BULLETIN_ENDPOINTS[0], needs, "uploader");
       }
       console.log("\n" + "=".repeat(60));
       console.log("Storage");
@@ -808,7 +804,7 @@ async function deploy(content, domainName = null, options = {}) {
                     carBytes,
                     cid: predictedCid,
                     toolVersion: VERSION,
-                    bulletinRpc: options.rpc ?? process.env.BULLETIN_RPC ?? DEFAULT_BULLETIN_RPC,
+                    bulletinRpc: BULLETIN_ENDPOINTS[0],
                     encrypted: Boolean(options.password)
                   }).catch((err) => err instanceof Error ? err : new Error(String(err)));
                 }
@@ -917,16 +913,11 @@ async function deploy(content, domainName = null, options = {}) {
           const freshness = await pollMirrorFreshness(mirror.url, cid, { timeoutMs: 3 * 60 * 1e3, intervalMs: 1e4 });
           if (freshness.verified) {
             console.log(`ok (${freshness.attempts} attempt${freshness.attempts === 1 ? "" : "s"}, ${(freshness.durationMs / 1e3).toFixed(0)}s).`);
+            setDeployAttribute("deploy.gh_pages_freshness_verified", "true");
           } else {
             console.log(`timed out.`);
             console.log(`   GitHub Pages last served cid=${freshness.lastCid ?? "n/a"} (expected ${cid}); it should catch up shortly. Non-fatal.`);
-            captureWarning("gh-pages mirror freshness poll timed out", {
-              url: mirror.url,
-              expectedCid: cid,
-              lastCid: freshness.lastCid ?? "n/a",
-              durationMs: freshness.durationMs,
-              attempts: freshness.attempts
-            });
+            setDeployAttribute("deploy.gh_pages_freshness_verified", "false");
           }
         });
       }
@@ -939,6 +930,7 @@ async function deploy(content, domainName = null, options = {}) {
       console.log("\n" + "=".repeat(60) + "\n");
       return { domainName: name, fullDomain: `${name}.dot`, cid, ipfsCid };
     } finally {
+      if (_deployRpcFailedOver) setDeployAttribute("deploy.rpc.failed_over", "true");
       provider?.client.destroy();
     }
   });
@@ -950,6 +942,7 @@ export {
   friendlyChainError,
   DEFAULT_BULLETIN_RPC,
   DEFAULT_POOL_SIZE,
+  CHUNK_MORTALITY_PERIOD,
   isConnectionError,
   deriveRootSigner,
   createCID,