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

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

@@ -12,9 +12,7 @@ import {
   createBillingModule,
   createBuildModule,
   getEnvironmentConfig as getEnvironmentConfig3,
-  requirePrivateKey,
-  getPrivateKeyWithSource,
-  addHexPrefix as addHexPrefix2
+  requirePrivateKey
 } from "@layr-labs/ecloud-sdk";
 
 // src/flags.ts
@@ -169,6 +167,7 @@ var CONFIG_DIR = path2.join(os2.homedir(), ".eigenx");
 var APPS_DIR = path2.join(CONFIG_DIR, "apps");
 
 // src/utils/prompts.ts
+import { execSync } from "child_process";
 async function getPrivateKeyInteractive(privateKey) {
   if (privateKey) {
     if (!validatePrivateKeyFormat(privateKey)) {
@@ -176,8 +175,8 @@ async function getPrivateKeyInteractive(privateKey) {
     }
     return privateKey;
   }
-  const { getPrivateKeyWithSource: getPrivateKeyWithSource2 } = await import("@layr-labs/ecloud-sdk");
-  const result = await getPrivateKeyWithSource2({ privateKey: void 0 });
+  const { getPrivateKeyWithSource } = await import("@layr-labs/ecloud-sdk");
+  const result = await getPrivateKeyWithSource({ privateKey: void 0 });
   if (result) {
     return result.key;
   }
@@ -196,6 +195,50 @@ async function getPrivateKeyInteractive(privateKey) {
   });
   return key.trim();
 }
+async function getEnvironmentInteractive(environment) {
+  if (environment) {
+    try {
+      getEnvironmentConfig2(environment);
+      if (!isEnvironmentAvailable(environment)) {
+        throw new Error(`Environment ${environment} is not available in this build`);
+      }
+      return environment;
+    } catch {
+    }
+  }
+  const availableEnvs = getAvailableEnvironments();
+  let defaultEnv;
+  const configDefaultEnv = getDefaultEnvironment();
+  if (configDefaultEnv && availableEnvs.includes(configDefaultEnv)) {
+    try {
+      getEnvironmentConfig2(configDefaultEnv);
+      defaultEnv = configDefaultEnv;
+    } catch {
+    }
+  }
+  const choices = [];
+  if (availableEnvs.includes("sepolia")) {
+    choices.push({ name: "sepolia - Ethereum Sepolia testnet", value: "sepolia" });
+  }
+  if (availableEnvs.includes("sepolia-dev")) {
+    choices.push({ name: "sepolia-dev - Ethereum Sepolia testnet (dev)", value: "sepolia-dev" });
+  }
+  if (availableEnvs.includes("mainnet-alpha")) {
+    choices.push({
+      name: "mainnet-alpha - Ethereum mainnet (\u26A0\uFE0F  uses real funds)",
+      value: "mainnet-alpha"
+    });
+  }
+  if (choices.length === 0) {
+    throw new Error("No environments available in this build");
+  }
+  const env = await select({
+    message: "Select environment:",
+    choices,
+    default: defaultEnv
+  });
+  return env;
+}
 var MAX_IMAGE_SIZE = 4 * 1024 * 1024;
 
 // src/flags.ts
@@ -222,38 +265,41 @@ var commonFlags = {
     default: false
   })
 };
+async function validateCommonFlags(flags, options) {
+  flags["environment"] = await getEnvironmentInteractive(flags["environment"]);
+  if (options?.requirePrivateKey !== false) {
+    flags["private-key"] = await getPrivateKeyInteractive(flags["private-key"]);
+  }
+  return flags;
+}
 
 // src/client.ts
