bulletin-deploy 0.6.3 → 0.6.5-rc.0

package/dist/{chunk-IPTNRVHY.js → chunk-FBV763OM.js}

@@ -4,13 +4,13 @@ import {
   TX_TIMEOUT_MS,
   fetchNonce,
   validateDomainLabel
-} from "./chunk-TITCVJJF.js";
+} from "./chunk-NXITLUZT.js";
 import {
   derivePoolAccounts,
   ensureAuthorized,
   fetchPoolAuthorizations,
   selectAccount
-} from "./chunk-AIHW2WLO.js";
+} from "./chunk-LGPTJYA3.js";
 import {
   VERSION,
   captureWarning,
@@ -18,7 +18,7 @@ import {
   setDeployAttribute,
   withDeploySpan,
   withSpan
-} from "./chunk-ECOC6TV4.js";
+} from "./chunk-FHAEFLVV.js";
 
 // src/deploy.ts
 import { Buffer } from "buffer";
@@ -280,8 +280,10 @@ var BULLETIN_RPC = DEFAULT_BULLETIN_RPC;
 var POOL_SIZE = DEFAULT_POOL_SIZE;
 var CHUNK_SIZE = 1 * 1024 * 1024;
 var MAX_FILE_SIZE = 8 * 1024 * 1024;
-var MAX_RECONNECTIONS = parseInt(process.env.BULLETIN_MAX_RECONNECTIONS ?? "1", 10);
-var CHUNK_TIMEOUT_MS = 3e4;
+var MAX_RECONNECTIONS = parseInt(process.env.BULLETIN_MAX_RECONNECTIONS ?? "3", 10);
+var CHUNK_TIMEOUT_MS = parseInt(process.env.BULLETIN_CHUNK_TIMEOUT_MS ?? "60000", 10);
+var RETRY_BASE_DELAY_MS = 2e3;
+var RETRY_MAX_DELAY_MS = 15e3;
 function isConnectionError(error) {
   const msg = error?.message || String(error);
   return /heartbeat timeout|WS halt|Unable to connect/i.test(msg);
@@ -362,7 +364,7 @@ function toHashingEnum(mhCode) {
 }
 async function getProvider() {
   console.log(`   Connecting to Bulletin: ${BULLETIN_RPC}`);
-  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC)));
+  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider([BULLETIN_RPC])));
   const unsafeApi = client.getUnsafeApi();
   try {
     await cryptoWaitReady();
@@ -373,10 +375,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, BULLETIN_RPC);
+      await ensureAuthorized(unsafeApi, best.address, BULLETIN_RPC, `pool account ${best.index}`);
       selected = best;
     } else {
-      await ensureAuthorized(unsafeApi, selected, BULLETIN_RPC);
+      await ensureAuthorized(unsafeApi, selected.address, BULLETIN_RPC, `pool account ${selected.index}`);
     }
     console.log(`   Using pool account ${selected.index}: ${selected.address}`);
     setDeployAttribute("deploy.signer.mode", "pool");
@@ -390,7 +392,7 @@ async function getProvider() {
 }
 async function getDirectProvider(mnemonic) {
   console.log(`   Connecting to Bulletin: ${BULLETIN_RPC}`);
-  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC)));
+  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider([BULLETIN_RPC])));
   const unsafeApi = client.getUnsafeApi();
   const { signer, ss58 } = deriveRootSigner(mnemonic);
   console.log(`   Using direct signer: ${ss58}`);
@@ -401,46 +403,53 @@ async function getDirectProvider(mnemonic) {
   const bytesRemaining = auth ? auth.extent.bytes : 0n;
   if (txsRemaining === 0n && bytesRemaining === 0n) {
     client.destroy();
-    throw new Error(`Account ${ss58} is not authorized for Bulletin storage. Run 'bulletin-deploy --bootstrap --mnemonic "..."' or authorize the account on-chain first.`);
+    throw new Error(`Account ${ss58} is not authorized for Bulletin storage.`);
   }
   console.log(`   Authorization: ${txsRemaining} txs, ${Number(bytesRemaining) / 1e6}MB remaining`);
   setDeployAttribute("deploy.signer.mode", "direct");
   setDeployAttribute("deploy.signer.address", ss58);
   return { client, unsafeApi, signer, ss58 };
 }
