bulletin-deploy 0.5.4 → 0.5.6

package/README.md

@@ -43,6 +43,9 @@ bulletin-deploy ./dist my-app00.dot
 
 # Custom RPC endpoint
 bulletin-deploy --rpc wss://custom-bulletin.example.com ./dist my-app00.dot
+
+# Deploy and publish to the Playground remix registry
+bulletin-deploy --playground ./dist my-app00.dot
 ```
 
 ### All options
@@ -50,9 +53,24 @@ bulletin-deploy --rpc wss://custom-bulletin.example.com ./dist my-app00.dot
 ```
 Options:
   --rpc wss://...     Bulletin RPC (or set BULLETIN_RPC env var)
+  --mnemonic "..."    DotNS owner mnemonic (or set MNEMONIC env var)
+  --playground        Publish to the Playground remix registry
+  --pool-size N       Number of pool accounts (default: 10)
   --help              Show help
 ```
 
+### Playground registry
+
+By default, deploys only upload to Bulletin storage and register the DotNS domain. The **Playground remix registry** is an on-chain app directory that makes your deploy visible in [Polkadot Playground](https://playground.polkadot.cloud).
+
+To publish to it, pass `--playground`:
+
+```bash
+bulletin-deploy --playground ./dist my-app.dot
+```
+
+This requires `cdm.json` in your project root (shipped with bulletin-deploy) and a git remote origin.
+
 ## GitHub Actions
 
 1. Copy `workflows/deploy-on-pr.yml` to your repo's `.github/workflows/` directory

package/bin/bulletin-deploy

@@ -13,6 +13,7 @@ for (let i = 0; i < args.length; i++) {
   else if (args[i] === "--pool-size") { flags.poolSize = parseInt(args[++i], 10); }
   else if (args[i] === "--mnemonic") { flags.mnemonic = args[++i]; }
   else if (args[i] === "--rpc") { flags.rpc = args[++i]; }
+  else if (args[i] === "--playground") { flags.playground = true; }
   else if (args[i] === "--help" || args[i] === "-h") { flags.help = true; }
   else { positional.push(args[i]); }
 }
@@ -26,6 +27,7 @@ Options:
   --mnemonic "..."    DotNS owner mnemonic (or set MNEMONIC env var)
   --rpc wss://...     Bulletin RPC (or set BULLETIN_RPC env var)
   --pool-size N       Number of pool accounts (default: 10)
+  --playground        Publish to the playground remix registry
   --help              Show this help`);
   process.exit(0);
 }
