wowok 1.0.3

package/src/permission.ts

@@ -0,0 +1,224 @@
+import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
+import { BCS } from '@mysten/bcs';
+import { description_data, FnCallType, PROTOCOL, TxbObject, GuardObject, TXB_OBJECT} from './protocol';
+import { array_unique } from './util';
+
+
+export const MAX_ADMIN_COUNT = 64;
+export const MAX_ENTITY_COUNT = 1024;
+export const MAX_PERMISSION_INDEX_COUNT = 512;
+
+export enum PermissionIndex {
+    repository = 100,
+    repository_set_description_set = 101,
+    repository_set_policy_mode = 102,
+    repository_add_policies = 106,
+    repository_remove_policies = 107,
+    repository_set_policy_description = 109,
+    repository_set_policy_permission = 110,
+    vote = 150,
+    vote_set_description = 151,
+    vote_set_reference = 152, 
+    vote_add_guard = 153,
+    vote_remove_guard = 154,
+    vote_add_option = 155,
+    vote_remove_option = 156,
+    vote_set_max_choice_count = 157,
+    vote_open_voting = 158,
+    vote_lock_deadline = 159,
+    vote_expand_deadline = 160,
+    vote_lock_guard = 161,
+    service = 200,
+    service_set_description = 201,
+    service_set_price = 202,
+    service_set_stock = 203,
+    service_add_stock = 203,
+    service_reduce_stock = 203,
+    service_set_payee = 205,
+    service_repository_add = 206,
+    service_repository_remove = 207,
+    service_add_withdraw_guards = 208,
+    service_remove_withdraw_guards  = 209,
+    service_add_refund_guards = 210,
+    service_remove_refund_guards = 211,
+    service_add_sales = 212,
+    service_remove_sales = 213,
+    service_discount_transfer = 214,
+    service_withdraw = 216,
+    service_set_buy_guard = 217,
+    service_set_machine = 218,
+    service_set_endpoint = 219,
+    service_publish = 220,
+    service_clone = 221,
+    service_set_customer_required = 222,
+    service_remove_customer_required = 222,
+    service_change_required_pubkey = 222,
+    service_change_order_required_pubkey = 224,
+    service_pause = 225,
+    reward = 240,
+    reward_refund = 241,
+    reward_expand_time = 242,
+    reward_add_guard = 243,
+    reward_remove_guard = 244,
+    reward_set_description = 245,
+    reward_lock_guards = 246,
+    demand = 260,
+    demand_refund = 261,
+    demand_expand_time = 262,
+    demand_set_guard = 263,
+    demand_set_description = 264,
+    demand_yes = 265,
+    machine = 600,
+    machine_set_description = 601,
+    machine_add_repository = 602,
+    machine_remove_repository = 603,
+    machine_clone =  604,
+    machine_add_node = 606,
+    machine_add_node2 = 606,
+    machine_remove_node = 607,
+    machine_set_endpoint = 608,
+    machine_pause = 609,
+    machine_publish = 610,
+    progress = 650,
+    progress_set_namedOperator = 651,
+    progress_bind_task = 652,
+    progress_set_context_repository = 653,
+    progress_unhold = 654,
+}
+export type Permission_Index = {
+    index:PermissionIndex;
+    guard?: TxbObject;
+}
+export type Permission_Entity = {
+    who:string;
+    permissions:Permission_Index[];
+}
+
+export type PermissionAddress = TransactionResult;
+export type PermissionObject = TransactionResult;
+
+export function permission(txb:TransactionBlock, description:string) : PermissionObject {
+    return txb.moveCall({
+        target: PROTOCOL.PermissionFn('new') as FnCallType,
+        arguments: [txb.pure(description_data(description))]
+    });
+}
+
+export function launch(txb:TransactionBlock, permission:PermissionObject) : PermissionAddress {
+    return txb.moveCall({ // address returned
+        target:PROTOCOL.PermissionFn('create')  as FnCallType,
+        arguments:[ permission ]        
+    })
+}
+
+export function add_entity(txb:TransactionBlock, permission:PermissionObject, entities:Permission_Entity[]) {
+    let guards:any[]  = [];
+    for (let i = 0; i < entities.length; i++) {
+        let entity = entities[i];
+        let indexes :number[] = [];
+
+        for (let j = 0; j <  entity.permissions.length; j++) {
+            let index = entity.permissions[j];
+            if (index?.guard) {
+                guards.push({who:entity.who, index:index.index, guard:index.guard});
+            }
+            
+            if (!indexes.includes(index.index))   {
+                indexes.push(index.index);
+            }      
+        }    
+        if (indexes.length > 0) {
+            txb.moveCall({
+                target:PROTOCOL.PermissionFn('add_batch') as FnCallType,
+                arguments:[permission, txb.pure(entity.who, BCS.ADDRESS), txb.pure(indexes, 'vector<u64>')]
+            })            
+        }
+    } 
+    // set guards
+    guards.forEach(({who, index, guard}) => {
+        txb.moveCall({
+            target:PROTOCOL.PermissionFn('guard_set') as FnCallType,
+            arguments:[ permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64), TXB_OBJECT(txb, guard)]
+        })
+    })
+}
+
+// guard: undefine to set none
+export function set_guard(txb:TransactionBlock, permission:PermissionObject, who:string, index:number, guard?:string | GuardObject) {
+    if (guard) {
+        txb.moveCall({
+            target:PROTOCOL.PermissionFn('guard_set') as FnCallType,
+            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64), TXB_OBJECT(txb, guard)]
+        })    
+    } else {
+        txb.moveCall({
+            target:PROTOCOL.PermissionFn('guard_none') as FnCallType,
+            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64)]
+        })       
+    }
+}
+
+export function add_or_modify(txb:TransactionBlock, permission:PermissionObject, who:string, index:number, modifyIfOldExist?:boolean, guard?:string | GuardObject) {
+    if (guard) {
+        txb.moveCall({
+            target:PROTOCOL.PermissionFn('add_or_modify') as FnCallType,
+            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64), TXB_OBJECT(txb, guard), txb.pure(modifyIfOldExist, BCS.BOOL)]
+        })    
+    } else {
+        txb.moveCall({
+            target:PROTOCOL.PermissionFn('add_or_modify') as FnCallType,
+            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64), txb.pure([], BCS.U8), txb.pure(modifyIfOldExist, BCS.BOOL)]
+        })   
+    }
+}
+export function remove_index(txb:TransactionBlock, permission:PermissionObject, who:string, index:number[]) {
+    if (index) {
+        txb.moveCall({
+            target:PROTOCOL.PermissionFn('remove_index') as FnCallType,
+            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, 'vector<u64>')]
+        })            
+    }
+}
+export function remove_entity(txb:TransactionBlock, permission:PermissionObject, who:string[]) {
+    if (who) {
+        txb.moveCall({
+            target:PROTOCOL.PermissionFn('remove') as FnCallType,
+            arguments:[permission, txb.pure(who, 'vector<address>')]
+        })           
+    }
+}
+export function set_description(txb:TransactionBlock, permission:PermissionObject, description:string) {
+    txb.moveCall({
+        target:PROTOCOL.PermissionFn('description_set') as FnCallType,
+        arguments: [permission, txb.pure(description_data(description))]
+    })
+}
+
+export function add_admin(txb:TransactionBlock, permission:PermissionObject, admin:string[]) {
+    let n = array_unique(admin); 
+    txb.moveCall({
+        target:PROTOCOL.PermissionFn('admin_add_batch')  as FnCallType,
+        arguments:[permission, txb.pure(n, 'vector<address>')]
+    });    
+}
+
+export function remove_admin(txb:TransactionBlock, permission:PermissionObject, admin:string[], removeall?:boolean) {
+    if (removeall) {
+        txb.moveCall({
+            target:PROTOCOL.PermissionFn('admins_clear')  as FnCallType,
+            arguments:[permission]
+        });    
+    } else {
+        txb.moveCall({
+            target:PROTOCOL.PermissionFn('admin_remove_batch')  as FnCallType,
+            arguments:[permission, txb.pure(admin, 'vector<address>')]
+        });            
+    }
+}
+
+export function change_owner(txb:TransactionBlock, permission:PermissionObject, new_owner:string) {
+    txb.moveCall({
+        target:PROTOCOL.PermissionFn('builder_set')  as FnCallType,
+        arguments:[permission, txb.pure(new_owner, BCS.ADDRESS)]
+    });        
+}

