create-dubhe 1.2.0-pre.98 → 2.0.0

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

@@ -0,0 +1,64 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::deck {
+    use sui::bcs::{to_bytes};
+    use dubhe::dapp_service::UserStorage;
+    use dubhe::dapp_system;
+    use card_duel::dapp_key;
+    use card_duel::dapp_key::DappKey;
+
+
+    const TABLE_NAME: vector<u8> = b"deck";
+    const OFFCHAIN: bool = false;
+
+    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"card_ids"], ctx);
+    }
+
+    public fun get(user_storage: &UserStorage): vector<address> {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let card_ids_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"card_ids");
+        let mut card_ids_bcs = sui::bcs::new(card_ids_raw);
+        let value = sui::bcs::peel_vec_address(&mut card_ids_bcs);
+        value
+    }
+
+    public(package) fun set(user_storage: &mut UserStorage, value: vector<address>, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"card_ids"];
+        let value_tuple = encode(value);
+        dapp_system::set_record<DappKey>(dapp_key::new(), user_storage, key_tuple, field_names, value_tuple, OFFCHAIN, ctx);
+    }
+
+    public fun encode(value: vector<address>): vector<vector<u8>> {
+        let mut value_tuple = vector::empty();
+        value_tuple.push_back(to_bytes(&value));
+        value_tuple
+    }
+}

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

