@0xobelisk/sui-common 0.5.8 → 0.5.10

package/dist/index.js

@@ -1,403 +1,158 @@
-import*as l from"prettier";import*as te from"prettier-plugin-rust";async function ke(e,t){let r;t&&(r=await l.resolveConfig(t));try{return l.format(e,{plugins:[te],printWidth:120,semi:!0,tabWidth:2,useTabs:!1,bracketSpacing:!0,...r})}catch(s){let o;return s instanceof Error?o=s.message:o=s,console.log(`Error during output formatting: ${o}`),e}}async function T(e){return l.format(e,{parser:"typescript"})}import{mkdirSync as A,writeFileSync as E}from"fs";import{dirname as x}from"path";async function i(e,t,r){A(x(t),{recursive:!0}),E(t,e),r!==void 0&&console.log(`${r}: ${t}`)}async function Te(e,t,r){let s=await T(e);A(x(t),{recursive:!0}),E(t,s),console.log(`${r}: ${t}`)}function Ee(e){return e.replace(/\\/g,"/")}import{existsSync as de}from"fs";import _ from"fs";function k(e){_.existsSync(e)&&(_.readdirSync(e).forEach(t=>{let r=`${e}/${t}`;_.lstatSync(r).isDirectory()?k(r):_.unlinkSync(r)}),_.rmdirSync(e))}function $(e){return e.charAt(0).toUpperCase()+e.slice(1)}function C(e){return e=e.charAt(0).toUpperCase()+e.slice(1),e.replace(/(_\w)/g,r=>r[1].toUpperCase())+"Data"}function M(e,t){let r=[];return Object.entries(t).forEach(([s,o])=>{typeof o=="object"&&o.ephemeral||r.push(`	use ${e}::${s}_schema;`)}),r}function W(e){let t=[];return Object.entries(e).forEach(([r,s])=>{typeof s=="object"&&s.ephemeral||t.push(`		${r}_schema::register(&mut _obelisk_world, &admin_cap, ctx);`)}),t}function c(e,t){return typeof e=="string"?[`${t}value`]:Object.entries(e).map(([r,s])=>`${t}${r}`)}function b(e){return/^0x[a-fA-F0-9]+$/.test(e)}function re(e,t){if(typeof t=="string"||typeof t=="boolean"||typeof t=="number")return e==="string"?[`string(b"${t}")`]:typeof t=="string"&&b(t)?[`@${t}`]:[`${t}`];if(Array.isArray(t))if(t.length>0){if(typeof t[0]=="string"||typeof t[0]=="boolean"||typeof t[0]=="number")return e==="vector<string>"?[`vector[${t.map(r=>`string(b"${r}")`)}]`]:typeof t[0]=="string"&&b(t[0])?[`vector[${t.map(r=>`@${r}`)}]`]:[`vector[${t.map(r=>`${r}`)}]`];if(typeof t=="object")return[`vector[${t.map(s=>`vector[${s.map(o=>`${o}`)}]`)}]`]}else return e==="vector<string>"?'vector[string(b"")]':"vector[]";else if(typeof t=="object")return Object.entries(t).map(([s,o])=>{if(typeof o=="string"||typeof o=="boolean"||typeof o=="number"){if(typeof e=="string"){if(e==="string")return`string(b"${o}")`}else if(e[s]==="string")return`string(b"${o}")`;return typeof o=="string"&&b(o)?`@${o}`:`${o}`}else if(Array.isArray(o)){if(o.length>0){if(typeof o[0]=="string"||typeof o[0]=="boolean"||typeof o[0]=="number"){if(typeof e=="string"){if(e==="vector<string>")return`vector[${o.map(n=>`string(b"${n}")`)}]`}else if(e[s]==="vector<string>")return`vector[${o.map(n=>`string(b"${n}")`)}]`;return typeof o[0]=="string"&&b(o[0])?`vector[${o.map(n=>`@${n}`)}]`:`vector[${o.map(n=>`${n}`)}]`}else if(typeof o=="object")return`vector[${o.map(u=>`vector[${u.map(p=>`${p}`)}]`)}]`}else if(typeof e!="string")return e[s]==="vector<string>"?'vector[string(b"")]':"vector[]"}});return[]}function j(e){return typeof e=="string"?e:`(${Object.entries(e).map(([t,r])=>`${r}`)})`}function d(e,t){return typeof e=="string"?[`${t}value: ${e}`]:Object.entries(e).map(([r,s])=>`${t}${r}: ${s}`)}function se(e,t){return typeof e=="string"?[`${t}_obelisk_data.value`]:Object.entries(e).map(([r,s])=>`${t}_obelisk_data.${r}`)}function g(e){return`	${c(e,"// ").join(`
-	`)}`}function f(e,t,r=!1){return`	public struct ${e} has copy, drop ${r?"":", store"} {
-${d(t,"		").join(`,
-`)}
-	}
-`}function h(e,t){return`	public fun new(${d(t,"").join(", ")}): ${e} {
-		${e} {
-${c(t,"			").join(`, 
-`)}
-		}
-	}
-`}function N(e){return`	public fun register(_obelisk_world: &mut World, admin_cap: &AdminCap, ctx: &mut TxContext) {
-		schema::add<Table<address,${e}>>(_obelisk_world, SCHEMA_ID, table::new<address, ${e}>(ctx), admin_cap);
-	}`}function R(e,t){return`	public(package) fun set(_obelisk_world: &mut World, _obelisk_entity_key: address, ${d(t," ")}) {
-		let _obelisk_schema = schema::get_mut<Table<address,${e}>, AppKey>(app_key::new(), _obelisk_world, SCHEMA_ID);
-		let _obelisk_data = new(${c(t," ")});
-		if(table::contains<address, ${e}>(_obelisk_schema, _obelisk_entity_key)) {
-			*table::borrow_mut<address, ${e}>(_obelisk_schema, _obelisk_entity_key) = _obelisk_data;
-		} else {
-			table::add(_obelisk_schema, _obelisk_entity_key, _obelisk_data);
-		};
-		events::emit_set(SCHEMA_ID, SCHEMA_TYPE, some(_obelisk_entity_key), _obelisk_data)
-	}
-`}function O(e){return`	public(package) fun remove(_obelisk_world: &mut World, _obelisk_entity_key: address) {
-		let _obelisk_schema = schema::get_mut<Table<address,${e}>, AppKey>(app_key::new(),_obelisk_world, SCHEMA_ID);
-		assert!(table::contains<address, ${e}>(_obelisk_schema, _obelisk_entity_key), EEntityDoesNotExist);
-		table::remove(_obelisk_schema, _obelisk_entity_key);
-		events::emit_remove(SCHEMA_ID, _obelisk_entity_key)
-	}
-`}function I(e,t){return typeof t=="string"?"":`
-`+Object.entries(t).map(([r,s])=>`	public(package) fun set_${r}(_obelisk_world: &mut World, _obelisk_entity_key: address, ${r}: ${s}) {
-		let _obelisk_schema = schema::get_mut<Table<address,${e}>, AppKey>(app_key::new(),_obelisk_world, SCHEMA_ID);
-		assert!(table::contains<address, ${e}>(_obelisk_schema, _obelisk_entity_key), EEntityDoesNotExist);
-		let _obelisk_data = table::borrow_mut<address, ${e}>(_obelisk_schema, _obelisk_entity_key);
-		_obelisk_data.${r} = ${r};
-		events::emit_set(SCHEMA_ID, SCHEMA_TYPE, some(_obelisk_entity_key), *_obelisk_data)
-	}
-`).join(`
-`)}function D(e,t){return`	public fun get(_obelisk_world: &World, _obelisk_entity_key: address): ${j(t)} {
-		let _obelisk_schema = schema::get<Table<address,${e}>>(_obelisk_world, SCHEMA_ID);
-		assert!(table::contains<address, ${e}>(_obelisk_schema, _obelisk_entity_key), EEntityDoesNotExist);
-		let _obelisk_data = table::borrow<address, ${e}>(_obelisk_schema, _obelisk_entity_key);
-		(
-${se(t,"			").join(`,
-`)}
-		)
-	}
-`}function F(e,t){return typeof t=="string"?"":`
-`+Object.entries(t).map(([r,s])=>`	public fun get_${r}(_obelisk_world: &World, _obelisk_entity_key: address): ${s} {
-		let _obelisk_schema = schema::get<Table<address,${e}>>(_obelisk_world, SCHEMA_ID);
-		assert!(table::contains<address, ${e}>(_obelisk_schema, _obelisk_entity_key), EEntityDoesNotExist);
-		let _obelisk_data = table::borrow<address, ${e}>(_obelisk_schema, _obelisk_entity_key);
-		_obelisk_data.${r}
-	}
-`).join(`
-`)}function H(e){return`	public fun contains(_obelisk_world: &World, _obelisk_entity_key: address): bool {
-		let _obelisk_schema = schema::get<Table<address,${e}>>(_obelisk_world, SCHEMA_ID);
-		table::contains<address, ${e}>(_obelisk_schema, _obelisk_entity_key)
-	}`}function V(e,t,r){return`	public fun register(_obelisk_world: &mut World, admin_cap: &AdminCap, _ctx: &mut TxContext) {
-		let _obelisk_schema = new(${re(t,r)});
-		schema::add<${e}>(_obelisk_world, SCHEMA_ID, _obelisk_schema, admin_cap);
-		events::emit_set(SCHEMA_ID, SCHEMA_TYPE, none(), _obelisk_schema);
-	}`}function B(e,t){return`	public(package) fun set(_obelisk_world: &mut World, ${d(t," ")}) {
-		let _obelisk_schema = schema::get_mut<${e}, AppKey>(app_key::new(),_obelisk_world, SCHEMA_ID);
-${typeof t=="string"?`		_obelisk_schema.value = value;
-        events::emit_set(SCHEMA_ID, SCHEMA_TYPE, none(), _obelisk_schema.value);`:`		let _obelisk_data = new(${c(t," ")});
-        *_obelisk_schema = _obelisk_data;
-        events::emit_set(SCHEMA_ID, SCHEMA_TYPE, none(), _obelisk_data);`}
-	}`}function K(e,t){return typeof t=="string"?"":`
-`+Object.entries(t).map(([r,s])=>`
-	public(package) fun set_${r}(_obelisk_world: &mut World, ${r}: ${s}) {
-		let _obelisk_schema = schema::get_mut<${e}, AppKey>(app_key::new(),_obelisk_world, SCHEMA_ID);
-		_obelisk_schema.${r} = ${r};
-		events::emit_set(SCHEMA_ID, SCHEMA_TYPE, none(), *_obelisk_schema)
-	}`).join(`
-`)}function U(e,t){return`	public fun get(_obelisk_world: &World): ${j(t)} {
-		let _obelisk_schema = schema::get<${e}>(_obelisk_world, SCHEMA_ID);
-		(
-${typeof t=="string"?"			_obelisk_schema.value":Object.entries(t).map(([r,s])=>`			_obelisk_schema.${r},`).join(`
-`)}
-		)
-	}`}function Y(e,t){return typeof t=="string"?"":`
-`+Object.entries(t).map(([r,s])=>`
-	public fun get_${r}(_obelisk_world: &World): ${s} {
-		let _obelisk_schema = schema::get<${e}>(_obelisk_world, SCHEMA_ID);
-		_obelisk_schema.${r}
-	}`).join(`
-`)}import{existsSync as oe}from"fs";function G(e,t){e.systems.map(r=>{if(!oe(`${t}/contracts/${e.name}/sources/system/${r}.move`)){let s=`module ${e.name}::${r} {
+import y from"prettier";import I from"prettier-plugin-move";async function S(e,t){let r;t&&(r=await y.resolveConfig(t));try{return y.format(e,{plugins:[I],parser:"move-parse",printWidth:120,semi:!0,tabWidth:2,useTabs:!1,bracketSpacing:!0,...r})}catch(o){let i;return o instanceof Error?i=o.message:i=o,console.log(`Error during output formatting: ${i}`),e}}async function h(e){return y.format(e,{parser:"typescript"})}import $ from"node:fs/promises";import A from"node:path";import v from"debug";var f=v("obelisk:common"),U=v("obelisk:common");f.log=console.debug.bind(console);U.log=console.error.bind(console);var g=f.extend("codegen"),B=f.extend("codegen");g.log=console.debug.bind(console);B.log=console.error.bind(console);async function a(e,t,r){let o=await S(e),s=`  // Copyright (c) Obelisk Labs, Inc.
+  // SPDX-License-Identifier: MIT
+  #[allow(unused_use)]
+  
+  /* Autogenerated file. Do not edit manually. */
+  `+o;(t.includes("deploy_hook")||t.includes(".toml")||t.includes("system"))&&(s=o),await $.mkdir(A.dirname(t),{recursive:!0}),await $.writeFile(t,s),g(`${r}: ${t}`)}async function ue(e,t,r){let o=await h(e);await $.mkdir(A.dirname(t),{recursive:!0}),await $.writeFile(t,o),g(`${r}: ${t}`)}function le(e){return e.replace(/\\/g,"/")}import{existsSync as k}from"fs";import d from"fs";function _(e){d.existsSync(e)&&(d.readdirSync(e).forEach(t=>{let r=`${e}/${t}`;d.lstatSync(r).isDirectory()?_(r):d.unlinkSync(r)}),d.rmdirSync(e))}function T(e){return Object.entries(e).map(([t,r])=>`${t}`).join(",")}function M(e){return typeof e=="string"?e:`(${Object.entries(e).map(([t,r])=>`${r}`)})`}function l(e){return Object.entries(e).map(([t,r])=>`${t}: ${r}`)}function C(e,t){return typeof e=="string"?[`${t}self.value`]:Object.entries(e).map(([r,o])=>`${t}self.${r}`)}import{existsSync as K}from"fs";async function D(e,t){e.systems.map(async r=>{if(!K(`${t}/contracts/${e.name}/sources/system/${r}.move`)){let o=`module ${e.name}::${r}_system {
 
 }
-`;i(s,`${t}/contracts/${e.name}/sources/system/${r}.move`,"formatAndWriteMove")}})}function z(e,t){let r=`[package]
+`;await a(o,`${t}/contracts/${e.name}/sources/system/${r}.move`,"formatAndWriteMove")}})}async function j(e,t){let r=`[package]
 name = "${e.name}"
 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.31.1" }
-# Obelisk = { git = "https://github.com/0xobelisk/obelisk-engine.git", subdir = "packages/obelisk-framework", rev = "mainnet-v1.31.1" }
-Obelisk = { local = "/Volumes/project/obelisk-engine/packages/obelisk-framework" }
+Obelisk = { git = "https://github.com/0xobelisk/obelisk-engine.git", subdir = "packages/obelisk-framework", rev = "main" }
 
 [addresses]
 sui =  "0x2"
-obelisk =  "0x6c93abd6e076235f51c6dd95b4adf9b0d4f5b6f6766c6a7b6653101a78a04d8c"
+obelisk =  "0x3dc2d6239eed38c9798444afbf4bada0998ec98edc365713864405fe64203256"
 ${e.name} = "0x0"
-`;i(r,`${t}/contracts/${e.name}/Move.toml`,"formatAndWriteMove")}function L(e,t){let r=`module ${e.name}::entity_key {
-    use sui::hash::keccak256;
-    use sui::address;
-    use sui::bcs;
-
-    public fun from_object<T: key + store>(object: &T): address {
-        object::id_address(object)
-    }
-
-    public fun from_bytes(bytes: vector<u8>): address {
-        address::from_bytes(keccak256(&bytes))
-    }
-
-    public fun from_u256(x: u256): address {
-        address::from_u256(x)
-    }
-
-   public fun from_address_with_seed(addr: address, seed: vector<u8>): address {
-        let mut data = address::to_bytes(addr);
-        vector::append(&mut data, seed);
-        from_bytes(data)
-    }
-
-    public fun from_address_with_u256(addr: address, x: u256): address {
-        let mut data = address::to_bytes(addr);
-        vector::append(&mut data, bcs::to_bytes<u256>(&x));
-        from_bytes(data)
-    }
-
-    public fun from_object_with_seed<T: key + store>(object: &T, seed: vector<u8>): address {
-        let mut data = address::to_bytes(object::id_address(object));
-        vector::append(&mut data, seed);
-        from_bytes(data)
-    }
-
-    public fun from_object_with_u256<T: key + store>(object: &T, x: u256): address {
-        let mut data = address::to_bytes(object::id_address(object));
-        vector::append(&mut data, bcs::to_bytes<u256>(&x));
-        from_bytes(data)
-    }
-}
-`;i(r,`${t}/contracts/${e.name}/sources/entity_key.move`,"formatAndWriteMove")}function P(e,t){let r=`#[allow(lint(share_owned))] 
-
-module ${e.name}::init {
-    use std::ascii::string;
-    use ${e.name}::app_key::AppKey;
-    use obelisk::access_control;
-    use obelisk::world;
-${M(e.name,e.schemas).join(`
+`;await a(r,`${t}/contracts/${e.name}/Move.toml`,"formatAndWriteMove")}function m(e){return e.split("_").map((t,r)=>t.charAt(0).toUpperCase()+t.slice(1).toLowerCase()).join("")}function L(e,t){return Object.entries(t).map(([r,o])=>`public(package) fun set_${r}(self: &mut ${e}, ${r}: ${o}) {
+                        self.${r} = ${r};
+                    }`).join(`
+`)}function V(e,t){return`public(package) fun set(self: &mut ${e}, ${l(t)}) {
+            ${Object.entries(t).map(([r])=>`self.${r} = ${r};`).join(`
 `)}
-
-    fun init(ctx: &mut TxContext) {
-        let (mut _obelisk_world, admin_cap) = world::create(string(b"${$(e.name)}"), string(b"${$(e.description)}"),ctx);
-        
-        // Authorize this application to access protected features of the World.
-        access_control::authorize_app<AppKey>(&admin_cap, &mut _obelisk_world);
-
-        // Add Schema
-${W(e.schemas).join(`
+            }`}function N(e,t){return`public fun get(self: &${e}): ${M(t)} {
+        (${C(t,"")})
+    }`}function z(e,t){return Object.entries(t).map(([r,o])=>`public fun get_${r}(self: &${e}): ${o} {
+                                    self.${r}
+                                }`).join(`
+`)}function u(e){return e.replace(/([A-Z])/g,"_$1").toLowerCase().replace(/^_/,"")}async function O(e,t,r){for(let o in t){let i=t[o];if(i.data)for(let s of i.data){let c="",p=i.data.filter(n=>Array.isArray(n.fields)).map(n=>n.name);Array.isArray(s.fields)?c=`module ${e}::${o}_${u(s.name)} {
+                        public enum ${s.name} has copy, drop , store {
+                                ${s.fields}
+                        }
+                        
+                        ${s.fields.map(n=>`public fun new_${u(n)}(): ${s.name} {
+                                ${s.name}::${n}
+                            }`).join("")}`:c=`module ${e}::${o}_${u(s.name)} {
+                            use std::ascii::String;
+                            ${p.map(n=>`use ${e}::${o}_${u(n)}::${n};`).join(`
 `)}
 
-        transfer::public_share_object(_obelisk_world);
-        transfer::public_transfer(admin_cap, tx_context::sender(ctx));
-    }
-
+                           public struct ${s.name} has copy, drop , store {
+                                ${l(s.fields)}
+                           }
+                        
+                           public fun new(${l(s.fields)}): ${s.name} {
+                               ${s.name} {
+                                   ${T(s.fields)}
+                               }
+                            }
+                        
+                           ${N(s.name,s.fields)}
+                           ${z(s.name,s.fields)}
+                           ${L(s.name,s.fields)}
+                           ${V(s.name,s.fields)}
+                        }`,await a(c,`${r}/contracts/${e}/sources/codegen/schemas/${o}_${u(s.name)}.move`,"formatAndWriteMove")}}}function G(e,t,r){return r.data?r.data.map(o=>`use ${e}::${t}_${u(o.name)}::${o.name};`).join(`
+`):""}async function W(e,t,r){for(let o in t){console.log(`Schema: ${o}`);let i=t[o],s=`module ${e}::${o}_schema {
+                    use std::ascii::String;
+                    use std::type_name;
+                    use sui::transfer::{public_share_object};
+                    use obelisk::dapps_system;
+                    use obelisk::dapps_schema::Dapps;
+                    use obelisk::storage_value::{Self, StorageValue};
+                    use obelisk::storage_map::{Self, StorageMap};
+                    use obelisk::storage_double_map::{Self, StorageDoubleMap};
+                    use ${e}::dapp_key::DappKey;
+                    ${G(e,o,i)}
+
+                    public struct ${m(o)} has key, store {
+                        id: UID,
+                        ${l(i.structure)}
+                    } 
+                    
+                     ${Object.entries(i.structure).map(([c,p])=>`public fun borrow_${c}(self: &${m(o)}) : &${p} {
+                        &self.${c}
+                    }
+                    
+                    public(package) fun borrow_mut_${c}(self: &mut ${m(o)}): &mut ${p} {
+                        &mut self.${c}
+                    }
+                    `).join("")} 
+                    
+                    public entry fun register(dapps: &mut Dapps, ctx: &mut TxContext) {
+                      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<${m(o)}>().into_string();
+                      assert!(!dapps.borrow_schemas().get(package_id).contains(&schema), 0);
+                
+                        public_share_object(${m(o)} {
+                          id: object::new(ctx),
+                          ${Object.entries(i.structure).map(([c,p])=>{let n="";return p.includes("StorageValue")?n="storage_value::new()":p.includes("StorageMap")?n="storage_map::new()":p.includes("StorageDoubleMap")&&(n="storage_double_map::new()"),`${c}: ${n},`}).join(" ")}
+                        });
+                
+                      dapps_system::add_schema<${m(o)}>(dapps, package_id, ctx);
+                    }
+               
+           }`;await a(s,`${r}/contracts/${e}/sources/codegen/schemas/${o}.move`,"formatAndWriteMove")}}import{existsSync as H}from"fs";async function R(e,t){if(!H(`${t}/contracts/${e.name}/sources/script/deploy_hook.move`)){let r=`module ${e.name}::deploy_hook {
+    use obelisk::dapps_schema::Dapps;
+    use obelisk::dapps_system;
+    use ${e.name}::dapp_key::DappKey;
+    use std::ascii;
+    use sui::clock::Clock;
     #[test_only]
-    public fun init_world_for_testing(ctx: &mut TxContext){
-        init(ctx)
-    }
-}
-`;i(r,`${t}/contracts/${e.name}/sources/codegen/init.move`,"formatAndWriteMove")}function ie(e){let t=[];for(let r of Object.keys(e.schemas)){let s=e.schemas[r],o,n,u,p=!1,v=!1,a=!1;if(typeof s=="string")n=s,s==="string"?(o="String",a=!0):s==="vector<string>"?(o="vector<String>",a=!0):o=s;else{if(n=s.valueType,typeof s.valueType=="string")s.valueType==="string"?(o="String",a=!0):s.valueType==="vector<string>"?(o="vector<String>",a=!0):o=s.valueType;else{o={...s.valueType};for(let m in o)o.hasOwnProperty(m)&&(o[m]==="string"?(o[m]="String",a=!0):o[m]==="vector<string>"&&(o[m]="vector<String>",a=!0))}u=s.defaultValue,p=s.ephemeral!==void 0?s.ephemeral:!1,v=s.defaultValue!==void 0}t.push({projectName:e.name,systems:e.systems,schemaName:r,structName:C(r),ephemeral:p,singleton:v,valueType:o,realType:n,defaultValue:u,needImportString:a})}return t}function Q(e,t){let r=ie(e);for(let s of r){let o;s.ephemeral?o=ne(s):s.defaultValue!==void 0?o=ae(s):o=ce(s),i(o,`${t}/contracts/${s.projectName}/sources/codegen/schemas/${s.schemaName}.move`,"formatAndWriteMove")}}function ne(e){return`module ${e.projectName}::${e.schemaName}_schema {
-	use std::option::none;
-	use obelisk::events;
-    
-    const SCHEMA_ID: vector<u8> = b"${e.schemaName}";
-    const SCHEMA_TYPE: u8 = 2;
-    
-${g(e.valueType)}
-${f(e.structName,e.valueType,e.ephemeral)}  
-	public fun emit_${e.schemaName}(${d(e.valueType," ")}) {
-		events::emit_set(SCHEMA_ID, SCHEMA_TYPE, none(), ${e.structName} { ${c(e.valueType," ")} })
-	}
-}`}function ae(e){return`module ${e.projectName}::${e.schemaName}_schema {
-${e.needImportString?`	use std::ascii::{String,string};
-	`:"	"}use std::option::none;
-    use ${e.projectName}::app_key;
-    use ${e.projectName}::app_key::AppKey;
-    use obelisk::schema;
-    use obelisk::events;
-    use obelisk::world::{World, AdminCap};
-
-	const SCHEMA_ID: vector<u8> = b"${e.schemaName}";
-	const SCHEMA_TYPE: u8 = 1;
-
-${g(e.valueType)}
-${f(e.structName,e.valueType)}
-${h(e.structName,e.valueType)}
-${V(e.structName,e.realType,e.defaultValue)}
-
-${B(e.structName,e.valueType)}${K(e.structName,e.valueType)}
-
-${U(e.structName,e.valueType)}${Y(e.structName,e.valueType)}
-}
-`}function ce(e){return`module ${e.projectName}::${e.schemaName}_schema {
-${e.needImportString?`	use std::ascii::String;
-	`:"	"}use std::option::some;
-    use ${e.projectName}::app_key;
-    use ${e.projectName}::app_key::AppKey;
-    use sui::table::{Self, Table};
-    use obelisk::schema;
-    use obelisk::events;
-    use obelisk::world::{World, AdminCap};
-
-	/// Entity does not exist
-	const EEntityDoesNotExist: u64 = 0;
-
-	const SCHEMA_ID: vector<u8> = b"${e.schemaName}";
-	const SCHEMA_TYPE: u8 = 0;
-
-${g(e.valueType)}
-${f(e.structName,e.valueType)}
-${h(e.structName,e.valueType)}
-${N(e.structName)}
-
-${R(e.structName,e.valueType)}${I(e.structName,e.valueType)}
-${D(e.structName,e.valueType)}${F(e.structName,e.valueType)}
-${O(e.structName)}
-${H(e.structName)}
-}
-`}import{existsSync as q}from"fs";function J(e,t){if(!q(`${t}/contracts/${e.name}/sources/script/deploy_hook.move`)){let r=`module ${e.name}::deploy_hook {
-    use obelisk::world::{World, AdminCap};
-
-    /// Not the right admin for this world
-    const ENotAdmin: u64 = 0;
-
-    public entry fun run(world: &mut World, admin_cap: &AdminCap) {
-         assert!(world.admin() == object::id(admin_cap), ENotAdmin);
+      use obelisk::dapps_schema;
+      #[test_only]
+      use sui::clock;
+      #[test_only]
+      use sui::test_scenario;
+      #[test_only]
+      use sui::test_scenario::Scenario;
+
+    public entry fun run(dapps: &mut Dapps, clock: &Clock, ctx: &mut TxContext) {
+        // Register the dapp to obelisk.
+        dapps_system::register<DappKey>(
+            dapps,
+            ascii::string(b"${e.name}"),
+            ascii::string(b"${e.description}"),
+            clock,
+            ctx
+        );
+        ${Object.keys(e.schemas).map(o=>`${e.name}::${o}_schema::register(dapps, ctx);`).join(`
+`)}
         
         // Logic that needs to be automated once the contract is deployed
-        
-    }
-
-    #[test_only]
-    public fun deploy_hook_for_testing(world: &mut World, admin_cap: &AdminCap){
-        run(world, admin_cap)
-    }
-}
-`;i(r,`${t}/contracts/${e.name}/sources/script/deploy_hook.move`,"formatAndWriteMove")}}function X(e,t){if(!q(`${t}/contracts/${e.name}/sources/script/migrate.move`)){let r=`module ${e.name}::migrate {
-    use obelisk::world::{World, AdminCap};
-
-    /// Not the right admin for this world
-    const ENotAdmin: u64 = 0;
-    const EWrongVersion: u64 = 1;
-    const ENotUpgrade: u64 = 2;
-    const VERSION: u64 = 1;
 
-    public entry fun run(world: &mut World, admin_cap: &AdminCap) {
-        assert!(world.admin() == object::id(admin_cap), ENotAdmin);
-        assert!(world.version() < VERSION, ENotUpgrade);
-        *obelisk::world::mut_version(world, admin_cap) = VERSION;
     }
 
-    public fun assert_version(world: &World){
-        assert!(world.version() == VERSION, EWrongVersion);
-    }
+    #[test_only]
+    public fun deploy_hook_for_testing(): (Scenario, Dapps) {
+      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 ctx = test_scenario::ctx(&mut scenario);
+      let clock = clock::create_for_testing(ctx);
+      run(&mut dapps, &clock, ctx);
+      clock::destroy_for_testing(clock);
+      test_scenario::next_tx(&mut scenario,@0xA);
+      (scenario, dapps)
+  }
 }
-`;i(r,`${t}/contracts/${e.name}/sources/script/migrate.move`,"formatAndWriteMove")}}function Z(e,t){let r=`module ${e.name}::app_key {
+`;await a(r,`${t}/contracts/${e.name}/sources/script/deploy_hook.move`,"formatAndWriteMove")}}async function E(e,t){let r=`module ${e.name}::dapp_key {
   /// Authorization token for the app.
-    public struct AppKey has drop {}
-
-    public(package) fun new(): AppKey {
-        AppKey {  }
-    }
-}
-`;i(r,`${t}/contracts/${e.name}/sources/codegen/app_key.move`,"formatAndWriteMove")}function it(e,t){let r="";t===void 0?r=process.cwd():r=t,de(`${r}/contracts/${e.name}`)?k(`${r}/contracts/${e.name}/sources/codegen`):(z(e,r),L(e,r)),G(e,r),J(e,r),X(e,r),Q(e,r),P(e,r),Z(e,r)}function ct(e,t,r){me(e,t,r),le(e,t)}function me(e,t,r){r===void 0&&(r=1);let s=`module ${e}::world {
-    use std::ascii::{String, string};
-    use std::vector;
-    use sui::tx_context::TxContext;
-    use sui::bag::{Self, Bag};
-    use sui::object::{Self, UID, ID};
-    
-    const VERSION: u64 = ${r};
-
-    /// Schema does not exist
-    const ESchemaDoesNotExist: u64 = 0;
-    /// Schema already exists
-    const ESchemaAlreadyExists: u64 = 1;
-    /// Not the right admin for this world
-    const ENotAdmin: u64 = 2;
-    /// Migration is not an upgrade
-    const ENotUpgrade: u64 = 3;
-    /// Calling functions from the wrong package version
-    const EWrongVersion: u64 = 4;
-
-    struct AdminCap has key, store {
-        id: UID,
-    }
-
-    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 _obelisk_world = World {
-            id: object::new(ctx),
-            name,
-            description,
-            schemas: bag::new(ctx),
-            schema_names: vector::empty(),
-            admin: object::id(&admin_cap),
-            version: VERSION
-        };
-        (_obelisk_world, admin_cap)
-    }
-    
-    public fun get_admin(_obelisk_world: &World): ID {
-        _obelisk_world.admin
-    }
-
-    public fun info(_obelisk_world: &World): (String, String, u64) {
-        (_obelisk_world.name, _obelisk_world.description, _obelisk_world.version)
-    }
-    
-    public fun schema_names(_obelisk_world: &World): vector<String> {
-        _obelisk_world.schema_names
-    }
-
-    public fun get_schema<T : store>(_obelisk_world: &World, _obelisk_schema_id: vector<u8>): &T {
-        assert!(_obelisk_world.version == VERSION, EWrongVersion);
-        assert!(bag::contains(&_obelisk_world.schemas, _obelisk_schema_id), ESchemaDoesNotExist);
-        bag::borrow<vector<u8>, T>(&_obelisk_world.schemas, _obelisk_schema_id)
-    }
-
-    public fun get_mut_schema<T : store>(_obelisk_world: &mut World, _obelisk_schema_id: vector<u8>): &mut T {
-        assert!(_obelisk_world.version == VERSION, EWrongVersion);
-        assert!(bag::contains(&_obelisk_world.schemas, _obelisk_schema_id), ESchemaDoesNotExist);
-        bag::borrow_mut<vector<u8>, T>(&mut _obelisk_world.schemas, _obelisk_schema_id)
-    }
-
-    public fun add_schema<T : store>(_obelisk_world: &mut World, _obelisk_schema_id: vector<u8>, schema: T, admin_cap: &AdminCap){
-        assert!(_obelisk_world.admin == object::id(admin_cap), ENotAdmin);
-        assert!(_obelisk_world.version == VERSION, EWrongVersion);
-        assert!(!bag::contains(&_obelisk_world.schemas, _obelisk_schema_id), ESchemaAlreadyExists);
-        vector::push_back(&mut _obelisk_world.schema_names, string(_obelisk_schema_id));
-        bag::add<vector<u8>,T>(&mut _obelisk_world.schemas, _obelisk_schema_id, schema);
-    }
-
-    public fun contains(_obelisk_world: &mut World, _obelisk_schema_id: vector<u8>): bool {
-        assert!(_obelisk_world.version == VERSION, EWrongVersion);
-        bag::contains(&mut _obelisk_world.schemas, _obelisk_schema_id)
-    }
-    
-    entry fun migrate(_obelisk_world: &mut World, admin_cap: &AdminCap) {
-        assert!(_obelisk_world.admin == object::id(admin_cap), ENotAdmin);
-        assert!(_obelisk_world.version < VERSION, ENotUpgrade);
-        _obelisk_world.version = VERSION;
-    }
-}
-`;i(s,`${t}/contracts/${e}/sources/codegen/eps/world.move`,"formatAndWriteMove")}function le(e,t){let r=`module ${e}::events {
-    use sui::event;
-    use std::option::Option;
-
-    struct SchemaSetRecord<T: copy + drop> has copy, drop {
-        _obelisk_schema_id: vector<u8>,
-        _obelisk_schema_type: u8, // obelisk_schema_type_enum => { 0: common, 1: singleton, 2: ephemeral }
-        _obelisk_entity_key: Option<address>,
-        data: T
-    }
-
-    struct SchemaRemoveRecord has copy, drop {
-        _obelisk_schema_id: vector<u8>,
-        _obelisk_entity_key: address
-    }
-
-    public fun emit_set<T: copy + drop>(_obelisk_schema_id: vector<u8>, _obelisk_schema_type: u8, _obelisk_entity_key: Option<address>, data: T) {
-        event::emit(SchemaSetRecord { _obelisk_schema_id, _obelisk_schema_type, _obelisk_entity_key, data})
-    }
+    public struct DappKey has drop {}
 
-    public fun emit_remove(_obelisk_schema_id: vector<u8>, _obelisk_entity_key: address) {
-        event::emit(SchemaRemoveRecord { _obelisk_schema_id, _obelisk_entity_key })
+    public(package) fun new(): DappKey {
+        DappKey {  }
     }
 }
-`;i(r,`${t}/contracts/${e}/sources/codegen/eps/events.move`,"formatAndWriteMove")}import{findUp as _e}from"find-up";import S from"path";import ue from"esbuild";var y=class extends Error{name="NotInsideProjectError";message="You are not inside a Obelisk project"};import{rmSync as pe}from"fs";import{pathToFileURL as be}from"url";import ge from"os";var fe=["obelisk.config.js","obelisk.config.mjs","obelisk.config.ts","obelisk.config.mts"],w="obelisk.config.example.mjs";async function yt(e){e=await ee(e);try{return await ue.build({entryPoints:[e],format:"esm",outfile:w,platform:"node",bundle:!0,packages:"external"}),e=await ee(w,!0),(await import(e+`?update=${Date.now()}`)).obeliskConfig}finally{pe(w,{force:!0})}}async function ee(e,t){return e===void 0?e=await ye():S.isAbsolute(e)||(e=S.join(process.cwd(),e),e=S.normalize(e)),t&&ge.platform()==="win32"?be(e).href:e}async function ye(){let e=await _e(fe);if(e===void 0)throw new y;return e}export{i as formatAndWriteMove,Te as formatAndWriteTypescript,ke as formatMove,T as formatTypescript,ct as generateEps,yt as loadConfig,Ee as posixPath,ee as resolveConfigPath,it as worldgen};
+`;await a(r,`${t}/contracts/${e.name}/sources/codegen/dapp_key.move`,"formatAndWriteMove")}async function Be(e,t){let r="";t===void 0?r=process.cwd():r=t,k(`${r}/contracts/${e.name}`)&&_(`${r}/contracts/${e.name}/sources/codegen`),k(`${r}/contracts/${e.name}/Move.toml`)||await j(e,r),k(`${r}/contracts/${e.name}/sources/script/deploy_hook.move`)||await R(e,r),await D(e,r),await O(e.name,e.schemas,r),await W(e.name,e.schemas,r),await E(e,r)}import{findUp as Q}from"find-up";import x from"path";import X from"esbuild";var b=class extends Error{name="NotInsideProjectError";message="You are not inside a Obelisk project"};import{rmSync as Y}from"fs";import{pathToFileURL as Z}from"url";import q from"os";var J=["obelisk.config.js","obelisk.config.mjs","obelisk.config.ts","obelisk.config.mts"],w="obelisk.config.example.mjs";async function Ye(e){e=await F(e);try{return await X.build({entryPoints:[e],format:"esm",outfile:w,platform:"node",bundle:!0,packages:"external"}),e=await F(w,!0),(await import(e+`?update=${Date.now()}`)).obeliskConfig}finally{Y(w,{force:!0})}}async function F(e,t){return e===void 0?e=await P():x.isAbsolute(e)||(e=x.join(process.cwd(),e),e=x.normalize(e)),t&&q.platform()==="win32"?Z(e).href:e}async function P(){let e=await Q(J);if(e===void 0)throw new b;return e}export{a as formatAndWriteMove,ue as formatAndWriteTypescript,S as formatMove,h as formatTypescript,Ye as loadConfig,le as posixPath,F as resolveConfigPath,Be as worldgen};
 //# sourceMappingURL=index.js.map