create-dubhe 0.1.13 → 1.2.0-pre.51

package/templates/contract/sui-template/src/dubhe/sources/core/dapp_store.move

@@ -0,0 +1,299 @@
+module dubhe::dapp_store {
+    use sui::table::{Self, Table};
+    use std::ascii::String;
+    use std::ascii::string;
+    use std::type_name;
+    use sui::bag;
+    use sui::bag::Bag;
+    use sui::clock::{Self, Clock};
+    use dubhe::dapp_metadata;
+    use dubhe::dapp_metadata::DappMetadata;
+    use dubhe::table_metadata;
+    use dubhe::table_metadata::TableMetadata;
+    use dubhe::dapp_fee_state;
+    use dubhe::dapp_fee_state::DappFeeState;
+
+    /// Error codes
+    const EInvalidTableId: u64 = 1;
+    const EInvalidKey: u64 = 2;
+    const EInvalidValue: u64 = 3;
+
+    /// Storage structure for DApp data and state management
+    public struct DappStore has key, store {
+        /// The unique identifier of the DappStore instance
+        id: UID,
+        /// The unique key identifier for the DApp
+        dapp_key: String,
+        /// Metadata containing DApp information like name, description, and version
+        dapp_metadata: DappMetadata,
+        /// State for managing transaction fees and usage statistics
+        dapp_fee_state: DappFeeState,
+        /// Stores metadata for each table, indexed by table_id
+        table_metadatas: Table<vector<u8>, TableMetadata>,
+        /// Stores the actual data tables, where each table contains key-value pairs
+        /// table_id => (key_tuple => value_tuple)
+        tables: Table<vector<u8>, Table<vector<vector<u8>>, vector<vector<u8>>>>,
+        /// Storage for miscellaneous objects that don't fit into the table structure
+        objects: Bag,
+    }
+
+    /// Create a new storage instance
+    public(package) fun new<DappKey: copy + drop>(
+        _: DappKey, 
+        name: vector<u8>,
+        description: vector<u8>,
+        clock: &Clock,
+        ctx: &mut TxContext
+    ): DappStore {
+        let dapp_key = type_name::get<DappKey>().into_string();
+        DappStore {
+            id: object::new(ctx),
+            dapp_key,
+            dapp_metadata: dapp_metadata::new(
+                string(name), 
+                string(description), 
+                string(b""),
+                vector::empty(), 
+                vector::empty(), 
+                vector::empty(), 
+                clock::timestamp_ms(clock),
+                ctx.sender(),
+                1,
+                false
+            ),
+            dapp_fee_state: dapp_fee_state::default(),
+            tables: table::new(ctx),
+            table_metadatas: table::new(ctx),
+            objects: bag::new(ctx),
+        }
+    }
+
+    /// Register a new table
+    public(package) fun register_table(
+        self: &mut DappStore,
+        table_id: vector<u8>,
+        name: vector<u8>,
+        key_schemas: vector<vector<u8>>,
+        key_names: vector<vector<u8>>,
+        value_schemas: vector<vector<u8>>,
+        value_names: vector<vector<u8>>,
+        ctx: &mut TxContext
+    ) {
+        // Create table metadata
+        let metadata = table_metadata::new(
+            name,
+            key_schemas,
+            key_names,
+            value_schemas,
+            value_names
+        );
+        // Add table metadata
+        self.table_metadatas.add(table_id, metadata);
+
+        // Create table data storage
+        self.tables.add(table_id, table::new(ctx));
+    }
+
+    /// Set a record
+    public(package) fun set_record(
+        self: &mut DappStore,
+        table_id: vector<u8>,
+        key_tuple: vector<vector<u8>>,
+        value_tuple: vector<vector<u8>>
+    ) {
+        assert!(self.tables.contains(table_id), EInvalidTableId);
+        
+        // Get table data
+        let table = self.tables.borrow_mut(table_id);
+        
+        // Store data
+        if (table.contains(key_tuple)) {
+            let value = table.borrow_mut(key_tuple);
+            *value = value_tuple;
+        } else {
+            table.add(key_tuple, value_tuple);
+        };
+    }
+
+    /// Set a field
+    public(package) fun set_field(
+        self: &mut DappStore,
+        table_id: vector<u8>,
+        key_tuple: vector<vector<u8>>,
+        field_index: u8,
+        value: vector<u8>
+    ) {
+        assert!(self.tables.contains(table_id), EInvalidTableId);
+        
+        // Get table data
+        let table = self.tables.borrow_mut(table_id);
+        
+        // Get existing data
+        let value_tuple = if (table.contains(key_tuple)) {
+            table.borrow_mut(key_tuple)
+        } else {
+            // Create a new record
+            let mut new_value = vector::empty();
+            let metadata = self.table_metadatas.borrow(table_id);
+            let field_len = metadata.get_value_schemas().length();
+            let mut i = 0;
+            while (i < field_len) {
+                new_value.push_back(vector::empty());
+                i = i + 1;
+            };
+            table.add(key_tuple, new_value);
+            table.borrow_mut(key_tuple)
+        };
+
+        // Update field
+        *value_tuple.borrow_mut(field_index as u64) = value;
+    }
+
+    /// Get a record
+    public fun get_record(
+        self: &DappStore,
+        table_id: vector<u8>,
+        key_tuple: vector<vector<u8>>
+    ): vector<u8> {
+        assert!(self.tables.contains(table_id), EInvalidTableId);
+        let table = self.tables.borrow(table_id);
+        assert!(table.contains(key_tuple), EInvalidKey);
+        let value_tuple = table.borrow(key_tuple);
+        let mut result = vector::empty();
+        let mut i = 0;
+        while (i < vector::length(value_tuple)) {
+            let value = vector::borrow(value_tuple, i);
+            assert!(!value.is_empty(), EInvalidValue);
+            vector::append(&mut result, *value);
+            i = i + 1;
+        };
+       result
+    }
+
+    /// Get a field
+    public fun get_field(
+        self: &DappStore,
+        table_id: vector<u8>,
+        key_tuple: vector<vector<u8>>,
+        field_index: u8
+    ): vector<u8> {
+        assert!(self.tables.contains(table_id), EInvalidTableId);
+        let table = self.tables.borrow(table_id);
+        assert!(table.contains(key_tuple), EInvalidKey);
+        let field = vector::borrow(table.borrow(key_tuple), field_index as u64);
+        assert!(!field.is_empty(), EInvalidValue);
+        *field
+    }
+
+    public fun has_record(
+        self: &DappStore,
+        table_id: vector<u8>,
+        key_tuple: vector<vector<u8>>
+    ): bool {
+        if (!self.tables.contains(table_id)) {
+            return false
+        };
+        let table = self.tables.borrow(table_id);
+        if (!table.contains(key_tuple)) {
+            return false
+        };
+        let value_tuple = table.borrow(key_tuple);
+        let mut i = 0;
+        while (i < value_tuple.length()) {
+            if (value_tuple.borrow(i).is_empty()) {
+                return false
+            };
+            i = i + 1;
+        };
+        true
+    }
+
+    public fun has_field(
+        self: &DappStore,
+        table_id: vector<u8>,
+        key_tuple: vector<vector<u8>>,
+        field_index: u8
+    ): bool {
+        if (!self.tables.contains(table_id)) {
+            return false
+        };
+        let table = self.tables.borrow(table_id);
+        if (!table.contains(key_tuple)) {
+            return false
+        };
+        let value_tuple = table.borrow(key_tuple);
+        if (value_tuple.length() <= field_index as u64) {
+            return false
+        };
+        if (value_tuple.borrow(field_index as u64).is_empty()) {
+            return false
+        };
+        true
+    }
+
+    public fun delete_record(
+        self: &mut DappStore,
+        table_id: vector<u8>,
+        key_tuple: vector<vector<u8>>
+    ): vector<vector<u8>> {
+        assert!(self.tables.contains(table_id), EInvalidTableId);
+        self.tables.borrow_mut(table_id).remove(key_tuple)
+    }
+
+public(package) fun calculate_bytes_size_and_fee(fee_state: &DappFeeState, key_tuple: vector<vector<u8>>, value_tuple: vector<vector<u8>>): (u256, u256) {
+    let mut total_bytes_size = 0;
+
+    let mut i = 0;
+    while (i < key_tuple.length()) {
+        let key_bytes_size = key_tuple[i].length();
+        total_bytes_size = total_bytes_size + key_bytes_size;
+        i = i + 1;
+    };
+
+    let mut j = 0;
+    while (j < value_tuple.length()) {
+        let value_bytes_size = value_tuple[j].length();
+        total_bytes_size = total_bytes_size + value_bytes_size;
+        j = j + 1;
+    };
+
+    (total_bytes_size as u256, total_bytes_size as u256 * fee_state.get_byte_fee() + fee_state.get_base_fee())
+}
+
+public(package) fun charge_fee(self: &mut DappStore, key_tuple: vector<vector<u8>>, value_tuple: vector<vector<u8>>) {
+   let ( bytes_size, fee ) = calculate_bytes_size_and_fee(&self.dapp_fee_state, key_tuple, value_tuple);
+   let fee_state = &mut self.dapp_fee_state;
+   let total_bytes_size = fee_state.get_total_bytes_size();
+   let total_paid = fee_state.get_total_paid();
+   let total_recharged = fee_state.get_total_recharged();
+   fee_state.set_total_bytes_size(total_bytes_size + bytes_size);
+   fee_state.set_total_paid(total_paid + fee);
+   fee_state.set_total_recharged(total_recharged - fee);
+}
+
+public(package) fun recharge(self: &mut DappStore, amount: u256) {
+    let fee_state = &mut self.dapp_fee_state;
+    let total_recharged = fee_state.get_total_recharged();
+    fee_state.set_total_recharged(total_recharged + amount);
+}
+
+    public fun get_dapp_key(self: &DappStore): String {
+        self.dapp_key
+    }
+
+    public fun get_dapp_metadata(self: &DappStore): DappMetadata {
+        self.dapp_metadata
+    }
+
+    public fun get_objects(self: &DappStore): &Bag {
+        &self.objects
+    }
+
+    public(package) fun get_mut_objects(self: &mut DappStore): &mut Bag {
+        &mut self.objects
+    }
+
+    public(package) fun set_dapp_metadata(self: &mut DappStore, dapp_metadata: DappMetadata) {
+        self.dapp_metadata = dapp_metadata
+    }
+}

