@0xobelisk/sui-cli 1.0.3 → 1.0.5

package/src/commands/call.ts

@@ -0,0 +1,90 @@
+import type { CommandModule } from 'yargs';
+import { logError } from '../utils/errors';
+import { callHandler } from '../utils';
+import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+
+type Options = {
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+	module: string;
+	function: string;
+	'config-path'?: string;
+	'package-id'?: string;
+	'metadata-path'?: string;
+	params?: any[];
+};
+
+/**
+ * CLI command for calling a function in a module
+ */
+const commandModule: CommandModule<Options, Options> = {
+	command: 'call',
+
+	describe: 'Call a function in a module',
+
+	builder: {
+		network: {
+			type: 'string',
+			choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+			desc: 'Node network (mainnet/testnet/devnet/localnet)',
+			demandOption: true,
+		},
+		module: {
+			type: 'string',
+			desc: 'Module name',
+			demandOption: true,
+		},
+		function: {
+			type: 'string',
+			desc: 'Function name',
+			demandOption: true,
+		},
+		'config-path': {
+			type: 'string',
+			default: 'dubhe.config.ts',
+			desc: 'Configuration file path',
+		},
+		'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 the function',
+			string: true,
+		},
+	},
+
+	async handler({
+		network,
+		'config-path': configPath,
+		module: moduleName,
+		function: funcName,
+		'package-id': packageId,
+		'metadata-path': metadataPath,
+		params,
+	}) {
+		try {
+			const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+
+			await callHandler({
+				dubheConfig,
+				moduleName,
+				funcName,
+				network,
+				packageId,
+				metadataFilePath: metadataPath,
+				params,
+			});
+		} catch (error: any) {
+			logError(error);
+			process.exit(1);
+		}
+		process.exit(0);
+	},
+};
+
+export default commandModule;

package/src/commands/index.ts

@@ -12,11 +12,13 @@ import generateKey from './generateKey';
 import checkBalance from './checkBalance';
 import configStore from './configStore';
 import query from './query';
+import call from './call';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
 	localnode,
 	publish,
+	call,
 	query,
 	faucet,
 	schemagen,

package/src/commands/query.ts

