@0xobelisk/sui-cli 1.0.1 → 1.0.3

package/src/commands/query.ts

@@ -0,0 +1,115 @@
+import type { CommandModule } from 'yargs';
+import { logError } from '../utils/errors';
+import { queryStorage } from '../utils';
+import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+
+type Options = {
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+	'config-path': string;
+	schema: string;
+	struct: string;
+	'object-id'?: string;
+	'package-id'?: string;
+	'metadata-path'?: string;
+	params?: any[];
+};
+
+/**
+ * CLI command module for querying schema struct state
+ *
+ * Examples:
+ *
+ * 1. Query StorageValue (no params required):
+ * ```bash
+ * dubhe query --config-path dubhe.config.ts --network devnet --schema counter --struct value
+ * ```
+ *
+ * 2. Query StorageMap (one param required):
+ * ```bash
+ * dubhe query --config-path dubhe.config.ts --network devnet --schema token --struct balances \
+ *   --params "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+ * ```
+ *
+ * 3. Query StorageDoubleMap (two params required):
+ * ```bash
+ * dubhe query --config-path dubhe.config.ts --network devnet --schema game --struct player_relations \
+ *   --params "0x123...456" "0x789...abc"
+ * ```
+ */
+const commandModule: CommandModule<Options, Options> = {
+	command: 'query',
+
+	describe: 'Query dubhe schema struct state',
+
+	builder: {
+		network: {
+			type: 'string',
+			choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+			desc: 'Node network (mainnet/testnet/devnet/localnet)',
+			demandOption: true,
+		},
+		'config-path': {
+			type: 'string',
+			default: 'dubhe.config.ts',
+			desc: 'Configuration file path',
+		},
+		schema: {
+			type: 'string',
+			desc: 'Schema name',
+			demandOption: true,
+		},
+		struct: {
+			type: 'string',
+			desc: 'Struct name',
+			demandOption: true,
+		},
+		'object-id': {
+			type: 'string',
+			desc: 'Object ID (optional)',
+		},
+		'package-id': {
+			type: 'string',
+			desc: 'Package ID (optional)',
+		},
+		'metadata-path': {
+			type: 'string',
+			desc: 'Path to metadata JSON file (optional)',
+		},
+		params: {
+			type: 'array',
+			desc: 'Params for storage type: StorageValue(no params), StorageMap(1 param), StorageDoubleMap(2 params)',
+		},
+	},
+
+	async handler({
+		network,
+		'config-path': configPath,
+		schema,
+		struct,
+		'object-id': objectId,
+		'package-id': packageId,
+		'metadata-path': metadataPath,
+		params,
+	}) {
+		try {
+			const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+
+			await queryStorage({
+				dubheConfig,
+				schema,
+				struct,
+				objectId,
+				network,
+				packageId,
+				metadataFilePath: metadataPath,
+				params,
+			});
+		} catch (error: any) {
+			logError(error);
+			process.exit(1);
+		}
+		process.exit(0);
+	},
+};
+
+export default commandModule;

package/src/commands/schemagen.ts

@@ -5,7 +5,6 @@ import chalk from 'chalk';
 type Options = {
 	'config-path'?: string;
 	network?: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
-	'framework-id'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -24,20 +23,12 @@ const commandModule: CommandModule<Options, Options> = {
 			choices: ['mainnet', 'testnet', 'devnet', 'localnet'] as const,
 			desc: 'Node network (mainnet/testnet/devnet/localnet)',
 		},
-		'framework-id': {
-			type: 'string',
-			desc: 'Framework Package ID',
-		},
 	},
 
