@tokamak-private-dapps/private-state-cli 2.4.3 → 3.0.0

package/lib/private-state-runtime-management.mjs

@@ -436,11 +436,50 @@ function readPrivateStateCliInstallManifest(cacheBaseRoot = resolveArtifactCache
   return readJsonIfExists(privateStateCliInstallManifestPath(cacheBaseRoot));
 }
 
+function privateStateCliTermsAcceptancePath(cacheBaseRoot = resolveArtifactCacheBaseRoot()) {
+  return path.join(privateStateCliArtifactRoot(cacheBaseRoot), "terms-acceptance.json");
+}
+
+function readPrivateStateCliTermsAcceptance(cacheBaseRoot = resolveArtifactCacheBaseRoot()) {
+  const installManifest = readPrivateStateCliInstallManifest(cacheBaseRoot);
+  return installManifest?.install?.termsAcceptance
+    ?? readJsonIfExists(privateStateCliTermsAcceptancePath(cacheBaseRoot))?.termsAcceptance
+    ?? null;
+}
+
+function writePrivateStateCliTermsAcceptance({
+  termsAcceptance,
+  cacheBaseRoot = resolveArtifactCacheBaseRoot(),
+}) {
+  const manifestPath = privateStateCliInstallManifestPath(cacheBaseRoot);
+  const installManifest = readJsonIfExists(manifestPath);
+  if (installManifest) {
+    installManifest.install = {
+      ...(installManifest.install ?? {}),
+      termsAcceptance,
+    };
+    writeJson(manifestPath, installManifest);
+    return {
+      path: manifestPath,
+      location: "install-manifest",
+      termsAcceptance,
+    };
+  }
+  const acceptancePath = privateStateCliTermsAcceptancePath(cacheBaseRoot);
+  writeJson(acceptancePath, { termsAcceptance });
+  return {
+    path: acceptancePath,
+    location: "terms-acceptance",
+    termsAcceptance,
+  };
+}
+
 function writePrivateStateCliInstallManifest({
   installMode = PRIVATE_STATE_INSTALL_MODES.FULL,
   dockerRequested,
   includeLocalArtifacts,
   localDeploymentBaseRoot,
+  termsAcceptance,
   deploymentArtifacts,
   selectedVersions,
   tokamakCliRuntime,
@@ -459,6 +498,7 @@ function writePrivateStateCliInstallManifest({
       mode: normalizeInstallMode(installMode),
       includeLocalArtifacts,
       localDeploymentBaseRoot,
+      termsAcceptance: termsAcceptance ?? null,
       artifactCacheRoot: deploymentArtifacts.cacheBaseRoot,
       selectedVersions,
       tokamakCliRuntime,
@@ -594,6 +634,7 @@ function buildDoctorReport({ probeGpu = false } = {}) {
       mode: installMode,
       dockerRequested: installManifest?.install?.dockerRequested ?? null,
       includeLocalArtifacts: installManifest?.install?.includeLocalArtifacts ?? null,
+      termsAcceptance: installManifest?.install?.termsAcceptance ?? null,
       selectedVersions: installManifest?.install?.selectedVersions ?? null,
       tokamakCliRuntime: installManifest?.install?.tokamakCliRuntime ?? null,
       groth16Runtime: installManifest?.install?.groth16Runtime ?? null,
@@ -773,7 +814,7 @@ async function installTokamakCliRuntimeForPrivateState({ version, docker }) {
   if (docker) {
     installArgs.push("--docker");
   }
-  run(invocation.command, installArgs, { cwd: packageInstall.packageRoot });
+  run(invocation.command, installArgs, { cwd: packageInstall.packageRoot, quiet: true });
   const doctor = runCaptured(invocation.command, [...invocation.args, "--doctor"], {
     cwd: packageInstall.packageRoot,
   });
@@ -807,7 +848,7 @@ async function installGroth16RuntimeForPrivateState({ version, docker }) {
   if (docker) {
     args.push("--docker");
   }
-  run(process.execPath, args, { cwd: packageRoot });
+  run(process.execPath, args, { cwd: packageRoot, quiet: true });
   const compatibleBackendVersion = readGroth16PackageCompatibleBackendVersion(packageRoot);
   const crsInstall = await installGroth16CrsForPrivateStateVersion(compatibleBackendVersion);
   const runtime = inspectGroth16Runtime({ packageRoot });
@@ -940,7 +981,7 @@ function installManagedNpmPackage({ packageName, version, cacheBaseRoot = resolv
     "--no-audit",
     "--fund=false",
     `${normalizedPackageName}@${normalizedVersion}`,
-  ]);
+  ], { quiet: true });
   const packageRoot = path.join(installPrefix, "node_modules", ...normalizedPackageName.split("/"));
   const packageJsonPath = path.join(packageRoot, "package.json");
   const packageJson = readJson(packageJsonPath);
@@ -1326,7 +1367,8 @@ async function installPrivateStateCliArtifacts({
     ?? DEFAULT_PUBLIC_ARTIFACT_INDEX_FILE_ID,
   cacheBaseRoot,
   localDeploymentBaseRoot,
-  localChainIds = [31337],
+  chainIds = null,
+  localChainIds = null,
   groth16CrsVersion,
 } = {}) {
   const normalizedDappName = requireNonEmptyString(dappName, "dappName");
@@ -1335,15 +1377,21 @@ async function installPrivateStateCliArtifacts({
   const normalizedLocalDeploymentBaseRoot = localDeploymentBaseRoot
     ? path.resolve(localDeploymentBaseRoot)
     : null;
+  const selectedChainIds = chainIds === null
+    ? null
+    : new Set(chainIds.map((chainId) => String(requireChainId(chainId))));
   const index = await fetchPublicArtifactIndex(indexFileId);
-  const installed = [];
+  const installedByChainId = new Map();
 
   for (const chainId of Object.keys(index.chains).sort(compareChainIds)) {
+    if (selectedChainIds !== null && !selectedChainIds.has(String(requireChainId(chainId)))) {
+      continue;
+    }
     const chain = index.chains[chainId];
     if (!chain?.bridge?.timestamp || !chain?.bridge?.files || !chain.dapps?.[normalizedDappName]) {
       continue;
     }
-    installed.push(await materializePrivateStateCliDeployment({
+    const installed = await materializePrivateStateCliDeployment({
       index,
       chainId,
       dappName: normalizedDappName,
@@ -1351,22 +1399,34 @@ async function installPrivateStateCliArtifacts({
       cacheBaseRoot: normalizedCacheBaseRoot,
       source: "drive",
       groth16CrsVersion,
-    }));
+    });
+    installedByChainId.set(String(installed.chainId), installed);
   }
 
   if (normalizedLocalDeploymentBaseRoot) {
-    for (const chainId of localChainIds) {
-      installed.push(await materializeLocalPrivateStateCliDeployment({
+    const discoveredLocalChainIds = (localChainIds ?? discoverLocalPrivateStateDeploymentChainIds({
+      localDeploymentBaseRoot: normalizedLocalDeploymentBaseRoot,
+      dappName: normalizedDappName,
+    })).filter((chainId) => selectedChainIds === null || selectedChainIds.has(String(requireChainId(chainId))));
+    if (discoveredLocalChainIds.length === 0) {
+      throw new Error(
+        `No local ${normalizedDappName} deployment artifacts found under ${normalizedLocalDeploymentBaseRoot}.`,
+      );
+    }
+    for (const chainId of discoveredLocalChainIds) {
+      const installed = await materializeLocalPrivateStateCliDeployment({
         chainId,
         dappName: normalizedDappName,
         installMode: normalizedInstallMode,
         cacheBaseRoot: normalizedCacheBaseRoot,
         localDeploymentBaseRoot: normalizedLocalDeploymentBaseRoot,
         groth16CrsVersion,
-      }));
+      });
+      installedByChainId.set(String(installed.chainId), installed);
     }
   }
 
+  const installed = [...installedByChainId.values()].sort((left, right) => compareChainIds(left.chainId, right.chainId));
   if (installed.length === 0) {
     throw new Error(`No installable artifacts found for ${normalizedDappName}.`);
   }
@@ -1378,6 +1438,23 @@ async function installPrivateStateCliArtifacts({
   };
 }
 
+function discoverLocalPrivateStateDeploymentChainIds({ localDeploymentBaseRoot, dappName }) {
+  const deploymentRoot = path.join(localDeploymentBaseRoot, "deployment");
+  if (!fs.existsSync(deploymentRoot)) {
+    return [];
+  }
+  return fs.readdirSync(deploymentRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => /^chain-id-(\d+)$/u.exec(entry.name)?.[1] ?? null)
+    .filter((chainId) => chainId !== null)
+    .filter((chainId) => {
+      const bridgeRoot = path.join(deploymentRoot, `chain-id-${chainId}`, "bridge");
+      const dappRoot = path.join(deploymentRoot, `chain-id-${chainId}`, "dapps", dappName);
+      return fs.existsSync(bridgeRoot) && fs.existsSync(dappRoot);
+    })
+    .sort(compareChainIds);
+}
+
 async function materializePrivateStateCliDeployment({
   index,
   chainId,
@@ -1559,7 +1636,9 @@ export {
   installTokamakCliRuntimeForPrivateState,
   installGroth16RuntimeForPrivateState,
   installPrivateStateCliArtifacts,
+  readPrivateStateCliTermsAcceptance,
   writePrivateStateCliInstallManifest,
+  writePrivateStateCliTermsAcceptance,
   parseJsonReport,
   resolveArtifactCacheBaseRoot,
   privateStateCliArtifactPaths,
@@ -1573,4 +1652,5 @@ export {
   readTokamakCliPackageReport,
   requireActiveTokamakCliRuntimeRoot,
   resolveTokamakCliResourceDirForRuntimeRoot,
+  resolveTokamakCliCacheRoot,
 };

package/lib/private-state-terms.mjs

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+export const PRIVATE_STATE_TERMS_VERSION = "2026-06-12";
+export const PRIVATE_STATE_TERMS_HASH_ALGORITHM = "sha256";
+export const PRIVATE_STATE_TERMS_PACKAGE_PATH = "assets/service-terms.md";
+export const PRIVATE_STATE_TERMS_PUBLIC_PATH = "docs/dapps/private-state/terms.md";
+
+const privateStateCliPackageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const privateStateTermsAssetPath = path.join(privateStateCliPackageRoot, PRIVATE_STATE_TERMS_PACKAGE_PATH);
+
+export function readPrivateStateTermsText() {
+  return fs.readFileSync(privateStateTermsAssetPath, "utf8");
+}
+
+export function computePrivateStateTermsHash(termsText = readPrivateStateTermsText()) {
+  return `${PRIVATE_STATE_TERMS_HASH_ALGORITHM}:${createHash(PRIVATE_STATE_TERMS_HASH_ALGORITHM)
+    .update(termsText, "utf8")
+    .digest("hex")}`;
+}
+
+export function readPrivateStateTermsMetadata() {
+  const termsText = readPrivateStateTermsText();
+  return {
+    termsVersion: PRIVATE_STATE_TERMS_VERSION,
+    termsHash: computePrivateStateTermsHash(termsText),
+    termsHashAlgorithm: PRIVATE_STATE_TERMS_HASH_ALGORITHM,
+    termsPackagePath: PRIVATE_STATE_TERMS_PACKAGE_PATH,
+    termsPublicPath: PRIVATE_STATE_TERMS_PUBLIC_PATH,
+    termsHashInput: "exact UTF-8 bytes of the packaged Service Terms Markdown",
+    termsContentBytes: Buffer.byteLength(termsText, "utf8"),
+  };
+}