create-dubhe 1.2.0-pre.98 → 2.0.0

package/templates/nextjs/sui-card-duel/packages/contracts/src/card_duel/sources/codegen/enums/card_kind.move

@@ -0,0 +1,47 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::card_kind {
+    use sui::bcs::{BCS, to_bytes, peel_enum_tag};
+
+    public enum CardKind has copy, drop, store {
+        Fireball,Heal,None,Shield,Strike
+    }
+
+    public fun new_fireball(): CardKind {
+        CardKind::Fireball
+    }
+
+    public fun new_heal(): CardKind {
+        CardKind::Heal
+    }
+
+    public fun new_none(): CardKind {
+        CardKind::None
+    }
+
+    public fun new_shield(): CardKind {
+        CardKind::Shield
+    }
+
+    public fun new_strike(): CardKind {
+        CardKind::Strike
+    }
+
+    public fun encode(self: CardKind): vector<u8> {
+        to_bytes(&self)
+    }
+
+    public fun decode(bytes: &mut BCS): CardKind {
+        match(peel_enum_tag(bytes)) {
+            0 => CardKind::Fireball,
+            1 => CardKind::Heal,
+            2 => CardKind::None,
+            3 => CardKind::Shield,
+            4 => CardKind::Strike,
+            _ => abort,
+        }
+    }
+}

package/templates/nextjs/sui-card-duel/packages/contracts/src/card_duel/sources/codegen/enums/match_state.move

@@ -0,0 +1,37 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::match_state {
+    use sui::bcs::{BCS, to_bytes, peel_enum_tag};
+
+    public enum MatchState has copy, drop, store {
+        Active,Finished,Waiting
+    }
+
+    public fun new_active(): MatchState {
+        MatchState::Active
+    }
+
+    public fun new_finished(): MatchState {
+        MatchState::Finished
+    }
+
+    public fun new_waiting(): MatchState {
+        MatchState::Waiting
+    }
+
+    public fun encode(self: MatchState): vector<u8> {
+        to_bytes(&self)
+    }
+
+    public fun decode(bytes: &mut BCS): MatchState {
+        match(peel_enum_tag(bytes)) {
+            0 => MatchState::Active,
+            1 => MatchState::Finished,
+            2 => MatchState::Waiting,
+            _ => abort,
+        }
+    }
+}

package/templates/nextjs/sui-card-duel/packages/contracts/src/card_duel/sources/codegen/enums/rarity.move

@@ -0,0 +1,37 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::rarity {
+    use sui::bcs::{BCS, to_bytes, peel_enum_tag};
+
+    public enum Rarity has copy, drop, store {
+        Common,Epic,Rare
+    }
+
+    public fun new_common(): Rarity {
+        Rarity::Common
+    }
+
+    public fun new_epic(): Rarity {
+        Rarity::Epic
+    }
+
+    public fun new_rare(): Rarity {
+        Rarity::Rare
+    }
+
+    public fun encode(self: Rarity): vector<u8> {
+        to_bytes(&self)
+    }
+
+    public fun decode(bytes: &mut BCS): Rarity {
+        match(peel_enum_tag(bytes)) {
+            0 => Rarity::Common,
+            1 => Rarity::Epic,
+            2 => Rarity::Rare,
+            _ => abort,
+        }
+    }
+}

package/templates/nextjs/sui-card-duel/packages/contracts/src/card_duel/sources/codegen/error.move

