create-dubhe 1.2.0-pre.99 → 2.0.0

package/templates/nextjs/sui-card-duel/packages/contracts/src/card_duel/sources/codegen/permits/duel_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::duel_permit {
+    use dubhe::dapp_service::{Self, DappStorage};
+    use card_duel::dapp_key;
+    use card_duel::dapp_key::DappKey;
+
+    const PERMIT_TYPE: vector<u8> = b"duel_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 DuelPermit has copy, drop {}
+
+    public fun meta(permit: &dubhe::dapp_service::ScenePermit<DuelPermit>): &dubhe::dapp_service::PermitMetadata {
+        dapp_service::scene_permit_meta(permit)
+    }
+
+    public fun is_active(permit: &dubhe::dapp_service::ScenePermit<DuelPermit>, 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<DuelPermit>, addr: address): bool {
+        dubhe::dapp_system::is_scene_permit_participant<DuelPermit>(permit, addr)
+    }
+
+    public(package) fun new_duel_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<DuelPermit> {
+        dubhe::dapp_system::new_scene_permit<DappKey, DuelPermit>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, participants, expires_at, max_participants, ctx
+        )
+    }
+
+    public(package) fun new_duel_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<DuelPermit> {
+        dubhe::dapp_system::new_scene_permit_with_invitations<DappKey, DuelPermit>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, invitees, invites_expire_at, scene_expires_at, max_participants, ctx
+        )
+    }
+
+    public(package) fun share_duel_permit(permit: dubhe::dapp_service::ScenePermit<DuelPermit>) {
+        dubhe::dapp_system::share_scene_permit<DappKey, DuelPermit>(
+            dapp_key::new(), permit
+        );
+    }
+
+    public(package) fun create_duel_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, DuelPermit>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, participants, expires_at, max_participants, ctx
+        );
+    }
+
+    public(package) fun create_duel_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, DuelPermit>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, invitees, invites_expire_at, scene_expires_at, max_participants, ctx
+        );
+    }
+
+    public(package) fun accept_duel_permit(
+        permit:       &mut dubhe::dapp_service::ScenePermit<DuelPermit>,
+        user_storage: &dubhe::dapp_service::UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::accept_scene_permit_invitation<DappKey, DuelPermit>(
+            dapp_key::new(), permit, user_storage, ctx
+        );
+    }
+
+    public(package) fun join_duel_permit(
+        permit:       &mut dubhe::dapp_service::ScenePermit<DuelPermit>,
+        user_storage: &dubhe::dapp_service::UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::join_scene_permit<DappKey, DuelPermit>(dapp_key::new(), permit, user_storage, ctx);
+    }
+
+    public(package) fun leave_duel_permit(
+        permit:       &mut dubhe::dapp_service::ScenePermit<DuelPermit>,
+        user_storage: &dubhe::dapp_service::UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::leave_scene_permit<DappKey, DuelPermit>(dapp_key::new(), permit, user_storage, ctx);
+    }
+
+    public(package) fun expire_duel_permit(
+        permit: dubhe::dapp_service::ScenePermit<DuelPermit>,
+        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, DuelPermit>(
+            dapp_key::new(), permit
+        );
+    }
+}

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

