create-dubhe 0.0.1

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

@@ -0,0 +1,398 @@
+#[test_only]
+module dubhe::storage_tests {
+    use dubhe::storage_double_map::StorageDoubleMap;
+    use dubhe::storage_map::StorageMap;
+    use dubhe::storage_double_map;
+    use dubhe::storage_map;
+    use dubhe::storage_value::StorageValue;
+    use sui::test_scenario;
+    use sui::transfer::public_share_object;
+    use dubhe::storage_value;
+
+    public struct TestValue has drop, copy, store {
+        value: u64,
+    }
+
+    public struct TestStoreValue has store {
+        value: u64,
+    }
+
+    /// Destroy a TestStoreValue`.
+    public fun destroy_value(value: TestStoreValue) {
+        let TestStoreValue { value: _ } = value;
+    }
+
+    public struct TestObject has key, store {
+        id: UID,
+        value: StorageValue<TestValue>,
+        immutable_value: StorageValue<TestStoreValue>,
+        map: StorageMap<u32, TestValue>,
+        immutable_map: StorageMap<u32, TestStoreValue>,
+        double_map: StorageDoubleMap<u32, u32, TestValue>,
+        immutable_double_map: StorageDoubleMap<u32, u32, TestStoreValue>,
+    }
+
+    public fun value(self: &mut TestObject): &mut StorageValue<TestValue> {
+        &mut self.value
+    }
+
+
+    #[test]
+    public fun test_double_map() {
+        let mut scenario = test_scenario::begin(@0x0001);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        let mut double_map = storage_double_map::new();
+
+        double_map.insert(0, 0, TestValue { value: 0 });
+        double_map.insert(0, 1, TestValue { value: 1 });
+        double_map.insert(0, 2, TestValue { value: 2 });
+
+        assert!(double_map.contains_key(0, 0));
+        assert!(double_map.contains_key(0, 1));
+        assert!(double_map.contains_key(0, 2));
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0, 0], 0);
+        assert!(keys2 == vector[0, 1, 2], 0);
+        assert!(double_map.values() == vector[TestValue { value: 0 }, TestValue { value: 1 }, TestValue { value: 2 }]);
+        assert!(double_map.length() == 3);
+        assert!(double_map.borrow(0, 0).value == 0);
+        assert!(double_map.borrow(0, 1).value == 1);
+        assert!(double_map.borrow_mut(0, 2).value == 2);
+        assert!(double_map.get(0, 0).value == 0);
+        assert!(double_map.get(0, 1).value == 1);
+        assert!(double_map.get(0, 2).value == 2);
+        assert!(double_map.try_get(0, 0) == option::some(TestValue { value: 0 }));
+        assert!(double_map.try_get(0, 1) == option::some(TestValue { value: 1 }));
+        assert!(double_map.try_get(0, 2) == option::some(TestValue { value: 2 }));
+        assert!(double_map.try_get(0, 3) == option::none());
+
+        double_map.take(0, 1);
+
+        assert!(double_map.contains_key(0, 0));
+        assert!(!double_map.contains_key(0, 1));
+        assert!(double_map.contains_key(0, 2));
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0]);
+        assert!(keys2 == vector[0, 2]);
+        assert!(double_map.values() == vector[TestValue { value: 0 }, TestValue { value: 2 }]);
+        assert!(double_map.length() == 2);
+        assert!(double_map.borrow(0, 0).value == 0);
+        assert!(double_map.borrow_mut(0, 2).value == 2);
+
+        double_map.mutate!(0, 0,  |value| {
+            *value = TestValue { value: 2 };
+        });
+
+        assert!(double_map.contains_key(0, 0));
+        assert!(!double_map.contains_key(0, 1));
+        assert!(double_map.contains_key(0, 2));
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0]);
+        assert!(keys2 == vector[0, 2]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }, TestValue { value: 2 }]);
+        assert!(double_map.length() == 2);
+        assert!(double_map.borrow(0, 0).value == 2);
+        assert!(double_map.borrow_mut(0, 2).value == 2);
+
+        double_map.remove(0, 0);
+        assert!(!double_map.contains_key(0,0));
+        assert!(double_map.length() == 1);
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0]);
+        assert!(keys2 == vector[2]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }]);
+
+        double_map.remove(0,3);
+        assert!(double_map.length() == 1);
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0]);
+        assert!(keys2 == vector[2]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }]);
+
+        double_map.set(0,3, TestValue { value: 0 });
+        assert!(double_map.contains_key(0,3));
+        assert!(double_map.length() == 2);
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0]);
+        assert!(keys2 == vector[2, 3]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }, TestValue { value: 0 }]);
+        assert!(double_map.get(0,3).value == 0);
+
+        double_map.set(0,3, TestValue { value: 3 });
+        assert!(double_map.contains_key(0,3));
+        assert!(double_map.length() == 2);
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0]);
+        assert!(keys2 == vector[2, 3]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }, TestValue { value: 3 }]);
+        assert!(double_map.get(0,3).value == 3);
+
+        public_share_object(TestObject {
+            id: object::new(ctx),
+            value: storage_value::new(),
+            immutable_value: storage_value::new(),
+            map: storage_map::new(),
+            immutable_map: storage_map::new(),
+            double_map,
+            immutable_double_map: storage_double_map::new(),
+        });
+
+        scenario.end();
+    }
+
+    #[test]
+    public fun test_value() {
+        let mut scenario = test_scenario::begin(@0x0001);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        let mut value = storage_value::new();
+        value.set(TestValue { value: 1 });
+        assert!(value.get() == TestValue { value: 1 });
+        assert!(*value.borrow() == TestValue { value: 1 });
+        assert!(*value.borrow_mut() == TestValue { value: 1 });
+
+        value.set(TestValue { value: 2 });
+        assert!(value.get() == TestValue { value: 2 });
+
+        value.mutate!(|value| {
+            *value = TestValue { value: 3 };
+        });
+        assert!(value.get() == TestValue { value: 3 });
+
+        value.set(TestValue { value: 4 });
+        assert!(value.get() == TestValue { value: 4 });
+
+
+        let mut immutable_value = storage_value::new();
+        immutable_value.put(TestStoreValue { value: 1 });
+        assert!(immutable_value.borrow().value == 1);
+
+        immutable_value.mutate!(|store_value| {
+            store_value.value = 2;
+        });
+        assert!(immutable_value.borrow().value == 2);
+        assert!(immutable_value.borrow_mut().value == 2);
+
+        immutable_value.mutate!(|store_value| {
+            store_value.value = 3;
+        });
+        assert!(immutable_value.borrow().value == 3);
+        assert!(immutable_value.borrow_mut().value == 3);
+
+        public_share_object(TestObject {
+            id: object::new(ctx),
+            value,
+            immutable_value,
+            map: storage_map::new(),
+            immutable_map: storage_map::new(),
+            double_map: storage_double_map::new(),
+            immutable_double_map: storage_double_map::new(),
+        });
+
+        scenario.end();
+    }
+
+    #[test]
+    public fun test_map() {
+        let mut scenario = test_scenario::begin(@0x0001);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        let mut map = storage_map::new();
+        map.insert(0, TestValue { value: 0 });
+        map.insert(1, TestValue { value: 1 });
+        map.insert(2, TestValue { value: 2 });
+
+        assert!(map.contains_key(0));
+        assert!(map.contains_key(1));
+        assert!(map.contains_key(2));
+        assert!(map.keys() == vector[0, 1, 2]);
+        assert!(map.values() == vector[TestValue { value: 0 }, TestValue { value: 1 }, TestValue { value: 2 }]);
+        assert!(map.length() == 3);
+        assert!(map.borrow(0).value == 0);
+        assert!(map.borrow(1).value == 1);
+        assert!(map.borrow_mut(2).value == 2);
+        assert!(map.get(0).value == 0);
+        assert!(map.get(1).value == 1);
+        assert!(map.get(2).value == 2);
+        assert!(map.try_get(0) == option::some(TestValue { value: 0 }));
+        assert!(map.try_get(1) == option::some(TestValue { value: 1 }));
+        assert!(map.try_get(2) == option::some(TestValue { value: 2 }));
+        assert!(map.try_get(3) == option::none());
+
+        map.take(1);
+
+        assert!(map.contains_key(0));
+        assert!(!map.contains_key(1));
+        assert!(map.contains_key(2));
+        assert!(map.keys() == vector[0, 2]);
+        assert!(map.values() == vector[TestValue { value: 0 }, TestValue { value: 2 }]);
+        assert!(map.length() == 2);
+        assert!(map.borrow(0).value == 0);
+        assert!(map.borrow_mut(2).value == 2);
+
+
+        map.mutate!(0, |store_value| {
+            store_value.value = 2;
+        });
+        assert!(map.contains_key(0));
+        assert!(!map.contains_key(1));
+        assert!(map.contains_key(2));
+        assert!(map.keys() == vector[0, 2]);
+        assert!(map.values() == vector[TestValue { value: 2 }, TestValue { value: 2 }]);
+        assert!(map.length() == 2);
+        assert!(map.borrow(0).value == 2);
+        assert!(map.borrow_mut(2).value == 2);
+
+        map.remove(0);
+        assert!(!map.contains_key(0));
+        assert!(map.length() == 1);
+        assert!(map.keys() == vector[2]);
+        assert!(map.values() == vector[TestValue { value: 2 }]);
+
+        map.remove(3);
+        assert!(map.length() == 1);
+        assert!(map.keys() == vector[2]);
+        assert!(map.values() == vector[TestValue { value: 2 }]);
+
+        map.set(3, TestValue { value: 0 });
+        assert!(map.contains_key(3));
+        assert!(map.length() == 2);
+        assert!(map.keys() == vector[2, 3]);
+        assert!(map.values() == vector[TestValue { value: 2 }, TestValue { value: 0 }]);
+        assert!(map.get(3).value == 0);
+
+        map.set(3, TestValue { value: 3 });
+        assert!(map.contains_key(3));
+        assert!(map.length() == 2);
+        assert!(map.keys() == vector[2, 3]);
+        assert!(map.values() == vector[TestValue { value: 2 }, TestValue { value: 3 }]);
+        assert!(map.get(3).value == 3);
+
+        public_share_object(TestObject {
+            id: object::new(ctx),
+            value: storage_value::new(),
+            immutable_value: storage_value::new(),
+            map,
+            immutable_map: storage_map::new(),
+            double_map: storage_double_map::new(),
+            immutable_double_map: storage_double_map::new(),
+        });
+
+        scenario.end();
+    }
+
+    #[test]
+    public fun test_immutable_map() {
+        let mut scenario = test_scenario::begin(@0x0001);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        let mut immutable_map = storage_map::new();
+        immutable_map.insert(0, TestStoreValue { value: 0 });
+        immutable_map.insert(1, TestStoreValue { value: 1 });
+        immutable_map.insert(2, TestStoreValue { value: 2 });
+
+        assert!(immutable_map.contains_key(0));
+        assert!(immutable_map.contains_key(1));
+        assert!(immutable_map.contains_key(2));
+        assert!(immutable_map.keys() == vector[0, 1, 2]);
+        assert!(immutable_map.length() == 3);
+        assert!(immutable_map.borrow(0).value == 0);
+        assert!(immutable_map.borrow(1).value == 1);
+        assert!(immutable_map.borrow_mut(2).value == 2);
+
+        let detele_store_value = immutable_map.take(1);
+        destroy_value(detele_store_value);
+        assert!(immutable_map.contains_key(0));
+        assert!(!immutable_map.contains_key(1));
+        assert!(immutable_map.contains_key(2));
+        assert!(immutable_map.keys() == vector[0, 2]);
+        assert!(immutable_map.length() == 2);
+        assert!(immutable_map.borrow(0).value == 0);
+        assert!(immutable_map.borrow_mut(2).value == 2);
+
+
+        immutable_map.mutate!(0, |store_value| {
+            store_value.value = 2;
+        });
+        assert!(immutable_map.contains_key(0));
+        assert!(!immutable_map.contains_key(1));
+        assert!(immutable_map.contains_key(2));
+        assert!(immutable_map.keys() == vector[0, 2]);
+        assert!(immutable_map.length() == 2);
+        assert!(immutable_map.borrow(0).value == 2);
+        assert!(immutable_map.borrow_mut(2).value == 2);
+
+        public_share_object(TestObject {
+            id: object::new(ctx),
+            value: storage_value::new(),
+            immutable_value: storage_value::new(),
+            map: storage_map::new(),
+            immutable_map,
+            double_map: storage_double_map::new(),
+            immutable_double_map: storage_double_map::new(),
+        });
+
+        scenario.end();
+    }
+
+    // #[test]
+    // public fun test_immutable_map2() {
+    //     let mut scenario = test_scenario::begin(@0x0001);
+    //     let ctx = test_scenario::ctx(&mut scenario);
+    //
+    //     let mut immutable_map = storage_immutable_map::new(ctx);
+    //     immutable_map.set(0, TestValue { value: 1 });
+    //
+    //     // immutable_map.mutate!(|store_value| {
+    //     //     store_value.value = 2;
+    //     // });
+    //     // assert!(immutable_map.get().value == 2);
+    //     // assert!(immutable_map.borrow_mut().value == 2);
+    //     //
+    //     // immutable_map.mutate!(|store_value| {
+    //     //     store_value.value = 3;
+    //     // });
+    //     // assert!(immutable_map.get().value == 3);
+    //     // assert!(immutable_map.borrow_mut().value == 3);
+    //
+    //     public_share_object(TestObject2 {
+    //         id: object::new(ctx),
+    //         value: storage_value::new(TestValue { value: 1 }),
+    //         immutable_value: storage_value::new(TestStoreValue { value: 1 }),
+    //         immutable_map,
+    //     });
+    //
+    //     scenario.end();
+    // }
+
+    // #[test]
+    // public fun test_object() {
+    //     let sender = @0x0001;
+    //     let mut scenario_val = test_scenario::begin(sender);
+    //     let scenario = &mut scenario_val;
+    //
+    //     let obj = TestObject {
+    //         id: object::new(test_scenario::ctx(scenario)),
+    //         value: storage_value::empty(),
+    //     };
+    //     public_share_object(obj);
+    //
+    //     test_scenario::next_tx(scenario, sender);
+    //
+    //     let mut obj = test_scenario::take_shared<TestObject>(scenario);
+    //
+    //     obj.value.set(TestValue { value: 1 });
+    //     assert!(obj.value.contains());
+    //     assert!(!obj.value.is_empty());
+    //     assert!(obj.value.get() == TestValue { value: 1 });
+    //
+    //     obj.value.set(TestValue { value: 2 });
+    //     assert!(obj.value.contains());
+    //     assert!(!obj.value.is_empty());
+    //     assert!(obj.value.get() == TestValue { value: 2 });
+    //
+    //     test_scenario::return_shared<TestObject>(obj);
+    //     test_scenario::end(scenario_val);
+    // }
+}