+var MAX_BEST_CHAIN_DROPS = 5;
 function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction", rpc, senderSS58, expectedNonce, timeoutMs } = {}) {
   const timeout = timeoutMs ?? TX_TIMEOUT_MS;
   return new Promise((resolve2, reject) => {
     let settled = false;
+    let sub;
+    let dropCount = 0;
     const settle = (fn) => (...args) => {
-      if (!settled) {
-        settled = true;
-        clearTimeout(timer);
-        try {
-          sub.unsubscribe();
-        } catch {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        sub?.unsubscribe();
+      } catch {
+      }
+      fn(...args);
+    };
+    const tryNonceFallback = async () => {
+      if (!rpc || !senderSS58 || expectedNonce == null) return false;
+      try {
+        const currentNonce = await fetchNonce(rpc, senderSS58);
+        if (settled) return true;
+        if (currentNonce > expectedNonce) {
+          console.log(`      ${label}: nonce advanced (${expectedNonce} -> ${currentNonce}), tx was included`);
+          settle(resolve2)({ value: onSuccess(), viaFallback: true });
+          return true;
         }
-        fn(...args);
+      } catch (e) {
+        if (settled) return true;
+        console.log(`      ${label}: nonce fallback failed: ${e.message?.slice(0, 80)}`);
       }
+      return false;
     };
     const timer = setTimeout(async () => {
       if (settled) return;
-      if (rpc && senderSS58 && expectedNonce != null) {
-        try {
-          const currentNonce = await fetchNonce(rpc, senderSS58);
-          if (currentNonce > expectedNonce) {
-            console.log(`      ${label}: subscription timed out but nonce advanced (${expectedNonce} -> ${currentNonce}), tx was included`);
-            settle(resolve2)({ value: onSuccess(), viaFallback: true });
-            return;
-          }
-        } catch (e) {
-          console.log(`      ${label}: nonce check failed: ${e.message}`);
-        }
-      }
+      if (await tryNonceFallback()) return;
       settle(reject)(new Error(`${label} timed out after ${timeout / 1e3}s waiting for block confirmation`));
     }, timeout);
-    const sub = tx.signSubmitAndWatch(signer, txOpts).subscribe({
-      next: (event) => {
+    sub = tx.signSubmitAndWatch(signer, txOpts).subscribe({
+      next: async (event) => {
         if (event.type === "txBestBlocksState") {
           if (event.found) {
             if (event.ok) {
@@ -449,7 +458,14 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
               settle(reject)(new Error(`${label} dispatch error`));
             }
           } else {
-            console.log(`      ${label}: tx dropped from best chain, waiting for re-inclusion...`);
+            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...`);
+            }
           }
         }
       },
@@ -525,19 +541,38 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     ss58 = provider.ss58;
     ownsClient = true;
   }
+  const requiredTxs = BigInt(chunks.length + 1);
+  const auth = await unsafeApi.query.TransactionStorage.Authorizations.getValue(
+    Enum("Account", ss58)
+  );
+  const txsRemaining = auth ? BigInt(auth.extent.transactions) : 0n;
+  const bytesRemaining = auth ? auth.extent.bytes : 0n;
+  if (txsRemaining < requiredTxs || bytesRemaining < BigInt(totalBytes)) {
+    console.log(`
+   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);
+      console.log(`   Re-authorization successful`);
+    } catch (e) {
+      throw new Error(`Re-authorization failed: ${e.message}`);
+    }
+  }
   let reconnectionsUsed = 0;
   async function doReconnect() {
     if (!reconnect || reconnectionsUsed >= MAX_RECONNECTIONS) {
       throw new Error(`Connection lost and max reconnections (${MAX_RECONNECTIONS}) exhausted`);
     }
     reconnectionsUsed++;
+    const delay = Math.min(RETRY_BASE_DELAY_MS * Math.pow(2, reconnectionsUsed - 1), RETRY_MAX_DELAY_MS);
     console.log(`
-   Connection lost, reconnecting to Bulletin (${reconnectionsUsed}/${MAX_RECONNECTIONS})...`);
+   Connection lost, reconnecting to Bulletin in ${(delay / 1e3).toFixed(0)}s (${reconnectionsUsed}/${MAX_RECONNECTIONS})...`);
     captureWarning("WebSocket connection lost, reconnecting", { reconnection: reconnectionsUsed, maxReconnections: MAX_RECONNECTIONS });
     try {
       client.destroy();
     } catch {
     }
+    await new Promise((r) => setTimeout(r, delay));
     const fresh = await reconnect();
     client = fresh.client;
     unsafeApi = fresh.unsafeApi;
@@ -589,10 +624,19 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
         captureWarning("Chunk upload failed, retrying", { chunkIndex: fail.index + 1, maxRetries: MAX_CHUNK_RETRIES, error: fail.error?.message?.slice(0, 200) });
         let retried = false;
         for (let attempt = 1; attempt <= MAX_CHUNK_RETRIES; attempt++) {
-          console.log(`   Retrying chunk ${fail.index + 1} (attempt ${attempt}/${MAX_CHUNK_RETRIES})...`);
-          await new Promise((r) => setTimeout(r, 6e3));
-          const freshNonce = await fetchNonce(BULLETIN_RPC, ss58);
+          const retryDelay = Math.min(RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1), RETRY_MAX_DELAY_MS);
+          console.log(`   Retrying chunk ${fail.index + 1} (attempt ${attempt}/${MAX_CHUNK_RETRIES}) in ${(retryDelay / 1e3).toFixed(0)}s...`);
+          await new Promise((r) => setTimeout(r, retryDelay));
+          if (isConnectionError(fail.error) && reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
+            try {
+              await doReconnect();
+            } catch (reconnectErr) {
+              console.log(`   Reconnect failed: ${reconnectErr.message?.slice(0, 80)}`);
+              break;
+            }
+          }
           try {
+            const freshNonce = await fetchNonce(BULLETIN_RPC, ss58);
             const result2 = await storeChunk(unsafeApi, signer, fail.chunkData, freshNonce, ss58);
             stored[fail.index] = result2;
             retried = true;
@@ -600,6 +644,12 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
           } catch (e) {
             captureWarning("Chunk retry failed", { chunkIndex: fail.index + 1, attempt, maxRetries: MAX_CHUNK_RETRIES, error: e.message?.slice(0, 200) });
             console.log(`   Retry ${attempt} failed: ${e.message?.slice(0, 80)}`);
+            if (isConnectionError(e) && reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
+              try {
+                await doReconnect();
+              } catch {
+              }
+            }
           }
         }
         if (!retried) {

package/dist/{chunk-ECOC6TV4.js → chunk-FHAEFLVV.js}

@@ -6,7 +6,7 @@ import * as path from "path";
 // package.json
 var package_default = {
   name: "bulletin-deploy",
-  version: "0.6.3",
+  version: "0.6.5-rc.0",
   private: false,
   repository: {
     type: "git",
@@ -87,7 +87,7 @@ function extractRepoSlug(url) {
 }
 function tryGitRemote() {
   try {
-    return extractRepoSlug(execSync("git remote get-url origin", { encoding: "utf-8" }).trim());
+    return extractRepoSlug(execSync("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim());
   } catch {
     return void 0;
   }
@@ -106,7 +106,7 @@ function resolveRepo(domain) {
 }
 function tryGitBranch() {
   try {
-    return execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8" }).trim();
+    return execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return "unknown";
   }

package/dist/{chunk-AIHW2WLO.js → chunk-LGPTJYA3.js}

@@ -55,16 +55,16 @@ async function fetchPoolAuthorizations(api, accounts) {
   );
   return results;
 }
-async function ensureAuthorized(api, poolAccount, bulletinRpc) {
+async function ensureAuthorized(api, address, bulletinRpc, label) {
   const auth = await api.query.TransactionStorage.Authorizations.getValue(
-    Enum("Account", poolAccount.address)
+    Enum("Account", address)
   );
   const txsRemaining = auth ? BigInt(auth.extent.transactions) : 0n;
   const bytesRemaining = auth ? auth.extent.bytes : 0n;
   if (txsRemaining >= TOPUP_THRESHOLD_TXS && bytesRemaining >= TOPUP_THRESHOLD_BYTES) {
     return;
   }
-  console.log(`   Auto-authorizing pool account ${poolAccount.index} (${poolAccount.address.slice(0, 8)}...)...`);
+  console.log(`   Auto-authorizing ${label ?? "account"} (${address.slice(0, 8)}...)...`);
   const aliceClient = createClient(withPolkadotSdkCompat(getWsProvider(bulletinRpc)));
   const aliceApi = aliceClient.getUnsafeApi();
   try {
@@ -72,7 +72,7 @@ async function ensureAuthorized(api, poolAccount, bulletinRpc) {
     const alice = keyring.addFromUri("//Alice");
     const aliceSigner = getPolkadotSigner(alice.publicKey, "Sr25519", (data) => alice.sign(data));
     const tx = aliceApi.tx.TransactionStorage.authorize_account({
-      who: poolAccount.address,
+      who: address,
       transactions: TOPUP_TRANSACTIONS,
       bytes: TOPUP_BYTES
     });

package/dist/{chunk-TITCVJJF.js → chunk-NXITLUZT.js}

@@ -1,7 +1,7 @@
 import {
   captureWarning,
   withSpan
-} from "./chunk-ECOC6TV4.js";
+} from "./chunk-FHAEFLVV.js";
 
 // src/dotns.ts
 import crypto from "crypto";
@@ -51,13 +51,18 @@ var _rpcIdCounter = 0;
 async function fetchNonce(rpc, ss58Address) {
   const WS = globalThis.WebSocket ?? (await import("./wrapper-IFSKR7DG.js")).default;
   return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
+    let done = false;
+    const settle = (fn, ...args) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
       try {
         ws.close();
       } catch {
       }
-      reject(new Error(`fetchNonce timed out after 10s for ${rpc}`));
-    }, 1e4);
+      fn(...args);
+    };
+    const timer = setTimeout(() => settle(reject, new Error(`fetchNonce timed out after 8s for ${rpc}`)), 8e3);
     const ws = new WS(rpc);
     const id = ++_rpcIdCounter;
     ws.onopen = () => ws.send(JSON.stringify({ jsonrpc: "2.0", id, method: "system_accountNextIndex", params: [ss58Address] }));
@@ -65,16 +70,11 @@ async function fetchNonce(rpc, ss58Address) {
       const d = typeof e.data === "string" ? e.data : e.data.toString();
       const r = JSON.parse(d);
       if (r.id === id) {
-        clearTimeout(timeout);
-        ws.close();
-        r.error ? reject(new Error(r.error.message)) : resolve(r.result);
+        r.error ? settle(reject, new Error(r.error.message)) : settle(resolve, r.result);
       }
     };
-    ws.onerror = () => {
-      clearTimeout(timeout);
-      ws.close();
-      reject(new Error(`WebSocket to ${rpc} failed`));
-    };
+    ws.onerror = () => settle(reject, new Error(`WebSocket to ${rpc} failed`));
+    ws.onclose = () => settle(reject, new Error(`WebSocket to ${rpc} closed before response`));
   });
 }
 var ProofOfPersonhoodStatus = {

package/dist/deploy.js

@@ -19,10 +19,10 @@ import {
   storeChunkedContent,
   storeDirectory,
   storeFile
-} from "./chunk-IPTNRVHY.js";
-import "./chunk-TITCVJJF.js";
-import "./chunk-AIHW2WLO.js";
-import "./chunk-ECOC6TV4.js";
+} from "./chunk-FBV763OM.js";
+import "./chunk-NXITLUZT.js";
+import "./chunk-LGPTJYA3.js";
+import "./chunk-FHAEFLVV.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DEFAULT_BULLETIN_RPC,

package/dist/dotns.js

@@ -19,8 +19,8 @@ import {
   sanitizeDomainLabel,
   stripTrailingDigits,
   validateDomainLabel
-} from "./chunk-TITCVJJF.js";
-import "./chunk-ECOC6TV4.js";
+} from "./chunk-NXITLUZT.js";
+import "./chunk-FHAEFLVV.js";
 import "./chunk-QGM4M3NI.js";
 export {
   CONNECTION_TIMEOUT_MS,

package/dist/index.js

@@ -1,17 +1,17 @@
 import {
   deploy
-} from "./chunk-IPTNRVHY.js";
+} from "./chunk-FBV763OM.js";
 import {
   DotNS
-} from "./chunk-TITCVJJF.js";
+} from "./chunk-NXITLUZT.js";
 import {
   bootstrapPool,
   derivePoolAccounts,
   ensureAuthorized,
   fetchPoolAuthorizations,
   selectAccount
-} from "./chunk-AIHW2WLO.js";
-import "./chunk-ECOC6TV4.js";
+} from "./chunk-LGPTJYA3.js";
+import "./chunk-FHAEFLVV.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DotNS,

package/dist/pool.d.ts

@@ -14,7 +14,7 @@ interface PoolAuthorization extends PoolAccount {
 declare function derivePoolAccounts(poolSize?: number, mnemonic?: string): PoolAccount[];
 declare function selectAccount(authorizations: PoolAuthorization[]): PoolAuthorization | null;
 declare function fetchPoolAuthorizations(api: any, accounts: PoolAccount[]): Promise<PoolAuthorization[]>;
-declare function ensureAuthorized(api: any, poolAccount: PoolAccount, bulletinRpc: string): Promise<void>;
+declare function ensureAuthorized(api: any, address: string, bulletinRpc: string, label?: string): Promise<void>;
 declare function bootstrapPool(bulletinRpc: string, poolSize?: number, mnemonic?: string): Promise<void>;
 
 export { type PoolAccount, type PoolAuthorization, bootstrapPool, derivePoolAccounts, ensureAuthorized, fetchPoolAuthorizations, selectAccount };

package/dist/pool.js

@@ -4,7 +4,7 @@ import {
   ensureAuthorized,
   fetchPoolAuthorizations,
   selectAccount
-} from "./chunk-AIHW2WLO.js";
+} from "./chunk-LGPTJYA3.js";
 import "./chunk-QGM4M3NI.js";
 export {
   bootstrapPool,

package/dist/telemetry.js

@@ -8,7 +8,7 @@ import {
   setDeployAttribute,
   withDeploySpan,
   withSpan
-} from "./chunk-ECOC6TV4.js";
+} from "./chunk-FHAEFLVV.js";
 import "./chunk-QGM4M3NI.js";
 export {
   VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulletin-deploy",
-  "version": "0.6.3",
+  "version": "0.6.5-rc.0",
   "private": false,
   "repository": {
     "type": "git",