@phala/cloud 0.0.5 → 0.0.6

package/dist/index.mjs

@@ -216,9 +216,133 @@ function createClient(config = {}) {
   return new Client(config);
 }
 
-// src/actions/get_current_user.ts
+// src/types/kms_info.ts
 import { z as z2 } from "zod";
 
+// src/types/supported_chains.ts
+import { anvil, base, mainnet } from "viem/chains";
+var SUPPORTED_CHAINS = {
+  [mainnet.id]: mainnet,
+  [base.id]: base,
+  [anvil.id]: anvil
+};
+
+// 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)
+}).passthrough();
+var KmsInfoSchema = KmsInfoBaseSchema.transform((data) => {
+  if (data.chain_id != null) {
+    const chain = SUPPORTED_CHAINS[data.chain_id];
+    if (chain) {
+      return { ...data, chain };
+    }
+  }
+  return data;
+});
+
+// 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(),
+  // 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()
+});
+var ManagedUserSchema = z3.object({
+  id: z3.number(),
+  username: z3.string()
+});
+var CvmNodeSchema = z3.object({
+  id: z3.number(),
+  name: z3.string(),
+  region_identifier: z3.string().optional()
+});
+var CvmNetworkUrlsSchema = z3.object({
+  app: z3.string(),
+  instance: z3.string()
+});
+var KMSInfoSchema = z3.object({
+  id: z3.string(),
+  // HashedId is represented as string in JS
+  slug: z3.string(),
+  url: z3.string(),
+  version: z3.string(),
+  chain_id: z3.number().optional(),
+  kms_contract_address: z3.string().optional(),
+  gateway_app_id: z3.string().optional()
+});
+var CvmInfoSchema = z3.object({
+  hosted: VmInfoSchema,
+  name: z3.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(),
+  // HashedId is represented as string in JS
+  project_type: z3.string().nullable(),
+  billing_period: z3.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)
+}).partial();
+var CvmLegacyDetailSchema = z3.object({
+  id: z3.number(),
+  name: z3.string(),
+  status: z3.string(),
+  in_progress: z3.boolean(),
+  teepod_id: z3.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(),
+  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()
+});
+
+// src/actions/get_current_user.ts
+import { z as z4 } from "zod";
+
 // src/utils/index.ts
 import { encryptEnvVars } from "@phala/dstack-sdk/encrypt-env-vars";
 
@@ -889,14 +1013,14 @@ async function autoCreateClients(chain, options = {}) {
 }
 
 // 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()
+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);
@@ -924,74 +1048,41 @@ async function safeGetCurrentUser(client, parameters) {
 }
 
 // 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 = {
