wowok 1.1.2 → 1.1.4

package/dist/passport.js

@@ -1,29 +1,389 @@
 import { Inputs } from '@mysten/sui.js/transactions';
-import { Protocol, ContextType, OperatorType, ValueType } from './protocol';
-import { parse_object_type, array_unique, Bcs, ulebDecode, IsValidAddress, IsValidArray } from './utils';
+import { Protocol, ContextType, OperatorType, ValueType, SER_VALUE } from './protocol';
+import { parse_object_type, array_unique, Bcs, ulebDecode, IsValidAddress, IsValidArray, readOption } from './utils';
 import { BCS } from '@mysten/bcs';
 import { ERROR, Errors } from './exception';
+import { Guard } from './guard';
 export class GuardParser {
     guard_list = [];
     protocol;
-    constructor(protocol) { this.protocol = protocol; }
+    guards;
+    index = 0;
+    get_index() { return this.index++; }
+    constructor(protocol, guards) {
+        this.protocol = protocol;
+        this.guards = guards.map(g => protocol.CurrentSession().object(g));
+    }
     guardlist = () => { return this.guard_list; };
+    /// convert guard-on-chain to js object
+    static GuardObject = async (protocol, guard) => {
+        if (!IsValidAddress(guard)) {
+            ERROR(Errors.IsValidAddress, 'GuardObject guard');
+        }
+        let res = await protocol.Query_Raw([guard]);
+        if (res.length == 0 || !res[0].data || res[0].data?.objectId != guard) {
+            ERROR(Errors.Fail, 'GuardObject query error');
+        }
+        console.log(res[0].data?.content);
+        let content = res[0].data.content;
+        if (content?.type != protocol.Package() + '::guard::Guard') {
+            ERROR(Errors.Fail, 'GuardObject object invalid');
+        }
+        let variables = [];
+        content.fields.variables.forEach((v) => {
+            let value;
+            switch (v.fields.type) {
+                case ContextType.TYPE_WITNESS_ID:
+                case ValueType.TYPE_ADDRESS:
+                    value = '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(v.fields.value)).toString();
+                    break;
+                case ValueType.TYPE_BOOL:
+                case ValueType.TYPE_U8:
+                case ValueType.TYPE_U64:
+                case ValueType.TYPE_U128:
+                case ValueType.TYPE_U256:
+                case ValueType.TYPE_VEC_U8:
+                case ValueType.TYPE_VEC_U64:
+                case ValueType.TYPE_VEC_U128:
+                case ValueType.TYPE_VEC_ADDRESS:
+                case ValueType.TYPE_VEC_BOOL:
+                case ValueType.TYPE_VEC_VEC_U8:
+                case ValueType.TYPE_OPTION_ADDRESS:
+                case ValueType.TYPE_OPTION_BOOL:
+                case ValueType.TYPE_OPTION_U128:
+                case ValueType.TYPE_OPTION_U8:
+                case ValueType.TYPE_OPTION_U64:
+                case ValueType.TYPE_OPTION_U256:
+                case ValueType.TYPE_VEC_U256:
+                    let de = SER_VALUE.find(s => s.type == v.fields.type);
+                    if (!de)
+                        ERROR(Errors.Fail, 'GuardObject de error');
+                    value = Bcs.getInstance().de(de.name, Uint8Array.from(v.fields.value));
+                    break;
+                default:
+                    ERROR(Errors.Fail, 'GuardObject variable type invalid');
+            }
+            variables.push({ identifier: v.fields.identifier, type: v.fields.type, value: value });
+        });
+        console.log(variables);
+        let arr = [].slice.call(content.fields.input.fields.bytes.reverse());
+        let data = [];
+        while (arr.length > 0) {
+            let type = arr.shift();
+            let value;
+            let cmd;
+            let identifier;
+            switch (type) {
+                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_VARIABLE:
+                    identifier = arr.shift(); // identifier
+                    break;
+                case ContextType.TYPE_WITNESS_ID: // add to variable 
+                case ValueType.TYPE_ADDRESS:
+                    value = '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(arr)).toString();
+                    arr.splice(0, 32); // address     
+                    break;
+                case ValueType.TYPE_BOOL:
+                    value = Bcs.getInstance().de(BCS.BOOL, Uint8Array.from(arr));
+                    arr.shift();
+                    break;
+                case ValueType.TYPE_U8:
+                    value = Bcs.getInstance().de(BCS.U8, Uint8Array.from(arr));
+                    arr.shift();
+                    break;
+                case ValueType.TYPE_U64:
+                    value = Bcs.getInstance().de(BCS.U64, Uint8Array.from(arr));
+                    arr.splice(0, 8);
+                    break;
+                case ValueType.TYPE_U128:
+                    value = Bcs.getInstance().de(BCS.U128, Uint8Array.from(arr));
+                    arr.splice(0, 16);
+                    break;
+                case ValueType.TYPE_U256:
+                    value = Bcs.getInstance().de(BCS.U256, Uint8Array.from(arr));
+                    arr.splice(0, 32);
+                    break;
+                case ValueType.TYPE_VEC_U8:
+                case ValueType.TYPE_VEC_BOOL:
+                    let r = ulebDecode(Uint8Array.from(arr));
+                    value = Bcs.getInstance().de('vector<u8>', Uint8Array.from(arr));
+                    arr.splice(0, r.value + r.length);
+                    break;
+                case ValueType.TYPE_VEC_ADDRESS:
+                    r = ulebDecode(Uint8Array.from(arr));
+                    value = Bcs.getInstance().de('vector<address>', Uint8Array.from(arr));
+                    arr.splice(0, r.value * 32 + r.length);
+                    break;
+                case ValueType.TYPE_VEC_U128:
+                    r = ulebDecode(Uint8Array.from(arr));
+                    value = Bcs.getInstance().de('vector<u128>', Uint8Array.from(arr));
+                    arr.splice(0, r.value * 16 + r.length);
+                    break;
+                case ValueType.TYPE_VEC_U256:
+                    r = ulebDecode(Uint8Array.from(arr));
+                    value = Bcs.getInstance().de('vector<u256>', Uint8Array.from(arr));
+                    arr.splice(0, r.value * 32 + r.length);
+                    break;
+                case ValueType.TYPE_VEC_U64:
+                    r = ulebDecode(Uint8Array.from(arr));
+                    value = Bcs.getInstance().de('vector<u64>', Uint8Array.from(arr));
+                    arr.splice(0, r.value * 8 + r.length);
+                    break;
+                case ValueType.TYPE_VEC_VEC_U8:
+                    r = ulebDecode(Uint8Array.from(arr));
+                    arr.splice(0, r.length);
+                    let res = [];
+                    for (let i = 0; i < r.value; i++) {
+                        let r2 = ulebDecode(Uint8Array.from(arr));
+                        res.push(Bcs.getInstance().de('vector<u8>', Uint8Array.from(arr)));
+                        arr.splice(0, r2.length + r2.value);
+                    }
+                    value = res;
+                    break;
+                case OperatorType.TYPE_QUERY:
+                    let t = arr.splice(0, 1); // data-type
+                    if (t[0] == ValueType.TYPE_ADDRESS || t[0] == ContextType.TYPE_WITNESS_ID) {
+                        let addr = '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(arr)).toString();
+                        arr.splice(0, 32); // address            
+                        value = addr;
+                        cmd = arr.shift(); // cmd
+                    }
+                    else if (t[0] == ContextType.TYPE_VARIABLE) {
+                        let id = arr.splice(0, 1); // key
+                        let v = variables.find((v) => (v.identifier == id[0]) &&
+                            ((v.type == ValueType.TYPE_ADDRESS) || (v.type == ContextType.TYPE_WITNESS_ID)));
+                        if (!v) {
+                            ERROR(Errors.Fail, 'GuardObject: indentifier not in  variable');
+                        }
+                        identifier = id[0];
+                        cmd = arr.shift(); // cmd
+                    }
+                    else {
+                        ERROR(Errors.Fail, 'GuardObject: variable type invalid');
+                    }
+                    break;
+                case ValueType.TYPE_OPTION_ADDRESS:
+                    let read = readOption(arr, BCS.ADDRESS);
+                    value = read.value;
+                    if (!read.bNone)
+                        arr.splice(0, 32);
+                    break;
+                case ValueType.TYPE_OPTION_BOOL:
+                    read = readOption(arr, BCS.BOOL);
+                    value = read.value;
+                    if (!read.bNone)
+                        arr.splice(0, 1);
+                    break;
+                case ValueType.TYPE_OPTION_U8:
+                    read = readOption(arr, BCS.U8);
+                    value = read.value;
+                    if (!read.bNone)
+                        arr.splice(0, 1);
+                    break;
+                case ValueType.TYPE_OPTION_U128:
+                    read = readOption(arr, BCS.U128);
+                    value = read.value;
+                    if (!read.bNone)
+                        arr.splice(0, 16);
+                    break;
+                case ValueType.TYPE_OPTION_U256:
+                    read = readOption(arr, BCS.U256);
+                    value = read.value;
+                    if (!read.bNone)
+                        arr.splice(0, 32);
+                    break;
+                case ValueType.TYPE_OPTION_U64:
+                    read = readOption(arr, BCS.U64);
+                    value = read.value;
+                    if (!read.bNone)
+                        arr.splice(0, 8);
+                    break;
+                default:
+                    ERROR(Errors.Fail, 'GuardObject: parse_bcs types');
+            }
+            data.push({ type: type, value: value, cmd: cmd, identifier: identifier, child: [] });
+        }
+        console.log(data);
+        if (!data || data.length == 0)
+            ERROR(Errors.Fail, 'GuardObject: data parsed error');
+        let stack = [];
+        data.forEach((d) => {
+            this.ResolveData(variables, stack, d);
+            console.log('---------------------------------');
+            console.log(stack);
+        });
+    };
+    static ResolveData = (variables, stack, current) => {
+        switch (current.type) {
+            case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
+                current.ret_type = ValueType.TYPE_BOOL;
+                return;
+            case OperatorType.TYPE_LOGIC_NOT:
+                current.ret_type = ValueType.TYPE_BOOL;
+                if (stack.length < 1)
+                    ERROR(Errors.Fail, 'ResolveData: TYPE_LOGIC_NOT');
+                let param = stack.pop();
+                if (!param.ret_type || param.ret_type != ValueType.TYPE_BOOL) {
+                    ERROR(Errors.Fail, 'ResolveData: TYPE_LOGIC_NOT type invalid');
+                }
+                current.child.push(param);
+                stack.push(current);
+                return;
+            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:
+                current.ret_type = ValueType.TYPE_BOOL;
+                if (stack.length < 2)
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type);
+                for (let i = 0; i < 2; ++i) {
+                    let p = stack.pop();
+                    if (!p.ret_type)
+                        ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
+                    if (p.ret_type != ValueType.TYPE_U8 && p.ret_type != ValueType.TYPE_U64 &&
+                        p.ret_type != ValueType.TYPE_U128 && p.ret_type != ValueType.TYPE_U256) {
+                        ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
+                    }
+                    ;
+                    current.child.push(p);
+                }
+                stack.push(current);
+                return;
+            case OperatorType.TYPE_LOGIC_EQUAL:
+                current.ret_type = ValueType.TYPE_BOOL;
+                if (stack.length < 2)
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type);
+                var p1 = stack.pop();
+                var p2 = stack.pop();
+                if (!p1.ret_type || !p2.ret_type)
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
+                if (p1.ret_type != p2.ret_type)
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' param type not match');
+                current.child.push(p1);
+                current.child.push(p2);
+                stack.push(current);
+                return;
+            case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
+                current.ret_type = ValueType.TYPE_BOOL;
+                if (stack.length < 2)
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type);
+                var p1 = stack.pop();
+                var p2 = stack.pop();
+                if (!p1.ret_type || !p2.ret_type)
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
+                if (p1.ret_type != ValueType.TYPE_VEC_U8 || p2.ret_type != ValueType.TYPE_VEC_U8) {
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' param type not match');
+                }
+                current.child.push(p1);
+                current.child.push(p2);
+                stack.push(current);
+                return;
+            case OperatorType.TYPE_LOGIC_AND:
+            case OperatorType.TYPE_LOGIC_OR:
+                current.ret_type = ValueType.TYPE_BOOL;
+                if (stack.length < 2)
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type);
+                var p1 = stack.pop();
+                var p2 = stack.pop();
+                if (!p1.ret_type || !p2.ret_type)
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
+                if (p1.ret_type != ValueType.TYPE_BOOL || p2.ret_type != ValueType.TYPE_BOOL) {
+                    ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' param type not match');
+                }
+                current.child.push(p1);
+                current.child.push(p2);
+                stack.push(current);
+                return;
+            case OperatorType.TYPE_QUERY:
+                if (!current?.cmd)
+                    ERROR(Errors.Fail, 'OperateParamCount: cmd invalid ' + current.type);
+                let r = Guard.GetCmd(current.cmd);
+                if (!r)
+                    ERROR(Errors.Fail, 'OperateParamCount: cmd not supported ' + current.type);
+                console.log(r);
+                if (stack.length < r[3].length)
+                    ERROR(Errors.Fail, 'OperateParamCount: cmd param lost ' + current.type);
+                r[3].forEach((e) => {
+                    let d = stack.pop();
+                    if (!d?.ret_type || d.ret_type != e) {
+                        ERROR(Errors.Fail, 'OperateParamCount: cmd param not match ' + current.type);
+                    }
+                    current.child.push(d);
+                });
+                stack.push(current);
+                return;
+            case ValueType.TYPE_ADDRESS:
+            case ValueType.TYPE_BOOL:
+            case ValueType.TYPE_U128:
+            case ValueType.TYPE_U256:
+            case ValueType.TYPE_U64:
+            case ValueType.TYPE_U8:
+            case ValueType.TYPE_VEC_ADDRESS:
+            case ValueType.TYPE_VEC_BOOL:
+            case ValueType.TYPE_VEC_U128:
+            case ValueType.TYPE_VEC_U256:
+            case ValueType.TYPE_VEC_U64:
+            case ValueType.TYPE_VEC_U8:
+            case ValueType.TYPE_VEC_VEC_U8:
+            case ValueType.TYPE_OPTION_ADDRESS:
+            case ValueType.TYPE_OPTION_BOOL:
+            case ValueType.TYPE_OPTION_U128:
+            case ValueType.TYPE_OPTION_U256:
+            case ValueType.TYPE_OPTION_U64:
+            case ValueType.TYPE_OPTION_U8:
+            case ContextType.TYPE_WITNESS_ID: /// notice!!
+                current.ret_type = current.type;
+                stack.push(current);
+                return;
+            case ContextType.TYPE_CLOCK:
+                current.ret_type = ValueType.TYPE_U64;
+                stack.push(current);
+                return;
+            case ContextType.TYPE_SIGNER:
+                current.ret_type = ValueType.TYPE_ADDRESS;
+                stack.push(current);
+                return;
+            case ContextType.TYPE_VARIABLE:
+                let v = variables.find((e) => e.identifier == current?.identifier);
+                if (!v)
+                    ERROR(Errors.Fail, 'OperateParamCount: identifier  invalid ' + current.type);
+                current.ret_type = v?.type;
+                stack.push(current);
+                return;
+        }
+        ERROR(Errors.Fail, 'OperateParamCount: type  invalid ' + current.type);
+    };
+    /// create GuardParser ayncly
     static CreateAsync = async (protocol, guards) => {
         if (!IsValidArray(guards, IsValidAddress)) {
             ERROR(Errors.IsValidArray, 'guards');
         }
         let guard_list = array_unique(guards);
-        const me = new GuardParser(protocol);
-        let res = await protocol.Query_Raw(guards);
+        const me = new GuardParser(protocol, guards);
+        let res = await protocol.Query_Raw(guard_list);
         res.forEach((r) => {
             let c = r.data?.content;
             if (!c)
                 return;
-            let index = protocol.WOWOK_OBJECTS_TYPE().findIndex(v => v.includes('guard::Guard') && v == c.type);
+            let index = protocol.WOWOK_OBJECTS_TYPE().findIndex(v => { return v.includes('guard::Guard') && v == c.type; });
             if (index == -1)
                 return;
-            let info = { id: c.fields.id.id, query_list: [], futrue_list: [] };
-            me.parse_future(info, c.fields.variables);
+            let info = { 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));
             }
@@ -31,12 +391,13 @@ export class GuardParser {
         });
         return me;
     };