@@ -0,0 +1,126 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::error {
+    #[error]
+    const EAlreadyRegistered: vector<u8> = b"Player already registered";
+    public fun already_registered(condition: bool) { assert!(condition, EAlreadyRegistered) }
+
+    #[error]
+    const ENotRegistered: vector<u8> = b"Player not registered";
+    public fun not_registered(condition: bool) { assert!(condition, ENotRegistered) }
+
+    #[error]
+    const EInsufficientGold: vector<u8> = b"Not enough gold";
+    public fun insufficient_gold(condition: bool) { assert!(condition, EInsufficientGold) }
+
+    #[error]
+    const ECardNotFound: vector<u8> = b"Card not owned";
+    public fun card_not_found(condition: bool) { assert!(condition, ECardNotFound) }
+
+    #[error]
+    const EInvalidCardKind: vector<u8> = b"Invalid card kind";
+    public fun invalid_card_kind(condition: bool) { assert!(condition, EInvalidCardKind) }
+
+    #[error]
+    const EDeckWrongSize: vector<u8> = b"Battle deck must contain exactly 5 cards";
+    public fun deck_wrong_size(condition: bool) { assert!(condition, EDeckWrongSize) }
+
+    #[error]
+    const EDeckDuplicateCard: vector<u8> = b"Battle deck contains duplicate cards";
+    public fun deck_duplicate_card(condition: bool) { assert!(condition, EDeckDuplicateCard) }
+
+    #[error]
+    const ECardNotInDeck: vector<u8> = b"Card is not in your battle deck";
+    public fun card_not_in_deck(condition: bool) { assert!(condition, ECardNotInDeck) }
+
+    #[error]
+    const ECardAlreadyUsed: vector<u8> = b"Card already used in this match";
+    public fun card_already_used(condition: bool) { assert!(condition, ECardAlreadyUsed) }
+
+    #[error]
+    const EAlreadyInMatch: vector<u8> = b"Already in an active match";
+    public fun already_in_match(condition: bool) { assert!(condition, EAlreadyInMatch) }
+
+    #[error]
+    const ENotInMatch: vector<u8> = b"Not in an active match";
+    public fun not_in_match(condition: bool) { assert!(condition, ENotInMatch) }
+
+    #[error]
+    const EWrongMatch: vector<u8> = b"Storage does not belong to this match";
+    public fun wrong_match(condition: bool) { assert!(condition, EWrongMatch) }
+
+    #[error]
+    const EMatchNotWaiting: vector<u8> = b"Match is not waiting for an opponent";
+    public fun match_not_waiting(condition: bool) { assert!(condition, EMatchNotWaiting) }
+
+    #[error]
+    const EMatchNotActive: vector<u8> = b"Match is not active";
+    public fun match_not_active(condition: bool) { assert!(condition, EMatchNotActive) }
+
+    #[error]
+    const EMatchNotFinished: vector<u8> = b"Match is not finished";
+    public fun match_not_finished(condition: bool) { assert!(condition, EMatchNotFinished) }
+
+    #[error]
+    const ENotMatchWinner: vector<u8> = b"Caller is not the winner of this match";
+    public fun not_match_winner(condition: bool) { assert!(condition, ENotMatchWinner) }
+
+    #[error]
+    const ENotYourTurn: vector<u8> = b"Not your turn";
+    public fun not_your_turn(condition: bool) { assert!(condition, ENotYourTurn) }
+
+    #[error]
+    const ENotInvited: vector<u8> = b"Caller is not the invited opponent";
+    public fun not_invited(condition: bool) { assert!(condition, ENotInvited) }
+
+    #[error]
+    const ENotChallenger: vector<u8> = b"Only the challenger can do this";
+    public fun not_challenger(condition: bool) { assert!(condition, ENotChallenger) }
+
+    #[error]
+    const ECannotPlaySelf: vector<u8> = b"Cannot start a match against yourself";
+    public fun cannot_play_self(condition: bool) { assert!(condition, ECannotPlaySelf) }
+
+    #[error]
+    const EInvalidStake: vector<u8> = b"Stake must be greater than zero";
+    public fun invalid_stake(condition: bool) { assert!(condition, EInvalidStake) }
+
+    #[error]
+    const ETurnNotTimedOut: vector<u8> = b"Current turn has not timed out yet";
+    public fun turn_not_timed_out(condition: bool) { assert!(condition, ETurnNotTimedOut) }
+
+    #[error]
+    const ETargetNotAlive: vector<u8> = b"Target is not alive in this brawl";
+    public fun target_not_alive(condition: bool) { assert!(condition, ETargetNotAlive) }
+
+    #[error]
+    const EBrawlNotHost: vector<u8> = b"Only the room host can do this";
+    public fun brawl_not_host(condition: bool) { assert!(condition, EBrawlNotHost) }
+
+    #[error]
+    const EBrawlFull: vector<u8> = b"Brawl room is full";
+    public fun brawl_full(condition: bool) { assert!(condition, EBrawlFull) }
+
+    #[error]
+    const EBrawlTooFewPlayers: vector<u8> = b"Need at least 2 players to start";
+    public fun brawl_too_few_players(condition: bool) { assert!(condition, EBrawlTooFewPlayers) }
+
+    #[error]
+    const EBrawlInvalidMaxPlayers: vector<u8> = b"Max players must be between 2 and 8";
+    public fun brawl_invalid_max_players(condition: bool) { assert!(condition, EBrawlInvalidMaxPlayers) }
+
+    #[error]
+    const EAlreadyJoined: vector<u8> = b"Already joined this brawl";
+    public fun already_joined(condition: bool) { assert!(condition, EAlreadyJoined) }
+
+    #[error]
+    const ENotInBrawl: vector<u8> = b"Caller has not joined this brawl";
+    public fun not_in_brawl(condition: bool) { assert!(condition, ENotInBrawl) }
+
+    #[error]
+    const EHostCannotLeave: vector<u8> = b"The host must cancel the room instead of leaving";
+    public fun host_cannot_leave(condition: bool) { assert!(condition, EHostCannotLeave) }
+}

