@layr-labs/ecloud-sdk 0.2.1-dev → 0.3.0-dev

package/dist/helpers-Dk0zwgms.d.cts

@@ -0,0 +1,983 @@
+import { a6 as EnvironmentConfig, ag as SubscriptionStatus, a5 as BillingEnvironmentConfig, ae as ProductID, ai as CreateSubscriptionOptions, aj as CreateSubscriptionResponse, ar as ProductSubscriptionResponse, G as GasEstimate, ab as Logger } from './index-C0w92tCs.cjs';
+import { Address, Hex, WalletClient, PublicClient, Chain } from 'viem';
+
+/**
+ * Environment configuration for different networks
+ */
+
+/**
+ * Get environment configuration
+ */
+declare function getEnvironmentConfig(environment: string, chainID?: bigint): EnvironmentConfig;
+/**
+ * Get billing environment configuration
+ * @param build - The build type ("dev" or "prod")
+ */
+declare function getBillingEnvironmentConfig(build: "dev" | "prod"): {
+    billingApiServerURL: string;
+};
+declare function getBuildType(): "dev" | "prod";
+/**
+ * Get available environments based on build type
+ * - dev: only "sepolia-dev"
+ * - prod: "sepolia" and "mainnet-alpha"
+ */
+declare function getAvailableEnvironments(): string[];
+/**
+ * Check if an environment is available in the current build
+ */
+declare function isEnvironmentAvailable(environment: string): boolean;
+/**
+ * Check if environment is mainnet (chain ID 1)
+ */
+declare function isMainnet(environmentConfig: EnvironmentConfig): boolean;
+
+/**
+ * Non-interactive validation utilities for SDK
+ *
+ * These functions validate parameters without any interactive prompts.
+ * They either return the validated value or throw an error.
+ */
+
+/**
+ * Validate app name format
+ * @throws Error if name is invalid
+ */
+declare function validateAppName(name: string): void;
+/**
+ * Validate Docker image reference format
+ * @returns true if valid, error message string if invalid
+ */
+declare function validateImageReference(value: string): true | string;
+/**
+ * Validate image reference and throw if invalid
+ * @throws Error if image reference is invalid
+ */
+declare function assertValidImageReference(value: string): void;
+/**
+ * Extract app name from image reference
+ */
+declare function extractAppNameFromImage(imageRef: string): string;
+/**
+ * Validate that a file path exists
+ * @returns true if valid, error message string if invalid
+ */
+declare function validateFilePath(value: string): true | string;
+/**
+ * Validate file path and throw if invalid
+ * @throws Error if file path is invalid or doesn't exist
+ */
+declare function assertValidFilePath(value: string): void;
+/**
+ * Validate instance type SKU against available types
+ * @returns the validated SKU
+ * @throws Error if SKU is not in the available types list
+ */
+declare function validateInstanceTypeSKU(sku: string, availableTypes: Array<{
+    sku: string;
+}>): string;
+/**
+ * Validate private key format
+ * Matches Go's common.ValidatePrivateKey() function
+ */
+declare function validatePrivateKeyFormat(key: string): boolean;
+/**
+ * Validate private key and throw if invalid
+ * @throws Error if private key format is invalid
+ */
+declare function assertValidPrivateKey(key: string): void;
+/**
+ * Validate URL format
+ * @returns undefined if valid, error message string if invalid
+ */
+declare function validateURL(rawURL: string): string | undefined;
+/**
+ * Validate X/Twitter URL format
+ * @returns undefined if valid, error message string if invalid
+ */
+declare function validateXURL(rawURL: string): string | undefined;
+/**
+ * Validate description length
+ * @returns undefined if valid, error message string if invalid
+ */
+declare function validateDescription(description: string): string | undefined;
+/**
+ * Validate image file path
+ * @returns undefined if valid, error message string if invalid
+ */
+declare function validateImagePath(filePath: string): string | undefined;
+/**
+ * Validate and normalize app ID address
+ * @param appID - App ID (must be a valid address)
+ * @returns Normalized app address
+ * @throws Error if app ID is not a valid address
+ *
+ * Note: Name resolution should be handled by CLI before calling SDK functions.
+ * The SDK only accepts resolved addresses.
+ */
+declare function validateAppID(appID: string | Address): Address;
+type LogVisibility = "public" | "private" | "off";
+/**
+ * Validate and convert log visibility setting to internal format
+ * @param logVisibility - Log visibility setting
+ * @returns Object with logRedirect and publicLogs settings
+ * @throws Error if log visibility value is invalid
+ */
+declare function validateLogVisibility(logVisibility: LogVisibility): {
+    logRedirect: string;
+    publicLogs: boolean;
+};
+type ResourceUsageMonitoring = "enable" | "disable";
+/**
+ * Validate and convert resource usage monitoring setting to internal format
+ * @param resourceUsageMonitoring - Resource usage monitoring setting
+ * @returns The resourceUsageAllow value for the Dockerfile label ("always" or "never")
+ * @throws Error if resource usage monitoring value is invalid
+ */
+declare function validateResourceUsageMonitoring(resourceUsageMonitoring: ResourceUsageMonitoring | undefined): string;
+/**
+ * Sanitize string (HTML escape and trim)
+ */
+declare function sanitizeString(s: string): string;
+/**
+ * Sanitize URL (add https:// if missing, validate)
+ * @throws Error if URL is invalid after sanitization
+ */
+declare function sanitizeURL(rawURL: string): string;
+/**
+ * Sanitize X/Twitter URL (handle username-only input, normalize)
+ * @throws Error if URL is invalid after sanitization
+ */
+declare function sanitizeXURL(rawURL: string): string;
+interface DeployParams {
+    dockerfilePath?: string;
+    imageRef?: string;
+    appName: string;
+    envFilePath?: string;
+    instanceType: string;
+    logVisibility: LogVisibility;
+}
+/**
+ * Validate deploy parameters
+ * @throws Error if required parameters are missing or invalid
+ */
+declare function validateDeployParams(params: Partial<DeployParams>): void;
+interface UpgradeParams {
+    appID: string | Address;
+    dockerfilePath?: string;
+    imageRef?: string;
+    envFilePath?: string;
+    instanceType: string;
+    logVisibility: LogVisibility;
+}
+/**
+ * Validate upgrade parameters
+ * @throws Error if required parameters are missing or invalid
+ */
+declare function validateUpgradeParams(params: Partial<UpgradeParams>): void;
+interface CreateAppParams {
+    name: string;
+    language: string;
+    template?: string;
+    templateVersion?: string;
+}
+/**
+ * Validate create app parameters
+ * @throws Error if required parameters are missing or invalid
+ */
+declare function validateCreateAppParams(params: Partial<CreateAppParams>): void;
+interface LogsParams {
+    appID: string | Address;
+    watch?: boolean;
+}
+/**
+ * Validate logs parameters
+ * @throws Error if required parameters are missing or invalid
+ */
+declare function validateLogsParams(params: Partial<LogsParams>): void;
+
+/**
+ * Billing utility functions
+ */
+
+/**
+ * Check if subscription status allows deploying apps
+ */
+declare function isSubscriptionActive(status: SubscriptionStatus): boolean;
+
+/**
+ * Private Key Generation
+ *
+ * Generate new secp256k1 private keys for Ethereum
+ */
+interface GeneratedKey {
+    privateKey: string;
+    address: string;
+}
+/**
+ * Generate a new secp256k1 private key
+ */
+declare function generateNewPrivateKey(): GeneratedKey;
+
+/**
+ * Compute API Session Management
+ *
+ * This module provides utilities for managing authentication sessions with the compute API
+ * using SIWE (Sign-In with Ethereum).
+ */
+
+interface ComputeApiConfig {
+    /** Base URL of the compute API (e.g., "https://api.eigencloud.xyz") */
+    baseUrl: string;
+}
+interface SessionInfo {
+    /** Whether the session is authenticated */
+    authenticated: boolean;
+    /** Authenticated wallet address (if authenticated) */
+    address?: Address;
+    /** Chain ID used for authentication (if authenticated) */
+    chainId?: number;
+}
+interface LoginResult {
+    /** Whether login was successful */
+    success: boolean;
+    /** Authenticated wallet address */
+    address: Address;
+}
+interface LoginRequest {
+    /** SIWE message string */
+    message: string;
+    /** Hex-encoded signature (with or without 0x prefix) */
+    signature: Hex | string;
+}
+/**
+ * Error thrown when session operations fail
+ */
+declare class SessionError extends Error {
+    readonly code: "NETWORK_ERROR" | "INVALID_SIGNATURE" | "INVALID_MESSAGE" | "SESSION_EXPIRED" | "UNAUTHORIZED" | "UNKNOWN";
+    readonly statusCode?: number | undefined;
+    constructor(message: string, code: "NETWORK_ERROR" | "INVALID_SIGNATURE" | "INVALID_MESSAGE" | "SESSION_EXPIRED" | "UNAUTHORIZED" | "UNKNOWN", statusCode?: number | undefined);
+}
+/**
+ * Login to the compute API using SIWE
+ *
+ * This establishes a session with the compute API by verifying the SIWE message
+ * and signature. On success, a session cookie is set in the browser.
+ *
+ * @param config - Compute API configuration
+ * @param request - Login request containing SIWE message and signature
+ * @returns Login result with the authenticated address
+ *
+ * @example
+ * ```typescript
+ * import { createSiweMessage, loginToComputeApi } from "@layr-labs/ecloud-sdk/browser";
+ *
+ * const { message } = createSiweMessage({
+ *   address: userAddress,
+ *   chainId: 11155111,
+ *   domain: window.location.host,
+ *   uri: window.location.origin,
+ * });
+ *
+ * const signature = await signMessageAsync({ message });
+ * const result = await loginToComputeApi(
+ *   { baseUrl: "https://api.eigencloud.xyz" },
+ *   { message, signature }
+ * );
+ * ```
+ */
+declare function loginToComputeApi(config: ComputeApiConfig, request: LoginRequest): Promise<LoginResult>;
+/**
+ * Get the current session status from the compute API
+ *
+ * @param config - Compute API configuration
+ * @returns Session information including authentication status and address
+ *
+ * @example
+ * ```typescript
+ * const session = await getComputeApiSession({ baseUrl: "https://api.eigencloud.xyz" });
+ * if (session.authenticated) {
+ *   console.log(`Logged in as ${session.address}`);
+ * }
+ * ```
+ */
+declare function getComputeApiSession(config: ComputeApiConfig): Promise<SessionInfo>;
+/**
+ * Logout from the compute API
+ *
+ * This destroys the current session and clears the session cookie.
+ *
+ * @param config - Compute API configuration
+ *
+ * @example
+ * ```typescript
+ * await logoutFromComputeApi({ baseUrl: "https://api.eigencloud.xyz" });
+ * ```
+ */
+declare function logoutFromComputeApi(config: ComputeApiConfig): Promise<void>;
+/**
+ * Check if a session is still valid (not expired)
+ *
+ * This is a convenience function that checks the session status
+ * and returns a boolean.
+ *
+ * @param config - Compute API configuration
+ * @returns True if session is authenticated, false otherwise
+ */
+declare function isSessionValid(config: ComputeApiConfig): Promise<boolean>;
+
+interface AppProfileInfo {
+    name: string;
+    website?: string;
+    description?: string;
+    xURL?: string;
+    imageURL?: string;
+}
+interface AppMetrics {
+    cpu_utilization_percent?: number;
+    memory_utilization_percent?: number;
+    memory_used_bytes?: number;
+    memory_total_bytes?: number;
+}
+interface DerivedAddress {
+    address: string;
+    derivationPath: string;
+}
+interface AppInfo {
+    address: Address;
+    status: string;
+    ip: string;
+    machineType: string;
+    profile?: AppProfileInfo;
+    metrics?: AppMetrics;
+    evmAddresses: DerivedAddress[];
+    solanaAddresses: DerivedAddress[];
+}
+interface AppInfoResponse {
+    apps: Array<{
+        addresses: {
+            data: {
+                evmAddresses: DerivedAddress[];
+                solanaAddresses: DerivedAddress[];
+            };
+            signature: string;
+        };
+        app_status: string;
+        ip: string;
+        machine_type: string;
+        profile?: AppProfileInfo;
+        metrics?: AppMetrics;
+    }>;
+}
+type AppContractStatus = "STARTED" | "STOPPED" | "TERMINATED" | "SUSPENDED" | string;
+interface AppReleaseBuild {
+    buildId?: string;
+    billingAddress?: string;
+    repoUrl?: string;
+    gitRef?: string;
+    status?: string;
+    buildType?: string;
+    imageName?: string;
+    imageDigest?: string;
+    imageUrl?: string;
+    provenanceJson?: unknown;
+    provenanceSignature?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    errorMessage?: string;
+    dependencies?: Record<string, AppReleaseBuild>;
+}
+interface AppRelease {
+    appId?: string;
+    rmsReleaseId?: string;
+    imageDigest?: string;
+    registryUrl?: string;
+    publicEnv?: string;
+    encryptedEnv?: string;
+    upgradeByTime?: number;
+    createdAt?: string;
+    createdAtBlock?: string;
+    build?: AppReleaseBuild;
+}
+interface AppResponse {
+    id: string;
+    creator?: string;
+    contractStatus?: AppContractStatus;
+    releases: AppRelease[];
+}
+/**
+ * Options for UserApiClient
+ */
+interface UserApiClientOptions {
+    /** Custom client ID for request tracking */
+    clientId?: string;
+    /**
+     * Use SIWE session authentication instead of per-request signatures.
+     * When true, requests rely on session cookies set by loginToComputeApi().
+     * When false (default), each request is signed individually.
+     */
+    useSession?: boolean;
+}
+/**
+ * UserAPI Client for interacting with the EigenCloud UserAPI service.
+ */
+declare class UserApiClient {
+    private readonly config;
+    private readonly walletClient;
+    private readonly publicClient;
+    private readonly clientId;
+    private readonly useSession;
+    constructor(config: EnvironmentConfig, walletClient: WalletClient, publicClient: PublicClient, options?: UserApiClientOptions);
+    /**
+     * Get the address of the connected wallet
+     */
+    get address(): Address;
+    getInfos(appIDs: Address[], addressCount?: number): Promise<AppInfo[]>;
+    /**
+     * Get app details from UserAPI (includes releases and build/provenance info when available).
+     *
+     * Endpoint: GET /apps/:appAddress
+     */
+    getApp(appAddress: Address): Promise<AppResponse>;
+    /**
+     * Get available SKUs (instance types) from UserAPI
+     */
+    getSKUs(): Promise<{
+        skus: Array<{
+            sku: string;
+            description: string;
+        }>;
+    }>;
+    /**
+     * Get logs for an app
+     */
+    getLogs(appID: Address): Promise<string>;
+    /**
+     * Get statuses for apps
+     */
+    getStatuses(appIDs: Address[]): Promise<Array<{
+        address: Address;
+        status: string;
+    }>>;
+    /**
+     * Upload app profile information with optional image
+     *
+     * @param appAddress - The app's contract address
+     * @param name - Display name for the app
+     * @param options - Optional fields including website, description, xURL, and image
+     * @param options.image - Image file as Blob or File (browser: from input element, Node.js: new Blob([buffer]))
+     * @param options.imageName - Filename for the image (required if image is provided)
+     */
+    uploadAppProfile(appAddress: Address, name: string, options?: {
+        website?: string;
+        description?: string;
+        xURL?: string;
+        image?: Blob | File;
+        imageName?: string;
+    }): Promise<{
+        name: string;
+        website?: string;
+        description?: string;
+        xURL?: string;
+        imageURL?: string;
+    }>;
+    private makeAuthenticatedRequest;
+    /**
+     * Generate authentication headers for UserAPI requests
+     */
+    private generateAuthHeaders;
+    /**
+     * Login to the compute API using SIWE (Sign-In with Ethereum)
+     *
+     * This establishes a session with the compute API by verifying the SIWE message
+     * and signature. On success, a session cookie is set in the browser.
+     *
+     * @param request - Login request containing SIWE message and signature
+     * @returns Login result with the authenticated address
+     *
+     * @example
+     * ```typescript
+     * import { createSiweMessage } from "@layr-labs/ecloud-sdk/browser";
+     *
+     * const { message } = createSiweMessage({
+     *   address: userAddress,
+     *   chainId: 11155111,
+     *   domain: window.location.host,
+     *   uri: window.location.origin,
+     * });
+     *
+     * const signature = await signMessageAsync({ message });
+     * const result = await client.siweLogin({ message, signature });
+     * ```
+     */
+    siweLogin(request: LoginRequest): Promise<LoginResult>;
+    /**
+     * Logout from the compute API
+     *
+     * This destroys the current session and clears the session cookie.
+     *
+     * @example
+     * ```typescript
+     * await client.siweLogout();
+     * ```
+     */
+    siweLogout(): Promise<void>;
+    /**
+     * Get the current SIWE session status from the compute API
+     *
+     * @returns Session information including authentication status and address
+     *
+     * @example
+     * ```typescript
+     * const session = await client.getSiweSession();
+     * if (session.authenticated) {
+     *   console.log(`Logged in as ${session.address}`);
+     * }
+     * ```
+     */
+    getSiweSession(): Promise<SessionInfo>;
+}
+
+/**
+ * Billing API Session Management
+ *
+ * This module provides utilities for managing authentication sessions with the billing API
+ * using SIWE (Sign-In with Ethereum).
+ *
+ * The billing API now supports the same SIWE-based session authentication as the compute API,
+ * allowing users to sign once and authenticate to both APIs simultaneously.
+ */
+
+interface BillingApiConfig {
+    /** Base URL of the billing API (e.g., "https://billing.eigencloud.xyz") */
+    baseUrl: string;
+}
+interface BillingSessionInfo {
+    /** Whether the session is authenticated */
+    authenticated: boolean;
+    /** Authenticated wallet address (if authenticated) */
+    address?: Address;
+    /** Chain ID used for authentication (if authenticated) */
+    chainId?: number;
+    /** Unix timestamp when authentication occurred (if authenticated) */
+    authenticatedAt?: number;
+}
+interface BillingLoginResult {
+    /** Whether login was successful */
+    success: boolean;
+    /** Authenticated wallet address */
+    address: Address;
+}
+interface BillingLoginRequest {
+    /** SIWE message string */
+    message: string;
+    /** Hex-encoded signature (with or without 0x prefix) */
+    signature: Hex | string;
+}
+/**
+ * Error thrown when billing session operations fail
+ */
+declare class BillingSessionError extends Error {
+    readonly code: "NETWORK_ERROR" | "INVALID_SIGNATURE" | "INVALID_MESSAGE" | "SESSION_EXPIRED" | "UNAUTHORIZED" | "UNKNOWN";
+    readonly statusCode?: number | undefined;
+    constructor(message: string, code: "NETWORK_ERROR" | "INVALID_SIGNATURE" | "INVALID_MESSAGE" | "SESSION_EXPIRED" | "UNAUTHORIZED" | "UNKNOWN", statusCode?: number | undefined);
+}
+/**
+ * Login to the billing API using SIWE
+ *
+ * This establishes a session with the billing API by verifying the SIWE message
+ * and signature. On success, a session cookie is set in the browser.
+ *
+ * The billing API accepts the same SIWE message format as the compute API,
+ * so users only need to sign once and can send the same message/signature
+ * to both APIs.
+ *
+ * @param config - Billing API configuration
+ * @param request - Login request containing SIWE message and signature
+ * @returns Login result with the authenticated address
+ *
+ * @example
+ * ```typescript
+ * import { createSiweMessage, loginToBillingApi } from "@layr-labs/ecloud-sdk/browser";
+ *
+ * const { message } = createSiweMessage({
+ *   address: userAddress,
+ *   chainId: 11155111,
+ *   domain: window.location.host,
+ *   uri: window.location.origin,
+ * });
+ *
+ * const signature = await signMessageAsync({ message });
+ *
+ * // Can send to both APIs with the same message/signature
+ * const [computeResult, billingResult] = await Promise.all([
+ *   loginToComputeApi({ baseUrl: computeApiUrl }, { message, signature }),
+ *   loginToBillingApi({ baseUrl: billingApiUrl }, { message, signature }),
+ * ]);
+ * ```
+ */
+declare function loginToBillingApi(config: BillingApiConfig, request: BillingLoginRequest): Promise<BillingLoginResult>;
+/**
+ * Get the current session status from the billing API
+ *
+ * @param config - Billing API configuration
+ * @returns Session information including authentication status and address
+ *
+ * @example
+ * ```typescript
+ * const session = await getBillingApiSession({ baseUrl: "https://billing.eigencloud.xyz" });
+ * if (session.authenticated) {
+ *   console.log(`Logged in as ${session.address}`);
+ * }
+ * ```
+ */
+declare function getBillingApiSession(config: BillingApiConfig): Promise<BillingSessionInfo>;
+/**
+ * Logout from the billing API
+ *
+ * This destroys the current session and clears the session cookie.
+ *
+ * @param config - Billing API configuration
+ *
+ * @example
+ * ```typescript
+ * await logoutFromBillingApi({ baseUrl: "https://billing.eigencloud.xyz" });
+ * ```
+ */
+declare function logoutFromBillingApi(config: BillingApiConfig): Promise<void>;
+/**
+ * Check if a billing session is still valid (not expired)
+ *
+ * This is a convenience function that checks the session status
+ * and returns a boolean.
+ *
+ * @param config - Billing API configuration
+ * @returns True if session is authenticated, false otherwise
+ */
+declare function isBillingSessionValid(config: BillingApiConfig): Promise<boolean>;
+/**
+ * Login to both compute and billing APIs simultaneously
+ *
+ * This is a convenience function that sends the same SIWE message and signature
+ * to both APIs in parallel, establishing sessions with both services at once.
+ *
+ * @param computeConfig - Compute API configuration
+ * @param billingConfig - Billing API configuration
+ * @param request - Login request containing SIWE message and signature
+ * @returns Object containing login results for both APIs
+ *
+ * @example
+ * ```typescript
+ * import { createSiweMessage, loginToBothApis } from "@layr-labs/ecloud-sdk/browser";
+ *
+ * const { message } = createSiweMessage({
+ *   address: userAddress,
+ *   chainId: 11155111,
+ *   domain: window.location.host,
+ *   uri: window.location.origin,
+ * });
+ *
+ * const signature = await signMessageAsync({ message });
+ * const { compute, billing } = await loginToBothApis(
+ *   { baseUrl: computeApiUrl },
+ *   { baseUrl: billingApiUrl },
+ *   { message, signature }
+ * );
+ * ```
+ */
+declare function loginToBothApis(computeConfig: {
+    baseUrl: string;
+}, billingConfig: BillingApiConfig, request: BillingLoginRequest): Promise<{
+    compute: BillingLoginResult;
+    billing: BillingLoginResult;
+}>;
+/**
+ * Logout from both compute and billing APIs simultaneously
+ *
+ * @param computeConfig - Compute API configuration
+ * @param billingConfig - Billing API configuration
+ *
+ * @example
+ * ```typescript
+ * await logoutFromBothApis(
+ *   { baseUrl: computeApiUrl },
+ *   { baseUrl: billingApiUrl }
+ * );
+ * ```
+ */
+declare function logoutFromBothApis(computeConfig: {
+    baseUrl: string;
+}, billingConfig: BillingApiConfig): Promise<void>;
+
+/**
+ * BillingAPI Client to manage product subscriptions
+ * Standalone client - does not depend on chain infrastructure
+ *
+ * Accepts viem's WalletClient which abstracts over both local accounts
+ * (privateKeyToAccount) and external signers (MetaMask, etc.).
+ *
+ * Supports two authentication modes:
+ * 1. EIP-712 signature auth (default) - signs each request with typed data
+ * 2. Session auth (optional) - uses SIWE session cookies
+ */
+
+interface BillingApiClientOptions {
+    /**
+     * Use session-based authentication instead of per-request signatures.
+     * When true, the client will rely on session cookies set by SIWE login.
+     * When false (default), uses EIP-712 typed data signatures for each request.
+     */
+    useSession?: boolean;
+}
+/**
+ * BillingAPI Client for managing product subscriptions.
+ */
+declare class BillingApiClient {
+    private readonly config;
+    private readonly walletClient;
+    private readonly options;
+    private readonly useSession;
+    constructor(config: BillingEnvironmentConfig, walletClient: WalletClient | null, options?: BillingApiClientOptions);
+    /**
+     * Get the address of the connected wallet
+     * Returns undefined if using session auth without a wallet client
+     */
+    get address(): Address | undefined;
+    /**
+     * Get the base URL of the billing API
+     */
+    get baseUrl(): string;
+    /**
+     * Login to the billing API using SIWE
+     *
+     * This establishes a session with the billing API by verifying the SIWE message
+     * and signature. On success, a session cookie is set in the browser.
+     *
+     * @param request - Login request containing SIWE message and signature
+     * @returns Login result with the authenticated address
+     *
+     * @example
+     * ```typescript
+     * const { message } = createSiweMessage({
+     *   address: userAddress,
+     *   chainId: 11155111,
+     *   domain: window.location.host,
+     *   uri: window.location.origin,
+     * });
+     *
+     * const signature = await signMessageAsync({ message });
+     * const result = await billingClient.siweLogin({ message, signature });
+     * ```
+     */
+    siweLogin(request: BillingLoginRequest): Promise<BillingLoginResult>;
+    /**
+     * Logout from the billing API
+     *
+     * This destroys the current session and clears the session cookie.
+     */
+    siweLogout(): Promise<void>;
+    /**
+     * Get the current session status from the billing API
+     *
+     * @returns Session information including authentication status and address
+     */
+    getSession(): Promise<BillingSessionInfo>;
+    /**
+     * Check if there is a valid session
+     *
+     * @returns True if session is authenticated, false otherwise
+     */
+    isSessionValid(): Promise<boolean>;
+    createSubscription(productId?: ProductID, options?: CreateSubscriptionOptions): Promise<CreateSubscriptionResponse>;
+    getSubscription(productId?: ProductID): Promise<ProductSubscriptionResponse>;
+    cancelSubscription(productId?: ProductID): Promise<void>;
+    /**
+     * Make an authenticated request to the billing API
+     *
+     * Uses session auth if useSession is true, otherwise uses EIP-712 signature auth.
+     */
+    private makeAuthenticatedRequest;
+    /**
+     * Make a request using session-based authentication (cookies)
+     */
+    private makeSessionAuthenticatedRequest;
+    /**
+     * Make a request using EIP-712 signature authentication
+     */
+    private makeSignatureAuthenticatedRequest;
+}
+
+/**
+ * EIP-7702 transaction handling
+ *
+ * This module handles EIP-7702 delegation and batch execution.
+ */
+
+type Execution = {
+    target: Address;
+    value: bigint;
+    callData: Hex;
+};
+/**
+ * Options for estimating batch gas
+ */
+interface EstimateBatchGasOptions {
+    publicClient: PublicClient;
+    account: Address;
+    executions: Execution[];
+}
+/**
+ * Estimate gas cost for a batch transaction
+ *
+ * Use this to get cost estimate before prompting user for confirmation.
+ */
+declare function estimateBatchGas(options: EstimateBatchGasOptions): Promise<GasEstimate>;
+interface ExecuteBatchOptions {
+    walletClient: WalletClient;
+    publicClient: PublicClient;
+    environmentConfig: EnvironmentConfig;
+    executions: Execution[];
+    pendingMessage: string;
+    /** Optional gas params from estimation */
+    gas?: GasEstimate;
+}
+/**
+ * Check if account is delegated to ERC-7702 delegator
+ */
+declare function checkERC7702Delegation(publicClient: PublicClient, account: Address, delegatorAddress: Address): Promise<boolean>;
+/**
+ * Execute batch of operations via EIP-7702 delegator
+ */
+declare function executeBatch(options: ExecuteBatchOptions, logger?: Logger): Promise<Hex>;
+
+/**
+ * SIWE (Sign-In with Ethereum) utilities for compute API authentication
+ *
+ * This module provides browser-safe utilities for creating and parsing SIWE messages
+ * compatible with the compute-tee API. Uses the official `siwe` package (EIP-4361).
+ */
+
+interface SiweMessageParams {
+    /** Ethereum address (checksummed or lowercase) */
+    address: Address;
+    /** Chain ID (e.g., 1 for mainnet, 11155111 for sepolia) */
+    chainId: number;
+    /** Domain requesting the signature (e.g., "api.eigencloud.xyz") */
+    domain: string;
+    /** Full URI of the signing request (e.g., "https://api.eigencloud.xyz") */
+    uri: string;
+    /** Optional nonce for replay protection (generated if not provided) */
+    nonce?: string;
+    /** Optional human-readable statement */
+    statement?: string;
+    /** Optional expiration time (defaults to 24 hours from now) */
+    expirationTime?: Date;
+    /** Optional issued at time (defaults to now) */
+    issuedAt?: Date;
+    /** Optional not-before time */
+    notBefore?: Date;
+    /** Optional request ID */
+    requestId?: string;
+    /** Optional resources array */
+    resources?: string[];
+}
+interface SiweMessageResult {
+    /** Raw SIWE message string for signing */
+    message: string;
+    /** Parsed parameters */
+    params: Required<Pick<SiweMessageParams, "address" | "chainId" | "domain" | "uri" | "nonce" | "issuedAt">> & Omit<SiweMessageParams, "address" | "chainId" | "domain" | "uri" | "nonce" | "issuedAt">;
+}
+/**
+ * Re-export generateNonce from siwe package
+ */
+declare const generateNonce: () => string;
+/**
+ * Create a SIWE message for compute API authentication
+ *
+ * @param params - Parameters for the SIWE message
+ * @returns The SIWE message object with the raw message string
+ *
+ * @example
+ * ```typescript
+ * const { message } = createSiweMessage({
+ *   address: "0x1234...",
+ *   chainId: 11155111,
+ *   domain: "api.eigencloud.xyz",
+ *   uri: "https://api.eigencloud.xyz",
+ *   statement: "Sign in to EigenCloud",
+ * });
+ *
+ * // Sign with wagmi
+ * const signature = await signMessageAsync({ message });
+ * ```
+ */
+declare function createSiweMessage(params: SiweMessageParams): SiweMessageResult;
+/**
+ * Parse a SIWE message string back to structured parameters
+ *
+ * @param message - Raw SIWE message string
+ * @returns Parsed parameters or null if invalid
+ */
+declare function parseSiweMessage(message: string): SiweMessageParams | null;
+/**
+ * Check if a SIWE message has expired
+ */
+declare function isSiweMessageExpired(params: SiweMessageParams): boolean;
+/**
+ * Check if a SIWE message is not yet valid (notBefore)
+ */
+declare function isSiweMessageNotYetValid(params: SiweMessageParams): boolean;
+
+/**
+ * General utility helpers
+ */
+
+/**
+ * Get a viem Chain object from a chain ID.
+ * Supports mainnet (1) and sepolia (11155111), defaults to the fallback chain for unknown chains.
+ */
+declare function getChainFromID(chainID: bigint, fallback?: Chain): Chain;
+/**
+ * Create viem clients from a private key
+ *
+ * This is a convenience helper for CLI and server applications that have direct
+ * access to a private key. For browser applications using external wallets (MetaMask, etc.),
+ * create the WalletClient directly using viem's createWalletClient with a custom transport.
+ *
+ * @example
+ * // CLI usage with private key
+ * const { walletClient, publicClient } = createClients({
+ *   privateKey: '0x...',
+ *   rpcUrl: 'https://sepolia.infura.io/v3/...',
+ *   chainId: 11155111n
+ * });
+ *
+ * @example
+ * // Browser usage with external wallet (create clients directly)
+ * const walletClient = createWalletClient({
+ *   chain: sepolia,
+ *   transport: custom(window.ethereum!)
+ * });
+ * const publicClient = createPublicClient({
+ *   chain: sepolia,
+ *   transport: custom(window.ethereum!)
+ * });
+ */
+declare function createClients(options: {
+    privateKey: string | Hex;
+    rpcUrl: string;
+    chainId: bigint;
+}): {
+    walletClient: WalletClient;
+    publicClient: PublicClient;
+};
+/**
+ * Ensure hex string has 0x prefix
+ */
+declare function addHexPrefix(value: string): Hex;
+/**
+ * Remove 0x prefix from hex string if present
+ */
+declare function stripHexPrefix(value: string): string;
+
+export { loginToComputeApi as $, type LogsParams as A, isSubscriptionActive as B, type ComputeApiConfig as C, generateNewPrivateKey as D, type UserApiClientOptions as E, type AppInfo as F, type GeneratedKey as G, type AppProfileInfo as H, type AppMetrics as I, type AppInfoResponse as J, BillingApiClient as K, type LogVisibility as L, type BillingApiClientOptions as M, estimateBatchGas as N, executeBatch as O, checkERC7702Delegation as P, type EstimateBatchGasOptions as Q, type ExecuteBatchOptions as R, type SessionInfo as S, type Execution as T, UserApiClient as U, createSiweMessage as V, parseSiweMessage as W, generateNonce as X, isSiweMessageExpired as Y, isSiweMessageNotYetValid as Z, type SiweMessageResult as _, SessionError as a, logoutFromComputeApi as a0, getComputeApiSession as a1, isSessionValid as a2, type LoginResult as a3, type LoginRequest as a4, loginToBillingApi as a5, logoutFromBillingApi as a6, getBillingApiSession as a7, isBillingSessionValid as a8, loginToBothApis as a9, logoutFromBothApis as aa, BillingSessionError as ab, type BillingApiConfig as ac, type BillingSessionInfo as ad, type BillingLoginResult as ae, type BillingLoginRequest as af, getChainFromID as ag, addHexPrefix as ah, stripHexPrefix as ai, type ResourceUsageMonitoring as aj, createClients as ak, type AppRelease as al, type AppReleaseBuild as am, type AppResponse as an, validateFilePath as ao, assertValidFilePath as ap, validateImagePath as aq, validateResourceUsageMonitoring as ar, type DeployParams as as, validateDeployParams as at, type UpgradeParams as au, validateUpgradeParams as av, type SiweMessageParams as b, getBillingEnvironmentConfig as c, getAvailableEnvironments as d, getBuildType as e, isMainnet as f, getEnvironmentConfig as g, validateImageReference as h, isEnvironmentAvailable as i, assertValidImageReference as j, extractAppNameFromImage as k, validateInstanceTypeSKU as l, validatePrivateKeyFormat as m, assertValidPrivateKey as n, validateURL as o, validateXURL as p, validateDescription as q, validateAppID as r, validateLogVisibility as s, sanitizeString as t, sanitizeURL as u, validateAppName as v, sanitizeXURL as w, validateCreateAppParams as x, validateLogsParams as y, type CreateAppParams as z };