@0xobelisk/sui-common 1.2.0-pre.99 → 2.0.0

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

@@ -1,24 +1,41 @@
-import { ErrorData } from '../../types';
+import { ErrorData, ErrorEntry } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 
-export async function generateSchemaError(projectName: string, errors: ErrorData, path: string) {
-  console.log('\n📦 Starting Schema Error Generation...');
+function toErrorConstName(key: string): string {
+  return (
+    'E' +
+    key
+      .split('_')
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join('')
+  );
+}
+
+function getMessage(entry: ErrorEntry): string {
+  return typeof entry === 'string' ? entry : entry.message;
+}
+
+export async function generateError(projectName: string, errors: ErrorData, path: string) {
+  console.log('\n📦 Starting Error Generation...');
+
+  const entries = Object.entries(errors)
+    .map(([name, entry]) => {
+      const constName = toErrorConstName(name);
+      const message = getMessage(entry as ErrorEntry);
+      console.log(`     └─ ${name}: ${message}`);
+      return [
+        `    #[error]`,
+        `    const ${constName}: vector<u8> = b"${message}";`,
+        `    public fun ${name}(condition: bool) { assert!(condition, ${constName}) }`
+      ].join('\n');
+    })
+    .join('\n\n');
 
-  let code = `module ${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')}
-            }`;
+  const code = `module ${projectName}::error {\n${entries}\n}\n`;
 
   await formatAndWriteMove(
     code,
-    `${path}/src/${projectName}/sources/codegen/errors.move`,
+    `${path}/src/${projectName}/sources/codegen/error.move`,
     'formatAndWriteMove'
   );
 }

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

@@ -1,30 +1,63 @@
 import { DubheConfig } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
-// import { existsSync } from 'fs'; // Unused
-// import { capitalizeAndRemoveUnderscores } from './generateSchema'; // Unused
-// import path from 'node:path'; // Unused
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function capitalizeFirstLetter(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1);
+export async function generateGenesis(config: DubheConfig, path: string, initialMode: 0 | 1 = 1) {
+  // The dubhe framework itself is not a DApp — it provides the infrastructure.
+  // Its genesis only needs to call deploy_hook::run to initialise framework state
+  // (fee config, admin, etc.) without creating a DappStorage for itself.
+  const isDubheFramework = config.name === 'dubhe';
+
+  let genesis_code = isDubheFramework
+    ? `module ${config.name}::genesis {
+    use dubhe::dapp_service::DappHub;
+
+    // The framework genesis initialises the DappHub state via deploy_hook.
+    // No DappStorage is created for the framework itself — the framework is
+    // infrastructure, not a DApp.
+    public fun run(dapp_hub: &mut DappHub, ctx: &mut TxContext) {
+        ${config.name}::deploy_hook::run(dapp_hub, ctx);
+    }
+
+    // Called during framework upgrades to run any custom migration logic.
+    // \`dubhe upgrade\` rewrites the region between the separator comments.
+    public(package) fun migrate(_dapp_hub: &mut DappHub, _ctx: &mut TxContext) {
+        // ==========================================
+        // Add custom migration logic here.
+        // ==========================================
+    }
 }
+`
+    : `module ${config.name}::genesis {
+    use sui::clock::Clock;
+    use dubhe::dapp_service::{DappHub, DappStorage};
+    use ${config.name}::dapp_key;
+    use dubhe::dapp_system;
+    use std::ascii::string;
+
+    // The one-shot guard is enforced inside dapp_system::create_dapp, which
+    // records the DappKey type in DappHub before returning DappStorage.
+    // genesis.move does not need to carry its own guard.
+    public fun run(dapp_hub: &mut DappHub, clock: &Clock, ctx: &mut TxContext) {
+        // create_dapp aborts with dapp_already_initialized_error on repeated calls.
+        let dapp_key = dapp_key::new();
+        let mut ds = dapp_system::create_dapp(dapp_key, dapp_hub, string(b"${config.name}"), string(b"${config.description}"), ${initialMode}, clock, ctx);
+
+        // Set up initial DApp state (e.g. default resource values).
+        ${config.name}::deploy_hook::run(&mut ds, ctx);
+
+        // Share DappStorage so every transaction can access it.
+        transfer::public_share_object(ds);
+    }
 
-export async function generateGenesis(config: DubheConfig, path: string) {
-  let genesis_code = `module ${config.name}::genesis {
-      use sui::clock::Clock;
-      use dubhe::dapp_service::DappHub;
-      use ${config.name}::dapp_key;
-      use dubhe::dapp_system;
-      use std::ascii::string;
-
-  public entry fun run(dapp_hub: &mut DappHub, clock: &Clock, ctx: &mut TxContext) {
-    // Create Dapp
-    let dapp_key = dapp_key::new();
-    dapp_system::create_dapp(dapp_hub, dapp_key, string(b"${config.name}"), string(b"${config.description}"), clock, ctx);
-
-    // Logic that needs to be automated once the contract is deployed
-    ${config.name}::deploy_hook::run(dapp_hub, ctx);
-  }
+    // Called during contract upgrades to register newly added resource tables
+    // and run any custom migration logic. \`dubhe upgrade\` rewrites the region
+    // between the separator comments; do not edit that block manually.
+    public(package) fun migrate(_dapp_hub: &mut DappHub, _dapp_storage: &mut DappStorage, _ctx: &mut TxContext) {
+        // ==========================================
+        // Add custom migration logic here (e.g. initialise new resource defaults).
+        // migrate_to_vN in migrate.move calls this function automatically.
+        // ==========================================
+    }
 }
 `;
   await formatAndWriteMove(genesis_code, path, 'formatAndWriteMove');

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

@@ -2,23 +2,35 @@ import { DubheConfig } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 
 export async function generateInitTest(config: DubheConfig, path: string) {
-  let init_test_code = `module ${config.name}::init_test {
-  use sui::clock;
-  use sui::test_scenario;
-  use sui::test_scenario::Scenario;
-  use dubhe::dapp_service::DappHub;
+  // For the dubhe package itself, we only need DappHub helpers (no UserStorage/DappStorage per-DApp).
+  // For DApp packages, expose all three test helpers.
+  const isDubhe = config.name === 'dubhe';
+
+  const dappSpecificHelpers = !isDubhe
+    ? `
+  /// Create a DappStorage for this DApp without sharing it.
+  /// Suitable for unit tests that exercise global-resource functions.
+  public fun create_dapp_storage_for_testing(ctx: &mut TxContext): dubhe::dapp_service::DappStorage {
+    dubhe::dapp_system::create_dapp_storage_for_testing<${config.name}::dapp_key::DappKey>(ctx)
+  }
+
+  /// Create a UserStorage for \`owner\` without sharing it.
+  /// Suitable for unit tests that exercise user-level resource functions.
+  public fun create_user_storage_for_testing(owner: address, ctx: &mut TxContext): dubhe::dapp_service::UserStorage {
+    dubhe::dapp_system::create_user_storage_for_testing<${config.name}::dapp_key::DappKey>(owner, ctx)
+  }`
+    : '';
+
+  let init_test_code = `
+module ${config.name}::init_test {
   use dubhe::dapp_system;
 
-  public fun deploy_dapp_for_testing(scenario: &mut Scenario): DappHub {
-    let ctx = test_scenario::ctx(scenario);
-    let clock = clock::create_for_testing(ctx);
-    let mut dapp_hub = dapp_system::create_dapp_hub_for_testing(ctx);
-    ${config.name != 'dubhe' ? `dubhe::genesis::run(&mut dapp_hub, &clock, ctx);` : ''}
-    ${config.name}::genesis::run(&mut dapp_hub, &clock, ctx);
-    clock::destroy_for_testing(clock);
-    test_scenario::next_tx(scenario, ctx.sender());
-    dapp_hub
+  /// Create a DappHub for testing without sharing it.
+  /// Suitable for unit tests that need a DappHub context.
+  public fun create_dapp_hub_for_testing(ctx: &mut TxContext): dubhe::dapp_service::DappHub {
+    dapp_system::create_dapp_hub_for_testing(ctx)
   }
+${dappSpecificHelpers}
 }
 `;
   await formatAndWriteMove(init_test_code, path, 'formatAndWriteMove');

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

@@ -0,0 +1,377 @@
+import { DubheConfig, ObjectConfig, Component } from '../../types';
+import { formatAndWriteMove } from '../formatAndWrite';
+import path from 'node:path';
+
+function toPascalCase(str: string): string {
+  return str
+    .split('_')
+    .map((word) => {
+      if (/^\d+$/.test(word)) return word;
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+    .join('');
+}
+
+function getMoveType(t: string): string {
+  return t === 'string' || t === 'String' ? 'String' : t;
+}
+
+/**
+ * Generate typed field accessors (get/set) for an ObjectStorage's own fields.
+ * Calls the framework's set_object_field / get_object_field which handle
+ * native-type storage and event emission automatically.
+ */
+// Type token for substitution into generated code
+function objStorageType(markerName: string): string {
+  return `dubhe::dapp_service::ObjectStorage<${markerName}>`;
+}
+
+function generateFieldAccessors(objKey: string, cfg: ObjectConfig): string {
+  const markerName = toPascalCase(objKey);
+  const storageType = objStorageType(markerName);
+  const lines: string[] = [];
+
+  for (const [fieldName, fieldType] of Object.entries(cfg.fields)) {
+    const moveType = getMoveType(fieldType as string);
+
+    lines.push(`
+    public fun get_${fieldName}(storage: &${storageType}): ${moveType} {
+        dubhe::dapp_system::get_object_field<${markerName}, ${moveType}>(storage, b"${fieldName}")
+    }
+
+    public(package) fun set_${fieldName}(storage: &mut ${storageType}, value: ${moveType}) {
+        dubhe::dapp_system::set_object_field<DappKey, ${markerName}, ${moveType}>(
+            dapp_key::new(), storage, b"${fieldName}", value
+        );
+    }`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate bag accessor functions for a fungible resource accepted by this object.
+ * Reads use has_object_field to return a default of 0; writes do a read-modify-write
+ * through the framework CRUD API so events are emitted.
+ */
+function generateFungibleBagAccessors(objKey: string, resourceName: string): string {
+  const markerName = toPascalCase(objKey);
+  const storageType = objStorageType(markerName);
+
+  return `
+    public fun get_${resourceName}(storage: &${storageType}): u64 {
+        if (dubhe::dapp_system::has_object_field<${markerName}, u64>(storage, b"${resourceName}")) {
+            dubhe::dapp_system::get_object_field<${markerName}, u64>(storage, b"${resourceName}")
+        } else { 0 }
+    }
+
+    public(package) fun add_${resourceName}(storage: &mut ${storageType}, amount: u64) {
+        let current = get_${resourceName}(storage);
+        dubhe::dapp_system::set_object_field<DappKey, ${markerName}, u64>(
+            dapp_key::new(), storage, b"${resourceName}", current + amount
+        );
+    }
+
+    public(package) fun sub_${resourceName}(storage: &mut ${storageType}, amount: u64) {
+        let current = get_${resourceName}(storage);
+        assert!(current >= amount, EInsufficientAmount);
+        dubhe::dapp_system::set_object_field<DappKey, ${markerName}, u64>(
+            dapp_key::new(), storage, b"${resourceName}", current - amount
+        );
+    }`;
+}
+
+/**
+ * Generate bag accessor functions for a keyed resource accepted by this object.
+ * item_id is BCS-encoded as the Bag key; value is vector<u8> (raw bytes).
+ */
+function generateKeyedBagAccessors(objKey: string, resourceName: string, idField: string): string {
+  const markerName = toPascalCase(objKey);
+  const storageType = objStorageType(markerName);
+
+  return `
+    public fun has_${resourceName}(storage: &${storageType}, ${idField}: u64): bool {
+        let key = sui::bcs::to_bytes(&${idField});
+        dubhe::dapp_system::has_object_field<${markerName}, vector<u8>>(storage, key)
+    }
+
+    public fun get_${resourceName}_data(storage: &${storageType}, ${idField}: u64): vector<u8> {
+        let key = sui::bcs::to_bytes(&${idField});
+        dubhe::dapp_system::get_object_field<${markerName}, vector<u8>>(storage, key)
+    }
+
+    public(package) fun set_${resourceName}_data(storage: &mut ${storageType}, ${idField}: u64, data: vector<u8>) {
+        let key = sui::bcs::to_bytes(&${idField});
+        assert!(!dubhe::dapp_system::has_object_field<${markerName}, vector<u8>>(storage, key), EDuplicateItemId);
+        dubhe::dapp_system::set_object_field<DappKey, ${markerName}, vector<u8>>(
+            dapp_key::new(), storage, key, data
+        );
+    }
+
+    public(package) fun remove_${resourceName}_data(storage: &mut ${storageType}, ${idField}: u64): vector<u8> {
+        let key = sui::bcs::to_bytes(&${idField});
+        assert!(dubhe::dapp_system::has_object_field<${markerName}, vector<u8>>(storage, key), EFieldNotFound);
+        dubhe::dapp_system::remove_object_field<DappKey, ${markerName}, vector<u8>>(dapp_key::new(), storage, key)
+    }`;
+}
+
+/**
+ * Generate cross-storage transfer functions for acceptsFrom sources.
+ * These live in the DESTINATION module and atomically move resources between
+ * two ObjectStorage (or SceneStorage) objects.
+ */
+function generateAcceptsFromTransfers(
+  projectName: string,
+  destKey: string,
+  destAccepts: string[],
+  acceptsFrom: string[],
+  config: DubheConfig
+): { imports: string[]; functions: string[] } {
+  const resources = config.resources ?? {};
+  const allObjects = config.objects ?? {};
+  const allScenes = config.scenes ?? {};
+
+  const destMarker = toPascalCase(destKey);
+  const destStorageType = objStorageType(destMarker);
+  const imports: string[] = [];
+  const functions: string[] = [];
+
+  for (const sourceName of acceptsFrom) {
+    const sourceCfg = allObjects[sourceName] ?? allScenes[sourceName];
+    if (!sourceCfg) continue;
+
+    const sourceAccepts = sourceCfg.accepts ?? [];
+    const sourceMarker = toPascalCase(sourceName);
+    // Source may be ObjectStorage or SceneStorage — import just the module
+    imports.push(`    use ${projectName}::${sourceName};`);
+
+    const commonResources = sourceAccepts.filter((r) => destAccepts.includes(r));
+
+    for (const resourceName of commonResources) {
+      const resCfg = resources[resourceName];
+      if (!resCfg || typeof resCfg === 'string') continue;
+      const comp = resCfg as Component;
+
+      // Use fully-qualified phantom type to avoid import issues
+      const isSourceScene = !!allScenes[sourceName];
+      const qualifiedSourceMarker = `${projectName}::${sourceName}::${sourceMarker}`;
+      const sourceStorageType = isSourceScene
+        ? `dubhe::dapp_service::SceneStorage<${qualifiedSourceMarker}>`
+        : `dubhe::dapp_service::ObjectStorage<${qualifiedSourceMarker}>`;
+      const sourceSceneCfg = isSourceScene ? allScenes[sourceName] : undefined;
+      const sourcePermitType =
+        sourceSceneCfg?.authorization.kind === 'permit'
+          ? `dubhe::dapp_service::ScenePermit<${projectName}::${
+              sourceSceneCfg.authorization.permit
+            }::${toPascalCase(sourceSceneCfg.authorization.permit)}>`
+          : '';
+      const sourcePermitParam =
+        sourceSceneCfg?.authorization.kind === 'permit'
+          ? `        source_permit: &${sourcePermitType},\n`
+          : '';
+      const sourceIsPermitScene = sourceSceneCfg?.authorization.kind === 'permit';
+      const sourceCallPrefix = sourceIsPermitScene ? 'source_permit, ' : '';
+      // Permit-authorized scene writes resolve the caller identity from user_storage.
+      const sourceUserStorageParam = sourceIsPermitScene
+        ? `        user_storage: &dubhe::dapp_service::UserStorage,\n`
+        : '';
+      const sourceUserStorageCall = sourceIsPermitScene ? 'user_storage, ' : '';
+      const sourceCtxParam = sourceIsPermitScene ? '        ctx:        &TxContext,\n' : '';
+      const sourceCtxCall = sourceIsPermitScene ? ', ctx' : '';
+
+      if (!comp.fungible && comp.keys?.length) {
+        const idField = comp.keys[0];
+        functions.push(`
+    /// Transfer ${resourceName} (keyed item) from ${sourceName} into this ${destKey}.
+    public(package) fun transfer_${sourceName}_to_${destKey}_${resourceName}(
+${sourcePermitParam}        from:       &mut ${sourceStorageType},
+        to:         &mut ${destStorageType},
+${sourceUserStorageParam}        ${idField}: u64,
+${sourceCtxParam}
+    ) {
+        let data = ${sourceName}::remove_${resourceName}_data(${sourceCallPrefix}from, ${sourceUserStorageCall}${idField}${sourceCtxCall});
+        set_${resourceName}_data(to, ${idField}, data);
+    }`);
+      } else {
+        functions.push(`
+    /// Transfer ${resourceName} (fungible) from ${sourceName} into this ${destKey}.
+    public(package) fun transfer_${sourceName}_to_${destKey}_${resourceName}(
+${sourcePermitParam}        from:   &mut ${sourceStorageType},
+        to:     &mut ${destStorageType},
+${sourceUserStorageParam}        amount: u64,
+${sourceCtxParam}
+    ) {
+        ${sourceName}::sub_${resourceName}(${sourceCallPrefix}from, ${sourceUserStorageCall}amount${sourceCtxCall});
+        add_${resourceName}(to, amount);
+    }`);
+      }
+    }
+  }
+
+  return { imports, functions };
+}
+
+export async function generateObjects(config: DubheConfig, outputDir: string) {
+  if (!config.objects || Object.keys(config.objects).length === 0) return;
+  console.log('\n📦 Starting Object Storage Generation...');
+
+  const projectName = config.name;
+  const resources = config.resources ?? {};
+
+  for (const [objKey, objCfg] of Object.entries(config.objects)) {
+    console.log(`     └─ ${objKey}`);
+    const markerName = toPascalCase(objKey);
+    const storageAlias = `${markerName}Storage`;
+    const typeTag = `b"${objKey}"`;
+
+    // Own field accessors (framework CRUD calls)
+    const fieldAccessors = generateFieldAccessors(objKey, objCfg);
+
+    // Bag accessors for accepted resources
+    const acceptedResources = objCfg.accepts ?? [];
+    const bagAccessorParts: string[] = [];
+    for (const resourceName of acceptedResources) {
+      const resCfg = resources[resourceName];
+      if (!resCfg || typeof resCfg === 'string') continue;
+      const comp = resCfg as Component;
+      if (!comp.fungible && comp.keys?.length) {
+        bagAccessorParts.push(generateKeyedBagAccessors(objKey, resourceName, comp.keys[0]));
+      } else {
+        bagAccessorParts.push(generateFungibleBagAccessors(objKey, resourceName));
+      }
+    }
+
+    // acceptsFrom: cross-storage transfer functions
+    const { imports: afImports, functions: afFunctions } = generateAcceptsFromTransfers(
+      projectName,
+      objKey,
+      acceptedResources,
+      objCfg.acceptsFrom ?? [],
+      config
+    );
+
+    // adminOnly check for create
+    const adminCheck = objCfg.adminOnly
+      ? `        assert!(ctx.sender() == dubhe::dapp_service::dapp_admin(dapp_storage), ENoPermission);`
+      : '';
+
+    const fullStorageTypeLocal = `dubhe::dapp_service::ObjectStorage<${markerName}>`;
+
+    // assert_<key>_id helper (reads entity_id via framework accessor)
+    const assertIdFn = `
+    public fun assert_${objKey}_id(storage: &${fullStorageTypeLocal}, expected: vector<u8>) {
+        assert!(*dubhe::dapp_service::object_storage_entity_id(storage) == expected, EWrongEntityId);
+    }`;
+
+    // entity_id accessor
+    const entityIdFn = `
+    public fun entity_id(storage: &${fullStorageTypeLocal}): vector<u8> {
+        *dubhe::dapp_service::object_storage_entity_id(storage)
+    }`;
+
+    // Conditional String import: needed when own fields or String-typed accepts are used
+    const ownFieldTypes = Object.values(objCfg.fields) as string[];
+    const needsStringImport = ownFieldTypes.some(
+      (t) => t === 'string' || t === 'String' || t === 'vector<String>'
+    );
+    const stringImport = needsStringImport ? `\n    use std::ascii::String;` : '';
+
+    // Conditional error constants
+    const hasKeyedAccepts = acceptedResources.some((r) => {
+      const rc = resources[r];
+      if (!rc || typeof rc === 'string') return false;
+      return !!(rc as Component).keys?.length && !(rc as Component).fungible;
+    });
+    const hasFungibleAccepts = acceptedResources.some((r) => {
+      const rc = resources[r];
+      if (!rc || typeof rc === 'string') return false;
+      return !!(rc as Component).fungible;
+    });
+    // EFieldNotFound is only used in remove_*_data for keyed bag accessors
+    const objNeedsFieldNotFound = hasKeyedAccepts;
+    const objNeedsInsufficient = hasFungibleAccepts;
+    const objNeedsDuplicate = hasKeyedAccepts;
+    const objNeedsNoPermission = !!objCfg.adminOnly;
+
+    const errorConstants = [
+      objNeedsFieldNotFound
+        ? `    #[error]\n    const EFieldNotFound: vector<u8> = b"Field not found";`
+        : '',
+      objNeedsInsufficient
+        ? `    #[error]\n    const EInsufficientAmount: vector<u8> = b"Insufficient amount";`
+        : '',
+      objNeedsDuplicate
+        ? `    #[error]\n    const EDuplicateItemId: vector<u8> = b"Duplicate item id";`
+        : '',
+      `    #[error]\n    const EWrongEntityId: vector<u8> = b"Wrong entity id";`,
+      objNeedsNoPermission
+        ? `    #[error]\n    const ENoPermission: vector<u8> = b"Caller does not have permission";`
+        : ''
+    ]
+      .filter(Boolean)
+      .join('\n');
+
+    const afImportBlock = afImports.length > 0 ? '\n' + afImports.join('\n') : '';
+
+    // Use the full framework type name for all function signatures.
+    // Move type aliases (public type) are not yet supported in this Sui version,
+    // so we use ObjectStorage<Marker> directly.
+    const fullStorageType = `dubhe::dapp_service::ObjectStorage<${markerName}>`;
+
+    const code = `module ${projectName}::${objKey} {
+    use dubhe::dapp_service::DappStorage;
+    use ${projectName}::dapp_key;
+    use ${projectName}::dapp_key::DappKey;${stringImport}${afImportBlock}
+
+    // ─── Error constants ───────────────────────────────────────────────────
+${errorConstants}
+
+    const TYPE_TAG: vector<u8> = ${typeTag};
+
+    // ─── Phantom marker type ───────────────────────────────────────────────
+    /// Phantom type that distinguishes ${storageAlias} from other ObjectStorage types
+    /// at the Move compiler level, preserving compile-time type safety.
+    /// All functions use ObjectStorage<${markerName}> directly in their signatures.
+    public struct ${markerName} has copy, drop {}
+
+    // ─── ID / entity accessors ─────────────────────────────────────────────
+${entityIdFn}
+
+${assertIdFn}
+
+    // ─── Field accessors (own fields) ──────────────────────────────────────
+${fieldAccessors}
+
+    // ─── Bag accessors for accepted resources ─────────────────────────────
+${bagAccessorParts.join('\n')}
+
+    // ─── acceptsFrom: cross-storage transfer functions ─────────────────────
+${afFunctions.join('\n')}
+
+    // ─── Lifecycle entry functions ─────────────────────────────────────────
+    public(package) fun create_${objKey}(
+        dapp_storage: &mut DappStorage,
+        entity_id:    vector<u8>,
+        ctx:          &mut TxContext,
+    ) {
+${adminCheck}
+        dubhe::dapp_system::create_and_share_typed_object<DappKey, ${markerName}>(
+            dapp_key::new(), dapp_storage, TYPE_TAG, entity_id, ctx
+        );
+    }
+
+    public(package) fun destroy_${objKey}(
+        dapp_storage: &mut DappStorage,
+        storage:      ${fullStorageType},
+        _ctx:         &TxContext,
+    ) {
+        dubhe::dapp_system::destroy_typed_object<DappKey, ${markerName}>(
+            dapp_key::new(), dapp_storage, storage
+        );
+    }
+}
+`;
+
+    await formatAndWriteMove(code, path.join(outputDir, `${objKey}.move`), 'formatAndWriteMove');
+  }
+}