package/templates/nextjs/sui-card-duel/packages/contracts/src/card_duel/sources/codegen/genesis.move

@@ -0,0 +1,33 @@
+#[allow(lint(share_owned))]
+module card_duel::genesis {
+    use sui::clock::Clock;
+    use dubhe::dapp_service::{DappHub, DappStorage};
+    use card_duel::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"card_duel"), string(b"Card Duel - Full-chain PvP card battle game (1v1 duels + multiplayer brawls)"), 1, clock, ctx);
+
+        // Set up initial DApp state (e.g. default resource values).
+        card_duel::deploy_hook::run(&mut ds, ctx);
+
+        // Share DappStorage so every transaction can access it.
+        transfer::public_share_object(ds);
+    }
+
+    // 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.
+        // ==========================================
+    }
+}

package/templates/nextjs/sui-card-duel/packages/contracts/src/card_duel/sources/codegen/init_test.move

@@ -0,0 +1,23 @@
+#[test_only]
+
+module card_duel::init_test {
+  use dubhe::dapp_system;
+
+  /// 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)
+  }
+
+  /// 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<card_duel::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<card_duel::dapp_key::DappKey>(owner, ctx)
+  }
+}

package/templates/nextjs/sui-card-duel/packages/contracts/src/card_duel/sources/codegen/objects/arena.move