@@ -37,14 +39,17 @@ try {
   if (flags.bootstrap) {
     const rpc = process.env.BULLETIN_RPC || "wss://paseo-bulletin-rpc.polkadot.io";
     const poolSize = parseInt(process.env.BULLETIN_POOL_SIZE || "10", 10);
-    await bootstrapPool(rpc, poolSize);
+    await bootstrapPool(rpc, poolSize, flags.mnemonic);
   } else {
     const [buildDir, domain] = positional;
     if (!buildDir) { console.error("Error: build directory required"); process.exit(1); }
     if (!domain) { console.error("Error: domain required (e.g. my-app.dot)"); process.exit(1); }
     if (!fs.existsSync(buildDir)) { console.error(`Error: ${buildDir} does not exist`); process.exit(1); }
 
-    const result = await deploy(buildDir, domain);
+    const result = await deploy(buildDir, domain, {
+      playground: flags.playground,
+      mnemonic: flags.mnemonic,
+    });
 
     const output = process.env.GITHUB_OUTPUT;
     if (output) {

package/cdm.json

@@ -13,8 +13,8 @@
   "contracts": {
     "acc2c3b5e912b762": {
       "@example/playground-registry": {
-        "version": 2,
-        "address": "0x7D97a3E87c0C2fe921E471D076b95975886CEAA8",
+        "version": 3,
+        "address": "0xF8304E5C17769A53E012f39c6990cC8a7AaBC6A5",
         "abi": [
           {
             "type": "constructor",
@@ -39,35 +39,58 @@
           },
           {
             "type": "function",
-            "name": "getMetadataUri",
+            "name": "getAppCount",
+            "inputs": [],
+            "outputs": [
+              {
+                "name": "",
+                "type": "uint32"
+              }
+            ],
+            "stateMutability": "view"
+          },
+          {
+            "type": "function",
+            "name": "getDomainAt",
             "inputs": [
               {
-                "name": "domain",
+                "name": "index",
+                "type": "uint32"
+              }
+            ],
+            "outputs": [
+              {
+                "name": "",
                 "type": "string"
               }
             ],
+            "stateMutability": "view"
+          },
+          {
+            "type": "function",
+            "name": "getOwnerAppCount",
+            "inputs": [
+              {
+                "name": "owner",
+                "type": "address"
+              }
+            ],
             "outputs": [
               {
                 "name": "",
-                "type": "tuple",
-                "components": [
-                  {
-                    "name": "isSome",
-                    "type": "bool"
-                  },
-                  {
-                    "name": "value",
-                    "type": "string"
-                  }
-                ]
+                "type": "uint32"
               }
             ],
             "stateMutability": "view"
           },
           {
             "type": "function",
-            "name": "getDomainAt",
+            "name": "getOwnerDomainAt",
             "inputs": [
+              {
+                "name": "owner",
+                "type": "address"
+              },
               {
                 "name": "index",
                 "type": "uint32"
@@ -83,7 +106,7 @@
           },
           {
             "type": "function",
-            "name": "getOwner",
+            "name": "getMetadataUri",
             "inputs": [
               {
                 "name": "domain",
@@ -93,25 +116,40 @@
             "outputs": [
               {
                 "name": "",
-                "type": "address"
+                "type": "tuple",
+                "components": [
+                  {
+                    "name": "isSome",
+                    "type": "bool"
+                  },
+                  {
+                    "name": "value",
+                    "type": "string"
+                  }
+                ]
               }
             ],
             "stateMutability": "view"
           },
           {
             "type": "function",
-            "name": "getAppCount",
-            "inputs": [],
+            "name": "getOwner",
+            "inputs": [
+              {
+                "name": "domain",
+                "type": "string"
+              }
+            ],
             "outputs": [
               {
                 "name": "",
-                "type": "uint32"
+                "type": "address"
               }
             ],
             "stateMutability": "view"
           }
         ],
-        "metadataCid": "bafk2bzacecrjrmrgumcww7oc23rllfscbxpd2lxc6p2svb26c6e5tjvmr565s"
+        "metadataCid": "bafk2bzacebkch7cuoi77j5vkrkoplax4urywwga7ijamtd3pntv7xjgabhtgs"
       }
     }
   }

package/dist/{chunk-2RURGSQW.js → chunk-4ZPXQDUZ.js}

@@ -56,6 +56,9 @@ function getDeployAttributes(domain) {
     "deploy.pr": process.env.GITHUB_PR_NUMBER || void 0
   };
 }
+function isExpectedError(msg) {
+  return /personhood|owned by|owner mismatch|reserved for original|invalid domain label|not authorized for bulletin/i.test(msg);
+}
 async function withSpan(op, description, attributes, fn) {
   if (!Sentry) return fn();
   return Sentry.startSpan({ op, name: description, attributes }, async (span) => {
@@ -63,9 +66,7 @@ async function withSpan(op, description, attributes, fn) {
       return await fn();
     } catch (error) {
       span.setAttribute("error.message", error.message);
-      Sentry.setTag("deploy.phase", op);
-      Sentry.captureException(error);
-      error._sentryCaptured = true;
+      span.setStatus({ code: 2, message: "internal_error" });
       throw error;
     }
   });
@@ -84,11 +85,12 @@ async function withDeploySpan(domain, fn) {
       try {
         return await fn();
       } catch (error) {
+        const msg = error.message;
         span.setAttribute("deploy.status", "error");
-        span.setAttribute("deploy.error", error.message);
-        if (!error._sentryCaptured) {
-          Sentry.setTag("deploy.phase", "deploy");
-          Sentry.captureException(error);
+        span.setAttribute("deploy.error", msg);
+        const isExpected = isExpectedError(msg);
+        if (!isExpected) {
+          span.setStatus({ code: 2, message: "internal_error" });
         }
         throw error;
       }
@@ -118,6 +120,7 @@ async function flush() {
 export {
   initTelemetry,
   resolveRepo,
+  isExpectedError,
   withSpan,
   withDeploySpan,
   setDeployAttribute,

package/dist/{chunk-OMZHBMOF.js → chunk-CXNOJQNX.js}

@@ -3,7 +3,7 @@ import {
   DotNS,
   TX_TIMEOUT_MS,
   fetchNonce
-} from "./chunk-K2KKLHWN.js";
+} from "./chunk-YTCA5JTA.js";
 import {
   derivePoolAccounts,
   ensureAuthorized,
@@ -16,7 +16,7 @@ import {
   setDeployAttribute,
   withDeploySpan,
   withSpan
-} from "./chunk-2RURGSQW.js";
+} from "./chunk-4ZPXQDUZ.js";
 
 // src/deploy.ts
 import { Buffer } from "buffer";
@@ -26,7 +26,7 @@ import { fileURLToPath } from "url";
 import { execSync } from "child_process";
 import { sha256 } from "@noble/hashes/sha256";
 import { blake2b } from "@noble/hashes/blake2b";
-import { createClient as createPolkadotClient } from "polkadot-api";
+import { createClient as createPolkadotClient, Enum } from "polkadot-api";
 import { Binary } from "@polkadot-api/substrate-bindings";
 import { getWsProvider } from "polkadot-api/ws-provider";
 import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
@@ -43,7 +43,6 @@ import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
 import { mnemonicToEntropy, entropyToMiniSecret, ss58Address } from "@polkadot-labs/hdkd-helpers";
 var BULLETIN_RPC = process.env.BULLETIN_RPC || "wss://paseo-bulletin-rpc.polkadot.io";
 var POOL_SIZE = parseInt(process.env.BULLETIN_POOL_SIZE || "10", 10);
-var POOL_MNEMONIC = process.env.BULLETIN_POOL_MNEMONIC || void 0;
 var CHUNK_SIZE = 1 * 1024 * 1024;
 var MAX_FILE_SIZE = 8 * 1024 * 1024;
 var CID_CONFIG = { version: 1, codec: 85, hashCode: 18, hashLength: 32 };
@@ -60,15 +59,18 @@ function getGitRemoteUrl() {
     return null;
   }
 }
-function getRegistrySigner() {
-  const mnemonic = process.env.DOTNS_MNEMONIC || process.env.MNEMONIC || DEFAULT_MNEMONIC;
+function deriveRootSigner(mnemonic) {
   const entropy = mnemonicToEntropy(mnemonic);
   const miniSecret = entropyToMiniSecret(entropy);
   const derive = sr25519CreateDerive(miniSecret);
   const keyPair = derive("");
   const signer = getPolkadotSigner(keyPair.publicKey, "Sr25519", keyPair.sign);
-  const origin = ss58Address(keyPair.publicKey);
-  return { signer, origin };
+  return { signer, ss58: ss58Address(keyPair.publicKey) };
+}
+function getRegistrySigner(explicitMnemonic) {
+  const mnemonic = explicitMnemonic || process.env.DOTNS_MNEMONIC || process.env.MNEMONIC || DEFAULT_MNEMONIC;
+  const { signer, ss58 } = deriveRootSigner(mnemonic);
+  return { signer, origin: ss58 };
 }
 function createCID(data, codec = CID_CONFIG.codec, hashCode = CID_CONFIG.hashCode) {
   let hash;
@@ -103,7 +105,8 @@ async function getProvider() {
   const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC)));
   const unsafeApi = client.getUnsafeApi();
   await cryptoWaitReady();
-  const poolAccounts = derivePoolAccounts(POOL_SIZE, POOL_MNEMONIC);
+  const poolMnemonic = process.env.BULLETIN_POOL_MNEMONIC || void 0;
+  const poolAccounts = derivePoolAccounts(POOL_SIZE, poolMnemonic);
   const authorizations = await fetchPoolAuthorizations(unsafeApi, poolAccounts);
   let selected = selectAccount(authorizations);
   if (!selected) {
@@ -115,10 +118,31 @@ async function getProvider() {
     await ensureAuthorized(unsafeApi, selected, BULLETIN_RPC);
   }
   console.log(`   Using pool account ${selected.index}: ${selected.address}`);
+  setDeployAttribute("deploy.signer.mode", "pool");
   setDeployAttribute("deploy.pool.account", selected.address);
   setDeployAttribute("deploy.pool.index", selected.index);
   return { client, unsafeApi, signer: selected.signer, ss58: selected.address };
 }
+async function getDirectProvider(mnemonic) {
+  console.log(`   Connecting to Bulletin: ${BULLETIN_RPC}`);
+  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC)));
+  const unsafeApi = client.getUnsafeApi();
+  const { signer, ss58 } = deriveRootSigner(mnemonic);
+  console.log(`   Using direct signer: ${ss58}`);
+  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 === 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.`);
+  }
+  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 };
+}
 function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction", rpc, senderSS58, expectedNonce } = {}) {
   return new Promise((resolve2, reject) => {
     let settled = false;
@@ -348,7 +372,7 @@ async function merkleize(directoryPath, outputCarPath) {
   console.log(`   CAR: ${(size / 1024 / 1024).toFixed(2)} MB`);
   return { carPath: outputCarPath, cid };
 }
-async function storeDirectory(directoryPath) {
+async function storeDirectory(directoryPath, provider = {}) {
   const carPath = path.join(path.dirname(directoryPath), `${path.basename(directoryPath)}.car`);
   const { cid: ipfsCid } = await withSpan("deploy.merkleize", "1a. merkleize", { "deploy.directory": directoryPath }, async () => {
     return merkleize(directoryPath, carPath);
@@ -356,11 +380,11 @@ async function storeDirectory(directoryPath) {
   const carBuffer = fs.readFileSync(carPath);
   const carChunks = chunk(carBuffer, CHUNK_SIZE);
   const storageCid = await withSpan("deploy.chunk-upload", "1b. chunk-upload", { "deploy.chunks.total": carChunks.length, "deploy.car.bytes": carBuffer.length }, async () => {
-    return storeChunkedContent(carChunks);
+    return storeChunkedContent(carChunks, provider);
   });
   return { storageCid, ipfsCid };
 }
-async function deploy(content, domainName = null) {
+async function deploy(content, domainName = null, options = {}) {
   initTelemetry();
   const randomSuffix = Math.floor(Math.random() * 100).toString().padStart(2, "0");
   const name = domainName ? domainName.replace(".dot", "") : `test-domain-${Date.now().toString(36)}${randomSuffix}`;
@@ -372,134 +396,139 @@ async function deploy(content, domainName = null) {
     console.log("=".repeat(60));
     console.log(`   Domain: ${name}.dot`);
     if (typeof content === "string") console.log(`   Build dir: ${path.resolve(content)}`);
-    console.log("\n" + "=".repeat(60));
-    console.log("Storage");
-    console.log("=".repeat(60));
-    await withSpan("deploy.storage", "1. storage", {}, async () => {
-      if (process.env.IPFS_CID) {
-        cid = process.env.IPFS_CID;
-        ipfsCid = cid;
-        console.log(`
+    const provider = options.mnemonic ? await getDirectProvider(options.mnemonic) : await getProvider();
+    try {
+      console.log("\n" + "=".repeat(60));
+      console.log("Storage");
+      console.log("=".repeat(60));
+      await withSpan("deploy.storage", "1. storage", {}, async () => {
+        if (process.env.IPFS_CID) {
+          cid = process.env.IPFS_CID;
+          ipfsCid = cid;
+          console.log(`
    Using CID: ${cid}`);
-      } else if (Array.isArray(content)) {
-        console.log(`
-   Mode: Multi-chunk (${content.length} chunks)`);
-        cid = await storeChunkedContent(content);
-      } else if (typeof content === "string") {
-        const contentPath = path.resolve(content);
-        if (!fs.existsSync(contentPath)) throw new Error(`Path not found: ${contentPath}`);
-        const stats = fs.statSync(contentPath);
-        if (stats.isDirectory()) {
+        } else if (Array.isArray(content)) {
           console.log(`
+   Mode: Multi-chunk (${content.length} chunks)`);
+          cid = await storeChunkedContent(content, provider);
+        } else if (typeof content === "string") {
+          const contentPath = path.resolve(content);
+          if (!fs.existsSync(contentPath)) throw new Error(`Path not found: ${contentPath}`);
+          const stats = fs.statSync(contentPath);
+          if (stats.isDirectory()) {
+            console.log(`
    Mode: Directory`);
-          console.log(`   Path: ${contentPath}`);
-          const result = await storeDirectory(contentPath);
-          cid = result.storageCid;
-          ipfsCid = result.ipfsCid;
-        } else {
-          console.log(`
+            console.log(`   Path: ${contentPath}`);
+            const result = await storeDirectory(contentPath, provider);
+            cid = result.storageCid;
+            ipfsCid = result.ipfsCid;
+          } else {
+            console.log(`
    Mode: File`);
-          console.log(`   Path: ${contentPath}`);
-          const fileContent = fs.readFileSync(contentPath);
-          if (fileContent.length > MAX_FILE_SIZE) {
+            console.log(`   Path: ${contentPath}`);
+            const fileContent = fs.readFileSync(contentPath);
+            if (fileContent.length > MAX_FILE_SIZE) {
+              console.log(`   Exceeds 8MB, chunking...`);
+              cid = await storeChunkedContent(chunk(fileContent), provider);
+            } else {
+              cid = await storeFile(new Uint8Array(fileContent), provider);
+            }
+          }
+        } else if (content instanceof Uint8Array) {
+          console.log(`
+   Mode: Bytes`);
+          if (content.length > MAX_FILE_SIZE) {
             console.log(`   Exceeds 8MB, chunking...`);
-            cid = await storeChunkedContent(chunk(fileContent));
+            cid = await storeChunkedContent(chunk(content), provider);
           } else {
-            cid = await storeFile(new Uint8Array(fileContent));
+            cid = await storeFile(content, provider);
           }
+        } else {
+          throw new Error("Invalid content: must be path, Uint8Array, or Array<Uint8Array>");
         }
-      } else if (content instanceof Uint8Array) {
-        console.log(`
-   Mode: Bytes`);
-        if (content.length > MAX_FILE_SIZE) {
-          console.log(`   Exceeds 8MB, chunking...`);
-          cid = await storeChunkedContent(chunk(content));
+      });
+      setDeployAttribute("deploy.cid", cid);
+      console.log("\n" + "=".repeat(60));
+      console.log("DotNS");
+      console.log("=".repeat(60));
+      await withSpan("deploy.dotns", "2. dotns", { "deploy.domain": name }, async () => {
+        const dotns = new DotNS();
+        await dotns.connect(options.mnemonic ? { mnemonic: options.mnemonic } : {});
+        const { owned, owner } = await dotns.checkOwnership(name);
+        if (owned) {
+          console.log(`   Status: Already owned`);
+        } else if (owner && owner !== "0x0000000000000000000000000000000000000000") {
+          throw new Error(`Domain ${name}.dot is owned by ${owner}, not ${dotns.evmAddress}`);
         } else {
-          cid = await storeFile(content);
+          console.log(`   Status: Registering...`);
+          await dotns.register(name);
         }
-      } else {
-        throw new Error("Invalid content: must be path, Uint8Array, or Array<Uint8Array>");
-      }
-    });
-    setDeployAttribute("deploy.cid", cid);
-    console.log("\n" + "=".repeat(60));
-    console.log("DotNS");
-    console.log("=".repeat(60));
-    await withSpan("deploy.dotns", "2. dotns", { "deploy.domain": name }, async () => {
-      const dotns = new DotNS();
-      await dotns.connect();
-      const { owned, owner } = await dotns.checkOwnership(name);
-      if (owned) {
-        console.log(`   Status: Already owned`);
-      } else if (owner && owner !== "0x0000000000000000000000000000000000000000") {
-        throw new Error(`Domain ${name}.dot is owned by ${owner}, not ${dotns.evmAddress}`);
-      } else {
-        console.log(`   Status: Registering...`);
-        await dotns.register(name);
-      }
-      const contenthashHex = `0x${encodeContenthash(cid)}`;
-      await dotns.setContenthash(name, contenthashHex);
-      dotns.disconnect();
-    });
-    console.log("\n" + "=".repeat(60));
-    console.log("Registry");
-    console.log("=".repeat(60));
-    await withSpan("deploy.registry", "3. registry", { "deploy.domain": name }, async () => {
-      const repoUrl = getGitRemoteUrl();
-      if (!repoUrl) {
-        console.log("\n   Skipping registry: not a git repository (no remote origin found)");
-        return;
-      }
-      if (!fs.existsSync(CDM_JSON_PATH)) {
-        console.log("\n   Skipping registry: cdm.json not found");
-        return;
-      }
-      console.log(`
-   Repository: ${repoUrl}`);
-      const metadata = JSON.stringify({ repository: repoUrl });
-      const metadataBytes = new Uint8Array(Buffer.from(metadata, "utf-8"));
-      console.log(`   Uploading metadata to Bulletin...`);
-      const metadataCid = await storeFile(metadataBytes);
-      console.log(`   Metadata CID: ${metadataCid}`);
-      const cdmJson = JSON.parse(fs.readFileSync(CDM_JSON_PATH, "utf-8"));
-      const { signer, origin } = getRegistrySigner();
-      console.log(`   Publishing to registry as ${origin}...`);
-      const MAX_REGISTRY_RETRIES = 3;
-      for (let attempt = 1; attempt <= MAX_REGISTRY_RETRIES; attempt++) {
-        const cdm = createCdm(cdmJson, { 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 app 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;
+        const contenthashHex = `0x${encodeContenthash(cid)}`;
+        await dotns.setContenthash(name, contenthashHex);
+        dotns.disconnect();
+      });
+      if (options.playground) {
+        console.log("\n" + "=".repeat(60));
+        console.log("Playground Registry");
+        console.log("=".repeat(60));
+        await withSpan("deploy.registry", "3. registry", { "deploy.domain": name }, async () => {
+          const repoUrl = getGitRemoteUrl();
+          if (!fs.existsSync(CDM_JSON_PATH)) {
+            console.log("\n   Skipping registry: cdm.json not found");
+            return;
           }
-          throw e;
-        } finally {
-          cdm.destroy();
-        }
+          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 cdmJson = JSON.parse(fs.readFileSync(CDM_JSON_PATH, "utf-8"));
+          const { signer, origin } = getRegistrySigner(options.mnemonic);
+          console.log(`   Publishing to registry as ${origin}...`);
+          const MAX_REGISTRY_RETRIES = 3;
+          for (let attempt = 1; attempt <= MAX_REGISTRY_RETRIES; attempt++) {
+            const cdm = createCdm(cdmJson, { 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();
+            }
+          }
+        });
       }
-    });
-    console.log("\n" + "=".repeat(60));
-    console.log("DEPLOYMENT COMPLETE!");
-    console.log("=".repeat(60));
-    console.log("\n\u{1F53A} Polkadot Triangle");
-    console.log(`   - Polkadot Desktop: ${name}.dot`);
-    console.log(`   - Polkadot Browser: https://${name}.dot.li`);
-    console.log("\n" + "=".repeat(60) + "\n");
-    return { domainName: name, fullDomain: `${name}.dot`, cid, ipfsCid };
+      console.log("\n" + "=".repeat(60));
+      console.log("DEPLOYMENT COMPLETE!");
+      console.log("=".repeat(60));
+      console.log("\n\u{1F53A} Polkadot Triangle");
+      console.log(`   - Polkadot Desktop: ${name}.dot`);
+      console.log(`   - Polkadot Browser: https://${name}.dot.li`);
+      console.log("\n" + "=".repeat(60) + "\n");
+      return { domainName: name, fullDomain: `${name}.dot`, cid, ipfsCid };
+    } finally {
+      provider.client.destroy();
+    }
   });
 }
 
 export {
+  deriveRootSigner,
   createCID,
   encodeContenthash,
   storeFile,

package/dist/{chunk-K2KKLHWN.js → chunk-YTCA5JTA.js}

@@ -1,7 +1,7 @@
 import {
   captureWarning,
   withSpan
-} from "./chunk-2RURGSQW.js";
+} from "./chunk-4ZPXQDUZ.js";
 
 // src/dotns.ts
 import crypto from "crypto";
@@ -607,7 +607,10 @@ var DotNS = class {
   }
   async register(label, options = {}) {
     return withSpan("deploy.dotns.register", `2a. register ${label}.dot`, {}, async () => {
-      const status = parseProofOfPersonhoodStatus(options.status || process.env.DOTNS_STATUS);
+      const MAINNET_RPC_PATTERNS = ["polkadot-asset-hub-rpc.polkadot.io", "kusama-asset-hub-rpc.polkadot.io", "polkadothub-rpc.com/mainnet"];
+      const isMainnet = this.rpc && MAINNET_RPC_PATTERNS.some((p) => this.rpc.includes(p));
+      const statusDefault = isMainnet ? "none" : "full";
+      const status = parseProofOfPersonhoodStatus(options.status || process.env.DOTNS_STATUS || statusDefault);
       const reverse = options.reverse ?? (process.env.DOTNS_REVERSE ?? "false").toLowerCase() === "true";
       if (!this.connected) await this.connect(options);
       label = validateDomainLabel(label);

package/dist/deploy.d.ts

@@ -14,6 +14,10 @@ interface ExistingProvider {
     signer?: PolkadotSigner;
     ss58?: string;
 }
+declare function deriveRootSigner(mnemonic: string): {
+    signer: PolkadotSigner;
+    ss58: string;
+};
 declare function createCID(data: Uint8Array, codec?: number, hashCode?: number): CID;
 declare function encodeContenthash(cidString: string): string;
 declare function storeFile(contentBytes: Uint8Array, { client: existingClient, unsafeApi: existingApi, signer: existingSigner }?: ExistingProvider): Promise<string>;
@@ -24,10 +28,14 @@ declare function merkleize(directoryPath: string, outputCarPath: string): Promis
     carPath: string;
     cid: string;
 }>;
-declare function storeDirectory(directoryPath: string): Promise<{
+declare function storeDirectory(directoryPath: string, provider?: ExistingProvider): Promise<{
     storageCid: string;
     ipfsCid: string;
 }>;
-declare function deploy(content: DeployContent, domainName?: string | null): Promise<DeployResult>;
+interface DeployOptions {
+    playground?: boolean;
+    mnemonic?: string;
+}
+declare function deploy(content: DeployContent, domainName?: string | null, options?: DeployOptions): Promise<DeployResult>;
 
-export { type DeployContent, type DeployResult, chunk, createCID, deploy, encodeContenthash, hasIPFS, merkleize, storeChunkedContent, storeDirectory, storeFile };
+export { type DeployContent, type DeployOptions, type DeployResult, chunk, createCID, deploy, deriveRootSigner, encodeContenthash, hasIPFS, merkleize, storeChunkedContent, storeDirectory, storeFile };

package/dist/deploy.js

@@ -2,21 +2,23 @@ import {
   chunk,
   createCID,
   deploy,
+  deriveRootSigner,
   encodeContenthash,
   hasIPFS,
   merkleize,
   storeChunkedContent,
   storeDirectory,
   storeFile
-} from "./chunk-OMZHBMOF.js";
-import "./chunk-K2KKLHWN.js";
+} from "./chunk-CXNOJQNX.js";
+import "./chunk-YTCA5JTA.js";
 import "./chunk-RV7XBIIO.js";
-import "./chunk-2RURGSQW.js";
+import "./chunk-4ZPXQDUZ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   chunk,
   createCID,
   deploy,
+  deriveRootSigner,
   encodeContenthash,
   hasIPFS,
   merkleize,

package/dist/dotns.js

@@ -18,8 +18,8 @@ import {
   sanitizeDomainLabel,
   stripTrailingDigits,
   validateDomainLabel
-} from "./chunk-K2KKLHWN.js";
-import "./chunk-2RURGSQW.js";
+} from "./chunk-YTCA5JTA.js";
+import "./chunk-4ZPXQDUZ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   CONTRACTS,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { DeployContent, DeployResult, deploy } from './deploy.js';
+export { DeployContent, DeployOptions, DeployResult, deploy } from './deploy.js';
 export { PoolAccount, PoolAuthorization, bootstrapPool, derivePoolAccounts, ensureAuthorized, fetchPoolAuthorizations, selectAccount } from './pool.js';
 export { DotNS, DotNSConnectOptions, OwnershipResult, PriceValidationResult } from './dotns.js';
 import 'multiformats/cid';

package/dist/index.js

@@ -1,9 +1,9 @@
 import {
   deploy
-} from "./chunk-OMZHBMOF.js";
+} from "./chunk-CXNOJQNX.js";
 import {
   DotNS
-} from "./chunk-K2KKLHWN.js";
+} from "./chunk-YTCA5JTA.js";
 import {
   bootstrapPool,
   derivePoolAccounts,
@@ -11,7 +11,7 @@ import {
   fetchPoolAuthorizations,
   selectAccount
 } from "./chunk-RV7XBIIO.js";
-import "./chunk-2RURGSQW.js";
+import "./chunk-4ZPXQDUZ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DotNS,

package/dist/telemetry.d.ts

@@ -1,9 +1,10 @@
 declare function initTelemetry(): void;
 declare function resolveRepo(domain: string): string;
+declare function isExpectedError(msg: string): boolean;
 declare function withSpan<T>(op: string, description: string, attributes: Record<string, string | number | boolean | undefined>, fn: () => T | Promise<T>): Promise<T>;
 declare function withDeploySpan<T>(domain: string, fn: () => T | Promise<T>): Promise<T>;
 declare function setDeployAttribute(key: string, value: string | number | boolean): void;
 declare function captureWarning(message: string, context?: Record<string, unknown>): void;
 declare function flush(): Promise<void>;
 
-export { captureWarning, flush, initTelemetry, resolveRepo, setDeployAttribute, withDeploySpan, withSpan };
+export { captureWarning, flush, initTelemetry, isExpectedError, resolveRepo, setDeployAttribute, withDeploySpan, withSpan };

package/dist/telemetry.js

@@ -2,16 +2,18 @@ import {
   captureWarning,
   flush,
   initTelemetry,
+  isExpectedError,
   resolveRepo,
   setDeployAttribute,
   withDeploySpan,
   withSpan
-} from "./chunk-2RURGSQW.js";
+} from "./chunk-4ZPXQDUZ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   captureWarning,
   flush,
   initTelemetry,
+  isExpectedError,
   resolveRepo,
   setDeployAttribute,
   withDeploySpan,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulletin-deploy",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "private": false,
   "repository": {
     "type": "git",