@0xobelisk/sui-cli 1.2.0-pre.22 → 1.2.0-pre.25

package/src/utils/queryStorage.ts

@@ -1,141 +1,141 @@
-import { loadMetadata } from '@0xobelisk/sui-client';
-import { DubheCliError } from './errors';
-import { getOldPackageId, getSchemaId, initializeDubhe } from './utils';
-import { DubheConfig } from '@0xobelisk/sui-common';
-import * as fs from 'fs';
-import * as path from 'path';
-
-function validateParams(storageType: string, params: any[]): boolean {
-  const formatStorageType = storageType.split('<')[0].trim();
-  switch (formatStorageType) {
-    case 'StorageValue':
-      return params.length === 0;
-    case 'StorageMap':
-      return params.length === 1;
-    case 'StorageDoubleMap':
-      return params.length === 2;
-    default:
-      return false;
-  }
-}
-
-function getExpectedParamsCount(storageType: string): number {
-  const formatStorageType = storageType.split('<')[0].trim();
-  switch (formatStorageType) {
-    case 'StorageValue':
-      return 0;
-    case 'StorageMap':
-      return 1;
-    case 'StorageDoubleMap':
-      return 2;
-    default:
-      return 0;
-  }
-}
-
-export async function queryStorage({
-  dubheConfig,
-  schema,
-  params,
-  network,
-  objectId,
-  packageId,
-  metadataFilePath
-}: {
-  dubheConfig: DubheConfig;
-  schema: string;
-  params?: any[];
-  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
-  objectId?: string;
-  packageId?: string;
-  metadataFilePath?: string;
-}) {
-  const path = process.cwd();
-  const projectPath = `${path}/src/${dubheConfig.name}`;
-
-  packageId = packageId || (await getOldPackageId(projectPath, network));
-
-  objectId = objectId || (await getSchemaId(projectPath, network));
-
-  let metadata;
-  if (metadataFilePath) {
-    metadata = await loadMetadataFromFile(metadataFilePath);
-  } else {
-    metadata = await loadMetadata(network, packageId);
-  }
-  if (!metadata) {
-    throw new DubheCliError(
-      `Metadata file not found. Please provide a metadata file path or set the packageId.`
-    );
-  }
-
-  if (!dubheConfig.schemas[schema]) {
-    throw new DubheCliError(
-      `Schema "${schema}" not found in dubhe config. Available schemas: ${Object.keys(
-        dubheConfig.schemas
-      ).join(', ')}`
-    );
-  }
-
-  const storageType = dubheConfig.schemas[schema];
-
-  const processedParams = params || [];
-  if (!validateParams(storageType, processedParams)) {
-    throw new Error(
-      `Invalid params count for ${storageType}. ` +
-        `Expected: ${getExpectedParamsCount(storageType)}, ` +
-        `Got: ${processedParams.length}`
-    );
-  }
-
-  const dubhe = initializeDubhe({
-    network,
-    packageId,
-    metadata
-  });
-  const result = await dubhe.parseState({
-    schema,
-    objectId,
-    storageType,
-    params: processedParams
-  });
-
-  console.log(result);
-}
-
-/**
- * Load metadata from a JSON file and construct the metadata structure
- * @param metadataFilePath Path to the metadata JSON file
- * @param network Network type
- * @param packageId Package ID
- * @returns Constructed metadata object
- */
-export async function loadMetadataFromFile(metadataFilePath: string) {
-  // Verify file extension is .json
-  if (path.extname(metadataFilePath) !== '.json') {
-    throw new Error('Metadata file must be in JSON format');
-  }
-
-  try {
-    // Read JSON file content
-    const rawData = fs.readFileSync(metadataFilePath, 'utf8');
-    const jsonData = JSON.parse(rawData);
-
-    // Validate JSON structure
-    if (!jsonData || typeof jsonData !== 'object') {
-      throw new Error('Invalid JSON format');
-    }
-
-    // Construct metadata structure
-    const metadata = {
-      ...jsonData
-    };
-
-    return metadata;
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`Failed to read metadata file: ${error.message}`);
-    }
-    throw error;
-  }
-}
+// import { loadMetadata } from '@0xobelisk/sui-client';
+// import { DubheCliError } from './errors';
+// import { getOldPackageId, getSchemaId, initializeDubhe } from './utils';
+// import { DubheConfig } from '@0xobelisk/sui-common';
+// import * as fs from 'fs';
+// import * as path from 'path';
+
+// function validateParams(storageType: string, params: any[]): boolean {
+//   const formatStorageType = storageType.split('<')[0].trim();
+//   switch (formatStorageType) {
+//     case 'StorageValue':
+//       return params.length === 0;
+//     case 'StorageMap':
+//       return params.length === 1;
+//     case 'StorageDoubleMap':
+//       return params.length === 2;
+//     default:
+//       return false;
+//   }
+// }
+
+// function getExpectedParamsCount(storageType: string): number {
+//   const formatStorageType = storageType.split('<')[0].trim();
+//   switch (formatStorageType) {
+//     case 'StorageValue':
+//       return 0;
+//     case 'StorageMap':
+//       return 1;
+//     case 'StorageDoubleMap':
+//       return 2;
+//     default:
+//       return 0;
+//   }
+// }
+
+// export async function queryStorage({
+//   dubheConfig,
+//   schema,
+//   params,
+//   network,
+//   objectId,
+//   packageId,
+//   metadataFilePath
+// }: {
+//   dubheConfig: DubheConfig;
+//   schema: string;
+//   params?: any[];
+//   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+//   objectId?: string;
+//   packageId?: string;
+//   metadataFilePath?: string;
+// }) {
+//   const path = process.cwd();
+//   const projectPath = `${path}/src/${dubheConfig.name}`;
+
+//   packageId = packageId || (await getOldPackageId(projectPath, network));
+
+//   objectId = objectId || (await getSchemaId(projectPath, network));
+
+//   let metadata;
+//   if (metadataFilePath) {
+//     metadata = await loadMetadataFromFile(metadataFilePath);
+//   } else {
+//     metadata = await loadMetadata(network, packageId);
+//   }
+//   if (!metadata) {
+//     throw new DubheCliError(
+//       `Metadata file not found. Please provide a metadata file path or set the packageId.`
+//     );
+//   }
+
+//   if (!dubheConfig.schemas[schema]) {
+//     throw new DubheCliError(
+//       `Schema "${schema}" not found in dubhe config. Available schemas: ${Object.keys(
+//         dubheConfig.schemas
+//       ).join(', ')}`
+//     );
+//   }
+
+//   const storageType = dubheConfig.schemas[schema];
+
+//   const processedParams = params || [];
+//   if (!validateParams(storageType, processedParams)) {
+//     throw new Error(
+//       `Invalid params count for ${storageType}. ` +
+//         `Expected: ${getExpectedParamsCount(storageType)}, ` +
+//         `Got: ${processedParams.length}`
+//     );
+//   }
+
+//   const dubhe = initializeDubhe({
+//     network,
+//     packageId,
+//     metadata
+//   });
+//   const result = await dubhe.parseState({
+//     schema,
+//     objectId,
+//     storageType,
+//     params: processedParams
+//   });
+
+//   console.log(result);
+// }
+
+// /**
+//  * Load metadata from a JSON file and construct the metadata structure
+//  * @param metadataFilePath Path to the metadata JSON file
+//  * @param network Network type
+//  * @param packageId Package ID
+//  * @returns Constructed metadata object
+//  */
+// export async function loadMetadataFromFile(metadataFilePath: string) {
+//   // Verify file extension is .json
+//   if (path.extname(metadataFilePath) !== '.json') {
+//     throw new Error('Metadata file must be in JSON format');
+//   }
+
+//   try {
+//     // Read JSON file content
+//     const rawData = fs.readFileSync(metadataFilePath, 'utf8');
+//     const jsonData = JSON.parse(rawData);
+
+//     // Validate JSON structure
+//     if (!jsonData || typeof jsonData !== 'object') {
+//       throw new Error('Invalid JSON format');
+//     }
+
+//     // Construct metadata structure
+//     const metadata = {
+//       ...jsonData
+//     };
+
+//     return metadata;
+//   } catch (error) {
+//     if (error instanceof Error) {
+//       throw new Error(`Failed to read metadata file: ${error.message}`);
+//     }
+//     throw error;
+//   }
+// }

