create-dubhe 1.2.0-pre.99 → 2.0.0

package/templates/nextjs/sui-farm/packages/contracts/src/harvest/sources/codegen/resources/crow_damage.move

@@ -0,0 +1,207 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module harvest::crow_damage {
+    use sui::bcs::{to_bytes};
+    use dubhe::dapp_service::UserStorage;
+    use dubhe::dapp_service::ScenePermit;
+    use dubhe::dapp_system;
+    use harvest::dapp_key;
+    use harvest::dapp_key::DappKey;
+
+
+    const TABLE_NAME: vector<u8> = b"crow_damage";
+    const OFFCHAIN: bool = false;
+
+    public struct CrowDamage has copy, drop, store {
+        expires_at: u64,
+        damage_pct: u8,
+    }
+
+    public fun new(expires_at: u64, damage_pct: u8): CrowDamage {
+        CrowDamage {
+            expires_at,
+            damage_pct,
+        }
+    }
+
+    public fun expires_at(self: &CrowDamage): u64 {
+        self.expires_at
+    }
+
+    public fun damage_pct(self: &CrowDamage): u8 {
+        self.damage_pct
+    }
+
+    public fun update_expires_at(self: &mut CrowDamage, expires_at: u64) {
+        self.expires_at = expires_at
+    }
+
+    public fun update_damage_pct(self: &mut CrowDamage, damage_pct: u8) {
+        self.damage_pct = damage_pct
+    }
+
+    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"expires_at", b"damage_pct"], ctx);
+    }
+
+    public fun get_expires_at(user_storage: &UserStorage): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let expires_at_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"expires_at");
+        let mut expires_at_bcs = sui::bcs::new(expires_at_raw);
+        let expires_at = sui::bcs::peel_u64(&mut expires_at_bcs);
+        expires_at
+    }
+
+    public(package) fun set_expires_at(user_storage: &mut UserStorage, expires_at: u64, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&expires_at);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"expires_at", value, ctx);
+    }
+
+    public fun get_damage_pct(user_storage: &UserStorage): u8 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let damage_pct_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"damage_pct");
+        let mut damage_pct_bcs = sui::bcs::new(damage_pct_raw);
+        let damage_pct = sui::bcs::peel_u8(&mut damage_pct_bcs);
+        damage_pct
+    }
+
+    public(package) fun set_damage_pct(user_storage: &mut UserStorage, damage_pct: u8, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = to_bytes(&damage_pct);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"damage_pct", value, ctx);
+    }
+
+    public fun get(user_storage: &UserStorage): (u64, u8) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let expires_at_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"expires_at");
+        let mut expires_at_bcs = sui::bcs::new(expires_at_raw);
+        let expires_at = sui::bcs::peel_u64(&mut expires_at_bcs);
+        let damage_pct_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"damage_pct");
+        let mut damage_pct_bcs = sui::bcs::new(damage_pct_raw);
+        let damage_pct = sui::bcs::peel_u8(&mut damage_pct_bcs);
+        (expires_at, damage_pct)
+    }
+
+    public(package) fun set(user_storage: &mut UserStorage, expires_at: u64, damage_pct: u8, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"expires_at", b"damage_pct"];
+        let value_tuple = encode(expires_at, damage_pct);
+        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): CrowDamage {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let expires_at_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"expires_at");
+        let mut expires_at_bcs = sui::bcs::new(expires_at_raw);
+        let expires_at = sui::bcs::peel_u64(&mut expires_at_bcs);
+        let damage_pct_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"damage_pct");
+        let mut damage_pct_bcs = sui::bcs::new(damage_pct_raw);
+        let damage_pct = sui::bcs::peel_u8(&mut damage_pct_bcs);
+        CrowDamage { expires_at, damage_pct }
+    }
+
+    public(package) fun set_struct(user_storage: &mut UserStorage, crow_damage: CrowDamage, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"expires_at", b"damage_pct"];
+        let value_tuple = encode_struct(crow_damage);
+        dapp_system::set_record<DappKey>(dapp_key::new(), user_storage, key_tuple, field_names, value_tuple, OFFCHAIN, ctx);
+    }
+
+    public fun encode(expires_at: u64, damage_pct: u8): vector<vector<u8>> {
+        let mut value_tuple = vector::empty();
+        value_tuple.push_back(to_bytes(&expires_at));
+        value_tuple.push_back(to_bytes(&damage_pct));
+        value_tuple
+    }
+
+    public fun encode_struct(crow_damage: CrowDamage): vector<vector<u8>> {
+        encode(crow_damage.expires_at, crow_damage.damage_pct)
+    }
+
+    public fun decode(data: vector<u8>): CrowDamage {
+        let mut bcs_type = sui::bcs::new(data);
+        let expires_at = sui::bcs::peel_u64(&mut bcs_type);
+        let damage_pct = sui::bcs::peel_u8(&mut bcs_type);
+        CrowDamage {
+            expires_at,
+            damage_pct,
+        }
+    }
+
+
+    // ─── 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,
+        expires_at: u64, damage_pct: u8,
+        ctx:    &mut TxContext,
+    ) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"expires_at", b"damage_pct"];
+        let value_tuple = encode(expires_at, damage_pct);
+        dapp_system::set_record_reactive<DappKey, PermType>(dapp_key::new(), permit, from, target, key_tuple, field_names, value_tuple, ctx);
+    }
+
+    public(package) fun set_expires_at_reactive<PermType>(
+        permit: &ScenePermit<PermType>,
+        from:   &mut UserStorage,
+        target: &mut UserStorage,
+        expires_at: u64,
+        ctx:    &mut TxContext,
+    ) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = sui::bcs::to_bytes(&expires_at);
+        dapp_system::set_field_reactive<DappKey, PermType>(dapp_key::new(), permit, from, target, key_tuple, b"expires_at", value, ctx);
+    }
+
+    public(package) fun set_damage_pct_reactive<PermType>(
+        permit: &ScenePermit<PermType>,
+        from:   &mut UserStorage,
+        target: &mut UserStorage,
+        damage_pct: u8,
+        ctx:    &mut TxContext,
+    ) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        let value = sui::bcs::to_bytes(&damage_pct);
+        dapp_system::set_field_reactive<DappKey, PermType>(dapp_key::new(), permit, from, target, key_tuple, b"damage_pct", value, ctx);
+    }
+}

