@0xobelisk/sui-cli 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-cli",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -31,7 +31,7 @@
     "dubhe": "./dist/dubhe.js"
   },
   "dependencies": {
-    "@mysten/sui": "^1.7.0",
+    "@mysten/sui": "^1.19.0",
     "chalk": "^5.0.1",
     "child_process": "^1.0.2",
     "dotenv": "^16.0.3",
@@ -45,8 +45,11 @@
     "yargs": "^17.7.1",
     "zod": "^3.22.3",
     "zod-validation-error": "^1.3.0",
-    "@0xobelisk/sui-common": "1.0.3",
-    "@0xobelisk/sui-client": "1.0.3"
+    "@types/sqlite3": "^3.1.11",
+    "sqlite": "^5.1.1",
+    "sqlite3": "^5.1.7",
+    "@0xobelisk/sui-common": "1.0.4",
+    "@0xobelisk/sui-client": "1.0.4"
   },
   "devDependencies": {
     "@types/ejs": "^3.1.1",

package/src/commands/build.ts

@@ -1,56 +1,62 @@
-import type { CommandModule } from "yargs";
-import { execSync } from "child_process";
-import chalk from "chalk";
+import type { CommandModule } from 'yargs';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
 import { switchEnv, updateDubheDependency } from '../utils';
 
 type Options = {
-  'config-path': string;
-   network: any;
-  'dump-bytecode-as-base64'?: boolean;
+	'config-path': string;
+	network: any;
+	'dump-bytecode-as-base64'?: boolean;
 };
 
 const commandModule: CommandModule<Options, Options> = {
-  command: "build",
-  describe: "Run tests in Dubhe contracts",
-  builder(yargs) {
-    return yargs.options({
-      'config-path': {
-        type: "string",
-        default: "dubhe.config.ts",
-        description: "Options to pass to forge test",
-      },
-      network: {
-        type: 'string',
-        choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
-        desc: 'Node network (mainnet/testnet/devnet/localnet)',
-      },
-      'dump-bytecode-as-base64': {
-        type: 'boolean',
-        default: false,
-        desc: 'Dump bytecode as base64',
-      },
-    });
-  },
+	command: 'build',
+	describe: 'Run tests in Dubhe contracts',
+	builder(yargs) {
+		return yargs.options({
+			'config-path': {
+				type: 'string',
+				default: 'dubhe.config.ts',
+				description: 'Options to pass to forge test',
+			},
+			network: {
+				type: 'string',
+				choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+				desc: 'Node network (mainnet/testnet/devnet/localnet)',
+			},
+			'dump-bytecode-as-base64': {
+				type: 'boolean',
+				default: false,
+				desc: 'Dump bytecode as base64',
+			},
+		});
+	},
 
-  async handler({ 'config-path': configPath, network, 'dump-bytecode-as-base64': dumpBytecodeAsBase64 }) {
-    // Start an internal anvil process if no world address is provided
-    try {
-      console.log('🚀 Running move build');
-      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      const path = process.cwd();
-      const projectPath = `${path}/contracts/${dubheConfig.name}`;
-      await switchEnv(network);
-      updateDubheDependency(projectPath+'/Move.toml', network);
-      const command = `sui move build --path ${projectPath} ${dumpBytecodeAsBase64 ? ` --dump-bytecode-as-base64` : ''}`;
-      const output = execSync(command, { encoding: "utf-8" });
-      console.log(output);
-    } catch (error: any) {
-      console.error(chalk.red("Error executing sui move build:"));
-      console.log(error.stdout);
-      process.exit(0);
-    }
-  },
+	async handler({
+		'config-path': configPath,
+		network,
+		'dump-bytecode-as-base64': dumpBytecodeAsBase64,
+	}) {
+		// Start an internal anvil process if no world address is provided
+		try {
+			console.log('🚀 Running move build');
+			const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+			const path = process.cwd();
+			const projectPath = `${path}/contracts/${dubheConfig.name}`;
+			await switchEnv(network);
+			await updateDubheDependency(projectPath + '/Move.toml', network);
+			const command = `sui move build --path ${projectPath} ${
+				dumpBytecodeAsBase64 ? ` --dump-bytecode-as-base64` : ''
+			}`;
+			const output = execSync(command, { encoding: 'utf-8' });
+			console.log(output);
+		} catch (error: any) {
+			console.error(chalk.red('Error executing sui move build:'));
+			console.log(error.stdout);
+			process.exit(0);
+		}
+	},
 };
 
 export default commandModule;

package/src/commands/call.ts

@@ -26,7 +26,7 @@ const commandModule: CommandModule<Options, Options> = {
 			type: 'string',
 			choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
 			desc: 'Node network (mainnet/testnet/devnet/localnet)',
-			demandOption: true,
+			default: 'localnet',
 		},
 		module: {
 			type: 'string',

package/src/commands/checkBalance.ts

@@ -13,6 +13,7 @@ const commandModule: CommandModule<Options, Options> = {
 			type: 'string',
 			choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
 			desc: 'Network to check balance on',
+			default: 'localnet',
 		},
 	},
 	async handler({ network }) {

package/src/commands/faucet.ts

@@ -51,8 +51,7 @@ const commandModule: CommandModule<Options, Options> = {
 			const dubhe = new Dubhe({
 				secretKey: privateKeyFormat,
 			});
-			const keypair = dubhe.getKeypair();
-			faucet_address = keypair.toSuiAddress();
+			faucet_address = dubhe.getAddress();
 		} else {
 			faucet_address = recipient;
 		}

package/src/commands/index.ts

@@ -13,6 +13,7 @@ import checkBalance from './checkBalance';
 import configStore from './configStore';
 import query from './query';
 import call from './call';
+import indexer from './indexer';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
@@ -29,4 +30,5 @@ export const commands: CommandModule<any, any>[] = [
 	generateKey,
 	checkBalance,
 	configStore,
+	indexer,
 ];

package/src/commands/indexer.ts

@@ -0,0 +1,61 @@
+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;

package/src/commands/publish.ts

@@ -19,6 +19,7 @@ const commandModule: CommandModule<Options, Options> = {
 			network: {
 				type: 'string',
 				choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+				default: 'localnet',
 				desc: 'Node network (mainnet/testnet/devnet/localnet)',
 			},
 			'config-path': {

package/src/commands/query.ts

@@ -7,7 +7,6 @@ type Options = {
 	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
 	'config-path'?: string;
 	schema: string;
-	field: string;
 	'object-id'?: string;
 	'package-id'?: string;
 	'metadata-path'?: string;
@@ -45,8 +44,8 @@ const commandModule: CommandModule<Options, Options> = {
 		network: {
 			type: 'string',
 			choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+			default: 'localnet',
 			desc: 'Node network (mainnet/testnet/devnet/localnet)',
-			demandOption: true,
 		},
 		'config-path': {
 			type: 'string',
@@ -58,11 +57,6 @@ const commandModule: CommandModule<Options, Options> = {
 			desc: 'Schema name',
 			demandOption: true,
 		},
-		field: {
-			type: 'string',
-			desc: 'Field name',
-			demandOption: true,
-		},
 		'object-id': {
 			type: 'string',
 			desc: 'Object ID (optional)',
@@ -86,7 +80,6 @@ const commandModule: CommandModule<Options, Options> = {
 		network,
 		'config-path': configPath,
 		schema,
-		field,
 		'object-id': objectId,
 		'package-id': packageId,
 		'metadata-path': metadataPath,
@@ -98,7 +91,6 @@ const commandModule: CommandModule<Options, Options> = {
 			await queryStorage({
 				dubheConfig,
 				schema,
-				field,
 				objectId,
 				network,
 				packageId,

package/src/commands/upgrade.ts

@@ -18,6 +18,7 @@ const commandModule: CommandModule<Options, Options> = {
 			network: {
 				type: 'string',
 				choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+				default: 'localnet',
 				desc: 'Network of the node (mainnet/testnet/devnet/localnet)',
 			},
 			'config-path': {

package/src/utils/generateAccount.ts

@@ -23,7 +23,7 @@ export async function generateAccountHandler(
 
 	if (force) {
 		const dubhe = new Dubhe();
-		const keypair = dubhe.getKeypair();
+		const keypair = dubhe.getSigner();
 		privateKey = keypair.getSecretKey();
 
 		fs.writeFileSync(`${path}/.env`, `PRIVATE_KEY=${privateKey}`);
@@ -59,7 +59,7 @@ export const ACCOUNT = '${keypair.toSuiAddress()}';
 		if (match && match[1]) {
 			privateKey = match[1];
 			const dubhe = new Dubhe({ secretKey: privateKey });
-			const keypair = dubhe.getKeypair();
+			const keypair = dubhe.getSigner();
 
 			if (outputTsPath) {
 				const dir = outputTsPath.substring(
@@ -89,7 +89,7 @@ export const ACCOUNT = '${keypair.toSuiAddress()}';
 
 	// If no existing private key, generate new account
 	const dubhe = new Dubhe();
-	const keypair = dubhe.getKeypair();
+	const keypair = dubhe.getSigner();
 	privateKey = keypair.getSecretKey();
 	fs.writeFileSync(`${path}/.env`, `PRIVATE_KEY=${privateKey}`);
 	console.log(chalk.green(`File created at: ${path}/.env`));

package/src/utils/index.ts

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

package/src/utils/indexerHandler.ts

@@ -0,0 +1,232 @@
+import { DubheCliError } from './errors';
+import {delay, getSchemaId} from './utils';
+import { DubheConfig } from '@0xobelisk/sui-common';
+import {getFullnodeUrl, SuiClient, SuiTransactionBlockResponse} from "@mysten/sui/client";
+import sqlite3 from 'sqlite3';
+import {Database, open} from 'sqlite';
+import chalk from "chalk";
+
+let sqliteDB: Database;
+
+const createDB = async (name: string) => {
+	sqliteDB = await open({
+		filename: `./${name}.db`,
+		driver: sqlite3.Database
+	});
+	await createTable(sqliteDB, name);
+	await createTxsTable(sqliteDB);
+	return sqliteDB;
+}
+const createTable = async (sqliteDB: Database, name: string) => {
+	let sql = `
+        CREATE TABLE IF NOT EXISTS ${name} (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            last_update_checkpoint TEXT,
+            last_update_digest TEXT,
+            name TEXT,
+            key1 TEXT,
+            key2 TEXT,
+            value TEXT,
+            is_removed BOOLEAN DEFAULT FALSE
+        )`;
+	await sqliteDB.exec(sql);
+}
+
+const createTxsTable = async (sqliteDB: Database) => {
+	let sql = `
+        CREATE TABLE IF NOT EXISTS dapp_transaction (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            checkpoint TEXT,
+            digest TEXT
+        )
+    `
+	await sqliteDB.exec(sql);
+}
+
+type SetRecord = {
+	name: string,
+	key1: string | object,
+	key2: string | object,
+	value: string | object
+}
+
+type RemoveRecord = {
+	name: string,
+	key1: string | object,
+	key2: string | object,
+}
+
+const processSetRecord = async (sqliteDB: Database, dbName: string, checkpoint: string, digest: string, event: unknown) => {
+	let res = event as SetRecord;
+	if ((typeof res.key1 === 'object' && res.key1 !== null) || Array.isArray(res.key1)) {
+		res.key1 = serializeData(res.key1);
+	} else if ((typeof res.key2 === 'object' && res.key2 !== null) || Array.isArray(res.key2)) {
+		res.key2 = serializeData(res.key2);
+	} else if (typeof res.value === 'object' || Array.isArray(res.value)) {
+		res.value = serializeData(res.value);
+	}
+	await insertData(sqliteDB, dbName, {
+		checkpoint: checkpoint,
+		digest: digest,
+		event: res
+	});
+}
+
+const processRemoveRecord = async (sqliteDB: Database, dbName: string, checkpoint: string, digest: string, event: unknown) => {
+	let res = event as RemoveRecord;
+	if ((typeof res.key1 === 'object' && res.key1 !== null) || Array.isArray(res.key1)) {
+		res.key1 = serializeData(res.key1);
+	} else if ((typeof res.key2 === 'object' && res.key2 !== null) || Array.isArray(res.key2)) {
+		res.key2 = serializeData(res.key2);
+	}
+	await removeData(sqliteDB, dbName, {
+		checkpoint: checkpoint,
+		digest: digest,
+		event: res
+	});
+}
+
+type SetData = {
+	checkpoint: string,
+	digest: string,
+	event: SetRecord
+}
+
+type RemoveData = {
+	checkpoint: string,
+	digest: string,
+	event: RemoveRecord
+}
+
+const serializeData = (data: object): string => {
+	if (data.hasOwnProperty("fields")) {
+		// @ts-ignore
+		return JSON.stringify(data["fields"]);
+	}
+	return JSON.stringify(data);
+};
+
+async function insertData(sqliteDB: Database, dbName: string, data: SetData) {
+	const { checkpoint, digest, event } = data;
+
+	let sql = `
+        INSERT OR REPLACE INTO ${dbName} (id, last_update_checkpoint, last_update_digest, name, key1, key2, value)
+        VALUES (
+        (SELECT id FROM ${dbName} WHERE name = ? AND (key1 = ? OR key1 IS NULL) AND (key2 = ? OR key2 IS NULL)),
+        ?, ?, ?, ?, ?, ?
+        )
+    `;
+
+	const values = [event.name, event.key1, event.key2, checkpoint, digest, event.name, event.key1, event.key2, event.value];
+
+	await sqliteDB.run(sql, values);
+	console.log("Insert or update data: ", checkpoint, digest, dbName, data);
+}
+
+async function removeData(sqliteDB: Database, dbName: string, data: RemoveData) {
+	const { checkpoint, digest, event } = data;
+
+	let sql = `
+        UPDATE ${dbName}
+        SET is_removed = TRUE
+        WHERE name = ? AND (key1 = ? OR key1 IS NULL) AND (key2 = ? OR key2 IS NULL)
+    `;
+
+	await sqliteDB.run(sql, [event.name, event.key1, event.key2]);
+	console.log("Remove data: ", checkpoint, digest, dbName, data);
+}
+
+async function insertTx(sqliteDB: Database, checkpoint: string, digest: string) {
+	let sql = `
+        INSERT INTO dapp_transaction (checkpoint, digest)
+        VALUES (?, ?)
+    `;
+
+	await sqliteDB.run(sql, [checkpoint, digest]);
+	console.log("Insert transaction: ", checkpoint, digest);
+}
+
+async function getLastDigest(sqliteDB: Database): Promise<string | null> {
+	const row = await sqliteDB.get(`
+        SELECT digest FROM dapp_transaction
+        ORDER BY id DESC
+        LIMIT 1
+    `);
+
+	return row ? row.digest : null;
+}
+
+export async function indexerHandler(
+	dubheConfig: DubheConfig,
+	network: 		'mainnet' | 'testnet' | 'devnet' | 'localnet',
+	db: 			string,
+	schemaId: 		string | undefined,
+) {
+	const path = process.cwd();
+	const projectPath = `${path}/contracts/${dubheConfig.name}`;
+
+	schemaId = schemaId || (await getSchemaId(projectPath, network));
+
+	console.log('\n🚀 Sqlite Started');
+	console.log(`  ├─ Project: ${projectPath}`);
+	console.log(`  ├─ Network: ${network}`);
+	console.log(`  ├─ Database: ${db}`);
+	console.log(`  ├─ Schema ID: ${schemaId}`);
+
+	if (!schemaId) {
+		throw new DubheCliError(
+			`Schema ID not found. Please provide a schema ID with the --schemaId flag.`
+		);
+	}
+	const client = new SuiClient({url: getFullnodeUrl(network) });
+
+	if(db === 'sqlite') {
+		sqliteDB = await createDB(dubheConfig.name);
+		while (true) {
+			await delay(2000);
+			const cursor = await getLastDigest(sqliteDB)
+			const response = await client.queryTransactionBlocks({
+				filter: {
+					// Transaction: 'FD43PRNS2PyNcYExFxwuouLqTVvonTd6NtDYMiVB7ZxZ'
+					// MoveFunction: {
+					//     package: '0x2dd117c4f48a6be9d2dd20eff67903ebf07080c7e259c7c589078fe21bb78471',
+					//     module: 'message_system',
+					//     function: 'send'
+					// }
+					ChangedObject: schemaId
+				},
+				order: "ascending",
+				cursor: cursor,
+				// limit: 2,
+				options: {
+					showEvents: true
+				}
+			});
+			const txs = response.data as SuiTransactionBlockResponse[]
+			// console.log("New Transactions: ", txs);
+			for (const tx of txs) {
+				await insertTx(sqliteDB, tx.checkpoint?.toString() as string, tx.digest);
+				if (tx.events) {
+					for (const event of tx.events) {
+						// @ts-ignore
+						if (event.parsedJson.hasOwnProperty("value")) {
+							await processSetRecord(sqliteDB, dubheConfig.name, tx.checkpoint?.toString() as string, tx.digest, event.parsedJson);
+						} else {
+							await processRemoveRecord(sqliteDB, dubheConfig.name, tx.checkpoint?.toString() as string, tx.digest, event.parsedJson);
+						}
+					}
+				}
+			}
+		};
+	} else {
+		throw new DubheCliError(
+			`Database "${db}" not supported. Supported databases: sqlite`
+		);
+	}
+}
+
+process.on('SIGINT', async () => {
+	await sqliteDB.close();
+	console.log(chalk.green('✅ Sqlite Stopped'));
+	process.exit();
+});