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

package/dist/browser.js

@@ -0,0 +1,4924 @@
+// src/client/common/types/index.ts
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  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 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/validation.ts
+import { isAddress } from "viem";
+
+// 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";
+var SUPPORTED_CHAINS = [mainnet, sepolia];
+
+// 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/validation.ts
+function validateAppName(name) {
+  if (!name) {
+    throw new Error("App name cannot be empty");
+  }
+  if (name.includes(" ")) {
+    throw new Error("App name cannot contain spaces");
+  }
+  if (name.length > 50) {
+    throw new Error("App name cannot be longer than 50 characters");
+  }
+}
+function validateImageReference(value) {
+  if (!value) {
+    return "Image reference cannot be empty";
+  }
+  if (!value.includes("/")) {
+    return "Image reference must contain at least one /";
+  }
+  return true;
+}
+function assertValidImageReference(value) {
+  const result = validateImageReference(value);
+  if (result !== true) {
+    throw new Error(result);
+  }
+}
+function extractAppNameFromImage(imageRef) {
+  const parts = imageRef.split("/");
+  let imageName = parts.length > 1 ? parts[parts.length - 1] : imageRef;
+  if (imageName.includes(":")) {
+    imageName = imageName.split(":")[0];
+  }
+  return imageName;
+}
+function validateInstanceTypeSKU(sku, availableTypes) {
+  if (!sku) {
+    throw new Error("Instance type SKU cannot be empty");
+  }
+  for (const it of availableTypes) {
+    if (it.sku === sku) {
+      return sku;
+    }
+  }
+  const validSKUs = availableTypes.map((it) => it.sku).join(", ");
+  throw new Error(`Invalid instance-type value: ${sku} (must be one of: ${validSKUs})`);
+}
+function validatePrivateKeyFormat(key) {
+  const keyWithoutPrefix = stripHexPrefix(key);
+  if (!/^[0-9a-fA-F]{64}$/.test(keyWithoutPrefix)) {
+    return false;
+  }
+  return true;
+}
+function assertValidPrivateKey(key) {
+  if (!key) {
+    throw new Error("Private key is required");
+  }
+  if (!validatePrivateKeyFormat(key)) {
+    throw new Error(
+      "Invalid private key format (must be 64 hex characters, optionally prefixed with 0x)"
+    );
+  }
+}
+function validateURL(rawURL) {
+  if (!rawURL.trim()) {
+    return "URL cannot be empty";
+  }
+  try {
+    const url = new URL(rawURL);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return "URL scheme must be http or https";
+    }
+  } catch {
+    return "Invalid URL format";
+  }
+  return void 0;
+}
+var VALID_X_HOSTS = ["twitter.com", "www.twitter.com", "x.com", "www.x.com"];
+function validateXURL(rawURL) {
+  const urlErr = validateURL(rawURL);
+  if (urlErr) {
+    return urlErr;
+  }
+  try {
+    const url = new URL(rawURL);
+    const host = url.hostname.toLowerCase();
+    if (!VALID_X_HOSTS.includes(host)) {
+      return "URL must be a valid X/Twitter URL (x.com or twitter.com)";
+    }
+    if (!url.pathname || url.pathname === "/") {
+      return "X URL must include a username or profile path";
+    }
+  } catch {
+    return "Invalid X URL format";
+  }
+  return void 0;
+}
+var MAX_DESCRIPTION_LENGTH = 1e3;
+function validateDescription(description) {
+  if (!description.trim()) {
+    return "Description cannot be empty";
+  }
+  if (description.length > MAX_DESCRIPTION_LENGTH) {
+    return `Description cannot exceed ${MAX_DESCRIPTION_LENGTH} characters`;
+  }
+  return void 0;
+}
+var MAX_IMAGE_SIZE = 4 * 1024 * 1024;
+function validateAppID(appID) {
+  if (!appID) {
+    throw new Error("App ID is required");
+  }
+  const normalized = typeof appID === "string" ? addHexPrefix(appID) : appID;
+  if (isAddress(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Invalid app ID: '${appID}' is not a valid address`);
+}
+function validateLogVisibility(logVisibility) {
+  switch (logVisibility) {
+    case "public":
+      return { logRedirect: "always", publicLogs: true };
+    case "private":
+      return { logRedirect: "always", publicLogs: false };
+    case "off":
+      return { logRedirect: "", publicLogs: false };
+    default:
+      throw new Error(
+        `Invalid log-visibility value: ${logVisibility} (must be public, private, or off)`
+      );
+  }
+}
+function hasScheme(rawURL) {
+  return rawURL.startsWith("http://") || rawURL.startsWith("https://");
+}
+function sanitizeString(s) {
+  return s.trim().replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeURL(rawURL) {
+  rawURL = rawURL.trim();
+  if (!hasScheme(rawURL)) {
+    rawURL = "https://" + rawURL;
+  }
+  const err = validateURL(rawURL);
+  if (err) {
+    throw new Error(err);
+  }
+  return rawURL;
+}
+function sanitizeXURL(rawURL) {
+  rawURL = rawURL.trim();
+  if (!rawURL.includes("://") && !rawURL.includes(".")) {
+    const username = rawURL.startsWith("@") ? rawURL.slice(1) : rawURL;
+    rawURL = `https://x.com/${username}`;
+  } else if (!hasScheme(rawURL)) {
+    rawURL = "https://" + rawURL;
+  }
+  rawURL = rawURL.replace(/twitter\.com/g, "x.com");
+  rawURL = rawURL.replace(/www\.x\.com/g, "x.com");
+  const err = validateXURL(rawURL);
+  if (err) {
+    throw new Error(err);
+  }
+  return rawURL;
+}
+function validateCreateAppParams(params) {
+  if (!params.name) {
+    throw new Error("Project name is required");
+  }
+  if (params.name.includes(" ")) {
+    throw new Error("Project name cannot contain spaces");
+  }
+  if (!params.language) {
+    throw new Error("Language is required");
+  }
+}
+function validateLogsParams(params) {
+  if (!params.appID) {
+    throw new Error("App ID is required for viewing logs");
+  }
+  validateAppID(params.appID);
+}
+
+// src/client/common/utils/billing.ts
+function isSubscriptionActive(status) {
+  return status === "active" || status === "trialing";
+}
+
+// src/client/common/auth/generate.ts
+import { generatePrivateKey, privateKeyToAddress } from "viem/accounts";
+function generateNewPrivateKey() {
+  const privateKey = generatePrivateKey();
+  const address = privateKeyToAddress(privateKey);
+  return {
+    privateKey,
+    address
+  };
+}
+
+// src/client/common/utils/userapi.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)"
+]);
+async function calculatePermissionSignature(options) {
+  const { permission, expiry, appControllerAddress, publicClient, walletClient } = options;
+  const digest = await publicClient.readContract({
+    address: appControllerAddress,
+    abi: APP_CONTROLLER_ABI,
+    functionName: "calculateApiPermissionDigestHash",
+    args: [permission, expiry]
+  });
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("WalletClient must have an account attached");
+  }
+  const signature = await walletClient.signMessage({
+    account,
+    message: { raw: digest }
+  });
+  return { signature, digest };
+}
+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/auth/session.ts
+var SessionError = class extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "SessionError";
+  }
+};
+function stripHexPrefix2(hex) {
+  return hex.startsWith("0x") ? hex.slice(2) : hex;
+}
+async function parseErrorResponse(response) {
+  try {
+    const data = await response.json();
+    return data.error || response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+async function loginToComputeApi(config, request) {
+  let response;
+  try {
+    response = await fetch(`${config.baseUrl}/auth/siwe/login`, {
+      method: "POST",
+      credentials: "include",
+      // Include cookies for session management
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        message: request.message,
+        signature: stripHexPrefix2(request.signature)
+      })
+    });
+  } catch (error) {
+    throw new SessionError(
+      `Network error connecting to ${config.baseUrl}: ${error instanceof Error ? error.message : String(error)}`,
+      "NETWORK_ERROR"
+    );
+  }
+  if (!response.ok) {
+    const errorMessage = await parseErrorResponse(response);
+    const status = response.status;
+    if (status === 400) {
+      if (errorMessage.toLowerCase().includes("siwe")) {
+        throw new SessionError(`Invalid SIWE message: ${errorMessage}`, "INVALID_MESSAGE", status);
+      }
+      throw new SessionError(`Bad request: ${errorMessage}`, "INVALID_MESSAGE", status);
+    }
+    if (status === 401) {
+      throw new SessionError(`Invalid signature: ${errorMessage}`, "INVALID_SIGNATURE", status);
+    }
+    throw new SessionError(`Login failed: ${errorMessage}`, "UNKNOWN", status);
+  }
+  const data = await response.json();
+  return {
+    success: data.success,
+    address: data.address
+  };
+}
+async function getComputeApiSession(config) {
+  let response;
+  try {
+    response = await fetch(`${config.baseUrl}/auth/session`, {
+      method: "GET",
+      credentials: "include",
+      // Include cookies for session management
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  } catch {
+    return {
+      authenticated: false
+    };
+  }
+  if (response.status === 401) {
+    return {
+      authenticated: false
+    };
+  }
+  if (!response.ok) {
+    const errorMessage = await parseErrorResponse(response);
+    throw new SessionError(`Failed to get session: ${errorMessage}`, "UNKNOWN", response.status);
+  }
+  const data = await response.json();
+  return {
+    authenticated: data.authenticated,
+    address: data.address,
+    chainId: data.chain_id
+  };
+}
+async function logoutFromComputeApi(config) {
+  let response;
+  try {
+    response = await fetch(`${config.baseUrl}/auth/logout`, {
+      method: "POST",
+      credentials: "include",
+      // Include cookies for session management
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  } catch (error) {
+    throw new SessionError(
+      `Network error connecting to ${config.baseUrl}: ${error instanceof Error ? error.message : String(error)}`,
+      "NETWORK_ERROR"
+    );
+  }
+  if (response.status === 401) {
+    return;
+  }
+  if (!response.ok) {
+    const errorMessage = await parseErrorResponse(response);
+    throw new SessionError(`Logout failed: ${errorMessage}`, "UNKNOWN", response.status);
+  }
+}
+async function isSessionValid(config) {
+  const session = await getComputeApiSession(config);
+  return session.authenticated;
+}
+
+// src/client/common/utils/userapi.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" ? v : void 0;
+}
+function readNumber(obj, key) {
+  const v = obj[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+var MAX_ADDRESS_COUNT = 5;
+var CanViewAppLogsPermission = "0x2fd3f2fe";
+var CanViewSensitiveAppInfoPermission = "0x0e67b22f";
+var CanUpdateAppProfilePermission = "0x036fef61";
+function getDefaultClientId() {
+  const version = true ? "0.2.2-dev" : "0.0.0";
+  return `ecloud-sdk/v${version}`;
+}
+var UserApiClient = class {
+  constructor(config, walletClient, publicClient, options) {
+    this.config = config;
+    this.walletClient = walletClient;
+    this.publicClient = publicClient;
+    this.clientId = options?.clientId || getDefaultClientId();
+    this.useSession = options?.useSession ?? false;
+  }
+  /**
+   * 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 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 app details from UserAPI (includes releases and build/provenance info when available).
+   *
+   * Endpoint: GET /apps/:appAddress
+   */
+  async getApp(appAddress) {
+    const endpoint = `${this.config.userApiServerURL}/apps/${appAddress}`;
+    const res = await this.makeAuthenticatedRequest(endpoint);
+    const raw = await res.json();
+    if (!isJsonObject(raw)) {
+      throw new Error("Unexpected /apps/:id response: expected object");
+    }
+    const id = readString(raw, "id");
+    if (!id) {
+      throw new Error("Unexpected /apps/:id response: missing 'id'");
+    }
+    const releasesRaw = raw.releases;
+    const releases = Array.isArray(releasesRaw) ? releasesRaw.map((r) => transformAppRelease(r)).filter((r) => !!r) : [];
+    return {
+      id,
+      creator: readString(raw, "creator"),
+      contractStatus: readString(raw, "contract_status") ?? readString(raw, "contractStatus"),
+      releases
+    };
+  }
+  /**
+   * 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.app_status || app.App_Status || ""
+    }));
+  }
+  /**
+   * 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)
+   */
+  async uploadAppProfile(appAddress, name, options) {
+    const endpoint = `${this.config.userApiServerURL}/apps/${appAddress}/profile`;
+    const formData = new FormData();
+    formData.append("name", name);
+    if (options?.website) {
+      formData.append("website", options.website);
+    }
+    if (options?.description) {
+      formData.append("description", options.description);
+    }
+    if (options?.xURL) {
+      formData.append("xURL", options.xURL);
+    }
+    if (options?.image) {
+      const fileName = options.image instanceof File ? options.image.name : options.imageName || "image";
+      formData.append("image", options.image, fileName);
+    }
+    const headers = {
+      "x-client-id": this.clientId
+    };
+    if (!this.useSession) {
+      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
+        withCredentials: true
+        // Include cookies for session auth
+      });
+      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.useSession) {
+      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
+        withCredentials: true
+        // Include cookies for session auth
+      });
+      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) {
+    const { signature } = await calculatePermissionSignature({
+      permission,
+      expiry,
+      appControllerAddress: this.config.appControllerAddress,
+      publicClient: this.publicClient,
+      walletClient: this.walletClient
+    });
+    return {
+      Authorization: `Bearer ${stripHexPrefix(signature)}`,
+      "X-eigenx-expiry": expiry.toString()
+    };
+  }
+  // ==========================================================================
+  // SIWE Session Management
+  // ==========================================================================
+  /**
+   * 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 });
+   * ```
+   */
+  async siweLogin(request) {
+    return loginToComputeApi({ baseUrl: this.config.userApiServerURL }, request);
+  }
+  /**
+   * Logout from the compute API
+   *
+   * This destroys the current session and clears the session cookie.
+   *
+   * @example
+   * ```typescript
+   * await client.siweLogout();
+   * ```
+   */
+  async siweLogout() {
+    return logoutFromComputeApi({ baseUrl: this.config.userApiServerURL });
+  }
+  /**
+   * 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}`);
+   * }
+   * ```
+   */
+  async getSiweSession() {
+    return getComputeApiSession({ baseUrl: this.config.userApiServerURL });
+  }
+};
+function transformAppReleaseBuild(raw) {
+  if (!isJsonObject(raw)) return void 0;
+  const depsRaw = raw.dependencies;
+  const deps = isJsonObject(depsRaw) ? Object.fromEntries(
+    Object.entries(depsRaw).flatMap(([digest, depRaw]) => {
+      const parsed = transformAppReleaseBuild(depRaw);
+      return parsed ? [[digest, parsed]] : [];
+    })
+  ) : void 0;
+  return {
+    buildId: readString(raw, "build_id") ?? readString(raw, "buildId"),
+    billingAddress: readString(raw, "billing_address") ?? readString(raw, "billingAddress"),
+    repoUrl: readString(raw, "repo_url") ?? readString(raw, "repoUrl"),
+    gitRef: readString(raw, "git_ref") ?? readString(raw, "gitRef"),
+    status: readString(raw, "status"),
+    buildType: readString(raw, "build_type") ?? readString(raw, "buildType"),
+    imageName: readString(raw, "image_name") ?? readString(raw, "imageName"),
+    imageDigest: readString(raw, "image_digest") ?? readString(raw, "imageDigest"),
+    imageUrl: readString(raw, "image_url") ?? readString(raw, "imageUrl"),
+    provenanceJson: raw.provenance_json ?? raw.provenanceJson,
+    provenanceSignature: readString(raw, "provenance_signature") ?? readString(raw, "provenanceSignature"),
+    createdAt: readString(raw, "created_at") ?? readString(raw, "createdAt"),
+    updatedAt: readString(raw, "updated_at") ?? readString(raw, "updatedAt"),
+    errorMessage: readString(raw, "error_message") ?? readString(raw, "errorMessage"),
+    dependencies: deps
+  };
+}
+function transformAppRelease(raw) {
+  if (!isJsonObject(raw)) return void 0;
+  return {
+    appId: readString(raw, "appId") ?? readString(raw, "app_id"),
+    rmsReleaseId: readString(raw, "rmsReleaseId") ?? readString(raw, "rms_release_id"),
+    imageDigest: readString(raw, "imageDigest") ?? readString(raw, "image_digest"),
+    registryUrl: readString(raw, "registryUrl") ?? readString(raw, "registry_url"),
+    publicEnv: readString(raw, "publicEnv") ?? readString(raw, "public_env"),
+    encryptedEnv: readString(raw, "encryptedEnv") ?? readString(raw, "encrypted_env"),
+    upgradeByTime: readNumber(raw, "upgradeByTime") ?? readNumber(raw, "upgrade_by_time"),
+    createdAt: readString(raw, "createdAt") ?? readString(raw, "created_at"),
+    createdAtBlock: readString(raw, "createdAtBlock") ?? readString(raw, "created_at_block"),
+    build: raw.build ? transformAppReleaseBuild(raw.build) : void 0
+  };
+}
+
+// src/client/common/utils/billingapi.ts
+import axios2 from "axios";
+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 axios2({
+        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/utils/buildapi.ts
+import axios3 from "axios";
+var MAX_RETRIES = 5;
+var INITIAL_BACKOFF_MS = 1e3;
+var MAX_BACKOFF_MS = 3e4;
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getRetryDelay(res, attempt) {
+  const retryAfter = res.headers["retry-after"];
+  if (retryAfter) {
+    const seconds = parseInt(retryAfter, 10);
+    if (!isNaN(seconds)) {
+      return Math.min(seconds * 1e3, MAX_BACKOFF_MS);
+    }
+  }
+  return Math.min(INITIAL_BACKOFF_MS * Math.pow(2, attempt), MAX_BACKOFF_MS);
+}
+async function requestWithRetry(config) {
+  let lastResponse;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    const res = await axios3({ ...config, validateStatus: () => true });
+    lastResponse = res;
+    if (res.status !== 429) {
+      return res;
+    }
+    if (attempt < MAX_RETRIES) {
+      const delay = getRetryDelay(res, attempt);
+      await sleep(delay);
+    }
+  }
+  return lastResponse;
+}
+var BuildApiClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.clientId = options.clientId;
+    this.walletClient = options.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 submitBuild(payload) {
+    return this.authenticatedJsonRequest("/builds", "POST", payload);
+  }
+  async getBuild(buildId) {
+    return this.publicJsonRequest(`/builds/${encodeURIComponent(buildId)}`);
+  }
+  async getBuildByDigest(digest) {
+    return this.publicJsonRequest(`/builds/image/${encodeURIComponent(digest)}`);
+  }
+  async verify(identifier) {
+    return this.publicJsonRequest(`/builds/verify/${encodeURIComponent(identifier)}`);
+  }
+  async getLogs(buildId) {
+    return this.authenticatedTextRequest(`/builds/${encodeURIComponent(buildId)}/logs`);
+  }
+  async listBuilds(params) {
+    const res = await requestWithRetry({
+      url: `${this.baseUrl}/builds`,
+      method: "GET",
+      params,
+      headers: this.clientId ? { "x-client-id": this.clientId } : void 0,
+      timeout: 6e4
+    });
+    if (res.status < 200 || res.status >= 300) throw buildApiHttpError(res);
+    return res.data;
+  }
+  async publicJsonRequest(path) {
+    const res = await requestWithRetry({
+      url: `${this.baseUrl}${path}`,
+      method: "GET",
+      headers: this.clientId ? { "x-client-id": this.clientId } : void 0,
+      timeout: 6e4
+    });
+    if (res.status < 200 || res.status >= 300) throw buildApiHttpError(res);
+    return res.data;
+  }
+  async authenticatedJsonRequest(path, method, body) {
+    if (!this.walletClient?.account) {
+      throw new Error("WalletClient with account required for authenticated requests");
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.clientId) headers["x-client-id"] = this.clientId;
+    const expiry = BigInt(Math.floor(Date.now() / 1e3) + 60);
+    const { signature } = await calculateBillingAuthSignature({
+      walletClient: this.walletClient,
+      product: "compute",
+      expiry
+    });
+    headers.Authorization = `Bearer ${signature}`;
+    headers["X-eigenx-expiry"] = expiry.toString();
+    headers["X-Account"] = this.address;
+    const res = await requestWithRetry({
+      url: `${this.baseUrl}${path}`,
+      method,
+      headers,
+      data: body,
+      timeout: 6e4
+    });
+    if (res.status < 200 || res.status >= 300) throw buildApiHttpError(res);
+    return res.data;
+  }
+  async authenticatedTextRequest(path) {
+    if (!this.walletClient?.account) {
+      throw new Error("WalletClient with account required for authenticated requests");
+    }
+    const headers = {};
+    if (this.clientId) headers["x-client-id"] = this.clientId;
+    const expiry = BigInt(Math.floor(Date.now() / 1e3) + 60);
+    const { signature } = await calculateBillingAuthSignature({
+      walletClient: this.walletClient,
+      product: "compute",
+      expiry
+    });
+    headers.Authorization = `Bearer ${signature}`;
+    headers["X-eigenx-expiry"] = expiry.toString();
+    headers["X-Account"] = this.address;
+    const res = await requestWithRetry({
+      url: `${this.baseUrl}${path}`,
+      method: "GET",
+      headers,
+      timeout: 6e4,
+      responseType: "text"
+    });
+    if (res.status < 200 || res.status >= 300) throw buildApiHttpError(res);
+    return typeof res.data === "string" ? res.data : JSON.stringify(res.data);
+  }
+};
+function buildApiHttpError(res) {
+  const status = res.status;
+  const body = typeof res.data === "string" ? res.data : res.data ? JSON.stringify(res.data) : "";
+  const url = res.config?.url ? ` ${res.config.url}` : "";
+  return new Error(`BuildAPI request failed: ${status}${url} - ${body || "Unknown error"}`);
+}
+
+// src/client/common/contract/eip7702.ts
+import { encodeFunctionData, encodeAbiParameters, decodeErrorResult } from "viem";
+
+// src/client/common/abis/ERC7702Delegator.json
+var ERC7702Delegator_default = [
+  {
+    type: "constructor",
+    inputs: [
+      {
+        name: "_delegationManager",
+        type: "address",
+        internalType: "contractIDelegationManager"
+      },
+      {
+        name: "_entryPoint",
+        type: "address",
+        internalType: "contractIEntryPoint"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "receive",
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "DOMAIN_VERSION",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "NAME",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "PACKED_USER_OP_TYPEHASH",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "VERSION",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "addDeposit",
+    inputs: [],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "delegationManager",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contractIDelegationManager"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "disableDelegation",
+    inputs: [
+      {
+        name: "_delegation",
+        type: "tuple",
+        internalType: "structDelegation",
+        components: [
+          {
+            name: "delegate",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "delegator",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "authority",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "caveats",
+            type: "tuple[]",
+            internalType: "structCaveat[]",
+            components: [
+              {
+                name: "enforcer",
+                type: "address",
+                internalType: "address"
+              },
+              {
+                name: "terms",
+                type: "bytes",
+                internalType: "bytes"
+              },
+              {
+                name: "args",
+                type: "bytes",
+                internalType: "bytes"
+              }
+            ]
+          },
+          {
+            name: "salt",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "signature",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "eip712Domain",
+    inputs: [],
+    outputs: [
+      {
+        name: "fields",
+        type: "bytes1",
+        internalType: "bytes1"
+      },
+      {
+        name: "name",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "version",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "chainId",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "verifyingContract",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "salt",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "extensions",
+        type: "uint256[]",
+        internalType: "uint256[]"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "enableDelegation",
+    inputs: [
+      {
+        name: "_delegation",
+        type: "tuple",
+        internalType: "structDelegation",
+        components: [
+          {
+            name: "delegate",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "delegator",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "authority",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "caveats",
+            type: "tuple[]",
+            internalType: "structCaveat[]",
+            components: [
+              {
+                name: "enforcer",
+                type: "address",
+                internalType: "address"
+              },
+              {
+                name: "terms",
+                type: "bytes",
+                internalType: "bytes"
+              },
+              {
+                name: "args",
+                type: "bytes",
+                internalType: "bytes"
+              }
+            ]
+          },
+          {
+            name: "salt",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "signature",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "entryPoint",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contractIEntryPoint"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "execute",
+    inputs: [
+      {
+        name: "_execution",
+        type: "tuple",
+        internalType: "structExecution",
+        components: [
+          {
+            name: "target",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "value",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "callData",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "execute",
+    inputs: [
+      {
+        name: "_mode",
+        type: "bytes32",
+        internalType: "ModeCode"
+      },
+      {
+        name: "_executionCalldata",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "executeFromExecutor",
+    inputs: [
+      {
+        name: "_mode",
+        type: "bytes32",
+        internalType: "ModeCode"
+      },
+      {
+        name: "_executionCalldata",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [
+      {
+        name: "returnData_",
+        type: "bytes[]",
+        internalType: "bytes[]"
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "getDeposit",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getDomainHash",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getNonce",
+    inputs: [
+      {
+        name: "_key",
+        type: "uint192",
+        internalType: "uint192"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getNonce",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getPackedUserOperationHash",
+    inputs: [
+      {
+        name: "_userOp",
+        type: "tuple",
+        internalType: "structPackedUserOperation",
+        components: [
+          {
+            name: "sender",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "nonce",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "initCode",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "callData",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "accountGasLimits",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "preVerificationGas",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "gasFees",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "paymasterAndData",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "signature",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getPackedUserOperationTypedDataHash",
+    inputs: [
+      {
+        name: "_userOp",
+        type: "tuple",
+        internalType: "structPackedUserOperation",
+        components: [
+          {
+            name: "sender",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "nonce",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "initCode",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "callData",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "accountGasLimits",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "preVerificationGas",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "gasFees",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "paymasterAndData",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "signature",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isDelegationDisabled",
+    inputs: [
+      {
+        name: "_delegationHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isValidSignature",
+    inputs: [
+      {
+        name: "_hash",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "_signature",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [
+      {
+        name: "magicValue_",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "onERC1155BatchReceived",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "uint256[]",
+        internalType: "uint256[]"
+      },
+      {
+        name: "",
+        type: "uint256[]",
+        internalType: "uint256[]"
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "onERC1155Received",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "onERC721Received",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "redeemDelegations",
+    inputs: [
+      {
+        name: "_permissionContexts",
+        type: "bytes[]",
+        internalType: "bytes[]"
+      },
+      {
+        name: "_modes",
+        type: "bytes32[]",
+        internalType: "ModeCode[]"
+      },
+      {
+        name: "_executionCallDatas",
+        type: "bytes[]",
+        internalType: "bytes[]"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "supportsExecutionMode",
+    inputs: [
+      {
+        name: "_mode",
+        type: "bytes32",
+        internalType: "ModeCode"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "supportsInterface",
+    inputs: [
+      {
+        name: "_interfaceId",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "validateUserOp",
+    inputs: [
+      {
+        name: "_userOp",
+        type: "tuple",
+        internalType: "structPackedUserOperation",
+        components: [
+          {
+            name: "sender",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "nonce",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "initCode",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "callData",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "accountGasLimits",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "preVerificationGas",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "gasFees",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "paymasterAndData",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "signature",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      },
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "_missingAccountFunds",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "validationData_",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "withdrawDeposit",
+    inputs: [
+      {
+        name: "_withdrawAddress",
+        type: "address",
+        internalType: "addresspayable"
+      },
+      {
+        name: "_withdrawAmount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "EIP712DomainChanged",
+    inputs: [],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SentPrefund",
+    inputs: [
+      {
+        name: "sender",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "success",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetDelegationManager",
+    inputs: [
+      {
+        name: "newDelegationManager",
+        type: "address",
+        indexed: true,
+        internalType: "contractIDelegationManager"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetEntryPoint",
+    inputs: [
+      {
+        name: "entryPoint",
+        type: "address",
+        indexed: true,
+        internalType: "contractIEntryPoint"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "TryExecuteUnsuccessful",
+    inputs: [
+      {
+        name: "batchExecutionindex",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "result",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "ECDSAInvalidSignature",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "ECDSAInvalidSignatureLength",
+    inputs: [
+      {
+        name: "length",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ECDSAInvalidSignatureS",
+    inputs: [
+      {
+        name: "s",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ExecutionFailed",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidEIP712NameLength",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidEIP712VersionLength",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidShortString",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NotDelegationManager",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NotEntryPoint",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NotEntryPointOrSelf",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NotSelf",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "StringTooLong",
+    inputs: [
+      {
+        name: "str",
+        type: "string",
+        internalType: "string"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "UnauthorizedCallContext",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "UnsupportedCallType",
+    inputs: [
+      {
+        name: "callType",
+        type: "bytes1",
+        internalType: "CallType"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "UnsupportedExecType",
+    inputs: [
+      {
+        name: "execType",
+        type: "bytes1",
+        internalType: "ExecType"
+      }
+    ]
+  }
+];
+
+// src/client/common/contract/eip7702.ts
+var EXECUTE_BATCH_MODE = "0x0100000000000000000000000000000000000000000000000000000000000000";
+var GAS_LIMIT_BUFFER_PERCENTAGE = 20n;
+var GAS_PRICE_BUFFER_PERCENTAGE = 100n;
+function encodeExecuteBatchData(executions) {
+  const encodedExecutions = encodeAbiParameters(
+    [
+      {
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "callData", type: "bytes" }
+        ]
+      }
+    ],
+    [executions]
+  );
+  return encodeFunctionData({
+    abi: ERC7702Delegator_default,
+    functionName: "execute",
+    args: [EXECUTE_BATCH_MODE, encodedExecutions]
+  });
+}
+async function estimateBatchGas(options) {
+  const { publicClient, account, executions } = options;
+  const executeBatchData = encodeExecuteBatchData(executions);
+  const [gasTipCap, block, estimatedGas] = await Promise.all([
+    publicClient.estimateMaxPriorityFeePerGas(),
+    publicClient.getBlock(),
+    publicClient.estimateGas({
+      account,
+      to: account,
+      data: executeBatchData
+    })
+  ]);
+  const baseFee = block.baseFeePerGas ?? 0n;
+  const maxFeePerGas = (baseFee + gasTipCap) * (100n + GAS_PRICE_BUFFER_PERCENTAGE) / 100n;
+  const gasLimit = estimatedGas * (100n + GAS_LIMIT_BUFFER_PERCENTAGE) / 100n;
+  const maxCostWei = gasLimit * maxFeePerGas;
+  return {
+    gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas: gasTipCap,
+    maxCostWei,
+    maxCostEth: formatETH(maxCostWei)
+  };
+}
+async function checkERC7702Delegation(publicClient, account, delegatorAddress) {
+  const code = await publicClient.getCode({ address: account });
+  if (!code) {
+    return false;
+  }
+  const expectedCode = `0xef0100${delegatorAddress.slice(2)}`;
+  return code.toLowerCase() === expectedCode.toLowerCase();
+}
+async function executeBatch(options, logger = noopLogger) {
+  const { walletClient, publicClient, environmentConfig, executions, pendingMessage, gas } = options;
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("Wallet client must have an account");
+  }
+  const chain = walletClient.chain;
+  if (!chain) {
+    throw new Error("Wallet client must have a chain");
+  }
+  const executeBatchData = encodeExecuteBatchData(executions);
+  const isDelegated2 = await checkERC7702Delegation(
+    publicClient,
+    account.address,
+    environmentConfig.erc7702DelegatorAddress
+  );
+  let authorizationList = [];
+  if (!isDelegated2) {
+    const transactionNonce = await publicClient.getTransactionCount({
+      address: account.address,
+      blockTag: "pending"
+    });
+    const chainId = await publicClient.getChainId();
+    const authorizationNonce = transactionNonce + 1;
+    logger.debug("Using wallet client signing for EIP-7702 authorization");
+    const signedAuthorization = await walletClient.signAuthorization({
+      account: account.address,
+      contractAddress: environmentConfig.erc7702DelegatorAddress,
+      chainId,
+      nonce: Number(authorizationNonce)
+    });
+    authorizationList = [signedAuthorization];
+  }
+  if (pendingMessage) {
+    logger.info(pendingMessage);
+  }
+  const txRequest = {
+    account: walletClient.account,
+    chain,
+    to: account.address,
+    data: executeBatchData,
+    value: 0n
+  };
+  if (authorizationList.length > 0) {
+    txRequest.authorizationList = authorizationList;
+  }
+  if (gas?.maxFeePerGas) {
+    txRequest.maxFeePerGas = gas.maxFeePerGas;
+  }
+  if (gas?.maxPriorityFeePerGas) {
+    txRequest.maxPriorityFeePerGas = gas.maxPriorityFeePerGas;
+  }
+  const hash = await walletClient.sendTransaction(txRequest);
+  logger.info(`Transaction sent: ${hash}`);
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  if (receipt.status === "reverted") {
+    let revertReason = "Unknown reason";
+    try {
+      await publicClient.call({
+        to: account.address,
+        data: executeBatchData,
+        account: account.address
+      });
+    } catch (callError) {
+      if (callError.data) {
+        try {
+          const decoded = decodeErrorResult({
+            abi: ERC7702Delegator_default,
+            data: callError.data
+          });
+          revertReason = `${decoded.errorName}: ${JSON.stringify(decoded.args)}`;
+        } catch {
+          revertReason = callError.message || "Unknown reason";
+        }
+      } else {
+        revertReason = callError.message || "Unknown reason";
+      }
+    }
+    throw new Error(`Transaction reverted: ${hash}. Reason: ${revertReason}`);
+  }
+  return hash;
+}
+
+// src/client/common/contract/caller.ts
+import { encodeFunctionData as encodeFunctionData2, decodeErrorResult as decodeErrorResult2, bytesToHex } from "viem";
+
+// src/client/common/abis/AppController.json
+var AppController_default = [
+  {
+    type: "constructor",
+    inputs: [
+      {
+        name: "_version",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "_permissionController",
+        type: "address",
+        internalType: "contractIPermissionController"
+      },
+      {
+        name: "_releaseManager",
+        type: "address",
+        internalType: "contractIReleaseManager"
+      },
+      {
+        name: "_computeAVSRegistrar",
+        type: "address",
+        internalType: "contractIComputeAVSRegistrar"
+      },
+      {
+        name: "_computeOperator",
+        type: "address",
+        internalType: "contractIComputeOperator"
+      },
+      {
+        name: "_appBeacon",
+        type: "address",
+        internalType: "contractIBeacon"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "API_PERMISSION_TYPEHASH",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "appBeacon",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contractIBeacon"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "calculateApiPermissionDigestHash",
+    inputs: [
+      {
+        name: "permission",
+        type: "bytes4",
+        internalType: "bytes4"
+      },
+      {
+        name: "expiry",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "calculateAppId",
+    inputs: [
+      {
+        name: "deployer",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "salt",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "computeAVSRegistrar",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contractIComputeAVSRegistrar"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "computeOperator",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contractIComputeOperator"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "createApp",
+    inputs: [
+      {
+        name: "salt",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "release",
+        type: "tuple",
+        internalType: "structIAppController.Release",
+        components: [
+          {
+            name: "rmsRelease",
+            type: "tuple",
+            internalType: "structIReleaseManagerTypes.Release",
+            components: [
+              {
+                name: "artifacts",
+                type: "tuple[]",
+                internalType: "structIReleaseManagerTypes.Artifact[]",
+                components: [
+                  {
+                    name: "digest",
+                    type: "bytes32",
+                    internalType: "bytes32"
+                  },
+                  {
+                    name: "registry",
+                    type: "string",
+                    internalType: "string"
+                  }
+                ]
+              },
+              {
+                name: "upgradeByTime",
+                type: "uint32",
+                internalType: "uint32"
+              }
+            ]
+          },
+          {
+            name: "publicEnv",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "encryptedEnv",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "domainSeparator",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getActiveAppCount",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAppCreator",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAppLatestReleaseBlockNumber",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAppOperatorSetId",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAppStatus",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint8",
+        internalType: "enumIAppController.AppStatus"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getApps",
+    inputs: [
+      {
+        name: "offset",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "limit",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "apps",
+        type: "address[]",
+        internalType: "contractIApp[]"
+      },
+      {
+        name: "appConfigsMem",
+        type: "tuple[]",
+        internalType: "structIAppController.AppConfig[]",
+        components: [
+          {
+            name: "creator",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "operatorSetId",
+            type: "uint32",
+            internalType: "uint32"
+          },
+          {
+            name: "latestReleaseBlockNumber",
+            type: "uint32",
+            internalType: "uint32"
+          },
+          {
+            name: "status",
+            type: "uint8",
+            internalType: "enumIAppController.AppStatus"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAppsByCreator",
+    inputs: [
+      {
+        name: "creator",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "offset",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "limit",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "apps",
+        type: "address[]",
+        internalType: "contractIApp[]"
+      },
+      {
+        name: "appConfigsMem",
+        type: "tuple[]",
+        internalType: "structIAppController.AppConfig[]",
+        components: [
+          {
+            name: "creator",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "operatorSetId",
+            type: "uint32",
+            internalType: "uint32"
+          },
+          {
+            name: "latestReleaseBlockNumber",
+            type: "uint32",
+            internalType: "uint32"
+          },
+          {
+            name: "status",
+            type: "uint8",
+            internalType: "enumIAppController.AppStatus"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAppsByDeveloper",
+    inputs: [
+      {
+        name: "developer",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "offset",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "limit",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "apps",
+        type: "address[]",
+        internalType: "contractIApp[]"
+      },
+      {
+        name: "appConfigsMem",
+        type: "tuple[]",
+        internalType: "structIAppController.AppConfig[]",
+        components: [
+          {
+            name: "creator",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "operatorSetId",
+            type: "uint32",
+            internalType: "uint32"
+          },
+          {
+            name: "latestReleaseBlockNumber",
+            type: "uint32",
+            internalType: "uint32"
+          },
+          {
+            name: "status",
+            type: "uint8",
+            internalType: "enumIAppController.AppStatus"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getMaxActiveAppsPerUser",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "globalActiveAppCount",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "initialize",
+    inputs: [
+      {
+        name: "admin",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "maxGlobalActiveApps",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "permissionController",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contractIPermissionController"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "releaseManager",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contractIReleaseManager"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setMaxActiveAppsPerUser",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "limit",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setMaxGlobalActiveApps",
+    inputs: [
+      {
+        name: "limit",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "startApp",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "stopApp",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "suspend",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "apps",
+        type: "address[]",
+        internalType: "contractIApp[]"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "terminateApp",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "terminateAppByAdmin",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "updateAppMetadataURI",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      },
+      {
+        name: "metadataURI",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "upgradeApp",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        internalType: "contractIApp"
+      },
+      {
+        name: "release",
+        type: "tuple",
+        internalType: "structIAppController.Release",
+        components: [
+          {
+            name: "rmsRelease",
+            type: "tuple",
+            internalType: "structIReleaseManagerTypes.Release",
+            components: [
+              {
+                name: "artifacts",
+                type: "tuple[]",
+                internalType: "structIReleaseManagerTypes.Artifact[]",
+                components: [
+                  {
+                    name: "digest",
+                    type: "bytes32",
+                    internalType: "bytes32"
+                  },
+                  {
+                    name: "registry",
+                    type: "string",
+                    internalType: "string"
+                  }
+                ]
+              },
+              {
+                name: "upgradeByTime",
+                type: "uint32",
+                internalType: "uint32"
+              }
+            ]
+          },
+          {
+            name: "publicEnv",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "encryptedEnv",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "version",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "AppCreated",
+    inputs: [
+      {
+        name: "creator",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "app",
+        type: "address",
+        indexed: true,
+        internalType: "contractIApp"
+      },
+      {
+        name: "operatorSetId",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AppMetadataURIUpdated",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        indexed: true,
+        internalType: "contractIApp"
+      },
+      {
+        name: "metadataURI",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AppStarted",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        indexed: true,
+        internalType: "contractIApp"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AppStopped",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        indexed: true,
+        internalType: "contractIApp"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AppSuspended",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        indexed: true,
+        internalType: "contractIApp"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AppTerminated",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        indexed: true,
+        internalType: "contractIApp"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AppTerminatedByAdmin",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        indexed: true,
+        internalType: "contractIApp"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AppUpgraded",
+    inputs: [
+      {
+        name: "app",
+        type: "address",
+        indexed: true,
+        internalType: "contractIApp"
+      },
+      {
+        name: "rmsReleaseId",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "release",
+        type: "tuple",
+        indexed: false,
+        internalType: "structIAppController.Release",
+        components: [
+          {
+            name: "rmsRelease",
+            type: "tuple",
+            internalType: "structIReleaseManagerTypes.Release",
+            components: [
+              {
+                name: "artifacts",
+                type: "tuple[]",
+                internalType: "structIReleaseManagerTypes.Artifact[]",
+                components: [
+                  {
+                    name: "digest",
+                    type: "bytes32",
+                    internalType: "bytes32"
+                  },
+                  {
+                    name: "registry",
+                    type: "string",
+                    internalType: "string"
+                  }
+                ]
+              },
+              {
+                name: "upgradeByTime",
+                type: "uint32",
+                internalType: "uint32"
+              }
+            ]
+          },
+          {
+            name: "publicEnv",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "encryptedEnv",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "GlobalMaxActiveAppsSet",
+    inputs: [
+      {
+        name: "limit",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Initialized",
+    inputs: [
+      {
+        name: "version",
+        type: "uint8",
+        indexed: false,
+        internalType: "uint8"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "MaxActiveAppsSet",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "limit",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "AccountHasActiveApps",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AppAlreadyExists",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AppDoesNotExist",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "GlobalMaxActiveAppsExceeded",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidAppStatus",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidPermissions",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidReleaseMetadataURI",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidShortString",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidSignature",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "MaxActiveAppsExceeded",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "MoreThanOneArtifact",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "SignatureExpired",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "StringTooLong",
+    inputs: [
+      {
+        name: "str",
+        type: "string",
+        internalType: "string"
+      }
+    ]
+  }
+];
+
+// src/client/common/abis/PermissionController.json
+var PermissionController_default = [
+  {
+    type: "function",
+    name: "acceptAdmin",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "addPendingAdmin",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "admin",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "canCall",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "caller",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "target",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "selector",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getAdmins",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address[]",
+        internalType: "address[]"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAppointeePermissions",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "appointee",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address[]",
+        internalType: "address[]"
+      },
+      {
+        name: "",
+        type: "bytes4[]",
+        internalType: "bytes4[]"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getAppointees",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "target",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "selector",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address[]",
+        internalType: "address[]"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getPendingAdmins",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address[]",
+        internalType: "address[]"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isAdmin",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "caller",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isPendingAdmin",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "pendingAdmin",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "removeAdmin",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "admin",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "removeAppointee",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "appointee",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "target",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "selector",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "removePendingAdmin",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "admin",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setAppointee",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "appointee",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "target",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "selector",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "version",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "AdminRemoved",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "admin",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AdminSet",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "admin",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AppointeeRemoved",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "appointee",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "target",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "selector",
+        type: "bytes4",
+        indexed: false,
+        internalType: "bytes4"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AppointeeSet",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "appointee",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "target",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "selector",
+        type: "bytes4",
+        indexed: false,
+        internalType: "bytes4"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PendingAdminAdded",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "admin",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PendingAdminRemoved",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "admin",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "AdminAlreadyPending",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AdminAlreadySet",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AdminNotPending",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AdminNotSet",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AppointeeAlreadySet",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AppointeeNotSet",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "CannotHaveZeroAdmins",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NotAdmin",
+    inputs: []
+  }
+];
+
+// src/client/common/contract/caller.ts
+function formatETH(wei) {
+  const eth = Number(wei) / 1e18;
+  const costStr = eth.toFixed(6);
+  const trimmed = costStr.replace(/\.?0+$/, "");
+  if (trimmed === "0" && wei > 0n) {
+    return "<0.000001";
+  }
+  return trimmed;
+}
+async function estimateTransactionGas(options) {
+  const { publicClient, from, to, data, value = 0n } = options;
+  const fees = await publicClient.estimateFeesPerGas();
+  const gasLimit = await publicClient.estimateGas({
+    account: from,
+    to,
+    data,
+    value
+  });
+  const maxFeePerGas = fees.maxFeePerGas;
+  const maxPriorityFeePerGas = fees.maxPriorityFeePerGas;
+  const maxCostWei = gasLimit * maxFeePerGas;
+  const maxCostEth = formatETH(maxCostWei);
+  return {
+    gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    maxCostWei,
+    maxCostEth
+  };
+}
+async function calculateAppID(options) {
+  const { publicClient, environmentConfig, ownerAddress, salt } = options;
+  const saltHexString = bytesToHex(salt).slice(2);
+  const paddedSaltHex = saltHexString.padStart(64, "0");
+  const saltHex = `0x${paddedSaltHex}`;
+  const appID = await publicClient.readContract({
+    address: environmentConfig.appControllerAddress,
+    abi: AppController_default,
+    functionName: "calculateAppId",
+    args: [ownerAddress, saltHex]
+  });
+  return appID;
+}
+async function prepareDeployBatch(options, logger = noopLogger) {
+  const { walletClient, publicClient, environmentConfig, salt, release, publicLogs } = options;
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("WalletClient must have an account attached");
+  }
+  logger.info("Calculating app ID...");
+  const appId = await calculateAppID({
+    publicClient,
+    environmentConfig,
+    ownerAddress: account.address,
+    salt
+  });
+  logger.debug(`App ID calculated: ${appId}`);
+  logger.debug(`This address will be used for acceptAdmin call`);
+  const saltHexString = bytesToHex(salt).slice(2);
+  const paddedSaltHex = saltHexString.padStart(64, "0");
+  const saltHex = `0x${paddedSaltHex}`;
+  const releaseForViem = {
+    rmsRelease: {
+      artifacts: release.rmsRelease.artifacts.map((artifact) => ({
+        digest: `0x${bytesToHex(artifact.digest).slice(2).padStart(64, "0")}`,
+        registry: artifact.registry
+      })),
+      upgradeByTime: release.rmsRelease.upgradeByTime
+    },
+    publicEnv: bytesToHex(release.publicEnv),
+    encryptedEnv: bytesToHex(release.encryptedEnv)
+  };
+  const createData = encodeFunctionData2({
+    abi: AppController_default,
+    functionName: "createApp",
+    args: [saltHex, releaseForViem]
+  });
+  const acceptAdminData = encodeFunctionData2({
+    abi: PermissionController_default,
+    functionName: "acceptAdmin",
+    args: [appId]
+  });
+  const executions = [
+    {
+      target: environmentConfig.appControllerAddress,
+      value: 0n,
+      callData: createData
+    },
+    {
+      target: environmentConfig.permissionControllerAddress,
+      value: 0n,
+      callData: acceptAdminData
+    }
+  ];
+  if (publicLogs) {
+    const anyoneCanViewLogsData = encodeFunctionData2({
+      abi: PermissionController_default,
+      functionName: "setAppointee",
+      args: [
+        appId,
+        "0x493219d9949348178af1f58740655951a8cd110c",
+        // AnyoneCanCallAddress
+        "0x57ee1fb74c1087e26446abc4fb87fd8f07c43d8d",
+        // ApiPermissionsTarget
+        "0x2fd3f2fe"
+        // CanViewAppLogsPermission
+      ]
+    });
+    executions.push({
+      target: environmentConfig.permissionControllerAddress,
+      value: 0n,
+      callData: anyoneCanViewLogsData
+    });
+  }
+  return {
+    appId,
+    salt,
+    executions,
+    walletClient,
+    publicClient,
+    environmentConfig
+  };
+}
+async function executeDeployBatch(data, context, gas, logger = noopLogger) {
+  const pendingMessage = "Deploying new app...";
+  const txHash = await executeBatch(
+    {
+      walletClient: context.walletClient,
+      publicClient: context.publicClient,
+      environmentConfig: context.environmentConfig,
+      executions: data.executions,
+      pendingMessage,
+      gas
+    },
+    logger
+  );
+  return { appId: data.appId, txHash };
+}
+async function deployApp(options, logger = noopLogger) {
+  const prepared = await prepareDeployBatch(options, logger);
+  const data = {
+    appId: prepared.appId,
+    salt: prepared.salt,
+    executions: prepared.executions
+  };
+  const context = {
+    walletClient: prepared.walletClient,
+    publicClient: prepared.publicClient,
+    environmentConfig: prepared.environmentConfig
+  };
+  return executeDeployBatch(data, context, options.gas, logger);
+}
+function supportsEIP7702(walletClient) {
+  const account = walletClient.account;
+  if (!account) return false;
+  return account.type === "local";
+}
+async function executeDeploySequential(options, logger = noopLogger) {
+  const { walletClient, publicClient, environmentConfig, data, publicLogs, onProgress } = options;
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("WalletClient must have an account attached");
+  }
+  const chain = getChainFromID(environmentConfig.chainID);
+  const txHashes = {
+    createApp: "0x",
+    acceptAdmin: "0x"
+  };
+  logger.info("Step 1/3: Creating app...");
+  onProgress?.("createApp");
+  const createAppExecution = data.executions[0];
+  const createAppHash = await walletClient.sendTransaction({
+    account,
+    to: createAppExecution.target,
+    data: createAppExecution.callData,
+    value: createAppExecution.value,
+    chain
+  });
+  logger.info(`createApp transaction sent: ${createAppHash}`);
+  const createAppReceipt = await publicClient.waitForTransactionReceipt({ hash: createAppHash });
+  if (createAppReceipt.status === "reverted") {
+    throw new Error(`createApp transaction reverted: ${createAppHash}`);
+  }
+  txHashes.createApp = createAppHash;
+  logger.info(`createApp confirmed in block ${createAppReceipt.blockNumber}`);
+  logger.info("Step 2/3: Accepting admin role...");
+  onProgress?.("acceptAdmin", createAppHash);
+  const acceptAdminExecution = data.executions[1];
+  const acceptAdminHash = await walletClient.sendTransaction({
+    account,
+    to: acceptAdminExecution.target,
+    data: acceptAdminExecution.callData,
+    value: acceptAdminExecution.value,
+    chain
+  });
+  logger.info(`acceptAdmin transaction sent: ${acceptAdminHash}`);
+  const acceptAdminReceipt = await publicClient.waitForTransactionReceipt({
+    hash: acceptAdminHash
+  });
+  if (acceptAdminReceipt.status === "reverted") {
+    throw new Error(`acceptAdmin transaction reverted: ${acceptAdminHash}`);
+  }
+  txHashes.acceptAdmin = acceptAdminHash;
+  logger.info(`acceptAdmin confirmed in block ${acceptAdminReceipt.blockNumber}`);
+  if (publicLogs && data.executions.length > 2) {
+    logger.info("Step 3/3: Setting public logs permission...");
+    onProgress?.("setPublicLogs", acceptAdminHash);
+    const setAppointeeExecution = data.executions[2];
+    const setAppointeeHash = await walletClient.sendTransaction({
+      account,
+      to: setAppointeeExecution.target,
+      data: setAppointeeExecution.callData,
+      value: setAppointeeExecution.value,
+      chain
+    });
+    logger.info(`setAppointee transaction sent: ${setAppointeeHash}`);
+    const setAppointeeReceipt = await publicClient.waitForTransactionReceipt({
+      hash: setAppointeeHash
+    });
+    if (setAppointeeReceipt.status === "reverted") {
+      throw new Error(`setAppointee transaction reverted: ${setAppointeeHash}`);
+    }
+    txHashes.setPublicLogs = setAppointeeHash;
+    logger.info(`setAppointee confirmed in block ${setAppointeeReceipt.blockNumber}`);
+  }
+  onProgress?.("complete", txHashes.setPublicLogs || txHashes.acceptAdmin);
+  logger.info(`Deployment complete! App ID: ${data.appId}`);
+  return {
+    appId: data.appId,
+    txHashes
+  };
+}
+async function supportsEIP5792(walletClient) {
+  try {
+    if (typeof walletClient.getCapabilities !== "function") {
+      return false;
+    }
+    const account = walletClient.account;
+    if (!account) return false;
+    const capabilities = await walletClient.getCapabilities({
+      account: account.address
+    });
+    return capabilities !== null && capabilities !== void 0 && Object.keys(capabilities).length > 0;
+  } catch {
+    return false;
+  }
+}
+async function executeDeployBatched(options, logger = noopLogger) {
+  const { walletClient, environmentConfig, data, publicLogs, onProgress } = options;
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("WalletClient must have an account attached");
+  }
+  const chain = getChainFromID(environmentConfig.chainID);
+  const calls = data.executions.map(
+    (execution) => ({
+      to: execution.target,
+      data: execution.callData,
+      value: execution.value
+    })
+  );
+  const filteredCalls = publicLogs ? calls : calls.slice(0, 2);
+  logger.info(`Deploying with EIP-5792 sendCalls (${filteredCalls.length} calls)...`);
+  onProgress?.("createApp");
+  try {
+    const { id: batchId } = await walletClient.sendCalls({
+      account,
+      chain,
+      calls: filteredCalls,
+      forceAtomic: true
+    });
+    logger.info(`Batch submitted with ID: ${batchId}`);
+    onProgress?.("acceptAdmin");
+    let status;
+    let attempts = 0;
+    const maxAttempts = 120;
+    while (attempts < maxAttempts) {
+      try {
+        status = await walletClient.getCallsStatus({ id: batchId });
+        if (status.status === "success" || status.status === "confirmed") {
+          logger.info(`Batch confirmed with ${status.receipts?.length || 0} receipts`);
+          break;
+        }
+        if (status.status === "failed" || status.status === "reverted") {
+          throw new Error(`Batch transaction failed: ${status.status}`);
+        }
+      } catch (statusError) {
+        if (statusError.message?.includes("not supported")) {
+          logger.warn("getCallsStatus not supported, waiting for chain confirmation...");
+          await new Promise((resolve) => setTimeout(resolve, 15e3));
+          break;
+        }
+        throw statusError;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 5e3));
+      attempts++;
+    }
+    if (attempts >= maxAttempts) {
+      throw new Error("Timeout waiting for batch confirmation");
+    }
+    if (publicLogs) {
+      onProgress?.("setPublicLogs");
+    }
+    onProgress?.("complete");
+    const receipts = (status?.receipts || []).map((r) => ({
+      transactionHash: r.transactionHash || r.hash
+    }));
+    logger.info(`Deployment complete! App ID: ${data.appId}`);
+    return {
+      appId: data.appId,
+      batchId,
+      receipts
+    };
+  } catch (error) {
+    if (error.message?.includes("not supported") || error.message?.includes("wallet_sendCalls") || error.code === -32601) {
+      throw new Error("EIP5792_NOT_SUPPORTED");
+    }
+    throw error;
+  }
+}
+async function prepareUpgradeBatch(options) {
+  const {
+    walletClient,
+    publicClient,
+    environmentConfig,
+    appID,
+    release,
+    publicLogs,
+    needsPermissionChange
+  } = options;
+  const releaseForViem = {
+    rmsRelease: {
+      artifacts: release.rmsRelease.artifacts.map((artifact) => ({
+        digest: `0x${bytesToHex(artifact.digest).slice(2).padStart(64, "0")}`,
+        registry: artifact.registry
+      })),
+      upgradeByTime: release.rmsRelease.upgradeByTime
+    },
+    publicEnv: bytesToHex(release.publicEnv),
+    encryptedEnv: bytesToHex(release.encryptedEnv)
+  };
+  const upgradeData = encodeFunctionData2({
+    abi: AppController_default,
+    functionName: "upgradeApp",
+    args: [appID, releaseForViem]
+  });
+  const executions = [
+    {
+      target: environmentConfig.appControllerAddress,
+      value: 0n,
+      callData: upgradeData
+    }
+  ];
+  if (needsPermissionChange) {
+    if (publicLogs) {
+      const addLogsData = encodeFunctionData2({
+        abi: PermissionController_default,
+        functionName: "setAppointee",
+        args: [
+          appID,
+          "0x493219d9949348178af1f58740655951a8cd110c",
+          // AnyoneCanCallAddress
+          "0x57ee1fb74c1087e26446abc4fb87fd8f07c43d8d",
+          // ApiPermissionsTarget
+          "0x2fd3f2fe"
+          // CanViewAppLogsPermission
+        ]
+      });
+      executions.push({
+        target: environmentConfig.permissionControllerAddress,
+        value: 0n,
+        callData: addLogsData
+      });
+    } else {
+      const removeLogsData = encodeFunctionData2({
+        abi: PermissionController_default,
+        functionName: "removeAppointee",
+        args: [
+          appID,
+          "0x493219d9949348178af1f58740655951a8cd110c",
+          // AnyoneCanCallAddress
+          "0x57ee1fb74c1087e26446abc4fb87fd8f07c43d8d",
+          // ApiPermissionsTarget
+          "0x2fd3f2fe"
+          // CanViewAppLogsPermission
+        ]
+      });
+      executions.push({
+        target: environmentConfig.permissionControllerAddress,
+        value: 0n,
+        callData: removeLogsData
+      });
+    }
+  }
+  return {
+    appId: appID,
+    executions,
+    walletClient,
+    publicClient,
+    environmentConfig
+  };
+}
+async function executeUpgradeBatch(data, context, gas, logger = noopLogger) {
+  const pendingMessage = `Upgrading app ${data.appId}...`;
+  const txHash = await executeBatch(
+    {
+      walletClient: context.walletClient,
+      publicClient: context.publicClient,
+      environmentConfig: context.environmentConfig,
+      executions: data.executions,
+      pendingMessage,
+      gas
+    },
+    logger
+  );
+  return txHash;
+}
+async function upgradeApp(options, logger = noopLogger) {
+  const prepared = await prepareUpgradeBatch(options);
+  const data = {
+    appId: prepared.appId,
+    executions: prepared.executions
+  };
+  const context = {
+    walletClient: prepared.walletClient,
+    publicClient: prepared.publicClient,
+    environmentConfig: prepared.environmentConfig
+  };
+  return executeUpgradeBatch(data, context, options.gas, logger);
+}
+async function sendAndWaitForTransaction(options, logger = noopLogger) {
+  const {
+    walletClient,
+    publicClient,
+    environmentConfig,
+    to,
+    data,
+    value = 0n,
+    pendingMessage,
+    txDescription,
+    gas
+  } = options;
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("WalletClient must have an account attached");
+  }
+  const chain = getChainFromID(environmentConfig.chainID);
+  if (pendingMessage) {
+    logger.info(`
+${pendingMessage}`);
+  }
+  const hash = await walletClient.sendTransaction({
+    account,
+    to,
+    data,
+    value,
+    ...gas?.maxFeePerGas && { maxFeePerGas: gas.maxFeePerGas },
+    ...gas?.maxPriorityFeePerGas && {
+      maxPriorityFeePerGas: gas.maxPriorityFeePerGas
+    },
+    chain
+  });
+  logger.info(`Transaction sent: ${hash}`);
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  if (receipt.status === "reverted") {
+    let revertReason = "Unknown reason";
+    try {
+      await publicClient.call({
+        to,
+        data,
+        account: account.address
+      });
+    } catch (callError) {
+      if (callError.data) {
+        try {
+          const decoded = decodeErrorResult2({
+            abi: AppController_default,
+            data: callError.data
+          });
+          const formattedError = formatAppControllerError(decoded);
+          revertReason = formattedError.message;
+        } catch {
+          revertReason = callError.message || "Unknown reason";
+        }
+      } else {
+        revertReason = callError.message || "Unknown reason";
+      }
+    }
+    logger.error(`${txDescription} transaction (hash: ${hash}) reverted: ${revertReason}`);
+    throw new Error(`${txDescription} transaction (hash: ${hash}) reverted: ${revertReason}`);
+  }
+  return hash;
+}
+function formatAppControllerError(decoded) {
+  const errorName = decoded.errorName;
+  switch (errorName) {
+    case "MaxActiveAppsExceeded":
+      return new Error(
+        "you have reached your app deployment limit. To request access or increase your limit, please visit https://onboarding.eigencloud.xyz/ or reach out to the Eigen team"
+      );
+    case "GlobalMaxActiveAppsExceeded":
+      return new Error(
+        "the platform has reached the maximum number of active apps. please try again later"
+      );
+    case "InvalidPermissions":
+      return new Error("you don't have permission to perform this operation");
+    case "AppAlreadyExists":
+      return new Error("an app with this owner and salt already exists");
+    case "AppDoesNotExist":
+      return new Error("the specified app does not exist");
+    case "InvalidAppStatus":
+      return new Error("the app is in an invalid state for this operation");
+    case "MoreThanOneArtifact":
+      return new Error("only one artifact is allowed per release");
+    case "InvalidSignature":
+      return new Error("invalid signature provided");
+    case "SignatureExpired":
+      return new Error("the provided signature has expired");
+    case "InvalidReleaseMetadataURI":
+      return new Error("invalid release metadata URI provided");
+    case "InvalidShortString":
+      return new Error("invalid short string format");
+    default:
+      return new Error(`contract error: ${errorName}`);
+  }
+}
+async function getActiveAppCount(publicClient, environmentConfig, user) {
+  const count = await publicClient.readContract({
+    address: environmentConfig.appControllerAddress,
+    abi: AppController_default,
+    functionName: "getActiveAppCount",
+    args: [user]
+  });
+  return Number(count);
+}
+async function getMaxActiveAppsPerUser(publicClient, environmentConfig, user) {
+  const quota = await publicClient.readContract({
+    address: environmentConfig.appControllerAddress,
+    abi: AppController_default,
+    functionName: "getMaxActiveAppsPerUser",
+    args: [user]
+  });
+  return Number(quota);
+}
+async function getAppsByCreator(publicClient, environmentConfig, creator, offset, limit) {
+  const result = await publicClient.readContract({
+    address: environmentConfig.appControllerAddress,
+    abi: AppController_default,
+    functionName: "getAppsByCreator",
+    args: [creator, offset, limit]
+  });
+  return {
+    apps: result[0],
+    appConfigs: result[1]
+  };
+}
+async function getAppsByDeveloper(publicClient, environmentConfig, developer, offset, limit) {
+  const result = await publicClient.readContract({
+    address: environmentConfig.appControllerAddress,
+    abi: AppController_default,
+    functionName: "getAppsByDeveloper",
+    args: [developer, offset, limit]
+  });
+  return {
+    apps: result[0],
+    appConfigs: result[1]
+  };
+}
+async function getAllAppsByDeveloper(publicClient, env, developer, pageSize = 100n) {
+  let offset = 0n;
+  const allApps = [];
+  const allConfigs = [];
+  while (true) {
+    const { apps, appConfigs } = await getAppsByDeveloper(
+      publicClient,
+      env,
+      developer,
+      offset,
+      pageSize
+    );
+    if (apps.length === 0) break;
+    allApps.push(...apps);
+    allConfigs.push(...appConfigs);
+    if (apps.length < Number(pageSize)) break;
+    offset += pageSize;
+  }
+  return {
+    apps: allApps,
+    appConfigs: allConfigs
+  };
+}
+async function suspend(options, logger = noopLogger) {
+  const { walletClient, publicClient, environmentConfig, account, apps } = options;
+  const suspendData = encodeFunctionData2({
+    abi: AppController_default,
+    functionName: "suspend",
+    args: [account, apps]
+  });
+  const pendingMessage = `Suspending ${apps.length} app(s)...`;
+  return sendAndWaitForTransaction(
+    {
+      walletClient,
+      publicClient,
+      environmentConfig,
+      to: environmentConfig.appControllerAddress,
+      data: suspendData,
+      pendingMessage,
+      txDescription: "Suspend"
+    },
+    logger
+  );
+}
+async function isDelegated(options) {
+  const { publicClient, environmentConfig, address } = options;
+  return checkERC7702Delegation(
+    publicClient,
+    address,
+    environmentConfig.erc7702DelegatorAddress
+  );
+}
+async function undelegate(options, logger = noopLogger) {
+  const { walletClient, publicClient, environmentConfig } = options;
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("WalletClient must have an account attached");
+  }
+  const chain = getChainFromID(environmentConfig.chainID);
+  const transactionNonce = await publicClient.getTransactionCount({
+    address: account.address,
+    blockTag: "pending"
+  });
+  const chainId = await publicClient.getChainId();
+  const authorizationNonce = BigInt(transactionNonce) + 1n;
+  logger.debug("Signing undelegate authorization");
+  const signedAuthorization = await walletClient.signAuthorization({
+    contractAddress: "0x0000000000000000000000000000000000000000",
+    chainId,
+    nonce: Number(authorizationNonce),
+    account
+  });
+  const authorizationList = [signedAuthorization];
+  const hash = await walletClient.sendTransaction({
+    account,
+    to: account.address,
+    // Send to self
+    data: "0x",
+    // Empty data
+    value: 0n,
+    authorizationList,
+    chain
+  });
+  logger.info(`Transaction sent: ${hash}`);
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  if (receipt.status === "reverted") {
+    logger.error(`Undelegate transaction (hash: ${hash}) reverted`);
+    throw new Error(`Undelegate transaction (hash: ${hash}) reverted`);
+  }
+  return hash;
+}
+
+// src/client/common/contract/encoders.ts
+import { parseAbi as parseAbi2, encodeFunctionData as encodeFunctionData3 } from "viem";
+var CONTROLLER_ABI = parseAbi2([
+  "function startApp(address appId)",
+  "function stopApp(address appId)",
+  "function terminateApp(address appId)"
+]);
+function encodeStartAppData(appId) {
+  return encodeFunctionData3({
+    abi: CONTROLLER_ABI,
+    functionName: "startApp",
+    args: [appId]
+  });
+}
+function encodeStopAppData(appId) {
+  return encodeFunctionData3({
+    abi: CONTROLLER_ABI,
+    functionName: "stopApp",
+    args: [appId]
+  });
+}
+function encodeTerminateAppData(appId) {
+  return encodeFunctionData3({
+    abi: CONTROLLER_ABI,
+    functionName: "terminateApp",
+    args: [appId]
+  });
+}
+
+// src/client/common/auth/siwe.ts
+import { SiweMessage, generateNonce as siweGenerateNonce } from "siwe";
+var generateNonce = siweGenerateNonce;
+function createSiweMessage(params) {
+  const now = /* @__PURE__ */ new Date();
+  const nonce = params.nonce || generateNonce();
+  const issuedAt = params.issuedAt || now;
+  const expirationTime = params.expirationTime || new Date(now.getTime() + 24 * 60 * 60 * 1e3);
+  const siweMessage = new SiweMessage({
+    domain: params.domain,
+    address: params.address,
+    statement: params.statement,
+    uri: params.uri,
+    version: "1",
+    chainId: params.chainId,
+    nonce,
+    issuedAt: issuedAt.toISOString(),
+    expirationTime: expirationTime.toISOString(),
+    notBefore: params.notBefore?.toISOString(),
+    requestId: params.requestId,
+    resources: params.resources
+  });
+  return {
+    message: siweMessage.prepareMessage(),
+    params: {
+      address: params.address,
+      chainId: params.chainId,
+      domain: params.domain,
+      uri: params.uri,
+      nonce,
+      issuedAt,
+      statement: params.statement,
+      expirationTime,
+      notBefore: params.notBefore,
+      requestId: params.requestId,
+      resources: params.resources
+    }
+  };
+}
+function parseSiweMessage(message) {
+  try {
+    const siweMessage = new SiweMessage(message);
+    return {
+      address: siweMessage.address,
+      chainId: siweMessage.chainId,
+      domain: siweMessage.domain,
+      uri: siweMessage.uri,
+      nonce: siweMessage.nonce,
+      statement: siweMessage.statement,
+      issuedAt: siweMessage.issuedAt ? new Date(siweMessage.issuedAt) : void 0,
+      expirationTime: siweMessage.expirationTime ? new Date(siweMessage.expirationTime) : void 0,
+      notBefore: siweMessage.notBefore ? new Date(siweMessage.notBefore) : void 0,
+      requestId: siweMessage.requestId,
+      resources: siweMessage.resources
+    };
+  } catch {
+    return null;
+  }
+}
+function isSiweMessageExpired(params) {
+  if (!params.expirationTime) return false;
+  return /* @__PURE__ */ new Date() > params.expirationTime;
+}
+function isSiweMessageNotYetValid(params) {
+  if (!params.notBefore) return false;
+  return /* @__PURE__ */ new Date() < params.notBefore;
+}
+
+// src/client/common/hooks/useComputeSession.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+function useComputeSession(config) {
+  const {
+    baseUrl,
+    refreshInterval = 6e4,
+    // 1 minute default
+    checkOnMount = true,
+    onSessionExpired,
+    onSessionRefreshed,
+    onError
+  } = config;
+  const [session, setSession] = useState(null);
+  const [isLoading, setIsLoading] = useState(checkOnMount);
+  const [error, setError] = useState(null);
+  const wasAuthenticatedRef = useRef(false);
+  const isMountedRef = useRef(true);
+  const refreshIntervalRef = useRef(null);
+  const apiConfig = { baseUrl };
+  const checkSession = useCallback(async () => {
+    try {
+      const sessionInfo = await getComputeApiSession(apiConfig);
+      if (!isMountedRef.current) {
+        return sessionInfo;
+      }
+      setSession(sessionInfo);
+      setError(null);
+      if (wasAuthenticatedRef.current && !sessionInfo.authenticated) {
+        onSessionExpired?.();
+      }
+      wasAuthenticatedRef.current = sessionInfo.authenticated;
+      if (sessionInfo.authenticated) {
+        onSessionRefreshed?.(sessionInfo);
+      }
+      return sessionInfo;
+    } catch (err) {
+      if (!isMountedRef.current) {
+        throw err;
+      }
+      const sessionError = err instanceof SessionError ? err : new SessionError(`Failed to check session: ${String(err)}`, "UNKNOWN");
+      setError(sessionError);
+      onError?.(sessionError);
+      const fallbackSession = { authenticated: false };
+      setSession(fallbackSession);
+      return fallbackSession;
+    }
+  }, [baseUrl, onSessionExpired, onSessionRefreshed, onError]);
+  const refresh = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      return await checkSession();
+    } finally {
+      if (isMountedRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [checkSession]);
+  const login = useCallback(
+    async (params, signMessage) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        let domain = params.domain;
+        let uri = params.uri;
+        if (typeof window !== "undefined") {
+          domain = domain || window.location.host;
+          uri = uri || window.location.origin;
+        }
+        if (!domain || !uri) {
+          throw new SessionError(
+            "domain and uri are required when not in browser environment",
+            "INVALID_MESSAGE"
+          );
+        }
+        const siweMessage = createSiweMessage({
+          ...params,
+          domain,
+          uri,
+          statement: params.statement || "Sign in to EigenCloud Compute API"
+        });
+        const signature = await signMessage({ message: siweMessage.message });
+        await loginToComputeApi(apiConfig, {
+          message: siweMessage.message,
+          signature
+        });
+        const sessionInfo = await checkSession();
+        if (!isMountedRef.current) {
+          return sessionInfo;
+        }
+        wasAuthenticatedRef.current = sessionInfo.authenticated;
+        return sessionInfo;
+      } catch (err) {
+        if (!isMountedRef.current) {
+          throw err;
+        }
+        const sessionError = err instanceof SessionError ? err : new SessionError(`Login failed: ${String(err)}`, "UNKNOWN");
+        setError(sessionError);
+        onError?.(sessionError);
+        throw sessionError;
+      } finally {
+        if (isMountedRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [baseUrl, checkSession, onError]
+  );
+  const logout = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      await logoutFromComputeApi(apiConfig);
+      if (!isMountedRef.current) {
+        return;
+      }
+      const newSession = { authenticated: false };
+      setSession(newSession);
+      wasAuthenticatedRef.current = false;
+    } catch (err) {
+      if (!isMountedRef.current) {
+        throw err;
+      }
+      const sessionError = err instanceof SessionError ? err : new SessionError(`Logout failed: ${String(err)}`, "UNKNOWN");
+      setError(sessionError);
+      onError?.(sessionError);
+      setSession({ authenticated: false });
+      wasAuthenticatedRef.current = false;
+    } finally {
+      if (isMountedRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [baseUrl, onError]);
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  useEffect(() => {
+    isMountedRef.current = true;
+    if (checkOnMount) {
+      checkSession().finally(() => {
+        if (isMountedRef.current) {
+          setIsLoading(false);
+        }
+      });
+    }
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, [checkOnMount, checkSession]);
+  useEffect(() => {
+    if (refreshInterval <= 0) {
+      return;
+    }
+    if (refreshIntervalRef.current) {
+      clearInterval(refreshIntervalRef.current);
+    }
+    refreshIntervalRef.current = setInterval(() => {
+      if (wasAuthenticatedRef.current) {
+        checkSession();
+      }
+    }, refreshInterval);
+    return () => {
+      if (refreshIntervalRef.current) {
+        clearInterval(refreshIntervalRef.current);
+        refreshIntervalRef.current = null;
+      }
+    };
+  }, [refreshInterval, checkSession]);
+  return {
+    session,
+    isLoading,
+    error,
+    isAuthenticated: session?.authenticated ?? false,
+    login,
+    logout,
+    refresh,
+    clearError
+  };
+}
+
+// src/client/common/encryption/kms.ts
+import { importSPKI, CompactEncrypt } from "jose";
+function getAppProtectedHeaders(appID) {
+  return {
+    "x-eigenx-app-id": appID
+  };
+}
+async function encryptRSAOAEPAndAES256GCM(encryptionKeyPEM, plaintext, protectedHeaders) {
+  const pemString = typeof encryptionKeyPEM === "string" ? encryptionKeyPEM : encryptionKeyPEM.toString("utf-8");
+  const publicKey = await importSPKI(pemString, "RSA-OAEP-256", {
+    extractable: true
+  });
+  const header = {
+    alg: "RSA-OAEP-256",
+    // Key encryption algorithm (SHA-256)
+    enc: "A256GCM",
+    // Content encryption algorithm
+    ...protectedHeaders || {}
+    // Add custom protected headers
+  };
+  const plaintextBytes = new Uint8Array(plaintext);
+  const jwe = await new CompactEncrypt(plaintextBytes).setProtectedHeader(header).encrypt(publicKey);
+  return jwe;
+}
+
+// keys/mainnet-alpha/prod/kms-encryption-public-key.pem
+var kms_encryption_public_key_default = "-----BEGIN PUBLIC KEY-----\nMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0kHU86k17ofCIGcJKDcf\nAFurFhSLeWmOL0bwWLCeVnTPG0MMHtJOq+woE0XXSWw6lzm+jzavBBTwKde1dgal\nAp91vULAZFMUpiUdd2dNUVtvU89qW0Pgf1Eu5FDj7BkY/SnyECbWJM4ga0BmpiGy\nnQwLNN9mMGhjVoVLn2zwEGZ7JzS9Nz11EZKO/k/9DcO6LaoIFmKuvVf3jl6lvZg8\naeA0LoZXjkycHlRUt/kfKwZnhakUaYHP1ksV7ZNmolS5GYDTSKGB2KPPNR1s4/Xu\nu8zeEFC8HuGRU8XuuBeaAunitnGhbNVREUNJGff6HZOGB6CIFNXjbQETeZ3p5uro\n0v+hd1QqQYBv7+DEaMCmGnJNGAyIMr2mn4vr7wGsIj0HonlSHmQ8rmdUhL2ocNTc\nLhKgZiZmBuDpSbFW/r53R2G7CHcqaqGeUBnT54QCH4zsYKw0/4dOtwFxQpTyBf9/\n+k+KaWEJYKkx9d9OzKGyAvzrTDVOFoajddiJ6LPvRlMdOUQr3hl4IAC0/nh9lhHq\nD0R+i5WAU96TkdAe7B7iTGH2D22k0KUPR6Q9W3aF353SLxQAMPNrgG4QQufAdRJn\nAF+8ntun5TkTqjTWRSwAsUJZ1z4wb96DympWJbDi0OciJRZ3Fz3j9+amC43yCHGg\naaEMjdt35ewbztUSc04F10MCAwEAAQ==\n-----END PUBLIC KEY-----";
+
+// keys/mainnet-alpha/prod/kms-signing-public-key.pem
+var kms_signing_public_key_default = "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfxbhXJjH4D0DH/iW5/rK1HzWS+f9\nEyooZTrCYjCfezuOEmRuOWNaZLvwXN8SdzrvjWA7gSvOS85hLzp4grANRQ==\n-----END PUBLIC KEY-----";
+
+// keys/sepolia/dev/kms-encryption-public-key.pem
+var kms_encryption_public_key_default2 = "-----BEGIN PUBLIC KEY-----\nMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAr/vqttU6aXX35HtsXavU\n5teysunDzZB3HyaFM4qcuRnqj+70KxqLOwZsERN5SwZ/56Jm8T2ds1CcXsQCMUMw\n+MPlsF6KMGfzghLtYHONwvKLnn+U9y886aAay6W8a0A7O7YCZehNYD3kQnCXjOIc\nMj6v8AEvMw+w/lNabjRXnwSBMKVIGp/cSL0hGwt8fGoC3TsxQN9opzvU1Z4rAw9K\na119l6dlPnqezDva378TCaXDjqKe/jSZOI1CcYpaSK2SJ+95Wbvte5j3lXbg1oT2\n0rXeJUHEJ68QxMtJplfw0Sg+Ek4CUJ2c/kbdg0u7sIIO5wcB4WHL/Lfbw2XPmcBI\nt0r0EC575D3iHF/aI01Ms2IRA0GDeHnNcr5FJLWJljTjNLEt4tFITrXwBe1Ealm3\nNCxamApl5bBSwQ72Gb5fiQFwB8Fl2/XG3wfGTFInFEvWE4c/H8dtu1wHTsyEFZcG\nB47IkD5GBSZq90Hd9xuZva55dxGpqUVrEJO88SqHGP9Oa+HLTYdEe5AR5Hitw4Mu\ndk1cCH+X5OqY9dfpdoCNbKAM0N2SJvNAnDTU2JKGYheXrnDslXR6atBmU5gDkH+W\nQVryDYl9xbwWIACMQsAQjrrtKw5xqJ4V89+06FN/wyEVF7KWAcJ4AhKiVnCvLqzb\nBbISc+gOkRsefhCDJVPEKDkCAwEAAQ==\n-----END PUBLIC KEY-----";
+
+// keys/sepolia/dev/kms-signing-public-key.pem
+var kms_signing_public_key_default2 = "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEb2Q88/cxdic2xi4jS2V0dtYHjLwq\n4wVFBFmaY8TTXoMXNggKEdU6PuE8EovocVKMpw3SIlaM27z9uxksNVL2xw==\n-----END PUBLIC KEY-----\n";
+
+// keys/sepolia/prod/kms-encryption-public-key.pem
+var kms_encryption_public_key_default3 = "-----BEGIN PUBLIC KEY-----\nMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEApDvk8pAivkgtiC5li5MP\nxMTJDduTeorBl18ynrooTxp2BwwgPwXfXbJaCA0qRubvc0aO2uh2VDrPM27CqMLH\no2S9YLtpLii4A1Nl7SE/MdWKWdG6v94xNGpc2YyPP7yWtHfqOkgDWp8sokl3Uq/9\nMS0pjUaI7RyS5boCTy8Qw90BxGMpucjOmqm+luw4EdPWZCrgriUR2bbGRRgAmrT1\nK4ou4IgPp799r120hwHbCWxnOvLdQdpiv2507b900xS/3yZahhnHCAn66146LU/f\nBrRpQKSM0qSpktXrrc9MH/ru2VLR5cGLp89ZcZMQA9cRGglWM5XWVY3Ti2TPJ6Kd\nAn1d7qNkGJaSdVa3x3HkOf6c6HeTyqis5/L/6L+PFhUsTRbmKg1FtwD+3xxdyf7h\nabFxryE9rv+WatHL6r6z5ztV0znJ/Fpfs5A45FWA6pfb28fA59RGpi/DQ8RxgdCH\nnZRNvdz8dTgRaXSPgkfGXBcCFqb/QhFmad7XbWDthGzfhbPOxNPtiaGRQ1Dr/Pgq\nn0ugdLbRQLmDOAFgaQcnr0U4y1TUlWJnvoZMETkVN7gmITtXA4F324ALT7Rd+Lgk\nHikW5vG+NjAEwXfPsK0YzT+VbHd7o1lbru9UxiDlN03XVEkz/oRQi47CvSTo3FSr\n5dB4lz8kov3UUcNJfQFZolMCAwEAAQ==\n-----END PUBLIC KEY-----";
+
+// keys/sepolia/prod/kms-signing-public-key.pem
+var kms_signing_public_key_default3 = "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsk6ZdmmvBqFfKHs+1cYjIemRGN7h\n1NatIEitFRyx+3q8wmTJ9LknTE1FwWBLcCNTseJDti8Rh+SaVxfGOyJuuA==\n-----END PUBLIC KEY-----";
+
+// src/client/common/utils/keys.ts
+var KEYS = {
+  "mainnet-alpha": {
+    prod: {
+      encryption: kms_encryption_public_key_default,
+      signing: kms_signing_public_key_default
+    }
+  },
+  sepolia: {
+    dev: {
+      encryption: kms_encryption_public_key_default2,
+      signing: kms_signing_public_key_default2
+    },
+    prod: {
+      encryption: kms_encryption_public_key_default3,
+      signing: kms_signing_public_key_default3
+    }
+  }
+};
+function getKMSKeysForEnvironment(environment, build = "prod") {
+  const envKeys = KEYS[environment];
+  if (!envKeys) {
+    throw new Error(`No keys found for environment: ${environment}`);
+  }
+  const buildKeys = envKeys[build];
+  if (!buildKeys) {
+    throw new Error(`No keys found for environment: ${environment}, build: ${build}`);
+  }
+  return {
+    encryptionKey: Buffer.from(buildKeys.encryption),
+    signingKey: Buffer.from(buildKeys.signing)
+  };
+}
+export {
+  BillingApiClient,
+  BuildApiClient,
+  SessionError,
+  UserApiClient,
+  addHexPrefix,
+  assertValidImageReference,
+  assertValidPrivateKey,
+  calculateAppID,
+  checkERC7702Delegation,
+  createSiweMessage,
+  deployApp,
+  encodeStartAppData,
+  encodeStopAppData,
+  encodeTerminateAppData,
+  encryptRSAOAEPAndAES256GCM,
+  estimateBatchGas,
+  estimateTransactionGas,
+  executeBatch,
+  executeDeployBatch,
+  executeDeployBatched,
+  executeDeploySequential,
+  executeUpgradeBatch,
+  extractAppNameFromImage,
+  formatETH,
+  generateNewPrivateKey,
+  generateNonce,
+  getActiveAppCount,
+  getAllAppsByDeveloper,
+  getAppProtectedHeaders,
+  getAppsByCreator,
+  getAppsByDeveloper,
+  getAvailableEnvironments,
+  getBillingEnvironmentConfig,
+  getBuildType,
+  getChainFromID,
+  getComputeApiSession,
+  getEnvironmentConfig,
+  getKMSKeysForEnvironment,
+  getMaxActiveAppsPerUser,
+  isDelegated,
+  isEnvironmentAvailable,
+  isMainnet,
+  isSessionValid,
+  isSiweMessageExpired,
+  isSiweMessageNotYetValid,
+  isSubscriptionActive,
+  loginToComputeApi,
+  logoutFromComputeApi,
+  noopLogger,
+  parseSiweMessage,
+  prepareDeployBatch,
+  prepareUpgradeBatch,
+  sanitizeString,
+  sanitizeURL,
+  sanitizeXURL,
+  sendAndWaitForTransaction,
+  stripHexPrefix,
+  supportsEIP5792,
+  supportsEIP7702,
+  suspend,
+  undelegate,
+  upgradeApp,
+  useComputeSession,
+  validateAppID,
+  validateAppName,
+  validateCreateAppParams,
+  validateDescription,
+  validateImageReference,
+  validateInstanceTypeSKU,
+  validateLogVisibility,
+  validateLogsParams,
+  validatePrivateKeyFormat,
+  validateURL,
+  validateXURL
+};
+//# sourceMappingURL=browser.js.map