wowok 1.0.3 → 1.0.4

package/src/demand.ts

@@ -1,173 +1,217 @@
-import { SuiClient, getFullnodeUrl, SuiObjectResponse } from '@mysten/sui.js/client';
 import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
 import { BCS } from '@mysten/bcs';
-import { CLOCK_OBJECT, FnCallType, PROTOCOL, description_data} from './protocol';
-import { GuardObject } from './protocol';
-import { verify,  PassportObject} from './passport'
-import { PermissionIndex, PermissionObject } from './permission'
-import { ServiceObject } from './service'
-
-export type DemandAddress = TransactionResult;
-export type DemandObject = TransactionResult;
+import { CLOCK_OBJECT, FnCallType, IsValidDesription, PROTOCOL, PassportObject, PermissionObject, IsValidArgType, GuardObject,
+    DemandAddress, DemandObject, TXB_OBJECT, IsValidUint, IsValidAddress, TxbObject, IsValidObjects, ServiceObject } from './protocol';
 
 export const MAX_EARNEST_COUNT = 200;
 export const MAX_PRESENTERS_COUNT = 200;
 
-export function demand(earnest_type:string, txb:TransactionBlock, permission:TransactionResult, description:string, earnest:TransactionResult, passport?:PassportObject) : DemandObject {
+
+export function demand(earnest_type:string, txb:TransactionBlock, permission:PermissionObject, description:string, 
+    earnest:TransactionResult, passport?:PassportObject) : DemandObject | boolean {
+    if (!IsValidObjects([permission, earnest])) return false;
+    if (!IsValidDesription(description) || !IsValidArgType(earnest_type)) return false;
+
     if (passport) {
         return txb.moveCall({
             target:PROTOCOL.DemandFn('new_with_passport') as FnCallType,
-            arguments:[passport, txb.pure(description_data(description)), earnest, permission],
+            arguments:[passport, txb.pure(description), earnest, TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })        
     } else {
         return txb.moveCall({
             target:PROTOCOL.DemandFn('new') as FnCallType,
-            arguments:[txb.pure(description_data(description)), earnest, permission],
+            arguments:[txb.pure(description), earnest, TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })        
     }
 }
 
-export function launch(earnest_type:string, txb:TransactionBlock, demand:DemandObject) : DemandAddress {
+export function launch(earnest_type:string, txb:TransactionBlock, demand:DemandObject) : DemandAddress | boolean {
+    if (!IsValidObjects([demand])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
     return txb.moveCall({
         target:PROTOCOL.DemandFn('create') as FnCallType,
-        arguments:[demand],
+        arguments:[TXB_OBJECT(txb, demand)],
         typeArguments:[earnest_type],
     })
 }
 
-export function destroy(earnest_type:string, txb:TransactionBlock, demand:DemandObject) {
-    return txb.moveCall({
+export function destroy(earnest_type:string, txb:TransactionBlock, demand:DemandObject) : boolean {
+    if (!IsValidObjects([demand])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
+    txb.moveCall({
         target:PROTOCOL.DemandFn('destroy') as FnCallType,
-        arguments: [demand],
+        arguments: [TXB_OBJECT(txb, demand)],
         typeArguments:[earnest_type]
-    })   
+    }) 
+    return true  
 }
-export function demand_refund(earnest_type:string, txb:TransactionBlock, demand:DemandObject, permission:TransactionResult, passport?:PassportObject) {
+export function demand_refund(earnest_type:string, txb:TransactionBlock, demand:DemandObject, permission:PermissionObject, 
+    passport?:PassportObject) : boolean {
+    if (!IsValidObjects([demand, permission])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
+
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.DemandFn('refund_with_passport') as FnCallType,
-            arguments:[passport, demand, txb.object(CLOCK_OBJECT), permission],
+            arguments:[passport, TXB_OBJECT(txb, demand), txb.object(CLOCK_OBJECT), TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.DemandFn('refund') as FnCallType,
-            arguments:[demand, txb.object(CLOCK_OBJECT), permission],
+            arguments:[TXB_OBJECT(txb, demand), txb.object(CLOCK_OBJECT), TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })            
     }
+    return true
 }
 
-export function demand_expand_time(earnest_type:string, txb:TransactionBlock, demand:DemandObject, permission:TransactionResult, 
-    minutes_duration:number, passport?:PassportObject) {
+export function demand_expand_time(earnest_type:string, txb:TransactionBlock, demand:DemandObject, permission:PermissionObject, 
+    minutes_duration:number, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([demand, permission])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
+    if (!IsValidUint(minutes_duration)) return false;
+
     if (passport) {
-        return txb.moveCall({
+        txb.moveCall({
             target:PROTOCOL.DemandFn('time_expand_with_passport') as FnCallType,
-            arguments:[passport, demand, txb.pure(minutes_duration, BCS.U64), txb.object(CLOCK_OBJECT), permission],
+            arguments:[passport, TXB_OBJECT(txb, demand), txb.pure(minutes_duration, BCS.U64), txb.object(CLOCK_OBJECT), TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })  
     } else {
-        return txb.moveCall({
+        txb.moveCall({
             target:PROTOCOL.DemandFn('time_expand') as FnCallType,
-            arguments:[demand, txb.pure(minutes_duration, BCS.U64), txb.object(CLOCK_OBJECT), permission],
+            arguments:[TXB_OBJECT(txb, demand), txb.pure(minutes_duration, BCS.U64), txb.object(CLOCK_OBJECT), TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })          
     }
+    return true
 }
 
-export function demand_set_guard(earnest_type:string, txb:TransactionBlock, demand:DemandObject, permission:TransactionResult, guard?:GuardObject, passport?:PassportObject) {  
+export function demand_set_guard(earnest_type:string, txb:TransactionBlock, demand:DemandObject, permission:PermissionObject, 
+    guard?:GuardObject, passport?:PassportObject) : boolean {  
+    if (!IsValidObjects([demand, permission])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
+
     if (passport) {
         if (guard) {
-            return txb.moveCall({
+            txb.moveCall({
                 target:PROTOCOL.DemandFn('guard_set_with_passport') as FnCallType,
-                arguments:[passport, demand, guard, permission],
+                arguments:[passport, TXB_OBJECT(txb, demand), TXB_OBJECT(txb, guard), TXB_OBJECT(txb, permission)],
                 typeArguments:[earnest_type],
             })            
         } else {
-            return txb.moveCall({
+            txb.moveCall({
                 target:PROTOCOL.DemandFn('guard_none_with_passport') as FnCallType,
-                arguments:[passport, demand, permission],
+                arguments:[passport, TXB_OBJECT(txb, demand), TXB_OBJECT(txb, permission)],
                 typeArguments:[earnest_type],
             })               
         }
     } else {
         if (guard) {
-            return txb.moveCall({
+            txb.moveCall({
                 target:PROTOCOL.DemandFn('guard_set') as FnCallType,
-                arguments:[demand, guard, permission],
+                arguments:[TXB_OBJECT(txb, demand), TXB_OBJECT(txb, guard), TXB_OBJECT(txb, permission)],
                 typeArguments:[earnest_type],
             })            
         } else {
-            return txb.moveCall({
+            txb.moveCall({
                 target:PROTOCOL.DemandFn('guard_none') as FnCallType,
-                arguments:[demand, permission],
+                arguments:[TXB_OBJECT(txb, demand), TXB_OBJECT(txb, permission)],
                 typeArguments:[earnest_type],
             })               
         }        
     }
+    return true
 }
 
-export function demand_set_description(earnest_type:string, txb:TransactionBlock, demand:DemandObject, permission:TransactionResult, description:string, passport?:PassportObject) {
+export function demand_set_description(earnest_type:string, txb:TransactionBlock, demand:DemandObject, 
+    permission:PermissionObject, description:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([demand, permission])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
+    if (!IsValidDesription(description)) return false;
+
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.DemandFn('description_set_with_passport') as FnCallType,
-            arguments:[passport, demand, txb.pure(description_data(description)), permission],
+            arguments:[passport, TXB_OBJECT(txb, demand), txb.pure(description), TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })    
     } else {
         txb.moveCall({
             target:PROTOCOL.DemandFn('description_set') as FnCallType,
-            arguments:[demand, txb.pure(description_data(description)), permission],
+            arguments:[TXB_OBJECT(txb, demand), txb.pure(description), TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })    
     }
+    return true
 }
 
-export function demand_yes(earnest_type:string, txb:TransactionBlock, demand:DemandObject, permission:TransactionResult, service:string, passport?:PassportObject) {
+export function demand_yes(earnest_type:string, txb:TransactionBlock, demand:DemandObject, permission:PermissionObject, 
+    service:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([demand, permission])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
+    if (!IsValidAddress(service)) return false;
+
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.DemandFn('yes_with_passport') as FnCallType,
-            arguments:[passport, demand, txb.pure(service, BCS.ADDRESS), permission],
+            arguments:[passport, TXB_OBJECT(txb, demand), txb.pure(service, BCS.ADDRESS), TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })    
     } else {
         txb.moveCall({
             target:PROTOCOL.DemandFn('yes') as FnCallType,
-            arguments:[demand, txb.pure(service, BCS.ADDRESS), permission],
+            arguments:[TXB_OBJECT(txb, demand), txb.pure(service, BCS.ADDRESS), TXB_OBJECT(txb, permission)],
             typeArguments:[earnest_type],
         })    
     }
+    return true
 }
 
-export function deposit(earnest_type:string, txb:TransactionBlock, demand:DemandObject, earnest:TransactionResult) {
-    return txb.moveCall({
+export function deposit(earnest_type:string, txb:TransactionBlock, demand:DemandObject, earnest:TxbObject) : boolean {
+    if (!IsValidObjects([demand, earnest])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
+    txb.moveCall({
         target:PROTOCOL.DemandFn('deposit') as FnCallType,
-        arguments:[demand, earnest],
+        arguments:[TXB_OBJECT(txb, demand), TXB_OBJECT(txb, earnest)],
         typeArguments:[earnest_type],
     })    
+    return true
 }
 
-export function present(earnest_type:string, service_type:string, txb:TransactionBlock, demand:DemandObject, service:ServiceObject, tips:string, passport?:PassportObject) {
+export function present(earnest_type:string, service_type:string, txb:TransactionBlock, demand:DemandObject, 
+    service:ServiceObject, tips:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([demand, service])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
+    if (!IsValidDesription(tips)) return false;
+
     if (passport) {
-        return txb.moveCall({
+        txb.moveCall({
             target:PROTOCOL.DemandFn('present_with_passport') as FnCallType,
-            arguments:[passport, demand, service, txb.pure(description_data(tips)), ],
+            arguments:[passport, TXB_OBJECT(txb, demand), TXB_OBJECT(txb, service), txb.pure(tips), ],
             typeArguments:[earnest_type, service_type],
         })   
     } else {
-        return txb.moveCall({
+        txb.moveCall({
             target:PROTOCOL.DemandFn('present') as FnCallType,
-            arguments:[demand, service, txb.pure(description_data(tips)), ],
+            arguments:[TXB_OBJECT(txb, demand), TXB_OBJECT(txb, service), txb.pure(tips), ],
             typeArguments:[earnest_type, service_type],
         })   
     } 
+    return true
 }
-export function change_permission(earnest_type:string, txb:TransactionBlock, demand:DemandObject, old_permission:PermissionObject, new_permission:PermissionObject) {
+export function change_permission(earnest_type:string, txb:TransactionBlock, demand:DemandObject, 
+    old_permission:PermissionObject, new_permission:PermissionObject) : boolean {
+    if (!IsValidObjects([demand, old_permission, new_permission])) return false;
+    if (!IsValidArgType(earnest_type)) return false;
+
     txb.moveCall({
         target:PROTOCOL.DemandFn('permission_set') as FnCallType,
-        arguments: [demand, old_permission, new_permission],
+        arguments: [TXB_OBJECT(txb, demand), TXB_OBJECT(txb, old_permission), TXB_OBJECT(txb, new_permission)],
         typeArguments:[earnest_type]            
     })    
+    return true
 }

package/src/guard.ts

@@ -1,13 +1,16 @@
 import { SuiObjectResponse, SuiObjectDataOptions, SuiParsedData } from '@mysten/sui.js/client';
 import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
 import { BCS, getSuiMoveConfig, toHEX, fromHEX, BcsReader } from '@mysten/bcs';
-import { PROTOCOL, GuardAddress, FnCallType, Data_Type, MODULES, GuardObject, OBJECTS_TYPE, OBJECTS_TYPE_PREFIX, Query_Param} from './protocol';
+import { PROTOCOL, GuardAddress, FnCallType, Data_Type, MODULES, ContextType, OBJECTS_TYPE, 
+    OBJECTS_TYPE_PREFIX, Query_Param, IsValidDesription, ValueType,  OperatorType} from './protocol';
 import { concatenate, array_equal, ulebDecode, array_unique } from './util';
 import { TransactionBlockDataBuilder } from '@mysten/sui.js/dist/cjs/builder/TransactionBlockData';
 
+export const MAX_SENSE_COUNT = 16;
+
 export enum Guard_Sense_Binder {
-    AND = 1, // first sense of guard always AND; for combining other guards
-    OR = 2,
+    AND = 0, // first sense of guard always AND; for combining other guards
+    OR = 1,
 }
 
 export type Guard_Sense = { 
@@ -21,15 +24,23 @@ export type Guard_Creation = {
     senses: Guard_Sense[];
 }
 
-export function launch(txb:TransactionBlock, creation:Guard_Creation) : GuardAddress {
-    var guard = txb.moveCall({
+export function launch(txb:TransactionBlock, creation:Guard_Creation) : GuardAddress | boolean {
+    if (!IsValidDesription(creation.description)) return false;
+    if (!creation.senses) return false;
+    let bValid = true;
+    creation.senses.forEach((v) => {
+        if (v.input.length == 0) bValid = false;
+    })
+    if (!bValid) return false;
+
+    let guard = txb.moveCall({
         target: PROTOCOL.GuardFn('new') as FnCallType,
-        arguments: [            txb.pure(creation.description , BCS.STRING),        ],  
+        arguments: [txb.pure(creation.description , BCS.STRING)],  
     });
-    creation?.senses.forEach((sense: Guard_Sense) => {
+    creation.senses.forEach((sense: Guard_Sense) => {
         txb.moveCall({
             target: PROTOCOL.GuardFn('sense_add') as FnCallType,
-            arguments:[                guard,                txb.pure([].slice.call(sense.input)),
+            arguments:[guard, txb.pure([].slice.call(sense.input)),
                 txb.pure(sense.notAfterSense, BCS.BOOL),
                 txb.pure(sense.binder, BCS.U8),
             ]
@@ -41,18 +52,12 @@ export function launch(txb:TransactionBlock, creation:Guard_Creation) : GuardAdd
     });
 }
 
-export function signer_guard(txb:TransactionBlock) {
+export function signer_guard(txb:TransactionBlock) : boolean {
     txb.moveCall({
         target: PROTOCOL.GuardFn('signer_guard') as FnCallType,
         arguments: []
     }); // { kind: 'Result', index: 0 }, ref to address could used by PTB
-}
-
-export function query_description(txb:TransactionBlock, guard:GuardObject) {
-    txb.moveCall({
-        target: PROTOCOL.GuardFn('description') as FnCallType,
-        arguments:[guard]
-    })
+    return true
 }
 
 export type Sense_Cmd_Type = {
@@ -63,23 +68,23 @@ export type Sense_Cmd_Type = {
     result:Data_Type
 };
 
-export const Sense_Cmd:any = [    [MODULES.permission, 'creator', 1, [], Data_Type.TYPE_STATIC_address],
-    [MODULES.permission, 'is_admin', 2, [Data_Type.TYPE_STATIC_address], Data_Type.TYPE_STATIC_bool],
-    [MODULES.permission, 'has_rights', 3, [Data_Type.TYPE_STATIC_address, Data_Type.TYPE_STATIC_u64], Data_Type.TYPE_STATIC_bool],
-    [MODULES.permission, 'contains_address', 4, [Data_Type.TYPE_STATIC_address], Data_Type.TYPE_STATIC_bool],
-    [MODULES.permission, 'contains_index', 5, [Data_Type.TYPE_STATIC_address, Data_Type.TYPE_STATIC_u64], Data_Type.TYPE_STATIC_bool],
-    [MODULES.permission, 'contains_guard', 6, [Data_Type.TYPE_STATIC_address, Data_Type.TYPE_STATIC_u64], Data_Type.TYPE_STATIC_bool],
-    [MODULES.repository, 'permission', 1, [], Data_Type.TYPE_STATIC_address],
-    [MODULES.repository, 'policy_contains', 2, [Data_Type.TYPE_STATIC_vec_u8], Data_Type.TYPE_STATIC_bool],
-    [MODULES.repository, 'policy_has_permission_index', 3, [Data_Type.TYPE_STATIC_vec_u8], Data_Type.TYPE_STATIC_bool],
-    [MODULES.repository, 'policy_permission_index', 4, [Data_Type.TYPE_STATIC_vec_u8], Data_Type.TYPE_STATIC_u64],
-    [MODULES.repository, 'policy_value_type', 5, [Data_Type.TYPE_STATIC_vec_u8], Data_Type.TYPE_STATIC_u8],
-    [MODULES.repository, 'contains_id', 6, [Data_Type.TYPE_STATIC_address], Data_Type.TYPE_STATIC_bool],   
-    [MODULES.repository, 'contains_value', 7, [Data_Type.TYPE_STATIC_address, Data_Type.TYPE_STATIC_vec_u8], Data_Type.TYPE_STATIC_bool],
-    [MODULES.repository, 'value_without_type', 8, [Data_Type.TYPE_STATIC_address, Data_Type.TYPE_STATIC_vec_u8], Data_Type.TYPE_STATIC_vec_u8],       
-    [MODULES.repository, 'value', 9, [Data_Type.TYPE_STATIC_address, Data_Type.TYPE_STATIC_vec_u8], Data_Type.TYPE_STATIC_vec_u8],
-    [MODULES.repository, 'type', 10, [], Data_Type.TYPE_STATIC_u8],   
-    [MODULES.repository, 'policy_mode', 11, [], Data_Type.TYPE_STATIC_u8],   
+export const Sense_Cmd:any = [ [MODULES.permission, 'creator', 1, [], ValueType.TYPE_STATIC_address],
+    [MODULES.permission, 'is_admin', 2, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
+    [MODULES.permission, 'has_rights', 3, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_u64], ValueType.TYPE_STATIC_bool],
+    [MODULES.permission, 'contains_address', 4, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
+    [MODULES.permission, 'contains_index', 5, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_u64], ValueType.TYPE_STATIC_bool],
+    [MODULES.permission, 'contains_guard', 6, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_u64], ValueType.TYPE_STATIC_bool],
+    [MODULES.repository, 'permission', 1, [], ValueType.TYPE_STATIC_address],
+    [MODULES.repository, 'policy_contains', 2, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
+    [MODULES.repository, 'policy_has_permission_index', 3, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
+    [MODULES.repository, 'policy_permission_index', 4, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64],
+    [MODULES.repository, 'policy_value_type', 5, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u8],
+    [MODULES.repository, 'contains_id', 6, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],   
+    [MODULES.repository, 'contains_value', 7, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
+    [MODULES.repository, 'value_without_type', 8, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_vec_u8],       
+    [MODULES.repository, 'value', 9, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_vec_u8],
+    [MODULES.repository, 'type', 10, [], ValueType.TYPE_STATIC_u8],   
+    [MODULES.repository, 'policy_mode', 11, [], ValueType.TYPE_STATIC_u8],   
 ]
 
 export class SenseMaker {
@@ -88,46 +93,46 @@ export class SenseMaker {
 
     constructor() { }
     // serialize const & data
-    add_param(type:Data_Type, param?:any) : boolean {
+    add_param(type:ValueType | ContextType, param?:any) : boolean {
         const bcs = new BCS(getSuiMoveConfig());
         switch(type)  {
-        case Data_Type.TYPE_STATIC_address: 
+        case ValueType.TYPE_STATIC_address: 
             this.data.push(bcs.ser(BCS.U8, type).toBytes());
             this.data.push(bcs.ser(BCS.ADDRESS, param).toBytes());
             this.type_validator.push(type);
             break;
-        case Data_Type.TYPE_STATIC_bool:
+        case ValueType.TYPE_STATIC_bool:
             this.data.push(bcs.ser(BCS.U8, type).toBytes());
             this.data.push(bcs.ser(BCS.BOOL, param).toBytes());
             this.type_validator.push(type);
             break;
-        case Data_Type.TYPE_STATIC_u8:
+        case ValueType.TYPE_STATIC_u8:
             this.data.push(bcs.ser(BCS.U8, type).toBytes());
             this.data.push(bcs.ser(BCS.U8, param).toBytes());
             this.type_validator.push(type);
             break;
-        case Data_Type.TYPE_STATIC_u64: 
+        case ValueType.TYPE_STATIC_u64: 
             this.data.push(bcs.ser(BCS.U8, type).toBytes());
             this.data.push(bcs.ser(BCS.U64, param).toBytes());
             this.type_validator.push(type);
             break;
-        case Data_Type.TYPE_STATIC_vec_u8:
+        case ValueType.TYPE_STATIC_vec_u8:
             this.data.push(bcs.ser(BCS.U8, type).toBytes());
             this.data.push(bcs.ser("vector<u8>", param).toBytes());
             this.type_validator.push(type);
             // this.data[this.data.length-1].forEach((item : number) => console.log(item))
             break;
-        case Data_Type.TYPE_CONTEXT_SIGNER:
+        case ContextType.TYPE_CONTEXT_SIGNER:
             this.data.push(bcs.ser(BCS.U8, type).toBytes());
-            this.type_validator.push(Data_Type.TYPE_STATIC_address);
+            this.type_validator.push(ValueType.TYPE_STATIC_address);
             break;
-        case Data_Type.TYPE_CONTEXT_CURRENT_CLOCK:
+        case ContextType.TYPE_CONTEXT_CURRENT_CLOCK:
             this.data.push(bcs.ser(BCS.U8, type).toBytes());
-            this.type_validator.push(Data_Type.TYPE_STATIC_u64);
+            this.type_validator.push(ValueType.TYPE_STATIC_u64);
             break;
-        case Data_Type.TYPE_CONTEXT_CURRENT_PROGRESS:
+        case ContextType.TYPE_CONTEXT_CURRENT_PROGRESS:
             this.data.push(bcs.ser(BCS.U8, type).toBytes());
-            this.type_validator.push(Data_Type.TYPE_STATIC_address);
+            this.type_validator.push(ValueType.TYPE_STATIC_address);
             break;
         default:
             return false;
@@ -148,7 +153,7 @@ export class SenseMaker {
         }
         
         const bcs = new BCS(getSuiMoveConfig());
-        this.data.push(bcs.ser(BCS.U8, Data_Type.TYPE_DYNAMIC_QUERY).toBytes()); // TYPE
+        this.data.push(bcs.ser(BCS.U8, OperatorType.TYPE_DYNAMIC_QUERY).toBytes()); // TYPE
         this.data.push(bcs.ser(BCS.ADDRESS, object_address).toBytes()); // object address
         this.data.push(bcs.ser(BCS.U8, Sense_Cmd[sense_index][2]).toBytes()); // cmd
 
@@ -157,19 +162,19 @@ export class SenseMaker {
         // console.log(this.type_validator)
         return true;
     }
-    add_logic(type:Data_Type) : boolean {
+    add_logic(type:OperatorType) : boolean {
         switch (type) {
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_GREATER:
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL:
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_LESSER:
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL:
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_EQUAL:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_GREATER:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_LESSER:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_EQUAL:
                 if (this.type_validator.length < 2)  { return false; }
                 if (!match_u128(this.type_validator[this.type_validator.length - 1])) { return false; }
                 if (!match_u128(this.type_validator[this.type_validator.length - 2])) { return false; }
                 break;
-            case Data_Type.TYPE_LOGIC_OPERATOR_EQUAL:
-            case Data_Type.TYPE_LOGIC_OPERATOR_HAS_SUBSTRING:
+            case OperatorType.TYPE_LOGIC_OPERATOR_EQUAL:
+            case OperatorType.TYPE_LOGIC_OPERATOR_HAS_SUBSTRING:
                 if (this.type_validator.length < 2)  { return false; }
                 break;
             default:
@@ -178,15 +183,15 @@ export class SenseMaker {
         const bcs = new BCS(getSuiMoveConfig());
         this.data.push(bcs.ser(BCS.U8, type).toBytes()); // TYPE     
         this.type_validator.splice(this.type_validator.length - 2); // delete type stack   
-        this.type_validator.push(Data_Type.TYPE_STATIC_bool); // add bool to type stack
+        this.type_validator.push(ValueType.TYPE_STATIC_bool); // add bool to type stack
         return true;
     }
 
-    make(bNotAfterSense:boolean, binder:Guard_Sense_Binder) : undefined | Guard_Sense {
+    make(bNotAfterSense:boolean, binder:Guard_Sense_Binder) : boolean | Guard_Sense {
         //console.log(this.type_validator);
         //this.data.forEach((value:Uint8Array) => console.log(value));
-        if (this.type_validator.length != 1 || this.type_validator[0] != Data_Type.TYPE_STATIC_bool) { 
-            return undefined;
+        if (this.type_validator.length != 1 || this.type_validator[0] != ValueType.TYPE_STATIC_bool) { 
+            return false;
         } // ERROR
 
         let input = concatenate(Uint8Array, ...this.data) as Uint8Array;
@@ -195,61 +200,62 @@ export class SenseMaker {
     }
 }
 
-function match_u128(type:Data_Type) : boolean {
-    if (type == Data_Type.TYPE_STATIC_option_u8 || 
-        type == Data_Type.TYPE_STATIC_option_u64 || 
-        type == Data_Type.TYPE_STATIC_option_u128 ) {
+function match_u128(type:number) : boolean {
+    if (type == ValueType.TYPE_STATIC_option_u8 || 
+        type == ValueType.TYPE_STATIC_option_u64 || 
+        type == ValueType.TYPE_STATIC_option_u128 ) {
             return true;
     }
     return false;
 }
 
 // parse guard senses input bytes of a guard, return [objectids] for 'query_cmd' 
-export function parse_sense_bsc(chain_sense_bsc:Uint8Array)  : undefined | string[] {
+export function parse_sense_bsc(chain_sense_bsc:Uint8Array)  : boolean | string[] {
     // console.log(data);
     var array = [].slice.call(chain_sense_bsc.reverse());
     const bcs = new BCS(getSuiMoveConfig());
     var result = [];
+
     while (array.length > 0) {
         var type : unknown = array.shift() ;
         // console.log(type);
-        switch (type as Data_Type) {
-            case Data_Type.TYPE_CONTEXT_SIGNER:
-            case Data_Type.TYPE_CONTEXT_CURRENT_CLOCK:
-            case Data_Type.TYPE_CONTEXT_CURRENT_PROGRESS:
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_GREATER:
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL:
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_LESSER:
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL:
-            case Data_Type.TYPE_LOGIC_OPERATOR_U128_EQUAL:
-            case Data_Type.TYPE_LOGIC_OPERATOR_EQUAL:
-            case Data_Type.TYPE_LOGIC_OPERATOR_HAS_SUBSTRING:
+        switch (type as Data_Type) { 
+            case ContextType.TYPE_CONTEXT_SIGNER:
+            case ContextType.TYPE_CONTEXT_CURRENT_CLOCK:
+            case ContextType.TYPE_CONTEXT_CURRENT_PROGRESS:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_GREATER:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_LESSER:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL:
+            case OperatorType.TYPE_LOGIC_OPERATOR_U128_EQUAL:
+            case OperatorType.TYPE_LOGIC_OPERATOR_EQUAL:
+            case OperatorType.TYPE_LOGIC_OPERATOR_HAS_SUBSTRING:
             break;    
-        case Data_Type.TYPE_STATIC_address: 
+        case ValueType.TYPE_STATIC_address: 
             //console.log('0x' + bcs.de(BCS.ADDRESS,  Uint8Array.from(array)).toString());
             array.splice(0, 32);
             break;
-        case Data_Type.TYPE_STATIC_bool:
-        case Data_Type.TYPE_STATIC_u8:
+        case ValueType.TYPE_STATIC_bool:
+        case ValueType.TYPE_STATIC_u8:
             array.splice(0, 1);
             break;
-        case Data_Type.TYPE_STATIC_u64: 
+        case ValueType.TYPE_STATIC_u64: 
             array.splice(0, 8);
             break;
-        case Data_Type.TYPE_STATIC_u128: 
+        case ValueType.TYPE_STATIC_u128: 
             array.splice(0, 16);
             break;
-        case Data_Type.TYPE_STATIC_vec_u8:
+        case ValueType.TYPE_STATIC_vec_u8:
             let {value, length} = ulebDecode(Uint8Array.from(array));
             array.splice(0, value+length);
             break;     
-        case Data_Type.TYPE_DYNAMIC_QUERY:
+        case OperatorType.TYPE_DYNAMIC_QUERY:
             result.push('0x' + bcs.de(BCS.ADDRESS,  Uint8Array.from(array)).toString());
             array.splice(0, 33); // address + cmd
             break;
         default:
             // console.log('parse_sense_bsc:undefined');
-            return undefined; // error
+            return false; // error
         }
     } 
     return result;