create-dubhe 1.2.0-pre.98 → 2.0.0

package/templates/nextjs/sui-template/packages/contracts/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/nextjs/sui-template/packages/contracts/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/nextjs/sui-template/packages/contracts/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/nextjs/sui-template/packages/contracts/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/nextjs/sui-template/packages/contracts/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(),
     }
 }