@0xobelisk/sui-cli 1.1.13 → 1.2.0-pre.1

package/src/utils/startNode.ts

@@ -1,8 +1,8 @@
 import { execSync, spawn } from 'child_process';
 import chalk from 'chalk';
 import { printDubhe } from './printDubhe';
-import { delay, DubheCliError, validatePrivateKey } from '../utils';
-import { Dubhe } from '@0xobelisk/sui-client';
+import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
 
 function isSuiStartRunning(): boolean {
   try {
@@ -22,39 +22,37 @@ function isSuiStartRunning(): boolean {
 
 async function printAccounts() {
   // These private keys are used for testing purposes only, do not use them in production.
-  const privateKeys = [
-    'suiprivkey1qq3ez3dje66l8pypgxynr7yymwps6uhn7vyczespj84974j3zya0wdpu76v',
-    'suiprivkey1qp6vcyg8r2x88fllmjmxtpzjl95gd9dugqrgz7xxf50w6rqdqzetg7x4d7s',
-    'suiprivkey1qpy3a696eh3m55fwa8h38ss063459u4n2dm9t24w2hlxxzjp2x34q8sdsnc',
-    'suiprivkey1qzxwp29favhzrjd95f6uj9nskjwal6nh9g509jpun395y6g72d6jqlmps4c',
-    'suiprivkey1qzhq4lv38sesah4uzsqkkmeyjx860xqjdz8qgw36tmrdd5tnle3evxpng57',
-    'suiprivkey1qzez45sjjsepjgtksqvpq6jw7dzw3zq0dx7a4sulfypd73acaynw5jl9x2c'
+  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' 
+    }
   ];
   console.log('📝Accounts');
   console.log('==========');
-  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}`);
+  accounts.forEach((account, index) => {
+    console.log(`  ┌─ Account #${index}: ${account.address}(100000 SUI)`);
+    console.log(`  └─ Private Key: ${account.privateKey}`);
   });
   console.log('==========');
   console.log(
@@ -64,7 +62,66 @@ async function printAccounts() {
     chalk.yellow('Any funds sent to them on Mainnet or any other live network WILL BE LOST.')
   );
 }
