create-dubhe 0.0.4 → 0.0.5

package/template/101/sui-template/localnet/dubhe-framework/sources/core/root/schema.move

@@ -0,0 +1,33 @@
+module dubhe::root_schema {
+    use dubhe::storage_value;
+    use dubhe::storage_value::StorageValue;
+    use sui::transfer::public_share_object;
+
+    public struct Root has key, store {
+        id: UID,
+        key: StorageValue<address>,
+    }
+
+
+    public(package) fun borrow_mut_key(self: &mut Root): &mut StorageValue<address> {
+        &mut self.key
+    }
+
+    public fun borrow_key(self: &Root): &StorageValue<address> {
+        &self.key
+    }
+
+    fun init(ctx: &mut TxContext) {
+        let mut key = storage_value::new();
+        key.set(ctx.sender());
+        public_share_object(Root {
+            id: object::new(ctx),
+            key,
+        });
+    }
+
+    #[test_only]
+    public fun init_root_for_testing(ctx: &mut TxContext){
+        init(ctx)
+    }
+}

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

@@ -0,0 +1,24 @@
+module dubhe::root_system {
+    use dubhe::root_schema::Root;
+
+    public entry fun set_key(
+        root: &mut Root,
+        key: address,
+        ctx: &mut TxContext
+    ) {
+        ensure_root(root, ctx);
+        root.borrow_mut_key().set(key);
+    }
+
+    public entry fun remove_key(
+        root: &mut Root,
+        ctx: &mut TxContext
+    ) {
+        ensure_root(root, ctx);
+        root.borrow_mut_key().remove();
+    }
+
+    public fun ensure_root(root: &Root, ctx: &TxContext) {
+        assert!(root.borrow_key().get() == ctx.sender(), 0);
+    }
+}

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

@@ -0,0 +1,39 @@
+#[test_only]
+module dubhe::root_tests {
+    use dubhe::root_schema::Root;
+    use dubhe::root_schema;
+    use dubhe::root_system;
+    use sui::test_scenario;
+
+    public struct USDT has drop {}
+
+    #[test]
+    public fun root_key() {
+        let mut scenario = test_scenario::begin(@0xA);
+        {
+            let ctx = test_scenario::ctx(&mut scenario);
+            root_schema::init_root_for_testing(ctx);
+            test_scenario::next_tx(&mut scenario,@0xA);
+        };
+
+        let mut root = test_scenario::take_shared<Root>(&scenario);
+        assert!(root.borrow_key().get() == @0xA, 0);
+
+        {
+            let ctx = test_scenario::ctx(&mut scenario);
+            root_system::set_key(&mut root, @0xB, ctx);
+            test_scenario::next_tx(&mut scenario,@0xB);
+        };
+        assert!(root.borrow_key().get() == @0xB, 0);
+
+        {
+            let ctx = test_scenario::ctx(&mut scenario);
+            root_system::remove_key(&mut root, ctx);
+            test_scenario::next_tx(&mut scenario,@0xC);
+        };
+        assert!(root.borrow_key().try_get() == option::none<address>(), 0);
+
+        test_scenario::return_shared<Root>(root);
+        scenario.end();
+    }
+}

package/template/101/sui-template/localnet/dubhe-framework/sources/frames/utils/type_info.move

@@ -0,0 +1,29 @@
+module dubhe::type_info {
+    use std::ascii::String;
+    use std::ascii::string;
+    use sui::address;
+    use std::type_name::TypeName;
+
+    public fun parse_type_name(type_name: TypeName): (address, String, String, String) {
+        let pending_parse_str = type_name.into_string();
+        let delimiter = string(b"::");
+
+        // TBD: this can probably be hard-coded as all hex addrs are 64 bytes
+        let package_delimiter_index = pending_parse_str.index_of(&delimiter);
+        let package_addr = pending_parse_str.substring(0, package_delimiter_index);
+        let package_id = address::from_ascii_bytes(package_addr.as_bytes());
+
+        let tail = pending_parse_str.substring(package_delimiter_index + 2, pending_parse_str.length());
+
+        let module_delimiter_index = tail.index_of(&delimiter);
+        let module_name = tail.substring(0, module_delimiter_index);
+
+        let struct_name_with_type = tail.substring(module_delimiter_index + 2, tail.length());
+
+        let delimiter = string(b"<");
+        let struct_name_delimiter_index = struct_name_with_type.index_of(&delimiter);
+        let struct_name = struct_name_with_type.substring(0, struct_name_delimiter_index);
+
+        (package_id, module_name, struct_name, struct_name_with_type)
+    }
+}

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

