wowok 1.0.4 → 1.0.5

package/src/guard.ts

@@ -4,7 +4,8 @@ import { BCS, getSuiMoveConfig, toHEX, fromHEX, BcsReader } from '@mysten/bcs';
 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';
+import { stringToUint8Array } from './util';
+
 
 export const MAX_SENSE_COUNT = 16;
 
@@ -29,7 +30,7 @@ export function launch(txb:TransactionBlock, creation:Guard_Creation) : GuardAdd
     if (!creation.senses) return false;
     let bValid = true;
     creation.senses.forEach((v) => {
-        if (v.input.length == 0) bValid = false;
+        if (!v.input || v.input.length == 0) bValid = false;
     })
     if (!bValid) return false;
 
@@ -52,15 +53,21 @@ export function launch(txb:TransactionBlock, creation:Guard_Creation) : GuardAdd
     });
 }
 
-export function signer_guard(txb:TransactionBlock) : boolean {
-    txb.moveCall({
+export function signer_guard(txb:TransactionBlock) : GuardAddress | boolean {
+    return txb.moveCall({
         target: PROTOCOL.GuardFn('signer_guard') as FnCallType,
         arguments: []
-    }); // { kind: 'Result', index: 0 }, ref to address could used by PTB
-    return true
+    }); 
 }
 
-export type Sense_Cmd_Type = {
+export function everyone_guard(txb:TransactionBlock) : GuardAddress | boolean {
+    return txb.moveCall({
+        target: PROTOCOL.GuardFn('everyone_guard') as FnCallType,
+        arguments: []
+    }); 
+}
+
+export type QUERIES_Type = {
     module:MODULES, 
     name:string, 
     cmd:number, 
@@ -68,12 +75,18 @@ export type Sense_Cmd_Type = {
     result:Data_Type
 };
 
-export const Sense_Cmd:any = [ [MODULES.permission, 'creator', 1, [], ValueType.TYPE_STATIC_address],
+export const QUERIES:any = [ 
+    // module, 'name', 'id', [input], output
+    [MODULES.permission, 'builder', 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.permission, 'contains_guard', 7, [ValueType.TYPE_STATIC_address, ValueType.TYPE_STATIC_u64], ValueType.TYPE_STATIC_address],
+    [MODULES.permission, 'entity_count', 8, [], ValueType.TYPE_STATIC_u64],
+    [MODULES.permission, 'admin_count', 9, [], ValueType.TYPE_STATIC_u64],
+
     [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],
@@ -85,6 +98,109 @@ export const Sense_Cmd:any = [ [MODULES.permission, 'creator', 1, [], ValueType.
     [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],   
+
+    [MODULES.machine, 'permission', 1, [], ValueType.TYPE_STATIC_address],
+    [MODULES.machine, 'has_paused', 2, [], ValueType.TYPE_STATIC_bool],
+    [MODULES.machine, 'has_published', 3, [], ValueType.TYPE_STATIC_bool],
+    [MODULES.machine, 'consensus_repositories_contains', 5, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
+    [MODULES.machine, 'has_endpoint', 6, [], ValueType.TYPE_STATIC_bool],   
+    [MODULES.machine, 'endpoint', 7, [], ValueType.TYPE_STATIC_vec_u8],
+
+    [MODULES.progress, 'machine', 1, [], ValueType.TYPE_STATIC_address],       
+    [MODULES.progress, 'current', 2, [], ValueType.TYPE_STATIC_vec_u8],
+    [MODULES.progress, 'has_parent', 3, [], ValueType.TYPE_STATIC_bool],   
+    [MODULES.progress, 'parent', 4, [], ValueType.TYPE_STATIC_address],   
+    [MODULES.progress, 'has_task', 5, [], ValueType.TYPE_STATIC_bool],       
+    [MODULES.progress, 'task', 6, [], ValueType.TYPE_STATIC_address],
+    [MODULES.progress, 'has_namedOperator', 7, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],   
+    [MODULES.progress, 'namedOperator_contains', 8, [ValueType.TYPE_STATIC_vec_u8, ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool], 
+    [MODULES.progress, 'has_context_repository', 9, [], ValueType.TYPE_STATIC_bool],
+    [MODULES.progress, 'context_repository', 10, [], ValueType.TYPE_STATIC_address],   
+
+    [MODULES.demand, 'permission', 1, [], ValueType.TYPE_STATIC_address],       
+    [MODULES.demand, 'has_time_expire', 2, [], ValueType.TYPE_STATIC_bool],
+    [MODULES.demand, 'time_expire', 3, [], ValueType.TYPE_STATIC_u64],   
+    [MODULES.demand, 'earnest_count', 4, [], ValueType.TYPE_STATIC_u64],   
+    [MODULES.demand, 'has_guard', 5, [], ValueType.TYPE_STATIC_bool],       
+    [MODULES.demand, 'guard', 6, [], ValueType.TYPE_STATIC_address],
+    [MODULES.demand, 'has_yes', 7, [], ValueType.TYPE_STATIC_bool],   
+    [MODULES.demand, 'yes', 8, [], ValueType.TYPE_STATIC_address], 
+    [MODULES.demand, 'presenters_count', 9, [], ValueType.TYPE_STATIC_u64],
+    [MODULES.demand, 'has_presenter', 10, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],   
+    [MODULES.demand, 'persenter', 11, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_address], 
+
+    [MODULES.order, 'amount', 1, [], ValueType.TYPE_STATIC_u64],       
+    [MODULES.order, 'payer', 2, [], ValueType.TYPE_STATIC_address],
+    [MODULES.order, 'service', 3, [], ValueType.TYPE_STATIC_address],   
+    [MODULES.order, 'has_progress', 4, [], ValueType.TYPE_STATIC_bool],   
+    [MODULES.order, 'progress', 5, [], ValueType.TYPE_STATIC_address],       
+    [MODULES.order, 'has_requred_info', 6, [], ValueType.TYPE_STATIC_bool],
+    [MODULES.order, 'requred_info_service_pubkey', 7, [], ValueType.TYPE_STATIC_vec_u8],   
+    [MODULES.order, 'requred_info_customer_pubkey', 8, [], ValueType.TYPE_STATIC_vec_u8], 
+    [MODULES.order, 'requred_info_info', 9, [], ValueType.TYPE_STATIC_vec_vec_u8],
+    [MODULES.order, 'has_discount', 10, [], ValueType.TYPE_STATIC_bool],   
+    [MODULES.order, 'discount', 11, [], ValueType.TYPE_STATIC_address], 
+    [MODULES.order, 'balance', 12, [], ValueType.TYPE_STATIC_u64], 
+    [MODULES.order, 'bRefunded', 13, [], ValueType.TYPE_STATIC_u8],
+    [MODULES.order, 'bWithdrawed', 14, [], ValueType.TYPE_STATIC_u8],   
+
+    [MODULES.service, 'permission', 1, [], ValueType.TYPE_STATIC_address],       
+    [MODULES.service, 'payee', 2, [], ValueType.TYPE_STATIC_address],
+    [MODULES.service, 'has_buy_guard', 3, [], ValueType.TYPE_STATIC_bool],   
+    [MODULES.service, 'buy_guard', 4, [], ValueType.TYPE_STATIC_address],   
+    [MODULES.service, 'repository_contains', 5, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],       
+    [MODULES.service, 'has_withdraw_guard', 6, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
+    [MODULES.service, 'withdraw_guard_percent', 7, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],   
+    [MODULES.service, 'has_refund_guard', 8, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool], 
+    [MODULES.service, 'refund_guard_percent', 9, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
+    [MODULES.service, 'has_sale', 10, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],   
+    [MODULES.service, 'sale_price', 11, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64], 
+    [MODULES.service, 'sale_stock', 12, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64], 
+    [MODULES.service, 'has_machine', 13, [], ValueType.TYPE_STATIC_bool],
+    [MODULES.service, 'machine', 14, [], ValueType.TYPE_STATIC_address],   
+    [MODULES.service, 'bPaused', 15, [], ValueType.TYPE_STATIC_bool], 
+    [MODULES.service, 'bPublished', 16, [], ValueType.TYPE_STATIC_bool], 
+    [MODULES.service, 'has_required', 17, [], ValueType.TYPE_STATIC_bool],
+    [MODULES.service, 'requrired_pubkey', 18, [], ValueType.TYPE_STATIC_vec_u8],   
+    [MODULES.service, 'requrired_info', 19, [], ValueType.TYPE_STATIC_vec_vec_u8],  
+
+    [MODULES.reward, 'permission', 1, [], ValueType.TYPE_STATIC_address],       
+    [MODULES.reward, 'rewards_count_remain', 2, [], ValueType.TYPE_STATIC_u64],
+    [MODULES.reward, 'rewards_count_supplied', 3, [], ValueType.TYPE_STATIC_u64],   
+    [MODULES.reward, 'guard_count', 4, [], ValueType.TYPE_STATIC_u64],   
+    [MODULES.reward, 'has_guard', 5, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],       
+    [MODULES.reward, 'guard_portions', 6, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
+    [MODULES.reward, 'time_expire', 7, [], ValueType.TYPE_STATIC_u64],   
+    [MODULES.reward, 'has_claimed', 8, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool], 
+    [MODULES.reward, 'claimed', 9, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],
+    [MODULES.reward, 'has_claimed_count', 10, [], ValueType.TYPE_STATIC_u64],   
+    [MODULES.reward, 'is_sponsor', 11, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool], 
+    [MODULES.reward, 'sponsor', 12, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64], 
+    [MODULES.reward, 'sponsor_count', 13, [], ValueType.TYPE_STATIC_u64],
+    [MODULES.reward, 'bAllowRepeatClaim', 14, [], ValueType.TYPE_STATIC_bool],  
+
+    [MODULES.vote, 'permission', 1, [], ValueType.TYPE_STATIC_address],       
+    [MODULES.vote, 'bOptions_locked_for_voting', 2, [], ValueType.TYPE_STATIC_bool],
+    [MODULES.vote, 'bdeadline_locked', 3, [], ValueType.TYPE_STATIC_bool],   
+    [MODULES.vote, 'bLockedGuard', 4, [], ValueType.TYPE_STATIC_bool],   
+    [MODULES.vote, 'max_choice_count', 5, [], ValueType.TYPE_STATIC_u8],       
+    [MODULES.vote, 'deadline', 6, [], ValueType.TYPE_STATIC_u64],
+    [MODULES.vote, 'has_reference', 7, [], ValueType.TYPE_STATIC_bool],   
+    [MODULES.vote, 'reference', 8, [], ValueType.TYPE_STATIC_address], 
+    [MODULES.vote, 'has_guard', 9, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool],
+    [MODULES.vote, 'guard', 10, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64],   
+    [MODULES.vote, 'voted', 11, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_bool], 
+    [MODULES.vote, 'voted_weight', 12, [ValueType.TYPE_STATIC_address], ValueType.TYPE_STATIC_u64], 
+    [MODULES.vote, 'has_agree', 13, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],
+    [MODULES.vote, 'agree_has_object', 14, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_bool],   
+    [MODULES.vote, 'agree_object', 15, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_address], 
+    [MODULES.vote, 'agree_count', 16, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64], 
+    [MODULES.vote, 'agree_votes', 17, [ValueType.TYPE_STATIC_vec_u8], ValueType.TYPE_STATIC_u64],
+    [MODULES.vote, 'voted_count', 18, [], ValueType.TYPE_STATIC_u64],   
+    [MODULES.vote, 'top1_name_by_count', 19, [], ValueType.TYPE_STATIC_vec_u8], 
+    [MODULES.vote, 'top1_count', 20, [], ValueType.TYPE_STATIC_u64], 
+    [MODULES.vote, 'top1_name_by_votes', 21, [], ValueType.TYPE_STATIC_vec_u8], 
+    [MODULES.vote, 'top1_votes', 22, [], ValueType.TYPE_STATIC_u64], 
 ]
 
 export class SenseMaker {
@@ -118,7 +234,7 @@ export class SenseMaker {
             break;
         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.data.push(bcs.ser(BCS.STRING, param).toBytes());
             this.type_validator.push(type);
             // this.data[this.data.length-1].forEach((item : number) => console.log(item))
             break;
@@ -140,25 +256,36 @@ export class SenseMaker {
         
         return true;
     }
-    add_cmd(object_address:string, sense_index:number) : boolean {
-        if (!object_address || sense_index >= Sense_Cmd.length) { return false; }
-        let offset = this.type_validator.length - Sense_Cmd[sense_index][3].length;
+    query_index(module:MODULES, query_name:string) : number {
+        for (let i = 0; i < QUERIES.length; i++) {
+            if (QUERIES[i][0] == module && QUERIES[i][1] == query_name) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    // query_index: index(from 0) of array QUERIES 
+    add_query(object_address:string, module:MODULES, query_name:string) : boolean {
+        let query_index = this.query_index(module, query_name);
+        if (!object_address || query_index == -1) { return false; }
+
+        let offset = this.type_validator.length - QUERIES[query_index][3].length;
         if (offset < 0) { 
             return false; 
         }
 
         let types = this.type_validator.slice(offset);
-        if (!array_equal(types, Sense_Cmd[sense_index][3])) { // type validate 
+        if (!array_equal(types, QUERIES[query_index][3])) { // type validate 
             return false; 
         }
         
         const bcs = new BCS(getSuiMoveConfig());
         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
+        this.data.push(bcs.ser(BCS.U8, QUERIES[query_index][2]).toBytes()); // cmd
 
-        this.type_validator.splice(offset, Sense_Cmd[sense_index][3].length); // delete type stack
-        this.type_validator.push(Sense_Cmd[sense_index][4]); // add the return value type to type stack
+        this.type_validator.splice(offset, QUERIES[query_index][3].length); // delete type stack
+        this.type_validator.push(QUERIES[query_index][4]); // add the return value type to type stack
         // console.log(this.type_validator)
         return true;
     }
@@ -187,10 +314,11 @@ export class SenseMaker {
         return true;
     }
 
-    make(bNotAfterSense:boolean, binder:Guard_Sense_Binder) : boolean | Guard_Sense {
+    make(bNotAfterSense:boolean = false, binder:Guard_Sense_Binder = Guard_Sense_Binder.AND) : 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] != ValueType.TYPE_STATIC_bool) { 
+            // console.log(this.type_validator)
             return false;
         } // ERROR
 
@@ -201,23 +329,33 @@ export class SenseMaker {
 }
 
 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 ) {
+    if (type == ValueType.TYPE_STATIC_u8 || 
+        type == ValueType.TYPE_STATIC_u64 || 
+        type == ValueType.TYPE_STATIC_u128 ) {
             return true;
     }
     return false;
 }
 
+export function parse_graphql_senses(senses:any) : string[] {
+    let objects:string[] = [];
+    senses.forEach((s:any) => {
+        let res = parse_sense_bsc(Uint8Array.from(s.input.bytes));
+        if (res) {
+           objects = objects.concat(res as string[]);
+        }
+    });
+    return array_unique(objects);
+}
+
 // parse guard senses input bytes of a guard, return [objectids] for 'query_cmd' 
 export function parse_sense_bsc(chain_sense_bsc:Uint8Array)  : boolean | string[] {
-    // console.log(data);
-    var array = [].slice.call(chain_sense_bsc.reverse());
+    var arr = [].slice.call(chain_sense_bsc.reverse());
     const bcs = new BCS(getSuiMoveConfig());
     var result = [];
 
-    while (array.length > 0) {
-        var type : unknown = array.shift() ;
+    while (arr.length > 0) {
+        var type : unknown = arr.shift() ;
         // console.log(type);
         switch (type as Data_Type) { 
             case ContextType.TYPE_CONTEXT_SIGNER:
@@ -230,42 +368,45 @@ export function parse_sense_bsc(chain_sense_bsc:Uint8Array)  : boolean | string[
             case OperatorType.TYPE_LOGIC_OPERATOR_U128_EQUAL:
             case OperatorType.TYPE_LOGIC_OPERATOR_EQUAL:
             case OperatorType.TYPE_LOGIC_OPERATOR_HAS_SUBSTRING:
+            case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
             break;    
         case ValueType.TYPE_STATIC_address: 
             //console.log('0x' + bcs.de(BCS.ADDRESS,  Uint8Array.from(array)).toString());
-            array.splice(0, 32);
+            arr.splice(0, 32);
             break;
         case ValueType.TYPE_STATIC_bool:
         case ValueType.TYPE_STATIC_u8:
-            array.splice(0, 1);
+            arr.splice(0, 1);
             break;
         case ValueType.TYPE_STATIC_u64: 
-            array.splice(0, 8);
+            arr.splice(0, 8);
             break;
         case ValueType.TYPE_STATIC_u128: 
-            array.splice(0, 16);
+            arr.splice(0, 16);
             break;
         case ValueType.TYPE_STATIC_vec_u8:
-            let {value, length} = ulebDecode(Uint8Array.from(array));
-            array.splice(0, value+length);
+            let {value, length} = ulebDecode(Uint8Array.from(arr));
+            arr.splice(0, value+length);
             break;     
         case OperatorType.TYPE_DYNAMIC_QUERY:
-            result.push('0x' + bcs.de(BCS.ADDRESS,  Uint8Array.from(array)).toString());
-            array.splice(0, 33); // address + cmd
+            result.push('0x' + bcs.de(BCS.ADDRESS,  Uint8Array.from(arr)).toString());
+            arr.splice(0, 33); // address + cmd
             break;
         default:
-            // console.log('parse_sense_bsc:undefined');
+            console.error('parse_sense_bsc:undefined');
+            console.log(type as number)
+            console.log(arr)
             return false; // error
         }
     } 
     return result;
 }
 
-const MODULE_GUARD_INDEX = 7;
-export const description_fn = (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
+export const rpc_description_fn = (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
     if (!response.error) {
         let c = response?.data?.content as any;
-        if (c.type == OBJECTS_TYPE[MODULE_GUARD_INDEX] && c.fields.id.id == param.objectid) { // GUARD OBJECT
+
+        if (OBJECTS_TYPE().find((v) => (v == c.type)) && c.fields.id.id == param.objectid) { // GUARD OBJECT
             let description = c.fields.description;
             if (!param.data.includes(description)) {
                 param.data.push(description);
@@ -273,17 +414,24 @@ export const description_fn = (response:SuiObjectResponse, param:Query_Param, op
         }        
     }
 }
-export const sense_objects_fn = (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
+
+export const rpc_sense_objects_fn = (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
     if (!response.error) {
         let c = response?.data?.content as any;
-        if (c.type == OBJECTS_TYPE[MODULE_GUARD_INDEX] && c.fields.id.id == param.objectid) { // GUARD OBJECT
+        let index = OBJECTS_TYPE().findIndex(v => v.includes('guard::Guard') && v == c.type);
+        if (index >= 0 && c.fields.id.id == param.objectid) { // GUARD OBJECT
             for (let i = 0; i < c.fields.senses.length; i ++) {
                 let sense = c.fields.senses[i];
-                if (sense.type == (OBJECTS_TYPE_PREFIX[MODULE_GUARD_INDEX] + 'Sense')) { // ...::guard::Sense                    
-                    let ids = parse_sense_bsc(Uint8Array.from(sense.fields.input.fields.bytes)) as string[];
-                    param.data = array_unique(param.data.concat(ids));
+                if (sense.type == (OBJECTS_TYPE_PREFIX()[index] + 'Sense')) { // ...::guard::Sense    
+                    let res = parse_sense_bsc(Uint8Array.from(sense.fields.input.fields.bytes));      
+                    if (res)   {
+                        let ids =  res as string[];
+                        param.data = param.data.concat(ids);      // DONT array_unique senses                  
+                    }       
                 }                         
             }
         } 
     }
-}
+}
+
+

package/src/index.ts

@@ -0,0 +1,12 @@
+export *  from './protocol'
+export {} from  './demand'
+export {} from  './machine'
+export {} from  './progress'
+export {} from  './service'
+export {} from  './reward'
+export {} from  './uitls'
+export {} from  './permission'
+export {} from  './guard'
+export {} from  './repository'
+export {} from  './vote'
+export * from  './passport'

package/src/machine.ts

@@ -3,13 +3,13 @@ import { BCS } from '@mysten/bcs';
 import { PROTOCOL, FnCallType, PermissionObject, RepositoryObject, IsValidEndpoint, OptionNone, IsValidDesription, PassportObject,
     TXB_OBJECT, MachineObject, MachineAddress, IsValidArray, IsValidAddress, IsValidName, IsValidName_AllowEmpty, GuardObject, 
     IsValidInt, IsValidUint, IsValidObjects} from './protocol';
-import { BCS_CONVERT } from './util'
+import { BCS_CONVERT, array_unique } from './util'
 import { IsValidPermissionIndex, PermissionIndexType } from './permission';
 
 
-export type MachineNodeObject = TransactionResult;
-
+export type MachineNodeObject = TransactionResult | String;
 export const INITIAL_NODE_NAME = '';
+export const namedOperator_ORDER_PAYER = 'order payer';
 
 export type Machine_Forward = {
     name: string; // foward name
@@ -29,7 +29,7 @@ export type Machine_Node = {
     pairs: Machine_Node_Pair[];
 }
 
-// 创建新的node加入到machine
+// create new nodes for machine
 export function machine_add_node(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
     nodes:Machine_Node[], passport?:PassportObject) : boolean {
     if (!IsValidObjects([machine, permission])) return false;
@@ -86,40 +86,46 @@ export function machine_add_node(txb:TransactionBlock, machine:MachineObject, pe
         new_nodes.push(n); 
     }); return machine_add_node2(txb, machine, permission, new_nodes, passport)
 }
-// 把个人拥有的node加入到machine
+// move MachineNodeObject to the machine from signer-owned MachineNode object 
 export function machine_add_node2(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
     nodes:MachineNodeObject[], passport?:PassportObject) : boolean {
     if (!IsValidObjects([machine, permission])) return false;
     if (!nodes) return false;
 
+    let n: TransactionResult[] = [];
+    array_unique(nodes).forEach((v) => {
+        n.push(TXB_OBJECT(txb, v));
+    })
+
     if (passport) {
         txb.moveCall({ // add node
             target:PROTOCOL.MachineFn('node_add_with_passport') as FnCallType,
-            arguments:[passport, TXB_OBJECT(txb, machine), txb.makeMoveVec({objects:nodes}), TXB_OBJECT(txb, permission)]
+            arguments:[passport, TXB_OBJECT(txb, machine), txb.makeMoveVec({objects:n}), TXB_OBJECT(txb, permission)]
         });     
     } else {
         txb.moveCall({ // add node
             target:PROTOCOL.MachineFn('node_add') as FnCallType,
-            arguments:[TXB_OBJECT(txb, machine), txb.makeMoveVec({objects:nodes}), TXB_OBJECT(txb, permission)]
+            arguments:[TXB_OBJECT(txb, machine), txb.makeMoveVec({objects:n}), TXB_OBJECT(txb, permission)]
         });     
     }    
     return true
 }
-// 从machine把node移动到个人地址
-export function machine_remove_node(txb:TransactionBlock, machine:MachineObject, permission:TransactionResult, 
-    nodes_name:string[], passport?:PassportObject) : boolean {
+// move MachineNodeObject from machine to signer-owned MachineNode object 
+export function machine_remove_node(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    nodes_name:string[], bTransferMyself:boolean = false, passport?:PassportObject) : boolean {
     if (!IsValidObjects([machine, permission])) return false;
     if (!nodes_name || !IsValidArray(nodes_name, IsValidName)) return false;
 
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('node_remove_with_passport') as FnCallType,
-            arguments:[passport, TXB_OBJECT(txb, machine), txb.pure(BCS_CONVERT.ser_vector_string(nodes_name)), permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), txb.pure(BCS_CONVERT.ser_vector_string(nodes_name)), 
+                txb.pure(bTransferMyself, BCS.BOOL), TXB_OBJECT(txb, permission)],
         });  
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('node_remove') as FnCallType,
-            arguments:[TXB_OBJECT(txb, machine), txb.pure(BCS_CONVERT.ser_vector_string(nodes_name)), permission],
+            arguments:[TXB_OBJECT(txb, machine), txb.pure(BCS_CONVERT.ser_vector_string(nodes_name)), txb.pure(bTransferMyself, BCS.BOOL), TXB_OBJECT(txb, permission)],
         });
     } 
     return true;

package/src/passport.ts

@@ -1,8 +1,8 @@
 import { SuiObjectResponse, SuiObjectDataOptions } from '@mysten/sui.js/client';
 import { TransactionBlock, TransactionResult, type TransactionObjectInput, Inputs } from '@mysten/sui.js/transactions';
-import { PROTOCOL, FnCallType, CLOCK_OBJECT, Query_Param, OBJECTS_TYPE, OBJECTS_TYPE_PREFIX, PassportObject} from './protocol';
+import { PROTOCOL, FnCallType, CLOCK_OBJECT, Query_Param, OBJECTS_TYPE, OBJECTS_TYPE_PREFIX, PassportObject, GuardObject, TXB_OBJECT} from './protocol';
 import { parse_object_type, array_unique } from './util';
-import { sense_objects_fn } from './guard';
+import { rpc_sense_objects_fn } from './guard';
 
 export const MAX_GUARD_COUNT = 8;
 
@@ -18,40 +18,57 @@ export const MAX_GUARD_COUNT = 8;
 
 export const passport_queries = async (guards:string[]) : Promise<Guard_Query_Object[]> => {
     let sense_objects = guards.map((value) => {
-        return {objectid:value, callback:sense_objects_fn, data:[]} as Query_Param
+        return {objectid:value, callback:rpc_sense_objects_fn, data:[]} as Query_Param
     });
     await PROTOCOL.Query(sense_objects); // objects need quering in guards
     let sense_objects_result:string[] = [];
-    sense_objects.forEach((value) => {
+    sense_objects.forEach((value) => { // DONT CHANGE objects sequence 
         sense_objects_result = sense_objects_result.concat(value.data);
     });
-    sense_objects_result = array_unique(sense_objects_result);
-    console.log(sense_objects_result);
+    sense_objects_result = array_unique(sense_objects_result); // objects in guards
+    // console.log(sense_objects_result);
 
     let queries = sense_objects_result.map((value) => { 
-        return {objectid:value, callback:query_cmd_fn} as Query_Param;
+        return {objectid:value, callback:rpc_query_cmd_fn, data:[]} as Query_Param;
     })
     await PROTOCOL.Query(queries, {'showType':true}); // queries for passport verifing
-    return queries.map((value) => {
-        return value.data as Guard_Query_Object;
+    let res : Guard_Query_Object[] = [];
+    sense_objects.forEach((guard) => { // DONT CHANGE objects sequence  for passport verifying
+        res = res.concat(guard.data.map((object:string) => {
+            let data = queries.filter((v) => {
+                return v.objectid == object
+            });
+            if (!data) {
+                console.error('error find data')
+                console.log(queries)
+                console.log(object)
+                return 
+            }
+            return data[0].data          
+        }))
     })
+    return res;
 }
-// return passport object for using
-export function verify(txb:TransactionBlock, passport_queries:Guard_Query_Object[]) : PassportObject | boolean {
-    if (passport_queries.length == 0 || passport_queries.length > MAX_GUARD_COUNT) {
+
+// return passport object used
+export function verify(txb:TransactionBlock, guards:string[], passport_queries:Guard_Query_Object[]) : PassportObject | boolean {
+    if (!guards || passport_queries.length == 0 || passport_queries.length > MAX_GUARD_COUNT) {
         return false;
     }
-    let guard_ids = passport_queries.map((value)=>value.id);
+    console.log(guards)
+    console.log(passport_queries)
+    
     var passport = txb.moveCall({
         target: PROTOCOL.PassportFn('new') as FnCallType,
-        arguments: [ txb.object(guard_ids[0]), txb.object(CLOCK_OBJECT)]
+        arguments: [ TXB_OBJECT(txb, guards[0]), txb.object(CLOCK_OBJECT)]
     });
 
     // add others guards, if any
-    for (let i = 1; i < guard_ids.length; i++) {
+    for (let i = 1; i < guards.length; i++) {
+        console.log('dfdfdf')
         txb.moveCall({
             target:PROTOCOL.PassportFn('guard_add') as FnCallType,
-            arguments:[passport, txb.object(guard_ids[i])]
+            arguments:[passport, TXB_OBJECT(txb, guards[i])]
         });
     }
 
@@ -84,20 +101,20 @@ export function destroy(txb:TransactionBlock, passport:PassportObject) : boolean
 }
 
 export type Guard_Query_Object = {
-    target: FnCallType,
-    object: TransactionObjectInput,
-    types: string[],
-    id: string,
+    target: FnCallType, // object fnCall
+    object: TransactionObjectInput, // object 
+    types: string[], // object type
+    id: string, // object id
 }
 
 // construct Guard_Query_Object of wowok objects for passport verify
-export const query_cmd_fn = (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
+export const rpc_query_cmd_fn = (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
     if (!response.error && response.data?.objectId == param.objectid && response.data?.type) {
-        for (let k = 0; k < OBJECTS_TYPE.length; k++) {
-            if (response?.data?.type.includes(OBJECTS_TYPE[k]) ) { // type: pack::m::Object<...>
-                param.data = { target:OBJECTS_TYPE_PREFIX[k] + 'guard_query' as FnCallType,
+        for (let k = 0; k < OBJECTS_TYPE().length; k++) {
+            if (response?.data?.type.includes(OBJECTS_TYPE()[k]) ) { // type: pack::m::Object<...>
+                param.data = { target:OBJECTS_TYPE_PREFIX()[k] + 'guard_query' as FnCallType,
                     object:Inputs.SharedObjectRef({
-                        objectId: param.objectid,
+                        objectId: response.data.objectId,
                         mutable: false,
                         initialSharedVersion: response.data!.version,
                     }) as TransactionObjectInput,
@@ -107,4 +124,24 @@ export const query_cmd_fn = (response:SuiObjectResponse, param:Query_Param, opti
             }
         }
     }
+}
+
+export const graphql_query_objects = (nodes:any) : Guard_Query_Object[] => {
+    let ret:Guard_Query_Object[] = [];
+    nodes.forEach((node:any) => {
+        for (let k = 0; k < OBJECTS_TYPE().length; k++) {
+            if (node?.asMoveObject?.contents?.type?.repr?.includes(OBJECTS_TYPE()[k]) ) { // type: pack::m::Object<...>
+                ret.push({ target:OBJECTS_TYPE_PREFIX()[k] + 'guard_query' as FnCallType,
+                    object:Inputs.SharedObjectRef({
+                        objectId: node.address,
+                        mutable: false,
+                        initialSharedVersion: node.version,
+                    }) as TransactionObjectInput,
+                    types:parse_object_type(node.asMoveObject.contents.type.repr as string),
+                    id: node.address,
+                } as Guard_Query_Object);
+            }
+        }        
+    })
+    return ret
 }

package/src/permission.ts

@@ -93,9 +93,11 @@ export const IsValidUserDefinedIndex = (index:number) : boolean => {
     return index >= PermissionIndex.user_defined_start && IsValidUint(index)
 }
 export const IsValidPermissionIndex = (index:PermissionIndexType) : boolean => {
+    //console.log(index)
     if (Object.values(PermissionIndex).includes(index)) {
         return true
     }
+    //console.log(Object.keys(PermissionIndex))
     return IsValidUserDefinedIndex(index);
 }
 
@@ -139,8 +141,11 @@ export function add_entity(txb:TransactionBlock, permission:PermissionObject, en
 
     let bValid = true;
     let e = entities.forEach((v) => {
-        if (!IsValidArray(v.permissions, IsValidPermissionIndex)) bValid = false;
         if (!IsValidAddress(v.entity_address)) bValid = false;
+        v.permissions.forEach((p) => {
+            if (!IsValidPermissionIndex(p.index)) bValid = false;
+            if (p?.guard && !IsValidObjects([p.guard])) bValid = false;
+        })
     });
     if (!bValid) return false;