@layr-labs/ecloud-cli 0.3.4 → 0.4.0-dev.0

package/dist/commands/billing/top-up.js

@@ -0,0 +1,491 @@
+#!/usr/bin/env node
+
+// src/commands/billing/top-up.ts
+import { Command, Flags as Flags2 } from "@oclif/core";
+
+// src/client.ts
+import {
+  createComputeModule,
+  createBillingModule,
+  createBuildModule,
+  getEnvironmentConfig as getEnvironmentConfig3,
+  requirePrivateKey,
+  getPrivateKeyWithSource,
+  addHexPrefix as addHexPrefix2
+} from "@layr-labs/ecloud-sdk";
+
+// src/flags.ts
+import { Flags } from "@oclif/core";
+import { getBuildType as getBuildType2 } from "@layr-labs/ecloud-sdk";
+
+// src/utils/prompts.ts
+import { input, select, password, confirm as inquirerConfirm } from "@inquirer/prompts";
+import chalk from "chalk";
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
+import { isAddress as isAddress2 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+import {
+  getEnvironmentConfig as getEnvironmentConfig2,
+  getAvailableEnvironments,
+  isEnvironmentAvailable,
+  getAllAppsByDeveloper as getAllAppsByDeveloper2,
+  getCategoryDescriptions,
+  fetchTemplateCatalog,
+  PRIMARY_LANGUAGES,
+  validateAppName,
+  validateImageReference,
+  validateFilePath,
+  validatePrivateKeyFormat,
+  extractAppNameFromImage,
+  UserApiClient as UserApiClient2
+} from "@layr-labs/ecloud-sdk";
+
+// src/utils/appResolver.ts
+import { isAddress } from "viem";
+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";
+import * as os from "os";
+import { load as loadYaml, dump as dumpYaml } from "js-yaml";
+import { getBuildType } from "@layr-labs/ecloud-sdk";
+import * as crypto from "crypto";
+var GLOBAL_CONFIG_FILE = "config.yaml";
+var PROFILE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function getGlobalConfigDir() {
+  const configHome = process.env.XDG_CONFIG_HOME;
+  let baseDir;
+  if (configHome && path.isAbsolute(configHome)) {
+    baseDir = configHome;
+  } else {
+    baseDir = path.join(os.homedir(), ".config");
+  }
+  const buildType = getBuildType();
+  const buildSuffix = buildType === "dev" ? "-dev" : "";
+  const configDirName = `ecloud${buildSuffix}`;
+  return path.join(baseDir, configDirName);
+}
+function getGlobalConfigPath() {
+  return path.join(getGlobalConfigDir(), GLOBAL_CONFIG_FILE);
+}
+function loadGlobalConfig() {
+  const configPath = getGlobalConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return {
+      first_run: true
+    };
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const config = loadYaml(content);
+    return config || { first_run: true };
+  } catch {
+    return {
+      first_run: true
+    };
+  }
+}
+function saveGlobalConfig(config) {
+  const configPath = getGlobalConfigPath();
+  const configDir = path.dirname(configPath);
+  fs.mkdirSync(configDir, { recursive: true, mode: 493 });
+  const content = dumpYaml(config, { lineWidth: -1 });
+  fs.writeFileSync(configPath, content, { mode: 420 });
+}
+function getDefaultEnvironment() {
+  const config = loadGlobalConfig();
+  return config.default_environment;
+}
+function getGlobalTelemetryPreference() {
+  const config = loadGlobalConfig();
+  return config.telemetry_enabled;
+}
+function getOrCreateUserUUID() {
+  const config = loadGlobalConfig();
+  if (config.user_uuid) {
+    return config.user_uuid;
+  }
+  const uuid = generateUUID();
+  config.user_uuid = uuid;
+  config.first_run = false;
+  saveGlobalConfig(config);
+  return uuid;
+}
+function generateUUID() {
+  const bytes = crypto.randomBytes(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+  return hex.slice(0, 4).join("") + hex.slice(4, 6).join("") + "-" + hex.slice(6, 8).join("") + "-" + hex.slice(8, 10).join("") + "-" + hex.slice(10, 12).join("") + "-" + hex.slice(12, 16).join("");
+}
+
+// src/utils/appNames.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+import { load as loadYaml2, dump as dumpYaml2 } from "js-yaml";
+var CONFIG_DIR = path2.join(os2.homedir(), ".eigenx");
+var APPS_DIR = path2.join(CONFIG_DIR, "apps");
+
+// src/utils/prompts.ts
+async function getPrivateKeyInteractive(privateKey) {
+  if (privateKey) {
+    if (!validatePrivateKeyFormat(privateKey)) {
+      throw new Error("Invalid private key format");
+    }
+    return privateKey;
+  }
+  const { getPrivateKeyWithSource: getPrivateKeyWithSource2 } = await import("@layr-labs/ecloud-sdk");
+  const result = await getPrivateKeyWithSource2({ privateKey: void 0 });
+  if (result) {
+    return result.key;
+  }
+  const key = await password({
+    message: "Enter private key:",
+    mask: true,
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Private key is required";
+      }
+      if (!validatePrivateKeyFormat(value)) {
+        return "Invalid private key format (must be 64 hex characters, optionally prefixed with 0x)";
+      }
+      return true;
+    }
+  });
+  return key.trim();
+}
+var MAX_IMAGE_SIZE = 4 * 1024 * 1024;
+
+// src/flags.ts
+var commonFlags = {
+  environment: Flags.string({
+    required: false,
+    description: "Deployment environment to use",
+    env: "ECLOUD_ENV",
+    default: async () => getDefaultEnvironment() || (getBuildType2() === "dev" ? "sepolia-dev" : "sepolia")
+  }),
+  "private-key": Flags.string({
+    required: false,
+    description: "Private key for signing transactions",
+    env: "ECLOUD_PRIVATE_KEY"
+  }),
+  "rpc-url": Flags.string({
+    required: false,
+    description: "RPC URL to connect to blockchain",
+    env: "ECLOUD_RPC_URL"
+  }),
+  verbose: Flags.boolean({
+    required: false,
+    description: "Enable verbose logging (default: false)",
+    default: false
+  })
+};
+
+// src/client.ts
+import { createWalletClient, custom } from "viem";
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+async function createBillingClient(flags) {
+  const result = await getPrivateKeyWithSource({
+    privateKey: flags["private-key"]
+  });
+  const privateKey = await getPrivateKeyInteractive(result?.key);
+  const account = privateKeyToAccount4(addHexPrefix2(privateKey));
+  const walletClient = createWalletClient({
+    account,
+    transport: custom({
+      async request() {
+        throw new Error("RPC not available - billing uses local signing only");
+      }
+    })
+  });
+  return createBillingModule({
+    verbose: flags.verbose ?? false,
+    walletClient,
+    skipTelemetry: true
+    // CLI already has telemetry, skip SDK telemetry
+  });
+}
+
+// src/commands/billing/top-up.ts
+import {
+  getEnvironmentConfig as getEnvironmentConfig4,
+  USDCCreditsABI,
+  ERC20ABI
+} from "@layr-labs/ecloud-sdk";
+import { formatUnits } from "viem";
+import chalk2 from "chalk";
+import { input as input2 } from "@inquirer/prompts";
+
+// src/telemetry.ts
+import {
+  createTelemetryClient,
+  createAppEnvironment,
+  createMetricsContext,
+  addMetric,
+  addMetricWithDimensions,
+  emitMetrics,
+  getBuildType as getBuildType3
+} from "@layr-labs/ecloud-sdk";
+function createCLITelemetryClient() {
+  const userUUID = getOrCreateUserUUID();
+  const environment = createAppEnvironment(userUUID);
+  const telemetryEnabled = getGlobalTelemetryPreference();
+  return createTelemetryClient(environment, "ecloud-cli", {
+    telemetryEnabled: telemetryEnabled !== false
+    // Enabled by default, disabled only if explicitly set to false
+  });
+}
+async function withTelemetry(command, action) {
+  const client = createCLITelemetryClient();
+  const metrics = createMetricsContext();
+  metrics.properties["source"] = "ecloud-cli";
+  metrics.properties["command"] = command.id || command.constructor.name;
+  const environment = getDefaultEnvironment() || "sepolia";
+  metrics.properties["environment"] = environment;
+  const buildType = getBuildType3() || "prod";
+  metrics.properties["build_type"] = buildType;
+  const cliVersion = command.config.version;
+  if (cliVersion) {
+    metrics.properties["cli_version"] = cliVersion;
+  }
+  addMetric(metrics, "Count", 1);
+  let actionError;
+  let result;
+  try {
+    result = await action();
+    return result;
+  } catch (err) {
+    actionError = err instanceof Error ? err : new Error(String(err));
+    throw err;
+  } finally {
+    const resultValue = actionError ? "Failure" : "Success";
+    const dimensions = {};
+    if (actionError) {
+      dimensions["error"] = actionError.message;
+    }
+    addMetricWithDimensions(metrics, resultValue, 1, dimensions);
+    const duration = Date.now() - metrics.startTime.getTime();
+    addMetric(metrics, "DurationMilliseconds", duration);
+    try {
+      await emitMetrics(client, metrics);
+      await client.close();
+    } catch {
+    }
+  }
+}
+
+// src/commands/billing/top-up.ts
+var POLL_INTERVAL_MS = 5e3;
+var POLL_TIMEOUT_MS = 3 * 60 * 1e3;
+var BillingTopUp = class _BillingTopUp extends Command {
+  static description = "Purchase EigenCompute credits with USDC";
+  static flags = {
+    ...commonFlags,
+    amount: Flags2.string({
+      required: false,
+      description: "Amount of USDC to spend (e.g., '50')"
+    }),
+    account: Flags2.string({
+      required: false,
+      description: "Target account address for purchaseCreditsFor (defaults to your wallet)"
+    }),
+    product: Flags2.string({
+      required: false,
+      description: "Product ID",
+      default: "compute",
+      options: ["compute"],
+      env: "ECLOUD_PRODUCT_ID"
+    })
+  };
+  async run() {
+    return withTelemetry(this, async () => {
+      const { flags } = await this.parse(_BillingTopUp);
+      const billing = await createBillingClient(flags);
+      const privateKey = await getPrivateKeyInteractive(flags["private-key"]);
+      const { publicClient, walletClient, address: walletAddress } = createViemClients({
+        privateKey,
+        rpcUrl: flags["rpc-url"],
+        environment: flags.environment
+      });
+      const environmentConfig = getEnvironmentConfig4(flags.environment);
+      const usdcCreditsAddress = environmentConfig.usdcCreditsAddress;
+      if (!usdcCreditsAddress) {
+        this.error(
+          `USDCCredits contract is not configured for environment "${flags.environment}". USDC credit purchasing is only available on environments with a deployed USDCCredits contract.`
+        );
+      }
+      const targetAccount = flags.account ?? walletAddress;
+      this.log(`
+${chalk2.bold("Purchase EigenCompute credits")}`);
+      this.log(`${chalk2.gray("\u2500".repeat(45))}`);
+      this.log(`
+  ${chalk2.bold("Wallet:")}  ${walletAddress}`);
+      if (targetAccount !== walletAddress) {
+        this.log(`  ${chalk2.bold("Target:")}  ${targetAccount}`);
+      }
+      let currentCredits;
+      try {
+        const status = await billing.getStatus({
+          productId: flags.product
+        });
+        currentCredits = status.remainingCredits;
+        if (currentCredits !== void 0) {
+          this.log(`  ${chalk2.bold("Credits:")} ${chalk2.cyan(`$${currentCredits.toFixed(2)}`)}`);
+        }
+      } catch {
+        this.debug("Could not fetch current credit balance");
+      }
+      const usdcAddress = await publicClient.readContract({
+        address: usdcCreditsAddress,
+        abi: USDCCreditsABI,
+        functionName: "usdc"
+      });
+      const minimumPurchase = await publicClient.readContract({
+        address: usdcCreditsAddress,
+        abi: USDCCreditsABI,
+        functionName: "minimumPurchase"
+      });
+      const usdcBalance = await publicClient.readContract({
+        address: usdcAddress,
+        abi: ERC20ABI,
+        functionName: "balanceOf",
+        args: [walletAddress]
+      });
+      const balanceFormatted = formatUnits(usdcBalance, 6);
+      this.log(`  ${chalk2.bold("USDC:")}    ${balanceFormatted} USDC`);
+      if (usdcBalance === BigInt(0)) {
+        this.log(`
+${chalk2.yellow("  No USDC in wallet.")}`);
+        this.log(`  Send USDC on Sepolia to: ${chalk2.cyan(walletAddress)}`);
+        this.log(`  Then re-run: ${chalk2.cyan("ecloud billing top-up")}
+`);
+        return;
+      }
+      const minimumFormatted = formatUnits(minimumPurchase, 6);
+      const amountStr = flags.amount ?? await input2({
+        message: `How much USDC to spend on credits? (minimum: ${minimumFormatted})`,
+        validate: (val) => {
+          const n = parseFloat(val);
+          if (isNaN(n) || n <= 0) return "Enter a positive number";
+          const raw = BigInt(Math.round(n * 1e6));
+          if (raw < minimumPurchase)
+            return `Minimum purchase is ${minimumFormatted} USDC`;
+          if (raw > usdcBalance)
+            return `Insufficient balance. You have ${balanceFormatted} USDC`;
+          return true;
+        }
+      });
+      const amountFloat = parseFloat(amountStr);
+      const amountRaw = BigInt(Math.round(amountFloat * 1e6));
+      if (amountRaw < minimumPurchase) {
+        this.error(`Minimum purchase is ${minimumFormatted} USDC`);
+      }
+      if (amountRaw > usdcBalance) {
+        this.error(
+          `Insufficient USDC balance. You have ${balanceFormatted} USDC but requested ${amountFloat.toFixed(2)}`
+        );
+      }
+      this.log(`
+  Purchasing ${chalk2.bold(`$${amountFloat.toFixed(2)}`)} in credits...`);
+      const currentAllowance = await publicClient.readContract({
+        address: usdcAddress,
+        abi: ERC20ABI,
+        functionName: "allowance",
+        args: [walletAddress, usdcCreditsAddress]
+      });
+      if (currentAllowance < amountRaw) {
+        this.log(chalk2.gray("  Approving USDC spend..."));
+        const approveTx = await walletClient.writeContract({
+          address: usdcAddress,
+          abi: ERC20ABI,
+          functionName: "approve",
+          args: [usdcCreditsAddress, amountRaw],
+          chain: walletClient.chain,
+          account: walletClient.account
+        });
+        await publicClient.waitForTransactionReceipt({ hash: approveTx });
+        this.log(`  ${chalk2.green("\u2713")} Approved`);
+      }
+      this.log(chalk2.gray("  Submitting credit purchase..."));
+      const purchaseTx = await walletClient.writeContract({
+        address: usdcCreditsAddress,
+        abi: USDCCreditsABI,
+        functionName: "purchaseCreditsFor",
+        args: [amountRaw, targetAccount],
+        chain: walletClient.chain,
+        account: walletClient.account
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash: purchaseTx });
+      this.log(`  ${chalk2.green("\u2713")} Transaction confirmed: ${receipt.transactionHash}`);
+      this.log(chalk2.gray("\n  Waiting for credits to appear..."));
+      const startTime = Date.now();
+      while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+        try {
+          const status = await billing.getStatus({
+            productId: flags.product
+          });
+          if (status.remainingCredits !== void 0 && (currentCredits === void 0 || status.remainingCredits > currentCredits)) {
+            this.log(
+              `
+  ${chalk2.green("\u2713")} Credits received! Balance: ${chalk2.cyan(`$${status.remainingCredits.toFixed(2)}`)}`
+            );
+            this.log();
+            return;
+          }
+        } catch {
+          this.debug("Error polling for credit balance");
+        }
+      }
+      this.log(
+        `
+  ${chalk2.yellow("\u26A0")} Credits haven't appeared yet. This can take a few minutes.`
+      );
+      this.log(`  ${chalk2.gray("Check your balance:")} ecloud billing status
+`);
+    });
+  }
+};
+export {
+  BillingTopUp as default
+};
+//# sourceMappingURL=top-up.js.map