-import { createWalletClient, custom } from "viem";
-import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
 async function createBillingClient(flags) {
-  const result = await getPrivateKeyWithSource({
+  flags = await validateCommonFlags(flags);
+  const environment = flags.environment;
+  const environmentConfig = getEnvironmentConfig3(environment);
+  const rpcUrl = flags["rpc-url"] || environmentConfig.billingRPCURL || environmentConfig.defaultRPCURL;
+  const { key: privateKey, source } = await requirePrivateKey({
     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");
-      }
-    })
+  if (flags.verbose) {
+    console.log(`Using private key from: ${source}`);
+  }
+  const { walletClient, publicClient } = createViemClients({
+    privateKey,
+    rpcUrl,
+    environment
   });
   return createBillingModule({
-    verbose: flags.verbose ?? false,
+    verbose: flags.verbose,
     walletClient,
+    publicClient,
+    environment,
     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";
@@ -343,19 +389,7 @@ var BillingTopUp = class _BillingTopUp extends Command {
     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 walletAddress = billing.address;
       const targetAccount = flags.account ?? walletAddress;
       this.log(`
 ${chalk2.bold("Purchase EigenCompute credits")}`);
@@ -365,34 +399,22 @@ ${chalk2.bold("Purchase EigenCompute credits")}`);
       if (targetAccount !== walletAddress) {
         this.log(`  ${chalk2.bold("Target:")}  ${targetAccount}`);
       }
-      let currentCredits;
+      let baselineTotal;
       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)}`)}`);
+        const remaining = status.remainingCredits ?? 0;
+        const applied = status.creditsApplied ?? 0;
+        baselineTotal = remaining + applied;
+        if (status.remainingCredits !== void 0) {
+          this.log(`  ${chalk2.bold("Credits:")} ${chalk2.cyan(`$${status.remainingCredits.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 onChainState = await billing.getTopUpInfo();
+      const { usdcBalance, minimumPurchase } = onChainState;
       const balanceFormatted = formatUnits(usdcBalance, 6);
       this.log(`  ${chalk2.bold("USDC:")}    ${balanceFormatted} USDC`);
       if (usdcBalance === BigInt(0)) {
@@ -429,36 +451,11 @@ ${chalk2.yellow("  No USDC in wallet.")}`);
       }
       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 { txHash } = await billing.topUp({
+        amount: amountRaw,
+        account: targetAccount
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: purchaseTx });
-      this.log(`  ${chalk2.green("\u2713")} Transaction confirmed: ${receipt.transactionHash}`);
+      this.log(`  ${chalk2.green("\u2713")} Transaction confirmed: ${txHash}`);
       this.log(chalk2.gray("\n  Waiting for credits to appear..."));
       const startTime = Date.now();
       while (Date.now() - startTime < POLL_TIMEOUT_MS) {
@@ -467,11 +464,25 @@ ${chalk2.yellow("  No USDC in wallet.")}`);
           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)}`)}`
-            );
+          const remaining = status.remainingCredits ?? 0;
+          const applied = status.creditsApplied ?? 0;
+          const currentTotal = remaining + applied;
+          this.debug(`Poll: remaining=${remaining}, applied=${applied}, total=${currentTotal}, baseline=${baselineTotal}`);
+          if (baselineTotal === void 0 || currentTotal > baselineTotal) {
+            const creditsAdded = baselineTotal !== void 0 ? currentTotal - baselineTotal : void 0;
+            const isMatched = creditsAdded !== void 0 && Math.abs(creditsAdded - amountFloat * 2) < 0.01;
+            const appliedFromTopUp = creditsAdded !== void 0 ? creditsAdded - remaining : 0;
+            this.log(`
+  ${chalk2.green("\u2713")} Credits received: ${chalk2.cyan(`$${(creditsAdded ?? amountFloat).toFixed(2)}`)}`);
+            if (isMatched) {
+              this.log(`  ${chalk2.green("\u2713")} Includes $${amountFloat.toFixed(2)} match bonus!`);
+            }
+            if (remaining > 0) {
+              this.log(`  Remaining balance: ${chalk2.cyan(`$${remaining.toFixed(2)}`)}`);
+            }
+            if (appliedFromTopUp > 0) {
+              this.log(`  ${chalk2.gray(`$${appliedFromTopUp.toFixed(2)} applied to current bill`)}`);
+            }
             this.log();
             return;
           }
@@ -494,95 +505,47 @@ 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()
+      getStatus: vi.fn(),
+      getTopUpInfo: vi.fn(),
+      topUp: 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 = {}) {
+  function setupOnChainState(overrides = {}) {
     const {
-      usdcAddress = USDC_ADDRESS,
+      usdcAddress = "0xUSDCAddress0000000000000000000000000000",
       minimumPurchase = BigInt(1e6),
       // 1 USDC
-      balanceOf = BigInt(1e8),
+      usdcBalance = BigInt(1e8),
       // 100 USDC
-      allowance = BigInt(0)
+      currentAllowance = 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}`));
-      }
+    mockBilling.getTopUpInfo.mockResolvedValue({
+      usdcAddress,
+      minimumPurchase,
+      usdcBalance,
+      currentAllowance
     });
   }
   function createCommand(flags = {}) {
@@ -602,8 +565,9 @@ describe("ecloud billing top-up", () => {
     });
     return cmd;
   }
