@layr-labs/ecloud-cli 0.2.0 → 0.2.1-dev

package/dist/commands/compute/app/info.js

@@ -3,7 +3,7 @@
 // src/commands/compute/app/info.ts
 import { Command, Args, Flags as Flags2 } from "@oclif/core";
 import {
-  getEnvironmentConfig as getEnvironmentConfig2,
+  getEnvironmentConfig as getEnvironmentConfig3,
   getAppLatestReleaseBlockNumbers,
   getBlockTimestamps,
   UserApiClient as UserApiClient3
@@ -19,9 +19,9 @@ import fs3 from "fs";
 import path3 from "path";
 import os3 from "os";
 import { isAddress as isAddress2 } from "viem";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 import {
-  getEnvironmentConfig,
+  getEnvironmentConfig as getEnvironmentConfig2,
   getAvailableEnvironments,
   isEnvironmentAvailable,
   getAllAppsByDeveloper as getAllAppsByDeveloper2,
@@ -38,12 +38,43 @@ import {
 
 // src/utils/appResolver.ts
 import { isAddress } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 import {
   UserApiClient,
   getAllAppsByDeveloper
 } from "@layr-labs/ecloud-sdk";
 
+// src/utils/viemClients.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  getEnvironmentConfig,
+  addHexPrefix,
+  createViemClients as sdkCreateViemClients,
+  getChainFromID
+} from "@layr-labs/ecloud-sdk";
+function createViemClients(options) {
+  const privateKey = addHexPrefix(options.privateKey);
+  const environmentConfig = getEnvironmentConfig(options.environment);
+  const rpcUrl = options.rpcUrl || environmentConfig.defaultRPCURL;
+  const chain = getChainFromID(environmentConfig.chainID);
+  const { publicClient, walletClient } = sdkCreateViemClients({
+    privateKey,
+    rpcUrl,
+    chainId: environmentConfig.chainID
+  });
+  const account = privateKeyToAccount(privateKey);
+  return {
+    publicClient,
+    walletClient,
+    chain,
+    address: account.address
+  };
+}
+
 // src/utils/globalConfig.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -188,7 +219,7 @@ function listApps(environment) {
 
 // src/utils/version.ts
 function getCliVersion() {
-  return true ? "0.2.0" : "0.0.0";
+  return true ? "0.2.1-dev" : "0.0.0";
 }
 function getClientId() {
   return `ecloud-cli/v${getCliVersion()}`;
@@ -211,7 +242,7 @@ async function getAppInfosChunked(userApiClient, appIds, addressCount) {
 }
 
 // src/utils/prompts.ts
-function addHexPrefix(value) {
+function addHexPrefix2(value) {
   if (value.startsWith("0x")) {
     return value;
   }
@@ -275,7 +306,7 @@ async function getOrPromptAppID(appIDOrOptions, environment) {
     };
   }
   if (options.appID) {
-    const normalized = typeof options.appID === "string" ? addHexPrefix(options.appID) : options.appID;
+    const normalized = typeof options.appID === "string" ? addHexPrefix2(options.appID) : options.appID;
     if (isAddress2(normalized)) {
       return normalized;
     }
@@ -291,7 +322,7 @@ async function getOrPromptAppID(appIDOrOptions, environment) {
     const apps = listApps(options.environment);
     const foundAppID = apps[options.appID];
     if (foundAppID) {
-      return addHexPrefix(foundAppID);
+      return addHexPrefix2(foundAppID);
     }
     throw new Error(
       `App name '${options.appID}' not found in environment '${options.environment}'`
@@ -302,18 +333,23 @@ async function getOrPromptAppID(appIDOrOptions, environment) {
 async function getAppIDInteractive(options) {
   const action = options.action || "view";
   const environment = options.environment || "sepolia";
-  const environmentConfig = getEnvironmentConfig(environment);
+  const environmentConfig = getEnvironmentConfig2(environment);
   if (!options.privateKey || !options.rpcUrl) {
     return getAppIDInteractiveFromRegistry(environment, action);
   }
   console.log(`
 Select an app to ${action}:
 `);
-  const privateKeyHex = addHexPrefix(options.privateKey);
-  const account = privateKeyToAccount2(privateKeyHex);
+  const privateKeyHex = addHexPrefix2(options.privateKey);
+  const account = privateKeyToAccount3(privateKeyHex);
   const developerAddr = account.address;
+  const { publicClient, walletClient } = createViemClients({
+    privateKey: options.privateKey,
+    rpcUrl: options.rpcUrl,
+    environment
+  });
   const { apps, appConfigs } = await getAllAppsByDeveloper2(
-    options.rpcUrl,
+    publicClient,
     environmentConfig,
     developerAddr
   );
@@ -326,8 +362,8 @@ Select an app to ${action}:
     try {
       const userApiClient = new UserApiClient2(
         environmentConfig,
-        options.privateKey,
-        options.rpcUrl,
+        walletClient,
+        publicClient,
         getClientId()
       );
       const appInfos = await getAppInfosChunked(userApiClient, apps);
@@ -452,14 +488,14 @@ async function getAppIDInteractiveFromRegistry(environment, action) {
         if (!value) {
           return "App ID or name cannot be empty";
         }
-        const normalized2 = addHexPrefix(value);
+        const normalized2 = addHexPrefix2(value);
         if (isAddress2(normalized2)) {
           return true;
         }
         return "Invalid app ID address";
       }
     });
-    const normalized = addHexPrefix(appIDInput);
+    const normalized = addHexPrefix2(appIDInput);
     if (isAddress2(normalized)) {
       return normalized;
     }
@@ -495,7 +531,7 @@ Select an app to ${action}:`);
         if (!value) {
           return "App ID or name cannot be empty";
         }
-        const normalized2 = addHexPrefix(value);
+        const normalized2 = addHexPrefix2(value);
         if (isAddress2(normalized2)) {
           return true;
         }
@@ -505,17 +541,17 @@ Select an app to ${action}:`);
         return "Invalid app ID or name not found";
       }
     });
-    const normalized = addHexPrefix(appIDInput);
+    const normalized = addHexPrefix2(appIDInput);
     if (isAddress2(normalized)) {
       return normalized;
     }
     const foundAppID = allApps[appIDInput];
     if (foundAppID) {
-      return addHexPrefix(foundAppID);
+      return addHexPrefix2(foundAppID);
     }
     throw new Error(`Failed to resolve app ID from input: ${appIDInput}`);
   }
-  return addHexPrefix(selected);
+  return addHexPrefix2(selected);
 }
 async function getPrivateKeyInteractive(privateKey) {
   if (privateKey) {
@@ -547,7 +583,7 @@ async function getPrivateKeyInteractive(privateKey) {
 async function getEnvironmentInteractive(environment) {
   if (environment) {
     try {
-      getEnvironmentConfig(environment);
+      getEnvironmentConfig2(environment);
       if (!isEnvironmentAvailable(environment)) {
         throw new Error(`Environment ${environment} is not available in this build`);
       }
@@ -560,7 +596,7 @@ async function getEnvironmentInteractive(environment) {
   const configDefaultEnv = getDefaultEnvironment();
   if (configDefaultEnv && availableEnvs.includes(configDefaultEnv)) {
     try {
-      getEnvironmentConfig(configDefaultEnv);
+      getEnvironmentConfig2(configDefaultEnv);
       defaultEnv = configDefaultEnv;
     } catch {
     }
@@ -748,6 +784,17 @@ function printAppDisplay(display, log, indent = "  ", options = {}) {
   }
 }
 
+// src/utils/dashboard.ts
+var DASHBOARD_URLS = {
+  "sepolia-dev": "https://compute-dashboard-sepolia-dev.vercel.app",
+  sepolia: "https://verify-sepolia.eigencloud.xyz",
+  "mainnet-alpha": "https://verify.eigencloud.xyz"
+};
+function getDashboardUrl(environment, appAddress) {
+  const baseUrl = DASHBOARD_URLS[environment] || DASHBOARD_URLS["sepolia"];
+  return `${baseUrl}/app/${appAddress}`;
+}
+
 // src/commands/compute/app/info.ts
 import chalk2 from "chalk";
 var AppInfo2 = class _AppInfo extends Command {
@@ -774,7 +821,7 @@ var AppInfo2 = class _AppInfo extends Command {
     const { args, flags } = await this.parse(_AppInfo);
     const validatedFlags = await validateCommonFlags(flags);
     const environment = validatedFlags.environment;
-    const environmentConfig = getEnvironmentConfig2(environment);
+    const environmentConfig = getEnvironmentConfig3(environment);
     const rpcUrl = validatedFlags["rpc-url"] || environmentConfig.defaultRPCURL;
     const privateKey = validatedFlags["private-key"];
     const appID = await getOrPromptAppID({
@@ -784,26 +831,31 @@ var AppInfo2 = class _AppInfo extends Command {
       rpcUrl,
       action: "view info for"
     });
-    const userApiClient = new UserApiClient3(environmentConfig, privateKey, rpcUrl, getClientId());
+    const { publicClient, walletClient } = createViemClients({
+      privateKey,
+      rpcUrl,
+      environment
+    });
+    const userApiClient = new UserApiClient3(environmentConfig, walletClient, publicClient, getClientId());
     if (flags.watch) {
-      await this.watchMode(appID, userApiClient, rpcUrl, environmentConfig, flags["address-count"]);
+      await this.watchMode(appID, userApiClient, publicClient, environmentConfig, flags["address-count"]);
     } else {
       await this.displayAppInfo(
         appID,
         userApiClient,
-        rpcUrl,
+        publicClient,
         environmentConfig,
         flags["address-count"]
       );
     }
   }
-  async displayAppInfo(appID, userApiClient, rpcUrl, environmentConfig, addressCount, clearScreen = false) {
+  async displayAppInfo(appID, userApiClient, publicClient, environmentConfig, addressCount, clearScreen = false) {
     const [appInfos, releaseBlockNumbers] = await Promise.all([
       userApiClient.getInfos([appID], addressCount).catch((err) => {
         this.warn(`Could not fetch app info: ${err}`);
         return [];
       }),
-      getAppLatestReleaseBlockNumbers(rpcUrl, environmentConfig, [appID]).catch((err) => {
+      getAppLatestReleaseBlockNumbers(publicClient, environmentConfig, [appID]).catch((err) => {
         this.warn(`Could not fetch release block numbers: ${err}`);
         return /* @__PURE__ */ new Map();
       })
@@ -815,11 +867,28 @@ var AppInfo2 = class _AppInfo extends Command {
     const releaseBlockNumber = releaseBlockNumbers.get(appID);
     let releaseTimestamp;
     if (releaseBlockNumber && releaseBlockNumber > 0) {
-      const blockTimestamps = await getBlockTimestamps(rpcUrl, environmentConfig, [
+      const blockTimestamps = await getBlockTimestamps(publicClient, [
         releaseBlockNumber
-      ]).catch(() => /* @__PURE__ */ new Map());
+      ]).catch((err) => {
+        this.debug(`Could not fetch block timestamps: ${err}`);
+        return /* @__PURE__ */ new Map();
+      });
       releaseTimestamp = blockTimestamps.get(releaseBlockNumber);
     }
+    let verifiabilityStatus;
+    try {
+      const appResponse = await userApiClient.getApp(appID);
+      const latestRelease = appResponse.releases?.[0];
+      if (latestRelease?.build?.provenanceSignature) {
+        verifiabilityStatus = chalk2.green("Verifiable \u2713");
+      } else {
+        verifiabilityStatus = chalk2.yellow(
+          "(dev image, not built verifiably, production workloads should always be verifiable)"
+        );
+      }
+    } catch (err) {
+      this.debug(`Could not determine verifiability status: ${err}`);
+    }
     if (clearScreen) {
       console.clear();
     }
@@ -836,17 +905,22 @@ var AppInfo2 = class _AppInfo extends Command {
       singleAddress: false,
       showProfile: true
     });
+    if (verifiabilityStatus) {
+      this.log(`  Build:          ${verifiabilityStatus}`);
+    }
+    const dashboardUrl = getDashboardUrl(environmentConfig.name, appID);
+    this.log(`  Dashboard:      ${chalk2.blue.underline(dashboardUrl)}`);
     console.log();
   }
-  async watchMode(appID, userApiClient, rpcUrl, environmentConfig, addressCount) {
+  async watchMode(appID, userApiClient, publicClient, environmentConfig, addressCount) {
     const REFRESH_INTERVAL_SECONDS = 5;
-    await this.displayAppInfo(appID, userApiClient, rpcUrl, environmentConfig, addressCount, true);
+    await this.displayAppInfo(appID, userApiClient, publicClient, environmentConfig, addressCount, true);
     while (true) {
       await showCountdown(REFRESH_INTERVAL_SECONDS);
       await this.displayAppInfo(
         appID,
         userApiClient,
-        rpcUrl,
+        publicClient,
         environmentConfig,
         addressCount,
         true