@0xobelisk/sui-common 0.5.9 → 0.5.10

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

@@ -1,217 +1,204 @@
 import {
-  ObeliskConfig,
-  BaseValueType,
-  BaseType,
-  RenderSchemaOptions,
-  MoveType,
+    BaseType, SchemaType,
 } from "../../types";
 import { formatAndWriteMove } from "../formatAndWrite";
 import {
-  renderKeyName,
-  renderSetFunc,
-  renderContainFunc,
-  renderRemoveFunc,
-  renderStruct,
-  renderNewStructFunc,
-  convertToCamelCase,
-  renderSetAttrsFunc,
-  renderRegisterFunc,
-  renderGetAllFunc,
-  renderGetAttrsFunc,
   getStructAttrsWithType,
   getStructAttrs,
-  renderRegisterFuncWithInit,
-  renderSingleSetFunc,
-  renderSingleSetAttrsFunc,
-  renderSingleGetAllFunc,
-  renderSingleGetAttrsFunc,
+    getStructTypes, getStructAttrsQuery,
 } from "./common";
 
-export function getRenderSchemaOptions(config: ObeliskConfig) {
-  const options: RenderSchemaOptions[] = [];
-  for (const schemaName of Object.keys(config.schemas)) {
-    const schemaData = config.schemas[schemaName];
-    let valueType: MoveType | Record<string, MoveType>;
-    let realType: BaseType | Record<string, BaseType>;
-    let defaultValue: BaseValueType | Record<string, BaseValueType> | undefined;
-    let ephemeral = false;
-    let singleton = false;
-    let needImportString = false;
-    if (typeof schemaData === "string") {
-      realType = schemaData;
-
-      if (schemaData === "string") {
-        valueType = "String";
-        needImportString = true;
-      } else if (schemaData === "vector<string>") {
-        valueType = "vector<String>";
-        needImportString = true;
-      } else {
-        valueType = schemaData;
-      }
-    } else {
-      realType = schemaData.valueType;
-
-      if (typeof schemaData.valueType === "string") {
-        if (schemaData.valueType === "string") {
-          valueType = "String";
-          needImportString = true;
-        } else if (schemaData.valueType === "vector<string>") {
-          valueType = "vector<String>";
-          needImportString = true;
-        } else {
-          valueType = schemaData.valueType;
-        }
-      } else {
-        valueType = { ...schemaData.valueType };
-        for (const key in valueType) {
-          if (valueType.hasOwnProperty(key)) {
-            if (valueType[key] === "string") {
-              valueType[key] = "String";
-              needImportString = true;
-            } else if (valueType[key] === "vector<string>") {
-              valueType[key] = "vector<String>";
-              needImportString = true;
-
-              // needImport = "\tuse std::ascii::{String, string};";
-            }
-          }
-        }
-      }
-      defaultValue = schemaData.defaultValue;
-      ephemeral =
-        schemaData.ephemeral !== undefined ? schemaData.ephemeral : false;
-      singleton = schemaData.defaultValue !== undefined ? true : false;
-    }
-
-    options.push({
-      projectName: config.name,
-      systems: config.systems,
-      schemaName: schemaName,
-      structName: convertToCamelCase(schemaName),
-      ephemeral,
-      singleton,
-      valueType,
-      realType,
-      // structAttrs: [renderKeyName(valueType)],
-      // structTypes: [renderStruct(convertToCamelCase(schemaName), valueType)],
-      defaultValue,
-      needImportString,
-    });
-  }
-  return options;
+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('');
 }
 
