@phala/cloud 0.1.0 → 0.1.1-beta.2

package/dist/index.mjs

@@ -321,9 +321,178 @@ function createClient(config = {}) {
   return new Client(config);
 }
 
-// src/types/kms_info.ts
+// src/actions/get_current_user.ts
 import { z as z2 } from "zod";
 
+// src/utils/validate-parameters.ts
+function validateActionParameters(parameters) {
+  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
+    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
+      throw new Error("Invalid schema: must be a Zod schema object, false, or undefined");
+    }
+  }
+}
+function safeValidateActionParameters(parameters) {
+  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
+    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
+      return {
+        success: false,
+        error: {
+          name: "ZodError",
+          message: "Invalid schema: must be a Zod schema object, false, or undefined",
+          issues: [
+            {
+              code: "invalid_type",
+              expected: "object",
+              received: typeof parameters.schema,
+              path: ["schema"],
+              message: "Invalid schema: must be a Zod schema object, false, or undefined"
+            }
+          ]
+        }
+      };
+    }
+  }
+  return void 0;
+}
+
+// src/utils/define-action.ts
+function defineSimpleAction(schema, fn) {
+  function action(client, parameters) {
+    return _actionImpl(client, parameters);
+  }
+  async function _actionImpl(client, parameters) {
+    validateActionParameters(parameters);
+    const response = await fn(client);
+    if (parameters?.schema === false) {
+      return response;
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.parse(response);
+  }
+  function safeAction(client, parameters) {
+    return _safeActionImpl(client, parameters);
+  }
+  async function _safeActionImpl(client, parameters) {
+    const parameterValidationError = safeValidateActionParameters(parameters);
+    if (parameterValidationError) {
+      return parameterValidationError;
+    }
+    const httpResult = await (async () => {
+      try {
+        const data = await fn(client);
+        return { success: true, data };
+      } catch (error) {
+        if (error && typeof error === "object" && "isRequestError" in error) {
+          return { success: false, error };
+        }
+        if (error && typeof error === "object" && "issues" in error) {
+          return { success: false, error };
+        }
+        return {
+          success: false,
+          error: {
+            name: "Error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    })();
+    if (!httpResult.success) {
+      return httpResult;
+    }
+    if (parameters?.schema === false) {
+      return { success: true, data: httpResult.data };
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.safeParse(httpResult.data);
+  }
+  return {
+    action,
+    safeAction
+  };
+}
+function defineAction(schema, fn) {
+  function action(client, ...args) {
+    const [params, parameters] = args;
+    return _actionImpl(client, params, parameters);
+  }
+  async function _actionImpl(client, params, parameters) {
+    validateActionParameters(parameters);
+    const response = await fn(client, params);
+    if (parameters?.schema === false) {
+      return response;
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.parse(response);
+  }
+  function safeAction(client, ...args) {
+    const [params, parameters] = args;
+    return _safeActionImpl(client, params, parameters);
+  }
+  async function _safeActionImpl(client, params, parameters) {
+    const parameterValidationError = safeValidateActionParameters(parameters);
+    if (parameterValidationError) {
+      return parameterValidationError;
+    }
+    const httpResult = await (async () => {
+      try {
+        const data = await fn(client, params);
+        return { success: true, data };
+      } catch (error) {
+        if (error && typeof error === "object" && "isRequestError" in error) {
+          return { success: false, error };
+        }
+        if (error && typeof error === "object" && "issues" in error) {
+          return { success: false, error };
+        }
+        return {
+          success: false,
+          error: {
+            name: "Error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    })();
+    if (!httpResult.success) {
+      return httpResult;
+    }
+    if (parameters?.schema === false) {
+      return { success: true, data: httpResult.data };
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.safeParse(httpResult.data);
+  }
+  return {
+    action,
+    safeAction
+  };
+}
+
+// src/actions/get_current_user.ts
+var CurrentUserSchema = z2.object({
+  username: z2.string(),
+  email: z2.string(),
+  credits: z2.number(),
+  granted_credits: z2.number(),
+  avatar: z2.string(),
+  team_name: z2.string(),
+  team_tier: z2.string()
+}).passthrough();
+var { action: getCurrentUser, safeAction: safeGetCurrentUser } = defineSimpleAction(
+  CurrentUserSchema,
+  async (client) => {
+    return await client.get("/auth/me");
+  }
+);
+
+// src/actions/get_available_nodes.ts
+import { z as z4 } from "zod";
+
+// src/types/kms_info.ts
+import { z as z3 } from "zod";
+
 // src/types/supported_chains.ts
 import { anvil, base, mainnet } from "viem/chains";
 var SUPPORTED_CHAINS = {
@@ -333,14 +502,14 @@ var SUPPORTED_CHAINS = {
 };
 
 // src/types/kms_info.ts
-var KmsInfoBaseSchema = z2.object({
-  id: z2.string(),
-  slug: z2.string().nullable(),
-  url: z2.string(),
-  version: z2.string(),
-  chain_id: z2.number().nullable(),
-  kms_contract_address: z2.string().nullable().transform((val) => val),
-  gateway_app_id: z2.string().nullable().transform((val) => val)
+var KmsInfoBaseSchema = z3.object({
+  id: z3.string(),
+  slug: z3.string().nullable(),
+  url: z3.string(),
+  version: z3.string(),
+  chain_id: z3.number().nullable(),
+  kms_contract_address: z3.string().nullable().transform((val) => val),
+  gateway_app_id: z3.string().nullable().transform((val) => val)
 }).passthrough();
 var KmsInfoSchema = KmsInfoBaseSchema.transform((data) => {
   if (data.chain_id != null) {
@@ -352,91 +521,597 @@ var KmsInfoSchema = KmsInfoBaseSchema.transform((data) => {
   return data;
 });
 
+// src/actions/get_available_nodes.ts
+var AvailableOSImageSchema = z4.object({
+  name: z4.string(),
+  is_dev: z4.boolean(),
+  version: z4.union([
+    z4.tuple([z4.number(), z4.number(), z4.number()]),
+    z4.tuple([z4.number(), z4.number(), z4.number(), z4.number()])
+  ]),
+  os_image_hash: z4.string().nullable().optional()
+}).passthrough();
+var TeepodCapacitySchema = z4.object({
+  teepod_id: z4.number(),
+  name: z4.string(),
+  listed: z4.boolean(),
+  resource_score: z4.number(),
+  remaining_vcpu: z4.number(),
+  remaining_memory: z4.number(),
+  remaining_cvm_slots: z4.number(),
+  images: z4.array(AvailableOSImageSchema),
+  support_onchain_kms: z4.boolean().optional(),
+  fmspc: z4.string().nullable().optional(),
+  device_id: z4.string().nullable().optional(),
+  region_identifier: z4.string().nullable().optional(),
+  default_kms: z4.string().nullable().optional(),
+  kms_list: z4.array(z4.string()).default([])
+}).passthrough();
+var ResourceThresholdSchema = z4.object({
+  max_instances: z4.number().nullable().optional(),
+  max_vcpu: z4.number().nullable().optional(),
+  max_memory: z4.number().nullable().optional(),
+  max_disk: z4.number().nullable().optional()
+}).passthrough();
+var AvailableNodesSchema = z4.object({
+  tier: z4.string(),
+  // TeamTier is string enum
+  capacity: ResourceThresholdSchema,
+  nodes: z4.array(TeepodCapacitySchema),
+  kms_list: z4.array(KmsInfoSchema)
+}).passthrough();
+var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSimpleAction(
+  AvailableNodesSchema,
+  async (client) => {
+    return await client.get("/teepods/available");
+  }
+);
+
+// src/actions/list-instance-types.ts
+import { z as z5 } from "zod";
+var ListInstanceTypesRequestSchema = z5.object({
+  page: z5.number().int().min(1).optional().default(1),
+  page_size: z5.number().int().min(1).max(1e3).optional().default(100)
+}).strict();
+var InstanceTypeSchema = z5.object({
+  id: z5.string(),
+  name: z5.string(),
+  description: z5.string(),
+  vcpu: z5.number(),
+  memory_mb: z5.number(),
+  hourly_rate: z5.string(),
+  requires_gpu: z5.boolean(),
+  public: z5.boolean(),
+  enabled: z5.boolean()
+}).passthrough();
+var PaginatedInstanceTypesSchema = z5.object({
+  items: z5.array(InstanceTypeSchema),
+  total: z5.number(),
+  page: z5.number(),
+  page_size: z5.number(),
+  pages: z5.number()
+}).strict();
+var { action: listInstanceTypes, safeAction: safeListInstanceTypes } = defineAction(PaginatedInstanceTypesSchema, async (client, request) => {
+  const validatedRequest = ListInstanceTypesRequestSchema.parse(request ?? {});
+  const queryParams = new URLSearchParams();
+  queryParams.append("page", validatedRequest.page.toString());
+  queryParams.append("page_size", validatedRequest.page_size.toString());
+  return await client.get(`/api/instance-types?${queryParams.toString()}`);
+});
+
+// src/actions/workspaces/list_workspaces.ts
+import { z as z6 } from "zod";
+var WorkspaceResponseSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  slug: z6.string().nullable(),
+  tier: z6.string(),
+  role: z6.string(),
+  created_at: z6.string()
+}).passthrough();
+var PaginationMetadataSchema = z6.object({
+  has_more: z6.boolean(),
+  next_cursor: z6.string().nullable(),
+  total: z6.number().nullable()
+}).passthrough();
+var ListWorkspacesSchema = z6.object({
+  data: z6.array(WorkspaceResponseSchema),
+  pagination: PaginationMetadataSchema
+}).passthrough();
+var { action: listWorkspaces, safeAction: safeListWorkspaces } = defineAction(ListWorkspacesSchema, async (client, request) => {
+  const queryParams = new URLSearchParams();
+  if (request?.cursor) queryParams.append("cursor", request.cursor);
+  if (request?.limit) queryParams.append("limit", request.limit.toString());
+  const url = queryParams.toString() ? `/workspaces?${queryParams.toString()}` : "/workspaces";
+  return await client.get(url);
+});
+
+// src/actions/workspaces/get_workspace.ts
+var { action: getWorkspace, safeAction: safeGetWorkspace } = defineAction(WorkspaceResponseSchema, async (client, teamSlug) => {
+  return await client.get(`/workspaces/${teamSlug}`);
+});
+
+// src/actions/cvms/get_cvm_info.ts
+import { z as z8 } from "zod";
+
 // src/types/cvm_info.ts
-import { z as z3 } from "zod";
-var VmInfoSchema = z3.object({
-  id: z3.string(),
-  name: z3.string(),
-  status: z3.string(),
-  uptime: z3.string(),
-  app_url: z3.string().nullable(),
-  app_id: z3.string(),
-  instance_id: z3.string().nullable(),
-  configuration: z3.any().optional(),
+import { z as z7 } from "zod";
+var VmInfoSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  status: z7.string(),
+  uptime: z7.string(),
+  app_url: z7.string().nullable(),
+  app_id: z7.string(),
+  instance_id: z7.string().nullable(),
+  configuration: z7.any().optional(),
   // TODO: add VmConfiguration schema if needed
-  exited_at: z3.string().nullable(),
-  boot_progress: z3.string().nullable(),
-  boot_error: z3.string().nullable(),
-  shutdown_progress: z3.string().nullable(),
-  image_version: z3.string().nullable()
+  exited_at: z7.string().nullable(),
+  boot_progress: z7.string().nullable(),
+  boot_error: z7.string().nullable(),
+  shutdown_progress: z7.string().nullable(),
+  image_version: z7.string().nullable()
 });
-var ManagedUserSchema = z3.object({
-  id: z3.number(),
-  username: z3.string()
+var ManagedUserSchema = z7.object({
+  id: z7.number(),
+  username: z7.string()
 });
-var CvmNodeSchema = z3.object({
-  id: z3.number(),
-  name: z3.string(),
-  region_identifier: z3.string().optional()
+var CvmNodeSchema = z7.object({
+  id: z7.number(),
+  name: z7.string(),
+  region_identifier: z7.string().optional()
 });
-var CvmNetworkUrlsSchema = z3.object({
-  app: z3.string(),
-  instance: z3.string()
+var CvmNetworkUrlsSchema = z7.object({
+  app: z7.string(),
+  instance: z7.string()
 });
-var CvmInfoSchema = z3.object({
+var CvmInfoSchema = z7.object({
   hosted: VmInfoSchema,
-  name: z3.string(),
+  name: z7.string(),
   managed_user: ManagedUserSchema.optional().nullable(),
   node: CvmNodeSchema.optional().nullable(),
-  listed: z3.boolean().default(false),
-  status: z3.string(),
-  in_progress: z3.boolean().default(false),
-  dapp_dashboard_url: z3.string().nullable(),
-  syslog_endpoint: z3.string().nullable(),
-  allow_upgrade: z3.boolean().default(false),
-  project_id: z3.string().nullable(),
+  listed: z7.boolean().default(false),
+  status: z7.string(),
+  in_progress: z7.boolean().default(false),
+  dapp_dashboard_url: z7.string().nullable(),
+  syslog_endpoint: z7.string().nullable(),
+  allow_upgrade: z7.boolean().default(false),
+  project_id: z7.string().nullable(),
   // HashedId is represented as string in JS
-  project_type: z3.string().nullable(),
-  billing_period: z3.string().nullable(),
+  project_type: z7.string().nullable(),
+  billing_period: z7.string().nullable(),
   kms_info: KmsInfoSchema.nullable(),
-  vcpu: z3.number().nullable(),
-  memory: z3.number().nullable(),
-  disk_size: z3.number().nullable(),
-  gateway_domain: z3.string().nullable(),
-  public_urls: z3.array(CvmNetworkUrlsSchema)
+  vcpu: z7.number().nullable(),
+  memory: z7.number().nullable(),
+  disk_size: z7.number().nullable(),
+  gateway_domain: z7.string().nullable(),
+  public_urls: z7.array(CvmNetworkUrlsSchema)
 }).partial();
-var CvmLegacyDetailSchema = z3.object({
-  id: z3.number(),
-  name: z3.string(),
-  status: z3.string(),
-  in_progress: z3.boolean(),
-  teepod_id: z3.number().nullable(),
+var CvmLegacyDetailSchema = z7.object({
+  id: z7.number(),
+  name: z7.string(),
+  status: z7.string(),
+  in_progress: z7.boolean(),
+  teepod_id: z7.number().nullable(),
   teepod: CvmNodeSchema,
-  app_id: z3.string(),
-  vm_uuid: z3.string().nullable(),
-  instance_id: z3.string().nullable(),
-  vcpu: z3.number().nullable(),
-  memory: z3.number().nullable(),
-  disk_size: z3.number().nullable(),
-  base_image: z3.string(),
-  encrypted_env_pubkey: z3.string().nullable(),
-  listed: z3.boolean(),
-  project_id: z3.string().nullable(),
-  project_type: z3.string().nullable(),
-  public_sysinfo: z3.boolean(),
-  public_logs: z3.boolean(),
-  dapp_dashboard_url: z3.string().nullable(),
-  syslog_endpoint: z3.string().nullable(),
+  app_id: z7.string(),
+  vm_uuid: z7.string().nullable(),
+  instance_id: z7.string().nullable(),
+  vcpu: z7.number().nullable(),
+  memory: z7.number().nullable(),
+  disk_size: z7.number().nullable(),
+  base_image: z7.string(),
+  encrypted_env_pubkey: z7.string().nullable(),
+  listed: z7.boolean(),
+  project_id: z7.string().nullable(),
+  project_type: z7.string().nullable(),
+  public_sysinfo: z7.boolean(),
+  public_logs: z7.boolean(),
+  dapp_dashboard_url: z7.string().nullable(),
+  syslog_endpoint: z7.string().nullable(),
   kms_info: KmsInfoSchema.nullable(),
-  contract_address: z3.string().nullable(),
-  deployer_address: z3.string().nullable(),
-  scheduled_delete_at: z3.string().nullable(),
-  public_urls: z3.array(CvmNetworkUrlsSchema),
-  gateway_domain: z3.string().nullable()
+  contract_address: z7.string().nullable(),
+  deployer_address: z7.string().nullable(),
+  scheduled_delete_at: z7.string().nullable(),
+  public_urls: z7.array(CvmNetworkUrlsSchema),
+  gateway_domain: z7.string().nullable()
+});
+
+// src/actions/cvms/get_cvm_info.ts
+var GetCvmInfoRequestSchema = z8.object({
+  id: z8.string().optional(),
+  uuid: z8.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: z8.string().refine(
+    (val) => !val.startsWith("app_") && val.length === 40,
+    "app_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
+  instance_id: z8.string().refine(
+    (val) => !val.startsWith("instance_") && val.length === 40,
+    "instance_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional()
+}).refine(
+  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
+  "One of id, uuid, app_id, or instance_id must be provided"
+).transform((data) => ({
+  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
+  _raw: data
+}));
+var { action: getCvmInfo, safeAction: safeGetCvmInfo } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
+  const validatedRequest = GetCvmInfoRequestSchema.parse(request);
+  return await client.get(`/cvms/${validatedRequest.cvmId}`);
+});
+
+// src/actions/cvms/get_cvm_list.ts
+import { z as z9 } from "zod";
+var GetCvmListRequestSchema = z9.object({
+  page: z9.number().int().min(1).optional(),
+  page_size: z9.number().int().min(1).optional(),
+  node_id: z9.number().int().min(1).optional()
+}).strict();
+var GetCvmListSchema = z9.object({
+  items: z9.array(CvmInfoSchema),
+  total: z9.number(),
+  page: z9.number(),
+  page_size: z9.number(),
+  pages: z9.number()
+}).strict();
+var { action: getCvmList, safeAction: safeGetCvmList } = defineAction(GetCvmListSchema, async (client, request) => {
+  const validatedRequest = GetCvmListRequestSchema.parse(request ?? {});
+  return await client.get("/cvms/paginated", { params: validatedRequest });
+});
+
+// src/actions/cvms/provision_cvm.ts
+import { z as z10 } from "zod";
+var ProvisionCvmSchema = z10.object({
+  app_id: z10.string().nullable().optional(),
+  app_env_encrypt_pubkey: z10.string().nullable().optional(),
+  compose_hash: z10.string(),
+  fmspc: z10.string().nullable().optional(),
+  device_id: z10.string().nullable().optional(),
+  os_image_hash: z10.string().nullable().optional(),
+  teepod_id: z10.number().nullable().optional(),
+  // Will be transformed to node_id
+  node_id: z10.number().nullable().optional(),
+  kms_id: z10.string().nullable().optional()
+}).passthrough().transform((data) => {
+  if ("teepod_id" in data && data.teepod_id !== void 0) {
+    const { teepod_id, ...rest } = data;
+    return { ...rest, node_id: teepod_id };
+  }
+  return data;
+});
+var ProvisionCvmRequestSchema = z10.object({
+  node_id: z10.number().optional(),
+  // recommended
+  teepod_id: z10.number().optional(),
+  // deprecated, for compatibility
+  name: z10.string(),
+  image: z10.string(),
+  vcpu: z10.number(),
+  memory: z10.number(),
+  disk_size: z10.number(),
+  compose_file: z10.object({
+    allowed_envs: z10.array(z10.string()).optional(),
+    pre_launch_script: z10.string().optional(),
+    docker_compose_file: z10.string().optional(),
+    name: z10.string().optional(),
+    kms_enabled: z10.boolean().optional(),
+    public_logs: z10.boolean().optional(),
+    public_sysinfo: z10.boolean().optional(),
+    gateway_enabled: z10.boolean().optional(),
+    // recommended
+    tproxy_enabled: z10.boolean().optional()
+    // deprecated, for compatibility
+  }),
+  listed: z10.boolean().optional(),
+  instance_type: z10.string().nullable().optional(),
+  kms_id: z10.string().optional(),
+  env_keys: z10.array(z10.string()).optional()
+}).passthrough();
+function autofillComposeFileName(appCompose) {
+  if (appCompose.compose_file && !appCompose.compose_file.name) {
+    return {
+      ...appCompose,
+      compose_file: {
+        ...appCompose.compose_file,
+        name: appCompose.name
+      }
+    };
+  }
+  return appCompose;
+}
+function handleGatewayCompatibility(appCompose) {
+  if (!appCompose.compose_file) {
+    return appCompose;
+  }
+  const composeFile = { ...appCompose.compose_file };
+  if (typeof composeFile.gateway_enabled === "boolean" && typeof composeFile.tproxy_enabled === "boolean") {
+    delete composeFile.tproxy_enabled;
+  } else if (typeof composeFile.tproxy_enabled === "boolean" && typeof composeFile.gateway_enabled === "undefined") {
+    composeFile.gateway_enabled = composeFile.tproxy_enabled;
+    delete composeFile.tproxy_enabled;
+    if (typeof window !== "undefined" ? window.console : globalThis.console) {
+      console.warn(
+        "[phala/cloud] tproxy_enabled is deprecated, please use gateway_enabled instead. See docs for migration."
+      );
+    }
+  }
+  return {
+    ...appCompose,
+    compose_file: composeFile
+  };
+}
+var { action: provisionCvm, safeAction: safeProvisionCvm } = defineAction(ProvisionCvmSchema, async (client, appCompose) => {
+  const body = handleGatewayCompatibility(autofillComposeFileName(appCompose));
+  let requestBody = { ...body };
+  if (typeof body.node_id === "number") {
+    requestBody = { ...body, teepod_id: body.node_id };
+    delete requestBody.node_id;
+  } else if (typeof body.teepod_id === "number") {
+    console.warn("[phala/cloud] teepod_id is deprecated, please use node_id instead.");
+  }
+  return await client.post("/cvms/provision", requestBody);
+});
+
+// src/actions/cvms/commit_cvm_provision.ts
+import { z as z11 } from "zod";
+var CommitCvmProvisionSchema = z11.object({
+  id: z11.number(),
+  name: z11.string(),
+  status: z11.string(),
+  teepod_id: z11.number(),
+  teepod: z11.object({
+    id: z11.number(),
+    name: z11.string()
+  }).nullable(),
+  user_id: z11.number().nullable(),
+  app_id: z11.string().nullable(),
+  vm_uuid: z11.string().nullable(),
+  instance_id: z11.string().nullable(),
+  app_url: z11.string().nullable(),
+  base_image: z11.string().nullable(),
+  vcpu: z11.number(),
+  memory: z11.number(),
+  disk_size: z11.number(),
+  manifest_version: z11.number().nullable(),
+  version: z11.string().nullable(),
+  runner: z11.string().nullable(),
+  docker_compose_file: z11.string().nullable(),
+  features: z11.array(z11.string()).nullable(),
+  created_at: z11.string(),
+  encrypted_env_pubkey: z11.string().nullable().optional(),
+  app_auth_contract_address: z11.string().nullable().optional(),
+  deployer_address: z11.string().nullable().optional()
+}).passthrough();
+var CommitCvmProvisionRequestSchema = z11.object({
+  encrypted_env: z11.string().optional().nullable(),
+  app_id: z11.string(),
+  compose_hash: z11.string().optional(),
+  kms_id: z11.string().optional(),
+  contract_address: z11.string().optional(),
+  deployer_address: z11.string().optional(),
+  env_keys: z11.array(z11.string()).optional().nullable()
+}).passthrough();
+var { action: commitCvmProvision, safeAction: safeCommitCvmProvision } = defineAction(CommitCvmProvisionSchema, async (client, payload) => {
+  return await client.post("/cvms", payload);
+});
+
+// src/actions/cvms/get_cvm_compose_file.ts
+import { z as z13 } from "zod";
+
+// src/types/app_compose.ts
+import { z as z12 } from "zod";
+var LooseAppComposeSchema = z12.object({
+  allowed_envs: z12.array(z12.string()).optional(),
+  docker_compose_file: z12.string(),
+  features: z12.array(z12.string()).optional(),
+  name: z12.string().optional(),
+  manifest_version: z12.number().optional(),
+  kms_enabled: z12.boolean().optional(),
+  public_logs: z12.boolean().optional(),
+  public_sysinfo: z12.boolean().optional(),
+  tproxy_enabled: z12.boolean().optional(),
+  pre_launch_script: z12.string().optional()
+}).passthrough();
+
+// src/actions/cvms/get_cvm_compose_file.ts
+var GetCvmComposeFileRequestSchema = z13.object({
+  id: z13.string().optional(),
+  uuid: z13.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: z13.string().refine(
+    (val) => !val.startsWith("app_") && val.length === 40,
+    "app_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
+  instance_id: z13.string().refine(
+    (val) => !val.startsWith("instance_") && val.length === 40,
+    "instance_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional()
+}).refine(
+  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
+  "One of id, uuid, app_id, or instance_id must be provided"
+).transform((data) => ({
+  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
+  _raw: data
+}));
+var { action: getCvmComposeFile, safeAction: safeGetCvmComposeFile } = defineAction(LooseAppComposeSchema, async (client, request) => {
+  const validatedRequest = GetCvmComposeFileRequestSchema.parse(request);
+  return await client.get(`/cvms/${validatedRequest.cvmId}/compose_file`);
+});
+
+// src/actions/cvms/provision_cvm_compose_file_update.ts
+import { z as z14 } from "zod";
+var ProvisionCvmComposeFileUpdateRequestSchema = z14.object({
+  id: z14.string().optional(),
+  uuid: z14.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: z14.string().refine(
+    (val) => !val.startsWith("app_") && val.length === 40,
+    "app_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
+  instance_id: z14.string().refine(
+    (val) => !val.startsWith("instance_") && val.length === 40,
+    "instance_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
+  app_compose: LooseAppComposeSchema,
+  update_env_vars: z14.boolean().optional().nullable()
+}).refine(
+  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
+  "One of id, uuid, app_id, or instance_id must be provided"
+).transform((data) => ({
+  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
+  request: data.app_compose,
+  update_env_vars: data.update_env_vars,
+  _raw: data
+}));
+var ProvisionCvmComposeFileUpdateResultSchema = z14.object({
+  app_id: z14.string().nullable(),
+  device_id: z14.string().nullable(),
+  compose_hash: z14.string(),
+  kms_info: KmsInfoSchema.nullable().optional()
+}).passthrough();
+var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmComposeFileUpdate } = defineAction(ProvisionCvmComposeFileUpdateResultSchema, async (client, request) => {
+  const validatedRequest = ProvisionCvmComposeFileUpdateRequestSchema.parse(request);
+  return await client.post(
+    `/cvms/${validatedRequest.cvmId}/compose_file/provision`,
+    validatedRequest.request
+  );
+});
+
+// src/actions/cvms/commit_cvm_compose_file_update.ts
+import { z as z15 } from "zod";
+var CommitCvmComposeFileUpdateRequestSchema = z15.object({
+  id: z15.string().optional(),
+  uuid: z15.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: z15.string().refine(
+    (val) => !val.startsWith("app_") && val.length === 40,
+    "app_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
+  instance_id: z15.string().refine(
+    (val) => !val.startsWith("instance_") && val.length === 40,
+    "instance_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
+  compose_hash: z15.string().min(1, "Compose hash is required"),
+  encrypted_env: z15.string().optional(),
+  env_keys: z15.array(z15.string()).optional(),
+  update_env_vars: z15.boolean().optional().nullable()
+}).refine(
+  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
+  "One of id, uuid, app_id, or instance_id must be provided"
+).transform((data) => ({
+  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
+  compose_hash: data.compose_hash,
+  encrypted_env: data.encrypted_env,
+  env_keys: data.env_keys,
+  update_env_vars: !!data.update_env_vars,
+  _raw: data
+}));
+var CommitCvmComposeFileUpdateSchema = z15.any().transform(() => void 0);
+var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUpdate } = defineAction(
+  CommitCvmComposeFileUpdateSchema,
+  async (client, request) => {
+    const validatedRequest = CommitCvmComposeFileUpdateRequestSchema.parse(request);
+    return await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
+      compose_hash: validatedRequest.compose_hash,
+      encrypted_env: validatedRequest.encrypted_env,
+      env_keys: validatedRequest.env_keys
+    });
+  }
+);
+
+// src/actions/kms/get_kms_info.ts
+import { z as z16 } from "zod";
+var GetKmsInfoRequestSchema = z16.object({
+  kms_id: z16.string().min(1, "KMS ID is required")
+});
+var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSchema, async (client, request) => {
+  const validatedRequest = GetKmsInfoRequestSchema.parse(request);
+  return await client.get(`/kms/${validatedRequest.kms_id}`);
+});
+
+// src/actions/kms/get_kms_list.ts
+import { z as z17 } from "zod";
+var GetKmsListRequestSchema = z17.object({
+  page: z17.number().int().min(1).optional(),
+  page_size: z17.number().int().min(1).optional(),
+  is_onchain: z17.boolean().optional()
+}).strict();
+var GetKmsListSchema = z17.object({
+  items: z17.array(KmsInfoSchema),
+  total: z17.number(),
+  page: z17.number(),
+  page_size: z17.number(),
+  pages: z17.number()
+}).strict();
+var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsListSchema, async (client, request) => {
+  const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
+  return await client.get("/kms", { params: validatedRequest });
+});
+
+// src/actions/kms/get_app_env_encrypt_pubkey.ts
+import { z as z18 } from "zod";
+var GetAppEnvEncryptPubKeyRequestSchema = z18.object({
+  kms: z18.string().min(1, "KMS ID or slug is required"),
+  app_id: z18.string().refine(
+    (val) => val.length === 40 || val.startsWith("0x") && val.length === 42,
+    "App ID must be exactly 40 characters or 42 characters with 0x prefix"
+  )
+}).strict();
+var GetAppEnvEncryptPubKeySchema = z18.object({
+  public_key: z18.string(),
+  signature: z18.string()
+}).strict();
+var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } = defineAction(GetAppEnvEncryptPubKeySchema, async (client, payload) => {
+  const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
+  return await client.get(`/kms/${validatedRequest.kms}/pubkey/${validatedRequest.app_id}`);
 });
 
-// src/actions/get_current_user.ts
-import { z as z4 } from "zod";
+// src/create-client.ts
+function createClient2(config = {}) {
+  const client = createClient(config);
+  const allActions = {
+    getCurrentUser,
+    safeGetCurrentUser,
+    getAvailableNodes,
+    safeGetAvailableNodes,
+    listInstanceTypes,
+    safeListInstanceTypes,
+    listWorkspaces,
+    safeListWorkspaces,
+    getWorkspace,
+    safeGetWorkspace,
+    getCvmInfo,
+    safeGetCvmInfo,
+    getCvmList,
+    safeGetCvmList,
+    provisionCvm,
+    safeProvisionCvm,
+    commitCvmProvision,
+    safeCommitCvmProvision,
+    getCvmComposeFile,
+    safeGetCvmComposeFile,
+    provisionCvmComposeFileUpdate,
+    safeProvisionCvmComposeFileUpdate,
+    commitCvmComposeFileUpdate,
+    safeCommitCvmComposeFileUpdate,
+    getKmsInfo,
+    safeGetKmsInfo,
+    getKmsList,
+    safeGetKmsList,
+    getAppEnvEncryptPubKey,
+    safeGetAppEnvEncryptPubKey
+  };
+  return client.extend(allActions);
+}
+
+// src/actions/blockchains/deploy_app_auth.ts
+import { z as z19 } from "zod";
+import {
+  createPublicClient as createPublicClient2,
+  createWalletClient as createWalletClient2,
+  http as http2,
+  parseEventLogs,
+  parseEther
+} from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 
 // src/utils/index.ts
 import { encryptEnvVars } from "@phala/dstack-sdk/encrypt-env-vars";
@@ -471,38 +1146,6 @@ function asHex(value) {
   throw new Error(`Invalid hex value: ${value}`);
 }
 
-// src/utils/validate-parameters.ts
-function validateActionParameters(parameters) {
-  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
-    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
-      throw new Error("Invalid schema: must be a Zod schema object, false, or undefined");
-    }
-  }
-}
-function safeValidateActionParameters(parameters) {
-  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
-    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
-      return {
-        success: false,
-        error: {
-          name: "ZodError",
-          message: "Invalid schema: must be a Zod schema object, false, or undefined",
-          issues: [
-            {
-              code: "invalid_type",
-              expected: "object",
-              received: typeof parameters.schema,
-              path: ["schema"],
-              message: "Invalid schema: must be a Zod schema object, false, or undefined"
-            }
-          ]
-        }
-      };
-    }
-  }
-  return void 0;
-}
-
 // src/utils/network.ts
 var NetworkError = class extends Error {
   constructor(message, code, details) {
@@ -1076,381 +1719,38 @@ async function addNetwork(provider, config) {
           chainName: config.name,
           rpcUrls: [config.rpcUrl],
           blockExplorerUrls: config.blockExplorer ? [config.blockExplorer] : void 0,
-          nativeCurrency: {
-            name: "ETH",
-            symbol: "ETH",
-            decimals: 18
-          }
-        }
-      ]
-    });
-  } catch (error) {
-    const errorObj = error;
-    throw new NetworkError(
-      `Failed to add network: ${errorObj.message || "Unknown error"}`,
-      "NETWORK_ADD_FAILED",
-      error
-    );
-  }
-}
-async function autoCreateClients(chain, options = {}) {
-  const { privateKey, rpcUrl, preferBrowser = false } = options;
-  if (privateKey) {
-    return createClientsFromPrivateKey(chain, privateKey, rpcUrl);
-  }
-  if (isBrowser() && (preferBrowser || !privateKey)) {
-    return createClientsFromBrowser(chain, rpcUrl);
-  }
-  throw new WalletError(
-    "No wallet connection method available. Provide a private key for server-side usage or use in browser environment.",
-    "NO_CONNECTION_METHOD"
-  );
-}
-
-// src/actions/get_current_user.ts
-var CurrentUserSchema = z4.object({
-  username: z4.string(),
-  email: z4.string(),
-  credits: z4.number(),
-  granted_credits: z4.number(),
-  avatar: z4.string(),
-  team_name: z4.string(),
-  team_tier: z4.string()
-}).passthrough();
-async function getCurrentUser(client, parameters) {
-  validateActionParameters(parameters);
-  const response = await client.get("/auth/me");
-  if (parameters?.schema === false) {
-    return response;
-  }
-  const schema = parameters?.schema || CurrentUserSchema;
-  return schema.parse(response);
-}
-async function safeGetCurrentUser(client, parameters) {
-  const parameterValidationError = safeValidateActionParameters(parameters);
-  if (parameterValidationError) {
-    return parameterValidationError;
-  }
-  const httpResult = await client.safeGet("/auth/me");
-  if (!httpResult.success) {
-    return httpResult;
-  }
-  if (parameters?.schema === false) {
-    return { success: true, data: httpResult.data };
-  }
-  const schema = parameters?.schema || CurrentUserSchema;
-  return schema.safeParse(httpResult.data);
-}
-
-// src/actions/get_available_nodes.ts
-import { z as z5 } from "zod";
-
-// src/utils/define-action.ts
-function defineSimpleAction(schema, fn) {
-  function action(client, parameters) {
-    return _actionImpl(client, parameters);
-  }
-  async function _actionImpl(client, parameters) {
-    validateActionParameters(parameters);
-    const response = await fn(client);
-    if (parameters?.schema === false) {
-      return response;
-    }
-    const actualSchema = parameters?.schema || schema;
-    return actualSchema.parse(response);
-  }
-  function safeAction(client, parameters) {
-    return _safeActionImpl(client, parameters);
-  }
-  async function _safeActionImpl(client, parameters) {
-    const parameterValidationError = safeValidateActionParameters(parameters);
-    if (parameterValidationError) {
-      return parameterValidationError;
-    }
-    const httpResult = await (async () => {
-      try {
-        const data = await fn(client);
-        return { success: true, data };
-      } catch (error) {
-        if (error && typeof error === "object" && "isRequestError" in error) {
-          return { success: false, error };
-        }
-        if (error && typeof error === "object" && "issues" in error) {
-          return { success: false, error };
-        }
-        return {
-          success: false,
-          error: {
-            name: "Error",
-            message: error instanceof Error ? error.message : String(error)
-          }
-        };
-      }
-    })();
-    if (!httpResult.success) {
-      return httpResult;
-    }
-    if (parameters?.schema === false) {
-      return { success: true, data: httpResult.data };
-    }
-    const actualSchema = parameters?.schema || schema;
-    return actualSchema.safeParse(httpResult.data);
-  }
-  return {
-    action,
-    safeAction
-  };
-}
-function defineAction(schema, fn) {
-  function action(client, ...args) {
-    const [params, parameters] = args;
-    return _actionImpl(client, params, parameters);
-  }
-  async function _actionImpl(client, params, parameters) {
-    validateActionParameters(parameters);
-    const response = await fn(client, params);
-    if (parameters?.schema === false) {
-      return response;
-    }
-    const actualSchema = parameters?.schema || schema;
-    return actualSchema.parse(response);
-  }
-  function safeAction(client, ...args) {
-    const [params, parameters] = args;
-    return _safeActionImpl(client, params, parameters);
-  }
-  async function _safeActionImpl(client, params, parameters) {
-    const parameterValidationError = safeValidateActionParameters(parameters);
-    if (parameterValidationError) {
-      return parameterValidationError;
-    }
-    const httpResult = await (async () => {
-      try {
-        const data = await fn(client, params);
-        return { success: true, data };
-      } catch (error) {
-        if (error && typeof error === "object" && "isRequestError" in error) {
-          return { success: false, error };
-        }
-        if (error && typeof error === "object" && "issues" in error) {
-          return { success: false, error };
-        }
-        return {
-          success: false,
-          error: {
-            name: "Error",
-            message: error instanceof Error ? error.message : String(error)
-          }
-        };
-      }
-    })();
-    if (!httpResult.success) {
-      return httpResult;
-    }
-    if (parameters?.schema === false) {
-      return { success: true, data: httpResult.data };
-    }
-    const actualSchema = parameters?.schema || schema;
-    return actualSchema.safeParse(httpResult.data);
-  }
-  return {
-    action,
-    safeAction
-  };
-}
-
-// src/actions/get_available_nodes.ts
-var AvailableOSImageSchema = z5.object({
-  name: z5.string(),
-  is_dev: z5.boolean(),
-  version: z5.union([
-    z5.tuple([z5.number(), z5.number(), z5.number()]),
-    z5.tuple([z5.number(), z5.number(), z5.number(), z5.number()])
-  ]),
-  os_image_hash: z5.string().nullable().optional()
-}).passthrough();
-var TeepodCapacitySchema = z5.object({
-  teepod_id: z5.number(),
-  name: z5.string(),
-  listed: z5.boolean(),
-  resource_score: z5.number(),
-  remaining_vcpu: z5.number(),
-  remaining_memory: z5.number(),
-  remaining_cvm_slots: z5.number(),
-  images: z5.array(AvailableOSImageSchema),
-  support_onchain_kms: z5.boolean().optional(),
-  fmspc: z5.string().nullable().optional(),
-  device_id: z5.string().nullable().optional(),
-  region_identifier: z5.string().nullable().optional(),
-  default_kms: z5.string().nullable().optional(),
-  kms_list: z5.array(z5.string()).default([])
-}).passthrough();
-var ResourceThresholdSchema = z5.object({
-  max_instances: z5.number().nullable().optional(),
-  max_vcpu: z5.number().nullable().optional(),
-  max_memory: z5.number().nullable().optional(),
-  max_disk: z5.number().nullable().optional()
-}).passthrough();
-var AvailableNodesSchema = z5.object({
-  tier: z5.string(),
-  // TeamTier is string enum
-  capacity: ResourceThresholdSchema,
-  nodes: z5.array(TeepodCapacitySchema),
-  kms_list: z5.array(KmsInfoSchema)
-}).passthrough();
-var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSimpleAction(
-  AvailableNodesSchema,
-  async (client) => {
-    return await client.get("/teepods/available");
-  }
-);
-
-// src/actions/provision_cvm.ts
-import { z as z6 } from "zod";
-var ProvisionCvmSchema = z6.object({
-  app_id: z6.string().nullable().optional(),
-  app_env_encrypt_pubkey: z6.string().nullable().optional(),
-  compose_hash: z6.string(),
-  fmspc: z6.string().nullable().optional(),
-  device_id: z6.string().nullable().optional(),
-  os_image_hash: z6.string().nullable().optional(),
-  teepod_id: z6.number().nullable().optional(),
-  // Will be transformed to node_id
-  node_id: z6.number().nullable().optional(),
-  kms_id: z6.string().nullable().optional()
-}).passthrough().transform((data) => {
-  if ("teepod_id" in data && data.teepod_id !== void 0) {
-    const { teepod_id, ...rest } = data;
-    return { ...rest, node_id: teepod_id };
-  }
-  return data;
-});
-var ProvisionCvmRequestSchema = z6.object({
-  node_id: z6.number().optional(),
-  // recommended
-  teepod_id: z6.number().optional(),
-  // deprecated, for compatibility
-  name: z6.string(),
-  image: z6.string(),
-  vcpu: z6.number(),
-  memory: z6.number(),
-  disk_size: z6.number(),
-  compose_file: z6.object({
-    allowed_envs: z6.array(z6.string()).optional(),
-    pre_launch_script: z6.string().optional(),
-    docker_compose_file: z6.string().optional(),
-    name: z6.string().optional(),
-    kms_enabled: z6.boolean().optional(),
-    public_logs: z6.boolean().optional(),
-    public_sysinfo: z6.boolean().optional(),
-    gateway_enabled: z6.boolean().optional(),
-    // recommended
-    tproxy_enabled: z6.boolean().optional()
-    // deprecated, for compatibility
-  }),
-  listed: z6.boolean().optional(),
-  instance_type: z6.string().nullable().optional(),
-  kms_id: z6.string().optional(),
-  env_keys: z6.array(z6.string()).optional()
-}).passthrough();
-function autofillComposeFileName(appCompose) {
-  if (appCompose.compose_file && !appCompose.compose_file.name) {
-    return {
-      ...appCompose,
-      compose_file: {
-        ...appCompose.compose_file,
-        name: appCompose.name
-      }
-    };
+          nativeCurrency: {
+            name: "ETH",
+            symbol: "ETH",
+            decimals: 18
+          }
+        }
+      ]
+    });
+  } catch (error) {
+    const errorObj = error;
+    throw new NetworkError(
+      `Failed to add network: ${errorObj.message || "Unknown error"}`,
+      "NETWORK_ADD_FAILED",
+      error
+    );
   }
-  return appCompose;
 }
-function handleGatewayCompatibility(appCompose) {
-  if (!appCompose.compose_file) {
-    return appCompose;
+async function autoCreateClients(chain, options = {}) {
+  const { privateKey, rpcUrl, preferBrowser = false } = options;
+  if (privateKey) {
+    return createClientsFromPrivateKey(chain, privateKey, rpcUrl);
   }
-  const composeFile = { ...appCompose.compose_file };
-  if (typeof composeFile.gateway_enabled === "boolean" && typeof composeFile.tproxy_enabled === "boolean") {
-    delete composeFile.tproxy_enabled;
-  } else if (typeof composeFile.tproxy_enabled === "boolean" && typeof composeFile.gateway_enabled === "undefined") {
-    composeFile.gateway_enabled = composeFile.tproxy_enabled;
-    delete composeFile.tproxy_enabled;
-    if (typeof window !== "undefined" ? window.console : globalThis.console) {
-      console.warn(
-        "[phala/cloud] tproxy_enabled is deprecated, please use gateway_enabled instead. See docs for migration."
-      );
-    }
+  if (isBrowser() && (preferBrowser || !privateKey)) {
+    return createClientsFromBrowser(chain, rpcUrl);
   }
-  return {
-    ...appCompose,
-    compose_file: composeFile
-  };
+  throw new WalletError(
+    "No wallet connection method available. Provide a private key for server-side usage or use in browser environment.",
+    "NO_CONNECTION_METHOD"
+  );
 }
-var { action: provisionCvm, safeAction: safeProvisionCvm } = defineAction(ProvisionCvmSchema, async (client, appCompose) => {
-  const body = handleGatewayCompatibility(autofillComposeFileName(appCompose));
-  let requestBody = { ...body };
-  if (typeof body.node_id === "number") {
-    requestBody = { ...body, teepod_id: body.node_id };
-    delete requestBody.node_id;
-  } else if (typeof body.teepod_id === "number") {
-    console.warn("[phala/cloud] teepod_id is deprecated, please use node_id instead.");
-  }
-  return await client.post("/cvms/provision", requestBody);
-});
-
-// src/actions/commit_cvm_provision.ts
-import { z as z7 } from "zod";
-var CommitCvmProvisionSchema = z7.object({
-  id: z7.number(),
-  name: z7.string(),
-  status: z7.string(),
-  teepod_id: z7.number(),
-  teepod: z7.object({
-    id: z7.number(),
-    name: z7.string()
-  }).nullable(),
-  user_id: z7.number().nullable(),
-  app_id: z7.string().nullable(),
-  vm_uuid: z7.string().nullable(),
-  instance_id: z7.string().nullable(),
-  app_url: z7.string().nullable(),
-  base_image: z7.string().nullable(),
-  vcpu: z7.number(),
-  memory: z7.number(),
-  disk_size: z7.number(),
-  manifest_version: z7.number().nullable(),
-  version: z7.string().nullable(),
-  runner: z7.string().nullable(),
-  docker_compose_file: z7.string().nullable(),
-  features: z7.array(z7.string()).nullable(),
-  created_at: z7.string(),
-  encrypted_env_pubkey: z7.string().nullable().optional(),
-  app_auth_contract_address: z7.string().nullable().optional(),
-  deployer_address: z7.string().nullable().optional()
-}).passthrough();
-var CommitCvmProvisionRequestSchema = z7.object({
-  encrypted_env: z7.string().optional().nullable(),
-  app_id: z7.string(),
-  compose_hash: z7.string().optional(),
-  kms_id: z7.string().optional(),
-  contract_address: z7.string().optional(),
-  deployer_address: z7.string().optional(),
-  env_keys: z7.array(z7.string()).optional().nullable()
-}).passthrough();
-var { action: commitCvmProvision, safeAction: safeCommitCvmProvision } = defineAction(CommitCvmProvisionSchema, async (client, payload) => {
-  return await client.post("/cvms", payload);
-});
 
-// src/actions/deploy_app_auth.ts
-import { z as z8 } from "zod";
-import {
-  createPublicClient as createPublicClient2,
-  createWalletClient as createWalletClient2,
-  http as http2,
-  parseEventLogs,
-  parseEther
-} from "viem";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+// src/actions/blockchains/deploy_app_auth.ts
 var kmsAuthAbi = [
   {
     inputs: [
@@ -1481,25 +1781,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = z8.object({
+var DeployAppAuthRequestBaseSchema = z19.object({
   // Chain configuration (conditionally required)
-  chain: z8.unknown().optional(),
-  rpcUrl: z8.string().optional(),
+  chain: z19.unknown().optional(),
+  rpcUrl: z19.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: z8.string(),
+  kmsContractAddress: z19.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z8.string().optional(),
-  walletClient: z8.unknown().optional(),
+  privateKey: z19.string().optional(),
+  walletClient: z19.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z8.unknown().optional(),
+  publicClient: z19.unknown().optional(),
   // App configuration (optional)
-  allowAnyDevice: z8.boolean().optional().default(false),
-  deviceId: z8.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  composeHash: z8.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  disableUpgrades: z8.boolean().optional().default(false),
+  allowAnyDevice: z19.boolean().optional().default(false),
+  deviceId: z19.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: z19.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: z19.boolean().optional().default(false),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z8.boolean().optional().default(false),
-  minBalance: z8.string().optional()
+  skipPrerequisiteChecks: z19.boolean().optional().default(false),
+  minBalance: z19.string().optional()
   // ETH amount as string, e.g., "0.01"
 }).passthrough();
 var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
@@ -1527,13 +1827,13 @@ var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
     path: ["chain"]
   }
 );
-var DeployAppAuthSchema = z8.object({
-  appId: z8.string(),
-  appAuthAddress: z8.string(),
-  deployer: z8.string(),
-  transactionHash: z8.string(),
-  blockNumber: z8.bigint().optional(),
-  gasUsed: z8.bigint().optional()
+var DeployAppAuthSchema = z19.object({
+  appId: z19.string(),
+  appAuthAddress: z19.string(),
+  deployer: z19.string(),
+  transactionHash: z19.string(),
+  blockNumber: z19.bigint().optional(),
+  gasUsed: z19.bigint().optional()
 }).passthrough();
 function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
   try {
@@ -1778,8 +2078,8 @@ async function safeDeployAppAuth(request, parameters) {
   }
 }
 
-// src/actions/add_compose_hash.ts
-import { z as z9 } from "zod";
+// src/actions/blockchains/add_compose_hash.ts
+import { z as z20 } from "zod";
 import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient3,
@@ -1803,29 +2103,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = z9.object({
+var AddComposeHashRequestSchema = z20.object({
   // Chain configuration (conditionally required)
-  chain: z9.unknown().optional(),
-  rpcUrl: z9.string().optional(),
-  appId: z9.string(),
-  composeHash: z9.string(),
+  chain: z20.unknown().optional(),
+  rpcUrl: z20.string().optional(),
+  appId: z20.string(),
+  composeHash: z20.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z9.string().optional(),
-  walletClient: z9.unknown().optional(),
+  privateKey: z20.string().optional(),
+  walletClient: z20.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z9.unknown().optional(),
+  publicClient: z20.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z9.boolean().optional().default(false),
-  minBalance: z9.string().optional(),
+  skipPrerequisiteChecks: z20.boolean().optional().default(false),
+  minBalance: z20.string().optional(),
   // ETH amount as string, e.g., "0.01"
   // Transaction control options
-  timeout: z9.number().optional().default(12e4),
-  retryOptions: z9.unknown().optional(),
-  signal: z9.unknown().optional(),
+  timeout: z20.number().optional().default(12e4),
+  retryOptions: z20.unknown().optional(),
+  signal: z20.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: z9.function().optional(),
-  onTransactionSubmitted: z9.function().optional(),
-  onTransactionConfirmed: z9.function().optional()
+  onTransactionStateChange: z20.function().optional(),
+  onTransactionSubmitted: z20.function().optional(),
+  onTransactionConfirmed: z20.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -1849,12 +2149,12 @@ var AddComposeHashRequestSchema = z9.object({
     path: ["chain"]
   }
 );
-var AddComposeHashSchema = z9.object({
-  composeHash: z9.string(),
-  appId: z9.string(),
-  transactionHash: z9.string(),
-  blockNumber: z9.bigint().optional(),
-  gasUsed: z9.bigint().optional()
+var AddComposeHashSchema = z20.object({
+  composeHash: z20.string(),
+  appId: z20.string(),
+  transactionHash: z20.string(),
+  blockNumber: z20.bigint().optional(),
+  gasUsed: z20.bigint().optional()
 }).passthrough();
 function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
   console.log(receipt.logs);
@@ -2045,282 +2345,6 @@ async function safeAddComposeHash(request, parameters) {
   }
 }
 
-// src/actions/get_cvm_compose_file.ts
-import { z as z11 } from "zod";
-
-// src/types/app_compose.ts
-import { z as z10 } from "zod";
-var LooseAppComposeSchema = z10.object({
-  allowed_envs: z10.array(z10.string()).optional(),
-  docker_compose_file: z10.string(),
-  features: z10.array(z10.string()).optional(),
-  name: z10.string().optional(),
-  manifest_version: z10.number().optional(),
-  kms_enabled: z10.boolean().optional(),
-  public_logs: z10.boolean().optional(),
-  public_sysinfo: z10.boolean().optional(),
-  tproxy_enabled: z10.boolean().optional(),
-  pre_launch_script: z10.string().optional()
-}).passthrough();
-
-// src/actions/get_cvm_compose_file.ts
-var GetCvmComposeFileRequestSchema = z11.object({
-  id: z11.string().optional(),
-  uuid: z11.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: z11.string().refine(
-    (val) => !val.startsWith("app_") && val.length === 40,
-    "app_id should be 40 characters without prefix"
-  ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: z11.string().refine(
-    (val) => !val.startsWith("instance_") && val.length === 40,
-    "instance_id should be 40 characters without prefix"
-  ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional()
-}).refine(
-  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
-  "One of id, uuid, app_id, or instance_id must be provided"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  _raw: data
-}));
-var { action: getCvmComposeFile, safeAction: safeGetCvmComposeFile } = defineAction(LooseAppComposeSchema, async (client, request) => {
-  const validatedRequest = GetCvmComposeFileRequestSchema.parse(request);
-  return await client.get(`/cvms/${validatedRequest.cvmId}/compose_file`);
-});
-
-// src/actions/provision_cvm_compose_file_update.ts
-import { z as z12 } from "zod";
-var ProvisionCvmComposeFileUpdateRequestSchema = z12.object({
-  id: z12.string().optional(),
-  uuid: z12.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: z12.string().refine(
-    (val) => !val.startsWith("app_") && val.length === 40,
-    "app_id should be 40 characters without prefix"
-  ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: z12.string().refine(
-    (val) => !val.startsWith("instance_") && val.length === 40,
-    "instance_id should be 40 characters without prefix"
-  ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
-  app_compose: LooseAppComposeSchema,
-  update_env_vars: z12.boolean().optional().nullable()
-}).refine(
-  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
-  "One of id, uuid, app_id, or instance_id must be provided"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  request: data.app_compose,
-  update_env_vars: data.update_env_vars,
-  _raw: data
-}));
-var ProvisionCvmComposeFileUpdateResultSchema = z12.object({
-  app_id: z12.string().nullable(),
-  device_id: z12.string().nullable(),
-  compose_hash: z12.string(),
-  kms_info: KmsInfoSchema.nullable().optional()
-}).passthrough();
-var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmComposeFileUpdate } = defineAction(ProvisionCvmComposeFileUpdateResultSchema, async (client, request) => {
-  const validatedRequest = ProvisionCvmComposeFileUpdateRequestSchema.parse(request);
-  return await client.post(
-    `/cvms/${validatedRequest.cvmId}/compose_file/provision`,
-    validatedRequest.request
-  );
-});
-
-// src/actions/commit_cvm_compose_file_update.ts
-import { z as z13 } from "zod";
-var CommitCvmComposeFileUpdateRequestSchema = z13.object({
-  id: z13.string().optional(),
-  uuid: z13.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: z13.string().refine(
-    (val) => !val.startsWith("app_") && val.length === 40,
-    "app_id should be 40 characters without prefix"
-  ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: z13.string().refine(
-    (val) => !val.startsWith("instance_") && val.length === 40,
-    "instance_id should be 40 characters without prefix"
-  ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
-  compose_hash: z13.string().min(1, "Compose hash is required"),
-  encrypted_env: z13.string().optional(),
-  env_keys: z13.array(z13.string()).optional(),
-  update_env_vars: z13.boolean().optional().nullable()
-}).refine(
-  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
-  "One of id, uuid, app_id, or instance_id must be provided"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  compose_hash: data.compose_hash,
-  encrypted_env: data.encrypted_env,
-  env_keys: data.env_keys,
-  update_env_vars: !!data.update_env_vars,
-  _raw: data
-}));
-var CommitCvmComposeFileUpdateSchema = z13.any().transform(() => void 0);
-var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUpdate } = defineAction(
-  CommitCvmComposeFileUpdateSchema,
-  async (client, request) => {
-    const validatedRequest = CommitCvmComposeFileUpdateRequestSchema.parse(request);
-    return await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
-      compose_hash: validatedRequest.compose_hash,
-      encrypted_env: validatedRequest.encrypted_env,
-      env_keys: validatedRequest.env_keys
-    });
-  }
-);
-
-// src/actions/get_app_env_encrypt_pubkey.ts
-import { z as z14 } from "zod";
-var GetAppEnvEncryptPubKeyRequestSchema = z14.object({
-  kms: z14.string().min(1, "KMS ID or slug is required"),
-  app_id: z14.string().refine(
-    (val) => val.length === 40 || val.startsWith("0x") && val.length === 42,
-    "App ID must be exactly 40 characters or 42 characters with 0x prefix"
-  )
-}).strict();
-var GetAppEnvEncryptPubKeySchema = z14.object({
-  public_key: z14.string(),
-  signature: z14.string()
-}).strict();
-var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } = defineAction(GetAppEnvEncryptPubKeySchema, async (client, payload) => {
-  const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
-  return await client.get(`/kms/${validatedRequest.kms}/pubkey/${validatedRequest.app_id}`);
-});
-
-// src/actions/get_cvm_info.ts
-import { z as z15 } from "zod";
-var GetCvmInfoRequestSchema = z15.object({
-  id: z15.string().optional(),
-  uuid: z15.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: z15.string().refine(
-    (val) => !val.startsWith("app_") && val.length === 40,
-    "app_id should be 40 characters without prefix"
-  ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: z15.string().refine(
-    (val) => !val.startsWith("instance_") && val.length === 40,
-    "instance_id should be 40 characters without prefix"
-  ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional()
-}).refine(
-  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
-  "One of id, uuid, app_id, or instance_id must be provided"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  _raw: data
-}));
-var { action: getCvmInfo, safeAction: safeGetCvmInfo } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
-  const validatedRequest = GetCvmInfoRequestSchema.parse(request);
-  return await client.get(`/cvms/${validatedRequest.cvmId}`);
-});
-
-// src/actions/get_cvm_list.ts
-import { z as z16 } from "zod";
-var GetCvmListRequestSchema = z16.object({
-  page: z16.number().int().min(1).optional(),
-  page_size: z16.number().int().min(1).optional(),
-  node_id: z16.number().int().min(1).optional()
-}).strict();
-var GetCvmListSchema = z16.object({
-  items: z16.array(CvmInfoSchema),
-  total: z16.number(),
-  page: z16.number(),
-  page_size: z16.number(),
-  pages: z16.number()
-}).strict();
-var { action: getCvmList, safeAction: safeGetCvmList } = defineAction(GetCvmListSchema, async (client, request) => {
-  const validatedRequest = GetCvmListRequestSchema.parse(request ?? {});
-  return await client.get("/cvms/paginated", { params: validatedRequest });
-});
-
-// src/actions/get_kms_info.ts
-import { z as z17 } from "zod";
-var GetKmsInfoRequestSchema = z17.object({
-  kms_id: z17.string().min(1, "KMS ID is required")
-});
-var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSchema, async (client, request) => {
-  const validatedRequest = GetKmsInfoRequestSchema.parse(request);
-  return await client.get(`/kms/${validatedRequest.kms_id}`);
-});
-
-// src/actions/get_kms_list.ts
-import { z as z18 } from "zod";
-var GetKmsListRequestSchema = z18.object({
-  page: z18.number().int().min(1).optional(),
-  page_size: z18.number().int().min(1).optional(),
-  is_onchain: z18.boolean().optional()
-}).strict();
-var GetKmsListSchema = z18.object({
-  items: z18.array(KmsInfoSchema),
-  total: z18.number(),
-  page: z18.number(),
-  page_size: z18.number(),
-  pages: z18.number()
-}).strict();
-var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsListSchema, async (client, request) => {
-  const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
-  return await client.get("/kms", { params: validatedRequest });
-});
-
-// src/actions/workspaces/list_workspaces.ts
-import { z as z19 } from "zod";
-var WorkspaceResponseSchema = z19.object({
-  id: z19.string(),
-  name: z19.string(),
-  slug: z19.string().nullable(),
-  tier: z19.string(),
-  role: z19.string(),
-  created_at: z19.string()
-}).passthrough();
-var PaginationMetadataSchema = z19.object({
-  has_more: z19.boolean(),
-  next_cursor: z19.string().nullable(),
-  total: z19.number().nullable()
-}).passthrough();
-var ListWorkspacesSchema = z19.object({
-  data: z19.array(WorkspaceResponseSchema),
-  pagination: PaginationMetadataSchema
-}).passthrough();
-var { action: listWorkspaces, safeAction: safeListWorkspaces } = defineAction(ListWorkspacesSchema, async (client, request) => {
-  const queryParams = new URLSearchParams();
-  if (request?.cursor) queryParams.append("cursor", request.cursor);
-  if (request?.limit) queryParams.append("limit", request.limit.toString());
-  const url = queryParams.toString() ? `/workspaces?${queryParams.toString()}` : "/workspaces";
-  return await client.get(url);
-});
-
-// src/actions/workspaces/get_workspace.ts
-var { action: getWorkspace, safeAction: safeGetWorkspace } = defineAction(WorkspaceResponseSchema, async (client, teamSlug) => {
-  return await client.get(`/workspaces/${teamSlug}`);
-});
-
-// src/actions/list-instance-types.ts
-import { z as z20 } from "zod";
-var ListInstanceTypesRequestSchema = z20.object({
-  page: z20.number().int().min(1).optional().default(1),
-  page_size: z20.number().int().min(1).max(1e3).optional().default(100)
-}).strict();
-var InstanceTypeSchema = z20.object({
-  id: z20.string(),
-  name: z20.string(),
-  description: z20.string(),
-  vcpu: z20.number(),
-  memory_mb: z20.number(),
-  hourly_rate: z20.string(),
-  requires_gpu: z20.boolean(),
-  public: z20.boolean(),
-  enabled: z20.boolean()
-}).passthrough();
-var PaginatedInstanceTypesSchema = z20.object({
-  items: z20.array(InstanceTypeSchema),
-  total: z20.number(),
-  page: z20.number(),
-  page_size: z20.number(),
-  pages: z20.number()
-}).strict();
-var { action: listInstanceTypes, safeAction: safeListInstanceTypes } = defineAction(PaginatedInstanceTypesSchema, async (client, request) => {
-  const validatedRequest = ListInstanceTypesRequestSchema.parse(request ?? {});
-  const queryParams = new URLSearchParams();
-  queryParams.append("page", validatedRequest.page.toString());
-  queryParams.append("page_size", validatedRequest.page_size.toString());
-  return await client.get(`/api/instance-types?${queryParams.toString()}`);
-});
-
 // src/parse_dotenv.ts
 var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function parseEnv(input) {
@@ -2408,7 +2432,8 @@ export {
   checkNetworkStatus,
   commitCvmComposeFileUpdate,
   commitCvmProvision,
-  createClient,
+  createClient as createBaseClient,
+  createClient2 as createClient,
   createClientsFromBrowser,
   createClientsFromPrivateKey,
   createNetworkClients,