wowok 1.0.3 → 1.0.5

package/src/machine.ts

@@ -1,29 +1,27 @@
 import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
 import { BCS } from '@mysten/bcs';
-import { name_data, CLOCK_OBJECT, PROTOCOL, FnCallType, description_data, MAX_ENDPOINT_LENGTH} from './protocol';
-import { verify,  PassportObject} from './passport'
-import { PermissionIndex, PermissionObject } from './permission'
-import { RepositoryObject } from './repository';
-import { BCS_CONVERT } from './util'
+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, array_unique } from './util'
+import { IsValidPermissionIndex, PermissionIndexType } from './permission';
 
 
-export type MachineAddress = TransactionResult;
-export type MachineObject = TransactionResult;
-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
-    namedOperator?: string; 
-    permission?: number; // permission-index or named-operator MUST one defined.
+    namedOperator?: string; // dynamic operator
+    permission?: PermissionIndexType; // permission-index or named-operator MUST one defined.
     weight?: number;
-    guard_address?: string;
+    guard?: GuardObject;
 }
 export type Machine_Node_Pair = {
     prior_node: string;
-    threshold: number;
     forwards: Machine_Forward[];
+    threshold?: number;
 }
 export type Machine_Node = {
     name: string;
@@ -31,227 +29,280 @@ export type Machine_Node = {
     pairs: Machine_Node_Pair[];
 }
 
-// node & forward & forward permission string length validation
-export function is_valid_name(name:string):boolean { return name.length > 0 && name.length < 33 }
+// 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;
+    let bValid = true;
+    nodes.forEach((node) => {
+        if (!IsValidDesription(node.description) || !IsValidName(node.name))  { bValid = false; }
+
+        node.pairs.forEach((p) => {
+            if (!IsValidName_AllowEmpty(p.prior_node)) { bValid = false; }
+            if (p?.threshold && !IsValidInt(p.threshold)) { bValid = false; }
+            p.forwards.forEach((f) => {
+                if (!IsValidName(f.name)) { bValid = false }
+                if (f?.namedOperator && !IsValidName_AllowEmpty(f?.namedOperator)) { bValid = false }
+                if (f?.permission && !IsValidPermissionIndex(f?.permission)) { bValid = false }
+                if (!f?.permission && !f?.namedOperator) { bValid = false; }
+                if (f?.weight && !IsValidUint(f.weight)) { bValid = false; }
+            })
+        })
+    })
+    if (!bValid) return false
 
-// 创建新的node加入到machine
-export function machine_add_node(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, nodes:Machine_Node[], passport?:PassportObject) {
     let new_nodes: MachineNodeObject[] = [];
     nodes.forEach((node) => {
         let n = txb.moveCall({
             target:PROTOCOL.NodeFn('new') as FnCallType,
-            arguments:[txb.pure(name_data(node.name)), txb.pure(description_data(node.description))]
+            arguments:[txb.pure(node.name), txb.pure(node.description)]
         });
         node.pairs.forEach((pair) => {
+            let threshold = pair?.threshold ? txb.pure(BCS_CONVERT.ser_option_u64(pair.threshold)) : OptionNone(txb);
+
             pair.forwards.forEach((forward) => {
-                if (!forward?.namedOperator && !forward?.permission) { return }
-                let weight = txb.pure(1); 
-                if (forward?.weight && forward.weight >  0) { 
-                    weight = txb.pure(forward.weight) 
-                }
-                
-                let per = txb.pure([], BCS.U8); 
-                if (forward?.permission) {
-                    per = txb.pure(BCS_CONVERT.ser_option_u64(forward.permission as number));
-                }; 
-                let namedOperator = txb.pure('');
-                if (forward?.namedOperator) {
-                    namedOperator = txb.pure(forward.namedOperator)
-                }; let f;
+                let weight = forward?.weight ? forward.weight : 1;
+                let perm = forward?.permission ? txb.pure(BCS_CONVERT.ser_option_u64(forward.permission)) : OptionNone(txb); 
+                let namedOperator = forward?.namedOperator ?  txb.pure(forward.namedOperator) : txb.pure('');
+                let f;
 
-                if (forward?.guard_address) {
+                if (forward?.guard) {
                     f = txb.moveCall({ 
                         target:PROTOCOL.NodeFn('forward') as FnCallType,
-                            arguments:[namedOperator, weight, txb.object(forward.guard_address), per]
+                            arguments:[namedOperator, txb.pure(weight), txb.object(TXB_OBJECT(txb, forward.guard)), perm]
                     });                        
                 } else {
                     f = txb.moveCall({ 
                         target:PROTOCOL.NodeFn('forward2') as FnCallType,
-                            arguments:[namedOperator, weight, per]
+                            arguments:[namedOperator, txb.pure(weight), perm]
                     });                
                 }
                 txb.moveCall({ // add forward
                     target:PROTOCOL.NodeFn('forward_add') as FnCallType,
-                        arguments:[n, txb.pure(pair.prior_node), txb.pure(name_data(forward.name)),  
-                            txb.pure(BCS_CONVERT.ser_option_u64(pair.threshold)), f]
+                        arguments:[n, txb.pure(pair.prior_node), txb.pure(forward.name),  threshold, f]
                 });                
             }); 
         }); 
         new_nodes.push(n); 
-    }); machine_add_node2(txb, machine, permission, new_nodes, passport)
+    }); return machine_add_node2(txb, machine, permission, new_nodes, passport)
 }