-export function generateSchema(config: ObeliskConfig, srcPrefix: string) {
-  const options = getRenderSchemaOptions(config);
-  for (const option of options) {
-    let code: string;
-    if (option.ephemeral) {
-      code = renderEphemeralSchema(option);
-    } else if (option.defaultValue !== undefined) {
-      code = renderSingleSchema(option);
-    } else {
-      code = renderSchema(option);
-    }
-    formatAndWriteMove(
-      code,
-      `${srcPrefix}/contracts/${option.projectName}/sources/codegen/schemas/${option.schemaName}.move`,
-      "formatAndWriteMove"
-    );
-  }
+export function renderSetAttrsFunc(
+    schemaName: string,
+    fields: BaseType | Record<string, BaseType>
+): string {
+  return Object.entries(fields)
+          .map(
+              ([key, type]) =>
+                  `public(package) fun set_${key}(self: &mut ${schemaName}, ${key}: ${type}) {
+                        self.${key} = ${key};
+                    }`
+          ).join("\n");
 }
 
-function renderEphemeralSchema(option: RenderSchemaOptions): string {
-  return `module ${option.projectName}::${option.schemaName}_schema {
-	use std::option::none;
-	use obelisk::events;
-    
-    const SCHEMA_ID: vector<u8> = b"${option.schemaName}";
-    const SCHEMA_TYPE: u8 = 2;
-    
-${renderKeyName(option.valueType)}
-${renderStruct(option.structName, option.valueType, option.ephemeral)}  
-\tpublic fun emit_${option.schemaName}(${getStructAttrsWithType(
-    option.valueType,
-    " "
-  )}) {
-\t\tevents::emit_set(SCHEMA_ID, SCHEMA_TYPE, none(), ${option.structName} { ${getStructAttrs(
-    option.valueType,
-    " "
-  )} })
-\t}
-}`;
+export function renderSetFunc(
+    schemaName: string,
+    fields: Record<string, string>
+): string {
+  return `public(package) fun set(self: &mut ${schemaName}, ${getStructAttrsWithType(fields)}) {
+            ${Object.entries(fields)
+                  .map(([fieldName]) => `self.${fieldName} = ${fieldName};`)
+                  .join('\n')}
+            }`;
 }
 
-function renderSingleSchema(option: RenderSchemaOptions): string {
-  return `module ${option.projectName}::${option.schemaName}_schema {
-${
-  option.needImportString ? "\tuse std::ascii::{String,string};\n\t" : "\t"
-}use std::option::none;
-    use ${option.projectName}::app_key;
-    use ${option.projectName}::app_key::AppKey;
-    use obelisk::schema;
-    use obelisk::events;
-    use obelisk::world::{World, AdminCap};
-
-\tconst SCHEMA_ID: vector<u8> = b"${option.schemaName}";
-\tconst SCHEMA_TYPE: u8 = 1;
-
-${renderKeyName(option.valueType)}
-${renderStruct(option.structName, option.valueType)}
-${renderNewStructFunc(option.structName, option.valueType)}
-${renderRegisterFuncWithInit(
-  option.structName,
-  option.realType,
-  option.defaultValue!
-)}
-
-${renderSingleSetFunc(
-  option.structName,
-  option.valueType
-)}${renderSingleSetAttrsFunc(option.structName, option.valueType)}
-
-${renderSingleGetAllFunc(
-  option.structName,
-  option.valueType
-)}${renderSingleGetAttrsFunc(option.structName, option.valueType)}
-}
-`;
+export function renderGetAllFunc(
+    schemaName: string,
+    fields: BaseType | Record<string, BaseType>
+): string {
+  return `public fun get(self: &${schemaName}): ${getStructTypes(fields)} {
+        (${getStructAttrsQuery(fields, "")})
+    }`;
 }
 
-function renderSchema(option: RenderSchemaOptions) {
-  return `module ${option.projectName}::${option.schemaName}_schema {
-${
-  option.needImportString ? "\tuse std::ascii::String;\n\t" : "\t"
-}use std::option::some;
-    use ${option.projectName}::app_key;
-    use ${option.projectName}::app_key::AppKey;
-    use sui::table::{Self, Table};
-    use obelisk::schema;
-    use obelisk::events;
-    use obelisk::world::{World, AdminCap};
-
-\t/// Entity does not exist
-\tconst EEntityDoesNotExist: u64 = 0;
-
-\tconst SCHEMA_ID: vector<u8> = b"${option.schemaName}";
-\tconst SCHEMA_TYPE: u8 = 0;
+export function renderGetAttrsFunc(
+    schemaName: string,
+    fields: BaseType | Record<string, BaseType>
+): string {
+  return Object.entries(fields)
+          .map(
+              ([key, type]) => `public fun get_${key}(self: &${schemaName}): ${type} {
+                                    self.${key}
+                                }`
+          ).join("\n");
+}
 
-${renderKeyName(option.valueType)}
-${renderStruct(option.structName, option.valueType)}
-${renderNewStructFunc(option.structName, option.valueType)}
-${renderRegisterFunc(option.structName)}
+function convertToSnakeCase(input: string): string {
+    return input
+        .replace(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .replace(/^_/, '');
+}
 
-${renderSetFunc(option.structName, option.valueType)}${renderSetAttrsFunc(
-    option.structName,
-    option.valueType
-  )}
-${renderGetAllFunc(option.structName, option.valueType)}${renderGetAttrsFunc(
-    option.structName,
-    option.valueType
-  )}
-${renderRemoveFunc(option.structName)}
-${renderContainFunc(option.structName)}
+export async function generateSchemaData(projectName: string, schemas: Record<string, SchemaType>, path: string) {
+    for (const schemaName in schemas) {
+        const schema = schemas[schemaName];
+        if (schema.data) {
+            for (const item of schema.data) {
+                let code = "";
+
+                const enumNames = schema.data
+                    .filter(item => Array.isArray(item.fields))
+                    .map(item => item.name);
+
+                if (Array.isArray(item.fields)) {
+                    code = `module ${projectName}::${schemaName}_${convertToSnakeCase(item.name)} {
+                        public enum ${item.name} has copy, drop , store {
+                                ${item.fields}
+                        }
+                        
+                        ${item.fields.map((field: string) => {
+                            return `public fun new_${convertToSnakeCase(field)}(): ${item.name} {
+                                ${item.name}::${field}
+                            }`
+                        }).join("")
+                    }`
+                } else {
+                    code = `module ${projectName}::${schemaName}_${convertToSnakeCase(item.name)} {
+                            use std::ascii::String;
+                            ${enumNames.map(name => `use ${projectName}::${schemaName}_${convertToSnakeCase(name)}::${name};`).join('\n')}
+
+                           public struct ${item.name} has copy, drop , store {
+                                ${getStructAttrsWithType(item.fields)}
+                           }
+                        
+                           public fun new(${getStructAttrsWithType(item.fields)}): ${item.name} {
+                               ${item.name} {
+                                   ${getStructAttrs(item.fields)}
+                               }
+                            }
+                        
+                           ${renderGetAllFunc(item.name, item.fields)}
+                           ${renderGetAttrsFunc(item.name, item.fields)}
+                           ${renderSetAttrsFunc(item.name, item.fields)}
+                           ${renderSetFunc(item.name, item.fields)}
+                        }`;
+                }
+
+                await formatAndWriteMove(
+                    code,
+                    `${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}_${convertToSnakeCase(item.name)}.move`,
+                    "formatAndWriteMove"
+                );
+            }
+        }
+    }
 }
-`;
+
+function generateImport(projectName: string, schemaName: string, schema: SchemaType) {
+    if (schema.data) {
+        return schema.data.map(item => {
+            return `use ${projectName}::${schemaName}_${convertToSnakeCase(item.name)}::${item.name};`
+        }).join('\n');
+    } else {
+        return ""
+    }
 }
+
+export async function generateSchemaStructure(projectName: string, schemas: Record<string, SchemaType>, path: string) {
+    for (const schemaName in schemas) {
+        console.log(`Schema: ${schemaName}`);
+        const schema = schemas[schemaName];
+        const schemaMoudle = `module ${projectName}::${schemaName}_schema {
+                    use std::ascii::String;
+                    use std::type_name;
+                    use sui::transfer::{public_share_object};
+                    use obelisk::dapps_system;
+                    use obelisk::dapps_schema::Dapps;
+                    use obelisk::storage_value::{Self, StorageValue};
+                    use obelisk::storage_map::{Self, StorageMap};
+                    use obelisk::storage_double_map::{Self, StorageDoubleMap};
+                    use ${projectName}::dapp_key::DappKey;
+                    ${generateImport(projectName, schemaName, schema)}
+
+                    public struct ${capitalizeAndRemoveUnderscores(schemaName)} has key, store {
+                        id: UID,
+                        ${getStructAttrsWithType(schema.structure)}
+                    } 
+                    
+                     ${Object.entries(schema.structure).map(([key, value]) => {
+                        return `public fun borrow_${key}(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : &${value} {
+                        &self.${key}
+                    }
+                    
+                    public(package) fun borrow_mut_${key}(self: &mut ${capitalizeAndRemoveUnderscores(schemaName)}): &mut ${value} {
+                        &mut self.${key}
+                    }
+                    `
+                    }).join('')} 
+                    
+                    public entry fun register(dapps: &mut Dapps, ctx: &mut TxContext) {
+                      let package_id = dapps_system::current_package_id<DappKey>();
+                      assert!(dapps.borrow_metadata().contains_key(package_id), 0);
+                      assert!(dapps.borrow_admin().get(package_id) == ctx.sender(), 0);
+                      let schema = type_name::get<${capitalizeAndRemoveUnderscores(schemaName)}>().into_string();
+                      assert!(!dapps.borrow_schemas().get(package_id).contains(&schema), 0);
+                
+                        public_share_object(${capitalizeAndRemoveUnderscores(schemaName)} {
+                          id: object::new(ctx),
+                          ${Object.entries(schema.structure).map(([key, value]) => {
+                                let storage_type = ""
+                                if (value.includes("StorageValue")) {
+                                    storage_type = `storage_value::new()`
+                                } else if (value.includes("StorageMap")) {
+                                    storage_type = `storage_map::new()`
+                                } else if (value.includes("StorageDoubleMap")) {
+                                    storage_type = `storage_double_map::new()`
+                                }
+                                return `${key}: ${storage_type},`
+                            }).join(' ')
+                            }
+                        });
+                
+                      dapps_system::add_schema<${capitalizeAndRemoveUnderscores(schemaName)}>(dapps, package_id, ctx);
+                    }
+               
+           }`;
+        await formatAndWriteMove(
+            schemaMoudle,
+            `${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}.move`,
+            "formatAndWriteMove"
+        );
+    }
+}

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

@@ -2,32 +2,63 @@ import { ObeliskConfig } from "../../types";
 import { formatAndWriteMove } from "../formatAndWrite";
 import { existsSync } from "fs";
 
-export function generateDeployHook(config: ObeliskConfig, srcPrefix: string) {
+export async function generateDeployHook(config: ObeliskConfig, srcPrefix: string) {
     if (
         !existsSync(
             `${srcPrefix}/contracts/${config.name}/sources/script/deploy_hook.move`
         )
     ) {
         let code = `module ${config.name}::deploy_hook {
-    use obelisk::world::{World, AdminCap};
-
-    /// Not the right admin for this world
-    const ENotAdmin: u64 = 0;
+    use obelisk::dapps_schema::Dapps;
+    use obelisk::dapps_system;
+    use ${config.name}::dapp_key::DappKey;
+    use std::ascii;
+    use sui::clock::Clock;
+    #[test_only]
+      use obelisk::dapps_schema;
+      #[test_only]
+      use sui::clock;
+      #[test_only]
+      use sui::test_scenario;
+      #[test_only]
+      use sui::test_scenario::Scenario;
 
-    public entry fun run(world: &mut World, admin_cap: &AdminCap) {
-         assert!(world.admin() == object::id(admin_cap), ENotAdmin);
+    public entry fun run(dapps: &mut Dapps, clock: &Clock, ctx: &mut TxContext) {
+        // Register the dapp to obelisk.
+        dapps_system::register<DappKey>(
+            dapps,
+            ascii::string(b"${config.name}"),
+            ascii::string(b"${config.description}"),
+            clock,
+            ctx
+        );
+        ${Object.keys(config.schemas).map(schemaName => {
+            return `${config.name}::${schemaName}_schema::register(dapps, ctx);`
+        }).join("\n")}
         
         // Logic that needs to be automated once the contract is deployed
-        
+
     }
 
     #[test_only]
-    public fun deploy_hook_for_testing(world: &mut World, admin_cap: &AdminCap){
-        run(world, admin_cap)
-    }
+    public fun deploy_hook_for_testing(): (Scenario, Dapps) {
+      let mut scenario = test_scenario::begin(@0xA);
+      {
+          let ctx = test_scenario::ctx(&mut scenario);
+          dapps_schema::init_dapps_for_testing(ctx);
+          test_scenario::next_tx(&mut scenario,@0xA);
+      };
+      let mut dapps = test_scenario::take_shared<Dapps>(&scenario);
+      let ctx = test_scenario::ctx(&mut scenario);
+      let clock = clock::create_for_testing(ctx);
+      run(&mut dapps, &clock, ctx);
+      clock::destroy_for_testing(clock);
+      test_scenario::next_tx(&mut scenario,@0xA);
+      (scenario, dapps)
+  }
 }
 `;
-        formatAndWriteMove(
+        await formatAndWriteMove(
             code,
             `${srcPrefix}/contracts/${config.name}/sources/script/deploy_hook.move`,
             "formatAndWriteMove"

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

@@ -2,52 +2,22 @@ import { ObeliskConfig } from "../../types";
 import { formatAndWriteMove } from "../formatAndWrite";
 import { existsSync } from "fs";
 
-export function generateSystem2(config: ObeliskConfig, srcPrefix: string) {
-  config.systems.map((systemName) => {
-    let code = `module ${config.name}::${systemName} {
-
-}
-`;
-    formatAndWriteMove(
-      code,
-      `${srcPrefix}/contracts/${config.name}/sources/system/${systemName}.move`,
-      "formatAndWriteMove"
-    );
-  });
-}
-
-export function generateNewSystem1(
-  name: string,
-  systemName: string,
-  srcPrefix: string
-) {
-  let code = `module ${name}::${systemName} {
-
-}
-`;
-  formatAndWriteMove(
-    code,
-    `${srcPrefix}/contracts/${name}/sources/system/${systemName}.move`,
-    "formatAndWriteMove"
-  );
-}
-
-export function generateSystem(config: ObeliskConfig, srcPrefix: string) {
-  config.systems.map((systemName) => {
+export async function generateSystem(config: ObeliskConfig, srcPrefix: string) {
+  config.systems.map(async (systemName) => {
     if (
       !existsSync(
         `${srcPrefix}/contracts/${config.name}/sources/system/${systemName}.move`
       )
     ) {
-      let code = `module ${config.name}::${systemName} {
+        let code = `module ${config.name}::${systemName}_system {
 
 }
 `;
-      formatAndWriteMove(
-        code,
-        `${srcPrefix}/contracts/${config.name}/sources/system/${systemName}.move`,
-        "formatAndWriteMove"
-      );
+            await formatAndWriteMove(
+                code,
+                `${srcPrefix}/contracts/${config.name}/sources/system/${systemName}.move`,
+                "formatAndWriteMove"
+            );
     }
   });
 }

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

@@ -1,7 +1,7 @@
 import { ObeliskConfig } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 
-export function generateToml(config: ObeliskConfig, srcPrefix: string) {
+export async function generateToml(config: ObeliskConfig, srcPrefix: string) {
 	let code = `[package]
 name = "${config.name}"
 version = "0.0.1"
@@ -9,15 +9,14 @@ edition = "2024.beta"
 
 [dependencies]
 Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.31.1" }
-# Obelisk = { git = "https://github.com/0xobelisk/obelisk-engine.git", subdir = "packages/obelisk-framework", rev = "mainnet-v1.31.1" }
-Obelisk = { local = "/Volumes/project/obelisk-engine/packages/obelisk-framework" }
+Obelisk = { git = "https://github.com/0xobelisk/obelisk-engine.git", subdir = "packages/obelisk-framework", rev = "main" }
 
 [addresses]
 sui =  "0x2"
-obelisk =  "0x6c93abd6e076235f51c6dd95b4adf9b0d4f5b6f6766c6a7b6653101a78a04d8c"
+obelisk =  "0x3dc2d6239eed38c9798444afbf4bada0998ec98edc365713864405fe64203256"
 ${config.name} = "0x0"
 `;
-	formatAndWriteMove(
+	await formatAndWriteMove(
 		code,
 		`${srcPrefix}/contracts/${config.name}/Move.toml`,
 		'formatAndWriteMove'

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

@@ -1,16 +1,13 @@
-import { SchemaMapType, ObeliskConfig } from "../../types";
+import { SchemaType, ObeliskConfig } from "../../types";
 import { rmdirSync, existsSync } from "fs";
 import { deleteFolderRecursive } from "./common";
 import { generateSystem } from "./generateSystem";
 import { generateToml } from "./generateToml";
-import { generateEntityKey } from "./generateEntityKey";
-import { generateInit } from "./generateInit";
-import { generateEps } from "./generateEps";
-import { generateSchema } from "./generateSchema";
+import {generateSchemaData, generateSchemaStructure} from "./generateSchema";
 import {generateDeployHook, generateMigrate} from "./generateScript";
-import {generateAppKey} from "./generateAppKey";
+import {generateDappKey} from "./generateDappKey";
 
-export function worldgen(config: ObeliskConfig, srcPrefix?: string) {
+export async function worldgen(config: ObeliskConfig, srcPrefix?: string) {
   let path = "";
   if (srcPrefix === undefined) {
     path = process.cwd();
@@ -20,17 +17,18 @@ export function worldgen(config: ObeliskConfig, srcPrefix?: string) {
 
   if (existsSync(`${path}/contracts/${config.name}`)) {
     deleteFolderRecursive(`${path}/contracts/${config.name}/sources/codegen`);
-  } else {
-    generateToml(config, path);
-    generateEntityKey(config, path);
   }
 
-  generateSystem(config, path);
-  generateDeployHook(config, path);
-  generateMigrate(config, path);
+  if (!existsSync(`${path}/contracts/${config.name}/Move.toml`)) {
+    await generateToml(config, path);
+  }
+
+  if (!existsSync(`${path}/contracts/${config.name}/sources/script/deploy_hook.move`)) {
+    await generateDeployHook(config, path);
+  }
 
-  // generate codegen
-  generateSchema(config, path);
-  generateInit(config, path);
-  generateAppKey(config, path);
+  await generateSystem(config, path);
+  await generateSchemaData(config.name, config.schemas, path);
+  await generateSchemaStructure(config.name, config.schemas, path);
+  await generateDappKey(config, path);
 }

package/src/debug.ts

@@ -0,0 +1,10 @@
+import createDebug from "debug";
+
+export const debug = createDebug("obelisk:common");
+export const error = createDebug("obelisk:common");
+
+// Pipe debug output to stdout instead of stderr
+debug.log = console.debug.bind(console);
+
+// Pipe error output to stderr
+error.log = console.error.bind(console);

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

@@ -1,24 +0,0 @@
-import { ObeliskConfig } from "../../types";
-import { formatAndWriteMove } from "../formatAndWrite";
-import {
-  getRegisterSchema,
-  getUseSchema,
-  capitalizeFirstLetter,
-} from "./common";
-
-export function generateAppKey(config: ObeliskConfig, srcPrefix: string) {
-  let code = `module ${config.name}::app_key {
-  /// Authorization token for the app.
-    public struct AppKey has drop {}
-
-    public(package) fun new(): AppKey {
-        AppKey {  }
-    }
-}
-`;
-  formatAndWriteMove(
-    code,
-    `${srcPrefix}/contracts/${config.name}/sources/codegen/app_key.move`,
-    "formatAndWriteMove"
-  );
-}