create-dubhe 1.2.0-pre.99 → 2.0.0

package/templates/nextjs/sui-template/packages/contracts/src/dubhe/sources/tests/user_storage_test.move

@@ -0,0 +1,160 @@
+/// Unit tests — UserStorage creation and registration
+///
+/// Covers:
+///   create_user_storage: initial state, registration recorded, duplicate abort
+///   canonical_owner is set correctly on creation
+///   session fields initialized to zero/empty
+#[test_only]
+module dubhe::user_storage_test;
+
+use dubhe::dapp_service::{Self, DappHub, DappStorage};
+use dubhe::dapp_system;
+use sui::test_scenario;
+
+public struct UsTestKey has copy, drop {}
+
+const USER: address = @0x1234;
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+fun setup(scenario: &mut test_scenario::Scenario): (DappHub, DappStorage) {
+    let ctx = test_scenario::ctx(scenario);
+    (
+        dapp_system::create_dapp_hub_for_testing(ctx),
+        dapp_system::create_dapp_storage_for_testing<UsTestKey>(ctx),
+    )
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Initial state
+// ═══════════════════════════════════════════════════════════════════════════════
+
+#[test]
+fun test_initial_write_counts_are_zero() {
+    let mut scenario = test_scenario::begin(USER);
+    {
+        let ctx = test_scenario::ctx(&mut scenario);
+        let us = dapp_service::create_user_storage_for_testing<UsTestKey>(USER, ctx);
+
+        assert!(dapp_service::write_count(&us) == 0);
+        assert!(dapp_service::settled_count(&us) == 0);
+        assert!(dapp_service::unsettled_count(&us) == 0);
+
+        dapp_service::destroy_user_storage(us);
+    };
+    scenario.end();
+}
+
+#[test]
+fun test_canonical_owner_set_on_creation() {
+    let mut scenario = test_scenario::begin(USER);
+    {
+        let ctx = test_scenario::ctx(&mut scenario);
+        let us = dapp_service::create_user_storage_for_testing<UsTestKey>(USER, ctx);
+        assert!(dapp_service::canonical_owner(&us) == USER);
+        dapp_service::destroy_user_storage(us);
+    };
+    scenario.end();
+}
+
+#[test]
+fun test_session_fields_cleared_on_creation() {
+    let mut scenario = test_scenario::begin(USER);
+    {
+        let ctx = test_scenario::ctx(&mut scenario);
+        let us = dapp_service::create_user_storage_for_testing<UsTestKey>(USER, ctx);
+        assert!(dapp_service::session_key(&us) == @0x0);
+        assert!(dapp_service::session_expires_at(&us) == 0);
+        dapp_service::destroy_user_storage(us);
+    };
+    scenario.end();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// create_user_storage (via dapp_system) — registration guard
+// ═══════════════════════════════════════════════════════════════════════════════
+
+#[test]
+fun test_create_user_storage_registers_address() {
+    let sender = @0xABC;
+    let mut scenario = test_scenario::begin(sender);
+    {
+        let (dh, mut ds) = setup(&mut scenario);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        assert!(!dapp_service::has_registered_user_storage(&ds, sender));
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        assert!(dapp_service::has_registered_user_storage(&ds, sender));
+
+        dapp_system::destroy_dapp_hub(dh);
+        dapp_system::destroy_dapp_storage(ds);
+    };
+    scenario.end();
+}
+
+#[test]
+#[expected_failure]
+fun test_create_user_storage_twice_aborts() {
+    let sender = @0xABC;
+    let mut scenario = test_scenario::begin(sender);
+    {
+        let (dh, mut ds) = setup(&mut scenario);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        // Second call from the same address must abort with user_storage_already_exists.
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+
+        dapp_system::destroy_dapp_hub(dh);
+        dapp_system::destroy_dapp_storage(ds);
+    };
+    scenario.end();
+}
+
+#[test]
+fun test_different_users_can_each_create_one_user_storage() {
+    let user_a = @0xAAAA;
+    let user_b = @0xBBBB;
+
+    let mut scenario = test_scenario::begin(user_a);
+    {
+        let (dh, mut ds) = setup(&mut scenario);
+
+        // user_a creates their storage.
+        let ctx = test_scenario::ctx(&mut scenario);
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        assert!(dapp_service::has_registered_user_storage(&ds, user_a));
+
+        // user_b creates theirs in a new tx.
+        test_scenario::next_tx(&mut scenario, user_b);
+        let ctx = test_scenario::ctx(&mut scenario);
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        assert!(dapp_service::has_registered_user_storage(&ds, user_b));
+
+        dapp_system::destroy_dapp_hub(dh);
+        dapp_system::destroy_dapp_storage(ds);
+    };
+    scenario.end();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Suspended DApp guard
+// ═══════════════════════════════════════════════════════════════════════════════
+
+#[test]
+fun test_create_user_storage_succeeds_after_registration_check() {
+    let sender = @0xABC;
+    let mut scenario = test_scenario::begin(sender);
+    {
+        let (dh, mut ds) = setup(&mut scenario);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        // Must succeed.
+        dapp_system::create_user_storage(UsTestKey {}, &dh, &mut ds, ctx);
+        assert!(dapp_service::has_registered_user_storage(&ds, sender));
+
+        dapp_system::destroy_dapp_hub(dh);
+        dapp_system::destroy_dapp_storage(ds);
+    };
+    scenario.end();
+}

package/templates/nextjs/sui-template/packages/contracts/src/dubhe/sources/utils/math.move

@@ -1,6 +1,7 @@
 module dubhe::dubhe_math {
     use std::u128;
     use std::u64;
+    use dubhe::error;
 
     public fun min(x: u256, y: u256): u256 {
         if (x < y) x else y
@@ -9,12 +10,12 @@ module dubhe::dubhe_math {
     public fun safe_mul(a: u256, b: u256): u256 {
         if (a == 0 || b == 0) return 0;
         let c = a * b;
-        assert!(c / a == b, 0);
+        error::math_overflow(c / a == b);
         c
     }
 
     public fun safe_div(a: u256, b: u256): u256 {
-        assert!(b != 0, 0);
+        error::division_by_zero(b != 0);
         a / b
     }
 
@@ -108,7 +109,7 @@ module dubhe::dubhe_math {
     }
 
     public(package) fun windows(x: &vector<u256>, size: u64): vector<vector<u256>> {
-        assert!(size > 0, 0);
+        error::invalid_window_size(size > 0);
 
         let length = vector::length(x);
         let mut result = vector::empty<vector<u256>>();

package/templates/nextjs/sui-template/packages/contracts/src/dubhe/sources/utils/type_info.move

@@ -29,11 +29,11 @@ module dubhe::type_info {
     }
 
     public fun get_package_id<T>(): address {
-        let type_name = type_name::get<T>().get_address();
+        let type_name = type_name::with_defining_ids<T>().address_string();
         address::from_ascii_bytes(type_name.as_bytes())
     }
 
     public fun get_type_name_string<T>(): String {
-        type_name::get<T>().into_string()
+        type_name::with_defining_ids<T>().into_string()
     }
 }

package/templates/101/sui-template/packages/contracts/src/counter/Move.lock

@@ -1,41 +0,0 @@
-# Generated by move; do not edit
-# This file should be checked in.
-
-[move]
-version = 4
-
-[pinned.testnet.Dubhe]
-source = { local = "../dubhe" }
-use_environment = "testnet"
-manifest_digest = "21C4ACDE8D1A1E22F33EBBF539FC94BA72EC8B363E3A9B495D51C157AAB5189C"
-deps = { Sui = "Sui_1" }
-
-[pinned.testnet.MoveStdlib]
-source = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/move-stdlib", rev = "655576caa3d7faaed39ebbc15d1bcc91d0761aee" }
-use_environment = "testnet"
-manifest_digest = "C4FE4C91DE74CBF223B2E380AE40F592177D21870DC2D7EB6227D2D694E05363"
-deps = {}
-
-[pinned.testnet.MoveStdlib_1]
-source = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/move-stdlib", rev = "ff441e0d66d6cd56c4527db1b6e6e38335e805ce" }
-use_environment = "testnet"
-manifest_digest = "C4FE4C91DE74CBF223B2E380AE40F592177D21870DC2D7EB6227D2D694E05363"
-deps = {}
-
-[pinned.testnet.Sui]
-source = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "655576caa3d7faaed39ebbc15d1bcc91d0761aee" }
-use_environment = "testnet"
-manifest_digest = "7AFB66695545775FBFBB2D3078ADFD084244D5002392E837FDE21D9EA1C6D01C"
-deps = { MoveStdlib = "MoveStdlib" }
-
-[pinned.testnet.Sui_1]
-source = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "ff441e0d66d6cd56c4527db1b6e6e38335e805ce" }
-use_environment = "testnet"
-manifest_digest = "7AFB66695545775FBFBB2D3078ADFD084244D5002392E837FDE21D9EA1C6D01C"
-deps = { MoveStdlib = "MoveStdlib_1" }
-
-[pinned.testnet.counter]
-source = { root = true }
-use_environment = "testnet"
-manifest_digest = "2D4D3310758A71D313468A1B290F249B20F4102A935C19C448A4997325E498D1"
-deps = { Dubhe = "Dubhe", std = "MoveStdlib", sui = "Sui" }

package/templates/101/sui-template/packages/contracts/src/counter/Published.toml

@@ -1,9 +0,0 @@
-# Generated by Move
-# This file contains metadata about published versions of this package in different environments
-# This file SHOULD be committed to source control
-
-[published.localnet]
-chain-id = "0e1d263b"
-published-at = "0x5b6be663374918fc768ceb703a075b7199456a86f3962f4229f7e5e3d749d284"
-original-id = "0x5b6be663374918fc768ceb703a075b7199456a86f3962f4229f7e5e3d749d284"
-version = 1

package/templates/101/sui-template/packages/contracts/src/counter/sources/codegen/errors.move

@@ -1,12 +0,0 @@
-  // Copyright (c) Obelisk Labs, Inc.
-  // SPDX-License-Identifier: Apache-2.0
-  #[allow(unused_use)]
-  
-  /* Autogenerated file. Do not edit manually. */
-  
-  module counter::errors {
-		#[error]
-				const INVALID_INCREMENT: vector<u8> = b"Number can't be incremented, must be more than 0";
-				public fun invalid_increment_error(condition: bool) { assert!(condition, INVALID_INCREMENT)  }
-		
-            }

package/templates/101/sui-template/packages/contracts/src/dubhe/sources/codegen/errors.move

@@ -1,140 +0,0 @@
-  // Copyright (c) Obelisk Labs, Inc.
-  // SPDX-License-Identifier: Apache-2.0
-  #[allow(unused_use)]
-  
-  /* Autogenerated file. Do not edit manually. */
-  
-  module dubhe::errors {
-		#[error]
-				const ASSET_NOT_FOUND: vector<u8> = b"Asset not found";
-				public fun asset_not_found_error(condition: bool) { assert!(condition, ASSET_NOT_FOUND)  }
-		
-#[error]
-				const ASSET_ALREADY_FROZEN: vector<u8> = b"Asset already frozen";
-				public fun asset_already_frozen_error(condition: bool) { assert!(condition, ASSET_ALREADY_FROZEN)  }
-		
-#[error]
-				const INVALID_SENDER: vector<u8> = b"Invalid sender";
-				public fun invalid_sender_error(condition: bool) { assert!(condition, INVALID_SENDER)  }
-		
-#[error]
-				const INVALID_RECEIVER: vector<u8> = b"Invalid receiver";
-				public fun invalid_receiver_error(condition: bool) { assert!(condition, INVALID_RECEIVER)  }
-		
-#[error]
-				const INVALID_METADATA: vector<u8> = b"Invalid metadata";
-				public fun invalid_metadata_error(condition: bool) { assert!(condition, INVALID_METADATA)  }
-		
-#[error]
-				const ACCOUNT_NOT_FOUND: vector<u8> = b"Account not found";
-				public fun account_not_found_error(condition: bool) { assert!(condition, ACCOUNT_NOT_FOUND)  }
-		
-#[error]
-				const ACCOUNT_BLOCKED: vector<u8> = b"Account is blocked";
-				public fun account_blocked_error(condition: bool) { assert!(condition, ACCOUNT_BLOCKED)  }
-		
-#[error]
-				const ACCOUNT_FROZEN: vector<u8> = b"Account is frozen";
-				public fun account_frozen_error(condition: bool) { assert!(condition, ACCOUNT_FROZEN)  }
-		
-#[error]
-				const BALANCE_TOO_LOW: vector<u8> = b"Balance too low";
-				public fun balance_too_low_error(condition: bool) { assert!(condition, BALANCE_TOO_LOW)  }
-		
-#[error]
-				const OVERFLOWS: vector<u8> = b"Operation overflows";
-				public fun overflows_error(condition: bool) { assert!(condition, OVERFLOWS)  }
-		
-#[error]
-				const NO_PERMISSION: vector<u8> = b"No permission";
-				public fun no_permission_error(condition: bool) { assert!(condition, NO_PERMISSION)  }
-		
-#[error]
-				const NOT_MINTABLE: vector<u8> = b"Asset is not mintable";
-				public fun not_mintable_error(condition: bool) { assert!(condition, NOT_MINTABLE)  }
-		
-#[error]
-				const NOT_BURNABLE: vector<u8> = b"Asset is not burnable";
-				public fun not_burnable_error(condition: bool) { assert!(condition, NOT_BURNABLE)  }
-		
-#[error]
-				const NOT_FREEZABLE: vector<u8> = b"Asset is not freezable";
-				public fun not_freezable_error(condition: bool) { assert!(condition, NOT_FREEZABLE)  }
-		
-#[error]
-				const BELOW_MIN_AMOUNT: vector<u8> = b"Amount is below minimum";
-				public fun below_min_amount_error(condition: bool) { assert!(condition, BELOW_MIN_AMOUNT)  }
-		
-#[error]
-				const LIQUIDITY_CANNOT_BE_ZERO: vector<u8> = b"Liquidity cannot be 0";
-				public fun liquidity_cannot_be_zero_error(condition: bool) { assert!(condition, LIQUIDITY_CANNOT_BE_ZERO)  }
-		
-#[error]
-				const MORE_THAN_MAX_SWAP_PATH_LEN: vector<u8> = b"More than Max";
-				public fun more_than_max_swap_path_len_error(condition: bool) { assert!(condition, MORE_THAN_MAX_SWAP_PATH_LEN)  }
-		
-#[error]
-				const MORE_THAN_RESERVE: vector<u8> = b"More than reserve";
-				public fun more_than_reserve_error(condition: bool) { assert!(condition, MORE_THAN_RESERVE)  }
-		
-#[error]
-				const SWAP_PATH_TOO_SMALL: vector<u8> = b"Swap path too small";
-				public fun swap_path_too_small_error(condition: bool) { assert!(condition, SWAP_PATH_TOO_SMALL)  }
-		
-#[error]
-				const RESERVES_CANNOT_BE_ZERO: vector<u8> = b"Reserve cannot be 0";
-				public fun reserves_cannot_be_zero_error(condition: bool) { assert!(condition, RESERVES_CANNOT_BE_ZERO)  }
-		
-#[error]
-				const AMOUNT_CANNOT_BE_ZERO: vector<u8> = b"Amount cannot be 0";
-				public fun amount_cannot_be_zero_error(condition: bool) { assert!(condition, AMOUNT_CANNOT_BE_ZERO)  }
-		
-#[error]
-				const LESS_THAN_AMOUNT_OUT_MIN: vector<u8> = b"Less than expected";
-				public fun less_than_amount_out_min_error(condition: bool) { assert!(condition, LESS_THAN_AMOUNT_OUT_MIN)  }
-		
-#[error]
-				const MORE_THAN_AMOUNT_IN_MAX: vector<u8> = b"More than expected";
-				public fun more_than_amount_in_max_error(condition: bool) { assert!(condition, MORE_THAN_AMOUNT_IN_MAX)  }
-		
-#[error]
-				const BRIDGE_NOT_OPENED: vector<u8> = b"Bridge is not opened";
-				public fun bridge_not_opened_error(condition: bool) { assert!(condition, BRIDGE_NOT_OPENED)  }
-		
-#[error]
-				const NOT_LATEST_VERSION: vector<u8> = b"Not latest version";
-				public fun not_latest_version_error(condition: bool) { assert!(condition, NOT_LATEST_VERSION)  }
-		
-#[error]
-				const DAPP_ALREADY_PAUSED: vector<u8> = b"Dapp already paused";
-				public fun dapp_already_paused_error(condition: bool) { assert!(condition, DAPP_ALREADY_PAUSED)  }
-		
-#[error]
-				const INVALID_PACKAGE_ID: vector<u8> = b"Invalid package id";
-				public fun invalid_package_id_error(condition: bool) { assert!(condition, INVALID_PACKAGE_ID)  }
-		
-#[error]
-				const INVALID_VERSION: vector<u8> = b"Invalid version";
-				public fun invalid_version_error(condition: bool) { assert!(condition, INVALID_VERSION)  }
-		
-#[error]
-				const DAPP_NOT_INITIALIZED: vector<u8> = b"Dapp not initialized";
-				public fun dapp_not_initialized_error(condition: bool) { assert!(condition, DAPP_NOT_INITIALIZED)  }
-		
-#[error]
-				const DAPP_ALREADY_INITIALIZED: vector<u8> = b"Dapp already initialized";
-				public fun dapp_already_initialized_error(condition: bool) { assert!(condition, DAPP_ALREADY_INITIALIZED)  }
-		
-#[error]
-				const INSUFFICIENT_CREDIT: vector<u8> = b"Insufficient credit";
-				public fun insufficient_credit_error(condition: bool) { assert!(condition, INSUFFICIENT_CREDIT)  }
-		
-#[error]
-				const DAPP_NOT_BEEN_DELEGATED: vector<u8> = b"Dapp not been delegated";
-				public fun dapp_not_been_delegated_error(condition: bool) { assert!(condition, DAPP_NOT_BEEN_DELEGATED)  }
-		
-#[error]
-				const DAPP_ALREADY_DELEGATED: vector<u8> = b"Dapp already delegated";
-				public fun dapp_already_delegated_error(condition: bool) { assert!(condition, DAPP_ALREADY_DELEGATED)  }
-		
-            }

package/templates/101/sui-template/packages/contracts/src/dubhe/sources/codegen/resources/dapp_fee_config.move

@@ -1,186 +0,0 @@
-  // Copyright (c) Obelisk Labs, Inc.
-  // SPDX-License-Identifier: Apache-2.0
-  #[allow(unused_use)]
-  
-  /* Autogenerated file. Do not edit manually. */
-  
-  module dubhe::dapp_fee_config { 
-    use sui::bcs::{to_bytes};
-    use std::ascii::{string, String, into_bytes};
-    use dubhe::table_id;
-    use dubhe::dapp_service::{Self, DappHub};
-    use dubhe::dapp_system;
-    use dubhe::dapp_key;
-    use dubhe::dapp_key::DappKey;
-
-
-    const TABLE_NAME: vector<u8> = b"dapp_fee_config";
-    const OFFCHAIN: bool = false;
-
-    public struct DappFeeConfig has copy, drop, store {
-        free_credit: u256,
-        base_fee: u256,
-        byte_fee: u256,
-    }
-
-    public fun new(free_credit: u256, base_fee: u256, byte_fee: u256): DappFeeConfig {
-        DappFeeConfig {
-            free_credit,
-            base_fee,
-            byte_fee,
-        }
-    }
-
-    public fun free_credit(self: &DappFeeConfig): u256 {
-        self.free_credit
-    }
-
-    public fun base_fee(self: &DappFeeConfig): u256 {
-        self.base_fee
-    }
-
-    public fun byte_fee(self: &DappFeeConfig): u256 {
-        self.byte_fee
-    }
-
-    public fun update_free_credit(self: &mut DappFeeConfig, free_credit: u256) {
-        self.free_credit = free_credit
-    }
-
-    public fun update_base_fee(self: &mut DappFeeConfig, base_fee: u256) {
-        self.base_fee = base_fee
-    }
-
-    public fun update_byte_fee(self: &mut DappFeeConfig, byte_fee: u256) {
-        self.byte_fee = byte_fee
-    }
-
-    public fun has(dapp_hub: &DappHub): bool {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        dapp_service::has_record<DappKey>(dapp_hub, dapp_key::package_id().to_ascii_string(), key_tuple)
-    }
-
-    public fun ensure_has(dapp_hub: &DappHub) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        dapp_service::ensure_has_record<DappKey>(dapp_hub, dapp_key::package_id().to_ascii_string(), key_tuple)
-    }
-
-    public fun ensure_has_not(dapp_hub: &DappHub) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        dapp_service::ensure_has_not_record<DappKey>(dapp_hub, dapp_key::package_id().to_ascii_string(), key_tuple)
-    }
-  
-
-    public(package) fun delete(dapp_hub: &mut DappHub) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        dapp_service::delete_record<DappKey>(dapp_hub, dapp_key::new(), key_tuple, dapp_key::package_id().to_ascii_string());
-    }
-
-    public fun get_free_credit(dapp_hub: &DappHub): u256 {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value = dapp_service::get_field<DappKey>(dapp_hub, dapp_key::package_id().to_ascii_string(), key_tuple, 0);
-        let mut bsc_type = sui::bcs::new(value);
-        let free_credit = sui::bcs::peel_u256(&mut bsc_type);
-        free_credit
-    }
-
-    public(package) fun set_free_credit(dapp_hub: &mut DappHub, free_credit: u256) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value = to_bytes(&free_credit);
-        dapp_service::set_field(dapp_hub, dapp_key::new(), key_tuple, 0, value, dapp_key::package_id().to_ascii_string());
-    }
-
-    public fun get_base_fee(dapp_hub: &DappHub): u256 {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value = dapp_service::get_field<DappKey>(dapp_hub, dapp_key::package_id().to_ascii_string(), key_tuple, 1);
-        let mut bsc_type = sui::bcs::new(value);
-        let base_fee = sui::bcs::peel_u256(&mut bsc_type);
-        base_fee
-    }
-
-    public(package) fun set_base_fee(dapp_hub: &mut DappHub, base_fee: u256) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value = to_bytes(&base_fee);
-        dapp_service::set_field(dapp_hub, dapp_key::new(), key_tuple, 1, value, dapp_key::package_id().to_ascii_string());
-    }
-
-    public fun get_byte_fee(dapp_hub: &DappHub): u256 {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value = dapp_service::get_field<DappKey>(dapp_hub, dapp_key::package_id().to_ascii_string(), key_tuple, 2);
-        let mut bsc_type = sui::bcs::new(value);
-        let byte_fee = sui::bcs::peel_u256(&mut bsc_type);
-        byte_fee
-    }
-
-    public(package) fun set_byte_fee(dapp_hub: &mut DappHub, byte_fee: u256) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value = to_bytes(&byte_fee);
-        dapp_service::set_field(dapp_hub, dapp_key::new(), key_tuple, 2, value, dapp_key::package_id().to_ascii_string());
-    }
-
-    public fun get(dapp_hub: &DappHub): (u256, u256, u256) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value_tuple = dapp_service::get_record<DappKey>(dapp_hub, dapp_key::package_id().to_ascii_string(), key_tuple);
-        let mut bsc_type = sui::bcs::new(value_tuple);
-        let free_credit = sui::bcs::peel_u256(&mut bsc_type);
-        let base_fee = sui::bcs::peel_u256(&mut bsc_type);
-        let byte_fee = sui::bcs::peel_u256(&mut bsc_type);
-        (free_credit, base_fee, byte_fee)
-    }
-
-    public(package) fun set(dapp_hub: &mut DappHub, free_credit: u256, base_fee: u256, byte_fee: u256, ctx: &mut TxContext) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value_tuple = encode(free_credit, base_fee, byte_fee);
-        dapp_service::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, dapp_key::package_id().to_ascii_string(), OFFCHAIN, ctx);
-    }
-
-    public fun get_struct(dapp_hub: &DappHub): DappFeeConfig {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value_tuple = dapp_service::get_record<DappKey>(dapp_hub, dapp_key::package_id().to_ascii_string(), key_tuple);
-        decode(value_tuple)
-    }
-
-    public(package) fun set_struct(dapp_hub: &mut DappHub, dapp_fee_config: DappFeeConfig, ctx: &mut TxContext) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value_tuple = encode_struct(dapp_fee_config);
-        dapp_service::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, dapp_key::package_id().to_ascii_string(), OFFCHAIN, ctx);
-    }
-
-    public fun encode(free_credit: u256, base_fee: u256, byte_fee: u256): vector<vector<u8>> {
-        let mut value_tuple = vector::empty();
-        value_tuple.push_back(to_bytes(&free_credit));
-        value_tuple.push_back(to_bytes(&base_fee));
-        value_tuple.push_back(to_bytes(&byte_fee));
-        value_tuple
-    }
-
-    public fun encode_struct(dapp_fee_config: DappFeeConfig): vector<vector<u8>> {
-        encode(dapp_fee_config.free_credit, dapp_fee_config.base_fee, dapp_fee_config.byte_fee)
-    }
-
-    public fun decode(data: vector<u8>): DappFeeConfig {
-        let mut bsc_type = sui::bcs::new(data);
-        let free_credit = sui::bcs::peel_u256(&mut bsc_type);
-        let base_fee = sui::bcs::peel_u256(&mut bsc_type);
-        let byte_fee = sui::bcs::peel_u256(&mut bsc_type);
-        DappFeeConfig {
-            free_credit,
-            base_fee,
-            byte_fee,
-        }
-    }
-}