create-dubhe 0.0.1

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/storages/double_map.move

@@ -0,0 +1,156 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#[allow(unused_variable)]
+module dubhe::storage_double_map {
+
+    // This key does not exist in the map
+    const EKeyDoesNotExist: u64 = 0;
+
+    /// This key already exists in the map
+    const EKeyAlreadyExists: u64 = 1;
+
+    // An entry in the map
+    public struct Entry<K1: copy + drop + store, K2: copy + drop + store, V: store> has copy, drop, store {
+        key1: K1,
+        key2: K2,
+        value: V,
+    }
+
+    // A map data structure backed by a vector. The map is guaranteed not to contain duplicate keys, but entries
+    public struct StorageDoubleMap<K1: copy + drop + store, K2: copy + drop + store, V: store> has store {
+        contents: vector<Entry<K1, K2, V>>,
+    }
+
+    // Create an empty `StorageDoubleMap`
+    public fun new<K1: copy + drop + store, K2: copy + drop + store, V: store>(): StorageDoubleMap<K1, K2,V> {
+        StorageDoubleMap { contents: vector[] }
+    }
+
+    // Return true if `self` contains_key an entry for `key`, false otherwise
+    public fun contains_key<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): bool {
+        get_idx_opt(self, key1, key2).is_some()
+    }
+
+    // Return the number of entries in `self`
+    public fun length<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>): u64 {
+        self.contents.length()
+    }
+
+    // Get a reference to the value bound to `key` in `self`.
+    // Aborts if `key` is not bound in `self`.
+    public fun borrow<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): &V {
+        let idx = self.get_idx(key1, key2);
+        let entry = &self.contents[idx];
+        &entry.value
+    }
+
+    // Get a mutable reference to the value bound to `key` in `self`.
+    // Aborts if `key` is not bound in `self`.
+    public fun borrow_mut<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &mut StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): &mut V {
+        let idx = self.get_idx(key1, key2);
+        let entry = &mut self.contents[idx];
+        &mut entry.value
+    }
+
+    // Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun take<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &mut StorageDoubleMap<K1, K2,V>, key1: K1, key2: K2): V {
+        let idx = self.get_idx(key1, key2);
+        let Entry { key1, key2, value } = self.contents.remove(idx);
+        value
+    }
+
+    public macro fun mutate<$K1: copy + drop, $K2: copy + drop, $V: copy + drop>(
+        $self: &mut StorageDoubleMap<$K1, $K2, $V>,
+        $key1: $K1,
+        $key2: $K2,
+        $f: |&mut $V|
+    ) {
+        let self = $self;
+        let key1 = $key1;
+        let key2 = $key2;
+        $f(borrow_mut(self, key1, key2));
+    }
+
+    // Returns a list of keys in the map.
+    // Do not assume any particular ordering.
+    public fun keys<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>): (vector<K1>, vector<K2>) {
+        let mut i = 0;
+        let n = self.contents.length();
+        let mut keys1 = vector[];
+        let mut keys2 = vector[];
+        while (i < n) {
+            let entry = self.contents.borrow(i);
+            keys1.push_back(entry.key1);
+            keys2.push_back(entry.key2);
+            i = i + 1;
+        };
+        (keys1, keys2)
+    }
+
+    // Find the index of `key` in `self`. Return `None` if `key` is not in `self`.
+    // Note that map entries are stored in insertion order, *not* sorted by key.
+    public fun get_idx_opt<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): Option<u64> {
+        self.contents.find_index!(|entry| { entry.key1 == key1 && entry.key2 == key2 })
+    }
+
+    // Find the index of `key` in `self`. Aborts if `key` is not in `self`.
+    // Note that map entries are stored in insertion order, *not* sorted by key.
+    public fun get_idx<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): u64 {
+        let idx_opt = self.get_idx_opt(key1, key2);
+        assert!(idx_opt.is_some(), EKeyDoesNotExist);
+        idx_opt.destroy_some()
+    }
+
+    /// Insert the entry `key` |-> `value` into `self`.
+    /// Aborts if `key` is already bound in `self`.
+    public fun insert<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &mut StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2, value: V) {
+        assert!(!self.contains_key(key1, key2), EKeyAlreadyExists);
+        self.contents.push_back(Entry { key1, key2, value })
+    }
+
+    // =======================================Value: drop + copy + store=======================================
+
+    // Insert the entry `key` |-> `value` into `self`.
+    public fun set<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &mut StorageDoubleMap<K1, K2,V>, key1: K1, key2: K2, value: V) {
+        let idx = self.get_idx_opt(key1, key2);
+        if (idx.is_some()) {
+            self.contents[idx.destroy_some()].value = value;
+        } else {
+            self.contents.push_back(Entry { key1, key2, value })
+        }
+    }
+
+    // Get a reference to the value bound to `key` in `self`.
+    // Aborts if `key` is not bound in `self`.
+    public fun get<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): V {
+        let idx = self.get_idx(key1, key2);
+        let entry = &self.contents[idx];
+        entry.value
+    }
+
+    // Safely try borrow a value bound to `key` in `self`.
+    // Return Some(V) if the value exists, None otherwise.
+    // Only works for a "copyable" value as references cannot be stored in `vector`.
+    public fun try_get<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): Option<V> {
+        if (self.contains_key(key1, key2)) {
+            option::some(get(self, key1, key2))
+        } else {
+            option::none()
+        }
+    }
+
+    // Remove the entry `key` |-> `value` from self.
+    public fun remove<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &mut StorageDoubleMap<K1, K2,V>, key1: K1, key2: K2) {
+        let idx = self.get_idx_opt(key1, key2);
+        if (idx.is_some()) {
+            self.contents.remove(idx.destroy_some());
+        }
+    }
+
+    // Returns a list of values in the map.
+    // Do not assume any particular ordering.
+    public fun values<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &StorageDoubleMap<K1, K2, V>): vector<V> {
+        self.contents.map!(|entry| entry.value)
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/storages/map.move

@@ -0,0 +1,159 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#[allow(unused_variable)]
+module dubhe::storage_map {
+
+    /// This key already exists in the map
+    const EKeyAlreadyExists: u64 = 0;
+
+    /// This key does not exist in the map
+    const EKeyDoesNotExist: u64 = 1;
+
+    /// An entry in the map
+    public struct Entry<K: copy + drop + store, V: store> has copy, drop, store {
+        key: K,
+        value: V,
+    }
+
+    /// A map data structure backed by a vector. The map is guaranteed not to contain duplicate keys, but entries
+    /// are *not* sorted by key--entries are included in insertion order.
+    /// All operations are O(N) in the size of the map--the intention of this data structure is only to provide
+    /// the convenience of programming against a map API.
+    /// Large maps should use handwritten parent/child relationships instead.
+    /// Maps that need sorted iteration rather than insertion order iteration should also be handwritten.
+    public struct StorageMap<K: copy + drop + store, V: store> has store {
+        contents: vector<Entry<K, V>>,
+    }
+
+    /// Create an empty `StorageMap`
+    public fun new<K: copy + drop + store, V: store>(): StorageMap<K, V> {
+        StorageMap { contents: vector[] }
+    }
+
+    /// Return true if `self` contains_key an entry for `key`, false otherwise
+    public fun contains_key<K: copy + drop + store, V: store>(self: &StorageMap<K, V>, key: K): bool {
+        get_idx_opt(self, key).is_some()
+    }
+
+    /// Return the number of entries in `self`
+    public fun length<K: copy + drop + store, V: store>(self: &StorageMap<K,V>): u64 {
+        self.contents.length()
+    }
+
+    /// Get a reference to the value bound to `key` in `self`.
+    /// Aborts if `key` is not bound in `self`.
+    public fun borrow<K: copy + drop + store, V: store>(self: &StorageMap<K,V>, key: K): &V {
+        let idx = self.get_idx(key);
+        let entry = &self.contents[idx];
+        &entry.value
+    }
+
+
+    /// Get a mutable reference to the value bound to `key` in `self`.
+    /// Aborts if `key` is not bound in `self`.
+    public fun borrow_mut<K: copy + drop + store, V: store>(self: &mut StorageMap<K,V>, key: K): &mut V {
+        let idx = self.get_idx(key);
+        let entry = &mut self.contents[idx];
+        &mut entry.value
+    }
+
+    /// Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun take<K: copy + drop + store, V: store>(self: &mut StorageMap<K,V>, key: K): V {
+        let idx = self.get_idx(key);
+        let Entry { key, value } = self.contents.remove(idx);
+        value
+    }
+
+    public macro fun mutate<$K: copy + drop + store, $V: store>(
+        $self: &mut StorageMap<$K, $V>,
+        $key: $K,
+        $f: |&mut $V|
+    ) {
+        let self = $self;
+        let key = $key;
+        $f(borrow_mut(self, key));
+    }
+
+    /// Returns a list of keys in the map.
+    /// Do not assume any particular ordering.
+    public fun keys<K: copy + drop + store, V: store>(self: &StorageMap<K, V>): vector<K> {
+        let mut i = 0;
+        let n = self.contents.length();
+        let mut keys = vector[];
+        while (i < n) {
+            let entry = self.contents.borrow(i);
+            keys.push_back(entry.key);
+            i = i + 1;
+        };
+        keys
+    }
+
+    /// Find the index of `key` in `self`. Return `None` if `key` is not in `self`.
+    /// Note that map entries are stored in insertion order, *not* sorted by key.
+    public fun get_idx_opt<K: copy + drop + store, V: store>(self: &StorageMap<K,V>, key: K): Option<u64> {
+        self.contents.find_index!(|entry| { entry.key == key})
+    }
+
+    /// Find the index of `key` in `self`. Aborts if `key` is not in `self`.
+    /// Note that map entries are stored in insertion order, *not* sorted by key.
+    public fun get_idx<K: copy + drop + store, V: store>(self: &StorageMap<K,V>, key: K): u64 {
+        let idx_opt = self.get_idx_opt(key);
+        assert!(idx_opt.is_some(), EKeyDoesNotExist);
+        idx_opt.destroy_some()
+    }
+
+    /// Insert the entry `key` |-> `value` into `self`.
+    /// Aborts if `key` is already bound in `self`.
+    public fun insert<K: copy + drop + store, V: store>(self: &mut StorageMap<K,V>, key: K, value: V) {
+        assert!(!self.contains_key(key), EKeyAlreadyExists);
+        self.contents.push_back(Entry { key, value })
+    }
+
+    // =======================================Value: drop + copy + store=======================================
+
+    /// Adds a key-value pair to the self `self: &mut StorageMap<K, V>`
+    /// Aborts with `sui::dynamic_field::EFieldAlreadyExists` if the self already has an entry with
+    /// that key `k: K`.
+    public fun set<K: copy + drop + store, V: copy + drop + store>(self: &mut StorageMap<K, V>, key: K, value: V) {
+        let idx = self.get_idx_opt(key);
+        if (idx.is_some()) {
+            self.contents[idx.destroy_some()].value = value;
+        } else {
+            self.contents.push_back(Entry { key, value })
+        }
+    }
+
+    /// Get a reference to the value bound to `key` in `self`.
+    /// Aborts if `key` is not bound in `self`.
+    public fun get<K: copy + drop + store, V: copy + drop + store>(self: &StorageMap<K,V>, key: K): V {
+        let idx = self.get_idx(key);
+        let entry = &self.contents[idx];
+        entry.value
+    }
+
+    /// Safely try borrow a value bound to `key` in `self`.
+    /// Return Some(V) if the value exists, None otherwise.
+    /// Only works for a "copyable" value as references cannot be stored in `vector`.
+    public fun try_get<K: copy + drop + store, V: copy + drop + store>(self: &StorageMap<K,V>, key: K): Option<V> {
+        if (self.contains_key(key)) {
+            option::some(get(self, key))
+        } else {
+            option::none()
+        }
+    }
+
+    /// Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun remove<K: copy + drop + store, V: copy + drop + store>(self: &mut StorageMap<K,V>, key: K) {
+        let idx = self.get_idx_opt(key);
+        if (idx.is_some()) {
+            self.contents.remove(idx.destroy_some());
+        }
+    }
+
+    // Returns a list of values in the map.
+    // Do not assume any particular ordering.
+    public fun values<K: copy + drop + store, V: copy + drop + store>(self: &StorageMap<K, V>): vector<V> {
+        self.contents.map!(|entry| entry.value)
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/storages/value.move

@@ -0,0 +1,100 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+module dubhe::storage_value {
+
+    /// This key does not exist in the map
+    const EValueDoesNotExist: u64 = 0;
+
+    /// This key does not exist in the map
+    const EValueAlreadyExist: u64 = 1;
+
+    /// An entry in the value
+    public struct Entry<Value: store> has copy, drop, store {
+        value: Value,
+    }
+
+    /// A storable handler for values in general. Is used in the `StorageValue`
+    public struct StorageValue<Value: store> has store {
+        contents: vector<Entry<Value>>,
+    }
+
+    /// Creates a new, empty StorageValue
+    public fun new<Value: store>(): StorageValue<Value> {
+        StorageValue { contents: vector[] }
+    }
+
+    /// Gets the value of the StorageValue `self: &StorageValue<Value>`.
+    public fun borrow<Value: store>(self: &StorageValue<Value>): &Value {
+        assert!(self.contains(), EValueDoesNotExist);
+        &self.contents[0].value
+    }
+
+    /// Gets the value of the StorageValue `self: &mut StorageValue<Value>`.
+    public fun borrow_mut<Value: store>(self: &mut StorageValue<Value>): &mut Value {
+        assert!(self.contains(), EValueDoesNotExist);
+        &mut self.contents[0].value
+    }
+
+    /// Update the `value` of the `StorageValue`.
+    public macro fun mutate<$Value: store>($self: &mut StorageValue<$Value>, $f: |&mut $Value|) {
+        let self = $self;
+        $f(borrow_mut(self));
+    }
+
+    /// Return true if `self` contains_key an entry for `key`, false otherwise
+    public fun contains<V: store>(self: &StorageValue<V>): bool {
+        self.contents.length() == 1
+    }
+
+    /// Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun take<V: store>(self: &mut StorageValue<V>): V {
+        assert!(self.contains(), EValueDoesNotExist);
+        let Entry { value } = self.contents.remove(0);
+        value
+    }
+
+    /// Set the `value` of the `StorageValue`.
+    public fun put<V: store>(self: &mut StorageValue<V>, value: V) {
+        assert!(!self.contains(), EValueAlreadyExist);
+        self.contents.push_back(Entry { value });
+    }
+
+
+    // ======================================= Value: drop + copy + store =======================================
+
+    /// Set the `value` of the `StorageValue`.
+    public fun set<V: copy + drop + store>(self: &mut StorageValue<V>, value: V) {
+        if (self.contains()) {
+            *self.borrow_mut() = value;
+        } else {
+            self.contents.push_back(Entry { value });
+        }
+    }
+
+    /// Get the `value` of the `StorageValue`.
+    public fun get<V: copy + drop + store>(self: &StorageValue<V>): V {
+        assert!(self.contains(), EValueDoesNotExist);
+        self.contents[0].value
+    }
+
+    /// Safely try borrow a value bound to `key` in `self`.
+    /// Return Some(V) if the value exists, None otherwise.
+    /// Only works for a "copyable" value as references cannot be stored in `vector`.
+    public fun try_get<V: copy + drop + store>(self: &StorageValue<V>): Option<V> {
+        if (self.contains()) {
+            option::some(self.contents[0].value)
+        } else {
+            option::none()
+        }
+    }
+
+    /// Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun remove<V: copy + drop + store>(self: &mut StorageValue<V>) {
+        if (self.contains()) {
+            self.contents.remove(0);
+        }
+    }
+
+    // ============================================================================================
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/systems/dapps.move