package/src/progress.ts

@@ -0,0 +1,139 @@
+import { SuiClient, getFullnodeUrl, SuiObjectResponse } from '@mysten/sui.js/client';
+import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
+import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
+import { BCS, getSuiMoveConfig, toHEX, fromHEX, BcsReader } from '@mysten/bcs';
+import { name_data, FnCallType, PROTOCOL,} from './protocol';
+import { verify,  PassportObject} from './passport'
+import { PermissionIndex, PermissionObject } from './permission'
+import { RepositoryObject } from './repository';
+import { MachineObject } from './machine';
+
+export type ProgressObject = TransactionResult;
+export type ProgressAddress = TransactionResult;
+export const MAX_NAMED_OPERATOR_COUNT = 64;
+
+export function progress(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : ProgressObject {
+    if (passport) {
+        return txb.moveCall({
+            target:PROTOCOL.ProgressFn('new_with_passport') as FnCallType,
+            arguments: [passport, machine, permission],
+        })    
+    } else {
+        return txb.moveCall({
+            target:PROTOCOL.ProgressFn('new') as FnCallType,
+            arguments: [machine, permission],
+        })    
+    }
+}
+export function launch(txb:TransactionBlock, progress:ProgressObject) : ProgressAddress {
+    return txb.moveCall({
+        target:PROTOCOL.ProgressFn('create') as FnCallType,
+        arguments: [progress],
+    })   
+}
+export function launch_as_child(txb:TransactionBlock, progress:ProgressObject, parent:ProgressObject, parent_next:ProgressNext) : ProgressAddress {
+    return txb.moveCall({
+        target:PROTOCOL.ProgressFn('create_as_child') as FnCallType,
+        arguments: [progress, parent, txb.pure(parent_next.next_node_name), txb.pure(name_data(parent_next.forward))],
+    })   
+}
+export function destroy(txb:TransactionBlock, progress:ProgressObject) {
+    return txb.moveCall({
+        target:PROTOCOL.ProgressFn('destroy') as FnCallType,
+        arguments: [progress],
+    })   
+}
+export function progress_set_namedOperator(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, name:string, addresses:string[], passport?:PassportObject) {
+    if (addresses.length == 0 || name.length == 0 || addresses.length > MAX_NAMED_OPERATOR_COUNT) return undefined;
+
+    if (passport) {
+        txb.moveCall({
+            target:PROTOCOL.ProgressFn('namedOperator_set_with_passport') as FnCallType,
+            arguments: [passport, progress, txb.pure(name_data(name)), txb.pure(addresses, 'vector<address>'), 
+                machine, permission],
+        })  
+    } else {
+        txb.moveCall({
+            target:PROTOCOL.ProgressFn('namedOperator_set') as FnCallType,
+            arguments: [progress, txb.pure(name_data(name)), txb.pure(addresses, 'vector<address>'), 
+                machine, permission],
+        })  
+    }  
+}
+export function progress_bind_task(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, task_address:string, passport?:PassportObject) {
+    if (passport) {
+        txb.moveCall({
+            target:PROTOCOL.ProgressFn('task_set_with_passport') as FnCallType,
+            arguments: [passport, progress, txb.pure(task_address, BCS.ADDRESS), machine, permission],
+        })   
+    } else {
+        txb.moveCall({
+            target:PROTOCOL.ProgressFn('task_set') as FnCallType,
+            arguments: [progress, txb.pure(task_address, BCS.ADDRESS), machine, permission],
+        })   
+    } 
+}
+export function progress_set_context_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, repository?:RepositoryObject, passport?:PassportObject) {
+    if (passport) {
+        if (repository) {
+            txb.moveCall({
+                target:PROTOCOL.ProgressFn('context_repository_set_with_passport') as FnCallType,
+                arguments: [passport, progress, repository, machine, permission],
+            })            
+        } else {
+            txb.moveCall({
+                target:PROTOCOL.ProgressFn('context_repository_none_with_passport') as FnCallType,
+                arguments: [passport, progress, machine, permission],
+            })           
+        }
+    } else {
+        if (repository) {
+            txb.moveCall({
+                target:PROTOCOL.ProgressFn('context_repository_set') as FnCallType,
+                arguments: [progress, repository, machine, permission],
+            })            
+        } else {
+            txb.moveCall({
+                target:PROTOCOL.ProgressFn('context_repository_none') as FnCallType,
+                arguments: [progress, machine, permission],
+            })           
+        }
+    }
+}
+export function progress_unhold(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, next:ProgressNext) {
+    txb.moveCall({
+        target:PROTOCOL.ProgressFn('unhold') as FnCallType,
+        arguments: [progress, machine, txb.pure(next.next_node_name), txb.pure(name_data(next.forward)), permission],
+    })   
+}
+
+export type ProgressNext = {
+    next_node_name: string;
+    forward: string;
+}
+export function next(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, next:ProgressNext,
+    deliverables_address?:string, passport?:PassportObject) {
+        let diliverable = txb.pure([], BCS.U8);
+        if (deliverables_address) { diliverable = txb.pure(deliverables_address, BCS.ADDRESS)}
+
+        if (passport) {
+            txb.moveCall({
+                target:PROTOCOL.ProgressFn('run_with_passport') as FnCallType,
+                arguments: [passport, progress, machine, txb.pure(next.next_node_name), 
+                    txb.pure(name_data(next.forward)), diliverable, permission],
+            })    
+        } else {
+            txb.moveCall({
+                target:PROTOCOL.ProgressFn('run') as FnCallType,
+                arguments: [progress, machine, txb.pure(next.next_node_name), 
+                    txb.pure(name_data(next.forward)), diliverable, permission],
+            })               
+        }
+}
+export function hold(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, next:ProgressNext, hold:boolean) {
+    txb.moveCall({
+        target:PROTOCOL.ProgressFn('hold') as FnCallType,
+        arguments: [progress, machine, txb.pure(next.next_node_name), 
+            txb.pure(name_data(next.forward)), txb.pure(hold, BCS.BOOL), permission],
+    })  
+}

