@parity/product-deploy 0.7.28-rc.0

package/dist/chunk-2VAUMZB2.js

@@ -0,0 +1,284 @@
+import {
+  PEOPLE_MEMBER_IDENTIFIER_HEX,
+  PGAS_ASSET_ID,
+  PROOF_BYTES
+} from "./chunk-T7EEVWNU.js";
+import {
+  buildImplicationMessage,
+  buildV5GeneralExtrinsic,
+  bytesToHex,
+  encodeMembers,
+  hexToBytes,
+  readExtensionOrder,
+  toHex
+} from "./chunk-ZYVGHDMU.js";
+
+// src/personhood/claim-pgas.ts
+import { Enum } from "polkadot-api";
+var PgasClaimError = class extends Error {
+  kind;
+  dispatchError;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "PgasClaimError";
+    this.kind = options.kind ?? "Unknown";
+    this.dispatchError = options.dispatchError;
+  }
+};
+var SECS_PER_DAY = 86400n;
+var IMPLICATION_EXCLUDE = /* @__PURE__ */ new Set([
+  "AuthorizeCall",
+  "AsPgas",
+  "StorageWeightReclaim"
+]);
+var PGAS_CONTEXT_PREFIX = new TextEncoder().encode("pop:gas:");
+function buildGasContext(day, slotIndex) {
+  const out = new Uint8Array(32);
+  out.set(PGAS_CONTEXT_PREFIX, 0);
+  const dv = new DataView(out.buffer);
+  dv.setUint32(8, day, true);
+  dv.setUint32(12, slotIndex, true);
+  return out;
+}
+function buildAsPgasClaimExtensionValue(proof, ringIndex, revision, day) {
+  return Enum("Claim", {
+    proof: bytesToHex(proof),
+    ring_index: ringIndex,
+    revision,
+    collection: Enum("People"),
+    day
+  });
+}
+var claimPgas = async ({
+  peopleUnsafeApi,
+  ahUnsafeApi,
+  ahClient,
+  target,
+  memberKey,
+  buildRingProof,
+  slotIndex = 0,
+  progress
+}) => {
+  const people = peopleUnsafeApi;
+  const ah = ahUnsafeApi;
+  if (memberKey.length !== 32) {
+    throw new PgasClaimError("memberKey must be 32 bytes", { kind: "ClientError" });
+  }
+  const asset = await ah.query.Assets.Asset.getValue(PGAS_ASSET_ID, { at: "best" });
+  if (!asset) {
+    throw new PgasClaimError(
+      "PGAS asset (id 2_000_000_000) does not exist on AH",
+      { kind: "PgasAssetNotCreated" }
+    );
+  }
+  const position = await people.query.Members.Members.getValue(
+    PEOPLE_MEMBER_IDENTIFIER_HEX,
+    bytesToHex(memberKey),
+    { at: "best" }
+  );
+  if (!position) {
+    throw new PgasClaimError(
+      "member key not present on People \u2014 recognize first",
+      { kind: "NotARecognizedPerson" }
+    );
+  }
+  if (position.type !== "Included") {
+    throw new PgasClaimError(
+      `member position is '${position.type}', expected 'Included'`,
+      { kind: "NotARecognizedPerson" }
+    );
+  }
+  const ringIndex = position.value.ring_index;
+  const allEntries = await people.query.Members.RingKeys.getEntries({ at: "best" });
+  const pages = [];
+  const identHex = PEOPLE_MEMBER_IDENTIFIER_HEX.toLowerCase();
+  for (const entry of allEntries) {
+    if (entry.keyArgs[0].toLowerCase() !== identHex) continue;
+    if (Number(entry.keyArgs[1]) !== ringIndex) continue;
+    pages.push([Number(entry.keyArgs[2]), [...entry.value]]);
+  }
+  pages.sort((a, b) => a[0] - b[0]);
+  const ringKeys = pages.flatMap(([, ks]) => ks);
+  if (ringKeys.length === 0) {
+    throw new PgasClaimError("ring has no members on People", {
+      kind: "ClientError"
+    });
+  }
+  const membersBytes = encodeMembers(ringKeys.map((k) => hexToBytes(k)));
+  const collectionId = await ah.constants.AliasAccounts.PeopleCollectionIdentifier();
+  const ringExp = await ah.constants.AliasAccounts.PeopleRingExponent();
+  const ringExponent = ringExp.type === "R2e9" ? 9 : ringExp.type === "R2e10" ? 10 : 14;
+  const ringRoots = await ah.query.MembersSubscriber.RingRoots.getValue(
+    collectionId,
+    ringIndex,
+    { at: "best" }
+  );
+  if (!ringRoots || ringRoots.length === 0) {
+    throw new PgasClaimError(
+      "AH has no RingRoots for this (collection, ring_index)",
+      { kind: "RingRootNotFound" }
+    );
+  }
+  const latest = ringRoots[ringRoots.length - 1];
+  const revision = latest.revision;
+  const nowRaw = await ah.query.Timestamp.Now.getValue({ at: "best" });
+  const nowSec = nowRaw > 10000000000n ? nowRaw / 1000n : nowRaw;
+  const day = Number(nowSec / SECS_PER_DAY);
+  const contextBytes = buildGasContext(day, slotIndex);
+  const innerTx = ah.tx.Pgas.claim_pgas({ slot_index: slotIndex, target });
+  const callBytes = await innerTx.getEncodedData();
+  const passEmpty = await capturePass(innerTx, void 0);
+  const msg = buildImplicationMessage(
+    callBytes,
+    passEmpty.extensions,
+    IMPLICATION_EXCLUDE
+  );
+  const { proof, alias } = await buildRingProof({
+    ringExponent,
+    members: membersBytes,
+    context: contextBytes,
+    msg
+  });
+  if (proof.length !== PROOF_BYTES) {
+    throw new PgasClaimError(
+      `ring proof must be ${PROOF_BYTES} bytes, got ${proof.length}`,
+      { kind: "ClientError" }
+    );
+  }
+  const asPgasValue = Enum("Claim", {
+    proof: bytesToHex(proof),
+    ring_index: ringIndex,
+    revision,
+    collection: Enum("People"),
+    day
+  });
+  const passProof = await capturePass(innerTx, asPgasValue);
+  const extrinsicBytes = buildV5GeneralExtrinsic(callBytes, passProof.extensions);
+  const extrinsicHex = toHex(extrinsicBytes);
+  const blockHash = await submitExtrinsic(ahClient, extrinsicHex, progress);
+  const amount = await ah.constants.Pgas.PgasClaimAmount();
+  return { blockHash, amount, alias };
+};
+var capturePass = async (innerTx, asPgasValue) => {
+  let captured = null;
+  const sentinel = new Error("__pgas_capture_sentinel__");
+  const signer = {
+    publicKey: new Uint8Array(32),
+    signTx: async (callData, signedExtensions, metadata) => {
+      const order = await readExtensionOrder(metadata);
+      const byIdentifier = {};
+      for (const id of order) {
+        const ext = signedExtensions[id];
+        byIdentifier[id] = {
+          value: ext.value,
+          additionalSigned: ext.additionalSigned
+        };
+      }
+      captured = { callData, extensions: { order, byIdentifier } };
+      throw sentinel;
+    },
+    signBytes: async () => new Uint8Array(64)
+  };
+  try {
+    await innerTx.sign(signer, {
+      mortality: { mortal: false },
+      customSignedExtensions: {
+        AsPgas: {
+          value: asPgasValue,
+          additionalSigned: new Uint8Array()
+        }
+      }
+    });
+  } catch (err) {
+    if (err !== sentinel) throw err;
+  }
+  if (captured === null) {
+    throw new PgasClaimError("extension capture failed", { kind: "ClientError" });
+  }
+  return captured;
+};
+var narrowDispatchError = (dispatchError) => {
+  if (typeof dispatchError === "object" && dispatchError !== null && "type" in dispatchError) {
+    const d = dispatchError;
+    if (d.type === "Invalid" && typeof d.value === "object" && d.value !== null) {
+      const v = d.value;
+      if (v.type === "BadProof") return "BadProof";
+      if (v.type === "Custom") {
+        switch (v.value) {
+          case 230:
+            return "InvalidClaimSlot";
+          case 231:
+            return "InvalidClaimDay";
+          case 232:
+            return "AlreadyClaimedToday";
+          case 233:
+            return "PgasAssetNotCreated";
+        }
+      }
+    }
+  }
+  return "DispatchError";
+};
+var submitExtrinsic = (client, extrinsicHex, progress) => {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    };
+    const succeed = (h) => {
+      if (settled) return;
+      settled = true;
+      resolve(h);
+    };
+    client.submitAndWatch(hexToBytes(extrinsicHex)).subscribe({
+      next: (event) => {
+        if (settled) return;
+        if (event.type === "broadcasted") {
+          progress?.onBroadcasted?.();
+          return;
+        }
+        if (event.type === "txBestBlocksState" && event.found) {
+          if (event.ok === false) {
+            fail(
+              new PgasClaimError("claim_pgas dispatched but failed in-block", {
+                kind: narrowDispatchError(event.dispatchError),
+                dispatchError: event.dispatchError
+              })
+            );
+            return;
+          }
+          progress?.onBestBlock?.(event.block.hash);
+          return;
+        }
+        if (event.type === "finalized") {
+          if (event.ok === false) {
+            fail(
+              new PgasClaimError("claim_pgas failed at finalization", {
+                kind: narrowDispatchError(event.dispatchError),
+                dispatchError: event.dispatchError
+              })
+            );
+            return;
+          }
+          succeed(event.block.hash);
+        }
+      },
+      error: (err) => {
+        fail(
+          err instanceof PgasClaimError ? err : new PgasClaimError(
+            err instanceof Error ? `RPC rejected extrinsic: ${err.message}` : "RPC error during submitAndWatch",
+            { cause: err, kind: "RpcError" }
+          )
+        );
+      }
+    });
+  });
+};
+
+export {
+  PgasClaimError,
+  buildAsPgasClaimExtensionValue,
+  claimPgas
+};