-    parse_future = (info, variables) => {
+    parse_variable = (info, variables) => {
         variables.forEach((v) => {
             if (v.type == (this.protocol.Package() + '::guard::Variable')) {
-                if (v.fields.type == OperatorType.TYPE_FUTURE_QUERY || v.fields.type == ContextType.TYPE_CONTEXT_FUTURE_ID) {
-                    info.futrue_list.push({ identifier: v.fields.identifier, type: v.fields.type,
-                        witness: '0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(v.fields.value)) });
+                // 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)) });
                 }
             }
         });
@@ -47,92 +408,116 @@ export class GuardParser {
             var type = arr.shift();
             // console.log(type);
             switch (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:
-                case OperatorType.TYPE_FUTURE_QUERY:
-                    var identifer = arr.splice(0, 1);
-                    let i = info.futrue_list.find(f => f.identifier == identifer[0]);
-                    if (!i) {
-                        ERROR(Errors.Fail, 'futrue_list not found');
-                    }
-                    if (type == OperatorType.TYPE_FUTURE_QUERY) {
-                        info.query_list.push({ identifier: identifer[0], type: type, witness: i.witness }); // query list item
-                        arr.splice(0, 1); // cmd
-                    }
+                case ContextType.TYPE_VARIABLE:
+                    arr.splice(0, 1); // identifier of variable
                     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
+                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 OperatorType.TYPE_QUERY_FROM_CONTEXT:
-                    arr.splice(0, 2); // identifer + cmd
+                case ValueType.TYPE_BOOL:
+                case ValueType.TYPE_U8:
+                    arr.splice(0, 1); // identifier
                     break;
-                case ValueType.TYPE_STATIC_address:
+                case ValueType.TYPE_ADDRESS:
                     arr.splice(0, 32);
                     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:
-                    info.query_list.push('0x' + Bcs.getInstance().de(BCS.ADDRESS, Uint8Array.from(arr)).toString());
-                    arr.splice(0, 33); // address + cmd
+                    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 });
+                        }
+                    }
+                    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:
                     ERROR(Errors.Fail, 'parse_bcs types');
             }
         }
     };
