@phala/cloud 0.0.1

package/dist/index.js

@@ -0,0 +1,2433 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AddComposeHashSchema: () => AddComposeHashSchema,
+  ApiErrorSchema: () => ApiErrorSchema,
+  AvailableNodesSchema: () => AvailableNodesSchema,
+  CommitCvmComposeFileUpdateRequestSchema: () => CommitCvmComposeFileUpdateRequestSchema,
+  CommitCvmComposeFileUpdateSchema: () => CommitCvmComposeFileUpdateSchema,
+  CommitCvmProvisionRequestSchema: () => CommitCvmProvisionRequestSchema,
+  CommitCvmProvisionSchema: () => CommitCvmProvisionSchema,
+  CurrentUserSchema: () => CurrentUserSchema,
+  DeployAppAuthRequestSchema: () => DeployAppAuthRequestSchema,
+  DeployAppAuthSchema: () => DeployAppAuthSchema,
+  GetAppEnvEncryptPubKeySchema: () => GetAppEnvEncryptPubKeySchema,
+  GetCvmComposeFileResultSchema: () => GetCvmComposeFileResultSchema,
+  GetCvmInfoSchema: () => GetCvmInfoSchema,
+  GetCvmListSchema: () => GetCvmListSchema,
+  GetKmsListSchema: () => GetKmsListSchema,
+  NetworkError: () => NetworkError,
+  ProvisionCvmComposeFileUpdateRequestSchema: () => ProvisionCvmComposeFileUpdateRequestSchema,
+  ProvisionCvmComposeFileUpdateResultSchema: () => ProvisionCvmComposeFileUpdateResultSchema,
+  ProvisionCvmRequestSchema: () => ProvisionCvmRequestSchema,
+  ProvisionCvmSchema: () => ProvisionCvmSchema,
+  RequestError: () => RequestError,
+  TransactionError: () => TransactionError,
+  WalletError: () => WalletError,
+  addComposeHash: () => addComposeHash,
+  addNetwork: () => addNetwork,
+  asHex: () => asHex,
+  autoCreateClients: () => autoCreateClients,
+  checkBalance: () => checkBalance,
+  checkNetworkStatus: () => checkNetworkStatus,
+  commitCvmComposeFileUpdate: () => commitCvmComposeFileUpdate,
+  commitCvmProvision: () => commitCvmProvision,
+  createClient: () => createClient,
+  createClientsFromBrowser: () => createClientsFromBrowser,
+  createClientsFromPrivateKey: () => createClientsFromPrivateKey,
+  createNetworkClients: () => createNetworkClients,
+  createTransactionTracker: () => createTransactionTracker,
+  deployAppAuth: () => deployAppAuth,
+  encryptEnvVars: () => import_encrypt_env_vars2.encryptEnvVars,
+  estimateTransactionGas: () => estimateTransactionGas,
+  executeBatchTransactions: () => executeBatchTransactions,
+  executeTransaction: () => executeTransaction,
+  executeTransactionWithRetry: () => executeTransactionWithRetry,
+  extractNetworkClients: () => extractNetworkClients,
+  getAppEnvEncryptPubKey: () => getAppEnvEncryptPubKey,
+  getAvailableNodes: () => getAvailableNodes,
+  getComposeHash: () => import_dstack_sdk.getComposeHash,
+  getCurrentUser: () => getCurrentUser,
+  getCvmComposeFile: () => getCvmComposeFile,
+  getCvmInfo: () => getCvmInfo,
+  getCvmList: () => getCvmList,
+  getErrorMessage: () => getErrorMessage,
+  getKmsInfo: () => getKmsInfo,
+  getKmsList: () => getKmsList,
+  provisionCvm: () => provisionCvm,
+  provisionCvmComposeFileUpdate: () => provisionCvmComposeFileUpdate,
+  safeAddComposeHash: () => safeAddComposeHash,
+  safeCommitCvmComposeFileUpdate: () => safeCommitCvmComposeFileUpdate,
+  safeCommitCvmProvision: () => safeCommitCvmProvision,
+  safeDeployAppAuth: () => safeDeployAppAuth,
+  safeGetAppEnvEncryptPubKey: () => safeGetAppEnvEncryptPubKey,
+  safeGetAvailableNodes: () => safeGetAvailableNodes,
+  safeGetCurrentUser: () => safeGetCurrentUser,
+  safeGetCvmComposeFile: () => safeGetCvmComposeFile,
+  safeGetCvmInfo: () => safeGetCvmInfo,
+  safeGetCvmList: () => safeGetCvmList,
+  safeGetKmsInfo: () => safeGetKmsInfo,
+  safeGetKmsList: () => safeGetKmsList,
+  safeProvisionCvm: () => safeProvisionCvm,
+  safeProvisionCvmComposeFileUpdate: () => safeProvisionCvmComposeFileUpdate,
+  safeValidateActionParameters: () => safeValidateActionParameters,
+  switchToNetwork: () => switchToNetwork,
+  validateActionParameters: () => validateActionParameters,
+  validateNetworkPrerequisites: () => validateNetworkPrerequisites,
+  verifyEnvEncryptPublicKey: () => import_dstack_sdk2.verifyEnvEncryptPublicKey,
+  waitForTransactionReceipt: () => waitForTransactionReceipt
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_ofetch = require("ofetch");
+
+// src/types/client.ts
+var import_zod = require("zod");
+var ApiErrorSchema = import_zod.z.object({
+  detail: import_zod.z.union([
+    import_zod.z.string(),
+    import_zod.z.array(
+      import_zod.z.object({
+        msg: import_zod.z.string(),
+        type: import_zod.z.string().optional(),
+        ctx: import_zod.z.record(import_zod.z.unknown()).optional()
+      })
+    ),
+    import_zod.z.record(import_zod.z.unknown())
+  ]),
+  type: import_zod.z.string().optional(),
+  code: import_zod.z.string().optional()
+});
+var RequestError = class _RequestError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "RequestError";
+    this.isRequestError = true;
+    this.status = options?.status;
+    this.statusText = options?.statusText;
+    this.data = options?.data;
+    this.request = options?.request;
+    this.response = options?.response;
+    this.detail = options?.detail || message;
+    this.code = options?.code;
+    this.type = options?.type;
+  }
+  /**
+   * Create RequestError from FetchError
+   */
+  static fromFetchError(error) {
+    const parseResult = ApiErrorSchema.safeParse(error.data);
+    if (parseResult.success) {
+      return new _RequestError(error.message, {
+        status: error.status ?? void 0,
+        statusText: error.statusText ?? void 0,
+        data: error.data,
+        request: error.request ?? void 0,
+        response: error.response ?? void 0,
+        detail: parseResult.data.detail,
+        code: parseResult.data.code ?? void 0,
+        type: parseResult.data.type ?? void 0
+      });
+    }
+    return new _RequestError(error.message, {
+      status: error.status ?? void 0,
+      statusText: error.statusText ?? void 0,
+      data: error.data,
+      request: error.request ?? void 0,
+      response: error.response ?? void 0,
+      detail: error.data?.detail || "Unknown API error",
+      code: error.status?.toString() ?? void 0
+    });
+  }
+  /**
+   * Create RequestError from generic Error
+   */
+  static fromError(error, request) {
+    return new _RequestError(error.message, {
+      request: request ?? void 0,
+      detail: error.message
+    });
+  }
+};
+
+// src/client.ts
+var Client = class {
+  constructor(config = {}) {
+    const resolvedConfig = {
+      ...config,
+      apiKey: config.apiKey || process.env.PHALA_CLOUD_API_KEY,
+      baseURL: config.baseURL || process.env.PHALA_CLOUD_API_PREFIX || "https://cloud-api.phala.network/api/v1"
+    };
+    this.config = resolvedConfig;
+    if (!resolvedConfig.apiKey) {
+      throw new Error(
+        "API key is required. Provide it via config.apiKey or set PHALA_CLOUD_API_KEY environment variable."
+      );
+    }
+    const { apiKey, baseURL, timeout, headers, ...fetchOptions } = resolvedConfig;
+    this.fetchInstance = import_ofetch.ofetch.create({
+      baseURL,
+      timeout: timeout || 3e4,
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json",
+        ...headers || {}
+      },
+      ...fetchOptions,
+      // Generic handlers for response error (similar to request.ts)
+      onResponseError: ({ response }) => {
+        console.warn(`HTTP ${response.status}: ${response.url}`);
+      }
+    });
+  }
+  /**
+   * Get the underlying ofetch instance for advanced usage
+   */
+  get raw() {
+    return this.fetchInstance;
+  }
+  // ===== Direct methods (throw on error) =====
+  /**
+   * Perform GET request (throws on error)
+   */
+  async get(request, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "GET"
+    });
+  }
+  /**
+   * Perform POST request (throws on error)
+   */
+  async post(request, body, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "POST",
+      body
+    });
+  }
+  /**
+   * Perform PUT request (throws on error)
+   */
+  async put(request, body, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "PUT",
+      body
+    });
+  }
+  /**
+   * Perform PATCH request (throws on error)
+   */
+  async patch(request, body, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "PATCH",
+      body
+    });
+  }
+  /**
+   * Perform DELETE request (throws on error)
+   */
+  async delete(request, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "DELETE"
+    });
+  }
+  // ===== Safe methods (return SafeResult) =====
+  /**
+   * Safe wrapper for any request method (zod-style result)
+   */
+  async safeRequest(fn) {
+    try {
+      const data = await fn();
+      return { success: true, data };
+    } catch (error) {
+      if (error && typeof error === "object" && "data" in error) {
+        const requestError2 = RequestError.fromFetchError(error);
+        return { success: false, error: requestError2 };
+      }
+      if (error instanceof Error) {
+        const requestError2 = RequestError.fromError(error);
+        return { success: false, error: requestError2 };
+      }
+      const requestError = new RequestError("Unknown error occurred", {
+        detail: "Unknown error occurred"
+      });
+      return { success: false, error: requestError };
+    }
+  }
+  /**
+   * Safe GET request (returns SafeResult)
+   */
+  async safeGet(request, options) {
+    return this.safeRequest(() => this.get(request, options));
+  }
+  /**
+   * Safe POST request (returns SafeResult)
+   */
+  async safePost(request, body, options) {
+    return this.safeRequest(() => this.post(request, body, options));
+  }
+  /**
+   * Safe PUT request (returns SafeResult)
+   */
+  async safePut(request, body, options) {
+    return this.safeRequest(() => this.put(request, body, options));
+  }
+  /**
+   * Safe PATCH request (returns SafeResult)
+   */
+  async safePatch(request, body, options) {
+    return this.safeRequest(() => this.patch(request, body, options));
+  }
+  /**
+   * Safe DELETE request (returns SafeResult)
+   */
+  async safeDelete(request, options) {
+    return this.safeRequest(() => this.delete(request, options));
+  }
+};
+function createClient(config = {}) {
+  return new Client(config);
+}
+
+// src/actions/get_current_user.ts
+var import_zod2 = require("zod");
+
+// src/utils/index.ts
+var import_encrypt_env_vars = require("@phala/dstack-sdk/encrypt-env-vars");
+
+// src/utils/get_error_message.ts
+function getErrorMessage(error) {
+  if (typeof error.detail === "string") {
+    return error.detail;
+  }
+  if (Array.isArray(error.detail)) {
+    if (error.detail.length > 0) {
+      return error.detail[0]?.msg || "Validation error";
+    }
+    return "Validation error";
+  }
+  if (typeof error.detail === "object" && error.detail !== null) {
+    return JSON.stringify(error.detail);
+  }
+  return "Unknown error occurred";
+}
+
+// src/utils/as-hex.ts
+var import_viem = require("viem");
+function asHex(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("0x") && (0, import_viem.isHex)(value)) {
+      return value;
+    } else if ((0, import_viem.isHex)(`0x${value}`)) {
+      return `0x${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) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "NetworkError";
+  }
+};
+var WalletError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "WalletError";
+  }
+};
+var TransactionError = class extends Error {
+  constructor(message, hash, details) {
+    super(message);
+    this.hash = hash;
+    this.details = details;
+    this.name = "TransactionError";
+  }
+};
+function createNetworkClients(publicClient, walletClient, address, chainId) {
+  return {
+    publicClient,
+    walletClient,
+    address,
+    chainId
+  };
+}
+async function checkNetworkStatus(clients, targetChainId) {
+  try {
+    const currentChainId = await clients.walletClient.getChainId();
+    return {
+      isCorrectNetwork: currentChainId === targetChainId,
+      currentChainId
+    };
+  } catch (error) {
+    throw new NetworkError(
+      `Failed to check network status: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "NETWORK_CHECK_FAILED",
+      error
+    );
+  }
+}
+async function checkBalance(publicClient, address, minBalance) {
+  try {
+    const balance = await publicClient.getBalance({ address });
+    return {
+      address,
+      balance,
+      sufficient: minBalance ? balance >= minBalance : true,
+      required: minBalance
+    };
+  } catch (error) {
+    throw new NetworkError(
+      `Failed to check balance: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "BALANCE_CHECK_FAILED",
+      error
+    );
+  }
+}
+async function waitForTransactionReceipt(publicClient, hash, options = {}) {
+  const {
+    timeout = 6e4,
+    // 60 seconds default
+    pollingInterval = 2e3,
+    // 2 seconds default
+    confirmations = 1
+  } = options;
+  const startTime = Date.now();
+  return new Promise((resolve, reject) => {
+    const poll = async () => {
+      try {
+        const receipt = await publicClient.getTransactionReceipt({ hash });
+        if (receipt) {
+          if (confirmations > 1) {
+            const currentBlock = await publicClient.getBlockNumber();
+            const confirmationCount = currentBlock - receipt.blockNumber + 1n;
+            if (confirmationCount < BigInt(confirmations)) {
+              const elapsed = Date.now() - startTime;
+              if (elapsed >= timeout) {
+                reject(
+                  new TransactionError(`Transaction confirmation timeout after ${timeout}ms`, hash)
+                );
+                return;
+              }
+              setTimeout(poll, pollingInterval);
+              return;
+            }
+          }
+          resolve(receipt);
+        } else {
+          const elapsed = Date.now() - startTime;
+          if (elapsed >= timeout) {
+            reject(new TransactionError(`Transaction receipt timeout after ${timeout}ms`, hash));
+            return;
+          }
+          setTimeout(poll, pollingInterval);
+        }
+      } catch (error) {
+        const elapsed = Date.now() - startTime;
+        if (elapsed >= timeout) {
+          reject(
+            new TransactionError(`Transaction receipt timeout after ${timeout}ms`, hash, error)
+          );
+          return;
+        }
+        setTimeout(poll, pollingInterval);
+      }
+    };
+    poll();
+  });
+}
+async function executeTransaction(clients, operation, args, options = {}) {
+  const { timeout = 6e4, confirmations = 1, onSubmitted, onConfirmed, onError } = options;
+  try {
+    const hash = await operation(clients, ...args);
+    onSubmitted?.(hash);
+    const receipt = await waitForTransactionReceipt(clients.publicClient, hash, {
+      timeout,
+      confirmations
+    });
+    const success = receipt.status === "success";
+    if (success) {
+      onConfirmed?.(receipt);
+    } else {
+      const error = new TransactionError("Transaction failed on-chain", hash, receipt);
+      onError?.(error, hash);
+      throw error;
+    }
+    return {
+      hash,
+      receipt,
+      success
+    };
+  } catch (error) {
+    const txError = error instanceof TransactionError ? error : new TransactionError(
+      `Transaction execution failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      void 0,
+      error
+    );
+    onError?.(txError, txError.hash);
+    throw txError;
+  }
+}
+async function extractNetworkClients(publicClient, walletClient) {
+  try {
+    const address = walletClient.account?.address;
+    if (!address) {
+      throw new WalletError("WalletClient must have an account", "NO_ACCOUNT");
+    }
+    const chainId = await walletClient.getChainId();
+    return createNetworkClients(publicClient, walletClient, address, chainId);
+  } catch (error) {
+    throw new WalletError(
+      `Failed to extract network clients: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "EXTRACTION_FAILED",
+      error
+    );
+  }
+}
+async function validateNetworkPrerequisites(clients, requirements) {
+  const { targetChainId, minBalance, requiredAddress } = requirements;
+  const networkStatus = await checkNetworkStatus(clients, targetChainId);
+  const balanceResult = await checkBalance(clients.publicClient, clients.address, minBalance);
+  const addressValid = requiredAddress ? clients.address.toLowerCase() === requiredAddress.toLowerCase() : true;
+  return {
+    networkValid: networkStatus.isCorrectNetwork,
+    balanceValid: balanceResult.sufficient,
+    addressValid,
+    details: {
+      currentChainId: networkStatus.currentChainId,
+      balance: balanceResult.balance,
+      address: clients.address
+    }
+  };
+}
+
+// src/utils/transaction.ts
+function createTransactionTracker() {
+  let status = { state: "idle" };
+  let timeoutHandle;
+  let abortController;
+  const updateStatus = (newStatus) => {
+    status = { ...status, ...newStatus };
+  };
+  const reset = () => {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+      timeoutHandle = void 0;
+    }
+    if (abortController) {
+      abortController.abort();
+      abortController = void 0;
+    }
+    status = { state: "idle" };
+  };
+  const abort = () => {
+    if (abortController) {
+      abortController.abort();
+    }
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+      timeoutHandle = void 0;
+    }
+    updateStatus({
+      state: "error",
+      aborted: true,
+      error: "Transaction aborted by user"
+    });
+  };
+  const execute = async (operation, clients, args, options = {}) => {
+    const {
+      timeout = 6e4,
+      confirmations = 1,
+      onSubmitted,
+      onConfirmed,
+      onError,
+      signal
+    } = options;
+    try {
+      reset();
+      abortController = new AbortController();
+      if (signal) {
+        if (signal.aborted) {
+          throw new TransactionError("Operation was aborted before execution");
+        }
+        signal.addEventListener("abort", () => {
+          abort();
+        });
+      }
+      updateStatus({
+        state: "submitting",
+        startTime: Date.now(),
+        error: void 0,
+        hash: void 0,
+        receipt: void 0,
+        aborted: false
+      });
+      if (abortController.signal.aborted) {
+        throw new TransactionError("Transaction aborted");
+      }
+      const hash = await operation(clients, ...args);
+      if (abortController.signal.aborted) {
+        throw new TransactionError("Transaction aborted after submission", hash);
+      }
+      updateStatus({
+        state: "pending",
+        hash,
+        submitTime: Date.now()
+      });
+      onSubmitted?.(hash);
+      if (timeout > 0) {
+        timeoutHandle = setTimeout(() => {
+          if (status.state === "pending" && !abortController?.signal.aborted) {
+            updateStatus({
+              state: "timeout",
+              error: `Transaction timeout after ${timeout}ms`
+            });
+          }
+        }, timeout);
+      }
+      const receipt = await Promise.race([
+        waitForTransactionReceipt(clients.publicClient, hash, { timeout, confirmations }),
+        new Promise((_, reject) => {
+          abortController?.signal.addEventListener("abort", () => {
+            reject(new TransactionError("Transaction aborted while waiting for receipt", hash));
+          });
+        })
+      ]);
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = void 0;
+      }
+      const success = receipt.status === "success";
+      updateStatus({
+        state: success ? "success" : "error",
+        receipt,
+        confirmTime: Date.now(),
+        error: success ? void 0 : "Transaction failed on-chain"
+      });
+      if (success) {
+        onConfirmed?.(receipt);
+      } else {
+        const error = new TransactionError("Transaction failed on-chain", hash, receipt);
+        onError?.(error, hash);
+        throw error;
+      }
+      return {
+        hash,
+        receipt,
+        success
+      };
+    } catch (error) {
+      const txError = error instanceof TransactionError ? error : new TransactionError(
+        `Transaction execution failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        status.hash,
+        error
+      );
+      updateStatus({
+        state: "error",
+        error: txError.message
+      });
+      onError?.(txError, status.hash);
+      throw txError;
+    }
+  };
+  return {
+    get status() {
+      return { ...status };
+    },
+    get isIdle() {
+      return status.state === "idle";
+    },
+    get isSubmitting() {
+      return status.state === "submitting";
+    },
+    get isPending() {
+      return status.state === "pending";
+    },
+    get isSuccess() {
+      return status.state === "success";
+    },
+    get isError() {
+      return status.state === "error";
+    },
+    get isTimeout() {
+      return status.state === "timeout";
+    },
+    get isAborted() {
+      return status.aborted === true;
+    },
+    get isComplete() {
+      return ["success", "error", "timeout"].includes(status.state);
+    },
+    abort,
+    reset,
+    execute
+  };
+}
+async function executeBatchTransactions(operations, clients, batchOptions) {
+  const { mode, failFast = false, onProgress } = batchOptions;
+  const results = [];
+  if (mode === "sequential") {
+    for (let i = 0; i < operations.length; i++) {
+      const op = operations[i];
+      if (!op) continue;
+      const { operation, args, options } = op;
+      try {
+        const tracker = createTransactionTracker();
+        const result = await tracker.execute(operation, clients, args, options);
+        results.push(result);
+        onProgress?.(i + 1, operations.length, results);
+      } catch (error) {
+        const txError = error instanceof Error ? error : new Error(String(error));
+        results.push(txError);
+        onProgress?.(i + 1, operations.length, results);
+        if (failFast) {
+          for (let j = i + 1; j < operations.length; j++) {
+            results.push(new Error("Cancelled due to previous failure"));
+          }
+          break;
+        }
+      }
+    }
+  } else {
+    const promises = operations.map(async ({ operation, args, options }) => {
+      try {
+        const tracker = createTransactionTracker();
+        return await tracker.execute(operation, clients, args, options);
+      } catch (error) {
+        return error instanceof Error ? error : new Error(String(error));
+      }
+    });
+    const allResults = await Promise.allSettled(promises);
+    results.push(...allResults.map((r) => r.status === "fulfilled" ? r.value : r.reason));
+    onProgress?.(operations.length, operations.length, results);
+  }
+  const successCount = results.filter((r) => !(r instanceof Error)).length;
+  const errorCount = results.length - successCount;
+  return {
+    results,
+    successCount,
+    errorCount,
+    allSuccessful: errorCount === 0
+  };
+}
+async function executeTransactionWithRetry(operation, clients, args, options = {}, retryOptions = {}) {
+  const {
+    maxRetries = 3,
+    initialDelay = 1e3,
+    maxDelay = 1e4,
+    backoffFactor = 2,
+    retryCondition = () => true
+  } = retryOptions;
+  let lastError;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const tracker = createTransactionTracker();
+      return await tracker.execute(operation, clients, args, options);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt === maxRetries) {
+        break;
+      }
+      if (!retryCondition(lastError)) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay = Math.min(delay * backoffFactor, maxDelay);
+    }
+  }
+  throw lastError;
+}
+async function estimateTransactionGas(clients, transaction, options = {}) {
+  const {
+    gasLimitMultiplier = 1.2,
+    maxFeePerGasMultiplier = 1.1,
+    priorityFeeMultiplier = 1.1
+  } = options;
+  try {
+    const estimatedGas = await clients.publicClient.estimateGas(transaction);
+    const gasLimit = BigInt(Math.ceil(Number(estimatedGas) * gasLimitMultiplier));
+    let maxFeePerGas;
+    let maxPriorityFeePerGas;
+    try {
+      const feeData = await clients.publicClient.estimateFeesPerGas();
+      if (feeData.maxFeePerGas) {
+        maxFeePerGas = BigInt(Math.ceil(Number(feeData.maxFeePerGas) * maxFeePerGasMultiplier));
+      }
+      if (feeData.maxPriorityFeePerGas) {
+        maxPriorityFeePerGas = BigInt(
+          Math.ceil(Number(feeData.maxPriorityFeePerGas) * priorityFeeMultiplier)
+        );
+      }
+    } catch (error) {
+    }
+    return {
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas
+    };
+  } catch (error) {
+    throw new TransactionError(
+      `Gas estimation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      void 0,
+      error
+    );
+  }
+}
+
+// src/utils/client-factories.ts
+var import_viem2 = require("viem");
+var import_accounts = require("viem/accounts");
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.ethereum !== "undefined";
+}
+function getEthereumProvider() {
+  if (!isBrowser()) return null;
+  const ethereum = window.ethereum;
+  return ethereum || null;
+}
+function createClientsFromPrivateKey(chain, privateKey, rpcUrl) {
+  try {
+    const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+    const publicClient = (0, import_viem2.createPublicClient)({
+      chain,
+      transport: (0, import_viem2.http)(rpcUrl || chain.rpcUrls.default.http[0])
+    });
+    const walletClient = (0, import_viem2.createWalletClient)({
+      account,
+      chain,
+      transport: (0, import_viem2.http)(rpcUrl || chain.rpcUrls.default.http[0])
+    });
+    return createNetworkClients(publicClient, walletClient, account.address, chain.id);
+  } catch (error) {
+    throw new WalletError(
+      `Failed to create clients from private key: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "CLIENT_CREATION_FAILED",
+      error
+    );
+  }
+}
+async function createClientsFromBrowser(chain, rpcUrl) {
+  if (!isBrowser()) {
+    throw new WalletError(
+      "Browser wallet connection is only available in browser environment",
+      "NOT_BROWSER_ENVIRONMENT"
+    );
+  }
+  const provider = getEthereumProvider();
+  if (!provider) {
+    throw new WalletError(
+      "No Ethereum provider found. Please install a wallet like MetaMask.",
+      "NO_PROVIDER"
+    );
+  }
+  try {
+    const accounts = await provider.request({
+      method: "eth_requestAccounts"
+    });
+    if (!accounts || accounts.length === 0) {
+      throw new WalletError("No accounts available", "NO_ACCOUNTS");
+    }
+    const address = accounts[0];
+    const chainId = await provider.request({ method: "eth_chainId" });
+    const currentChainId = parseInt(chainId, 16);
+    if (currentChainId !== chain.id) {
+      await switchToNetwork(provider, chain.id);
+    }
+    const publicClient = (0, import_viem2.createPublicClient)({
+      chain,
+      transport: (0, import_viem2.http)(rpcUrl || chain.rpcUrls.default.http[0])
+    });
+    const walletClient = (0, import_viem2.createWalletClient)({
+      account: address,
+      chain,
+      transport: (0, import_viem2.custom)(provider)
+    });
+    return createNetworkClients(publicClient, walletClient, address, chain.id);
+  } catch (error) {
+    if (error instanceof WalletError || error instanceof NetworkError) {
+      throw error;
+    }
+    throw new WalletError(
+      `Failed to connect browser wallet: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "BROWSER_CONNECTION_FAILED",
+      error
+    );
+  }
+}
+async function switchToNetwork(provider, chainId) {
+  try {
+    await provider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: `0x${chainId.toString(16)}` }]
+    });
+  } catch (error) {
+    const errorObj = error;
+    if (errorObj.code === 4902) {
+      throw new NetworkError(
+        `Network ${chainId} not found in wallet. Please add it manually.`,
+        "NETWORK_NOT_FOUND",
+        error
+      );
+    }
+    throw new NetworkError(
+      `Failed to switch network: ${errorObj.message || "Unknown error"}`,
+      "NETWORK_SWITCH_FAILED",
+      error
+    );
+  }
+}
+async function addNetwork(provider, config) {
+  try {
+    await provider.request({
+      method: "wallet_addEthereumChain",
+      params: [
+        {
+          chainId: `0x${config.chainId.toString(16)}`,
+          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 = import_zod2.z.object({
+  username: import_zod2.z.string(),
+  email: import_zod2.z.string(),
+  credits: import_zod2.z.number(),
+  granted_credits: import_zod2.z.number(),
+  avatar: import_zod2.z.string(),
+  team_name: import_zod2.z.string(),
+  team_tier: import_zod2.z.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
+var import_zod4 = require("zod");
+
+// src/types/kms_info.ts
+var import_zod3 = require("zod");
+var KmsInfoSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  slug: import_zod3.z.string().nullable(),
+  url: import_zod3.z.string(),
+  version: import_zod3.z.string(),
+  chain_id: import_zod3.z.number().nullable(),
+  kms_contract_address: import_zod3.z.string().nullable().transform((val) => val),
+  gateway_app_id: import_zod3.z.string().nullable().transform((val) => val)
+}).passthrough();
+
+// src/actions/get_available_nodes.ts
+var AvailableOSImageSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  is_dev: import_zod4.z.boolean(),
+  version: import_zod4.z.tuple([import_zod4.z.number(), import_zod4.z.number(), import_zod4.z.number()]),
+  os_image_hash: import_zod4.z.string().nullable().optional()
+}).passthrough();
+var TeepodCapacitySchema = import_zod4.z.object({
+  teepod_id: import_zod4.z.number(),
+  name: import_zod4.z.string(),
+  listed: import_zod4.z.boolean(),
+  resource_score: import_zod4.z.number(),
+  remaining_vcpu: import_zod4.z.number(),
+  remaining_memory: import_zod4.z.number(),
+  remaining_cvm_slots: import_zod4.z.number(),
+  images: import_zod4.z.array(AvailableOSImageSchema),
+  dedicated_for_team_id: import_zod4.z.number().nullable().optional(),
+  support_onchain_kms: import_zod4.z.boolean().optional(),
+  fmspc: import_zod4.z.string().nullable().optional(),
+  device_id: import_zod4.z.string().nullable().optional()
+}).passthrough();
+var ResourceThresholdSchema = import_zod4.z.object({
+  max_instances: import_zod4.z.number().nullable().optional(),
+  max_vcpu: import_zod4.z.number().nullable().optional(),
+  max_memory: import_zod4.z.number().nullable().optional(),
+  max_disk: import_zod4.z.number().nullable().optional()
+}).passthrough();
+var AvailableNodesSchema = import_zod4.z.object({
+  tier: import_zod4.z.string(),
+  // TeamTier is string enum
+  capacity: ResourceThresholdSchema,
+  nodes: import_zod4.z.array(TeepodCapacitySchema),
+  kms_list: import_zod4.z.array(KmsInfoSchema)
+}).passthrough();
+async function getAvailableNodes(client, parameters) {
+  const response = await client.get("/teepods/available");
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || AvailableNodesSchema;
+  return schema.parse(response);
+}
+async function safeGetAvailableNodes(client, parameters) {
+  const httpResult = await client.safeGet("/teepods/available");
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const schema = parameters?.schema || AvailableNodesSchema;
+  return schema.safeParse(httpResult.data);
+}
+
+// src/actions/provision_cvm.ts
+var import_zod5 = require("zod");
+var ProvisionCvmSchema = import_zod5.z.object({
+  app_id: import_zod5.z.string().nullable().optional(),
+  app_env_encrypt_pubkey: import_zod5.z.string().nullable().optional(),
+  compose_hash: import_zod5.z.string(),
+  fmspc: import_zod5.z.string().nullable().optional(),
+  device_id: import_zod5.z.string().nullable().optional(),
+  os_image_hash: import_zod5.z.string().nullable().optional(),
+  node_id: import_zod5.z.number().nullable().optional()
+  // Transformed from teepod_id in response
+}).passthrough();
+var ProvisionCvmRequestSchema = import_zod5.z.object({
+  node_id: import_zod5.z.number().optional(),
+  // recommended
+  teepod_id: import_zod5.z.number().optional(),
+  // deprecated, for compatibility
+  name: import_zod5.z.string(),
+  image: import_zod5.z.string(),
+  vcpu: import_zod5.z.number(),
+  memory: import_zod5.z.number(),
+  disk_size: import_zod5.z.number(),
+  compose_file: import_zod5.z.object({
+    allowed_envs: import_zod5.z.array(import_zod5.z.string()).optional(),
+    pre_launch_script: import_zod5.z.string().optional(),
+    docker_compose_file: import_zod5.z.string().optional(),
+    name: import_zod5.z.string().optional(),
+    kms_enabled: import_zod5.z.boolean().optional(),
+    public_logs: import_zod5.z.boolean().optional(),
+    public_sysinfo: import_zod5.z.boolean().optional(),
+    gateway_enabled: import_zod5.z.boolean().optional(),
+    // recommended
+    tproxy_enabled: import_zod5.z.boolean().optional()
+    // deprecated, for compatibility
+  }),
+  listed: import_zod5.z.boolean().optional(),
+  instance_type: import_zod5.z.string().nullable().optional(),
+  kms_id: import_zod5.z.string().optional(),
+  env_keys: import_zod5.z.array(import_zod5.z.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
+  };
+}
+function transformResponse(data, isDefaultSchema) {
+  if (!isDefaultSchema || !data || typeof data !== "object") {
+    return data;
+  }
+  if (data && typeof data === "object" && "teepod_id" in data) {
+    const { teepod_id, ...rest } = data;
+    return { ...rest, node_id: teepod_id };
+  }
+  return data;
+}
+async function provisionCvm(client, appCompose, parameters) {
+  validateActionParameters(parameters);
+  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.");
+  }
+  const response = await client.post("/cvms/provision", requestBody);
+  const isDefaultSchema = parameters?.schema === void 0;
+  const transformedData = transformResponse(response, isDefaultSchema);
+  if (parameters?.schema === false) {
+    return transformedData;
+  }
+  const usedSchema = parameters?.schema || ProvisionCvmSchema;
+  return usedSchema.parse(transformedData);
+}
+async function safeProvisionCvm(client, appCompose, parameters) {
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const schema = parameters?.schema;
+  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.");
+  }
+  const httpResult = await client.safePost("/cvms/provision", requestBody);
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const isDefaultSchema = !schema;
+  const usedSchema = schema || ProvisionCvmSchema;
+  const transformResult = usedSchema.safeParse(transformResponse(httpResult.data, isDefaultSchema));
+  return transformResult;
+}
+
+// src/actions/commit_cvm_provision.ts
+var import_zod6 = require("zod");
+var CommitCvmProvisionSchema = import_zod6.z.object({
+  id: import_zod6.z.number(),
+  name: import_zod6.z.string(),
+  status: import_zod6.z.string(),
+  teepod_id: import_zod6.z.number(),
+  teepod: import_zod6.z.object({
+    id: import_zod6.z.number(),
+    name: import_zod6.z.string()
+  }).nullable(),
+  user_id: import_zod6.z.number().nullable(),
+  app_id: import_zod6.z.string().nullable(),
+  vm_uuid: import_zod6.z.string().nullable(),
+  instance_id: import_zod6.z.string().nullable(),
+  app_url: import_zod6.z.string().nullable(),
+  base_image: import_zod6.z.string().nullable(),
+  vcpu: import_zod6.z.number(),
+  memory: import_zod6.z.number(),
+  disk_size: import_zod6.z.number(),
+  manifest_version: import_zod6.z.number().nullable(),
+  version: import_zod6.z.string().nullable(),
+  runner: import_zod6.z.string().nullable(),
+  docker_compose_file: import_zod6.z.string().nullable(),
+  features: import_zod6.z.array(import_zod6.z.string()).nullable(),
+  created_at: import_zod6.z.string(),
+  encrypted_env_pubkey: import_zod6.z.string().nullable().optional(),
+  app_auth_contract_address: import_zod6.z.string().nullable().optional(),
+  deployer_address: import_zod6.z.string().nullable().optional()
+}).passthrough();
+var CommitCvmProvisionRequestSchema = import_zod6.z.object({
+  encrypted_env: import_zod6.z.string().optional().nullable(),
+  app_id: import_zod6.z.string(),
+  compose_hash: import_zod6.z.string().optional(),
+  kms_id: import_zod6.z.string().optional(),
+  contract_address: import_zod6.z.string().optional(),
+  deployer_address: import_zod6.z.string().optional(),
+  env_keys: import_zod6.z.array(import_zod6.z.string()).optional().nullable()
+}).passthrough();
+async function commitCvmProvision(client, payload, parameters) {
+  validateActionParameters(parameters);
+  const response = await client.post("/cvms", payload);
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || CommitCvmProvisionSchema;
+  return schema.parse(response);
+}
+async function safeCommitCvmProvision(client, payload, parameters) {
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const httpResult = await client.safePost("/cvms", payload);
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const schema = parameters?.schema || CommitCvmProvisionSchema;
+  const validationResult = schema.safeParse(httpResult.data);
+  return validationResult;
+}
+
+// src/actions/deploy_app_auth.ts
+var import_zod7 = require("zod");
+var import_viem3 = require("viem");
+var import_accounts2 = require("viem/accounts");
+var kmsAuthAbi = [
+  {
+    inputs: [
+      { name: "deployer", type: "address" },
+      { name: "disableUpgrades", type: "bool" },
+      { name: "allowAnyDevice", type: "bool" },
+      { name: "deviceId", type: "bytes32" },
+      { name: "composeHash", type: "bytes32" }
+    ],
+    name: "deployAndRegisterApp",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "appId", type: "address", indexed: true },
+      { name: "deployer", type: "address", indexed: true }
+    ],
+    name: "AppDeployedViaFactory",
+    type: "event",
+    anonymous: false
+  },
+  {
+    inputs: [{ name: "appId", type: "address", indexed: false }],
+    name: "AppRegistered",
+    type: "event",
+    anonymous: false
+  }
+];
+var DeployAppAuthRequestBaseSchema = import_zod7.z.object({
+  // Chain configuration (conditionally required)
+  chain: import_zod7.z.unknown().optional(),
+  // Contract configuration (required)
+  kmsContractAddress: import_zod7.z.string(),
+  // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
+  privateKey: import_zod7.z.string().optional(),
+  walletClient: import_zod7.z.unknown().optional(),
+  // Public client (optional, will create default if not provided)
+  publicClient: import_zod7.z.unknown().optional(),
+  // App configuration (optional)
+  allowAnyDevice: import_zod7.z.boolean().optional().default(false),
+  deviceId: import_zod7.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: import_zod7.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: import_zod7.z.boolean().optional().default(false),
+  // Validation configuration (optional)
+  skipPrerequisiteChecks: import_zod7.z.boolean().optional().default(false),
+  minBalance: import_zod7.z.string().optional()
+  // ETH amount as string, e.g., "0.01"
+}).passthrough();
+var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
+  (data) => {
+    const hasPrivateKey = !!data.privateKey;
+    const hasWalletClient = !!data.walletClient;
+    return hasPrivateKey !== hasWalletClient;
+  },
+  {
+    message: "Either 'privateKey' or 'walletClient' must be provided, but not both",
+    path: ["privateKey", "walletClient"]
+  }
+).refine(
+  (data) => {
+    const hasPublicClient = !!data.publicClient;
+    const hasWalletClient = !!data.walletClient;
+    const hasChain = !!data.chain;
+    if (hasPublicClient && hasWalletClient) {
+      return true;
+    }
+    return hasChain;
+  },
+  {
+    message: "Chain is required when publicClient or walletClient is not provided",
+    path: ["chain"]
+  }
+);
+var DeployAppAuthSchema = import_zod7.z.object({
+  appId: import_zod7.z.string(),
+  appAuthAddress: import_zod7.z.string(),
+  deployer: import_zod7.z.string(),
+  transactionHash: import_zod7.z.string(),
+  blockNumber: import_zod7.z.bigint().optional(),
+  gasUsed: import_zod7.z.bigint().optional()
+}).passthrough();
+function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
+  try {
+    const logs = (0, import_viem3.parseEventLogs)({
+      abi: kmsAuthAbi,
+      eventName: "AppDeployedViaFactory",
+      logs: receipt.logs,
+      strict: false
+    });
+    if (logs.length === 0) {
+      if (receipt.status === "reverted") {
+        throw new Error(`Transaction failed: ${receipt.transactionHash}`);
+      }
+      throw new Error(
+        `Transaction ${receipt.transactionHash} has no AppDeployedViaFactory events. The deployment failed. Status: ${receipt.status}. Found ${receipt.logs.length} logs.`
+      );
+    }
+    const deploymentEvent = logs[0];
+    if (!deploymentEvent?.args) {
+      throw new Error("Event has no data");
+    }
+    const { appId, deployer: eventDeployer } = deploymentEvent.args;
+    if (!appId) {
+      throw new Error("Event missing appId");
+    }
+    return {
+      appId,
+      appAuthAddress: appId,
+      deployer,
+      transactionHash: receipt.transactionHash,
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.gasUsed
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(`Parse failed: ${error}`);
+  }
+}
+async function deployAppAuth(request, parameters) {
+  const validatedRequest = DeployAppAuthRequestSchema.parse(request);
+  const {
+    chain,
+    kmsContractAddress,
+    privateKey,
+    walletClient: providedWalletClient,
+    publicClient: providedPublicClient,
+    allowAnyDevice: rawAllowAnyDevice = false,
+    deviceId = "0000000000000000000000000000000000000000000000000000000000000000",
+    composeHash = "0000000000000000000000000000000000000000000000000000000000000000",
+    disableUpgrades = false,
+    skipPrerequisiteChecks = false,
+    minBalance,
+    timeout = 12e4,
+    // 2 minutes default
+    retryOptions,
+    signal,
+    onTransactionStateChange,
+    onTransactionSubmitted,
+    onTransactionConfirmed
+  } = validatedRequest;
+  const defaultDeviceId = "0000000000000000000000000000000000000000000000000000000000000000";
+  const hasSpecificDevice = deviceId !== defaultDeviceId && deviceId !== "0x" + defaultDeviceId;
+  const allowAnyDevice = hasSpecificDevice ? false : rawAllowAnyDevice;
+  let publicClient;
+  let walletClient;
+  let deployerAddress;
+  let chainId;
+  if (privateKey) {
+    const account = (0, import_accounts2.privateKeyToAccount)(privateKey);
+    if (providedPublicClient) {
+      if (typeof providedPublicClient !== "object" || !providedPublicClient) {
+        throw new Error("publicClient is invalid");
+      }
+      publicClient = providedPublicClient;
+    } else {
+      if (!chain) {
+        throw new Error("Chain required for publicClient");
+      }
+      publicClient = (0, import_viem3.createPublicClient)({
+        chain,
+        transport: (0, import_viem3.http)()
+      });
+    }
+    if (!chain) {
+      throw new Error("Chain required for walletClient");
+    }
+    walletClient = (0, import_viem3.createWalletClient)({
+      account,
+      chain,
+      transport: (0, import_viem3.http)()
+    });
+    deployerAddress = account.address;
+    chainId = chain.id;
+  } else if (providedWalletClient) {
+    if (typeof providedWalletClient !== "object" || !providedWalletClient) {
+      throw new Error("walletClient is invalid");
+    }
+    walletClient = providedWalletClient;
+    if (providedPublicClient) {
+      if (typeof providedPublicClient !== "object" || !providedPublicClient) {
+        throw new Error("publicClient is invalid");
+      }
+      publicClient = providedPublicClient;
+    } else {
+      if (!chain) {
+        throw new Error("Chain required for publicClient");
+      }
+      publicClient = (0, import_viem3.createPublicClient)({
+        chain,
+        transport: (0, import_viem3.http)()
+      });
+    }
+    if (!walletClient.account?.address) {
+      throw new Error("WalletClient needs an account");
+    }
+    deployerAddress = walletClient.account.address;
+    if (chain) {
+      chainId = chain.id;
+    } else {
+      chainId = await walletClient.getChainId();
+    }
+  } else {
+    throw new Error("Need privateKey or walletClient");
+  }
+  const networkClients = {
+    publicClient,
+    walletClient,
+    address: deployerAddress,
+    chainId
+  };
+  const transactionTracker = createTransactionTracker();
+  if (onTransactionStateChange && typeof onTransactionStateChange === "function") {
+    const pollStatus = () => {
+      onTransactionStateChange(
+        transactionTracker.status
+      );
+      if (!transactionTracker.isComplete) {
+        setTimeout(pollStatus, 100);
+      }
+    };
+    setTimeout(pollStatus, 10);
+  }
+  if (!skipPrerequisiteChecks) {
+    const requirements = {
+      targetChainId: chainId,
+      minBalance: minBalance ? (0, import_viem3.parseEther)(minBalance) : (0, import_viem3.parseEther)("0.001")
+      // Default 0.001 ETH
+    };
+    const validation = await validateNetworkPrerequisites(networkClients, requirements);
+    if (!validation.networkValid) {
+      throw new Error(
+        `Wrong network. Need chain ${requirements.targetChainId}, got ${validation.details.currentChainId}`
+      );
+    }
+    if (!validation.balanceValid) {
+      const requiredEth = Number(requirements.minBalance) / 1e18;
+      const currentEth = Number(validation.details.balance) / 1e18;
+      throw new Error(`Not enough ETH. Need ${requiredEth}, have ${currentEth.toFixed(6)}`);
+    }
+  }
+  const deviceIdHex = asHex(deviceId);
+  const composeHashHex = asHex(composeHash);
+  const deviceIdBytes = `0x${deviceIdHex.slice(2).padEnd(64, "0")}`;
+  const composeHashBytes = `0x${composeHashHex.slice(2).padEnd(64, "0")}`;
+  const deployOperation = async (clients) => {
+    try {
+      const code = await clients.publicClient.getCode({ address: kmsContractAddress });
+      if (!code || code === "0x") {
+        throw new Error(`No contract at ${kmsContractAddress}`);
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("No contract at")) {
+        throw error;
+      }
+    }
+    const contractCall = {
+      address: kmsContractAddress,
+      abi: kmsAuthAbi,
+      functionName: "deployAndRegisterApp",
+      args: [
+        clients.address,
+        disableUpgrades,
+        allowAnyDevice,
+        deviceIdBytes,
+        composeHashBytes
+      ],
+      account: clients.walletClient.account || clients.address,
+      chain: chain || null
+    };
+    return await clients.walletClient.writeContract(contractCall);
+  };
+  const transactionResult = retryOptions ? await executeTransactionWithRetry(
+    deployOperation,
+    networkClients,
+    [],
+    {
+      timeout,
+      confirmations: 1,
+      onSubmitted: onTransactionSubmitted,
+      onConfirmed: onTransactionConfirmed,
+      signal
+    },
+    retryOptions
+  ) : await transactionTracker.execute(deployOperation, networkClients, [], {
+    timeout,
+    confirmations: 1,
+    onSubmitted: onTransactionSubmitted,
+    onConfirmed: onTransactionConfirmed,
+    signal
+  });
+  const result = parseDeploymentResult(
+    transactionResult.receipt,
+    deployerAddress,
+    kmsContractAddress
+  );
+  if (parameters?.schema === false) {
+    return result;
+  }
+  const schema = parameters?.schema || DeployAppAuthSchema;
+  return schema.parse(result);
+}
+async function safeDeployAppAuth(request, parameters) {
+  try {
+    const result = await deployAppAuth(request, parameters);
+    return { success: true, data: result };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown deployment error";
+    const requestError = {
+      isRequestError: true,
+      message: errorMessage,
+      status: 500,
+      // Use 500 for blockchain errors since they're not HTTP errors
+      detail: errorMessage
+    };
+    return {
+      success: false,
+      error: requestError
+    };
+  }
+}
+
+// src/actions/add_compose_hash.ts
+var import_zod8 = require("zod");
+var import_viem4 = require("viem");
+var import_accounts3 = require("viem/accounts");
+var appAuthAbi = [
+  {
+    inputs: [{ name: "composeHash", type: "bytes32" }],
+    name: "addComposeHash",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "composeHash", type: "bytes32", indexed: false }],
+    name: "ComposeHashAdded",
+    type: "event",
+    anonymous: false
+  }
+];
+var AddComposeHashRequestSchema = import_zod8.z.object({
+  // Chain configuration (conditionally required)
+  chain: import_zod8.z.unknown().optional(),
+  // Contract configuration (required)
+  kmsContractAddress: import_zod8.z.string(),
+  appId: import_zod8.z.string(),
+  composeHash: import_zod8.z.string(),
+  // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
+  privateKey: import_zod8.z.string().optional(),
+  walletClient: import_zod8.z.unknown().optional(),
+  // Public client (optional, will create default if not provided)
+  publicClient: import_zod8.z.unknown().optional(),
+  // Validation configuration (optional)
+  skipPrerequisiteChecks: import_zod8.z.boolean().optional().default(false),
+  minBalance: import_zod8.z.string().optional(),
+  // ETH amount as string, e.g., "0.01"
+  // Transaction control options
+  timeout: import_zod8.z.number().optional().default(12e4),
+  retryOptions: import_zod8.z.unknown().optional(),
+  signal: import_zod8.z.unknown().optional(),
+  // Progress callbacks
+  onTransactionStateChange: import_zod8.z.function().optional(),
+  onTransactionSubmitted: import_zod8.z.function().optional(),
+  onTransactionConfirmed: import_zod8.z.function().optional()
+}).passthrough().refine(
+  (data) => {
+    const hasPrivateKey = !!data.privateKey;
+    const hasWalletClient = !!data.walletClient;
+    return hasPrivateKey !== hasWalletClient;
+  },
+  {
+    message: "Either 'privateKey' or 'walletClient' must be provided, but not both",
+    path: ["privateKey", "walletClient"]
+  }
+).refine(
+  (data) => {
+    const hasPublicClient = !!data.publicClient;
+    const hasWalletClient = !!data.walletClient;
+    const hasChain = !!data.chain;
+    if (hasPublicClient && hasWalletClient) return true;
+    return hasChain;
+  },
+  {
+    message: "Chain is required when publicClient or walletClient is not provided",
+    path: ["chain"]
+  }
+);
+var AddComposeHashSchema = import_zod8.z.object({
+  composeHash: import_zod8.z.string(),
+  appId: import_zod8.z.string(),
+  transactionHash: import_zod8.z.string(),
+  blockNumber: import_zod8.z.bigint().optional(),
+  gasUsed: import_zod8.z.bigint().optional()
+}).passthrough();
+function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
+  console.log(receipt.logs);
+  try {
+    const logs = (0, import_viem4.parseEventLogs)({
+      abi: appAuthAbi,
+      eventName: "ComposeHashAdded",
+      logs: receipt.logs,
+      strict: false
+    });
+    if (logs.length > 0) {
+      const event = logs[0];
+      if (event?.args?.composeHash !== composeHash) {
+        console.warn(
+          `Event compose hash (${event?.args?.composeHash}) does not match expected (${composeHash})`
+        );
+      }
+    }
+    return {
+      composeHash,
+      appAuthAddress,
+      appId,
+      transactionHash: receipt.transactionHash,
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.gasUsed
+    };
+  } catch (parseError) {
+    console.warn("Failed to parse ComposeHashAdded event, returning basic result:", parseError);
+    return {
+      composeHash,
+      appAuthAddress,
+      appId,
+      transactionHash: receipt.transactionHash,
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.gasUsed
+    };
+  }
+}
+async function addComposeHash(request, parameters) {
+  const validatedRequest = AddComposeHashRequestSchema.parse(request);
+  const {
+    chain,
+    appId,
+    composeHash,
+    privateKey,
+    walletClient: providedWalletClient,
+    publicClient: providedPublicClient,
+    timeout = 12e4,
+    retryOptions,
+    signal,
+    onTransactionStateChange,
+    onTransactionSubmitted,
+    onTransactionConfirmed,
+    skipPrerequisiteChecks = false,
+    minBalance
+  } = validatedRequest;
+  let publicClient;
+  let walletClient;
+  let address;
+  let chainId;
+  const appAuthAddress = appId.startsWith("0x") ? appId : `0x${appId}`;
+  if (privateKey) {
+    const account = (0, import_accounts3.privateKeyToAccount)(privateKey);
+    if (providedPublicClient) {
+      publicClient = providedPublicClient;
+    } else {
+      if (!chain) throw new Error("Chain required when creating publicClient");
+      publicClient = (0, import_viem4.createPublicClient)({ chain, transport: (0, import_viem4.http)() });
+    }
+    if (!chain) throw new Error("Chain required when creating walletClient");
+    walletClient = (0, import_viem4.createWalletClient)({
+      account,
+      chain,
+      transport: (0, import_viem4.http)()
+    });
+    address = account.address;
+    chainId = chain.id;
+  } else if (providedWalletClient) {
+    walletClient = providedWalletClient;
+    if (providedPublicClient) {
+      publicClient = providedPublicClient;
+    } else {
+      if (!chain) throw new Error("Chain required when creating publicClient");
+      publicClient = (0, import_viem4.createPublicClient)({ chain, transport: (0, import_viem4.http)() });
+    }
+    if (!walletClient.account?.address) {
+      throw new Error("WalletClient must have an account with address");
+    }
+    address = walletClient.account.address;
+    chainId = chain ? chain.id : await walletClient.getChainId();
+  } else {
+    throw new Error("Either privateKey or walletClient must be provided");
+  }
+  const networkClients = {
+    publicClient,
+    walletClient,
+    address,
+    chainId
+  };
+  const transactionTracker = createTransactionTracker();
+  if (onTransactionStateChange && typeof onTransactionStateChange === "function") {
+    const pollStatus = () => {
+      onTransactionStateChange(transactionTracker.status);
+      if (!transactionTracker.isComplete) {
+        setTimeout(pollStatus, 100);
+      }
+    };
+    setTimeout(pollStatus, 10);
+  }
+  if (!skipPrerequisiteChecks) {
+    const requirements = {
+      targetChainId: chainId,
+      minBalance: minBalance ? (0, import_viem4.parseEther)(minBalance) : (0, import_viem4.parseEther)("0.001")
+    };
+    const validation = await validateNetworkPrerequisites(networkClients, requirements);
+    if (!validation.networkValid) {
+      throw new Error(
+        `Network mismatch: Expected chain ${requirements.targetChainId}, but wallet is on chain ${validation.details.currentChainId}`
+      );
+    }
+    if (!validation.balanceValid) {
+      const requiredEth = Number(requirements.minBalance) / 1e18;
+      const currentEth = Number(validation.details.balance) / 1e18;
+      throw new Error(
+        `Insufficient balance: Required ${requiredEth} ETH, but account has ${currentEth.toFixed(6)} ETH`
+      );
+    }
+  }
+  const addComposeHashOperation = async (clients) => {
+    const hash = await clients.walletClient.writeContract({
+      address: appAuthAddress,
+      abi: appAuthAbi,
+      functionName: "addComposeHash",
+      args: [asHex(composeHash)],
+      account: clients.walletClient.account || clients.address,
+      chain: chain || null
+    });
+    return hash;
+  };
+  const transactionResult = retryOptions ? await executeTransactionWithRetry(
+    addComposeHashOperation,
+    networkClients,
+    [],
+    {
+      timeout,
+      confirmations: 1,
+      onSubmitted: onTransactionSubmitted,
+      onConfirmed: onTransactionConfirmed,
+      signal
+    },
+    retryOptions
+  ) : await transactionTracker.execute(addComposeHashOperation, networkClients, [], {
+    timeout,
+    confirmations: 1,
+    onSubmitted: onTransactionSubmitted,
+    onConfirmed: onTransactionConfirmed,
+    signal
+  });
+  const result = parseComposeHashResult(
+    transactionResult.receipt,
+    asHex(composeHash),
+    appAuthAddress,
+    appId
+  );
+  if (parameters?.schema === false) {
+    return result;
+  }
+  const schema = parameters?.schema || AddComposeHashSchema;
+  return schema.parse(result);
+}
+async function safeAddComposeHash(request, parameters) {
+  try {
+    const result = await addComposeHash(request, parameters);
+    return { success: true, data: result };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown blockchain error";
+    return {
+      success: false,
+      error: {
+        isRequestError: true,
+        message: errorMessage,
+        status: 500,
+        // Blockchain errors use 500
+        detail: errorMessage
+      }
+    };
+  }
+}
+
+// src/actions/get_cvm_compose_file.ts
+var import_zod9 = require("zod");
+var GetCvmComposeFileResultSchema = import_zod9.z.object({
+  allowed_envs: import_zod9.z.array(import_zod9.z.string()).optional(),
+  docker_compose_file: import_zod9.z.string(),
+  features: import_zod9.z.array(import_zod9.z.string()).optional(),
+  name: import_zod9.z.string().optional(),
+  manifest_version: import_zod9.z.number().optional(),
+  kms_enabled: import_zod9.z.boolean().optional(),
+  public_logs: import_zod9.z.boolean().optional(),
+  public_sysinfo: import_zod9.z.boolean().optional(),
+  tproxy_enabled: import_zod9.z.boolean().optional(),
+  pre_launch_script: import_zod9.z.string().optional()
+}).passthrough();
+var GetCvmComposeFileRequestSchema = import_zod9.z.object({
+  id: import_zod9.z.string().optional(),
+  uuid: import_zod9.z.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: import_zod9.z.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: import_zod9.z.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
+}));
+async function getCvmComposeFile(client, request, parameters) {
+  const validatedRequest = GetCvmComposeFileRequestSchema.parse(request);
+  const response = await client.get(`/cvms/${validatedRequest.cvmId}/compose_file`);
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || GetCvmComposeFileResultSchema;
+  return schema.parse(response);
+}
+async function safeGetCvmComposeFile(client, request, parameters) {
+  const requestValidation = GetCvmComposeFileRequestSchema.safeParse(request);
+  if (!requestValidation.success) {
+    return requestValidation;
+  }
+  const httpResult = await client.safeGet(`/cvms/${requestValidation.data.cvmId}/compose_file`);
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const schema = parameters?.schema || GetCvmComposeFileResultSchema;
+  return schema.safeParse(httpResult.data);
+}
+
+// src/actions/provision_cvm_compose_file_update.ts
+var import_zod10 = require("zod");
+var ProvisionCvmComposeFileUpdateRequestSchema = import_zod10.z.object({
+  id: import_zod10.z.string().optional(),
+  uuid: import_zod10.z.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: import_zod10.z.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: import_zod10.z.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: import_zod10.z.object({
+    allowed_envs: import_zod10.z.array(import_zod10.z.string()).optional(),
+    docker_compose_file: import_zod10.z.string().min(1, "Docker compose file is required"),
+    name: import_zod10.z.string(),
+    kms_enabled: import_zod10.z.boolean().optional(),
+    public_logs: import_zod10.z.boolean().optional(),
+    public_sysinfo: import_zod10.z.boolean().optional(),
+    pre_launch_script: import_zod10.z.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"
+).transform((data) => ({
+  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
+  request: data.app_compose,
+  _raw: data
+}));
+var ProvisionCvmComposeFileUpdateResultSchema = import_zod10.z.object({
+  app_id: import_zod10.z.string().nullable(),
+  device_id: import_zod10.z.string().nullable(),
+  compose_hash: import_zod10.z.string(),
+  kms_info: KmsInfoSchema.nullable().optional()
+}).passthrough();
+async function provisionCvmComposeFileUpdate(client, request, parameters) {
+  const validatedRequest = ProvisionCvmComposeFileUpdateRequestSchema.parse(request);
+  const response = await client.post(
+    `/cvms/${validatedRequest.cvmId}/compose_file/provision`,
+    validatedRequest.request
+  );
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || ProvisionCvmComposeFileUpdateResultSchema;
+  return schema.parse(response);
+}
+async function safeProvisionCvmComposeFileUpdate(client, request, parameters) {
+  const requestValidation = ProvisionCvmComposeFileUpdateRequestSchema.safeParse(request);
+  if (!requestValidation.success) {
+    return requestValidation;
+  }
+  const httpResult = await client.safePost(
+    `/cvms/${requestValidation.data.cvmId}/compose_file/provision`,
+    requestValidation.data.request
+  );
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const schema = parameters?.schema || ProvisionCvmComposeFileUpdateResultSchema;
+  return schema.safeParse(httpResult.data);
+}
+
+// src/actions/commit_cvm_compose_file_update.ts
+var import_zod11 = require("zod");
+var CommitCvmComposeFileUpdateRequestSchema = import_zod11.z.object({
+  id: import_zod11.z.string().optional(),
+  uuid: import_zod11.z.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: import_zod11.z.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: import_zod11.z.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: import_zod11.z.string().min(1, "Compose hash is required"),
+  encrypted_env: import_zod11.z.string().optional(),
+  env_keys: import_zod11.z.array(import_zod11.z.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"
+).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,
+  _raw: data
+}));
+var CommitCvmComposeFileUpdateSchema = import_zod11.z.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`, {
+    compose_hash: validatedRequest.compose_hash,
+    encrypted_env: validatedRequest.encrypted_env,
+    env_keys: validatedRequest.env_keys
+  });
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || CommitCvmComposeFileUpdateSchema;
+  return schema.parse(response);
+}
+async function safeCommitCvmComposeFileUpdate(client, request, parameters) {
+  const requestValidation = CommitCvmComposeFileUpdateRequestSchema.safeParse(request);
+  if (!requestValidation.success) {
+    return requestValidation;
+  }
+  const httpResult = await client.safePatch(`/cvms/${requestValidation.data.cvmId}/compose_file`, {
+    compose_hash: requestValidation.data.compose_hash,
+    encrypted_env: requestValidation.data.encrypted_env,
+    env_keys: requestValidation.data.env_keys
+  });
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const schema = parameters?.schema || CommitCvmComposeFileUpdateSchema;
+  return schema.safeParse(httpResult.data);
+}
+
+// src/actions/get_app_env_encrypt_pubkey.ts
+var import_zod12 = require("zod");
+var GetAppEnvEncryptPubKeyRequestSchema = import_zod12.z.object({
+  kms: import_zod12.z.string().min(1, "KMS ID or slug is required"),
+  app_id: import_zod12.z.string().length(40, "App ID must be exactly 40 characters")
+}).strict();
+var GetAppEnvEncryptPubKeySchema = import_zod12.z.object({
+  public_key: import_zod12.z.string(),
+  signature: import_zod12.z.string()
+}).strict();
+var getAppEnvEncryptPubKey = async (client, payload, parameters) => {
+  const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
+  validateActionParameters(parameters);
+  const response = await client.get(
+    `/kms/${validatedRequest.kms}/pubkey/${validatedRequest.app_id}`
+  );
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || GetAppEnvEncryptPubKeySchema;
+  return schema.parse(response);
+};
+var safeGetAppEnvEncryptPubKey = async (client, payload, parameters) => {
+  const requestValidation = GetAppEnvEncryptPubKeyRequestSchema.safeParse(payload);
+  if (!requestValidation.success) {
+    return requestValidation;
+  }
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const httpResult = await client.safeGet(
+    `/kms/${requestValidation.data.kms}/pubkey/${requestValidation.data.app_id}`
+  );
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const schema = parameters?.schema || GetAppEnvEncryptPubKeySchema;
+  return schema.safeParse(httpResult.data);
+};
+
+// src/actions/get_cvm_info.ts
+var import_zod14 = require("zod");
+
+// src/types/cvm_info.ts
+var import_zod13 = require("zod");
+var VmInfoSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  name: import_zod13.z.string(),
+  status: import_zod13.z.string(),
+  uptime: import_zod13.z.string(),
+  app_url: import_zod13.z.string().nullable(),
+  app_id: import_zod13.z.string(),
+  instance_id: import_zod13.z.string().nullable(),
+  configuration: import_zod13.z.any().optional(),
+  // TODO: add VmConfiguration schema if needed
+  exited_at: import_zod13.z.string().nullable(),
+  boot_progress: import_zod13.z.string().nullable(),
+  boot_error: import_zod13.z.string().nullable(),
+  shutdown_progress: import_zod13.z.string().nullable(),
+  image_version: import_zod13.z.string().nullable()
+});
+var ManagedUserSchema = import_zod13.z.object({
+  id: import_zod13.z.number(),
+  username: import_zod13.z.string()
+});
+var CvmNodeSchema = import_zod13.z.object({
+  id: import_zod13.z.number(),
+  name: import_zod13.z.string(),
+  region_identifier: import_zod13.z.string().optional()
+});
+var CvmNetworkUrlsSchema = import_zod13.z.object({
+  app: import_zod13.z.string(),
+  instance: import_zod13.z.string()
+});
+var KMSInfoSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  // HashedId is represented as string in JS
+  slug: import_zod13.z.string(),
+  url: import_zod13.z.string(),
+  version: import_zod13.z.string(),
+  chain_id: import_zod13.z.number().optional(),
+  kms_contract_address: import_zod13.z.string().optional(),
+  gateway_app_id: import_zod13.z.string().optional()
+});
+var CvmInfoSchema = import_zod13.z.object({
+  hosted: VmInfoSchema,
+  name: import_zod13.z.string(),
+  managed_user: ManagedUserSchema.optional().nullable(),
+  node: CvmNodeSchema.optional().nullable(),
+  listed: import_zod13.z.boolean().default(false),
+  status: import_zod13.z.string(),
+  in_progress: import_zod13.z.boolean().default(false),
+  dapp_dashboard_url: import_zod13.z.string().nullable(),
+  syslog_endpoint: import_zod13.z.string().nullable(),
+  allow_upgrade: import_zod13.z.boolean().default(false),
+  project_id: import_zod13.z.string().nullable(),
+  // HashedId is represented as string in JS
+  project_type: import_zod13.z.string().nullable(),
+  billing_period: import_zod13.z.string().nullable(),
+  kms_info: KMSInfoSchema.nullable(),
+  vcpu: import_zod13.z.number().nullable(),
+  memory: import_zod13.z.number().nullable(),
+  disk_size: import_zod13.z.number().nullable(),
+  gateway_domain: import_zod13.z.string().nullable(),
+  public_urls: import_zod13.z.array(CvmNetworkUrlsSchema)
+}).partial();
+
+// src/actions/get_cvm_info.ts
+var GetCvmInfoSchema = CvmInfoSchema;
+var GetCvmInfoRequestSchema = import_zod14.z.object({
+  id: import_zod14.z.string().optional(),
+  uuid: import_zod14.z.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: import_zod14.z.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: import_zod14.z.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
+}));
+async function getCvmInfo(client, request, parameters) {
+  const validatedRequest = GetCvmInfoRequestSchema.parse(request);
+  validateActionParameters(parameters);
+  const response = await client.get(`/cvms/${validatedRequest.cvmId}`);
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || GetCvmInfoSchema;
+  return schema.parse(response);
+}
+async function safeGetCvmInfo(client, request, parameters) {
+  const requestValidation = GetCvmInfoRequestSchema.safeParse(request);
+  if (!requestValidation.success) {
+    return requestValidation;
+  }
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const httpResult = await client.safeGet(`/cvms/${requestValidation.data.cvmId}`);
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return {
+      success: true,
+      data: httpResult.data
+    };
+  }
+  const schema = parameters?.schema || GetCvmInfoSchema;
+  const validationResult = schema.safeParse(httpResult.data);
+  return validationResult;
+}
+
+// src/actions/get_cvm_list.ts
+var import_zod15 = require("zod");
+var GetCvmListRequestSchema = import_zod15.z.object({
+  page: import_zod15.z.number().int().min(1).optional(),
+  page_size: import_zod15.z.number().int().min(1).optional(),
+  node_id: import_zod15.z.number().int().min(1).optional()
+}).strict();
+var GetCvmListSchema = import_zod15.z.object({
+  items: import_zod15.z.array(CvmInfoSchema),
+  total: import_zod15.z.number(),
+  page: import_zod15.z.number(),
+  page_size: import_zod15.z.number(),
+  pages: import_zod15.z.number()
+}).strict();
+async function getCvmList(client, request, parameters) {
+  const validatedRequest = GetCvmListRequestSchema.parse(request ?? {});
+  validateActionParameters(parameters);
+  const response = await client.get("/cvms/paginated", { params: validatedRequest });
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || GetCvmListSchema;
+  return schema.parse(response);
+}
+async function safeGetCvmList(client, request, parameters) {
+  const requestValidation = GetCvmListRequestSchema.safeParse(request ?? {});
+  if (!requestValidation.success) {
+    return requestValidation;
+  }
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const httpResult = await client.safeGet("/cvms/paginated", { params: requestValidation.data });
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return {
+      success: true,
+      data: httpResult.data
+    };
+  }
+  const schema = parameters?.schema || GetCvmListSchema;
+  const validationResult = schema.safeParse(httpResult.data);
+  return validationResult;
+}
+
+// src/actions/get_kms_info.ts
+var import_zod16 = require("zod");
+var GetKmsInfoRequestSchema = import_zod16.z.object({
+  kms_id: import_zod16.z.string().min(1, "KMS ID is required")
+});
+async function getKmsInfo(client, request, parameters) {
+  const validatedRequest = GetKmsInfoRequestSchema.parse(request);
+  validateActionParameters(parameters);
+  const response = await client.get(`/kms/${validatedRequest.kms_id}`);
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || KmsInfoSchema;
+  return schema.parse(response);
+}
+async function safeGetKmsInfo(client, request, parameters) {
+  const requestValidation = GetKmsInfoRequestSchema.safeParse(request);
+  if (!requestValidation.success) {
+    return requestValidation;
+  }
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const httpResult = await client.safeGet(`/kms/${requestValidation.data.kms_id}`);
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const schema = parameters?.schema || KmsInfoSchema;
+  const validationResult = schema.safeParse(httpResult.data);
+  return validationResult;
+}
+
+// src/actions/get_kms_list.ts
+var import_zod17 = require("zod");
+var GetKmsListRequestSchema = import_zod17.z.object({
+  page: import_zod17.z.number().int().min(1).optional(),
+  page_size: import_zod17.z.number().int().min(1).optional(),
+  is_onchain: import_zod17.z.boolean().optional()
+}).strict();
+var GetKmsListSchema = import_zod17.z.object({
+  items: import_zod17.z.array(KmsInfoSchema),
+  total: import_zod17.z.number(),
+  page: import_zod17.z.number(),
+  page_size: import_zod17.z.number(),
+  pages: import_zod17.z.number()
+}).strict();
+async function getKmsList(client, request, parameters) {
+  const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
+  validateActionParameters(parameters);
+  const response = await client.get("/kms", { params: validatedRequest });
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || GetKmsListSchema;
+  return schema.parse(response);
+}
+async function safeGetKmsList(client, request, parameters) {
+  const requestValidation = GetKmsListRequestSchema.safeParse(request ?? {});
+  if (!requestValidation.success) {
+    return requestValidation;
+  }
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const httpResult = await client.safeGet("/kms", { params: requestValidation.data });
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return {
+      success: true,
+      data: httpResult.data
+    };
+  }
+  const schema = parameters?.schema || GetKmsListSchema;
+  const validationResult = schema.safeParse(httpResult.data);
+  return validationResult;
+}
+
+// src/index.ts
+var import_encrypt_env_vars2 = require("@phala/dstack-sdk/encrypt-env-vars");
+var import_dstack_sdk = require("@phala/dstack-sdk");
+var import_dstack_sdk2 = require("@phala/dstack-sdk");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddComposeHashSchema,
+  ApiErrorSchema,
+  AvailableNodesSchema,
+  CommitCvmComposeFileUpdateRequestSchema,
+  CommitCvmComposeFileUpdateSchema,
+  CommitCvmProvisionRequestSchema,
+  CommitCvmProvisionSchema,
+  CurrentUserSchema,
+  DeployAppAuthRequestSchema,
+  DeployAppAuthSchema,
+  GetAppEnvEncryptPubKeySchema,
+  GetCvmComposeFileResultSchema,
+  GetCvmInfoSchema,
+  GetCvmListSchema,
+  GetKmsListSchema,
+  NetworkError,
+  ProvisionCvmComposeFileUpdateRequestSchema,
+  ProvisionCvmComposeFileUpdateResultSchema,
+  ProvisionCvmRequestSchema,
+  ProvisionCvmSchema,
+  RequestError,
+  TransactionError,
+  WalletError,
+  addComposeHash,
+  addNetwork,
+  asHex,
+  autoCreateClients,
+  checkBalance,
+  checkNetworkStatus,
+  commitCvmComposeFileUpdate,
+  commitCvmProvision,
+  createClient,
+  createClientsFromBrowser,
+  createClientsFromPrivateKey,
+  createNetworkClients,
+  createTransactionTracker,
+  deployAppAuth,
+  encryptEnvVars,
+  estimateTransactionGas,
+  executeBatchTransactions,
+  executeTransaction,
+  executeTransactionWithRetry,
+  extractNetworkClients,
+  getAppEnvEncryptPubKey,
+  getAvailableNodes,
+  getComposeHash,
+  getCurrentUser,
+  getCvmComposeFile,
+  getCvmInfo,
+  getCvmList,
+  getErrorMessage,
+  getKmsInfo,
+  getKmsList,
+  provisionCvm,
+  provisionCvmComposeFileUpdate,
+  safeAddComposeHash,
+  safeCommitCvmComposeFileUpdate,
+  safeCommitCvmProvision,
+  safeDeployAppAuth,
+  safeGetAppEnvEncryptPubKey,
+  safeGetAvailableNodes,
+  safeGetCurrentUser,
+  safeGetCvmComposeFile,
+  safeGetCvmInfo,
+  safeGetCvmList,
+  safeGetKmsInfo,
+  safeGetKmsList,
+  safeProvisionCvm,
+  safeProvisionCvmComposeFileUpdate,
+  safeValidateActionParameters,
+  switchToNetwork,
+  validateActionParameters,
+  validateNetworkPrerequisites,
+  verifyEnvEncryptPublicKey,
+  waitForTransactionReceipt
+});