@@ -0,0 +1,267 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::game_config {
+    use sui::bcs::{to_bytes};
+    use dubhe::dapp_service::DappStorage;
+    use dubhe::dapp_system;
+    use card_duel::dapp_key;
+    use card_duel::dapp_key::DappKey;
+
+
+    const TABLE_NAME: vector<u8> = b"game_config";
+    const OFFCHAIN: bool = false;
+
+    public struct GameConfig has copy, drop, store {
+        pack_price: u64,
+        starting_gold: u64,
+        rake_bps: u64,
+        max_hp: u64,
+        turn_timeout_ms: u64,
+    }
+
+    public fun new(pack_price: u64, starting_gold: u64, rake_bps: u64, max_hp: u64, turn_timeout_ms: u64): GameConfig {
+        GameConfig {
+            pack_price,
+            starting_gold,
+            rake_bps,
+            max_hp,
+            turn_timeout_ms,
+        }
+    }
+
+    public fun pack_price(self: &GameConfig): u64 {
+        self.pack_price
+    }
+
+    public fun starting_gold(self: &GameConfig): u64 {
+        self.starting_gold
+    }
+
+    public fun rake_bps(self: &GameConfig): u64 {
+        self.rake_bps
+    }
+
+    public fun max_hp(self: &GameConfig): u64 {
+        self.max_hp
+    }
+
+    public fun turn_timeout_ms(self: &GameConfig): u64 {
+        self.turn_timeout_ms
+    }
+
+    public fun update_pack_price(self: &mut GameConfig, pack_price: u64) {
+        self.pack_price = pack_price
+    }
+
+    public fun update_starting_gold(self: &mut GameConfig, starting_gold: u64) {
+        self.starting_gold = starting_gold
+    }
+
+    public fun update_rake_bps(self: &mut GameConfig, rake_bps: u64) {
+        self.rake_bps = rake_bps
+    }
+
+    public fun update_max_hp(self: &mut GameConfig, max_hp: u64) {
+        self.max_hp = max_hp
+    }
+
+    public fun update_turn_timeout_ms(self: &mut GameConfig, turn_timeout_ms: u64) {
+        self.turn_timeout_ms = turn_timeout_ms
+    }
+
+    public fun has(dapp_storage: &DappStorage): bool {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        dapp_system::has_global_record<DappKey>(dapp_storage, key_tuple)
+    }
+
+    public fun ensure_has(dapp_storage: &DappStorage) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        dapp_system::ensure_has_global_record<DappKey>(dapp_storage, key_tuple)
+    }
+
+    public fun ensure_has_not(dapp_storage: &DappStorage) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        dapp_system::ensure_has_not_global_record<DappKey>(dapp_storage, key_tuple)
+    }
+  
+
+    public(package) fun delete(dapp_storage: &mut DappStorage) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        dapp_system::delete_global_record<DappKey>(dapp_key::new(), dapp_storage, key_tuple, vector[b"pack_price", b"starting_gold", b"rake_bps", b"max_hp", b"turn_timeout_ms"]);
+    }
+
+    public fun get_pack_price(dapp_storage: &DappStorage): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let pack_price_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"pack_price");
+        let mut pack_price_bcs = sui::bcs::new(pack_price_raw);
+        let pack_price = sui::bcs::peel_u64(&mut pack_price_bcs);
+        pack_price
+    }
+
+    public(package) fun set_pack_price(dapp_storage: &mut DappStorage, pack_price: u64) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&pack_price);
+        dapp_system::set_global_field<DappKey>(dapp_key::new(), dapp_storage, key_tuple, b"pack_price", value);
+    }
+
+    public fun get_starting_gold(dapp_storage: &DappStorage): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let starting_gold_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"starting_gold");
+        let mut starting_gold_bcs = sui::bcs::new(starting_gold_raw);
+        let starting_gold = sui::bcs::peel_u64(&mut starting_gold_bcs);
+        starting_gold
+    }
+
+    public(package) fun set_starting_gold(dapp_storage: &mut DappStorage, starting_gold: u64) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&starting_gold);
+        dapp_system::set_global_field<DappKey>(dapp_key::new(), dapp_storage, key_tuple, b"starting_gold", value);
+    }
+
+    public fun get_rake_bps(dapp_storage: &DappStorage): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let rake_bps_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"rake_bps");
+        let mut rake_bps_bcs = sui::bcs::new(rake_bps_raw);
+        let rake_bps = sui::bcs::peel_u64(&mut rake_bps_bcs);
+        rake_bps
+    }
+
+    public(package) fun set_rake_bps(dapp_storage: &mut DappStorage, rake_bps: u64) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&rake_bps);
+        dapp_system::set_global_field<DappKey>(dapp_key::new(), dapp_storage, key_tuple, b"rake_bps", value);
+    }
+
+    public fun get_max_hp(dapp_storage: &DappStorage): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let max_hp_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"max_hp");
+        let mut max_hp_bcs = sui::bcs::new(max_hp_raw);
+        let max_hp = sui::bcs::peel_u64(&mut max_hp_bcs);
+        max_hp
+    }
+
+    public(package) fun set_max_hp(dapp_storage: &mut DappStorage, max_hp: u64) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&max_hp);
+        dapp_system::set_global_field<DappKey>(dapp_key::new(), dapp_storage, key_tuple, b"max_hp", value);
+    }
+
+    public fun get_turn_timeout_ms(dapp_storage: &DappStorage): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let turn_timeout_ms_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"turn_timeout_ms");
+        let mut turn_timeout_ms_bcs = sui::bcs::new(turn_timeout_ms_raw);
+        let turn_timeout_ms = sui::bcs::peel_u64(&mut turn_timeout_ms_bcs);
+        turn_timeout_ms
+    }
+
+    public(package) fun set_turn_timeout_ms(dapp_storage: &mut DappStorage, turn_timeout_ms: u64) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&turn_timeout_ms);
+        dapp_system::set_global_field<DappKey>(dapp_key::new(), dapp_storage, key_tuple, b"turn_timeout_ms", value);
+    }
+
+    public fun get(dapp_storage: &DappStorage): (u64, u64, u64, u64, u64) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let pack_price_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"pack_price");
+        let mut pack_price_bcs = sui::bcs::new(pack_price_raw);
+        let pack_price = sui::bcs::peel_u64(&mut pack_price_bcs);
+        let starting_gold_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"starting_gold");
+        let mut starting_gold_bcs = sui::bcs::new(starting_gold_raw);
+        let starting_gold = sui::bcs::peel_u64(&mut starting_gold_bcs);
+        let rake_bps_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"rake_bps");
+        let mut rake_bps_bcs = sui::bcs::new(rake_bps_raw);
+        let rake_bps = sui::bcs::peel_u64(&mut rake_bps_bcs);
+        let max_hp_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"max_hp");
+        let mut max_hp_bcs = sui::bcs::new(max_hp_raw);
+        let max_hp = sui::bcs::peel_u64(&mut max_hp_bcs);
+        let turn_timeout_ms_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"turn_timeout_ms");
+        let mut turn_timeout_ms_bcs = sui::bcs::new(turn_timeout_ms_raw);
+        let turn_timeout_ms = sui::bcs::peel_u64(&mut turn_timeout_ms_bcs);
+        (pack_price, starting_gold, rake_bps, max_hp, turn_timeout_ms)
+    }
+
+    public(package) fun set(dapp_storage: &mut DappStorage, pack_price: u64, starting_gold: u64, rake_bps: u64, max_hp: u64, turn_timeout_ms: u64) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"pack_price", b"starting_gold", b"rake_bps", b"max_hp", b"turn_timeout_ms"];
+        let value_tuple = encode(pack_price, starting_gold, rake_bps, max_hp, turn_timeout_ms);
+        dapp_system::set_global_record<DappKey>(dapp_key::new(), dapp_storage, key_tuple, field_names, value_tuple, OFFCHAIN);
+    }
+
+    public fun get_struct(dapp_storage: &DappStorage): GameConfig {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let pack_price_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"pack_price");
+        let mut pack_price_bcs = sui::bcs::new(pack_price_raw);
+        let pack_price = sui::bcs::peel_u64(&mut pack_price_bcs);
+        let starting_gold_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"starting_gold");
+        let mut starting_gold_bcs = sui::bcs::new(starting_gold_raw);
+        let starting_gold = sui::bcs::peel_u64(&mut starting_gold_bcs);
+        let rake_bps_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"rake_bps");
+        let mut rake_bps_bcs = sui::bcs::new(rake_bps_raw);
+        let rake_bps = sui::bcs::peel_u64(&mut rake_bps_bcs);
+        let max_hp_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"max_hp");
+        let mut max_hp_bcs = sui::bcs::new(max_hp_raw);
+        let max_hp = sui::bcs::peel_u64(&mut max_hp_bcs);
+        let turn_timeout_ms_raw = dapp_system::get_global_field<DappKey>(dapp_storage, key_tuple, b"turn_timeout_ms");
+        let mut turn_timeout_ms_bcs = sui::bcs::new(turn_timeout_ms_raw);
+        let turn_timeout_ms = sui::bcs::peel_u64(&mut turn_timeout_ms_bcs);
+        GameConfig { pack_price, starting_gold, rake_bps, max_hp, turn_timeout_ms }
+    }
+
+    public(package) fun set_struct(dapp_storage: &mut DappStorage, game_config: GameConfig) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"pack_price", b"starting_gold", b"rake_bps", b"max_hp", b"turn_timeout_ms"];
+        let value_tuple = encode_struct(game_config);
+        dapp_system::set_global_record<DappKey>(dapp_key::new(), dapp_storage, key_tuple, field_names, value_tuple, OFFCHAIN);
+    }
+
+    public fun encode(pack_price: u64, starting_gold: u64, rake_bps: u64, max_hp: u64, turn_timeout_ms: u64): vector<vector<u8>> {
+        let mut value_tuple = vector::empty();
+        value_tuple.push_back(to_bytes(&pack_price));
+        value_tuple.push_back(to_bytes(&starting_gold));
+        value_tuple.push_back(to_bytes(&rake_bps));
+        value_tuple.push_back(to_bytes(&max_hp));
+        value_tuple.push_back(to_bytes(&turn_timeout_ms));
+        value_tuple
+    }
+
+    public fun encode_struct(game_config: GameConfig): vector<vector<u8>> {
+        encode(game_config.pack_price, game_config.starting_gold, game_config.rake_bps, game_config.max_hp, game_config.turn_timeout_ms)
+    }
+
+    public fun decode(data: vector<u8>): GameConfig {
+        let mut bcs_type = sui::bcs::new(data);
+        let pack_price = sui::bcs::peel_u64(&mut bcs_type);
+        let starting_gold = sui::bcs::peel_u64(&mut bcs_type);
+        let rake_bps = sui::bcs::peel_u64(&mut bcs_type);
+        let max_hp = sui::bcs::peel_u64(&mut bcs_type);
+        let turn_timeout_ms = sui::bcs::peel_u64(&mut bcs_type);
+        GameConfig {
+            pack_price,
+            starting_gold,
+            rake_bps,
+            max_hp,
+            turn_timeout_ms,
+        }
+    }
+}

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

