wowok 1.0.7 → 1.0.8

package/src/guard.ts

@@ -2,9 +2,11 @@ import { SuiObjectResponse, SuiObjectDataOptions, SuiParsedData } from '@mysten/
 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, ContextType, OBJECTS_TYPE, 
-    OBJECTS_TYPE_PREFIX, Query_Param, IsValidDesription, ValueType,  OperatorType} from './protocol';
+    OBJECTS_TYPE_PREFIX, Query_Param, IsValidDesription, ValueType,  OperatorType,
+    IsValidInt,
+    IsValidAddress} from './protocol';
 import { concatenate, array_equal, ulebDecode, array_unique } from './utils';
-import { stringToUint8Array } from './utils';
+import { stringToUint8Array, BCS_CONVERT } from './utils';
 
 
 export const MAX_SENSE_COUNT = 16;
@@ -19,19 +21,145 @@ export type Guard_Sense = {
     notAfterSense: boolean; 
     binder:Guard_Sense_Binder ;
 };
+export type VariableType = Map<number, Guard_Vriable>;
 
+export type Guard_Vriable = {
+    type: ContextType | OperatorType,
+    value?: Uint8Array,
+    witness?: Uint8Array,
+}
 export type Guard_Creation = {
     description: string;
+    variables?: VariableType;
     senses: Guard_Sense[];
 }
 
+// de sense bsc => FutureValueRequest
+export type FutureValueRequest = {
+    guardid: string;
+    identifier: number;
+    type: ContextType | OperatorType,
+    witness: string,
+    value?: string, // future object address
+}
+
+
+export const IsValidGuardVirableType = (type:OperatorType | ContextType) : boolean => {
+    if (type == OperatorType.TYPE_FUTURE_QUERY || type == ContextType.TYPE_CONTEXT_FUTURE_ID || type == OperatorType.TYPE_QUERY_FROM_CONTEXT || 
+        type == ContextType.TYPE_CONTEXT_bool || type ==ContextType.TYPE_CONTEXT_address || type == ContextType.TYPE_CONTEXT_u64 || 
+        type == ContextType.TYPE_CONTEXT_u8 ||  type == ContextType.TYPE_CONTEXT_vec_u8) {
+        return true;
+    };
+    return false;
+}
+export const IsValidIndentifier = (identifier:number) : boolean => {
+    if (!IsValidInt(identifier) || identifier > 255) return false;
+    return true
+}
+/*
+// called by de-guard or passport
+export function set_futrue_value(variables:VariableType, identifier:number, type:OperatorType | ContextType, value?:any) : boolean {
+    if (!IsValidIndentifier(identifier)) return false;
+    if (!IsValidGuardVirableType(type)) return false;
+    let v = variables.get(identifier);
+    if (v) {
+        v.value = BCS_CONVERT.ser_address(value);     
+        return true;   
+    }
+    return false;
+} */
+export function get_variable_value(variables:VariableType, identifier:number, type:OperatorType | ContextType) : Uint8Array | boolean {
+    if (variables.has(identifier)) {
+        let v = variables.get(identifier);
+        if (v?.value && v.type == type) {
+            return v.value;
+        }
+    }  return false;
+}
+export function get_variable_witness(variables:VariableType, identifier:number, type:OperatorType | ContextType) : Uint8Array | boolean {
+    if (variables.has(identifier)) {
+        let v = variables.get(identifier);
+        if (v?.witness && v.type == type) {
+            return v.witness;
+        }
+    }  return false;
+}
+
+export function add_future_variable(variables:VariableType, identifier:number, type:OperatorType | ContextType, 
+    witness:any, value?:any, bNeedSerialize=true) : boolean {
+    if (!IsValidIndentifier(identifier)) return false;
+    if (!IsValidGuardVirableType(type)) return false;
+    if (!witness && !value) return false;
+
+    switch (type) {
+        case OperatorType.TYPE_FUTURE_QUERY : 
+        case ContextType.TYPE_CONTEXT_FUTURE_ID :
+            if (variables.has(identifier)) {
+                let v = (variables.get(identifier) as Guard_Vriable);
+                if (bNeedSerialize) {
+                    v.value = value ? BCS_CONVERT.ser_address(value) : undefined;
+                    v.witness = witness ? BCS_CONVERT.ser_address(witness) : undefined;
+                } else {
+                    v.value = value ? value : undefined; 
+                    v.witness = witness ? witness : undefined;                  
+                }
+            } else {
+                if (bNeedSerialize) {
+                    variables.set(identifier, {type:type, value:value ? BCS_CONVERT.ser_address(value) : undefined, witness:witness ? BCS_CONVERT.ser_address(witness) : undefined})
+                } else {
+                    variables.set(identifier, {type:type, value:value?value:undefined, witness:witness?witness:undefined});             
+                }                     
+            }
+            return true;
+    }
+    return false;
+}
+
+export function add_variable(variables:VariableType, identifier:number, type:OperatorType | ContextType, 
+    value:any, bNeedSerialize=true) : boolean {
+    if (!IsValidIndentifier(identifier)) return false;
+    if (!IsValidGuardVirableType(type)) return false;
+    if (!value) return false;
+
+    switch (type) {
+        case ContextType.TYPE_CONTEXT_bool:
+            bNeedSerialize ? variables.set(identifier, {type:type, value:BCS_CONVERT.ser_bool(value)}) :
+                variables.set(identifier,  {type:type, value:value})              
+            return true;   
+        case ContextType.TYPE_CONTEXT_address:
+        case OperatorType.TYPE_QUERY_FROM_CONTEXT:
+            bNeedSerialize ? variables.set(identifier, {type:type, value:BCS_CONVERT.ser_address(value)}):
+                variables.set(identifier,  {type:type, value:value});       
+            return true;   
+        case ContextType.TYPE_CONTEXT_u64:
+            bNeedSerialize ? variables.set(identifier, {type:type, value:BCS_CONVERT.ser_u64(value)}) :
+                variables.set(identifier,  {type:type, value:value})       
+            return true;  
+        case ContextType.TYPE_CONTEXT_u8:
+            bNeedSerialize ? variables.set(identifier, {type:type, value:BCS_CONVERT.ser_u8(value)}) :
+                variables.set(identifier,  {type:type, value:value})    
+            return true;  
+        case ContextType.TYPE_CONTEXT_vec_u8:
+            bNeedSerialize ? variables.set(identifier, {type:type, value:BCS_CONVERT.ser_string(value)}) :
+                variables.set(identifier,  {type:type, value:value})    
+            return true;  
+    }
+    return false;
+}
+
 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 || v.input.length == 0) bValid = false;
     })
