create-dubhe 1.2.0-pre.98 → 2.0.0

package/templates/101/sui-template/packages/contracts/src/dubhe/sources/tests/user_storage_test.move

@@ -0,0 +1,160 @@
+/// Unit tests — UserStorage creation and registration
+///
+/// Covers:
+///   create_user_storage: initial state, registration recorded, duplicate abort
+///   canonical_owner is set correctly on creation
+///   session fields initialized to zero/empty
+#[test_only]
+module dubhe::user_storage_test;
+
+use dubhe::dapp_service::{Self, DappHub, DappStorage};
+use dubhe::dapp_system;
+use sui::test_scenario;
+
+public struct UsTestKey has copy, drop {}
+
+const USER: address = @0x1234;
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+fun setup(scenario: &mut test_scenario::Scenario): (DappHub, DappStorage) {
+    let ctx = test_scenario::ctx(scenario);
+    (
+        dapp_system::create_dapp_hub_for_testing(ctx),
+        dapp_system::create_dapp_storage_for_testing<UsTestKey>(ctx),
+    )
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Initial state
+// ═══════════════════════════════════════════════════════════════════════════════
+
+#[test]
+fun test_initial_write_counts_are_zero() {
+    let mut scenario = test_scenario::begin(USER);
+    {
+        let ctx = test_scenario::ctx(&mut scenario);
+        let us = dapp_service::create_user_storage_for_testing<UsTestKey>(USER, ctx);
+
+        assert!(dapp_service::write_count(&us) == 0);
+        assert!(dapp_service::settled_count(&us) == 0);
+        assert!(dapp_service::unsettled_count(&us) == 0);
+
+        dapp_service::destroy_user_storage(us);
+    };
+    scenario.end();
+}
+
+#[test]
+fun test_canonical_owner_set_on_creation() {
+    let mut scenario = test_scenario::begin(USER);
+    {
+        let ctx = test_scenario::ctx(&mut scenario);
+        let us = dapp_service::create_user_storage_for_testing<UsTestKey>(USER, ctx);
+        assert!(dapp_service::canonical_owner(&us) == USER);
+        dapp_service::destroy_user_storage(us);
+    };
+    scenario.end();
+}
+
+#[test]
+fun test_session_fields_cleared_on_creation() {
+    let mut scenario = test_scenario::begin(USER);
+    {
+        let ctx = test_scenario::ctx(&mut scenario);
+        let us = dapp_service::create_user_storage_for_testing<UsTestKey>(USER, ctx);
+        assert!(dapp_service::session_key(&us) == @0x0);
+        assert!(dapp_service::session_expires_at(&us) == 0);
+        dapp_service::destroy_user_storage(us);
+    };
+    scenario.end();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// create_user_storage (via dapp_system) — registration guard
+// ═══════════════════════════════════════════════════════════════════════════════
+
+#[test]
+fun test_create_user_storage_registers_address() {
+    let sender = @0xABC;
+    let mut scenario = test_scenario::begin(sender);
+    {
+        let (dh, mut ds) = setup(&mut scenario);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        assert!(!dapp_service::has_registered_user_storage(&ds, sender));
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        assert!(dapp_service::has_registered_user_storage(&ds, sender));
+
+        dapp_system::destroy_dapp_hub(dh);
+        dapp_system::destroy_dapp_storage(ds);
+    };
+    scenario.end();
+}
+
+#[test]
+#[expected_failure]
+fun test_create_user_storage_twice_aborts() {
+    let sender = @0xABC;
+    let mut scenario = test_scenario::begin(sender);
+    {
+        let (dh, mut ds) = setup(&mut scenario);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        // Second call from the same address must abort with user_storage_already_exists.
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+
+        dapp_system::destroy_dapp_hub(dh);
+        dapp_system::destroy_dapp_storage(ds);
+    };
+    scenario.end();
+}
+
+#[test]
+fun test_different_users_can_each_create_one_user_storage() {
+    let user_a = @0xAAAA;
+    let user_b = @0xBBBB;
+
+    let mut scenario = test_scenario::begin(user_a);
+    {
+        let (dh, mut ds) = setup(&mut scenario);
+
+        // user_a creates their storage.
+        let ctx = test_scenario::ctx(&mut scenario);
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        assert!(dapp_service::has_registered_user_storage(&ds, user_a));
+
+        // user_b creates theirs in a new tx.
+        test_scenario::next_tx(&mut scenario, user_b);
+        let ctx = test_scenario::ctx(&mut scenario);
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        assert!(dapp_service::has_registered_user_storage(&ds, user_b));
+
+        dapp_system::destroy_dapp_hub(dh);
+        dapp_system::destroy_dapp_storage(ds);
+    };
+    scenario.end();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Suspended DApp guard
+// ═══════════════════════════════════════════════════════════════════════════════
+
+#[test]
+fun test_create_user_storage_succeeds_after_registration_check() {
+    let sender = @0xABC;
+    let mut scenario = test_scenario::begin(sender);
+    {
+        let (dh, mut ds) = setup(&mut scenario);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        // Must succeed.
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        assert!(dapp_service::has_registered_user_storage(&ds, sender));
+
+        dapp_system::destroy_dapp_hub(dh);
+        dapp_system::destroy_dapp_storage(ds);
+    };
+    scenario.end();
+}

package/templates/101/sui-template/packages/contracts/src/dubhe/sources/utils/math.move

@@ -1,6 +1,7 @@
 module dubhe::dubhe_math {
     use std::u128;
     use std::u64;
+    use dubhe::error;
 
     public fun min(x: u256, y: u256): u256 {
         if (x < y) x else y
@@ -9,12 +10,12 @@ module dubhe::dubhe_math {
     public fun safe_mul(a: u256, b: u256): u256 {
         if (a == 0 || b == 0) return 0;
         let c = a * b;
-        assert!(c / a == b, 0);
+        error::math_overflow(c / a == b);
         c
     }
 
     public fun safe_div(a: u256, b: u256): u256 {
-        assert!(b != 0, 0);
+        error::division_by_zero(b != 0);
         a / b
     }
 
@@ -108,7 +109,7 @@ module dubhe::dubhe_math {
     }
 
     public(package) fun windows(x: &vector<u256>, size: u64): vector<vector<u256>> {
-        assert!(size > 0, 0);
+        error::invalid_window_size(size > 0);
 
         let length = vector::length(x);
         let mut result = vector::empty<vector<u256>>();

package/templates/101/sui-template/packages/contracts/src/dubhe/sources/utils/type_info.move

@@ -29,11 +29,11 @@ module dubhe::type_info {
     }
 
     public fun get_package_id<T>(): address {
-        let type_name = type_name::get<T>().get_address();
+        let type_name = type_name::with_defining_ids<T>().address_string();
         address::from_ascii_bytes(type_name.as_bytes())
     }
 
     public fun get_type_name_string<T>(): String {
-        type_name::get<T>().into_string()
+        type_name::with_defining_ids<T>().into_string()
     }
 }

package/templates/contract/sui-template/dubhe.config.ts

@@ -3,6 +3,5 @@ import { defineConfig } from '@0xobelisk/sui-common';
 export const dubheConfig = defineConfig({
   name: 'template',
   description: 'template',
-  components: {},
   resources: {}
 });

package/templates/contract/sui-template/package.json

@@ -4,14 +4,14 @@
   "description": "Simple starter template",
   "license": "Apache-2.0",
   "scripts": {
-    "gen": "pnpm dubhe schemagen"
+    "gen": "pnpm dubhe generate"
   },
   "dependencies": {
     "@0xobelisk/sui-cli": "{{dubhe-version}}",
     "@0xobelisk/sui-client": "{{dubhe-version}}",
     "@0xobelisk/sui-common": "{{dubhe-version}}",
-    "dotenv": "^16.4.5",
-    "chalk": "^4.1.2"
+    "chalk": "^4.1.2",
+    "dotenv": "^16.4.5"
   },
   "devDependencies": {
     "@types/node": "^22.16.0",

package/templates/contract/sui-template/src/dubhe/Move.lock

@@ -1,38 +1,41 @@
-# @generated by Move, please check-in and do not edit manually.
+# Generated by move; do not edit
+# This file should be checked in.
 
 [move]
-version = 3
-manifest_digest = "9E441545FB5525E6DED36D5515A5D25F03199A6CD5699C95CF663AFB76CAB789"
-deps_digest = "F8BBB0CCB2491CA29A3DF03D6F92277A4F3574266507ACD77214D37ECA3F3082"
-dependencies = [
-  { id = "Sui", name = "Sui" },
-]
+version = 4
 
-[[move.package]]
-id = "MoveStdlib"
-source = { git = "https://github.com/MystenLabs/sui.git", rev = "mainnet-v1.46.3", subdir = "crates/sui-framework/packages/move-stdlib" }
+[pinned.mainnet.Dubhe]
+source = { root = true }
+use_environment = "mainnet"
+manifest_digest = "2AF62652675929717F20B988B31D3936712B319F150E7B7E069948FF27B34E0E"
+deps = { Sui = "Sui" }
 
-[[move.package]]
-id = "Sui"
-source = { git = "https://github.com/MystenLabs/sui.git", rev = "mainnet-v1.46.3", subdir = "crates/sui-framework/packages/sui-framework" }
+[pinned.mainnet.MoveStdlib]
+source = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/move-stdlib", rev = "3c0f387ebb40b8be292d3b7bd3f5bee8ad226d33" }
+use_environment = "mainnet"
+manifest_digest = "C4FE4C91DE74CBF223B2E380AE40F592177D21870DC2D7EB6227D2D694E05363"
+deps = {}
 
-dependencies = [
-  { id = "MoveStdlib", name = "MoveStdlib" },
-]
+[pinned.mainnet.Sui]
+source = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "3c0f387ebb40b8be292d3b7bd3f5bee8ad226d33" }
+use_environment = "mainnet"
+manifest_digest = "CD547CB1ACCE0880C835DAED2D8FFCB91D56C833AE5240D3AA5B918398263195"
+deps = { MoveStdlib = "MoveStdlib" }
 
-[move.toolchain-version]
-compiler-version = "1.40.1"
-edition = "2024"
-flavor = "sui"
+[pinned.testnet.Dubhe]
+source = { root = true }
+use_environment = "testnet"
+manifest_digest = "B50A32218E466AACB70E7FB4A9B0991CFCF16B50B77AA0D5FBEC6A0730F28D67"
+deps = { Sui = "Sui" }
 
-[env.localnet]
-chain-id = "31a2786f"
-original-published-id = "0x090035fe80abad17e6f7dbfc933a5f73736043fed333d32250725275ef63d7b6"
-latest-published-id = "0x090035fe80abad17e6f7dbfc933a5f73736043fed333d32250725275ef63d7b6"
-published-version = "1"
+[pinned.testnet.MoveStdlib]
+source = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/move-stdlib", rev = "3c0f387ebb40b8be292d3b7bd3f5bee8ad226d33" }
+use_environment = "testnet"
+manifest_digest = "C4FE4C91DE74CBF223B2E380AE40F592177D21870DC2D7EB6227D2D694E05363"
+deps = {}
 
-[env.testnet]
-chain-id = "4c78adac"
-original-published-id = "0x8817b4976b6c607da01cea49d728f71d09274c82e9b163fa20c2382586f8aefc"
-latest-published-id = "0x8817b4976b6c607da01cea49d728f71d09274c82e9b163fa20c2382586f8aefc"
-published-version = "1"
+[pinned.testnet.Sui]
+source = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "3c0f387ebb40b8be292d3b7bd3f5bee8ad226d33" }
+use_environment = "testnet"
+manifest_digest = "7AFB66695545775FBFBB2D3078ADFD084244D5002392E837FDE21D9EA1C6D01C"
+deps = { MoveStdlib = "MoveStdlib" }

package/templates/contract/sui-template/src/dubhe/Move.toml

@@ -4,11 +4,16 @@ edition = "2024"
 version = "1.0.0"
 license = "apache2.0"
 authors = ["Obelisk Labs"]
-published-at = "0x8817b4976b6c607da01cea49d728f71d09274c82e9b163fa20c2382586f8aefc"
+published-at = "0x1a79c1611ab49723b388510813553ad912d96a4f1a9ed5fdbdb57e446c6fe946"
 
 [dependencies]
-Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.46.3" }
+Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.68.1", override = true }
 
 [addresses]
-dubhe = "0x8817b4976b6c607da01cea49d728f71d09274c82e9b163fa20c2382586f8aefc"
+dubhe = "0x1a79c1611ab49723b388510813553ad912d96a4f1a9ed5fdbdb57e446c6fe946"
+
+[environments]
+testnet = "4c78adac"
+mainnet = "35834a8a"
+localnet = "d3e1a0e6"
 

package/templates/contract/sui-template/src/dubhe/sources/codegen/dapp_key.move

@@ -1,32 +1,46 @@
-  // Copyright (c) Obelisk Labs, Inc.
-  // SPDX-License-Identifier: Apache-2.0
-  #[allow(unused_use)]
-  
-  /* Autogenerated file. Do not edit manually. */
-  
-  module dubhe::dapp_key {
-use std::type_name;
-  use sui::address;
-  use std::ascii::String;
-
-  /// Authorization token for the app.
-
-  public struct DappKey has copy, drop {}
-
-  public(package) fun new(): DappKey {
-    DappKey {  }
-  }
-
-  public fun to_string(): String {
-    type_name::get<DappKey>().into_string()
-  }
-
-  public fun package_id(): address {
-    let package_id_str = type_name::get<DappKey>().get_address();
-    address::from_ascii_bytes(package_id_str.as_bytes())
-  }
-
-  public fun eq<DappKey1: copy + drop, DappKey2: copy + drop>(_: &DappKey1, _: &DappKey2): bool {
-    type_name::get<DappKey1>() == type_name::get<DappKey2>()
-  }
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module dubhe::dapp_key {
+    use std::type_name;
+    use sui::address;
+    use std::ascii::String;
+
+    /// DappKey — package-level authorization token for this DApp.
+    ///
+    /// SECURITY: `new()` is intentionally `public(package)`.
+    /// Only code compiled into this package can construct a DappKey instance.
+    /// All framework write functions (`set_record`, `set_field`,
+    /// `take_record`, `create_user_storage`, …) require `_auth: DappKey`
+    /// as proof that the call originated from inside this package — an
+    /// external PTB cannot fabricate that proof.
+    ///
+    /// NEVER change `new()` to `public`, and never accept a DappKey
+    /// value as a parameter from an external caller.  Either mistake removes
+    /// every package-level access guard, allowing any PTB to write arbitrary
+    /// user data or register UserStorages without going through the DApp's
+    /// own entry functions.
+
+    public struct DappKey has copy, drop {}
+
+    /// Constructs an authorization token. Callable only from within this package.
+    /// Pass the result as `_auth` to any framework function that requires it.
+    public(package) fun new(): DappKey {
+        DappKey {}
+    }
+
+    public fun to_string(): String {
+        type_name::with_defining_ids<DappKey>().into_string()
+    }
+
+    public fun package_id(): address {
+        let package_id_str = type_name::with_defining_ids<DappKey>().address_string();
+        address::from_ascii_bytes(package_id_str.as_bytes())
+    }
+
+    public fun eq<DappKey1: copy + drop, DappKey2: copy + drop>(_: &DappKey1, _: &DappKey2): bool {
+        type_name::with_defining_ids<DappKey1>() == type_name::with_defining_ids<DappKey2>()
+    }
 }

package/templates/contract/sui-template/src/dubhe/sources/codegen/error.move

@@ -0,0 +1,170 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module dubhe::error {
+    #[error]
+    const ENoPermission: vector<u8> = b"No permission";
+    public fun no_permission(condition: bool) { assert!(condition, ENoPermission) }
+
+    #[error]
+    const ENotLatestVersion: vector<u8> = b"Not latest version";
+    public fun not_latest_version(condition: bool) { assert!(condition, ENotLatestVersion) }
+
+    #[error]
+    const EDappPaused: vector<u8> = b"Dapp is paused";
+    public fun dapp_paused(condition: bool) { assert!(condition, EDappPaused) }
+
+    #[error]
+    const EInvalidPackageId: vector<u8> = b"Invalid package id";
+    public fun invalid_package_id(condition: bool) { assert!(condition, EInvalidPackageId) }
+
+    #[error]
+    const EInvalidVersion: vector<u8> = b"Invalid version";
+    public fun invalid_version(condition: bool) { assert!(condition, EInvalidVersion) }
+
+    #[error]
+    const EDappAlreadyInitialized: vector<u8> = b"Dapp already initialized";
+    public fun dapp_already_initialized(condition: bool) { assert!(condition, EDappAlreadyInitialized) }
+
+    #[error]
+    const EInsufficientCredit: vector<u8> = b"Insufficient credit";
+    public fun insufficient_credit(condition: bool) { assert!(condition, EInsufficientCredit) }
+
+    #[error]
+    const ENoPendingOwnershipTransfer: vector<u8> = b"No pending ownership transfer";
+    public fun no_pending_ownership_transfer(condition: bool) { assert!(condition, ENoPendingOwnershipTransfer) }
+
+    #[error]
+    const EUserDebtLimitExceeded: vector<u8> = b"User debt limit exceeded";
+    public fun user_debt_limit_exceeded(condition: bool) { assert!(condition, EUserDebtLimitExceeded) }
+
+    #[error]
+    const EDappKeyMismatch: vector<u8> = b"Dapp key mismatch";
+    public fun dapp_key_mismatch(condition: bool) { assert!(condition, EDappKeyMismatch) }
+
+    #[error]
+    const ENoActiveSession: vector<u8> = b"No active session";
+    public fun no_active_session(condition: bool) { assert!(condition, ENoActiveSession) }
+
+    #[error]
+    const ENotCanonicalOwner: vector<u8> = b"Not canonical owner";
+    public fun not_canonical_owner(condition: bool) { assert!(condition, ENotCanonicalOwner) }
+
+    #[error]
+    const EUserStorageAlreadyExists: vector<u8> = b"User storage already exists";
+    public fun user_storage_already_exists(condition: bool) { assert!(condition, EUserStorageAlreadyExists) }
+
+    #[error]
+    const EInvalidSessionKey: vector<u8> = b"Invalid session key";
+    public fun invalid_session_key(condition: bool) { assert!(condition, EInvalidSessionKey) }
+
+    #[error]
+    const EInvalidSessionDuration: vector<u8> = b"Invalid session duration";
+    public fun invalid_session_duration(condition: bool) { assert!(condition, EInvalidSessionDuration) }
+
+    #[error]
+    const EWrongPaymentCoinType: vector<u8> = b"Wrong payment coin type";
+    public fun wrong_payment_coin_type(condition: bool) { assert!(condition, EWrongPaymentCoinType) }
+
+    #[error]
+    const ENoPendingCoinTypeChange: vector<u8> = b"No pending coin type change";
+    public fun no_pending_coin_type_change(condition: bool) { assert!(condition, ENoPendingCoinTypeChange) }
+
+    #[error]
+    const ECoinTypeChangeNotReady: vector<u8> = b"Coin type change not ready";
+    public fun coin_type_change_not_ready(condition: bool) { assert!(condition, ECoinTypeChangeNotReady) }
+
+    #[error]
+    const EWrongSettlementMode: vector<u8> = b"Wrong settlement mode";
+    public fun wrong_settlement_mode(condition: bool) { assert!(condition, EWrongSettlementMode) }
+
+    #[error]
+    const ERevenueShareExceedsMax: vector<u8> = b"Invalid revenue share bps";
+    public fun revenue_share_exceeds_max(condition: bool) { assert!(condition, ERevenueShareExceedsMax) }
+
+    #[error]
+    const ENoRevenueToWithdraw: vector<u8> = b"No revenue to withdraw";
+    public fun no_revenue_to_withdraw(condition: bool) { assert!(condition, ENoRevenueToWithdraw) }
+
+    #[error]
+    const ESceneExpired: vector<u8> = b"Scene has expired";
+    public fun scene_expired(condition: bool) { assert!(condition, ESceneExpired) }
+
+    #[error]
+    const ENotSceneParticipant: vector<u8> = b"Not a scene participant";
+    public fun not_scene_participant(condition: bool) { assert!(condition, ENotSceneParticipant) }
+
+    #[error]
+    const EEntityNotFound: vector<u8> = b"Entity not found";
+    public fun entity_not_found(condition: bool) { assert!(condition, EEntityNotFound) }
+
+    #[error]
+    const EEntityIdAlreadyExists: vector<u8> = b"Entity id already exists";
+    public fun entity_id_already_exists(condition: bool) { assert!(condition, EEntityIdAlreadyExists) }
+
+    #[error]
+    const EInsufficientBalance: vector<u8> = b"Insufficient balance";
+    public fun insufficient_balance(condition: bool) { assert!(condition, EInsufficientBalance) }
+
+    #[error]
+    const EParticipantsStillPresent: vector<u8> = b"Cannot destroy scene while participants are still present";
+    public fun participants_still_present(condition: bool) { assert!(condition, EParticipantsStillPresent) }
+
+    #[error]
+    const EWriteLimitOutOfRange: vector<u8> = b"Write limit out of range";
+    public fun write_limit_out_of_range(condition: bool) { assert!(condition, EWriteLimitOutOfRange) }
+
+    #[error]
+    const ESceneFull: vector<u8> = b"Scene has reached its maximum participant limit";
+    public fun scene_full(condition: bool) { assert!(condition, ESceneFull) }
+
+    #[error]
+    const EMarketplaceFeeExceedsMax: vector<u8> = b"Marketplace fee bps cannot exceed 10000";
+    public fun marketplace_fee_exceeds_max(condition: bool) { assert!(condition, EMarketplaceFeeExceedsMax) }
+
+    #[error]
+    const ENotParticipant: vector<u8> = b"Sender is not a participant or invitee";
+    public fun not_participant(condition: bool) { assert!(condition, ENotParticipant) }
+
+    #[error]
+    const EInvitationExpired: vector<u8> = b"Invitation window has expired";
+    public fun invitation_expired(condition: bool) { assert!(condition, EInvitationExpired) }
+
+    #[error]
+    const EInvalidKey: vector<u8> = b"Invalid record key";
+    public fun invalid_key(condition: bool) { assert!(condition, EInvalidKey) }
+
+    #[error]
+    const ELengthMismatch: vector<u8> = b"Field names and values length mismatch";
+    public fun length_mismatch(condition: bool) { assert!(condition, ELengthMismatch) }
+
+    #[error]
+    const EInvalidEvmAddress: vector<u8> = b"Invalid EVM address length";
+    public fun invalid_evm_address(condition: bool) { assert!(condition, EInvalidEvmAddress) }
+
+    #[error]
+    const EInvalidSolanaAddress: vector<u8> = b"Invalid Solana address length";
+    public fun invalid_solana_address(condition: bool) { assert!(condition, EInvalidSolanaAddress) }
+
+    #[error]
+    const EMathOverflow: vector<u8> = b"Arithmetic overflow";
+    public fun math_overflow(condition: bool) { assert!(condition, EMathOverflow) }
+
+    #[error]
+    const EDivisionByZero: vector<u8> = b"Division by zero";
+    public fun division_by_zero(condition: bool) { assert!(condition, EDivisionByZero) }
+
+    #[error]
+    const EInvalidWindowSize: vector<u8> = b"Window size must be greater than zero";
+    public fun invalid_window_size(condition: bool) { assert!(condition, EInvalidWindowSize) }
+
+    #[error]
+    const EInsufficientPayment: vector<u8> = b"Insufficient payment for listing price";
+    public fun insufficient_payment(condition: bool) { assert!(condition, EInsufficientPayment) }
+
+    #[error]
+    const EItemAlreadyOwned: vector<u8> = b"Buyer already owns an item with this key";
+    public fun item_already_owned(condition: bool) { assert!(condition, EItemAlreadyOwned) }
+}

package/templates/contract/sui-template/src/dubhe/sources/codegen/genesis.move

@@ -1,16 +1,19 @@
-#[allow(lint(share_owned))]module dubhe::genesis {
-      use sui::clock::Clock;
-      use dubhe::dapp_service::DappHub;
-      use dubhe::dapp_key;
-      use dubhe::dapp_system;
-      use std::ascii::string;
+#[allow(lint(share_owned))]
+module dubhe::genesis {
+    use dubhe::dapp_service::DappHub;
 
-  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"dubhe"), string(b"Dubhe Protocol"), clock, ctx);
+    // 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) {
+        dubhe::deploy_hook::run(dapp_hub, ctx);
+    }
 
-    // Logic that needs to be automated once the contract is deployed
-    dubhe::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.
+        // ==========================================
+    }
 }

package/templates/contract/sui-template/src/dubhe/sources/codegen/init_test.move

@@ -1,18 +1,12 @@
-#[test_only]module dubhe::init_test {
-  use sui::clock;
-  use sui::test_scenario;
-  use sui::test_scenario::Scenario;
-  use dubhe::dapp_service::DappHub;
+#[test_only]
+
+module dubhe::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);
-    
-    dubhe::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)
   }
+
 }

package/templates/contract/sui-template/src/dubhe/sources/core/account_key.move

@@ -1,9 +1,7 @@
 module dubhe::account_key;
 
 use std::ascii::String;
-use std::bcs;
 use std::type_name;
-use sui::address;
 
 public struct AccountData has key, store { id: UID }
 
@@ -27,6 +25,6 @@ public struct AccountKey has copy, drop, store {
 public(package) fun new_account_key<DappKey: copy + drop>(address: String): AccountKey {
     AccountKey {
         address: address,
-        package_id: type_name::get<DappKey>().get_address(),
+        package_id: type_name::with_defining_ids<DappKey>().address_string(),
     }
 }