@0xobelisk/sui-common 1.1.6 → 1.1.8

package/src/codegen/utils/formatAndWrite.ts

@@ -1,7 +1,7 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { formatMove, formatTypescript } from "./format";
-import { debug } from "../debug";
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { formatMove, formatTypescript } from './format';
+import { debug } from '../debug';
 
 export async function formatAndWriteMove(
   output: string,
@@ -9,27 +9,30 @@ export async function formatAndWriteMove(
   logPrefix?: string
 ): Promise<void> {
   const formattedOutput = await formatMove(output);
-  let schemaPrefix =
-`  // Copyright (c) Obelisk Labs, Inc.
+  let schemaPrefix = `  // Copyright (c) Obelisk Labs, Inc.
   // SPDX-License-Identifier: Apache-2.0
   #[allow(unused_use)]
   
   /* Autogenerated file. Do not edit manually. */
   
-  `
+  `;
 
-  let initPrefix = `#[test_only]`
+  let initPrefix = `#[test_only]`;
 
-  let code = schemaPrefix + formattedOutput
+  let code = schemaPrefix + formattedOutput;
 
-  let deployHookPrefix = `#[allow(lint(share_owned))]`
+  let deployHookPrefix = `#[allow(lint(share_owned))]`;
 
-  if (fullOutputPath.includes(".toml") || fullOutputPath.includes("system") || fullOutputPath.includes("migrate")) {
-    code = formattedOutput
-  } else if (fullOutputPath.includes("init")) {
-    code = initPrefix + formattedOutput
-  } else if (fullOutputPath.includes("genesis")) {
-    code = deployHookPrefix + formattedOutput
+  if (
+    fullOutputPath.includes('.toml') ||
+    fullOutputPath.includes('system') ||
+    fullOutputPath.includes('migrate')
+  ) {
+    code = formattedOutput;
+  } else if (fullOutputPath.includes('init')) {
+    code = initPrefix + formattedOutput;
+  } else if (fullOutputPath.includes('genesis')) {
+    code = deployHookPrefix + formattedOutput;
   }
 
   await fs.mkdir(path.dirname(fullOutputPath), { recursive: true });
@@ -44,9 +47,9 @@ export async function formatAndWriteMove(
  * @param logPrefix prefix for debug logs
  */
 export async function formatAndWriteTypescript(
-    output: string,
-    fullOutputPath: string,
-    logPrefix: string,
+  output: string,
+  fullOutputPath: string,
+  logPrefix: string
 ): Promise<void> {
   const formattedOutput = await formatTypescript(output);
 

package/src/codegen/utils/posixPath.ts

@@ -4,5 +4,5 @@
  * because solc expects `/` as path separator, but path.join produces `\` if the user is on windows.
  */
 export function posixPath(path: string): string {
-  return path.replace(/\\/g, "/");
+  return path.replace(/\\/g, '/');
 }

package/src/codegen/utils/renderMove/common.ts

@@ -2,21 +2,21 @@ import { MoveType } from '../../types';
 import fs from 'fs';
 
 export function deleteFolderRecursive(path: string) {
-	if (fs.existsSync(path)) {
-		fs.readdirSync(path).forEach(file => {
-			const curPath = `${path}/${file}`;
-			if (fs.lstatSync(curPath).isDirectory()) {
-				deleteFolderRecursive(curPath);
-			} else {
-				fs.unlinkSync(curPath);
-			}
-		});
-		fs.rmdirSync(path);
-	}
+  if (fs.existsSync(path)) {
+    fs.readdirSync(path).forEach((file) => {
+      const curPath = `${path}/${file}`;
+      if (fs.lstatSync(curPath).isDirectory()) {
+        deleteFolderRecursive(curPath);
+      } else {
+        fs.unlinkSync(curPath);
+      }
+    });
+    fs.rmdirSync(path);
+  }
 }
 
 export function capitalizeFirstLetter(input: string): string {
-	return input.charAt(0).toUpperCase() + input.slice(1);
+  return input.charAt(0).toUpperCase() + input.slice(1);
 }
 
 /**
@@ -25,17 +25,15 @@ export function capitalizeFirstLetter(input: string): string {
  * @param prefixArgs
  * @return [ name, age, birth_time ]
  */
-export function getStructAttrs(
-	values: Record<string, string> | string
-): string {
-	return Object.entries(values)
-		.map(([key, _]) => `${key}`)
-		.join(',');
+export function getStructAttrs(values: Record<string, string> | string): string {
+  return Object.entries(values)
+    .map(([key, _]) => `${key}`)
+    .join(',');
 }
 
 function isAddress(str: string): boolean {
-	const regex = /^0x[a-fA-F0-9]+$/;
-	return regex.test(str);
+  const regex = /^0x[a-fA-F0-9]+$/;
+  return regex.test(str);
 }
 
 /**
@@ -44,10 +42,8 @@ function isAddress(str: string): boolean {
  * @return ( bool , u64 , u64)
  */
 // export function getStructTypes(values: SchemaType): string {
-export function getStructTypes(
-	values: Record<string, string>
-): string {
-	return `(${Object.entries(values).map(([_, type]) => `${type}`)})`;
+export function getStructTypes(values: Record<string, string>): string {
+  return `(${Object.entries(values).map(([_, type]) => `${type}`)})`;
 }
 
 /**
@@ -55,30 +51,29 @@ export function getStructTypes(
  * @param values
  * @return Attributes and types of the struct. [ name: string, age: u64 ]
  */
-export function getStructAttrsWithType(
-	values: Record<string, string>
-): string[] {
-	return Object.entries(values).map(([key, type]) => `${key}: ${type}`);
+export function getStructAttrsWithType(values: Record<string, string>): string[] {
+  return Object.entries(values).map(([key, type]) => `${key}: ${type}`);
 }
 
 /**
  * @param values
  * @return [ data.name, data.age ]
  */
-export function getStructAttrsQuery(
-	values: Record<string, string>,
-): string[] {
-	return Object.entries(values).map(([key, _]) => `self.${key}`);
+export function getStructAttrsQuery(values: Record<string, string>): string[] {
+  return Object.entries(values).map(([key, _]) => `self.${key}`);
 }
 
 export function containsString(obj: Record<string, any>, searchString: string): boolean {
-	for (const key in obj) {
-		if (obj.hasOwnProperty(key)) {
-			const value = obj[key];
-			if (typeof value === 'string' && value === searchString) {
-				return true;
-			}
-		}
-	}
-	return false;
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const value = obj[key];
+      if (
+        (typeof value === 'string' && value === searchString) ||
+        (typeof value === 'string' && value.includes(searchString) && value.includes('>'))
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
 }

package/src/codegen/utils/renderMove/generateDappKey.ts

@@ -1,16 +1,13 @@
 import { DubheConfig } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 
-export async function generateDappKey(
-	config: DubheConfig,
-	srcPrefix: string
-) {
-	console.log('\n🔑 Starting DappKey Generation...');
-	console.log(
-		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/codegen/dapp_key.move`
-	);
+export async function generateDappKey(config: DubheConfig, srcPrefix: string) {
+  console.log('\n🔑 Starting DappKey Generation...');
+  console.log(
+    `  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/codegen/dapp_key.move`
+  );
 
-	let code = `module ${config.name}::${config.name}_dapp_key {
+  let code = `module ${config.name}::${config.name}_dapp_key {
 \t/// Authorization token for the app.
 \tpublic struct DappKey has drop {}
 
@@ -19,10 +16,10 @@ export async function generateDappKey(
 \t}
 }
 `;
-	await formatAndWriteMove(
-		code,
-		`${srcPrefix}/contracts/${config.name}/sources/codegen/dapp_key.move`,
-		'formatAndWriteMove'
-	);
-	console.log('✅ DappKey Generation Complete\n');
+  await formatAndWriteMove(
+    code,
+    `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp_key.move`,
+    'formatAndWriteMove'
+  );
+  console.log('✅ DappKey Generation Complete\n');
 }

package/src/codegen/utils/renderMove/generateDefaultSchema.ts

@@ -3,19 +3,16 @@ import { formatAndWriteMove } from '../formatAndWrite';
 import { existsSync } from 'fs';
 import { capitalizeAndRemoveUnderscores } from './generateSchema';
 
-export async function generateDefaultSchema(
-	config: DubheConfig,
-	srcPrefix: string
-) {
-	await generateDappSchemaMetadata(config, srcPrefix);
-	await generateDappSchema(config, srcPrefix);
-	await generateDappSystem(config, srcPrefix);
+export async function generateDefaultSchema(config: DubheConfig, srcPrefix: string) {
+  await generateDappSchemaMetadata(config, srcPrefix);
+  await generateDappSchema(config, srcPrefix);
+  await generateDappSystem(config, srcPrefix);
 }
 
 async function generateDappSchemaMetadata(config: DubheConfig, srcPrefix: string) {
-	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/metadata.move`
-	if (!existsSync(path)) {
-		let code = `module ${config.name}::${config.name}_dapp_metadata {
+  const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/metadata.move`;
+  if (!existsSync(path)) {
+    let code = `module ${config.name}::${config.name}_dapp_metadata {
     use std::ascii::String;
 
     public struct DappMetadata has drop, copy, store {
@@ -112,19 +109,14 @@ async function generateDappSchemaMetadata(config: DubheConfig, srcPrefix: string
 
 }
 `;
-		await formatAndWriteMove(
-			code,
-			path,
-			'formatAndWriteMove'
-		);
-	}
+    await formatAndWriteMove(code, path, 'formatAndWriteMove');
+  }
 }
 
-
 async function generateDappSchema(config: DubheConfig, srcPrefix: string) {
-	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/schema.move`
-	if (!existsSync(path)) {
-		let code = `module ${config.name}::${config.name}_dapp_schema {
+  const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/schema.move`;
+  if (!existsSync(path)) {
+    let code = `module ${config.name}::${config.name}_dapp_schema {
   use ${config.name}::${config.name}_dapp_metadata::DappMetadata;
   use dubhe::storage_value;
   use dubhe::storage_value::StorageValue;
@@ -226,18 +218,14 @@ async function generateDappSchema(config: DubheConfig, srcPrefix: string) {
   }
 }
 `;
-		await formatAndWriteMove(
-			code,
-			path,
-			'formatAndWriteMove'
-		);
-	}
+    await formatAndWriteMove(code, path, 'formatAndWriteMove');
+  }
 }
 
 async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
-	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/system.move`
-	if (!existsSync(path)) {
-		let code = `module ${config.name}::${config.name}_dapp_system {
+  const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/system.move`;
+  if (!existsSync(path)) {
+    let code = `module ${config.name}::${config.name}_dapp_system {
   use std::ascii::String;
   use std::ascii;
   use dubhe::type_info;
@@ -325,10 +313,6 @@ async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
 
 
 `;
-		await formatAndWriteMove(
-			code,
-			path,
-			'formatAndWriteMove'
-		);
-	}
-}
+    await formatAndWriteMove(code, path, 'formatAndWriteMove');
+  }
+}

package/src/codegen/utils/renderMove/generateError.ts

@@ -1,42 +1,37 @@
-import {BaseType, ErrorData, SchemaType} from '../../types';
+import { BaseType, ErrorData, SchemaType } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 import {
-	getStructAttrsWithType,
-	getStructAttrs,
-	getStructTypes,
-	getStructAttrsQuery,
+  getStructAttrsWithType,
+  getStructAttrs,
+  getStructTypes,
+  getStructAttrsQuery
 } from './common';
 
 function convertToSnakeCase(input: string): string {
-	return input
-		.replace(/([A-Z])/g, '_$1')
-		.toLowerCase()
-		.replace(/^_/, '');
+  return input
+    .replace(/([A-Z])/g, '_$1')
+    .toLowerCase()
+    .replace(/^_/, '');
 }
 
-export async function generateSchemaError(
-	projectName: string,
-	errors: ErrorData,
-	path: string
-) {
-	console.log('\n📦 Starting Schema Error Generation...');
+export async function generateSchemaError(projectName: string, errors: ErrorData, path: string) {
+  console.log('\n📦 Starting Schema Error Generation...');
 
-	let	code = `module ${projectName}::${projectName}_errors {
-		${Object.entries(errors).map(([name, message]) => {
-			console.log(`  ├─ Generating Error: ${name}`);
-		console.log(`  │  └─ Message: ${message}`);
-		return `#[error]
-				const ${name}: vector<u8> = b"${message}";
-				public fun ${convertToSnakeCase(name)}_error(condition: bool) { assert!(condition, ${name})  }
-		`
-	}).join('\n')}		
-            }`
+  let code = `module ${projectName}::${projectName}_errors {
+		${Object.entries(errors)
+      .map(([name, message]) => {
+        console.log(`     └─ ${name}: ${message}`);
+        return `#[error]
+				const ${name.toUpperCase()}: vector<u8> = b"${message}";
+				public fun ${name}_error(condition: bool) { assert!(condition, ${name.toUpperCase()})  }
+		`;
+      })
+      .join('\n')}		
+            }`;
 
-
-	await formatAndWriteMove(
-		code,
-		`${path}/contracts/${projectName}/sources/codegen/errors.move`,
-		'formatAndWriteMove'
-	);
-	console.log('✅ Schema Error Generation Complete\n');
-}
+  await formatAndWriteMove(
+    code,
+    `${path}/contracts/${projectName}/sources/codegen/errors.move`,
+    'formatAndWriteMove'
+  );
+}

package/src/codegen/utils/renderMove/generateEvent.ts

@@ -1,110 +1,98 @@
-import {BaseType, EventData, SchemaData, SchemaType} from '../../types';
+import { BaseType, EventData, SchemaData, SchemaType } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 import {
-	getStructAttrsWithType,
-	getStructAttrs,
-	getStructTypes,
-	getStructAttrsQuery,
+  getStructAttrsWithType,
+  getStructAttrs,
+  getStructTypes,
+  getStructAttrsQuery
 } from './common';
 
-function capitalizeAndRemoveUnderscores(input: string): string {
-	return input
-		.split('_')
-		.map((word, index) => {
-			return index === 0
-				? word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
-				: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-		})
-		.join('');
+// account_not_found => AccountNotFound,
+function toPascalCase(str: string): string {
+  return str
+    .split('_')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
 }
 
 function convertToSnakeCase(input: string): string {
-	return input
-		.replace(/([A-Z])/g, '_$1')
-		.toLowerCase()
-		.replace(/^_/, '');
+  return input
+    .replace(/([A-Z])/g, '_$1')
+    .toLowerCase()
+    .replace(/^_/, '');
 }
 
-function generateImport(
-	projectName: string,
-	data: Record<string, SchemaData> | null,
-) {
-	if (data != null) {
-		const names = Object.keys(data);
-		return names
-			.map(name => {
-				return `use ${projectName}::${projectName}_${convertToSnakeCase(
-					name,
-				)}::${name};`;
-			})
-			.join('\n');
-	} else {
-		return '';
-	}
+function generateImport(projectName: string, data: Record<string, SchemaData> | null) {
+  if (data != null) {
+    const names = Object.keys(data);
+    return names
+      .map((name) => {
+        return `use ${projectName}::${projectName}_${convertToSnakeCase(name)}::${name};`;
+      })
+      .join('\n');
+  } else {
+    return '';
+  }
 }
 
 export async function generateSchemaEvent(
-	projectName: string,
-	data: Record<string, SchemaData> | null,
-	events: Record<string, EventData>,
-	path: string
+  projectName: string,
+  data: Record<string, SchemaData> | null,
+  events: Record<string, EventData>,
+  path: string
 ) {
-	console.log('\n📦 Starting Schema Event Generation...');
-	for (const key of Object.keys(events)) {
-				const name = key;
-				const fields = events[key];
-				console.log(
-					`     └─ Generating ${name} event: ${fields}`
-				);
+  console.log('\n📦 Starting Schema Event Generation...');
+  for (const key of Object.keys(events)) {
+    const name = key;
+    const fields = events[key];
+    console.log(`     └─ ${name} event: ${JSON.stringify(fields)}`);
 
-				let	code = `module ${projectName}::${projectName}_${convertToSnakeCase(name)}_event {
+    let code = `module ${projectName}::${projectName}_${name}_event {
 						use sui::event;
 						use std::ascii::String;
 						${generateImport(projectName, data)}
 
-                        public struct ${name}Event has copy, drop {
+                        public struct ${toPascalCase(name)}Event has copy, drop {
                                 ${getStructAttrsWithType(fields as Record<string, string>)}
                         }
 
-                        public fun new(${getStructAttrsWithType(fields as Record<string, string>)}): ${name}Event {
-                               ${name}Event {
+                        public fun new(${getStructAttrsWithType(fields as Record<string, string>)}): ${toPascalCase(name)}Event {
+                               ${toPascalCase(name)}Event {
                                    ${getStructAttrs(fields as Record<string, string>)}
                                }
                         }
                         }`;
-				await formatAndWriteMove(
-					code,
-					`${path}/contracts/${projectName}/sources/codegen/data/${convertToSnakeCase(
-						name
-					)}_event.move`,
-					'formatAndWriteMove'
-				);
-			}
+    await formatAndWriteMove(
+      code,
+      `${path}/contracts/${projectName}/sources/codegen/data/${name}_event.move`,
+      'formatAndWriteMove'
+    );
+  }
 
-	let	code = `module ${projectName}::${projectName}_events {
+  let code = `module ${projectName}::${projectName}_events {
 	 	use std::ascii::{String, string};
 	 	${generateImport(projectName, data)}
-		${Object.entries(events).map(([name, fields]) => {
-		return `
-use ${projectName}::${projectName}_${convertToSnakeCase(name)}_event::${name}Event;
-use ${projectName}::${projectName}_${convertToSnakeCase(name)}_event;
-			public fun ${convertToSnakeCase(name)}_event(${getStructAttrsWithType(fields as Record<string, string>)}) {
-			 dubhe::storage_event::emit_set_record<${name}Event, ${name}Event, ${name}Event>(
-				string(b"${convertToSnakeCase(name)}_event"),
+		${Object.entries(events)
+      .map(([name, fields]) => {
+        return `
+use ${projectName}::${projectName}_${name}_event::${toPascalCase(name)}Event;
+use ${projectName}::${projectName}_${name}_event;
+			public fun ${name}_event(${getStructAttrsWithType(fields as Record<string, string>)}) {
+			 dubhe::storage_event::emit_set_record<${toPascalCase(name)}Event, ${toPascalCase(name)}Event, ${toPascalCase(name)}Event>(
+				string(b"${name}_event"),
 				option::none(),
 			  	option::none(),
-			  option::some(${projectName}_${convertToSnakeCase(name)}_event::new(${getStructAttrs(fields as Record<string, string>)}))
+			  option::some(${projectName}_${name}_event::new(${getStructAttrs(fields as Record<string, string>)}))
 			  )
 			}
-		`
-	}).join('\n')}		
-            }`
+		`;
+      })
+      .join('\n')}		
+            }`;
 
-
-	await formatAndWriteMove(
-		code,
-		`${path}/contracts/${projectName}/sources/codegen/events.move`,
-		'formatAndWriteMove'
-	);
-	console.log('✅ Schema Event Generation Complete\n');
-}
+  await formatAndWriteMove(
+    code,
+    `${path}/contracts/${projectName}/sources/codegen/events.move`,
+    'formatAndWriteMove'
+  );
+}

package/src/codegen/utils/renderMove/generateInit.ts

@@ -3,16 +3,8 @@ import { formatAndWriteMove } from '../formatAndWrite';
 import { existsSync } from 'fs';
 import { capitalizeAndRemoveUnderscores } from './generateSchema';
 
-export async function generateInit(
-	config: DubheConfig,
-	srcPrefix: string
-) {
-	console.log('\n📝 Starting Init Generation...');
-	console.log(
-		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/tests/init.move`
-	);
-
-		let init_test_code = `module ${config.name}::${config.name}_init_test {
+export async function generateInit(config: DubheConfig, srcPrefix: string) {
+  let init_test_code = `module ${config.name}::${config.name}_init_test {
     use ${config.name}::${config.name}_dapp_schema::Dapp;
     use sui::clock;
     use sui::test_scenario;
@@ -30,13 +22,13 @@ export async function generateInit(
     }
 }
 `;
-		await formatAndWriteMove(
-			init_test_code,
-			`${srcPrefix}/contracts/${config.name}/sources/tests/init.move`,
-			'formatAndWriteMove'
-		);
+  await formatAndWriteMove(
+    init_test_code,
+    `${srcPrefix}/contracts/${config.name}/sources/tests/init.move`,
+    'formatAndWriteMove'
+  );
 
-	let init_code = `module ${config.name}::${config.name}_genesis {
+  let init_code = `module ${config.name}::${config.name}_genesis {
       use std::ascii::string;
 
   use sui::clock::Clock;
@@ -56,11 +48,9 @@ export async function generateInit(
   }
 }
 `;
-	await formatAndWriteMove(
-		init_code,
-		`${srcPrefix}/contracts/${config.name}/sources/codegen/genesis.move`,
-		'formatAndWriteMove'
-	);
-
-	console.log('✅ Init Generation Complete\n');
-}
+  await formatAndWriteMove(
+    init_code,
+    `${srcPrefix}/contracts/${config.name}/sources/codegen/genesis.move`,
+    'formatAndWriteMove'
+  );
+}