-	async handler({
-		'config-path': configPath,
-		network,
-		'framework-id': frameworkId,
-	}) {
+	async handler({ 'config-path': configPath, network }) {
 		try {
 			const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-			await schemaGen(dubheConfig, undefined, network, frameworkId);
+			await schemaGen(dubheConfig, undefined, network);
 			process.exit(0);
 		} catch (error: any) {
 			console.log(chalk.red('Schemagen failed!'));

package/src/utils/index.ts

@@ -3,3 +3,4 @@ export * from './publishHandler';
 export * from './errors';
 export * from './printDubhe';
 export * from './utils';
+export * from './queryStorage';

package/src/utils/queryStorage.ts

@@ -0,0 +1,166 @@
+import { Dubhe, loadMetadata } from '@0xobelisk/sui-client';
+import { DubheCliError } from './errors';
+import { validatePrivateKey, getOldPackageId, getObjectId } 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,
+	struct,
+	params,
+	network,
+	objectId,
+	packageId,
+	metadataFilePath,
+}: {
+	dubheConfig: DubheConfig;
+	schema: string;
+	struct: string;
+	params?: any[];
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+	objectId?: string;
+	packageId?: string;
+	metadataFilePath?: string;
+}) {
+	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 path = process.cwd();
+	const projectPath = `${path}/contracts/${dubheConfig.name}`;
+
+	packageId = packageId || (await getOldPackageId(projectPath, network));
+
+	objectId = objectId || (await getObjectId(projectPath, network, schema));
+
+	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(', ')}`
+		);
+	}
+
+	if (!dubheConfig.schemas[schema].structure[struct]) {
+		throw new DubheCliError(
+			`Struct "${struct}" not found in schema "${schema}". Available structs: ${Object.keys(
+				dubheConfig.schemas[schema].structure
+			).join(', ')}`
+		);
+	}
+
+	const storageType = dubheConfig.schemas[schema].structure[struct];
+
+	const processedParams = params || [];
+	if (!validateParams(storageType, processedParams)) {
+		throw new Error(
+			`Invalid params count for ${storageType}. ` +
+				`Expected: ${getExpectedParamsCount(storageType)}, ` +
+				`Got: ${processedParams.length}`
+		);
+	}
+
+	const dubhe = new Dubhe({
+		secretKey: privateKeyFormat,
+		networkType: network,
+		packageId,
+		metadata,
+	});
+	const result = await dubhe.state({
+		schema,
+		struct,
+		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/utils.ts

@@ -10,7 +10,7 @@ import { spawn } from 'child_process';
 export type schema = {
 	name: string;
 	objectId: string;
-	structure: Record<string, string>
+	structure: Record<string, string>;
 };
 
 export type DeploymentJsonType = {
@@ -110,6 +110,27 @@ export async function getOldPackageId(
 	return deployment.packageId;
 }
 
+export async function getObjectId(
+	projectPath: string,
+	network: string,
+	schemaName: string
+): Promise<string> {
+	const deployment = await getDeploymentJson(projectPath, network);
+	const schema = deployment.schemas.find(schema =>
+		schema.name
+			.toLowerCase()
+			.endsWith(`::${schemaName.toLowerCase()}_schema::${schemaName}`)
+	);
+
+	if (!schema?.objectId) {
+		throw new Error(
+			`Schema '${schemaName}' not found in deployment history`
+		);
+	}
+
+	return schema.objectId;
+}
+
 export async function getUpgradeCap(
 	projectPath: string,
 	network: string
@@ -134,7 +155,7 @@ export function saveContractData(
 	packageId: string,
 	upgradeCap: string,
 	version: number,
-  schemas: schema[],
+	schemas: schema[]
 ) {
 	const DeploymentData: DeploymentJsonType = {
 		projectName,
@@ -167,7 +188,9 @@ export async function writeOutput(
 	}
 }
 
-function getDubheDependency(network: 'mainnet' | 'testnet' |  'devnet' | 'localnet'): string {
+function getDubheDependency(
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+): string {
 	switch (network) {
 		case 'localnet':
 			return 'Dubhe = { local = "../dubhe-framework" }';
@@ -180,14 +203,19 @@ function getDubheDependency(network: 'mainnet' | 'testnet' |  'devnet' | 'localn
 	}
 }
 
-export function updateDubheDependency(filePath: string, network: 'mainnet' | 'testnet' | 'devnet' | 'localnet') {
+export function updateDubheDependency(
+	filePath: string,
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+) {
 	const fileContent = fs.readFileSync(filePath, 'utf-8');
 	const newDependency = getDubheDependency(network);
 	const updatedContent = fileContent.replace(/Dubhe = \{.*\}/, newDependency);
 	fs.writeFileSync(filePath, updatedContent, 'utf-8');
 	console.log(`Updated Dubhe dependency in ${filePath} for ${network}.`);
 }
-export async function switchEnv(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet') {
+export async function switchEnv(
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+) {
 	try {
 		return new Promise<void>((resolve, reject) => {
 			const suiProcess = spawn(
@@ -195,7 +223,7 @@ export async function switchEnv(network: 'mainnet' | 'testnet' | 'devnet' | 'loc
 				['client', 'switch', '--env', network],
 				{
 					env: { ...process.env },
-					stdio: 'pipe'
+					stdio: 'pipe',
 				}
 			);
 
@@ -209,9 +237,11 @@ export async function switchEnv(network: 'mainnet' | 'testnet' | 'devnet' | 'loc
 				reject(error); // Reject promise on error
 			});
 
-			suiProcess.on('exit', (code) => {
+			suiProcess.on('exit', code => {
 				if (code !== 0) {
-					console.error(chalk.red(`\n❌ Process exited with code: ${code}`));
+					console.error(
+						chalk.red(`\n❌ Process exited with code: ${code}`)
+					);
 					reject(new Error(`Process exited with code: ${code}`));
 				} else {
 					resolve(); // Resolve promise on successful exit