-// 把个人拥有的node加入到machine
-export function machine_add_node2(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, nodes:MachineNodeObject[], passport?:PassportObject) {
+// 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, machine, txb.makeMoveVec({objects:nodes}), 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:[machine, txb.makeMoveVec({objects:nodes}), 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[], receive_address:string, passport?:PassportObject) {
+// 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, 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:[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;
 }
-export function machine(txb:TransactionBlock, permission:PermissionObject, description:string, endpoint_url?:string, passport?:PassportObject) : MachineObject | undefined {
-    if (endpoint_url && endpoint_url.length > MAX_ENDPOINT_LENGTH) return undefined;
-    let endpoint = endpoint_url? txb.pure(BCS_CONVERT.ser_option_string(endpoint_url)) : txb.pure([], BCS.U8);
+export function machine(txb:TransactionBlock, permission:PermissionObject, description:string, 
+    endpoint?:string, passport?:PassportObject) : MachineObject | boolean {
+    if (!IsValidObjects([permission])) return false;    
+    if (!IsValidDesription(description)) return false;
+    if (endpoint && !IsValidEndpoint(endpoint)) return false;
+    let ep = endpoint? txb.pure(BCS_CONVERT.ser_option_string(endpoint)) : OptionNone(txb);
 
     if (passport) {
         return txb.moveCall({
             target:PROTOCOL.MachineFn('new_with_passport') as FnCallType,
-            arguments:[passport, txb.pure(description_data(description)), endpoint, permission],
+            arguments:[passport, txb.pure(description), ep, TXB_OBJECT(txb, permission)],
         })
     } else {
-        //console.log(endpoint)
         return txb.moveCall({
             target:PROTOCOL.MachineFn('new') as FnCallType,
-            arguments:[txb.pure(description_data(description)), endpoint, permission],
+            arguments:[txb.pure(description), ep, TXB_OBJECT(txb, permission)],
         })
     }
 }
-export function destroy(txb:TransactionBlock, machine:MachineObject) {
-    return txb.moveCall({
+export function destroy(txb:TransactionBlock, machine:MachineObject) : boolean{
+    if (!IsValidObjects([machine])) return false;
+    txb.moveCall({
         target:PROTOCOL.MachineFn('destroy') as FnCallType,
-        arguments: [machine],
-    })   
+        arguments: [TXB_OBJECT(txb, machine)],
+    })  
+    return true 
 }
-export function launch(txb:TransactionBlock, machine:MachineObject) : MachineAddress {
+export function launch(txb:TransactionBlock, machine:MachineObject) : MachineAddress | boolean {
+    if (!IsValidObjects([machine])) return false;
     return txb.moveCall({
         target:PROTOCOL.MachineFn('create') as FnCallType,
-        arguments:[machine],
+        arguments:[TXB_OBJECT(txb, machine)],
     })
 }
-export function machine_set_description(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, description:string, passport?:PassportObject) {
+export function machine_set_description(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    description:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
+    if (!IsValidDesription(description)) return false;
+
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('description_set_with_passport') as FnCallType,
-            arguments:[passport, machine, txb.pure(description_data(description)), permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), txb.pure(description), TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('description_set') as FnCallType,
-            arguments:[machine, txb.pure(description_data(description)), permission],
+            arguments:[TXB_OBJECT(txb, machine), txb.pure(description), TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
-export function machine_add_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, repository:RepositoryObject, passport?:PassportObject) {
+export function machine_add_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    repository:RepositoryObject, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission, repository])) return false;
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('repository_add_with_passport') as FnCallType,
-            arguments:[passport, machine, repository, permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), TXB_OBJECT(txb, repository), TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('repository_add') as FnCallType,
-            arguments:[machine, repository, permission],
+            arguments:[TXB_OBJECT(txb, machine), TXB_OBJECT(txb, repository), TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
 
-export function machine_remove_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, repositories:string[], removeall?:boolean, passport?:PassportObject) {
+export function machine_remove_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    repositories:string[], removeall?:boolean, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
+    if (!removeall && !repositories) return false;
+    if (!IsValidArray(repositories, IsValidAddress)) return false;
+
     if (passport) {
         if (removeall) {
             txb.moveCall({
                 target:PROTOCOL.MachineFn('repository_remove_all_with_passport') as FnCallType,
-                arguments:[passport, machine, permission],
+                arguments:[passport, TXB_OBJECT(txb, machine), TXB_OBJECT(txb, machine)],
             })
         } else {
             txb.moveCall({
                 target:PROTOCOL.MachineFn('repository_remove_with_passport') as FnCallType,
-                arguments:[passport, machine, txb.pure(repositories, 'vector<address>'), permission],
+                arguments:[passport, TXB_OBJECT(txb, machine), txb.pure(repositories, 'vector<address>'), TXB_OBJECT(txb, permission)],
             })
         }   
     } else {
         if (removeall) {
             txb.moveCall({
                 target:PROTOCOL.MachineFn('repository_remove_all') as FnCallType,
-                arguments:[machine, permission],
+                arguments:[TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
             })
         } else {
             txb.moveCall({
                 target:PROTOCOL.MachineFn('repository_remove') as FnCallType,
-                arguments:[machine, txb.pure(repositories, 'vector<address>'), permission],
+                arguments:[TXB_OBJECT(txb, machine), txb.pure(repositories, 'vector<address>'), TXB_OBJECT(txb, permission)],
             })
         }   
-    }     
+    }   
+    return true  
 }
 
-export function machine_clone(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : MachineObject {
+export function machine_clone(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : MachineObject | boolean {
+    if (!IsValidObjects([machine, permission])) return false;
     if (passport) {
         return txb.moveCall({
             target:PROTOCOL.MachineFn('clone_with_passport') as FnCallType,
-            arguments:[passport, machine, permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })
     } else {
         return txb.moveCall({
             target:PROTOCOL.MachineFn('clone') as FnCallType,
-            arguments:[machine, permission],
+            arguments:[TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })
     }
 }
-export function machine_set_endpoint(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, endpoint_url?:string, passport?:PassportObject) {
-    if (endpoint_url && endpoint_url.length > MAX_ENDPOINT_LENGTH) return undefined;
-    let endpoint = endpoint_url? txb.pure(BCS_CONVERT.ser_option_string(endpoint_url)) : txb.pure([], BCS.U8);
+export function machine_set_endpoint(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    endpoint?:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
+    if (endpoint && !IsValidEndpoint(endpoint)) return false;
+    let ep = endpoint? txb.pure(BCS_CONVERT.ser_option_string(endpoint)) : OptionNone(txb);
 
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('endpoint_set_with_passport') as FnCallType,
-            arguments:[passport, machine, endpoint, permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), ep, TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('endpoint_set') as FnCallType,
-            arguments:[machine, endpoint, permission],
+            arguments:[TXB_OBJECT(txb, machine), ep, TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
-export function machine_pause(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, bPaused:boolean, passport?:PassportObject) {
+export function machine_pause(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, bPaused:boolean, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('pause_with_passport') as FnCallType,
-            arguments:[passport, machine, txb.pure(bPaused), permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), txb.pure(bPaused), TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('pause') as FnCallType,
-            arguments:[machine, txb.pure(bPaused), permission],
+            arguments:[TXB_OBJECT(txb, machine), txb.pure(bPaused), TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
-export function machine_publish(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) {
+export function machine_publish(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('publish_with_passport') as FnCallType,
-            arguments:[passport, machine, permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('publish') as FnCallType,
-            arguments:[machine, permission],
+            arguments:[TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
 
-export function change_permission(txb:TransactionBlock, machine:MachineObject, old_permission:PermissionObject, new_permission:PermissionObject) {
+export function change_permission(txb:TransactionBlock, machine:MachineObject, old_permission:PermissionObject, new_permission:PermissionObject) : boolean {
+    if (!IsValidObjects([machine, old_permission, new_permission])) return false;
     txb.moveCall({
         target:PROTOCOL.MachineFn('permission_set') as FnCallType,
-        arguments: [machine, old_permission, new_permission],
+        arguments: [TXB_OBJECT(txb, machine), TXB_OBJECT(txb, old_permission), TXB_OBJECT(txb, new_permission)],
         typeArguments:[]            
     })    
+    return true
 }

package/src/passport.ts

@@ -1,10 +1,10 @@
 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} 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 = 4;
+export const MAX_GUARD_COUNT = 8;
 
 // passport verify for some guards, MUST be in ONE pxb:
 // 0. construct Guard_Query_Objects(passport_quries) from queries for guards of objects
@@ -15,44 +15,60 @@ export const MAX_GUARD_COUNT = 4;
 // 5. ops using passport(guard set on object)
 // 6. destroy passport
 
-export type PassportObject = TransactionResult;
 
-export const passport_quries = async (guards:string[]) : Promise<Guard_Query_Object[]> => {
+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 | undefined {
-    if (passport_queries.length == 0 || passport_queries.length > MAX_GUARD_COUNT) {
-        return undefined;
+
+// 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])]
         });
     }
 
@@ -76,28 +92,29 @@ export function verify(txb:TransactionBlock, passport_queries:Guard_Query_Object
     return passport;
 }
 
-export function destroy(txb:TransactionBlock, passport:PassportObject) {
+export function destroy(txb:TransactionBlock, passport:PassportObject) : boolean {
     txb.moveCall({
         target: PROTOCOL.PassportFn('destroy') as FnCallType,
         arguments: [ passport ]
     });  
+    return true
 }
 
 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
 }