@0xobelisk/sui-common 1.1.6 → 1.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-common",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "Common low level logic shared between packages",
   "keywords": [
     "sui",
@@ -38,7 +38,6 @@
   },
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@mysten/sui": "^1.7.0",
     "chalk": "^5.0.1",
     "debug": "^4.3.4",
     "dotenv": "^16.0.3",
@@ -65,7 +64,10 @@
     "@types/yargs": "^17.0.10",
     "tsup": "^6.7.0",
     "tsx": "^3.12.6",
-    "vitest": "^2.1.3"
+    "vitest": "^2.1.3",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "3.3.3"
   },
   "scripts": {
     "build": "pnpm run build:js",
@@ -74,6 +76,10 @@
     "clean:js": "rimraf dist",
     "dev": "tsup --watch",
     "lint": "eslint . --ext .ts",
-    "test": "vitest"
+    "test": "vitest",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "type-check": "tsc --noEmit",
+    "validate": "pnpm format:check && pnpm type-check"
   }
 }

package/src/codegen/debug.ts

@@ -1,7 +1,7 @@
-import { debug as parentDebug } from "../debug";
+import { debug as parentDebug } from '../debug';
 
-export const debug = parentDebug.extend("codegen");
-export const error = parentDebug.extend("codegen");
+export const debug = parentDebug.extend('codegen');
+export const error = parentDebug.extend('codegen');
 
 // Pipe debug output to stdout instead of stderr
 debug.log = console.debug.bind(console);

package/src/codegen/index.ts

@@ -1,3 +1,3 @@
 // import "./modules.d";
-export * from "./utils";
-export * from "./types";
+export * from './utils';
+export * from './types';

package/src/codegen/modules.d.ts

@@ -1 +1 @@
-declare module "prettier-plugin-rust";
+declare module 'prettier-plugin-rust';

package/src/codegen/types/index.ts

@@ -16,14 +16,9 @@ export type BaseType =
   | 'vector<u128>'
   | string;
 
-export type StorageDataType =
-  | 'Struct'
-  | 'Enum';
+export type StorageDataType = 'Struct' | 'Enum';
 
-export type StorageMapType =
-  | 'Map'
-  | 'Bag'
-  | 'Table';
+export type StorageMapType = 'Map' | 'Bag' | 'Table';
 
 type Address = string;
 type Bool = boolean;
@@ -48,10 +43,30 @@ export type BaseValueType =
   | Vector<U64>
   | Vector<U128>;
 
