@0xobelisk/sui-common 0.4.9

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

@@ -0,0 +1,40 @@
+import { ObeliskConfig } from "../../types";
+import { formatAndWriteMove } from "../formatAndWrite";
+import {
+  getRegisterSchema,
+  getUseSchema,
+  capitalizeFirstLetter,
+} from "./common";
+
+export function generateInit(config: ObeliskConfig, srcPrefix: string) {
+  let code = `module ${config.name}::init {
+    use std::ascii::string;
+    use sui::transfer;
+    use sui::tx_context::{Self, TxContext};
+    use ${config.name}::world;
+${getUseSchema(config.name, config.schemas).join("\n")}
+
+    fun init(ctx: &mut TxContext) {
+        let (_obelisk_world, admin_cap) = world::create(string(b"${capitalizeFirstLetter(
+          config.name
+        )}"), string(b"${capitalizeFirstLetter(config.description)}"),ctx);
+
+        // Add Schema
+${getRegisterSchema(config.schemas).join("\n")}
+
+        transfer::public_share_object(_obelisk_world);
+        transfer::public_transfer(admin_cap, tx_context::sender(ctx));
+    }
+
+    #[test_only]
+    public fun init_world_for_testing(ctx: &mut TxContext){
+        init(ctx)
+    }
+}
+`;
+  formatAndWriteMove(
+    code,
+    `${srcPrefix}/contracts/${config.name}/sources/codegen/init.move`,
+    "formatAndWriteMove"
+  );
+}

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

@@ -0,0 +1,219 @@
+import {
+  ObeliskConfig,
+  BaseValueType,
+  BaseType,
+  RenderSchemaOptions,
+  MoveType,
+} from "../../types";
+import { formatAndWriteMove } from "../formatAndWrite";
+import {
+  getFriendSystem,
+  renderKeyName,
+  renderSetFunc,
+  renderContainFunc,
+  renderRemoveFunc,
+  renderStruct,
+  renderNewStructFunc,
+  convertToCamelCase,
+  renderSetAttrsFunc,
+  renderRegisterFunc,
+  renderGetAllFunc,
+  renderGetAttrsFunc,
+  getStructAttrsWithType,
+  getStructAttrs,
+  renderRegisterFuncWithInit,
+  renderSingleSetFunc,
+  renderSingleSetAttrsFunc,
+  renderSingleGetAllFunc,
+  renderSingleGetAttrsFunc,
+} 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;
+}
+
+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"
+    );
+  }
+}
+
+function renderEphemeralSchema(option: RenderSchemaOptions): string {
+  return `module ${option.projectName}::${option.schemaName}_schema {
+    use std::option::none;
+    use ${option.projectName}::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}
+}`;
+}
+
+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 sui::tx_context::TxContext;
+    use ${option.projectName}::events;
+    use ${option.projectName}::world::{Self, World, AdminCap};
+    // Systems
+${getFriendSystem(option.projectName, option.systems)}
+
+\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)}
+}
+`;
+}
+
+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 sui::tx_context::TxContext;
+    use sui::table::{Self, Table};
+    use ${option.projectName}::events;
+    use ${option.projectName}::world::{Self, World, AdminCap};
+
+    // Systems
+${getFriendSystem(option.projectName, option.systems)}
+
+\t/// Entity does not exist
+\tconst EEntityDoesNotExist: u64 = 0;
+
+\tconst SCHEMA_ID: vector<u8> = b"${option.schemaName}";
+\tconst SCHEMA_TYPE: u8 = 0;
+
+${renderKeyName(option.valueType)}
+${renderStruct(option.structName, option.valueType)}
+${renderNewStructFunc(option.structName, option.valueType)}
+${renderRegisterFunc(option.structName)}
+
+${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)}
+}
+`;
+}

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

@@ -0,0 +1,37 @@
+import { ObeliskConfig } from "../../types";
+import { formatAndWriteMove } from "../formatAndWrite";
+import { existsSync } from "fs";
+
+export function generateScript(config: ObeliskConfig, srcPrefix: string) {
+    if (
+        !existsSync(
+            `${srcPrefix}/contracts/${config.name}/sources/script/deploy_hook.move`
+        )
+    ) {
+        let code = `module ${config.name}::deploy_hook {
+    use ${config.name}::world::{World, AdminCap, get_admin};
+    use sui::object;
+
+    /// Not the right admin for this world
+    const ENotAdmin: u64 = 0;
+
+    public entry fun run(world: &mut World, admin_cap: &AdminCap) {
+        assert!( get_admin(world) == object::id(admin_cap), ENotAdmin);
+        
+        // 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)
+    }
+}
+`;
+        formatAndWriteMove(
+            code,
+            `${srcPrefix}/contracts/${config.name}/sources/script/deploy_hook.move`,
+            "formatAndWriteMove"
+        );
+    }
+}

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

@@ -0,0 +1,53 @@
+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) => {
+    if (
+      !existsSync(
+        `${srcPrefix}/contracts/${config.name}/sources/system/${systemName}.move`
+      )
+    ) {
+      let code = `module ${config.name}::${systemName} {
+
+}
+`;
+      formatAndWriteMove(
+        code,
+        `${srcPrefix}/contracts/${config.name}/sources/system/${systemName}.move`,
+        "formatAndWriteMove"
+      );
+    }
+  });
+}

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

@@ -0,0 +1,21 @@
+import { ObeliskConfig } from "../../types";
+import { formatAndWriteMove } from "../formatAndWrite";
+
+export function generateToml(config: ObeliskConfig, srcPrefix: string) {
+  let code = `[package]
+name = "${config.name}"
+version = "0.0.1"
+
+[dependencies]
+Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "testnet-v1.8.0" }
+
+[addresses]
+sui =  "0x2"
+${config.name} = "0x0"
+`;
+  formatAndWriteMove(
+    code,
+    `${srcPrefix}/contracts/${config.name}/Move.toml`,
+    "formatAndWriteMove"
+  );
+}

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

@@ -0,0 +1,34 @@
+import { SchemaMapType, 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 {generateScript} from "./generateScript";
+
+export function worldgen(config: ObeliskConfig, srcPrefix?: string) {
+  let path = "";
+  if (srcPrefix === undefined) {
+    path = process.cwd();
+  } else {
+    path = srcPrefix;
+  }
+
+  if (existsSync(`${path}/contracts/${config.name}`)) {
+    deleteFolderRecursive(`${path}/contracts/${config.name}/sources/codegen`);
+  } else {
+    generateToml(config, path);
+    generateEntityKey(config, path);
+  }
+
+  generateSystem(config, path);
+  generateScript(config, path);
+
+  // generate codegen
+  generateSchema(config, path);
+  generateEps(config.name, path);
+  generateInit(config, path);
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./codegen";

package/src/modules.d.ts

@@ -0,0 +1,11 @@
+// adding .js to minimal would break clients down the line because it probably won't get a synthetic default import
+/* eslint-disable @typescript-eslint/no-explicit-any */
+declare module "protobufjs/minimal" {
+  export const configure: any;
+  export const util: any;
+  export const Reader: any;
+  export type Reader = any;
+  export const Writer: any;
+  export type Writer = any;
+}
+declare module "rollup-plugin-preserve-shebang";