@layr-labs/ecloud-sdk 0.1.0-rc.1 → 0.1.0

package/README.md

@@ -22,6 +22,8 @@ No SLA - Mainnet Alpha does not have SLAs around support, and uptime of infrastr
 
 
 ## Quick Start
+> [!NOTE]
+> Migrating from `eigenx`? Head over to [Migration guide](./MIGRATION.md) first
 ### Installation
 
 ```bash
@@ -312,7 +314,7 @@ const client = createECloudClient({
 });
 
 // Deploy an application
-const result = await client.app.deploy({
+const result = await client.compute.app.deploy({
   image: "myapp:latest",
 });
 
@@ -320,13 +322,13 @@ console.log(`Deployed app ID: ${result.appId}`);
 console.log(`Transaction hash: ${result.tx}`);
 
 // Start an application
-await client.app.start(result.appId);
+await client.compute.app.start(result.appId);
 
 // Stop an application
-await client.app.stop(result.appId);
+await client.compute.app.stop(result.appId);
 
 // Terminate an application
-await client.app.terminate(result.appId);
+await client.compute.app.terminate(result.appId);
 ```
 
 ## Environments

package/VERSION

@@ -1,2 +1,2 @@
-version=0.1.0-rc.1
-commit=bd1a94f02bdaebb6621925b9137be57d7240075c
+version=0.1.0
+commit=f751ea0fecc2e77d93bc962aeb11aa2497b74b73

package/dist/billing.cjs

