@0xobelisk/sui-cli 1.2.0-pre.4 → 1.2.0-pre.41

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}/contracts/${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

@@ -1,20 +1,106 @@
 import { execSync, spawn } from 'child_process';
 import chalk from 'chalk';
 import { printDubhe } from './printDubhe';
-import { existsSync, mkdirSync, appendFileSync } from 'fs';
-import { join } from 'path';
+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;
   }
@@ -22,37 +108,39 @@ function isSuiStartRunning(): boolean {
 
 async function printAccounts() {
   // These private keys are used for testing purposes only, do not use them in production.
-  const accounts = [
-    { 
-      privateKey: 'suiprivkey1qq3ez3dje66l8pypgxynr7yymwps6uhn7vyczespj84974j3zya0wdpu76v', 
-      address: '0xe7f93ad7493035bcd674f287f78526091e195a6df9d64f23def61a7ce3adada9' 
-    },
-    { 
-      privateKey: 'suiprivkey1qp6vcyg8r2x88fllmjmxtpzjl95gd9dugqrgz7xxf50w6rqdqzetg7x4d7s', 
-      address: '0x492404a537c32b46610bd6ae9f7f16ba16ff5a607d272543fe86cada69d8cf44' 
-    },
-    { 
-      privateKey: 'suiprivkey1qpy3a696eh3m55fwa8h38ss063459u4n2dm9t24w2hlxxzjp2x34q8sdsnc', 
-      address: '0xd27e203483700d837a462d159ced6104619d8e36f737bf2a20c251153bf39f24' 
-    },
-    { 
-      privateKey: 'suiprivkey1qzxwp29favhzrjd95f6uj9nskjwal6nh9g509jpun395y6g72d6jqlmps4c', 
-      address: '0x018f1f175c9b6739a14bc9c81e7984c134ebf9031015cf796fefcef04b8c4990' 
-    },
-    { 
-      privateKey: 'suiprivkey1qzhq4lv38sesah4uzsqkkmeyjx860xqjdz8qgw36tmrdd5tnle3evxpng57', 
-      address: '0x932f6aab2bc636a25374f99794dc8451c4e27c91e87083e301816ed08bc98ed0' 
-    },
-    { 
-      privateKey: 'suiprivkey1qzez45sjjsepjgtksqvpq6jw7dzw3zq0dx7a4sulfypd73acaynw5jl9x2c', 
-      address: '0x9a66b2da3036badd22529e3de8a00b0cd7dbbfe589873aa03d5f885f5f8c6501' 
-    }
+  const privateKeys = [
+    'suiprivkey1qq3ez3dje66l8pypgxynr7yymwps6uhn7vyczespj84974j3zya0wdpu76v',
+    'suiprivkey1qp6vcyg8r2x88fllmjmxtpzjl95gd9dugqrgz7xxf50w6rqdqzetg7x4d7s',
+    'suiprivkey1qpy3a696eh3m55fwa8h38ss063459u4n2dm9t24w2hlxxzjp2x34q8sdsnc',
+    'suiprivkey1qzxwp29favhzrjd95f6uj9nskjwal6nh9g509jpun395y6g72d6jqlmps4c',
+    'suiprivkey1qzhq4lv38sesah4uzsqkkmeyjx860xqjdz8qgw36tmrdd5tnle3evxpng57',
+    'suiprivkey1qzez45sjjsepjgtksqvpq6jw7dzw3zq0dx7a4sulfypd73acaynw5jl9x2c'
   ];
   console.log('📝Accounts');
   console.log('==========');
-  accounts.forEach((account, index) => {
-    console.log(`  ┌─ Account #${index}: ${account.address}(100000 SUI)`);
-    console.log(`  └─ Private Key: ${account.privateKey}`);
+  privateKeys.forEach((privateKey, index) => {
+    const dubhe = new Dubhe({ secretKey: privateKey });
+    const keypair = dubhe.getSigner();
+    spawn(
+      'curl',
+      [
+        '--location',
+        '--request',
+        'POST',
+        'http://127.0.0.1:9123/gas',
+        '--header',
+        'Content-Type: application/json',
+        '--data-raw',
+        `{"FixedAmountRequest": {"recipient": "${keypair.toSuiAddress()}"}}`
+      ],
+      {
+        env: { ...process.env },
+        stdio: 'ignore',
+        detached: true
+      }
+    );
+    console.log(`  ┌─ Account #${index}: ${keypair.toSuiAddress()}(1000 SUI)`);
+    console.log(`  └─ Private Key: ${privateKey}`);
   });
   console.log('==========');
   console.log(
@@ -63,51 +151,6 @@ async function printAccounts() {
   );
 }
 
-async function setupDirectories() {
-  const nodeLogsDir = join(process.cwd(), 'node_logs');
-  const logsDir = join(nodeLogsDir, 'logs');
-  
-  if (!existsSync(nodeLogsDir)) {
-    mkdirSync(nodeLogsDir, { recursive: true });
-  }
-  
-  if (!existsSync(logsDir)) {
-    mkdirSync(logsDir, { recursive: true });
-  }
-  
-  return { nodeLogsDir, logsDir };
-}
-
-async function generateGenesisConfig(nodeLogsDir: string, logsDir: string) {
-  console.log('  ├─ Generating genesis configuration...');
-  execSync(`sui genesis --write-config ${join(nodeLogsDir, 'sui.yaml')}`);
-  
-  const additionalConfig = `
-  - address: "0xe7f93ad7493035bcd674f287f78526091e195a6df9d64f23def61a7ce3adada9"
-    gas_amounts:
-      - 100000000000000
-  - address: "0x492404a537c32b46610bd6ae9f7f16ba16ff5a607d272543fe86cada69d8cf44"
-    gas_amounts:
-      - 100000000000000
-  - address: "0xd27e203483700d837a462d159ced6104619d8e36f737bf2a20c251153bf39f24"
-    gas_amounts:
-      - 100000000000000
-  - address: "0x018f1f175c9b6739a14bc9c81e7984c134ebf9031015cf796fefcef04b8c4990"
-    gas_amounts:
-      - 100000000000000
-  - address: "0x932f6aab2bc636a25374f99794dc8451c4e27c91e87083e301816ed08bc98ed0"
-    gas_amounts:
-      - 100000000000000
-  - address: "0x9a66b2da3036badd22529e3de8a00b0cd7dbbfe589873aa03d5f885f5f8c6501"
-    gas_amounts:
-      - 100000000000000
-`;
-  appendFileSync(join(nodeLogsDir, 'sui.yaml'), additionalConfig);
-  
-  console.log('  ├─ Initializing genesis...');
-  execSync(`sui genesis --working-dir ${logsDir} -f --from-config ${join(nodeLogsDir, 'sui.yaml')}`);
-}
-
 function handleProcessSignals(suiProcess: ReturnType<typeof spawn> | null) {
   const cleanup = () => {
     console.log(chalk.yellow('\n🔔 Stopping Local Node...'));
@@ -121,8 +164,15 @@ function handleProcessSignals(suiProcess: ReturnType<typeof spawn> | null) {
   process.on('SIGTERM', cleanup);
 }
 
-export async function startLocalNode(options: { forceRegenesis?: boolean } = {}) {
-  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'));
@@ -131,34 +181,39 @@ export async function startLocalNode(options: { forceRegenesis?: boolean } = {})
 
   printDubhe();
   console.log('🚀 Starting Local Node...');
-  
   let suiProcess: ReturnType<typeof spawn> | null = null;
-
   try {
-    const { nodeLogsDir, logsDir } = await setupDirectories();
+    suiProcess = spawn(
+      'sui',
+      ['start', '--with-faucet', '--force-regenesis', '--data-ingestion-dir', data_dir],
+      {
+        env: { ...process.env, RUST_LOG: 'off,sui_node=info' },
+        stdio: 'ignore'
+      }
+    );
 
-    if (options.forceRegenesis) {
-      console.log('  ├─ Force Regenesis: Yes');
-      await generateGenesisConfig(nodeLogsDir, logsDir);
-    } else {
-      console.log('  ├─ Force Regenesis: No');
-    }
-    
+    suiProcess.on('error', (error) => {
+      console.error(chalk.red('\n❌ Failed to Start Local Node'));
+      console.error(chalk.red(`  └─ Error: ${error.message}`));
+    });
+    await delay(5000);
     console.log('  ├─ Faucet: Enabled');
+    console.log('  └─ Force Regenesis: Yes');
     console.log('  └─ HTTP server: http://127.0.0.1:9000/');
     console.log('  └─ Faucet server: http://127.0.0.1:9123/');
+
     await printAccounts();
-    console.log(chalk.green('🎉 Local environment is ready!'));
 
-    suiProcess = spawn('sui', [
-      'start',
-      '--with-faucet',
-      '--network.config',
-      join(logsDir, 'network.yaml')
-    ], {
-      env: { ...process.env, RUST_LOG: 'off,sui_node=info' },
-      stdio: 'ignore'
-    });
+    await delay(2000);
+
+    const privateKeyFormat = validatePrivateKey(
+      'suiprivkey1qzez45sjjsepjgtksqvpq6jw7dzw3zq0dx7a4sulfypd73acaynw5jl9x2c'
+    );
+    if (privateKeyFormat === false) {
+      throw new DubheCliError(`Please check your privateKey.`);
+    }
+
+    console.log(chalk.green('🎉 Local environment is ready!'));
 
     handleProcessSignals(suiProcess);
 

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');
@@ -40,7 +34,7 @@ export async function storeConfigHandler(
   outputPath: string
 ) {
   const path = process.cwd();
-  const contractPath = `${path}/contracts/${dubheConfig.name}`;
+  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);
 }