-  it("happy path: sufficient balance, approval needed, purchase succeeds", async () => {
-    setupContractReads();
+  it("happy path: sufficient balance, purchase succeeds", async () => {
+    setupOnChainState();
+    mockBilling.topUp.mockResolvedValue({ txHash: TX_HASH, walletAddress: WALLET_ADDRESS });
     mockBilling.getStatus.mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 10 }).mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 60 });
     const cmd = createCommand({ amount: "50" });
     const promise = cmd.run();
@@ -615,27 +579,17 @@ describe("ecloud billing top-up", () => {
     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("Purchasing");
     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]
-      })
-    );
+    expect(mockBilling.topUp).toHaveBeenCalledWith({
+      amount: BigInt(5e7),
+      account: WALLET_ADDRESS
+    });
   });
   it("zero USDC balance: exits with fund wallet message", async () => {
-    setupContractReads({ balanceOf: BigInt(0) });
+    setupOnChainState({ usdcBalance: BigInt(0) });
     mockBilling.getStatus.mockResolvedValue({ subscriptionStatus: "inactive" });
     const cmd = createCommand({ amount: "50" });
     await cmd.run();
@@ -643,17 +597,18 @@ describe("ecloud billing top-up", () => {
     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();
+    expect(mockBilling.topUp).not.toHaveBeenCalled();
   });
   it("below minimum purchase: shows error", async () => {
-    setupContractReads({ minimumPurchase: BigInt(1e7) });
+    setupOnChainState({ 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 () => {
+  it("--account flag: passes different address to topUp", async () => {
     const targetAccount = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-    setupContractReads();
+    setupOnChainState();
+    mockBilling.topUp.mockResolvedValue({ txHash: TX_HASH, walletAddress: WALLET_ADDRESS });
     mockBilling.getStatus.mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 10 }).mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 60 });
     const cmd = createCommand({ amount: "50", account: targetAccount });
     const promise = cmd.run();
@@ -663,33 +618,14 @@ describe("ecloud billing top-up", () => {
     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"
-      })
-    );
+    expect(mockBilling.topUp).toHaveBeenCalledWith({
+      amount: BigInt(5e7),
+      account: targetAccount
+    });
   });
   it("billing API poll timeout: shows timeout message", async () => {
-    setupContractReads();
+    setupOnChainState();
+    mockBilling.topUp.mockResolvedValue({ txHash: TX_HASH, walletAddress: WALLET_ADDRESS });
     mockBilling.getStatus.mockResolvedValue({
       subscriptionStatus: "active",
       remainingCredits: 10
@@ -703,7 +639,8 @@ describe("ecloud billing top-up", () => {
     expect(fullOutput).toContain("ecloud billing status");
   });
   it("uses --amount flag when provided (skips prompt)", async () => {
-    setupContractReads();
+    setupOnChainState();
+    mockBilling.topUp.mockResolvedValue({ txHash: TX_HASH, walletAddress: WALLET_ADDRESS });
     mockBilling.getStatus.mockResolvedValueOnce({ subscriptionStatus: "inactive" }).mockResolvedValueOnce({ subscriptionStatus: "active", remainingCredits: 100 });
     const cmd = createCommand({ amount: "100" });
     const promise = cmd.run();
@@ -714,14 +651,15 @@ describe("ecloud billing top-up", () => {
     expect(input3).not.toHaveBeenCalled();
   });
   it("does not fail if status check errors", async () => {
-    setupContractReads();
+    setupOnChainState();
+    mockBilling.topUp.mockResolvedValue({ txHash: TX_HASH, walletAddress: WALLET_ADDRESS });
     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("Purchasing");
     expect(fullOutput).toContain("Transaction confirmed");
     expect(fullOutput).toContain("Credits haven't appeared yet");
   });