@@ -0,0 +1,536 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/billing.ts
+var billing_exports = {};
+__export(billing_exports, {
+  createBillingModule: () => createBillingModule
+});
+module.exports = __toCommonJS(billing_exports);
+
+// src/client/common/utils/billingapi.ts
+var import_axios = __toESM(require("axios"), 1);
+var import_accounts = require("viem/accounts");
+
+// src/client/common/utils/auth.ts
+var import_viem = require("viem");
+var APP_CONTROLLER_ABI = (0, import_viem.parseAbi)([
+  "function calculateApiPermissionDigestHash(bytes4 permission, uint256 expiry) view returns (bytes32)"
+]);
+async function calculateBillingAuthSignature(options) {
+  const { account, product, expiry } = options;
+  const signature = await account.signTypedData({
+    domain: {
+      name: "EigenCloud Billing API",
+      version: "1"
+    },
+    types: {
+      BillingAuth: [
+        { name: "product", type: "string" },
+        { name: "expiry", type: "uint256" }
+      ]
+    },
+    primaryType: "BillingAuth",
+    message: {
+      product,
+      expiry
+    }
+  });
+  return { signature, expiry };
+}
+
+// src/client/common/utils/billingapi.ts
+var BillingApiClient = class {
+  constructor(config, privateKey) {
+    this.account = (0, import_accounts.privateKeyToAccount)(privateKey);
+    this.config = config;
+  }
+  async createSubscription(productId = "compute") {
+    const endpoint = `${this.config.billingApiServerURL}/products/${productId}/subscription`;
+    const resp = await this.makeAuthenticatedRequest(endpoint, "POST", productId);
+    return resp.json();
+  }
+  async getSubscription(productId = "compute") {
+    const endpoint = `${this.config.billingApiServerURL}/products/${productId}/subscription`;
+    const resp = await this.makeAuthenticatedRequest(endpoint, "GET", productId);
+    return resp.json();
+  }
+  async cancelSubscription(productId = "compute") {
+    const endpoint = `${this.config.billingApiServerURL}/products/${productId}/subscription`;
+    await this.makeAuthenticatedRequest(endpoint, "DELETE", productId);
+  }
+  /**
+   * Make an authenticated request to the billing API
+   */
+  async makeAuthenticatedRequest(url, method, productId) {
+    const expiry = BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
+    const { signature } = await calculateBillingAuthSignature({
+      account: this.account,
+      product: productId,
+      expiry
+    });
+    const headers = {
+      Authorization: `Bearer ${signature}`,
+      "X-Account": this.account.address,
+      "X-Expiry": expiry.toString()
+    };
+    try {
+      const response = await (0, import_axios.default)({
+        method,
+        url,
+        headers,
+        timeout: 3e4,
+        maxRedirects: 0,
+        validateStatus: () => true
+        // Don't throw on any status
+      });
+      const status = response.status;
+      const statusText = status >= 200 && status < 300 ? "OK" : "Error";
+      if (status < 200 || status >= 300) {
+        const body = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+        throw new Error(`BillingAPI request failed: ${status} ${statusText} - ${body}`);
+      }
+      return {
+        json: async () => response.data,
+        text: async () => typeof response.data === "string" ? response.data : JSON.stringify(response.data)
+      };
+    } catch (error) {
+      if (error.message?.includes("fetch failed") || error.message?.includes("ECONNREFUSED") || error.message?.includes("ENOTFOUND") || error.cause) {
+        const cause = error.cause?.message || error.cause || error.message;
+        throw new Error(
+          `Failed to connect to BillingAPI at ${url}: ${cause}
+Please check:
+1. Your internet connection
+2. The API server is accessible: ${this.config.billingApiServerURL}
+3. Firewall/proxy settings`
+        );
+      }
+      throw error;
+    }
+  }
+};
+
+// src/client/common/config/environment.ts
+var SEPOLIA_CHAIN_ID = 11155111;
+var MAINNET_CHAIN_ID = 1;
+var CommonAddresses = {
+  ERC7702Delegator: "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b"
+};
+var ChainAddresses = {
+  [MAINNET_CHAIN_ID]: {
+    PermissionController: "0x25E5F8B1E7aDf44518d35D5B2271f114e081f0E5"
+  },
+  [SEPOLIA_CHAIN_ID]: {
+    PermissionController: "0x44632dfBdCb6D3E21EF613B0ca8A6A0c618F5a37"
+  }
+};
+var BILLING_ENVIRONMENTS = {
+  dev: {
+    billingApiServerURL: "https://billingapi-dev.eigencloud.xyz"
+  },
+  prod: {
+    billingApiServerURL: "https://billingapi.eigencloud.xyz"
+  }
+};
+var ENVIRONMENTS = {
+  "sepolia-dev": {
+    name: "sepolia",
+    build: "dev",
+    appControllerAddress: "0xa86DC1C47cb2518327fB4f9A1627F51966c83B92",
+    permissionControllerAddress: ChainAddresses[SEPOLIA_CHAIN_ID].PermissionController,
+    erc7702DelegatorAddress: CommonAddresses.ERC7702Delegator,
+    kmsServerURL: "http://10.128.0.57:8080",
+    userApiServerURL: "https://userapi-compute-sepolia-dev.eigencloud.xyz",
+    defaultRPCURL: "https://ethereum-sepolia-rpc.publicnode.com"
+  },
+  sepolia: {
+    name: "sepolia",
+    build: "prod",
+    appControllerAddress: "0x0dd810a6ffba6a9820a10d97b659f07d8d23d4E2",
+    permissionControllerAddress: ChainAddresses[SEPOLIA_CHAIN_ID].PermissionController,
+    erc7702DelegatorAddress: CommonAddresses.ERC7702Delegator,
+    kmsServerURL: "http://10.128.15.203:8080",
+    userApiServerURL: "https://userapi-compute-sepolia-prod.eigencloud.xyz",
+    defaultRPCURL: "https://ethereum-sepolia-rpc.publicnode.com"
+  },
+  "mainnet-alpha": {
+    name: "mainnet-alpha",
+    build: "prod",
+    appControllerAddress: "0xc38d35Fc995e75342A21CBd6D770305b142Fbe67",
+    permissionControllerAddress: ChainAddresses[MAINNET_CHAIN_ID].PermissionController,
+    erc7702DelegatorAddress: CommonAddresses.ERC7702Delegator,
+    kmsServerURL: "http://10.128.0.2:8080",
+    userApiServerURL: "https://userapi-compute.eigencloud.xyz",
+    defaultRPCURL: "https://ethereum-rpc.publicnode.com"
+  }
+};
+var CHAIN_ID_TO_ENVIRONMENT = {
+  [SEPOLIA_CHAIN_ID.toString()]: "sepolia",
+  [MAINNET_CHAIN_ID.toString()]: "mainnet-alpha"
+};
+function getBillingEnvironmentConfig(build) {
+  const config = BILLING_ENVIRONMENTS[build];
+  if (!config) {
+    throw new Error(`Unknown billing environment: ${build}`);
+  }
+  return config;
+}
+function getBuildType() {
+  const buildTimeType = true ? "prod"?.toLowerCase() : void 0;
+  const runtimeType = process.env.BUILD_TYPE?.toLowerCase();
+  const buildType = buildTimeType || runtimeType;
+  if (buildType === "dev") {
+    return "dev";
+  }
+  return "prod";
+}
+
+// src/client/common/utils/logger.ts
+var getLogger = (verbose) => ({
+  info: (...args) => console.info(...args),
+  warn: (...args) => console.warn(...args),
+  error: (...args) => console.error(...args),
+  debug: (...args) => verbose && console.debug(...args)
+});
+
+// src/client/common/utils/userapi.ts
+var import_axios2 = __toESM(require("axios"), 1);
+var import_form_data = __toESM(require("form-data"), 1);
+var import_viem3 = require("viem");
+var import_accounts2 = require("viem/accounts");
+
+// src/client/common/utils/helpers.ts
+var import_viem2 = require("viem");
+var import_chains2 = require("viem/chains");
+
+// src/client/common/constants.ts
+var import_chains = require("viem/chains");
+
+// src/client/common/utils/helpers.ts
+function addHexPrefix(value) {
+  return value.startsWith("0x") ? value : `0x${value}`;
+}
+
+// src/client/common/utils/billing.ts
+function isSubscriptionActive(status) {
+  return status === "active" || status === "trialing";
+}
+
+// src/client/common/telemetry/noop.ts
+var NoopClient = class {
+  /**
+   * AddMetric implements the TelemetryClient interface
+   */
+  async addMetric(_metric) {
+  }
+  /**
+   * Close implements the TelemetryClient interface
+   */
+  async close() {
+  }
+};
+function isNoopClient(client) {
+  return client instanceof NoopClient;
+}
+
+// src/client/common/telemetry/posthog.ts
+var import_posthog_node = require("posthog-node");
+var PostHogClient = class {
+  constructor(environment, namespace, apiKey, endpoint) {
+    this.namespace = namespace;
+    this.appEnvironment = environment;
+    const host = endpoint || "https://us.i.posthog.com";
+    this.client = new import_posthog_node.PostHog(apiKey, {
+      host,
+      flushAt: 1,
+      // Flush immediately for CLI/SDK usage
+      flushInterval: 0
+      // Disable interval flushing
+    });
+    this.client.identify({
+      distinctId: environment.userUUID,
+      properties: {
+        os: environment.os,
+        arch: environment.arch,
+        ...environment.cliVersion ? { cliVersion: environment.cliVersion } : {}
+      }
+    });
+  }
+  /**
+   * AddMetric implements the TelemetryClient interface
+   */
+  async addMetric(metric) {
+    try {
+      const props = {
+        name: metric.name,
+        value: metric.value
+      };
+      for (const [k, v] of Object.entries(metric.dimensions)) {
+        props[k] = v;
+      }
+      this.client.capture({
+        distinctId: this.appEnvironment.userUUID,
+        event: this.namespace,
+        properties: props
+      });
+    } catch {
+    }
+  }
+  /**
+   * Close implements the TelemetryClient interface
+   */
+  async close() {
+    try {
+      this.client.shutdown();
+    } catch {
+    }
+  }
+};
+function getPostHogAPIKey() {
+  if (process.env.ECLOUD_POSTHOG_KEY) {
+    return process.env.ECLOUD_POSTHOG_KEY;
+  }
+  return true ? "phc_BiKfywNft5iBI8N7MxmuVCkb4GGZj4mDFXYPmOPUAI8" : void 0;
+}
+function getPostHogEndpoint() {
+  return process.env.ECLOUD_POSTHOG_ENDPOINT || "https://us.i.posthog.com";
+}
+
+// src/client/common/telemetry/index.ts
+var os = __toESM(require("os"), 1);
+
+// src/client/common/telemetry/metricsContext.ts
+function createMetricsContext() {
+  return {
+    startTime: /* @__PURE__ */ new Date(),
+    metrics: [],
+    properties: {}
+  };
+}
+function addMetric(context, name, value) {
+  addMetricWithDimensions(context, name, value, {});
+}
+function addMetricWithDimensions(context, name, value, dimensions) {
+  context.metrics.push({
+    name,
+    value,
+    dimensions
+  });
+}
+
+// src/client/common/telemetry/index.ts
+function createTelemetryClient(environment, namespace, options) {
+  const telemetryEnabled = options?.telemetryEnabled === true;
+  if (!telemetryEnabled) {
+    return new NoopClient();
+  }
+  const resolvedApiKey = options?.apiKey || getPostHogAPIKey();
+  if (!resolvedApiKey) {
+    return new NoopClient();
+  }
+  const endpoint = options?.endpoint || getPostHogEndpoint();
+  try {
+    return new PostHogClient(environment, namespace, resolvedApiKey, endpoint);
+  } catch {
+    return new NoopClient();
+  }
+}
+function createAppEnvironment(userUUID, cliVersion, osOverride, archOverride) {
+  return {
+    userUUID,
+    cliVersion,
+    os: osOverride || os.platform(),
+    arch: archOverride || os.arch()
+  };
+}
+async function emitMetrics(client, context) {
+  if (isNoopClient(client)) {
+    return;
+  }
+  for (const metric of context.metrics) {
+    const dimensions = {
+      ...metric.dimensions,
+      ...context.properties
+    };
+    const metricWithProperties = {
+      ...metric,
+      dimensions
+    };
+    try {
+      await client.addMetric(metricWithProperties);
+    } catch {
+    }
+  }
+}
+
+// src/client/common/telemetry/wrapper.ts
+var import_crypto = require("crypto");
+function generateRandomUUID() {
+  return (0, import_crypto.randomUUID)();
+}
+async function withSDKTelemetry(options, action) {
+  if (options.skipTelemetry) {
+    return action();
+  }
+  const userUUID = options.userUUID || generateRandomUUID();
+  const environment = createAppEnvironment(userUUID);
+  const client = createTelemetryClient(environment, "ecloud-sdk", {
+    telemetryEnabled: options.telemetryEnabled,
+    apiKey: options.apiKey,
+    endpoint: options.endpoint
+  });
+  const metrics = createMetricsContext();
+  metrics.properties["source"] = "ecloud-sdk";
+  metrics.properties["function"] = options.functionName;
+  if (options.properties) {
+    Object.assign(metrics.properties, options.properties);
+  }
+  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/client/modules/billing/index.ts
+function createBillingModule(config) {
+  const { verbose = false, skipTelemetry = false } = config;
+  const privateKey = addHexPrefix(config.privateKey);
+  const logger = getLogger(verbose);
+  const billingEnvConfig = getBillingEnvironmentConfig(getBuildType());
+  const billingApi = new BillingApiClient(billingEnvConfig, privateKey);
+  return {
+    async subscribe(opts) {
+      return withSDKTelemetry(
+        {
+          functionName: "subscribe",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { productId: opts?.productId || "compute" }
+        },
+        async () => {
+          const productId = opts?.productId || "compute";
+          logger.debug(`Checking existing subscription for ${productId}...`);
+          const currentStatus = await billingApi.getSubscription(productId);
+          if (isSubscriptionActive(currentStatus.subscriptionStatus)) {
+            logger.debug(`Subscription already active: ${currentStatus.subscriptionStatus}`);
+            return {
+              type: "already_active",
+              status: currentStatus.subscriptionStatus
+            };
+          }
+          if (currentStatus.subscriptionStatus === "past_due" || currentStatus.subscriptionStatus === "unpaid") {
+            logger.debug(`Subscription has payment issue: ${currentStatus.subscriptionStatus}`);
+            return {
+              type: "payment_issue",
+              status: currentStatus.subscriptionStatus,
+              portalUrl: currentStatus.portalUrl
+            };
+          }
+          logger.debug(`Creating subscription for ${productId}...`);
+          const result = await billingApi.createSubscription(productId);
+          logger.debug(`Checkout URL: ${result.checkoutUrl}`);
+          return {
+            type: "checkout_created",
+            checkoutUrl: result.checkoutUrl
+          };
+        }
+      );
+    },
+    async getStatus(opts) {
+      return withSDKTelemetry(
+        {
+          functionName: "getStatus",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { productId: opts?.productId || "compute" }
+        },
+        async () => {
+          const productId = opts?.productId || "compute";
+          logger.debug(`Fetching subscription status for ${productId}...`);
+          const result = await billingApi.getSubscription(productId);
+          logger.debug(`Subscription status: ${result.subscriptionStatus}`);
+          return result;
+        }
+      );
+    },
+    async cancel(opts) {
+      return withSDKTelemetry(
+        {
+          functionName: "cancel",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { productId: opts?.productId || "compute" }
+        },
+        async () => {
+          const productId = opts?.productId || "compute";
+          logger.debug(`Checking subscription status for ${productId}...`);
+          const currentStatus = await billingApi.getSubscription(productId);
+          if (!isSubscriptionActive(currentStatus.subscriptionStatus)) {
+            logger.debug(`No active subscription to cancel: ${currentStatus.subscriptionStatus}`);
+            return {
+              type: "no_active_subscription",
+              status: currentStatus.subscriptionStatus
+            };
+          }
+          logger.debug(`Canceling subscription for ${productId}...`);
+          await billingApi.cancelSubscription(productId);
+          logger.debug(`Subscription canceled successfully`);
+          return {
+            type: "canceled"
+          };
+        }
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBillingModule
+});
+//# sourceMappingURL=billing.cjs.map