@@ -0,0 +1,255 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::battle_state {
+    use sui::bcs::{to_bytes};
+    use dubhe::dapp_service::UserStorage;
+    use dubhe::dapp_service::ScenePermit;
+    use dubhe::dapp_system;
+    use card_duel::dapp_key;
+    use card_duel::dapp_key::DappKey;
+
+
+    const TABLE_NAME: vector<u8> = b"battle_state";
+    const OFFCHAIN: bool = false;
+
+    public struct BattleState has copy, drop, store {
+        match_id: address,
+        hp: u64,
+        shield: u64,
+    }
+
+    public fun new(match_id: address, hp: u64, shield: u64): BattleState {
+        BattleState {
+            match_id,
+            hp,
+            shield,
+        }
+    }
+
+    public fun match_id(self: &BattleState): address {
+        self.match_id
+    }
+
+    public fun hp(self: &BattleState): u64 {
+        self.hp
+    }
+
+    public fun shield(self: &BattleState): u64 {
+        self.shield
+    }
+
+    public fun update_match_id(self: &mut BattleState, match_id: address) {
+        self.match_id = match_id
+    }
+
+    public fun update_hp(self: &mut BattleState, hp: u64) {
+        self.hp = hp
+    }
+
+    public fun update_shield(self: &mut BattleState, shield: u64) {
+        self.shield = shield
+    }
+
+    public fun has(user_storage: &UserStorage): bool {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        dapp_system::has_record<DappKey>(user_storage, key_tuple)
+    }
+
+    public fun ensure_has(user_storage: &UserStorage) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        dapp_system::ensure_has_record<DappKey>(user_storage, key_tuple)
+    }
+
+    public fun ensure_has_not(user_storage: &UserStorage) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        dapp_system::ensure_has_not_record<DappKey>(user_storage, key_tuple)
+    }
+  
+
+    public(package) fun delete(user_storage: &mut UserStorage, ctx: &TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        dapp_system::delete_record<DappKey>(dapp_key::new(), user_storage, key_tuple, vector[b"match_id", b"hp", b"shield"], ctx);
+    }
+
+    public fun get_match_id(user_storage: &UserStorage): address {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let match_id_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"match_id");
+        let mut match_id_bcs = sui::bcs::new(match_id_raw);
+        let match_id = sui::bcs::peel_address(&mut match_id_bcs);
+        match_id
+    }
+
+    public(package) fun set_match_id(user_storage: &mut UserStorage, match_id: address, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&match_id);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"match_id", value, ctx);
+    }
+
+    public fun get_hp(user_storage: &UserStorage): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let hp_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"hp");
+        let mut hp_bcs = sui::bcs::new(hp_raw);
+        let hp = sui::bcs::peel_u64(&mut hp_bcs);
+        hp
+    }
+
+    public(package) fun set_hp(user_storage: &mut UserStorage, hp: u64, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&hp);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"hp", value, ctx);
+    }
+
+    public fun get_shield(user_storage: &UserStorage): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let shield_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"shield");
+        let mut shield_bcs = sui::bcs::new(shield_raw);
+        let shield = sui::bcs::peel_u64(&mut shield_bcs);
+        shield
+    }
+
+    public(package) fun set_shield(user_storage: &mut UserStorage, shield: u64, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&shield);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"shield", value, ctx);
+    }
+
+    public fun get(user_storage: &UserStorage): (address, u64, u64) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let match_id_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"match_id");
+        let mut match_id_bcs = sui::bcs::new(match_id_raw);
+        let match_id = sui::bcs::peel_address(&mut match_id_bcs);
+        let hp_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"hp");
+        let mut hp_bcs = sui::bcs::new(hp_raw);
+        let hp = sui::bcs::peel_u64(&mut hp_bcs);
+        let shield_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"shield");
+        let mut shield_bcs = sui::bcs::new(shield_raw);
+        let shield = sui::bcs::peel_u64(&mut shield_bcs);
+        (match_id, hp, shield)
+    }
+
+    public(package) fun set(user_storage: &mut UserStorage, match_id: address, hp: u64, shield: u64, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"match_id", b"hp", b"shield"];
+        let value_tuple = encode(match_id, hp, shield);
+        dapp_system::set_record<DappKey>(dapp_key::new(), user_storage, key_tuple, field_names, value_tuple, OFFCHAIN, ctx);
+    }
+
+    public fun get_struct(user_storage: &UserStorage): BattleState {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let match_id_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"match_id");
+        let mut match_id_bcs = sui::bcs::new(match_id_raw);
+        let match_id = sui::bcs::peel_address(&mut match_id_bcs);
+        let hp_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"hp");
+        let mut hp_bcs = sui::bcs::new(hp_raw);
+        let hp = sui::bcs::peel_u64(&mut hp_bcs);
+        let shield_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"shield");
+        let mut shield_bcs = sui::bcs::new(shield_raw);
+        let shield = sui::bcs::peel_u64(&mut shield_bcs);
+        BattleState { match_id, hp, shield }
+    }
+
+    public(package) fun set_struct(user_storage: &mut UserStorage, battle_state: BattleState, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"match_id", b"hp", b"shield"];
+        let value_tuple = encode_struct(battle_state);
+        dapp_system::set_record<DappKey>(dapp_key::new(), user_storage, key_tuple, field_names, value_tuple, OFFCHAIN, ctx);
+    }
+
+    public fun encode(match_id: address, hp: u64, shield: u64): vector<vector<u8>> {
+        let mut value_tuple = vector::empty();
+        value_tuple.push_back(to_bytes(&match_id));
+        value_tuple.push_back(to_bytes(&hp));
+        value_tuple.push_back(to_bytes(&shield));
+        value_tuple
+    }
+
+    public fun encode_struct(battle_state: BattleState): vector<vector<u8>> {
+        encode(battle_state.match_id, battle_state.hp, battle_state.shield)
+    }
+
+    public fun decode(data: vector<u8>): BattleState {
+        let mut bcs_type = sui::bcs::new(data);
+        let match_id = sui::bcs::peel_address(&mut bcs_type);
+        let hp = sui::bcs::peel_u64(&mut bcs_type);
+        let shield = sui::bcs::peel_u64(&mut bcs_type);
+        BattleState {
+            match_id,
+            hp,
+            shield,
+        }
+    }
+
+
+    // ─── reactive: cross-user write variants ───────────────────────────
+    // Package-level helpers: add pause checks and access control in your system
+    // functions before calling these.
+    public(package) fun set_reactive<PermType>(
+        permit: &ScenePermit<PermType>,
+        from:   &mut UserStorage,
+        target: &mut UserStorage,
+        match_id: address, hp: u64, shield: u64,
+        ctx:    &mut TxContext,
+    ) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"match_id", b"hp", b"shield"];
+        let value_tuple = encode(match_id, hp, shield);
+        dapp_system::set_record_reactive<DappKey, PermType>(dapp_key::new(), permit, from, target, key_tuple, field_names, value_tuple, ctx);
+    }
+
+    public(package) fun set_match_id_reactive<PermType>(
+        permit: &ScenePermit<PermType>,
+        from:   &mut UserStorage,
+        target: &mut UserStorage,
+        match_id: address,
+        ctx:    &mut TxContext,
+    ) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = sui::bcs::to_bytes(&match_id);
+        dapp_system::set_field_reactive<DappKey, PermType>(dapp_key::new(), permit, from, target, key_tuple, b"match_id", value, ctx);
+    }
+
+    public(package) fun set_hp_reactive<PermType>(
+        permit: &ScenePermit<PermType>,
+        from:   &mut UserStorage,
+        target: &mut UserStorage,
+        hp: u64,
+        ctx:    &mut TxContext,
+    ) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = sui::bcs::to_bytes(&hp);
+        dapp_system::set_field_reactive<DappKey, PermType>(dapp_key::new(), permit, from, target, key_tuple, b"hp", value, ctx);
+    }
+
+    public(package) fun set_shield_reactive<PermType>(
+        permit: &ScenePermit<PermType>,
+        from:   &mut UserStorage,
+        target: &mut UserStorage,
+        shield: u64,
+        ctx:    &mut TxContext,
+    ) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = sui::bcs::to_bytes(&shield);
+        dapp_system::set_field_reactive<DappKey, PermType>(dapp_key::new(), permit, from, target, key_tuple, b"shield", value, ctx);
+    }
+}

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