package/templates/contract/sui-template/src/dubhe/sources/core/events.move

@@ -0,0 +1,58 @@
+module dubhe::dubhe_events;
+
+use sui::event;
+
+
+public struct Store_SetRecord has copy, drop {
+      table_id: vector<u8>,
+      key_tuple: vector<vector<u8>>,
+      value_tuple: vector<vector<u8>>
+}
+
+public fun new_store_set_record(table_id: vector<u8>, key_tuple: vector<vector<u8>>, value_tuple: vector<vector<u8>>): Store_SetRecord {
+      Store_SetRecord {
+            table_id,
+            key_tuple,
+            value_tuple
+      }
+}
+
+public fun emit_store_set_record(table_id: vector<u8>, key_tuple: vector<vector<u8>>, value_tuple: vector<vector<u8>>) {
+      event::emit(new_store_set_record(table_id, key_tuple, value_tuple));
+}
+
+public struct Store_SetField has copy, drop {
+      table_id: vector<u8>,
+      key_tuple: vector<vector<u8>>,
+      field_index: u8,
+      value: vector<u8>
+}
+
+public fun new_store_set_field(table_id: vector<u8>, key_tuple: vector<vector<u8>>, field_index: u8, value: vector<u8>): Store_SetField {
+      Store_SetField {
+            table_id,
+            key_tuple,
+            field_index,
+            value
+      }
+}
+
+public fun emit_store_set_field(table_id: vector<u8>, key_tuple: vector<vector<u8>>, field_index: u8, value: vector<u8>) {
+      event::emit(new_store_set_field(table_id, key_tuple, field_index, value));
+}
+
+public struct Store_DeleteRecord has copy, drop {
+      table_id: vector<u8>,
+      key_tuple: vector<vector<u8>>
+}
+
+public fun new_store_delete_record(table_id: vector<u8>, key_tuple: vector<vector<u8>>): Store_DeleteRecord {
+      Store_DeleteRecord {
+            table_id,
+            key_tuple
+      }
+}
+
+public fun emit_store_delete_record(table_id: vector<u8>, key_tuple: vector<vector<u8>>) {
+      event::emit(new_store_delete_record(table_id, key_tuple));
+}

