bulletin-deploy 0.6.16 → 0.7.1

package/dist/{chunk-K7TA53E2.js → chunk-BVTSCGRO.js}

@@ -1,38 +1,43 @@
 import {
-  DEFAULT_MNEMONIC,
+  setDeployContext
+} from "./chunk-5N4VL73E.js";
+import {
   DotNS,
   TX_TIMEOUT_MS,
   fetchNonce,
   popStatusName,
   validateDomainLabel
-} from "./chunk-3C7PWPPG.js";
+} from "./chunk-MORJYP3A.js";
 import {
   MirrorSkipped,
-  mirrorToGitHubPages
-} from "./chunk-UZVOH3HB.js";
-import {
-  merkleizeJS
-} from "./chunk-QILGABSF.js";
-import {
-  derivePoolAccounts,
-  detectTestnet,
-  ensureAuthorized,
-  fetchPoolAuthorizations,
-  selectAccount,
-  topUpBy
-} from "./chunk-JHNW2EKY.js";
+  mirrorToGitHubPages,
+  pollMirrorFreshness
+} from "./chunk-2Q2WSKFD.js";
 import {
   VERSION,
   captureWarning,
   initTelemetry,
   resolveRunner,
   resolveRunnerType,
+  sampleMemory,
   setDeployAttribute,
+  setDeployReportContext,
   setDeploySentryTag,
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-LF3XAUCI.js";
+} from "./chunk-PH43YXEE.js";
+import {
+  merkleizeJS
+} from "./chunk-B7GUYYAN.js";
+import {
+  derivePoolAccounts,
+  detectTestnet,
+  ensureAuthorized,
+  fetchPoolAuthorizations,
+  selectAccount,
+  topUpBy
+} from "./chunk-JHNW2EKY.js";
 
 // src/deploy.ts
 import { Buffer } from "buffer";
@@ -52,262 +57,9 @@ import { base58btc } from "multiformats/bases/base58";
 import * as dagPB from "@ipld/dag-pb";
 import { UnixFS } from "ipfs-unixfs";
 import { cryptoWaitReady } from "@polkadot/util-crypto";
-import { createCdm } from "@dotdm/cdm";
 import { getPolkadotSigner } from "polkadot-api/signer";
 import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
 import { mnemonicToEntropy, entropyToMiniSecret, ss58Address } from "@polkadot-labs/hdkd-helpers";
