@0xobelisk/sui-cli 1.2.0-pre.12 → 1.2.0-pre.121

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,19 +3,105 @@ 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;
-  } catch (error) {
+    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,7 +183,13 @@ 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'], {
+    const args = ['start', '--with-faucet'];
+    if (force) {
+      args.push('--force-regenesis');
+    }
+    args.push('--data-ingestion-dir', data_dir);
+
+    suiProcess = spawn('sui', args, {
       env: { ...process.env, RUST_LOG: 'off,sui_node=info' },
       stdio: 'ignore'
     });
@@ -101,8 +200,8 @@ export async function startLocalNode() {
     });
     await delay(5000);
     console.log('  ├─ Faucet: Enabled');
-    console.log('  └─ Force Regenesis: Yes');
-    console.log('  └─ HTTP server: http://127.0.0.1:9000/');
+    console.log(`  ├─ Force Regenesis: ${force ? 'Yes' : 'No'}`);
+    console.log('  ├─ RPC server: http://127.0.0.1:9000/');
     console.log('  └─ Faucet server: http://127.0.0.1:9123/');
 
     await printAccounts();
@@ -131,4 +230,4 @@ export async function startLocalNode() {
     }
     process.exit(1);
   }
-}
+}

package/src/utils/storeConfig.ts

@@ -1,22 +1,53 @@
 import { mkdirSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 import { DubheConfig } from '@0xobelisk/sui-common';
-import { getDeploymentJson, getDubheSchemaId } from './utils';
+import { getDeploymentJson, getDubheDappHubId, getOriginalDubhePackageId } from './utils';
+
+/** Derive the stable dapp_key type string from the original (genesis) package ID.
+ *  Matches the Move-side `type_name::with_defining_ids<DappKey>().into_string()` output:
+ *  "<hex64>::dapp_key::DappKey"  (no "0x" prefix, address zero-padded to 64 hex chars).
+ */
+function buildDappKey(originalPackageId: string): string {
+  const hex = originalPackageId.replace(/^0x/i, '').padStart(64, '0');
+  return `${hex}::dapp_key::DappKey`;
+}
 
 async function storeConfig(
   network: string,
   packageId: string,
-  schemaId: string,
+  originalPackageId: string,
+  dappStorageId: string,
   outputPath: string
 ) {
-  const dubheSchemaId = await getDubheSchemaId(network);
-  let code = `type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+  const dappHubId = await getDubheDappHubId(network);
+
+  // Mirror getDubheDappHubId: for localnet the framework is deployed ephemerally so we
+  // read its package ID from src/dubhe/.history/sui_localnet/latest.json.
+  // For testnet/mainnet the SDK resolves the framework address automatically via
+  // getDefaultConfig(), so we emit undefined.
+  let frameworkPackageId: string | undefined;
+  if (network === 'localnet') {
+    frameworkPackageId = await getOriginalDubhePackageId(network);
+  }
+
+  const frameworkIdLine =
+    frameworkPackageId !== undefined
+      ? `\n// Published package ID of the dubhe framework — required for proxy operations.\nexport const FrameworkPackageId: string | undefined = '${frameworkPackageId}';\n`
+      : `\n// Published package ID of the dubhe framework — required for proxy operations.\n// For testnet/mainnet the SDK resolves this automatically via getDefaultConfig().\nexport const FrameworkPackageId: string | undefined = undefined;\n`;
+
+  const dappKey = buildDappKey(originalPackageId);
+
+  const 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 Network: NetworkType = '${network}';
+export const PackageId = '${packageId}';
+/** The first-published (original) package ID — stable across upgrades. Used for dapp_key and indexer filtering. */
+export const OriginalPackageId = '${originalPackageId}';
+/** Canonical dapp_key type string derived from OriginalPackageId. Pass to the Dubhe SDK and GraphQL queries. */
+export const DappKey = '${dappKey}';
+export const DappHubId = '${dappHubId}';
+export const DappStorageId = '${dappStorageId}';
+${frameworkIdLine}`;
 
   writeOutput(code, outputPath, 'storeConfig');
 }
@@ -42,5 +73,14 @@ 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);
+  // Prefer the persisted originalPackageId; fall back to packageId for old deployments
+  // that were created before this field was introduced.
+  const originalPackageId = deployment.originalPackageId ?? deployment.packageId;
+  await storeConfig(
+    deployment.network,
+    deployment.packageId,
+    originalPackageId,
+    deployment.dappStorageId ?? '',
+    outputPath
+  );
 }