-  [mainnet.id]: mainnet,
-  [base.id]: base,
-  [anvil.id]: anvil
-};
-
-// src/types/kms_info.ts
-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) {
-    const chain = SUPPORTED_CHAINS[data.chain_id];
-    if (chain) {
-      return { ...data, chain };
-    }
-  }
-  return data;
-});
-
-// src/actions/get_available_nodes.ts
-var AvailableOSImageSchema = z4.object({
-  name: z4.string(),
-  is_dev: z4.boolean(),
-  version: z4.tuple([z4.number(), z4.number(), z4.number()]),
-  os_image_hash: z4.string().nullable().optional()
+import { z as z5 } from "zod";
+var AvailableOSImageSchema = z5.object({
+  name: z5.string(),
+  is_dev: z5.boolean(),
+  version: z5.tuple([z5.number(), z5.number(), z5.number()]),
+  os_image_hash: z5.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([])
+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 = 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()
+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 = z4.object({
-  tier: z4.string(),
+var AvailableNodesSchema = z5.object({
+  tier: z5.string(),
   // TeamTier is string enum
   capacity: ResourceThresholdSchema,
-  nodes: z4.array(TeepodCapacitySchema),
-  kms_list: z4.array(KmsInfoSchema)
+  nodes: z5.array(TeepodCapacitySchema),
+  kms_list: z5.array(KmsInfoSchema)
 }).passthrough();
 async function getAvailableNodes(client, parameters) {
   const response = await client.get("/teepods/available");
@@ -1014,44 +1105,44 @@ async function safeGetAvailableNodes(client, parameters) {
 }
 
 // src/actions/provision_cvm.ts
-import { z as z5 } from "zod";
-var ProvisionCvmSchema = z5.object({
-  app_id: z5.string().nullable().optional(),
-  app_env_encrypt_pubkey: z5.string().nullable().optional(),
-  compose_hash: z5.string(),
-  fmspc: z5.string().nullable().optional(),
-  device_id: z5.string().nullable().optional(),
-  os_image_hash: z5.string().nullable().optional(),
-  node_id: z5.number().nullable().optional()
+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(),
+  node_id: z6.number().nullable().optional()
   // Transformed from teepod_id in response
 }).passthrough();
-var ProvisionCvmRequestSchema = z5.object({
-  node_id: z5.number().optional(),
+var ProvisionCvmRequestSchema = z6.object({
+  node_id: z6.number().optional(),
   // recommended
-  teepod_id: z5.number().optional(),
+  teepod_id: z6.number().optional(),
   // deprecated, for compatibility
-  name: z5.string(),
-  image: z5.string(),
-  vcpu: z5.number(),
-  memory: z5.number(),
-  disk_size: z5.number(),
-  compose_file: z5.object({
-    allowed_envs: z5.array(z5.string()).optional(),
-    pre_launch_script: z5.string().optional(),
-    docker_compose_file: z5.string().optional(),
-    name: z5.string().optional(),
-    kms_enabled: z5.boolean().optional(),
-    public_logs: z5.boolean().optional(),
-    public_sysinfo: z5.boolean().optional(),
-    gateway_enabled: z5.boolean().optional(),
+  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: z5.boolean().optional()
+    tproxy_enabled: z6.boolean().optional()
     // deprecated, for compatibility
   }),
-  listed: z5.boolean().optional(),
-  instance_type: z5.string().nullable().optional(),
-  kms_id: z5.string().optional(),
-  env_keys: z5.array(z5.string()).optional()
+  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) {
@@ -1143,43 +1234,43 @@ async function safeProvisionCvm(client, appCompose, parameters) {
 }
 
 // src/actions/commit_cvm_provision.ts
-import { z as z6 } from "zod";
-var CommitCvmProvisionSchema = z6.object({
-  id: z6.number(),
-  name: z6.string(),
-  status: z6.string(),
-  teepod_id: z6.number(),
-  teepod: z6.object({
-    id: z6.number(),
-    name: z6.string()
+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: z6.number().nullable(),
-  app_id: z6.string().nullable(),
-  vm_uuid: z6.string().nullable(),
-  instance_id: z6.string().nullable(),
-  app_url: z6.string().nullable(),
-  base_image: z6.string().nullable(),
-  vcpu: z6.number(),
-  memory: z6.number(),
-  disk_size: z6.number(),
-  manifest_version: z6.number().nullable(),
-  version: z6.string().nullable(),
-  runner: z6.string().nullable(),
-  docker_compose_file: z6.string().nullable(),
-  features: z6.array(z6.string()).nullable(),
-  created_at: z6.string(),
-  encrypted_env_pubkey: z6.string().nullable().optional(),
-  app_auth_contract_address: z6.string().nullable().optional(),
-  deployer_address: z6.string().nullable().optional()
+  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 = z6.object({
-  encrypted_env: z6.string().optional().nullable(),
-  app_id: z6.string(),
-  compose_hash: z6.string().optional(),
-  kms_id: z6.string().optional(),
-  contract_address: z6.string().optional(),
-  deployer_address: z6.string().optional(),
-  env_keys: z6.array(z6.string()).optional().nullable()
+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();
 async function commitCvmProvision(client, payload, parameters) {
   validateActionParameters(parameters);
@@ -1208,7 +1299,7 @@ async function safeCommitCvmProvision(client, payload, parameters) {
 }
 
 // src/actions/deploy_app_auth.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 import {
   createPublicClient as createPublicClient2,
   createWalletClient as createWalletClient2,
@@ -1247,25 +1338,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = z7.object({
+var DeployAppAuthRequestBaseSchema = z8.object({
   // Chain configuration (conditionally required)
-  chain: z7.unknown().optional(),
-  rpcUrl: z7.string().optional(),
+  chain: z8.unknown().optional(),
+  rpcUrl: z8.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: z7.string(),
+  kmsContractAddress: z8.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z7.string().optional(),
-  walletClient: z7.unknown().optional(),
+  privateKey: z8.string().optional(),
+  walletClient: z8.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z7.unknown().optional(),
+  publicClient: z8.unknown().optional(),
   // App configuration (optional)
-  allowAnyDevice: z7.boolean().optional().default(false),
-  deviceId: z7.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  composeHash: z7.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  disableUpgrades: z7.boolean().optional().default(false),
+  allowAnyDevice: z8.boolean().optional().default(false),
+  deviceId: z8.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: z8.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: z8.boolean().optional().default(false),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z7.boolean().optional().default(false),
-  minBalance: z7.string().optional()
+  skipPrerequisiteChecks: z8.boolean().optional().default(false),
+  minBalance: z8.string().optional()
   // ETH amount as string, e.g., "0.01"
 }).passthrough();
 var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
@@ -1293,13 +1384,13 @@ var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
     path: ["chain"]
   }
 );
-var DeployAppAuthSchema = z7.object({
-  appId: z7.string(),
-  appAuthAddress: z7.string(),
-  deployer: z7.string(),
-  transactionHash: z7.string(),
-  blockNumber: z7.bigint().optional(),
-  gasUsed: z7.bigint().optional()
+var DeployAppAuthSchema = z8.object({
+  appId: z8.string(),
+  appAuthAddress: z8.string(),
+  deployer: z8.string(),
+  transactionHash: z8.string(),
+  blockNumber: z8.bigint().optional(),
+  gasUsed: z8.bigint().optional()
 }).passthrough();
 function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
   try {
@@ -1545,7 +1636,7 @@ async function safeDeployAppAuth(request, parameters) {
 }
 
 // src/actions/add_compose_hash.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient3,
@@ -1569,29 +1660,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = z8.object({
+var AddComposeHashRequestSchema = z9.object({
   // Chain configuration (conditionally required)
-  chain: z8.unknown().optional(),
-  rpcUrl: z8.string().optional(),
-  appId: z8.string(),
-  composeHash: z8.string(),
+  chain: z9.unknown().optional(),
+  rpcUrl: z9.string().optional(),
+  appId: z9.string(),
+  composeHash: z9.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z8.string().optional(),
-  walletClient: z8.unknown().optional(),
+  privateKey: z9.string().optional(),
+  walletClient: z9.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z8.unknown().optional(),
+  publicClient: z9.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z8.boolean().optional().default(false),
-  minBalance: z8.string().optional(),
+  skipPrerequisiteChecks: z9.boolean().optional().default(false),
+  minBalance: z9.string().optional(),
   // ETH amount as string, e.g., "0.01"
   // Transaction control options
-  timeout: z8.number().optional().default(12e4),
-  retryOptions: z8.unknown().optional(),
-  signal: z8.unknown().optional(),
+  timeout: z9.number().optional().default(12e4),
+  retryOptions: z9.unknown().optional(),
+  signal: z9.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: z8.function().optional(),
-  onTransactionSubmitted: z8.function().optional(),
-  onTransactionConfirmed: z8.function().optional()
+  onTransactionStateChange: z9.function().optional(),
+  onTransactionSubmitted: z9.function().optional(),
+  onTransactionConfirmed: z9.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -1615,12 +1706,12 @@ var AddComposeHashRequestSchema = z8.object({
     path: ["chain"]
   }
 );
-var AddComposeHashSchema = z8.object({
-  composeHash: z8.string(),
-  appId: z8.string(),
-  transactionHash: z8.string(),
-  blockNumber: z8.bigint().optional(),
-  gasUsed: z8.bigint().optional()
+var AddComposeHashSchema = z9.object({
+  composeHash: z9.string(),
+  appId: z9.string(),
+  transactionHash: z9.string(),
+  blockNumber: z9.bigint().optional(),
+  gasUsed: z9.bigint().optional()
 }).passthrough();
 function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
   console.log(receipt.logs);
@@ -1812,27 +1903,27 @@ async function safeAddComposeHash(request, parameters) {
 }
 
 // src/actions/get_cvm_compose_file.ts
-import { z as z9 } from "zod";
-var GetCvmComposeFileResultSchema = z9.object({
-  allowed_envs: z9.array(z9.string()).optional(),
-  docker_compose_file: z9.string(),
-  features: z9.array(z9.string()).optional(),
-  name: z9.string().optional(),
-  manifest_version: z9.number().optional(),
-  kms_enabled: z9.boolean().optional(),
-  public_logs: z9.boolean().optional(),
-  public_sysinfo: z9.boolean().optional(),
-  tproxy_enabled: z9.boolean().optional(),
-  pre_launch_script: z9.string().optional()
+import { z as z10 } from "zod";
+var GetCvmComposeFileResultSchema = 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();
-var GetCvmComposeFileRequestSchema = z9.object({
-  id: z9.string().optional(),
-  uuid: z9.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: z9.string().refine(
+var GetCvmComposeFileRequestSchema = z10.object({
+  id: z10.string().optional(),
+  uuid: z10.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: z10.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: z9.string().refine(
+  instance_id: z10.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()
@@ -1869,26 +1960,26 @@ async function safeGetCvmComposeFile(client, request, parameters) {
 }
 
 // src/actions/provision_cvm_compose_file_update.ts
-import { z as z10 } from "zod";
-var ProvisionCvmComposeFileUpdateRequestSchema = z10.object({
-  id: z10.string().optional(),
-  uuid: z10.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: z10.string().refine(
+import { z as z11 } from "zod";
+var ProvisionCvmComposeFileUpdateRequestSchema = 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: z10.string().refine(
+  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(),
-  app_compose: z10.object({
-    allowed_envs: z10.array(z10.string()).optional(),
-    docker_compose_file: z10.string().min(1, "Docker compose file is required"),
-    name: z10.string(),
-    kms_enabled: z10.boolean().optional(),
-    public_logs: z10.boolean().optional(),
-    public_sysinfo: z10.boolean().optional(),
-    pre_launch_script: z10.string().optional()
+  app_compose: z11.object({
+    allowed_envs: z11.array(z11.string()).optional(),
+    docker_compose_file: z11.string().min(1, "Docker compose file is required"),
+    name: z11.string(),
+    kms_enabled: z11.boolean().optional(),
+    public_logs: z11.boolean().optional(),
+    public_sysinfo: z11.boolean().optional(),
+    pre_launch_script: z11.string().optional()
   })
 }).refine(
   (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
@@ -1898,10 +1989,10 @@ var ProvisionCvmComposeFileUpdateRequestSchema = z10.object({
   request: data.app_compose,
   _raw: data
 }));
-var ProvisionCvmComposeFileUpdateResultSchema = z10.object({
-  app_id: z10.string().nullable(),
-  device_id: z10.string().nullable(),
-  compose_hash: z10.string(),
+var ProvisionCvmComposeFileUpdateResultSchema = z11.object({
+  app_id: z11.string().nullable(),
+  device_id: z11.string().nullable(),
+  compose_hash: z11.string(),
   kms_info: KmsInfoSchema.nullable().optional()
 }).passthrough();
 async function provisionCvmComposeFileUpdate(client, request, parameters) {
@@ -1936,21 +2027,21 @@ async function safeProvisionCvmComposeFileUpdate(client, request, parameters) {
 }
 
 // src/actions/commit_cvm_compose_file_update.ts
-import { z as z11 } from "zod";
-var CommitCvmComposeFileUpdateRequestSchema = 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(
+import { z as z12 } from "zod";
+var CommitCvmComposeFileUpdateRequestSchema = 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: z11.string().refine(
+  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(),
-  compose_hash: z11.string().min(1, "Compose hash is required"),
-  encrypted_env: z11.string().optional(),
-  env_keys: z11.array(z11.string()).optional()
+  compose_hash: z12.string().min(1, "Compose hash is required"),
+  encrypted_env: z12.string().optional(),
+  env_keys: z12.array(z12.string()).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"
@@ -1961,7 +2052,7 @@ var CommitCvmComposeFileUpdateRequestSchema = z11.object({
   env_keys: data.env_keys,
   _raw: data
 }));
-var CommitCvmComposeFileUpdateSchema = z11.any().transform(() => void 0);
+var CommitCvmComposeFileUpdateSchema = z12.any().transform(() => void 0);
 async function commitCvmComposeFileUpdate(client, request, parameters) {
   const validatedRequest = CommitCvmComposeFileUpdateRequestSchema.parse(request);
   const response = await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
@@ -1996,17 +2087,17 @@ async function safeCommitCvmComposeFileUpdate(client, request, parameters) {
 }
 
 // src/actions/get_app_env_encrypt_pubkey.ts
-import { z as z12 } from "zod";
-var GetAppEnvEncryptPubKeyRequestSchema = z12.object({
-  kms: z12.string().min(1, "KMS ID or slug is required"),
-  app_id: z12.string().refine(
+import { z as z13 } from "zod";
+var GetAppEnvEncryptPubKeyRequestSchema = z13.object({
+  kms: z13.string().min(1, "KMS ID or slug is required"),
+  app_id: z13.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 = z12.object({
-  public_key: z12.string(),
-  signature: z12.string()
+var GetAppEnvEncryptPubKeySchema = z13.object({
+  public_key: z13.string(),
+  signature: z13.string()
 }).strict();
 var getAppEnvEncryptPubKey = async (client, payload, parameters) => {
   const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
@@ -2044,101 +2135,6 @@ var safeGetAppEnvEncryptPubKey = async (client, payload, parameters) => {
 
 // src/actions/get_cvm_info.ts
 import { z as z14 } from "zod";
-
-// src/types/cvm_info.ts
-import { z as z13 } from "zod";
-var VmInfoSchema = z13.object({
-  id: z13.string(),
-  name: z13.string(),
-  status: z13.string(),
-  uptime: z13.string(),
-  app_url: z13.string().nullable(),
-  app_id: z13.string(),
-  instance_id: z13.string().nullable(),
-  configuration: z13.any().optional(),
-  // TODO: add VmConfiguration schema if needed
-  exited_at: z13.string().nullable(),
-  boot_progress: z13.string().nullable(),
-  boot_error: z13.string().nullable(),
-  shutdown_progress: z13.string().nullable(),
-  image_version: z13.string().nullable()
-});
-var ManagedUserSchema = z13.object({
-  id: z13.number(),
-  username: z13.string()
-});
-var CvmNodeSchema = z13.object({
-  id: z13.number(),
-  name: z13.string(),
-  region_identifier: z13.string().optional()
-});
-var CvmNetworkUrlsSchema = z13.object({
-  app: z13.string(),
-  instance: z13.string()
-});
-var KMSInfoSchema = z13.object({
-  id: z13.string(),
-  // HashedId is represented as string in JS
-  slug: z13.string(),
-  url: z13.string(),
-  version: z13.string(),
-  chain_id: z13.number().optional(),
-  kms_contract_address: z13.string().optional(),
-  gateway_app_id: z13.string().optional()
-});
-var CvmInfoSchema = z13.object({
-  hosted: VmInfoSchema,
-  name: z13.string(),
-  managed_user: ManagedUserSchema.optional().nullable(),
-  node: CvmNodeSchema.optional().nullable(),
-  listed: z13.boolean().default(false),
-  status: z13.string(),
-  in_progress: z13.boolean().default(false),
-  dapp_dashboard_url: z13.string().nullable(),
-  syslog_endpoint: z13.string().nullable(),
-  allow_upgrade: z13.boolean().default(false),
-  project_id: z13.string().nullable(),
-  // HashedId is represented as string in JS
-  project_type: z13.string().nullable(),
-  billing_period: z13.string().nullable(),
-  kms_info: KMSInfoSchema.nullable(),
-  vcpu: z13.number().nullable(),
-  memory: z13.number().nullable(),
-  disk_size: z13.number().nullable(),
-  gateway_domain: z13.string().nullable(),
-  public_urls: z13.array(CvmNetworkUrlsSchema)
-}).partial();
-var CvmLegacyDetailSchema = z13.object({
-  id: z13.number(),
-  name: z13.string(),
-  status: z13.string(),
-  in_progress: z13.boolean(),
-  teepod_id: z13.number().nullable(),
-  teepod: CvmNodeSchema,
-  app_id: z13.string(),
-  vm_uuid: z13.string().nullable(),
-  instance_id: z13.string().nullable(),
-  vcpu: z13.number().nullable(),
-  memory: z13.number().nullable(),
-  disk_size: z13.number().nullable(),
-  base_image: z13.string(),
-  encrypted_env_pubkey: z13.string().nullable(),
-  listed: z13.boolean(),
-  project_id: z13.string().nullable(),
-  project_type: z13.string().nullable(),
-  public_sysinfo: z13.boolean(),
-  public_logs: z13.boolean(),
-  dapp_dashboard_url: z13.string().nullable(),
-  syslog_endpoint: z13.string().nullable(),
-  kms_info: KMSInfoSchema.nullable(),
-  contract_address: z13.string().nullable(),
-  deployer_address: z13.string().nullable(),
-  scheduled_delete_at: z13.string().nullable(),
-  public_urls: z13.array(CvmNetworkUrlsSchema),
-  gateway_domain: z13.string().nullable()
-});
-
-// src/actions/get_cvm_info.ts
 var GetCvmInfoRequestSchema = 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(),
@@ -2369,20 +2365,28 @@ export {
   CommitCvmProvisionRequestSchema,
   CommitCvmProvisionSchema,
   CurrentUserSchema,
+  CvmInfoSchema,
   CvmLegacyDetailSchema,
+  CvmNetworkUrlsSchema,
+  CvmNodeSchema,
   DeployAppAuthRequestSchema,
   DeployAppAuthSchema,
   GetAppEnvEncryptPubKeySchema,
   GetCvmComposeFileResultSchema,
   GetCvmListSchema,
   GetKmsListSchema,
+  KMSInfoSchema,
+  KmsInfoSchema,
+  ManagedUserSchema,
   NetworkError,
   ProvisionCvmComposeFileUpdateRequestSchema,
   ProvisionCvmComposeFileUpdateResultSchema,
   ProvisionCvmRequestSchema,
   ProvisionCvmSchema,
   RequestError,
+  SUPPORTED_CHAINS,
   TransactionError,
+  VmInfoSchema,
   WalletError,
   addComposeHash,
   addNetwork,