@layr-labs/ecloud-sdk 0.2.0 → 0.2.2-dev

package/dist/billing.js

@@ -1,7 +1,522 @@
-import {
-  createBillingModule
-} from "./chunk-ZDXN2WKP.js";
-import "./chunk-CA5Y4OVI.js";
+// src/client/common/utils/billingapi.ts
+import axios from "axios";
+
+// src/client/common/utils/auth.ts
+import { parseAbi } from "viem";
+var APP_CONTROLLER_ABI = parseAbi([
+  "function calculateApiPermissionDigestHash(bytes4 permission, uint256 expiry) view returns (bytes32)"
+]);
+var generateBillingSigData = (product, expiry) => {
+  return {
+    domain: {
+      name: "EigenCloud Billing API",
+      version: "1"
+    },
+    types: {
+      BillingAuth: [
+        { name: "product", type: "string" },
+        { name: "expiry", type: "uint256" }
+      ]
+    },
+    primaryType: "BillingAuth",
+    message: {
+      product,
+      expiry
+    }
+  };
+};
+async function calculateBillingAuthSignature(options) {
+  const { walletClient, product, expiry } = options;
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("WalletClient must have an account attached");
+  }
+  const signature = await walletClient.signTypedData({
+    account,
+    ...generateBillingSigData(product, expiry)
+  });
+  return { signature, expiry };
+}
+
+// src/client/common/utils/billingapi.ts
+var BillingApiClient = class {
+  constructor(config, walletClient) {
+    this.config = config;
+    this.walletClient = walletClient;
+  }
+  /**
+   * Get the address of the connected wallet
+   */
+  get address() {
+    const account = this.walletClient.account;
+    if (!account) {
+      throw new Error("WalletClient must have an account attached");
+    }
+    return account.address;
+  }
+  async createSubscription(productId = "compute", options) {
+    const endpoint = `${this.config.billingApiServerURL}/products/${productId}/subscription`;
+    const body = options ? {
+      success_url: options.successUrl,
+      cancel_url: options.cancelUrl
+    } : void 0;
+    const resp = await this.makeAuthenticatedRequest(endpoint, "POST", productId, body);
+    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, body) {
+    const expiry = BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
+    const { signature } = await calculateBillingAuthSignature({
+      walletClient: this.walletClient,
+      product: productId,
+      expiry
+    });
+    const headers = {
+      Authorization: `Bearer ${signature}`,
+      "X-Account": this.address,
+      "X-Expiry": expiry.toString()
+    };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+    }
+    try {
+      const response = await axios({
+        method,
+        url,
+        headers,
+        data: body,
+        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 body2 = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+        throw new Error(`BillingAPI request failed: ${status} ${statusText} - ${body2}`);
+      }
+      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 ? "dev"?.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
+import axios2 from "axios";
+
+// src/client/common/utils/helpers.ts
+import { extractChain, createPublicClient, createWalletClient, http } from "viem";
+import { sepolia as sepolia2 } from "viem/chains";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/client/common/constants.ts
+import { sepolia, mainnet } from "viem/chains";
+
+// 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/index.ts
+import * as os from "os";
+
+// 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
+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/modules/billing/index.ts
+function createBillingModule(config) {
+  const { verbose = false, skipTelemetry = false, walletClient } = config;
+  if (!walletClient.account) {
+    throw new Error("WalletClient must have an account attached");
+  }
+  const address = walletClient.account.address;
+  const logger = getLogger(verbose);
+  const billingEnvConfig = getBillingEnvironmentConfig(getBuildType());
+  const billingApi = new BillingApiClient(billingEnvConfig, walletClient);
+  return {
+    address,
+    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"
+          };
+        }
+      );
+    }
+  };
+}
 export {
   createBillingModule
 };