package/templates/contract/sui-template/src/dubhe/sources/core/table_id.move

@@ -0,0 +1,37 @@
+module dubhe::table_id;
+
+const ONCHAIN_TABLE: vector<u8> = b"ont";
+const OFFCHAIN_TABLE: vector<u8> = b"oft";
+
+
+public fun onchain_table_type(): vector<u8> {
+    ONCHAIN_TABLE
+}
+
+public fun offchain_table_type(): vector<u8> {
+    OFFCHAIN_TABLE
+}
+
+public fun encode(table_type: vector<u8>, name: vector<u8>): vector<u8> { 
+      let mut table_id = table_type;
+      table_id.append(name);
+      table_id
+}
+
+public fun table_type(table_id: &vector<u8>): vector<u8> {
+    let mut table_type = vector::empty();
+    table_type.push_back(table_id[0]);
+    table_type.push_back(table_id[1]);
+    table_type.push_back(table_id[2]);
+    table_type
+}
+
+public fun table_name(table_id: &vector<u8>): vector<u8> {
+    let mut table_name = vector::empty<u8>();
+    let mut i = 3;
+    while (i < table_id.length()) {
+        table_name.push_back(table_id[i]);
+        i = i + 1;
+    };
+    table_name
+}

package/templates/contract/sui-template/src/dubhe/sources/core/table_metadata.move