-
-// cdm.json
-var cdm_default = {
-  targets: {
-    acc2c3b5e912b762: {
-      "asset-hub": "wss://asset-hub-paseo-rpc.n.dwellir.com",
-      bulletin: "https://paseo-ipfs.polkadot.io/ipfs"
-    }
-  },
-  dependencies: {
-    acc2c3b5e912b762: {
-      "@example/playground-registry": "latest"
-    }
-  },
-  contracts: {
-    acc2c3b5e912b762: {
-      "@example/playground-registry": {
-        version: 6,
-        address: "0x279585Cb8E8971e34520A3ebbda3E0C4D77C3d97",
-        abi: [
-          {
-            type: "constructor",
-            inputs: [],
-            stateMutability: "nonpayable"
-          },
-          {
-            type: "function",
-            name: "publish",
-            inputs: [
-              {
-                name: "domain",
-                type: "string"
-              },
-              {
-                name: "metadata_uri",
-                type: "string"
-              }
-            ],
-            outputs: [],
-            stateMutability: "nonpayable"
-          },
-          {
-            type: "function",
-            name: "unpublish",
-            inputs: [
-              {
-                name: "domain",
-                type: "string"
-              }
-            ],
-            outputs: [],
-            stateMutability: "nonpayable"
-          },
-          {
-            type: "function",
-            name: "rateApp",
-            inputs: [
-              {
-                name: "domain",
-                type: "string"
-              },
-              {
-                name: "rating",
-                type: "uint8"
-              },
-              {
-                name: "comment_uri",
-                type: "string"
-              }
-            ],
-            outputs: [],
-            stateMutability: "nonpayable"
-          },
-          {
-            type: "function",
-            name: "removeRating",
-            inputs: [
-              {
-                name: "domain",
-                type: "string"
-              },
-              {
-                name: "reviewer",
-                type: "address"
-              }
-            ],
-            outputs: [],
-            stateMutability: "nonpayable"
-          },
-          {
-            type: "function",
-            name: "getContextId",
-            inputs: [],
-            outputs: [
-              {
-                name: "",
-                type: "bytes32"
-              }
-            ],
-            stateMutability: "view"
-          },
-          {
-            type: "function",
-            name: "getAppCount",
-            inputs: [],
-            outputs: [
-              {
-                name: "",
-                type: "uint32"
-              }
-            ],
-            stateMutability: "view"
-          },
-          {
-            type: "function",
-            name: "getDomainAt",
-            inputs: [
-              {
-                name: "index",
-                type: "uint32"
-              }
-            ],
-            outputs: [
-              {
-                name: "",
-                type: "tuple",
-                components: [
-                  {
-                    name: "isSome",
-                    type: "bool"
-                  },
-                  {
-                    name: "value",
-                    type: "string"
-                  }
-                ]
-              }
-            ],
-            stateMutability: "view"
-          },
-          {
-            type: "function",
-            name: "getOwnerAppCount",
-            inputs: [
-              {
-                name: "owner",
-                type: "address"
-              }
-            ],
-            outputs: [
-              {
-                name: "",
-                type: "uint32"
-              }
-            ],
-            stateMutability: "view"
-          },
-          {
-            type: "function",
-            name: "getOwnerDomainAt",
-            inputs: [
-              {
-                name: "owner",
-                type: "address"
-              },
-              {
-                name: "index",
-                type: "uint32"
-              }
-            ],
-            outputs: [
-              {
-                name: "",
-                type: "tuple",
-                components: [
-                  {
-                    name: "isSome",
-                    type: "bool"
-                  },
-                  {
-                    name: "value",
-                    type: "string"
-                  }
-                ]
-              }
-            ],
-            stateMutability: "view"
-          },
-          {
-            type: "function",
-            name: "getSudo",
-            inputs: [],
-            outputs: [
-              {
-                name: "",
-                type: "address"
-              }
-            ],
-            stateMutability: "view"
-          },
-          {
-            type: "function",
-            name: "getMetadataUri",
-            inputs: [
-              {
-                name: "domain",
-                type: "string"
-              }
-            ],
-            outputs: [
-              {
-                name: "",
-                type: "tuple",
-                components: [
-                  {
-                    name: "isSome",
-                    type: "bool"
-                  },
-                  {
-                    name: "value",
-                    type: "string"
-                  }
-                ]
-              }
-            ],
-            stateMutability: "view"
-          },
-          {
-            type: "function",
-            name: "getOwner",
-            inputs: [
-              {
-                name: "domain",
-                type: "string"
-              }
-            ],
-            outputs: [
-              {
-                name: "",
-                type: "address"
-              }
-            ],
-            stateMutability: "view"
-          }
-        ],
-        metadataCid: "bafk2bzaceck7veaix4ttzyd6bmwlssgycrrlgilpat2c272nczzlrgnqy6fze"
-      }
-    }
-  }
-};
-
-// src/deploy.ts
 var NonRetryableError = class extends Error {
   constructor(message) {
     super(message);
@@ -337,17 +89,6 @@ function isConnectionError(error) {
   return /heartbeat timeout|WS halt|Unable to connect/i.test(msg);
 }
 var CID_CONFIG = { version: 1, codec: 85, hashCode: 18, hashLength: 32 };
-function getGitRemoteUrl() {
-  try {
-    const raw = execSync("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    if (raw.startsWith("git@")) {
-      return raw.replace(/^git@([^:]+):/, "https://$1/").replace(/\.git$/, "");
-    }
-    return raw.replace(/\.git$/, "");
-  } catch {
-    return null;
-  }
-}
 function deriveRootSigner(mnemonic, path2 = "") {
   const entropy = mnemonicToEntropy(mnemonic);
   const miniSecret = entropyToMiniSecret(entropy);
@@ -356,11 +97,6 @@ function deriveRootSigner(mnemonic, path2 = "") {
   const signer = getPolkadotSigner(keyPair.publicKey, "Sr25519", keyPair.sign);
   return { signer, ss58: ss58Address(keyPair.publicKey) };
 }
-function getRegistrySigner(explicitMnemonic, derivationPath) {
-  const mnemonic = explicitMnemonic || process.env.DOTNS_MNEMONIC || process.env.MNEMONIC || DEFAULT_MNEMONIC;
-  const { signer, ss58 } = deriveRootSigner(mnemonic, derivationPath ?? "");
-  return { signer, origin: ss58 };
-}
 function createCID(data, codec = CID_CONFIG.codec, hashCode = CID_CONFIG.hashCode) {
   let hash;
   if (hashCode === 45600) hash = blake2b(data, { dkLen: CID_CONFIG.hashLength });
@@ -431,7 +167,7 @@ async function getProvider() {
     console.log(`   Using pool account ${selected.index}: ${selected.address}`);
     setDeployAttribute("deploy.signer.mode", "pool");
     setDeployAttribute("deploy.pool.account", truncateAddress(selected.address));
-    setDeployAttribute("deploy.pool.index", selected.index);
+    setDeployAttribute("deploy.pool.index", String(selected.index));
     return { client, unsafeApi, signer: selected.signer, ss58: selected.address };
   } catch (e) {
     client.destroy();
@@ -617,6 +353,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     console.log(`
    Connection lost, reconnecting to Bulletin in ${(delay / 1e3).toFixed(0)}s (${reconnectionsUsed}/${MAX_RECONNECTIONS})...`);
     captureWarning("WebSocket connection lost, reconnecting", { reconnection: reconnectionsUsed, maxReconnections: MAX_RECONNECTIONS });
+    sampleMemory(`reconnect_${reconnectionsUsed}_before`);
     try {
       client.destroy();
     } catch {
@@ -628,6 +365,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     signer = fresh.signer;
     ss58 = fresh.ss58;
     ownsClient = true;
+    sampleMemory(`reconnect_${reconnectionsUsed}_after`);
   }
   try {
     let startNonce = await fetchNonce(BULLETIN_RPC, ss58);
@@ -797,7 +535,7 @@ function chunk(data, size = CHUNK_SIZE) {
   let offset = 0;
   while (offset < data.length) {
     const end = Math.min(offset + size, data.length);
-    chunks.push(new Uint8Array(data.subarray(offset, end)));
+    chunks.push(data.subarray(offset, end));
     offset = end;
   }
   return chunks;
@@ -826,33 +564,78 @@ async function merkleize(directoryPath, outputCarPath) {
   console.log(`   CAR: ${(size / 1024 / 1024).toFixed(2)} MB`);
   return { carPath: outputCarPath, cid };
 }
-async function storeDirectory(directoryPath, provider = {}, password, jsMerkle) {
+function computeStorageCid(chunks) {
+  const hashCode = 18;
+  const chunkInfo = chunks.map((c) => ({
+    cid: createCID(c, CID_CONFIG.codec, hashCode),
+    len: c.length
+  }));
+  const fileData = new UnixFS({ type: "file", blockSizes: chunkInfo.map((c) => BigInt(c.len)) });
+  const dagNode = dagPB.prepare({ Data: fileData.marshal(), Links: chunkInfo.map((c) => ({ Name: "", Tsize: c.len, Hash: c.cid })) });
+  const dagBytes = dagPB.encode(dagNode);
+  return createCID(dagBytes, 112, hashCode).toString();
+}
+async function storeDirectory(directoryPath, providerOrOptions = {}, password, jsMerkle) {
+  const opts = providerOrOptions && ("provider" in providerOrOptions || "onCarReady" in providerOrOptions || "password" in providerOrOptions || "jsMerkle" in providerOrOptions) ? providerOrOptions : { provider: providerOrOptions, password, jsMerkle };
+  const provider = opts.provider ?? {};
+  password = opts.password;
+  jsMerkle = opts.jsMerkle;
   let carContent;
   let ipfsCid;
   const dirBasename = path.basename(directoryPath);
+  sampleMemory("storage_start");
   if (jsMerkle) {
     const result = await withSpan("deploy.merkleize", "1a. merkleize (js)", { "deploy.directory": dirBasename }, async () => {
-      return merkleizeJS(directoryPath);
+      const r = await merkleizeJS(directoryPath);
+      sampleMemory("merkleize_end");
+      return r;
     });
     carContent = result.carBytes;
     ipfsCid = result.cid;
   } else {
     const carPath = path.join(path.dirname(directoryPath), `${path.basename(directoryPath)}.car`);
     const { cid } = await withSpan("deploy.merkleize", "1a. merkleize", { "deploy.directory": dirBasename }, async () => {
-      return merkleize(directoryPath, carPath);
+      const r = await merkleize(directoryPath, carPath);
+      sampleMemory("merkleize_end");
+      return r;
     });
     ipfsCid = cid;
-    carContent = new Uint8Array(fs.readFileSync(carPath));
+    carContent = fs.readFileSync(carPath);
   }
   if (password) {
     console.log(`   Encrypting CAR file...`);
     carContent = await encryptContent(carContent, password);
     console.log(`   Encrypted: ${(carContent.length / 1024 / 1024).toFixed(2)} MB`);
   }
+  const dumpPath = process.env.BULLETIN_DEPLOY_DUMP_CAR ?? path.join(path.dirname(directoryPath), `${path.basename(directoryPath)}.bulletin.car`);
+  fs.writeFileSync(dumpPath, carContent);
+  console.log(`   Pre-upload CAR saved to ${dumpPath} (${(carContent.length / 1024 / 1024).toFixed(2)} MB)`);
   const carChunks = chunk(carContent, CHUNK_SIZE);
-  const storageCid = await withSpan("deploy.chunk-upload", "1b. chunk-upload", { "deploy.chunks.total": carChunks.length, "deploy.car.bytes": carContent.length }, async () => {
-    return storeChunkedContent(carChunks, provider);
+  const predictedStorageCid = computeStorageCid(carChunks);
+  if (opts.onCarReady) await opts.onCarReady(carContent, predictedStorageCid);
+  setDeployReportContext({
+    jsMerkle: Boolean(jsMerkle),
+    chunkCount: carChunks.length,
+    carBytes: carContent.length,
+    outputDir: path.dirname(directoryPath)
+  });
+  setDeployContext({
+    chunkCount: carChunks.length,
+    totalSize: `${(carContent.length / 1024 / 1024).toFixed(2)} MB`
   });
+  const carMb = String(Math.round(carContent.length / 1024 / 1024 * 100) / 100);
+  const storageCid = await withSpan("deploy.chunk-upload", "1b. chunk-upload", { "deploy.chunks.total": String(carChunks.length), "deploy.car.bytes": String(carContent.length), "deploy.car.mb": carMb }, async () => {
+    sampleMemory("chunk_upload_start");
+    const r = await storeChunkedContent(carChunks, provider);
+    sampleMemory("chunk_upload_end");
+    return r;
+  });
+  if (storageCid !== predictedStorageCid) {
+    captureWarning("computeStorageCid drift vs storeChunkedContent", {
+      predicted: predictedStorageCid,
+      uploaded: storageCid
+    });
+  }
   return { storageCid, ipfsCid, carBytes: carContent };
 }
 async function estimateUploadBytes(content) {
@@ -896,7 +679,7 @@ async function deploy(content, domainName = null, options = {}) {
     }
     let cid;
     let ipfsCid;
-    let mirrorCarBytes;
+    let mirrorPromise = Promise.resolve(null);
     console.log("\n" + "=".repeat(60));
     console.log(`DEPLOYING TO TESTNET                    v${VERSION}`);
     console.log("=".repeat(60));
@@ -997,10 +780,25 @@ async function deploy(content, domainName = null, options = {}) {
             console.log(`
    Mode: Directory`);
             console.log(`   Path: ${contentPath}`);
-            const dirResult = await storeDirectory(contentPath, providerWithReconnect, options.password, options.jsMerkle);
-            cid = dirResult.storageCid;
-            ipfsCid = dirResult.ipfsCid;
-            mirrorCarBytes = dirResult.carBytes;
+            const { storageCid: sCid, ipfsCid: iCid } = await storeDirectory(contentPath, {
+              provider: providerWithReconnect,
+              password: options.password,
+              jsMerkle: options.jsMerkle,
+              onCarReady: (carBytes, predictedCid) => {
+                if (options.ghPagesMirror) {
+                  mirrorPromise = mirrorToGitHubPages({
+                    domain: name,
+                    carBytes,
+                    cid: predictedCid,
+                    toolVersion: VERSION,
+                    bulletinRpc: options.rpc ?? process.env.BULLETIN_RPC ?? DEFAULT_BULLETIN_RPC,
+                    encrypted: Boolean(options.password)
+                  }).catch((err) => err instanceof Error ? err : new Error(String(err)));
+                }
+              }
+            });
+            cid = sCid;
+            ipfsCid = iCid;
           } else {
             console.log(`
    Mode: File`);
@@ -1064,74 +862,40 @@ async function deploy(content, domainName = null, options = {}) {
       });
       if (options.ghPagesMirror) {
         console.log("\n" + "=".repeat(60));
-        console.log("GitHub Pages mirror");
-        console.log("=".repeat(60));
-        if (!mirrorCarBytes) {
-          console.log("   Skipped: --gh-pages-mirror only supports directory deploys (no CAR captured for this content type).");
-        } else {
-          await withSpan("deploy.gh-pages-mirror", "3b. gh-pages-mirror", { "deploy.domain": name }, async () => {
-            try {
-              const mirror = await mirrorToGitHubPages({
-                domain: name,
-                carBytes: mirrorCarBytes,
-                cid,
-                toolVersion: VERSION,
-                bulletinRpc: options.rpc ?? process.env.BULLETIN_RPC ?? DEFAULT_BULLETIN_RPC,
-                encrypted: Boolean(options.password)
-              });
-              console.log(`   Mirror: ${mirror.url}`);
-              console.log(`   Manifest: https://${mirror.owner}.github.io/${mirror.repo}/${mirror.manifestPath}`);
-              setDeployAttribute("deploy.gh_pages_url", mirror.url);
-            } catch (err) {
-              if (err instanceof MirrorSkipped) {
-                console.log(`   Skipped: ${err.message}`);
-              } else {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.log(`   Failed (non-fatal): ${msg}`);
-                captureWarning("gh-pages mirror failed", { error: msg.slice(0, 200) });
-              }
-            }
-          });
-        }
-      }
-      if (options.playground) {
-        console.log("\n" + "=".repeat(60));
-        console.log("Playground Registry");
+        console.log("Final checks");
         console.log("=".repeat(60));
-        await withSpan("deploy.registry", "3. registry", { "deploy.domain": name }, async () => {
-          const repoUrl = getGitRemoteUrl();
-          const metadata = {};
-          if (repoUrl) metadata.repository = repoUrl;
-          console.log(`
-   Metadata: ${JSON.stringify(metadata)}`);
-          const metadataBytes = new Uint8Array(Buffer.from(JSON.stringify(metadata), "utf-8"));
-          console.log(`   Uploading metadata to Bulletin...`);
-          const metadataCid = await storeFile(metadataBytes, provider);
-          console.log(`   Metadata CID: ${metadataCid}`);
-          const { signer, origin } = options.signer && options.signerAddress ? { signer: options.signer, origin: options.signerAddress } : getRegistrySigner(options.mnemonic, options.derivationPath);
-          console.log(`   Publishing to registry as ${origin}...`);
-          const MAX_REGISTRY_RETRIES = 3;
-          for (let attempt = 1; attempt <= MAX_REGISTRY_RETRIES; attempt++) {
-            const cdm = createCdm(cdm_default, { defaultSigner: signer, defaultOrigin: origin });
-            try {
-              const registry = cdm.getContract("@example/playground-registry");
-              const result = await registry.publish.tx(`${name}.dot`, metadataCid);
-              if (!result.ok) throw new Error("Registry publish transaction failed");
-              console.log(`   Tx: ${result.txHash}`);
-              console.log(`   Registered ${name}.dot in playground registry!`);
-              break;
-            } catch (e) {
-              if (attempt < MAX_REGISTRY_RETRIES) {
-                captureWarning("Registry publish failed, retrying", { attempt, maxRetries: MAX_REGISTRY_RETRIES, error: e.message?.slice(0, 200) });
-                console.log(`   Attempt ${attempt} failed: ${e.message?.slice(0, 80)}`);
-                console.log(`   Retrying in 6s...`);
-                await new Promise((r) => setTimeout(r, 6e3));
-                continue;
-              }
-              throw e;
-            } finally {
-              cdm.destroy();
-            }
+        await withSpan("deploy.gh-pages-mirror", "4. gh-pages-mirror", { "deploy.domain": name }, async () => {
+          const mirror = await mirrorPromise;
+          if (mirror === null) {
+            console.log("   GitHub Pages mirror: skipped (only directory deploys produce a CAR suitable for mirroring).");
+            return;
+          }
+          if (mirror instanceof MirrorSkipped) {
+            console.log(`   GitHub Pages mirror: skipped \u2014 ${mirror.message}`);
+            return;
+          }
+          if (mirror instanceof Error) {
+            console.log(`   GitHub Pages mirror: failed (non-fatal) \u2014 ${mirror.message}`);
+            captureWarning("gh-pages mirror failed", { error: mirror.message.slice(0, 200) });
+            return;
+          }
+          console.log(`   Mirror: ${mirror.url}`);
+          console.log(`   Manifest: https://${mirror.owner}.github.io/${mirror.repo}/${mirror.manifestPath}`);
+          setDeployAttribute("deploy.gh_pages_url", mirror.url);
+          process.stdout.write("   Verifying Pages serves this deploy's CAR... ");
+          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).`);
+          } 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
+            });
           }
         });
       }
@@ -1171,6 +935,7 @@ export {
   chunk,
   hasIPFS,
   merkleize,
+  computeStorageCid,
   storeDirectory,
   estimateUploadBytes,
   deploy

package/dist/{chunk-BGLOVKHX.js → chunk-DYKCMHZ6.js}

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

package/dist/{chunk-3C7PWPPG.js → chunk-MORJYP3A.js}

@@ -1,10 +1,10 @@
-import {
-  isTestnetSpecName
-} from "./chunk-JHNW2EKY.js";
 import {
   captureWarning,
   withSpan
-} from "./chunk-LF3XAUCI.js";
+} from "./chunk-PH43YXEE.js";
+import {
+  isTestnetSpecName
+} from "./chunk-JHNW2EKY.js";
 
 // src/dotns.ts
 import crypto from "crypto";