-export type SchemaData = Record<string, string> | string[]
-export type SchemaType = string
-export type EventData = Record<string, string>
-export type ErrorData = Record<string, string>
+export type SchemaData = Record<string, string> | string[];
+export type SchemaType = string;
+export type EventData = Record<string, string>;
+export type ErrorData = Record<string, string>;
+
+type DataType = any;
+
+export function storage<T extends DataType>(value: T): SchemaType;
+export function storage<K extends DataType, V extends DataType>(key: K, value: V): SchemaType;
+export function storage<K1 extends DataType, K2 extends DataType, V extends DataType>(
+  key1: K1,
+  key2: K2,
+  value: V
+): SchemaType;
+export function storage(...args: DataType[]): SchemaType {
+  if (args.length === 1) {
+    return `StorageValue<${args[0]}>`;
+  } else if (args.length === 2) {
+    return `StorageMap<${args[0]}, ${args[1]}>`;
+  } else if (args.length === 3) {
+    return `StorageDoubleMap<${args[0]}, ${args[1]}, ${args[2]}>`;
+  }
+  throw new Error('Invalid number of arguments for storage()');
+}
 
 export type DubheConfig = {
   name: string;

package/src/codegen/utils/config.ts

@@ -1,33 +1,28 @@
-import { findUp } from "find-up";
-import path from "path";
-import esbuild from "esbuild";
-import { NotInsideProjectError } from "./errors";
-import { rmSync } from "fs";
-import { pathToFileURL } from "url";
-import os from "os";
+import { findUp } from 'find-up';
+import path from 'path';
+import esbuild from 'esbuild';
+import { NotInsideProjectError } from './errors';
+import { rmSync } from 'fs';
+import { pathToFileURL } from 'url';
+import os from 'os';
 
 // In order of preference files are checked
-const configFiles = [
-  "dubhe.config.js",
-  "dubhe.config.mjs",
-  "dubhe.config.ts",
-  "dubhe.config.mts",
-];
-const TEMP_CONFIG = "dubhe.config.example.mjs";
+const configFiles = ['dubhe.config.js', 'dubhe.config.mjs', 'dubhe.config.ts', 'dubhe.config.mts'];
+const TEMP_CONFIG = 'dubhe.config.example.mjs';
 
 export async function loadConfig(configPath?: string): Promise<unknown> {
   configPath = await resolveConfigPath(configPath);
   try {
     await esbuild.build({
       entryPoints: [configPath],
-      format: "esm",
+      format: 'esm',
       outfile: TEMP_CONFIG,
       // https://esbuild.github.io/getting-started/#bundling-for-node
-      platform: "node",
+      platform: 'node',
       // bundle local imports (otherwise it may error, js can't import ts)
       bundle: true,
       // avoid bundling external imports (it's unnecessary and esbuild can't handle all node features)
-      packages: "external",
+      packages: 'external'
     });
     configPath = await resolveConfigPath(TEMP_CONFIG, true);
     // Node.js caches dynamic imports, so without appending a cache breaking
@@ -39,10 +34,7 @@ export async function loadConfig(configPath?: string): Promise<unknown> {
   }
 }
 
-export async function resolveConfigPath(
-  configPath: string | undefined,
-  toFileURL?: boolean
-) {
+export async function resolveConfigPath(configPath: string | undefined, toFileURL?: boolean) {
   if (configPath === undefined) {
     configPath = await getUserConfigPath();
   } else {
@@ -54,9 +46,7 @@ export async function resolveConfigPath(
 
   // Add `file:///` for Windows support
   // (see https://github.com/nodejs/node/issues/31710)
-  return toFileURL && os.platform() === "win32"
-    ? pathToFileURL(configPath).href
-    : configPath;
+  return toFileURL && os.platform() === 'win32' ? pathToFileURL(configPath).href : configPath;
 }
 
 async function getUserConfigPath() {

package/src/codegen/utils/errors.ts

@@ -1,5 +1,4 @@
-
 export class NotInsideProjectError extends Error {
-name = "NotInsideProjectError";
-message = "You are not inside a Dubhe project";
-}
+  name = 'NotInsideProjectError';
+  message = 'You are not inside a Dubhe project';
+}

package/src/codegen/utils/format.ts

@@ -1,39 +1,36 @@
 import prettier from 'prettier';
 import prettierPluginMove from 'prettier-plugin-move-js';
 
-export async function formatMove(
-	content: string,
-	prettierConfigPath?: string
-): Promise<string> {
-	let config;
-	if (prettierConfigPath) {
-		config = await prettier.resolveConfig(prettierConfigPath);
-	}
-	try {
-		return prettier.format(content, {
-			plugins: [prettierPluginMove],
-			parser: 'move-parse',
-			printWidth: 120,
-			semi: true,
-			tabWidth: 2,
-			useTabs: false,
-			bracketSpacing: true,
-			...config,
-		});
-	} catch (error) {
-		let message;
-		if (error instanceof Error) {
-			message = error.message;
-		} else {
-			message = error;
-		}
-		console.log(`Error during output formatting: ${message}`);
-		return content;
-	}
+export async function formatMove(content: string, prettierConfigPath?: string): Promise<string> {
+  let config;
+  if (prettierConfigPath) {
+    config = await prettier.resolveConfig(prettierConfigPath);
+  }
+  try {
+    return prettier.format(content, {
+      plugins: [prettierPluginMove],
+      parser: 'move-parse',
+      printWidth: 120,
+      semi: true,
+      tabWidth: 2,
+      useTabs: false,
+      bracketSpacing: true,
+      ...config
+    });
+  } catch (error) {
+    let message;
+    if (error instanceof Error) {
+      message = error.message;
+    } else {
+      message = error;
+    }
+    console.log(`Error during output formatting: ${message}`);
+    return content;
+  }
 }
 
 export async function formatTypescript(content: string): Promise<string> {
-	return prettier.format(content, {
-		parser: 'typescript',
-	});
+  return prettier.format(content, {
+    parser: 'typescript'
+  });
 }

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,26 @@ 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) {
+        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,39 @@
-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(`  ├─ Generating Error: ${name}`);
+        console.log(`  │  └─ Message: ${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'
+  );
+  console.log('✅ Schema Error Generation Complete\n');
+}