package/src/protocol.ts

@@ -0,0 +1,189 @@
+import { SuiClient, SuiObjectResponse, SuiObjectDataOptions, SuiTransactionBlockResponseOptions, 
+    SuiTransactionBlockResponse, SuiObjectChange } from '@mysten/sui.js/client';
+import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
+import { BCS, getSuiMoveConfig, toHEX, fromHEX, BcsReader } from '@mysten/bcs';
+import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
+import { capitalize } from './util'
+
+export type GuardObject = TransactionResult;
+export type GuardAddress = TransactionResult;
+
+export const MAX_DESCRIPTION_LENGTH = 1024;
+export const MAX_NAME_LENGTH = 64;
+export const MAX_ENDPOINT_LENGTH = 1024;
+
+export function description_data(description:string) : string {
+    return description.substring(0, MAX_DESCRIPTION_LENGTH);
+}
+export function endpoint_data(endpoint:string) : string {
+    return endpoint.substring(0, MAX_ENDPOINT_LENGTH);
+}
+export function name_data(name:string) : string {
+    return name.substring(0, MAX_NAME_LENGTH);
+}
+export enum MODULES {
+    machine = 'machine',
+    node = 'node',
+    progress = 'progress',
+    community = 'community',
+    repository = 'repository',
+    permission = 'permission',
+    passport = 'passport',
+    guard = 'guard',
+    vote = 'vote',
+    demand = 'demand',
+    order = 'order',
+    reward = 'reward',
+    service = 'service',
+    wowok = 'wowok',
+}
+
+export type TxbObject = string | TransactionResult;
+export function TXB_OBJECT(txb:TransactionBlock, arg:TxbObject) : TransactionResult {
+    if (typeof arg == 'string') return txb.object(arg) as TransactionResult;
+    return arg;
+}
+
+export type WowokObject = TransactionResult;
+export type FnCallType = `${string}::${string}::${string}`;
+
+export const CLOCK_OBJECT = Inputs.SharedObjectRef({
+    objectId:"0x6",
+    mutable: false,
+    initialSharedVersion: 1,
+});
+
+export enum Data_Type {
+    TYPE_DYNAMIC_QUERY = 1,
+    TYPE_LOGIC_OPERATOR_U128_GREATER = 11,
+    TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL = 12,
+    TYPE_LOGIC_OPERATOR_U128_LESSER = 13,
+    TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL = 14,
+    TYPE_LOGIC_OPERATOR_U128_EQUAL = 15,
+    TYPE_LOGIC_OPERATOR_EQUAL = 16, // TYPE&DATA(vector<u8>) MUST BE EQUAL
+    TYPE_LOGIC_OPERATOR_HAS_SUBSTRING = 17, // SUBSTRING
+    TYPE_LOGIC_ALWAYS_TRUE = 18, // aways true
+    // TYPE_LOGIC_OPERATOR_VECU8_CONTAINS = 18, // SUB VEC<U8>
+    TYPE_CONTEXT_SIGNER  = 60,
+    TYPE_CONTEXT_CURRENT_PROGRESS = 61,
+    TYPE_CONTEXT_CURRENT_CLOCK = 62,
+    TYPE_STATIC_bool = 100,
+    TYPE_STATIC_address = 101,
+    TYPE_STATIC_u64 = 102,
+    TYPE_STATIC_u8 = 103,
+    TYPE_STATIC_u128 = 104,
+    TYPE_STATIC_vec_u8 = 105,
+    TYPE_STATIC_vec_address = 106,
+    TYPE_STATIC_vec_bool = 107,
+    TYPE_STATIC_vec_vec_u8 = 108,
+    TYPE_STATIC_vec_u64 = 109,
+    TYPE_STATIC_vec_u128 = 110,
+    TYPE_STATIC_option_address = 111,
+    TYPE_STATIC_option_bool = 112,
+    TYPE_STATIC_option_u8 = 113,
+    TYPE_STATIC_option_u64 = 114,
+    TYPE_STATIC_option_u128 = 115,
+    TYPE_STATIC_by_value_specified = 126,
+    TYPE_STATIC_error = 127,
+}
+
+export enum ENTRYPOINT {
+    mainnet = 'mainnet',
+    testnet = 'testnet',
+    devnet = 'devnet',
+    localnet = 'localnet'
+}
+
+export class Protocol {
+    protected network = '';
+    protected package = '';
+    protected signer = '';
+    protected everyone_guard = '';
+
+    constructor(network:ENTRYPOINT=ENTRYPOINT.localnet, signer="0xe386bb9e01b3528b75f3751ad8a1e418b207ad979fea364087deef5250a73d3f") {
+        this.network = network;
+        this.signer = signer;
+        switch(network) {
+            case ENTRYPOINT.localnet:
+                this.package = "0x74df733df2395d0c3a34c6d086d2e1f130603b8aa16962e53781cb0fa9c6958c";
+                this.everyone_guard = "0xb1a2e3d0cf13c3fcb491f126af8422f7d098147659d8a58a52511cfbb783a6e8";
+                break;
+            case ENTRYPOINT.devnet:
+                break;
+            case ENTRYPOINT.testnet:
+                this.package = "0x038b0be329e4fd227d846b850aeb1822f9629c62c14d85ffcd22d856c843923f";
+                this.everyone_guard = "0xdfe42468bfc7d7988fa1707978ef9376178dcefbe938d140a1bfd97abe755998";
+                break;
+            case ENTRYPOINT.mainnet:
+                break;
+        };
+    }
+    Package(): string { return this.package }
+    EveryoneGuard(): string { return this.everyone_guard }
+    NetworkUrl() : string { 
+        switch(this.network) {
+            case ENTRYPOINT.localnet:
+                return "http://127.0.0.1:9000";
+            case ENTRYPOINT.devnet:
+                return "https://fullnode.devnet.sui.io:443";
+            case ENTRYPOINT.testnet:
+                return "https://fullnode.testnet.sui.io:443";
+            case ENTRYPOINT.mainnet:
+                return "https://fullnode.mainnet.sui.io:443";
+        }; return "";
+    };
+    MachineFn = (fn:any) => { return `${this.package}::${MODULES.machine}::${fn}`};
+    NodeFn = (fn: any) => { return `${this.package}::${MODULES.node}::${fn}`};
+    ProgressFn = (fn:any) => { return `${this.package}::${MODULES.progress}::${fn}`};
+    CommunityFn = (fn: any) => { return `${this.package}::${MODULES.community}::${fn}`};
+    RepositoryFn = (fn:any) => { return `${this.package}::${MODULES.repository}::${fn}`};
+    PermissionFn = (fn: any) => { return `${this.package}::${MODULES.permission}::${fn}`};
+    PassportFn = (fn:any) => { return `${this.package}::${MODULES.passport}::${fn}`};
+    GuardFn = (fn: any) => { return `${this.package}::${MODULES.guard}::${fn}`};
+    VoteFn = (fn:any) => { return `${this.package}::${MODULES.vote}::${fn}`};
+    DemandFn = (fn: any) => { return `${this.package}::${MODULES.demand}::${fn}`};
+    OrderFn = (fn:any) => { return `${this.package}::${MODULES.order}::${fn}`};
+    RewardFn = (fn: any) => { return `${this.package}::${MODULES.reward}::${fn}`};
+    ServiceFn = (fn: any) => { return `${this.package}::${MODULES.service}::${fn}`};
+    WowokFn = (fn: any) => { return `${this.package}::${MODULES.wowok}::${fn}`};
+    
+
+    Query = async (objects: Query_Param[], options:SuiObjectDataOptions={showContent:true}) : Promise<SuiObjectResponse[]> => {
+        const client =  new SuiClient({ url: PROTOCOL.NetworkUrl() });  
+        const ids = objects.map((value) => value.objectid);
+        const res = await client.call('sui_multiGetObjects', [ids, options]) as SuiObjectResponse[];
+        let ret:any[] = [];
+        for (let i = 0; i < res.length; i ++ ) {
+            objects.forEach((object) => {
+                object.callback(res[i], object, options);
+            })
+        }   
+        return res;
+    } 
+    Sign_Excute = async (exes: (txb:TransactionBlock, param:any) => void, priv_key:string, param?:any, options:SuiTransactionBlockResponseOptions={showObjectChanges:true}) : Promise<SuiTransactionBlockResponse> => {
+        const client =  new SuiClient({ url: PROTOCOL.NetworkUrl() });  
+        const txb = new TransactionBlock();
+    
+        exes(txb, param);
+        const privkey = fromHEX(priv_key);
+        const keypair = Ed25519Keypair.fromSecretKey(privkey);
+    
+        const response = await client.signAndExecuteTransactionBlock({
+            transactionBlock: txb, 
+            signer: keypair,
+            options
+        });
+        return response;
+    }
+}
+
+export type Query_Param = {
+    objectid: string;
+    callback: (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions)=>void;
+    data?: any; // response data filted by callback
+};
+
+
+export const PROTOCOL = new Protocol();
+export const OBJECTS_TYPE_PREFIX = (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => { return PROTOCOL.Package() + '::' + key + '::'; })
+export const OBJECTS_TYPE = (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => { let i = PROTOCOL.Package() + '::' + key + '::'; return i + capitalize(key); })