@@ -0,0 +1,137 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::arena {
+    use dubhe::dapp_service::DappStorage;
+    use card_duel::dapp_key;
+    use card_duel::dapp_key::DappKey;
+    use std::ascii::String;
+    use card_duel::duel;
+    use card_duel::brawl;
+
+    // ─── Error constants ───────────────────────────────────────────────────
+    #[error]
+    const EInsufficientAmount: vector<u8> = b"Insufficient amount";
+    #[error]
+    const EWrongEntityId: vector<u8> = b"Wrong entity id";
+    #[error]
+    const ENoPermission: vector<u8> = b"Caller does not have permission";
+
+    const TYPE_TAG: vector<u8> = b"arena";
+
+    // ─── Phantom marker type ───────────────────────────────────────────────
+    /// Phantom type that distinguishes ArenaStorage from other ObjectStorage types
+    /// at the Move compiler level, preserving compile-time type safety.
+    /// All functions use ObjectStorage<Arena> directly in their signatures.
+    public struct Arena has copy, drop {}
+
+    // ─── ID / entity accessors ─────────────────────────────────────────────
+
+    public fun entity_id(storage: &dubhe::dapp_service::ObjectStorage<Arena>): vector<u8> {
+        *dubhe::dapp_service::object_storage_entity_id(storage)
+    }
+
+
+    public fun assert_arena_id(storage: &dubhe::dapp_service::ObjectStorage<Arena>, expected: vector<u8>) {
+        assert!(*dubhe::dapp_service::object_storage_entity_id(storage) == expected, EWrongEntityId);
+    }
+
+    // ─── Field accessors (own fields) ──────────────────────────────────────
+
+    public fun get_name(storage: &dubhe::dapp_service::ObjectStorage<Arena>): String {
+        dubhe::dapp_system::get_object_field<Arena, String>(storage, b"name")
+    }
+
+    public(package) fun set_name(storage: &mut dubhe::dapp_service::ObjectStorage<Arena>, value: String) {
+        dubhe::dapp_system::set_object_field<DappKey, Arena, String>(
+            dapp_key::new(), storage, b"name", value
+        );
+    }
+
+    public fun get_season(storage: &dubhe::dapp_service::ObjectStorage<Arena>): u8 {
+        dubhe::dapp_system::get_object_field<Arena, u8>(storage, b"season")
+    }
+
+    public(package) fun set_season(storage: &mut dubhe::dapp_service::ObjectStorage<Arena>, value: u8) {
+        dubhe::dapp_system::set_object_field<DappKey, Arena, u8>(
+            dapp_key::new(), storage, b"season", value
+        );
+    }
+
+    // ─── Bag accessors for accepted resources ─────────────────────────────
+
+    public fun get_gold(storage: &dubhe::dapp_service::ObjectStorage<Arena>): u64 {
+        if (dubhe::dapp_system::has_object_field<Arena, u64>(storage, b"gold")) {
+            dubhe::dapp_system::get_object_field<Arena, u64>(storage, b"gold")
+        } else { 0 }
+    }
+
+    public(package) fun add_gold(storage: &mut dubhe::dapp_service::ObjectStorage<Arena>, amount: u64) {
+        let current = get_gold(storage);
+        dubhe::dapp_system::set_object_field<DappKey, Arena, u64>(
+            dapp_key::new(), storage, b"gold", current + amount
+        );
+    }
+
+    public(package) fun sub_gold(storage: &mut dubhe::dapp_service::ObjectStorage<Arena>, amount: u64) {
+        let current = get_gold(storage);
+        assert!(current >= amount, EInsufficientAmount);
+        dubhe::dapp_system::set_object_field<DappKey, Arena, u64>(
+            dapp_key::new(), storage, b"gold", current - amount
+        );
+    }
+
+    // ─── acceptsFrom: cross-storage transfer functions ─────────────────────
+
+    /// Transfer gold (fungible) from duel into this arena.
+    public(package) fun transfer_duel_to_arena_gold(
+        source_permit: &dubhe::dapp_service::ScenePermit<card_duel::duel_permit::DuelPermit>,
+        from:   &mut dubhe::dapp_service::SceneStorage<card_duel::duel::Duel>,
+        to:     &mut dubhe::dapp_service::ObjectStorage<Arena>,
+        user_storage: &dubhe::dapp_service::UserStorage,
+        amount: u64,
+        ctx:        &TxContext,
+
+    ) {
+        duel::sub_gold(source_permit, from, user_storage, amount, ctx);
+        add_gold(to, amount);
+    }
+
+    /// Transfer gold (fungible) from brawl into this arena.
+    public(package) fun transfer_brawl_to_arena_gold(
+        source_permit: &dubhe::dapp_service::ScenePermit<card_duel::brawl_permit::BrawlPermit>,
+        from:   &mut dubhe::dapp_service::SceneStorage<card_duel::brawl::Brawl>,
+        to:     &mut dubhe::dapp_service::ObjectStorage<Arena>,
+        user_storage: &dubhe::dapp_service::UserStorage,
+        amount: u64,
+        ctx:        &TxContext,
+
+    ) {
+        brawl::sub_gold(source_permit, from, user_storage, amount, ctx);
+        add_gold(to, amount);
+    }
+
+    // ─── Lifecycle entry functions ─────────────────────────────────────────
+    public(package) fun create_arena(
+        dapp_storage: &mut DappStorage,
+        entity_id:    vector<u8>,
+        ctx:          &mut TxContext,
+    ) {
+        assert!(ctx.sender() == dubhe::dapp_service::dapp_admin(dapp_storage), ENoPermission);
+        dubhe::dapp_system::create_and_share_typed_object<DappKey, Arena>(
+            dapp_key::new(), dapp_storage, TYPE_TAG, entity_id, ctx
+        );
+    }
+
+    public(package) fun destroy_arena(
+        dapp_storage: &mut DappStorage,
+        storage:      dubhe::dapp_service::ObjectStorage<Arena>,
+        _ctx:         &TxContext,
+    ) {
+        dubhe::dapp_system::destroy_typed_object<DappKey, Arena>(
+            dapp_key::new(), dapp_storage, storage
+        );
+    }
+}

package/templates/nextjs/sui-card-duel/packages/contracts/src/card_duel/sources/codegen/permits/brawl_permit.move