@@ -0,0 +1,90 @@
+module dubhe::dapps_system {
+    use std::ascii::String;
+    use std::ascii;
+    use std::type_name;
+    use sui::address;
+    use dubhe::dapp_metadata;
+    use sui::clock::Clock;
+    use dubhe::dapps_schema::Dapps;
+
+    public fun current_package_id<T>(): address {
+        let dapp_package_id_string = type_name::get<T>().get_address().into_bytes();
+        address::from_ascii_bytes(&dapp_package_id_string)
+    }
+
+    public entry fun register<T>(
+        dapps: &mut Dapps,
+        name: String,
+        description: String,
+        clock: &Clock,
+        ctx: &mut TxContext
+    ) {
+        let dapp_package_id = current_package_id<T>();
+        assert!(!dapps.borrow_metadata().contains_key(dapp_package_id), 0);
+
+        dapps.borrow_mut_metadata().set(
+            dapp_package_id,
+            dapp_metadata::new(
+                name,
+                description,
+                ascii::string(b""),
+                ascii::string(b""),
+                clock.timestamp_ms(),
+                vector[]
+            )
+        );
+        dapps.borrow_mut_admin().set(dapp_package_id, ctx.sender());
+        dapps.borrow_mut_version().set(dapp_package_id, 0);
+        dapps.borrow_mut_schemas().set(dapp_package_id, vector[]);
+        dapps.borrow_mut_safe_mode().set(dapp_package_id, false);
+    }
+
+    public entry fun set_metadata(
+        dapps: &mut Dapps,
+        package_id: address,
+        clock: &Clock,
+        name: String,
+        description: String,
+        icon_url: String,
+        website_url: String,
+        partners: vector<String>,
+        ctx: &mut TxContext
+    ) {
+        assert!(dapps.borrow_admin().get(package_id) == ctx.sender(), 0);
+        let created_at = clock.timestamp_ms();
+        assert!(dapps.borrow_metadata().contains_key(package_id), 0);
+        dapps.borrow_mut_metadata().mutate!(package_id, |metadata| {
+            metadata.set(name, description, icon_url, website_url, created_at, partners);
+        });
+    }
+
+    public entry fun add_schema<T>(dapps: &mut Dapps, package_id: address, ctx: &mut TxContext) {
+        assert!(dapps.borrow_admin().get(package_id) == ctx.sender(), 0);
+        let schema = type_name::get<T>().into_string();
+        assert!(!dapps.borrow_schemas().get(package_id).contains(&schema), 0);
+        dapps.borrow_mut_schemas().mutate!(package_id, |schemas| {
+            schemas.push_back(schema);
+        });
+    }
+
+    public entry fun transfer_ownership(
+        dapps: &mut Dapps,
+        package_id: address,
+        new_admin: address,
+        ctx: &mut TxContext
+    ) {
+        assert!(dapps.borrow_admin().get(package_id) == ctx.sender(), 0);
+        dapps.borrow_mut_admin().set(package_id, new_admin);
+    }
+
+    public fun assert_admin<T: drop>(dapps: &Dapps, ctx: &TxContext) {
+        let package_id = current_package_id<T>();
+        assert!(dapps.borrow_admin().get(package_id) == ctx.sender(), 0);
+    }
+
+    public fun assert_is_safe_mode<T: drop>(dapps: &Dapps) {
+        let package_id = current_package_id<T>();
+        assert!(!dapps.borrow_safe_mode().get(package_id), 0);
+    }
+
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/world.move

@@ -0,0 +1,81 @@
+module dubhe::world {
+    use std::ascii::{String};
+    use sui::bag::{Self, Bag};
+
+    public struct AdminCap has key, store {
+        id: UID,
+    }
+
+    public struct World has key, store {
+        id: UID,
+        /// Name of the world
+        name: String,
+        /// Description of the world
+        description: String,
+        /// Schemas of the world
+        schemas: Bag,
+        /// Schema names of the world
+        schema_names: vector<String>,
+        /// admin of the world
+        admin: ID,
+        /// version of the world
+        version: u64
+    }
+
+    public fun create(name: String, description: String, ctx: &mut TxContext): (World, AdminCap) {
+        let admin_cap = AdminCap {
+            id: object::new(ctx),
+        };
+        let world = World {
+            id: object::new(ctx),
+            name,
+            description,
+            schemas: bag::new(ctx),
+            schema_names: vector::empty(),
+            admin: object::id(&admin_cap),
+            version: 1,
+        };
+        (world, admin_cap)
+    }
+    
+    public fun admin(world: &World): ID {
+        world.admin
+    }
+
+    public fun version(world: &World): u64 {
+        world.version
+    }
+
+    public fun mut_version(world: &mut World, admin_cap: &AdminCap): &mut u64 {
+        assert!(world.admin() == object::id(admin_cap), 0);
+        &mut world.version
+    }
+
+    public fun info(world: &World): (String, String) {
+        (world.name, world.description)
+    }
+
+    public fun schema_names(world: &World): vector<String> {
+        world.schema_names
+    }
+
+    public(package) fun mut_schema_names(world: &mut World): &mut vector<String> {
+        &mut world.schema_names
+    }
+
+    public(package) fun mut_uid(world: &mut World): &mut UID {
+        &mut world.id
+    }
+
+    public(package) fun uid(world: &World): &UID {
+        &world.id
+    }
+
+    public(package) fun schemas(world: &World): &Bag {
+        &world.schemas
+    }
+
+    public(package) fun mut_schemas(world: &mut World): &mut Bag {
+        &mut world.schemas
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/tests/dapp.move

@@ -0,0 +1,16 @@
+#[test_only]
+module dubhe::dapps_tests {
+    use std::debug;
+    use std::type_name;
+    use sui::address;
+
+    public struct USDT has drop {}
+
+    #[test]
+    public fun dapps_register() {
+        let name = type_name::get<USDT>().get_address().into_bytes();
+        let package_id = address::from_ascii_bytes(&name);
+        debug::print(&package_id);
+        debug::print(&type_name::get<USDT>().get_module());
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/tests/init.move

@@ -0,0 +1,6 @@
+#[test_only]
+module dubhe::init_tests {
+    public fun init_dubhe_for_testing(ctx: &mut TxContext){
+        dubhe::dapps_schema::init_dapps_for_testing(ctx);
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/tests/obelisk_framework_tests.move

@@ -0,0 +1,19 @@
+/*
+#[test_only]
+module dubhe_framework::dubhe_framework_tests {
+    // uncomment this line to import the module
+    // use dubhe_framework::dubhe_framework;
+
+    const ENotImplemented: u64 = 0;
+
+    #[test]
+    fun test_dubhe_framework() {
+        // pass
+    }
+
+    #[test, expected_failure(abort_code = ::dubhe_framework::dubhe_framework_tests::ENotImplemented)]
+    fun test_dubhe_framework_fail() {
+        abort ENotImplemented
+    }
+}
+*/