@@ -1,6 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
 #[allow(unused_variable)]
 module dubhe::storage_double_map {
 

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

@@ -1,6 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
 #[allow(unused_variable)]
 module dubhe::storage_map {
 

package/template/101/sui-template/localnet/dubhe-framework/sources/storages/migrate.move

@@ -0,0 +1,19 @@
+module dubhe::storage_migrate {
+    use sui::dynamic_field as df;
+
+    public fun add_field<StorageType: store>(uid: &mut UID, field_name: vector<u8>, storagr_type: StorageType) {
+        df::add(uid, field_name, storagr_type);
+    }
+
+    public fun borrow_field<StorageType: store>(uid: &UID, field_name: vector<u8>): &StorageType {
+        df::borrow(uid, field_name)
+    }
+
+    public fun borrow_mut_field<StorageType: store>(uid: &mut UID, field_name: vector<u8>): &mut StorageType {
+        df::borrow_mut(uid, field_name)
+    }
+
+    public fun field_exists(uid: &UID, field_name: vector<u8>): bool {
+        df::exists_(uid, field_name)
+    }
+}

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

@@ -1,6 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
 module dubhe::storage_value {
 
     /// This key does not exist in the map

package/template/101/sui-template/package.json

@@ -5,39 +5,31 @@
   "author": "team@0xobelisk.com",
   "license": "MIT",
   "scripts": {
-    "// Development Environment": "----------------",
-    "dev": "pnpm dev:localnet",
-    "dev:localnet": "pnpm localnet:setup && pnpm next",
-    "dev:testnet": "pnpm testnet:setup && pnpm next",
-    "// Production Environment": "----------------",
-    "prod:localnet": "pnpm config:store localnet && pnpm next",
-    "prod:testnet": "pnpm config:store testnet && pnpm next",
-    "// Local Network": "----------------",
-    "localnet:setup": "pnpm localnet:start && pnpm localnet:wait && pnpm localnet:account && pnpm localnet:faucet && pnpm localnet:deploy",
-    "localnet:start": "pnpm dubhe localnode start -b",
-    "localnet:restart": "pnpm dubhe localnode restart -b",
-    "localnet:stop": "pnpm dubhe localnode stop",
-    "localnet:status": "pnpm dubhe localnode status",
-    "localnet:wait": "NODE_NO_WARNINGS=1 ts-node scripts/waitNode.ts",
-    "localnet:account": "NODE_NO_WARNINGS=1 ts-node scripts/generateAccount.ts",
-    "localnet:faucet": "pnpm dubhe faucet --network localnet",
-    "localnet:deploy": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/localnet/deploy.ts",
-    "// Test Network": "----------------",
-    "testnet:setup": "pnpm testnet:account && pnpm testnet:check-balance && pnpm testnet:deploy",
-    "testnet:account": "NODE_NO_WARNINGS=1 ts-node scripts/generateAccount.ts",
-    "testnet:check-balance": "NODE_NO_WARNINGS=1 ts-node scripts/checkBalance.ts testnet",
-    "testnet:faucet": "pnpm dubhe faucet --network testnet",
-    "testnet:deploy": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/testnet/deploy.ts",
     "// Utility Commands": "----------------",
     "schema:gen": "pnpm dubhe schemagen --configPath ./dubhe.config.ts",
+    "account:gen": "NODE_NO_WARNINGS=1 ts-node scripts/generateAccount.ts",
     "config:store": "ts-node scripts/storeConfig.ts",
+    "start:localnet": "pnpm dubhe localnode start",
+    "faucet": "pnpm dubhe faucet --network",
+    "check-balance": "NODE_NO_WARNINGS=1 ts-node scripts/checkBalance.ts",
+    "deploy:localnet": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/localnet/deploy.ts",
+    "deploy:testnet": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/testnet/deploy.ts",
+    "// Development Environment": "----------------",
+    "dev": "pnpm dev:localnet",
+    "dev:localnet": "pnpm setup:localnet && pnpm next",
+    "dev:testnet": "pnpm setup:testnet && pnpm next",
+    "setup:localnet": "pnpm account:gen && pnpm faucet localnet && pnpm deploy:localnet",
+    "setup:testnet": "pnpm account:gen && pnpm check-balance testnet && pnpm deploy:testnet",
     "build": "next build",
-    "start": "next start"
+    "start": "next start",
+    "// Production Environment": "----------------",
+    "prod:localnet": "pnpm config:store localnet && pnpm next",
+    "prod:testnet": "pnpm config:store testnet && pnpm next"
   },
   "dependencies": {
-    "@0xobelisk/sui-cli": "^0.5.23",
-    "@0xobelisk/sui-client": "^0.5.27",
-    "@0xobelisk/sui-common": "^0.5.19",
+    "@0xobelisk/sui-cli": "^0.5.25",
+    "@0xobelisk/sui-client": "v0.5.28",
+    "@0xobelisk/sui-common": "^0.5.21",
     "@mysten/sui": "1.7.0",
     "clsx": "^1.2.1",
     "dotenv": "^16.4.5",

package/template/101/sui-template/scripts/deployment/testnet/deploy.ts

@@ -4,7 +4,7 @@ import { dubheConfig } from '../../../dubhe.config';
 import fs from 'fs/promises';
 import path from 'path';
 
-const TESTNET_FRAMEWORK_ID = '0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28';
+const TESTNET_FRAMEWORK_ID = '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
 
 async function updateDubheMoveToml(projectName: string) {
   try {
@@ -14,7 +14,7 @@ async function updateDubheMoveToml(projectName: string) {
 
     content = content.replace(
       /Dubhe = \{[^}]+\}/,
-      `Dubhe = { git = "https://github.com/0xobelisk/dubhe.git", subdir = "packages/dubhe-framework", rev = "main" }`,
+      `Dubhe = { git = "https://github.com/0xobelisk/dubhe.git", rev = "release-dubhe-v1.0.0-rc1" }`,
     );
 
     content = content.replace(/^dubhe\s+=\s+"0x[0-9a-fA-F]+"/m, `dubhe = "${TESTNET_FRAMEWORK_ID}"`);

package/template/101/sui-template/src/chain/config.ts

@@ -1,7 +1,7 @@
 type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
 
-export const NETWORK: NetworkType = 'testnet';
+export const NETWORK: NetworkType = 'localnet';
 
-export const PACKAGE_ID = '0xc58411ca78d829dbc3bb104ee7e63b8c95c0b0fb110cc98332023a88c18837a6'
+export const PACKAGE_ID = '0x578a4e578b31cc9a0e749e35a94e85adb2adf9f16794d5636b9f23b2ef02cf16'
 
-export const Counter_Object_Id = '0x35a38188257ee072283672fb112488737dda1a081f30f691063fd7dcd370a421'
+export const Counter_Object_Id = '0x31bee9e1c6973d825480a645ce018e927a448b62f958e4aadd9e7c63b66233ee'

package/template/cocos/sui-template/assets/lib/dubhe.js

@@ -4562,6 +4562,26 @@ function numberToAddressHex(num) {
 
 // src/dubhe.ts
 
+// src/errors/index.ts
+var ContractDataParsingError = class extends Error {
+  constructor(dryResult) {
+    const error = dryResult?.effects?.status?.error || "";
+    const functionMatch = error ? error.match(/function_name: Some\("([^"]+)"\)/) : null;
+    const moduleMatch = error ? error.match(/address: ([a-fA-F0-9]+)/) : null;
+    const functionName = functionMatch ? functionMatch[1] : "unknown";
+    const moduleAddress = moduleMatch ? "0x" + moduleMatch[1] : "unknown";
+    const errorMessage = dryResult.error ? dryResult.error : "UNKNOWN_ERROR";
+    const message = [`
+- Function: ${functionName}`, `- Module Address: ${moduleAddress}`, `- Error Message: ${errorMessage}`].join("\n");
+    super(message);
+    this.errorType = "ContractDataParsingError";
+    this.functionName = functionName;
+    this.moduleAddress = moduleAddress;
+    this.errorMessage = errorMessage;
+  }
+};
+
+// src/dubhe.ts
 function isUndefined(value) {
   return value === void 0;
 }
@@ -4953,7 +4973,7 @@ var Dubhe = class {
       }
       return returnValues;
     } else {
-      return void 0;
+      throw new ContractDataParsingError(dryResult);
     }
   }
   /**

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

@@ -9,5 +9,5 @@ Dubhe = { git = "https://github.com/0xobelisk/dubhe.git", subdir = "packages/dub
 
 [addresses]
 sui =  "0x2"
-dubhe =  "0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28"
+dubhe =  "0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6"
 counter = "0x0"

package/template/cocos/sui-template/package.json

@@ -15,9 +15,9 @@
 		"generateAccount": "ts-node scripts/generateAccount.ts"
 	},
 	"dependencies": {
-		"@0xobelisk/sui-cli": "^0.5.23",
-		"@0xobelisk/sui-client": "^0.5.27",
-		"@0xobelisk/sui-common": "^0.5.19"
+		"@0xobelisk/sui-cli": "^0.5.25",
+		"@0xobelisk/sui-client": "v0.5.28",
+		"@0xobelisk/sui-common": "^0.5.21"
 	},
 	"devDependencies": {
 		"@types/node": "18.16.16",

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

@@ -0,0 +1,13 @@
+[package]
+name = "counter"
+version = "0.0.1"
+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-framework.git", rev = "release-dubhe-v1.0.0-rc1" }
+
+[addresses]
+sui = "0x2"
+dubhe = "0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6"
+counter = "0x0"

package/template/contract/sui-template/contracts/counter/sources/codegen/dapp_key.move

@@ -0,0 +1,16 @@
+  // Copyright (c) Obelisk Labs, Inc.
+  // SPDX-License-Identifier: MIT
+  #[allow(unused_use)]
+  
+  /* Autogenerated file. Do not edit manually. */
+  
+  module counter::dapp_key {
+
+  /// Authorization token for the app.
+
+  public struct DappKey has drop {}
+
+  public(package) fun new(): DappKey {
+    DappKey {  }
+  }
+}

package/template/contract/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/contract/sui-template/contracts/counter/sources/codegen/schemas/counter.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::counter_schema {
+
+  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};
+
+  use dubhe::storage_map::{Self, StorageMap};
+
+  use dubhe::storage_double_map::{Self, StorageDoubleMap};
+
+  use counter::dapp_key::DappKey;
+
+  use sui::dynamic_field as df;
+
+  public struct Counter has key, store {
+    id: UID,
+  }
+
+  public fun borrow_value(self: &Counter): &StorageValue<u32> {
+    storage_migrate::borrow_field(&self.id, b"value")
+  }
+
+  public(package) fun borrow_mut_value(self: &mut Counter): &mut StorageValue<u32> {
+    storage_migrate::borrow_mut_field(&mut self.id, b"value")
+  }
+
+  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.borrow_value().try_get()
+  }
+
+  // =========================================================================================================
+}

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

@@ -0,0 +1,85 @@
+#[allow(lint(share_owned))]
+  
+  module counter::deploy_hook {
+
+  use dubhe::dapps_schema::Dapps;
+
+  use dubhe::dapps_system;
+
+  use counter::schema_hub::SchemaHub;
+
+  use std::ascii::string;
+
+  use sui::clock::Clock;
+
+  use sui::package::UpgradeCap;
+
+  use sui::transfer::public_share_object;
+
+  use counter::counter_schema::Counter;
+
+  #[test_only]
+
+  use sui::clock;
+
+  #[test_only]
+
+  use sui::test_scenario;
+
+  #[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(
+    schema_hub: &mut SchemaHub,
+    dapps: &mut Dapps,
+    cap: &UpgradeCap,
+    clock: &Clock,
+    ctx: &mut TxContext,
+  ) {
+    // Register the dapp to dubhe.
+    dapps_system::register(dapps,cap,string(b"counter"),string(b"counter contract"),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);
+    // Authorize schemas and public share objects
+    schema_hub.authorize_schema<Counter>();
+    public_share_object(counter);
+  }
+
+  #[test_only]
+
+  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);
+    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, schema_hub, dapps)
+  }
+}

