@layr-labs/ecloud-cli 0.4.0-dev → 0.4.0-dev.1

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

@@ -0,0 +1,729 @@
+#!/usr/bin/env node
+
+// src/commands/billing/__tests__/top-up.test.ts
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// 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
+`);
+    });
+  }
+};
+
+// src/commands/billing/__tests__/top-up.test.ts
+import { input as input3 } from "@inquirer/prompts";
+vi.mock("../../../client", () => ({
+  createBillingClient: vi.fn()
+}));
+vi.mock("../../../utils/viemClients", () => ({
+  createViemClients: vi.fn()
+}));
+vi.mock("../../../telemetry", () => ({
+  withTelemetry: vi.fn((_cmd, fn) => fn())
+}));
+vi.mock("@inquirer/prompts", () => ({
+  input: vi.fn()
+}));
+vi.mock("@layr-labs/ecloud-sdk", async () => {
+  const actual = await vi.importActual("@layr-labs/ecloud-sdk");
+  return {
+    ...actual,
+    getEnvironmentConfig: vi.fn().mockReturnValue({
+      name: "sepolia",
+      build: "dev",
+      chainID: BigInt(11155111),
+      appControllerAddress: "0xa86DC1C47cb2518327fB4f9A1627F51966c83B92",
+      permissionControllerAddress: "0x44632dfBdCb6D3E21EF613B0ca8A6A0c618F5a37",
+      erc7702DelegatorAddress: "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b",
+      kmsServerURL: "http://10.128.0.57:8080",
+      userApiServerURL: "https://userapi-compute-sepolia-dev.eigencloud.xyz",
+      defaultRPCURL: "https://ethereum-sepolia-rpc.publicnode.com",
+      usdcCreditsAddress: "0xbdA3897c3A428763B59015C64AB766c288C97376"
+    })
+  };
+});
+var WALLET_ADDRESS = "0x1234567890abcdef1234567890abcdef12345678";
+var USDC_ADDRESS = "0xUSDCAddress0000000000000000000000000000";
+var USDC_CREDITS_ADDRESS = "0xbdA3897c3A428763B59015C64AB766c288C97376";
+var TX_HASH = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
+describe("ecloud billing top-up", () => {
+  let logOutput;
+  let mockBilling;
+  let mockPublicClient;
+  let mockWalletClient;
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+    logOutput = [];
+    mockBilling = {
+      address: WALLET_ADDRESS,
+      getStatus: vi.fn()
+    };
+    createBillingClient.mockResolvedValue(mockBilling);
+    mockPublicClient = {
+      readContract: vi.fn(),
+      waitForTransactionReceipt: vi.fn().mockResolvedValue({
+        transactionHash: TX_HASH
+      })
+    };
+    mockWalletClient = {
+      writeContract: vi.fn().mockResolvedValue(TX_HASH),
+      chain: { id: 11155111 },
+      account: { address: WALLET_ADDRESS }
+    };
+    createViemClients.mockReturnValue({
+      publicClient: mockPublicClient,
+      walletClient: mockWalletClient,
+      address: WALLET_ADDRESS,
+      chain: { id: 11155111 }
+    });
+    input3.mockResolvedValue("50");
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+  function setupContractReads(overrides = {}) {
+    const {
+      usdcAddress = USDC_ADDRESS,
+      minimumPurchase = BigInt(1e6),
+      // 1 USDC
+      balanceOf = BigInt(1e8),
+      // 100 USDC
+      allowance = BigInt(0)
+    } = overrides;
+    mockPublicClient.readContract.mockImplementation(({ functionName }) => {
+      switch (functionName) {
+        case "usdc":
+          return Promise.resolve(usdcAddress);
+        case "minimumPurchase":
+          return Promise.resolve(minimumPurchase);
+        case "balanceOf":
+          return Promise.resolve(balanceOf);
+        case "allowance":
+          return Promise.resolve(allowance);
+        default:
+          return Promise.reject(new Error(`Unexpected readContract: ${functionName}`));
+      }
+    });
+  }
+  function createCommand(flags = {}) {
+    const cmd = new BillingTopUp([], {});
+    cmd.parse = vi.fn().mockResolvedValue({
+      flags: {
+        product: "compute",
+        "private-key": "0xdeadbeef",
+        environment: "sepolia-dev",
+        ...flags
+      }
+    });
+    cmd.log = vi.fn((...args) => logOutput.push(args.join(" ")));
+    cmd.debug = vi.fn();
+    cmd.error = vi.fn((msg) => {
+      throw new Error(msg);
+    });
+    return cmd;
+  }
+  it("happy path: sufficient balance, approval needed, purchase succeeds", async () => {
+    setupContractReads();
+    mockBilling.getStatus.mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 10 }).mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 60 });
+    const cmd = createCommand({ amount: "50" });
+    const promise = cmd.run();
+    for (let i = 0; i < 10; i++) {
+      await vi.advanceTimersByTimeAsync(5e3);
+    }
+    await promise;
+    const fullOutput = logOutput.join("\n");
+    expect(fullOutput).toContain(WALLET_ADDRESS);
+    expect(fullOutput).toContain("$10.00");
+    expect(fullOutput).toContain("100 USDC");
+    expect(fullOutput).toContain("Approving USDC spend");
+    expect(fullOutput).toContain("Approved");
+    expect(fullOutput).toContain("Submitting credit purchase");
+    expect(fullOutput).toContain("Transaction confirmed");
+    expect(fullOutput).toContain("Credits received");
+    expect(fullOutput).toContain("$60.00");
+    expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        functionName: "approve",
+        args: [USDC_CREDITS_ADDRESS, BigInt(5e7)]
+      })
+    );
+    expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        functionName: "purchaseCreditsFor",
+        args: [BigInt(5e7), WALLET_ADDRESS]
+      })
+    );
+  });
+  it("zero USDC balance: exits with fund wallet message", async () => {
+    setupContractReads({ balanceOf: BigInt(0) });
+    mockBilling.getStatus.mockResolvedValue({ subscriptionStatus: "inactive" });
+    const cmd = createCommand({ amount: "50" });
+    await cmd.run();
+    const fullOutput = logOutput.join("\n");
+    expect(fullOutput).toContain("No USDC in wallet");
+    expect(fullOutput).toContain("Send USDC on Sepolia to");
+    expect(fullOutput).toContain(WALLET_ADDRESS);
+    expect(mockWalletClient.writeContract).not.toHaveBeenCalled();
+  });
+  it("below minimum purchase: shows error", async () => {
+    setupContractReads({ minimumPurchase: BigInt(1e7) });
+    mockBilling.getStatus.mockResolvedValue({ subscriptionStatus: "inactive" });
+    const cmd = createCommand({ amount: "5" });
+    await expect(cmd.run()).rejects.toThrow("Minimum purchase is 10 USDC");
+  });
+  it("--account flag: passes different address to purchaseCreditsFor", async () => {
+    const targetAccount = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+    setupContractReads();
+    mockBilling.getStatus.mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 10 }).mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 60 });
+    const cmd = createCommand({ amount: "50", account: targetAccount });
+    const promise = cmd.run();
+    for (let i = 0; i < 10; i++) {
+      await vi.advanceTimersByTimeAsync(5e3);
+    }
+    await promise;
+    const fullOutput = logOutput.join("\n");
+    expect(fullOutput).toContain(targetAccount);
+    expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        functionName: "purchaseCreditsFor",
+        args: [BigInt(5e7), targetAccount]
+      })
+    );
+  });
+  it("allowance already sufficient: skips approve step", async () => {
+    setupContractReads({ allowance: BigInt(1e8) });
+    mockBilling.getStatus.mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 10 }).mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 60 });
+    const cmd = createCommand({ amount: "50" });
+    const promise = cmd.run();
+    for (let i = 0; i < 10; i++) {
+      await vi.advanceTimersByTimeAsync(5e3);
+    }
+    await promise;
+    const fullOutput = logOutput.join("\n");
+    expect(fullOutput).not.toContain("Approving USDC spend");
+    expect(mockWalletClient.writeContract).toHaveBeenCalledTimes(1);
+    expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        functionName: "purchaseCreditsFor"
+      })
+    );
+  });
+  it("billing API poll timeout: shows timeout message", async () => {
+    setupContractReads();
+    mockBilling.getStatus.mockResolvedValue({
+      subscriptionStatus: "active",
+      remainingCredits: 10
+    });
+    const cmd = createCommand({ amount: "50" });
+    const promise = cmd.run();
+    await vi.advanceTimersByTimeAsync(2e5);
+    await promise;
+    const fullOutput = logOutput.join("\n");
+    expect(fullOutput).toContain("Credits haven't appeared yet");
+    expect(fullOutput).toContain("ecloud billing status");
+  });
+  it("uses --amount flag when provided (skips prompt)", async () => {
+    setupContractReads();
+    mockBilling.getStatus.mockResolvedValueOnce({ subscriptionStatus: "inactive" }).mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 100 });
+    const cmd = createCommand({ amount: "100" });
+    const promise = cmd.run();
+    for (let i = 0; i < 10; i++) {
+      await vi.advanceTimersByTimeAsync(5e3);
+    }
+    await promise;
+    expect(input3).not.toHaveBeenCalled();
+  });
+  it("does not fail if status check errors", async () => {
+    setupContractReads();
+    mockBilling.getStatus.mockRejectedValue(new Error("API unavailable"));
+    const cmd = createCommand({ amount: "50" });
+    const promise = cmd.run();
+    await vi.advanceTimersByTimeAsync(2e5);
+    await promise;
+    const fullOutput = logOutput.join("\n");
+    expect(fullOutput).toContain("Submitting credit purchase");
+    expect(fullOutput).toContain("Transaction confirmed");
+    expect(fullOutput).toContain("Credits haven't appeared yet");
+  });
+});
+//# sourceMappingURL=top-up.test.js.map