wowok 1.1.1 → 1.1.3

package/src/index.ts

@@ -10,3 +10,4 @@ export * from './protocol'
 export * from './passport'
 export * from './machine'
 export * from './service'
+export * from './graphql'

package/src/machine.ts

@@ -9,19 +9,19 @@ import { Errors, ERROR}  from './exception'
 
 export type MachineNodeObject = TransactionResult | String;
 
-export type Machine_Forward = {
+export interface Machine_Forward {
     name: string; // foward name
     namedOperator?: string; // dynamic operator
     permission?: PermissionIndexType; // this.permission-index or named-operator MUST one defined.
     weight?: number;
     guard?: GuardObject;
 }
-export type Machine_Node_Pair = {
+export interface Machine_Node_Pair {
     prior_node: string;
     forwards: Machine_Forward[];
     threshold?: number;
 }
-export type Machine_Node = {
+export interface Machine_Node {
     name: string;
     description: string;
     pairs: Machine_Node_Pair[];

package/src/passport.ts

@@ -1,11 +1,8 @@
-import { SuiObjectResponse, SuiObjectDataOptions } from '@mysten/sui.js/client';
-import { TransactionBlock, type TransactionObjectInput, Inputs } from '@mysten/sui.js/transactions';
-import { FnCallType, Query_Param, PassportObject, GuardObject, Protocol, ContextType, OperatorType, Data_Type,
-    ValueType, MODULES,
-} from './protocol';
-import { parse_object_type, array_unique, Bcs, ulebDecode } from './utils';
-import { VariableType, Guard, Guard_Vriable} from './guard';
-import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig, TypeName, StructTypeDefinition } from '@mysten/bcs';
+import { type TransactionObjectInput, Inputs } from '@mysten/sui.js/transactions';
+import { FnCallType, GuardObject, Protocol, ContextType, OperatorType, Data_Type,
+    ValueType, MODULES } from './protocol';
+import { parse_object_type, array_unique, Bcs, ulebDecode, IsValidAddress, IsValidArray } from './utils';
+import { BCS } from '@mysten/bcs';
 import { ERROR, Errors } from './exception';
 
 export type Guard_Query_Object = {
@@ -15,291 +12,234 @@ export type Guard_Query_Object = {
     id: string, // object id
 }
 
-export type GUARD_QUERIES_TYPE = {
-    module:MODULES, 
-    name:string, 
-    cmd:number, 
-    params:Data_Type[], 
-    result:Data_Type
-};
-
-// de sense bsc => FutureValueRequest
-export type FutureValueRequest = {
-    guardid: string;
-    identifier: number;
-    type: ContextType | OperatorType,
-    witness: string,
-    value: string, // future object address
+interface QueryInfo {
+    identifier?: number;
+    index:  number;
+    type: number;
+    value_or_witness: string;
+    future?: string;
+}
+interface GuardInfo {
+    id: string;
+    query_list: (string | QueryInfo)[]; // object or witness object query
+    variable: QueryInfo[]; // witness in variable & ValueType.TYPE_ADDRESS(for Query)
+    input_witness: QueryInfo[]; // witness in input
 }
 
+interface FutrueFill {
+    guard: string;
+    index: number;
+    future: string;
+}
+interface PassportQuery {
+    guard: GuardObject[];
+    query: Guard_Query_Object[];
+    witness: Guard_Query_Object[];
+}
 export class GuardParser {
-    // from guards: get objects to fill FUTURE value by singer 
-    static guard_futures = async (protocol:Protocol, guards:string[]) : Promise<FutureValueRequest[]> => {
-        let futrue_objects = guards.map((value) => {
-            return {objectid:value, callback:GuardParser.rpc_sense_objects_fn, parser:GuardParser.parse_futures, data:[]} as Query_Param
-        });
-        await protocol.Query(futrue_objects); // future objects
-        let future_objects_result:FutureValueRequest[] = [];
-        futrue_objects.forEach((futrue) => { 
-            futrue.data.forEach((f:FutureValueRequest) => {
-                if (future_objects_result.findIndex((v)=>{ return v.guardid == f.guardid && v.identifier == f.identifier}) ==  -1) {
-                    future_objects_result.push(f);
-                }
-            }) ;
-        });
+    protected guard_list: GuardInfo[] = [];
+    protected protocol: Protocol;
+    protected guards: GuardObject[];
+    private index:number = 0;
+    private get_index() { return this.index++ }
 
-        return future_objects_result
+    private constructor(protocol: Protocol, guards: string[]) { 
+        this.protocol = protocol ;
+        this.guards = guards.map(g => protocol.CurrentSession().object(g) as GuardObject);
     }
+    guardlist = () => { return this.guard_list }
 
-    // parse  guard futures into result, WITH future variable READY.
-    static parse_futures(result:FutureValueRequest[], guardid: string, chain_sense_bsc:Uint8Array, variable?:VariableType) : boolean {
-        var arr = [].slice.call(chain_sense_bsc.reverse());
-        while (arr.length > 0) {
-            var type : unknown = arr.shift() ;
-            // console.log(type);
-            switch (type as Data_Type) { 
-                case ContextType.TYPE_CONTEXT_SIGNER:
-                case ContextType.TYPE_CONTEXT_CLOCK:
-                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:
-                case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
-                break;    
-            case ContextType.TYPE_CONTEXT_FUTURE_ID: // MACHINE-ID
-            case OperatorType.TYPE_FUTURE_QUERY:
-                var identifer = arr.splice(0, 1);  
-                if (type == OperatorType.TYPE_FUTURE_QUERY) {
-                    arr.splice(0, 1); // cmd
-                }
-                if (!variable || variable?.get(identifer[0])?.type != type) return false;
-                
-                let witness = Guard.get_variable_witness(variable, identifer[0], type as OperatorType) ;
-                if (!witness)  return false;
-                result.push({guardid:guardid, identifier:identifer[0], type:type, value:'',
-                    witness:'0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(witness as Uint8Array))} as FutureValueRequest);
-                break;
-            case ContextType.TYPE_CONTEXT_address:
-            case ContextType.TYPE_CONTEXT_bool:
-            case ContextType.TYPE_CONTEXT_u8:
-            case ContextType.TYPE_CONTEXT_u64:
-            case ContextType.TYPE_CONTEXT_vec_u8:
-            case ValueType.TYPE_STATIC_bool:
-            case ValueType.TYPE_STATIC_u8:
-                arr.splice(0, 1); // identifier
-                break;
-            case OperatorType.TYPE_QUERY_FROM_CONTEXT: 
-                arr.splice(0, 2); // identifer + cmd
-                break;
-            case ValueType.TYPE_STATIC_address: 
-                arr.splice(0, 32);
-                break;
-            case ValueType.TYPE_STATIC_u64: 
-                arr.splice(0, 8);
-                break;
-            case ValueType.TYPE_STATIC_u128: 
-                arr.splice(0, 16);
-                break;
-            case ValueType.TYPE_STATIC_vec_u8:
-                let {value, length} = ulebDecode(Uint8Array.from(arr));
-                arr.splice(0, value+length);
-                break;     
-            case OperatorType.TYPE_QUERY:
-                arr.splice(0, 33); // address + cmd
-                break;
-            default:
-                console.error('parse_sense_bsc:undefined');
-                console.log(type as number)
-                console.log(arr)
-                return false; // error
-            }
-        } 
-        return true;
-    }
-
-    // from guards: get objects to 'guard_query' on chain , with future variables had filled.
-    // passport verify for some guards, MUST be in ONE pxb:
-    // 0. construct Guard_Query_Objects(passport_quries) from queries for guards of objects
-    // 1. create passport
-    // 2. add all guards / guards future variables
-    // 3. verify passport
-    // 4. ops using passport(guard set on object)
-    // 5. ops using passport(guard set on object)
-    // 6. destroy passport
-    static guard_queries = async (protocol:Protocol, guards:string[], futures?:FutureValueRequest[]) : Promise<Guard_Query_Object[]> => {
-        let sense_objects = guards.map((value) => {
-            let v:VariableType = new Map();
-            futures?.forEach((f) => {
-                if (f.guardid == value) {   
-                    Guard.add_future_variable(v, f.identifier, f.type, f.witness.slice(0), f?.value?f.value.slice(0):undefined, true);
-                } 
-            })
-            return {objectid:value, callback:GuardParser.rpc_sense_objects_fn, parser:GuardParser.parse_sense_bsc, data:[], variables:futures?v:undefined} as Query_Param
-        });
+    static CreateAsync = async (protocol: Protocol, guards: string[]) => {
+        if (!IsValidArray(guards, IsValidAddress)) {
+            ERROR(Errors.IsValidArray, 'guards');
+        }
 
-        await protocol.Query(sense_objects); // objects need quering in guards
-        let sense_objects_result:string[] = [];
-        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); // objects in guards
+        let guard_list = array_unique(guards);
+        const me = new GuardParser(protocol, guards);
         
-        let queries = sense_objects_result.map((value) => { 
-            return {objectid:value, callback:GuardParser.rpc_query_cmd_fn, data:[]} as Query_Param;
+        let res =  await protocol.Query_Raw(guard_list);
+        res.forEach((r) => {
+            let c = r.data?.content as any;
+            if (!c) return;
+
+            let index = protocol.WOWOK_OBJECTS_TYPE().findIndex(v => {return v.includes('guard::Guard') && v == c.type});
+            if (index == -1) return;
+
+            let info:GuardInfo = {id: c.fields.id.id, query_list:[],  variable:[], input_witness:[]};
+            me.parse_variable(info,  c.fields.variables);
+            if (c.fields.input.type == (protocol.Package() + '::bcs::BCS')) {
+                me.parse_bcs(info,  Uint8Array.from(c.fields.input.fields.bytes));
+            }
+            me.guard_list.push(info);
         })
+        return me
+    }
 
-        await protocol.Query(queries, {'showType':true}); // queries for passport verifing
-        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 
+    parse_variable = (info:GuardInfo, variables:any)  => {
+        variables.forEach((v:any) => {
+            if (v.type == (this.protocol.Package() + '::guard::Variable')) {
+                // ValueType.TYPE_ADDRESS: Query_Cmd maybe used the address, so save it for using
+                if (v.fields.type == ContextType.TYPE_WITNESS_ID || v.fields.type == ValueType.TYPE_ADDRESS) {
+                    info.variable.push({identifier:v.fields.identifier,  index:this.get_index(), type:v.fields.type,
+                        value_or_witness:'0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(v.fields.value))});
                 }
-                return data[0].data          
-            }))
-        })
-        return res;
+            }
+        });
     }
 
-    // parse guard senses input bytes of a guard, return [objectids] for 'query_cmd' 
-    static parse_sense_bsc(result:string[], guardid: string, chain_sense_bsc:Uint8Array, variable?:VariableType)  : boolean {
-        var arr = [].slice.call(chain_sense_bsc.reverse());
-    
+    parse_bcs = (info:GuardInfo, chain_bytes: Uint8Array) => {
+        var arr = [].slice.call(chain_bytes.reverse());
         while (arr.length > 0) {
             var type : unknown = arr.shift() ;
             // console.log(type);
             switch (type as Data_Type) { 
-                case ContextType.TYPE_CONTEXT_SIGNER:
-                case ContextType.TYPE_CONTEXT_CLOCK:
-                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:
+                case ContextType.TYPE_SIGNER:
+                case ContextType.TYPE_CLOCK:
+                case OperatorType.TYPE_LOGIC_AS_U256_GREATER:
+                case OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL:
+                case OperatorType.TYPE_LOGIC_AS_U256_LESSER:
+                case OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL:
+                case OperatorType.TYPE_LOGIC_AS_U256_EQUAL:
+                case OperatorType.TYPE_LOGIC_EQUAL:
+                case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
                 case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
+                case OperatorType.TYPE_LOGIC_NOT:
+                case OperatorType.TYPE_LOGIC_AND:
+                case OperatorType.TYPE_LOGIC_OR:
                 break;    
-            case ContextType.TYPE_CONTEXT_FUTURE_ID: // MACHINE-ID
-                var v = arr.splice(0, 1);
-                if (!variable || variable?.get(v[0])?.type != type) return false;
+            case ContextType.TYPE_VARIABLE:
+                arr.splice(0, 1); // identifier of variable
+                break;
+            case ContextType.TYPE_WITNESS_ID:  // add to variable 
+                let addr = '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(arr)).toString();
+                arr.splice(0, 32); // address     
+                info.input_witness.push({index:this.get_index(), type:ContextType.TYPE_WITNESS_ID, value_or_witness:addr})
                 break;
-            case ContextType.TYPE_CONTEXT_address:
-            case ContextType.TYPE_CONTEXT_bool:
-            case ContextType.TYPE_CONTEXT_u8:
-            case ContextType.TYPE_CONTEXT_u64:
-            case ContextType.TYPE_CONTEXT_vec_u8:
+            case ValueType.TYPE_BOOL:
+            case ValueType.TYPE_U8:
                 arr.splice(0, 1); // identifier
                 break;
-            case ValueType.TYPE_STATIC_address: 
-                //console.log('0x' + bcs.de(BCS.ADDRESS,  Uint8Array.from(array)).toString());
+            case ValueType.TYPE_ADDRESS: 
                 arr.splice(0, 32);
                 break;
-            case ValueType.TYPE_STATIC_bool:
-            case ValueType.TYPE_STATIC_u8:
-                arr.splice(0, 1);
-                break;
-            case ValueType.TYPE_STATIC_u64: 
+            case ValueType.TYPE_U64: 
                 arr.splice(0, 8);
                 break;
-            case ValueType.TYPE_STATIC_u128: 
+            case ValueType.TYPE_U128: 
                 arr.splice(0, 16);
                 break;
-            case ValueType.TYPE_STATIC_vec_u8:
+            case ValueType.TYPE_U256:
+                arr.splice(0, 32);
+                break;
+            case ValueType.TYPE_VEC_U8:
                 let {value, length} = ulebDecode(Uint8Array.from(arr));
                 arr.splice(0, value+length);
                 break;     
             case OperatorType.TYPE_QUERY:
-                result.push('0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(arr)).toString());
-                arr.splice(0, 33); // address + cmd
-                break;
-            case OperatorType.TYPE_QUERY_FROM_CONTEXT: 
-            case OperatorType.TYPE_FUTURE_QUERY: 
-                var identifer = arr.splice(0, 1);
-                if (variable) {
-                    let v = Guard.get_variable_value(variable, identifer[0], type as OperatorType) ;
-                    if (v)  {
-                        result.push('0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(v as Uint8Array)).toString());
-                        arr.splice(0, 1); // splice cmd  
-                        break;
+                let type = arr.splice(0, 1);
+                if (type[0] == ValueType.TYPE_ADDRESS || type[0] == ContextType.TYPE_WITNESS_ID) {
+                    let addr = '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(arr)).toString();
+                    arr.splice(0, 33); // address + cmd              
+                    if (type[0] == ValueType.TYPE_ADDRESS) {
+                        info.query_list.push(addr);
+                    } else if (type[0] == ContextType.TYPE_WITNESS_ID){
+                        info.query_list.push({index:this.get_index(), type:type[0], value_or_witness:addr});
                     }
-                }; return false  
+                } else if (type[0] == ContextType.TYPE_VARIABLE) {
+                    let identifer = arr.splice(0, 2); // key + cmd
+                    let variable = info.variable.find((v) => 
+                        (v.identifier == identifer[0]) && 
+                        ((v.type == ValueType.TYPE_ADDRESS) || (v.type == ContextType.TYPE_WITNESS_ID)));
+                    if (!variable) { ERROR(Errors.Fail, 'indentifier not in  variable')}
+                    if (variable?.type == ValueType.TYPE_ADDRESS) {
+                        info.query_list.push(variable.value_or_witness);
+                    } else if (variable?.type == ContextType.TYPE_WITNESS_ID) {
+                        info.query_list.push({identifier:identifer[0], type:variable.type, value_or_witness:variable.value_or_witness, index:this.get_index()});
+                    } 
+                } else {
+                    ERROR(Errors.Fail, 'variable type invalid');
+                }
+
+                break;
             default:
-                console.error('parse_sense_bsc:undefined');
-                console.log(type as number)
-                console.log(arr)
-                return false; // error
+                ERROR(Errors.Fail, 'parse_bcs types')
             }
         } 
-        return true;
     }
 
+    private get_object(guardid:string, info:QueryInfo, fill?:FutrueFill[]) :  string  {
+        let r = fill?.find(i => guardid == i.guard && i.index == info.index);
+        if (!r || !r.future) {
+            if (!info.future) {
+                ERROR(Errors.InvalidParam, 'index invalid for fill') 
+            }
+        } else {
+            info.future = r!.future;
+        }
+        return info.future!
+    }
 
-    // callback  to  parse guard's object-queries into Guard_Query_Object[]
-    static rpc_sense_objects_fn = (protocol:Protocol, response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
-        if (!response.error) {
-            let c = response?.data?.content as any;
-            let index = protocol.WOWOK_OBJECTS_TYPE().findIndex(v => v.includes('guard::Guard') && v == c.type);
-            if (index >= 0 && c.fields.id.id == param.objectid) { // GUARD OBJECT
-                if (!param?.variables)  {
-                    let v =  new Map<number, Guard_Vriable>();
-                    for (let i = 0; i < c.fields.variables.length; i ++) {
-                        let variable = c.fields.variables[i]; let bret ;
-                        if (variable.type == (protocol.WOWOK_OBJECTS_PREFIX_TYPE()[index] + 'Variable')) { // ...::guard::Variable
-                            if (variable.fields.type == OperatorType.TYPE_FUTURE_QUERY || variable.fields.type == ContextType.TYPE_CONTEXT_FUTURE_ID) {
-                                bret = Guard.add_future_variable(v, variable.fields.identifier, variable.fields.type, 
-                                    variable.fields?.value?Uint8Array.from(variable.fields.value):undefined, undefined, false);
-                            } else {
-                                bret = Guard.add_variable(v, variable.fields.identifier, variable.fields.type, 
-                                    variable.fields?.value?Uint8Array.from(variable.fields.value):undefined, false);
-                            }
-                            if (!bret) {
-                                console.log('rpc_sense_objects_fn add_variable error');
-                                console.log(variable);
-                                return ;       
-                            }
-                        }                         
-                    }
-                    param.variables = v;
+    done = async (fill?:FutrueFill[]) : Promise<PassportQuery>=> {
+        let objects: string[] = [];
+        this.guard_list.forEach((g) => {
+            g.variable.filter(v => v.type == ContextType.TYPE_WITNESS_ID).forEach((q) => {
+                objects.push(this.get_object(g.id, q, fill));
+            })
+            let list = g.query_list.map((q) => {
+                if (typeof(q) === "string") {
+                    objects.push(q)
+                    return q
+                } else {
+                    let r = this.get_object(g.id, q, fill);
+                    objects.push(r);
+                    return r
                 }
-                
-                for (let i = 0; i < c.fields.senses.length; i ++) {
-                    let sense = c.fields.senses[i];
-                    if (sense.type == (protocol.WOWOK_OBJECTS_PREFIX_TYPE()[index] + 'Sense')) { // ...::guard::Sense    
-                        let result : any[] = [];
-                        if (param?.parser && param.parser(result, param.objectid, Uint8Array.from(sense.fields.input.fields.bytes), param.variables)) {
-                            param.data = param.data.concat(result);      // DONT array_unique senses                  
-                        }       
-                    }                         
+            })
+            g.query_list =  list;
+            g.input_witness.forEach((q) => {
+                objects.push(this.get_object(g.id, q, fill));
+            })
+        })
+
+        // objects info
+        let res = await  this.protocol.Query_Raw(array_unique(objects), {showType:true});
+        let query: Guard_Query_Object[] = [];
+        let witness: Guard_Query_Object[] = [];
+        this.guard_list.forEach(g => {
+            g.query_list.forEach(q => {
+                let r = res.find(r => r.data?.objectId == q as string);  
+                if (!r)   { ERROR(Errors.Fail, 'query object not match')} 
+                let object = this.object_query(r!.data);
+                if (!object) { ERROR(Errors.Fail, 'query object fail')} 
+                query.push(object!);
+            })
+            res.forEach(q => {
+                let r1 = g.variable.find(v  => v.future == q.data?.objectId);
+                let r2 = g.input_witness.find(v  => v.future == q.data?.objectId)
+                // not match r1 || r2 means query-cmd, not witness-cmd
+                if (r1 || r2) {
+                    let object = this.object_query(q.data, 'witness');
+                    if (!object)  { ERROR(Errors.Fail, 'witness object fail') }
+                    witness.push(object!);
                 }
-            } 
-        }
+            })
+        })
+
+        return {guard:this.guards, query:query,  witness:witness} as PassportQuery;
     }
 
-    // construct Guard_Query_Object of wowok objects for passport verify
-    static rpc_query_cmd_fn = (protocol:Protocol, response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
-        if (!response.error && response.data?.objectId == param.objectid && response.data?.type) {
-            for (let k = 0; k < protocol.WOWOK_OBJECTS_TYPE().length; k++) {
-                if (response?.data?.type.includes(protocol.WOWOK_OBJECTS_TYPE()[k]) ) { // type: pack::m::Object<...>
-                    param.data = { target:protocol.WOWOK_OBJECTS_PREFIX_TYPE()[k] + 'guard_query' as FnCallType,
-                        object:Inputs.SharedObjectRef({
-                            objectId: response.data.objectId,
-                            mutable: false,
-                            initialSharedVersion: response.data!.version,
-                        }) as TransactionObjectInput,
-                        types:parse_object_type(response?.data?.type as string),
-                        id: param.objectid,
-                    } as Guard_Query_Object;
-                }
+    private object_query = (data: any, method:string='guard_query') : Guard_Query_Object | undefined=> {
+        for (let k = 0; k < this.protocol.WOWOK_OBJECTS_TYPE().length; k++) {
+            if (data.type.includes(this.protocol.WOWOK_OBJECTS_TYPE()[k]) ) { // type: pack::m::Object<...>
+                return  { target:this.protocol.WOWOK_OBJECTS_PREFIX_TYPE()[k] + method as FnCallType,
+                    object:Inputs.SharedObjectRef({
+                        objectId: data.objectId,
+                        mutable: false,
+                        initialSharedVersion: data.version,
+                    }) as TransactionObjectInput,
+                    types:parse_object_type(data.type as string),
+                    id: data.objectId,
+                } as Guard_Query_Object;
             }
         }
     }
@@ -312,11 +252,11 @@ export class Passport {
 
     get_object () { return this.passport }
     // return passport object used
-    constructor (protocol:Protocol, guards:GuardObject[], guard_queries:Guard_Query_Object[], future_values?:FutureValueRequest[])  {
-        if (!guards || guards.length > Passport.MAX_GUARD_COUNT)   {
+    constructor (protocol:Protocol, query:PassportQuery)  {
+        if (!query.guard || query.guard.length > Passport.MAX_GUARD_COUNT)   {
             ERROR(Errors.InvalidParam, 'guards' )
         }
-        if (!Protocol.IsValidObjects(guards)) {
+        if (!Protocol.IsValidObjects(query.guard)) {
             ERROR(Errors.IsValidObjects, 'guards')
         }
 
@@ -328,48 +268,35 @@ export class Passport {
         });
 
         // add others guards, if any
-        guards.forEach((guard) => {
+        query.guard.forEach((g) => {
             txb.moveCall({
                 target:protocol.PassportFn('guard_add') as FnCallType,
-                arguments:[this.passport, Protocol.TXB_OBJECT(txb, guard)]
+                arguments:[this.passport, Protocol.TXB_OBJECT(txb, g)]
             });        
         })
-    
-        type futureResultItem = {
-            identifier:number[],
-            real_address: string[],
-        }
-        
-        let result = new Map<string, futureResultItem>();
-        future_values?.forEach((v) => {
-            if (result.has(v.guardid)) {
-                result.get(v.guardid)?.identifier.push(v.identifier);
-                result.get(v.guardid)?.real_address.push(v.value!);
-            } else {
-                result.set(v.guardid, {identifier:[v.identifier], real_address:[v.value!]})
-            }
-        })
-        
-        result.forEach((v, k) => {
+
+        // witness
+        query?.witness.forEach((w) => {
             txb.moveCall({
-                target:protocol.PassportFn('futures_set') as FnCallType,
-                arguments:[this.passport, txb.pure(Bcs.getInstance().ser_address(k)), txb.pure(Bcs.getInstance().ser_vector_u8(v.identifier)), 
-                    txb.pure(v.real_address, 'vector<address>')]
+                target: w.target as FnCallType,
+                arguments: [this.passport, txb.object(w.object)],
+                typeArguments: w.types,
             })
         })
 
         // rules: 'verify' & 'query' in turns；'verify' at final end.
-        for (let i = 0; i < guard_queries.length; i++) {
-            let res = txb.moveCall({
+        query?.query.forEach((q) => {
+            let address = txb.moveCall({
                 target: protocol.PassportFn('passport_verify') as FnCallType,
-                arguments: [ this.passport, txb.object(Protocol.CLOCK_OBJECT),  ]
+                arguments: [ this.passport, txb.object(Protocol.CLOCK_OBJECT)]
             }); 
             txb.moveCall({
-                target: guard_queries[i].target as FnCallType,
-                arguments: [ txb.object(guard_queries[i].object), this.passport, res ],
-                typeArguments: guard_queries[i].types,
+                target: q.target as FnCallType,
+                arguments: [ txb.object(q.object), this.passport, address ],
+                typeArguments: q.types,
             })
-        }  
+        })
+        
         txb.moveCall({
             target: protocol.PassportFn('passport_verify') as FnCallType,
             arguments: [ this.passport,  txb.object(Protocol.CLOCK_OBJECT) ]

package/src/permission.ts

@@ -11,6 +11,9 @@ export enum PermissionIndex {
     repository_remove_policies = 104,
     repository_set_policy_description = 105,
     repository_set_policy_permission = 106,
+    repository_reference_add = 107,
+    repository_reference_remove = 108,
+    repository_reference_removeall = 108,
     vote = 150,
     vote_set_description = 151,
     vote_set_reference = 152,