+    get_object(guardid, info, fill) {
+        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;
+    }
     done = async (fill) => {
         let objects = [];
         this.guard_list.forEach((g) => {
-            g.futrue_list.forEach((f) => {
-                let r = fill?.find(i => i.identifier == f.identifier && g.id == i.guard);
-                if (!r && !f.futrue) {
-                    ERROR(Errors.InvalidParam, 'fill');
-                }
-                if (r)
-                    f.futrue = r.future;
-                objects.push(f.futrue);
+            g.variable.filter(v => v.type == ContextType.TYPE_WITNESS_ID).forEach((q) => {
+                objects.push(this.get_object(g.id, q, fill));
             });
-            g.query_list = g.query_list.map((q) => {
+            let list = g.query_list.map((q) => {
                 if (typeof (q) === "string") {
                     objects.push(q);
                     return q;
                 }
                 else {
-                    let r = g.futrue_list.find(f => f.identifier == q.identifier && f.type == q.type && f.witness == q.witness);
-                    if (!r || !r.futrue) {
-                        ERROR(Errors.Fail, 'query witness not match');
-                    }
-                    objects.push(r.futrue);
-                    return r.futrue;
+                    let r = this.get_object(g.id, q, fill);
+                    objects.push(r);
+                    return r;
                 }
             });
+            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 });
@@ -146,20 +531,24 @@ export class GuardParser {
                 }
                 let object = this.object_query(r.data);
                 if (!object) {
-                    ERROR(Errors.Fail, 'object fail');
+                    ERROR(Errors.Fail, 'query object fail');
                 }
                 query.push(object);
             });
-            g.futrue_list.forEach(f => {
-                let r = res.find(r => r.data?.objectId == f.futrue);
-                if (!r) {
-                    ERROR(Errors.Fail, 'query future not match');
+            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);
                 }
-                let object = this.object_query(r.data, 'witness');
-                witness.push(object);
             });
         });