@@ -5,9 +5,9 @@ import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
 
 type Options = {
 	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
-	'config-path': string;
+	'config-path'?: string;
 	schema: string;
-	struct: string;
+	field: string;
 	'object-id'?: string;
 	'package-id'?: string;
 	'metadata-path'?: string;
@@ -21,18 +21,18 @@ type Options = {
  *
  * 1. Query StorageValue (no params required):
  * ```bash
- * dubhe query --config-path dubhe.config.ts --network devnet --schema counter --struct value
+ * dubhe query --config-path dubhe.config.ts --network devnet --schema counter --field value
  * ```
  *
  * 2. Query StorageMap (one param required):
  * ```bash
- * dubhe query --config-path dubhe.config.ts --network devnet --schema token --struct balances \
+ * dubhe query --config-path dubhe.config.ts --network devnet --schema token --field balances \
  *   --params "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
  * ```
  *
  * 3. Query StorageDoubleMap (two params required):
  * ```bash
- * dubhe query --config-path dubhe.config.ts --network devnet --schema game --struct player_relations \
+ * dubhe query --config-path dubhe.config.ts --network devnet --schema game --field player_relations \
  *   --params "0x123...456" "0x789...abc"
  * ```
  */
@@ -58,9 +58,9 @@ const commandModule: CommandModule<Options, Options> = {
 			desc: 'Schema name',
 			demandOption: true,
 		},
-		struct: {
+		field: {
 			type: 'string',
-			desc: 'Struct name',
+			desc: 'Field name',
 			demandOption: true,
 		},
 		'object-id': {
@@ -78,6 +78,7 @@ const commandModule: CommandModule<Options, Options> = {
 		params: {
 			type: 'array',
 			desc: 'Params for storage type: StorageValue(no params), StorageMap(1 param), StorageDoubleMap(2 params)',
+			string: true,
 		},
 	},
 
@@ -85,7 +86,7 @@ const commandModule: CommandModule<Options, Options> = {
 		network,
 		'config-path': configPath,
 		schema,
-		struct,
+		field,
 		'object-id': objectId,
 		'package-id': packageId,
 		'metadata-path': metadataPath,
@@ -97,7 +98,7 @@ const commandModule: CommandModule<Options, Options> = {
 			await queryStorage({
 				dubheConfig,
 				schema,
-				struct,
+				field,
 				objectId,
 				network,
 				packageId,

package/src/commands/test.ts

@@ -6,6 +6,7 @@ import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
 type Options = {
   'config-path': string;
   'test'?: string;
+  'gas-limit'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -24,19 +25,22 @@ const commandModule: CommandModule<Options, Options> = {
         type: 'string',
         desc: 'Run a specific test',
       },
+      'gas-limit': {
+        type: 'string',
+        desc: 'Set the gas limit for the test',
+      },
     });
   },
 
-  async handler({ 'config-path': configPath, test }) {
+  async handler({ 'config-path': configPath, test, 'gas-limit': gasLimit }) {
     // Start an internal anvil process if no world address is provided
     try {
       console.log('🚀 Running move test');
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
       const path = process.cwd();
       const projectPath = `${path}/contracts/${dubheConfig.name}`;
-      const command = `sui move test --path ${projectPath} ${test ? ` --test ${test}` : ''}`;
-      const output =  execSync(command, { encoding: "utf-8" });
-      console.log(output);
+      const command = `sui move test --path ${projectPath} ${test ? ` --test ${test}` : ''} ${gasLimit ? ` --gas-limit ${gasLimit}` : ''}`;
+      execSync(command, { stdio: 'inherit', encoding: "utf-8" });
     } catch (error: any) {
       console.error(chalk.red("Error executing sui move test:"));
       console.log(error.stdout);

package/src/utils/callHandler.ts

@@ -0,0 +1,166 @@
+import {
+	Dubhe,
+	loadMetadata,
+	Transaction,
+	TransactionResult,
+} from '@0xobelisk/sui-client';
+import { DubheCliError } from './errors';
+import { validatePrivateKey, getOldPackageId, getObjectId } from './utils';
+import { DubheConfig } from '@0xobelisk/sui-common';
+import { loadMetadataFromFile } from './queryStorage';
+
+const BaseTxType = [
+	'u8',
+	'u16',
+	'u32',
+	'u64',
+	'u128',
+	'u256',
+	'bool',
+	'id',
+	'string',
+	'address',
+	'object',
+];
+
+function validateParams(params: any[]) {
+	try {
+		params.forEach(param => {
+			const [type, value] = param.split(':');
+			if (!BaseTxType.includes(type)) {
+				throw new Error(`Invalid param type: ${type}`);
+			}
+		});
+	} catch (error) {
+		throw new Error(`Invalid params: ${error}`);
+	}
+}
+
+// param:
+// u8:1
+// u16:1
+// u32:1
+// u64:1
+// u128:1
+// u256:1
+// object:0x1
+// address:0x1
+// bool:true
+// string:"hello"
+function formatBCS(tx: Transaction, param: string) {
+	const [type, value] = param.split(':');
+	switch (type) {
+		case 'u8':
+			return tx.pure.u8(parseInt(value));
+		case 'u16':
+			return tx.pure.u16(parseInt(value));
+		case 'u32':
+			return tx.pure.u32(parseInt(value));
+		case 'u64':
+			return tx.pure.u64(parseInt(value));
+		case 'u128':
+			return tx.pure.u128(parseInt(value));
+		case 'u256':
+			return tx.pure.u256(parseInt(value));
+		case 'object':
+			return tx.object(value);
+		case 'address':
+			return tx.pure.address(value);
+		case 'bool':
+			return tx.pure.bool(value === 'true');
+		case 'string':
+			return tx.pure.string(value);
+		default:
+			throw new Error(`Invalid param type: ${type}`);
+	}
+}
+
+function formatBCSParams(tx: Transaction, params: any[]) {
+	return params.map(param => formatBCS(tx, param));
+}
+
+export async function callHandler({
+	dubheConfig,
+	moduleName,
+	funcName,
+	params,
+	network,
+	packageId,
+	metadataFilePath,
+}: {
+	dubheConfig: DubheConfig;
+	moduleName: string;
+	funcName: string;
+	params?: any[];
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+	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 || [];
+	validateParams(processedParams);
+	const dubhe = new Dubhe({
+		secretKey: privateKeyFormat,
+		networkType: network,
+		packageId,
+		metadata,
+	});
+	const tx = new Transaction();
+	const formattedParams = formatBCSParams(tx, processedParams);
+
+	const result = (await dubhe.tx[moduleName][funcName]({
+		tx,
+		params: formattedParams,
+	})) as TransactionResult;
+
+	console.log(result);
+}

package/src/utils/index.ts

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

package/src/utils/queryStorage.ts

@@ -36,7 +36,7 @@ function getExpectedParamsCount(storageType: string): number {
 export async function queryStorage({
 	dubheConfig,
 	schema,
-	struct,
+	field,
 	params,
 	network,
 	objectId,
@@ -45,7 +45,7 @@ export async function queryStorage({
 }: {
 	dubheConfig: DubheConfig;
 	schema: string;
-	struct: string;
+	field: string;
 	params?: any[];
 	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
 	objectId?: string;
@@ -92,15 +92,15 @@ in your contracts directory to use the default sui private key.`
 		);
 	}
 
-	if (!dubheConfig.schemas[schema].structure[struct]) {
+	if (!dubheConfig.schemas[schema][field]) {
 		throw new DubheCliError(
-			`Struct "${struct}" not found in schema "${schema}". Available structs: ${Object.keys(
-				dubheConfig.schemas[schema].structure
+			`Field "${field}" not found in schema "${schema}". Available fields: ${Object.keys(
+				dubheConfig.schemas[schema]
 			).join(', ')}`
 		);
 	}
 
-	const storageType = dubheConfig.schemas[schema].structure[struct];
+	const storageType = dubheConfig.schemas[schema][field];
 
 	const processedParams = params || [];
 	if (!validateParams(storageType, processedParams)) {
@@ -119,7 +119,7 @@ in your contracts directory to use the default sui private key.`
 	});
 	const result = await dubhe.state({
 		schema,
-		struct,
+		field,
 		objectId,
 		storageType,
 		params: processedParams,