package/src/utils/startNode.ts

@@ -3,18 +3,104 @@ import chalk from 'chalk';
 import { printDubhe } from './printDubhe';
 import { delay, DubheCliError, validatePrivateKey } from '../utils';
 import { Dubhe } from '@0xobelisk/sui-client';
+import * as fs from 'fs';
+
+export function stopLocalNode(): void {
+  console.log(chalk.yellow('🔔 Stopping existing Local Node...'));
+
+  let processStopped = false;
+
+  if (process.platform === 'win32') {
+    // Windows: Kill all sui.exe processes
+    try {
+      execSync('taskkill /F /IM sui.exe', { stdio: 'ignore' });
+      processStopped = true;
+    } catch (error) {
+      // Process not found
+    }
+  } else {
+    // Unix-like systems: Try multiple patterns to find sui processes
+    const patterns = [
+      'sui start', // Exact match
+      'sui.*start', // Pattern with any flags
+      '^sui', // Any sui command
+      'sui.*--with-faucet' // Match our specific startup pattern
+    ];
+
+    for (const pattern of patterns) {
+      try {
+        const result = execSync(`pgrep -f "${pattern}"`, { stdio: 'pipe' }).toString().trim();
+        if (result) {
+          const pids = result.split('\n').filter((pid) => pid);
+          console.log(chalk.cyan(`  ├─ Found ${pids.length} process(es) matching "${pattern}"`));
+
+          pids.forEach((pid) => {
+            try {
+              // First try graceful termination
+              execSync(`kill -TERM ${pid}`, { stdio: 'ignore' });
+              console.log(chalk.cyan(`  ├─ Sent SIGTERM to process ${pid}`));
+            } catch (error) {
+              // If graceful termination fails, force kill
+              try {
+                execSync(`kill -KILL ${pid}`, { stdio: 'ignore' });
+                console.log(chalk.cyan(`  ├─ Force killed process ${pid}`));
+              } catch (killError) {
+                console.log(chalk.gray(`  ├─ Process ${pid} already terminated`));
+              }
+            }
+          });
+          processStopped = true;
+          break; // Stop after first successful pattern match
+        }
+      } catch (error) {
+        // This pattern didn't match any processes, continue to next pattern
+        continue;
+      }
+    }
+  }
+
+  if (processStopped) {
+    console.log(chalk.green('  └─ Local Node stopped successfully'));
+  } else {
+    console.log(chalk.gray('  └─ No running Local Node found'));
+  }
+}
+
+export function removeDirectory(dirPath: string): void {
+  try {
+    if (fs.existsSync(dirPath)) {
+      console.log(chalk.yellow(`🗑️  Removing directory: ${dirPath}`));
+      fs.rmSync(dirPath, { recursive: true, force: true });
+      console.log(chalk.green('  └─ Directory removed successfully'));
+    } else {
+      console.log(chalk.gray(`  └─ Directory ${dirPath} does not exist`));
+    }
+  } catch (error: any) {
+    console.error(chalk.red(`  └─ Error removing directory: ${error.message}`));
+  }
+}
 
 function isSuiStartRunning(): boolean {
   try {
-    const cmd =
-      process.platform === 'win32'
-        ? `tasklist /FI "IMAGENAME eq sui.exe" /FO CSV /NH`
-        : 'pgrep -f "sui start"';
-
-    const result = execSync(cmd).toString().trim();
-    return process.platform === 'win32'
-      ? result.toLowerCase().includes('sui.exe')
-      : result.length > 0;
+    if (process.platform === 'win32') {
+      const result = execSync(`tasklist /FI "IMAGENAME eq sui.exe" /FO CSV /NH`).toString().trim();
+      return result.toLowerCase().includes('sui.exe');
+    } else {
+      // Try multiple patterns to detect running sui processes
+      const patterns = ['sui start', 'sui.*start', '^sui', 'sui.*--with-faucet'];
+
+      for (const pattern of patterns) {
+        try {
+          const result = execSync(`pgrep -f "${pattern}"`, { stdio: 'pipe' }).toString().trim();
+          if (result && result.length > 0) {
+            return true;
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+      return false;
+    }
   } catch (error) {
     return false;
   }
@@ -78,8 +164,15 @@ function handleProcessSignals(suiProcess: ReturnType<typeof spawn> | null) {
   process.on('SIGTERM', cleanup);
 }
 
-export async function startLocalNode() {
-  if (isSuiStartRunning()) {
+export async function startLocalNode(data_dir: string, force?: boolean) {
+  if (force) {
+    console.log(chalk.cyan('\n🔄 Force mode enabled'));
+    stopLocalNode();
+    console.log(chalk.yellow('  ├─ Waiting for processes to terminate...'));
+    await delay(3000); // Wait longer for process to fully stop
+    removeDirectory(data_dir);
+    console.log('');
+  } else if (isSuiStartRunning()) {
     console.log(chalk.yellow('\n⚠️  Warning: Local Node Already Running'));
     console.log(chalk.yellow('  ├─ Cannot start a new instance'));
     console.log(chalk.yellow('  └─ Please stop the existing process first'));
@@ -90,10 +183,14 @@ export async function startLocalNode() {
   console.log('🚀 Starting Local Node...');
   let suiProcess: ReturnType<typeof spawn> | null = null;
   try {
-    suiProcess = spawn('sui', ['start', '--with-faucet', '--force-regenesis'], {
-      env: { ...process.env, RUST_LOG: 'off,sui_node=info' },
-      stdio: 'ignore'
-    });
+    suiProcess = spawn(
+      'sui',
+      ['start', '--with-faucet', '--force-regenesis', '--data-ingestion-dir', data_dir],
+      {
+        env: { ...process.env, RUST_LOG: 'off,sui_node=info' },
+        stdio: 'ignore'
+      }
+    );
 
     suiProcess.on('error', (error) => {
       console.error(chalk.red('\n❌ Failed to Start Local Node'));
@@ -131,4 +228,4 @@ export async function startLocalNode() {
     }
     process.exit(1);
   }
-}
+}

package/src/utils/storeConfig.ts

@@ -1,21 +1,15 @@
 import { mkdirSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 import { DubheConfig } from '@0xobelisk/sui-common';
-import { getDeploymentJson, getDubheSchemaId } from './utils';
+import { getDeploymentJson, getDubheDappHub } from './utils';
 
-async function storeConfig(
-  network: string,
-  packageId: string,
-  schemaId: string,
-  outputPath: string
-) {
-  const dubheSchemaId = await getDubheSchemaId(network);
+async function storeConfig(network: string, packageId: string, outputPath: string) {
+  const dubheDappHub = await getDubheDappHub(network);
   let code = `type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
 
 export const NETWORK: NetworkType = '${network}';
 export const PACKAGE_ID = '${packageId}';
-export const SCHEMA_ID = '${schemaId}';
-export const DUBHE_SCHEMA_ID = '${dubheSchemaId}';
+export const DUBHE_SCHEMA_ID = '${dubheDappHub}';
 `;
 
   writeOutput(code, outputPath, 'storeConfig');
@@ -42,5 +36,5 @@ export async function storeConfigHandler(
   const path = process.cwd();
   const contractPath = `${path}/src/${dubheConfig.name}`;
   const deployment = await getDeploymentJson(contractPath, network);
-  await storeConfig(deployment.network, deployment.packageId, deployment.schemaId, outputPath);
+  await storeConfig(deployment.network, deployment.packageId, outputPath);
 }