-export async function startLocalNode() {
+
+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...'));
+    if (suiProcess) {
+      suiProcess.kill('SIGINT');
+    }
+    process.exit(0);
+  };
+
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+}
+
+export async function startLocalNode(options: { forceRegenesis?: boolean } = {}) {
   if (isSuiStartRunning()) {
     console.log(chalk.yellow('\n⚠️  Warning: Local Node Already Running'));
     console.log(chalk.yellow('  ├─ Cannot start a new instance'));
@@ -74,47 +131,46 @@ export async function startLocalNode() {
 
   printDubhe();
   console.log('🚀 Starting Local Node...');
+  
+  let suiProcess: ReturnType<typeof spawn> | null = null;
+
   try {
-    const suiProcess = spawn('sui', ['start', '--with-faucet', '--force-regenesis'], {
-      env: { ...process.env, RUST_LOG: 'off,sui_node=info' },
-      stdio: 'ignore',
-      detached: true
-    });
+    const { nodeLogsDir, logsDir } = await setupDirectories();
 
-    suiProcess.on('error', (error) => {
-      console.error(chalk.red('\n❌ Failed to Start Local Node'));
-      console.error(chalk.red(`  └─ Error: ${error.message}`));
-    });
-    await delay(5000);
+    if (options.forceRegenesis) {
+      console.log('  ├─ Force Regenesis: Yes');
+      await generateGenesisConfig(nodeLogsDir, logsDir);
+    } else {
+      console.log('  ├─ Force Regenesis: No');
+    }
+    
     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!'));
 
-    await delay(2000);
-
-    const privateKeyFormat = validatePrivateKey(
-      'suiprivkey1qzez45sjjsepjgtksqvpq6jw7dzw3zq0dx7a4sulfypd73acaynw5jl9x2c'
-    );
-    if (privateKeyFormat === false) {
-      throw new DubheCliError(`Please check your privateKey.`);
-    }
+    suiProcess = spawn('sui', [
+      'start',
+      '--with-faucet',
+      '--network.config',
+      join(logsDir, 'network.yaml')
+    ], {
+      env: { ...process.env, RUST_LOG: 'off,sui_node=info' },
+      stdio: 'ignore'
+    });
 
-    console.log(chalk.green('🎉 Local environment is ready!'));
+    handleProcessSignals(suiProcess);
 
-    process.on('SIGINT', () => {
-      console.log(chalk.yellow('\n🔔 Stopping Local Node...'));
-      if (suiProcess) {
-        suiProcess.kill();
-        console.log(chalk.green('✅ Local Node Stopped'));
-      }
-      process.exit();
+    await new Promise<void>((resolve) => {
+      suiProcess?.on('exit', () => resolve());
     });
   } catch (error: any) {
     console.error(chalk.red('\n❌ Failed to Start Local Node'));
     console.error(chalk.red(`  └─ Error: ${error.message}`));
+    if (suiProcess) {
+      suiProcess.kill('SIGINT');
+    }
     process.exit(1);
   }
 }

package/src/utils/storeConfig.ts

@@ -1,36 +1,24 @@
-import * as fsAsync from 'fs/promises';
 import { mkdirSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
-import { DeploymentJsonType } from './utils';
 import { DubheConfig } from '@0xobelisk/sui-common';
+import { getDeploymentJson, getDubheSchemaId } from './utils';
 
-async function getDeploymentJson(
-  projectPath: string,
-  network: string
-): Promise<DeploymentJsonType> {
-  try {
-    const data = await fsAsync.readFile(
-      `${projectPath}/.history/sui_${network}/latest.json`,
-      'utf8'
-    );
-    return JSON.parse(data) as DeploymentJsonType;
-  } catch (error) {
-    throw new Error(`read .history/sui_${network}/latest.json failed. ${error}`);
-  }
-}
-
-function storeConfig(network: string, packageId: string, schemaId: string, outputPath: string) {
+async function storeConfig(
+  network: string,
+  packageId: string,
+  schemaId: string,
+  outputPath: string
+) {
+  const dubheSchemaId = await getDubheSchemaId(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 PACKAGE_ID = '${packageId}';
+export const SCHEMA_ID = '${schemaId}';
+export const DUBHE_SCHEMA_ID = '${dubheSchemaId}';
 `;
 
-  // if (outputPath) {
   writeOutput(code, outputPath, 'storeConfig');
-  // writeOutput(code, `${path}/src/chain/config.ts`, 'storeConfig');
-  // }
 }
 
 async function writeOutput(
@@ -54,5 +42,5 @@ export async function storeConfigHandler(
   const path = process.cwd();
   const contractPath = `${path}/contracts/${dubheConfig.name}`;
   const deployment = await getDeploymentJson(contractPath, network);
-  storeConfig(deployment.network, deployment.packageId, deployment.schemaId, outputPath);
+  await storeConfig(deployment.network, deployment.packageId, deployment.schemaId, outputPath);
 }

package/src/utils/upgradeHandler.ts

@@ -1,16 +1,16 @@
-import { Dubhe, Transaction, UpgradePolicy } from '@0xobelisk/sui-client';
+import { Transaction, UpgradePolicy } from '@0xobelisk/sui-client';
 import { execSync } from 'child_process';
 import chalk from 'chalk';
-import { DubheCliError, UpgradeError } from './errors';
+import { UpgradeError } from './errors';
 import {
   getOldPackageId,
   getVersion,
   getUpgradeCap,
   saveContractData,
-  validatePrivateKey,
   getOnchainSchemas,
   switchEnv,
-  getSchemaId
+  getSchemaId,
+  initializeDubhe
 } from './utils';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -97,21 +97,9 @@ export async function upgradeHandler(
 
   const path = process.cwd();
   const projectPath = `${path}/contracts/${name}`;
-  const privateKey = process.env.PRIVATE_KEY;
-  if (!privateKey)
-    throw new DubheCliError(
-      `Missing PRIVATE_KEY environment variable.
-Run 'echo "PRIVATE_KEY=YOUR_PRIVATE_KEY" > .env'
-in your contracts directory to use the default sui private key.`
-    );
 
-  const privateKeyFormat = validatePrivateKey(privateKey);
-  if (privateKeyFormat === false) {
-    throw new DubheCliError(`Please check your privateKey.`);
-  }
-  const dubhe = new Dubhe({
-    networkType: network,
-    secretKey: privateKeyFormat
+  const dubhe = initializeDubhe({
+    network
   });
 
   let oldVersion = Number(await getVersion(projectPath, network));
@@ -248,7 +236,9 @@ in your contracts directory to use the default sui private key.`
         console.log(chalk.green(`Migration Transaction Digest: ${result.digest}`));
       },
       onError: (error) => {
-        console.log(chalk.red('Migration Transaction failed!, Please execute the migration manually.'));
+        console.log(
+          chalk.red('Migration Transaction failed!, Please execute the migration manually.')
+        );
         console.error(error);
       }
     });

package/src/utils/utils.ts

@@ -6,6 +6,8 @@ import { FsIibError } from './errors';
 import * as fs from 'fs';
 import chalk from 'chalk';
 import { spawn } from 'child_process';
+import { Dubhe, NetworkType, SuiMoveNormalizedModules } from '@0xobelisk/sui-client';
+import { DubheCliError } from './errors';
 
 export type DeploymentJsonType = {
   projectName: string;
@@ -58,15 +60,49 @@ export async function updateVersionInFile(projectPath: string, newVersion: strin
   }
 }
 
-async function getDeploymentJson(projectPath: string, network: string) {
+export async function getDeploymentJson(
+  projectPath: string,
+  network: string
+): Promise<DeploymentJsonType> {
   try {
     const data = await fsAsync.readFile(
       `${projectPath}/.history/sui_${network}/latest.json`,
       'utf8'
     );
     return JSON.parse(data) as DeploymentJsonType;
-  } catch {
-    throw new FsIibError('Fs read deployment file failed.');
+  } catch (error) {
+    throw new Error(`read .history/sui_${network}/latest.json failed. ${error}`);
+  }
+}
+
+export async function getDeploymentSchemaId(projectPath: string, network: string): Promise<string> {
+  try {
+    const data = await fsAsync.readFile(
+      `${projectPath}/.history/sui_${network}/latest.json`,
+      'utf8'
+    );
+    const deployment = JSON.parse(data) as DeploymentJsonType;
+    return deployment.schemaId;
+  } catch (error) {
+    return '';
+  }
+}
+
+export async function getDubheSchemaId(network: string) {
+  const path = process.cwd();
+  const contractPath = `${path}/contracts/dubhe-framework`;
+
+  switch (network) {
+    case 'mainnet':
+      return await getDeploymentSchemaId(contractPath, 'mainnet');
+    case 'testnet':
+      return '0xa565cbb3641fff8f7e8ef384b215808db5f1837aa72c1cca1803b5d973699aac';
+    case 'devnet':
+      return await getDeploymentSchemaId(contractPath, 'devnet');
+    case 'localnet':
+      return await getDeploymentSchemaId(contractPath, 'localnet');
+    default:
+      throw new Error(`Invalid network: ${network}`);
   }
 }
 
@@ -200,3 +236,38 @@ export async function switchEnv(network: 'mainnet' | 'testnet' | 'devnet' | 'loc
 }
 
 export const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export function loadKey(): string {
+  const privateKey = process.env.PRIVATE_KEY || process.env.NEXT_PUBLIC_PRIVATE_KEY;
+  if (!privateKey) {
+    throw new DubheCliError(
+      `Missing private key environment variable.
+  Run 'echo "PRIVATE_KEY=YOUR_PRIVATE_KEY" > .env'
+  or 'echo "NEXT_PUBLIC_PRIVATE_KEY=YOUR_PRIVATE_KEY" > .env'
+  in your contracts directory to use the default sui private key.`
+    );
+  }
+  const privateKeyFormat = validatePrivateKey(privateKey);
+  if (privateKeyFormat === false) {
+    throw new DubheCliError(`Please check your privateKey.`);
+  }
+  return privateKeyFormat;
+}
+
+export function initializeDubhe({
+  network,
+  packageId,
+  metadata
+}: {
+  network: NetworkType;
+  packageId?: string;
+  metadata?: SuiMoveNormalizedModules;
+}): Dubhe {
+  const privateKey = loadKey();
+  return new Dubhe({
+    networkType: network,
+    secretKey: privateKey,
+    packageId,
+    metadata
+  });
+}

package/src/commands/indexer.ts

@@ -1,56 +0,0 @@
-import type { CommandModule } from 'yargs';
-import { logError } from '../utils/errors';
-import { indexerHandler } from '../utils';
-import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
-
-type Options = {
-  network: any;
-  'config-path': string;
-  db: string;
-  schemaId?: string;
-};
-
-const commandModule: CommandModule<Options, Options> = {
-  command: 'indexer',
-
-  describe: 'Dubhe indexer',
-
-  builder(yargs) {
-    return yargs.options({
-      network: {
-        type: 'string',
-        choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
-        desc: 'Node network (mainnet/testnet/devnet/localnet)',
-        default: 'localnet'
-      },
-      'config-path': {
-        type: 'string',
-        default: 'dubhe.config.ts',
-        desc: 'Configuration file path'
-      },
-      schemaId: {
-        type: 'string',
-        desc: 'Schema ID'
-      },
-      db: {
-        type: 'string',
-        choices: ['sqlite', 'postgres'],
-        desc: 'Optional gas budget for the transaction',
-        default: 'sqlite'
-      }
-    });
-  },
-
-  async handler({ network, 'config-path': configPath, db, schemaId: schemaId }) {
-    try {
-      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      await indexerHandler(dubheConfig, network, db, schemaId);
-    } catch (error: any) {
-      logError(error);
-      process.exit(1);
-    }
-    process.exit(0);
-  }
-};
-
-export default commandModule;