@@ -0,0 +1,205 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module card_duel::gold {
+    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"gold";
+    const OFFCHAIN: bool = false;
+
+    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"amount"], ctx);
+    }
+
+    public fun get(user_storage: &UserStorage): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let amount_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"amount");
+        let mut amount_bcs = sui::bcs::new(amount_raw);
+        let value = sui::bcs::peel_u64(&mut amount_bcs);
+        value
+    }
+
+    public(package) fun set(user_storage: &mut UserStorage, value: u64, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"amount"];
+        let value_tuple = encode(value);
+        dapp_system::set_record<DappKey>(dapp_key::new(), user_storage, key_tuple, field_names, value_tuple, OFFCHAIN, ctx);
+    }
+
+    public fun encode(value: u64): vector<vector<u8>> {
+        let mut value_tuple = vector::empty();
+        value_tuple.push_back(to_bytes(&value));
+        value_tuple
+    }
+
+
+    // ─── fungible add / sub ─────────────────────────────────────────────
+    #[error]
+    const EInsufficientAmount: vector<u8> = b"Insufficient amount";
+
+    public(package) fun add(user_storage: &mut UserStorage, amount: u64, ctx: &mut TxContext) {
+        let current = if (has(user_storage)) { get(user_storage) } else { 0 };
+        set(user_storage, current + amount, ctx);
+    }
+
+    public(package) fun sub(user_storage: &mut UserStorage, amount: u64, ctx: &mut TxContext) {
+        let current = get(user_storage);
+        assert!(current >= amount, EInsufficientAmount);
+        set(user_storage, current - amount, ctx);
+    }
+
+    // ─── transferable: User ↔ ArenaStorage (fungible) ─────────────
+    public(package) fun transfer_user_to_arena(
+        user:   &mut UserStorage,
+        target: &mut dubhe::dapp_service::ObjectStorage<card_duel::arena::Arena>,
+        amount: u64,
+        ctx:    &mut TxContext,
+    ) {
+        sub(user, amount, ctx);
+        card_duel::arena::add_gold(target, amount);
+    }
+
+    public(package) fun transfer_arena_to_user(
+        source: &mut dubhe::dapp_service::ObjectStorage<card_duel::arena::Arena>,
+        user:   &mut UserStorage,
+        amount: u64,
+        ctx:    &mut TxContext,
+    ) {
+        card_duel::arena::sub_gold(source, amount);
+        add(user, amount, ctx);
+    }
+
+    // ─── transferable: User ↔ DuelStorage (fungible) ──────────
+    public(package) fun transfer_user_to_duel(
+        permit: &dubhe::dapp_service::ScenePermit<card_duel::duel_permit::DuelPermit>,
+        user:   &mut UserStorage,
+        target: &mut dubhe::dapp_service::SceneStorage<card_duel::duel::Duel>,
+        amount: u64,
+        ctx:    &mut TxContext,
+    ) {
+        sub(user, amount, ctx);
+        card_duel::duel::add_gold(permit, target, user, amount, ctx);
+    }
+
+    // ★ No expiry check on withdraw direction — prevents asset lock-in expired scenes.
+    public(package) fun transfer_duel_to_user(
+        permit: &dubhe::dapp_service::ScenePermit<card_duel::duel_permit::DuelPermit>,
+        source: &mut dubhe::dapp_service::SceneStorage<card_duel::duel::Duel>,
+        user:   &mut UserStorage,
+        amount: u64,
+        ctx:    &mut TxContext,
+    ) {
+        card_duel::duel::sub_gold(permit, source, user, amount, ctx);
+        add(user, amount, ctx);
+    }
+
+    // ─── transferable: User ↔ BrawlStorage (fungible) ──────────
+    public(package) fun transfer_user_to_brawl(
+        permit: &dubhe::dapp_service::ScenePermit<card_duel::brawl_permit::BrawlPermit>,
+        user:   &mut UserStorage,
+        target: &mut dubhe::dapp_service::SceneStorage<card_duel::brawl::Brawl>,
+        amount: u64,
+        ctx:    &mut TxContext,
+    ) {
+        sub(user, amount, ctx);
+        card_duel::brawl::add_gold(permit, target, user, amount, ctx);
+    }
+
+    // ★ No expiry check on withdraw direction — prevents asset lock-in expired scenes.
+    public(package) fun transfer_brawl_to_user(
+        permit: &dubhe::dapp_service::ScenePermit<card_duel::brawl_permit::BrawlPermit>,
+        source: &mut dubhe::dapp_service::SceneStorage<card_duel::brawl::Brawl>,
+        user:   &mut UserStorage,
+        amount: u64,
+        ctx:    &mut TxContext,
+    ) {
+        card_duel::brawl::sub_gold(permit, source, user, amount, ctx);
+        add(user, amount, ctx);
+    }
+
+    // ─── listable: market protocol (fungible) ──────────────────────────
+    // 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,
+        amount:       u64,
+        price:        u64,
+        listed_until: std::option::Option<u64>,
+        ctx:          &mut TxContext,
+    ) {
+        dubhe::dapp_system::take_fungible_record<DappKey, CoinType>(
+            dapp_key::new(),
+            user_storage,
+            b"gold",
+            { let mut k = vector::empty(); k.push_back(TABLE_NAME); k },
+            b"amount",
+            amount,
+            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_fungible_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::cancel_fungible_listing<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_fungible_listing<DappKey, CoinType>(
+            dapp_key::new(), listing, user_storage, ctx
+        );
+    }
+}