@layr-labs/ecloud-sdk 0.1.1 → 0.1.2-dev

package/dist/compute.cjs

@@ -40,6 +40,7 @@ module.exports = __toCommonJS(compute_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;
@@ -114,7 +115,7 @@ function getEnvironmentConfig(environment, chainID) {
   };
 }
 function getBuildType() {
-  const buildTimeType = true ? "prod"?.toLowerCase() : void 0;
+  const buildTimeType = true ? "dev"?.toLowerCase() : void 0;
   const runtimeType = process.env.BUILD_TYPE?.toLowerCase();
   const buildType = buildTimeType || runtimeType;
   if (buildType === "dev") {
@@ -162,6 +163,7 @@ async function buildDockerImage(buildContext, dockerfilePath, tag, logger) {
     tag,
     "-f",
     dockerfilePath,
+    "--load",
     "--progress=plain",
     buildContext
   ];
@@ -287,7 +289,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) => {
@@ -354,7 +356,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
@@ -828,10 +830,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 }
@@ -871,7 +873,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);
@@ -2205,6 +2207,25 @@ var ERC7702Delegator_default = [
 ];
 
 // src/client/common/contract/eip7702.ts
+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 maxCostWei = gasLimit * maxFeePerGas;
+  const maxCostEth = formatETH(maxCostWei);
+  return {
+    gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    maxCostWei,
+    maxCostEth
+  };
+}
 async function checkERC7702Delegation(publicClient, account, delegatorAddress) {
   const code = await publicClient.getBytecode({ address: account });
   if (!code) {
@@ -2390,7 +2411,7 @@ var CanViewAppLogsPermission = "0x2fd3f2fe";
 var CanViewSensitiveAppInfoPermission = "0x0e67b22f";
 var CanUpdateAppProfilePermission = "0x036fef61";
 function getDefaultClientId() {
-  const version = true ? "0.1.1" : "0.0.0";
+  const version = true ? "0.1.2-dev" : "0.0.0";
   return `ecloud-sdk/v${version}`;
 }
 var UserApiClient = class {
@@ -4142,6 +4163,15 @@ var PermissionController_default = [
 ];
 
 // src/client/common/contract/caller.ts
+function formatETH(wei) {
+  const eth = Number(wei) / 1e18;
+  const costStr = eth.toFixed(6);
+  const trimmed = costStr.replace(/\.?0+$/, "");
+  if (trimmed === "0" && wei > 0n) {
+    return "<0.000001";
+  }
+  return trimmed;
+}
 async function calculateAppID(privateKey, rpcUrl, environmentConfig, salt) {
   const privateKeyHex = addHexPrefix(privateKey);
   const account = (0, import_accounts2.privateKeyToAccount)(privateKeyHex);
@@ -4246,20 +4276,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(
@@ -4273,7 +4303,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 {
@@ -4369,14 +4409,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
     },
@@ -4394,7 +4434,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 {
@@ -5213,6 +5262,141 @@ function generateRandomSalt() {
   crypto.getRandomValues(salt);
   return salt;
 }
+async function prepareDeploy(options, logger = defaultLogger) {
+  return withSDKTelemetry(
+    {
+      functionName: "prepareDeploy",
+      skipTelemetry: options.skipTelemetry,
+      properties: {
+        environment: options.environment || "sepolia"
+      }
+    },
+    async () => {
+      validateDeployOptions(options);
+      const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
+      const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
+      logger.debug("Performing preflight checks...");
+      const preflightCtx = await doPreflightChecks(
+        {
+          privateKey: options.privateKey,
+          rpcUrl: options.rpcUrl,
+          environment: options.environment
+        },
+        logger
+      );
+      logger.debug("Checking quota availability...");
+      await checkQuotaAvailable(preflightCtx);
+      logger.debug("Checking Docker...");
+      await ensureDockerIsRunning();
+      const dockerfilePath = options.dockerfilePath || "";
+      const imageRef = options.imageRef || "";
+      const appName = options.appName;
+      const envFilePath = options.envFilePath || "";
+      const instanceType = options.instanceType;
+      const salt = generateRandomSalt();
+      logger.debug(`Generated salt: ${Buffer.from(salt).toString("hex")}`);
+      logger.debug("Calculating app ID...");
+      const appIDToBeDeployed = await calculateAppID(
+        preflightCtx.privateKey,
+        options.rpcUrl || preflightCtx.rpcUrl,
+        preflightCtx.environmentConfig,
+        salt
+      );
+      logger.info(``);
+      logger.info(`App ID: ${appIDToBeDeployed}`);
+      logger.info(``);
+      logger.info("Preparing release...");
+      const { release, finalImageRef } = await prepareRelease(
+        {
+          dockerfilePath,
+          imageRef,
+          envFilePath,
+          logRedirect,
+          resourceUsageAllow,
+          instanceType,
+          environmentConfig: preflightCtx.environmentConfig,
+          appId: appIDToBeDeployed
+        },
+        logger
+      );
+      logger.debug("Preparing deploy batch...");
+      const batch = await prepareDeployBatch(
+        {
+          privateKey: preflightCtx.privateKey,
+          rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
+          environmentConfig: preflightCtx.environmentConfig,
+          salt,
+          release,
+          publicLogs
+        },
+        logger
+      );
+      logger.debug("Estimating gas...");
+      const gasEstimate = await estimateBatchGas({
+        publicClient: batch.publicClient,
+        environmentConfig: batch.environmentConfig,
+        executions: batch.executions
+      });
+      const data = {
+        appId: batch.appId,
+        salt: batch.salt,
+        executions: batch.executions
+      };
+      return {
+        prepared: {
+          data,
+          appName,
+          imageRef: finalImageRef
+        },
+        gasEstimate
+      };
+    }
+  );
+}
+async function executeDeploy(options) {
+  const { prepared, context, gas, logger = defaultLogger, skipTelemetry } = options;
+  return withSDKTelemetry(
+    {
+      functionName: "executeDeploy",
+      skipTelemetry
+    },
+    async () => {
+      logger.info("Deploying on-chain...");
+      const { appId, txHash } = await executeDeployBatch(prepared.data, context, gas, logger);
+      return {
+        appId,
+        txHash,
+        appName: prepared.appName,
+        imageRef: prepared.imageRef
+      };
+    }
+  );
+}
+async function watchDeployment(appId, privateKey, rpcUrl, environment, logger = defaultLogger, clientId, skipTelemetry) {
+  return withSDKTelemetry(
+    {
+      functionName: "watchDeployment",
+      skipTelemetry,
+      properties: {
+        environment
+      }
+    },
+    async () => {
+      const environmentConfig = getEnvironmentConfig(environment);
+      logger.info("Waiting for app to start...");
+      return watchUntilRunning(
+        {
+          privateKey,
+          rpcUrl,
+          environmentConfig,
+          appId,
+          clientId
+        },
+        logger
+      );
+    }
+  );
+}
 
 // src/client/common/utils/permissions.ts
 var import_viem8 = require("viem");
@@ -5344,6 +5528,125 @@ async function upgrade(options, logger = defaultLogger) {
     }
   );
 }
+async function prepareUpgrade(options, logger = defaultLogger) {
+  return withSDKTelemetry(
+    {
+      functionName: "prepareUpgrade",
+      skipTelemetry: options.skipTelemetry,
+      properties: {
+        environment: options.environment || "sepolia"
+      }
+    },
+    async () => {
+      logger.debug("Performing preflight checks...");
+      const preflightCtx = await doPreflightChecks(
+        {
+          privateKey: options.privateKey,
+          rpcUrl: options.rpcUrl,
+          environment: options.environment
+        },
+        logger
+      );
+      const appID = validateUpgradeOptions(options);
+      const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
+      const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
+      logger.debug("Checking Docker...");
+      await ensureDockerIsRunning();
+      const dockerfilePath = options.dockerfilePath || "";
+      const imageRef = options.imageRef || "";
+      const envFilePath = options.envFilePath || "";
+      const instanceType = options.instanceType;
+      logger.info("Preparing release...");
+      const { release, finalImageRef } = await prepareRelease(
+        {
+          dockerfilePath,
+          imageRef,
+          envFilePath,
+          logRedirect,
+          resourceUsageAllow,
+          instanceType,
+          environmentConfig: preflightCtx.environmentConfig,
+          appId: appID
+        },
+        logger
+      );
+      logger.debug("Checking current log permission state...");
+      const currentlyPublic = await checkAppLogPermission(preflightCtx, appID, logger);
+      const needsPermissionChange = currentlyPublic !== publicLogs;
+      logger.debug("Preparing upgrade batch...");
+      const batch = await prepareUpgradeBatch({
+        privateKey: preflightCtx.privateKey,
+        rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
+        environmentConfig: preflightCtx.environmentConfig,
+        appId: appID,
+        release,
+        publicLogs,
+        needsPermissionChange
+      });
+      logger.debug("Estimating gas...");
+      const gasEstimate = await estimateBatchGas({
+        publicClient: batch.publicClient,
+        environmentConfig: batch.environmentConfig,
+        executions: batch.executions
+      });
+      const data = {
+        appId: batch.appId,
+        executions: batch.executions
+      };
+      return {
+        prepared: {
+          data,
+          appId: appID,
+          imageRef: finalImageRef
+        },
+        gasEstimate
+      };
+    }
+  );
+}
+async function executeUpgrade(options) {
+  const { prepared, context, gas, logger = defaultLogger, skipTelemetry } = options;
+  return withSDKTelemetry(
+    {
+      functionName: "executeUpgrade",
+      skipTelemetry
+    },
+    async () => {
+      logger.info("Upgrading on-chain...");
+      const txHash = await executeUpgradeBatch(prepared.data, context, gas, logger);
+      return {
+        appId: prepared.appId,
+        imageRef: prepared.imageRef,
+        txHash
+      };
+    }
+  );
+}
+async function watchUpgrade(appId, privateKey, rpcUrl, environment, logger = defaultLogger, clientId, skipTelemetry) {
+  return withSDKTelemetry(
+    {
+      functionName: "watchUpgrade",
+      skipTelemetry,
+      properties: {
+        environment
+      }
+    },
+    async () => {
+      const environmentConfig = getEnvironmentConfig(environment);
+      logger.info("Waiting for upgrade to complete...");
+      await watchUntilUpgradeComplete(
+        {
+          privateKey,
+          rpcUrl,
+          environmentConfig,
+          appId,
+          clientId
+        },
+        logger
+      );
+    }
+  );
+}
 
 // src/client/modules/compute/app/create.ts
 var fs7 = __toESM(require("fs"), 1);
@@ -5441,8 +5744,8 @@ var path4 = __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");
@@ -5451,13 +5754,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 }
@@ -5502,14 +5805,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 = path4.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}`);
   }
@@ -6084,6 +6387,151 @@ 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 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 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(
         {