wowok 1.1.4 → 1.2.0

package/src/passport.ts

@@ -13,7 +13,7 @@ export type Guard_Query_Object = {
     id: string, // object id
 }
 
-interface QueryInfo {
+export interface QueryInfo {
     identifier?: number;
     index:  number;
     type: number;
@@ -23,16 +23,16 @@ interface QueryInfo {
 interface GuardInfo {
     id: string;
     query_list: (string | QueryInfo)[]; // object or witness object query
-    variable: QueryInfo[]; // witness in variable & ValueType.TYPE_ADDRESS(for Query)
+    constant: QueryInfo[]; // witness in constant & ValueType.TYPE_ADDRESS(for Query)
     input_witness: QueryInfo[]; // witness in input
 }
 
-interface DeGuardVariable {
+export interface DeGuardConstant {
     type: number;
     value: any;
     identifier?: number;
 }
-interface DeGuardData {
+export interface DeGuardData {
     type: number;
     value?: any;
     identifier?: number;
@@ -41,12 +41,12 @@ interface DeGuardData {
     ret_type?: number;
 }
 
-interface FutrueFill {
+export interface FutrueFill {
     guard: string;
     index: number;
     future: string;
 }
-interface PassportQuery {
+export interface PassportQuery {
     guard: GuardObject[];
     query: Guard_Query_Object[];
     witness: Guard_Query_Object[];
@@ -64,30 +64,15 @@ export class GuardParser {
     }
     guardlist = () => { return this.guard_list }
 
-    /// convert guard-on-chain to js object
-    static DeGuardObject = async (protocol: Protocol, guard: string) : Promise<DeGuardData> => {
-        if (!IsValidAddress(guard)) {
-            ERROR(Errors.IsValidAddress,  'GuardObject guard')
-        }
-
-        let res = await protocol.Query_Raw([guard]);
-        if (res.length == 0 || !res[0].data || res[0].data?.objectId != guard) {
-            ERROR(Errors.Fail, 'GuardObject query error');
-        }
-
-        // console.log(res[0].data?.content);
-        let content = res[0].data!.content as any;
-        if (content?.type != protocol.Package() + '::guard::Guard') {
-            ERROR(Errors.Fail, 'GuardObject object invalid')
-        }
-
-        let  variables : DeGuardVariable[] = [];
-        content.fields.variables.forEach((v:any) => {
-            let value : any;
-            switch (v.fields.type) {
+    static DeGuardObject_FromData = (guard_constants:any, guard_input_bytes:any) : {object:DeGuardData, constant:DeGuardConstant[]} => {
+        let  constants : DeGuardConstant[] = [];
+        guard_constants.forEach((c:any) => {
+            let value : any; 
+            let v = c?.fields ?? c; // graphql dosnot 'fields', but rpcall has.
+            switch (v.type) {
                 case ContextType.TYPE_WITNESS_ID:
                 case ValueType.TYPE_ADDRESS:
-                    value = '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(v.fields.value)).toString();
+                    value = '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(v.value)).toString();
                     break;
                 case ValueType.TYPE_BOOL:
                 case ValueType.TYPE_U8:
@@ -107,19 +92,19 @@ export class GuardParser {
                 case ValueType.TYPE_OPTION_U64:
                 case ValueType.TYPE_OPTION_U256:
                 case ValueType.TYPE_VEC_U256:
-                    let de  = SER_VALUE.find(s=>s.type==v.fields.type);
+                    let de  = SER_VALUE.find(s=>s.type==v.type);
                     if (!de) ERROR(Errors.Fail, 'GuardObject de error')
-                    value = Bcs.getInstance().de(de!.name, Uint8Array.from(v.fields.value));
+                    value = Bcs.getInstance().de(de!.name, Uint8Array.from(v.value));
                     break;
 
                 default:
-                    ERROR(Errors.Fail, 'GuardObject variable type invalid')
+                    ERROR(Errors.Fail, 'GuardObject constant type invalid')
             }
-            variables.push({identifier:v.fields.identifier, type:v.fields.type,  value:value});
+            constants.push({identifier:v.identifier, type:v.type,  value:value});
         });
-        // console.log(variables)
-
-        let arr = [].slice.call(content.fields.input.fields.bytes.reverse());
+        // console.log(constants)
+        let bytes = Uint8Array.from(guard_input_bytes);
+        let arr = [].slice.call(bytes.reverse());
         let data : DeGuardData[] = [];
         while (arr.length > 0) {
             let type : unknown = arr.shift() ;
@@ -139,10 +124,10 @@ export class GuardParser {
                 case OperatorType.TYPE_LOGIC_AND:
                 case OperatorType.TYPE_LOGIC_OR:
                     break;    
-                case ContextType.TYPE_VARIABLE:
+                case ContextType.TYPE_CONSTANT:
                     identifier = arr.shift()! as number;  // identifier
                     break;
-                case ContextType.TYPE_WITNESS_ID:  // add to variable 
+                case ContextType.TYPE_WITNESS_ID:  // add to constant 
                 case ValueType.TYPE_ADDRESS: 
                     value = '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(arr)).toString();
                     arr.splice(0, 32); // address     
@@ -210,16 +195,16 @@ export class GuardParser {
                         arr.splice(0, 32); // address            
                         value = addr;
                         cmd = arr.shift()! as number; // cmd
-                    } else if (t[0] == ContextType.TYPE_VARIABLE) {
+                    } else if (t[0] == ContextType.TYPE_CONSTANT) {
                         let id = arr.splice(0, 1); // key
-                        let v = variables.find((v) => 
+                        let v = constants.find((v) => 
                             (v.identifier == id[0]) && 
                             ((v.type == ValueType.TYPE_ADDRESS) || (v.type == ContextType.TYPE_WITNESS_ID)));
-                        if (!v) { ERROR(Errors.Fail, 'GuardObject: indentifier not in  variable')}
+                        if (!v) { ERROR(Errors.Fail, 'GuardObject: indentifier not in  constant')}
                         identifier = id[0];
                         cmd = arr.shift()! as number; // cmd
                     } else {
-                        ERROR(Errors.Fail, 'GuardObject: variable type invalid');
+                        ERROR(Errors.Fail, 'GuardObject: constant type invalid');
                     }
                     break;
                 case ValueType.TYPE_OPTION_ADDRESS:
@@ -262,17 +247,36 @@ export class GuardParser {
         if (!data || data.length == 0) ERROR(Errors.Fail, 'GuardObject: data parsed error');
         let stack: DeGuardData[] = [];
         data.forEach((d) => {
-            this.ResolveData(variables, stack, d);
+            this.ResolveData(constants, stack, d);
         })
 
         if (stack.length != 1) {
             ERROR(Errors.Fail, 'GuardObject: parse error');
         }
     
-        return stack.pop()!;
+        return {object:stack.pop()!, constant:constants};
     }
+    /// convert guard-on-chain to js object
+    static DeGuardObject = async (protocol: Protocol, guard: string) : Promise<{object:DeGuardData, constant:DeGuardConstant[]}> => {
+        if (!IsValidAddress(guard)) {
+            ERROR(Errors.IsValidAddress,  'GuardObject guard')
+        }
 
-    static ResolveData = (variables:  DeGuardVariable[], stack:DeGuardData[], current: DeGuardData) => {
+        let res = await protocol.Query_Raw([guard]);
+        if (res.length == 0 || !res[0].data || res[0].data?.objectId != guard) {
+            ERROR(Errors.Fail, 'GuardObject query error');
+        }
+
+        // console.log(res[0].data?.content);
+        let content = res[0].data!.content as any;
+        if (content?.type != protocol.Package() + '::guard::Guard') {
+            ERROR(Errors.Fail, 'GuardObject object invalid')
+        }
+
+        return GuardParser.DeGuardObject_FromData(content.fields.constants, content.fields.input.fields.bytes);
+    }
+
+    static ResolveData = (constants:  DeGuardConstant[], stack:DeGuardData[], current: DeGuardData) => {
         switch (current.type) {
             case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
                 current.ret_type = ValueType.TYPE_BOOL;
@@ -393,8 +397,8 @@ export class GuardParser {
                 current.ret_type = ValueType.TYPE_ADDRESS;
                 stack.push(current);
                 return;
-            case ContextType.TYPE_VARIABLE:
-                let  v = variables.find((e) => e.identifier ==  current?.identifier);
+            case ContextType.TYPE_CONSTANT:
+                let  v = constants.find((e) => e.identifier ==  current?.identifier);
                 if (!v) ERROR(Errors.Fail, 'OperateParamCount: identifier  invalid ' + current.type);
                 
                 current.ret_type = v?.type;
@@ -404,6 +408,7 @@ export class GuardParser {
                 
                 stack.push(current);
                 return;
+                
         }   
         ERROR(Errors.Fail, 'OperateParamCount: type  invalid ' + current.type);
     }
@@ -425,8 +430,8 @@ export class GuardParser {
             let index = protocol.WOWOK_OBJECTS_TYPE().findIndex(v => {return v.includes('guard::Guard') && v == c.type});
             if (index == -1) return;
 
-            let info:GuardInfo = {id: c.fields.id.id, query_list:[],  variable:[], input_witness:[]};
-            me.parse_variable(info,  c.fields.variables);
+            let info:GuardInfo = {id: c.fields.id.id, query_list:[],  constant:[], input_witness:[]};
+            me.parse_constant(info,  c.fields.constants);
             if (c.fields.input.type == (protocol.Package() + '::bcs::BCS')) {
                 me.parse_bcs(info,  Uint8Array.from(c.fields.input.fields.bytes));
             }
@@ -435,12 +440,12 @@ export class GuardParser {
         return me
     }
 
-    parse_variable = (info:GuardInfo, variables:any)  => {
-        variables.forEach((v:any) => {
-            if (v.type == (this.protocol.Package() + '::guard::Variable')) {
+    parse_constant = (info:GuardInfo, constants:any)  => {
+        constants.forEach((v:any) => {
+            if (v.type == (this.protocol.Package() + '::guard::Constant')) {
                 // ValueType.TYPE_ADDRESS: Query_Cmd maybe used the address, so save it for using
                 if (v.fields.type == ContextType.TYPE_WITNESS_ID || v.fields.type == ValueType.TYPE_ADDRESS) {
-                    info.variable.push({identifier:v.fields.identifier,  index:this.get_index(), type:v.fields.type,
+                    info.constant.push({identifier:v.fields.identifier,  index:this.get_index(), type:v.fields.type,
                         value_or_witness:'0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(v.fields.value))});
                 }
             }
@@ -467,10 +472,10 @@ export class GuardParser {
                 case OperatorType.TYPE_LOGIC_AND:
                 case OperatorType.TYPE_LOGIC_OR:
                 break;    
-            case ContextType.TYPE_VARIABLE:
-                arr.splice(0, 1); // identifier of variable
+            case ContextType.TYPE_CONSTANT:
+                arr.splice(0, 1); // identifier of constant
                 break;
-            case ContextType.TYPE_WITNESS_ID:  // add to variable 
+            case ContextType.TYPE_WITNESS_ID:  // add to constant 
                 let addr = '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(arr)).toString();
                 arr.splice(0, 32); // address     
                 info.input_witness.push({index:this.get_index(), type:ContextType.TYPE_WITNESS_ID, value_or_witness:addr})
@@ -505,19 +510,19 @@ export class GuardParser {
                     } else if (type[0] == ContextType.TYPE_WITNESS_ID){
                         info.query_list.push({index:this.get_index(), type:type[0], value_or_witness:addr});
                     }
-                } else if (type[0] == ContextType.TYPE_VARIABLE) {
+                } else if (type[0] == ContextType.TYPE_CONSTANT) {
                     let identifer = arr.splice(0, 2); // key + cmd
-                    let variable = info.variable.find((v) => 
+                    let constant = info.constant.find((v) => 
                         (v.identifier == identifer[0]) && 
                         ((v.type == ValueType.TYPE_ADDRESS) || (v.type == ContextType.TYPE_WITNESS_ID)));
-                    if (!variable) { ERROR(Errors.Fail, 'indentifier not in  variable')}
-                    if (variable?.type == ValueType.TYPE_ADDRESS) {
-                        info.query_list.push(variable.value_or_witness);
-                    } else if (variable?.type == ContextType.TYPE_WITNESS_ID) {
-                        info.query_list.push({identifier:identifer[0], type:variable.type, value_or_witness:variable.value_or_witness, index:this.get_index()});
+                    if (!constant) { ERROR(Errors.Fail, 'indentifier not in  constant')}
+                    if (constant?.type == ValueType.TYPE_ADDRESS) {
+                        info.query_list.push(constant.value_or_witness);
+                    } else if (constant?.type == ContextType.TYPE_WITNESS_ID) {
+                        info.query_list.push({identifier:identifer[0], type:constant.type, value_or_witness:constant.value_or_witness, index:this.get_index()});
                     } 
                 } else {
-                    ERROR(Errors.Fail, 'variable type invalid');
+                    ERROR(Errors.Fail, 'constant type invalid');
                 }
 
                 break;
@@ -542,7 +547,7 @@ export class GuardParser {
     done = async (fill?:FutrueFill[]) : Promise<PassportQuery>=> {
         let objects: string[] = [];
         this.guard_list.forEach((g) => {
-            g.variable.filter(v => v.type == ContextType.TYPE_WITNESS_ID).forEach((q) => {
+            g.constant.filter(v => v.type == ContextType.TYPE_WITNESS_ID).forEach((q) => {
                 objects.push(this.get_object(g.id, q, fill));
             })
             let list = g.query_list.map((q) => {
@@ -574,7 +579,7 @@ export class GuardParser {
                 query.push(object!);
             })
             res.forEach(q => {
-                let r1 = g.variable.find(v  => v.future == q.data?.objectId);
+                let r1 = g.constant.find(v  => v.future == q.data?.objectId);
                 let r2 = g.input_witness.find(v  => v.future == q.data?.objectId)
                 // not match r1 || r2 means query-cmd, not witness-cmd
                 if (r1 || r2) {

package/src/permission.ts

@@ -2,6 +2,7 @@ import { BCS } from '@mysten/bcs';
 import { FnCallType, TxbObject, PermissionObject, PermissionAddress, GuardObject, Protocol} from './protocol';
 import { array_unique, IsValidAddress, IsValidArray,  IsValidDesription, IsValidUint, Bcs} from './utils';
 import { ERROR, Errors } from './exception';
+import { Resource } from './resource';
 
 export enum PermissionIndex {
     repository = 100,
@@ -113,12 +114,11 @@ export class  Permission {
     }
 
     static New(protocol:Protocol, description:string) : Permission {
-        let p = new Permission(protocol);
-
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)
         }
 
+        let p = new Permission(protocol);
         let txb = protocol.CurrentSession();
         p.object = txb.moveCall({
             target: protocol.PermissionFn('new') as FnCallType,
@@ -134,14 +134,15 @@ export class  Permission {
             arguments:[ Protocol.TXB_OBJECT(txb, this.object) ]        
         })
     }
+
     destroy()  {
         let txb = this.protocol.CurrentSession();
         txb.moveCall({
             target:this.protocol.PermissionFn('destroy') as FnCallType,
             arguments: [Protocol.TXB_OBJECT(txb, this.object)],
-        })   
-        
+        })  
     }
+
     add_entity(entities:Permission_Entity[])  {
         if (!entities) {
             ERROR(Errors.InvalidParam, 'entities');

package/src/progress.ts

@@ -4,6 +4,7 @@ import { FnCallType, PermissionObject, RepositoryObject, PassportObject, Machine
     TxbObject} from './protocol';
 import { Bcs, array_unique,IsValidName, IsValidAddress, IsValidArray, OptionNone, IsValidInt  } from './utils'
 import { ERROR, Errors } from './exception';
+import { Resource } from './resource';
 
 export type ProgressNext = {
     next_node_name: string;
@@ -34,12 +35,11 @@ export class Progress {
         return p
     }
     static New(protocol:Protocol, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : Progress {
-        let p = new Progress(protocol, machine, permission);
-
         if (!Protocol.IsValidObjects([machine, permission])) {
             ERROR(Errors.IsValidObjects, 'machine & permission')
         }
 
+        let p = new Progress(protocol, machine, permission);
         let txb = protocol.CurrentSession();
 
         if (passport) {
@@ -86,7 +86,15 @@ export class Progress {
             arguments: [Protocol.TXB_OBJECT(txb, this.object)],
         })   
     }
-    
+/* move to: Entity.mark
+    mark(like:'like' | 'unlike', resource:Resource)  {
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.ProgressFn(like) as FnCallType,
+            arguments: [Protocol.TXB_OBJECT(txb, resource.get_object()), Protocol.TXB_OBJECT(txb, this.object)],
+        })   
+    }
+*/
     set_namedOperator(name:string, addresses:string[], passport?:PassportObject)  {
         if (!IsValidName(name)) {
             ERROR(Errors.IsValidName, 'name')

package/src/protocol.ts

@@ -4,7 +4,7 @@ import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
 import { BCS, getSuiMoveConfig, toHEX, fromHEX, BcsReader } from '@mysten/bcs';
 import { TransactionBlock, Inputs, TransactionResult, TransactionArgument } from '@mysten/sui.js/transactions';
 import { capitalize, IsValidArray } from './utils'
-import { GuardVariable } from './guard';
+import { GuardConstant } from './guard';
 
 
 export enum MODULES {
@@ -21,6 +21,8 @@ export enum MODULES {
     order = 'order',
     reward = 'reward',
     service = 'service',
+    resource = 'resource',
+    entity = 'entity',
     wowok = 'wowok',
 }
 
@@ -47,9 +49,13 @@ export type DiscountObject = TransactionResult | string;
 export type CoinObject = TransactionResult | string;
 export type VoteObject = TransactionResult | string;
 export type VoteAddress = TransactionResult;
+export type ResourceObject = TransactionResult | string;
+export type ResourceAddress = TransactionResult;
+export type EntityObject = TransactionResult | string;
+export type EntityAddress = TransactionResult;
 
 export type TxbObject = string | TransactionResult | GuardObject |  RepositoryObject | PermissionObject | MachineObject | PassportObject |
-    DemandObject | ServiceObject | RewardObject | OrderObject | DiscountObject | VoteObject | DemandObject;
+    DemandObject | ServiceObject | RewardObject | OrderObject | DiscountObject | VoteObject | DemandObject | ResourceObject | EntityObject;
 
 export type WowokObject = TransactionResult;
 export type FnCallType = `${string}::${string}::${string}`;
@@ -100,38 +106,39 @@ export const IsValidValueType = (type:number) => { return ValueTypeArray.include
 interface ValueTypeString {
     type: ValueType;
     name: string;
+    description: string;
 }
 
 export const SER_VALUE: ValueTypeString[] = [
-    {type: ValueType.TYPE_BOOL, name: 'bool'},
-    {type: ValueType.TYPE_ADDRESS, name: 'address'},
-    {type: ValueType.TYPE_U64, name: 'u64'},
-    {type: ValueType.TYPE_U8, name: 'u8'},
-    {type: ValueType.TYPE_VEC_U8, name: 'vector<u8>'},
-    {type: ValueType.TYPE_U128, name: 'u128'},
-    {type: ValueType.TYPE_VEC_ADDRESS, name: 'vector<address>'},
-    {type: ValueType.TYPE_VEC_BOOL, name: 'vector<bool>'},
-    {type: ValueType.TYPE_VEC_VEC_U8, name: 'vector<vector<u8>>'},
-    {type: ValueType.TYPE_VEC_U64, name: 'vector<u64>'},
-    {type: ValueType.TYPE_VEC_U128, name: 'vector<u128>'},
-    {type: ValueType.TYPE_OPTION_ADDRESS, name: 'Option<address>'},
-    {type: ValueType.TYPE_OPTION_BOOL, name: 'Option<bool>'},
-    {type: ValueType.TYPE_OPTION_U8, name: 'Option<u8>'},
-    {type: ValueType.TYPE_OPTION_U64, name: 'Option<u64>'},
-    {type: ValueType.TYPE_OPTION_U128, name: 'Option<u128>'},
-    {type: ValueType.TYPE_OPTION_U256, name: 'Option<u256>'},
-    {type: ValueType.TYPE_VEC_U256, name: 'vector<u256>'},
-    {type: ValueType.TYPE_U256, name: 'u256'},
+    {type: ValueType.TYPE_BOOL, name: 'bool', description:'boolean. eg:true or false'},
+    {type: ValueType.TYPE_ADDRESS, name: 'address', description:'address or object-id. eg:0x6789af'},
+    {type: ValueType.TYPE_U64, name: 'number', description:'unsigned-64 number. eg:23870233'},
+    {type: ValueType.TYPE_U8, name: 'number', description:'unsigned-8 number. eg:255'},
+    {type: ValueType.TYPE_VEC_U8, name: '[number]', description:'unsigned-8 number array. eg:"wowok"'},
+    {type: ValueType.TYPE_U128, name: 'number', description:'unsigned-8 number. eg:12348900999'},
+    {type: ValueType.TYPE_VEC_ADDRESS, name: '[address]', description:'address array. eg:[0x2277f2, 0x3344af]'},
+    {type: ValueType.TYPE_VEC_BOOL, name: '[bool]', description:'boolean array. eg:[true, false, true]'},
+    {type: ValueType.TYPE_VEC_VEC_U8, name: '[[number]]', description:'array of unsigned-8 number array. eg:["i", "like", "wowok"]'},
+    {type: ValueType.TYPE_VEC_U64, name: '[number]', description:'unsigned-64 number array. eg:[123, 778888, 42312]'},
+    {type: ValueType.TYPE_VEC_U128, name: '[number]', description:'unsigned-128 number array. eg:[123, 778888, 42312]'},
+    {type: ValueType.TYPE_OPTION_ADDRESS, name: 'option', description:'option of address. eg:none or address'},
+    {type: ValueType.TYPE_OPTION_BOOL, name: 'option', description:'option of bool. eg:none or boolean value'},
+    {type: ValueType.TYPE_OPTION_U8, name: 'option', description:'option of u8. eg:none or u8 value'},
+    {type: ValueType.TYPE_OPTION_U64, name: 'option', description:'option of u64. eg:none or u64 value'},
+    {type: ValueType.TYPE_OPTION_U128, name: 'option', description:'option of u128. eg:none or u128 value'},
+    {type: ValueType.TYPE_OPTION_U256, name: 'option', description:'option of u256. eg:none or u256 value'},
+    {type: ValueType.TYPE_VEC_U256, name: '[number]', description:'unsigned-256 number array. eg:[123, 778888, 42312]'},
+    {type: ValueType.TYPE_U256, name: 'number', description:'unsigned-256 number. eg:12345678901233'},
 ]
 
 export enum ContextType {
     TYPE_SIGNER  = 60,
     TYPE_CLOCK = 61,
     TYPE_WITNESS_ID = 62, 
-    TYPE_VARIABLE = 80,
+    TYPE_CONSTANT = 80,
 }
 
-export type VariableType = ValueType | ContextType.TYPE_WITNESS_ID;
+export type ConstantType = ValueType | ContextType.TYPE_WITNESS_ID;
 export type Data_Type = ValueType | OperatorType | ContextType;
 
 export enum ENTRYPOINT {
@@ -145,7 +152,8 @@ export class Protocol {
     protected network = '';
     protected package = '';
     protected signer = '';
-    protected everyone_guard = '';
+    protected wowok_object = '';
+    protected entity_object = '';
     protected graphql = '';
     protected txb: TransactionBlock | undefined;
 
@@ -157,14 +165,13 @@ export class Protocol {
         this.network = network;
         switch(network) {
             case ENTRYPOINT.localnet:
-                this.package = "0xe9721254e97dd074e06c5efe5c57be169b64b39ae48939d89c00bf2f62b19e10";
-                this.everyone_guard = "0xb2a3fe7881cb883743c4e962b7e3c7716a1cd47a67adad01dc79795def4f769d";
                 break;
             case ENTRYPOINT.devnet:
                 break;
             case ENTRYPOINT.testnet:
-                this.package = "0x9a7fc338ab9fd0a8f4c108e2f3dbe53393b83529263eb31a391120997d962400";
-                this.everyone_guard = "0x78a41fcc4f566360839613f6b917fb101ae015e56b43143f496f265b6422fddc";
+                this.package = "0x2ac00805aa0ec3c62b575e412108bb295389bbfc86202fd7b73c69dbbb80769a";
+                this.wowok_object = '0x49d49fb41c63c3f6c838fca20c25741f20aa74a176391685446794bdaa9b7934';
+                this.entity_object= '0xd21d8d76f553b2db6c6d28a8b2ae3405bec92f2a300676d80fcc004ca40b0a77';
                 this.graphql = 'https://sui-testnet.mystenlabs.com/graphql';
                 break;
             case ENTRYPOINT.mainnet:
@@ -172,7 +179,8 @@ export class Protocol {
         };
     }
     Package(): string { return this.package }
-    EveryoneGuard(): string { return this.everyone_guard }
+    WowokObject(): string { return this.wowok_object }
+    EntityObject(): string { return this.entity_object }
     GraphqlUrl() : string { return this.graphql }
     
     NetworkUrl() : string { 
@@ -201,6 +209,8 @@ export class Protocol {
     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}`};
+    ResourceFn = (fn: any) => { return `${this.package}::${MODULES.resource}::${fn}`};
+    EntityFn = (fn: any) => { return `${this.package}::${MODULES.entity}::${fn}`};
     WowokFn = (fn: any) => { return `${this.package}::${MODULES.wowok}::${fn}`};
     
     Query = async (objects: Query_Param[], options:SuiObjectDataOptions={showContent:true}) : Promise<SuiObjectResponse[]> => {
@@ -325,7 +335,7 @@ export class RpcResultParser {
 export type Query_Param = {
     objectid: string;
     callback: (protocol:Protocol, response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions)=>void;
-    parser?: (result:any[], guardid: string, chain_sense_bsc:Uint8Array, variable?:GuardVariable)  => boolean;
+    parser?: (result:any[], guardid: string, chain_sense_bsc:Uint8Array, constant?:GuardConstant)  => boolean;
     data?: any; // response data filted by callback
-    variables?: GuardVariable;
+    constants?: GuardConstant;
 };

package/src/repository.ts

@@ -3,6 +3,7 @@ import { Protocol, FnCallType, ValueType, RepositoryObject, RepositoryAddress, P
 import { PermissionIndexType, Permission } from './permission'
 import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, OptionNone,  } from './utils';
 import { ERROR, Errors } from './exception';
+import { Resource } from './resource';
 
 export enum Repository_Policy_Mode {
     POLICY_MODE_FREE = 0,
@@ -42,7 +43,6 @@ export class Repository {
     }
     static New(protocol:Protocol, permission:PermissionObject, description:string, 
         policy_mode: Repository_Policy_Mode, passport?:PassportObject) : Repository {
-        let r = new Repository(protocol, permission);
         if (!Protocol.IsValidObjects([permission])) {
             ERROR(Errors.IsValidObjects, 'permission')
         }
@@ -50,6 +50,7 @@ export class Repository {
             ERROR(Errors.IsValidDesription)
         }
 
+        let r = new Repository(protocol, permission);
         let txb = protocol.CurrentSession();
 
         if (passport) {
@@ -81,7 +82,16 @@ export class Repository {
             arguments: [Protocol.TXB_OBJECT(txb, this.object)],
         })   
     }
-
+/* move to: Entity.mark
+    mark(like:'like' | 'unlike', resource:Resource)  {
+        if (!Protocol.IsValidObjects([this.object])) return false;
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.RepositoryFn(like) as FnCallType,
+            arguments: [Protocol.TXB_OBJECT(txb, resource.get_object()), Protocol.TXB_OBJECT(txb, this.object)],
+        })   
+    }
+*/
     add_data(data:Repository_Policy_Data)  {
         if (!Repository.IsValidName(data.key)) {
             ERROR(Errors.IsValidName)

package/src/resource.ts

@@ -0,0 +1,90 @@
+import { BCS } from '@mysten/bcs';
+import { Protocol, FnCallType, TxbObject, ResourceAddress} from './protocol';
+import { IsValidDesription, IsValidAddress, IsValidName,  } from './utils';
+import { ERROR, Errors } from './exception';
+
+
+export class Resource {
+    static MAX_WORDS_LEN = 102400;
+    static IsValidWords(words:string) : boolean {
+        return words.length <= Resource.MAX_WORDS_LEN
+    }
+
+    protected object:TxbObject;
+    protected protocol;
+
+    get_object() { return this.object }
+    private constructor(protocol:Protocol) {
+        this.protocol = protocol;
+        this.object = '';
+    }
+
+    static From(protocol:Protocol, object:TxbObject) : Resource {
+        let r = new Resource(protocol);
+        r.object = Protocol.TXB_OBJECT(protocol.CurrentSession(), object);
+        return r
+    }
+
+    add(name:string, object:string)  {
+        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'Resource: add');
+        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: add');
+
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.ResourceFn('add')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), txb.pure(object, BCS.ADDRESS)]
+        });
+    }
+
+    remove(name:string, object?:string, removeall?:boolean)  {
+        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'Resource: remove');
+        if (!object && !removeall) ERROR(Errors.InvalidParam, 'Resource: remove, BOTH param undefined');
+        
+        let txb = this.protocol.CurrentSession();
+        if (removeall) {
+            txb.moveCall({
+                target:this.protocol.ResourceFn('remove_all')  as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING)]
+            });
+        } else if(object) {
+            if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: remove');
+
+            txb.moveCall({
+                target:this.protocol.ResourceFn('remove')  as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), txb.pure(object, BCS.ADDRESS)]
+            });
+        }
+    }
+
+    rename(old_name:string, new_name:string)  {
+        if (!IsValidName(new_name)) ERROR(Errors.IsValidName, 'Resource: rename');
+        
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.ResourceFn('rename')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(old_name, BCS.STRING), txb.pure(new_name, BCS.STRING)]
+        }); 
+    }
+
+    add_words(object:string, words:string) {
+        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: add_words');
+        if (!Resource.IsValidWords(words)) ERROR(Errors.Fail, 'Resource: add_words');
+
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.ResourceFn('words_add')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(object, BCS.ADDRESS), txb.pure(words, BCS.STRING)]
+        });
+    }
+
+    remove_words(object:string) {
+        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: remove_words');
+
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.ResourceFn('words_remove')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(object, BCS.ADDRESS)]
+        });
+    }
+}
+