@@ -0,0 +1,68 @@
+module dubhe::table_metadata;
+
+/// Table metadata structure
+public struct TableMetadata has store {
+    name: vector<u8>,
+    key_schemas: vector<vector<u8>>,
+    key_names: vector<vector<u8>>,
+    value_schemas: vector<vector<u8>>,
+    value_names: vector<vector<u8>>
+}
+
+/// Create a new table metadata
+public fun new(
+    name: vector<u8>,
+    key_schemas: vector<vector<u8>>,
+    key_names: vector<vector<u8>>,
+    value_schemas: vector<vector<u8>>,
+    value_names: vector<vector<u8>>
+): TableMetadata {
+    TableMetadata {
+        name,
+        key_schemas,
+        key_names,
+        value_schemas,
+        value_names
+    }
+}
+
+/// Get and set functions       
+public fun get_name(self: &TableMetadata): vector<u8> {
+    self.name
+}
+
+public fun get_key_schemas(self: &TableMetadata): vector<vector<u8>> {
+    self.key_schemas
+}
+
+public fun get_key_names(self: &TableMetadata): vector<vector<u8>> {
+    self.key_names
+}
+
+public fun get_value_schemas(self: &TableMetadata): vector<vector<u8>> {
+    self.value_schemas
+}
+
+public fun get_value_names(self: &TableMetadata): vector<vector<u8>> {
+    self.value_names
+}
+
+public(package) fun set_name(self: &mut TableMetadata, name: vector<u8>) {
+    self.name = name;
+}
+
+public(package) fun set_key_schemas(self: &mut TableMetadata, key_schemas: vector<vector<u8>>) {
+    self.key_schemas = key_schemas;
+}
+
+public(package) fun set_key_names(self: &mut TableMetadata, key_names: vector<vector<u8>>) {
+    self.key_names = key_names;
+}
+
+public(package) fun set_value_schemas(self: &mut TableMetadata, value_schemas: vector<vector<u8>>) {    
+    self.value_schemas = value_schemas;
+}
+
+public(package) fun set_value_names(self: &mut TableMetadata, value_names: vector<vector<u8>>) {
+    self.value_names = value_names;
+}

package/templates/contract/sui-template/src/dubhe/sources/scripts/deploy_hook.move

@@ -0,0 +1,58 @@
+  // Copyright (c) Obelisk Labs, Inc.
+  // SPDX-License-Identifier: Apache-2.0
+  #[allow(unused_use)]
+  
+  /* Autogenerated file. Do not edit manually. */
+  
+  module dubhe::deploy_hook {
+
+  use dubhe::dapp_service::DappHub;
+  use dubhe::dubhe_config;
+  use dubhe::bridge_config;
+  use dubhe::dubhe_asset_id;
+  use dubhe::wrapper_system;
+  use sui::sui::SUI;
+  use dubhe::dubhe::DUBHE;
+
+  public(package) fun run(dapp_hub: &mut DappHub, ctx: &mut TxContext) {
+    let next_asset_id = 0;
+      // 0.3% swap fee
+    let swap_fee = 30;
+    let fee_to = ctx.sender();
+    let max_swap_path_len = 6;
+    dubhe_config::set(
+      dapp_hub, 
+      next_asset_id, 
+      swap_fee, 
+      fee_to, 
+      max_swap_path_len,
+      ctx.sender()
+    );
+
+    // set bridge config
+    bridge_config::set(dapp_hub, b"Dubhe OS", 10 * 10000000, 2 * 10000000, true);
+    bridge_config::set(dapp_hub, b"Aptos", 10 * 10000000, 2 * 10000000, true);
+
+    let sui_asset_id = wrapper_system::do_register<SUI>(
+      dapp_hub,
+      b"Wrapped SUI",
+      b"wSUI",
+      b"Wrapped SUI",
+    9,
+    b"https://cryptologos.cc/logos/sui-sui-logo.png?v=040",
+    );
+    let dubhe_asset_id = wrapper_system::do_register<DUBHE>(
+      dapp_hub,
+      b"Wrapped DUBHE",
+      b"wDUBHE",
+      b"Wrapped DUBHE",
+      7,
+      b"https://raw.githubusercontent.com/0xobelisk/dubhe/refs/heads/main/assets/logo.jpg",
+    );
+    dubhe_asset_id::set(dapp_hub, dubhe_asset_id);
+
+    std::debug::print(&sui_asset_id);
+    std::debug::print(&dubhe_asset_id);
+    
+  }
+}

package/templates/contract/sui-template/src/dubhe/sources/scripts/migrate.move

@@ -0,0 +1,8 @@
+module dubhe::migrate {
+
+  const ON_CHAIN_VERSION: u32 = 1;
+
+  public fun on_chain_version(): u32 {
+    ON_CHAIN_VERSION
+  }
+}