package/templates/nextjs/sui-farm/packages/contracts/src/harvest/sources/codegen/resources/farm_plot.move

@@ -0,0 +1,261 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module harvest::farm_plot {
+    use sui::bcs::{to_bytes};
+    use dubhe::dapp_service::UserStorage;
+    use dubhe::dapp_system;
+    use harvest::dapp_key;
+    use harvest::dapp_key::DappKey;
+
+
+    const TABLE_NAME: vector<u8> = b"farm_plot";
+    const OFFCHAIN: bool = false;
+
+    public struct FarmPlot has copy, drop, store {
+        crop_type: u8,
+        count: u64,
+        planted_at: u64,
+        harvest_at: u64,
+    }
+
+    public fun new(crop_type: u8, count: u64, planted_at: u64, harvest_at: u64): FarmPlot {
+        FarmPlot {
+            crop_type,
+            count,
+            planted_at,
+            harvest_at,
+        }
+    }
+
+    public fun crop_type(self: &FarmPlot): u8 {
+        self.crop_type
+    }
+
+    public fun count(self: &FarmPlot): u64 {
+        self.count
+    }
+
+    public fun planted_at(self: &FarmPlot): u64 {
+        self.planted_at
+    }
+
+    public fun harvest_at(self: &FarmPlot): u64 {
+        self.harvest_at
+    }
+
+    public fun update_crop_type(self: &mut FarmPlot, crop_type: u8) {
+        self.crop_type = crop_type
+    }
+
+    public fun update_count(self: &mut FarmPlot, count: u64) {
+        self.count = count
+    }
+
+    public fun update_planted_at(self: &mut FarmPlot, planted_at: u64) {
+        self.planted_at = planted_at
+    }
+
+    public fun update_harvest_at(self: &mut FarmPlot, harvest_at: u64) {
+        self.harvest_at = harvest_at
+    }
+
+    public fun has(user_storage: &UserStorage, plot_id: u8): bool {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        dapp_system::has_record<DappKey>(user_storage, key_tuple)
+    }
+
+    public fun ensure_has(user_storage: &UserStorage, plot_id: u8) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        dapp_system::ensure_has_record<DappKey>(user_storage, key_tuple)
+    }
+
+    public fun ensure_has_not(user_storage: &UserStorage, plot_id: u8) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        dapp_system::ensure_has_not_record<DappKey>(user_storage, key_tuple)
+    }
+  
+
+    public(package) fun delete(user_storage: &mut UserStorage, plot_id: u8, ctx: &TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        dapp_system::delete_record<DappKey>(dapp_key::new(), user_storage, key_tuple, vector[b"crop_type", b"count", b"planted_at", b"harvest_at"], ctx);
+    }
+
+    public fun get_crop_type(user_storage: &UserStorage, plot_id: u8): u8 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let crop_type_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"crop_type");
+        let mut crop_type_bcs = sui::bcs::new(crop_type_raw);
+        let crop_type = sui::bcs::peel_u8(&mut crop_type_bcs);
+        crop_type
+    }
+
+    public(package) fun set_crop_type(user_storage: &mut UserStorage, plot_id: u8, crop_type: u8, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let value = to_bytes(&crop_type);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"crop_type", value, ctx);
+    }
+
+    public fun get_count(user_storage: &UserStorage, plot_id: u8): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let count_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"count");
+        let mut count_bcs = sui::bcs::new(count_raw);
+        let count = sui::bcs::peel_u64(&mut count_bcs);
+        count
+    }
+
+    public(package) fun set_count(user_storage: &mut UserStorage, plot_id: u8, count: u64, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let value = to_bytes(&count);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"count", value, ctx);
+    }
+
+    public fun get_planted_at(user_storage: &UserStorage, plot_id: u8): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let planted_at_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"planted_at");
+        let mut planted_at_bcs = sui::bcs::new(planted_at_raw);
+        let planted_at = sui::bcs::peel_u64(&mut planted_at_bcs);
+        planted_at
+    }
+
+    public(package) fun set_planted_at(user_storage: &mut UserStorage, plot_id: u8, planted_at: u64, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let value = to_bytes(&planted_at);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"planted_at", value, ctx);
+    }
+
+    public fun get_harvest_at(user_storage: &UserStorage, plot_id: u8): u64 {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let harvest_at_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"harvest_at");
+        let mut harvest_at_bcs = sui::bcs::new(harvest_at_raw);
+        let harvest_at = sui::bcs::peel_u64(&mut harvest_at_bcs);
+        harvest_at
+    }
+
+    public(package) fun set_harvest_at(user_storage: &mut UserStorage, plot_id: u8, harvest_at: u64, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let value = to_bytes(&harvest_at);
+        dapp_system::set_field<DappKey>(dapp_key::new(), user_storage, key_tuple, b"harvest_at", value, ctx);
+    }
+
+    public fun get(user_storage: &UserStorage, plot_id: u8): (u8, u64, u64, u64) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let crop_type_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"crop_type");
+        let mut crop_type_bcs = sui::bcs::new(crop_type_raw);
+        let crop_type = sui::bcs::peel_u8(&mut crop_type_bcs);
+        let count_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"count");
+        let mut count_bcs = sui::bcs::new(count_raw);
+        let count = sui::bcs::peel_u64(&mut count_bcs);
+        let planted_at_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"planted_at");
+        let mut planted_at_bcs = sui::bcs::new(planted_at_raw);
+        let planted_at = sui::bcs::peel_u64(&mut planted_at_bcs);
+        let harvest_at_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"harvest_at");
+        let mut harvest_at_bcs = sui::bcs::new(harvest_at_raw);
+        let harvest_at = sui::bcs::peel_u64(&mut harvest_at_bcs);
+        (crop_type, count, planted_at, harvest_at)
+    }
+
+    public(package) fun set(user_storage: &mut UserStorage, plot_id: u8, crop_type: u8, count: u64, planted_at: u64, harvest_at: u64, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let field_names = vector[b"crop_type", b"count", b"planted_at", b"harvest_at"];
+        let value_tuple = encode(crop_type, count, planted_at, harvest_at);
+        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, plot_id: u8): FarmPlot {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let crop_type_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"crop_type");
+        let mut crop_type_bcs = sui::bcs::new(crop_type_raw);
+        let crop_type = sui::bcs::peel_u8(&mut crop_type_bcs);
+        let count_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"count");
+        let mut count_bcs = sui::bcs::new(count_raw);
+        let count = sui::bcs::peel_u64(&mut count_bcs);
+        let planted_at_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"planted_at");
+        let mut planted_at_bcs = sui::bcs::new(planted_at_raw);
+        let planted_at = sui::bcs::peel_u64(&mut planted_at_bcs);
+        let harvest_at_raw = dapp_system::get_field<DappKey>(user_storage, key_tuple, b"harvest_at");
+        let mut harvest_at_bcs = sui::bcs::new(harvest_at_raw);
+        let harvest_at = sui::bcs::peel_u64(&mut harvest_at_bcs);
+        FarmPlot { crop_type, count, planted_at, harvest_at }
+    }
+
+    public(package) fun set_struct(user_storage: &mut UserStorage, plot_id: u8, farm_plot: FarmPlot, ctx: &mut TxContext) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        key_tuple.push_back(to_bytes(&plot_id));
+        let field_names = vector[b"crop_type", b"count", b"planted_at", b"harvest_at"];
+        let value_tuple = encode_struct(farm_plot);
+        dapp_system::set_record<DappKey>(dapp_key::new(), user_storage, key_tuple, field_names, value_tuple, OFFCHAIN, ctx);
+    }
+
+    public fun encode(crop_type: u8, count: u64, planted_at: u64, harvest_at: u64): vector<vector<u8>> {
+        let mut value_tuple = vector::empty();
+        value_tuple.push_back(to_bytes(&crop_type));
+        value_tuple.push_back(to_bytes(&count));
+        value_tuple.push_back(to_bytes(&planted_at));
+        value_tuple.push_back(to_bytes(&harvest_at));
+        value_tuple
+    }
+
+    public fun encode_struct(farm_plot: FarmPlot): vector<vector<u8>> {
+        encode(farm_plot.crop_type, farm_plot.count, farm_plot.planted_at, farm_plot.harvest_at)
+    }
+
+    public fun decode(data: vector<u8>): FarmPlot {
+        let mut bcs_type = sui::bcs::new(data);
+        let crop_type = sui::bcs::peel_u8(&mut bcs_type);
+        let count = sui::bcs::peel_u64(&mut bcs_type);
+        let planted_at = sui::bcs::peel_u64(&mut bcs_type);
+        let harvest_at = sui::bcs::peel_u64(&mut bcs_type);
+        FarmPlot {
+            crop_type,
+            count,
+            planted_at,
+            harvest_at,
+        }
+    }
+
+
+    // ─── 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,
+        plot_id: u8, crop_type: u8, count: u64, planted_at: u64, harvest_at: u64,
+        ctx: &mut TxContext,
+    ) {
+        ensure_has_not(user_storage, plot_id);
+        set(user_storage, plot_id, crop_type, count, planted_at, harvest_at, ctx);
+    }
+}

package/templates/nextjs/sui-farm/packages/contracts/src/harvest/sources/codegen/resources/gold.move

@@ -0,0 +1,80 @@
+// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+module harvest::gold {
+    use sui::bcs::{to_bytes};
+    use dubhe::dapp_service::UserStorage;
+    use dubhe::dapp_system;
+    use harvest::dapp_key;
+    use harvest::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);
+    }
+}