@0xobelisk/sui-cli 1.2.0-pre.2 → 1.2.0-pre.21

package/src/utils/utils.ts

@@ -8,6 +8,7 @@ import chalk from 'chalk';
 import { spawn } from 'child_process';
 import { Dubhe, NetworkType, SuiMoveNormalizedModules } from '@0xobelisk/sui-client';
 import { DubheCliError } from './errors';
+import packageJson from '../../package.json';
 
 export type DeploymentJsonType = {
   projectName: string;
@@ -90,13 +91,13 @@ export async function getDeploymentSchemaId(projectPath: string, network: string
 
 export async function getDubheSchemaId(network: string) {
   const path = process.cwd();
-  const contractPath = `${path}/contracts/dubhe-framework`;
+  const contractPath = `${path}/src/dubhe`;
 
   switch (network) {
     case 'mainnet':
       return await getDeploymentSchemaId(contractPath, 'mainnet');
     case 'testnet':
-      return '0xa565cbb3641fff8f7e8ef384b215808db5f1837aa72c1cca1803b5d973699aac';
+      return await getDeploymentSchemaId(contractPath, 'testnet');
     case 'devnet':
       return await getDeploymentSchemaId(contractPath, 'devnet');
     case 'localnet':
@@ -165,7 +166,7 @@ export function saveContractData(
   const storeDeploymentData = JSON.stringify(DeploymentData, null, 2);
   writeOutput(
     storeDeploymentData,
-    `${path}/contracts/${projectName}/.history/sui_${network}/latest.json`,
+    `${path}/src/${projectName}/.history/sui_${network}/latest.json`,
     'Update deploy log'
   );
 }
@@ -186,11 +187,11 @@ export async function writeOutput(
 function getDubheDependency(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'): string {
   switch (network) {
     case 'localnet':
-      return 'Dubhe = { local = "../dubhe-framework" }';
+      return 'Dubhe = { local = "../dubhe" }';
     case 'testnet':
-      return 'Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", subdir = "contracts/dubhe", rev = "develop" }';
+      return `Dubhe = { git = "https://github.com/0xobelisk/dubhe-wip.git", subdir = "packages/sui-framework/src/dubhe", rev = "v${packageJson.version}" }`;
     case 'mainnet':
-      return 'Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", subdir = "contracts/dubhe", rev = "develop" }';
+      return `Dubhe = { git = "https://github.com/0xobelisk/dubhe-wip.git", subdir = "packages/sui-framework/src/dubhe", rev = "v${packageJson.version}" }`;
     default:
       throw new Error(`Unsupported network: ${network}`);
   }
@@ -206,32 +207,147 @@ export async function updateDubheDependency(
   fs.writeFileSync(filePath, updatedContent, 'utf-8');
   console.log(`Updated Dubhe dependency in ${filePath} for ${network}.`);
 }
+
+async function checkRpcAvailability(rpcUrl: string): Promise<boolean> {
+  try {
+    const response = await fetch(rpcUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'sui_getLatestCheckpointSequenceNumber',
+        params: []
+      })
+    });
+
+    if (!response.ok) {
+      return false;
+    }
+
+    const data = await response.json();
+    return !data.error;
+  } catch (error) {
+    return false;
+  }
+}
+
+export async function addEnv(
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+): Promise<void> {
+  const rpcMap = {
+    localnet: 'http://127.0.0.1:9000',
+    devnet: 'https://fullnode.devnet.sui.io:443/',
+    testnet: 'https://fullnode.testnet.sui.io:443/',
+    mainnet: 'https://fullnode.mainnet.sui.io:443/'
+  };
+
+  const rpcUrl = rpcMap[network];
+
+  // Check RPC availability first
+  const isRpcAvailable = await checkRpcAvailability(rpcUrl);
+  if (!isRpcAvailable) {
+    throw new Error(
+      `RPC endpoint ${rpcUrl} is not available. Please check your network connection or try again later.`
+    );
+  }
+
+  return new Promise<void>((resolve, reject) => {
+    let errorOutput = '';
+    let stdoutOutput = '';
+
+    const suiProcess = spawn(
+      'sui',
+      ['client', 'new-env', '--alias', network, '--rpc', rpcMap[network]],
+      {
+        env: { ...process.env },
+        stdio: 'pipe'
+      }
+    );
+
+    // Capture standard output
+    suiProcess.stdout.on('data', (data) => {
+      stdoutOutput += data.toString();
+    });
+
+    // Capture error output
+    suiProcess.stderr.on('data', (data) => {
+      errorOutput += data.toString();
+    });
+
+    // Handle process errors (e.g., command not found)
+    suiProcess.on('error', (error) => {
+      console.error(chalk.red(`\n❌ Failed to execute sui command: ${error.message}`));
+      reject(new Error(`Failed to execute sui command: ${error.message}`));
+    });
+
+    // Handle process exit
+    suiProcess.on('exit', (code) => {
+      // Check if "already exists" message is present
+      if (errorOutput.includes('already exists') || stdoutOutput.includes('already exists')) {
+        console.log(chalk.yellow(`Environment ${network} already exists, proceeding...`));
+        resolve();
+        return;
+      }
+
+      if (code === 0) {
+        console.log(chalk.green(`Successfully added environment ${network}`));
+        resolve();
+      } else {
+        const finalError = errorOutput || stdoutOutput || `Process exited with code ${code}`;
+        console.error(chalk.red(`\n❌ Failed to add environment ${network}`));
+        console.error(chalk.red(`  └─ ${finalError.trim()}`));
+        reject(new Error(finalError));
+      }
+    });
+  });
+}
+
 export async function switchEnv(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet') {
   try {
+    // First, try to add the environment
+    await addEnv(network);
+
+    // Then switch to the specified environment
     return new Promise<void>((resolve, reject) => {
+      let errorOutput = '';
+      let stdoutOutput = '';
+
       const suiProcess = spawn('sui', ['client', 'switch', '--env', network], {
         env: { ...process.env },
         stdio: 'pipe'
       });
 
+      suiProcess.stdout.on('data', (data) => {
+        stdoutOutput += data.toString();
+      });
+
+      suiProcess.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
       suiProcess.on('error', (error) => {
-        console.error(chalk.red('\n❌ Failed to Switch Env'));
-        console.error(chalk.red(`  Error: ${error.message}`));
-        reject(error); // Reject promise on error
+        console.error(chalk.red(`\n❌ Failed to execute sui command: ${error.message}`));
+        reject(new Error(`Failed to execute sui command: ${error.message}`));
       });
 
       suiProcess.on('exit', (code) => {
-        if (code !== 0) {
-          console.error(chalk.red(`\n❌ Process exited with code: ${code}`));
-          reject(new Error(`Process exited with code: ${code}`));
+        if (code === 0) {
+          console.log(chalk.green(`Successfully switched to environment ${network}`));
+          resolve();
         } else {
-          resolve(); // Resolve promise on successful exit
+          const finalError = errorOutput || stdoutOutput || `Process exited with code ${code}`;
+          console.error(chalk.red(`\n❌ Failed to switch to environment ${network}`));
+          console.error(chalk.red(`  └─ ${finalError.trim()}`));
+          reject(new Error(finalError));
         }
       });
     });
   } catch (error) {
-    console.error(chalk.red('\n❌ Failed to Switch Env'));
-    console.error(chalk.red(`  └─ Error: ${error}`));
+    // Re-throw the error for the caller to handle
+    throw error;
   }
 }