@layr-labs/ecloud-sdk 0.2.0-dev → 0.2.0-dev.1

package/dist/index.cjs

@@ -131,6 +131,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/client/modules/compute/app/index.ts
 var import_viem9 = require("viem");
+var import_accounts5 = require("viem/accounts");
 
 // src/client/common/config/environment.ts
 var SEPOLIA_CHAIN_ID = 11155111;
@@ -271,6 +272,7 @@ async function buildDockerImage(buildContext, dockerfilePath, tag, logger) {
     tag,
     "-f",
     dockerfilePath,
+    "--load",
     "--progress=plain",
     buildContext
   ];
@@ -396,7 +398,7 @@ async function pullDockerImage(docker, imageTag, platform2 = "linux/amd64", logg
 var child_process2 = __toESM(require("child_process"), 1);
 var import_child_process = require("child_process");
 var import_util2 = require("util");
-var execAsync = (0, import_util2.promisify)(import_child_process.exec);
+var execFileAsync = (0, import_util2.promisify)(import_child_process.execFile);
 async function pushDockerImage(docker, imageRef, logger) {
   logger?.info?.(`Pushing image ${imageRef}...`);
   return new Promise((resolve2, reject) => {
@@ -437,9 +439,9 @@ async function pushDockerImage(docker, imageRef, logger) {
       if (!output.includes("digest:") && !output.includes("pushed") && !output.includes("Pushed")) {
         logger?.debug?.("No clear success indicator in push output, verifying...");
       }
-      logger?.info?.("Image push completed successfully");
       try {
         await verifyImageExists(imageRef, logger);
+        logger?.info?.("Image push completed successfully");
         resolve2();
       } catch (error) {
         reject(error);
@@ -463,7 +465,7 @@ async function verifyImageExists(imageRef, logger) {
   let retries = 5;
   while (retries > 0) {
     try {
-      await execAsync(`docker manifest inspect ${imageRef}`, {
+      await execFileAsync("docker", ["manifest", "inspect", imageRef], {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 1e4
         // 10 second timeout
@@ -937,10 +939,10 @@ async function setupLayeredBuildDirectory(environmentConfig, layeredDockerfileCo
 // src/client/common/registry/digest.ts
 var child_process3 = __toESM(require("child_process"), 1);
 var import_util3 = require("util");
-var execFileAsync = (0, import_util3.promisify)(child_process3.execFile);
+var execFileAsync2 = (0, import_util3.promisify)(child_process3.execFile);
 async function getImageDigestAndName(imageRef) {
   try {
-    const { stdout } = await execFileAsync(
+    const { stdout } = await execFileAsync2(
       "docker",
       ["manifest", "inspect", imageRef],
       { maxBuffer: 10 * 1024 * 1024 }
@@ -980,7 +982,7 @@ function extractDigestFromMultiPlatform(manifest, imageRef) {
 }
 async function extractDigestFromSinglePlatform(manifest, imageRef) {
   try {
-    const { stdout } = await execFileAsync("docker", ["inspect", imageRef], {
+    const { stdout } = await execFileAsync2("docker", ["inspect", imageRef], {
       maxBuffer: 10 * 1024 * 1024
     });
     const inspectData = JSON.parse(stdout);
@@ -1297,7 +1299,10 @@ async function createReleaseFromImageDigest(options, logger) {
   publicEnv["EIGEN_MACHINE_TYPE_PUBLIC"] = instanceType;
   logger.info(`Instance type: ${instanceType}`);
   logger.info("Encrypting environment variables...");
-  const { encryptionKey } = getKMSKeysForEnvironment(environmentConfig.name, environmentConfig.build);
+  const { encryptionKey } = getKMSKeysForEnvironment(
+    environmentConfig.name,
+    environmentConfig.build
+  );
   const protectedHeaders = getAppProtectedHeaders(appId);
   const privateEnvBytes = Buffer.from(JSON.stringify(privateEnv));
   const encryptedEnvStr = await encryptRSAOAEPAndAES256GCM(
@@ -2372,27 +2377,55 @@ var ERC7702Delegator_default = [
 ];
 
 // src/client/common/contract/eip7702.ts
+var EXECUTE_BATCH_MODE = "0x0100000000000000000000000000000000000000000000000000000000000000";
+var GAS_LIMIT_BUFFER_PERCENTAGE = 20n;
+var GAS_PRICE_BUFFER_PERCENTAGE = 100n;
+function encodeExecuteBatchData(executions) {
+  const encodedExecutions = (0, import_viem.encodeAbiParameters)(
+    [
+      {
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "callData", type: "bytes" }
+        ]
+      }
+    ],
+    [executions]
+  );
+  return (0, import_viem.encodeFunctionData)({
+    abi: ERC7702Delegator_default,
+    functionName: "execute",
+    args: [EXECUTE_BATCH_MODE, encodedExecutions]
+  });
+}
 async function estimateBatchGas(options) {
-  const { publicClient, executions } = options;
-  const fees = await publicClient.estimateFeesPerGas();
-  const baseGas = 100000n;
-  const perExecutionGas = 50000n;
-  const estimatedGas = baseGas + BigInt(executions.length) * perExecutionGas;
-  const gasLimit = estimatedGas * 120n / 100n;
-  const maxFeePerGas = fees.maxFeePerGas;
-  const maxPriorityFeePerGas = fees.maxPriorityFeePerGas;
+  const { publicClient, account, executions } = options;
+  const executeBatchData = encodeExecuteBatchData(executions);
+  const [gasTipCap, block, estimatedGas] = await Promise.all([
+    publicClient.estimateMaxPriorityFeePerGas(),
+    publicClient.getBlock(),
+    publicClient.estimateGas({
+      account,
+      to: account,
+      data: executeBatchData
+    })
+  ]);
+  const baseFee = block.baseFeePerGas ?? 0n;
+  const maxFeePerGas = (baseFee + gasTipCap) * (100n + GAS_PRICE_BUFFER_PERCENTAGE) / 100n;
+  const gasLimit = estimatedGas * (100n + GAS_LIMIT_BUFFER_PERCENTAGE) / 100n;
   const maxCostWei = gasLimit * maxFeePerGas;
-  const maxCostEth = formatETH(maxCostWei);
   return {
     gasLimit,
     maxFeePerGas,
-    maxPriorityFeePerGas,
+    maxPriorityFeePerGas: gasTipCap,
     maxCostWei,
-    maxCostEth
+    maxCostEth: formatETH(maxCostWei)
   };
 }
 async function checkERC7702Delegation(publicClient, account, delegatorAddress) {
-  const code = await publicClient.getBytecode({ address: account });
+  const code = await publicClient.getCode({ address: account });
   if (!code) {
     return false;
   }
@@ -2409,36 +2442,7 @@ async function executeBatch(options, logger) {
   if (!chain) {
     throw new Error("Wallet client must have a chain");
   }
-  const encodedExecutions = (0, import_viem.encodeAbiParameters)(
-    [
-      {
-        type: "tuple[]",
-        components: [
-          { name: "target", type: "address" },
-          { name: "value", type: "uint256" },
-          { name: "callData", type: "bytes" }
-        ]
-      }
-    ],
-    [executions]
-  );
-  const executeBatchMode = "0x0100000000000000000000000000000000000000000000000000000000000000";
-  let executeBatchData;
-  try {
-    executeBatchData = (0, import_viem.encodeFunctionData)({
-      abi: ERC7702Delegator_default,
-      functionName: "execute",
-      args: [executeBatchMode, encodedExecutions]
-    });
-  } catch {
-    const functionSignature = "execute(bytes32,bytes)";
-    const selector = (0, import_viem.keccak256)((0, import_viem.toBytes)(functionSignature)).slice(0, 10);
-    const encodedParams = (0, import_viem.encodeAbiParameters)(
-      [{ type: "bytes32" }, { type: "bytes" }],
-      [executeBatchMode, encodedExecutions]
-    );
-    executeBatchData = (0, import_viem.concat)([selector, encodedParams]);
-  }
+  const executeBatchData = encodeExecuteBatchData(executions);
   const isDelegated2 = await checkERC7702Delegation(
     publicClient,
     account.address,
@@ -2608,7 +2612,7 @@ var CanViewAppLogsPermission = "0x2fd3f2fe";
 var CanViewSensitiveAppInfoPermission = "0x0e67b22f";
 var CanUpdateAppProfilePermission = "0x036fef61";
 function getDefaultClientId() {
-  const version = true ? "0.2.0-dev" : "0.0.0";
+  const version = true ? "0.2.0-dev.1" : "0.0.0";
   return `ecloud-sdk/v${version}`;
 }
 var UserApiClient = class {
@@ -4573,20 +4577,20 @@ async function prepareDeployBatch(options, logger) {
     environmentConfig
   };
 }
-async function executeDeployBatch(prepared, gas, logger) {
+async function executeDeployBatch(data, context, gas, logger) {
   const pendingMessage = "Deploying new app...";
   const txHash = await executeBatch(
     {
-      walletClient: prepared.walletClient,
-      publicClient: prepared.publicClient,
-      environmentConfig: prepared.environmentConfig,
-      executions: prepared.executions,
+      walletClient: context.walletClient,
+      publicClient: context.publicClient,
+      environmentConfig: context.environmentConfig,
+      executions: data.executions,
       pendingMessage,
       gas
     },
     logger
   );
-  return { appId: prepared.appId, txHash };
+  return { appId: data.appId, txHash };
 }
 async function deployApp(options, logger) {
   const prepared = await prepareDeployBatch(
@@ -4600,7 +4604,17 @@ async function deployApp(options, logger) {
     },
     logger
   );
-  return executeDeployBatch(prepared, options.gas, logger);
+  const data = {
+    appId: prepared.appId,
+    salt: prepared.salt,
+    executions: prepared.executions
+  };
+  const context = {
+    walletClient: prepared.walletClient,
+    publicClient: prepared.publicClient,
+    environmentConfig: prepared.environmentConfig
+  };
+  return executeDeployBatch(data, context, options.gas, logger);
 }
 async function prepareUpgradeBatch(options) {
   const {
@@ -4696,14 +4710,14 @@ async function prepareUpgradeBatch(options) {
     environmentConfig
   };
 }
-async function executeUpgradeBatch(prepared, gas, logger) {
-  const pendingMessage = `Upgrading app ${prepared.appId}...`;
+async function executeUpgradeBatch(data, context, gas, logger) {
+  const pendingMessage = `Upgrading app ${data.appId}...`;
   const txHash = await executeBatch(
     {
-      walletClient: prepared.walletClient,
-      publicClient: prepared.publicClient,
-      environmentConfig: prepared.environmentConfig,
-      executions: prepared.executions,
+      walletClient: context.walletClient,
+      publicClient: context.publicClient,
+      environmentConfig: context.environmentConfig,
+      executions: data.executions,
       pendingMessage,
       gas
     },
@@ -4721,7 +4735,16 @@ async function upgradeApp(options, logger) {
     publicLogs: options.publicLogs,
     needsPermissionChange: options.needsPermissionChange
   });
-  return executeUpgradeBatch(prepared, options.gas, logger);
+  const data = {
+    appId: prepared.appId,
+    executions: prepared.executions
+  };
+  const context = {
+    walletClient: prepared.walletClient,
+    publicClient: prepared.publicClient,
+    environmentConfig: prepared.environmentConfig
+  };
+  return executeUpgradeBatch(data, context, options.gas, logger);
 }
 async function sendAndWaitForTransaction(options, logger) {
   const {
@@ -5700,7 +5723,9 @@ async function prepareDeployFromVerifiableBuild(options, logger = defaultLogger)
       validateAppName(options.appName);
       validateLogVisibility(options.logVisibility);
       if (!/^sha256:[0-9a-f]{64}$/i.test(options.imageDigest)) {
-        throw new Error(`imageDigest must be in format sha256:<64 hex>, got: ${options.imageDigest}`);
+        throw new Error(
+          `imageDigest must be in format sha256:<64 hex>, got: ${options.imageDigest}`
+        );
       }
       const { publicLogs } = validateLogVisibility(options.logVisibility);
       validateResourceUsageMonitoring(options.resourceUsageMonitoring);
@@ -5753,19 +5778,19 @@ async function prepareDeployFromVerifiableBuild(options, logger = defaultLogger)
       logger.debug("Estimating gas...");
       const gasEstimate = await estimateBatchGas({
         publicClient: batch.publicClient,
-        environmentConfig: batch.environmentConfig,
+        account: batch.walletClient.account.address,
         executions: batch.executions
       });
+      const data = {
+        appId: batch.appId,
+        salt: batch.salt,
+        executions: batch.executions
+      };
       return {
         prepared: {
-          batch,
+          data,
           appName: options.appName,
-          imageRef: options.imageRef,
-          preflightCtx: {
-            privateKey: preflightCtx.privateKey,
-            rpcUrl: preflightCtx.rpcUrl,
-            environmentConfig: preflightCtx.environmentConfig
-          }
+          imageRef: options.imageRef
         },
         gasEstimate
       };
@@ -5992,26 +6017,27 @@ async function prepareDeploy(options, logger = defaultLogger) {
       logger.debug("Estimating gas...");
       const gasEstimate = await estimateBatchGas({
         publicClient: batch.publicClient,
-        environmentConfig: batch.environmentConfig,
+        account: batch.walletClient.account.address,
         executions: batch.executions
       });
+      const data = {
+        appId: batch.appId,
+        salt: batch.salt,
+        executions: batch.executions
+      };
       return {
         prepared: {
-          batch,
+          data,
           appName,
-          imageRef: finalImageRef,
-          preflightCtx: {
-            privateKey: preflightCtx.privateKey,
-            rpcUrl: preflightCtx.rpcUrl,
-            environmentConfig: preflightCtx.environmentConfig
-          }
+          imageRef: finalImageRef
         },
         gasEstimate
       };
     }
   );
 }
-async function executeDeploy(prepared, gas, logger = defaultLogger, skipTelemetry) {
+async function executeDeploy(options) {
+  const { prepared, context, gas, logger = defaultLogger, skipTelemetry } = options;
   return withSDKTelemetry(
     {
       functionName: "executeDeploy",
@@ -6019,7 +6045,7 @@ async function executeDeploy(prepared, gas, logger = defaultLogger, skipTelemetr
     },
     async () => {
       logger.info("Deploying on-chain...");
-      const { appId, txHash } = await executeDeployBatch(prepared.batch, gas, logger);
+      const { appId, txHash } = await executeDeployBatch(prepared.data, context, gas, logger);
       return {
         appId,
         txHash,
@@ -6138,19 +6164,18 @@ async function prepareUpgradeFromVerifiableBuild(options, logger = defaultLogger
       logger.debug("Estimating gas...");
       const gasEstimate = await estimateBatchGas({
         publicClient: batch.publicClient,
-        environmentConfig: batch.environmentConfig,
+        account: batch.walletClient.account.address,
         executions: batch.executions
       });
+      const data = {
+        appId: batch.appId,
+        executions: batch.executions
+      };
       return {
         prepared: {
-          batch,
+          data,
           appId: appID,
-          imageRef: options.imageRef,
-          preflightCtx: {
-            privateKey: preflightCtx.privateKey,
-            rpcUrl: preflightCtx.rpcUrl,
-            environmentConfig: preflightCtx.environmentConfig
-          }
+          imageRef: options.imageRef
         },
         gasEstimate
       };
@@ -6319,26 +6344,26 @@ async function prepareUpgrade(options, logger = defaultLogger) {
       logger.debug("Estimating gas...");
       const gasEstimate = await estimateBatchGas({
         publicClient: batch.publicClient,
-        environmentConfig: batch.environmentConfig,
+        account: batch.walletClient.account.address,
         executions: batch.executions
       });
+      const data = {
+        appId: batch.appId,
+        executions: batch.executions
+      };
       return {
         prepared: {
-          batch,
+          data,
           appId: appID,
-          imageRef: finalImageRef,
-          preflightCtx: {
-            privateKey: preflightCtx.privateKey,
-            rpcUrl: preflightCtx.rpcUrl,
-            environmentConfig: preflightCtx.environmentConfig
-          }
+          imageRef: finalImageRef
         },
         gasEstimate
       };
     }
   );
 }
-async function executeUpgrade(prepared, gas, logger = defaultLogger, skipTelemetry) {
+async function executeUpgrade(options) {
+  const { prepared, context, gas, logger = defaultLogger, skipTelemetry } = options;
   return withSDKTelemetry(
     {
       functionName: "executeUpgrade",
@@ -6346,7 +6371,7 @@ async function executeUpgrade(prepared, gas, logger = defaultLogger, skipTelemet
     },
     async () => {
       logger.info("Upgrading on-chain...");
-      const txHash = await executeUpgradeBatch(prepared.batch, gas, logger);
+      const txHash = await executeUpgradeBatch(prepared.data, context, gas, logger);
       return {
         appId: prepared.appId,
         imageRef: prepared.imageRef,
@@ -6477,8 +6502,8 @@ var path5 = __toESM(require("path"), 1);
 var os3 = __toESM(require("os"), 1);
 var import_child_process2 = require("child_process");
 var import_util4 = require("util");
-var execAsync2 = (0, import_util4.promisify)(import_child_process2.exec);
-var execFileAsync2 = (0, import_util4.promisify)(import_child_process2.execFile);
+var execAsync = (0, import_util4.promisify)(import_child_process2.exec);
+var execFileAsync3 = (0, import_util4.promisify)(import_child_process2.execFile);
 async function fetchTemplate(repoURL, ref, targetDir, config, logger) {
   if (!repoURL) {
     throw new Error("repoURL is required");
@@ -6487,13 +6512,13 @@ async function fetchTemplate(repoURL, ref, targetDir, config, logger) {
 Cloning repo: ${repoURL} \u2192 ${targetDir}
 `);
   try {
-    await execAsync2(`git clone --no-checkout --progress ${repoURL} ${targetDir}`, {
+    await execAsync(`git clone --no-checkout --progress ${repoURL} ${targetDir}`, {
       maxBuffer: 10 * 1024 * 1024
     });
-    await execFileAsync2("git", ["-C", targetDir, "checkout", "--quiet", ref], {
+    await execFileAsync3("git", ["-C", targetDir, "checkout", "--quiet", ref], {
       maxBuffer: 10 * 1024 * 1024
     });
-    await execFileAsync2(
+    await execFileAsync3(
       "git",
       ["-C", targetDir, "submodule", "update", "--init", "--recursive", "--progress"],
       { maxBuffer: 10 * 1024 * 1024 }
@@ -6538,14 +6563,14 @@ Cloning template: ${repoURL} \u2192 extracting ${subPath}
 }
 async function cloneSparse(repoURL, ref, subPath, tempDir) {
   try {
-    await execFileAsync2("git", ["init", tempDir]);
-    await execFileAsync2("git", ["-C", tempDir, "remote", "add", "origin", repoURL]);
-    await execFileAsync2("git", ["-C", tempDir, "config", "core.sparseCheckout", "true"]);
+    await execFileAsync3("git", ["init", tempDir]);
+    await execFileAsync3("git", ["-C", tempDir, "remote", "add", "origin", repoURL]);
+    await execFileAsync3("git", ["-C", tempDir, "config", "core.sparseCheckout", "true"]);
     const sparseCheckoutPath = path5.join(tempDir, ".git/info/sparse-checkout");
     fs5.writeFileSync(sparseCheckoutPath, `${subPath}
 `);
-    await execFileAsync2("git", ["-C", tempDir, "fetch", "origin", ref]);
-    await execFileAsync2("git", ["-C", tempDir, "checkout", ref]);
+    await execFileAsync3("git", ["-C", tempDir, "fetch", "origin", ref]);
+    await execFileAsync3("git", ["-C", tempDir, "checkout", ref]);
   } catch (error) {
     throw new Error(`Failed to clone sparse repository: ${error.message}`);
   }
@@ -7120,6 +7145,187 @@ function createAppModule(ctx) {
         imageRef: result.imageRef
       };
     },
+    // Granular deploy control
+    async prepareDeploy(opts) {
+      return prepareDeploy(
+        {
+          privateKey,
+          rpcUrl: ctx.rpcUrl,
+          environment: ctx.environment,
+          appName: opts.name,
+          instanceType: opts.instanceType,
+          dockerfilePath: opts.dockerfile,
+          envFilePath: opts.envFile,
+          imageRef: opts.imageRef,
+          logVisibility: opts.logVisibility,
+          resourceUsageMonitoring: opts.resourceUsageMonitoring,
+          skipTelemetry
+        },
+        logger
+      );
+    },
+    async prepareDeployFromVerifiableBuild(opts) {
+      return prepareDeployFromVerifiableBuild(
+        {
+          privateKey,
+          rpcUrl: ctx.rpcUrl,
+          environment: ctx.environment,
+          appName: opts.name,
+          instanceType: opts.instanceType,
+          envFilePath: opts.envFile,
+          imageRef: opts.imageRef,
+          imageDigest: opts.imageDigest,
+          logVisibility: opts.logVisibility,
+          resourceUsageMonitoring: opts.resourceUsageMonitoring,
+          skipTelemetry
+        },
+        logger
+      );
+    },
+    async executeDeploy(prepared, gas) {
+      const account = (0, import_accounts5.privateKeyToAccount)(privateKey);
+      const chain = getChainFromID(environment.chainID);
+      const publicClient = (0, import_viem9.createPublicClient)({
+        chain,
+        transport: (0, import_viem9.http)(ctx.rpcUrl)
+      });
+      const walletClient = (0, import_viem9.createWalletClient)({
+        account,
+        chain,
+        transport: (0, import_viem9.http)(ctx.rpcUrl)
+      });
+      const result = await executeDeploy({
+        prepared,
+        context: {
+          walletClient,
+          publicClient,
+          environmentConfig: environment
+        },
+        gas,
+        logger,
+        skipTelemetry
+      });
+      return {
+        appId: result.appId,
+        txHash: result.txHash,
+        appName: result.appName,
+        imageRef: result.imageRef
+      };
+    },
+    async watchDeployment(appId) {
+      return watchDeployment(
+        appId,
+        privateKey,
+        ctx.rpcUrl,
+        ctx.environment,
+        logger,
+        ctx.clientId,
+        skipTelemetry
+      );
+    },
+    // Granular upgrade control
+    async prepareUpgrade(appId, opts) {
+      return prepareUpgrade(
+        {
+          appId,
+          privateKey,
+          rpcUrl: ctx.rpcUrl,
+          environment: ctx.environment,
+          instanceType: opts.instanceType,
+          dockerfilePath: opts.dockerfile,
+          envFilePath: opts.envFile,
+          imageRef: opts.imageRef,
+          logVisibility: opts.logVisibility,
+          resourceUsageMonitoring: opts.resourceUsageMonitoring,
+          skipTelemetry
+        },
+        logger
+      );
+    },
+    async prepareUpgradeFromVerifiableBuild(appId, opts) {
+      return prepareUpgradeFromVerifiableBuild(
+        {
+          appId,
+          privateKey,
+          rpcUrl: ctx.rpcUrl,
+          environment: ctx.environment,
+          instanceType: opts.instanceType,
+          envFilePath: opts.envFile,
+          imageRef: opts.imageRef,
+          imageDigest: opts.imageDigest,
+          logVisibility: opts.logVisibility,
+          resourceUsageMonitoring: opts.resourceUsageMonitoring,
+          skipTelemetry
+        },
+        logger
+      );
+    },
+    async executeUpgrade(prepared, gas) {
+      const account = (0, import_accounts5.privateKeyToAccount)(privateKey);
+      const chain = getChainFromID(environment.chainID);
+      const publicClient = (0, import_viem9.createPublicClient)({
+        chain,
+        transport: (0, import_viem9.http)(ctx.rpcUrl)
+      });
+      const walletClient = (0, import_viem9.createWalletClient)({
+        account,
+        chain,
+        transport: (0, import_viem9.http)(ctx.rpcUrl)
+      });
+      const result = await executeUpgrade({
+        prepared,
+        context: {
+          walletClient,
+          publicClient,
+          environmentConfig: environment
+        },
+        gas,
+        logger,
+        skipTelemetry
+      });
+      return {
+        appId: result.appId,
+        txHash: result.txHash,
+        imageRef: result.imageRef
+      };
+    },
+    async watchUpgrade(appId) {
+      return watchUpgrade(
+        appId,
+        privateKey,
+        ctx.rpcUrl,
+        ctx.environment,
+        logger,
+        ctx.clientId,
+        skipTelemetry
+      );
+    },
+    // Profile management
+    async setProfile(appId, profile) {
+      return withSDKTelemetry(
+        {
+          functionName: "setProfile",
+          skipTelemetry,
+          properties: { environment: ctx.environment }
+        },
+        async () => {
+          const userApiClient = new UserApiClient(
+            environment,
+            privateKey,
+            ctx.rpcUrl,
+            ctx.clientId
+          );
+          return userApiClient.uploadAppProfile(
+            appId,
+            profile.name,
+            profile.website,
+            profile.description,
+            profile.xURL,
+            profile.imagePath
+          );
+        }
+      );
+    },
     async logs(opts) {
       return logs(
         {
@@ -7270,10 +7476,10 @@ function createComputeModule(config) {
 
 // src/client/common/utils/billingapi.ts
 var import_axios2 = __toESM(require("axios"), 1);
-var import_accounts5 = require("viem/accounts");
+var import_accounts6 = require("viem/accounts");
 var BillingApiClient = class {
   constructor(config, privateKey) {
-    this.account = (0, import_accounts5.privateKeyToAccount)(privateKey);
+    this.account = (0, import_accounts6.privateKeyToAccount)(privateKey);
     this.config = config;
   }
   async createSubscription(productId = "compute") {
@@ -7341,90 +7547,331 @@ Please check:
   }
 };
 
-// src/client/modules/billing/index.ts
-function createBillingModule(config) {
-  const { verbose = false, skipTelemetry = false } = config;
-  const privateKey = addHexPrefix(config.privateKey);
-  const logger = getLogger(verbose);
-  const billingEnvConfig = getBillingEnvironmentConfig(getBuildType());
-  const billingApi = new BillingApiClient(billingEnvConfig, privateKey);
-  return {
-    async subscribe(opts) {
-      return withSDKTelemetry(
-        {
-          functionName: "subscribe",
-          skipTelemetry,
-          // Skip if called from CLI
-          properties: { productId: opts?.productId || "compute" }
-        },
-        async () => {
-          const productId = opts?.productId || "compute";
-          logger.debug(`Checking existing subscription for ${productId}...`);
-          const currentStatus = await billingApi.getSubscription(productId);
-          if (isSubscriptionActive(currentStatus.subscriptionStatus)) {
-            logger.debug(`Subscription already active: ${currentStatus.subscriptionStatus}`);
-            return {
-              type: "already_active",
-              status: currentStatus.subscriptionStatus
-            };
-          }
-          if (currentStatus.subscriptionStatus === "past_due" || currentStatus.subscriptionStatus === "unpaid") {
-            logger.debug(`Subscription has payment issue: ${currentStatus.subscriptionStatus}`);
-            return {
-              type: "payment_issue",
-              status: currentStatus.subscriptionStatus,
-              portalUrl: currentStatus.portalUrl
-            };
-          }
-          logger.debug(`Creating subscription for ${productId}...`);
-          const result = await billingApi.createSubscription(productId);
-          logger.debug(`Checkout URL: ${result.checkoutUrl}`);
-          return {
-            type: "checkout_created",
-            checkoutUrl: result.checkoutUrl
-          };
-        }
-      );
-    },
-    async getStatus(opts) {
-      return withSDKTelemetry(
-        {
-          functionName: "getStatus",
-          skipTelemetry,
-          // Skip if called from CLI
-          properties: { productId: opts?.productId || "compute" }
-        },
-        async () => {
-          const productId = opts?.productId || "compute";
-          logger.debug(`Fetching subscription status for ${productId}...`);
-          const result = await billingApi.getSubscription(productId);
-          logger.debug(`Subscription status: ${result.subscriptionStatus}`);
-          return result;
-        }
-      );
-    },
-    async cancel(opts) {
-      return withSDKTelemetry(
-        {
-          functionName: "cancel",
-          skipTelemetry,
-          // Skip if called from CLI
-          properties: { productId: opts?.productId || "compute" }
-        },
-        async () => {
-          const productId = opts?.productId || "compute";
-          logger.debug(`Checking subscription status for ${productId}...`);
-          const currentStatus = await billingApi.getSubscription(productId);
-          if (!isSubscriptionActive(currentStatus.subscriptionStatus)) {
-            logger.debug(`No active subscription to cancel: ${currentStatus.subscriptionStatus}`);
-            return {
-              type: "no_active_subscription",
-              status: currentStatus.subscriptionStatus
-            };
-          }
-          logger.debug(`Canceling subscription for ${productId}...`);
-          await billingApi.cancelSubscription(productId);
-          logger.debug(`Subscription canceled successfully`);
+// src/client/common/auth/keyring.ts
+var import_keyring = require("@napi-rs/keyring");
+var import_accounts7 = require("viem/accounts");
+var SERVICE_NAME = "ecloud";
+var ACCOUNT_NAME = "key";
+var EIGENX_SERVICE_NAME = "eigenx-cli";
+var EIGENX_DEV_SERVICE_NAME = "eigenx-cli-dev";
+var EIGENX_ACCOUNT_PREFIX = "eigenx-";
+var GO_KEYRING_BASE64_PREFIX = "go-keyring-base64:";
+var GO_KEYRING_ENCODED_PREFIX = "go-keyring-encoded:";
+async function storePrivateKey(privateKey) {
+  const normalizedKey = normalizePrivateKey(privateKey);
+  const isValid = validatePrivateKey2(normalizedKey);
+  if (!isValid) {
+    throw new Error("Invalid private key format");
+  }
+  const entry = new import_keyring.AsyncEntry(SERVICE_NAME, ACCOUNT_NAME);
+  try {
+    await entry.setPassword(normalizedKey);
+  } catch (err) {
+    throw new Error(
+      `Failed to store key in OS keyring: ${err?.message ?? err}. Ensure keyring service is available.`
+    );
+  }
+}
+async function getPrivateKey() {
+  const entry = new import_keyring.AsyncEntry(SERVICE_NAME, ACCOUNT_NAME);
+  try {
+    const key = await entry.getPassword();
+    if (key && validatePrivateKey2(key)) {
+      return key;
+    }
+  } catch {
+  }
+  return null;
+}
+async function deletePrivateKey() {
+  const entry = new import_keyring.AsyncEntry(SERVICE_NAME, ACCOUNT_NAME);
+  try {
+    await entry.deletePassword();
+    return true;
+  } catch {
+    console.warn("No key found in keyring");
+    return false;
+  }
+}
+async function listStoredKeys() {
+  const keys = [];
+  const creds = (0, import_keyring.findCredentials)(SERVICE_NAME);
+  for (const cred of creds) {
+    if (cred.account === ACCOUNT_NAME) {
+      try {
+        const address = getAddressFromPrivateKey(cred.password);
+        keys.push({ address });
+      } catch (err) {
+        console.warn(`Warning: Invalid key found, skipping: ${err}`);
+      }
+    }
+  }
+  return keys;
+}
+async function keyExists() {
+  const key = await getPrivateKey();
+  return key !== null;
+}
+async function getLegacyKeys() {
+  const keys = [];
+  try {
+    const eigenxCreds = (0, import_keyring.findCredentials)(EIGENX_SERVICE_NAME);
+    for (const cred of eigenxCreds) {
+      const accountName = cred.account;
+      if (!accountName.startsWith(EIGENX_ACCOUNT_PREFIX)) {
+        continue;
+      }
+      const environment = accountName.substring(EIGENX_ACCOUNT_PREFIX.length);
+      try {
+        const decodedKey = decodeGoKeyringValue(cred.password);
+        const address = getAddressFromPrivateKey(decodedKey);
+        keys.push({ environment, address, source: "eigenx" });
+      } catch (err) {
+        console.warn(
+          `Warning: Invalid key found for ${environment} (eigenx-cli), skipping: ${err}`
+        );
+      }
+    }
+  } catch {
+  }
+  try {
+    const eigenxDevCreds = (0, import_keyring.findCredentials)(EIGENX_DEV_SERVICE_NAME);
+    for (const cred of eigenxDevCreds) {
+      const accountName = cred.account;
+      if (!accountName.startsWith(EIGENX_ACCOUNT_PREFIX)) {
+        continue;
+      }
+      const environment = accountName.substring(EIGENX_ACCOUNT_PREFIX.length);
+      try {
+        const decodedKey = decodeGoKeyringValue(cred.password);
+        const address = getAddressFromPrivateKey(decodedKey);
+        keys.push({ environment, address, source: "eigenx-dev" });
+      } catch (err) {
+        console.warn(
+          `Warning: Invalid key found for ${environment} (eigenx-dev), skipping: ${err}`
+        );
+      }
+    }
+  } catch {
+  }
+  return keys;
+}
+async function getLegacyPrivateKey(environment, source) {
+  const serviceName = source === "eigenx" ? EIGENX_SERVICE_NAME : EIGENX_DEV_SERVICE_NAME;
+  const accountName = EIGENX_ACCOUNT_PREFIX + environment;
+  const entry = new import_keyring.AsyncEntry(serviceName, accountName);
+  try {
+    const rawKey = await entry.getPassword();
+    if (rawKey) {
+      const decodedKey = decodeGoKeyringValue(rawKey);
+      if (validatePrivateKey2(decodedKey)) {
+        return decodedKey;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function deleteLegacyPrivateKey(environment, source) {
+  const serviceName = source === "eigenx" ? EIGENX_SERVICE_NAME : EIGENX_DEV_SERVICE_NAME;
+  const accountName = EIGENX_ACCOUNT_PREFIX + environment;
+  const entry = new import_keyring.AsyncEntry(serviceName, accountName);
+  try {
+    await entry.deletePassword();
+    return true;
+  } catch {
+    console.warn(`No key found for ${environment} in ${source}`);
+    return false;
+  }
+}
+function validatePrivateKey2(privateKey) {
+  try {
+    getAddressFromPrivateKey(privateKey);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getAddressFromPrivateKey(privateKey) {
+  const normalized = normalizePrivateKey(privateKey);
+  return (0, import_accounts7.privateKeyToAddress)(normalized);
+}
+function decodeGoKeyringValue(rawValue) {
+  if (rawValue.startsWith(GO_KEYRING_BASE64_PREFIX)) {
+    const encoded = rawValue.substring(GO_KEYRING_BASE64_PREFIX.length);
+    try {
+      const decoded = Buffer.from(encoded, "base64").toString("utf8");
+      return decoded;
+    } catch (err) {
+      console.warn(`Warning: Failed to decode go-keyring base64 value: ${err}`);
+      return rawValue;
+    }
+  }
+  if (rawValue.startsWith(GO_KEYRING_ENCODED_PREFIX)) {
+    const encoded = rawValue.substring(GO_KEYRING_ENCODED_PREFIX.length);
+    try {
+      const decoded = Buffer.from(encoded, "hex").toString("utf8");
+      return decoded;
+    } catch (err) {
+      console.warn(`Warning: Failed to decode go-keyring hex value: ${err}`);
+      return rawValue;
+    }
+  }
+  return rawValue;
+}
+function normalizePrivateKey(privateKey) {
+  if (!privateKey.startsWith("0x")) {
+    return `0x${privateKey}`;
+  }
+  return privateKey;
+}
+
+// src/client/common/auth/resolver.ts
+async function getPrivateKeyWithSource(options) {
+  if (options.privateKey) {
+    if (!validatePrivateKey2(options.privateKey)) {
+      throw new Error(
+        "Invalid private key format provided via command flag. Please check and try again."
+      );
+    }
+    return {
+      key: options.privateKey,
+      source: "command flag"
+    };
+  }
+  const envKey = process.env.ECLOUD_PRIVATE_KEY;
+  if (envKey) {
+    if (!validatePrivateKey2(envKey)) {
+      throw new Error(
+        "Invalid private key format provided via environment variable. Please check and try again."
+      );
+    }
+    return {
+      key: envKey,
+      source: "environment variable (ECLOUD_PRIVATE_KEY)"
+    };
+  }
+  const keyringKey = await getPrivateKey();
+  if (keyringKey) {
+    return {
+      key: keyringKey,
+      source: "stored credentials"
+    };
+  }
+  return null;
+}
+async function requirePrivateKey(options) {
+  const result = await getPrivateKeyWithSource({
+    privateKey: options.privateKey
+  });
+  if (!result) {
+    throw new Error(
+      `Private key required. Please provide it via:
+  \u2022 Keyring: ecloud auth login
+  \u2022 Flag: --private-key YOUR_KEY
+  \u2022 Environment: export ECLOUD_PRIVATE_KEY=YOUR_KEY`
+    );
+  }
+  return result;
+}
+
+// src/client/common/auth/generate.ts
+var import_accounts8 = require("viem/accounts");
+function generateNewPrivateKey() {
+  const privateKey = (0, import_accounts8.generatePrivateKey)();
+  const address = (0, import_accounts8.privateKeyToAddress)(privateKey);
+  return {
+    privateKey,
+    address
+  };
+}
+
+// src/client/modules/billing/index.ts
+function createBillingModule(config) {
+  const { verbose = false, skipTelemetry = false } = config;
+  const privateKey = addHexPrefix(config.privateKey);
+  const address = getAddressFromPrivateKey(privateKey);
+  const logger = getLogger(verbose);
+  const billingEnvConfig = getBillingEnvironmentConfig(getBuildType());
+  const billingApi = new BillingApiClient(billingEnvConfig, privateKey);
+  return {
+    address,
+    async subscribe(opts) {
+      return withSDKTelemetry(
+        {
+          functionName: "subscribe",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { productId: opts?.productId || "compute" }
+        },
+        async () => {
+          const productId = opts?.productId || "compute";
+          logger.debug(`Checking existing subscription for ${productId}...`);
+          const currentStatus = await billingApi.getSubscription(productId);
+          if (isSubscriptionActive(currentStatus.subscriptionStatus)) {
+            logger.debug(`Subscription already active: ${currentStatus.subscriptionStatus}`);
+            return {
+              type: "already_active",
+              status: currentStatus.subscriptionStatus
+            };
+          }
+          if (currentStatus.subscriptionStatus === "past_due" || currentStatus.subscriptionStatus === "unpaid") {
+            logger.debug(`Subscription has payment issue: ${currentStatus.subscriptionStatus}`);
+            return {
+              type: "payment_issue",
+              status: currentStatus.subscriptionStatus,
+              portalUrl: currentStatus.portalUrl
+            };
+          }
+          logger.debug(`Creating subscription for ${productId}...`);
+          const result = await billingApi.createSubscription(productId);
+          logger.debug(`Checkout URL: ${result.checkoutUrl}`);
+          return {
+            type: "checkout_created",
+            checkoutUrl: result.checkoutUrl
+          };
+        }
+      );
+    },
+    async getStatus(opts) {
+      return withSDKTelemetry(
+        {
+          functionName: "getStatus",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { productId: opts?.productId || "compute" }
+        },
+        async () => {
+          const productId = opts?.productId || "compute";
+          logger.debug(`Fetching subscription status for ${productId}...`);
+          const result = await billingApi.getSubscription(productId);
+          logger.debug(`Subscription status: ${result.subscriptionStatus}`);
+          return result;
+        }
+      );
+    },
+    async cancel(opts) {
+      return withSDKTelemetry(
+        {
+          functionName: "cancel",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { productId: opts?.productId || "compute" }
+        },
+        async () => {
+          const productId = opts?.productId || "compute";
+          logger.debug(`Checking subscription status for ${productId}...`);
+          const currentStatus = await billingApi.getSubscription(productId);
+          if (!isSubscriptionActive(currentStatus.subscriptionStatus)) {
+            logger.debug(`No active subscription to cancel: ${currentStatus.subscriptionStatus}`);
+            return {
+              type: "no_active_subscription",
+              status: currentStatus.subscriptionStatus
+            };
+          }
+          logger.debug(`Canceling subscription for ${productId}...`);
+          await billingApi.cancelSubscription(productId);
+          logger.debug(`Subscription canceled successfully`);
           return {
             type: "canceled"
           };
@@ -7436,13 +7883,13 @@ function createBillingModule(config) {
 
 // src/client/common/utils/buildapi.ts
 var import_axios3 = __toESM(require("axios"), 1);
-var import_accounts6 = require("viem/accounts");
+var import_accounts9 = require("viem/accounts");
 var BuildApiClient = class {
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.clientId = options.clientId;
     if (options.privateKey) {
-      this.account = (0, import_accounts6.privateKeyToAccount)(options.privateKey);
+      this.account = (0, import_accounts9.privateKeyToAccount)(options.privateKey);
     }
   }
   async submitBuild(payload) {
@@ -7788,245 +8235,6 @@ function transformVerifyResult(raw) {
   };
 }
 
-// src/client/common/auth/keyring.ts
-var import_keyring = require("@napi-rs/keyring");
-var import_accounts7 = require("viem/accounts");
-var SERVICE_NAME = "ecloud";
-var ACCOUNT_NAME = "key";
-var EIGENX_SERVICE_NAME = "eigenx-cli";
-var EIGENX_DEV_SERVICE_NAME = "eigenx-cli-dev";
-var EIGENX_ACCOUNT_PREFIX = "eigenx-";
-var GO_KEYRING_BASE64_PREFIX = "go-keyring-base64:";
-var GO_KEYRING_ENCODED_PREFIX = "go-keyring-encoded:";
-async function storePrivateKey(privateKey) {
-  const normalizedKey = normalizePrivateKey(privateKey);
-  const isValid = validatePrivateKey2(normalizedKey);
-  if (!isValid) {
-    throw new Error("Invalid private key format");
-  }
-  const entry = new import_keyring.AsyncEntry(SERVICE_NAME, ACCOUNT_NAME);
-  try {
-    await entry.setPassword(normalizedKey);
-  } catch (err) {
-    throw new Error(
-      `Failed to store key in OS keyring: ${err?.message ?? err}. Ensure keyring service is available.`
-    );
-  }
-}
-async function getPrivateKey() {
-  const entry = new import_keyring.AsyncEntry(SERVICE_NAME, ACCOUNT_NAME);
-  try {
-    const key = await entry.getPassword();
-    if (key && validatePrivateKey2(key)) {
-      return key;
-    }
-  } catch {
-  }
-  return null;
-}
-async function deletePrivateKey() {
-  const entry = new import_keyring.AsyncEntry(SERVICE_NAME, ACCOUNT_NAME);
-  try {
-    await entry.deletePassword();
-    return true;
-  } catch {
-    console.warn("No key found in keyring");
-    return false;
-  }
-}
-async function listStoredKeys() {
-  const keys = [];
-  const creds = (0, import_keyring.findCredentials)(SERVICE_NAME);
-  for (const cred of creds) {
-    if (cred.account === ACCOUNT_NAME) {
-      try {
-        const address = getAddressFromPrivateKey(cred.password);
-        keys.push({ address });
-      } catch (err) {
-        console.warn(`Warning: Invalid key found, skipping: ${err}`);
-      }
-    }
-  }
-  return keys;
-}
-async function keyExists() {
-  const key = await getPrivateKey();
-  return key !== null;
-}
-async function getLegacyKeys() {
-  const keys = [];
-  try {
-    const eigenxCreds = (0, import_keyring.findCredentials)(EIGENX_SERVICE_NAME);
-    for (const cred of eigenxCreds) {
-      const accountName = cred.account;
-      if (!accountName.startsWith(EIGENX_ACCOUNT_PREFIX)) {
-        continue;
-      }
-      const environment = accountName.substring(EIGENX_ACCOUNT_PREFIX.length);
-      try {
-        const decodedKey = decodeGoKeyringValue(cred.password);
-        const address = getAddressFromPrivateKey(decodedKey);
-        keys.push({ environment, address, source: "eigenx" });
-      } catch (err) {
-        console.warn(
-          `Warning: Invalid key found for ${environment} (eigenx-cli), skipping: ${err}`
-        );
-      }
-    }
-  } catch {
-  }
-  try {
-    const eigenxDevCreds = (0, import_keyring.findCredentials)(EIGENX_DEV_SERVICE_NAME);
-    for (const cred of eigenxDevCreds) {
-      const accountName = cred.account;
-      if (!accountName.startsWith(EIGENX_ACCOUNT_PREFIX)) {
-        continue;
-      }
-      const environment = accountName.substring(EIGENX_ACCOUNT_PREFIX.length);
-      try {
-        const decodedKey = decodeGoKeyringValue(cred.password);
-        const address = getAddressFromPrivateKey(decodedKey);
-        keys.push({ environment, address, source: "eigenx-dev" });
-      } catch (err) {
-        console.warn(
-          `Warning: Invalid key found for ${environment} (eigenx-dev), skipping: ${err}`
-        );
-      }
-    }
-  } catch {
-  }
-  return keys;
-}
-async function getLegacyPrivateKey(environment, source) {
-  const serviceName = source === "eigenx" ? EIGENX_SERVICE_NAME : EIGENX_DEV_SERVICE_NAME;
-  const accountName = EIGENX_ACCOUNT_PREFIX + environment;
-  const entry = new import_keyring.AsyncEntry(serviceName, accountName);
-  try {
-    const rawKey = await entry.getPassword();
-    if (rawKey) {
-      const decodedKey = decodeGoKeyringValue(rawKey);
-      if (validatePrivateKey2(decodedKey)) {
-        return decodedKey;
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-async function deleteLegacyPrivateKey(environment, source) {
-  const serviceName = source === "eigenx" ? EIGENX_SERVICE_NAME : EIGENX_DEV_SERVICE_NAME;
-  const accountName = EIGENX_ACCOUNT_PREFIX + environment;
-  const entry = new import_keyring.AsyncEntry(serviceName, accountName);
-  try {
-    await entry.deletePassword();
-    return true;
-  } catch {
-    console.warn(`No key found for ${environment} in ${source}`);
-    return false;
-  }
-}
-function validatePrivateKey2(privateKey) {
-  try {
-    getAddressFromPrivateKey(privateKey);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getAddressFromPrivateKey(privateKey) {
-  const normalized = normalizePrivateKey(privateKey);
-  return (0, import_accounts7.privateKeyToAddress)(normalized);
-}
-function decodeGoKeyringValue(rawValue) {
-  if (rawValue.startsWith(GO_KEYRING_BASE64_PREFIX)) {
-    const encoded = rawValue.substring(GO_KEYRING_BASE64_PREFIX.length);
-    try {
-      const decoded = Buffer.from(encoded, "base64").toString("utf8");
-      return decoded;
-    } catch (err) {
-      console.warn(`Warning: Failed to decode go-keyring base64 value: ${err}`);
-      return rawValue;
-    }
-  }
-  if (rawValue.startsWith(GO_KEYRING_ENCODED_PREFIX)) {
-    const encoded = rawValue.substring(GO_KEYRING_ENCODED_PREFIX.length);
-    try {
-      const decoded = Buffer.from(encoded, "hex").toString("utf8");
-      return decoded;
-    } catch (err) {
-      console.warn(`Warning: Failed to decode go-keyring hex value: ${err}`);
-      return rawValue;
-    }
-  }
-  return rawValue;
-}
-function normalizePrivateKey(privateKey) {
-  if (!privateKey.startsWith("0x")) {
-    return `0x${privateKey}`;
-  }
-  return privateKey;
-}
-
-// src/client/common/auth/resolver.ts
-async function getPrivateKeyWithSource(options) {
-  if (options.privateKey) {
-    if (!validatePrivateKey2(options.privateKey)) {
-      throw new Error(
-        "Invalid private key format provided via command flag. Please check and try again."
-      );
-    }
-    return {
-      key: options.privateKey,
-      source: "command flag"
-    };
-  }
-  const envKey = process.env.ECLOUD_PRIVATE_KEY;
-  if (envKey) {
-    if (!validatePrivateKey2(envKey)) {
-      throw new Error(
-        "Invalid private key format provided via environment variable. Please check and try again."
-      );
-    }
-    return {
-      key: envKey,
-      source: "environment variable (ECLOUD_PRIVATE_KEY)"
-    };
-  }
-  const keyringKey = await getPrivateKey();
-  if (keyringKey) {
-    return {
-      key: keyringKey,
-      source: "stored credentials"
-    };
-  }
-  return null;
-}
-async function requirePrivateKey(options) {
-  const result = await getPrivateKeyWithSource({
-    privateKey: options.privateKey
-  });
-  if (!result) {
-    throw new Error(
-      `Private key required. Please provide it via:
-  \u2022 Keyring: ecloud auth login
-  \u2022 Flag: --private-key YOUR_KEY
-  \u2022 Environment: export ECLOUD_PRIVATE_KEY=YOUR_KEY`
-    );
-  }
-  return result;
-}
-
-// src/client/common/auth/generate.ts
-var import_accounts8 = require("viem/accounts");
-function generateNewPrivateKey() {
-  const privateKey = (0, import_accounts8.generatePrivateKey)();
-  const address = (0, import_accounts8.privateKeyToAddress)(privateKey);
-  return {
-    privateKey,
-    address
-  };
-}
-
 // src/client/common/utils/instance.ts
 async function getCurrentInstanceType(preflightCtx, appID, logger, clientId) {
   try {