+    creation?.variables?.forEach((v, k) => {
+        if (!IsValidIndentifier(k)) bValid = false;
+        if (!IsValidGuardVirableType(v.type)) bValid  = false;
+        if (!v.value && !v.witness) bValid =  false;
+    })
     if (!bValid) return false;
 
     let guard = txb.moveCall({
@@ -47,6 +175,23 @@ export function launch(txb:TransactionBlock, creation:Guard_Creation) : GuardAdd
             ]
         })
     });
+    creation?.variables?.forEach((v, k) => {
+        if (v.type == OperatorType.TYPE_FUTURE_QUERY || v.type == ContextType.TYPE_CONTEXT_FUTURE_ID) {
+            if (!v.witness) return false;
+            txb.moveCall({
+                target:PROTOCOL.GuardFn("variable_add") as FnCallType,
+                arguments:[guard, txb.pure(k, BCS.U8), txb.pure(v.type, BCS.U8), txb.pure([].slice.call(v.witness)), txb.pure(true, BCS.BOOL)]
+            })            
+        } else {
+            if (!v.value)   return false;
+
+            txb.moveCall({
+                target:PROTOCOL.GuardFn("variable_add") as FnCallType,
+                arguments:[guard, txb.pure(k, BCS.U8), txb.pure(v.type, BCS.U8), txb.pure([].slice.call(v.value)), txb.pure(true, BCS.BOOL)]
+            }) 
+        }
+    });
+
     return txb.moveCall({
         target:PROTOCOL.GuardFn("create") as FnCallType,
         arguments:[guard]
@@ -206,51 +351,80 @@ export const QUERIES:any = [
 export class SenseMaker {
     protected data : Uint8Array[] = [];
     protected type_validator : Data_Type[] = [];
-
     constructor() { }
+
     // serialize const & data
-    add_param(type:ValueType | ContextType, param?:any) : boolean {
-        const bcs = new BCS(getSuiMoveConfig());
+    add_param(type:ValueType | ContextType, param?:any, variable?:VariableType) : boolean {
         switch(type)  {
         case ValueType.TYPE_STATIC_address: 
-            this.data.push(bcs.ser(BCS.U8, type).toBytes());
-            this.data.push(bcs.ser(BCS.ADDRESS, param).toBytes());
+            if (!param) return false
+            this.data.push(BCS_CONVERT.ser_u8(type));
+            this.data.push(BCS_CONVERT.ser_address(param));
             this.type_validator.push(type);
             break;
         case ValueType.TYPE_STATIC_bool:
-            this.data.push(bcs.ser(BCS.U8, type).toBytes());
-            this.data.push(bcs.ser(BCS.BOOL, param).toBytes());
+            if (!param) return false
+            this.data.push(BCS_CONVERT.ser_u8(type));
+            this.data.push(BCS_CONVERT.ser_bool(param));
             this.type_validator.push(type);
             break;
         case ValueType.TYPE_STATIC_u8:
-            this.data.push(bcs.ser(BCS.U8, type).toBytes());
-            this.data.push(bcs.ser(BCS.U8, param).toBytes());
+            if (!param) return false
+            this.data.push(BCS_CONVERT.ser_u8(type));
+            this.data.push(BCS_CONVERT.ser_u8(param));
             this.type_validator.push(type);
             break;
         case ValueType.TYPE_STATIC_u64: 
-            this.data.push(bcs.ser(BCS.U8, type).toBytes());
-            this.data.push(bcs.ser(BCS.U64, param).toBytes());
+            if (!param) return false
+            this.data.push(BCS_CONVERT.ser_u8(type));
+            this.data.push(BCS_CONVERT.ser_u64(param));
             this.type_validator.push(type);
             break;
         case ValueType.TYPE_STATIC_vec_u8:
-            this.data.push(bcs.ser(BCS.U8, type).toBytes());
-            this.data.push(bcs.ser(BCS.STRING, param).toBytes());
+            if (!param) return false
+            this.data.push(BCS_CONVERT.ser_u8(type));
+            this.data.push(BCS_CONVERT.ser_string(param));
             this.type_validator.push(type);
             // this.data[this.data.length-1].forEach((item : number) => console.log(item))
             break;
         case ContextType.TYPE_CONTEXT_SIGNER:
-            this.data.push(bcs.ser(BCS.U8, type).toBytes());
+            this.data.push(BCS_CONVERT.ser_u8(type));
             this.type_validator.push(ValueType.TYPE_STATIC_address);
             break;
         case ContextType.TYPE_CONTEXT_CLOCK:
-            this.data.push(bcs.ser(BCS.U8, type).toBytes());
+            this.data.push(BCS_CONVERT.ser_u8(type));
             this.type_validator.push(ValueType.TYPE_STATIC_u64);
             break;
+        case ContextType.TYPE_CONTEXT_bool:
+        case ContextType.TYPE_CONTEXT_u8:
+        case ContextType.TYPE_CONTEXT_u64:
+        case ContextType.TYPE_CONTEXT_vec_u8:
+        case ContextType.TYPE_CONTEXT_address:
         case ContextType.TYPE_CONTEXT_FUTURE_ID:
-            this.data.push(bcs.ser(BCS.U8, type).toBytes());
-            this.data.push(bcs.ser(BCS.ADDRESS, param).toBytes());
-            this.type_validator.push(ValueType.TYPE_STATIC_address);
-            break;
+            if (!variable || !param) return false;
+            if (typeof(param) != 'number') return false;
+            if (!IsValidInt(param) || param > 255) return false;
+            
+            var v = variable.get(param);
+            if (v?.type == type) {
+                this.data.push(BCS_CONVERT.ser_u8(type));
+                this.data.push(BCS_CONVERT.ser_u8(param));
+                if (type == ContextType.TYPE_CONTEXT_bool) {
+                    this.type_validator.push(ValueType.TYPE_STATIC_bool);                    
+                } else if (type == ContextType.TYPE_CONTEXT_u8) {
+                    this.type_validator.push(ValueType.TYPE_STATIC_u8);
+                } else if (type == ContextType.TYPE_CONTEXT_u64) {
+                    this.type_validator.push(ValueType.TYPE_STATIC_u64);
+                } else if (type == ContextType.TYPE_CONTEXT_vec_u8) {
+                    this.type_validator.push(ValueType.TYPE_STATIC_vec_u8);
+                } else if (type == ContextType.TYPE_CONTEXT_address) {
+                    this.type_validator.push(ValueType.TYPE_STATIC_address);
+                } else if (type == ContextType.TYPE_CONTEXT_FUTURE_ID) {
+                    this.type_validator.push(ValueType.TYPE_STATIC_address);
+                }
+                break;
+            }; 
+            return false;
         default:
             return false;
         };
@@ -265,14 +439,41 @@ export class SenseMaker {
         }
         return -1;
     }
-    // query_index: index(from 0) of array QUERIES 
-    // TYPE_FUTURE_ORDER_DYNAMIC_QUERY: object_address: service/machine id;  module:order/progress 
-    add_query(type:OperatorType, object_address:string, module:MODULES, query_name:string) : boolean {
+    add_future_query(identifier:number, module:MODULES, query_name:string, variable:VariableType) : boolean {
         let query_index = this.query_index(module, query_name);
-        if (!object_address || query_index == -1) { return false; }
-        // if future type , object_address must be SERVICE OR MACHINE address
-        if (type == OperatorType.TYPE_FUTURE_ORDER_DYNAMIC_QUERY && module != MODULES.order) return false;
-        if (type == OperatorType.TYPE_FUTURE_PROGRESS_DYNAMIC_QUERY && module != MODULES.progress) return false;
+        if (!IsValidIndentifier(identifier) || query_index == -1)  return false;  
+        if (module != MODULES.order && module != MODULES.progress)    return false;
+        if (!variable  || variable.get(identifier)?.type != OperatorType.TYPE_FUTURE_QUERY) 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, QUERIES[query_index][3])) { // type validate 
+            return false; 
+        }
+
+        this.data.push(BCS_CONVERT.ser_u8(OperatorType.TYPE_FUTURE_QUERY)); // TYPE
+        this.data.push(BCS_CONVERT.ser_u8(identifier)); // variable identifier
+        this.data.push(BCS_CONVERT.ser_u8(QUERIES[query_index][2])); // cmd
+
+        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;
+    }
+
+    // object_address_from: string for static address; number as identifier  for variable
+    add_query(module:MODULES, query_name:string, object_address_from:string | number) : boolean {
+        let query_index = this.query_index(module, query_name); // query_index: index(from 0) of array QUERIES 
+        if (query_index == -1)  return false; 
+        if (typeof(object_address_from) == 'number') {
+            if (!IsValidIndentifier(object_address_from)) return false;
+        } else {
+            if (!IsValidAddress(object_address_from)) return false;
+        }
 
         let offset = this.type_validator.length - QUERIES[query_index][3].length;
         if (offset < 0) { 
@@ -284,16 +485,22 @@ export class SenseMaker {
             return false; 
         }
         
-        const bcs = new BCS(getSuiMoveConfig());
-        this.data.push(bcs.ser(BCS.U8, type).toBytes()); // TYPE
-        this.data.push(bcs.ser(BCS.ADDRESS, object_address).toBytes()); // object address
-        this.data.push(bcs.ser(BCS.U8, QUERIES[query_index][2]).toBytes()); // cmd
+        if (typeof(object_address_from) == 'string') {
+            this.data.push(BCS_CONVERT.ser_u8(OperatorType.TYPE_QUERY));// TYPE
+            this.data.push(BCS_CONVERT.ser_address(object_address_from)); // object address            
+        } else {
+            this.data.push(BCS_CONVERT.ser_u8(OperatorType.TYPE_QUERY_FROM_CONTEXT));// TYPE
+            this.data.push(BCS_CONVERT.ser_u8(object_address_from)); // object identifer in variables
+        }
+
+        this.data.push(BCS_CONVERT.ser_u8(QUERIES[query_index][2])); // cmd
 
         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;
     }
+
     add_logic(type:OperatorType) : boolean {
         switch (type) {
             case OperatorType.TYPE_LOGIC_OPERATOR_U128_GREATER:
@@ -312,8 +519,7 @@ export class SenseMaker {
             default:
                 return false;
         }
-        const bcs = new BCS(getSuiMoveConfig());
-        this.data.push(bcs.ser(BCS.U8, type).toBytes()); // TYPE     
+        this.data.push(BCS_CONVERT.ser_u8(type)); // TYPE     
         this.type_validator.splice(this.type_validator.length - 2); // delete type stack   
         this.type_validator.push(ValueType.TYPE_STATIC_bool); // add bool to type stack
         return true;
@@ -323,7 +529,7 @@ export class SenseMaker {
         //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)
+            console.log(this.type_validator)
             return false;
         } // ERROR
 
@@ -342,22 +548,84 @@ function match_u128(type:number) : boolean {
     return false;
 }
 
-export function parse_graphql_senses(senses:any) : string[] {
+export function parse_graphql_senses(guardid:string, 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[]);
-        }
+        let res = parse_sense_bsc(objects,  guardid, Uint8Array.from(s.input.bytes));
     });
-    return array_unique(objects);
+    return objects;
+}
+
+export function parse_futures(result:any[], 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 = get_variable_witness(variable, identifer[0], type as OperatorType) ;
+            if (!witness)  return false;
+            result.push({guardid:guardid, identifier:identifer[0], type:type, 
+                witness:'0x' + BCS_CONVERT.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
+        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;
 }
 
 // parse guard senses input bytes of a guard, return [objectids] for 'query_cmd' 
-export function parse_sense_bsc(chain_sense_bsc:Uint8Array, future_order?:string[], future_progress?:string[])  : boolean | string[] {
+export function parse_sense_bsc(result:any[], guardid: string, chain_sense_bsc:Uint8Array, variable?:VariableType)  : boolean {
     var arr = [].slice.call(chain_sense_bsc.reverse());
-    const bcs = new BCS(getSuiMoveConfig());
-    var result = [];
 
     while (arr.length > 0) {
         var type : unknown = arr.shift() ;
@@ -375,7 +643,15 @@ export function parse_sense_bsc(chain_sense_bsc:Uint8Array, future_order?:string
             case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
             break;    
         case ContextType.TYPE_CONTEXT_FUTURE_ID: // MACHINE-ID
-            arr.splice(0, 32);
+            var v = arr.splice(0, 1);
+            if (!variable || variable?.get(v[0])?.type != type) return false;
+            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:
+            arr.splice(0, 1); // identifier
             break;
         case ValueType.TYPE_STATIC_address: 
             //console.log('0x' + bcs.de(BCS.ADDRESS,  Uint8Array.from(array)).toString());
@@ -395,28 +671,21 @@ export function parse_sense_bsc(chain_sense_bsc:Uint8Array, future_order?:string
             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(arr)).toString());
+        case OperatorType.TYPE_QUERY:
+            result.push('0x' + BCS_CONVERT.de(BCS.ADDRESS, Uint8Array.from(arr)).toString());
             arr.splice(0, 33); // address + cmd
             break;
-        case OperatorType.TYPE_FUTURE_PROGRESS_DYNAMIC_QUERY: // SERVICE-ID
-            if (!future_progress) {
-                console.error('OperatorType.TYPE_FUTURE_PROGRESS_DYNAMIC_QUERY need object');
-                console.log(arr)
-                return false; // error                
-            }
-            result.push(future_progress!.shift() as string) // real query object
-            arr.splice(0, 33)
-            break;
-        case OperatorType.TYPE_FUTURE_ORDER_DYNAMIC_QUERY: // 
-            if (!future_order) {
-                console.error('OperatorType.TYPE_FUTURE_ORDER_DYNAMIC_QUERY need object');
-                console.log(arr)
-                return false; // error                
-            }
-            result.push(future_order!.shift() as string)
-            arr.splice(0, 33)
-            break;
+        case OperatorType.TYPE_QUERY_FROM_CONTEXT: 
+        case OperatorType.TYPE_FUTURE_QUERY: 
+            var identifer = arr.splice(0, 1);
+            if (variable) {
+                let v = get_variable_value(variable, identifer[0], type as OperatorType) ;
+                if (v)  {
+                    result.push('0x' + BCS_CONVERT.de(BCS.ADDRESS, Uint8Array.from(v as Uint8Array)).toString());
+                    arr.splice(0, 1); // splice cmd  
+                    break;
+                }
+            }; return false  
         default:
             console.error('parse_sense_bsc:undefined');
             console.log(type as number)
@@ -424,7 +693,7 @@ export function parse_sense_bsc(chain_sense_bsc:Uint8Array, future_order?:string
             return false; // error
         }
     } 
-    return result;
+    return true;
 }
 
 export const rpc_description_fn = (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
@@ -440,18 +709,40 @@ export const rpc_description_fn = (response:SuiObjectResponse, param:Query_Param
     }
 }
 
+
 export const rpc_sense_objects_fn = (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions) => {
     if (!response.error) {
         let c = response?.data?.content as any;
         let index = 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 == (OBJECTS_TYPE_PREFIX()[index] + 'Variable')) { // ...::guard::Variable
+                        if (variable.fields.type == OperatorType.TYPE_FUTURE_QUERY || variable.fields.type == ContextType.TYPE_CONTEXT_FUTURE_ID) {
+                            bret = add_future_variable(v, variable.fields.identifier, variable.fields.type, 
+                                variable.fields?.value?Uint8Array.from(variable.fields.value):undefined, undefined, false);
+                        } else {
+                            bret = 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;
+            }
+            
             for (let i = 0; i < c.fields.senses.length; i ++) {
                 let sense = c.fields.senses[i];
                 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                  
+                    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                  
                     }       
                 }                         
             }

package/src/index.ts

@@ -7,7 +7,7 @@ export { demand, demand_expand_time, demand_refund, demand_set_description, dema
 export { machine, machine_add_node, machine_add_node2, machine_add_repository,  machine_clone, machine_pause, machine_publish,
     machine_remove_node, machine_remove_repository, machine_set_description,  machine_set_endpoint, MachineNodeObject, Machine_Forward, 
     Machine_Node,  Machine_Node_Pair, launch as machine_launch,  destroy as  machine_destroy, change_permission as machine_change_permission,
-    INITIAL_NODE_NAME, namedOperator_ORDER_PAYER } from  './machine'
+    INITIAL_NODE_NAME, OPERATOR_ORDER_PAYER } from  './machine'
 export { progress, ProgressNext, ParentProgress, progress_bind_task, progress_parent, progress_set_context_repository, progress_unhold,
     hold, progress_set_namedOperator, MAX_NAMED_OPERATOR_COUNT, next } from  './progress'
 export { service, service_add_refund_guards, service_add_sale, service_add_stock, service_add_withdraw_guards, service_clone,

package/src/machine.ts

@@ -9,7 +9,7 @@ import { IsValidPermissionIndex, PermissionIndexType } from './permission';
 
 export type MachineNodeObject = TransactionResult | String;
 export const INITIAL_NODE_NAME = '';
-export const namedOperator_ORDER_PAYER = 'order payer';
+export const OPERATOR_ORDER_PAYER = 'order payer';
 
 export type Machine_Forward = {
     name: string; // foward name
@@ -36,7 +36,6 @@ export function machine_add_node(txb:TransactionBlock, machine:MachineObject, pe
     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; }