@layr-labs/ecloud-sdk 0.1.0-dev.1 → 0.1.0-dev.3

package/dist/chunk-6WSXUSKJ.js

@@ -0,0 +1,668 @@
+// 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 getEnvironmentConfig(environment, chainID) {
+  const env = ENVIRONMENTS[environment];
+  if (!env) {
+    throw new Error(`Unknown environment: ${environment}`);
+  }
+  if (!isEnvironmentAvailable(environment)) {
+    throw new Error(
+      `Environment ${environment} is not available in this build type. Available environments: ${getAvailableEnvironments().join(", ")}`
+    );
+  }
+  if (chainID) {
+    const expectedEnv = CHAIN_ID_TO_ENVIRONMENT[chainID.toString()];
+    if (expectedEnv && expectedEnv !== environment) {
+      throw new Error(`Environment ${environment} does not match chain ID ${chainID}`);
+    }
+  }
+  const resolvedChainID = chainID || (environment === "sepolia" || environment === "sepolia-dev" ? SEPOLIA_CHAIN_ID : MAINNET_CHAIN_ID);
+  return {
+    ...env,
+    chainID: BigInt(resolvedChainID)
+  };
+}
+function getBillingEnvironmentConfig(build) {
+  const config = BILLING_ENVIRONMENTS[build];
+  if (!config) {
+    throw new Error(`Unknown billing environment: ${build}`);
+  }
+  return config;
+}
+function getBuildType() {
+  const buildTimeType = true ? "dev"?.toLowerCase() : void 0;
+  const runtimeType = process.env.BUILD_TYPE?.toLowerCase();
+  const buildType = buildTimeType || runtimeType;
+  if (buildType === "dev") {
+    return "dev";
+  }
+  return "prod";
+}
+function getAvailableEnvironments() {
+  const buildType = getBuildType();
+  if (buildType === "dev") {
+    return ["sepolia-dev"];
+  }
+  return ["sepolia", "mainnet-alpha"];
+}
+function isEnvironmentAvailable(environment) {
+  return getAvailableEnvironments().includes(environment);
+}
+function isMainnet(environmentConfig) {
+  return environmentConfig.chainID === BigInt(MAINNET_CHAIN_ID);
+}
+
+// src/client/common/utils/userapi.ts
+import axios from "axios";
+import FormData from "form-data";
+import { createPublicClient, http } from "viem";
+
+// src/client/common/utils/auth.ts
+import { parseAbi } from "viem";
+var APP_CONTROLLER_ABI = parseAbi([
+  "function calculateApiPermissionDigestHash(bytes4 permission, uint256 expiry) view returns (bytes32)"
+]);
+async function calculatePermissionSignature(options) {
+  const { permission, expiry, appControllerAddress, publicClient, account } = options;
+  const digest = await publicClient.readContract({
+    address: appControllerAddress,
+    abi: APP_CONTROLLER_ABI,
+    functionName: "calculateApiPermissionDigestHash",
+    args: [permission, expiry]
+  });
+  const signature = await account.signMessage({
+    message: { raw: digest }
+  });
+  return { signature, digest };
+}
+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/userapi.ts
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/client/common/utils/helpers.ts
+import { extractChain } from "viem";
+import { sepolia as sepolia2 } from "viem/chains";
+
+// src/client/common/constants.ts
+import { sepolia, mainnet } from "viem/chains";
+var SUPPORTED_CHAINS = [mainnet, sepolia];
+var DOCKER_PLATFORM = "linux/amd64";
+var REGISTRY_PROPAGATION_WAIT_SECONDS = 3;
+var LAYERED_DOCKERFILE_NAME = "Dockerfile.eigencompute";
+var ENV_SOURCE_SCRIPT_NAME = "compute-source-env.sh";
+var KMS_CLIENT_BINARY_NAME = "kms-client";
+var KMS_SIGNING_KEY_NAME = "kms-signing-public-key.pem";
+var TLS_KEYGEN_BINARY_NAME = "tls-keygen";
+var CADDYFILE_NAME = "Caddyfile";
+var LAYERED_BUILD_DIR_PREFIX = "ecloud-layered-build";
+
+// src/client/common/utils/helpers.ts
+function getChainFromID(chainID, fallback = sepolia2) {
+  const id = Number(chainID);
+  return extractChain({ chains: SUPPORTED_CHAINS, id }) || fallback;
+}
+function addHexPrefix(value) {
+  return value.startsWith("0x") ? value : `0x${value}`;
+}
+function stripHexPrefix(value) {
+  return value.startsWith("0x") ? value.slice(2) : value;
+}
+
+// src/client/common/utils/userapi.ts
+var MAX_ADDRESS_COUNT = 5;
+var CanViewAppLogsPermission = "0x2fd3f2fe";
+var CanViewSensitiveAppInfoPermission = "0x0e67b22f";
+var CanUpdateAppProfilePermission = "0x036fef61";
+function getDefaultClientId() {
+  const version = true ? "0.1.0-dev.3" : "0.0.0";
+  return `ecloud-sdk/v${version}`;
+}
+var UserApiClient = class {
+  constructor(config, privateKey, rpcUrl, clientId) {
+    this.config = config;
+    if (privateKey) {
+      const privateKeyHex = addHexPrefix(privateKey);
+      this.account = privateKeyToAccount(privateKeyHex);
+    }
+    this.rpcUrl = rpcUrl;
+    this.clientId = clientId || getDefaultClientId();
+  }
+  async getInfos(appIDs, addressCount = 1) {
+    const count = Math.min(addressCount, MAX_ADDRESS_COUNT);
+    const endpoint = `${this.config.userApiServerURL}/info`;
+    const url = `${endpoint}?${new URLSearchParams({ apps: appIDs.join(",") })}`;
+    const res = await this.makeAuthenticatedRequest(url, CanViewSensitiveAppInfoPermission);
+    const result = await res.json();
+    return result.apps.map((app, i) => {
+      const evmAddresses = app.addresses?.data?.evmAddresses?.slice(0, count) || [];
+      const solanaAddresses = app.addresses?.data?.solanaAddresses?.slice(0, count) || [];
+      return {
+        address: appIDs[i],
+        status: app.app_status,
+        ip: app.ip,
+        machineType: app.machine_type,
+        profile: app.profile,
+        metrics: app.metrics,
+        evmAddresses,
+        solanaAddresses
+      };
+    });
+  }
+  /**
+   * Get available SKUs (instance types) from UserAPI
+   */
+  async getSKUs() {
+    const endpoint = `${this.config.userApiServerURL}/skus`;
+    const response = await this.makeAuthenticatedRequest(endpoint);
+    const result = await response.json();
+    return {
+      skus: result.skus || result.SKUs || []
+    };
+  }
+  /**
+   * Get logs for an app
+   */
+  async getLogs(appID) {
+    const endpoint = `${this.config.userApiServerURL}/logs/${appID}`;
+    const response = await this.makeAuthenticatedRequest(endpoint, CanViewAppLogsPermission);
+    return await response.text();
+  }
+  /**
+   * Get statuses for apps
+   */
+  async getStatuses(appIDs) {
+    const endpoint = `${this.config.userApiServerURL}/status`;
+    const url = `${endpoint}?${new URLSearchParams({ apps: appIDs.join(",") })}`;
+    const response = await this.makeAuthenticatedRequest(url);
+    const result = await response.json();
+    const apps = result.apps || result.Apps || [];
+    return apps.map((app, i) => ({
+      address: app.address || appIDs[i],
+      status: app.status || app.Status || ""
+    }));
+  }
+  /**
+   * Upload app profile information with optional image
+   */
+  async uploadAppProfile(appAddress, name, website, description, xURL, imagePath) {
+    const endpoint = `${this.config.userApiServerURL}/apps/${appAddress}/profile`;
+    const formData = new FormData();
+    formData.append("name", name);
+    if (website) {
+      formData.append("website", website);
+    }
+    if (description) {
+      formData.append("description", description);
+    }
+    if (xURL) {
+      formData.append("xURL", xURL);
+    }
+    if (imagePath) {
+      const fs = await import("fs");
+      const path2 = await import("path");
+      const fileName = path2.basename(imagePath);
+      const fileBuffer = fs.readFileSync(imagePath);
+      formData.append("image", fileBuffer, fileName);
+    }
+    const headers = {
+      "x-client-id": this.clientId,
+      ...formData.getHeaders()
+    };
+    if (this.account) {
+      const expiry = BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
+      const authHeaders = await this.generateAuthHeaders(CanUpdateAppProfilePermission, expiry);
+      Object.assign(headers, authHeaders);
+    }
+    try {
+      const response = await axios.post(endpoint, formData, {
+        headers,
+        maxRedirects: 0,
+        validateStatus: () => true,
+        // Don't throw on any status
+        maxContentLength: Infinity,
+        // Allow large file uploads
+        maxBodyLength: Infinity
+        // Allow large file uploads
+      });
+      const status = response.status;
+      if (status !== 200 && status !== 201) {
+        const body = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+        if (status === 403 && body.includes("Cloudflare") && body.includes("challenge-platform")) {
+          throw new Error(
+            `Cloudflare protection is blocking the request. This is likely due to bot detection.
+Status: ${status}`
+          );
+        }
+        throw new Error(
+          `UserAPI request failed: ${status} ${status >= 200 && status < 300 ? "OK" : "Error"} - ${body.substring(0, 500)}${body.length > 500 ? "..." : ""}`
+        );
+      }
+      return 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 UserAPI at ${endpoint}: ${cause}
+Please check:
+1. Your internet connection
+2. The API server is accessible: ${this.config.userApiServerURL}
+3. Firewall/proxy settings`
+        );
+      }
+      throw error;
+    }
+  }
+  async makeAuthenticatedRequest(url, permission) {
+    const headers = {
+      "x-client-id": this.clientId
+    };
+    if (permission && this.account) {
+      const expiry = BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
+      const authHeaders = await this.generateAuthHeaders(permission, expiry);
+      Object.assign(headers, authHeaders);
+    }
+    try {
+      const response = await axios.get(url, {
+        headers,
+        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(`UserAPI 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 UserAPI at ${url}: ${cause}
+Please check:
+1. Your internet connection
+2. The API server is accessible: ${this.config.userApiServerURL}
+3. Firewall/proxy settings`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Generate authentication headers for UserAPI requests
+   */
+  async generateAuthHeaders(permission, expiry) {
+    if (!this.account) {
+      throw new Error("Private key required for authenticated requests");
+    }
+    if (!this.rpcUrl) {
+      throw new Error("RPC URL required for authenticated requests");
+    }
+    const chain = getChainFromID(this.config.chainID);
+    const publicClient = createPublicClient({
+      chain,
+      transport: http(this.rpcUrl)
+    });
+    const { signature } = await calculatePermissionSignature({
+      permission,
+      expiry,
+      appControllerAddress: this.config.appControllerAddress,
+      publicClient,
+      account: this.account
+    });
+    return {
+      Authorization: `Bearer ${stripHexPrefix(signature)}`,
+      "X-eigenx-expiry": expiry.toString()
+    };
+  }
+};
+
+// 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
+import { PostHog } from "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 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/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
+import * as os from "os";
+
+// src/client/common/telemetry/wrapper.ts
+import { randomUUID } from "crypto";
+function generateRandomUUID() {
+  return 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/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/utils/logger.ts
+var defaultLogger = {
+  info: (...args) => console.info(...args),
+  warn: (...args) => console.warn(...args),
+  error: (...args) => console.error(...args),
+  debug: (...args) => console.debug(...args)
+};
+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/dirname.ts
+import * as path from "path";
+import { fileURLToPath } from "url";
+function getDirname() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  try {
+    const metaUrl = import.meta.url;
+    return path.dirname(fileURLToPath(metaUrl));
+  } catch {
+    return process.cwd();
+  }
+}
+
+export {
+  calculateBillingAuthSignature,
+  getEnvironmentConfig,
+  getBillingEnvironmentConfig,
+  getBuildType,
+  getAvailableEnvironments,
+  isEnvironmentAvailable,
+  isMainnet,
+  defaultLogger,
+  getLogger,
+  DOCKER_PLATFORM,
+  REGISTRY_PROPAGATION_WAIT_SECONDS,
+  LAYERED_DOCKERFILE_NAME,
+  ENV_SOURCE_SCRIPT_NAME,
+  KMS_CLIENT_BINARY_NAME,
+  KMS_SIGNING_KEY_NAME,
+  TLS_KEYGEN_BINARY_NAME,
+  CADDYFILE_NAME,
+  LAYERED_BUILD_DIR_PREFIX,
+  getChainFromID,
+  addHexPrefix,
+  stripHexPrefix,
+  UserApiClient,
+  getDirname,
+  isSubscriptionActive,
+  NoopClient,
+  isNoopClient,
+  PostHogClient,
+  getPostHogAPIKey,
+  getPostHogEndpoint,
+  createMetricsContext,
+  addMetric,
+  addMetricWithDimensions,
+  createTelemetryClient,
+  createAppEnvironment,
+  emitMetrics,
+  withSDKTelemetry
+};
+//# sourceMappingURL=chunk-6WSXUSKJ.js.map