-        return { query: query, witness: witness };
+        return { guard: this.guards, query: query, witness: witness };
     };
     object_query = (data, method = 'guard_query') => {
         for (let k = 0; k < this.protocol.WOWOK_OBJECTS_TYPE().length; k++) {
@@ -182,11 +571,11 @@ export class Passport {
     protocol;
     get_object() { return this.passport; }
     // return passport object used
-    constructor(protocol, guards, query) {
-        if (!guards || guards.length > Passport.MAX_GUARD_COUNT) {
+    constructor(protocol, query) {
+        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');
         }
         this.protocol = protocol;
@@ -196,10 +585,10 @@ export class Passport {
             arguments: []
         });
         // add others guards, if any
-        guards.forEach((guard) => {
+        query.guard.forEach((g) => {
             txb.moveCall({
                 target: protocol.PassportFn('guard_add'),
-                arguments: [this.passport, Protocol.TXB_OBJECT(txb, guard)]
+                arguments: [this.passport, Protocol.TXB_OBJECT(txb, g)]
             });
         });
         // witness
@@ -212,13 +601,13 @@ export class Passport {
         });
         // rules: 'verify' & 'query' in turns；'verify' at final end.
         query?.query.forEach((q) => {
-            let [type, address] = txb.moveCall({
+            let address = txb.moveCall({
                 target: protocol.PassportFn('passport_verify'),
                 arguments: [this.passport, txb.object(Protocol.CLOCK_OBJECT)]
             });
             txb.moveCall({
                 target: q.target,
-                arguments: [txb.object(q.object), this.passport, type, address],
+                arguments: [txb.object(q.object), this.passport, address],
                 typeArguments: q.types,
             });
         });