package/template/contract/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/contract/sui-template/dubhe.config.ts

@@ -0,0 +1,14 @@
+import { DubheConfig } from '@0xobelisk/sui-common';
+
+export const dubheConfig = {
+	name: 'counter',
+	description: 'counter contract',
+	systems: ['counter'],
+	schemas: {
+		counter: {
+			structure: {
+				value: 'StorageValue<u32>',
+			},
+		},
+	},
+} as DubheConfig;

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

@@ -0,0 +1,29 @@
+[package]
+name = "Dubhe"
+edition = "2024.alpha"
+version = "1.0.0"
+published-at = "0x6e792e0532d681cf7c5cb461ca9ee27295e64eabdf9b534df276acb34111b3f5"
+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" }
+
+[addresses]
+dubhe = "0x6e792e0532d681cf7c5cb461ca9ee27295e64eabdf9b534df276acb34111b3f5"
+#dubhe = "0x0"
+
+# Named addresses will be accessible in Move as `@name`. They're also exported:
+# for example, `std = "0x1"` is exported by the Standard Library.
+# alice = "0xA11CE"
+
+[dev-dependencies]
+# The dev-dependencies section allows overriding dependencies for `--test` and
+# `--dev` modes. You can introduce test-only dependencies here.
+# Local = { local = "../path/to/dev-build" }
+
+[dev-addresses]
+# The dev-addresses section allows overwriting named addresses for the `--test`
+# and `--dev` modes.
+# alice = "0xB0B"
+

package/template/{101/sui-template/localnet/dubhe-framework/sources/schemas/dapps/dapps.move → contract/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(),
         });
     }