wowok 1.1.5 → 1.2.0

package/src/guard.ts

@@ -1,14 +1,14 @@
 
 import { BCS } from '@mysten/bcs';
-import { Protocol, GuardAddress, FnCallType, Data_Type, MODULES, ContextType, ValueType,  OperatorType, VariableType, SER_VALUE} from './protocol';
+import { Protocol, GuardAddress, FnCallType, Data_Type, MODULES, ContextType, ValueType,  OperatorType, ConstantType, SER_VALUE} from './protocol';
 import { concatenate, array_equal } from './utils';
 import { IsValidDesription, Bcs, IsValidInt, IsValidAddress } from './utils';
 import { ERROR, Errors } from './exception';
 
-export type GuardVariable = Map<number, Guard_Vriable>;
+export type GuardConstant = Map<number, Guard_Vriable>;
 
 export interface Guard_Vriable {
-    type: VariableType ,
+    type: ConstantType ,
     value?: Uint8Array,
     witness?: Uint8Array,
 }
@@ -24,18 +24,18 @@ export class Guard {
             ERROR(Errors.IsValidDesription)
         }
         let bcs_input = maker.get_input()[0];
-        let variables = maker.get_variable();
+        let constants = maker.get_constant();
         if (bcs_input.length == 0 || bcs_input.length > Guard.MAX_INPUT_LENGTH) {
             ERROR(Errors.InvalidParam, 'launch input')
         }
     
         let bValid = true;