package/dist/chunk-43HLT335.js

@@ -0,0 +1,232 @@
+import {
+  VERSION
+} from "./chunk-MFTODIIT.js";
+
+// src/version-check.ts
+import { execSync, execFileSync } from "child_process";
+import { createInterface } from "readline";
+var REGISTRY_URL = "https://registry.npmjs.org/bulletin-deploy/latest";
+var KILL_SWITCH_URL = "https://raw.githubusercontent.com/paritytech/triangle-deploy/main/min-version.json";
+var FETCH_TIMEOUT = 3e3;
+function checkNodeVersion(enginesNode, currentVersion) {
+  const match = enginesNode.match(/(\d+)/);
+  if (!match) return null;
+  const required = parseInt(match[1], 10);
+  const actual = parseInt(currentVersion.replace(/^v/, "").split(".")[0], 10);
+  if (actual < required) {
+    return `bulletin-deploy requires Node.js ${enginesNode} (running ${currentVersion}).
+       Download a supported version at https://nodejs.org/`;
+  }
+  return null;
+}
+function compareSemver(a, b) {
+  const [coreA, preA] = a.split("-", 2);
+  const [coreB, preB] = b.split("-", 2);
+  const pa = coreA.split(".").map(Number);
+  const pb = coreB.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+  }
+  if (preA && !preB) return -1;
+  if (!preA && preB) return 1;
+  return 0;
+}
+function isPreReleaseVersion(version) {
+  return version.includes("-");
+}
+function preReleaseWarning(version) {
+  if (!isPreReleaseVersion(version)) return null;
+  return [
+    "",
+    `\u26A0\uFE0F  Running bulletin-deploy ${version} (release candidate).`,
+    "   This version is not recommended for production deploys.",
+    "   For stable:  npm install -g bulletin-deploy@latest",
+    ""
+  ].join("\n");
+}
+async function fetchJson(url) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+    const res = await fetch(url, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function fetchVersionInfo() {
+  const [registry, killSwitch] = await Promise.all([
+    fetchJson(REGISTRY_URL),
+    fetchJson(KILL_SWITCH_URL)
+  ]);
+  if (!registry && !killSwitch) return null;
+  return {
+    latest: registry?.version ?? VERSION,
+    minimumFromRegistry: registry?.minimumVersion ?? null,
+    minimumFromKillSwitch: killSwitch?.minimumVersion ?? null,
+    killSwitchMessage: killSwitch?.message ?? null
+  };
+}
+function handlePreflightVersionCheck(info) {
+  if (!info) return "ok";
+  const effectiveMinimum = [info.minimumFromRegistry, info.minimumFromKillSwitch].filter(Boolean).sort((a, b) => compareSemver(b, a))[0] ?? null;
+  if (effectiveMinimum && compareSemver(VERSION, effectiveMinimum) < 0) {
+    console.error(`
+   bulletin-deploy ${VERSION} is no longer supported (minimum: ${effectiveMinimum}).`);
+    const ks = info.killSwitchMessage;
+    if (ks) console.error(`   Reason: ${ks}`);
+    console.error(`   Please update: npm install -g bulletin-deploy@latest
+`);
+    return "abort";
+  }
+  if (compareSemver(VERSION, info.latest) < 0) {
+    console.error(`
+   A newer version of bulletin-deploy is available (${VERSION} \u2192 ${info.latest}).`);
+    console.error(`   Run: npm install -g bulletin-deploy@latest
+`);
+    return "nudge";
+  }
+  return "ok";
+}
+function isInternalUser(cwd) {
+  const repo = process.env.GITHUB_REPOSITORY;
+  if (repo?.startsWith("paritytech/")) return true;
+  const opts = { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], ...cwd ? { cwd } : {} };
+  try {
+    const remote = execSync("git remote get-url origin", opts).trim();
+    if (remote.includes("paritytech/")) return true;
+  } catch {
+  }
+  try {
+    const email = execSync("git config user.email", opts).trim();
+    if (email.endsWith("@parity.io")) return true;
+  } catch {
+  }
+  return false;
+}
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && !process.env.CI);
+}
+async function promptYesNo(question, input) {
+  const stdin = input ?? process.stdin;
+  if (!input && !process.stdin.isTTY) return false;
+  const rl = createInterface({ input: stdin, output: process.stderr });
+  let answered = false;
+  return new Promise((resolve) => {
+    rl.on("close", () => {
+      if (!answered) {
+        answered = true;
+        resolve(false);
+      }
+    });
+    rl.question(question, (answer) => {
+      if (answered) return;
+      const a = answer.trim().toLowerCase();
+      if (a === "" || a === "y" || a === "yes") {
+        answered = true;
+        rl.close();
+        resolve(true);
+      } else if (a === "n" || a === "no") {
+        answered = true;
+        rl.close();
+        resolve(false);
+      } else {
+        rl.question("   Please answer Y or N: ", (retry) => {
+          if (answered) return;
+          const r = retry.trim().toLowerCase();
+          answered = true;
+          rl.close();
+          resolve(r === "" || r === "y" || r === "yes");
+        });
+      }
+    });
+  });
+}
+function updateAndRetry() {
+  console.error("\n   Updating bulletin-deploy...");
+  try {
+    execSync("npm install -g bulletin-deploy@latest", { stdio: "inherit" });
+    console.error("   Updated. Retrying deploy...\n");
+    execFileSync(process.argv[0], process.argv.slice(1), { stdio: "inherit" });
+    process.exit(0);
+  } catch {
+    console.error("   Update failed. Please run: npm install -g bulletin-deploy@latest");
+    process.exit(1);
+  }
+}
+function classifyErrorArea(msg) {
+  if (/personhood|owned by|owner mismatch|reserved for original|domain|dotns|commit-reveal/i.test(msg)) return "area:dotns";
+  if (/chunk|storage|authorized|authorization|pool|alice/i.test(msg)) return "area:storage";
+  if (/ipfs|cid|pin|dag/i.test(msg)) return "area:ipfs";
+  if (/connect|timeout|websocket|rpc|ECONNREFUSED|ENOTFOUND/i.test(msg)) return "area:network";
+  return null;
+}
+function assessVersion(currentVersion, info, internal) {
+  const effectiveMinimum = [info.minimumFromRegistry, info.minimumFromKillSwitch].filter(Boolean).sort((a, b) => compareSemver(b, a))[0] ?? null;
+  if (effectiveMinimum && compareSemver(currentVersion, effectiveMinimum) < 0) {
+    return { action: "forced_update", currentVersion, minimumVersion: effectiveMinimum, message: info.killSwitchMessage };
+  }
+  if (compareSemver(currentVersion, info.latest) < 0) {
+    return { action: "suggest_update", currentVersion, latestVersion: info.latest, internal };
+  }
+  if (internal) {
+    return { action: "bug_report", internal: true };
+  }
+  return { action: "none" };
+}
+async function handleFailedDeploy(error) {
+  if (process.env.BULLETIN_DEPLOY_UPDATE_CHECK === "0") return;
+  const info = await fetchVersionInfo();
+  if (!info) return;
+  let verdict = assessVersion(VERSION, info, false);
+  if (verdict.action === "suggest_update" || verdict.action === "none") {
+    const internal = isInternalUser();
+    if (internal) verdict = assessVersion(VERSION, info, true);
+  }
+  switch (verdict.action) {
+    case "forced_update":
+      console.error(`
+   bulletin-deploy ${verdict.currentVersion} is no longer supported (minimum: ${verdict.minimumVersion}).`);
+      if (verdict.message) console.error(`   Reason: ${verdict.message}`);
+      console.error(`   Please update: npm install -g bulletin-deploy@latest
+`);
+      break;
+    case "suggest_update":
+      if (isInteractive()) {
+        const yes = await promptYesNo(`
+   bulletin-deploy ${verdict.currentVersion} \u2192 ${verdict.latestVersion} available. Update and retry? [Y/n] `);
+        if (yes) updateAndRetry();
+        else console.error(`   Skipped. Run: npm install -g bulletin-deploy@latest
+`);
+      } else {
+        console.error(`
+   A newer version of bulletin-deploy is available (${verdict.currentVersion} \u2192 ${verdict.latestVersion}).`);
+        console.error(`   Run: npm install -g bulletin-deploy@latest
+`);
+      }
+      break;
+    case "bug_report": {
+      const { offerBugReport } = await import("./bug-report.js");
+      await offerBugReport(error);
+      break;
+    }
+  }
+}
+
+export {
+  checkNodeVersion,
+  compareSemver,
+  isPreReleaseVersion,
+  preReleaseWarning,
+  fetchVersionInfo,
+  handlePreflightVersionCheck,
+  isInternalUser,
+  isInteractive,
+  promptYesNo,
+  classifyErrorArea,
+  assessVersion,
+  handleFailedDeploy
+};