create-dubhe 0.0.4 → 0.0.5

package/template/101/rooch-template/src/jotai/index.tsx

@@ -0,0 +1,12 @@
+import { atom } from 'jotai';
+
+const SellPopUpBoxState = atom(false);
+const SellState = atom({
+  type: '',
+  hash: '',
+  state: false,
+});
+const OpenBoxState = atom(false);
+const Value = atom('');
+
+export { SellPopUpBoxState, SellState, OpenBoxState, Value };

package/template/101/rooch-template/src/pages/_app.tsx

@@ -0,0 +1,9 @@
+import 'tailwindcss/tailwind.css';
+import '../css/font-awesome.css';
+import type { AppProps } from 'next/app';
+
+function MyApp({ Component, pageProps }: AppProps) {
+  return <Component {...pageProps} />;
+}
+
+export default MyApp;

package/template/101/rooch-template/src/pages/home/index.tsx

@@ -0,0 +1,82 @@
+import { loadMetadata, Dubhe, Transaction } from '@0xobelisk/rooch-client';
+import { useEffect, useState } from 'react';
+import { useAtom } from 'jotai';
+import { Value } from '../../jotai';
+import { useRouter } from 'next/router';
+import { NETWORK, PACKAGE_ID } from '../../chain/config';
+import { PRIVATEKEY } from '../../chain/key';
+
+const Home = () => {
+  const router = useRouter();
+  const [value, setValue] = useAtom(Value);
+  const [loading, setLoading] = useState(false);
+
+  const query_counter_value = async () => {
+    const metadata = await loadMetadata(NETWORK, PACKAGE_ID, ['counter']);
+    const dubhe = new Dubhe({
+      networkType: NETWORK,
+      packageId: PACKAGE_ID,
+      metadata: metadata,
+    });
+    const query_value = await dubhe.query.counter.value();
+
+    if (query_value.return_values) {
+      console.log(query_value.return_values[0].decoded_value);
+      setValue(query_value.return_values[0].decoded_value.toString());
+    }
+  };
+
+  const counter = async () => {
+    setLoading(true);
+    try {
+      const metadata = await loadMetadata(NETWORK, PACKAGE_ID, ['counter']);
+      const dubhe = new Dubhe({
+        networkType: NETWORK,
+        packageId: PACKAGE_ID,
+        metadata: metadata,
+        secretKey: PRIVATEKEY,
+      });
+
+      const tx = new Transaction();
+      const response = await dubhe.tx.counter.increase(tx);
+      console.log(response.execution_info.tx_hash, response.execution_info.status.type);
+      if (response.execution_info.status.type == 'executed') {
+        setTimeout(async () => {
+          await query_counter_value();
+          setLoading(false);
+        }, 200);
+      }
+    } catch (error) {
+      setLoading(false);
+      console.error(error);
+    }
+  };
+
+  useEffect(() => {
+    if (router.isReady) {
+      query_counter_value();
+    }
+  }, [router.isReady]);
+  return (
+    <div className="max-w-7xl mx-auto text-center py-12 px-4 sm:px-6 lg:py-16 lg:px-8 flex-6">
+      <div className="flex flex-col gap-6 mt-12">
+        <div className="flex flex-col gap-4">
+          You account already have some sui from testnet
+          <div className="flex flex-col gap-6 text-2xl text-green-600 mt-6 ">Counter: {value}</div>
+          <div className="flex flex-col gap-6">
+            <button
+              type="button"
+              className="mx-auto px-5 py-3 border border-transparent text-base font-medium rounded-md text-white bg-indigo-600 hover:bg-indigo-700"
+              onClick={() => counter()}
+              disabled={loading}
+            >
+              {loading ? 'Processing...' : 'Increment'}
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default Home;

package/template/101/rooch-template/src/pages/index.tsx

@@ -0,0 +1,14 @@
+import type { NextPage } from 'next';
+import Home from "./home";
+
+const IndexPage: NextPage = () => {
+  return (
+      <main>
+          <Home/>
+      </main>
+  )
+}
+
+export default IndexPage
+
+

package/template/101/rooch-template/tailwind.config.js

@@ -0,0 +1,56 @@
+const defaultTheme = require('tailwindcss/defaultTheme')
+
+module.exports = {
+
+    content: ['./src/**/*.{js,ts,jsx,tsx}'],
+    darkMode: 'media', // or 'media' or 'class'
+    theme: {
+        extend: {
+            spacing: {
+                "70":"17rem",
+                '78':'18rem',
+                '82': '20rem',
+                '90': '22rem',
+                '93': '23rem',
+                '97': '25rem',
+                '98': '27rem',
+                '99': "30rem",
+                "new":"34rem",
+                "new-1":"39rem",
+                "100":"43rem",
+                "105":"46rem",
+                "106":"48rem",
+            },
+            colors: {
+                transparent: 'transparent',
+                current: 'currentColor',
+                custom:{
+                    DEFAULT:'#8861D1',
+                    light:"#8861D1",
+                    dark:"#8861D1",
+                }
+
+            },
+            screens: {
+                '3xl': '1700px',
+            },
+            fontFamily: {
+                sans: ['Inter var', ...defaultTheme.fontFamily.sans],
+            },
+
+        },
+
+
+
+    },
+    plugins: [
+
+        require('@tailwindcss/line-clamp'),
+        require('tailwind-scrollbar'),
+    ],
+    variants: {
+        scrollbar: ['rounded']
+    }
+
+}
+

package/template/101/rooch-template/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "ts-node": {
+    "compilerOptions": {
+      "module": "CommonJS"
+    }
+  },
+  "compilerOptions": {
+    "target": "es6",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules"]
+}

package/template/101/sui-template/contracts/counter/Move.toml

@@ -5,9 +5,9 @@ edition = "2024.beta"
 
 [dependencies]
 Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.36.2" }
-Dubhe = { git = "https://github.com/0xobelisk/dubhe.git", subdir = "packages/dubhe-framework", rev = "main" }
+Dubhe = { local = "../../localnet/dubhe-framework" }
 
 [addresses]
 sui = "0x2"
-dubhe = "0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28"
-counter = "0x0"
+dubhe = "0xe2793ee7dd5f05c73969577b0074f29aae3f70ab33c57dd42681ca29196e6a04"
+counter = "0x0"

package/template/101/sui-template/contracts/counter/sources/codegen/schema_hub.move

@@ -0,0 +1,60 @@
+  // Copyright (c) Obelisk Labs, Inc.
+  // SPDX-License-Identifier: MIT
+  #[allow(unused_use)]
+  
+  /* Autogenerated file. Do not edit manually. */
+  
+  module counter::schema_hub {
+
+  use sui::transfer::public_share_object;
+
+  use sui::dynamic_field as df;
+
+  public struct SchemaHub has key, store {
+    id: UID,
+    admin: address,
+  }
+
+  public struct SchemaTypeWapper<phantom Schema: key + store> has copy, store, drop {}
+
+  /// Authorize an schema to access protected features of the SchemaHub.
+
+  public(package) fun authorize_schema<Schema: key + store>(self: &mut SchemaHub) {
+    df::add(&mut self.id, SchemaTypeWapper<Schema> {}, true);
+  }
+
+  /// Deauthorize an schema by removing its authorization key.
+
+  public(package) fun deauthorize_schema<Schema: key + store>(self: &mut SchemaHub) {
+    df::remove<SchemaTypeWapper<Schema>, bool>(&mut self.id, SchemaTypeWapper<Schema> {});
+  }
+
+  /// Check if an schema is authorized to access protected features of
+
+  /// the SchemaHub.
+
+  public fun is_schema_authorized<Schema: key + store>(self: &SchemaHub): bool {
+    df::exists_(&self.id, SchemaTypeWapper<Schema> {})
+  }
+
+  /// Assert that an schema is authorized to access protected features of
+
+  /// the SchemaHub. Aborts with `EAppNotAuthorized` if not.
+
+  public fun ensure_schema_authorized<Schema: key + store>(self: &SchemaHub) {
+    assert!(self.is_schema_authorized<Schema>(), 0);
+  }
+
+  fun init(ctx: &mut TxContext) {
+    public_share_object(SchemaHub {
+            id: object::new(ctx),
+            admin: ctx.sender(),
+        });
+  }
+
+  #[test_only]
+
+  public fun init_schema_hub_for_testing(ctx: &mut TxContext) {
+    init(ctx);
+  }
+}

package/template/101/sui-template/contracts/counter/sources/codegen/schemas/counter.move

@@ -8,10 +8,16 @@
 
   use std::ascii::String;
 
+  use std::ascii::string;
+
+  use sui::package::UpgradeCap;
+
   use std::type_name;
 
   use dubhe::dapps_system;
 
+  use dubhe::storage_migrate;
+
   use dubhe::dapps_schema::Dapps;
 
   use dubhe::storage_value::{Self, StorageValue};
@@ -22,36 +28,32 @@
 
   use counter::dapp_key::DappKey;
 
+  use sui::dynamic_field as df;
+
   public struct Counter has key, store {
     id: UID,
-    value: StorageValue<u32>,
   }
 
   public fun borrow_value(self: &Counter): &StorageValue<u32> {
-    &self.value
+    storage_migrate::borrow_field(&self.id, b"value")
   }
 
   public(package) fun borrow_mut_value(self: &mut Counter): &mut StorageValue<u32> {
-    &mut self.value
+    storage_migrate::borrow_mut_field(&mut self.id, b"value")
   }
 
-  public fun register(dapps: &mut Dapps, ctx: &mut TxContext): Counter {
-    let package_id = dapps_system::current_package_id<DappKey>();
-    assert!(dapps.borrow_metadata().contains_key(package_id), 0);
-    assert!(dapps.borrow_admin().get(package_id) == ctx.sender(), 0);
-    let schema = type_name::get<Counter>().into_string();
-    assert!(!dapps.borrow_schemas().get(package_id).contains(&schema), 0);
-    dapps_system::add_schema<Counter>(dapps, package_id, ctx);
-    Counter {
-                          id: object::new(ctx),
-                          value: storage_value::new(),
-                        }
+  public(package) fun create(ctx: &mut TxContext): Counter {
+    let mut id = object::new(ctx);
+    storage_migrate::add_field<StorageValue<u32>>(&mut id, b"value", storage_value::new());
+    Counter { id }
   }
 
+  public fun migrate(_counter: &mut Counter, _cap: &UpgradeCap) {}
+
   // ======================================== View Functions ========================================
 
   public fun get_value(self: &Counter): Option<u32> {
-    self.value.try_get()
+    self.borrow_value().try_get()
   }
 
   // =========================================================================================================

package/template/101/sui-template/contracts/counter/sources/script/deploy_hook.move

@@ -6,17 +6,17 @@
 
   use dubhe::dapps_system;
 
-  use counter::dapp_key::DappKey;
+  use counter::schema_hub::SchemaHub;
 
-  use std::ascii;
+  use std::ascii::string;
 
   use sui::clock::Clock;
 
-  use sui::transfer::public_share_object;
+  use sui::package::UpgradeCap;
 
-  #[test_only]
+  use sui::transfer::public_share_object;
 
-  use dubhe::dapps_schema;
+  use counter::counter_schema::Counter;
 
   #[test_only]
 
@@ -28,40 +28,58 @@
 
   #[test_only]
 
+  use sui::package;
+
+  #[test_only]
+
+  use counter::schema_hub;
+
+  #[test_only]
+
+  use dubhe::dapps_schema;
+
+  #[test_only]
+
   use sui::test_scenario::Scenario;
 
-  public entry fun run(dapps: &mut Dapps, clock: &Clock, ctx: &mut TxContext) {
+  public entry fun run(
+    schema_hub: &mut SchemaHub,
+    dapps: &mut Dapps,
+    cap: &UpgradeCap,
+    clock: &Clock,
+    ctx: &mut TxContext,
+  ) {
     // Register the dapp to dubhe.
-    dapps_system::register<DappKey>(
-            dapps,
-            ascii::string(b"counter"),
-            ascii::string(b"counter"),
-            clock,
-            ctx
-        );
-    let mut counter = counter::counter_schema::register(dapps, ctx);
+    dapps_system::register(dapps,cap,string(b"counter"),string(b"counter"),clock,ctx);
+    // Create schemas
+    let mut counter = counter::counter_schema::create(ctx);
     // Logic that needs to be automated once the contract is deployed
-      counter.borrow_mut_value().set(0);
 
-    // Share the dapp object with the public
+    counter.borrow_mut_value().set(0);
+    // Authorize schemas and public share objects
+    schema_hub.authorize_schema<Counter>();
     public_share_object(counter);
   }
 
   #[test_only]
 
-  public fun deploy_hook_for_testing(): (Scenario, Dapps) {
+  public fun deploy_hook_for_testing(): (Scenario, SchemaHub, Dapps) {
     let mut scenario = test_scenario::begin(@0xA);
     {
           let ctx = test_scenario::ctx(&mut scenario);
           dapps_schema::init_dapps_for_testing(ctx);
+          schema_hub::init_schema_hub_for_testing(ctx);
           test_scenario::next_tx(&mut scenario,@0xA);
       };
     let mut dapps = test_scenario::take_shared<Dapps>(&scenario);
+    let mut schema_hub = test_scenario::take_shared<SchemaHub>(&scenario);
     let ctx = test_scenario::ctx(&mut scenario);
     let clock = clock::create_for_testing(ctx);
-    run(&mut dapps, &clock, ctx);
+    let upgrade_cap = package::test_publish(@0x42.to_id(), ctx);
+    run(&mut schema_hub, &mut dapps, &upgrade_cap, &clock, ctx);
     clock::destroy_for_testing(clock);
+    upgrade_cap.make_immutable();
     test_scenario::next_tx(&mut scenario,@0xA);
-    (scenario, dapps)
+    (scenario, schema_hub, dapps)
   }
 }

package/template/101/sui-template/contracts/counter/sources/script/migrate.move

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

package/template/101/sui-template/localnet/dubhe-framework/Move.toml

@@ -1,26 +1,16 @@
 [package]
 name = "Dubhe"
-edition = "2024.alpha" # edition = "legacy" to use legacy (pre-2024) Move
-published-at = "0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28"
-# license = ""           # e.g., "MIT", "GPL", "Apache 2.0"
-# authors = ["..."]      # e.g., ["Joe Smith (joesmith@noemail.com)", "John Snow (johnsnow@noemail.com)"]
+edition = "2024.alpha"
+version = "1.0.0"
+published-at = "0xe2793ee7dd5f05c73969577b0074f29aae3f70ab33c57dd42681ca29196e6a04"
+license = "MIT"
+authors = ["Obelisk Labs"]
 
 [dependencies]
 Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.36.2" }
 
-# For remote import, use the `{ git = "...", subdir = "...", rev = "..." }`.
-# Revision can be a branch, a tag, and a commit hash.
-# MyRemotePackage = { git = "https://some.remote/host.git", subdir = "remote/path", rev = "main" }
-
-# For local dependencies use `local = path`. Path is relative to the package root
-# Local = { local = "../path/to" }
-
-# To resolve a version conflict and force a specific version for dependency
-# override use `override = true`
-# Override = { local = "../conflicting/version", override = true }
-
 [addresses]
-dubhe = "0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28"
+dubhe = "0xe2793ee7dd5f05c73969577b0074f29aae3f70ab33c57dd42681ca29196e6a04"
 #dubhe = "0x0"
 
 # Named addresses will be accessible in Move as `@name`. They're also exported:

package/template/{nextjs/sui-template/localnet/dubhe-framework/sources/schemas/dapps/dapps.move → 101/sui-template/localnet/dubhe-framework/sources/core/dapps/schema.move}

@@ -11,7 +11,8 @@ module dubhe::dapps_schema {
         version: StorageMap<address, u32>,
         metadata: StorageMap<address, DappMetadata>,
         schemas: StorageMap<address, vector<String>>,
-        safe_mode: StorageMap<address, bool>
+        safe_mode: StorageMap<address, bool>,
+        verified: StorageMap<address, bool>
     }
 
 
@@ -35,6 +36,10 @@ module dubhe::dapps_schema {
         &mut self.safe_mode
     }
 
+    public(package) fun borrow_mut_verified(self: &mut Dapps): &mut StorageMap<address, bool> {
+        &mut self.verified
+    }
+
     public fun borrow_admin(self: &Dapps): &StorageMap<address, address> {
         &self.admin
     }
@@ -55,6 +60,10 @@ module dubhe::dapps_schema {
         &self.safe_mode
     }
 
+    public fun borrow_verified(self: &mut Dapps): &StorageMap<address, bool> {
+        &self.verified
+    }
+
     fun init(ctx: &mut TxContext) {
         public_share_object(Dapps {
             id: object::new(ctx),
@@ -62,7 +71,8 @@ module dubhe::dapps_schema {
             version: storage_map::new(),
             metadata: storage_map::new(),
             schemas: storage_map::new(),
-            safe_mode: storage_map::new()
+            safe_mode: storage_map::new(),
+            verified: storage_map::new(),
         });
     }
 

package/template/101/sui-template/localnet/dubhe-framework/sources/core/dapps/system.move

@@ -0,0 +1,75 @@
+module dubhe::dapps_system {
+    use std::ascii::String;
+    use std::ascii;
+    use dubhe::root_schema::Root;
+    use dubhe::dapp_metadata;
+    use sui::clock::Clock;
+    use dubhe::dapps_schema::Dapps;
+    use dubhe::root_system;
+
+    public entry fun register<UpgradeCap: key>(
+        dapps: &mut Dapps,
+        upgrade_cap: &UpgradeCap,
+        name: String,
+        description: String,
+        clock: &Clock,
+        ctx: &mut TxContext
+    ) {
+        
+        let dapp_id = object::id_address<UpgradeCap>(upgrade_cap);
+        assert!(!dapps.borrow_metadata().contains_key(dapp_id), 0);
+
+        dapps.borrow_mut_metadata().set(
+            dapp_id,
+            dapp_metadata::new(
+                name,
+                description,
+                ascii::string(b""),
+                ascii::string(b""),
+                clock.timestamp_ms(),
+                vector[]
+            )
+        );
+        dapps.borrow_mut_admin().set(dapp_id, ctx.sender());
+        dapps.borrow_mut_version().set(dapp_id, 0);
+        dapps.borrow_mut_safe_mode().set(dapp_id, false);
+    }
+
+    public entry fun set_metadata<UpgradeCap: key>(
+        dapps: &mut Dapps,
+        upgrade_cap: &UpgradeCap,
+        name: String,
+        description: String,
+        icon_url: String,
+        website_url: String,
+        partners: vector<String>
+    ) {
+        let dapp_id = object::id_address<UpgradeCap>(upgrade_cap);
+        assert!(dapps.borrow_metadata().contains_key(dapp_id), 0);
+        let created_at = dapps.borrow_mut_metadata().take(dapp_id).get_created_at();
+        dapps.borrow_mut_metadata().set(dapp_id, dapp_metadata::new(name, description, icon_url, website_url, created_at, partners));
+    }
+
+    public entry fun transfer_ownership<UpgradeCap: key>(
+        dapps: &mut Dapps,
+        upgrade_cap: &UpgradeCap,
+        new_admin: address,
+        ctx: &mut TxContext
+    ) {
+        let dapp_id = object::id_address<UpgradeCap>(upgrade_cap);
+        assert!(dapps.borrow_admin().get(dapp_id) == ctx.sender(), 0);
+        dapps.borrow_mut_admin().set(dapp_id, new_admin);
+    }
+
+    public entry fun add_verification(dapps: &mut Dapps, root: &Root, dapp_id: address, ctx: &mut TxContext) {
+        root_system::ensure_root(root, ctx);
+        assert!(dapps.borrow_metadata().contains_key(dapp_id), 0);
+        dapps.borrow_mut_verified().set(dapp_id, true);
+    }
+
+    public entry fun remove_verification(dapps: &mut Dapps, root: &Root, dapp_id: address, ctx: &mut TxContext) {
+        root_system::ensure_root(root, ctx);
+        assert!(dapps.borrow_metadata().contains_key(dapp_id), 0);
+        dapps.borrow_mut_verified().remove(dapp_id);
+    }
+}

package/template/101/sui-template/localnet/dubhe-framework/sources/core/dapps/tests.move

@@ -0,0 +1,52 @@
+#[test_only]
+module dubhe::dapps_tests {
+    use dubhe::dapps_schema::Dapps;
+    use dubhe::dapps_schema;
+    use dubhe::dapps_system;
+    use std::ascii::string;
+    use std::debug;
+    use sui::clock;
+    use sui::test_scenario;
+    use sui::package;
+    use sui::package::UpgradeCap;
+
+    public struct DappKey has drop {}
+
+    #[test]
+    public fun dapps_register() {
+        let mut scenario = test_scenario::begin(@0xA);
+        {
+            let ctx = test_scenario::ctx(&mut scenario);
+            dapps_schema::init_dapps_for_testing(ctx);
+            test_scenario::next_tx(&mut scenario,@0xA);
+        };
+
+        let mut dapps = test_scenario::take_shared<Dapps>(&scenario);
+
+        let upgrade_cap = package::test_publish(@0x42.to_id(), scenario.ctx());
+        debug::print(&object::id_address<UpgradeCap>(&upgrade_cap));
+
+        let clock = clock::create_for_testing(test_scenario::ctx(&mut scenario));
+        dapps_system::register<UpgradeCap>(
+            &mut dapps,
+            &upgrade_cap,
+            string(b"DappKey"),
+            string(b"DappKey"),
+            &clock,
+            test_scenario::ctx(&mut scenario)
+        );
+
+        test_scenario::next_tx(&mut scenario,@0xA);
+
+        let dapp_id = object::id_address<UpgradeCap>(&upgrade_cap);
+        assert!(dapps.borrow_version().get(dapp_id) == 0, 0);
+        assert!(dapps.borrow_metadata().contains_key(dapp_id));
+        assert!(dapps.borrow_admin().get(dapp_id) == test_scenario::ctx(&mut scenario).sender(), 0);
+        assert!(dapps.borrow_safe_mode().get(dapp_id) == false, 0);
+
+        clock::destroy_for_testing(clock);
+        test_scenario::return_shared<Dapps>(dapps);
+        upgrade_cap.make_immutable();
+        scenario.end();
+    }
+}