-        variables?.forEach((v, k) => {
-            if (!GuardVariableHelper.IsValidIndentifier(k)) bValid = false;
+        constants?.forEach((v, k) => {
+            if (!GuardConstantHelper.IsValidIndentifier(k)) bValid = false;
             if (!v.value && !v.witness) bValid =  false;
         })
         if (!bValid) {
-            ERROR(Errors.InvalidParam, 'launch variables')
+            ERROR(Errors.InvalidParam, 'launch constants')
         }
         
         let txb = protocol.CurrentSession();
@@ -47,23 +47,23 @@ export class Guard {
             arguments: [txb.pure(description , BCS.STRING), txb.pure([].slice.call(input.reverse()))],  
         });
 
-        variables?.forEach((v, k) => {
+        constants?.forEach((v, k) => {
             if (v.type == ContextType.TYPE_WITNESS_ID) {
                 if (!v.witness) {
-                    ERROR(Errors.InvalidParam, 'variables type')
+                    ERROR(Errors.InvalidParam, 'constants type')
                 }
 
                 txb.moveCall({
-                    target:protocol.GuardFn("variable_add") as FnCallType,
+                    target:protocol.GuardFn("constant_add") as FnCallType,
                     arguments:[guard, txb.pure(k, BCS.U8), txb.pure(v.type, BCS.U8), txb.pure([].slice.call(v.witness)), txb.pure(true, BCS.BOOL)]
                 })            
             } else {
                 if (!v.value)   {
-                    ERROR(Errors.InvalidParam, 'variables type')
+                    ERROR(Errors.InvalidParam, 'constants type')
                 }
     
                 txb.moveCall({
-                    target:protocol.GuardFn("variable_add") as FnCallType,
+                    target:protocol.GuardFn("constant_add") as FnCallType,
                     arguments:[guard, txb.pure(k, BCS.U8), txb.pure(v.type, BCS.U8), txb.pure([].slice.call(v.value)), txb.pure(true, BCS.BOOL)]
                 }) 
             }
@@ -231,7 +231,7 @@ export class Guard {
 
         [MODULES.entity, 'has_entity', 230, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
         [MODULES.entity, 'entity_like', 231, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
-        [MODULES.entity, 'entity_unlike', 232, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
+        [MODULES.entity, 'entity_dislike', 232, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
         [MODULES.entity, 'entity_infomation', 233, [ValueType.TYPE_ADDRESS], ValueType.TYPE_VEC_U8], 
     ];
     static BoolCmd = Guard.QUERIES.filter(q => q[4] == ValueType.TYPE_BOOL);
@@ -241,43 +241,43 @@ export class Guard {
     }
 }
 
-export class GuardVariableHelper {
+export class GuardConstantHelper {
     static IsValidIndentifier = (identifier:number) : boolean => {
         if (!IsValidInt(identifier) || identifier > 255) return false;
         return true
     }
-    static get_variable_value(variables:GuardVariable, identifier:number, type:VariableType) : Uint8Array | undefined {
-        if (variables.has(identifier)) {
-            let v = variables.get(identifier);
+    static get_constant_value(constants:GuardConstant, identifier:number, type:ConstantType) : Uint8Array | undefined {
+        if (constants.has(identifier)) {
+            let v = constants.get(identifier);
             if (v?.value && v.type == type) {
                 return v.value;
             }
         } 
     }
-    static get_variable_witness(variables:GuardVariable, identifier:number) : Uint8Array | undefined {
-        if (variables.has(identifier)) {
-            let v = variables.get(identifier);
+    static get_constant_witness(constants:GuardConstant, identifier:number) : Uint8Array | undefined {
+        if (constants.has(identifier)) {
+            let v = constants.get(identifier);
             if (v?.witness && v.type == ContextType.TYPE_WITNESS_ID) {
                 return v.witness;
             }
         } 
     }
 
-    static add_future_variable(variables:GuardVariable, identifier:number, witness:any, value?:any, bNeedSerialize=true)  {
-        if (!GuardVariableHelper.IsValidIndentifier(identifier)) ERROR(Errors.IsValidIndentifier, 'add_future_variable');
+    static add_future_constant(constants:GuardConstant, identifier:number, witness:any, value?:any, bNeedSerialize=true)  {
+        if (!GuardConstantHelper.IsValidIndentifier(identifier)) ERROR(Errors.IsValidIndentifier, 'add_future_constant');
         if (!witness && !value) ERROR(Errors.InvalidParam, 'both witness and value invalid');
-        let v = variables.get(identifier);
+        let v = constants.get(identifier);
         if (!v || v.type == ContextType.TYPE_WITNESS_ID) {
             if (bNeedSerialize) {
-                variables.set(identifier, {type:ContextType.TYPE_WITNESS_ID, value:value ? Bcs.getInstance().ser_address(value) : undefined, witness:witness ? Bcs.getInstance().ser_address(witness) : undefined})
+                constants.set(identifier, {type:ContextType.TYPE_WITNESS_ID, value:value ? Bcs.getInstance().ser_address(value) : undefined, witness:witness ? Bcs.getInstance().ser_address(witness) : undefined})
             } else {
-                variables.set(identifier, {type:ContextType.TYPE_WITNESS_ID, value:value?value:undefined, witness:witness?witness:undefined});             
+                constants.set(identifier, {type:ContextType.TYPE_WITNESS_ID, value:value?value:undefined, witness:witness?witness:undefined});             
             }                     
         } 
     }
     
-    static add_variable(variables:GuardVariable, identifier:number, type:ValueType, value:any, bNeedSerialize=true) {
-        if (!GuardVariableHelper.IsValidIndentifier(identifier)) return false;
+    static add_constant(constants:GuardConstant, identifier:number, type:ValueType, value:any, bNeedSerialize=true) {
+        if (!GuardConstantHelper.IsValidIndentifier(identifier)) return false;
         if (!value) return false;
     
         switch (type) {
@@ -300,26 +300,26 @@ export class GuardVariableHelper {
             case ValueType.TYPE_VEC_U128:
             case ValueType.TYPE_VEC_U256:
                 let ser = SER_VALUE.find(s=>s.type==type);
-                if (!ser) ERROR(Errors.Fail, 'add_variable: invalid type');
-                bNeedSerialize ? variables.set(identifier, {type:type, value:Bcs.getInstance().ser(ser!.name, value)}) :
-                variables.set(identifier,  {type:type, value:value})    
+                if (!ser) ERROR(Errors.Fail, 'add_constant: invalid type');
+                bNeedSerialize ? constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ser!.name, value)}) :
+                constants.set(identifier,  {type:type, value:value})    
                 return         
             case ValueType.TYPE_VEC_U8:
                 if (typeof(value) === 'string') {
-                    variables.set(identifier, {type:type, value:Bcs.getInstance().ser_string(value)})                 
+                    constants.set(identifier, {type:type, value:Bcs.getInstance().ser_string(value)})                 
                 } else {
-                    variables.set(identifier,  {type:type, value:value})      
+                    constants.set(identifier,  {type:type, value:value})      
                 }
                 return;  
             default:
-                ERROR(Errors.Fail, 'add_variable  serialize not impl yet')
+                ERROR(Errors.Fail, 'add_constant  serialize not impl yet')
         }
     }
 }
 export class GuardMaker {
     protected data : Uint8Array[] = [];
     protected type_validator : Data_Type[] = [];
-    protected variable : GuardVariable = new Map();
+    protected constant : GuardConstant = new Map();
 
     private static index: number = 0;
     private static get_index() { 
@@ -331,13 +331,13 @@ export class GuardMaker {
 
     constructor() { }
 
-    add_variable(type:VariableType, value:any, bNeedSerialize=true) : number {
+    add_constant(type:ConstantType, value:any, bNeedSerialize=true) : number {
         let identifier = GuardMaker.get_index();
         if (type == ContextType.TYPE_WITNESS_ID) {
-            // add witness to variable
-            GuardVariableHelper.add_future_variable(this.variable, identifier, value, undefined, bNeedSerialize);
+            // add witness to constant
+            GuardConstantHelper.add_future_constant(this.constant, identifier, value, undefined, bNeedSerialize);
         } else {
-            GuardVariableHelper.add_variable(this.variable, identifier, type, value, bNeedSerialize);
+            GuardConstantHelper.add_constant(this.constant, identifier, type, value, bNeedSerialize);
         }
         return identifier
     }
@@ -398,7 +398,7 @@ export class GuardMaker {
             this.data.push(Bcs.getInstance().ser_address(param));
             this.type_validator.push(ValueType.TYPE_ADDRESS);
             break;   
-        case ContextType.TYPE_VARIABLE:
+        case ContextType.TYPE_CONSTANT:
             if (!param) {
                 ERROR(Errors.InvalidParam, 'param invalid');
             }
@@ -406,8 +406,8 @@ export class GuardMaker {
                 ERROR(Errors.InvalidParam, 'add_param param');
             }
             
-            var v = this.variable.get(param);
-            if (!v) ERROR(Errors.Fail, 'identifier not in variable');
+            var v = this.constant.get(param);
+            if (!v) ERROR(Errors.Fail, 'identifier not in constant');
             this.type_validator.push(v!.type);
             this.data.push(Bcs.getInstance().ser_u8(type));
             this.data.push(Bcs.getInstance().ser_u8(param));
@@ -418,7 +418,7 @@ export class GuardMaker {
         return this;
     }
 
-    // object_address_from: string for static address; number as identifier  invariable
+    // object_address_from: string for static address; number as identifier  inconstant
     add_query(module:MODULES, query_name:string, object_address_from:string | number, bWitness:boolean=false) : GuardMaker {
         let query_index = Guard.QUERIES.findIndex((q) => { return q[0] ==  module && q[1]  == query_name})
         if (query_index == -1)  {
@@ -426,7 +426,7 @@ export class GuardMaker {
         }
 
         if (typeof(object_address_from) == 'number' ) {
-            if (!GuardVariableHelper.IsValidIndentifier(object_address_from)) {
+            if (!GuardConstantHelper.IsValidIndentifier(object_address_from)) {
                 ERROR(Errors.InvalidParam, 'object_address_from');
             }
         } else {
@@ -451,11 +451,11 @@ export class GuardMaker {
                 this.data.push(Bcs.getInstance().ser_u8(ValueType.TYPE_ADDRESS)); 
             this.data.push(Bcs.getInstance().ser_address(object_address_from)); // object address            
         } else {
-            let v =  this.variable.get(object_address_from);
-            if (!v) ERROR(Errors.Fail, 'object_address_from not in variable');
+            let v =  this.constant.get(object_address_from);
+            if (!v) ERROR(Errors.Fail, 'object_address_from not in constant');
             if ((bWitness && v?.type == ContextType.TYPE_WITNESS_ID) || (!bWitness && v?.type == ValueType.TYPE_ADDRESS)) {
-                this.data.push(Bcs.getInstance().ser_u8(ContextType.TYPE_VARIABLE));
-                this.data.push(Bcs.getInstance().ser_u8(object_address_from)); // object identifer in variables
+                this.data.push(Bcs.getInstance().ser_u8(ContextType.TYPE_CONSTANT));
+                this.data.push(Bcs.getInstance().ser_u8(object_address_from)); // object identifer in constants
             } else {
                 ERROR(Errors.Fail, 'type bWitness not match')
             }
@@ -523,17 +523,17 @@ export class GuardMaker {
         return this.type_validator.length == 1 && this.type_validator[0] == ValueType.TYPE_BOOL && this.data.length == 1;
     }
 
-    combine(otherBuilt:GuardMaker, bAnd:boolean = true, bCombinVariable=false) : GuardMaker {
+    combine(otherBuilt:GuardMaker, bAnd:boolean = true, bCombinConstant=false) : GuardMaker {
         if (!otherBuilt.IsReady() || !this.IsReady()) { ERROR(Errors.Fail, 'both should built yet')};
         let maker = new GuardMaker();
-        this.variable.forEach((v, k) => {
-            maker.variable.set(k,  {type:v.type, value:v.value, witness:v.witness});
+        this.constant.forEach((v, k) => {
+            maker.constant.set(k,  {type:v.type, value:v.value, witness:v.witness});
         })
-        otherBuilt.variable.forEach((v, k) => {
-            if (maker.variable.has(k) && !bCombinVariable) {
-                ERROR(Errors.Fail, 'variable identifier exist');
+        otherBuilt.constant.forEach((v, k) => {
+            if (maker.constant.has(k) && !bCombinConstant) {
+                ERROR(Errors.Fail, 'constant identifier exist');
             }
-            maker.variable.set(k, {type:v.type, value:v.value, witness:v.witness});
+            maker.constant.set(k, {type:v.type, value:v.value, witness:v.witness});
         })
         let op = bAnd ? OperatorType.TYPE_LOGIC_AND :  OperatorType.TYPE_LOGIC_OR;
         maker.data.push(concatenate(Uint8Array, ...this.data, ...otherBuilt.data, Bcs.getInstance().ser_u8(op)));
@@ -542,7 +542,7 @@ export class GuardMaker {
         return maker
     }
 
-    get_variable() { return this.variable  }
+    get_constant() { return this.constant  }
     get_input() { return this.data }
 
     static input_combine(input1:Uint8Array, input2:Uint8Array, bAnd:boolean = true) : Uint8Array {

package/src/index.ts

@@ -1,13 +1,16 @@
 export * from './demand'
-export * from  './progress'
-export * from  './reward'
-export * from  './utils'
-export * from  './permission'
-export * from  './guard'
-export * from  './repository'
-export * from  './vote'
+export * from './progress'
+export * from './reward'
+export * from './utils'
+export * from './permission'
+export * from './guard'
+export * from './repository'
+export * from './vote'
 export * from './protocol'
 export * from './passport'
 export * from './machine'
 export * from './service'
-export * from './graphql'
+export * from './graphql'
+export * from './entity'
+export * from './wowok'
+export * from './resource'

package/src/machine.ts

@@ -196,14 +196,6 @@ export class Machine {
         })
     }
 
-    mark(like:'like' | 'unlike', resource:Resource) {
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.MachineFn(like) as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(txb, resource.get_object()), Protocol.TXB_OBJECT(txb,  this.object)],
-        })  
-    }
-    
     set_description(description:string, passport?:PassportObject) {
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)

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<{object:DeGuardData, variable:DeGuardVariable[]}> => {
-        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 {object:stack.pop()!, variable:variables};
+        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')
+        }
+
+        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 = (variables:  DeGuardVariable[], stack:DeGuardData[], current: DeGuardData) => {
+    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;
@@ -426,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));
             }
@@ -436,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))});
                 }
             }
@@ -468,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})
@@ -506,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;
@@ -543,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) => {
@@ -575,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

@@ -143,14 +143,6 @@ export class  Permission {
         })  
     }
 
-    mark(like:'like' | 'unlike', resource:Resource)  {
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn(like) as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(txb, resource.get_object()), Protocol.TXB_OBJECT(txb, this.object)],
-        })  
-    }
-
     add_entity(entities:Permission_Entity[])  {
         if (!entities) {
             ERROR(Errors.InvalidParam, 'entities');

package/src/progress.ts

@@ -86,7 +86,7 @@ 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({
@@ -94,7 +94,7 @@ export class Progress {
             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')