@@ -0,0 +1,282 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::card {
+    use sui::bcs::{to_bytes};
+    use dubhe::dapp_service::{UserStorage, DappStorage};
+    use dubhe::dapp_system;
+    use card_duel::dapp_key;
+    use card_duel::dapp_key::DappKey;
+
+
+    const TABLE_NAME: vector<u8> = b"card";
+    const OFFCHAIN: bool = false;
+
+    public struct Card has copy, drop, store {
+        kind: u8,
+        power: u32,
+        rarity: u8,
+    }
+
+    public fun new(kind: u8, power: u32, rarity: u8): Card {
+        Card {
+            kind,
+            power,
+            rarity,
+        }
+    }
+
+    public fun kind(self: &Card): u8 {
+        self.kind
+    }
+
+    public fun power(self: &Card): u32 {
+        self.power
+    }
+
+    public fun rarity(self: &Card): u8 {
+        self.rarity
+    }
+
+    public fun update_kind(self: &mut Card, kind: u8) {
+        self.kind = kind
+    }
+
+    public fun update_power(self: &mut Card, power: u32) {
+        self.power = power
+    }
+
+    public fun update_rarity(self: &mut Card, rarity: u8) {
+        self.rarity = rarity
+    }
+
+    public fun has(user_storage: &UserStorage, card_id: address): bool {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        dapp_system::has_record<DappKey>(user_storage, key_tuple)
+    }
+
+    public fun ensure_has(user_storage: &UserStorage, card_id: address) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        dapp_system::ensure_has_record<DappKey>(user_storage, key_tuple)
+    }
+
+    public fun ensure_has_not(user_storage: &UserStorage, card_id: address) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        dapp_system::ensure_has_not_record<DappKey>(user_storage, key_tuple)
+    }
+  
+
+    public(package) fun delete(user_storage: &mut UserStorage, card_id: address, ctx: &TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        dapp_system::delete_record<DappKey>(dapp_key::new(), user_storage, key_tuple, vector[b"kind", b"power", b"rarity"], ctx);
+    }
+
+    public fun get_kind(user_storage: &UserStorage, card_id: address): u8 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let kind_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"kind");
+        let mut kind_bcs = sui::bcs::new(kind_raw);
+        let kind = sui::bcs::peel_u8(&mut kind_bcs);
+        kind
+    }
+
+    public(package) fun set_kind(user_storage: &mut UserStorage, card_id: address, kind: u8, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let value = to_bytes(&kind);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"kind", value, ctx);
+    }
+
+    public fun get_power(user_storage: &UserStorage, card_id: address): u32 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let power_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"power");
+        let mut power_bcs = sui::bcs::new(power_raw);
+        let power = sui::bcs::peel_u32(&mut power_bcs);
+        power
+    }
+
+    public(package) fun set_power(user_storage: &mut UserStorage, card_id: address, power: u32, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let value = to_bytes(&power);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"power", value, ctx);
+    }
+
+    public fun get_rarity(user_storage: &UserStorage, card_id: address): u8 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let rarity_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"rarity");
+        let mut rarity_bcs = sui::bcs::new(rarity_raw);
+        let rarity = sui::bcs::peel_u8(&mut rarity_bcs);
+        rarity
+    }
+
+    public(package) fun set_rarity(user_storage: &mut UserStorage, card_id: address, rarity: u8, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let value = to_bytes(&rarity);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"rarity", value, ctx);
+    }
+
+    public fun get(user_storage: &UserStorage, card_id: address): (u8, u32, u8) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let kind_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"kind");
+        let mut kind_bcs = sui::bcs::new(kind_raw);
+        let kind = sui::bcs::peel_u8(&mut kind_bcs);
+        let power_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"power");
+        let mut power_bcs = sui::bcs::new(power_raw);
+        let power = sui::bcs::peel_u32(&mut power_bcs);
+        let rarity_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"rarity");
+        let mut rarity_bcs = sui::bcs::new(rarity_raw);
+        let rarity = sui::bcs::peel_u8(&mut rarity_bcs);
+        (kind, power, rarity)
+    }
+
+    public(package) fun set(user_storage: &mut UserStorage, card_id: address, kind: u8, power: u32, rarity: u8, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let field_names = vector[b"kind", b"power", b"rarity"];
+        let value_tuple = encode(kind, power, rarity);
+        dapp_system::set_record<DappKey>(dapp_key::new(), user_storage, key_tuple, field_names, value_tuple, OFFCHAIN, ctx);
+    }
+
+    public fun get_struct(user_storage: &UserStorage, card_id: address): Card {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let kind_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"kind");
+        let mut kind_bcs = sui::bcs::new(kind_raw);
+        let kind = sui::bcs::peel_u8(&mut kind_bcs);
+        let power_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"power");
+        let mut power_bcs = sui::bcs::new(power_raw);
+        let power = sui::bcs::peel_u32(&mut power_bcs);
+        let rarity_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"rarity");
+        let mut rarity_bcs = sui::bcs::new(rarity_raw);
+        let rarity = sui::bcs::peel_u8(&mut rarity_bcs);
+        Card { kind, power, rarity }
+    }
+
+    public(package) fun set_struct(user_storage: &mut UserStorage, card_id: address, card: Card, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&card_id));
+        let field_names = vector[b"kind", b"power", b"rarity"];
+        let value_tuple = encode_struct(card);
+        dapp_system::set_record<DappKey>(dapp_key::new(), user_storage, key_tuple, field_names, value_tuple, OFFCHAIN, ctx);
+    }
+
+    public fun encode(kind: u8, power: u32, rarity: u8): vector<vector<u8>> {
+        let mut value_tuple = vector::empty();
+        value_tuple.push_back(to_bytes(&kind));
+        value_tuple.push_back(to_bytes(&power));
+        value_tuple.push_back(to_bytes(&rarity));
+        value_tuple
+    }
+
+    public fun encode_struct(card: Card): vector<vector<u8>> {
+        encode(card.kind, card.power, card.rarity)
+    }
+
+    public fun decode(data: vector<u8>): Card {
+        let mut bcs_type = sui::bcs::new(data);
+        let kind = sui::bcs::peel_u8(&mut bcs_type);
+        let power = sui::bcs::peel_u32(&mut bcs_type);
+        let rarity = sui::bcs::peel_u8(&mut bcs_type);
+        Card {
+            kind,
+            power,
+            rarity,
+        }
+    }
+
+
+    // ─── keys: mint (developer provides keys; framework ensures no duplicate) ─
+    // Choosing the ID strategy (fresh address, counter, coordinate pack, etc.)
+    // is intentionally left to the caller.
+    public(package) fun mint(
+        user_storage: &mut UserStorage,
+        card_id: address, kind: u8, power: u32, rarity: u8,
+        ctx: &mut TxContext,
+    ) {
+        ensure_has_not(user_storage, card_id);
+        set(user_storage, card_id, kind, power, rarity, ctx);
+    }
+
+    // ─── listable: market protocol (keyed) ──────────────────────────────
+    // Package-level helpers: call these from your system functions.
+    // Add pause checks, access control, and custom logic there.
+    public(package) fun list<CoinType>(
+        user_storage: &mut UserStorage,
+        card_id:   address,
+        price:        u64,
+        listed_until: std::option::Option<u64>,
+        ctx:          &mut TxContext,
+    ) {
+        let mut record_key = vector::empty();
+        record_key.push_back(TABLE_NAME);
+        record_key.push_back(sui::bcs::to_bytes(&card_id));
+        dubhe::dapp_system::take_record<DappKey, CoinType>(
+            dapp_key::new(),
+            user_storage,
+            b"card",
+            record_key,
+            vector[b"kind", b"power", b"rarity"],
+            price,
+            listed_until,
+            ctx,
+        );
+    }
+
+    public(package) fun buy<CoinType>(
+        dh:            &dubhe::dapp_service::DappHub,
+        dapp_storage:  &mut DappStorage,
+        listing:       dubhe::dapp_service::Listing<CoinType>,
+        user_storage:  &mut UserStorage,
+        payment:       sui::coin::Coin<CoinType>,
+        ctx:           &mut TxContext,
+    ): sui::coin::Coin<CoinType> {
+        dubhe::dapp_system::buy_record<DappKey, CoinType>(
+            dapp_key::new(), dh, dapp_storage, listing, user_storage, payment, ctx
+        )
+    }
+
+    public(package) fun cancel_listing<CoinType>(
+        listing:      dubhe::dapp_service::Listing<CoinType>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::restore_record<DappKey, CoinType>(
+            dapp_key::new(), listing, user_storage, ctx
+        );
+    }
+
+    public(package) fun expire_listing<CoinType>(
+        listing:      dubhe::dapp_service::Listing<CoinType>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::expire_listing<DappKey, CoinType>(
+            dapp_key::new(), listing, user_storage, ctx
+        );
+    }
+}