package/template/nextjs/sui-template/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

package/template/nextjs/sui-template/next-i18next.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+    i18n: {
+        defaultLocale: 'cn',
+        locales: ['en','cn'],
+    },
+};

package/template/nextjs/sui-template/next.config.js

@@ -0,0 +1,15 @@
+"use strict";
+const { i18n } = require('./next-i18next.config');
+
+module.exports = {
+    experimental: {
+        // outputStandalone: true,
+        ignoreDuringBuilds: true,
+    },
+    staticPageGenerationTimeout: 1000,
+    eslint: {
+        dirs: ['src'], // Only run ESLint on the 'pages' and 'utils' directories during production builds (next build)
+    },
+    i18n,
+}
+

package/template/nextjs/sui-template/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "dubhe-nextjs-template",
+  "version": "0.0.1",
+  "description": "Simple starter template",
+  "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",
+    "config:store": "ts-node scripts/storeConfig.ts",
+    "build": "next build",
+    "start": "next start"
+  },
+  "dependencies": {
+    "@0xobelisk/sui-cli": "^0.5.21",
+    "@0xobelisk/sui-client": "^0.5.25",
+    "@0xobelisk/sui-common": "^0.5.18",
+    "@mysten/dapp-kit": "0.14.9",
+    "@mysten/sui": "1.7.0",
+    "dotenv": "^16.4.5",
+    "@tanstack/react-query": "^5.17.19",
+    "clsx": "^1.2.1",
+    "framer-motion": "^10.12.16",
+    "jotai": "^1.7.2",
+    "next": "^12.1.6",
+    "next-i18next": "^11.0.0",
+    "react": "18.1.0",
+    "react-dom": "18.1.0",
+    "react-select": "^5.4.0",
+    "swiper": "^9.2.4",
+    "chalk": "^4.1.2"
+  },
+  "devDependencies": {
+    "@headlessui/react": "^1.7.15",
+    "@heroicons/react": "^2.0.18",
+    "@tailwindcss/aspect-ratio": "^0.4.2",
+    "@tailwindcss/forms": "^0.5.3",
+    "@tailwindcss/line-clamp": "^0.4.4",
+    "@tailwindcss/typography": "^0.5.9",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@testing-library/react": "^14.0.0",
+    "@testing-library/user-event": "^14.4.3",
+    "@types/jest": "^29.5.2",
+    "@types/node": "18.16.16",
+    "@types/react": "18.2.8",
+    "@types/react-dom": "18.2.4",
+    "autoprefixer": "^10.4.14",
+    "eslint": "^8.41.0",
+    "eslint-config-next": "13.4.4",
+    "jest": "^29.5.0",
+    "jest-css-modules-transform": "^4.4.2",
+    "postcss": "^8.4.24",
+    "prettier": "^2.8.8",
+    "prop-types": "^15.8.1",
+    "tailwind-scrollbar": "^2.1.0",
+    "tailwindcss": "^3.2.4",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "5.1.6"
+  }
+}

package/template/nextjs/sui-template/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}