@0xobelisk/sui-common 0.4.9

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

@@ -0,0 +1,473 @@
+import { BaseType, SchemaMapType, BaseValueType, 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);
+  }
+}
+
+export function capitalizeFirstLetter(input: string): string {
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
+
+/**
+ * Convert snake_case to camelCase
+ * @param str
+ */
+export function convertToCamelCase(str: string): string {
+  str = str.charAt(0).toUpperCase() + str.slice(1);
+  let result = str.replace(/(_\w)/g, (match) => match[1].toUpperCase());
+  return result + "Data";
+}
+
+/**
+ *
+ * @param name
+ * @param values
+ * @return [use name::name_schema, use name::info_schema]
+ */
+export function getUseSchema(
+  name: string,
+  values: Record<string, SchemaMapType>
+): string[] {
+  let schema: string[] = [];
+  Object.entries(values).forEach(([key, value]) => {
+    if (typeof value === "object" && value.ephemeral) {
+    } else {
+      schema.push(`\tuse ${name}::${key}_schema;`);
+    }
+  });
+  return schema;
+}
+
+/**
+ * @param values
+ * @return [ name_schema::register(&mut _obelisk_world, ctx) ,info_schema::register(&mut _obelisk_world, ctx) ]
+ */
+export function getRegisterSchema(
+  values: Record<string, SchemaMapType>
+): string[] {
+  let registers: string[] = [];
+  Object.entries(values).forEach(([key, value]) => {
+    if (typeof value === "object" && value.ephemeral) {
+    } else {
+      registers.push(`\t\t${key}_schema::register(&mut _obelisk_world, &admin_cap, ctx);`);
+    }
+  });
+  return registers;
+}
+
+/**
+ *
+ * @param name
+ * @param values
+ * @return [ friend name::name_system, friend name::info_system ]
+ */
+export function getFriendSystem(name: string, values: string[]): string {
+  return values.map((key) => `\tfriend ${name}::${key};`).join("\n") + `\n\tfriend ${name}::deploy_hook;`;
+}
+
+/**
+ *
+ * @param values
+ * @param prefixArgs
+ * @return [ name, age, birth_time ]
+ */
+export function getStructAttrs(
+  values: Record<string, string> | string,
+  prefixArgs: string
+): string[] {
+  return typeof values === "string"
+    ? [`${prefixArgs}value`]
+    : Object.entries(values).map(([key, _]) => `${prefixArgs}${key}`);
+}
+
+function isAddress(str: string): boolean {
+  const regex = /^0x[a-fA-F0-9]+$/;
+  return regex.test(str);
+}
+
+export function getStructInitValue(
+  keys: BaseType | Record<string, BaseType>,
+  values: BaseValueType | Record<string, BaseValueType>
+) {
+  if (
+    typeof values === "string" ||
+    typeof values === "boolean" ||
+    typeof values === "number"
+  ) {
+    if (keys === "string") {
+      return [`string(b"${values}")`];
+    }
+    if (typeof values === "string") {
+      if (isAddress(values)) {
+        return [`@${values}`];
+      }
+    }
+    return [`${values}`];
+  } else if (Array.isArray(values)) {
+    // Check the array element type
+    if (values.length > 0) {
+      if (
+        typeof values[0] === "string" ||
+        typeof values[0] === "boolean" ||
+        typeof values[0] === "number"
+      ) {
+        if (keys === "vector<string>") {
+          return [`vector[${values.map((item) => `string(b"${item}")`)}]`];
+        }
+
+        if (typeof values[0] === "string") {
+          if (isAddress(values[0])) {
+            return [`vector[${values.map((item) => `@${item}`)}]`];
+          }
+        }
+        return [`vector[${values.map((item) => `${item}`)}]`];
+      } else if (typeof values === "object") {
+        let res = `vector[${values.map((item: any) => {
+          return `vector[${item.map((data: any) => {
+            return `${data}`;
+          })}]`;
+        })}]`;
+
+        return [res];
+      }
+    }
+  } else if (typeof values === "object") {
+    // It's an object, handle accordingly
+    let res = Object.entries(values).map(([key, value]) => {
+      if (
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        typeof value === "number"
+      ) {
+        if (typeof keys === "string") {
+          if (keys === "string") {
+            return `string(b"${value}")`;
+          }
+        } else {
+          if (keys[key] === "string") {
+            return `string(b"${value}")`;
+          }
+        }
+
+        if (typeof value === "string") {
+          if (isAddress(value)) {
+            return `@${value}`;
+          }
+        }
+        return `${value}`;
+      } else if (Array.isArray(value)) {
+        // Check the array element type
+        if (value.length > 0) {
+          if (
+            typeof value[0] === "string" ||
+            typeof value[0] === "boolean" ||
+            typeof value[0] === "number"
+          ) {
+            if (typeof keys === "string") {
+              if (keys === "vector<string>") {
+                return `vector[${value.map((item) => `string(b"${item}")`)}]`;
+              }
+            } else {
+              if (keys[key] === "vector<string>") {
+                return `vector[${value.map((item) => `string(b"${item}")`)}]`;
+              }
+            }
+
+            if (typeof value[0] === "string") {
+              if (isAddress(value[0])) {
+                return `vector[${value.map((item) => `@${item}`)}]`;
+              }
+            }
+            return `vector[${value.map((item) => `${item}`)}]`;
+          } else if (typeof value === "object") {
+            let res = `vector[${value.map((item: any) => {
+              return `vector[${item.map((data: any) => {
+                return `${data}`;
+              })}]`;
+            })}]`;
+
+            return res;
+          }
+        }
+      }
+    });
+    return res;
+  }
+  // Handle other cases or return an empty array if type not recognized
+  return [];
+}
+
+/**
+ *
+ * @param values
+ * @return ( bool , u64 , u64)
+ */
+// export function getStructTypes(values: SchemaMapType): string {
+export function getStructTypes(
+  values: MoveType | Record<string, MoveType>
+): string {
+  return typeof values === "string"
+    ? values
+    : `(${Object.entries(values).map(([_, type]) => `${type}`)})`;
+}
+
+/**
+ *
+ * @param values
+ * @return Attributes and types of the struct. [ name: string, age: u64 ]
+ */
+export function getStructAttrsWithType(
+  values: Record<string, string> | string,
+  prefix: string
+): string[] {
+  return typeof values === "string"
+    ? [`${prefix}value: ${values}`]
+    : Object.entries(values).map(([key, type]) => `${prefix}${key}: ${type}`);
+}
+
+/**
+ * @param values
+ * @param prefixArgs
+ * @return [ data.name, data.age ]
+ */
+export function getStructAttrsQuery(
+  values: MoveType | Record<string, MoveType>,
+  prefixArgs: string
+): string[] {
+  return typeof values === "string"
+    ? [`${prefixArgs}_obelisk_data.value`]
+    : Object.entries(values).map(
+        ([key, _]) => `${prefixArgs}_obelisk_data.${key}`
+      );
+}
+
+export function renderKeyName(values: Record<string, string> | string): string {
+  return `\t${getStructAttrs(values, "// ").join("\n\t")}`;
+}
+
+export function renderStruct(
+  structName: string,
+  values: Record<string, string> | string,
+  isEphemeral: boolean = false
+): string {
+  return `\tstruct ${structName} has copy, drop ${
+    isEphemeral ? "" : ", store"
+  } {
+${getStructAttrsWithType(values, "\t\t").join(",\n")}
+\t}\n`;
+}
+
+export function renderNewStructFunc(
+  structName: string,
+  values: Record<string, string> | string
+): string {
+  return `\tpublic fun new(${getStructAttrsWithType(values, "").join(
+    ", "
+  )}): ${structName} {
+\t\t${structName} {
+${getStructAttrs(values, "\t\t\t").join(", \n")}
+\t\t}
+\t}\n`;
+}
+
+export function renderRegisterFunc(structName: string): string {
+  return `\tpublic fun register(_obelisk_world: &mut World, admin_cap: &AdminCap, ctx: &mut TxContext) {
+\t\tworld::add_schema<Table<address,${structName}>>(_obelisk_world, SCHEMA_ID, table::new<address, ${structName}>(ctx), admin_cap);
+\t}`;
+}
+
+export function renderSetFunc(
+  structName: string,
+  values: Record<string, string> | string
+): string {
+  return `\tpublic(friend) fun set(_obelisk_world: &mut World, _obelisk_entity_key: address, ${getStructAttrsWithType(
+    values,
+    " "
+  )}) {
+\t\tlet _obelisk_schema = world::get_mut_schema<Table<address,${structName}>>(_obelisk_world, SCHEMA_ID);
+\t\tlet _obelisk_data = new(${getStructAttrs(values, " ")});
+\t\tif(table::contains<address, ${structName}>(_obelisk_schema, _obelisk_entity_key)) {
+\t\t\t*table::borrow_mut<address, ${structName}>(_obelisk_schema, _obelisk_entity_key) = _obelisk_data;
+\t\t} else {
+\t\t\ttable::add(_obelisk_schema, _obelisk_entity_key, _obelisk_data);
+\t\t};
+\t\tevents::emit_set(SCHEMA_ID, SCHEMA_TYPE, some(_obelisk_entity_key), _obelisk_data)
+\t}
+`;
+}
+
+export function renderRemoveFunc(structName: string): string {
+  return `\tpublic(friend) fun remove(_obelisk_world: &mut World, _obelisk_entity_key: address) {
+\t\tlet _obelisk_schema = world::get_mut_schema<Table<address,${structName}>>(_obelisk_world, SCHEMA_ID);
+\t\tassert!(table::contains<address, ${structName}>(_obelisk_schema, _obelisk_entity_key), EEntityDoesNotExist);
+\t\ttable::remove(_obelisk_schema, _obelisk_entity_key);
+\t\tevents::emit_remove(SCHEMA_ID, _obelisk_entity_key)
+\t}
+`;
+}
+
+export function renderSetAttrsFunc(
+  structName: string,
+  struct: MoveType | Record<string, MoveType>
+): string {
+  return typeof struct === "string"
+    ? ""
+    : "\n" +
+        Object.entries(struct)
+          .map(
+            ([key, type]) =>
+              `\tpublic(friend) fun set_${key}(_obelisk_world: &mut World, _obelisk_entity_key: address, ${key}: ${type}) {
+\t\tlet _obelisk_schema = world::get_mut_schema<Table<address,${structName}>>(_obelisk_world, SCHEMA_ID);
+\t\tassert!(table::contains<address, ${structName}>(_obelisk_schema, _obelisk_entity_key), EEntityDoesNotExist);
+\t\tlet _obelisk_data = table::borrow_mut<address, ${structName}>(_obelisk_schema, _obelisk_entity_key);
+\t\t_obelisk_data.${key} = ${key};
+\t\tevents::emit_set(SCHEMA_ID, SCHEMA_TYPE, some(_obelisk_entity_key), *_obelisk_data)
+\t}
+`
+          )
+          .join("\n");
+}
+
+export function renderGetAllFunc(
+  structName: string,
+  struct: MoveType | Record<string, MoveType>
+): string {
+  return `\tpublic fun get(_obelisk_world: &World, _obelisk_entity_key: address): ${getStructTypes(
+    struct
+  )} {
+\t\tlet _obelisk_schema = world::get_schema<Table<address,${structName}>>(_obelisk_world, SCHEMA_ID);
+\t\tassert!(table::contains<address, ${structName}>(_obelisk_schema, _obelisk_entity_key), EEntityDoesNotExist);
+\t\tlet _obelisk_data = table::borrow<address, ${structName}>(_obelisk_schema, _obelisk_entity_key);
+\t\t(
+${getStructAttrsQuery(struct, "\t\t\t").join(",\n")}
+\t\t)
+\t}
+`;
+}
+
+export function renderGetAttrsFunc(
+  structName: string,
+  struct: MoveType | Record<string, MoveType>
+): string {
+  return typeof struct === "string"
+    ? ""
+    : "\n" +
+        Object.entries(struct)
+          .map(
+            ([
+              key,
+              type,
+            ]) => `\tpublic fun get_${key}(_obelisk_world: &World, _obelisk_entity_key: address): ${type} {
+\t\tlet _obelisk_schema = world::get_schema<Table<address,${structName}>>(_obelisk_world, SCHEMA_ID);
+\t\tassert!(table::contains<address, ${structName}>(_obelisk_schema, _obelisk_entity_key), EEntityDoesNotExist);
+\t\tlet _obelisk_data = table::borrow<address, ${structName}>(_obelisk_schema, _obelisk_entity_key);
+\t\t_obelisk_data.${key}
+\t}
+`
+          )
+          .join("\n");
+}
+
+export function renderContainFunc(structName: string): string {
+  return `\tpublic fun contains(_obelisk_world: &World, _obelisk_entity_key: address): bool {
+\t\tlet _obelisk_schema = world::get_schema<Table<address,${structName}>>(_obelisk_world, SCHEMA_ID);
+\t\ttable::contains<address, ${structName}>(_obelisk_schema, _obelisk_entity_key)
+\t}`;
+}
+
+export function renderRegisterFuncWithInit(
+  structName: string,
+  valueType: BaseType | Record<string, BaseType>,
+  defaultValue: BaseValueType | Record<string, BaseValueType>
+): string {
+  return `\tpublic fun register(_obelisk_world: &mut World, admin_cap: &AdminCap, _ctx: &mut TxContext) {
+\t\tlet _obelisk_schema = new(${getStructInitValue(valueType, defaultValue)});
+\t\tworld::add_schema<${structName}>(_obelisk_world, SCHEMA_ID, _obelisk_schema, admin_cap);
+\t\tevents::emit_set(SCHEMA_ID, SCHEMA_TYPE, none(), _obelisk_schema);
+\t}`;
+}
+
+export function renderSingleSetFunc(
+  structName: string,
+  values: Record<string, string> | string
+): string {
+  return `\tpublic(friend) fun set(_obelisk_world: &mut World, ${getStructAttrsWithType(
+    values,
+    " "
+  )}) {
+\t\tlet _obelisk_schema = world::get_mut_schema<${structName}>(_obelisk_world, SCHEMA_ID);
+${
+  typeof values === "string"
+    ? `\t\t_obelisk_schema.value = value;`
+    : Object.entries(values)
+        .map(([key, _]) => `\t\t_obelisk_schema.${key} = ${key};`)
+        .join("\n")
+}
+\t}`;
+}
+
+export function renderSingleSetAttrsFunc(
+  structName: string,
+  struct: MoveType | Record<string, MoveType>
+): string {
+  return typeof struct === "string"
+    ? ""
+    : "\n" +
+        Object.entries(struct)
+          .map(
+            ([key, type]) => `
+\tpublic(friend) fun set_${key}(_obelisk_world: &mut World, ${key}: ${type}) {
+\t\tlet _obelisk_schema = world::get_mut_schema<${structName}>(_obelisk_world, SCHEMA_ID);
+\t\t_obelisk_schema.${key} = ${key};
+\t\tevents::emit_set(SCHEMA_ID, SCHEMA_TYPE, none(), *_obelisk_schema)
+\t}`
+          )
+          .join("\n");
+}
+
+export function renderSingleGetAllFunc(
+  structName: string,
+  values: MoveType | Record<string, MoveType>
+): string {
+  return `\tpublic fun get(_obelisk_world: &World): ${getStructTypes(values)} {
+\t\tlet _obelisk_schema = world::get_schema<${structName}>(_obelisk_world, SCHEMA_ID);
+\t\t(
+${
+  typeof values === "string"
+    ? `\t\t\t_obelisk_schema.value`
+    : Object.entries(values)
+        .map(([key, _]) => `\t\t\t_obelisk_schema.${key},`)
+        .join("\n")
+}
+\t\t)
+\t}`;
+}
+
+export function renderSingleGetAttrsFunc(
+  structName: string,
+  struct: MoveType | Record<string, MoveType>
+): string {
+  return typeof struct === "string"
+    ? ""
+    : "\n" +
+        Object.entries(struct)
+          .map(
+            ([key, type]) => `
+\tpublic fun get_${key}(_obelisk_world: &World): ${type} {
+\t\tlet _obelisk_schema = world::get_schema<${structName}>(_obelisk_world, SCHEMA_ID);
+\t\t_obelisk_schema.${key}
+\t}`
+          )
+          .join("\n");
+}

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

@@ -0,0 +1,53 @@
+import { ObeliskConfig } from "../../types";
+import { formatAndWriteMove } from "../formatAndWrite";
+
+export function generateEntityKey(config: ObeliskConfig, srcPrefix: string) {
+  let code = `module ${config.name}::entity_key {
+    use sui::hash::keccak256;
+    use sui::address;
+    use sui::object;
+    use std::vector;
+
+    public fun from_object<T: key + store>(object: &T): address {
+        object::id_address(object)
+    }
+
+    public fun from_bytes(bytes: vector<u8>): address {
+        address::from_bytes(keccak256(&bytes))
+    }
+
+    public fun from_u256(x: u256): address {
+        address::from_u256(x)
+    }
+
+    public fun from_address_with_seed(addr: address, seed: vector<u8>): address {
+        let data = address::to_bytes(addr);
+        vector::append(&mut data, seed);
+        from_bytes(data)
+    }
+
+    public fun from_address_with_u256(addr: address, x: u256): address {
+        let data = address::to_bytes(addr);
+        vector::append(&mut data, bcs::to_bytes<u256>(&x));
+        from_bytes(data)
+    }
+
+    public fun from_object_with_seed<T: key + store>(object: &T, seed: vector<u8>): address {
+      let data = address::to_bytes(object::id_address(object));
+      vector::append(&mut data, seed);
+      from_bytes(data)
+    }
+
+    public fun from_object_with_u256<T: key + store>(object: &T, x: u256): address {
+      let data = address::to_bytes(object::id_address(object));
+      vector::append(&mut data, bcs::to_bytes<u256>(&x));
+      from_bytes(data)
+    }
+}
+`;
+  formatAndWriteMove(
+    code,
+    `${srcPrefix}/contracts/${config.name}/sources/entity_key.move`,
+    "formatAndWriteMove"
+  );
+}

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

@@ -0,0 +1,159 @@
+import { formatAndWriteMove } from "../formatAndWrite";
+
+export function generateEps(
+  projectName: string,
+  srcPrefix: string,
+  version?: number
+) {
+  generateWorld(projectName, srcPrefix, version);
+  generateEvents(projectName, srcPrefix);
+}
+
+function generateWorld(
+  projectName: string,
+  srcPrefix: string,
+  version?: number
+) {
+  if (version === undefined) {
+    version = 1;
+  }
+
+  let code = `module ${projectName}::world {
+    use std::ascii::{String, string};
+    use std::vector;
+    use sui::tx_context::TxContext;
+    use sui::bag::{Self, Bag};
+    use sui::object::{Self, UID, ID};
+    
+    const VERSION: u64 = ${version};
+
+    /// Schema does not exist
+    const ESchemaDoesNotExist: u64 = 0;
+    /// Schema already exists
+    const ESchemaAlreadyExists: u64 = 1;
+    /// Not the right admin for this world
+    const ENotAdmin: u64 = 2;
+    /// Migration is not an upgrade
+    const ENotUpgrade: u64 = 3;
+    /// Calling functions from the wrong package version
+    const EWrongVersion: u64 = 4;
+
+    struct AdminCap has key, store {
+        id: UID,
+    }
+
+    struct World has key, store {
+        id: UID,
+        /// Name of the world
+        name: String,
+        /// Description of the world
+        description: String,
+        /// Schemas of the world
+        schemas: Bag,
+        /// Schema names of the world
+        schema_names: vector<String>,
+        /// admin of the world
+        admin: ID,
+        /// Version of the world
+        version: u64
+    }
+
+    public fun create(name: String, description: String, ctx: &mut TxContext): (World, AdminCap) {
+        let admin_cap = AdminCap {
+            id: object::new(ctx),
+        };
+        let _obelisk_world = World {
+            id: object::new(ctx),
+            name,
+            description,
+            schemas: bag::new(ctx),
+            schema_names: vector::empty(),
+            admin: object::id(&admin_cap),
+            version: VERSION
+        };
+        (_obelisk_world, admin_cap)
+    }
+    
+    public fun get_admin(_obelisk_world: &World): ID {
+        _obelisk_world.admin
+    }
+
+    public fun info(_obelisk_world: &World): (String, String, u64) {
+        (_obelisk_world.name, _obelisk_world.description, _obelisk_world.version)
+    }
+    
+    public fun schema_names(_obelisk_world: &World): vector<String> {
+        _obelisk_world.schema_names
+    }
+
+    public fun get_schema<T : store>(_obelisk_world: &World, _obelisk_schema_id: vector<u8>): &T {
+        assert!(_obelisk_world.version == VERSION, EWrongVersion);
+        assert!(bag::contains(&_obelisk_world.schemas, _obelisk_schema_id), ESchemaDoesNotExist);
+        bag::borrow<vector<u8>, T>(&_obelisk_world.schemas, _obelisk_schema_id)
+    }
+
+    public fun get_mut_schema<T : store>(_obelisk_world: &mut World, _obelisk_schema_id: vector<u8>): &mut T {
+        assert!(_obelisk_world.version == VERSION, EWrongVersion);
+        assert!(bag::contains(&_obelisk_world.schemas, _obelisk_schema_id), ESchemaDoesNotExist);
+        bag::borrow_mut<vector<u8>, T>(&mut _obelisk_world.schemas, _obelisk_schema_id)
+    }
+
+    public fun add_schema<T : store>(_obelisk_world: &mut World, _obelisk_schema_id: vector<u8>, schema: T, admin_cap: &AdminCap){
+        assert!(_obelisk_world.admin == object::id(admin_cap), ENotAdmin);
+        assert!(_obelisk_world.version == VERSION, EWrongVersion);
+        assert!(!bag::contains(&_obelisk_world.schemas, _obelisk_schema_id), ESchemaAlreadyExists);
+        vector::push_back(&mut _obelisk_world.schema_names, string(_obelisk_schema_id));
+        bag::add<vector<u8>,T>(&mut _obelisk_world.schemas, _obelisk_schema_id, schema);
+    }
+
+    public fun contains(_obelisk_world: &mut World, _obelisk_schema_id: vector<u8>): bool {
+        assert!(_obelisk_world.version == VERSION, EWrongVersion);
+        bag::contains(&mut _obelisk_world.schemas, _obelisk_schema_id)
+    }
+    
+    entry fun migrate(_obelisk_world: &mut World, admin_cap: &AdminCap) {
+        assert!(_obelisk_world.admin == object::id(admin_cap), ENotAdmin);
+        assert!(_obelisk_world.version < VERSION, ENotUpgrade);
+        _obelisk_world.version = VERSION;
+    }
+}
+`;
+  formatAndWriteMove(
+    code,
+    `${srcPrefix}/contracts/${projectName}/sources/codegen/eps/world.move`,
+    "formatAndWriteMove"
+  );
+}
+
+function generateEvents(projectName: string, srcPrefix: string) {
+  let code = `module ${projectName}::events {
+    use sui::event;
+    use std::option::Option;
+
+    struct SchemaSetRecord<T: copy + drop> has copy, drop {
+        _obelisk_schema_id: vector<u8>,
+        _obelisk_schema_type: u8, // obelisk_schema_type_enum => { 0: common, 1: singleton, 2: ephemeral }
+        _obelisk_entity_key: Option<address>,
+        data: T
+    }
+
+    struct SchemaRemoveRecord has copy, drop {
+        _obelisk_schema_id: vector<u8>,
+        _obelisk_entity_key: address
+    }
+
+    public fun emit_set<T: copy + drop>(_obelisk_schema_id: vector<u8>, _obelisk_schema_type: u8, _obelisk_entity_key: Option<address>, data: T) {
+        event::emit(SchemaSetRecord { _obelisk_schema_id, _obelisk_schema_type, _obelisk_entity_key, data})
+    }
+
+    public fun emit_remove(_obelisk_schema_id: vector<u8>, _obelisk_entity_key: address) {
+        event::emit(SchemaRemoveRecord { _obelisk_schema_id, _obelisk_entity_key })
+    }
+}
+`;
+  formatAndWriteMove(
+    code,
+    `${srcPrefix}/contracts/${projectName}/sources/codegen/eps/events.move`,
+    "formatAndWriteMove"
+  );
+}