@@ -0,0 +1,125 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::brawl_permit {
+    use dubhe::dapp_service::{Self, DappStorage};
+    use card_duel::dapp_key;
+    use card_duel::dapp_key::DappKey;
+
+    const PERMIT_TYPE: vector<u8> = b"brawl_permit";
+
+    #[error]
+    const EPermitNotExpiredYet: vector<u8> = b"Scene permit is still active";
+
+    /// Phantom type that distinguishes this permit from others at compile time.
+    public struct BrawlPermit has copy, drop {}
+
+    public fun meta(permit: &dubhe::dapp_service::ScenePermit<BrawlPermit>): &dubhe::dapp_service::PermitMetadata {
+        dapp_service::scene_permit_meta(permit)
+    }
+
+    public fun is_active(permit: &dubhe::dapp_service::ScenePermit<BrawlPermit>, now_ms: u64): bool {
+        dapp_service::is_scene_active(dapp_service::scene_permit_meta(permit), now_ms)
+    }
+
+    public fun is_participant(permit: &dubhe::dapp_service::ScenePermit<BrawlPermit>, addr: address): bool {
+        dubhe::dapp_system::is_scene_permit_participant<BrawlPermit>(permit, addr)
+    }
+
+    public(package) fun new_brawl_permit(
+        dapp_storage:     &DappStorage,
+        participants:     vector<address>,
+        expires_at:       std::option::Option<u64>,
+        max_participants: std::option::Option<u64>,
+        ctx:              &mut TxContext,
+    ): dubhe::dapp_service::ScenePermit<BrawlPermit> {
+        dubhe::dapp_system::new_scene_permit<DappKey, BrawlPermit>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, participants, expires_at, max_participants, ctx
+        )
+    }
+
+    public(package) fun new_brawl_permit_with_invitations(
+        dapp_storage:      &DappStorage,
+        invitees:          vector<address>,
+        invites_expire_at: std::option::Option<u64>,
+        scene_expires_at:  std::option::Option<u64>,
+        max_participants:  std::option::Option<u64>,
+        ctx:               &mut TxContext,
+    ): dubhe::dapp_service::ScenePermit<BrawlPermit> {
+        dubhe::dapp_system::new_scene_permit_with_invitations<DappKey, BrawlPermit>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, invitees, invites_expire_at, scene_expires_at, max_participants, ctx
+        )
+    }
+
+    public(package) fun share_brawl_permit(permit: dubhe::dapp_service::ScenePermit<BrawlPermit>) {
+        dubhe::dapp_system::share_scene_permit<DappKey, BrawlPermit>(
+            dapp_key::new(), permit
+        );
+    }
+
+    public(package) fun create_brawl_permit(
+        dapp_storage:     &DappStorage,
+        participants:     vector<address>,
+        expires_at:       std::option::Option<u64>,
+        max_participants: std::option::Option<u64>,
+        ctx:              &mut TxContext,
+    ) {
+        dubhe::dapp_system::create_and_share_scene_permit<DappKey, BrawlPermit>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, participants, expires_at, max_participants, ctx
+        );
+    }
+
+    public(package) fun create_brawl_permit_with_invitations(
+        dapp_storage:      &DappStorage,
+        invitees:          vector<address>,
+        invites_expire_at: std::option::Option<u64>,
+        scene_expires_at:  std::option::Option<u64>,
+        max_participants:  std::option::Option<u64>,
+        ctx:               &mut TxContext,
+    ) {
+        dubhe::dapp_system::create_and_share_scene_permit_with_invitations<DappKey, BrawlPermit>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, invitees, invites_expire_at, scene_expires_at, max_participants, ctx
+        );
+    }
+
+    public(package) fun accept_brawl_permit(
+        permit:       &mut dubhe::dapp_service::ScenePermit<BrawlPermit>,
+        user_storage: &dubhe::dapp_service::UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::accept_scene_permit_invitation<DappKey, BrawlPermit>(
+            dapp_key::new(), permit, user_storage, ctx
+        );
+    }
+
+    public(package) fun join_brawl_permit(
+        permit:       &mut dubhe::dapp_service::ScenePermit<BrawlPermit>,
+        user_storage: &dubhe::dapp_service::UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::join_scene_permit<DappKey, BrawlPermit>(dapp_key::new(), permit, user_storage, ctx);
+    }
+
+    public(package) fun leave_brawl_permit(
+        permit:       &mut dubhe::dapp_service::ScenePermit<BrawlPermit>,
+        user_storage: &dubhe::dapp_service::UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::leave_scene_permit<DappKey, BrawlPermit>(dapp_key::new(), permit, user_storage, ctx);
+    }
+
+    public(package) fun expire_brawl_permit(
+        permit: dubhe::dapp_service::ScenePermit<BrawlPermit>,
+        ctx:    &TxContext,
+    ) {
+        assert!(
+            !dapp_service::is_scene_active(dapp_service::scene_permit_meta(&permit), ctx.epoch_timestamp_ms()),
+            EPermitNotExpiredYet
+        );
+        dubhe::dapp_system::destroy_scene_permit<DappKey, BrawlPermit>(
+            dapp_key::new(), permit
+        );
+    }
+}